X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FUndo.h;h=59f3ca44fc93a58975ee459ffc9440e5889a5ac1;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=8bdc6af3c8d4410a6d622606ea66a86fd9c49992;hpb=76dec26fec47df5b828973554b85dc91f3b564d1;p=lyx.git diff --git a/src/Undo.h b/src/Undo.h index 8bdc6af3c8..59f3ca44fc 100644 --- a/src/Undo.h +++ b/src/Undo.h @@ -5,10 +5,11 @@ * 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. */ @@ -16,130 +17,145 @@ #ifndef UNDO_H #define UNDO_H -#include "DocIterator.h" -#include "BufferParams.h" - #include "support/types.h" -#include - - namespace lyx { +class Buffer; class BufferParams; -class BufferView; -class DocIterator; -class Cursor; +class CursorData; +class Inset; class MathData; class ParagraphList; - -/** -These are the elements put on the undo stack. Each object contains complete -paragraphs from some cell and sufficient information to restore the cursor -state. - -The cell is given by a DocIterator pointing to this cell, the 'interesting' -range of paragraphs by counting them from begin and end of cell, -respectively. - -The cursor is also given as DocIterator and should point to some place in -the stored paragraph range. In case of math, we simply store the whole -cell, as there usually is just a simple paragraph in a cell. - -The idea is to store the contents of 'interesting' paragraphs in some -structure ('Undo') _before_ it is changed in some edit operation. -Obviously, the stored ranged should be as small as possible. However, it -there is a lower limit: The StableDocIterator pointing stored in the undo -class must be valid after the changes, too, as it will used as a pointer -where to insert the stored bits when performining undo. - -*/ - -class Undo { -public: - /// This is used to combine consecutive undo recordings of the same kind. - enum undo_kind { - /** - * Insert something - these will combine to one big chunk - * when many inserts come after each other. - */ - INSERT, - /** - * Delete something - these will combine to one big chunk - * when many deletes come after each other. - */ - DELETE, - /// Atomic - each of these will have its own entry in the stack - ATOMIC - }; - - /// Which kind of operation are we recording for? - undo_kind kind; - /// the position of the cursor - StableDocIterator cursor; - /// the position of the cell described - StableDocIterator cell; - /// counted from begin of cell - pit_type from; - /// complement to end of this cell - pit_type end; - /// the contents of the saved Paragraphs (for texted) - ParagraphList * pars; - /// the contents of the saved MathData (for mathed) - MathData * array; - /// Only used in case of full backups - BufferParams bparams; - /// Only used in case of full backups - bool isFullBuffer; +/// This is used to combine consecutive undo recordings of the same kind. +enum UndoKind { + /** + * Insert something - these will combine to one big chunk + * when many inserts come after each other. + */ + INSERT_UNDO, + /** + * Delete something - these will combine to one big chunk + * when many deletes come after each other. + */ + DELETE_UNDO, + /// Atomic - each of these will have its own entry in the stack + ATOMIC_UNDO }; -/// this will undo the last action - returns false if no undo possible -bool textUndo(BufferView & bv); - -/// this will redo the last undo - returns false if no redo possible -bool textRedo(BufferView & bv); +class Undo +{ + /// noncopyable + Undo(Undo const &); + void operator=(Undo const &); +public: -/// makes sure the next operation will be stored -void finishUndo(); + 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(CursorData &); + + /// this will redo the last undo - returns false if no redo possible + bool textRedo(CursorData &); + + /// End a sequence of INSERT_UNDO or DELETE_UNDO type of undo + /// operations (grouping of consecutive characters insertion/deletion). + void finishUndo(); + + /// + bool hasUndoStack() const; + /// + bool hasRedoStack() const; + + /// 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. + /** + * Record undo information - call with the current cursor and + * the 'other end' of the range of changed paragraphs. So we + * 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(CursorData const & cur, pit_type from, pit_type to); + + /// Convenience: record undo information for the single + /// paragraph or cell containing the cursor. + void recordUndo(CursorData 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 recordUndoFullBuffer(CursorData const & cur); + +private: + struct Private; + Private * const d; +}; -/** - * Record undo information - call with the current cursor and the 'other - * end' of the range of changed paragraphs. So we 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. +/** Helper class to simplify the use of undo groups across several buffers. * - * FIXME: We need something to record undo in partial grids for mathed. - * Right now we use recordUndoInset if more than one cell is changed, - * but that puts the cursor in front of the inset after undo. We would need - * something like - * recordUndoGrid(Cursor & cur, Undo::undo_kind kind, idx_type from, idx_type to); - * and store the cell information in class Undo. + * 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_; +}; -/// The general case: prepare undo for an arbitrary range. -/// FIXME: replace Cursor with DocIterator. This is not possible right -/// now because we need access to Buffer->params()!. -void recordUndo(Cursor & cur, Undo::undo_kind kind, - pit_type from, pit_type to); - -/// Convenience: prepare undo for the range between 'from' and cursor. -void recordUndo(Cursor & cur, Undo::undo_kind kind, pit_type from); - -/// Convenience: prepare undo for the single paragraph or cell -/// containing the cursor -void recordUndo(Cursor & cur, Undo::undo_kind kind = Undo::ATOMIC); -/// Convenience: prepare undo for the inset containing the cursor -void recordUndoInset(Cursor & cur, Undo::undo_kind kind = Undo::ATOMIC); -/// Convenience: prepare undo for the selected paragraphs -void recordUndoSelection(Cursor & cur, Undo::undo_kind kind = Undo::ATOMIC); - -/// Convenience: prepare undo for the whole buffer -void recordUndoFullDocument(BufferView * bv); } // namespace lyx -#endif // UNDO_FUNCS_H +#endif // UNDO_H