}
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;
if (tip.pos() != lastp) {
// this is impossible for pos() == size()
- if (inMathed()) {
+ 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()) {
}
+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();
// 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));
// 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(InsetMath const * inset) const
{
for (size_t l = 0; l != slices_.size(); ++l) {
if (slices_[l].asInsetMath() == inset)
}
-void DocIterator::cutOff(DocIterator::idx_type above, vector<CursorSlice> & cut)
+void DocIterator::cutOff(int above, vector<CursorSlice> & cut)
{
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);
}
}
-bool operator<(DocIterator const & p, DocIterator const & q)
-{
- size_t depth = 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)