| """ParenMatch -- An IDLE extension for parenthesis matching. |
| |
| When you hit a right paren, the cursor should move briefly to the left |
| paren. Paren here is used generically; the matching applies to |
| parentheses, square brackets, and curly braces. |
| """ |
| |
| from idlelib.HyperParser import HyperParser |
| from idlelib.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)) |