Fixed redraw problems after undo/redo.

[lyx.git] / src / undo_funcs.C

diff --git a/src/undo_funcs.C b/src/undo_funcs.C
index e54aab24a7e1d7841a9739badc49d7393b939387..b988b6787118c7d56b948a664e4a88bcf1565e0c 100644 (file)
--- a/src/undo_funcs.C
+++ b/src/undo_funcs.C
@@ -23,11 +23,14 @@
 
 #include "iterators.h"
 
-//#define DELETE_UNUSED_PARAGRAPHS 1
+#define DELETE_UNUSED_PARAGRAPHS 1
 #ifdef DELETE_UNUSED_PARAGRAPHS
 #include <vector>
 #endif
 
+using std::vector;
+
+
 /// the flag used by FinishUndo();
 bool undo_finished;
 /// a flag
@@ -140,6 +143,8 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
                        Inset * in = 0;
                        if (before)
                                in = before->inInset();
+                       else if (undo->number_of_inset_id >= 0)
+                               in = bv->buffer()->getInsetFromID(undo->number_of_inset_id);
                        tmppar4->setInsetOwner(in);
                        while (tmppar4->next()) {
                                tmppar4 = tmppar4->next();
@@ -149,7 +154,7 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
     
                // now remove the old text if there is any
 #ifdef DELETE_UNUSED_PARAGRAPHS
-               std::vector<Paragraph *> vvpar;
+               vector<Paragraph *> vvpar;
 #endif
                if (before != behind || (!behind && !before)) {
                        if (before)
@@ -178,18 +183,23 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
                }
     
                // put the new stuff in the list if there is one
-               if (tmppar3){
+               if (tmppar3) {
                        if (before)
                                before->next(tmppar3);
                        else
-                               bv->text->ownerParagraph(tmppar3->id(),
-                                                        tmppar3);
+                               bv->text->ownerParagraph(firstUndoParagraph(bv, undo->number_of_inset_id)->id(),
+                                                        tmppar3);
 
                        tmppar3->previous(before);
                } else {
-                       // Do we really enter here ??? (Jug)
-                       if (!before)
-                               bv->text->ownerParagraph(behind);
+                       // We enter here on DELETE undo operations where we have to
+                       // substitue the second paragraph with the first if the removed
+                       // one is the first!
+                       if (!before && behind) {
+                               bv->text->ownerParagraph(firstUndoParagraph(bv, undo->number_of_inset_id)->id(),
+                                                        behind);
+                               tmppar3 = behind;
+                       }
                }
                if (tmppar4) {
                        tmppar4->next(behind);
@@ -211,22 +221,16 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
                // calculate the endpar for redoing the paragraphs.
                if (behind)
                        endpar = behind->next();
-    
+
                tmppar = bv->buffer()->getParFromID(undo->number_of_cursor_par);
-               UpdatableInset* it = static_cast<UpdatableInset*>(tmppar3->inInset());
+               UpdatableInset* it = 0;
+               if (tmppar3)
+                       it = static_cast<UpdatableInset*>(tmppar3->inInset());
                if (it) {
-                       it->getLyXText(bv)->redoParagraphs(bv, it->getLyXText(bv)->cursor,
+                       it->getLyXText(bv)->redoParagraphs(bv,
+                                                          it->getLyXText(bv)->cursor,
                                                           endpar);
-                       LyXFont font;
-                       it->update(bv, font, false);
-                       // we now would have to rebreak the whole paragraph the undo-par
-                       // was in. How we do it here is not really true. We would have to
-                       // save this information in the undo-struct and then we could do
-                       // the right rebreak. Here we only handle the case where this
-                       // was in the actual paragraph, which not always is true.
-                       bv->text->redoParagraphs(bv, bv->text->cursor,
-                                                                        bv->text->cursor.par());
-                       if (tmppar){
+                       if (tmppar) {
                                it = static_cast<UpdatableInset*>(tmppar->inInset());
                                LyXText * t;
                                if (it) {
@@ -237,9 +241,11 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
                                }
                                t->setCursorIntern(bv, tmppar, undo->cursor_pos);
                                t->updateCounters(bv, t->cursor.row());
+                               bv->fitCursor();
                        }
+                       bv->updateInset(it, false);
                        bv->text->setCursorIntern(bv, bv->text->cursor.par(),
-                                                                         bv->text->cursor.pos());
+                                                 bv->text->cursor.pos());
                } else {
                        bv->text->redoParagraphs(bv, bv->text->cursor, endpar);
                        if (tmppar) {
@@ -259,19 +265,29 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
                delete undo;
 #ifdef DELETE_UNUSED_PARAGRAPHS
                // And here it's save enough to delete all removed paragraphs
-               std::vector<Paragraph *>::iterator pit = vvpar.begin();
+               vector<Paragraph *>::iterator pit = vvpar.begin();
                if (pit != vvpar.end()) {
+#if 0
+                       lyxerr << endl << "PARS BEFORE:";
+                       ParIterator end = bv->buffer()->par_iterator_end();
+                       ParIterator it = bv->buffer()->par_iterator_begin();
+                       for (; it != end; ++it)
+                               lyxerr << (*it)->previous() << "<- " << (*it) << " ->" << (*it)->next() << endl;
                        lyxerr << "DEL: ";
+#endif
                        for(;pit != vvpar.end(); ++pit) {
-                               lyxerr << *pit << " ";
+//                             lyxerr << *pit << " ";
+                               (*pit)->previous(0);
+                               (*pit)->next(0);
                                delete (*pit);
                        }
-                       lyxerr << endl << "PARS:";
-                       ParIterator end = bv->buffer()->par_iterator_end();
-                       ParIterator it = bv->buffer()->par_iterator_begin();
+#if 0
+                       lyxerr << endl << "PARS AFTER:";
+                       end = bv->buffer()->par_iterator_end();
+                       it = bv->buffer()->par_iterator_begin();
                        for (; it != end; ++it)
-                               lyxerr << *it << " ";
-                       lyxerr << endl;
+                               lyxerr << (*it)->previous() << "<- " << (*it) << " ->" << (*it)->next() << endl;
+#endif
                }
 #endif
        }
@@ -342,7 +358,7 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind,
        // appear one by one when undoing. 
        // EDIT is special since only layout information, not the
        // contents of a paragaph are stored.
-       if (!undo_finished && (kind != Undo::EDIT) && (kind != Undo::FINISH)){
+       if (!undo_finished && (kind != Undo::EDIT) && (kind != Undo::FINISH)) {
                // check wether storing is needed
                if (!bv->buffer()->undostack.empty() && 
                    bv->buffer()->undostack.top()->kind == kind &&
@@ -382,13 +398,19 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind,
   
                while (tmppar != end && tmppar->next()) {
                        tmppar = tmppar->next();
+#if 0
                        tmppar2->next(new Paragraph(*tmppar, true));
+#else
+                       Paragraph * ptmp = new Paragraph(*tmppar, true);
+                       tmppar2->next(ptmp);
+#endif
                        // a memory optimization: Just store the layout
                        // information when only edit
                        if (kind == Undo::EDIT) {
                                tmppar2->clearContents();
                        }
                        tmppar2->next()->previous(tmppar2);
+                       
                        tmppar2 = tmppar2->next();
                }
                tmppar2->next(0);