* Lazy MathData to avoid unneeded interpretation of macro definitions

[features.git] / src / mathed / InsetMathNest.cpp

diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp
index f2f55151ddad08c29f9c57bcbc1e2032901176c8..00d4e2ac6e0c7759f4e48fd7cd99221dc907f65d 100644 (file)
--- a/src/mathed/InsetMathNest.cpp
+++ b/src/mathed/InsetMathNest.cpp
@@ -38,17 +38,18 @@
 #include "CoordCache.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
-#include "debug.h"
+#include "support/debug.h"
 #include "DispatchResult.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
 #include "LyXFunc.h"
-#include "gettext.h"
+#include "support/gettext.h"
 #include "Text.h"
 #include "OutputParams.h"
 
 #include "support/lstrings.h"
 #include "support/textutils.h"
+#include "support/docstream.h"
 
 #include "frontends/Clipboard.h"
 #include "frontends/Painter.h"
@@ -58,6 +59,8 @@
 
 #include <sstream>
 
+using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 
@@ -67,10 +70,6 @@ using cap::cutSelection;
 using cap::replaceSelection;
 using cap::selClearOrDel;
 
-using std::endl;
-using std::string;
-using std::istringstream;
-
 
 InsetMathNest::InsetMathNest(idx_type nargs)
        : cells_(nargs), lock_(false), mouse_hover_(false)
@@ -131,7 +130,7 @@ void InsetMathNest::cursorPos(BufferView const & bv,
        }
        Point const pt2 = coord_cache.getInsets().xy(this);
        //lyxerr << "retrieving position cache for MathData "
-       //      << pt.x_ << ' ' << pt.y_ << std::endl;
+       //      << pt.x_ << ' ' << pt.y_ << endl;
        x = pt.x_ - pt2.x_ + ar.pos2x(sl.pos());
        y = pt.y_ - pt2.y_;
 //     lyxerr << "pt.y_ : " << pt.y_ << " pt2_.y_ : " << pt2.y_
@@ -245,9 +244,10 @@ void InsetMathNest::drawSelection(PainterInfo & pi, int x, int y) const
                return;
 
        // FIXME: hack to get position cache warm
+       bool const original_drawing_state = pi.pain.isDrawingEnabled();
        pi.pain.setDrawingEnabled(false);
        draw(pi, x, y);
-       pi.pain.setDrawingEnabled(true);
+       pi.pain.setDrawingEnabled(original_drawing_state);
 
        CursorSlice s1 = cur.selBegin();
        CursorSlice s2 = cur.selEnd();
@@ -440,7 +440,7 @@ void InsetMathNest::handleFont2(Cursor & cur, docstring const & arg)
 
 void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-       //lyxerr << "InsetMathNest: request: " << cmd << std::endl;
+       //lyxerr << "InsetMathNest: request: " << cmd << endl;
        //CursorSlice sl = cur.current();
 
        switch (cmd.action) {
@@ -542,26 +542,24 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
        case LFUN_CHAR_RIGHT_SELECT:
                //FIXME: for visual cursor, really move right
                if (reverseDirectionNeeded(cur))
-                       lyx::dispatch(FuncRequest(
-                               cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
-                                       LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD));
+                       cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
+                                       LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
                else 
-                       lyx::dispatch(FuncRequest(
-                               cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
-                                       LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD));
+                       cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
+                                       LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
+               doDispatch(cur, cmd);
                break;
 
        case LFUN_CHAR_LEFT:
        case LFUN_CHAR_LEFT_SELECT:
                //FIXME: for visual cursor, really move left
                if (reverseDirectionNeeded(cur))
-                       lyx::dispatch(FuncRequest(
-                               cmd.action == LFUN_CHAR_LEFT_SELECT ? 
-                                       LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD));
+                       cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? 
+                                       LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
                else 
-                       lyx::dispatch(FuncRequest(
-                               cmd.action == LFUN_CHAR_LEFT_SELECT ? 
-                                       LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD));
+                       cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? 
+                                       LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
+               doDispatch(cur, cmd);
                break;
 
        case LFUN_DOWN:
@@ -726,6 +724,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
                }
                break;
 
+       // 'Locks' the math inset. A 'locked' math inset behaves as a unit
+       // that is traversed by a single <CursorLeft>/<CursorRight>.
        case LFUN_INSET_TOGGLE:
                cur.recordUndo();
                lock(!lock());
@@ -923,7 +923,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 
        case LFUN_MATH_DELIM: {
                docstring ls;
-               docstring rs = support::split(cmd.argument(), ls, ' ');
+               docstring rs = split(cmd.argument(), ls, ' ');
                // Reasonable default values
                if (ls.empty())
                        ls = '(';
@@ -994,12 +994,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
                bool fold = cmd.action == LFUN_MATH_MACRO_FOLD;
                bool found = findMacroToFoldUnfold(it, fold);
                if (found) {
-                       cur.recordUndo();
+                       MathMacro * macro = it.nextInset()->asInsetMath()->asMacro();
+                       cur.recordUndoInset();
                        if (fold)
-                               it.nextInset()->asInsetMath()->asMacro()->fold(cur);
+                               macro->fold(cur);
                        else
-                               it.nextInset()->asInsetMath()->asMacro()->unfold(cur);
-               }\v
+                               macro->unfold(cur);
+               }
                break;
        }
 
@@ -1028,7 +1029,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
                        InsetMathRef tmp(name);
                        data = tmp.createDialogStr(to_utf8(name));
                }
-               cur.bv().showInsetDialog(to_utf8(name), data, 0);
+               cur.bv().showDialog(to_utf8(name), data);
                break;
        }
 
@@ -1189,11 +1190,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
                break;
        }
                
-       case LFUN_HYPHENATION_POINT_INSERT:
-       case LFUN_LIGATURE_BREAK_INSERT:
-       case LFUN_MENU_SEPARATOR_INSERT:
-       case LFUN_DOTS_INSERT:
-       case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
+       case LFUN_SPECIALCHAR_INSERT:
                // FIXME: These would probably make sense in math-text mode
                flag.enabled(false);
                break;