

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: CodeContext.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>&quot;&quot;&quot;CodeContext - Extension to 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. &#039;if&#039;, 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.

&quot;&quot;&quot;
import Tkinter
from Tkconstants import TOP, LEFT, X, W, SUNKEN
import re
from sys import maxint as INFINITY
from idlelib.configHandler import idleConf

BLOCKOPENERS = {&quot;class&quot;, &quot;def&quot;, &quot;elif&quot;, &quot;else&quot;, &quot;except&quot;, &quot;finally&quot;, &quot;for&quot;,
                    &quot;if&quot;, &quot;try&quot;, &quot;while&quot;, &quot;with&quot;}
UPDATEINTERVAL = 100 # millisec
FONTUPDATEINTERVAL = 1000 # millisec

getspacesfirstword =\
                   lambda s, c=re.compile(r&quot;^(\s*)(\w*)&quot;): c.match(s).groups()

class CodeContext:
    menudefs = [(&#039;options&#039;, [(&#039;!Code Conte_xt&#039;, &#039;&lt;&lt;toggle-code-context&gt;&gt;&#039;)])]
    context_depth = idleConf.GetOption(&quot;extensions&quot;, &quot;CodeContext&quot;,
                                       &quot;numlines&quot;, type=&quot;int&quot;, default=3)
    bgcolor = idleConf.GetOption(&quot;extensions&quot;, &quot;CodeContext&quot;,
                                 &quot;bgcolor&quot;, type=&quot;str&quot;, default=&quot;LightGray&quot;)
    fgcolor = idleConf.GetOption(&quot;extensions&quot;, &quot;CodeContext&quot;,
                                 &quot;fgcolor&quot;, type=&quot;str&quot;, default=&quot;Black&quot;)
    def __init__(self, editwin):
        self.editwin = editwin
        self.text = editwin.text
        self.textfont = self.text[&quot;font&quot;]
        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 &#039;dummy&#039; line which
        # starts the toplevel &#039;block&#039; of the module.
        self.info = [(0, -1, &quot;&quot;, False)]
        self.topvisible = 1
        visible = idleConf.GetOption(&quot;extensions&quot;, &quot;CodeContext&quot;,
                                     &quot;visible&quot;, type=&quot;bool&quot;, default=False)
        if visible:
            self.toggle_code_context_event()
            self.editwin.setvar(&#039;&lt;&lt;toggle-code-context&gt;&gt;&#039;, 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:
            # 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 int(str(&lt;value&gt;)), since some
            # values may be pixel objects, which can&#039;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 += int(str( widget.pack_info()[&#039;padx&#039;] ))
                padx += int(str( widget.cget(&#039;padx&#039;) ))
            # Calculate the required border width
            border = 0
            for widget in widgets:
                border += int(str( widget.cget(&#039;border&#039;) ))
            self.label = Tkinter.Label(self.editwin.top,
                                       text=&quot;\n&quot; * (self.context_depth - 1),
                                       anchor=W, justify=LEFT,
                                       font=self.textfont,
                                       bg=self.bgcolor, fg=self.fgcolor,
                                       width=1, #don&#039;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(&quot;extensions&quot;, &quot;CodeContext&quot;, &quot;visible&quot;,
                           str(self.label is not None))
        idleConf.SaveUserCfgFiles()

    def get_line_info(self, linenum):
        &quot;&quot;&quot;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.

        &quot;&quot;&quot;
        text = self.text.get(&quot;%d.0&quot; % linenum, &quot;%d.end&quot; % linenum)
        spaces, firstword = getspacesfirstword(text)
        opener = firstword in BLOCKOPENERS and firstword
        if len(text) == len(spaces) or text[len(spaces)] == &#039;#&#039;:
            indent = INFINITY
        else:
            indent = len(spaces)
        return indent, text, opener

    def get_context(self, new_topvisible, stopline=1, stopindent=0):
        &quot;&quot;&quot;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.

        &quot;&quot;&quot;
        assert stopline &gt; 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 xrange(new_topvisible, stopline-1, -1):
            indent, text, opener = self.get_line_info(linenum)
            if indent &lt; lastindent:
                lastindent = indent
                if opener in (&quot;else&quot;, &quot;elif&quot;):
                    # We also show the if statement
                    lastindent += 1
                if opener and linenum &lt; new_topvisible and indent &gt;= stopindent:
                    lines.append((linenum, indent, text, opener))
                if lastindent &lt;= stopindent:
                    break
        lines.reverse()
        return lines, lastindent

    def update_code_context(self):
        &quot;&quot;&quot;Update context information and lines visible in the context pane.

        &quot;&quot;&quot;
        new_topvisible = int(self.text.index(&quot;@0,0&quot;).split(&#039;.&#039;)[0])
        if self.topvisible == new_topvisible:      # haven&#039;t scrolled
            return
        if self.topvisible &lt; 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] &gt;= lastindent:
                del self.info[-1]
        elif self.topvisible &gt; 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] &gt;= 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 = [&quot;&quot;] * 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[&quot;text&quot;] = &#039;\n&#039;.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[&quot;font&quot;]
        if self.label and newtextfont != self.textfont:
            self.textfont = newtextfont
            self.label[&quot;font&quot;] = self.textfont
        self.text.after(FONTUPDATEINTERVAL, self.font_timer_event)
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/idlelib/CodeContext.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython2.7%2Fidlelib' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>