Amend 6c3447c8: FindAdv: sometimes a space is added on some math symbols

[lyx.git] / src / Undo.cpp

diff --git a/src/Undo.cpp b/src/Undo.cpp
index a870241d13b2475df8d9b25d18d07bce8c1ec15d..ddc7025e1cae2858d226ec44d218352902f4184f 100644 (file)
--- a/src/Undo.cpp
+++ b/src/Undo.cpp
@@ -312,12 +312,29 @@ void Undo::Private::doRecordUndo(UndoKind kind,
 
        if (first_pit > last_pit)
                swap(first_pit, last_pit);
+       pit_type const from = first_pit;
+       pit_type const end = cell.lastpit() - last_pit;
+
+       /* Undo coalescing: if the undo element we want to add only
+        * changes stuff that was already modified by the previous one on
+        * undo stack (in the same group), then skip it. There is nothing
+        * to gain in adding it to the stack. The code below works for
+        * both texted and mathed.
+       */
+       if (!stack.empty()
+           && stack.top().group_id == group_id_
+           && !stack.top().bparams
+           && samePar(stack.top().cell, cell)
+           //&& stack.top().kind == kind // needed?
+           && stack.top().from <= from
+           && stack.top().end >= end) {
+               LYXERR(Debug::UNDO, "Undo coalescing: skip entry");
+               return;
+       }
 
        // Undo::ATOMIC are always recorded (no overlapping there).
        // As nobody wants all removed character appear one by one when undoing,
        // we want combine 'similar' non-ATOMIC undo recordings to one.
-       pit_type from = first_pit;
-       pit_type end = cell.lastpit() - last_pit;
        if (!undo_finished_
            && kind != ATOMIC_UNDO
            && !stack.empty()
@@ -374,6 +391,9 @@ void Undo::Private::recordUndo(UndoKind kind,
        LASSERT(first_pit <= cell.lastpit(), return);
        LASSERT(last_pit <= cell.lastpit(), return);
 
+       if (buffer_.isReadonly())
+               return;
+
        doRecordUndo(kind, cell, first_pit, last_pit, cur,
                undostack_);
 
@@ -408,6 +428,9 @@ void Undo::Private::doRecordUndoBufferParams(CursorData const & cur_before,
 
 void Undo::Private::recordUndoBufferParams(CursorData const & cur)
 {
+       if (buffer_.isReadonly())
+               return;
+
        doRecordUndoBufferParams(cur, undostack_);
 
        // next time we'll try again to combine entries if possible
@@ -517,6 +540,9 @@ void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack,
 
 bool Undo::Private::undoRedoAction(CursorData & cur, bool isUndoOperation)
 {
+       if (buffer_.isReadonly())
+               return false;
+
        undo_finished_ = true;
 
        UndoElementStack & stack = isUndoOperation ?  undostack_ : redostack_;