Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / devtools / v9 / 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)