Fix broken left movement (and some other things using prevInset())

[lyx.git] / src / mathed / math_cursor.C

diff --git a/src/mathed/math_cursor.C b/src/mathed/math_cursor.C
index c788404cd40a3b98b3c7397955519823d356c2b2..ace2f1228954417531070986fce3b4259629c3b5 100644 (file)
--- a/src/mathed/math_cursor.C
+++ b/src/mathed/math_cursor.C
@@ -30,12 +30,14 @@
 #include "formulabase.h"
 #include "math_cursor.h"
 #include "math_arrayinset.h"
+#include "math_bigopinset.h"
 #include "math_symbolinset.h"
 #include "math_decorationinset.h"
 #include "math_deliminset.h"
 #include "math_dotsinset.h"
 #include "math_fracinset.h"
 #include "math_funcinset.h"
+#include "math_funcliminset.h"
 #include "math_gridinset.h"
 #include "math_macro.h"
 #include "math_macroarg.h"
@@ -179,23 +181,27 @@ void MathCursor::dump(char const * what) const
 }
 
 
-void MathCursor::seldump(char const *) const
+void MathCursor::seldump(char const * str) const
 {
        //lyxerr << "SEL: " << str << ": '" << theSelection << "'\n";
        //dump("   Pos");
        return;
 
-       //lyxerr << "\n\n\\n=================vvvvvvvvvvvvv=======================   "
-       //      <<  str << "\ntheSelection: " << theSelection;
-       //for (unsigned int i = 0; i < Cursor_.size(); ++i) 
-       //      lyxerr << Cursor_[i].par_ << "\n'" << Cursor_[i].cell() << "'\n";
+       lyxerr << "\n\n\n=================vvvvvvvvvvvvv=======================   "
+               <<  str << "\ntheSelection: " << selection_
+               << " '" << theSelection.glue() << "'\n";
+       for (unsigned int i = 0; i < Cursor_.size(); ++i) 
+               lyxerr << Cursor_[i].par_ << "\n'" << Cursor_[i].cell() << "'\n";
+       lyxerr << "\n";
+       for (unsigned int i = 0; i < Anchor_.size(); ++i) 
+               lyxerr << Anchor_[i].par_ << "\n'" << Anchor_[i].cell() << "'\n";
        //lyxerr << "\ncursor.pos_: " << cursor().pos_;
        //lyxerr << "\nanchor.pos_: " << anchor().pos_;
-       //lyxerr << "\n===================^^^^^^^^^^^^=====================\n\n\n";
+       lyxerr << "\n===================^^^^^^^^^^^^=====================\n\n\n";
 }
 
 
-bool MathCursor::isInside(MathInset * p) const
+bool MathCursor::isInside(MathInset const * p) const
 {
        for (unsigned i = 0; i < Cursor_.size(); ++i) 
                if (parInset(i) == p) 
@@ -208,6 +214,7 @@ bool MathCursor::openable(MathInset * p, bool sel, bool useupdown) const
 {
        if (!p)
                return false;
+
        if (!(p->isActive() || (useupdown && p->isScriptInset())))
                return false;
 
@@ -222,9 +229,15 @@ bool MathCursor::openable(MathInset * p, bool sel, bool useupdown) const
 }
 
 
-bool MathCursor::plainLeft()
+void MathCursor::plainLeft()
+{
+       --cursor().pos_;
+}
+
+
+void MathCursor::plainRight()
 {
-       return array().prev(cursor().pos_);
+       ++cursor().pos_;
 }
 
 
@@ -249,8 +262,10 @@ bool MathCursor::left(bool sel)
                push(p, false);
                return true;
        } 
-       if (plainLeft())
+       if (cursor().pos_) {
+               plainLeft();
                return true;
+       }
        if (cursor().par_->idxLeft(cursor().idx_, cursor().pos_))
                return true;
        if (pop())
@@ -259,12 +274,6 @@ bool MathCursor::left(bool sel)
 }
 
 
-bool MathCursor::plainRight()
-{
-       return array().next(cursor().pos_);
-}
-
-
 bool MathCursor::right(bool sel)
 {
        dump("Right 1");
@@ -280,28 +289,32 @@ bool MathCursor::right(bool sel)
                push(p, true);
                return true;
        }
-       if (array().next(cursor().pos_))
+       if (cursor().pos_ != array().size()) {
+               plainRight();
+               return true;
+       }
+       if (cursor().par_->idxRight(cursor().idx_, cursor().pos_)) {
                return true;
-       if (cursor().par_->idxRight(cursor().idx_, cursor().pos_))
+       }
+       if (pop()) {
+               plainRight();
                return true;
-       if (!pop())
-               return false;
-       array().next(cursor().pos_);
-       return true;
+       }
+       return false;
 }
 
 
 void MathCursor::first()
 {
        Cursor_.clear();
-       push(formula_->par(), true);
+       push(outerPar(), true);
 }
 
 
 void MathCursor::last()
 {
        Cursor_.clear();
-       push(formula_->par(), false);
+       push(outerPar(), false);
 }
 
 
@@ -314,7 +327,7 @@ void MathCursor::setPos(int x, int y)
        lastcode_ = LM_TC_MIN;
        first();
 
-       cursor().par_  = formula()->par();
+       cursor().par_  = outerPar();
 
        while (1) {
                cursor().idx_ = -1;
@@ -370,7 +383,7 @@ void MathCursor::end()
        clearLastCode();
        if (!cursor().par_->idxEnd(cursor().idx_, cursor().pos_)) {
                pop();
-               array().next(cursor().pos_);
+               ++cursor().pos_;
        }
        dump("end 2");
 }
@@ -403,7 +416,7 @@ void MathCursor::insert(char c, MathTextCodes t)
        }
 
        array().insert(cursor().pos_, c, t);
-       array().next(cursor().pos_);
+       plainRight();
 }
 
 
@@ -419,7 +432,7 @@ void MathCursor::insert(MathInset * p)
        }
 
        array().insert(cursor().pos_, p);
-       array().next(cursor().pos_);
+       plainRight();
 }
 
 
@@ -446,7 +459,7 @@ void MathCursor::erase()
        }
 
        // delete empty cells if necessary
-       if (cursor().pos_ == 0 && array().size() == 0) {
+       if (cursor().pos_ == 0 && array().empty()) {
                bool popit;
                bool removeit;
                cursor().par_->idxDelete(cursor().idx_, popit, removeit);
@@ -586,9 +599,9 @@ bool MathCursor::down(bool sel)
 
 bool MathCursor::toggleLimits()
 {
-       if (!prevIsInset())
-               return false;
        MathScriptInset * p = prevScriptInset();
+       if (!p)
+               return false;
        int old = p->limits();
        p->limits(old < 0 ? 1 : -1);
        return old != p->limits();
@@ -670,9 +683,15 @@ void MathCursor::interpret(string const & s)
                        p = new MathFuncInset(s);
        } else {
                switch (l->token) {
-                       case LM_TK_SYM: 
-                       case LM_TK_BIGSYM: 
+                       case LM_TK_BIGSYM:
+                               p = new MathBigopInset(l);
+                               break;
+
                        case LM_TK_FUNCLIM:
+                               p = new MathFuncLimInset(l);
+                               break;
+
+                       case LM_TK_SYM: 
                                p = new MathSymbolInset(l);
                                break;
 
@@ -711,15 +730,12 @@ void MathCursor::interpret(string const & s)
        }
 
        if (p) {
-               bool oldsel = selection_;
-               if (oldsel) 
-                       selCut();
+               selCut();
                insert(p);
                if (p->nargs()) {
                        plainLeft();
                        right();  // do not push for e.g. MathSymbolInset
-                       if (oldsel) 
-                               selPaste();
+                       selPaste();
                }
                p->metrics(p->size());
        }
@@ -731,7 +747,7 @@ void MathCursor::macroModeOpen()
        if (!imacro_) {
                imacro_ = new MathFuncInset("");
                array().insert(cursor().pos_, imacro_);
-               array().next(cursor().pos_);
+               ++cursor().pos_;
                //insert(imacro_);
        } else
                lyxerr << "Math Warning: Already in macro mode" << endl;
@@ -767,6 +783,8 @@ void MathCursor::selCut()
                theSelection.grab(*this);
                theSelection.erase(*this);
                selClear();
+       } else {
+               theSelection.clear();
        }
 }
 
@@ -791,10 +809,12 @@ void MathCursor::selPaste()
 
 void MathCursor::selHandle(bool sel)
 {
-       if (sel && !selection_)
-               selStart();
-       if (!sel && selection_)
-               selClear();
+       if (sel == selection_)
+               return;
+
+       theSelection.clear();
+       Anchor_    = Cursor_;
+       selection_ = sel;
 }
 
 
@@ -804,6 +824,7 @@ void MathCursor::selStart()
        if (selection_)
                return;
 
+       theSelection.clear();
        Anchor_ = Cursor_;
        selection_ = true;
 }
@@ -811,6 +832,7 @@ void MathCursor::selStart()
 
 void MathCursor::selClear()
 {
+       seldump("selClear");
        selection_ = false;
 }
 
@@ -856,8 +878,8 @@ void MathCursor::handleFont(MathTextCodes t)
                getSelection(i1, i2); 
                if (i1.idx_ == i2.idx_) {
                        MathArray & ar = i1.cell();
-                       for (int pos = i1.pos_; pos != i2.pos_; ar.next(pos))
-                               if (!ar.isInset(pos) && isalnum(ar.getChar(pos))) { 
+                       for (int pos = i1.pos_; pos != i2.pos_; ++pos)
+                               if (isalnum(ar.getChar(pos))) { 
                                        MathTextCodes c = ar.getCode(pos) == t ? LM_TC_VAR : t;
                                        ar.setCode(pos, c);
                                }
@@ -1048,10 +1070,10 @@ string MathCursorPos::readString()
 MathInset * MathCursor::prevInset() const
 {
        normalize();
-       int c = cursor().pos_;
-       if (!array().prev(c))
+       int pos = cursor().pos_;
+       if (!pos)
                return 0;
-       return array().nextInset(c);
+       return array().nextInset(pos - 1);
 }
 
 
@@ -1065,7 +1087,7 @@ MathInset * MathCursor::nextInset() const
 MathScriptInset * MathCursor::prevScriptInset() const
 {
        normalize();
-       MathInset * p = array().prevInset(cursor().pos_);
+       MathInset * p = prevInset();
        return (p && p->isScriptInset()) ? static_cast<MathScriptInset *>(p) : 0;
 }
 
@@ -1073,7 +1095,7 @@ MathScriptInset * MathCursor::prevScriptInset() const
 MathSpaceInset * MathCursor::prevSpaceInset() const
 {
        normalize();
-       MathInset * p = array().prevInset(cursor().pos_);
+       MathInset * p = prevInset();
        return (p && p->isSpaceInset()) ? static_cast<MathSpaceInset *>(p) : 0;
 }
 
@@ -1101,18 +1123,6 @@ MathXArray & MathCursor::xarray() const
 }
 
 
-bool MathCursor::nextIsInset() const
-{
-       return cursor().pos_ < array().size() && MathIsInset(nextCode());
-}
-
-
-bool MathCursor::prevIsInset() const
-{
-       return cursor().pos_ > 0 && MathIsInset(prevCode());
-}
-
-
 int MathCursor::xpos() const 
 {
        normalize();
@@ -1153,7 +1163,7 @@ void MathCursor::splitCell()
 
 void MathCursor::breakLine()
 {
-       MathMatrixInset * p = static_cast<MathMatrixInset *>(formula()->par());
+       MathMatrixInset * p = outerPar();
        if (p->getType() == LM_OT_SIMPLE || p->getType() == LM_OT_EQUATION) {
                p->mutate(LM_OT_EQNARRAY);
                p->addRow(0);
@@ -1284,7 +1294,7 @@ MathCursorPos MathCursor::normalAnchor() const
        MathCursorPos normal = Anchor_[Cursor_.size() - 1];
        if (Cursor_.size() < Anchor_.size() && !(normal < cursor())) {
                // anchor is behind cursor -> move anchor behind the inset
-               normal.cell().next(normal.pos_);
+               ++normal.pos_;
        }
        //lyxerr << "normalizing: from " << Anchor_[Anchor_.size() - 1] << " to "
        //      << normal << "\n";
@@ -1314,3 +1324,10 @@ bool MathCursorPos::idxRight()
 {
        return par_->idxRight(idx_, pos_);
 }
+
+
+MathMatrixInset * MathCursor::outerPar() const
+{
+       return
+               static_cast<MathMatrixInset *>(const_cast<MathInset *>(formula_->par()));
+}