fix bug that disabled entering 'special char macros' like \, and \:

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

diff --git a/src/mathed/math_cursor.C b/src/mathed/math_cursor.C
index 86a3b12da80d65da912b69161bed049ea74d529b..ba00fe0e751543a6a2e3842847b6975737cab3e2 100644 (file)
--- a/src/mathed/math_cursor.C
+++ b/src/mathed/math_cursor.C
@@ -133,15 +133,25 @@ struct Selection
                        cursor.insert(data_.cell(0));
                } else {
                        // mulitple cells
-                       idx_type idx;
+                       idx_type idx; // index of upper left cell
                        MathGridInset * p = cursor.enclosingGrid(idx);
                        col_type const numcols = min(data_.ncols(), p->ncols() - p->col(idx));
                        row_type const numrows = min(data_.nrows(), p->nrows() - p->row(idx));
-                       for (row_type row = 0; row < numrows; ++row)
+                       for (row_type row = 0; row < numrows; ++row) {
                                for (col_type col = 0; col < numcols; ++col) {
                                        idx_type i = p->index(row + p->row(idx), col + p->col(idx));
                                        p->cell(i).push_back(data_.cell(data_.index(row, col)));
                                }
+                               // append the left over horizontal cells to the last column
+                               idx_type i = p->index(row + p->row(idx), p->ncols() - 1);
+                               for (col_type col = numcols; col < data_.ncols(); ++col) 
+                                       p->cell(i).push_back(data_.cell(data_.index(row, col)));
+                       }
+                       // append the left over vertical cells to the last _cell_
+                       idx_type i = p->nargs() - 1;
+                       for (row_type row = numrows; row < data_.nrows(); ++row) 
+                               for (col_type col = 0; col < data_.ncols(); ++col) 
+                                       p->cell(i).push_back(data_.cell(data_.index(row, col)));
                }
        }
 
@@ -537,18 +547,16 @@ void MathCursor::erase()
                return;
        }
 
-       // delete empty cells if necessary
-       if (array().empty()) {
-               bool popit;
-               bool removeit;
-               par()->idxDelete(idx(), popit, removeit);
-               if (popit && popLeft() && removeit)
-                       plainErase();
-               return;
-       }
+       // delete empty cells if possible
+       if (array().empty())
+               if (par()->idxDelete(idx()))
+                       return;
 
-       if (pos() == size())
+       // old behaviour when in last position of cell
+       if (pos() == size()) {
+               par()->idxGlue(idx());
                return;
+       }
 
        MathScriptInset * p = nextAtom()->asScriptInset();
        if (p) {
@@ -626,13 +634,14 @@ bool MathCursor::toggleLimits()
 
 void MathCursor::macroModeClose()
 {
+       MathInset::difference_type const t = macroNamePos();
+       if (t == -1)
+               return;
        string s = macroName();
-       if (s.size()) {
-               size_type old = pos();
-               pos() -= s.size();
-               array().erase(pos(), old);
+       array().erase(t, pos());
+       pos() = t;
+       if (s != "\\")
                interpret(s);
-       }
 }
 
 
@@ -889,12 +898,20 @@ MathGridInset * MathCursor::enclosingGrid(MathCursor::idx_type & idx) const
                if (p) {
                        idx = Cursor_[i].idx_;
                        return p;
+                       lyxerr << "found grid and idx: " << idx << "\n";
                }
        }
        return 0;
 }
 
 
+void MathCursor::popToEnclosingGrid()
+{
+       while (Cursor_.size() && !Cursor_.back().par_->asGridInset())
+               Cursor_.pop_back();
+}
+
+
 void MathCursor::pullArg(bool goright)
 {
        dump("pullarg");
@@ -957,7 +974,7 @@ void MathCursor::normalize()
                lyxerr << "this should not really happen - 2: "
                        << pos() << " " << size() <<  " in idx: " << idx()
                        << " in atom: '";
-               WriteStream wi(lyxerr, false);
+               WriteStream wi(lyxerr, false, true);
                par()->write(wi);
                lyxerr << "\n";
                dump("error 4");
@@ -1316,9 +1333,6 @@ bool MathCursor::interpret(string const & s)
        if (s.empty())
                return true;
 
-       if (s.size() == 1)
-               return interpret(s[0]);
-
        //lyxerr << "char: '" << s[0] << "'  int: " << int(s[0]) << endl;
        //owner_->getIntl()->getTrans().TranslateAndInsert(s[0], lt);
        //lyxerr << "trans: '" << s[0] << "'  int: " << int(s[0]) << endl;
@@ -1358,9 +1372,11 @@ bool MathCursor::interpret(string const & s)
                return true;
        }
 
-       if (s == "\\over" || s == "\\choose" || s == "\\atop") {
+       string name = s.substr(1);
+
+       if (name == "over" || name == "choose" || name == "atop") {
                MathArray ar = array();
-               MathAtom t(createMathInset(s.substr(1)));
+               MathAtom t(createMathInset(name));
                t->asNestInset()->cell(0).swap(array());
                pos() = 0;
                niceInsert(t);
@@ -1369,7 +1385,7 @@ bool MathCursor::interpret(string const & s)
                return true;
        }
 
-       latexkeys const * l = in_word_set(s.substr(1));
+       latexkeys const * l = in_word_set(name);
        if (l && (l->token == LM_TK_FONT || l->token == LM_TK_OLDFONT)) {
                lastcode_ = static_cast<MathTextCodes>(l->id);
                return true;
@@ -1377,13 +1393,13 @@ bool MathCursor::interpret(string const & s)
 
        // prevent entering of recursive macros
        if (formula()->lyxCode() == Inset::MATHMACRO_CODE
-               && formula()->getInsetName() == s.substr(1))
+               && formula()->getInsetName() == name)
        {
                lyxerr << "can't enter recursive macro\n";
                return true;
        }
 
-       niceInsert(createMathInset(s.substr(1)));
+       niceInsert(createMathInset(name));
        return true;
 }
 
@@ -1417,6 +1433,7 @@ bool MathCursor::script(bool up)
 
 bool MathCursor::interpret(char c)
 {
+       //lyxerr << "interpret 2: '" << c << "'\n";
        if (inMacroArgMode()) {
                --pos();
                plainErase();
@@ -1434,31 +1451,34 @@ bool MathCursor::interpret(char c)
        // handle macroMode
        if (inMacroMode()) {
                string name = macroName();
+               //lyxerr << "interpret name: '" << name << "'\n";
 
-               if (name == "\\" && c == '\\') {
-                       backspace();
-                       interpret("\\backslash");
+               // extend macro name if possible
+               if (isalpha(c)) {
+                       insert(c, LM_TC_TEX);
                        return true;
                }
 
-               if (isalpha(c)) {
-                       insert(c, LM_TC_TEX);
+               // leave macro mode if explicitly requested
+               if (c == ' ') {
+                       macroModeClose();
                        return true;
                }
 
+               // handle 'special char' macros
                if (name == "\\") {
-                       insert(c, LM_TC_TEX);
-                       macroModeClose();
+                       // remove the '\\'
+                       backspace();
+                       if (c == '\\') 
+                               interpret("\\backslash");
+                       else
+                               interpret(string("\\") + c);
                        return true;
                }
 
+               // leave macro mode and try again
                macroModeClose();
-
-               if (c == '\\')
-                       insert(c, LM_TC_TEX);
-               else if (c != ' ')
-                       insert(c, lastcode_);
-
+               interpret(c);
                return true;
        }
 
@@ -1589,5 +1609,5 @@ string MathCursor::info() const
        ostringstream os;
        if (pos() > 0)
                prevAtom()->infoize(os);
-       return os.str();
+       return os.str().c_str(); // .c_str() needed for lyxstring
 }