Next: Maintaining Undo, Previous: The Kill Ring, Up: Text [Contents][Index]
Most buffers have an undo list, which records all changes made
to the buffer’s text so that they can be undone. (The buffers that
don’t have one are usually special-purpose buffers for which SXEmacs
assumes that undoing is not useful.) All the primitives that modify the
text in the buffer automatically add elements to the front of the undo
list, which is in the variable buffer-undo-list
.
This variable’s value is the undo list of the current buffer.
A value of t
disables the recording of undo information.
Here are the kinds of elements an undo list can have:
integer
This kind of element records a previous value of point. Ordinary cursor motion does not get any sort of undo record, but deletion commands use these entries to record where point was before the command.
(start . end)
This kind of element indicates how to delete text that was inserted. Upon insertion, the text occupied the range start–end in the buffer.
(text . position)
This kind of element indicates how to reinsert text that was deleted.
The deleted text itself is the string text. The place to
reinsert it is (abs position)
.
(t high . low)
This kind of element indicates that an unmodified buffer became
modified. The elements high and low are two integers, each
recording 16 bits of the visited file’s modification time as of when it
was previously visited or saved. primitive-undo
uses those
values to determine whether to mark the buffer as unmodified once again;
it does so only if the file’s modification time matches those numbers.
(nil property value start . end)
This kind of element records a change in a text property. Here’s how you might undo the change:
(put-text-property start end property value)
position
This element indicates where point was at an earlier time. Undoing this element sets point to position. Deletion normally creates an element of this kind as well as a reinsertion element.
nil
This element is a boundary. The elements between two boundaries are called a change group; normally, each change group corresponds to one keyboard command, and undo commands normally undo an entire group as a unit.
This function places a boundary element in the undo list. The undo
command stops at such a boundary, and successive undo commands undo
to earlier and earlier boundaries. This function returns nil
.
The editor command loop automatically creates an undo boundary before each key sequence is executed. Thus, each undo normally undoes the effects of one command. Self-inserting input characters are an exception. The command loop makes a boundary for the first such character; the next 19 consecutive self-inserting input characters do not make boundaries, and then the 20th does, and so on as long as self-inserting characters continue.
All buffer modifications add a boundary whenever the previous undoable change was made in some other buffer. This way, a command that modifies several buffers makes a boundary in each buffer it changes.
Calling this function explicitly is useful for splitting the effects of
a command into more than one unit. For example, query-replace
calls undo-boundary
after each replacement, so that the user can
undo individual replacements one by one.
This is the basic function for undoing elements of an undo list. It undoes the first count elements of list, returning the rest of list. You could write this function in Lisp, but it is convenient to have it in C.
primitive-undo
adds elements to the buffer’s undo list when it
changes the buffer. Undo commands avoid confusion by saving the undo
list value at the beginning of a sequence of undo operations. Then the
undo operations use and update the saved value. The new elements added
by undoing are not part of this saved value, so they don’t interfere with
continuing to undo.
Next: Maintaining Undo, Previous: The Kill Ring, Up: Text [Contents][Index]