#include "paragraph.h"
#include "mathed/math_support.h"
+#include "insets/updatableinset.h"
#include <algorithm>
-using lyx::par_type;
+using lyx::pit_type;
using std::advance;
using std::endl;
void recordUndo(Undo::undo_kind kind,
- DocIterator & cell,
- par_type first_par, par_type last_par,
+ DocIterator & cell,
+ pit_type first_pit, pit_type last_pit,
DocIterator & cur,
limited_stack<Undo> & stack)
{
- if (first_par > last_par)
- std::swap(first_par, last_par);
-
+ if (first_pit > last_pit)
+ std::swap(first_pit, last_pit);
// create the position information of the Undo entry
Undo undo;
undo.kind = kind;
lyxerr << "recordUndo: cur: " << cur << endl;
lyxerr << "recordUndo: pos: " << cur.pos() << endl;
//lyxerr << "recordUndo: cell: " << cell << endl;
- undo.from = first_par;
- undo.end = cell.lastpar() - last_par;
+ undo.from = first_pit;
+ undo.end = cell.lastpit() - last_pit;
// Undo::ATOMIC are always recorded (no overlapping there).
// As nobody wants all removed character appear one by one when undoing,
BOOST_ASSERT(text);
ParagraphList & plist = text->paragraphs();
ParagraphList::iterator first = plist.begin();
- advance(first, first_par);
+ advance(first, first_pit);
ParagraphList::iterator last = plist.begin();
- advance(last, last_par + 1);
+ advance(last, last_pit + 1);
undo.pars = ParagraphList(first, last);
}
undo_finished = false;
}
+
void recordUndo(Undo::undo_kind kind,
- LCursor & cur, par_type first_par, par_type last_par,
+ LCursor & cur, pit_type first_pit, pit_type last_pit,
limited_stack<Undo> & stack)
{
- BOOST_ASSERT(first_par <= cur.lastpar());
- BOOST_ASSERT(last_par <= cur.lastpar());
+ BOOST_ASSERT(first_pit <= cur.lastpit());
+ BOOST_ASSERT(last_pit <= cur.lastpit());
- recordUndo(kind, cur, first_par, last_par, cur, stack);
+ recordUndo(kind, cur, first_pit, last_pit, cur, stack);
}
// re-insert old stuff instead
first = plist.begin();
advance(first, undo.from);
+
+ // this ugly stuff is needed until we get rid of the
+ // inset_owner backpointer
+ ParagraphList::const_iterator pit = undo.pars.begin();
+ ParagraphList::const_iterator end = undo.pars.end();
+ for (; pit != end; ++pit)
+ const_cast<Paragraph &>(*pit).setInsetOwner(dynamic_cast<UpdatableInset *>(&dit.inset()));
plist.insert(first, undo.pars.begin(), undo.pars.end());
}
bool textUndoOrRedo(BufferView & bv,
limited_stack<Undo> & stack, limited_stack<Undo> & otherstack)
{
+ finishUndo();
+
if (stack.empty()) {
// Nothing to do.
- finishUndo();
return false;
}
- //
// Adjust undo stack and get hold of current undo data.
- //
Undo undo = stack.top();
stack.pop();
- finishUndo();
+ // We will store in otherstack the part of the document under 'undo'
+ DocIterator cell_dit = undo.cell.asDocIterator(&bv.buffer()->inset());
- //
- // This implements redo.
- //
-
- // The cursor will be placed at cur_dit after
- // the ongoing undo operation.
- DocIterator cur_dit =
- undo.cursor.asDocIterator(&bv.buffer()->inset());
-
- // This is the place the cursor is currently located.
- LCursor & cur = bv.cursor();
- DocIterator cell_dit = cur;
-
- // If both places have the same depth we stay in the same
- // cell and store paragraphs from this cell. Otherwise we
- // will drop slices from the more nested iterator and
- // create an undo item from a single paragraph of the common
- // ancestor.
- DocIterator ancestor_dit = cur_dit;
- while (ancestor_dit.size() > cur.size())
- ancestor_dit.pop_back();
-
- if (cur_dit.size() == cell_dit.size()) {
- recordUndo(Undo::ATOMIC, cell_dit,
- cell_dit.par(), cur_dit.par(),
- cur_dit, otherstack);
- }
- else {
- recordUndo(Undo::ATOMIC, ancestor_dit,
- ancestor_dit.par(),
- ancestor_dit.par(),
- cur_dit, otherstack);
- }
-
+ recordUndo(Undo::ATOMIC, cell_dit,
+ undo.from, cell_dit.lastpit() - undo.end,
+ bv.cursor(), otherstack);
- //
- // This does the actual undo.
- //
+ // This does the actual undo/redo.
performUndoOrRedo(bv, undo);
return true;
}
void recordUndo(Undo::undo_kind kind,
- LCursor & cur, par_type first, par_type last)
+ LCursor & cur, pit_type first, pit_type last)
{
Buffer * buf = cur.bv().buffer();
recordUndo(kind, cur, first, last, buf->undostack());
void recordUndo(LCursor & cur, Undo::undo_kind kind)
{
- recordUndo(kind, cur, cur.par(), cur.par());
+ recordUndo(kind, cur, cur.pit(), cur.pit());
}
void recordUndoSelection(LCursor & cur, Undo::undo_kind kind)
{
- recordUndo(kind, cur, cur.selBegin().par(), cur.selEnd().par());
+ recordUndo(kind, cur, cur.selBegin().pit(), cur.selEnd().pit());
}
-void recordUndo(LCursor & cur, Undo::undo_kind kind, par_type from)
+void recordUndo(LCursor & cur, Undo::undo_kind kind, pit_type from)
{
- recordUndo(kind, cur, cur.par(), from);
+ recordUndo(kind, cur, cur.pit(), from);
}
void recordUndo(LCursor & cur, Undo::undo_kind kind,
- par_type from, par_type to)
+ pit_type from, pit_type to)
{
recordUndo(kind, cur, from, to);
}
-void recordUndoFullDocument(LCursor &)
+void recordUndoFullDocument(LCursor & cur)
{
- //recordUndo(Undo::ATOMIC,
- // cur, 0, cur.bv().text()->paragraphs().size() - 1);
+ recordUndo(Undo::ATOMIC, cur, 0,
+ cur.bv().text()->paragraphs().size() - 1);
}
projects / lyx.git / blobdiff