"""ParenMatch -- An IDLE extension for parenthesis matching. When you hit a right paren, the cursor should move briefly to the leftparen.  Paren here is used generically; the matching applies toparentheses, square brackets, and curly braces.""" from HyperParser import HyperParserfrom configHandler import idleConf _openers = {')':'(',']':'[','}':'{'}CHECK_DELAY = 100 # miliseconds class ParenMatch:    """Highlight matching parentheses     There are three supported style of paren matching, based loosely    on the Emacs options.  The style is select based on the    HILITE_STYLE attribute; it can be changed used the set_style    method.     The supported styles are:     default -- When a right paren is typed, highlight the matching        left paren for 1/2 sec.     expression -- When a right paren is typed, highlight the entire        expression from the left paren to the right paren.     TODO:        - extend IDLE with configuration dialog to change options        - implement rest of Emacs highlight styles (see below)        - print mismatch warning in IDLE status window     Note: In Emacs, there are several styles of highlight where the    matching paren is highlighted whenever the cursor is immediately    to the right of a right paren.  I don't know how to do that in Tk,    so I haven't bothered.    """    menudefs = [        ('edit', [            ("Show surrounding parens", "<<flash-paren>>"),        ])    ]    STYLE = idleConf.GetOption('extensions','ParenMatch','style',            default='expression')    FLASH_DELAY = idleConf.GetOption('extensions','ParenMatch','flash-delay',            type='int',default=500)    HILITE_CONFIG = idleConf.GetHighlight(idleConf.CurrentTheme(),'hilite')    BELL = idleConf.GetOption('extensions','ParenMatch','bell',            type='bool',default=1)     RESTORE_VIRTUAL_EVENT_NAME = "<<parenmatch-check-restore>>"    # We want the restore event be called before the usual return and    # backspace events.    RESTORE_SEQUENCES = ("<KeyPress>", "<ButtonPress>",                         "<Key-Return>", "<Key-BackSpace>")     def __init__(self, editwin):        self.editwin = editwin        self.text = editwin.text        # Bind the check-restore event to the function restore_event,        # so that we can then use activate_restore (which calls event_add)        # and deactivate_restore (which calls event_delete).        editwin.text.bind(self.RESTORE_VIRTUAL_EVENT_NAME,                          self.restore_event)        self.counter = 0        self.is_restore_active = 0        self.set_style(self.STYLE)     def activate_restore(self):        if not self.is_restore_active:            for seq in self.RESTORE_SEQUENCES:                self.text.event_add(self.RESTORE_VIRTUAL_EVENT_NAME, seq)            self.is_restore_active = True     def deactivate_restore(self):        if self.is_restore_active:            for seq in self.RESTORE_SEQUENCES:                self.text.event_delete(self.RESTORE_VIRTUAL_EVENT_NAME, seq)            self.is_restore_active = False     def set_style(self, style):        self.STYLE = style        if style == "default":            self.create_tag = self.create_tag_default            self.set_timeout = self.set_timeout_last        elif style == "expression":            self.create_tag = self.create_tag_expression            self.set_timeout = self.set_timeout_none     def flash_paren_event(self, event):        indices = HyperParser(self.editwin, "insert").get_surrounding_brackets()        if indices is None:            self.warn_mismatched()            return        self.activate_restore()        self.create_tag(indices)        self.set_timeout_last()     def paren_closed_event(self, event):        # If it was a shortcut and not really a closing paren, quit.        closer = self.text.get("insert-1c")        if closer not in _openers:            return        hp = HyperParser(self.editwin, "insert-1c")        if not hp.is_in_code():            return        indices = hp.get_surrounding_brackets(_openers[closer], True)        if indices is None:            self.warn_mismatched()            return        self.activate_restore()        self.create_tag(indices)        self.set_timeout()     def restore_event(self, event=None):        self.text.tag_delete("paren")        self.deactivate_restore()        self.counter += 1   # disable the last timer, if there is one.     def handle_restore_timer(self, timer_count):        if timer_count == self.counter:            self.restore_event()     def warn_mismatched(self):        if self.BELL:            self.text.bell()     # any one of the create_tag_XXX methods can be used depending on    # the style     def create_tag_default(self, indices):        """Highlight the single paren that matches"""        self.text.tag_add("paren", indices[0])        self.text.tag_config("paren", self.HILITE_CONFIG)     def create_tag_expression(self, indices):        """Highlight the entire expression"""        if self.text.get(indices[1]) in (')', ']', '}'):            rightindex = indices[1]+"+1c"        else:            rightindex = indices[1]        self.text.tag_add("paren", indices[0], rightindex)        self.text.tag_config("paren", self.HILITE_CONFIG)     # any one of the set_timeout_XXX methods can be used depending on    # the style     def set_timeout_none(self):        """Highlight will remain until user input turns it off        or the insert has moved"""        # After CHECK_DELAY, call a function which disables the "paren" tag        # if the event is for the most recent timer and the insert has changed,        # or schedules another call for itself.        self.counter += 1        def callme(callme, self=self, c=self.counter,                   index=self.text.index("insert")):            if index != self.text.index("insert"):                self.handle_restore_timer(c)            else:                self.editwin.text_frame.after(CHECK_DELAY, callme, callme)        self.editwin.text_frame.after(CHECK_DELAY, callme, callme)     def set_timeout_last(self):        """The last highlight created will be removed after .5 sec"""        # associate a counter with an event; only disable the "paren"        # tag if the event is for the most recent timer.        self.counter += 1        self.editwin.text_frame.after(self.FLASH_DELAY,                                      lambda self=self, c=self.counter: \                                      self.handle_restore_timer(c))