#include "Buffer.h"
#include "BufferList.h"
#include "BufferParams.h"
-#include "buffer_funcs.h"
#include "Cursor.h"
#include "CutAndPaste.h"
#include "ErrorList.h"
#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"
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()
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
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();
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,
/// 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_;
+
};
if (first_pit > last_pit)
swap(first_pit, last_pit);
+ pit_type const from = first_pit;
+ pit_type const end = cell.lastpit() - last_pit;
+
+ /* Undo coalescing: if the undo element we want to add only
+ * changes stuff that was already modified by the previous one on
+ * undo stack (in the same group), then skip it. There is nothing
+ * to gain in adding it to the stack. The code below works for
+ * both texted and mathed.
+ */
+ if (!stack.empty()
+ && stack.top().group_id == group_id_
+ && !stack.top().bparams
+ && samePar(stack.top().cell, cell)
+ //&& stack.top().kind == kind // needed?
+ && stack.top().from <= from
+ && stack.top().end >= end) {
+ LYXERR(Debug::UNDO, "Undo coalescing: skip entry");
+ return;
+ }
// Undo::ATOMIC are always recorded (no overlapping there).
// As nobody wants all removed character appear one by one when undoing,
// we want combine 'similar' non-ATOMIC undo recordings to one.
- pit_type from = first_pit;
- pit_type end = cell.lastpit() - last_pit;
if (!undo_finished_
&& kind != ATOMIC_UNDO
&& !stack.empty()
// 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()) {
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_);
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
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<InsetText &>(buffer_.inset()), el);
- LATTEST(el.empty());
+ static_cast<InsetText &>(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
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();
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;
bool Undo::Private::undoRedoAction(CursorData & cur, bool isUndoOperation)
{
+ if (buffer_.isReadonly())
+ return false;
+
undo_finished_ = true;
UndoElementStack & stack = isUndoOperation ? undostack_ : redostack_;