mirror of
https://github.com/python/cpython.git
synced 2025-10-05 14:41:07 +00:00
d6c397bf77
About 10 IDLE features were implemented as supposedly optional
extensions. Their different behavior could be confusing or worse for
users and not good for maintenance. Hence the conversion.
The main difference for users is that user configurable key bindings
for builtin features are now handled uniformly. Now, editing a binding
in a keyset only affects its value in the keyset. All bindings are
defined together in the system-specific default keysets in config-
extensions.def. All custom keysets are saved as a whole in config-
extension.cfg. All take effect as soon as one clicks Apply or Ok.
The affected events are '<<force-open-completions>>', '<<expand-word>>',
'<<force-open-calltip>>', '<<flash-paren>>', '<<format-paragraph>>',
'<<run-module>>', '<<check-module>>', and '<<zoom-height>>'. Any
(global) customizations made before 3.6.3 will not affect their keyset-
specific customization after 3.6.3. and vice versa.
Inital patch by Charles Wohlganger, revised by Terry Jan Reedy.
(cherry picked from commit 58fc71c)
185 lines
8.2 KiB
Python
185 lines
8.2 KiB
Python
"""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 numlines
|
|
variable in the codecontext section of config-extensions.def. Lines which do
|
|
not open blocks are not shown in the context hints pane.
|
|
|
|
"""
|
|
import re
|
|
from sys import maxsize as INFINITY
|
|
|
|
import tkinter
|
|
from tkinter.constants import TOP, LEFT, X, W, SUNKEN
|
|
|
|
from idlelib.config import idleConf
|
|
|
|
BLOCKOPENERS = {"class", "def", "elif", "else", "except", "finally", "for",
|
|
"if", "try", "while", "with"}
|
|
UPDATEINTERVAL = 100 # millisec
|
|
FONTUPDATEINTERVAL = 1000 # millisec
|
|
|
|
getspacesfirstword =\
|
|
lambda s, c=re.compile(r"^(\s*)(\w*)"): c.match(s).groups()
|
|
|
|
|
|
class CodeContext:
|
|
bgcolor = idleConf.GetOption("extensions", "CodeContext",
|
|
"bgcolor", type="str", default="LightGray")
|
|
fgcolor = idleConf.GetOption("extensions", "CodeContext",
|
|
"fgcolor", type="str", default="Black")
|
|
def __init__(self, editwin):
|
|
self.editwin = editwin
|
|
self.text = editwin.text
|
|
self.textfont = self.text["font"]
|
|
self.label = None
|
|
# self.info is a list of (line number, indent level, line text, block
|
|
# keyword) tuples providing the block structure associated with
|
|
# self.topvisible (the linenumber of the line displayed at the top of
|
|
# the edit window). self.info[0] is initialized as a 'dummy' line which
|
|
# starts the toplevel 'block' of the module.
|
|
self.info = [(0, -1, "", False)]
|
|
self.topvisible = 1
|
|
self.reload()
|
|
# Start two update cycles, one for context lines, one for font changes.
|
|
self.text.after(UPDATEINTERVAL, self.timer_event)
|
|
self.text.after(FONTUPDATEINTERVAL, self.font_timer_event)
|
|
|
|
@classmethod
|
|
def reload(cls):
|
|
cls.context_depth = idleConf.GetOption("extensions", "CodeContext",
|
|
"numlines", type="int", default=3)
|
|
cls.bgcolor = idleConf.GetOption("extensions", "CodeContext",
|
|
"bgcolor", type="str", default="LightGray")
|
|
cls.fgcolor = idleConf.GetOption("extensions", "CodeContext",
|
|
"fgcolor", type="str", default="Black")
|
|
|
|
def toggle_code_context_event(self, event=None):
|
|
if not self.label:
|
|
# 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 vertical padding
|
|
padx = 0
|
|
for widget in widgets:
|
|
padx += widget.tk.getint(widget.pack_info()['padx'])
|
|
padx += widget.tk.getint(widget.cget('padx'))
|
|
# Calculate the required border width
|
|
border = 0
|
|
for widget in widgets:
|
|
border += widget.tk.getint(widget.cget('border'))
|
|
self.label = tkinter.Label(self.editwin.top,
|
|
text="\n" * (self.context_depth - 1),
|
|
anchor=W, justify=LEFT,
|
|
font=self.textfont,
|
|
bg=self.bgcolor, fg=self.fgcolor,
|
|
width=1, #don't request more than we get
|
|
padx=padx, border=border,
|
|
relief=SUNKEN)
|
|
# Pack the label widget before and above the text_frame widget,
|
|
# thus ensuring that it will appear directly above text_frame
|
|
self.label.pack(side=TOP, fill=X, expand=False,
|
|
before=self.editwin.text_frame)
|
|
else:
|
|
self.label.destroy()
|
|
self.label = None
|
|
idleConf.SetOption("main", "Theme", "contexton",
|
|
str(self.label is not None))
|
|
idleConf.SaveUserCfgFiles()
|
|
return "break"
|
|
|
|
def get_line_info(self, linenum):
|
|
"""Get the line indent value, text, and any block start keyword
|
|
|
|
If the line does not start a block, the keyword value is False.
|
|
The indentation of empty lines (or comment lines) is INFINITY.
|
|
|
|
"""
|
|
text = self.text.get("%d.0" % linenum, "%d.end" % linenum)
|
|
spaces, firstword = getspacesfirstword(text)
|
|
opener = firstword in BLOCKOPENERS and firstword
|
|
if len(text) == len(spaces) or text[len(spaces)] == '#':
|
|
indent = INFINITY
|
|
else:
|
|
indent = len(spaces)
|
|
return indent, text, opener
|
|
|
|
def get_context(self, new_topvisible, stopline=1, stopindent=0):
|
|
"""Get context lines, starting at new_topvisible and working backwards.
|
|
|
|
Stop when stopline or stopindent is reached. Return a tuple of context
|
|
data and the indent level at the top of the region inspected.
|
|
|
|
"""
|
|
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):
|
|
indent, text, opener = self.get_line_info(linenum)
|
|
if indent < lastindent:
|
|
lastindent = indent
|
|
if opener in ("else", "elif"):
|
|
# We 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.
|
|
|
|
"""
|
|
new_topvisible = int(self.text.index("@0,0").split('.')[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]
|
|
elif 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
|
|
# empty lines in context pane:
|
|
context_strings = [""] * max(0, self.context_depth - len(self.info))
|
|
# followed by the context hint lines:
|
|
context_strings += [x[2] for x in self.info[-self.context_depth:]]
|
|
self.label["text"] = '\n'.join(context_strings)
|
|
|
|
def timer_event(self):
|
|
if self.label:
|
|
self.update_code_context()
|
|
self.text.after(UPDATEINTERVAL, self.timer_event)
|
|
|
|
def font_timer_event(self):
|
|
newtextfont = self.text["font"]
|
|
if self.label and newtextfont != self.textfont:
|
|
self.textfont = newtextfont
|
|
self.label["font"] = self.textfont
|
|
self.text.after(FONTUPDATEINTERVAL, self.font_timer_event)
|
|
|
|
|
|
CodeContext.reload()
|