X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FUndo.h;h=59f3ca44fc93a58975ee459ffc9440e5889a5ac1;hb=d1dddde6d800834eb6b8c7626da4d251e7c74f08;hp=a895e8e39cafdbe1fe740cbad02938852093d7c8;hpb=2aeb9dead02e65598ed0b70133e647956a3add5e;p=lyx.git diff --git a/src/Undo.h b/src/Undo.h index a895e8e39c..59f3ca44fc 100644 --- a/src/Undo.h +++ b/src/Undo.h @@ -5,10 +5,10 @@ * Licence details can be found in the file COPYING. * * \author Asger Alstrup - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author John Levon - * \author André Pönitz - * \author Jürgen Vigna + * \author André Pönitz + * \author Jürgen Vigna * \author Abdelrazak Younes * * Full author contact details are available in file CREDITS. @@ -23,7 +23,8 @@ namespace lyx { class Buffer; class BufferParams; -class DocIterator; +class CursorData; +class Inset; class MathData; class ParagraphList; @@ -46,17 +47,23 @@ enum UndoKind { class Undo { + /// noncopyable + Undo(Undo const &); + void operator=(Undo const &); public: Undo(Buffer &); ~Undo(); + /// Clear out all undo/redo contents. + void clear(); + /// this will undo the last action - returns false if no undo possible - bool textUndo(DocIterator &); + bool textUndo(CursorData &); /// this will redo the last undo - returns false if no redo possible - bool textRedo(DocIterator &); + bool textRedo(CursorData &); /// End a sequence of INSERT_UNDO or DELETE_UNDO type of undo /// operations (grouping of consecutive characters insertion/deletion). @@ -67,15 +74,28 @@ public: /// bool hasRedoStack() const; - /// open a new group of undo operations. Groups can be nested. + /// Mark all the elements of the undo and redo stacks as dirty + void markDirty(); + + /// open a new group of undo operations. /** * Groups can be nested. Such a nested group e.g. { {} {} } is undone in * a single step. This means you can add a group whenever you are not sure. */ void beginUndoGroup(); - + /// open a new group as above and specify a cursor to set as cur_before + /// of the group's undo elements. + /** + * This cursor takes precedence over what is passed to recordUndo. + * In the case of nested groups, only the first cur_before is + * taken into account. The cursor is reset at the end of the + * top-level group. + */ + void beginUndoGroup(CursorData const & cur_before); /// end the current undo group. void endUndoGroup(); + /// end the current undo group and set UndoElement::cur_after if necessary. + void endUndoGroup(CursorData const & cur_after); /// The general case: record undo information for an arbitrary range. /** @@ -84,25 +104,22 @@ public: * give an inclusive range. This is called before you make the * changes to the paragraph, and it will record the original * information of the paragraphs in the undo stack. + * Kind of undo is always ATOMIC_UNDO. */ - void recordUndo(DocIterator const & cur, UndoKind kind, - pit_type from, pit_type to); - - /// Convenience: record undo information for the range between - /// 'from' and cursor. - void recordUndo(DocIterator const & cur, UndoKind kind, pit_type from); + void recordUndo(CursorData const & cur, pit_type from, pit_type to); /// Convenience: record undo information for the single /// paragraph or cell containing the cursor. - void recordUndo(DocIterator const & cur, UndoKind kind = ATOMIC_UNDO); + void recordUndo(CursorData const & cur, UndoKind kind = ATOMIC_UNDO); - /// Convenience: record undo information for the inset - /// containing the cursor. - void recordUndoInset(DocIterator const & cur, - UndoKind kind = ATOMIC_UNDO); + /// prepare undo for the inset containing the cursor + void recordUndoInset(CursorData const & cur, Inset const * inset); + + /// Convenience: record undo for buffer parameters + void recordUndoBufferParams(CursorData const & cur); /// Convenience: prepare undo for the whole buffer - void recordUndoFullDocument(DocIterator const & cur); + void recordUndoFullBuffer(CursorData const & cur); private: struct Private; @@ -110,6 +127,34 @@ private: }; +/** Helper class to simplify the use of undo groups across several buffers. + * + * The undo group is created when the object is instanciated; it is + * then ended as the object goes out of scope or the buffer is reset + * (see below) + */ +class UndoGroupHelper { +public: + UndoGroupHelper(Buffer * buf) : buffer_(0) + { + resetBuffer(buf); + } + + ~UndoGroupHelper() + { + resetBuffer(0); + } + + /** Close the current undo group if necessary and create a new one + * for buffer \c buf. + */ + void resetBuffer(Buffer * buf); + +private: + Buffer * buffer_; +}; + + } // namespace lyx