X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FUndo.h;h=d5748a97ea4b116e5ce33e4b6b26653780345afd;hb=612109bb6e5e61ba3c3693696f329eac3a288b5b;hp=29f25d9c6bda7f206a85e35318aca4277d6b7c72;hpb=345d7c00cd85576102a025daad82e6537fcb12d2;p=lyx.git diff --git a/src/Undo.h b/src/Undo.h index 29f25d9c6b..d5748a97ea 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,111 @@ #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 LCursor; -class MathArray; +class Inset; +class MathData; class ParagraphList; +/// 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 +}; -/** -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. +class Undo +{ +public: -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. + Undo(Buffer &); -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. + ~Undo(); -*/ + /// Clear out all undo/redo contents. + void clear(); -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 MathArray (for mathed) - MathArray * array; - /// Only used in case of full backups - BufferParams bparams; - /// Only used in case of full backups - bool isFullBuffer; -}; + /// this will undo the last action - returns false if no undo possible + bool textUndo(DocIterator &); + /// this will redo the last undo - returns false if no redo possible + bool textRedo(DocIterator &); -/// this will undo the last action - returns false if no undo possible -bool textUndo(BufferView & bv); + /// End a sequence of INSERT_UNDO or DELETE_UNDO type of undo + /// operations (grouping of consecutive characters insertion/deletion). + void finishUndo(); -/// this will redo the last undo - returns false if no redo possible -bool textRedo(BufferView & bv); + /// + bool hasUndoStack() const; + /// + bool hasRedoStack() const; -/// makes sure the next operation will be stored -void finishUndo(); + /// 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(); -/** - * 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. - * - * 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(LCursor & cur, Undo::undo_kind kind, idx_type from, idx_type to); - * and store the cell information in class Undo. - */ + /// end the current undo group. + void endUndoGroup(); + + /// end the current undo group and set UndoElement::cur_after if necessary. + void endUndoGroup(DocIterator const &); -/// The general case: prepare undo for an arbitrary range. -/// FIXME: replace LCursor with DocIterator. This is not possible right -/// now because we need access to Buffer->params()!. -void recordUndo(LCursor & cur, Undo::undo_kind kind, - pit_type from, pit_type to); + /// 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. + */ + void recordUndo(DocIterator const & cur, UndoKind kind, + pit_type from, pit_type to); -/// Convenience: prepare undo for the range between 'from' and cursor. -void recordUndo(LCursor & cur, Undo::undo_kind kind, pit_type from); + /// Convenience: record undo information for the range between + /// 'from' and cursor. + void recordUndo(DocIterator const & cur, UndoKind kind, pit_type from); -/// Convenience: prepare undo for the single paragraph or cell -/// containing the cursor -void recordUndo(LCursor & cur, Undo::undo_kind kind = Undo::ATOMIC); -/// Convenience: prepare undo for the inset containing the cursor -void recordUndoInset(LCursor & cur, Undo::undo_kind kind = Undo::ATOMIC); -/// Convenience: prepare undo for the selected paragraphs -void recordUndoSelection(LCursor & cur, Undo::undo_kind kind = Undo::ATOMIC); + /// Convenience: record undo information for the single + /// paragraph or cell containing the cursor. + void recordUndo(DocIterator 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, + Inset const * inset = 0); + + /// Convenience: prepare undo for the whole buffer + void recordUndoFullDocument(DocIterator const & cur); + +private: + struct Private; + Private * const d; +}; -/// Convenience: prepare undo for the whole buffer -void recordUndoFullDocument(BufferView * bv); } // namespace lyx -#endif // UNDO_FUNCS_H +#endif // UNDO_H