#include "debug.h"
#include "lyxtext.h"
-#include "lyxrow.h"
#include "paragraph.h"
-#include "mathed/math_data.h"
-#include "mathed/math_inset.h"
+#include "mathed/MathData.h"
+#include "mathed/InsetMath.h"
+
+#include "insets/insettabular.h"
#include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+
+
+namespace lyx {
using std::endl;
// We could be able to get rid of this if only every BufferView were
// associated to a buffer on construction.
DocIterator::DocIterator()
- : inset_(0)
+ : boundary_(false), inset_(0)
{}
DocIterator::DocIterator(InsetBase & inset)
- : inset_(&inset)
+ : boundary_(false), inset_(&inset)
{}
if (pos() == 0)
return 0;
if (inMathed())
- return prevAtom().nucleus();
+ if (cell().empty())
+ // FIXME: this should not happen but it does.
+ // See bug 3189
+ // http://bugzilla.lyx.org/show_bug.cgi?id=3189
+ return 0;
+ else
+ return prevAtom().nucleus();
return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
}
if (pos() == 0)
return 0;
if (inMathed())
- return prevAtom().nucleus();
+ if (cell().empty())
+ // FIXME: this should not happen but it does.
+ // See bug 3189
+ // http://bugzilla.lyx.org/show_bug.cgi?id=3189
+ return 0;
+ else
+ return prevAtom().nucleus();
return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
}
+InsetBase * DocIterator::realInset() const
+{
+ BOOST_ASSERT(inTexted());
+ // if we are in a tabular, we need the cell
+ if (inset().lyxCode() == InsetBase::TABULAR_CODE) {
+ InsetTabular & tabular = static_cast<InsetTabular&>(inset());
+ return tabular.cell(idx()).get();
+ }
+ return &inset();
+}
+
+
MathAtom const & DocIterator::prevAtom() const
{
BOOST_ASSERT(!empty());
Paragraph & DocIterator::paragraph()
{
- if (!inTexted())
+ if (!inTexted())
lyxerr << *this << endl;
BOOST_ASSERT(inTexted());
return top().paragraph();
}
-Row & DocIterator::textRow()
-{
- BOOST_ASSERT(!paragraph().rows().empty());
- return paragraph().getRow(pos());
-}
-
-
-Row const & DocIterator::textRow() const
-{
- BOOST_ASSERT(!paragraph().rows().empty());
- return paragraph().getRow(pos());
-}
-
-
-DocIterator::pit_type DocIterator::lastpit() const
+pit_type DocIterator::lastpit() const
{
return inMathed() ? 0 : text()->paragraphs().size() - 1;
}
-DocIterator::pos_type DocIterator::lastpos() const
+pos_type DocIterator::lastpos() const
{
return inMathed() ? cell().size() : paragraph().size();
}
}
-bool DocIterator::inMathed() const
-{
- return !empty() && inset().inMathed();
-}
-
-
-bool DocIterator::inTexted() const
-{
- return !empty() && !inset().inMathed();
-}
-
-
LyXText * DocIterator::innerText()
{
BOOST_ASSERT(!empty());
}
-void DocIterator::forwardPos()
+void DocIterator::forwardPos(bool ignorecollapsed)
{
//this dog bites his tail
if (empty()) {
return;
}
+ InsetBase * 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() != InsetBase::HIGHLY_EDITABLE)) {
+ ++top().pos();
+ return;
+ }
+
CursorSlice & tip = top();
//lyxerr << "XXX\n" << *this << endl;
}
//lyxerr << "... no next idx" << endl;
- // otherwise we can't move on
+ // otherwise leave inset and jump over inset as a whole
+ pop_back();
+ // 'top' is invalid now...
+ if (!empty())
+ ++top().pos();
}
void DocIterator::forwardPar()
{
forwardPos();
- while (!empty() && (!inTexted() || pos() != 0))
+
+ while (!empty() && (!inTexted() || pos() != 0)) {
+ if (inTexted()) {
+ pos_type const lastp = lastpos();
+ Paragraph const & par = paragraph();
+ pos_type & pos = top().pos();
+ if (par.insetlist.empty())
+ pos = lastp;
+ else
+ while (pos < lastp && !par.isInset(pos))
+ ++pos;
+ }
forwardPos();
+ }
}
void DocIterator::forwardInset()
{
forwardPos();
- while (!empty() && (pos() == lastpos() || nextInset() == 0))
+
+ while (!empty() && !nextInset()) {
+ if (inTexted()) {
+ pos_type const lastp = lastpos();
+ Paragraph const & par = paragraph();
+ pos_type & pos = top().pos();
+ while (pos < lastp && !par.isInset(pos))
+ ++pos;
+ if (pos < lastp)
+ break;
+ }
forwardPos();
+ }
}
}
+void DocIterator::updateInsets(InsetBase * inset)
+{
+ // this function re-creates the cache of inset pointers.
+ // code taken in part from StableDocIterator::asDocIterator.
+ //lyxerr << "converting:\n" << *this << endl;
+ DocIterator dit = DocIterator(*inset);
+ size_t const n = slices_.size();
+ for (size_t i = 0 ; i < n; ++i) {
+ BOOST_ASSERT(inset);
+ dit.push_back(slices_[i]);
+ dit.top().inset_ = inset;
+ if (i + 1 != n)
+ inset = dit.nextInset();
+ }
+ //lyxerr << "converted:\n" << *this << endl;
+ operator=(dit);
+}
+
+
std::ostream & operator<<(std::ostream & os, DocIterator const & dit)
{
for (size_t i = 0, n = dit.depth(); i != n; ++i)
os << " " << dit.data_[i] << "\n";
return os;
}
+
+
+bool operator==(StableDocIterator const & dit1, StableDocIterator const & dit2)
+{
+ return dit1.data_ == dit2.data_;
+}
+
+
+} // namespace lyx