Remove hardcoded values

[lyx.git] / src / Cursor.cpp

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index 8d5c63b55e67c182dc658536df9d3914d28805b6..e2d1f893ae120d986073905fe3ef217c38b02192 100644 (file)
--- a/src/Cursor.cpp
+++ b/src/Cursor.cpp
@@ -15,6 +15,7 @@
 #include <config.h>
 
 #include "Buffer.h"
+#include "BufferParams.h"
 #include "BufferView.h"
 #include "CoordCache.h"
 #include "Cursor.h"
@@ -47,9 +48,11 @@
 
 #include "mathed/InsetMath.h"
 #include "mathed/InsetMathBrace.h"
+#include "mathed/InsetMathEnsureMath.h"
 #include "mathed/InsetMathScript.h"
 #include "mathed/MacroTable.h"
 #include "mathed/MathData.h"
+#include "mathed/MathFactory.h"
 #include "mathed/MathMacro.h"
 
 #include <sstream>
@@ -192,13 +195,37 @@ void Cursor::reset()
 }
 
 
-// this (intentionally) does neither touch anchor nor selection status
 void Cursor::setCursor(DocIterator const & cur)
 {
        DocIterator::operator=(cur);
 }
 
 
+void Cursor::setCursorSelectionTo(DocIterator dit)
+{
+       size_t i = 0;
+       // normalise dit
+       while (i < dit.depth() && i < anchor_.depth() && dit[i] == anchor_[i])
+               ++i;
+       if (i != dit.depth()) {
+               // otherwise the cursor is already normal
+               if (i == anchor_.depth())
+                       // dit is a proper extension of the anchor_
+                       dit.cutOff(i - 1);
+               else if (i + 1 < dit.depth()) {
+                       // one has dit[i] != anchor_[i] but either dit[i-1] == anchor_[i-1]
+                       // or i == 0. Remove excess.
+                       dit.cutOff(i);
+                       if (dit[i] > anchor_[i])
+                               // place dit after the inset it was in
+                               ++dit.pos();
+               }
+       }
+       setCursor(dit);
+       setSelection();
+}
+
+
 void Cursor::setCursorToAnchor()
 {
        if (selection()) {
@@ -1424,8 +1451,9 @@ bool Cursor::macroModeClose()
        InsetMathNest * const in = inset().asInsetMath()->asNestInset();
        if (in && in->interpretString(*this, s))
                return true;
-       MathAtom atom = buffer()->getMacro(name, *this, false) ?
-               MathAtom(new MathMacro(buffer(), name)) : createInsetMath(name, buffer());
+       bool const user_macro = buffer()->getMacro(name, *this, false);
+       MathAtom atom = user_macro ? MathAtom(new MathMacro(buffer(), name))
+                                  : createInsetMath(name, buffer());
 
        // try to put argument into macro, if we just inserted a macro
        bool macroArg = false;
@@ -1447,7 +1475,29 @@ bool Cursor::macroModeClose()
        else if (atom.nucleus()->nargs() > 0)
                atom.nucleus()->cell(0).append(selection);
 
-       plainInsert(atom);
+       MathWordList const & words = mathedWordList();
+       MathWordList::const_iterator it = words.find(name);
+       bool keep_mathmode = it != words.end() && (it->second.inset == "font"
+                                               || it->second.inset == "oldfont"
+                                               || it->second.inset == "mbox");
+       bool ert_macro = !user_macro && it == words.end() && atomAsMacro;
+
+       if (in && in->currentMode() == Inset::TEXT_MODE
+           && atom.nucleus()->currentMode() == Inset::MATH_MODE
+           && name != from_ascii("ensuremath") && !ert_macro) {
+               MathAtom at(new InsetMathEnsureMath(buffer()));
+               at.nucleus()->cell(0).push_back(atom);
+               niceInsert(at);
+               posForward();
+       } else if (in && in->currentMode() == Inset::MATH_MODE
+                  && atom.nucleus()->currentMode() == Inset::TEXT_MODE
+                  && !keep_mathmode) {
+               MathAtom at = createInsetMath("text", buffer());
+               at.nucleus()->cell(0).push_back(atom);
+               niceInsert(at);
+               posForward();
+       } else
+               plainInsert(atom);
 
        // finally put the macro argument behind, if needed
        if (macroArg) {
@@ -1567,7 +1617,7 @@ void Cursor::normalize()
                        << pos() << ' ' << lastpos() <<  " in idx: " << idx()
                       << " in atom: '";
                odocstringstream os;
-               otexrowstream ots(os, false);
+               otexrowstream ots(os);
                WriteStream wi(ots, false, true, WriteStream::wsDefault);
                inset().asInsetMath()->write(wi);
                lyxerr << to_utf8(os.str()) << endl;
@@ -2017,10 +2067,14 @@ Encoding const * Cursor::getEncoding() const
 {
        if (empty())
                return 0;
+       BufferParams const & bp = bv().buffer().params();
+       if (bp.useNonTeXFonts)
+               return encodings.fromLyXName("utf8-plain");
+
        CursorSlice const & sl = innerTextSlice();
        Text const & text = *sl.text();
-       Font font = text.getPar(sl.pit()).getFont(
-               bv().buffer().params(), sl.pos(), text.outerFont(sl.pit()));
+       Font font = text.getPar(sl.pit()).getFont(bp, sl.pos(),
+                                                 text.outerFont(sl.pit()));
        return font.language()->encoding();
 }
 
@@ -2072,6 +2126,7 @@ Font Cursor::getFont() const
        // The logic here should more or less match to the
        // Cursor::setCurrentFont logic, i.e. the cursor height should
        // give a hint what will happen if a character is entered.
+       // FIXME: this is not the case, what about removing this method ? (see #10478).
 
        // HACK. far from being perfect...