Obviously, the stored range should be as small as possible. However,
there is a lower limit: The StableDocIterator 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.
+where to insert the stored bits when performining undo.
*/
struct UndoElement
{
///
- UndoElement(UndoKind kin, CursorData const & cb,
+ UndoElement(UndoKind kin, CursorData const & cb,
StableDocIterator const & cel,
- pit_type fro, pit_type en, ParagraphList * pl,
- MathData * ar, BufferParams const & bp,
+ pit_type fro, pit_type en, ParagraphList * pl,
+ MathData * ar, BufferParams const & bp,
bool ifb, bool lc, size_t gid) :
kind(kin), cur_before(cb), cell(cel), from(fro), end(en),
pars(pl), array(ar), bparams(0), isFullBuffer(ifb),
size_t group_id;
private:
/// Protect construction
- UndoElement();
+ UndoElement();
};
-class UndoElementStack
+class UndoElementStack
{
public:
/// limit is the maximum size of the stack
/// Push an item on to the stack, deleting the bottom group on
/// overflow.
void push(UndoElement const & v) {
- c_.push_front(v);
- if (c_.size() > limit_) {
+ // Remove some entries if the limit has been reached.
+ // However, if the only group on the stack is the one
+ // we are currently populating, do nothing.
+ if (c_.size() >= limit_
+ && c_.front().group_id != v.group_id) {
// remove a whole group at once.
const size_t gid = c_.back().group_id;
while (!c_.empty() && c_.back().group_id == gid)
c_.pop_back();
}
+ c_.push_front(v);
}
/// Mark all the elements of the stack as dirty
void markDirty() {
for (size_t i = 0; i != c_.size(); ++i)
c_[i].lyx_clean = false;
- }
+ }
private:
/// Internal contents.
struct Undo::Private
{
- Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true),
+ Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true),
group_id(0), group_level(0) {}
-
+
// Do one undo/redo step
- void doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
+ void doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
UndoElementStack & otherStack);
// Apply one undo/redo group. Returns false if no undo possible.
bool textUndoOrRedo(CursorData & cur, bool isUndoOperation);
{
d->undo_finished_ = true;
d->undostack_.markDirty();
- d->redostack_.markDirty();
+ d->redostack_.markDirty();
}
else
LYXERR(Debug::UNDO, "Create undo element of group " << group_id);
// create the position information of the Undo entry
- UndoElement undo(kind, cur_before, cell, from, end, 0, 0,
+ UndoElement undo(kind, cur_before, cell, from, end, 0, 0,
buffer_.params(), isFullBuffer, buffer_.isClean(), group_id);
// fill in the real data to be saved
// This one may happen outside of the main undo group, so we
// put it in its own subgroup to avoid complaints.
beginUndoGroup();
- d->recordUndo(ATOMIC_UNDO, doc_iterator_begin(&d->buffer_),
+ d->recordUndo(ATOMIC_UNDO, doc_iterator_begin(&d->buffer_),
0, d->buffer_.paragraphs().size() - 1, cur, true);
endUndoGroup();
}