and this

[lyx.git] / src / undo.C

diff --git a/src/undo.C b/src/undo.C
index b3e3334d37420cba3e79a337687062885afeefe0..08431d9ee2c395eeec516278d054e5eb0ed015ee 100644 (file)
--- a/src/undo.C
+++ b/src/undo.C
@@ -27,7 +27,10 @@
 
 #include <algorithm>
 
-using lyx::paroffset_type;
+using lyx::par_type;
+
+using std::advance;
+using std::endl;
 
 
 namespace {
@@ -38,14 +41,13 @@ bool undo_finished;
 
 std::ostream & operator<<(std::ostream & os, Undo const & undo)
 {
-       return os << " from: " << undo.from
-               << " end: " << undo.end
+       return os << " from: " << undo.from << " end: " << undo.end
                << " cursor:\n" << undo.cursor;
 }
 
 
 void recordUndo(Undo::undo_kind kind,
-       LCursor & cur, paroffset_type first_par, paroffset_type last_par,
+       LCursor & cur, par_type first_par, par_type last_par,
        limited_stack<Undo> & stack)
 {
        BOOST_ASSERT(first_par <= cur.lastpar());
@@ -57,7 +59,9 @@ void recordUndo(Undo::undo_kind kind,
        // create the position information of the Undo entry
        Undo undo;
        undo.kind = kind;
-       undo.cursor = StableDocumentIterator(cur);
+       undo.cursor = StableDocIterator(cur);
+       lyxerr << "recordUndo: cur: " << cur << endl;
+       lyxerr << "recordUndo: undo.cursor: " << undo.cursor << endl;
        undo.from = first_par;
        undo.end = cur.lastpar() - last_par;
 
@@ -91,7 +95,7 @@ void recordUndo(Undo::undo_kind kind,
                undo.pars = ParagraphList(first, last);
        }
 
-       // push the undo entry to undo stack 
+       // push the undo entry to undo stack
        //lyxerr << "undo record: " << stack.top() << std::endl;
        stack.push(undo);
 
@@ -104,7 +108,8 @@ void performUndoOrRedo(BufferView & bv, Undo const & undo)
 {
        LCursor & cur = bv.cursor();
        lyxerr << "undo, performing: " << undo << std::endl;
-       cur.setCursor(undo.cursor.asDocumentIterator(&bv.buffer()->inset()), false);
+       cur.setCursor(undo.cursor.asDocIterator(&bv.buffer()->inset()));
+       cur.selection() = false;
 
        if (cur.inMathed()) {
                // We stored the full cell here as there is not much to be
@@ -135,12 +140,12 @@ void performUndoOrRedo(BufferView & bv, Undo const & undo)
 }
 
 
-// returns false if no undo possible
+// Returns false if no undo possible.
 bool textUndoOrRedo(BufferView & bv,
        limited_stack<Undo> & stack, limited_stack<Undo> & otherstack)
 {
        if (stack.empty()) {
-               // nothing to do
+               // Nothing to do.
                finishUndo();
                return false;
        }
@@ -149,13 +154,21 @@ bool textUndoOrRedo(BufferView & bv,
        stack.pop();
        finishUndo();
 
-       // this implements redo
+       // This implements redo
        otherstack.push(undo);
-       DocumentIterator dit =
-               undo.cursor.asDocumentIterator(&bv.buffer()->inset());
+       // FIXME: This triggers the error in dociterator.C +454
+       // could the reason be that we rebuild the dit _before_ the
+       // contents is actually 'undone'?
+       // I.e. state now is 'A', state on undo stack is 'B'.
+       // dit is created according to positions from undo.cursor, i.e. B
+       // but current buffer contents is more likely 'A'.
+       DocIterator dit = undo.cursor.asDocIterator(&bv.buffer()->inset());
        if (dit.inMathed()) {
-               // not much to be done
+               // Easy way out: store a full cell.
+               otherstack.top().array = asString(dit.cell());
        } else {
+               // As cells might be too large in texted, store just a part
+               // of the paragraph list.
                otherstack.top().pars.clear();
                LyXText * text = dit.text();
                BOOST_ASSERT(text);
@@ -180,7 +193,7 @@ bool textUndoOrRedo(BufferView & bv,
 
 void finishUndo()
 {
-       // makes sure the next operation will be stored
+       // Make sure the next operation will be stored.
        undo_finished = true;
 }
 
@@ -200,7 +213,7 @@ bool textRedo(BufferView & bv)
 
 
 void recordUndo(Undo::undo_kind kind,
-       LCursor & cur, paroffset_type first, paroffset_type last)
+       LCursor & cur, par_type first, par_type last)
 {
        Buffer * buf = cur.bv().buffer();
        recordUndo(kind, cur, first, last, buf->undostack());
@@ -217,20 +230,28 @@ void recordUndo(LCursor & cur, Undo::undo_kind kind)
 }
 
 
+void recordUndoInset(LCursor & cur, Undo::undo_kind kind)
+{
+       LCursor c = cur;
+       c.pop();
+       recordUndo(c, kind);
+}
+
+
 void recordUndoSelection(LCursor & cur, Undo::undo_kind kind)
 {
        recordUndo(kind, cur, cur.selBegin().par(), cur.selEnd().par());
 }
 
 
-void recordUndo(LCursor & cur, Undo::undo_kind kind, paroffset_type from)
+void recordUndo(LCursor & cur, Undo::undo_kind kind, par_type from)
 {
        recordUndo(kind, cur, cur.par(), from);
 }
 
 
 void recordUndo(LCursor & cur, Undo::undo_kind kind,
-       paroffset_type from, paroffset_type to)
+       par_type from, par_type to)
 {
        recordUndo(kind, cur, from, to);
 }