small up/down tweaking

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

diff --git a/src/mathed/math_cursor.C b/src/mathed/math_cursor.C
index 15c6a5f51d6ac4915985759923a6ec0b2aaffbee..44b0136ce6075e99e6c4f33a7c6a8e5c961fbd8c 100644 (file)
--- a/src/mathed/math_cursor.C
+++ b/src/mathed/math_cursor.C
@@ -35,6 +35,7 @@
 #include "math_charinset.h"
 #include "math_extern.h"
 #include "math_factory.h"
+#include "math_fontinset.h"
 #include "math_gridinset.h"
 #include "math_iterator.h"
 #include "math_macroarg.h"
@@ -64,7 +65,7 @@ string theCutBuffer;
 
 
 MathCursor::MathCursor(InsetFormulaBase * formula, bool front)
-       :       formula_(formula), autocorrect_(false), selection_(false)
+       :       formula_(formula), autocorrect_(false), selection_(false), targetx_(-1)
 {
        front ? first() : last();
        Anchor_ = Cursor_;
@@ -73,9 +74,9 @@ MathCursor::MathCursor(InsetFormulaBase * formula, bool front)
 
 MathCursor::~MathCursor()
 {
-  // ensure that 'notifyCursorLeave' is called
-  while (popLeft())
-    ;
+       // ensure that 'notifyCursorLeave' is called
+       while (popLeft())
+               ;
 }
 
 
@@ -107,10 +108,10 @@ bool MathCursor::popLeft()
        //cerr << "Leaving atom to the left\n";
        if (depth() <= 1) {
                if (depth() == 1)
-                       par()->notifyCursorLeaves();
+                       par()->notifyCursorLeaves(idx());
                return false;
        }
-       par()->notifyCursorLeaves();
+       par()->notifyCursorLeaves(idx());
        Cursor_.pop_back();
        return true;
 }
@@ -121,10 +122,10 @@ bool MathCursor::popRight()
        //cerr << "Leaving atom "; par()->write(cerr, false); cerr << " right\n";
        if (depth() <= 1) {
                if (depth() == 1)
-                       par()->notifyCursorLeaves();
+                       par()->notifyCursorLeaves(idx());
                return false;
        }
-       par()->notifyCursorLeaves();
+       par()->notifyCursorLeaves(idx());
        Cursor_.pop_back();
        posRight();
        return true;
@@ -135,14 +136,14 @@ bool MathCursor::popRight()
 #if FILEDEBUG
        void MathCursor::dump(char const * what) const
        {
-               lyxerr << "MC: " << what << "\n";
-               lyxerr << " Cursor: " << depth() << "\n";
+               lyxerr << "MC: " << what << endl;
+               lyxerr << " Cursor: " << depth() << endl;
                for (unsigned i = 0; i < depth(); ++i)
-                       lyxerr << "    i: " << i << " " << Cursor_[i] << "\n";
-               lyxerr << " Anchor: " << Anchor_.size() << "\n";
+                       lyxerr << "    i: " << i << ' ' << Cursor_[i] << endl;
+               lyxerr << " Anchor: " << Anchor_.size() << endl;
                for (unsigned i = 0; i < Anchor_.size(); ++i)
-                       lyxerr << "    i: " << i << " " << Anchor_[i] << "\n";
-               lyxerr  << " sel: " << selection_ << "\n";
+                       lyxerr << "    i: " << i << ' ' << Anchor_[i] << endl;
+               lyxerr  << " sel: " << selection_ << endl;
        }
 #else
        void MathCursor::dump(char const *) const {}
@@ -377,7 +378,7 @@ void MathCursor::niceInsert(string const & t)
        MathArray ar = asArray(t);
        if (ar.size() == 1)
                niceInsert(ar[0]);
-       else 
+       else
                insert(ar);
 }
 
@@ -415,16 +416,17 @@ void MathCursor::paste(string const & data)
 void MathCursor::backspace()
 {
        autocorrect_ = false;
-       if (pos() == 0) {
-               pullArg();
-               return;
-       }
 
        if (selection_) {
                selDel();
                return;
        }
 
+       if (pos() == 0) {
+               pullArg();
+               return;
+       }
+
        if (inMacroMode()) {
                MathUnknownInset * p = activeMacro();
                if (p->name().size() > 1) {
@@ -664,6 +666,18 @@ MathCursor::pos_type MathCursor::pos() const
 }
 
 
+void MathCursor::adjust(pos_type from, difference_type diff)
+{
+       if (cursor().pos_ > from)
+               cursor().pos_ += diff;
+       if (Anchor_.back().pos_ > from)
+               Anchor_.back().pos_ += diff;
+       // just to be on the safe side
+       // theoretically unecessary
+       normalize();
+}
+
+
 MathCursor::pos_type & MathCursor::pos()
 {
        return cursor().pos_;
@@ -764,36 +778,22 @@ void MathCursor::normalize()
 {
        if (idx() >= par()->nargs()) {
                lyxerr << "this should not really happen - 1: "
-                      << idx() << " " << par()->nargs() << " in: " << par() << "\n";
+                      << idx() << ' ' << par()->nargs()
+                      << " in: " << par() << endl;
                dump("error 2");
        }
        idx() = min(idx(), par()->nargs() - 1);
 
        if (pos() > size()) {
                lyxerr << "this should not really happen - 2: "
-                       << pos() << " " << size() <<  " in idx: " << idx()
-                       << " in atom: '";
+                       << pos() << ' ' << size() <<  " in idx: " << idx()
+                      << " in atom: '";
                WriteStream wi(lyxerr, false, true);
                par()->write(wi);
-               lyxerr << "\n";
+               lyxerr << endl;
                dump("error 4");
        }
        pos() = min(pos(), size());
-
-       // remove empty scripts if possible
-       if (1) {
-               for (pos_type i = 0; i < size(); ++i) {
-                       MathScriptInset * p = array()[i].nucleus()->asScriptInset();
-                       if (p) {
-                               p->removeEmptyScripts();
-                               if (!p->hasUp() && !p->hasDown() && p->nuc().size() == 1)
-                                       array()[i] = p->nuc()[0];
-                       }
-               }
-       }
-
-       // fix again position
-       pos() = min(pos(), size());
 }
 
 
@@ -1201,7 +1201,7 @@ bool MathCursor::interpret(char c)
        }
 
        if (c == '\n') {
-               if (currentMode() == MathInset::TEXT_MODE) 
+               if (currentMode() == MathInset::TEXT_MODE)
                        insert(c);
                return true;
        }
@@ -1288,10 +1288,9 @@ string MathCursor::info() const
                os << "  ";
        }
        if (hasPrevAtom())
-               if (prevAtom()->asSymbolInset() || prevAtom()->asScriptInset())
-                       prevAtom()->infoize(os);
+               prevAtom()->infoize2(os);
        os << "                    ";
-       return os.str().c_str(); // .c_str() needed for lyxstring
+       return STRCONV(os.str());
 }
 
 
@@ -1332,6 +1331,11 @@ string MathCursor::grabSelection() const
        MathCursorPos i2;
        getSelection(i1, i2);
 
+       if (i1.idx_ == i2.idx_) {
+               MathArray::const_iterator it = i1.cell().begin();
+               return asString(MathArray(it + i1.pos_, it + i2.pos_));
+       }
+
        row_type r1, r2;
        col_type c1, c2;
        region(i1, i2, r1, r2, c1, c2);
@@ -1339,10 +1343,10 @@ string MathCursor::grabSelection() const
        string data;
        for (row_type row = r1; row <= r2; ++row) {
                if (row > r1)
-                       data += "\\n";
+                       data += "\\\\";
                for (col_type col = c1; col <= c2; ++col) {
                        if (col > c1)
-                               data += "&";
+                               data += '&';
                        data += asString(i1.par_->cell(i1.par_->index(row, col)));
                }
        }
@@ -1427,12 +1431,47 @@ MathInset::mode_type MathCursor::currentMode() const
 }
 
 
-void releaseMathCursor(BufferView * bv)
+void MathCursor::handleFont(string const & font)
 {
-       if (!mathcursor)
-               return;
-       mathcursor->formula()->hideInsetCursor(bv);
-       delete mathcursor;
-       mathcursor = 0;
+       string safe;
+       if (selection()) {
+               macroModeClose();
+               safe = grabAndEraseSelection();
+       }
+
+       if (array().size()) {
+               // something left in the cell
+               if (pos() == 0) {
+                       // cursor in first position
+                       popLeft();
+               } else if (pos() == array().size()) {
+                       // cursor in last position
+                       popRight();
+               } else {
+                       // cursor in between. split cell
+                       MathArray::iterator bt = array().begin();
+                       MathAtom at = createMathInset(font);
+                       at.nucleus()->cell(0) = MathArray(bt, bt + pos());
+                       cursor().cell().erase(bt, bt + pos());
+                       popLeft();
+                       plainInsert(at);
+               }
+       } else {
+               // nothing left in the cell
+               pullArg();
+               plainErase();
+       }
+       insert(safe);
 }
 
+
+void releaseMathCursor(BufferView * bv)
+{
+       if (mathcursor) {
+               InsetFormulaBase * f =  mathcursor->formula();
+               f->hideInsetCursor(bv);
+               delete mathcursor;
+               mathcursor = 0;
+               f->insetUnlock(bv);
+       }
+}