File Manager

X7ROOT File Manager

Current Path: /opt/alt/python27/lib64/python2.7/idlelib

opt / alt / python27 / lib64 / python2.7 / idlelib /

ðŸ“ ..
ðŸ“„ AutoComplete.py(8.75 KB)
ðŸ“„ AutoComplete.pyc(7.99 KB)
ðŸ“„ AutoComplete.pyo(7.99 KB)
ðŸ“„ AutoCompleteWindow.py(16.91 KB)
ðŸ“„ AutoCompleteWindow.pyc(12.42 KB)
ðŸ“„ AutoCompleteWindow.pyo(12.36 KB)
ðŸ“„ AutoExpand.py(3.32 KB)
ðŸ“„ AutoExpand.pyc(3.5 KB)
ðŸ“„ AutoExpand.pyo(3.5 KB)
ðŸ“„ Bindings.py(2.91 KB)
ðŸ“„ Bindings.pyc(4.6 KB)
ðŸ“„ Bindings.pyo(4.6 KB)
ðŸ“„ CREDITS.txt(1.82 KB)
ðŸ“„ CallTipWindow.py(5.92 KB)
ðŸ“„ CallTipWindow.pyc(6.14 KB)
ðŸ“„ CallTipWindow.pyo(6.14 KB)
ðŸ“„ CallTips.py(7.56 KB)
ðŸ“„ CallTips.pyc(8.16 KB)
ðŸ“„ CallTips.pyo(8.16 KB)
ðŸ“„ ChangeLog(55.07 KB)
ðŸ“„ ClassBrowser.py(6.83 KB)
ðŸ“„ ClassBrowser.pyc(9.66 KB)
ðŸ“„ ClassBrowser.pyo(9.66 KB)
ðŸ“„ CodeContext.py(8.15 KB)
ðŸ“„ CodeContext.pyc(6.63 KB)
ðŸ“„ CodeContext.pyo(6.59 KB)
ðŸ“„ ColorDelegator.py(9.53 KB)
ðŸ“„ ColorDelegator.pyc(8.91 KB)
ðŸ“„ ColorDelegator.pyo(8.91 KB)
ðŸ“„ Debugger.py(17.81 KB)
ðŸ“„ Debugger.pyc(17.72 KB)
ðŸ“„ Debugger.pyo(17.72 KB)
ðŸ“„ Delegator.py(665 B)
ðŸ“„ Delegator.pyc(1.31 KB)
ðŸ“„ Delegator.pyo(1.31 KB)
ðŸ“„ EditorWindow.py(63.96 KB)
ðŸ“„ EditorWindow.pyc(57.15 KB)
ðŸ“„ EditorWindow.pyo(57.05 KB)
ðŸ“„ FileList.py(3.63 KB)
ðŸ“„ FileList.pyc(4.07 KB)
ðŸ“„ FileList.pyo(4.04 KB)
ðŸ“„ FormatParagraph.py(7.12 KB)
ðŸ“„ FormatParagraph.pyc(7.14 KB)
ðŸ“„ FormatParagraph.pyo(7.14 KB)
ðŸ“„ GrepDialog.py(5.02 KB)
ðŸ“„ GrepDialog.pyc(6.45 KB)
ðŸ“„ GrepDialog.pyo(6.45 KB)
ðŸ“„ HISTORY.txt(10.08 KB)
ðŸ“„ HyperParser.py(10.25 KB)
ðŸ“„ HyperParser.pyc(6.64 KB)
ðŸ“„ HyperParser.pyo(6.64 KB)
ðŸ“„ IOBinding.py(21.4 KB)
ðŸ“„ IOBinding.pyc(18.62 KB)
ðŸ“„ IOBinding.pyo(18.62 KB)
ðŸ“ Icons
ðŸ“„ IdleHistory.py(3.96 KB)
ðŸ“„ IdleHistory.pyc(4.05 KB)
ðŸ“„ IdleHistory.pyo(4.05 KB)
ðŸ“„ MultiCall.py(17.29 KB)
ðŸ“„ MultiCall.pyc(16.4 KB)
ðŸ“„ MultiCall.pyo(16.33 KB)
ðŸ“„ MultiStatusBar.py(1.32 KB)
ðŸ“„ MultiStatusBar.pyc(2.3 KB)
ðŸ“„ MultiStatusBar.pyo(2.3 KB)
ðŸ“„ NEWS.txt(46.14 KB)
ðŸ“„ ObjectBrowser.py(4.27 KB)
ðŸ“„ ObjectBrowser.pyc(7.26 KB)
ðŸ“„ ObjectBrowser.pyo(7.26 KB)
ðŸ“„ OutputWindow.py(4.47 KB)
ðŸ“„ OutputWindow.pyc(5.3 KB)
ðŸ“„ OutputWindow.pyo(5.3 KB)
ðŸ“„ ParenMatch.py(6.56 KB)
ðŸ“„ ParenMatch.pyc(7.18 KB)
ðŸ“„ ParenMatch.pyo(7.18 KB)
ðŸ“„ PathBrowser.py(2.94 KB)
ðŸ“„ PathBrowser.pyc(4.57 KB)
ðŸ“„ PathBrowser.pyo(4.57 KB)
ðŸ“„ Percolator.py(3.15 KB)
ðŸ“„ Percolator.pyc(4.69 KB)
ðŸ“„ Percolator.pyo(4.51 KB)
ðŸ“„ PyParse.py(19.05 KB)
ðŸ“„ PyParse.pyc(9.99 KB)
ðŸ“„ PyParse.pyo(9.56 KB)
ðŸ“„ PyShell.py(57.49 KB)
ðŸ“„ PyShell.pyc(53 KB)
ðŸ“„ PyShell.pyo(52.9 KB)
ðŸ“„ README.txt(7.71 KB)
ðŸ“„ RemoteDebugger.py(11.36 KB)
ðŸ“„ RemoteDebugger.pyc(16.73 KB)
ðŸ“„ RemoteDebugger.pyo(16.58 KB)
ðŸ“„ RemoteObjectBrowser.py(942 B)
ðŸ“„ RemoteObjectBrowser.pyc(2.23 KB)
ðŸ“„ RemoteObjectBrowser.pyo(2.23 KB)
ðŸ“„ ReplaceDialog.py(6.48 KB)
ðŸ“„ ReplaceDialog.pyc(7.83 KB)
ðŸ“„ ReplaceDialog.pyo(7.83 KB)
ðŸ“„ RstripExtension.py(1.03 KB)
ðŸ“„ RstripExtension.pyc(1.63 KB)
ðŸ“„ RstripExtension.pyo(1.63 KB)
ðŸ“„ ScriptBinding.py(8.26 KB)
ðŸ“„ ScriptBinding.pyc(8.17 KB)
ðŸ“„ ScriptBinding.pyo(8.17 KB)
ðŸ“„ ScrolledList.py(4.27 KB)
ðŸ“„ ScrolledList.pyc(6.61 KB)
ðŸ“„ ScrolledList.pyo(6.61 KB)
ðŸ“„ SearchDialog.py(2.57 KB)
ðŸ“„ SearchDialog.pyc(4.04 KB)
ðŸ“„ SearchDialog.pyo(4.04 KB)
ðŸ“„ SearchDialogBase.py(6.93 KB)
ðŸ“„ SearchDialogBase.pyc(8.43 KB)
ðŸ“„ SearchDialogBase.pyo(8.43 KB)
ðŸ“„ SearchEngine.py(7.29 KB)
ðŸ“„ SearchEngine.pyc(8.37 KB)
ðŸ“„ SearchEngine.pyo(8.37 KB)
ðŸ“„ StackViewer.py(4.33 KB)
ðŸ“„ StackViewer.pyc(6.52 KB)
ðŸ“„ StackViewer.pyo(6.52 KB)
ðŸ“„ TODO.txt(8.28 KB)
ðŸ“„ ToolTip.py(3.1 KB)
ðŸ“„ ToolTip.pyc(4.78 KB)
ðŸ“„ ToolTip.pyo(4.78 KB)
ðŸ“„ TreeWidget.py(14.68 KB)
ðŸ“„ TreeWidget.pyc(17.95 KB)
ðŸ“„ TreeWidget.pyo(17.95 KB)
ðŸ“„ UndoDelegator.py(10.53 KB)
ðŸ“„ UndoDelegator.pyc(13.88 KB)
ðŸ“„ UndoDelegator.pyo(13.88 KB)
ðŸ“„ WidgetRedirector.py(6.74 KB)
ðŸ“„ WidgetRedirector.pyc(7.76 KB)
ðŸ“„ WidgetRedirector.pyo(7.76 KB)
ðŸ“„ WindowList.py(2.42 KB)
ðŸ“„ WindowList.pyc(3.74 KB)
ðŸ“„ WindowList.pyo(3.74 KB)
ðŸ“„ ZoomHeight.py(1.27 KB)
ðŸ“„ ZoomHeight.pyc(1.67 KB)
ðŸ“„ ZoomHeight.pyo(1.67 KB)
ðŸ“„ __init__.py(288 B)
ðŸ“„ __init__.pyc(444 B)
ðŸ“„ __init__.pyo(444 B)
ðŸ“„ aboutDialog.py(6.85 KB)
ðŸ“„ aboutDialog.pyc(6.85 KB)
ðŸ“„ aboutDialog.pyo(6.85 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(64.41 KB)
ðŸ“„ configDialog.pyc(53.16 KB)
ðŸ“„ configDialog.pyo(53.16 KB)
ðŸ“„ configHandler.py(31.72 KB)
ðŸ“„ configHandler.pyc(29.28 KB)
ðŸ“„ configHandler.pyo(29.28 KB)
ðŸ“„ configHelpSourceEdit.py(6.53 KB)
ðŸ“„ configHelpSourceEdit.pyc(6.55 KB)
ðŸ“„ configHelpSourceEdit.pyo(6.55 KB)
ðŸ“„ configSectionNameDialog.py(3.95 KB)
ðŸ“„ configSectionNameDialog.pyc(4.4 KB)
ðŸ“„ configSectionNameDialog.pyo(4.4 KB)
ðŸ“„ dynOptionMenuWidget.py(1.94 KB)
ðŸ“„ dynOptionMenuWidget.pyc(2.8 KB)
ðŸ“„ dynOptionMenuWidget.pyo(2.8 KB)
ðŸ“„ extend.txt(3.56 KB)
ðŸ“„ help.html(41.42 KB)
ðŸ“„ help.py(10.78 KB)
ðŸ“„ help.pyc(12.25 KB)
ðŸ“„ help.pyo(12.25 KB)
ðŸ“„ help.txt(11.86 KB)
ðŸ“„ idle.py(453 B)
ðŸ“„ idle.pyc(423 B)
ðŸ“„ idle.pyo(423 B)
ðŸ“„ idle.pyw(563 B)
ðŸ“ idle_test
ðŸ“„ idlever.py(415 B)
ðŸ“„ idlever.pyc(591 B)
ðŸ“„ idlever.pyo(591 B)
ðŸ“„ keybindingDialog.py(12.18 KB)
ðŸ“„ keybindingDialog.pyc(12.08 KB)
ðŸ“„ keybindingDialog.pyo(12.08 KB)
ðŸ“„ macosxSupport.py(8.24 KB)
ðŸ“„ macosxSupport.pyc(8.38 KB)
ðŸ“„ macosxSupport.pyo(8.25 KB)
ðŸ“„ rpc.py(19.68 KB)
ðŸ“„ rpc.pyc(21.97 KB)
ðŸ“„ rpc.pyo(21.86 KB)
ðŸ“„ run.py(12.61 KB)
ðŸ“„ run.pyc(13.45 KB)
ðŸ“„ run.pyo(13.39 KB)
ðŸ“„ tabbedpages.py(18.01 KB)
ðŸ“„ tabbedpages.pyc(18.63 KB)
ðŸ“„ tabbedpages.pyo(18.63 KB)
ðŸ“„ textView.py(3.44 KB)
ðŸ“„ textView.pyc(4.02 KB)
ðŸ“„ textView.pyo(4.02 KB)

Editing: UndoDelegator.py

import string
from Tkinter import *

from idlelib.Delegator import Delegator

#$ event <<redo>>
#$ win <Control-y>
#$ unix <Alt-z>

#$ event <<undo>>
#$ win <Control-z>
#$ unix <Control-z>

#$ event <<dump-undo-state>>
#$ win <Control-backslash>
#$ unix <Control-backslash>

class UndoDelegator(Delegator):

max_undo = 1000

def __init__(self):
        Delegator.__init__(self)
        self.reset_undo()

def setdelegate(self, delegate):
        if self.delegate is not None:
            self.unbind("<<undo>>")
            self.unbind("<<redo>>")
            self.unbind("<<dump-undo-state>>")
        Delegator.setdelegate(self, delegate)
        if delegate is not None:
            self.bind("<<undo>>", self.undo_event)
            self.bind("<<redo>>", self.redo_event)
            self.bind("<<dump-undo-state>>", self.dump_event)

def dump_event(self, event):
        from pprint import pprint
        pprint(self.undolist[:self.pointer])
        print "pointer:", self.pointer,
        print "saved:", self.saved,
        print "can_merge:", self.can_merge,
        print "get_saved():", self.get_saved()
        pprint(self.undolist[self.pointer:])
        return "break"

def reset_undo(self):
        self.was_saved = -1
        self.pointer = 0
        self.undolist = []
        self.undoblock = 0  # or a CommandSequence instance
        self.set_saved(1)

def set_saved(self, flag):
        if flag:
            self.saved = self.pointer
        else:
            self.saved = -1
        self.can_merge = False
        self.check_saved()

def get_saved(self):
        return self.saved == self.pointer

saved_change_hook = None

def set_saved_change_hook(self, hook):
        self.saved_change_hook = hook

was_saved = -1

def check_saved(self):
        is_saved = self.get_saved()
        if is_saved != self.was_saved:
            self.was_saved = is_saved
            if self.saved_change_hook:
                self.saved_change_hook()

def insert(self, index, chars, tags=None):
        self.addcmd(InsertCommand(index, chars, tags))

def delete(self, index1, index2=None):
        self.addcmd(DeleteCommand(index1, index2))

# Clients should call undo_block_start() and undo_block_stop()
    # around a sequence of editing cmds to be treated as a unit by
    # undo & redo.  Nested matching calls are OK, and the inner calls
    # then act like nops.  OK too if no editing cmds, or only one
    # editing cmd, is issued in between:  if no cmds, the whole
    # sequence has no effect; and if only one cmd, that cmd is entered
    # directly into the undo list, as if undo_block_xxx hadn't been
    # called.  The intent of all that is to make this scheme easy
    # to use:  all the client has to worry about is making sure each
    # _start() call is matched by a _stop() call.

def undo_block_start(self):
        if self.undoblock == 0:
            self.undoblock = CommandSequence()
        self.undoblock.bump_depth()

def undo_block_stop(self):
        if self.undoblock.bump_depth(-1) == 0:
            cmd = self.undoblock
            self.undoblock = 0
            if len(cmd) > 0:
                if len(cmd) == 1:
                    # no need to wrap a single cmd
                    cmd = cmd.getcmd(0)
                # this blk of cmds, or single cmd, has already
                # been done, so don't execute it again
                self.addcmd(cmd, 0)

def addcmd(self, cmd, execute=True):
        if execute:
            cmd.do(self.delegate)
        if self.undoblock != 0:
            self.undoblock.append(cmd)
            return
        if self.can_merge and self.pointer > 0:
            lastcmd = self.undolist[self.pointer-1]
            if lastcmd.merge(cmd):
                return
        self.undolist[self.pointer:] = [cmd]
        if self.saved > self.pointer:
            self.saved = -1
        self.pointer = self.pointer + 1
        if len(self.undolist) > self.max_undo:
            ##print "truncating undo list"
            del self.undolist[0]
            self.pointer = self.pointer - 1
            if self.saved >= 0:
                self.saved = self.saved - 1
        self.can_merge = True
        self.check_saved()

def undo_event(self, event):
        if self.pointer == 0:
            self.bell()
            return "break"
        cmd = self.undolist[self.pointer - 1]
        cmd.undo(self.delegate)
        self.pointer = self.pointer - 1
        self.can_merge = False
        self.check_saved()
        return "break"

def redo_event(self, event):
        if self.pointer >= len(self.undolist):
            self.bell()
            return "break"
        cmd = self.undolist[self.pointer]
        cmd.redo(self.delegate)
        self.pointer = self.pointer + 1
        self.can_merge = False
        self.check_saved()
        return "break"

class Command:

# Base class for Undoable commands

tags = None

def __init__(self, index1, index2, chars, tags=None):
        self.marks_before = {}
        self.marks_after = {}
        self.index1 = index1
        self.index2 = index2
        self.chars = chars
        if tags:
            self.tags = tags

def __repr__(self):
        s = self.__class__.__name__
        t = (self.index1, self.index2, self.chars, self.tags)
        if self.tags is None:
            t = t[:-1]
        return s + repr(t)

def do(self, text):
        pass

def redo(self, text):
        pass

def undo(self, text):
        pass

def merge(self, cmd):
        return 0

def save_marks(self, text):
        marks = {}
        for name in text.mark_names():
            if name != "insert" and name != "current":
                marks[name] = text.index(name)
        return marks

def set_marks(self, text, marks):
        for name, index in marks.items():
            text.mark_set(name, index)

class InsertCommand(Command):

# Undoable insert command

def __init__(self, index1, chars, tags=None):
        Command.__init__(self, index1, None, chars, tags)

def do(self, text):
        self.marks_before = self.save_marks(text)
        self.index1 = text.index(self.index1)
        if text.compare(self.index1, ">", "end-1c"):
            # Insert before the final newline
            self.index1 = text.index("end-1c")
        text.insert(self.index1, self.chars, self.tags)
        self.index2 = text.index("%s+%dc" % (self.index1, len(self.chars)))
        self.marks_after = self.save_marks(text)
        ##sys.__stderr__.write("do: %s\n" % self)

def redo(self, text):
        text.mark_set('insert', self.index1)
        text.insert(self.index1, self.chars, self.tags)
        self.set_marks(text, self.marks_after)
        text.see('insert')
        ##sys.__stderr__.write("redo: %s\n" % self)

def undo(self, text):
        text.mark_set('insert', self.index1)
        text.delete(self.index1, self.index2)
        self.set_marks(text, self.marks_before)
        text.see('insert')
        ##sys.__stderr__.write("undo: %s\n" % self)

def merge(self, cmd):
        if self.__class__ is not cmd.__class__:
            return False
        if self.index2 != cmd.index1:
            return False
        if self.tags != cmd.tags:
            return False
        if len(cmd.chars) != 1:
            return False
        if self.chars and \
           self.classify(self.chars[-1]) != self.classify(cmd.chars):
            return False
        self.index2 = cmd.index2
        self.chars = self.chars + cmd.chars
        return True

alphanumeric = string.ascii_letters + string.digits + "_"

def classify(self, c):
        if c in self.alphanumeric:
            return "alphanumeric"
        if c == "\n":
            return "newline"
        return "punctuation"

class DeleteCommand(Command):

# Undoable delete command

def __init__(self, index1, index2=None):
        Command.__init__(self, index1, index2, None, None)

def do(self, text):
        self.marks_before = self.save_marks(text)
        self.index1 = text.index(self.index1)
        if self.index2:
            self.index2 = text.index(self.index2)
        else:
            self.index2 = text.index(self.index1 + " +1c")
        if text.compare(self.index2, ">", "end-1c"):
            # Don't delete the final newline
            self.index2 = text.index("end-1c")
        self.chars = text.get(self.index1, self.index2)
        text.delete(self.index1, self.index2)
        self.marks_after = self.save_marks(text)
        ##sys.__stderr__.write("do: %s\n" % self)

def redo(self, text):
        text.mark_set('insert', self.index1)
        text.delete(self.index1, self.index2)
        self.set_marks(text, self.marks_after)
        text.see('insert')
        ##sys.__stderr__.write("redo: %s\n" % self)

def undo(self, text):
        text.mark_set('insert', self.index1)
        text.insert(self.index1, self.chars)
        self.set_marks(text, self.marks_before)
        text.see('insert')
        ##sys.__stderr__.write("undo: %s\n" % self)

class CommandSequence(Command):

# Wrapper for a sequence of undoable cmds to be undone/redone
    # as a unit

def __init__(self):
        self.cmds = []
        self.depth = 0

def __repr__(self):
        s = self.__class__.__name__
        strs = []
        for cmd in self.cmds:
            strs.append("    %r" % (cmd,))
        return s + "(\n" + ",\n".join(strs) + "\n)"

def __len__(self):
        return len(self.cmds)

def append(self, cmd):
        self.cmds.append(cmd)

def getcmd(self, i):
        return self.cmds[i]

def redo(self, text):
        for cmd in self.cmds:
            cmd.redo(text)

def undo(self, text):
        cmds = self.cmds[:]
        cmds.reverse()
        for cmd in cmds:
            cmd.undo(text)

def bump_depth(self, incr=1):
        self.depth = self.depth + incr
        return self.depth

def _undo_delegator(parent):
    from idlelib.Percolator import Percolator
    root = Tk()
    root.title("Test UndoDelegator")
    width, height, x, y = list(map(int, re.split('[x+]', parent.geometry())))
    root.geometry("+%d+%d"%(x, y + 150))

text = Text(root)
    text.config(height=10)
    text.pack()
    text.focus_set()
    p = Percolator(text)
    d = UndoDelegator()
    p.insertfilter(d)

undo = Button(root, text="Undo", command=lambda:d.undo_event(None))
    undo.pack(side='left')
    redo = Button(root, text="Redo", command=lambda:d.redo_event(None))
    redo.pack(side='left')
    dump = Button(root, text="Dump", command=lambda:d.dump_event(None))
    dump.pack(side='left')

root.mainloop()

if __name__ == "__main__":
    from idlelib.idle_test.htest import run
    run(_undo_delegator)

X7ROOT File Manager

Editing: UndoDelegator.py

Upload File

Create Folder