X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=8bbac0eee23d72130b13b5e8ce6e143c98c623bb;hb=a11780b59fcb6cdd16b15f9fa4de45d7ddfd1b2a;hp=f234c7cb7d027c95fd979b3cd281c0709092493a;hpb=9e6d22ea9cc508c3ffd0f92c0ec619ceafbee017;p=features.git

diff --git a/src/Text3.cpp b/src/Text3.cpp
index f234c7cb7d..8bbac0eee2 100644
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -18,18 +18,15 @@
 #include "Text.h"
 
 #include "BranchList.h"
-#include "FloatList.h"
-#include "FuncStatus.h"
 #include "Buffer.h"
-#include "buffer_funcs.h"
 #include "BufferParams.h"
 #include "BufferView.h"
-#include "Changes.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
 #include "DispatchResult.h"
-#include "ErrorList.h"
 #include "factory.h"
+#include "FloatList.h"
+#include "FuncStatus.h"
 #include "FuncRequest.h"
 #include "InsetList.h"
 #include "Intl.h"
@@ -61,6 +58,7 @@
 #include "insets/InsetGraphics.h"
 #include "insets/InsetGraphicsParams.h"
 #include "insets/InsetInfo.h"
+#include "insets/InsetIndexMacro.h"
 #include "insets/InsetIPAMacro.h"
 #include "insets/InsetNewline.h"
 #include "insets/InsetQuotes.h"
@@ -70,21 +68,19 @@
 
 #include "support/convert.h"
 #include "support/debug.h"
+#include "support/docstring_list.h"
 #include "support/filetools.h"
 #include "support/gettext.h"
 #include "support/lassert.h"
 #include "support/limited_stack.h"
 #include "support/lstrings.h"
-#include "support/lyxalgo.h"
-#include "support/lyxtime.h"
-#include "support/os.h"
-#include "support/regex.h"
 
 #include "mathed/InsetMathHull.h"
 #include "mathed/InsetMathMacroTemplate.h"
 #include "lyxfind.h"
 
 #include <clocale>
+#include <regex>
 #include <sstream>
 
 using namespace std;
@@ -123,6 +119,11 @@ static void toggleAndShow(Cursor & cur, Text * text,
 						       cur.real_current_font))
 			text->setCursor(cur, cur.pit(), cur.pos(),
 					false, !cur.boundary());
+		if (font.language() != ignore_language)
+			// We need a buffer update if we change the language
+			// (e.g., with info insets or if the selection contains
+			// a par label)
+			cur.forceBufferUpdate();
 	}
 }
 
@@ -243,7 +244,8 @@ static void ipaChar(Cursor & cur, InsetIPAChar::Kind kind)
 
 
 static bool doInsertInset(Cursor & cur, Text * text,
-	FuncRequest const & cmd, bool edit, bool pastesel)
+			  FuncRequest const & cmd, bool edit,
+			  bool pastesel, bool resetfont = false)
 {
 	Buffer & buffer = cur.bv().buffer();
 	BufferParams const & bparams = buffer.params();
@@ -257,7 +259,7 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	cur.recordUndo();
 	if (cmd.action() == LFUN_ARGUMENT_INSERT) {
 		bool cotextinsert = false;
-		InsetArgument const * const ia = static_cast<InsetArgument const *>(inset);
+		InsetArgument * const ia = static_cast<InsetArgument *>(inset);
 		Layout const & lay = cur.paragraph().layout();
 		Layout::LaTeXArgMap args = lay.args();
 		Layout::LaTeXArgMap::const_iterator const lait = args.find(ia->name());
@@ -280,6 +282,7 @@ static bool doInsertInset(Cursor & cur, Text * text,
 			else
 				ds = cur.paragraph().asString();
 			text->insertInset(cur, inset);
+			ia->init(cur.paragraph());
 			if (edit)
 				inset->edit(cur, true);
 			// Now put co-text into inset
@@ -293,11 +296,25 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	}
 
 	bool gotsel = false;
+	bool move_layout = false;
 	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.
+			 * FIXME: figure out a good test in the environment case (see #12251).
+			 */
+			if (cur.paragraph().layout().isCommand()
+			     && cur.paragraph().empty()
+			     && !inset->forcePlainLayout()) {
+				cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass());
+				move_layout = true;
+			}
+		}
 		cur.clearSelection();
 		gotsel = true;
 	} else if (cmd.action() == LFUN_INDEX_INSERT) {
@@ -307,6 +324,19 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	}
 	text->insertInset(cur, inset);
 
+	InsetText * inset_text = inset->asInsetText();
+	if (inset_text) {
+		Font const & font = inset->inheritFont()
+			? cur.bv().textMetrics(text).displayFont(cur.pit(), cur.pos())
+			: bparams.getFont();
+		inset_text->setOuterFont(cur.bv(), font.fontInfo());
+	}
+
+	if (cmd.action() == LFUN_ARGUMENT_INSERT) {
+		InsetArgument * const ia = static_cast<InsetArgument *>(inset);
+		ia->init(cur.paragraph());
+	}
+
 	if (edit)
 		inset->edit(cur, true);
 
@@ -317,27 +347,31 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	cur.buffer()->errors("Paste");
 	cur.clearSelection(); // bug 393
 	cur.finishUndo();
-	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);
+		if (resetfont) {
+			// Reset of font (not language) is requested.
+			// Used by InsetIndex (#11961).
+			Language const * lang = cur.getFont().language();
+			Font font(bparams.getFont().fontInfo(), lang);
+			cur.paragraph().resetFonts(font);
 		}
+		inset_text->fixParagraphsFont();
+		cur.pos() = 0;
+		cur.pit() = 0;
+		/* If the containing paragraph has kept its layout, reset the
+		 * layout of the first paragraph of the inset.
+		 */
+		if (!move_layout)
+			cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass());
+		// 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
@@ -360,7 +394,7 @@ enum OutlineOp {
 };
 
 
-static void insertSeparator(Cursor & cur, depth_type const depth)
+static void insertSeparator(Cursor const & cur, depth_type const depth)
 {
 	Buffer & buf = *cur.buffer();
 	lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
@@ -383,7 +417,7 @@ static void outline(OutlineOp mode, Cursor & cur, Text * text)
 	ParagraphList & pars = buf.text().paragraphs();
 	ParagraphList::iterator const bgn = pars.begin();
 	// The first paragraph of the area to be copied:
-	ParagraphList::iterator start = lyx::next(bgn, pit);
+	ParagraphList::iterator start = pars.iterator_at(pit);
 	// The final paragraph of area to be copied:
 	ParagraphList::iterator finish = start;
 	ParagraphList::iterator const end = pars.end();
@@ -534,16 +568,14 @@ static void outline(OutlineOp mode, Cursor & cur, Text * text)
 					continue;
 
 				DocumentClass const & tc = buf.params().documentClass();
-				DocumentClass::const_iterator lit = tc.begin();
-				DocumentClass::const_iterator len = tc.end();
 				int const newtoclevel =
 					(mode == OutlineIn ? toclevel + 1 : toclevel - 1);
 				LabelType const oldlabeltype = start->layout().labeltype;
 
-				for (; lit != len; ++lit) {
-					if (lit->toclevel ==  newtoclevel &&
-					     lit->labeltype == oldlabeltype) {
-						start->setLayout(*lit);
+				for (auto const & lay : tc) {
+					if (lay.toclevel ==  newtoclevel &&
+						 lay.labeltype == oldlabeltype) {
+						start->setLayout(lay);
 						break;
 					}
 				}
@@ -580,7 +612,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 +704,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();
@@ -787,24 +817,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bool const cur_moved = cursorForward(cur);
 		needsUpdate |= cur_moved;
 
-		if (!cur_moved && oldTopSlice == cur.top()
-			       && cur.boundary() == oldBoundary) {
+		if (!cur_moved && cur.depth() > 1
+		     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 			cur.undispatched();
 			cmd = FuncRequest(LFUN_FINISHED_FORWARD);
 
-			// we will probably be moving out the inset, so we should execute
-			// the depm-mechanism, but only when the cursor has a place to
-			// go outside this inset, i.e. in a slice above.
-			if (cur.depth() > 1 && cur.pos() == cur.lastpos()
-				  && cur.pit() == cur.lastpit()) {
-				// The cursor hasn't changed yet. To give the
-				// DEPM the possibility of doing something we must
-				// provide it with two different cursors.
-				Cursor dummy = cur;
-				dummy.pos() = dummy.pit() = 0;
-				if (cur.bv().checkDepm(dummy, cur))
-					cur.forceBufferUpdate();
-			}
+			// we will be moving out the inset, so we should execute
+			// the depm-mechanism.
+			// The cursor hasn't changed yet. To give the DEPM the
+			// possibility of doing something we must provide it with
+			// two different cursors.
+			Cursor dummy = cur;
+			dummy.pos() = dummy.pit() = 0;
+			if (cur.bv().checkDepm(dummy, cur))
+				cur.forceBufferUpdate();
 		}
 		break;
 	}
@@ -816,24 +842,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bool const cur_moved = cursorBackward(cur);
 		needsUpdate |= cur_moved;
 
-		if (!cur_moved && oldTopSlice == cur.top()
-			       && cur.boundary() == oldBoundary) {
+		if (!cur_moved && cur.depth() > 1
+		     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 			cur.undispatched();
 			cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
 
-			// we will probably be moving out the inset, so we should execute
-			// the depm-mechanism, but only when the cursor has a place to
-			// go outside this inset, i.e. in a slice above.
-			if (cur.depth() > 1 && cur.pos() == 0 && cur.pit() == 0) {
-				// The cursor hasn't changed yet. To give the
-				// DEPM the possibility of doing something we must
-				// provide it with two different cursors.
-				Cursor dummy = cur;
-				dummy.pos() = cur.lastpos();
-				dummy.pit() = cur.lastpit();
-				if (cur.bv().checkDepm(dummy, cur))
-					cur.forceBufferUpdate();
-			}
+			// we will be moving out the inset, so we should execute
+			// the depm-mechanism.
+			// The cursor hasn't changed yet. To give the DEPM the
+			// possibility of doing something we must provide it with
+			// two different cursors.
+			Cursor dummy = cur;
+			dummy.pos() = cur.lastpos();
+			dummy.pit() = cur.lastpit();
+			if (cur.bv().checkDepm(dummy, cur))
+				cur.forceBufferUpdate();
 		}
 		break;
 	}
@@ -844,8 +867,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			needsUpdate |= cur.selHandle(act == LFUN_CHAR_LEFT_SELECT);
 			bool const cur_moved = cursorVisLeft(cur);
 			needsUpdate |= cur_moved;
-			if (!cur_moved && oldTopSlice == cur.top()
-				       && cur.boundary() == oldBoundary) {
+			if (!cur_moved && cur.depth() > 1
+			     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 				cur.undispatched();
 				cmd = FuncRequest(LFUN_FINISHED_LEFT);
 			}
@@ -868,8 +891,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			needsUpdate |= cur.selHandle(cmd.action() == LFUN_CHAR_RIGHT_SELECT);
 			bool const cur_moved = cursorVisRight(cur);
 			needsUpdate |= cur_moved;
-			if (!cur_moved && oldTopSlice == cur.top()
-				       && cur.boundary() == oldBoundary) {
+			if (!cur_moved && cur.depth() > 1
+			     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 				cur.undispatched();
 				cmd = FuncRequest(LFUN_FINISHED_RIGHT);
 			}
@@ -965,7 +988,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		ParagraphList & pars = buf.text().paragraphs();
 		ParagraphList::iterator bgn = pars.begin();
 		// The first paragraph of the area to be selected:
-		ParagraphList::iterator start = lyx::next(bgn, pit);
+		ParagraphList::iterator start = pars.iterator_at(pit);
 		// The final paragraph of area to be selected:
 		ParagraphList::iterator finish = start;
 		ParagraphList::iterator end = pars.end();
@@ -1002,8 +1025,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_RIGHT_SELECT);
 			bool const cur_moved = cursorVisRightOneWord(cur);
 			needsUpdate |= cur_moved;
-			if (!cur_moved && oldTopSlice == cur.top()
-				       && cur.boundary() == oldBoundary) {
+			if (!cur_moved && cur.depth() > 1
+			     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 				cur.undispatched();
 				cmd = FuncRequest(LFUN_FINISHED_RIGHT);
 			}
@@ -1026,24 +1049,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bool const cur_moved = cursorForwardOneWord(cur);
 		needsUpdate |= cur_moved;
 
-		if (!cur_moved && oldTopSlice == cur.top()
-			       && cur.boundary() == oldBoundary) {
+		if (!cur_moved && cur.depth() > 1
+		     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 			cur.undispatched();
 			cmd = FuncRequest(LFUN_FINISHED_FORWARD);
 
-			// we will probably be moving out the inset, so we should execute
-			// the depm-mechanism, but only when the cursor has a place to
-			// go outside this inset, i.e. in a slice above.
-			if (cur.depth() > 1 && cur.pos() == cur.lastpos()
-				  && cur.pit() == cur.lastpit()) {
-				// The cursor hasn't changed yet. To give the
-				// DEPM the possibility of doing something we must
-				// provide it with two different cursors.
-				Cursor dummy = cur;
-				dummy.pos() = dummy.pit() = 0;
-				if (cur.bv().checkDepm(dummy, cur))
-					cur.forceBufferUpdate();
-			}
+			// we will be moving out the inset, so we should execute
+			// the depm-mechanism.
+			// The cursor hasn't changed yet. To give the DEPM the
+			// possibility of doing something we must provide it with
+			// two different cursors.
+			Cursor dummy = cur;
+			dummy.pos() = dummy.pit() = 0;
+			if (cur.bv().checkDepm(dummy, cur))
+				cur.forceBufferUpdate();
 		}
 		break;
 	}
@@ -1054,8 +1073,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_LEFT_SELECT);
 			bool const cur_moved = cursorVisLeftOneWord(cur);
 			needsUpdate |= cur_moved;
-			if (!cur_moved && oldTopSlice == cur.top()
-				       && cur.boundary() == oldBoundary) {
+			if (!cur_moved && cur.depth() > 1
+			     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 				cur.undispatched();
 				cmd = FuncRequest(LFUN_FINISHED_LEFT);
 			}
@@ -1078,25 +1097,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bool const cur_moved = cursorBackwardOneWord(cur);
 		needsUpdate |= cur_moved;
 
-		if (!cur_moved && oldTopSlice == cur.top()
-			       && cur.boundary() == oldBoundary) {
+		if (!cur_moved && cur.depth() > 1
+		     && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) {
 			cur.undispatched();
 			cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
 
-			// we will probably be moving out the inset, so we should execute
-			// the depm-mechanism, but only when the cursor has a place to
-			// go outside this inset, i.e. in a slice above.
-			if (cur.depth() > 1 && cur.pos() == 0
-				  && cur.pit() == 0) {
-				// The cursor hasn't changed yet. To give the
-				// DEPM the possibility of doing something we must
-				// provide it with two different cursors.
-				Cursor dummy = cur;
-				dummy.pos() = cur.lastpos();
-				dummy.pit() = cur.lastpit();
-				if (cur.bv().checkDepm(dummy, cur))
-					cur.forceBufferUpdate();
-			}
+			// we will be moving out the inset, so we should execute
+			// the depm-mechanism.
+			// The cursor hasn't changed yet. To give the DEPM the
+			// possibility of doing something we must provide it with
+			// two different cursors.
+			Cursor dummy = cur;
+			dummy.pos() = cur.lastpos();
+			dummy.pit() = cur.lastpit();
+			if (cur.bv().checkDepm(dummy, cur))
+				cur.forceBufferUpdate();
 		}
 		break;
 	}
@@ -1109,7 +1124,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_NEWLINE_INSERT: {
 		InsetNewlineParams inp;
-		docstring arg = cmd.argument();
+		docstring const & arg = cmd.argument();
 		if (arg == "linebreak")
 			inp.kind = InsetNewlineParams::LINEBREAK;
 		else
@@ -1221,6 +1236,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			cur.resetAnchor();
 		} else {
 			cutSelection(cur, false);
+			cur.setCurrentFont();
 			singleParUpdate = false;
 		}
 		moveCursor(cur, false);
@@ -1250,7 +1266,14 @@ 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);
+			cur.setCurrentFont();
 			singleParUpdate = false;
 		}
 		break;
@@ -1263,7 +1286,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		Paragraph const & nextpar = lastpar ? par : pars_[pit + 1];
 		pit_type prev = pit > 0 ? depthHook(pit, par.getDepth()) : pit;
 		if (prev < pit && cur.pos() == par.beginOfBody()
-		    && !par.size() && !par.isEnvSeparator(cur.pos())
+		    && par.empty() && !par.isEnvSeparator(cur.pos())
 		    && !par.layout().keepempty
 		    && !par.layout().isCommand()
 		    && pars_[prev].layout() != par.layout()
@@ -1363,6 +1386,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
+	case LFUN_INSET_SPLIT: {
+		if (splitInset(cur)) {
+			needsUpdate = true;
+			cur.forceBufferUpdate();
+		}
+		break;
+	}
+
 	case LFUN_GRAPHICS_SET_GROUP: {
 		InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
 		if (!ins)
@@ -1487,7 +1518,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				pasteFromStack(cur, bv->buffer().errorList("Paste"), 0);
 			else if (theClipboard().hasTextContents()) {
 				if (pasteClipboardText(cur, bv->buffer().errorList("Paste"),
-				                       true, Clipboard::AnyTextType))
+				                       !cur.paragraph().parbreakIsNewline(),
+					                   Clipboard::AnyTextType))
 					tryGraphics = false;
 			}
 			if (tryGraphics && theClipboard().hasGraphicsContents())
@@ -1522,6 +1554,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		}
 
 		bv->buffer().errors("Paste");
+		bv->buffer().updatePreviews(); // bug 11619
 		cur.clearSelection(); // bug 393
 		cur.finishUndo();
 		break;
@@ -1532,11 +1565,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		cur.message(_("Cut"));
 		break;
 
-	case LFUN_COPY:
-		copySelection(cur);
-		cur.message(_("Copy"));
-		break;
-
 	case LFUN_SERVER_GET_XY:
 		cur.message(from_utf8(
 			convert<string>(tm->cursorX(cur.top(), cur.boundary()))
@@ -1584,8 +1612,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (change_layout) {
 			setLayout(cur, layout);
 			if (cur.pit() > 0 && !ignoreautonests) {
+				pit_type prev_pit = cur.pit() - 1;
+				depth_type const cur_depth = pars_[cur.pit()].getDepth();
+				// Scan for the previous par on same nesting level
+				while (prev_pit > 0 && pars_[prev_pit].getDepth() > cur_depth)
+					--prev_pit;
 				set<docstring> const & autonests =
-						pars_[cur.pit() - 1].layout().autonests();
+						pars_[prev_pit].layout().autonests();
 				set<docstring> const & autonested =
 						pars_[cur.pit()].layout().isAutonestedBy();
 				if (autonests.find(layout) != autonests.end()
@@ -1604,7 +1637,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				if (inautoarg) {
 					cur.leaveInset(cur.inset());
 					cur.posForward();
-					inautoarg = false;
 				}
 				FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first);
 				lyx::dispatch(cmd2);
@@ -1625,7 +1657,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (para.layout().isEnvironment())
 			layout = para.layout().name();
 		depth_type split_depth = cur.paragraph().params().depth();
-		depth_type nextpar_depth = 0;
+		vector<depth_type> nextpars_depth;
 		if (outer || previous) {
 			// check if we have an environment in our scope
 			pit_type pit = cur.pit();
@@ -1650,9 +1682,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		}
 		if ((outer || normal) && cur.pit() < cur.lastpit()) {
-			// save nesting of following paragraph
-			Paragraph cpar = pars_[cur.pit() + 1];
-			nextpar_depth = cpar.params().depth();
+			// save nesting of following paragraphs if they are deeper
+			// or same depth
+			pit_type offset = 1;
+			depth_type cur_depth = pars_[cur.pit()].params().depth();
+			while (cur.pit() + offset <= cur.lastpit()) {
+				Paragraph cpar = pars_[cur.pit() + offset];
+				depth_type nextpar_depth = cpar.params().depth();
+				if (cur_depth <= nextpar_depth && nextpar_depth > 0) {
+					nextpars_depth.push_back(nextpar_depth);
+					cur_depth = nextpar_depth;
+					++offset;
+				} else
+					break;
+			}
 		}
 		if (before)
 			cur.top().setPitPos(cur.pit(), 0);
@@ -1680,17 +1723,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		else
 			lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse"));
 		lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout));
-		if ((outer || normal) && nextpar_depth > 0) {
-			// restore nesting of following paragraph
+		if ((outer || normal) && !nextpars_depth.empty()) {
+			// restore nesting of following paragraphs
 			DocIterator scur = cur;
-			depth_type const max_depth = cur.paragraph().params().depth() + 1;
-			cur.forwardPar();
-			while (cur.paragraph().params().depth() < min(nextpar_depth, max_depth)) {
-				depth_type const olddepth = cur.paragraph().params().depth();
-				lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
-				if (olddepth == cur.paragraph().params().depth())
-					// leave loop if no incrementation happens
-					break;
+			depth_type max_depth = cur.paragraph().params().depth() + 1;
+			for (auto nextpar_depth : nextpars_depth) {
+				cur.forwardPar();
+				while (cur.paragraph().params().depth() < min(nextpar_depth, max_depth)) {
+					depth_type const olddepth = cur.paragraph().params().depth();
+					lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+					if (olddepth == cur.paragraph().params().depth())
+						// leave loop if no incrementation happens
+						break;
+				}
+				max_depth = cur.paragraph().params().depth() + 1;
 			}
 			cur.setCursor(scur);
 		}
@@ -1769,8 +1815,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				}
 			}
 		}
-		InsetQuotesParams::QuoteLevel const quote_level = inner
-				? InsetQuotesParams::SecondaryQuotes : InsetQuotesParams::PrimaryQuotes;
+		QuoteLevel const quote_level = inner
+				? QuoteLevel::Secondary : QuoteLevel::Primary;
 		cur.insert(new InsetQuotes(cur.buffer(), c, quote_level, cmd.getArg(1), cmd.getArg(2)));
 		cur.buffer()->updateBuffer();
 		cur.posForward();
@@ -1809,8 +1855,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				bvcur.resetAnchor();
 			if (!bv->mouseSetCursor(cur, cmd.modifier() == ShiftModifier))
 				cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
-			if (bvcur.wordSelection())
-				selectWord(bvcur, WHOLE_WORD);
+			// FIXME: move this to mouseSetCursor?
+			if (bvcur.wordSelection() && bvcur.inTexted())
+				expandWordSel(bvcur);
 			break;
 
 		case mouse_button::button2:
@@ -1828,7 +1875,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			// Don't do anything if we right-click a
 			// selection, a context menu will popup.
 			if (bvcur.selection() && cur >= bvcur.selectionBegin()
-			    && cur < bvcur.selectionEnd()) {
+			    && cur <= bvcur.selectionEnd()) {
 				cur.noScreenUpdate();
 				return;
 			}
@@ -1878,6 +1925,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// We continue with our existing selection or start a new one, so don't
 		// reset the anchor.
 		bvcur.setCursor(cur);
+		if (bvcur.wordSelection() && bvcur.inTexted())
+			expandWordSel(bvcur);
 		bvcur.selection(true);
 		bvcur.setCurrentFont();
 		if (cur.top() == old) {
@@ -1941,8 +1990,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// "auto_region_delete", which defaults to
 		// true (on).
 
-		if (lyxrc.auto_region_delete && cur.selection())
+		if (lyxrc.auto_region_delete && cur.selection()) {
 			cutSelection(cur, false);
+			cur.setCurrentFont();
+		}
 		cur.clearSelection();
 
 		for (char_type c : cmd.argument())
@@ -2040,31 +2091,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_BRANCH_INSERT:
 	case LFUN_PHANTOM_INSERT:
 	case LFUN_ERT_INSERT:
+	case LFUN_INDEXMACRO_INSERT:
 	case LFUN_LISTING_INSERT:
 	case LFUN_MARGINALNOTE_INSERT:
 	case LFUN_ARGUMENT_INSERT:
 	case LFUN_INDEX_INSERT:
 	case LFUN_PREVIEW_INSERT:
 	case LFUN_SCRIPT_INSERT:
-	case LFUN_IPA_INSERT:
+	case LFUN_IPA_INSERT: {
+		// Indexes reset font formatting (#11961)
+		bool const resetfont = cmd.action() == LFUN_INDEX_INSERT;
 		// Open the inset, and move the current selection
 		// inside it.
-		doInsertInset(cur, this, cmd, true, true);
+		doInsertInset(cur, this, cmd, true, true, resetfont);
 		cur.posForward();
-		if (act == LFUN_SCRIPT_INSERT) {
-			/* Script insets change the font style in metrics(), and
-			 * this is used to compute the height of the caret
-			 * (because the font is stored in TextMetrics::font_).
-			 * When we insert, we have to make sure that metrics are
-			 * computed so that the caret height is wrong. Arguably,
-			 * this is hackish.*/
-			bv->processUpdateFlags(Update::SinglePar);
-		}
 		cur.setCurrentFont();
 		// Some insets are numbered, others are shown in the outline pane so
 		// let's update the labels and the toc backend.
 		cur.forceBufferUpdate();
 		break;
+	}
 
 	case LFUN_FLEX_INSERT: {
 		// Open the inset, and move the current selection
@@ -2072,12 +2118,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bool const sel = cur.selection();
 		doInsertInset(cur, this, cmd, true, true);
 		// Insert auto-insert arguments
-		bool autoargs, inautoarg = 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;
+		for (auto const & argt : args) {
+			Layout::latexarg arg = argt.second;
 			if (!inautoarg && arg.insertonnewline && cur.pos() > 0) {
 				FuncRequest cmd2(LFUN_PARAGRAPH_BREAK);
 				lyx::dispatch(cmd2);
@@ -2089,14 +2133,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				// leave this now in order to insert the next one.
 				if (inautoarg) {
 					cur.leaveInset(cur.inset());
+					cur.setCurrentFont();
 					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);
+				FuncRequest cmd2(LFUN_ARGUMENT_INSERT, argt.first);
 				lyx::dispatch(cmd2);
 				autoargs = true;
 				inautoarg = true;
@@ -2132,7 +2176,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				// 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();
@@ -2148,7 +2191,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			break;
 		int const r = convert<int>(rows);
 		int const c = convert<int>(cols);
-			
+
 		string suffix;
 		if (r == 1)
 			suffix = "_1x1";
@@ -2242,7 +2285,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_NOMENCL_INSERT: {
 		InsetCommandParams p(NOMENCL_CODE);
 		if (cmd.argument().empty()) {
-			p["symbol"] = 
+			p["symbol"] =
 				bv->cursor().innerText()->getStringForDialog(bv->cursor());
 			cur.clearSelection();
 		} else
@@ -2450,6 +2493,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
+	case LFUN_FONT_NO_SPELLCHECK: {
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setNoSpellcheck(FONT_TOGGLE);
+		toggleAndShow(cur, this, font);
+		break;
+	}
+
 	case LFUN_FONT_SIZE: {
 		Font font(ignore_font, ignore_language);
 		setLyXSize(to_utf8(cmd.argument()), font.fontInfo());
@@ -2471,10 +2521,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
 		Font font(ignore_font, lang);
 		toggleAndShow(cur, this, font, toggle);
-		// We need a buffer update if we change the language
-		// of an info inset
-		if (cur.insetInSelection(INFO_CODE))
-			cur.forceBufferUpdate();
 		break;
 	}
 
@@ -2509,10 +2555,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			freeFonts.push(make_pair(props, font));
 			toggleall = toggle;
 			toggleAndShow(cur, this, font, toggleall);
-			// We need a buffer update if we change the language
-			// of an info inset
-			if (cur.insetInSelection(INFO_CODE))
-				cur.forceBufferUpdate();
 			cur.message(bformat(_("Text properties applied: %1$s"), props));
 		} else
 			LYXERR0("Invalid argument of textstyle-update");
@@ -2646,8 +2688,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		docstring arg = cmd.argument();
 		if (arg.empty()) {
 			arg = cur.selectionAsString(false);
-			// FIXME
+			// Too large. We unselect if needed and try to get
+			// the first word in selection or under cursor
 			if (arg.size() > 100 || arg.empty()) {
+				if (cur.selection()) {
+					DocIterator selbeg = cur.selectionBegin();
+					cur.clearSelection();
+					setCursorIntern(cur, selbeg.pit(), selbeg.pos());
+					cur.screenUpdateFlags(Update::Force);
+				}
 				// Get word or selection
 				selectWordWhenUnderCursor(cur, WHOLE_WORD);
 				arg = cur.selectionAsString(false);
@@ -2692,6 +2741,65 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
+	case LFUN_SPELLING_ADD_LOCAL: {
+		Language const * language = getLanguage(cur, cmd.getArg(1));
+		docstring word = from_utf8(cmd.getArg(0));
+		if (word.empty()) {
+			word = cur.selectionAsString(false);
+			if (word.size() > 100)
+				break;
+			if (word.empty()) {
+				// Get word or selection
+				selectWordWhenUnderCursor(cur, WHOLE_WORD);
+				word = cur.selectionAsString(false);
+			}
+		}
+		WordLangTuple wl(word, language);
+		if (!bv->buffer().params().spellignored(wl)) {
+			cur.recordUndoBufferParams();
+			bv->buffer().params().spellignore().push_back(wl);
+			cur.recordUndo();
+			// trigger re-check of whole buffer
+			bv->buffer().requestSpellcheck();
+		}
+		break;
+	}
+
+	case LFUN_SPELLING_REMOVE_LOCAL: {
+		Language const * language = getLanguage(cur, cmd.getArg(1));
+		docstring word = from_utf8(cmd.getArg(0));
+		if (word.empty()) {
+			word = cur.selectionAsString(false);
+			if (word.size() > 100)
+				break;
+			if (word.empty()) {
+				// Get word or selection
+				selectWordWhenUnderCursor(cur, WHOLE_WORD);
+				word = cur.selectionAsString(false);
+			}
+		}
+		WordLangTuple wl(word, language);
+		bool has_item = false;
+		vector<WordLangTuple>::const_iterator it = bv->buffer().params().spellignore().begin();
+		for (; it != bv->buffer().params().spellignore().end(); ++it) {
+			if (it->lang()->code() != wl.lang()->code())
+				continue;
+			if (it->word() == wl.word()) {
+				has_item = true;
+				break;
+			}
+		}
+		if (has_item) {
+			cur.recordUndoBufferParams();
+			bv->buffer().params().spellignore().erase(it);
+			cur.recordUndo();
+			// trigger re-check of whole buffer
+			bv->buffer().requestSpellcheck();
+		}
+		break;
+	}
+
+
 	case LFUN_SPELLING_IGNORE: {
 		Language const * language = getLanguage(cur, cmd.getArg(1));
 		docstring word = from_utf8(cmd.getArg(0));
@@ -2759,19 +2867,23 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		}
 		break;
 
-	case LFUN_OUTLINE_UP:
+	case LFUN_OUTLINE_UP: {
+		pos_type const opos = cur.pos();
 		outline(OutlineUp, cur, this);
-		setCursor(cur, cur.pit(), 0);
+		setCursor(cur, cur.pit(), opos);
 		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
+	}
 
-	case LFUN_OUTLINE_DOWN:
+	case LFUN_OUTLINE_DOWN: {
+		pos_type const opos = cur.pos();
 		outline(OutlineDown, cur, this);
-		setCursor(cur, cur.pit(), 0);
+		setCursor(cur, cur.pit(), opos);
 		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
+	}
 
 	case LFUN_OUTLINE_IN:
 		outline(OutlineIn, cur, this);
@@ -2785,32 +2897,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		needsUpdate = true;
 		break;
 
-	case LFUN_SERVER_GET_STATISTICS:
-		{
-			DocIterator from, to;
-			if (cur.selection()) {
-				from = cur.selectionBegin();
-				to = cur.selectionEnd();
-			} else {
-				from = doc_iterator_begin(cur.buffer());
-				to = doc_iterator_end(cur.buffer());
-			}
-
-			cur.buffer()->updateStatistics(from, to);
-			string const arg0 = cmd.getArg(0);
-			if (arg0 == "words") {
-				cur.message(convert<docstring>(cur.buffer()->wordCount()));
-			} else if (arg0 == "chars") {
-				cur.message(convert<docstring>(cur.buffer()->charCount(false)));
-			} else if (arg0 == "chars-space") {
-				cur.message(convert<docstring>(cur.buffer()->charCount(true)));
-			} else {
-				cur.message(convert<docstring>(cur.buffer()->wordCount()) + " "
-				+ convert<docstring>(cur.buffer()->charCount(false)) + " "
-				+ convert<docstring>(cur.buffer()->charCount(true)));
-			}
+	case LFUN_SERVER_GET_STATISTICS: {
+		DocIterator from, to;
+		if (cur.selection()) {
+			from = cur.selectionBegin();
+			to = cur.selectionEnd();
+		} else {
+			from = doc_iterator_begin(cur.buffer());
+			to = doc_iterator_end(cur.buffer());
+		}
+
+		cur.buffer()->updateStatistics(from, to);
+		string const arg0 = cmd.getArg(0);
+		if (arg0 == "words") {
+			cur.message(convert<docstring>(cur.buffer()->wordCount()));
+		} else if (arg0 == "chars") {
+			cur.message(convert<docstring>(cur.buffer()->charCount(false)));
+		} else if (arg0 == "chars-space") {
+			cur.message(convert<docstring>(cur.buffer()->charCount(true)));
+		} else {
+			cur.message(convert<docstring>(cur.buffer()->wordCount()) + " "
+			+ convert<docstring>(cur.buffer()->charCount(false)) + " "
+			+ convert<docstring>(cur.buffer()->charCount(true)));
 		}
 		break;
+	}
 
 	default:
 		LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text");
@@ -2875,7 +2986,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 
 bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
-			FuncStatus & flag) const
+			FuncStatus & status) const
 {
 	LBUFERR(this == cur.text());
 
@@ -2883,7 +2994,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	bool enable = true;
 	bool allow_in_passthru = false;
 	InsetCode code = NO_CODE;
-	
+
 	switch (cmd.action()) {
 
 	case LFUN_DEPTH_DECREMENT:
@@ -2898,7 +3009,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		// FIXME We really should not allow this to be put, e.g.,
 		// in a footnote, or in ERT. But it would make sense in a
 		// branch, so I'm not sure what to do.
-		flag.setOnOff(cur.paragraph().params().startOfAppendix());
+		status.setOnOff(cur.paragraph().params().startOfAppendix());
 		break;
 
 	case LFUN_DIALOG_SHOW_NEW_INSET:
@@ -2915,6 +3026,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 			code = BRANCH_CODE;
 		else if (cmd.argument() == "citation")
 			code = CITE_CODE;
+		else if (cmd.argument() == "counter")
+			code = COUNTER_CODE;
 		else if (cmd.argument() == "ert")
 			code = ERT_CODE;
 		else if (cmd.argument() == "external")
@@ -3028,7 +3141,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 			if (cit == floats.end() ||
 					// and that we know how to generate a list of them
 			    (!cit->second.usesFloatPkg() && cit->second.listCommand().empty())) {
-				flag.setUnknown(true);
+				status.setUnknown(true);
 				// probably not necessary, but...
 				enable = false;
 			}
@@ -3051,16 +3164,22 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 	case LFUN_FLEX_INSERT: {
 		code = FLEX_CODE;
-		string s = cmd.getArg(0);
-		InsetLayout il =
-			cur.buffer()->params().documentClass().insetLayout(from_utf8(s));
-		if (il.lyxtype() != InsetLayout::CHARSTYLE &&
-		    il.lyxtype() != InsetLayout::CUSTOM &&
-		    il.lyxtype() != InsetLayout::ELEMENT &&
-		    il.lyxtype ()!= InsetLayout::STANDARD)
+		docstring s = from_utf8(cmd.getArg(0));
+		// Prepend "Flex:" prefix if not there
+		if (!prefixIs(s, from_ascii("Flex:")))
+			s = from_ascii("Flex:") + s;
+		if (!cur.buffer()->params().documentClass().hasInsetLayout(s))
 			enable = false;
-		break;
+		else {
+			InsetLyXType ilt =
+				cur.buffer()->params().documentClass().insetLayout(s).lyxtype();
+			if (ilt != InsetLyXType::CHARSTYLE
+			    && ilt != InsetLyXType::CUSTOM
+			    && ilt != InsetLyXType::STANDARD)
+				enable = false;
 		}
+		break;
+	}
 	case LFUN_BOX_INSERT:
 		code = BOX_CODE;
 		break;
@@ -3158,6 +3277,14 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		}
 		code = HYPERLINK_CODE;
 		break;
+	case LFUN_INDEXMACRO_INSERT: {
+		string const arg = cmd.getArg(0);
+		if (arg == "sortkey")
+			code = INDEXMACRO_SORTKEY_CODE;
+		else
+			code = INDEXMACRO_CODE;
+		break;
+	}
 	case LFUN_IPAMACRO_INSERT: {
 		string const arg = cmd.getArg(0);
 		if (arg == "deco")
@@ -3213,43 +3340,42 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 
 	case LFUN_FONT_EMPH:
-		flag.setOnOff(fontinfo.emph() == FONT_ON);
+		status.setOnOff(fontinfo.emph() == FONT_ON);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_ITAL:
-		flag.setOnOff(fontinfo.shape() == ITALIC_SHAPE);
+		status.setOnOff(fontinfo.shape() == ITALIC_SHAPE);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_NOUN:
-		flag.setOnOff(fontinfo.noun() == FONT_ON);
+		status.setOnOff(fontinfo.noun() == FONT_ON);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_BOLD:
 	case LFUN_FONT_BOLDSYMBOL:
-		flag.setOnOff(fontinfo.series() == BOLD_SERIES);
+		status.setOnOff(fontinfo.series() == BOLD_SERIES);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_SANS:
-		flag.setOnOff(fontinfo.family() == SANS_FAMILY);
+		status.setOnOff(fontinfo.family() == SANS_FAMILY);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_ROMAN:
-		flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
+		status.setOnOff(fontinfo.family() == ROMAN_FAMILY);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_TYPEWRITER:
-		flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
+		status.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
 		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_CUT:
-	case LFUN_COPY:
 		enable = cur.selection();
 		break;
 
@@ -3316,6 +3442,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 
 	case LFUN_PRIMARY_SELECTION_PASTE:
+		status.setUnknown(!theSelection().supported());
 		enable = cur.selection() || !theSelection().empty();
 		break;
 
@@ -3353,11 +3480,17 @@ 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;
 				}
+				if (beg != end && it.paragraph().hasChangedInsets(beg, end)) {
+					enable = true;
+					break;
+				}
 				if (in_last_par)
 					break;
 			}
@@ -3394,7 +3527,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		if (!ins)
 			enable = false;
 		else
-			flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
+			status.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
 		break;
 	}
 
@@ -3406,7 +3539,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_LANGUAGE:
 		enable = !cur.paragraph().isPassThru();
-		flag.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang());
+		status.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang());
 		break;
 
 	case LFUN_PARAGRAPH_BREAK:
@@ -3414,13 +3547,15 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 
 	case LFUN_SPELLING_ADD:
+	case LFUN_SPELLING_ADD_LOCAL:
+	case LFUN_SPELLING_REMOVE_LOCAL:
 	case LFUN_SPELLING_IGNORE:
 	case LFUN_SPELLING_REMOVE:
-		enable = theSpellChecker() != NULL;
+		enable = theSpellChecker() != nullptr;
 		if (enable && !cmd.getArg(1).empty()) {
 			// validate explicitly given language
 			Language const * const lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
-			enable &= lang != NULL;
+			enable &= lang != nullptr;
 		}
 		break;
 
@@ -3430,8 +3565,10 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		docstring const req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
 		docstring const layout = resolveLayout(req_layout, cur);
 
-		enable = !owner_->forcePlainLayout() && !layout.empty();
-		flag.setOnOff(isAlreadyLayout(layout, cur));
+		// FIXME: make this work in multicell selection case
+		enable = !owner_->forcePlainLayout() && !layout.empty() && !cur.selIsMultiCell();
+		status.setOnOff(!owner_->forcePlainLayout() && !cur.selIsMultiCell()
+		                && isAlreadyLayout(layout, cur));
 		break;
 	}
 
@@ -3511,6 +3648,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_FONT_CROSSOUT:
 	case LFUN_FONT_UNDERUNDERLINE:
 	case LFUN_FONT_UNDERWAVE:
+	case LFUN_FONT_NO_SPELLCHECK:
 	case LFUN_TEXTSTYLE_UPDATE:
 		enable = !cur.paragraph().isPassThru();
 		break;
@@ -3640,7 +3778,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		|| (cur.paragraph().layout().pass_thru && !allow_in_passthru)))
 		enable = false;
 
-	flag.setEnabled(enable);
+	status.setEnabled(enable);
 	return true;
 }
 
@@ -3659,9 +3797,9 @@ void Text::pasteString(Cursor & cur, docstring const & clip,
 
 
 // FIXME: an item inset would make things much easier.
-bool Text::inDescriptionItem(Cursor & cur) const
+bool Text::inDescriptionItem(Cursor const & cur) const
 {
-	Paragraph & par = cur.paragraph();
+	Paragraph const & par = cur.paragraph();
 	pos_type const pos = cur.pos();
 	pos_type const body_pos = par.beginOfBody();
 
@@ -3680,12 +3818,8 @@ std::vector<docstring> Text::getFreeFonts() const
 {
 	vector<docstring> ffList;
 
-	FontStack::const_iterator cit = freeFonts.begin();
-	FontStack::const_iterator end = freeFonts.end();
-	for (; cit != end; ++cit)
-		// we do not use cit-> here because gcc 2.9x does not
-		// like it (JMarc)
-		ffList.push_back((*cit).first);
+	for (auto const & f : freeFonts)
+		ffList.push_back(f.first);
 
 	return ffList;
 }