MathData * ar, BufferParams const & bp,
bool ifb) :
kind(kin), cursor(cur), cell(cel), from(fro), end(en),
- pars(pl), array(ar), bparams(bp), isFullBuffer(ifb)
- {}
+ pars(pl), array(ar), bparams(0), isFullBuffer(ifb)
+ {
+ if (isFullBuffer)
+ bparams = new BufferParams(bp);
+ }
+ ///
+ UndoElement(UndoElement const & ue)
+ {
+ kind = ue.kind;
+ cursor = ue.cursor;
+ cell = ue.cell;
+ from = ue.from;
+ end = ue.end;
+ pars = ue.pars;
+ array = ue.array;
+ bparams = ue.isFullBuffer
+ ? new BufferParams(*ue.bparams) : ue.bparams;
+ isFullBuffer = ue.isFullBuffer;
+ }
+ ///
+ ~UndoElement()
+ {
+ if (isFullBuffer)
+ delete bparams;
+ }
/// Which kind of operation are we recording for?
UndoKind kind;
/// the position of the cursor
/// the contents of the saved MathData (for mathed)
MathData * array;
/// Only used in case of full backups
- BufferParams bparams;
+ BufferParams const * bparams;
/// Only used in case of full backups
bool isFullBuffer;
private:
{
if (first_pit > last_pit)
swap(first_pit, last_pit);
- // create the position information of the Undo entry
- UndoElement undo(kind, cur, cell, first_pit, cell.lastpit() - last_pit, 0, 0,
- buffer_.params(), isFullBuffer);
- UndoElementStack & stack = isUndoOperation ? undostack_ : redostack_;
// 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;
+ UndoElementStack & stack = isUndoOperation ? undostack_ : redostack_;
if (!undo_finished_
&& kind != ATOMIC_UNDO
&& !stack.empty()
- && samePar(stack.top().cell, undo.cell)
- && stack.top().kind == undo.kind
- && stack.top().from == undo.from
- && stack.top().end == undo.end)
+ && samePar(stack.top().cell, cell)
+ && stack.top().kind == kind
+ && stack.top().from == from
+ && stack.top().end == end)
return;
+ // create the position information of the Undo entry
+ UndoElement undo(kind, cur, cell, from, end, 0, 0,
+ buffer_.params(), isFullBuffer);
+
// fill in the real data to be saved
if (cell.inMathed()) {
// simply use the whole cell
UndoElementStack & otherstack = isUndoOperation ? redostack_ : undostack_;
// Adjust undo stack and get hold of current undo data.
- UndoElement undo = stack.top();
- stack.pop();
+ UndoElement & undo = stack.top();
+ // We'll pop the stack only when we're done with this element. So do NOT
+ // try to return early.
// We will store in otherstack the part of the document under 'undo'
DocIterator cell_dit = undo.cell.asDocIterator(&buffer_.inset());
if (undo.isFullBuffer) {
LASSERT(undo.pars, /**/);
// This is a full document
- otherstack.top().bparams = buffer_.params();
- buffer_.params() = undo.bparams;
+ delete otherstack.top().bparams;
+ otherstack.top().bparams = new BufferParams(buffer_.params());
+ buffer_.params() = *undo.bparams;
swap(buffer_.paragraphs(), *undo.pars);
delete undo.pars;
undo.pars = 0;
LASSERT(undo.array == 0, /**/);
cur = undo.cursor.asDocIterator(&buffer_.inset());
-
+ // Now that we're done with undo, we pop it off the stack.
+ stack.pop();
+
if (labelsUpdateNeeded)
updateLabels(buffer_);
undo_finished_ = true;