Make Helge happy: no more crash on arrow up/down in math macro

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

diff --git a/src/mathed/math_nestinset.C b/src/mathed/math_nestinset.C
index 4ae1a471bbc98c5382a7cb3d6df81509d0e297ed..79ca87f7799b544ca00724d277bca077742ad453 100644 (file)
--- a/src/mathed/math_nestinset.C
+++ b/src/mathed/math_nestinset.C
@@ -13,6 +13,7 @@
 #include "math_nestinset.h"
 
 #include "math_arrayinset.h"
+#include "math_boxinset.h"
 #include "math_braceinset.h"
 #include "math_commentinset.h"
 #include "math_data.h"
@@ -21,7 +22,7 @@
 #include "math_hullinset.h"
 #include "math_mathmlstream.h"
 #include "math_macroarg.h"
-#include "math_mboxinset.h"
+//#include "math_mboxinset.h"
 #include "math_parser.h"
 #include "math_scriptinset.h"
 #include "math_spaceinset.h"
@@ -63,18 +64,6 @@ using std::string;
 using std::istringstream;
 
 
-
-namespace {
-
-// local global
-int first_x;
-int first_y;
-
-} // namespace anon
-
-
-
-
 MathNestInset::MathNestInset(idx_type nargs)
        : cells_(nargs), lock_(false)
 {}
@@ -110,23 +99,23 @@ void MathNestInset::getCursorPos(CursorSlice const & sl,
 // absolute again when actually drawing the cursor. What a mess.
        BOOST_ASSERT(ptr_cmp(&sl.inset(), this));
        MathArray const & ar = sl.cell();
-       if (!theCoords.arrays_.has(&ar)) {
-               // this can (semi-)legally happen if we jsut created this cell
+       if (!theCoords.getArrays().has(&ar)) {
+               // this can (semi-)legally happen if we just created this cell
                // and it never has been drawn before. So don't ASSERT.
                //lyxerr << "no cached data for array " << &ar << endl;
                x = 0;
                y = 0;
                return;
        }
-       Point const pt = theCoords.arrays_.xy(&ar);
-       if (!theCoords.insets_.has(this)) {
+       Point const pt = theCoords.getArrays().xy(&ar);
+       if (!theCoords.getInsets().has(this)) {
                // same as above
                //lyxerr << "no cached data for inset " << this << endl;
                x = 0;
                y = 0;
                return;
        }
-       Point const pt2 = theCoords.insets_.xy(this);
+       Point const pt2 = theCoords.getInsets().xy(this);
        //lyxerr << "retrieving position cache for MathArray "
        //      << pt.x_ << ' ' << pt.y_ << std::endl;
        x = pt.x_ - pt2.x_ + ar.pos2x(sl.pos());
@@ -139,6 +128,7 @@ void MathNestInset::getCursorPos(CursorSlice const & sl,
                x += 2;
 }
 
+
 void MathNestInset::metrics(MetricsInfo const & mi) const
 {
        MetricsInfo m = mi;
@@ -506,16 +496,30 @@ void MathNestInset::doDispatch(LCursor & cur, FuncRequest & cmd)
 
        case LFUN_UPSEL:
        case LFUN_UP:
+               // FIXME Tried to use clearTargetX and macroModeClose, crashed on cur.up()
+               if (cur.inMacroMode()) {
+                       // Make Helge happy
+                       cur.macroModeClose();
+                       break;
+               }
                cur.selHandle(cmd.action == LFUN_UPSEL);
                if (!cur.up())
                        cmd = FuncRequest(LFUN_FINISHED_UP);
+               // fixes bug 1598. Please check!
+               cur.normalize();
                break;
 
        case LFUN_DOWNSEL:
        case LFUN_DOWN:
+               if (cur.inMacroMode()) {
+                       cur.macroModeClose();
+                       break;
+               }
                cur.selHandle(cmd.action == LFUN_DOWNSEL);
                if (!cur.down())
                        cmd = FuncRequest(LFUN_FINISHED_DOWN);
+               // fixes bug 1598. Please check!
+               cur.normalize();
                break;
 
        case LFUN_MOUSE_DOUBLE:
@@ -563,7 +567,7 @@ void MathNestInset::doDispatch(LCursor & cur, FuncRequest & cmd)
                cur.clearTargetX();
                if (cur.pos() != cur.lastpos()) {
                        cur.pos() = cur.lastpos();
-               } else if (cur.col() != cur.lastcol()) {
+               } else if (ncols() && (cur.col() != cur.lastcol())) {
                        cur.idx() = cur.idx() - cur.col() + cur.lastcol();
                        cur.pos() = cur.lastpos();
                } else if (cur.idx() != cur.lastidx()) {
@@ -720,7 +724,8 @@ void MathNestInset::doDispatch(LCursor & cur, FuncRequest & cmd)
                        break;
                cur.macroModeClose();
                selClearOrDel(cur);
-               cur.plainInsert(MathAtom(new MathMBoxInset(cur.bv())));
+               //cur.plainInsert(MathAtom(new MathMBoxInset(cur.bv())));
+               cur.plainInsert(MathAtom(new MathBoxInset("mbox")));
                cur.posLeft();
                cur.pushLeft(*cur.nextInset());
 #else
@@ -784,13 +789,13 @@ void MathNestInset::doDispatch(LCursor & cur, FuncRequest & cmd)
                recordUndo(cur, Undo::ATOMIC);
                interpret(cur, '\\');
                break;
-               
+
        case LFUN_SUBSCRIPT:
                // interpret this as if a _ was typed
                recordUndo(cur, Undo::ATOMIC);
                interpret(cur, '_');
                break;
-               
+
        case LFUN_SUPERSCRIPT:
                // interpret this as if a ^ was typed
                recordUndo(cur, Undo::ATOMIC);
@@ -800,10 +805,16 @@ void MathNestInset::doDispatch(LCursor & cur, FuncRequest & cmd)
 // FIXME: We probably should swap parts of "math-insert" and "self-insert"
 // handling such that "self-insert" works on "arbitrary stuff" too, and
 // math-insert only handles special math things like "matrix".
-       case LFUN_INSERT_MATH:
+       case LFUN_INSERT_MATH: {
                recordUndo(cur, Undo::ATOMIC);
-               cur.niceInsert(cmd.argument);
+               MathArray ar;
+               asArray(cmd.argument, ar);
+               if (ar.size() == 1 && (ar[0].nucleus()->asNestInset())) {
+                       cur.handleNest(ar[0]);
+               } else
+                       cur.niceInsert(cmd.argument);
                break;
+               }
 
        case LFUN_DIALOG_SHOW_NEW_INSET: {
                string const & name = cmd.argument;
@@ -952,11 +963,9 @@ InsetBase * MathNestInset::editXY(LCursor & cur, int x, int y) const
 
 void MathNestInset::lfunMousePress(LCursor & cur, FuncRequest & cmd)
 {
-       lyxerr << "lfunMousePress: buttons: " << cmd.button() << endl;
+       //lyxerr << "## lfunMousePress: buttons: " << cmd.button() << endl;
        if (cmd.button() == mouse_button::button1) {
-               first_x = cmd.x;
-               first_y = cmd.y;
-               lyxerr << "lfunMousePress: setting cursor to: " << cur << endl;
+               //lyxerr << "## lfunMousePress: setting cursor to: " << cur << endl;
                cur.resetAnchor();
                cur.bv().cursor() = cur;
        }
@@ -972,22 +981,22 @@ void MathNestInset::lfunMouseMotion(LCursor & cur, FuncRequest & cmd)
        // only select with button 1
        if (cmd.button() == mouse_button::button1) {
                LCursor & bvcur = cur.bv().cursor();
-               if (abs(cmd.x - first_x) + abs(cmd.y - first_y) > 4
-                   && bvcur.anchor_.hasPart(cur)) {
-                       first_x = cmd.x;
-                       first_y = cmd.y;
-
+               if (bvcur.anchor_.hasPart(cur)) {
+                       //lyxerr << "## lfunMouseMotion: cursor: " << cur << endl;
                        bvcur.setCursor(cur);
                        bvcur.selection() = true;
-               } else
+                       //lyxerr << "MOTION " << bvcur << endl;
+               }
+               else {
                        cur.undispatched();
+               }
        }
 }
 
 
 void MathNestInset::lfunMouseRelease(LCursor & cur, FuncRequest & cmd)
 {
-       lyxerr << "lfunMouseRelease: buttons: " << cmd.button() << endl;
+       //lyxerr << "## lfunMouseRelease: buttons: " << cmd.button() << endl;
 
        if (cmd.button() == mouse_button::button1) {
                //cur.bv().stuffClipboard(cur.grabSelection());