Hello there!
I just wanted to ask if there would be someone interested in a framework
library for undo/redo-functionality. In other C++ groups sometimes the
question pops up, how to implement undo-functionality. Since I've written
such thing as part of a programm of mine and since I have it "boostenised"
already, I would like to introduce it briefly. Please feel free to give me
any comments about it...
Basicly there are two classes: boost::undo_list and boost::undo_action, the
latter is an abstract base class for any undo-function you want to
provide...
Instead of describing all the details I'll just give a short example of how
one could use the library...
// ----------------------------------------------------
#include <string>
#include <iostream>
using namespace std;
#include "undo_action.hpp" // class boost::undo_action
#include "undo_list.hpp" // class boost::undo_list
#include "myown_undoactions.hpp" // contains undo-action classes
int main() {
// 1. create the undo list somewhere
boost::undo_list undolist;
// 2. maybe you want to change the number of maximum undo steps
undolist.set_maxundo(100);
string teststring;
teststring = "This is a simple test of the boost undo library";
cout << "Original string: " << teststring << endl;
// Ok, someone want's to remove a part of that string.
// let's start with constructing the undo-action and adding that to
// the undo list. The class StringEraseUndo is a user defined
// undo class derived from undo_action
// 3. create and add an undo action
// NOTE: the constructor can look whatever the user wants it
// to look like (see example at end of posting)
undolist.add( new StringEraseUndo(10, 7,
teststring.substr(10, 7), teststring) );
// NOTE: All pointers added to the list make the objects
// be OWNED by the list, thus the list is responsable
// for cleaning up the memory
// 4. perform the will-be-made-undone action
// That means, let's finally delete that substring
teststring.erase(10, 7);
cout << "After erase: " << teststring << endl;
// 5. and now let's make this undone...
undolist.undo_last();
cout << "After UNDO: " << teststring << endl;
// 6. or re-done, if you like
undolist.redo_last();
cout << "After REDO: " << teststring << endl;
};
// ----------------------------------------------------
Well, it is obvious that the biggest problem in using the undo-library will
be the implementation of the user defined undo/redo-classes.
For the example above the class StringEraseUndo could look like this:
class StringEraseUndo : public undo_action {
public:
// Ctor
StringEraseUndo(std::size_t start, std::size_t size,
const std::string& snipped, std::string& str)
: start_(start), size_(size), snipped_(snipped), str_(str) {};
virtual bool undo();
virtual void redo();
private:
std::size_t start_;
std::size_t size_;
std::string snipped_;
std::string& str_;
};
bool StringEraseUndo::undo() {
str_.insert(start_, snipped_);
return true;
};
void StringEraseUndo::redo() {
str_.erase(start_, size_);
};
However, since the undo-classes can be whatever they want to be, including
non-C++-standard stuff like GUI things, this library can be used in almost
any circumstances. The Framework, that is the undo_list and the undo_action
classes can still be written in plain C++ without having to know anything
about the users environment. This clearly qualifies these classes as a
library.
Sorry for the long text, but with just describing the system shortly it
would have caused too much confusion :-)
The library itself (that is the undo_action.hpp, undo_list.hpp and
undo_list.cpp) are ready so far. Do you think this could be a useful
addition to the boost library?
Thanks for any comments!
Bye - Andreas
_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
