Reimplement inset-select-all in a generic way

[lyx.git] / src / Undo.cpp

diff --git a/src/Undo.cpp b/src/Undo.cpp
index 122b1aada65011d341d3104c34628527aa0901da..31eaec3dbd84977ee7d52e3dca4c86b3726df7f9 100644 (file)
--- a/src/Undo.cpp
+++ b/src/Undo.cpp
@@ -61,15 +61,15 @@ structure ('Undo') _before_ it is changed in some edit operation.
 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),
@@ -127,11 +127,11 @@ struct UndoElement
        size_t group_id;
 private:
        /// Protect construction
-       UndoElement();  
+       UndoElement();
 };
 
 
-class UndoElementStack 
+class UndoElementStack
 {
 public:
        /// limit is the maximum size of the stack
@@ -160,20 +160,24 @@ public:
        /// 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.
@@ -185,11 +189,11 @@ private:
 
 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);
@@ -273,7 +277,7 @@ void Undo::markDirty()
 {
        d->undo_finished_ = true;
        d->undostack_.markDirty();
-       d->redostack_.markDirty();      
+       d->redostack_.markDirty();
 }
 
 
@@ -328,7 +332,7 @@ void Undo::Private::doRecordUndo(UndoKind kind,
        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
@@ -341,7 +345,7 @@ void Undo::Private::doRecordUndo(UndoKind kind,
                // main Text _is_ the whole document.
                // record the relevant paragraphs
                Text const * text = cell.text();
-               LBUFERR(text, _("Uninitialized cell."));
+               LBUFERR(text);
                ParagraphList const & plist = text->paragraphs();
                ParagraphList::const_iterator first = plist.begin();
                advance(first, first_pit);
@@ -401,7 +405,7 @@ void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
        //LYXERR0("undo, performing: " << undo);
        DocIterator dit = undo.cell.asDocIterator(&buffer_);
        if (undo.isFullBuffer) {
-               LBUFERR(undo.pars, _("Undo stack is corrupt!"));
+               LBUFERR(undo.pars);
                // This is a full document
                delete otherstack.top().bparams;
                otherstack.top().bparams = new BufferParams(buffer_.params());
@@ -414,15 +418,15 @@ void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
                // gained by storing just 'a few' paragraphs (most if not
                // all math inset cells have just one paragraph!)
                //LYXERR0("undo.array: " << *undo.array);
-               LBUFERR(undo.array, _("Undo stack is corrupt!"));
+               LBUFERR(undo.array);
                dit.cell().swap(*undo.array);
                delete undo.array;
                undo.array = 0;
        } else {
                // Some finer machinery is needed here.
                Text * text = dit.text();
-               LBUFERR(text, _("Invalid cursor."));
-               LBUFERR(undo.pars, _("Undo stack is corrupt!"));
+               LBUFERR(text);
+               LBUFERR(undo.pars);
                ParagraphList & plist = text->paragraphs();
 
                // remove new stuff between first and last
@@ -578,7 +582,7 @@ void Undo::recordUndoFullDocument(CursorData const & cur)
        // 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();
 }