Just one thought : couldn't much of this be achieved without having to
create your own undo classes by boost::functions and the boost::bind
library?
for example, to implement just the undo (untested code, just to give an
idea, I'm not suggesting that this wouldn't be better wrapped in an
undo_list class):
-
void string_erase_undo(std::string& dest, int pos, std::string to_insert)
{
dest.insert(pos, to_insert);
}
std::vector< boost::function<void()> > undolist;
std::string teststring = "This is a simple test of the boost undo library";
undolist.push_back(boost::bind(string_erase_undo, teststring, 10,
std::string(teststring, 10, 7));
teststring.erase(10, 7);
// to undo:
undolist.back()()
-
> 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
>
>
_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
