File Manager

Hackfut Security File Manager

Current Path: /usr/lib64/python2.6/idlelib

usr / lib64 / python2.6 / idlelib /

📁 ..
📄 AutoComplete.py(8.85 KB)
📄 AutoComplete.pyc(7.83 KB)
📄 AutoComplete.pyo(7.83 KB)
📄 AutoCompleteWindow.py(16.8 KB)
📄 AutoCompleteWindow.pyc(12.29 KB)
📄 AutoCompleteWindow.pyo(12.22 KB)
📄 AutoExpand.py(2.42 KB)
📄 AutoExpand.pyc(2.53 KB)
📄 AutoExpand.pyo(2.53 KB)
📄 Bindings.py(3.42 KB)
📄 Bindings.pyc(4.95 KB)
📄 Bindings.pyo(4.95 KB)
📄 CREDITS.txt(1.81 KB)
📄 CallTipWindow.py(5.79 KB)
📄 CallTipWindow.pyc(6.07 KB)
📄 CallTipWindow.pyo(6.07 KB)
📄 CallTips.py(7.43 KB)
📄 CallTips.pyc(10.05 KB)
📄 CallTips.pyo(10.05 KB)
📄 ChangeLog(55.07 KB)
📄 ClassBrowser.py(6.22 KB)
📄 ClassBrowser.pyc(9 KB)
📄 ClassBrowser.pyo(9 KB)
📄 CodeContext.py(8.15 KB)
📄 CodeContext.pyc(6.58 KB)
📄 CodeContext.pyo(6.53 KB)
📄 ColorDelegator.py(9.91 KB)
📄 ColorDelegator.pyc(8.77 KB)
📄 ColorDelegator.pyo(8.77 KB)
📄 Debugger.py(15.45 KB)
📄 Debugger.pyc(16.67 KB)
📄 Debugger.pyo(16.67 KB)
📄 Delegator.py(831 B)
📄 Delegator.pyc(1.58 KB)
📄 Delegator.pyo(1.58 KB)
📄 EditorWindow.py(58.33 KB)
📄 EditorWindow.pyc(51.76 KB)
📄 EditorWindow.pyo(51.66 KB)
📄 FileList.py(3.57 KB)
📄 FileList.pyc(3.92 KB)
📄 FileList.pyo(3.88 KB)
📄 FormatParagraph.py(5.6 KB)
📄 FormatParagraph.pyc(4.71 KB)
📄 FormatParagraph.pyo(4.71 KB)
📄 GrepDialog.py(3.96 KB)
📄 GrepDialog.pyc(4.94 KB)
📄 GrepDialog.pyo(4.94 KB)
📄 HISTORY.txt(10.08 KB)
📄 HyperParser.py(10.07 KB)
📄 HyperParser.pyc(6.48 KB)
📄 HyperParser.pyo(6.48 KB)
📄 IOBinding.py(20.48 KB)
📄 IOBinding.pyc(17.37 KB)
📄 IOBinding.pyo(17.37 KB)
📁 Icons
📄 IdleHistory.py(3.07 KB)
📄 IdleHistory.pyc(3.16 KB)
📄 IdleHistory.pyo(3.16 KB)
📄 MultiCall.py(17.06 KB)
📄 MultiCall.pyc(15.83 KB)
📄 MultiCall.pyo(15.75 KB)
📄 MultiStatusBar.py(789 B)
📄 MultiStatusBar.pyc(1.51 KB)
📄 MultiStatusBar.pyo(1.51 KB)
📄 NEWS.txt(26.53 KB)
📄 ObjectBrowser.py(4.06 KB)
📄 ObjectBrowser.pyc(6.59 KB)
📄 ObjectBrowser.pyo(6.59 KB)
📄 OutputWindow.py(4.29 KB)
📄 OutputWindow.pyc(4.9 KB)
📄 OutputWindow.pyo(4.9 KB)
📄 ParenMatch.py(6.47 KB)
📄 ParenMatch.pyc(6.84 KB)
📄 ParenMatch.pyo(6.84 KB)
📄 PathBrowser.py(2.58 KB)
📄 PathBrowser.pyc(4.07 KB)
📄 PathBrowser.pyo(4.07 KB)
📄 Percolator.py(2.55 KB)
📄 Percolator.pyc(3.57 KB)
📄 Percolator.pyo(3.38 KB)
📄 PyParse.py(19.05 KB)
📄 PyParse.pyc(9.97 KB)
📄 PyParse.pyo(9.52 KB)
📄 PyShell.py(50.69 KB)
📄 PyShell.pyc(45.59 KB)
📄 PyShell.pyo(45.5 KB)
📄 README.txt(2.56 KB)
📄 RemoteDebugger.py(11.39 KB)
📄 RemoteDebugger.pyc(16.03 KB)
📄 RemoteDebugger.pyo(15.88 KB)
📄 RemoteObjectBrowser.py(942 B)
📄 RemoteObjectBrowser.pyc(2.12 KB)
📄 RemoteObjectBrowser.pyo(2.12 KB)
📄 ReplaceDialog.py(5.01 KB)
📄 ReplaceDialog.pyc(5.84 KB)
📄 ReplaceDialog.pyo(5.84 KB)
📄 ScriptBinding.py(7.6 KB)
📄 ScriptBinding.pyc(7.43 KB)
📄 ScriptBinding.pyo(7.43 KB)
📄 ScrolledList.py(3.9 KB)
📄 ScrolledList.pyc(6.05 KB)
📄 ScrolledList.pyo(6.05 KB)
📄 SearchDialog.py(1.99 KB)
📄 SearchDialog.pyc(2.96 KB)
📄 SearchDialog.pyo(2.96 KB)
📄 SearchDialogBase.py(4.28 KB)
📄 SearchDialogBase.pyc(5.39 KB)
📄 SearchDialogBase.pyo(5.39 KB)
📄 SearchEngine.py(6.57 KB)
📄 SearchEngine.pyc(7.09 KB)
📄 SearchEngine.pyo(7.09 KB)
📄 StackViewer.py(3.77 KB)
📄 StackViewer.pyc(5.82 KB)
📄 StackViewer.pyo(5.82 KB)
📄 TODO.txt(8.28 KB)
📄 ToolTip.py(2.67 KB)
📄 ToolTip.pyc(4.06 KB)
📄 ToolTip.pyo(4.06 KB)
📄 TreeWidget.py(14.88 KB)
📄 TreeWidget.pyc(17.59 KB)
📄 TreeWidget.pyo(17.59 KB)
📄 UndoDelegator.py(10.04 KB)
📄 UndoDelegator.pyc(12.35 KB)
📄 UndoDelegator.pyo(12.35 KB)
📄 WidgetRedirector.py(4.37 KB)
📄 WidgetRedirector.pyc(5.24 KB)
📄 WidgetRedirector.pyo(5.24 KB)
📄 WindowList.py(2.42 KB)
📄 WindowList.pyc(3.57 KB)
📄 WindowList.pyo(3.57 KB)
📄 ZoomHeight.py(1.28 KB)
📄 ZoomHeight.pyc(1.62 KB)
📄 ZoomHeight.pyo(1.62 KB)
📄 __init__.py(37 B)
📄 __init__.pyc(127 B)
📄 __init__.pyo(127 B)
📄 aboutDialog.py(6.67 KB)
📄 aboutDialog.pyc(6.8 KB)
📄 aboutDialog.pyo(6.8 KB)
📄 config-extensions.def(2.63 KB)
📄 config-highlight.def(1.7 KB)
📄 config-keys.def(7.34 KB)
📄 config-main.def(2.45 KB)
📄 configDialog.py(51.98 KB)
📄 configDialog.pyc(43.93 KB)
📄 configDialog.pyo(43.93 KB)
📄 configHandler.py(28.13 KB)
📄 configHandler.pyc(26.72 KB)
📄 configHandler.pyo(26.72 KB)
📄 configHelpSourceEdit.py(6.52 KB)
📄 configHelpSourceEdit.pyc(6.59 KB)
📄 configHelpSourceEdit.pyo(6.59 KB)
📄 configSectionNameDialog.py(3.63 KB)
📄 configSectionNameDialog.pyc(4.22 KB)
📄 configSectionNameDialog.pyo(4.22 KB)
📄 dynOptionMenuWidget.py(1.27 KB)
📄 dynOptionMenuWidget.pyc(1.67 KB)
📄 dynOptionMenuWidget.pyo(1.67 KB)
📄 extend.txt(3.57 KB)
📄 help.txt(10.96 KB)
📄 idle.py(664 B)
📄 idle.pyc(596 B)
📄 idle.pyo(596 B)
📄 idle.pyw(664 B)
📄 idlever.py(23 B)
📄 idlever.pyc(159 B)
📄 idlever.pyo(159 B)
📄 keybindingDialog.py(12.12 KB)
📄 keybindingDialog.pyc(12.13 KB)
📄 keybindingDialog.pyo(12.13 KB)
📄 macosxSupport.py(4.61 KB)
📄 macosxSupport.pyc(4.77 KB)
📄 macosxSupport.pyo(4.77 KB)
📄 rpc.py(19.74 KB)
📄 rpc.pyc(21.42 KB)
📄 rpc.pyo(21.32 KB)
📄 run.py(11.07 KB)
📄 run.pyc(11.93 KB)
📄 run.pyo(11.93 KB)
📄 tabbedpages.py(17.76 KB)
📄 tabbedpages.pyc(17.74 KB)
📄 tabbedpages.pyo(17.74 KB)
📄 textView.py(3.17 KB)
📄 textView.pyc(3.89 KB)
📄 textView.pyo(3.89 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 main():
    from idlelib.Percolator import Percolator
    root = Tk()
    root.wm_protocol("WM_DELETE_WINDOW", root.quit)
    text = Text()
    text.pack()
    text.focus_set()
    p = Percolator(text)
    d = UndoDelegator()
    p.insertfilter(d)
    root.mainloop()

if __name__ == "__main__":
    main()

Hackfut Security File Manager

Editing: UndoDelegator.py

Upload File

Create Folder