[OpenSPARC-T2-SAM] / sam-t2 / devtools / v8plus / lib / python2.4 / idlelib / CodeContext.py

"""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)
Commit	Line	Data
920dae64 AT	1	"""CodeContext - Display the block context of code at top of edit window
	2
	3	Once code has scrolled off the top of the screen, it can be difficult
	4	to determine which block you are in. This extension implements a pane
	5	at the top of each IDLE edit window which provides block structure
	6	hints. These hints are the lines which contain the block opening
	7	keywords, e.g. 'if', for the enclosing block. The number of hint lines
	8	is determined by the numlines variable in the CodeContext section of
	9	config-extensions.def. Lines which do not open blocks are not shown in
	10	the context hints pane.
	11
	12	"""
	13	import Tkinter
	14	from configHandler import idleConf
	15	from sets import Set
	16	import re
	17
	18	BLOCKOPENERS = Set(["class", "def", "elif", "else", "except", "finally", "for",
	19	"if", "try", "while"])
	20	INFINITY = 1 << 30
	21	UPDATEINTERVAL = 100 # millisec
	22	FONTUPDATEINTERVAL = 1000 # millisec
	23
	24	getspacesfirstword = lambda s, c=re.compile(r"^(\s)(\w)"): c.match(s).groups()
	25
	26	class CodeContext:
	27	menudefs = [('options', [('!Code Conte_xt', '<<toggle-code-context>>')])]
	28
	29	numlines = idleConf.GetOption("extensions", "CodeContext",
	30	"numlines", type="int", default=3)
	31	bgcolor = idleConf.GetOption("extensions", "CodeContext",
	32	"bgcolor", type="str", default="LightGray")
	33	fgcolor = idleConf.GetOption("extensions", "CodeContext",
	34	"fgcolor", type="str", default="Black")
	35	def __init__(self, editwin):
	36	self.editwin = editwin
	37	self.text = editwin.text
	38	self.textfont = self.text["font"]
	39	self.label = None
	40	# Dummy line, which starts the "block" of the whole document:
	41	self.info = list(self.interesting_lines(1))
	42	self.lastfirstline = 1
	43	visible = idleConf.GetOption("extensions", "CodeContext",
	44	"visible", type="bool", default=False)
	45	if visible:
	46	self.toggle_code_context_event()
	47	self.editwin.setvar('<<toggle-code-context>>', True)
	48	# Start two update cycles, one for context lines, one for font changes.
	49	self.text.after(UPDATEINTERVAL, self.timer_event)
	50	self.text.after(FONTUPDATEINTERVAL, self.font_timer_event)
	51
	52	def toggle_code_context_event(self, event=None):
	53	if not self.label:
	54	self.label = Tkinter.Label(self.editwin.top,
	55	text="\n" * (self.numlines - 1),
	56	anchor="w", justify="left",
	57	font=self.textfont,
	58	bg=self.bgcolor, fg=self.fgcolor,
	59	relief="sunken",
	60	width=1, # Don't request more than we get
	61	)
	62	self.label.pack(side="top", fill="x", expand=0,
	63	after=self.editwin.status_bar)
	64	else:
65	self.label.destroy()
66	self.label = None
67	idleConf.SetOption("extensions", "CodeContext", "visible",
68	str(self.label is not None))
69	idleConf.SaveUserCfgFiles()
70
71	def get_line_info(self, linenum):
72	"""Get the line indent value, text, and any block start keyword
73
74	If the line does not start a block, the keyword value is False.
75	The indentation of empty lines (or comment lines) is INFINITY.
76	There is a dummy block start, with indentation -1 and text "".
77
78	Return the indent level, text (including leading whitespace),
79	and the block opening keyword.
80
81	"""
82	if linenum == 0:
83	return -1, "", True
84	text = self.text.get("%d.0" % linenum, "%d.end" % linenum)
85	spaces, firstword = getspacesfirstword(text)
86	opener = firstword in BLOCKOPENERS and firstword
87	if len(text) == len(spaces) or text[len(spaces)] == '#':
88	indent = INFINITY
89	else:
90	indent = len(spaces)
91	return indent, text, opener
92
93	def interesting_lines(self, firstline):
94	"""Generator which yields context lines, starting at firstline."""
95	# The indentation level we are currently in:
96	lastindent = INFINITY
97	# For a line to be interesting, it must begin with a block opening
98	# keyword, and have less indentation than lastindent.
99	for line_index in xrange(firstline, -1, -1):
100	indent, text, opener = self.get_line_info(line_index)
101	if indent < lastindent:
102	lastindent = indent
103	if opener in ("else", "elif"):
104	# We also show the if statement
105	lastindent += 1
106	if opener and line_index < firstline:
107	yield line_index, text
108
109	def update_label(self):
110	firstline = int(self.text.index("@0,0").split('.')[0])
111	if self.lastfirstline == firstline:
112	return
113	self.lastfirstline = firstline
114	tmpstack = []
115	for line_index, text in self.interesting_lines(firstline):
116	# Remove irrelevant self.info items, and when we reach a relevant
117	# item (which must happen because of the dummy element), break.
118	while self.info[-1][0] > line_index:
119	del self.info[-1]
120	if self.info[-1][0] == line_index:
121	break
122	tmpstack.append((line_index, text))
123	while tmpstack:
124	self.info.append(tmpstack.pop())
125	lines = [""] * max(0, self.numlines - len(self.info)) + \
126	[x[1] for x in self.info[-self.numlines:]]
127	self.label["text"] = '\n'.join(lines)
128
129	def timer_event(self):
130	if self.label:
131	self.update_label()
132	self.text.after(UPDATEINTERVAL, self.timer_event)
133
134	def font_timer_event(self):
135	newtextfont = self.text["font"]
136	if self.label and newtextfont != self.textfont:
137	self.textfont = newtextfont
138	self.label["font"] = self.textfont
139	self.text.after(FONTUPDATEINTERVAL, self.font_timer_event)