1 import string

     2 from Tkinter import *

     3 from Delegator import Delegator

     4 

     5 #$ event <<redo>>

     6 #$ win <Control-y>

     7 #$ unix <Alt-z>

     8 

     9 #$ event <<undo>>

    10 #$ win <Control-z>

    11 #$ unix <Control-z>

    12 

    13 #$ event <<dump-undo-state>>

    14 #$ win <Control-backslash>

    15 #$ unix <Control-backslash>

    16 

    17 

    18 class UndoDelegator(Delegator):

    19 

    20     max_undo = 1000

    21 

    22     def __init__(self):

    23         Delegator.__init__(self)

    24         self.reset_undo()

    25 

    26     def setdelegate(self, delegate):

    27         if self.delegate is not None:

    28             self.unbind("<<undo>>")

    29             self.unbind("<<redo>>")

    30             self.unbind("<<dump-undo-state>>")

    31         Delegator.setdelegate(self, delegate)

    32         if delegate is not None:

    33             self.bind("<<undo>>", self.undo_event)

    34             self.bind("<<redo>>", self.redo_event)

    35             self.bind("<<dump-undo-state>>", self.dump_event)

    36 

    37     def dump_event(self, event):

    38         from pprint import pprint

    39         pprint(self.undolist[:self.pointer])

    40         print "pointer:", self.pointer,

    41         print "saved:", self.saved,

    42         print "can_merge:", self.can_merge,

    43         print "get_saved():", self.get_saved()

    44         pprint(self.undolist[self.pointer:])

    45         return "break"

    46 

    47     def reset_undo(self):

    48         self.was_saved = -1

    49         self.pointer = 0

    50         self.undolist = []

    51         self.undoblock = 0  # or a CommandSequence instance

    52         self.set_saved(1)

    53 

    54     def set_saved(self, flag):

    55         if flag:

    56             self.saved = self.pointer

    57         else:

    58             self.saved = -1

    59         self.can_merge = False

    60         self.check_saved()

    61 

    62     def get_saved(self):

    63         return self.saved == self.pointer

    64 

    65     saved_change_hook = None

    66 

    67     def set_saved_change_hook(self, hook):

    68         self.saved_change_hook = hook

    69 

    70     was_saved = -1

    71 

    72     def check_saved(self):

    73         is_saved = self.get_saved()

    74         if is_saved != self.was_saved:

    75             self.was_saved = is_saved

    76             if self.saved_change_hook:

    77                 self.saved_change_hook()

    78 

    79     def insert(self, index, chars, tags=None):

    80         self.addcmd(InsertCommand(index, chars, tags))

    81 

    82     def delete(self, index1, index2=None):

    83         self.addcmd(DeleteCommand(index1, index2))

    84 

    85     # Clients should call undo_block_start() and undo_block_stop()

    86     # around a sequence of editing cmds to be treated as a unit by

    87     # undo & redo.  Nested matching calls are OK, and the inner calls

    88     # then act like nops.  OK too if no editing cmds, or only one

    89     # editing cmd, is issued in between:  if no cmds, the whole

    90     # sequence has no effect; and if only one cmd, that cmd is entered

    91     # directly into the undo list, as if undo_block_xxx hadn't been

    92     # called.  The intent of all that is to make this scheme easy

    93     # to use:  all the client has to worry about is making sure each

    94     # _start() call is matched by a _stop() call.

    95 

    96     def undo_block_start(self):

    97         if self.undoblock == 0:

    98             self.undoblock = CommandSequence()

    99         self.undoblock.bump_depth()

   100 

   101     def undo_block_stop(self):

   102         if self.undoblock.bump_depth(-1) == 0:

   103             cmd = self.undoblock

   104             self.undoblock = 0

   105             if len(cmd) > 0:

   106                 if len(cmd) == 1:

   107                     # no need to wrap a single cmd

   108                     cmd = cmd.getcmd(0)

   109                 # this blk of cmds, or single cmd, has already

   110                 # been done, so don't execute it again

   111                 self.addcmd(cmd, 0)

   112 

   113     def addcmd(self, cmd, execute=True):

   114         if execute:

   115             cmd.do(self.delegate)

   116         if self.undoblock != 0:

   117             self.undoblock.append(cmd)

   118             return

   119         if self.can_merge and self.pointer > 0:

   120             lastcmd = self.undolist[self.pointer-1]

   121             if lastcmd.merge(cmd):

   122                 return

   123         self.undolist[self.pointer:] = [cmd]

   124         if self.saved > self.pointer:

   125             self.saved = -1

   126         self.pointer = self.pointer + 1

   127         if len(self.undolist) > self.max_undo:

   128             ##print "truncating undo list"

   129             del self.undolist[0]

   130             self.pointer = self.pointer - 1

   131             if self.saved >= 0:

   132                 self.saved = self.saved - 1

   133         self.can_merge = True

   134         self.check_saved()

   135 

   136     def undo_event(self, event):

   137         if self.pointer == 0:

   138             self.bell()

   139             return "break"

   140         cmd = self.undolist[self.pointer - 1]

   141         cmd.undo(self.delegate)

   142         self.pointer = self.pointer - 1

   143         self.can_merge = False

   144         self.check_saved()

   145         return "break"

   146 

   147     def redo_event(self, event):

   148         if self.pointer >= len(self.undolist):

   149             self.bell()

   150             return "break"

   151         cmd = self.undolist[self.pointer]

   152         cmd.redo(self.delegate)

   153         self.pointer = self.pointer + 1

   154         self.can_merge = False

   155         self.check_saved()

   156         return "break"

   157 

   158 

   159 class Command:

   160 

   161     # Base class for Undoable commands

   162 

   163     tags = None

   164 

   165     def __init__(self, index1, index2, chars, tags=None):

   166         self.marks_before = {}

   167         self.marks_after = {}

   168         self.index1 = index1

   169         self.index2 = index2

   170         self.chars = chars

   171         if tags:

   172             self.tags = tags

   173 

   174     def __repr__(self):

   175         s = self.__class__.__name__

   176         t = (self.index1, self.index2, self.chars, self.tags)

   177         if self.tags is None:

   178             t = t[:-1]

   179         return s + repr(t)

   180 

   181     def do(self, text):

   182         pass

   183 

   184     def redo(self, text):

   185         pass

   186 

   187     def undo(self, text):

   188         pass

   189 

   190     def merge(self, cmd):

   191         return 0

   192 

   193     def save_marks(self, text):

   194         marks = {}

   195         for name in text.mark_names():

   196             if name != "insert" and name != "current":

   197                 marks[name] = text.index(name)

   198         return marks

   199 

   200     def set_marks(self, text, marks):

   201         for name, index in marks.items():

   202             text.mark_set(name, index)

   203 

   204 

   205 class InsertCommand(Command):

   206 

   207     # Undoable insert command

   208 

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

   210         Command.__init__(self, index1, None, chars, tags)

   211 

   212     def do(self, text):

   213         self.marks_before = self.save_marks(text)

   214         self.index1 = text.index(self.index1)

   215         if text.compare(self.index1, ">", "end-1c"):

   216             # Insert before the final newline

   217             self.index1 = text.index("end-1c")

   218         text.insert(self.index1, self.chars, self.tags)

   219         self.index2 = text.index("%s+%dc" % (self.index1, len(self.chars)))

   220         self.marks_after = self.save_marks(text)

   221         ##sys.__stderr__.write("do: %s\n" % self)

   222 

   223     def redo(self, text):

   224         text.mark_set('insert', self.index1)

   225         text.insert(self.index1, self.chars, self.tags)

   226         self.set_marks(text, self.marks_after)

   227         text.see('insert')

   228         ##sys.__stderr__.write("redo: %s\n" % self)

   229 

   230     def undo(self, text):

   231         text.mark_set('insert', self.index1)

   232         text.delete(self.index1, self.index2)

   233         self.set_marks(text, self.marks_before)

   234         text.see('insert')

   235         ##sys.__stderr__.write("undo: %s\n" % self)

   236 

   237     def merge(self, cmd):

   238         if self.__class__ is not cmd.__class__:

   239             return False

   240         if self.index2 != cmd.index1:

   241             return False

   242         if self.tags != cmd.tags:

   243             return False

   244         if len(cmd.chars) != 1:

   245             return False

   246         if self.chars and \

   247            self.classify(self.chars[-1]) != self.classify(cmd.chars):

   248             return False

   249         self.index2 = cmd.index2

   250         self.chars = self.chars + cmd.chars

   251         return True

   252 

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

   254 

   255     def classify(self, c):

   256         if c in self.alphanumeric:

   257             return "alphanumeric"

   258         if c == "\n":

   259             return "newline"

   260         return "punctuation"

   261 

   262 

   263 class DeleteCommand(Command):

   264 

   265     # Undoable delete command

   266 

   267     def __init__(self, index1, index2=None):

   268         Command.__init__(self, index1, index2, None, None)

   269 

   270     def do(self, text):

   271         self.marks_before = self.save_marks(text)

   272         self.index1 = text.index(self.index1)

   273         if self.index2:

   274             self.index2 = text.index(self.index2)

   275         else:

   276             self.index2 = text.index(self.index1 + " +1c")

   277         if text.compare(self.index2, ">", "end-1c"):

   278             # Don't delete the final newline

   279             self.index2 = text.index("end-1c")

   280         self.chars = text.get(self.index1, self.index2)

   281         text.delete(self.index1, self.index2)

   282         self.marks_after = self.save_marks(text)

   283         ##sys.__stderr__.write("do: %s\n" % self)

   284 

   285     def redo(self, text):

   286         text.mark_set('insert', self.index1)

   287         text.delete(self.index1, self.index2)

   288         self.set_marks(text, self.marks_after)

   289         text.see('insert')

   290         ##sys.__stderr__.write("redo: %s\n" % self)

   291 

   292     def undo(self, text):

   293         text.mark_set('insert', self.index1)

   294         text.insert(self.index1, self.chars)

   295         self.set_marks(text, self.marks_before)

   296         text.see('insert')

   297         ##sys.__stderr__.write("undo: %s\n" % self)

   298 

   299 class CommandSequence(Command):

   300 

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

   302     # as a unit

   303 

   304     def __init__(self):

   305         self.cmds = []

   306         self.depth = 0

   307 

   308     def __repr__(self):

   309         s = self.__class__.__name__

   310         strs = []

   311         for cmd in self.cmds:

   312             strs.append("    %r" % (cmd,))

   313         return s + "(\n" + ",\n".join(strs) + "\n)"

   314 

   315     def __len__(self):

   316         return len(self.cmds)

   317 

   318     def append(self, cmd):

   319         self.cmds.append(cmd)

   320 

   321     def getcmd(self, i):

   322         return self.cmds[i]

   323 

   324     def redo(self, text):

   325         for cmd in self.cmds:

   326             cmd.redo(text)

   327 

   328     def undo(self, text):

   329         cmds = self.cmds[:]

   330         cmds.reverse()

   331         for cmd in cmds:

   332             cmd.undo(text)

   333 

   334     def bump_depth(self, incr=1):

   335         self.depth = self.depth + incr

   336         return self.depth

   337 

   338 def main():

   339     from Percolator import Percolator

   340     root = Tk()

   341     root.wm_protocol("WM_DELETE_WINDOW", root.quit)

   342     text = Text()

   343     text.pack()

   344     text.focus_set()

   345     p = Percolator(text)

   346     d = UndoDelegator()

   347     p.insertfilter(d)

   348     root.mainloop()

   349 

   350 if __name__ == "__main__":

   351     main()