More requires --> required, for C++2a.

[lyx.git] / src / Text3.cpp

diff --git a/src/Text3.cpp b/src/Text3.cpp
index f8ef5ff49c804816d2c08e81fcd91e6342796416..1e0180cc2e726375487a1818373d1851e758dab1 100644 (file)
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -296,8 +296,16 @@ static bool doInsertInset(Cursor & cur, Text * text,
        if (cur.selection()) {
                if (cmd.action() == LFUN_INDEX_INSERT)
                        copySelectionToTemp(cur);
-               else
+               else {
                        cutSelectionToTemp(cur, pastesel);
+                       /* Move layout information inside the inset if the whole
+                        * paragraph and the inset allows setting layout
+                        * FIXME: this does not work as expected when change tracking is on
+                        *   However, we do not really know what to do in this case.
+                        */
+                       if (cur.paragraph().empty() && !inset->forcePlainLayout())
+                               cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass());
+               }
                cur.clearSelection();
                gotsel = true;
        } else if (cmd.action() == LFUN_INDEX_INSERT) {
@@ -320,24 +328,17 @@ static bool doInsertInset(Cursor & cur, Text * text,
        InsetText * inset_text = inset->asInsetText();
        if (inset_text) {
                inset_text->fixParagraphsFont();
-               if (!inset_text->allowMultiPar() || cur.lastpit() == 0) {
-                       // reset first par to default
-                       cur.text()->paragraphs().begin()
-                               ->setPlainOrDefaultLayout(bparams.documentClass());
-                       cur.pos() = 0;
-                       cur.pit() = 0;
-                       // Merge multiple paragraphs -- hack
-                       while (cur.lastpit() > 0)
-                               mergeParagraph(bparams, cur.text()->paragraphs(), 0);
-                       if (cmd.action() == LFUN_FLEX_INSERT)
-                               return true;
-                       Cursor old = cur;
-                       cur.leaveInset(*inset);
-                       if (cmd.action() == LFUN_PREVIEW_INSERT
-                           || cmd.action() == LFUN_IPA_INSERT)
-                               // trigger preview
-                               notifyCursorLeavesOrEnters(old, cur);
-               }
+               cur.pos() = 0;
+               cur.pit() = 0;
+               // FIXME: what does this do?
+               if (cmd.action() == LFUN_FLEX_INSERT)
+                       return true;
+               Cursor old = cur;
+               cur.leaveInset(*inset);
+               if (cmd.action() == LFUN_PREVIEW_INSERT
+                       || cmd.action() == LFUN_IPA_INSERT)
+                       // trigger preview
+                       notifyCursorLeavesOrEnters(old, cur);
        } else {
                cur.leaveInset(*inset);
                // reset surrounding par to default
@@ -580,7 +581,6 @@ Language const * getLanguage(Cursor const & cur, string const & lang)
 docstring resolveLayout(docstring layout, DocIterator const & dit)
 {
        Paragraph const & par = dit.paragraph();
-       docstring const old_layout = par.layout().name();
        DocumentClass const & tclass = dit.buffer()->params().documentClass();
 
        if (layout.empty())
@@ -673,7 +673,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        case LFUN_PARAGRAPH_MOVE_DOWN: {
                pit_type const pit = cur.pit();
                cur.recordUndo(pit, pit + 1);
-               cur.finishUndo();
                pars_.swap(pit, pit + 1);
                needsUpdate = true;
                cur.forceBufferUpdate();
@@ -1250,7 +1249,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                }
                        }
                } else {
+                       DocIterator const dit = cur.selectionBegin();
                        cutSelection(cur, false);
+                       if (cur.buffer()->params().track_changes)
+                               // since we're doing backwards deletion,
+                               // and the selection is not really cut,
+                               // move cursor before selection (#11630)
+                               cur.setCursor(dit);
                        singleParUpdate = false;
                }
                break;
@@ -1522,6 +1527,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                }
 
                bv->buffer().errors("Paste");
+               bv->buffer().updatePreviews(); // bug 11619
                cur.clearSelection(); // bug 393
                cur.finishUndo();
                break;
@@ -1595,11 +1601,19 @@ 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();
+                               }
                                FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first);
                                lyx::dispatch(cmd2);
+                               inautoarg = true;
                        }
                }
 
@@ -2063,18 +2077,33 @@ 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;
+               bool autoargs = false, 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();
+                                       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) {
@@ -3328,7 +3357,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
                                if (in_last_par)
                                        end = cur.selectionEnd().pos();
                                else
-                                       end = it.lastpos();
+                                       // the +1 is needed for cases, e.g., where there is a
+                                       // paragraph break. See #11629.
+                                       end = it.lastpos() + 1;
                                if (beg != end && it.paragraph().isChanged(beg, end)) {
                                        enable = true;
                                        break;