[OpenSPARC-T2-DV] / tools / src / nas,5.n2.os.2 / lib / python / lib / python2.4 / idlelib / UndoDelegator.py

import sys
import string
from Tkinter import *
from 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 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()
Commit	Line	Data
86530b38 AT	1	import sys
	2	import string
	3	from Tkinter import *
	4	from Delegator import Delegator
	5
	6	#$ event <<redo>>
	7	#$ win <Control-y>
	8	#$ unix <Alt-z>
	9
	10	#$ event <<undo>>
	11	#$ win <Control-z>
	12	#$ unix <Control-z>
	13
	14	#$ event <<dump-undo-state>>
	15	#$ win <Control-backslash>
	16	#$ unix <Control-backslash>
	17
	18
	19	class UndoDelegator(Delegator):
	20
	21	max_undo = 1000
	22
	23	def __init__(self):
	24	Delegator.__init__(self)
	25	self.reset_undo()
	26
	27	def setdelegate(self, delegate):
	28	if self.delegate is not None:
	29	self.unbind("<<undo>>")
	30	self.unbind("<<redo>>")
	31	self.unbind("<<dump-undo-state>>")
	32	Delegator.setdelegate(self, delegate)
	33	if delegate is not None:
	34	self.bind("<<undo>>", self.undo_event)
	35	self.bind("<<redo>>", self.redo_event)
	36	self.bind("<<dump-undo-state>>", self.dump_event)
	37
	38	def dump_event(self, event):
	39	from pprint import pprint
	40	pprint(self.undolist[:self.pointer])
	41	print "pointer:", self.pointer,
	42	print "saved:", self.saved,
	43	print "can_merge:", self.can_merge,
	44	print "get_saved():", self.get_saved()
	45	pprint(self.undolist[self.pointer:])
	46	return "break"
	47
	48	def reset_undo(self):
	49	self.was_saved = -1
	50	self.pointer = 0
	51	self.undolist = []
	52	self.undoblock = 0 # or a CommandSequence instance
	53	self.set_saved(1)
	54
	55	def set_saved(self, flag):
	56	if flag:
	57	self.saved = self.pointer
	58	else:
	59	self.saved = -1
	60	self.can_merge = False
	61	self.check_saved()
	62
	63	def get_saved(self):
	64	return self.saved == self.pointer
65
66	saved_change_hook = None
67
68	def set_saved_change_hook(self, hook):
69	self.saved_change_hook = hook
70
71	was_saved = -1
72
73	def check_saved(self):
74	is_saved = self.get_saved()
75	if is_saved != self.was_saved:
76	self.was_saved = is_saved
77	if self.saved_change_hook:
78	self.saved_change_hook()
79
80	def insert(self, index, chars, tags=None):
81	self.addcmd(InsertCommand(index, chars, tags))
82
83	def delete(self, index1, index2=None):
84	self.addcmd(DeleteCommand(index1, index2))
85
86	# Clients should call undo_block_start() and undo_block_stop()
87	# around a sequence of editing cmds to be treated as a unit by
88	# undo & redo. Nested matching calls are OK, and the inner calls
89	# then act like nops. OK too if no editing cmds, or only one
90	# editing cmd, is issued in between: if no cmds, the whole
91	# sequence has no effect; and if only one cmd, that cmd is entered
92	# directly into the undo list, as if undo_block_xxx hadn't been
93	# called. The intent of all that is to make this scheme easy
94	# to use: all the client has to worry about is making sure each
95	# _start() call is matched by a _stop() call.
96
97	def undo_block_start(self):
98	if self.undoblock == 0:
99	self.undoblock = CommandSequence()
100	self.undoblock.bump_depth()
101
102	def undo_block_stop(self):
103	if self.undoblock.bump_depth(-1) == 0:
104	cmd = self.undoblock
105	self.undoblock = 0
106	if len(cmd) > 0:
107	if len(cmd) == 1:
108	# no need to wrap a single cmd
109	cmd = cmd.getcmd(0)
110	# this blk of cmds, or single cmd, has already
111	# been done, so don't execute it again
112	self.addcmd(cmd, 0)
113
114	def addcmd(self, cmd, execute=True):
115	if execute:
116	cmd.do(self.delegate)
117	if self.undoblock != 0:
118	self.undoblock.append(cmd)
119	return
120	if self.can_merge and self.pointer > 0:
121	lastcmd = self.undolist[self.pointer-1]
122	if lastcmd.merge(cmd):
123	return
124	self.undolist[self.pointer:] = [cmd]
125	if self.saved > self.pointer:
126	self.saved = -1
127	self.pointer = self.pointer + 1
128	if len(self.undolist) > self.max_undo:
129	##print "truncating undo list"
130	del self.undolist[0]
131	self.pointer = self.pointer - 1
132	if self.saved >= 0:
133	self.saved = self.saved - 1
134	self.can_merge = True
135	self.check_saved()
136
137	def undo_event(self, event):
138	if self.pointer == 0:
139	self.bell()
140	return "break"
141	cmd = self.undolist[self.pointer - 1]
142	cmd.undo(self.delegate)
143	self.pointer = self.pointer - 1
144	self.can_merge = False
145	self.check_saved()
146	return "break"
147
148	def redo_event(self, event):
149	if self.pointer >= len(self.undolist):
150	self.bell()
151	return "break"
152	cmd = self.undolist[self.pointer]
153	cmd.redo(self.delegate)
154	self.pointer = self.pointer + 1
155	self.can_merge = False
156	self.check_saved()
157	return "break"
158
159
160	class Command:
161
162	# Base class for Undoable commands
163
164	tags = None
165
166	def __init__(self, index1, index2, chars, tags=None):
167	self.marks_before = {}
168	self.marks_after = {}
169	self.index1 = index1
170	self.index2 = index2
171	self.chars = chars
172	if tags:
173	self.tags = tags
174
175	def __repr__(self):
176	s = self.__class__.__name__
177	t = (self.index1, self.index2, self.chars, self.tags)
178	if self.tags is None:
179	t = t[:-1]
180	return s + repr(t)
181
182	def do(self, text):
183	pass
184
185	def redo(self, text):
186	pass
187
188	def undo(self, text):
189	pass
190
191	def merge(self, cmd):
192	return 0
193
194	def save_marks(self, text):
195	marks = {}
196	for name in text.mark_names():
197	if name != "insert" and name != "current":
198	marks[name] = text.index(name)
199	return marks
200
201	def set_marks(self, text, marks):
202	for name, index in marks.items():
203	text.mark_set(name, index)
204
205
206	class InsertCommand(Command):
207
208	# Undoable insert command
209
210	def __init__(self, index1, chars, tags=None):
211	Command.__init__(self, index1, None, chars, tags)
212
213	def do(self, text):
214	self.marks_before = self.save_marks(text)
215	self.index1 = text.index(self.index1)
216	if text.compare(self.index1, ">", "end-1c"):
217	# Insert before the final newline
218	self.index1 = text.index("end-1c")
219	text.insert(self.index1, self.chars, self.tags)
220	self.index2 = text.index("%s+%dc" % (self.index1, len(self.chars)))
221	self.marks_after = self.save_marks(text)
222	##sys.__stderr__.write("do: %s\n" % self)
223
224	def redo(self, text):
225	text.mark_set('insert', self.index1)
226	text.insert(self.index1, self.chars, self.tags)
227	self.set_marks(text, self.marks_after)
228	text.see('insert')
229	##sys.__stderr__.write("redo: %s\n" % self)
230
231	def undo(self, text):
232	text.mark_set('insert', self.index1)
233	text.delete(self.index1, self.index2)
234	self.set_marks(text, self.marks_before)
235	text.see('insert')
236	##sys.__stderr__.write("undo: %s\n" % self)
237
238	def merge(self, cmd):
239	if self.__class__ is not cmd.__class__:
240	return False
241	if self.index2 != cmd.index1:
242	return False
243	if self.tags != cmd.tags:
244	return False
245	if len(cmd.chars) != 1:
246	return False
247	if self.chars and \
248	self.classify(self.chars[-1]) != self.classify(cmd.chars):
249	return False
250	self.index2 = cmd.index2
251	self.chars = self.chars + cmd.chars
252	return True
253
254	alphanumeric = string.ascii_letters + string.digits + "_"
255
256	def classify(self, c):
257	if c in self.alphanumeric:
258	return "alphanumeric"
259	if c == "\n":
260	return "newline"
261	return "punctuation"
262
263
264	class DeleteCommand(Command):
265
266	# Undoable delete command
267
268	def __init__(self, index1, index2=None):
269	Command.__init__(self, index1, index2, None, None)
270
271	def do(self, text):
272	self.marks_before = self.save_marks(text)
273	self.index1 = text.index(self.index1)
274	if self.index2:
275	self.index2 = text.index(self.index2)
276	else:
277	self.index2 = text.index(self.index1 + " +1c")
278	if text.compare(self.index2, ">", "end-1c"):
279	# Don't delete the final newline
280	self.index2 = text.index("end-1c")
281	self.chars = text.get(self.index1, self.index2)
282	text.delete(self.index1, self.index2)
283	self.marks_after = self.save_marks(text)
284	##sys.__stderr__.write("do: %s\n" % self)
285
286	def redo(self, text):
287	text.mark_set('insert', self.index1)
288	text.delete(self.index1, self.index2)
289	self.set_marks(text, self.marks_after)
290	text.see('insert')
291	##sys.__stderr__.write("redo: %s\n" % self)
292
293	def undo(self, text):
294	text.mark_set('insert', self.index1)
295	text.insert(self.index1, self.chars)
296	self.set_marks(text, self.marks_before)
297	text.see('insert')
298	##sys.__stderr__.write("undo: %s\n" % self)
299
300	class CommandSequence(Command):
301
302	# Wrapper for a sequence of undoable cmds to be undone/redone
303	# as a unit
304
305	def __init__(self):
306	self.cmds = []
307	self.depth = 0
308
309	def __repr__(self):
310	s = self.__class__.__name__
311	strs = []
312	for cmd in self.cmds:
313	strs.append(" %r" % (cmd,))
314	return s + "(\n" + ",\n".join(strs) + "\n)"
315
316	def __len__(self):
317	return len(self.cmds)
318
319	def append(self, cmd):
320	self.cmds.append(cmd)
321
322	def getcmd(self, i):
323	return self.cmds[i]
324
325	def redo(self, text):
326	for cmd in self.cmds:
327	cmd.redo(text)
328
329	def undo(self, text):
330	cmds = self.cmds[:]
331	cmds.reverse()
332	for cmd in cmds:
333	cmd.undo(text)
334
335	def bump_depth(self, incr=1):
336	self.depth = self.depth + incr
337	return self.depth
338
339	def main():
340	from Percolator import Percolator
341	root = Tk()
342	root.wm_protocol("WM_DELETE_WINDOW", root.quit)
343	text = Text()
344	text.pack()
345	text.focus_set()
346	p = Percolator(text)
347	d = UndoDelegator()
348	p.insertfilter(d)
349	root.mainloop()
350
351	if __name__ == "__main__":
352	main()