wxPython / wx / tools / Editra / src / extern / stcspellcheck.py

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
#-----------------------------------------------------------------------------
# Name:        stcspellcheck.py
# Purpose:     Spell checking for the wx.StyledTextControl using pyenchant
#
# Author:      Rob McMullen
#
# Created:     2008
# RCS-ID:      $Id: stcspellcheck.py 69791 2011-11-19 22:02:59Z CJP $
# Copyright:   (c) 2008 Rob McMullen
# License:     wxWidgets
#-----------------------------------------------------------------------------
#
# Originally based on code from Luke-SDK, which includes the following
# copyright notice:
# 
# Copyright (c) 2007 Eur Ing Christopher Thoday, cthoday@mail.berlios.de.
#
# Permission to use, copy, modify and distribute this software and its
# documentation for any purpose and without fee is hereby granted, provided
# that the above copyright notice appear in all copies and that both
# the copyright notice and this permission notice appear in supporting
# documentation.
#
# Christopher Thoday makes no representations about the suitability of this
# software for any purpose.  It is provided "as is" without express or implied
# warranty.

"""Spell checking for the wx.StyledTextControl using pyenchant

This module was insipred by the spell check function from Christopher Thoday's
U{Luke SDK<http://luke-sdk.berlios.de/>}.

Spell checking is provided by the pyenchant library, which is an external
dependency not part of wxPython.  Packages are available for Mac, Unix, and
windows at U{http://pyenchant.sourceforge.net}

Currently provides:
 - spell checking of entire buffer, currently visible page, or selection region
 - user specified indicator number (0 - 2), style, and color
 - language can be changed on the fly
 - update the spelling as you type
 - check the document in either idle time or in a background thread

@author: Rob McMullen
@version: 1.2

Changelog::
    1.2:
        - Rewrote as a standalone class rather than a static mixin
    1.1:
        - Added helper function to use idle processing time to check document
        - Added word checking function for use in instant spell checking
    1.0:
        - First public release
"""

import os
import locale
import wx
import wx.stc

# Assume MacPorts install of Enchant
if wx.Platform == '__WXMAC__':
    if 'PYENCHANT_LIBRARY_PATH' not in os.environ:
        os.environ['PYENCHANT_LIBRARY_PATH'] = '/opt/local/lib/libenchant.dylib'

try:
    import enchant
except ImportError:
    # no big deal; support for enchant simply won't be included
    pass
except:
    # big deal; enchant is there but there's some error that is preventing
    # its import
    import traceback
    traceback.print_exc()

class STCSpellCheck(object):
    """Spell checking for use with wx.StyledTextControl.
    
    This shows spelling errors using the styling indicators (e.g.  the red
    squiggly underline) of the styled text control; I find this much more
    convenient than a dialog-box that makes you click through each mistake.
    
    The eventual goal of the module is to provide on-the-fly spell checking
    that will display errors as you type, and also will highlight errors
    during idle time or in a background thread.
    
    Spell checking is provided through the pyenchant module.  Without
    pyenchant, this object won't do anything useful, but it is still safe to
    be used.  It wraps all calls to pyenchant with try/except blocks to catch
    import errors, and any calls to the spell checking functions will return
    immediately.
    
    To use the spelling check, use one of the methods L{checkAll},
    L{checkCurrentPage}, or L{checkSelection}.  Clear the spelling
    indicators with L{clearAll}.
    """
    # Class attributes to act as default values
    _spelling_lang = None
    _spelling_dict = None
    
    def __init__(self, stc, *args, **kwargs):
        """Mixin must be initialized using this constructor.
        
        Keyword arguments are also available instead of calling the
        convenience functions.  For L{setIndicator}, use C{indicator},
        C{indicator_color}, and {indicator_style}; for L{setLanguage},
        use C{language}; and for L{setMinimumWordSize}, use
        C{min_word_size}.  See the descriptions of those methods for more info.
        """
        self.stc = stc
        self.setIndicator(kwargs.get('indicator', 2),
                          kwargs.get('indicator_color', "#FF0000"),
                          kwargs.get('indicator_style', wx.stc.STC_INDIC_SQUIGGLE))
        self.setMinimumWordSize(kwargs.get('min_word_size', 3))
        if 'language' in kwargs:
            # Don't set default language unless explicitly specified -- it
            # might have already been set through the class method
            self.setDefaultLanguage(kwargs['language'])
        if 'check_region' in kwargs:
            # optional function to specify if the region should be spell
            # checked.  Function should return True if the position should
            # be spell-checked; False if it doesn't make sense to spell check
            # that part of the document
            self._spell_check_region = kwargs['check_region']
        else:
            self._spell_check_region = lambda s: True
        self._spelling_debug = False
        
        self._spelling_last_idle_line = -1
        self.dirty_range_count_per_idle = 5
        
        self._no_update = False
        self._last_block = -1
        
        self.clearDirtyRanges()

    def setIndicator(self, indicator=None, color=None, style=None):
        """Set the indicator styling for misspelled words.
        
        Set the indicator index to use, its color, and the visual style.
        
        @param indicator: indicator number (usually 0, 1, or 2, but may be fewer
        depending on the number of style bits you've chosen for the stc.)
        @param color: string indicating the color of the indicator (e.g.
        "#FF0000" for red)
        @param style: stc indicator style; one of the wx.stc.STC_INDIC_*
        constants (currently wx.stc.STC_INDIC_PLAIN, wx.stc.STC_INDIC_SQUIGGLE,
        wx.stc.STC_INDIC_TT, wx.stc.STC_INDIC_DIAGONAL,
        wx.stc.STC_INDIC_STRIKE, wx.stc.STC_INDIC_HIDDEN,
        wx.stc.STC_INDIC_BOX, wx.stc.STC_INDIC_ROUNDBOX)
        """
        indicators = {0: wx.stc.STC_INDIC0_MASK,
                      1: wx.stc.STC_INDIC1_MASK,
                      2: wx.stc.STC_INDIC2_MASK
                      }
        if indicator is not None:
            if indicator not in indicators:
                indicator = 0
            # The current view may have fewer than 3 indicators
            bitmax = 7 - self.stc.GetStyleBits()
            if indicator > bitmax:
                indicator = bitmax
            self._spelling_indicator = indicator
        self._spelling_indicator_mask = indicators[self._spelling_indicator]
        
        if color is not None:
            self._spelling_color = color
        self.stc.IndicatorSetForeground(self._spelling_indicator,
                                    self._spelling_color)
    
        if style is not None:
            if style > wx.stc.STC_INDIC_MAX:
                style = wx.stc.STC_INDIC_MAX
            self._spelling_style = style
        self.stc.IndicatorSetStyle(self._spelling_indicator,
                               self._spelling_style)
    
    @classmethod
    def getAvailableLanguages(cls):
        """Return a list of supported languages.
        
        Pyenchant supplies a list of its supported languages, so this is just
        a simple wrapper around its C{list_languages} function.  Each item in
        the list is a text string indicating the locale name, e.g.  en_US, ru,
        ru_RU, eo, es_ES, etc.
        
        @return: a list of text strings indicating the supported languages
        """
        try:
            return enchant.list_languages()
        except NameError:
            pass
        return []
    
    @classmethod
    def _getDict(cls, lang):
        try:
            d = enchant.Dict(lang)
        except:
            # Catch all exceptions, because if pyenchant isn't available, you
            # can't catch the enchant.DictNotFound error.
            d = None
        return d

    def setCheckRegion(self, func):
        """Set region checker callable
        @param func: def func(pos): return bool

        """
        self.clearAll()
        self._spell_check_region = func

    @classmethod
    def setDefaultLanguage(cls, lang):
        """Set the default language for spelling check.
        
        The string should be in language locale format, e.g.  en_US, ru, ru_RU,
        eo, es_ES, etc.  See L{getAvailableLanguages}.
        
        @param lang: text string indicating the language
        """
        cls._spelling_lang = lang
        cls._spelling_dict = cls._getDict(lang)

    @classmethod
    def getSpellingDictionary(cls):
        """Get the currently used spelling dictionary
        @return: enchant.Dict instance or None

        """
        return cls._spelling_dict

    def setLanguage(self, lang):
        """Set the language for spelling check for this class, if different than
        the default.
        
        The string should be in language locale format, e.g.  en_US, ru, ru_RU,
        eo, es_ES, etc.  See L{getAvailableLanguages}.
        
        @param lang: text string indicating the language
        """
        # Note that this instance variable will shadow the class attribute
        self._spelling_lang = lang
        self._spelling_dict = self._getDict(lang)
    
    def hasDictionary(self):
        """Returns True if a dictionary is available to spell check the current
        language.
        """
        return self._spelling_dict is not None

    @classmethod
    def isEnchantOk(cls):
        """Returns True if enchant is available"""
        return 'enchant' in globals()

    @classmethod
    def reloadEnchant(cls, libpath=u''):
        """Try (re)loading the enchant module. Use to dynamically try to
        import enchant incase it could be loaded at the time of the import of
        this module.
        @keyword libpath: optionally specify path to libenchant
        @return: bool

        """
        try:
            if libpath and os.path.exists(libpath):
                os.environ['PYENCHANT_LIBRARY_PATH'] = libpath

            if cls.isEnchantOk():
                reload(enchant)
            else:
                mod = __import__('enchant', globals(), locals())
                globals()['enchant'] = mod
        except ImportError:
            return False
        else:
            return True

    def getLanguage(self):
        """Returns True if a dictionary is available to spell check the current
        language.
        """
        return self._spelling_lang
    
    def setMinimumWordSize(self, size):
        """Set the minimum word size that will be looked up in the dictionary.
        
        Words smaller than this size won't be spell checked.
        """
        self._spelling_word_size = size
    
    def clearAll(self):
        """Clear the stc of all spelling indicators."""
        self.stc.StartStyling(0, self._spelling_indicator_mask)
        self.stc.SetStyling(self.stc.GetLength(), 0)
    
    def checkRange(self, start, end):
        """Perform a spell check over a range of text in the document.
        
        This is the main spell checking routine -- it loops over the range
        of text using the L{findNextWord} method to break the text into
        words to check.  Misspelled words are highlighted using the current
        indicator.
        
        @param start: starting position
        @param end: last position to check
        """
        spell = self._spelling_dict
        if not spell:
            return
        
        # Remove any old spelling indicators
        mask = self._spelling_indicator_mask
        count = end - start
        if count <= 0:
            if self._spelling_debug:
                print("No need to check range: start=%d end=%d count=%d" % (start, end, count))
            return
        self.stc.StartStyling(start, mask)
        self.stc.SetStyling(count, 0)
        
        text = self.stc.GetTextRange(start, end) # note: returns unicode
        unicode_index = 0
        max_index = len(text)
        
        last_index = 0 # last character in text a valid raw byte position
        last_pos = start # raw byte position corresponding to last_index
        while unicode_index < max_index:
            start_index, end_index = self.findNextWord(text, unicode_index, max_index)
            if end_index >= 0:
                if end_index - start_index >= self._spelling_word_size:
                    if self._spelling_debug:
                        print("checking %s at text[%d:%d]" % (repr(text[start_index:end_index]), start_index, end_index))
                    if not spell.check(text[start_index:end_index]):
                        # Because unicode characters are stored as utf-8 in the
                        # stc and the positions in the stc correspond to the
                        # raw bytes, not the number of unicode characters, we
                        # have to find out the offset to the unicode chars in
                        # terms of raw bytes.
                        
                        # find the number of raw bytes from the last calculated
                        # styling position to the start of the word
                        last_pos += len(text[last_index:start_index].encode('utf-8'))
                        
                        # find the length of the word in raw bytes
                        raw_count = len(text[start_index:end_index].encode('utf-8'))
                        
                        if self._spell_check_region(last_pos):
                            if self._spelling_debug:
                                print("styling text[%d:%d] = (%d,%d) to %d" % (start_index, end_index, last_pos, last_pos + raw_count, mask))
                            self.stc.StartStyling(last_pos, mask)
                            self.stc.SetStyling(raw_count, mask)
                        elif self._spelling_debug:
                            print("not in valid spell check region.  styling position corresponding to text[%d:%d] = (%d,%d)" % (start_index, end_index, last_pos, last_pos + raw_count))
                        last_pos += raw_count
                        last_index = end_index
                unicode_index = end_index
            else:
                break

    def checkAll(self):
        """Perform a spell check on the entire document."""
        return self.checkRange(0, self.stc.GetLength())
    
    def checkSelection(self):
        """Perform a spell check on the currently selected region."""
        return self.checkRange(self.stc.GetSelectionStart(), self.stc.GetSelectionEnd())
    
    def checkLines(self, startline=-1, count=-1):
        """Perform a spell check on group of lines.
        
        Given the starting line, check the spelling on a block of lines.  If
        the number of lines in the block is not specified, use the number of
        currently visibile lines.
        
        @param startline: current line, or -1 to use the first visible line
        @param count: number of lines in the block, or -1 to use the number of
        lines visible on screen
        """
        if startline < 0:
            startline = self.stc.GetFirstVisibleLine()
        start = self.stc.PositionFromLine(startline)
        if count < 0:
            count = self.stc.LinesOnScreen()
        endline = startline + count
        if endline > self.stc.GetLineCount():
            endline = self.stc.GetLineCount() - 1
        end = self.stc.GetLineEndPosition(endline)
        if self._spelling_debug:
            print("Checking lines %d-%d, chars %d=%d" % (startline, endline, start, end))
        return self.checkRange(start, end)
    
    def checkCurrentPage(self):
        """Perform a spell check on the currently visible lines."""
        return self.checkLines()
    
    def findNextWord(self, utext, index, length):
        """Find the next valid word to check.
        
        Designed to be overridden in subclasses, this method takes a starting
        position in an array of text and returns a tuple indicating the next
        valid word in the string.
        
        @param utext: array of unicode chars
        @param i: starting index within the array to search
        @param length: length of the text
        @return: tuple indicating the word start and end indexes, or (-1, -1)
        indicating that the end of the array was reached and no word was found
        """
        while index < length:
            if utext[index].isalpha():
                end = index + 1
                while end < length and utext[end].isalpha():
                    end += 1
                return (index, end)
            index += 1
        return (-1, -1)
    
    def startIdleProcessing(self):
        """Initialize parameters needed for idle block spell checking.
        
        This must be called before the first call to L{processIdleBlock}
        or if you wish to restart the spell checking from the start
        of the document.  It initializes parameters needed by the
        L{processIdleBlock} in order to process the document during idle
        time.
        """
        self._spelling_last_idle_line = 0
        
    def processIdleBlock(self):
        """Process a block of lines during idle time.
        
        This method is designed to be called during idle processing and will
        spell check a small number of lines.  The next idle processing event
        will continue from where the previous call left off, and in this way
        over some number of idle events will spell check the entire document.
        
        Once the entire document is spell checked, a flag is set and
        further calls to this method will immediately return.  Calling
        L{startIdleProcessing} will cause the idle processing to start
        checking from the beginning of the document.
        """
        self.processDirtyRanges()
        if self._spelling_last_idle_line < 0:
            return
        if self._spelling_debug:
            print("Idle processing page starting at line %d" % self._spelling_last_idle_line)
        self.checkLines(self._spelling_last_idle_line)
        self._spelling_last_idle_line += self.stc.LinesOnScreen()
        if self._spelling_last_idle_line > self.stc.GetLineCount():
            self._spelling_last_idle_line = -1
            return False
        return True

    def processCurrentlyVisibleBlock(self):
        """Alternate method to check lines during idle time.
        
        This method is designed to be called during idle processing and will
        spell check the currently visible block of lines.  Once the visible
        block has been checked, repeatedly calling this method will have
        no effect until the line position changes (or in the less frequent
        occurrence when the number of lines on screen changes by resizing
        the window).
        """
        self.processDirtyRanges()

        self._spelling_last_idle_line = self.stc.GetFirstVisibleLine()
        curr_block = self._spelling_last_idle_line + self.stc.LinesOnScreen()
        if self._no_update or curr_block == self._last_block:
            return

        self.checkLines(self._spelling_last_idle_line)
        self._spelling_last_idle_line += self.stc.LinesOnScreen()
        self._last_block = self._spelling_last_idle_line
        return True

    def getSuggestions(self, word):
        """Get suggestion for the correct spelling of a word.
        
        @param word: word to check
        
        @return: list of suggestions, or an empty list if any of the following
        are true: there are no suggestions, the word is shorter than the
        minimum length, or the dictionary can't be found.
        """
        spell = self._spelling_dict
        if spell and len(word) >= self._spelling_word_size:
            words = spell.suggest(word)
            if self._spelling_debug:
                print("suggestions for %s: %s" % (word, words))
            return words
        return []
    
    def checkWord(self, pos=None, atend=False):
        """Check the word at the current or specified position.
        
        @param pos: position of a character in the word (or at the start or end
        of the word), or None to use the current position
        @param atend: True if you know the cursor is at the end of the word
        """
        if pos is None:
            pos = self.stc.GetCurrentPos()
        if atend:
            end = pos
        else:
            end = self.stc.WordEndPosition(pos, True)
        start = self.stc.WordStartPosition(pos, True)
        if self._spelling_debug:
            print("%d-%d: %s" % (start, end, self.stc.GetTextRange(start, end)))
        self.checkRange(start, end)
    
    def addDirtyRange(self, start, end, lines_added=0, deleted=False):
        """Add a range of characters to a list of dirty regions that need to be
        updated when some idle time is available.
        
        """
        count = end - start
        if deleted:
            count = -count
        if start == self.current_dirty_end:
            self.current_dirty_end = end
        elif start >= self.current_dirty_start and start < self.current_dirty_end:
            self.current_dirty_end += count
        else:
            ranges = []
            if self.current_dirty_start >= 0:
                ranges.append((self.current_dirty_start, self.current_dirty_end))
            for range_start, range_end in self.dirty_ranges:
                if start < range_start:
                    range_start += count
                    range_end += count
                ranges.append((range_start, range_end))
            self.dirty_ranges = ranges
                
            self.current_dirty_start = start
            self.current_dirty_end = end
        
        # If there has been a change before the word that used to be under the
        # cursor, move the pointer so it matches the text
        if start < self.current_word_start:
            self.current_word_start += count
            self.current_word_end += count
        elif start <= self.current_word_end:
            self.current_word_end += count
            # Prevent nonsensical word end if lots of text have been deleted
            if self.current_word_end < self.current_word_start:
                #print("word start = %d, word end = %d" % (self.current_word_start, self.current_word_end))
                self.current_word_end = self.current_word_start
            
        if lines_added > 0:
            start = self.current_dirty_start
            line = self.stc.LineFromPosition(start)
            while True:
                line_end = self.stc.GetLineEndPosition(line)
                if line_end >= end:
                    #self.dirty_ranges.append((start, line_end))
                    if end > start:
                        self.current_dirty_start = start
                        self.current_dirty_end = end
                    else:
                        self.current_dirty_start = self.current_dirty_end = -1
                    break
                self.dirty_ranges.append((start, line_end))
                line += 1
                start = self.stc.PositionFromLine(line)
            
        if self._spelling_debug:
            print("event: %d-%d, current dirty range: %d-%d, older=%s" % (start, end, self.current_dirty_start, self.current_dirty_end, self.dirty_ranges))
    
    def clearDirtyRanges(self, ranges=None):
        """Throw away all dirty ranges
        
        """
        self.current_dirty_start = self.current_dirty_end = -1
        self.current_word_start = self.current_word_end = -1
        if ranges is not None:
            self.dirty_ranges = ranges
        else:
            self.dirty_ranges = []
    
    def processDirtyRanges(self):
        cursor = self.stc.GetCurrentPos()
        
        # Check that the cursor has moved off the current word and if so check
        # its spelling
        if self.current_word_start > 0:
            if cursor < self.current_word_start or cursor > self.current_word_end:
                self.checkRange(self.current_word_start, self.current_word_end)
                self.current_word_start = -1
        
        # Check spelling around the region currently being typed
        if self.current_dirty_start >= 0:
            range_start, range_end = self.processDirtyRange(self.current_dirty_start, self.current_dirty_end)
            
            # If the cursor is in the middle of a word, remove the spelling
            # markers
            if cursor >= range_start and cursor <= range_end:
                word_start = self.stc.WordStartPosition(cursor, True)
                word_end = self.stc.WordEndPosition(cursor, True)
                mask = self._spelling_indicator_mask
                self.stc.StartStyling(word_start, mask)
                self.stc.SetStyling(word_end - word_start, 0)
                
                if word_start != word_end:
                    self.current_word_start = word_start
                    self.current_word_end = word_end
                else:
                    self.current_word_start = -1
            self.current_dirty_start = self.current_dirty_end = -1
        
        # Process a chunk of dirty ranges
        needed = min(len(self.dirty_ranges), self.dirty_range_count_per_idle)
        ranges = self.dirty_ranges[0:needed]
        self.dirty_ranges = self.dirty_ranges[needed:]
        for start, end in ranges:
            if self._spelling_debug:
                print("processing %d-%d" % (start, end))
            self.processDirtyRange(start, end)
    
    def processDirtyRange(self, start, end):
        range_start = self.stc.WordStartPosition(start, True)
        range_end = self.stc.WordEndPosition(end, True)
        if self._spelling_debug:
            print("processing dirty range %d-%d (modified from %d-%d): %s" % (range_start, range_end, start, end, repr(self.stc.GetTextRange(range_start, range_end))))
        self.checkRange(range_start, range_end)
        return range_start, range_end


if __name__ == "__main__":
    import sys
    try:
        import enchant
    except:
        print("pyenchant not available, so spelling correction won't work.")
        print("Get pyenchant from http://pyenchant.sourceforge.net")
    
    class TestSTC(wx.stc.StyledTextCtrl):
        def __init__(self, *args, **kwargs):
            wx.stc.StyledTextCtrl.__init__(self, *args, **kwargs)
            self.spell = STCSpellCheck(self, language="en_US")
            self.SetMarginType(0, wx.stc.STC_MARGIN_NUMBER)
            self.SetMarginWidth(0, 32)
            self.Bind(wx.stc.EVT_STC_MODIFIED, self.OnModified)
            self.Bind(wx.EVT_IDLE, self.OnIdle)
            self.modified_count = 0
            self.idle_count = 0

        def OnModified(self, evt):
            # NOTE: on really big insertions, evt.GetText can cause a
            # MemoryError on MSW, so I've commented this dprint out.
            mod = evt.GetModificationType()
            if mod & wx.stc.STC_MOD_INSERTTEXT or mod & wx.stc.STC_MOD_DELETETEXT:
                #print("(%s) at %d: text=%s len=%d" % (self.transModType(evt.GetModificationType()),evt.GetPosition(), repr(evt.GetText()), evt.GetLength()))
                pos = evt.GetPosition()
                last = pos + evt.GetLength()
                self.spell.addDirtyRange(pos, last, evt.GetLinesAdded(), mod & wx.stc.STC_MOD_DELETETEXT)
                #self.modified_count += 1
                #if self.modified_count > 10:
                #    wx.CallAfter(self.spell.processDirtyRanges)
                #    self.modified_count = 0
            evt.Skip()
        
        def OnIdle(self, evt):
            #print("Idle")
            self.idle_count += 1
            if self.idle_count > 10:
                self.spell.processIdleBlock()
                self.idle_count = 0
            
        def transModType(self, modType):
            st = ""
            table = [(wx.stc.STC_MOD_INSERTTEXT, "InsertText"),
                     (wx.stc.STC_MOD_DELETETEXT, "DeleteText"),
                     (wx.stc.STC_MOD_CHANGESTYLE, "ChangeStyle"),
                     (wx.stc.STC_MOD_CHANGEFOLD, "ChangeFold"),
                     (wx.stc.STC_PERFORMED_USER, "UserFlag"),
                     (wx.stc.STC_PERFORMED_UNDO, "Undo"),
                     (wx.stc.STC_PERFORMED_REDO, "Redo"),
                     (wx.stc.STC_LASTSTEPINUNDOREDO, "Last-Undo/Redo"),
                     (wx.stc.STC_MOD_CHANGEMARKER, "ChangeMarker"),
                     (wx.stc.STC_MOD_BEFOREINSERT, "B4-Insert"),
                     (wx.stc.STC_MOD_BEFOREDELETE, "B4-Delete")
                     ]

            for flag,text in table:
                if flag & modType:
                    st = st + text + " "

            if not st:
                st = 'UNKNOWN'

            return st

    class Frame(wx.Frame):
        def __init__(self, *args, **kwargs):
            super(self.__class__, self).__init__(*args, **kwargs)

            self.stc = TestSTC(self, -1)

            self.CreateStatusBar()
            menubar = wx.MenuBar()
            self.SetMenuBar(menubar)  # Adding the MenuBar to the Frame content.
            menu = wx.Menu()
            menubar.Append(menu, "File")
            self.menuAdd(menu, "Open", "Open File", self.OnOpenFile)
            self.menuAdd(menu, "Quit", "Exit the pragram", self.OnQuit)
            menu = wx.Menu()
            menubar.Append(menu, "Edit")
            self.menuAdd(menu, "Check All", "Spell check the entire document", self.OnCheckAll)
            self.menuAdd(menu, "Check Current Page", "Spell check the currently visible page", self.OnCheckPage)
            self.menuAdd(menu, "Check Selection", "Spell check the selected region", self.OnCheckSelection)
            menu.AppendSeparator()
            self.menuAdd(menu, "Clear Spelling", "Remove spelling correction indicators", self.OnClearSpelling)
            menu = wx.Menu()
            menubar.Append(menu, "Language")
            langs = self.stc.spell.getAvailableLanguages()
            self.lang_id = {}
            for lang in langs:
                id = wx.NewId()
                self.lang_id[id] = lang
                self.menuAdd(menu, lang, "Change dictionary to %s" % lang, self.OnChangeLanguage, id=id)


        def loadFile(self, filename):
            fh = open(filename)
            self.stc.SetText(fh.read())
            self.stc.spell.clearDirtyRanges()
            self.stc.spell.checkCurrentPage()
        
        def loadSample(self, paragraphs=10):
            lorem_ipsum = u"""\
Lorem ipsum dolor sit amet, consectetuer adipiscing elit.  Vivamus mattis
commodo sem.  Phasellus scelerisque tellus id lorem.  Nulla facilisi.
Suspendisse potenti.  Fusce velit odio, scelerisque vel, consequat nec,
dapibus sit amet, tortor.  Vivamus eu turpis.  Nam eget dolor.  Integer
at elit.  Praesent mauris.  Nullam non nulla at nulla tincidunt malesuada.
Phasellus id ante.  Sed mauris.  Integer volutpat nisi non diam.  Etiam
elementum.  Pellentesque interdum justo eu risus.  Cum sociis natoque
penatibus et magnis dis parturient montes, nascetur ridiculus mus.  Nunc
semper.  In semper enim ut odio.  Nulla varius leo commodo elit.  Quisque
condimentum, nisl eget elementum laoreet, mauris turpis elementum felis, ut
accumsan nisl velit et mi.

And some Russian: \u041f\u0438\u0442\u043e\u043d - \u043b\u0443\u0447\u0448\u0438\u0439 \u044f\u0437\u044b\u043a \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f!

"""
            self.stc.ClearAll()
            for i in range(paragraphs):
                self.stc.AppendText(lorem_ipsum)
            # Call the spell check after the text has had a chance to be
            # displayed and the window resized to the correct size.
            self.stc.spell.clearDirtyRanges()
            wx.CallAfter(self.stc.spell.checkCurrentPage)

        def menuAdd(self, menu, name, desc, fcn, id=-1, kind=wx.ITEM_NORMAL):
            if id == -1:
                id = wx.NewId()
            a = wx.MenuItem(menu, id, name, desc, kind)
            menu.AppendItem(a)
            wx.EVT_MENU(self, id, fcn)
            menu.SetHelpString(id, desc)
        
        def OnOpenFile(self, evt):
            dlg = wx.FileDialog(self, "Choose a text file",
                               defaultDir = "",
                               defaultFile = "",
                               wildcard = "*")
            if dlg.ShowModal() == wx.ID_OK:
                print("Opening %s" % dlg.GetPath())
                self.loadFile(dlg.GetPath())
            dlg.Destroy()
        
        def OnQuit(self, evt):
            self.Close(True)
        
        def OnCheckAll(self, evt):
            self.stc.spell.checkAll()
        
        def OnCheckPage(self, evt):
            self.stc.spell.checkCurrentPage()
        
        def OnCheckSelection(self, evt):
            self.stc.spell.checkSelection()
        
        def OnClearSpelling(self, evt):
            self.stc.spell.clearAll()
        
        def OnChangeLanguage(self, evt):
            id = evt.GetId()
            normalized = locale.normalize(self.lang_id[id])
            try:
                locale.setlocale(locale.LC_ALL, normalized)
                print("Changing locale %s, dictionary set to %s" % (normalized, self.lang_id[id]))
            except locale.Error:
                print("Can't set python locale to %s; dictionary set to %s" % (normalized, self.lang_id[id]))
            self.stc.spell.setLanguage(self.lang_id[id])
            self.stc.spell.clearAll()
            self.stc.spell.checkCurrentPage()

    app = wx.App(False)
    frame = Frame(None, size=(600, -1))
    need_sample = True
    if len(sys.argv) > 1:
        if not sys.argv[-1].startswith("-"):
            frame.loadFile(sys.argv[-1])
            need_sample = False
    if need_sample:
        frame.loadSample()
    if '-d' in sys.argv:
        frame.stc.spell._spelling_debug = True
    frame.Show()
    app.MainLoop()
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.