X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FUndo.cpp;h=da4d27ca03d457f5172215b0d589c07689952107;hb=654559feb8b4ed357647554b4043b6c631482b4e;hp=31072ba065d2dd61c4609ed850a0b5a8a703f10d;hpb=66e1819ad170bd2fa0096872cd8cd20c123eba59;p=lyx.git diff --git a/src/Undo.cpp b/src/Undo.cpp index 31072ba065..da4d27ca03 100644 --- a/src/Undo.cpp +++ b/src/Undo.cpp @@ -18,6 +18,7 @@ #include "Undo.h" #include "Buffer.h" +#include "BufferList.h" #include "BufferParams.h" #include "buffer_funcs.h" #include "Cursor.h" @@ -40,6 +41,7 @@ #include #include +#include using namespace std; using namespace lyx::support; @@ -74,43 +76,32 @@ struct UndoElement StableDocIterator const & cel, pit_type fro, pit_type en, ParagraphList * pl, MathData * ar, bool lc, size_t gid) : - kind(kin), cur_before(cb), cell(cel), from(fro), end(en), - pars(pl), array(ar), bparams(0), - lyx_clean(lc), group_id(gid), time(current_time()) - { - } + cur_before(cb), cell(cel), from(fro), end(en), + pars(pl), array(ar), bparams(nullptr), + group_id(gid), time(current_time()), kind(kin), lyx_clean(lc) + {} /// UndoElement(CursorData const & cb, BufferParams const & bp, bool lc, size_t gid) : - kind(ATOMIC_UNDO), cur_before(cb), cell(), from(0), end(0), - pars(0), array(0), bparams(new BufferParams(bp)), - lyx_clean(lc), group_id(gid), time(current_time()) - { - } + cur_before(cb), cell(), from(0), end(0), + pars(nullptr), array(nullptr), bparams(new BufferParams(bp)), + group_id(gid), time(current_time()), kind(ATOMIC_UNDO), lyx_clean(lc) + {} /// - UndoElement(UndoElement const & ue) : time(current_time()) - { - kind = ue.kind; - cur_before = ue.cur_before; - cur_after = ue.cur_after; - cell = ue.cell; - from = ue.from; - end = ue.end; - pars = ue.pars; - array = ue.array; - bparams = ue.bparams - ? new BufferParams(*ue.bparams) : 0; - lyx_clean = ue.lyx_clean; - group_id = ue.group_id; - } + UndoElement(UndoElement const & ue) : + cur_before(ue.cur_before), cur_after(ue.cur_after), + cell(ue.cell), from(ue.from), end(ue.end), + pars(ue.pars), array(ue.array), + bparams(ue.bparams ? new BufferParams(*ue.bparams) : nullptr), + group_id(ue.group_id), time(current_time()), kind(ue.kind), + lyx_clean(ue.lyx_clean) + {} /// ~UndoElement() { if (bparams) delete bparams; } - /// Which kind of operation are we recording for? - UndoKind kind; /// the position of the cursor before recordUndo CursorData cur_before; /// the position of the cursor at the end of the undo group @@ -127,12 +118,14 @@ struct UndoElement MathData * array; /// Only used in case of params undo BufferParams const * bparams; - /// Was the buffer clean at this point? - bool lyx_clean; /// the element's group id size_t group_id; /// timestamp time_t time; + /// Which kind of operation are we recording for? + UndoKind kind; + /// Was the buffer clean at this point? + bool lyx_clean; private: /// Protect construction UndoElement(); @@ -197,14 +190,14 @@ private: struct Undo::Private { - Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true), - group_id_(0), group_level_(0) {} + Private(Buffer & buffer) : buffer_(buffer), + group_id_(0), group_level_(0), undo_finished_(true) {} // Do one undo/redo step - void doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack, + void doUndoRedoAction(CursorData & cur, UndoElementStack & stack, UndoElementStack & otherStack); // Apply one undo/redo group. Returns false if no undo possible. - bool textUndoOrRedo(CursorData & cur, bool isUndoOperation); + bool undoRedoAction(CursorData & cur, bool isUndoOperation); /// void doRecordUndo(UndoKind kind, @@ -231,15 +224,16 @@ struct Undo::Private /// Redo stack. UndoElementStack redostack_; - /// The flag used by Undo::finishUndo(). - bool undo_finished_; - /// Current group Id. size_t group_id_; /// Current group nesting nevel. size_t group_level_; /// the position of cursor before the group was created CursorData group_cur_before_; + + /// The flag used by Undo::finishUndo(). + bool undo_finished_; + }; @@ -347,7 +341,7 @@ void Undo::Private::doRecordUndo(UndoKind kind, // create the position information of the Undo entry UndoElement undo(kind, group_cur_before_.empty() ? cur_before : group_cur_before_, - cell, from, end, 0, 0, buffer_.isClean(), group_id_); + cell, from, end, nullptr, nullptr, buffer_.isClean(), group_id_); // fill in the real data to be saved if (cell.inMathed()) { @@ -428,7 +422,7 @@ void Undo::Private::recordUndoBufferParams(CursorData const & cur) } -void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack, UndoElementStack & otherstack) +void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack, UndoElementStack & otherstack) { // Adjust undo stack and get hold of current undo data. UndoElement & undo = stack.top(); @@ -470,8 +464,9 @@ void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack, //LYXERR0("undo.array: " << *undo.array); LBUFERR(undo.array); dit.cell().swap(*undo.array); + dit.inset().setBuffer(buffer_); delete undo.array; - undo.array = 0; + undo.array = nullptr; } else { // Some finer machinery is needed here. Text * text = dit.text(); @@ -504,15 +499,15 @@ void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack, ParagraphList::iterator fend = fpit; advance(fend, undo.pars->size()); for (; fpit != fend; ++fpit) - fpit->setBuffer(buffer_); + fpit->setInsetBuffers(buffer_); delete undo.pars; - undo.pars = 0; + undo.pars = nullptr; } // We'll clean up in release mode. - LASSERT(undo.pars == 0, undo.pars = 0); - LASSERT(undo.array == 0, undo.array = 0); + LASSERT(undo.pars == nullptr, undo.pars = nullptr); + LASSERT(undo.array == nullptr, undo.array = nullptr); if (!undo.cur_before.empty()) cur = undo.cur_before; @@ -525,7 +520,7 @@ void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack, } -bool Undo::Private::textUndoOrRedo(CursorData & cur, bool isUndoOperation) +bool Undo::Private::undoRedoAction(CursorData & cur, bool isUndoOperation) { undo_finished_ = true; @@ -539,7 +534,7 @@ bool Undo::Private::textUndoOrRedo(CursorData & cur, bool isUndoOperation) const size_t gid = stack.top().group_id; while (!stack.empty() && stack.top().group_id == gid) - doTextUndoOrRedo(cur, stack, otherstack); + doUndoRedoAction(cur, stack, otherstack); return true; } @@ -551,15 +546,15 @@ void Undo::finishUndo() } -bool Undo::textUndo(CursorData & cur) +bool Undo::undoAction(CursorData & cur) { - return d->textUndoOrRedo(cur, true); + return d->undoRedoAction(cur, true); } -bool Undo::textRedo(CursorData & cur) +bool Undo::redoAction(CursorData & cur) { - return d->textUndoOrRedo(cur, false); + return d->undoRedoAction(cur, false); } @@ -568,7 +563,8 @@ void Undo::beginUndoGroup() if (d->group_level_ == 0) { // create a new group ++d->group_id_; - LYXERR(Debug::UNDO, "+++++++Creating new group " << d->group_id_); + LYXERR(Debug::UNDO, "+++++++ Creating new group " << d->group_id_ + << " for buffer " << &d->buffer_); } ++d->group_level_; } @@ -592,7 +588,8 @@ void Undo::endUndoGroup() if (d->group_level_ == 0) { // real end of the group d->group_cur_before_ = CursorData(); - LYXERR(Debug::UNDO, "-------End of group " << d->group_id_); + LYXERR(Debug::UNDO, "------- End of group " << d->group_id_ + << " of buffer " << &d->buffer_); } } @@ -605,6 +602,24 @@ void Undo::endUndoGroup(CursorData const & cur_after) } +void Undo::splitUndoGroup(CursorData const & cur) +{ + size_t const level = d->group_level_; + d->group_level_ = 1; + endUndoGroup(cur); + beginUndoGroup(cur); + d->group_level_ = level; +} + + +bool Undo::activeUndoGroup() const +{ + return d->group_level_ > 0 + && !d->undostack_.empty() + && d->undostack_.top().group_id == d->group_id_; +} + + void Undo::recordUndo(CursorData const & cur, UndoKind kind) { d->recordUndo(kind, cur, cur.pit(), cur.pit(), cur); @@ -649,22 +664,32 @@ void Undo::recordUndoFullBuffer(CursorData const & cur) /// UndoGroupHelper class stuff -/** FIXME: handle restarted groups - * It may happen that the buffers are visited in order buffer1, - * buffer2, buffer1. In this case, we want to have only one undo group - * in buffer1. One solution is to replace buffer_ with a set, - * but I am not sure yet how to do it. A use case is - * InsetLabel::updateReferences. - */ +class UndoGroupHelper::Impl { + friend class UndoGroupHelper; + set buffers_; +}; + + +UndoGroupHelper::UndoGroupHelper(Buffer * buf) : d(new UndoGroupHelper::Impl) +{ + resetBuffer(buf); +} + + +UndoGroupHelper::~UndoGroupHelper() +{ + for (Buffer * buf : d->buffers_) + if (theBufferList().isLoaded(buf) || theBufferList().isInternal(buf)) + buf->undo().endUndoGroup(); + delete d; +} + void UndoGroupHelper::resetBuffer(Buffer * buf) { - if (buf == buffer_) - return; - if (buffer_) - buffer_->undo().endUndoGroup(); - buffer_ = buf; - if (buffer_) - buffer_->undo().beginUndoGroup(); + if (buf && d->buffers_.count(buf) == 0) { + d->buffers_.insert(buf); + buf->undo().beginUndoGroup(); + } }