X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fundo_funcs.C;h=d8304ed94b6fb16ca4ab3549429612bb341b57ad;hb=98c966c64594611e469313314abd1e59524adb4a;hp=d8b76866fc884b1fd22e3413474c69227eb7e84d;hpb=7fdf62dd8ed3771d17253822fc1722144ab8b4e5;p=lyx.git diff --git a/src/undo_funcs.C b/src/undo_funcs.C index d8b76866fc..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. * * ====================================================== */ @@ -21,6 +21,16 @@ #include "debug.h" #include "support/LAssert.h" +#include "iterators.h" + +#define DELETE_UNUSED_PARAGRAPHS 1 +#ifdef DELETE_UNUSED_PARAGRAPHS +#include +#endif + +using std::vector; + + /// the flag used by FinishUndo(); bool undo_finished; /// a flag @@ -43,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))); } } } @@ -74,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))); } } } @@ -95,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; @@ -121,17 +131,31 @@ 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 + // 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) { - while (tmppar4->next()) + 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 vvpar; +#endif if (before != behind || (!behind && !before)) { if (before) tmppar5 = before->next(); @@ -139,41 +163,51 @@ bool textHandleUndo(BufferView * bv, Undo * undo) 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 + // 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 tmppar->clearContents(); +#endif tmppar2 = tmppar2->next(); } } } - + // 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) - 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); if (behind) behind->previous(tmppar4); } - - + + // Set the cursor for redoing if (before) { Inset * it = before->inInset(); @@ -187,44 +221,75 @@ 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(tmppar3->inInset()); + UpdatableInset* it = 0; + if (tmppar3) + 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)->redoParagraphs(bv, + it->getLyXText(bv)->cursor, + endpar); + if (tmppar) { it = static_cast(tmppar->inInset()); - it->edit(bv); - it->getLyXText(bv)->setCursorIntern(bv, tmppar, undo->cursor_pos); - it->getLyXText(bv)->updateCounters(bv, it->getLyXText(bv)->cursor.row()); + 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()); + bv->text->cursor.pos()); } else { bv->text->redoParagraphs(bv, bv->text->cursor, endpar); if (tmppar) { LyXText * t; Inset * it = tmppar->inInset(); - if (it) + if (it) { + it->edit(bv); t = it->getLyXText(bv); - else + } 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::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 + } +#endif } finishUndo(); bv->text->status(bv, LyXText::NEED_MORE_REFRESH); @@ -254,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)); @@ -264,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); @@ -288,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) { @@ -322,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) { @@ -330,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); @@ -348,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; } @@ -361,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()); }