#include "Buffer.h"
#include "BufferParams.h"
#include "buffer_funcs.h"
-#include "DocIterator.h"
+#include "Cursor.h"
#include "Paragraph.h"
#include "ParagraphList.h"
-#include "ParagraphParameters.h"
#include "Text.h"
#include "mathed/MathSupport.h"
#include "insets/Inset.h"
-#include "support/lassert.h"
#include "support/debug.h"
+#include "support/gettext.h"
+#include "support/lassert.h"
#include <algorithm>
#include <deque>
Obviously, the stored range should be as small as possible. However,
there is a lower limit: The StableDocIterator stored in the undo class
must be valid after the changes, too, as it will used as a pointer
-where to insert the stored bits when performining undo.
+where to insert the stored bits when performining undo.
*/
struct UndoElement
{
///
- UndoElement(UndoKind kin, StableDocIterator const & cb,
+ UndoElement(UndoKind kin, CursorData const & cb,
StableDocIterator const & cel,
- pit_type fro, pit_type en, ParagraphList * pl,
- MathData * ar, BufferParams const & bp,
+ pit_type fro, pit_type en, ParagraphList * pl,
+ MathData * ar, BufferParams const & bp,
bool ifb, bool lc, size_t gid) :
kind(kin), cur_before(cb), cell(cel), from(fro), end(en),
pars(pl), array(ar), bparams(0), isFullBuffer(ifb),
/// Which kind of operation are we recording for?
UndoKind kind;
/// the position of the cursor before recordUndo
- StableDocIterator cur_before;
+ CursorData cur_before;
/// the position of the cursor at the end of the undo group
- StableDocIterator cur_after;
+ CursorData cur_after;
/// the position of the cell described
StableDocIterator cell;
/// counted from begin of cell
size_t group_id;
private:
/// Protect construction
- UndoElement();
+ UndoElement();
};
-class UndoElementStack
+class UndoElementStack
{
public:
/// limit is the maximum size of the stack
/// Push an item on to the stack, deleting the bottom group on
/// overflow.
void push(UndoElement const & v) {
- c_.push_front(v);
- if (c_.size() > limit_) {
+ // Remove some entries if the limit has been reached.
+ // However, if the only group on the stack is the one
+ // we are currently populating, do nothing.
+ if (c_.size() >= limit_
+ && c_.front().group_id != v.group_id) {
// remove a whole group at once.
const size_t gid = c_.back().group_id;
while (!c_.empty() && c_.back().group_id == gid)
c_.pop_back();
}
+ c_.push_front(v);
}
/// Mark all the elements of the stack as dirty
void markDirty() {
for (size_t i = 0; i != c_.size(); ++i)
c_[i].lyx_clean = false;
- }
+ }
private:
/// Internal contents.
struct Undo::Private
{
- Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true),
+ Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true),
group_id(0), group_level(0) {}
-
+
// Do one undo/redo step
- void doTextUndoOrRedo(DocIterator & cur, UndoElementStack & stack,
+ void doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
UndoElementStack & otherStack);
// Apply one undo/redo group. Returns false if no undo possible.
- bool textUndoOrRedo(DocIterator & cur, bool isUndoOperation);
+ bool textUndoOrRedo(CursorData & cur, bool isUndoOperation);
///
void doRecordUndo(UndoKind kind,
DocIterator const & cell,
pit_type first_pit,
pit_type last_pit,
- StableDocIterator const & cur,
+ CursorData const & cur,
bool isFullBuffer,
UndoElementStack & stack);
///
DocIterator const & cell,
pit_type first_pit,
pit_type last_pit,
- DocIterator const & cur,
+ CursorData const & cur,
bool isFullBuffer);
///
d->undostack_.clear();
d->redostack_.clear();
d->undo_finished_ = true;
- d->group_id = 0;
- d->group_level = 0;
+ // We used to do that, but I believe it is better to keep
+ // groups (only used in Buffer::reload for now (JMarc)
+ //d->group_id = 0;
+ //d->group_level = 0;
}
{
d->undo_finished_ = true;
d->undostack_.markDirty();
- d->redostack_.markDirty();
+ d->redostack_.markDirty();
}
void Undo::Private::doRecordUndo(UndoKind kind,
DocIterator const & cell,
pit_type first_pit, pit_type last_pit,
- StableDocIterator const & cur_before,
+ CursorData const & cur_before,
bool isFullBuffer,
UndoElementStack & stack)
{
&& stack.top().from == from
&& stack.top().end == end) {
// reset cur_after; it will be filled correctly by endUndoGroup.
- stack.top().cur_after = StableDocIterator();
+ stack.top().cur_after = CursorData();
return;
}
else
LYXERR(Debug::UNDO, "Create undo element of group " << group_id);
// create the position information of the Undo entry
- UndoElement undo(kind, cur_before, cell, from, end, 0, 0,
+ UndoElement undo(kind, cur_before, cell, from, end, 0, 0,
buffer_.params(), isFullBuffer, buffer_.isClean(), group_id);
// fill in the real data to be saved
// main Text _is_ the whole document.
// record the relevant paragraphs
Text const * text = cell.text();
- LASSERT(text, /**/);
+ LBUFERR(text);
ParagraphList const & plist = text->paragraphs();
ParagraphList::const_iterator first = plist.begin();
advance(first, first_pit);
ParagraphList::const_iterator last = plist.begin();
advance(last, last_pit + 1);
- // If the paragraphs after the last one have a
- // non-zero depth and the depth of last paragraph is
- // decremented, then these paragraphs may be affected
- // (ticket #8159). We guard against that by saving
- // these extra paragraphs.
- while (last != plist.end() && last->params().depth() > 0) {
- ++last;
- --undo.end;
- }
undo.pars = new ParagraphList(first, last);
}
void Undo::Private::recordUndo(UndoKind kind,
DocIterator const & cell,
pit_type first_pit, pit_type last_pit,
- DocIterator const & cur,
+ CursorData const & cur,
bool isFullBuffer)
{
- LASSERT(first_pit <= cell.lastpit(), /**/);
- LASSERT(last_pit <= cell.lastpit(), /**/);
+ LASSERT(first_pit <= cell.lastpit(), return);
+ LASSERT(last_pit <= cell.lastpit(), return);
doRecordUndo(kind, cell, first_pit, last_pit, cur,
isFullBuffer, undostack_);
}
-void Undo::Private::doTextUndoOrRedo(DocIterator & cur, UndoElementStack & stack, UndoElementStack & otherstack)
+void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack, UndoElementStack & otherstack)
{
// Adjust undo stack and get hold of current undo data.
UndoElement & undo = stack.top();
//LYXERR0("undo, performing: " << undo);
DocIterator dit = undo.cell.asDocIterator(&buffer_);
if (undo.isFullBuffer) {
- LASSERT(undo.pars, /**/);
+ LBUFERR(undo.pars);
// This is a full document
delete otherstack.top().bparams;
otherstack.top().bparams = new BufferParams(buffer_.params());
// gained by storing just 'a few' paragraphs (most if not
// all math inset cells have just one paragraph!)
//LYXERR0("undo.array: " << *undo.array);
- LASSERT(undo.array, /**/);
+ LBUFERR(undo.array);
dit.cell().swap(*undo.array);
delete undo.array;
undo.array = 0;
} else {
// Some finer machinery is needed here.
Text * text = dit.text();
- LASSERT(text, /**/);
- LASSERT(undo.pars, /**/);
+ LBUFERR(text);
+ LBUFERR(undo.pars);
ParagraphList & plist = text->paragraphs();
// remove new stuff between first and last
delete undo.pars;
undo.pars = 0;
}
- LASSERT(undo.pars == 0, /**/);
- LASSERT(undo.array == 0, /**/);
- if (undo.cur_before.size())
- cur = undo.cur_before.asDocIterator(&buffer_);
+ // We'll clean up in release mode.
+ LASSERT(undo.pars == 0, undo.pars = 0);
+ LASSERT(undo.array == 0, undo.array = 0);
+
+ if (!undo.cur_before.empty())
+ cur = undo.cur_before;
if (undo.lyx_clean)
buffer_.markClean();
else
}
-bool Undo::Private::textUndoOrRedo(DocIterator & cur, bool isUndoOperation)
+bool Undo::Private::textUndoOrRedo(CursorData & cur, bool isUndoOperation)
{
undo_finished_ = true;
}
-bool Undo::textUndo(DocIterator & cur)
+bool Undo::textUndo(CursorData & cur)
{
return d->textUndoOrRedo(cur, true);
}
-bool Undo::textRedo(DocIterator & cur)
+bool Undo::textRedo(CursorData & cur)
{
return d->textUndoOrRedo(cur, false);
}
void Undo::endUndoGroup()
{
- if (d->group_level == 0)
+ if (d->group_level == 0) {
LYXERR0("There is no undo group to end here");
+ return;
+ }
--d->group_level;
if (d->group_level == 0) {
// real end of the group
}
-void Undo::endUndoGroup(DocIterator const & cur)
+void Undo::endUndoGroup(CursorData const & cur)
{
endUndoGroup();
- if (!d->undostack_.empty() && !d->undostack_.top().cur_after.size())
+ if (!d->undostack_.empty() && d->undostack_.top().cur_after.empty())
d->undostack_.top().cur_after = cur;
}
// Private::recordUndo public as sole interface. The code in the
// convenience functions can move to Cursor.cpp.
-void Undo::recordUndo(DocIterator const & cur, UndoKind kind)
+void Undo::recordUndo(CursorData const & cur, UndoKind kind)
{
d->recordUndo(kind, cur, cur.pit(), cur.pit(), cur, false);
}
-void Undo::recordUndoInset(DocIterator const & cur, UndoKind kind,
+void Undo::recordUndoInset(CursorData const & cur, UndoKind kind,
Inset const * inset)
{
if (!inset || inset == &cur.inset()) {
}
-void Undo::recordUndo(DocIterator const & cur, UndoKind kind, pit_type from)
+void Undo::recordUndo(CursorData const & cur, UndoKind kind, pit_type from)
{
d->recordUndo(kind, cur, cur.pit(), from, cur, false);
}
-void Undo::recordUndo(DocIterator const & cur, UndoKind kind,
+void Undo::recordUndo(CursorData const & cur, UndoKind kind,
pit_type from, pit_type to)
{
d->recordUndo(kind, cur, from, to, cur, false);
}
-void Undo::recordUndoFullDocument(DocIterator const & cur)
+void Undo::recordUndoFullDocument(CursorData const & cur)
{
// This one may happen outside of the main undo group, so we
// put it in its own subgroup to avoid complaints.
beginUndoGroup();
- d->recordUndo(ATOMIC_UNDO, doc_iterator_begin(&d->buffer_),
+ d->recordUndo(ATOMIC_UNDO, doc_iterator_begin(&d->buffer_),
0, d->buffer_.paragraphs().size() - 1, cur, true);
endUndoGroup();
}
projects / lyx.git / blobdiff