Fix the rest of bug 5010.

[lyx.git] / src / Undo.cpp

diff --git a/src/Undo.cpp b/src/Undo.cpp
index 8f3e67c8e2ee44a4451c2248ad00896acd2ed1e2..efdae631685d8c50f9f729872c49ae47e63c0e47 100644 (file)
--- a/src/Undo.cpp
+++ b/src/Undo.cpp
@@ -30,13 +30,11 @@
 
 #include "insets/Inset.h"
 
+#include "support/lassert.h"
 #include "support/debug.h"
-#include "support/limited_stack.h"
-
-#include "support/assert.h"
 
 #include <algorithm>
-#include <ostream>
+#include <deque>
 
 using namespace std;
 using namespace lyx::support;
@@ -68,6 +66,15 @@ 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(bp), isFullBuffer(ifb)
+       {}
        /// Which kind of operation are we recording for?
        UndoKind kind;
        /// the position of the cursor
@@ -86,6 +93,51 @@ struct UndoElement
        BufferParams bparams;
        /// Only used in case of full backups
        bool isFullBuffer;
+private:
+       /// Protect construction
+       UndoElement();  
+};
+
+
+class UndoElementStack 
+{
+public:
+       /// limit is the maximum size of the stack
+       UndoElementStack(size_t limit = 100) { limit_ = limit; }
+       /// limit is the maximum size of the stack
+       ~UndoElementStack() { clear(); }
+
+       /// Return the top element.
+       UndoElement & top() { return c_.front(); }
+
+       /// Pop and throw away the top element.
+       void pop() { c_.pop_front(); }
+
+       /// Return true if the stack is empty.
+       bool empty() const { return c_.empty(); }
+
+       /// Clear all elements, deleting them.
+       void clear() {
+               for (size_t i = 0; i != c_.size(); ++i) {
+                       delete c_[i].array;
+                       delete c_[i].pars;
+               }
+               c_.clear();
+       }
+
+       /// Push an item on to the stack, deleting the
+       /// bottom item on overflow.
+       void push(UndoElement const & v) {
+               c_.push_front(v);
+               if (c_.size() > limit_)
+                       c_.pop_back();
+       }
+
+private:
+       /// Internal contents.
+       std::deque<UndoElement> c_;
+       /// The maximum number elements stored.
+       size_t limit_;
 };
 
 
@@ -113,9 +165,9 @@ struct Undo::Private
        ///
        Buffer & buffer_;
        /// Undo stack.
-       limited_stack<UndoElement> undostack_;
+       UndoElementStack undostack_;
        /// Redo stack.
-       limited_stack<UndoElement> redostack_;
+       UndoElementStack redostack_;
 
        /// The flag used by Undo::finishUndo().
        bool undo_finished_;
@@ -152,14 +204,6 @@ bool Undo::hasRedoStack() const
 }
 
 
-static ostream & operator<<(ostream & os, UndoElement const & undo)
-{
-       return os << " from: " << undo.from << " end: " << undo.end
-               << " cell:\n" << undo.cell
-               << " cursor:\n" << undo.cursor;
-}
-
-
 static bool samePar(StableDocIterator const & i1, StableDocIterator const & i2)
 {
        StableDocIterator tmpi2 = i2;
@@ -184,22 +228,9 @@ 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;
-
-       limited_stack<UndoElement> & stack = isUndoOperation ?
-               undostack_ : redostack_;
+       UndoElement undo(kind, cur, cell, first_pit, cell.lastpit() - last_pit, 0, 0, 
+                        buffer_.params(), isFullBuffer);
+       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,
@@ -261,15 +292,13 @@ bool Undo::Private::textUndoOrRedo(DocIterator & cur, bool isUndoOperation)
 {
        undo_finished_ = true;
 
-       limited_stack<UndoElement> & stack = isUndoOperation ?
-               undostack_ : redostack_;
+       UndoElementStack & stack = isUndoOperation ?  undostack_ : redostack_;
 
        if (stack.empty())
                // Nothing to do.
                return false;
 
-       limited_stack<UndoElement> & otherstack = isUndoOperation ?
-               redostack_ : undostack_;
+       UndoElementStack & otherstack = isUndoOperation ?  redostack_ : undostack_;
 
        // Adjust undo stack and get hold of current undo data.
        UndoElement undo = stack.top();