+
+void LCursor::markInsert()
+{
+ insert(char(0));
+}
+
+
+void LCursor::markErase()
+{
+ cell().erase(pos());
+}
+
+
+void LCursor::plainInsert(MathAtom const & t)
+{
+ cell().insert(pos(), t);
+ ++pos();
+}
+
+
+void LCursor::insert(string const & str)
+{
+ for_each(str.begin(), str.end(),
+ boost::bind(static_cast<void(LCursor::*)(char)>
+ (&LCursor::insert), this, _1));
+}
+
+
+void LCursor::insert(char c)
+{
+ //lyxerr << "LCursor::insert char '" << c << "'" << endl;
+ BOOST_ASSERT(!empty());
+ if (inMathed()) {
+ lyx::cap::selClearOrDel(*this);
+ insert(new MathCharInset(c));
+ } else {
+ text()->insertChar(*this, c);
+ }
+}
+
+
+void LCursor::insert(MathAtom const & t)
+{
+ //lyxerr << "LCursor::insert MathAtom '" << t << "'" << endl;
+ macroModeClose();
+ lyx::cap::selClearOrDel(*this);
+ plainInsert(t);
+}
+
+
+void LCursor::insert(InsetBase * inset)
+{
+ if (inMathed())
+ insert(MathAtom(inset));
+ else
+ text()->insertInset(*this, inset);
+}
+
+
+void LCursor::niceInsert(string const & t)
+{
+ MathArray ar;
+ asArray(t, ar);
+ if (ar.size() == 1)
+ niceInsert(ar[0]);
+ else
+ insert(ar);
+}
+
+
+void LCursor::niceInsert(MathAtom const & t)
+{
+ macroModeClose();
+ string const safe = lyx::cap::grabAndEraseSelection(*this);
+ plainInsert(t);
+ // enter the new inset and move the contents of the selection if possible
+ if (t->isActive()) {
+ posLeft();
+ // be careful here: don't use 'pushLeft(t)' as this we need to
+ // push the clone, not the original
+ pushLeft(*nextInset());
+ paste(safe);
+ }
+}
+
+
+void LCursor::insert(MathArray const & ar)
+{
+ macroModeClose();
+ if (selection())
+ lyx::cap::eraseSelection(*this);
+ cell().insert(pos(), ar);
+ pos() += ar.size();
+}
+
+
+bool LCursor::backspace()
+{
+ autocorrect() = false;
+
+ if (selection()) {
+ lyx::cap::selDel(*this);
+ return true;
+ }
+
+ if (pos() == 0) {
+ if (inset().nargs() == 1 && depth() == 1 && lastpos() == 0)
+ return false;
+ pullArg();
+ return true;
+ }
+
+ if (inMacroMode()) {
+ MathUnknownInset * p = activeMacro();
+ if (p->name().size() > 1) {
+ p->setName(p->name().substr(0, p->name().size() - 1));
+ return true;
+ }
+ }
+
+ if (pos() != 0 && prevAtom()->nargs() > 0) {
+ // let's require two backspaces for 'big stuff' and
+ // highlight on the first
+ resetAnchor();
+ selection() = true;
+ --pos();
+ } else {
+ --pos();
+ plainErase();
+ }
+ return true;
+}
+
+
+bool LCursor::erase()
+{
+ autocorrect() = false;
+ if (inMacroMode())
+ return true;
+
+ if (selection()) {
+ lyx::cap::selDel(*this);
+ return true;
+ }
+
+ // delete empty cells if possible
+ if (pos() == lastpos() && inset().idxDelete(idx()))
+ return true;
+
+ // special behaviour when in last position of cell
+ if (pos() == lastpos()) {
+ bool one_cell = inset().nargs() == 1;
+ if (one_cell && depth() == 1 && lastpos() == 0)
+ return false;
+ // remove markup
+ if (one_cell)
+ pullArg();
+ else
+ inset().idxGlue(idx());
+ return true;
+ }
+
+ // 'clever' UI hack: only erase large items if previously slected
+ if (pos() != lastpos() && inset().nargs() > 0) {
+ resetAnchor();
+ selection() = true;
+ ++pos();
+ } else {
+ plainErase();
+ }
+
+ return true;
+}
+
+
+bool LCursor::up()
+{
+ macroModeClose();
+ DocIterator save = *this;
+ if (goUpDown(true))
+ return true;
+ setCursor(save);
+ autocorrect() = false;
+ return selection();
+}
+
+
+bool LCursor::down()
+{
+ macroModeClose();
+ DocIterator save = *this;
+ if (goUpDown(false))
+ return true;
+ setCursor(save);
+ autocorrect() = false;
+ return selection();
+}
+
+
+void LCursor::macroModeClose()
+{
+ if (!inMacroMode())
+ return;
+ MathUnknownInset * p = activeMacro();
+ p->finalize();
+ string const s = p->name();
+ --pos();
+ cell().erase(pos());
+
+ // do nothing if the macro name is empty
+ if (s == "\\")
+ return;
+
+ string const name = s.substr(1);
+
+ // prevent entering of recursive macros
+ // FIXME: this is only a weak attempt... only prevents immediate
+ // recursion
+ InsetBase const * macro = innerInsetOfType(InsetBase::MATHMACRO_CODE);
+ if (macro && macro->getInsetName() == name)
+ lyxerr << "can't enter recursive macro" << endl;
+
+ plainInsert(createMathInset(name));
+}
+
+
+string LCursor::macroName()
+{
+ return inMacroMode() ? activeMacro()->name() : string();
+}
+
+
+void LCursor::handleNest(MathAtom const & a, int c)
+{
+ //lyxerr << "LCursor::handleNest: " << c << endl;
+ MathAtom t = a;
+ asArray(lyx::cap::grabAndEraseSelection(*this), t.nucleus()->cell(c));
+ insert(t);
+ posLeft();
+ pushLeft(*nextInset());
+}
+
+
+int LCursor::targetX() const
+{
+ if (x_target() != -1)
+ return x_target();
+ int x = 0;
+ int y = 0;
+ getPos(x, y);
+ return x;
+}
+
+
+void LCursor::setTargetX()
+{
+ // For now this is good enough. A better solution would be to
+ // avoid this rebreak by setting cursorX only after drawing
+ bottom().text()->redoParagraph(bottom().pit());
+ int x;
+ int y;
+ getPos(x, y);
+ x_target_ = x;
+}
+
+
+bool LCursor::inMacroMode() const
+{
+ if (pos() == 0)
+ return false;
+ MathUnknownInset const * p = prevAtom()->asUnknownInset();
+ return p && !p->final();
+}
+
+
+MathUnknownInset * LCursor::activeMacro()
+{
+ return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : 0;
+}
+
+
+void LCursor::pullArg()
+{
+#ifdef WITH_WARNINGS
+#warning Look here
+#endif
+ MathArray ar = cell();
+ if (popLeft() && inMathed()) {
+ plainErase();
+ cell().insert(pos(), ar);
+ resetAnchor();
+ } else {
+ //formula()->mutateToText();
+ }
+}
+
+
+void LCursor::touch()
+{
+#ifdef WITH_WARNINGS
+#warning look here
+#endif
+#if 0
+ DocIterator::const_iterator it = begin();
+ DocIterator::const_iterator et = end();
+ for ( ; it != et; ++it)
+ it->cell().touch();
+#endif
+}
+
+
+void LCursor::normalize()
+{
+ if (idx() >= nargs()) {
+ lyxerr << "this should not really happen - 1: "
+ << idx() << ' ' << nargs()
+ << " in: " << &inset() << endl;
+ }
+ idx() = min(idx(), lastidx());
+
+ if (pos() > lastpos()) {
+ lyxerr << "this should not really happen - 2: "
+ << pos() << ' ' << lastpos() << " in idx: " << idx()
+ << " in atom: '";
+ WriteStream wi(lyxerr, false, true);
+ inset().asMathInset()->write(wi);
+ lyxerr << endl;
+ }
+ pos() = min(pos(), lastpos());
+}
+
+
+bool LCursor::goUpDown(bool up)
+{
+ // Be warned: The 'logic' implemented in this function is highly
+ // fragile. A distance of one pixel or a '<' vs '<=' _really
+ // matters. So fiddle around with it only if you think you know
+ // what you are doing!
+
+ int xo = 0;
+ int yo = 0;
+ getPos(xo, yo);
+
+ // check if we had something else in mind, if not, this is the future goal
+ if (x_target() == -1)
+ x_target() = xo;
+ else
+ xo = x_target();
+
+ // try neigbouring script insets
+ if (!selection()) {
+ // try left
+ if (pos() != 0) {
+ MathScriptInset const * p = prevAtom()->asScriptInset();
+ if (p && p->has(up)) {
+ --pos();
+ push(inset());
+ idx() = up; // the superscript has index 1
+ pos() = lastpos();
+ //lyxerr << "updown: handled by scriptinset to the left" << endl;
+ return true;