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 da4d27ca03d457f5172215b0d589c07689952107..ddc7025e1cae2858d226ec44d218352902f4184f 100644 (file)
--- a/src/Undo.cpp
+++ b/src/Undo.cpp
@@ -20,7 +20,6 @@
 #include "Buffer.h"
 #include "BufferList.h"
 #include "BufferParams.h"
-#include "buffer_funcs.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
 #include "ErrorList.h"
@@ -28,14 +27,13 @@
 #include "ParagraphList.h"
 #include "Text.h"
 
-#include "mathed/MathSupport.h"
+#include "mathed/InsetMath.h"
 #include "mathed/MathData.h"
+#include "mathed/MathRow.h"
 
-#include "insets/Inset.h"
 #include "insets/InsetText.h"
 
 #include "support/debug.h"
-#include "support/gettext.h"
 #include "support/lassert.h"
 #include "support/lyxtime.h"
 
@@ -314,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()
@@ -376,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_);
 
@@ -410,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
@@ -452,11 +473,8 @@ void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack,
                otherstack.top().bparams = new BufferParams(buffer_.params());
                DocumentClassConstPtr olddc = buffer_.params().documentClassPtr();
                buffer_.params() = *undo.bparams;
-               // The error list is not supposed to be helpful here.
-               ErrorList el;
                cap::switchBetweenClasses(olddc, buffer_.params().documentClassPtr(),
-                       static_cast<InsetText &>(buffer_.inset()), el);
-               LATTEST(el.empty());
+                       static_cast<InsetText &>(buffer_.inset()));
        } else if (dit.inMathed()) {
                // We stored the full cell here as there is not much to be
                // gained by storing just 'a few' paragraphs (most if not
@@ -522,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_;