#include "DocIterator.h"
-#include "support/debug.h"
#include "InsetList.h"
#include "Paragraph.h"
#include "Text.h"
#include "insets/InsetTabular.h"
+#include "support/debug.h"
+
#include <boost/assert.hpp>
#include <ostream>
+using namespace std;
namespace lyx {
}
if (inMathed())
return nextAtom().nucleus();
- return paragraph().isInset(pos()) ? paragraph().getInset(pos()) : 0;
+ return paragraph().getInset(pos());
}
else
return prevAtom().nucleus();
}
- return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
+ return paragraph().getInset(pos() - 1);
}
}
-void DocIterator::forwardPos(bool ignorecollapsed)
+// This duplicates code above, but is in the critical path.
+// So please think twice before adding stuff
+void DocIterator::forwardPos()
{
- //this dog bites his tail
+ // this dog bites his tail
if (empty()) {
push_back(CursorSlice(*inset_));
return;
}
- Inset * const nextinset = nextInset();
- // jump over collapsables if they are collapsed
- // FIXME: the check for asInsetMath() shouldn't be necessary
- // but math insets do not return a sensible editable() state yet.
- if (ignorecollapsed && nextinset && (!nextinset->asInsetMath()
- && nextinset->editable() != Inset::HIGHLY_EDITABLE)) {
- ++top().pos();
- return;
- }
-
CursorSlice & tip = top();
//lyxerr << "XXX\n" << *this << endl;
- // this is used twice and shows up in the profiler!
- pos_type const lastp = lastpos();
-
- // move into an inset to the right if possible
- Inset * n = 0;
-
- if (tip.pos() != lastp) {
- // this is impossible for pos() == size()
- if (inMathed()) {
+ // not at cell/paragraph end?
+ if (tip.pos() != tip.lastpos()) {
+ // move into an inset to the right if possible
+ Inset * n = 0;
+ if (inMathed())
n = (tip.cell().begin() + tip.pos())->nucleus();
- } else {
- if (paragraph().isInset(tip.pos()))
- n = paragraph().getInset(tip.pos());
+ else
+ n = paragraph().getInset(tip.pos());
+ if (n && n->isActive()) {
+ //lyxerr << "... descend" << endl;
+ push_back(CursorSlice(*n));
+ return;
}
}
- if (n && n->isActive()) {
- //lyxerr << "... descend" << endl;
- push_back(CursorSlice(*n));
- return;
- }
-
+ // jump to the next cell/paragraph if possible
if (!tip.at_end()) {
tip.forwardPos();
return;
}
+
// otherwise leave inset and jump over inset as a whole
pop_back();
// 'tip' is invalid now...
}
+void DocIterator::forwardPosIgnoreCollapsed()
+{
+ Inset * const nextinset = nextInset();
+ // FIXME: the check for asInsetMath() shouldn't be necessary
+ // but math insets do not return a sensible editable() state yet.
+ if (nextinset && !nextinset->asInsetMath()
+ && nextinset->editable() != Inset::HIGHLY_EDITABLE) {
+ ++top().pos();
+ return;
+ }
+ forwardPos();
+}
+
+
void DocIterator::forwardPar()
{
forwardPos();
return;
}
+ // at inset beginning?
if (top().at_begin()) {
pop_back();
return;
top().backwardPos();
+ // entered another cell/paragraph from the right?
+ if (top().pos() == top().lastpos())
+ return;
+
// move into an inset to the left if possible
Inset * n = 0;
-
- if (inMathed()) {
+ if (inMathed())
n = (top().cell().begin() + top().pos())->nucleus();
- } else {
- if (paragraph().isInset(top().pos()))
- n = paragraph().getInset(top().pos());
- }
-
+ else
+ n = paragraph().getInset(top().pos());
if (n && n->isActive()) {
push_back(CursorSlice(*n));
top().idx() = lastidx();
bool DocIterator::fixIfBroken()
{
+ if (empty())
+ return false;
+
// Go through the slice stack from the bottom.
// Check that all coordinates (idx, pit, pos) are correct and
// that the inset is the one which is claimed to be there
// get inset which is supposed to be in the next slice
if (cs.inset().inMathed())
inset = (cs.cell().begin() + cs.pos())->nucleus();
- else if (cs.paragraph().isInset(cs.pos()))
- inset = cs.paragraph().getInset(cs.pos());
+ else if (Inset * csInset = cs.paragraph().getInset(cs.pos()))
+ inset = csInset;
else {
// there are slices left, so there must be another inset
break;
}
-DocIterator::idx_type DocIterator::find(MathData const & cell) const
+int DocIterator::find(MathData const & cell) const
{
for (size_t l = 0; l != slices_.size(); ++l) {
if (slices_[l].asInsetMath() && &slices_[l].cell() == &cell)
}
-DocIterator::idx_type DocIterator::find(InsetMath const * inset) const
+int DocIterator::find(Inset const * inset) const
{
for (size_t l = 0; l != slices_.size(); ++l) {
- if (slices_[l].asInsetMath() == inset)
+ if (&slices_[l].inset() == inset)
return l;
}
return -1;
}
-void DocIterator::cutOff(DocIterator::idx_type above, std::vector<CursorSlice> & cut)
+void DocIterator::cutOff(int above, vector<CursorSlice> & cut)
{
- cut = std::vector<CursorSlice>(slices_.begin() + above + 1, slices_.end());
+ cut = vector<CursorSlice>(slices_.begin() + above + 1, slices_.end());
slices_.resize(above + 1);
}
-void DocIterator::cutOff(DocIterator::idx_type above)
+void DocIterator::cutOff(int above)
{
slices_.resize(above + 1);
}
-void DocIterator::append(std::vector<CursorSlice> const & x)
+void DocIterator::append(vector<CursorSlice> const & x)
{
slices_.insert(slices_.end(), x.begin(), x.end());
}
}
-std::ostream & operator<<(std::ostream & os, DocIterator const & dit)
+ostream & operator<<(ostream & os, DocIterator const & dit)
{
for (size_t i = 0, n = dit.depth(); i != n; ++i)
os << " " << dit[i] << "\n";
}
-bool operator<(DocIterator const & p, DocIterator const & q)
-{
- size_t depth = std::min(p.depth(), q.depth());
- for (size_t i = 0 ; i < depth ; ++i) {
- if (p[i] != q[i])
- return p[i] < q[i];
- }
- return p.depth() < q.depth();
-}
-
-
-bool operator>(DocIterator const & p, DocIterator const & q)
-{
- return q < p;
-}
-
-
-bool operator<=(DocIterator const & p, DocIterator const & q)
-{
- return !(q < p);
-}
-
-
///////////////////////////////////////////////////////
StableDocIterator::StableDocIterator(DocIterator const & dit)
}
-std::ostream & operator<<(std::ostream & os, StableDocIterator const & dit)
+ostream & operator<<(ostream & os, StableDocIterator const & dit)
{
for (size_t i = 0, n = dit.data_.size(); i != n; ++i)
os << " " << dit.data_[i] << "\n";