Undo is an interaction technique which is implemented in many computer programs. It erases the last change done to the document reverting it to an older state. In some more advanced programs such as graphic processingundo will negate the last command done to the file being edited.
With the possibility of undo users can explore and work with the programs without be afraid of making mistakes because they can easily be undone.
So the expectations for undo are to be easy to understand, to have a predictable functionality and to include all undoable commands. For example saving file is not undoable, but is queued in the list to show, that Undo shortcut word command was executed. Another action, which Undo shortcut word not undoable and not stored, too, is scrolling or selection. The opposite of undo is redo. The redo command reverses the undo or advances the buffer to a more current state.
In all Macintosh applications, the Undo command is activated by pressing Command -Z.
The ability to undo an operation on a computer was independently invented multiple times, as a response to how people used computers. The File Retrieval and Editing Systemdeveloped starting in at Brown Universityis reported to be the first computer-based system to have had an "undo" feature.
Miller and John C.
Thomas of IBMnoted that "It would be quite useful to permit users to 'take back' at least the immediately preceding command by issuing some special 'undo' command. There, he and Bill Atkinson advocated for the presence of the undo command as a standard fixture on the Apple Lisa. Atkinson was able to convince the individual developers of the Lisa's application software to include a single level of undo and redo, but was unsuccessful in lobbying "Undo shortcut word" multiple levels.
Multi-level undo commands were introduced in the s, allowing the users to take back a series of actions, not just the most recent one.
NewWord, another word-processing program released by NewStar inhad an unerase command. Undo models can be categorizes as linear or non-linear undo models. Linear undo is implemented with is a history list in which all executed commands are stored. When a new command is called, it is added to the list. Thereof only the last executed command can be undone and after that removed from the history list.
Undo can repeated as long as the history list is empty. The restricted linear model is an augmentation of the linear undo model. It satisfies the above described stable execution property for linear undo, because this model does not keep the property if a command is done while the history list includes other commands. The restricted linear model clears the history list before a new command is added.
But restrictions are available, too. For Undo shortcut word, the size of the history list can be restricted or when a defined size is reached, the first executed command is deleted from the list. The main difference between linear undo and non-linear undo is the possibility of the user Undo shortcut word undo the executed commands in an arbitrary order.
He has the chance to undo not the most recently command but rather choose a command from the list. The script model handles user actions as editing a script of commands. A disadvantage of this model is that the user has to know the connection between undone command and the current state to avoid side effects. One of this can be for example duplication. The special feature of this model is that it has the option of skipping a command.
This means that redoing a command can be skipped. The command which is skipped is marked as skipped but not deleted. When new commands are executed, the history list is retained, so the order of the executed commands can be reproducible with that.
This non-linear undo model has besides undo and redo the possibility to rotate. It has the same data structure as the above mentioned models with a history list and a separated redo list which includes the redo operations. The rotate operation sets the last command of Undo shortcut word redo list in front of it. On one hand this means that the next command to be redone can be selected by placing it in front.
There are three main issues.
The first is that undone commands can be outside of the originally context. Through this there can be dead references which have to be handled. The second issue that modified commands can be undone and so it has to be solved Undo shortcut word state after undo will be presented. The third issue is discarding command problems. Selective undo has no pointer in the lists, so this means that no command should be discarded of the stack.
Direct Selective Undo is an extension of restricted linear undo with a history tree. The operation creates a copy of the selected command, executes this and add it to the history list.
There two non-linear operations selective undo and selective redo are defined, so it is more symmetric. When multiple users can edit the same document simultaneously, a multi-user undo is needed.
Global multi-user undo reverts the latest action made to the document, regardless of who performed the edit. Local multi-user undo only reverts actions done by the local user, which requires a non-linear undo implementation.
Where undo can be used to backtrack through multiple edits, the redo command goes Undo shortcut word through the action history. Making a new edit usually clears the redo list. If a branching redo model is used, the new edit branches the action history. The number of previous actions that can be undone varies by program, version, and hardware or software capabilities.
As another example, earlier [ when? Simplistic, single-edit undo features sometimes do away with "redo" by treating the undo command itself as an action that can be undone. This is known as the flip undo model, because the user can flip between two program states using the undo command.
Undo can be implemented through different patterns. The most common patterns are Command pattern and Memento pattern. The Command pattern is a software design pattern which encapsulate information from the operation into command Undo shortcut word. This means that every action is stored in an object. The abstract command class implements an abstract execute operation, so every command object has an execute operation.
For undo there also have to be unexecuted operation, which undoes the effect of the executed command, which are stored in a history list. Undo and redo are implemented so that the list is run through forwards and backwards when the execute or unexecute command is called. For single undo only the executed command is stored.
In contrast to the multi level undo where not only the history list with the commands is Undo shortcut word but also the number of undo levels can be determined of the maximum "Undo shortcut word" of the list.
With Memento pattern the internal state of an object is stored. The object in which the state is saved, is called memento and is organized through the memento originator. This returns a memento, initialized with information of the current state, when undo is executed, so that the state can be Undo shortcut word. The memento is only visible for the originator.
In memento pattern the undo mechanism is called caretaker. It is responsible for the safekeeping of the mementos but never change the contents of these. For undo the caretaker requests a memento of the originator and then applying the undo. The most part of undo mechanism can implemented without dependency to specific "Undo shortcut word" or command classes. Every command class has a do method which is called when a command is executed. The undo-method implements the reverse operation of the do-method.
To implement the reverse, there are several different strategies. From Wikipedia, the free encyclopedia. For other uses, see Undo disambiguation. For information on how to "undo" an edit in Wikipedia, see Wikipedia: It is not to be confused with Do over. University of California, San Diego. The Evolution of Hypertext.