Spaces:
Running
Running
| """codecontext - display the block context above the edit window | |
| Once code has scrolled off the top of a window, it can be difficult to | |
| determine which block you are in. This extension implements a pane at the top | |
| of each IDLE edit window which provides block structure hints. These hints are | |
| the lines which contain the block opening keywords, e.g. 'if', for the | |
| enclosing block. The number of hint lines is determined by the maxlines | |
| variable in the codecontext section of config-extensions.def. Lines which do | |
| not open blocks are not shown in the context hints pane. | |
| For EditorWindows, <<toggle-code-context>> is bound to CodeContext(self). | |
| toggle_code_context_event. | |
| """ | |
| import re | |
| from sys import maxsize as INFINITY | |
| from tkinter import Frame, Text, TclError | |
| from tkinter.constants import NSEW, SUNKEN | |
| from idlelib.config import idleConf | |
| BLOCKOPENERS = {'class', 'def', 'if', 'elif', 'else', 'while', 'for', | |
| 'try', 'except', 'finally', 'with', 'async'} | |
| def get_spaces_firstword(codeline, c=re.compile(r"^(\s*)(\w*)")): | |
| "Extract the beginning whitespace and first word from codeline." | |
| return c.match(codeline).groups() | |
| def get_line_info(codeline): | |
| """Return tuple of (line indent value, codeline, block start keyword). | |
| The indentation of empty lines (or comment lines) is INFINITY. | |
| If the line does not start a block, the keyword value is False. | |
| """ | |
| spaces, firstword = get_spaces_firstword(codeline) | |
| indent = len(spaces) | |
| if len(codeline) == indent or codeline[indent] == '#': | |
| indent = INFINITY | |
| opener = firstword in BLOCKOPENERS and firstword | |
| return indent, codeline, opener | |
| class CodeContext: | |
| "Display block context above the edit window." | |
| UPDATEINTERVAL = 100 # millisec | |
| def __init__(self, editwin): | |
| """Initialize settings for context block. | |
| editwin is the Editor window for the context block. | |
| self.text is the editor window text widget. | |
| self.context displays the code context text above the editor text. | |
| Initially None, it is toggled via <<toggle-code-context>>. | |
| self.topvisible is the number of the top text line displayed. | |
| self.info is a list of (line number, indent level, line text, | |
| block keyword) tuples for the block structure above topvisible. | |
| self.info[0] is initialized with a 'dummy' line which | |
| starts the toplevel 'block' of the module. | |
| self.t1 and self.t2 are two timer events on the editor text widget to | |
| monitor for changes to the context text or editor font. | |
| """ | |
| self.editwin = editwin | |
| self.text = editwin.text | |
| self._reset() | |
| def _reset(self): | |
| self.context = None | |
| self.cell00 = None | |
| self.t1 = None | |
| self.topvisible = 1 | |
| self.info = [(0, -1, "", False)] | |
| def reload(cls): | |
| "Load class variables from config." | |
| cls.context_depth = idleConf.GetOption("extensions", "CodeContext", | |
| "maxlines", type="int", | |
| default=15) | |
| def __del__(self): | |
| "Cancel scheduled events." | |
| if self.t1 is not None: | |
| try: | |
| self.text.after_cancel(self.t1) | |
| except TclError: # pragma: no cover | |
| pass | |
| self.t1 = None | |
| def toggle_code_context_event(self, event=None): | |
| """Toggle code context display. | |
| If self.context doesn't exist, create it to match the size of the editor | |
| window text (toggle on). If it does exist, destroy it (toggle off). | |
| Return 'break' to complete the processing of the binding. | |
| """ | |
| if self.context is None: | |
| # Calculate the border width and horizontal padding required to | |
| # align the context with the text in the main Text widget. | |
| # | |
| # All values are passed through getint(), since some | |
| # values may be pixel objects, which can't simply be added to ints. | |
| widgets = self.editwin.text, self.editwin.text_frame | |
| # Calculate the required horizontal padding and border width. | |
| padx = 0 | |
| border = 0 | |
| for widget in widgets: | |
| info = (widget.grid_info() | |
| if widget is self.editwin.text | |
| else widget.pack_info()) | |
| padx += widget.tk.getint(info['padx']) | |
| padx += widget.tk.getint(widget.cget('padx')) | |
| border += widget.tk.getint(widget.cget('border')) | |
| context = self.context = Text( | |
| self.editwin.text_frame, | |
| height=1, | |
| width=1, # Don't request more than we get. | |
| highlightthickness=0, | |
| padx=padx, border=border, relief=SUNKEN, state='disabled') | |
| self.update_font() | |
| self.update_highlight_colors() | |
| context.bind('<ButtonRelease-1>', self.jumptoline) | |
| # Get the current context and initiate the recurring update event. | |
| self.timer_event() | |
| # Grid the context widget above the text widget. | |
| context.grid(row=0, column=1, sticky=NSEW) | |
| line_number_colors = idleConf.GetHighlight(idleConf.CurrentTheme(), | |
| 'linenumber') | |
| self.cell00 = Frame(self.editwin.text_frame, | |
| bg=line_number_colors['background']) | |
| self.cell00.grid(row=0, column=0, sticky=NSEW) | |
| menu_status = 'Hide' | |
| else: | |
| self.context.destroy() | |
| self.context = None | |
| self.cell00.destroy() | |
| self.cell00 = None | |
| self.text.after_cancel(self.t1) | |
| self._reset() | |
| menu_status = 'Show' | |
| self.editwin.update_menu_label(menu='options', index='*ode*ontext', | |
| label=f'{menu_status} Code Context') | |
| return "break" | |
| def get_context(self, new_topvisible, stopline=1, stopindent=0): | |
| """Return a list of block line tuples and the 'last' indent. | |
| The tuple fields are (linenum, indent, text, opener). | |
| The list represents header lines from new_topvisible back to | |
| stopline with successively shorter indents > stopindent. | |
| The list is returned ordered by line number. | |
| Last indent returned is the smallest indent observed. | |
| """ | |
| assert stopline > 0 | |
| lines = [] | |
| # The indentation level we are currently in. | |
| lastindent = INFINITY | |
| # For a line to be interesting, it must begin with a block opening | |
| # keyword, and have less indentation than lastindent. | |
| for linenum in range(new_topvisible, stopline-1, -1): | |
| codeline = self.text.get(f'{linenum}.0', f'{linenum}.end') | |
| indent, text, opener = get_line_info(codeline) | |
| if indent < lastindent: | |
| lastindent = indent | |
| if opener in ("else", "elif"): | |
| # Also show the if statement. | |
| lastindent += 1 | |
| if opener and linenum < new_topvisible and indent >= stopindent: | |
| lines.append((linenum, indent, text, opener)) | |
| if lastindent <= stopindent: | |
| break | |
| lines.reverse() | |
| return lines, lastindent | |
| def update_code_context(self): | |
| """Update context information and lines visible in the context pane. | |
| No update is done if the text hasn't been scrolled. If the text | |
| was scrolled, the lines that should be shown in the context will | |
| be retrieved and the context area will be updated with the code, | |
| up to the number of maxlines. | |
| """ | |
| new_topvisible = self.editwin.getlineno("@0,0") | |
| if self.topvisible == new_topvisible: # Haven't scrolled. | |
| return | |
| if self.topvisible < new_topvisible: # Scroll down. | |
| lines, lastindent = self.get_context(new_topvisible, | |
| self.topvisible) | |
| # Retain only context info applicable to the region | |
| # between topvisible and new_topvisible. | |
| while self.info[-1][1] >= lastindent: | |
| del self.info[-1] | |
| else: # self.topvisible > new_topvisible: # Scroll up. | |
| stopindent = self.info[-1][1] + 1 | |
| # Retain only context info associated | |
| # with lines above new_topvisible. | |
| while self.info[-1][0] >= new_topvisible: | |
| stopindent = self.info[-1][1] | |
| del self.info[-1] | |
| lines, lastindent = self.get_context(new_topvisible, | |
| self.info[-1][0]+1, | |
| stopindent) | |
| self.info.extend(lines) | |
| self.topvisible = new_topvisible | |
| # Last context_depth context lines. | |
| context_strings = [x[2] for x in self.info[-self.context_depth:]] | |
| showfirst = 0 if context_strings[0] else 1 | |
| # Update widget. | |
| self.context['height'] = len(context_strings) - showfirst | |
| self.context['state'] = 'normal' | |
| self.context.delete('1.0', 'end') | |
| self.context.insert('end', '\n'.join(context_strings[showfirst:])) | |
| self.context['state'] = 'disabled' | |
| def jumptoline(self, event=None): | |
| """ Show clicked context line at top of editor. | |
| If a selection was made, don't jump; allow copying. | |
| If no visible context, show the top line of the file. | |
| """ | |
| try: | |
| self.context.index("sel.first") | |
| except TclError: | |
| lines = len(self.info) | |
| if lines == 1: # No context lines are showing. | |
| newtop = 1 | |
| else: | |
| # Line number clicked. | |
| contextline = int(float(self.context.index('insert'))) | |
| # Lines not displayed due to maxlines. | |
| offset = max(1, lines - self.context_depth) - 1 | |
| newtop = self.info[offset + contextline][0] | |
| self.text.yview(f'{newtop}.0') | |
| self.update_code_context() | |
| def timer_event(self): | |
| "Event on editor text widget triggered every UPDATEINTERVAL ms." | |
| if self.context is not None: | |
| self.update_code_context() | |
| self.t1 = self.text.after(self.UPDATEINTERVAL, self.timer_event) | |
| def update_font(self): | |
| if self.context is not None: | |
| font = idleConf.GetFont(self.text, 'main', 'EditorWindow') | |
| self.context['font'] = font | |
| def update_highlight_colors(self): | |
| if self.context is not None: | |
| colors = idleConf.GetHighlight(idleConf.CurrentTheme(), 'context') | |
| self.context['background'] = colors['background'] | |
| self.context['foreground'] = colors['foreground'] | |
| if self.cell00 is not None: | |
| line_number_colors = idleConf.GetHighlight(idleConf.CurrentTheme(), | |
| 'linenumber') | |
| self.cell00.config(bg=line_number_colors['background']) | |
| CodeContext.reload() | |
| if __name__ == "__main__": | |
| from unittest import main | |
| main('idlelib.idle_test.test_codecontext', verbosity=2, exit=False) | |
| # Add htest. | |