File Manager

X7ROOT File Manager

Current Path: /opt/alt/python34/lib64/python3.4/idlelib

opt / alt / python34 / lib64 / python3.4 / idlelib /

ðŸ“ ..
ðŸ“„ AutoComplete.py(8.99 KB)
ðŸ“„ AutoCompleteWindow.py(17.32 KB)
ðŸ“„ AutoExpand.py(3.32 KB)
ðŸ“„ Bindings.py(2.97 KB)
ðŸ“„ CREDITS.txt(1.82 KB)
ðŸ“„ CallTipWindow.py(5.89 KB)
ðŸ“„ CallTips.py(5.79 KB)
ðŸ“„ ChangeLog(55.07 KB)
ðŸ“„ ClassBrowser.py(6.83 KB)
ðŸ“„ CodeContext.py(8.15 KB)
ðŸ“„ ColorDelegator.py(9.47 KB)
ðŸ“„ Debugger.py(18.32 KB)
ðŸ“„ Delegator.py(665 B)
ðŸ“„ EditorWindow.py(64.51 KB)
ðŸ“„ FileList.py(3.72 KB)
ðŸ“„ FormatParagraph.py(7.12 KB)
ðŸ“„ GrepDialog.py(5 KB)
ðŸ“„ HISTORY.txt(10.08 KB)
ðŸ“„ HyperParser.py(12.58 KB)
ðŸ“„ IOBinding.py(19.31 KB)
ðŸ“ Icons
ðŸ“„ IdleHistory.py(3.96 KB)
ðŸ“„ MultiCall.py(18.14 KB)
ðŸ“„ MultiStatusBar.py(1.32 KB)
ðŸ“„ NEWS.txt(38.9 KB)
ðŸ“„ ObjectBrowser.py(3.88 KB)
ðŸ“„ OutputWindow.py(4.29 KB)
ðŸ“„ ParenMatch.py(6.56 KB)
ðŸ“„ PathBrowser.py(3.13 KB)
ðŸ“„ Percolator.py(3.17 KB)
ðŸ“„ PyParse.py(19.98 KB)
ðŸ“„ PyShell.py(57.08 KB)
ðŸ“„ README.txt(7.53 KB)
ðŸ“„ RemoteDebugger.py(11.73 KB)
ðŸ“„ RemoteObjectBrowser.py(964 B)
ðŸ“„ ReplaceDialog.py(6.48 KB)
ðŸ“„ RstripExtension.py(1.03 KB)
ðŸ“„ ScriptBinding.py(7.87 KB)
ðŸ“„ ScrolledList.py(4.27 KB)
ðŸ“„ SearchDialog.py(2.57 KB)
ðŸ“„ SearchDialogBase.py(6.84 KB)
ðŸ“„ SearchEngine.py(7.31 KB)
ðŸ“„ StackViewer.py(4.32 KB)
ðŸ“„ TODO.txt(8.28 KB)
ðŸ“„ ToolTip.py(3.1 KB)
ðŸ“„ TreeWidget.py(14.67 KB)
ðŸ“„ UndoDelegator.py(10.56 KB)
ðŸ“„ WidgetRedirector.py(6.71 KB)
ðŸ“„ WindowList.py(2.41 KB)
ðŸ“„ ZoomHeight.py(1.27 KB)
ðŸ“„ __init__.py(288 B)
ðŸ“„ __main__.py(159 B)
ðŸ“ __pycache__
ðŸ“„ aboutDialog.py(6.53 KB)
ðŸ“„ config-extensions.def(2.9 KB)
ðŸ“„ config-highlight.def(2.46 KB)
ðŸ“„ config-keys.def(7.59 KB)
ðŸ“„ config-main.def(2.5 KB)
ðŸ“„ configDialog.py(62.8 KB)
ðŸ“„ configHandler.py(31.44 KB)
ðŸ“„ configHelpSourceEdit.py(6.51 KB)
ðŸ“„ configSectionNameDialog.py(3.91 KB)
ðŸ“„ dynOptionMenuWidget.py(1.94 KB)
ðŸ“„ extend.txt(3.56 KB)
ðŸ“„ help.html(40.16 KB)
ðŸ“„ help.py(9.47 KB)
ðŸ“„ help.txt(17.48 KB)
ðŸ“„ idle.py(400 B)
ðŸ“„ idle.pyw(570 B)
ðŸ“ idle_test
ðŸ“„ idlever.py(415 B)
ðŸ“„ keybindingDialog.py(12.13 KB)
ðŸ“„ macosxSupport.py(8.48 KB)
ðŸ“„ rpc.py(20.29 KB)
ðŸ“„ run.py(13.35 KB)
ðŸ“„ tabbedpages.py(17.99 KB)
ðŸ“„ textView.py(3.15 KB)

Editing: ParenMatch.py

"""ParenMatch -- An IDLE extension for parenthesis matching.

When you hit a right paren, the cursor should move briefly to the left
paren.  Paren here is used generically; the matching applies to
parentheses, square brackets, and curly braces.
"""

from idlelib.HyperParser import HyperParser
from idlelib.configHandler import idleConf

_openers = {')':'(',']':'[','}':'{'}
CHECK_DELAY = 100 # miliseconds

class ParenMatch:
    """Highlight matching parentheses

There are three supported style of paren matching, based loosely
    on the Emacs options.  The style is select based on the
    HILITE_STYLE attribute; it can be changed used the set_style
    method.

The supported styles are:

default -- When a right paren is typed, highlight the matching
        left paren for 1/2 sec.

expression -- When a right paren is typed, highlight the entire
        expression from the left paren to the right paren.

TODO:
        - extend IDLE with configuration dialog to change options
        - implement rest of Emacs highlight styles (see below)
        - print mismatch warning in IDLE status window

Note: In Emacs, there are several styles of highlight where the
    matching paren is highlighted whenever the cursor is immediately
    to the right of a right paren.  I don't know how to do that in Tk,
    so I haven't bothered.
    """
    menudefs = [
        ('edit', [
            ("Show surrounding parens", "<<flash-paren>>"),
        ])
    ]
    STYLE = idleConf.GetOption('extensions','ParenMatch','style',
            default='expression')
    FLASH_DELAY = idleConf.GetOption('extensions','ParenMatch','flash-delay',
            type='int',default=500)
    HILITE_CONFIG = idleConf.GetHighlight(idleConf.CurrentTheme(),'hilite')
    BELL = idleConf.GetOption('extensions','ParenMatch','bell',
            type='bool',default=1)

RESTORE_VIRTUAL_EVENT_NAME = "<<parenmatch-check-restore>>"
    # We want the restore event be called before the usual return and
    # backspace events.
    RESTORE_SEQUENCES = ("<KeyPress>", "<ButtonPress>",
                         "<Key-Return>", "<Key-BackSpace>")

def __init__(self, editwin):
        self.editwin = editwin
        self.text = editwin.text
        # Bind the check-restore event to the function restore_event,
        # so that we can then use activate_restore (which calls event_add)
        # and deactivate_restore (which calls event_delete).
        editwin.text.bind(self.RESTORE_VIRTUAL_EVENT_NAME,
                          self.restore_event)
        self.counter = 0
        self.is_restore_active = 0
        self.set_style(self.STYLE)

def activate_restore(self):
        if not self.is_restore_active:
            for seq in self.RESTORE_SEQUENCES:
                self.text.event_add(self.RESTORE_VIRTUAL_EVENT_NAME, seq)
            self.is_restore_active = True

def deactivate_restore(self):
        if self.is_restore_active:
            for seq in self.RESTORE_SEQUENCES:
                self.text.event_delete(self.RESTORE_VIRTUAL_EVENT_NAME, seq)
            self.is_restore_active = False

def set_style(self, style):
        self.STYLE = style
        if style == "default":
            self.create_tag = self.create_tag_default
            self.set_timeout = self.set_timeout_last
        elif style == "expression":
            self.create_tag = self.create_tag_expression
            self.set_timeout = self.set_timeout_none

def flash_paren_event(self, event):
        indices = (HyperParser(self.editwin, "insert")
                   .get_surrounding_brackets())
        if indices is None:
            self.warn_mismatched()
            return
        self.activate_restore()
        self.create_tag(indices)
        self.set_timeout_last()

def paren_closed_event(self, event):
        # If it was a shortcut and not really a closing paren, quit.
        closer = self.text.get("insert-1c")
        if closer not in _openers:
            return
        hp = HyperParser(self.editwin, "insert-1c")
        if not hp.is_in_code():
            return
        indices = hp.get_surrounding_brackets(_openers[closer], True)
        if indices is None:
            self.warn_mismatched()
            return
        self.activate_restore()
        self.create_tag(indices)
        self.set_timeout()

def restore_event(self, event=None):
        self.text.tag_delete("paren")
        self.deactivate_restore()
        self.counter += 1   # disable the last timer, if there is one.

def handle_restore_timer(self, timer_count):
        if timer_count == self.counter:
            self.restore_event()

def warn_mismatched(self):
        if self.BELL:
            self.text.bell()

# any one of the create_tag_XXX methods can be used depending on
    # the style

def create_tag_default(self, indices):
        """Highlight the single paren that matches"""
        self.text.tag_add("paren", indices[0])
        self.text.tag_config("paren", self.HILITE_CONFIG)

def create_tag_expression(self, indices):
        """Highlight the entire expression"""
        if self.text.get(indices[1]) in (')', ']', '}'):
            rightindex = indices[1]+"+1c"
        else:
            rightindex = indices[1]
        self.text.tag_add("paren", indices[0], rightindex)
        self.text.tag_config("paren", self.HILITE_CONFIG)

# any one of the set_timeout_XXX methods can be used depending on
    # the style

def set_timeout_none(self):
        """Highlight will remain until user input turns it off
        or the insert has moved"""
        # After CHECK_DELAY, call a function which disables the "paren" tag
        # if the event is for the most recent timer and the insert has changed,
        # or schedules another call for itself.
        self.counter += 1
        def callme(callme, self=self, c=self.counter,
                   index=self.text.index("insert")):
            if index != self.text.index("insert"):
                self.handle_restore_timer(c)
            else:
                self.editwin.text_frame.after(CHECK_DELAY, callme, callme)
        self.editwin.text_frame.after(CHECK_DELAY, callme, callme)

def set_timeout_last(self):
        """The last highlight created will be removed after .5 sec"""
        # associate a counter with an event; only disable the "paren"
        # tag if the event is for the most recent timer.
        self.counter += 1
        self.editwin.text_frame.after(
            self.FLASH_DELAY,
            lambda self=self, c=self.counter: self.handle_restore_timer(c))

if __name__ == '__main__':
    import unittest
    unittest.main('idlelib.idle_test.test_parenmatch', verbosity=2)

X7ROOT File Manager

Editing: ParenMatch.py

Upload File

Create Folder