don't copy if a reference is fine

[lyx.git] / src / undo_funcs.C

diff --git a/src/undo_funcs.C b/src/undo_funcs.C
index a0a0aa567d8cb2f41ae85179860dced26a415060..e0b0e42117d517414b6e2151597628b46efd689d 100644 (file)
--- a/src/undo_funcs.C
+++ b/src/undo_funcs.C
@@ -215,37 +215,37 @@ bool textHandleUndo(BufferView * bv, Undo * undo)
                        endpar = behind->next();
 
                tmppar = bv->buffer()->getParFromID(undo->number_of_cursor_par);
-               if (tmppar3) {
-                       UpdatableInset* it = static_cast<UpdatableInset*>(tmppar3->inInset());
-                       if (it) {
-                               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){
-                                       it = static_cast<UpdatableInset*>(tmppar->inInset());
-                                       LyXText * t;
-                                       if (it) {
-                                               it->edit(bv);
-                                               t = it->getLyXText(bv);
-                                       } else {
-                                               t = bv->text;
-                                       }
-                                       t->setCursorIntern(bv, tmppar, undo->cursor_pos);
-                                       t->updateCounters(bv, t->cursor.row());
+               UpdatableInset* it = 0;
+               if (tmppar3)
+                       it = static_cast<UpdatableInset*>(tmppar3->inInset());
+               if (it) {
+                       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){
+                               it = static_cast<UpdatableInset*>(tmppar->inInset());
+                               LyXText * t;
+                               if (it) {
+                                       it->edit(bv);
+                                       t = it->getLyXText(bv);
+                               } else {
+                                       t = bv->text;
                                }
-                               bv->text->setCursorIntern(bv, bv->text->cursor.par(),
-                                                         bv->text->cursor.pos());
+                               t->setCursorIntern(bv, tmppar, undo->cursor_pos);
+                               t->updateCounters(bv, t->cursor.row());
                        }
+                       bv->text->setCursorIntern(bv, bv->text->cursor.par(),
+                                                 bv->text->cursor.pos());
                } else {
                        bv->text->redoParagraphs(bv, bv->text->cursor, endpar);
                        if (tmppar) {
@@ -388,13 +388,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);