140 lines
6.0 KiB
Python
140 lines
6.0 KiB
Python
"""CodeContext - Display the block context of code at top of edit window
|
|
|
|
Once code has scrolled off the top of the screen, 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 Tkinter
|
|
from configHandler import idleConf
|
|
from sets import Set
|
|
import re
|
|
|
|
BLOCKOPENERS = Set(["class", "def", "elif", "else", "except", "finally", "for",
|
|
"if", "try", "while"])
|
|
INFINITY = 1 << 30
|
|
UPDATEINTERVAL = 100 # millisec
|
|
FONTUPDATEINTERVAL = 1000 # millisec
|
|
|
|
getspacesfirstword = lambda s, c=re.compile(r"^(\s*)(\w*)"): c.match(s).groups()
|
|
|
|
class CodeContext:
|
|
menudefs = [('options', [('!Code Conte_xt', '<<toggle-code-context>>')])]
|
|
|
|
numlines = idleConf.GetOption("extensions", "CodeContext",
|
|
"numlines", type="int", default=3)
|
|
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
|
|
# Dummy line, which starts the "block" of the whole document:
|
|
self.info = list(self.interesting_lines(1))
|
|
self.lastfirstline = 1
|
|
visible = idleConf.GetOption("extensions", "CodeContext",
|
|
"visible", type="bool", default=False)
|
|
if visible:
|
|
self.toggle_code_context_event()
|
|
self.editwin.setvar('<<toggle-code-context>>', True)
|
|
# 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)
|
|
|
|
def toggle_code_context_event(self, event=None):
|
|
if not self.label:
|
|
self.label = Tkinter.Label(self.editwin.top,
|
|
text="\n" * (self.numlines - 1),
|
|
anchor="w", justify="left",
|
|
font=self.textfont,
|
|
bg=self.bgcolor, fg=self.fgcolor,
|
|
relief="sunken",
|
|
width=1, # Don't request more than we get
|
|
)
|
|
self.label.pack(side="top", fill="x", expand=0,
|
|
after=self.editwin.status_bar)
|
|
else:
|
|
self.label.destroy()
|
|
self.label = None
|
|
idleConf.SetOption("extensions", "CodeContext", "visible",
|
|
str(self.label is not None))
|
|
idleConf.SaveUserCfgFiles()
|
|
|
|
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.
|
|
There is a dummy block start, with indentation -1 and text "".
|
|
|
|
Return the indent level, text (including leading whitespace),
|
|
and the block opening keyword.
|
|
|
|
"""
|
|
if linenum == 0:
|
|
return -1, "", True
|
|
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 interesting_lines(self, firstline):
|
|
"""Generator which yields context lines, starting at firstline."""
|
|
# 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 line_index in xrange(firstline, -1, -1):
|
|
indent, text, opener = self.get_line_info(line_index)
|
|
if indent < lastindent:
|
|
lastindent = indent
|
|
if opener in ("else", "elif"):
|
|
# We also show the if statement
|
|
lastindent += 1
|
|
if opener and line_index < firstline:
|
|
yield line_index, text
|
|
|
|
def update_label(self):
|
|
firstline = int(self.text.index("@0,0").split('.')[0])
|
|
if self.lastfirstline == firstline:
|
|
return
|
|
self.lastfirstline = firstline
|
|
tmpstack = []
|
|
for line_index, text in self.interesting_lines(firstline):
|
|
# Remove irrelevant self.info items, and when we reach a relevant
|
|
# item (which must happen because of the dummy element), break.
|
|
while self.info[-1][0] > line_index:
|
|
del self.info[-1]
|
|
if self.info[-1][0] == line_index:
|
|
break
|
|
tmpstack.append((line_index, text))
|
|
while tmpstack:
|
|
self.info.append(tmpstack.pop())
|
|
lines = [""] * max(0, self.numlines - len(self.info)) + \
|
|
[x[1] for x in self.info[-self.numlines:]]
|
|
self.label["text"] = '\n'.join(lines)
|
|
|
|
def timer_event(self):
|
|
if self.label:
|
|
self.update_label()
|
|
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)
|