class TQUndoManager: public TQCommand

The Command design pattern is based on the idea, that all editing
in an application is done by creating instances of command objects.
Command objects apply changes to the edited object and then are
stored  on a command stack. Furthermore, each command knows how to
undo its changes to bring the edited object back to its previous
state. As long as the application only uses command objects to
change the state of the edited object, it is possible to undo
a sequence of commands by traversing the command stack downwards and
calling the "undo" method of each command in turn. It is also
possible to redo a sequence of commands by traversing the command
stack upwards and calling the "redo" method of each command.


Examples:

1. Create a new command

TQCommand *com = new TQCommand("TH1", hpx, "SetFillColor(Color_t)"
"SetFillColor(Color_t)");

1st parameter - the name of class
2nd parameter - object
3rd parameter - the name of do/redo method
4th parameter - the name of undo method

Since redo,undo methods are the same, undo name can be omitted, e.g.

TQCommand *com = new TQCommand("TH1", hpx, "SetFillColor(Color_t)");

For objects derived from TObject class name can be omitted, e.g.

TQCommand *com = new TQCommand(hpx, "SetFillColor(Color_t)");

2. Setting undo, redo parameters.

Color_t old_color = hpx->GetFillColor();
Color_t new_color = 4;  // blue color

com->SetRedoArgs(1, new_color);
com->SetUndoArgs(1, old_color);

1st argument - the number of undo, redo parameters
the other arguments - undo, redo values

Since the number of undo,redo parameters is the same one can use

com->SetArgs(1, new_color, old_color);

3. Undo, redo method execution

com->Redo(); // execute redo method
com->Undo(); // execute undo method

4. Merged commands

It possible to group several commands together so an end user
can undo and redo them with one command.

TQCommand *update = new TQCommand(gPad, "Modified()");
com->Add(update);

5. Macro commands

"Merging" allows to create macro commands, e.g.

TQCommand *macro = new TQCommand("my macro");
macro->Add(com1);
macro->Add(com2);


During Redo operation commands composing macro command are executed
sequentially in direct  order (first in first out). During Undo,
they are executed in reverse order (last in first out).

6. Undo manager.

TQUndoManager is recorder of undo and redo operations. This is
command history list which can be traversed backwards and upwards
performing undo and redo operations.
To register command TQUndoManager::Add(TObject*) method is used.

TQUndoManager *history = new TQUndoManager();
history->Add(com);

TQUndoManager::Add automatically invokes execution of command's
Redo method.

Use TQUndoManager::Undo to undo commands in  history list.
 Redo is Undo for undo action. Use TQUndoManager::Redo method for that