]> git.lyx.org Git - lyx.git/blobdiff - src/undo_funcs.C
Point fix, earlier forgotten
[lyx.git] / src / undo_funcs.C
index b988b6787118c7d56b948a664e4a88bcf1565e0c..9fbef8b6bc40ca83e1baae8765b61f22a1327b13 100644 (file)
-/* This file is part of
- * ====================================================== 
- * 
- *           LyX, The Document Processor
- *        
- *           Copyright 1995-2001 The LyX Team.
+/**
+ * \file undo_funcs.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- * ====================================================== */
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author John Levon
+ * \author André Pönitz
+ * \author Jürgen Vigna
+ *
+ * Full author contact details are available in file CREDITS.
+ */
 
 #include <config.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include "undo_funcs.h"
 #include "lyxtext.h"
+#include "funcrequest.h"
 #include "BufferView.h"
 #include "buffer.h"
-#include "insets/inset.h"
+#include "insets/updatableinset.h"
+#include "insets/insettext.h"
 #include "debug.h"
 #include "support/LAssert.h"
-
 #include "iterators.h"
 
-#define DELETE_UNUSED_PARAGRAPHS 1
-#ifdef DELETE_UNUSED_PARAGRAPHS
-#include <vector>
-#endif
 
-using std::vector;
-
-
-/// the flag used by FinishUndo();
+/// The flag used by FinishUndo().
 bool undo_finished;
-/// a flag
+
+/// Whether actions are not added to the undo stacks.
 bool undo_frozen;
 
+namespace {
 
-bool textUndo(BufferView * bv)
+
+void recordUndo(BufferView * bv, Undo::undo_kind kind,
+       ParagraphList::iterator first, ParagraphList::iterator last,
+       limited_stack<Undo> & stack)
 {
-       // returns false if no undo possible
-       Undo * undo = bv->buffer()->undostack.top();
-       bv->buffer()->undostack.pop();
-       if (undo) {
-               finishUndo();
-               if (!undo_frozen) {
-                       Paragraph * first = bv->buffer()->getParFromID(undo->number_of_before_par);
-                       if (first && first->next())
-                               first = first->next();
-                       else if (!first)
-                               first = firstUndoParagraph(bv, undo->number_of_inset_id);
-                       if (first) {
-                               bv->buffer()->redostack.push(
-                                       createUndo(bv, undo->kind, first,
-                                                  bv->buffer()->getParFromID(undo->number_of_behind_par)));
-                       }
+       Buffer * buf = bv->buffer();
+
+       // First, record inset id, if cursor is in one
+       UpdatableInset * inset = first->inInset();
+       LyXText * text = inset ? inset->getLyXText(bv) : bv->text;
+       int const inset_id = inset ? inset->id() : -1;
+
+       // We simply record the entire outer paragraphs
+       ParagraphList * plist = &buf->paragraphs;
+       ParIterator null = buf->par_iterator_end();
+
+       // First, identify the outer paragraphs
+       for (ParIterator it = buf->par_iterator_begin(); it != null; ++it) {
+               if (it->id() == first->id())
+                       first = it.outerPar();
+               if (it->id() == last->id())
+                       last = it.outerPar();
+       }
+
+       // And calculate a stable reference to them
+       int const first_offset = std::distance(plist->begin(), first);
+       int const last_offset = std::distance(last, plist->end());
+
+       // Undo::ATOMIC are always recorded (no overlapping there).
+
+       // Overlapping only with insert and delete inside one paragraph:
+       // Nobody wants all removed character appear one by one when undoing.
+       if (! undo_finished && kind != Undo::ATOMIC) {
+               // Check whether storing is needed.
+               if (! buf->undostack.empty() 
+                   && buf->undostack.top().kind == kind 
+                   && buf->undostack.top().first_par_offset == first_offset
+                   && buf->undostack.top().last_par_offset == last_offset) {
+                       // No additonal undo recording needed -
+                       // effectively, we combine undo recordings to one.
+                       return;
                }
        }
-       // now we can unlock the inset for saftey because the inset pointer could
-       // be changed during the undo-function. Anyway if needed we have to lock
-       // the right inset/position if this is requested.
-       freezeUndo();
-       bv->unlockInset(bv->theLockingInset());
-       bool ret = textHandleUndo(bv, undo);
-       unFreezeUndo();
-       return ret;
-}
 
+       // Record the cursor position in a stable way.
+       int const cursor_offset = std::distance
+               (text->ownerParagraphs().begin(), text->cursor.par());
 
-bool textRedo(BufferView * bv)
-{
-       // returns false if no redo possible
-       Undo * undo = bv->buffer()->redostack.top();
-       bv->buffer()->redostack.pop();
-       if (undo) {
-               finishUndo();
-               if (!undo_frozen) {
-                       Paragraph * first = bv->buffer()->getParFromID(undo->number_of_before_par);
-                       if (first && first->next())
-                               first = first->next();
-                       else if (!first)
-                               first = firstUndoParagraph(bv, undo->number_of_inset_id);
-                       if (first) {
-                               bv->buffer()->undostack.push(
-                                       createUndo(bv, undo->kind, first,
-                                                  bv->buffer()->getParFromID(undo->number_of_behind_par)));
-                       }
-               }
+       // Make and push the Undo entry
+       stack.push(Undo(kind, inset_id,
+               first_offset, last_offset,
+               cursor_offset, text->cursor.pos(),
+               ParagraphList()));
+
+       // Record the relevant paragraphs
+       ParagraphList & undo_pars = stack.top().pars;
+
+       for (ParagraphList::iterator it = first; it != last; ++it) {
+               undo_pars.push_back(*it);
+               undo_pars.back().id(it->id());
        }
-       // now we can unlock the inset for saftey because the inset pointer could
-       // be changed during the undo-function. Anyway if needed we have to lock
-       // the right inset/position if this is requested.
-       freezeUndo();
-       bv->unlockInset(bv->theLockingInset());
-       bool ret = textHandleUndo(bv, undo);
-       unFreezeUndo();
-       return ret;
+       undo_pars.push_back(*last);
+       undo_pars.back().id(last->id());
+
+       // And make sure that next time, we should be combining if possible
+       undo_finished = false;
 }
 
 
-bool textHandleUndo(BufferView * bv, Undo * undo)
+// Returns false if no undo possible.
+bool performUndoOrRedo(BufferView * bv, Undo & undo)
 {
-       // returns false if no undo possible
-       bool result = false;
-       if (undo) {
-               Paragraph * before =
-                       bv->buffer()->getParFromID(undo->number_of_before_par); 
-               Paragraph * behind =
-                       bv->buffer()->getParFromID(undo->number_of_behind_par); 
-               Paragraph * tmppar;
-               Paragraph * tmppar2;
-               Paragraph * tmppar5;
-
-               // if there's no before take the beginning
-               // of the document for redoing
-               if (!before) {
-                       LyXText * t = bv->text;
-                       int num = undo->number_of_inset_id;
-                       if (undo->number_of_inset_id >= 0) {
-                               Inset * in = bv->buffer()->getInsetFromID(num);
-                               if (in) {
-                                       t = in->getLyXText(bv);
-                               } else {
-                                       num = -1;
-                               }
-                       }
-                       t->setCursorIntern(bv, firstUndoParagraph(bv, num), 0);
-               }
+       Buffer * buf = bv->buffer();
+       ParagraphList * plist = &buf->paragraphs;
 
-               // replace the paragraphs with the undo informations
-
-               Paragraph * tmppar3 = undo->par;
-               undo->par = 0;  /* otherwise the undo destructor would
-                                  delete the paragraph */
-
-               // get last undo par and set the right(new) inset-owner of the
-               // paragraph if there is any. This is not needed if we don't have
-               // a paragraph before because then in is automatically done in the
-               // function which assigns the first paragraph to an InsetText. (Jug)
-               Paragraph * tmppar4 = tmppar3;
-               if (tmppar4) {
-                       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();
-                               tmppar4->setInsetOwner(in);
-                       }
-               }
-    
-               // now remove the old text if there is any
-#ifdef DELETE_UNUSED_PARAGRAPHS
-               vector<Paragraph *> vvpar;
-#endif
-               if (before != behind || (!behind && !before)) {
-                       if (before)
-                               tmppar5 = before->next();
-                       else
-                               tmppar5 = firstUndoParagraph(bv, undo->number_of_inset_id);
-                       tmppar2 = tmppar3;
-                       while (tmppar5 && tmppar5 != behind) {
-#ifdef DELETE_UNUSED_PARAGRAPHS
-                               vvpar.push_back(tmppar5);
-#endif
-                               tmppar = tmppar5;
-                               tmppar5 = tmppar5->next();
-                               // a memory optimization for edit:
-                               // Only layout information 
-                               // is stored in the undo. So restore
-                               // the text informations. 
-                               if (undo->kind == Undo::EDIT) {
-                                       tmppar2->setContentsFromPar(tmppar);
-#ifndef DELETE_UNUSED_PARAGRAPHS
-                                       tmppar->clearContents();
-#endif
-                                       tmppar2 = tmppar2->next();
-                               }
-                       }
-               }
-    
-               // put the new stuff in the list if there is one
-               if (tmppar3) {
-                       if (before)
-                               before->next(tmppar3);
-                       else
-                               bv->text->ownerParagraph(firstUndoParagraph(bv, undo->number_of_inset_id)->id(),
-                                                        tmppar3);
-
-                       tmppar3->previous(before);
+       // Remove new stuff between first and last
+       {
+               ParagraphList::iterator first = plist->begin();
+               advance(first, undo.first_par_offset);
+               ParagraphList::iterator last = plist->begin();
+               advance(last, plist->size() - undo.last_par_offset);
+               plist->erase(first, ++last);
+       }
+               
+       // Re-insert old stuff instead
+       {
+               if (plist->empty()) {
+                       plist->assign(undo.pars.begin(), undo.pars.end());
                } else {
-                       // 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);
-                       if (behind)
-                               behind->previous(tmppar4);
-               }
-    
-    
-               // Set the cursor for redoing
-               if (before) {
-                       Inset * it = before->inInset();
-                       if (it)
-                               it->getLyXText(bv)->setCursorIntern(bv, before, 0);
-                       else
-                               bv->text->setCursorIntern(bv, before, 0);
+                       ParagraphList::iterator first = plist->begin();
+                       advance(first, undo.first_par_offset);
+                       plist->insert(first, undo.pars.begin(), undo.pars.end());
                }
+       }
 
-               Paragraph * endpar = 0;
-               // calculate the endpar for redoing the paragraphs.
-               if (behind)
-                       endpar = behind->next();
-
-               tmppar = bv->buffer()->getParFromID(undo->number_of_cursor_par);
-               UpdatableInset* it = 0;
-               if (tmppar3)
-                       it = static_cast<UpdatableInset*>(tmppar3->inInset());
-               if (it) {
-                       it->getLyXText(bv)->redoParagraphs(bv,
-                                                          it->getLyXText(bv)->cursor,
-                                                          endpar);
-                       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());
-                               bv->fitCursor();
-                       }
-                       bv->updateInset(it, false);
-                       bv->text->setCursorIntern(bv, bv->text->cursor.par(),
-                                                 bv->text->cursor.pos());
-               } else {
-                       bv->text->redoParagraphs(bv, bv->text->cursor, endpar);
-                       if (tmppar) {
-                               LyXText * t;
-                               Inset * it = tmppar->inInset();
-                               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());
-                       }
-               }
-               result = true;
-               delete undo;
-#ifdef DELETE_UNUSED_PARAGRAPHS
-               // And here it's save enough to delete all removed paragraphs
-               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 << " ";
-                               (*pit)->previous(0);
-                               (*pit)->next(0);
-                               delete (*pit);
-                       }
-#if 0
-                       lyxerr << endl << "PARS AFTER:";
-                       end = bv->buffer()->par_iterator_end();
-                       it = bv->buffer()->par_iterator_begin();
-                       for (; it != end; ++it)
-                               lyxerr << (*it)->previous() << "<- " << (*it) << " ->" << (*it)->next() << endl;
-#endif
+       // Rebreak the entire document
+       bv->text->fullRebreak();
+
+       // set cursor
+       {
+               // Get a hold of the inset for the cursor, if relevant
+               UpdatableInset * inset =
+                       static_cast<UpdatableInset *>(
+                               buf->getInsetFromID(undo.inset_id));
+
+               LyXText * text = inset ? inset->getLyXText(bv) : bv->text;
+               ParagraphList::iterator cursor = text->ownerParagraphs().begin();
+               advance(cursor, undo.cursor_par_offset);
+               text->setCursorIntern(cursor, undo.cursor_pos);
+
+               if (inset) {
+                       // Magic needed to update inset internal state
+                       FuncRequest cmd(bv, LFUN_INSET_EDIT, "left");
+                       inset->localDispatch(cmd);
                }
-#endif
+
+               // set cursor again to force the position to be the right one
+               text->setCursorIntern(cursor, undo.cursor_pos);
+
+               // Clear any selection and set the selection
+               // cursor for any new selection.
+               text->clearSelection();
+               text->selection.cursor = text->cursor;
+               text->updateCounters();
        }
+
        finishUndo();
-       bv->text->status(bv, LyXText::NEED_MORE_REFRESH);
-       return result;
+       return true;
 }
 
 
-void finishUndo()
+// Returns false if no undo possible.
+bool textUndoOrRedo(BufferView * bv,
+       limited_stack<Undo> & stack,
+       limited_stack<Undo> & otherstack)
 {
-       // makes sure the next operation will be stored
-       undo_finished = true;
+       if (stack.empty()) {
+               /*
+                * Finish the undo operation in the case there was no entry
+                * on the stack to perform.
+                */
+               freezeUndo();
+               bv->unlockInset(bv->theLockingInset());
+               finishUndo();
+               unFreezeUndo();
+               return false;
+       }
+
+       Undo undo = stack.top();
+       stack.pop();
+       finishUndo();
+
+       if (!undo_frozen) {
+               otherstack.push(undo);
+               otherstack.top().pars.clear();
+               Buffer * buf = bv->buffer();
+               ParagraphList & plist = buf->paragraphs;
+               if (undo.first_par_offset + undo.last_par_offset <= int(plist.size())) {
+                       ParagraphList::iterator first = plist.begin();
+                       advance(first, undo.first_par_offset);
+                       ParagraphList::iterator last = plist.begin();
+                       advance(last, plist.size() - undo.last_par_offset + 1);
+                       otherstack.top().pars.insert(otherstack.top().pars.begin(), first, last);
+               }
+       }
+
+       // Now we can unlock the inset for safety because the inset
+       // pointer could be changed during the undo-function. Anyway
+       // if needed we have to lock the right inset/position if this
+       // is requested.
+       freezeUndo();
+       bv->unlockInset(bv->theLockingInset());
+       bool const ret = performUndoOrRedo(bv, undo);
+       unFreezeUndo();
+       return ret;
 }
 
+} // namespace anon
+
 
 void freezeUndo()
 {
-       // this is dangerous and for internal use only
+       // This is dangerous and for internal use only.
        undo_frozen = true;
 }
 
 
 void unFreezeUndo()
 {
-       // this is dangerous and for internal use only
+       // This is dangerous and for internal use only.
        undo_frozen = false;
 }
 
 
-void setUndo(BufferView * bv, Undo::undo_kind kind,
-             Paragraph const * first, Paragraph const * behind)
+void finishUndo()
 {
-       if (!undo_frozen) {
-               bv->buffer()->undostack.push(createUndo(bv, kind, first, behind));
-               bv->buffer()->redostack.clear();
-       }
+       // Makes sure the next operation will be stored.
+       undo_finished = true;
 }
 
 
-void setRedo(BufferView * bv, Undo::undo_kind kind,
-             Paragraph const * first, Paragraph const * behind)
+bool textUndo(BufferView * bv)
 {
-       bv->buffer()->redostack.push(createUndo(bv, kind, first, behind));
+       return textUndoOrRedo(bv, bv->buffer()->undostack,
+                             bv->buffer()->redostack);
 }
 
 
-Undo * createUndo(BufferView * bv, Undo::undo_kind kind,
-                  Paragraph const * first, Paragraph const * behind)
+bool textRedo(BufferView * bv)
 {
-       lyx::Assert(first);
-
-       int before_number = -1;
-       int behind_number = -1;
-       int inset_id = -1;
-
-       if (first->previous())
-               before_number = first->previous()->id();
-       if (behind)
-               behind_number = behind->id();
-       if (first->inInset())
-               inset_id = first->inInset()->id();
-
-       // Undo::EDIT  and Undo::FINISH are
-       // always finished. (no overlapping there)
-       // overlapping only with insert and delete inside one paragraph: 
-       // Nobody wants all removed  character
-       // 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)) {
-               // check wether storing is needed
-               if (!bv->buffer()->undostack.empty() && 
-                   bv->buffer()->undostack.top()->kind == kind &&
-                   bv->buffer()->undostack.top()->number_of_before_par == before_number &&
-                   bv->buffer()->undostack.top()->number_of_behind_par == behind_number) {
-                       // no undo needed
-                       return 0;
-               }
-       }
-       // create a new Undo
-       Paragraph * undopar;
-
-       Paragraph * start = const_cast<Paragraph *>(first);
-       Paragraph * end = 0;
-
-       if (behind)
-               end = const_cast<Paragraph*>(behind->previous());
-       else {
-               end = start;
-               while (end->next())
-                       end = end->next();
-       }
-       if (start && end && (start != end->next()) &&
-           ((before_number != behind_number) ||
-                ((before_number < 0) && (behind_number < 0))))
-       {
-               Paragraph * tmppar = start;
-               Paragraph * tmppar2 = new Paragraph(*tmppar, true);
-               
-               // a memory optimization: Just store the layout information
-               // when only edit
-               if (kind == Undo::EDIT) {
-                       tmppar2->clearContents();
-               }
-
-               undopar = tmppar2;
-  
-               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);
-       } else
-               undopar = 0; // nothing to replace (undo of delete maybe)
-
-       int cursor_par = undoCursor(bv).par()->id();
-       int cursor_pos =  undoCursor(bv).pos();
-       
-       Undo * undo = new Undo(kind, inset_id,
-                              before_number, behind_number,  
-                              cursor_par, cursor_pos, undopar);
-  
-       undo_finished = false;
-       return undo;
+       return textUndoOrRedo(bv, bv->buffer()->redostack,
+                             bv->buffer()->undostack);
 }
 
 
-void setCursorParUndo(BufferView * bv)
+void recordUndo(BufferView * bv, Undo::undo_kind kind,
+            ParagraphList::iterator first, ParagraphList::iterator last)
 {
-       setUndo(bv, Undo::FINISH, bv->text->cursor.par(),
-               bv->text->cursor.par()->next());
+       if (!undo_frozen) {
+               recordUndo(bv, kind, first, last, bv->buffer()->undostack);
+               bv->buffer()->redostack.clear();
+       }
 }
 
 
-Paragraph * firstUndoParagraph(BufferView * bv, int inset_id)
+void recordUndo(BufferView * bv, Undo::undo_kind kind,
+            ParagraphList::iterator first)
 {
-       Inset * inset = bv->buffer()->getInsetFromID(inset_id);
-       if (inset) {
-               Paragraph * result = inset->getFirstParagraph(0);
-               if (result)
-                       return result;
-       }
-       return bv->text->ownerParagraph();
+       recordUndo(bv, kind, first, first);
 }
 
 
-LyXCursor const & undoCursor(BufferView * bv)
+void recordUndo(BufferView * bv, Undo::undo_kind kind)
 {
-       if (bv->theLockingInset())
-               return bv->theLockingInset()->cursor(bv);
-       return bv->text->cursor;
+       recordUndo(bv, kind, bv->text->cursor.par());
 }
+