Make math autocorrrect work with more than 2 chars

[lyx.git] / src / Text3.cpp

diff --git a/src/Text3.cpp b/src/Text3.cpp
index d63bb93e42f5a791d4b78c4462f26d50ef67be4b..f234c7cb7d027c95fd979b3cd281c0709092493a 100644 (file)
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -562,10 +562,10 @@ void Text::number(Cursor & cur)
 }
 
 
-bool Text::isRTL(Paragraph const & par) const
+bool Text::isRTL(pit_type const pit) const
 {
        Buffer const & buffer = owner_->buffer();
-       return par.isRTL(buffer.params());
+       return pars_[pit].isRTL(buffer.params());
 }
 
 
@@ -927,6 +927,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                break;
        }
 
+       case LFUN_PARAGRAPH_SELECT:
+               if (cur.pos() > 0)
+                       needsUpdate |= setCursor(cur, cur.pit(), 0);
+               needsUpdate |= cur.selHandle(true);
+               if (cur.pos() < cur.lastpos())
+                       needsUpdate |= setCursor(cur, cur.pit(), cur.lastpos());
+               break;
+
        case LFUN_PARAGRAPH_UP:
        case LFUN_PARAGRAPH_UP_SELECT:
                needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_UP_SELECT);
@@ -1587,11 +1595,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                }
 
                DocumentClass const & tclass = bv->buffer().params().documentClass();
+               bool inautoarg = false;
                for (auto const & la_pair : tclass[layout].args()) {
                        Layout::latexarg const & arg = la_pair.second;
                        if (arg.autoinsert) {
+                               // If we had already inserted an arg automatically,
+                               // leave this now in order to insert the next one.
+                               if (inautoarg) {
+                                       cur.leaveInset(cur.inset());
+                                       cur.posForward();
+                                       inautoarg = false;
+                               }
                                FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first);
                                lyx::dispatch(cmd2);
+                               inautoarg = true;
                        }
                }
 
@@ -1762,9 +1779,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
        case LFUN_MOUSE_TRIPLE:
                if (cmd.button() == mouse_button::button1) {
-                       tm->cursorHome(cur);
+                       if (cur.pos() > 0)
+                               setCursor(cur, cur.pit(), 0);
+                       bv->cursor() = cur;
                        cur.resetAnchor();
-                       tm->cursorEnd(cur);
+                       if (cur.pos() < cur.lastpos())
+                               setCursor(cur, cur.pit(), cur.lastpos());
                        cur.setSelection();
                        bv->cursor() = cur;
                }
@@ -2052,18 +2072,34 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                bool const sel = cur.selection();
                doInsertInset(cur, this, cmd, true, true);
                // Insert auto-insert arguments
-               bool autoargs = false;
-               Layout::LaTeXArgMap args = cur.inset().getLayout().latexargs();
+               bool autoargs, inautoarg = false;
+               Layout::LaTeXArgMap args = cur.inset().getLayout().args();
                Layout::LaTeXArgMap::const_iterator lait = args.begin();
                Layout::LaTeXArgMap::const_iterator const laend = args.end();
                for (; lait != laend; ++lait) {
                        Layout::latexarg arg = (*lait).second;
+                       if (!inautoarg && arg.insertonnewline && cur.pos() > 0) {
+                               FuncRequest cmd2(LFUN_PARAGRAPH_BREAK);
+                               lyx::dispatch(cmd2);
+                       }
                        if (arg.autoinsert) {
                                // The cursor might have been invalidated by the replaceSelection.
                                cur.buffer()->changed(true);
+                               // If we had already inserted an arg automatically,
+                               // leave this now in order to insert the next one.
+                               if (inautoarg) {
+                                       cur.leaveInset(cur.inset());
+                                       cur.posForward();
+                                       inautoarg = false;
+                                       if (arg.insertonnewline && cur.pos() > 0) {
+                                               FuncRequest cmd2(LFUN_PARAGRAPH_BREAK);
+                                               lyx::dispatch(cmd2);
+                                       }
+                               }
                                FuncRequest cmd2(LFUN_ARGUMENT_INSERT, (*lait).first);
                                lyx::dispatch(cmd2);
                                autoargs = true;
+                               inautoarg = true;
                        }
                }
                if (!autoargs) {
@@ -2077,14 +2113,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                break;
        }
 
-       case LFUN_TABULAR_INSERT:
+       case LFUN_TABULAR_INSERT: {
                // if there were no arguments, just open the dialog
+               if (cmd.argument().empty()) {
+                       bv->showDialog("tabularcreate");
+                       break;
+               } else if (cur.buffer()->masterParams().tablestyle != "default"
+                          || bv->buffer().params().documentClass().tablestyle() != "default") {
+                       string tabstyle = cur.buffer()->masterParams().tablestyle;
+                       if (tabstyle == "default")
+                               tabstyle = bv->buffer().params().documentClass().tablestyle();
+                       if (!libFileSearch("tabletemplates", tabstyle + ".lyx").empty()) {
+                               FuncRequest fr(LFUN_TABULAR_STYLE_INSERT,
+                                              tabstyle + " " + to_ascii(cmd.argument()));
+                               lyx::dispatch(fr);
+                               break;
+                       } else
+                               // Unknown style. Report and fall back to default.
+                               cur.errorMessage(from_utf8(N_("Table Style ")) + from_utf8(tabstyle) +
+                                                    from_utf8(N_(" not known")));
+                       
+               }
                if (doInsertInset(cur, this, cmd, false, true))
                        cur.posForward();
-               else
-                       bv->showDialog("tabularcreate");
-
                break;
+       }
 
        case LFUN_TABULAR_STYLE_INSERT: {
                string const style = cmd.getArg(0);
@@ -2109,30 +2162,27 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                cur.recordUndo();
                FuncRequest cmd2(LFUN_FILE_INSERT, tabstyle.absFileName() + " ignorelang");
                lyx::dispatch(cmd2);
+               // go into table
+               cur.backwardPos();
                if (r > 2) {
-                       // go into table
-                       cur.backwardPos();
                        // move one cell up to middle cell
                        cur.up();
-                       // now add the missing rows and columns
+                       // add the missing rows
                        int const addrows = r - 3;
-                       int const addcols = c - 1;
                        for (int i = 0 ; i < addrows ; ++i) {
                                FuncRequest fr(LFUN_TABULAR_FEATURE, "append-row");
                                lyx::dispatch(fr);
                        }
-                       for (int i = 0 ; i < addcols ; ++i) {
-                               FuncRequest fr(LFUN_TABULAR_FEATURE, "append-column");
-                               lyx::dispatch(fr);
-                       }
+               }
+               // add the missing columns
+               int const addcols = c - 1;
+               for (int i = 0 ; i < addcols ; ++i) {
+                       FuncRequest fr(LFUN_TABULAR_FEATURE, "append-column");
+                       lyx::dispatch(fr);
+               }
+               if (r > 1)
                        // go to first cell
                        cur.up();
-               } else {
-                       // jump over table
-                       cur.backwardChar();
-                       // go to first cell
-                       cur.forwardPos();
-               }
                break;
        }
 
@@ -3520,6 +3570,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_UP_SELECT:
        case LFUN_DOWN:
        case LFUN_DOWN_SELECT:
+       case LFUN_PARAGRAPH_SELECT:
        case LFUN_PARAGRAPH_UP_SELECT:
        case LFUN_PARAGRAPH_DOWN_SELECT:
        case LFUN_LINE_BEGIN_SELECT: