X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FUndo.cpp;h=4e970df5a03cd4a394a9ef00de7798e6f4f01c1b;hb=975f304185eca53d62de8b36e6fc5f95b2da4fd9;hp=28a2e822395abefca4956d3970e079567922f1c1;hpb=714113655ad434f9a73d0101038568d59311af72;p=features.git diff --git a/src/Undo.cpp b/src/Undo.cpp index 28a2e82239..4e970df5a0 100644 --- a/src/Undo.cpp +++ b/src/Undo.cpp @@ -20,7 +20,6 @@ #include "Buffer.h" #include "BufferList.h" #include "BufferParams.h" -#include "buffer_funcs.h" #include "Cursor.h" #include "CutAndPaste.h" #include "ErrorList.h" @@ -28,14 +27,13 @@ #include "ParagraphList.h" #include "Text.h" -#include "mathed/MathSupport.h" +#include "mathed/InsetMath.h" #include "mathed/MathData.h" +#include "mathed/MathRow.h" -#include "insets/Inset.h" #include "insets/InsetText.h" #include "support/debug.h" -#include "support/gettext.h" #include "support/lassert.h" #include "support/lyxtime.h" @@ -76,28 +74,25 @@ 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) : - 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), - time(current_time()) + 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() @@ -105,8 +100,6 @@ struct 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 @@ -123,12 +116,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(); @@ -193,8 +188,8 @@ 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 doUndoRedoAction(CursorData & cur, UndoElementStack & stack, @@ -227,15 +222,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_; + }; @@ -343,7 +339,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()) { @@ -378,6 +374,9 @@ void Undo::Private::recordUndo(UndoKind kind, LASSERT(first_pit <= cell.lastpit(), return); LASSERT(last_pit <= cell.lastpit(), return); + if (buffer_.isReadonly()) + return; + doRecordUndo(kind, cell, first_pit, last_pit, cur, undostack_); @@ -412,6 +411,9 @@ void Undo::Private::doRecordUndoBufferParams(CursorData const & cur_before, void Undo::Private::recordUndoBufferParams(CursorData const & cur) { + if (buffer_.isReadonly()) + return; + doRecordUndoBufferParams(cur, undostack_); // next time we'll try again to combine entries if possible @@ -454,11 +456,8 @@ void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack, otherstack.top().bparams = new BufferParams(buffer_.params()); DocumentClassConstPtr olddc = buffer_.params().documentClassPtr(); buffer_.params() = *undo.bparams; - // The error list is not supposed to be helpful here. - ErrorList el; cap::switchBetweenClasses(olddc, buffer_.params().documentClassPtr(), - static_cast(buffer_.inset()), el); - LATTEST(el.empty()); + static_cast(buffer_.inset())); } else if (dit.inMathed()) { // We stored the full cell here as there is not much to be // gained by storing just 'a few' paragraphs (most if not @@ -468,7 +467,7 @@ void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack, 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,12 +503,12 @@ void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack, 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; @@ -524,6 +523,9 @@ void Undo::Private::doUndoRedoAction(CursorData & cur, UndoElementStack & stack, bool Undo::Private::undoRedoAction(CursorData & cur, bool isUndoOperation) { + if (buffer_.isReadonly()) + return false; + undo_finished_ = true; UndoElementStack & stack = isUndoOperation ? undostack_ : redostack_;