X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fundo_funcs.C;h=d8304ed94b6fb16ca4ab3549429612bb341b57ad;hb=98c966c64594611e469313314abd1e59524adb4a;hp=68b6576053d2efb2883bd13281847785af87f2ea;hpb=455a8f6ca259f006c31345bd1049b9570b21e835;p=lyx.git diff --git a/src/undo_funcs.C b/src/undo_funcs.C index 68b6576053..d8304ed94b 100644 --- a/src/undo_funcs.C +++ b/src/undo_funcs.C @@ -1,8 +1,8 @@ /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995-2001 The LyX Team. * * ====================================================== */ @@ -23,11 +23,14 @@ #include "iterators.h" -//#define DELETE_UNUSED_PARAGRAPHS 1 +#define DELETE_UNUSED_PARAGRAPHS 1 #ifdef DELETE_UNUSED_PARAGRAPHS #include #endif +using std::vector; + + /// the flag used by FinishUndo(); bool undo_finished; /// a flag @@ -50,7 +53,7 @@ bool textUndo(BufferView * bv) if (first) { bv->buffer()->redostack.push( createUndo(bv, undo->kind, first, - bv->buffer()->getParFromID(undo->number_of_behind_par))); + bv->buffer()->getParFromID(undo->number_of_behind_par))); } } } @@ -81,7 +84,7 @@ bool textRedo(BufferView * bv) if (first) { bv->buffer()->undostack.push( createUndo(bv, undo->kind, first, - bv->buffer()->getParFromID(undo->number_of_behind_par))); + bv->buffer()->getParFromID(undo->number_of_behind_par))); } } } @@ -102,9 +105,9 @@ bool textHandleUndo(BufferView * bv, Undo * undo) bool result = false; if (undo) { Paragraph * before = - bv->buffer()->getParFromID(undo->number_of_before_par); + bv->buffer()->getParFromID(undo->number_of_before_par); Paragraph * behind = - bv->buffer()->getParFromID(undo->number_of_behind_par); + bv->buffer()->getParFromID(undo->number_of_behind_par); Paragraph * tmppar; Paragraph * tmppar2; Paragraph * tmppar5; @@ -128,8 +131,8 @@ bool textHandleUndo(BufferView * bv, Undo * undo) // replace the paragraphs with the undo informations Paragraph * tmppar3 = undo->par; - undo->par = 0; /* otherwise the undo destructor would - delete the paragraph */ + 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 @@ -140,16 +143,18 @@ 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(); tmppar4->setInsetOwner(in); } } - + // now remove the old text if there is any #ifdef DELETE_UNUSED_PARAGRAPHS - std::vector vvpar; + vector vvpar; #endif if (before != behind || (!behind && !before)) { if (before) @@ -164,9 +169,9 @@ bool textHandleUndo(BufferView * bv, Undo * undo) tmppar = tmppar5; tmppar5 = tmppar5->next(); // a memory optimization for edit: - // Only layout information + // Only layout information // is stored in the undo. So restore - // the text informations. + // the text informations. if (undo->kind == Undo::EDIT) { tmppar2->setContentsFromPar(tmppar); #ifndef DELETE_UNUSED_PARAGRAPHS @@ -176,20 +181,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(), + bv->text->ownerParagraph(firstUndoParagraph(bv, undo->number_of_inset_id)->id(), tmppar3); tmppar3->previous(before); } else { - // Do we really enter here ??? (Jug) + // 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(behind); + bv->text->ownerParagraph(firstUndoParagraph(bv, undo->number_of_inset_id)->id(), + behind); tmppar3 = behind; } } @@ -198,8 +206,8 @@ bool textHandleUndo(BufferView * bv, Undo * undo) if (behind) behind->previous(tmppar4); } - - + + // Set the cursor for redoing if (before) { Inset * it = before->inInset(); @@ -220,19 +228,9 @@ bool textHandleUndo(BufferView * bv, Undo * undo) it = static_cast(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->getLyXText(bv)->cursor, + endpar); + if (tmppar) { it = static_cast(tmppar->inInset()); LyXText * t; if (it) { @@ -243,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) { @@ -265,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::iterator pit = vvpar.begin(); + vector::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 } @@ -309,7 +319,7 @@ void unFreezeUndo() void setUndo(BufferView * bv, Undo::undo_kind kind, - Paragraph const * first, Paragraph const * behind) + Paragraph const * first, Paragraph const * behind) { if (!undo_frozen) { bv->buffer()->undostack.push(createUndo(bv, kind, first, behind)); @@ -319,14 +329,14 @@ void setUndo(BufferView * bv, Undo::undo_kind kind, void setRedo(BufferView * bv, Undo::undo_kind kind, - Paragraph const * first, Paragraph const * behind) + Paragraph const * first, Paragraph const * behind) { bv->buffer()->redostack.push(createUndo(bv, kind, first, behind)); } Undo * createUndo(BufferView * bv, Undo::undo_kind kind, - Paragraph const * first, Paragraph const * behind) + Paragraph const * first, Paragraph const * behind) { lyx::Assert(first); @@ -343,14 +353,14 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind, // Undo::EDIT and Undo::FINISH are // always finished. (no overlapping there) - // overlapping only with insert and delete inside one paragraph: + // overlapping only with insert and delete inside one paragraph: // Nobody wants all removed character - // appear one by one when undoing. + // 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() && + 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) { @@ -377,7 +387,7 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind, { Paragraph * tmppar = start; Paragraph * tmppar2 = new Paragraph(*tmppar, true); - + // a memory optimization: Just store the layout information // when only edit if (kind == Undo::EDIT) { @@ -385,16 +395,22 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind, } 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); @@ -403,11 +419,11 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind, 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); - + before_number, behind_number, + cursor_par, cursor_pos, undopar); + undo_finished = false; return undo; } @@ -416,7 +432,7 @@ Undo * createUndo(BufferView * bv, Undo::undo_kind kind, void setCursorParUndo(BufferView * bv) { setUndo(bv, Undo::FINISH, bv->text->cursor.par(), - bv->text->cursor.par()->next()); + bv->text->cursor.par()->next()); }