* GuiView.cpp:

[lyx.git] / src / Undo.cpp

diff --git a/src/Undo.cpp b/src/Undo.cpp
index f7d31eb0a40e8f2e7c583e163ffef1e4314e69e8..06bd16ccc80ce13c0956397b14c23e33931ed925 100644 (file)
--- a/src/Undo.cpp
+++ b/src/Undo.cpp
@@ -66,6 +66,38 @@ where to insert the stored bits when performining undo.
 
 struct UndoElement
 {
+       ///
+       UndoElement(UndoKind kin, StableDocIterator const & cur, 
+                   StableDocIterator const & cel,
+                   pit_type fro, pit_type en, ParagraphList * pl, 
+                   MathData * ar, BufferParams const & bp, 
+                   bool ifb) :
+               kind(kin), cursor(cur), cell(cel), from(fro), end(en),
+               pars(pl), array(ar), bparams(0), isFullBuffer(ifb)
+       {
+               if (isFullBuffer)
+                       bparams = new BufferParams(bp);
+       }
+       ///
+       UndoElement(UndoElement const & ue)
+       {
+               kind = ue.kind;
+               cursor = ue.cursor;
+               cell = ue.cell;
+               from = ue.from;
+               end = ue.end;
+               pars = ue.pars;
+               array = ue.array;
+               bparams = ue.isFullBuffer
+                       ? new BufferParams(*ue.bparams) : ue.bparams;
+               isFullBuffer = ue.isFullBuffer;
+       }
+       ///
+       ~UndoElement()
+       {
+               if (isFullBuffer)
+                       delete bparams;
+       }
        /// Which kind of operation are we recording for?
        UndoKind kind;
        /// the position of the cursor
@@ -81,9 +113,12 @@ struct UndoElement
        /// the contents of the saved MathData (for mathed)
        MathData * array;
        /// Only used in case of full backups
-       BufferParams bparams;
+       BufferParams const * bparams;
        /// Only used in case of full backups
        bool isFullBuffer;
+private:
+       /// Protect construction
+       UndoElement();  
 };
 
 
@@ -215,35 +250,26 @@ void Undo::Private::doRecordUndo(UndoKind kind,
 {
        if (first_pit > last_pit)
                swap(first_pit, last_pit);
-       // create the position information of the Undo entry
-       UndoElement undo;
-       undo.array = 0;
-       undo.pars = 0;
-       undo.kind = kind;
-       undo.cell = cell;
-       undo.cursor = cur;
-       undo.bparams = buffer_.params();
-       undo.isFullBuffer = isFullBuffer;
-       //lyxerr << "recordUndo: cur: " << cur << endl;
-       //lyxerr << "recordUndo: pos: " << cur.pos() << endl;
-       //lyxerr << "recordUndo: cell: " << cell << endl;
-       undo.from = first_pit;
-       undo.end = cell.lastpit() - last_pit;
-
-       UndoElementStack & stack = isUndoOperation ?  undostack_ : redostack_;
 
        // 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;
+       UndoElementStack & stack = isUndoOperation ?  undostack_ : redostack_;
        if (!undo_finished_
            && kind != ATOMIC_UNDO
            && !stack.empty()
-           && samePar(stack.top().cell, undo.cell)
-           && stack.top().kind == undo.kind
-           && stack.top().from == undo.from
-           && stack.top().end == undo.end)
+           && samePar(stack.top().cell, cell)
+           && stack.top().kind == kind
+           && stack.top().from == from
+           && stack.top().end == end)
                return;
 
+       // create the position information of the Undo entry
+       UndoElement undo(kind, cur, cell, from, end, 0, 0, 
+                        buffer_.params(), isFullBuffer);
+
        // fill in the real data to be saved
        if (cell.inMathed()) {
                // simply use the whole cell
@@ -301,8 +327,9 @@ bool Undo::Private::textUndoOrRedo(DocIterator & cur, bool isUndoOperation)
        UndoElementStack & otherstack = isUndoOperation ?  redostack_ : undostack_;
 
        // Adjust undo stack and get hold of current undo data.
-       UndoElement undo = stack.top();
-       stack.pop();
+       UndoElement & undo = stack.top();
+       // We'll pop the stack only when we're done with this element. So do NOT
+       // try to return early.
 
        // We will store in otherstack the part of the document under 'undo'
        DocIterator cell_dit = undo.cell.asDocIterator(&buffer_.inset());
@@ -318,8 +345,9 @@ bool Undo::Private::textUndoOrRedo(DocIterator & cur, bool isUndoOperation)
        if (undo.isFullBuffer) {
                LASSERT(undo.pars, /**/);
                // This is a full document
-               otherstack.top().bparams = buffer_.params();
-               buffer_.params() = undo.bparams;
+               delete otherstack.top().bparams;
+               otherstack.top().bparams = new BufferParams(buffer_.params());
+               buffer_.params() = *undo.bparams;
                swap(buffer_.paragraphs(), *undo.pars);
                delete undo.pars;
                undo.pars = 0;
@@ -365,7 +393,9 @@ bool Undo::Private::textUndoOrRedo(DocIterator & cur, bool isUndoOperation)
        LASSERT(undo.array == 0, /**/);
 
        cur = undo.cursor.asDocIterator(&buffer_.inset());
-       
+       // Now that we're done with undo, we pop it off the stack.
+       stack.pop();
+
        if (labelsUpdateNeeded)
                updateLabels(buffer_);
        undo_finished_ = true;