X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=26d6d7136bbbe573e298de4bb64cc17081d3d83c;hb=86bfa10abb57a0af7bbddc3af2c7cdb891c77203;hp=f4190d2e95cb2e0c0dcc2dc3b559c9c7969d95b3;hpb=bceaa7f92971f62014da43557815479d40adf551;p=lyx.git

diff --git a/src/Text3.cpp b/src/Text3.cpp
index f4190d2e95..26d6d7136b 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"
@@ -60,6 +57,7 @@
 #include "insets/InsetFloatList.h"
 #include "insets/InsetGraphics.h"
 #include "insets/InsetGraphicsParams.h"
+#include "insets/InsetInfo.h"
 #include "insets/InsetIPAMacro.h"
 #include "insets/InsetNewline.h"
 #include "insets/InsetQuotes.h"
@@ -69,18 +67,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;
@@ -89,6 +88,7 @@ using namespace lyx::support;
 namespace lyx {
 
 using cap::copySelection;
+using cap::copySelectionToTemp;
 using cap::cutSelection;
 using cap::cutSelectionToTemp;
 using cap::pasteFromStack;
@@ -102,13 +102,14 @@ using cap::pasteSimpleText;
 using frontend::Clipboard;
 
 // globals...
-static Font freefont(ignore_font, ignore_language);
+typedef limited_stack<pair<docstring, Font>> FontStack;
+static FontStack freeFonts(15);
 static bool toggleall = false;
 
 static void toggleAndShow(Cursor & cur, Text * text,
-	Font const & font, bool toggleall = true)
+	Font const & font, bool togall = true)
 {
-	text->toggleFree(cur, font, toggleall);
+	text->toggleFree(cur, font, togall);
 
 	if (font.language() != ignore_language ||
 	    font.fontInfo().number() != FONT_IGNORE) {
@@ -249,20 +250,7 @@ static bool doInsertInset(Cursor & cur, Text * text,
 		ci->setButtonLabel();
 
 	cur.recordUndo();
-	if (cmd.action() == LFUN_INDEX_INSERT) {
-		docstring ds = subst(text->getStringToIndex(cur), '\n', ' ');
-		text->insertInset(cur, inset);
-		if (edit)
-			inset->edit(cur, true);
-		// Now put this into inset
-		Font const f(inherit_font, cur.current_font.language());
-		if (!ds.empty()) {
-			cur.text()->insertStringAsLines(cur, ds, f);
-			cur.leaveInset(*inset);
-		}
-		return true;
-	}
-	else if (cmd.action() == LFUN_ARGUMENT_INSERT) {
+	if (cmd.action() == LFUN_ARGUMENT_INSERT) {
 		bool cotextinsert = false;
 		InsetArgument const * const ia = static_cast<InsetArgument const *>(inset);
 		Layout const & lay = cur.paragraph().layout();
@@ -300,10 +288,28 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	}
 
 	bool gotsel = false;
+	bool move_layout = false;
 	if (cur.selection()) {
-		cutSelectionToTemp(cur, false, pastesel);
+		if (cmd.action() == LFUN_INDEX_INSERT)
+			copySelectionToTemp(cur);
+		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());
+				move_layout = true;
+			}
+		}
 		cur.clearSelection();
 		gotsel = true;
+	} else if (cmd.action() == LFUN_INDEX_INSERT) {
+		gotsel = text->selectWordWhenUnderCursor(cur, WHOLE_WORD);
+		copySelectionToTemp(cur);
+		cur.clearSelection();
 	}
 	text->insertInset(cur, inset);
 
@@ -320,24 +326,22 @@ 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;
+		/* 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
@@ -351,12 +355,6 @@ static bool doInsertInset(Cursor & cur, Text * text,
 }
 
 
-string const freefont2string()
-{
-	return freefont.toString(toggleall);
-}
-
-
 /// the type of outline operation
 enum OutlineOp {
 	OutlineUp, // Move this header with text down
@@ -366,17 +364,34 @@ enum OutlineOp {
 };
 
 
-static void outline(OutlineOp mode, Cursor & cur)
+static void insertSeparator(Cursor const & cur, depth_type const depth)
+{
+	Buffer & buf = *cur.buffer();
+	lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
+	DocumentClass const & tc = buf.params().documentClass();
+	lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
+				  + from_ascii("\" ignoreautonests")));
+	// FIXME: Bibitem mess!
+	if (cur.prevInset() && cur.prevInset()->lyxCode() == BIBITEM_CODE)
+		lyx::dispatch(FuncRequest(LFUN_CHAR_DELETE_BACKWARD));
+	lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
+	while (cur.paragraph().params().depth() > depth)
+		lyx::dispatch(FuncRequest(LFUN_DEPTH_DECREMENT));
+}
+
+
+static void outline(OutlineOp mode, Cursor & cur, Text * text)
 {
 	Buffer & buf = *cur.buffer();
 	pit_type & pit = cur.pit();
 	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();
+	depth_type const current_depth = cur.paragraph().params().depth();
 
 	int const thistoclevel = buf.text().getTocLevel(distance(bgn, start));
 	int toclevel;
@@ -411,27 +426,47 @@ static void outline(OutlineOp mode, Cursor & cur)
 			// Not found; do nothing
 			if (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel)
 				return;
+			pit_type newpit = distance(bgn, dest);
+			pit_type const len = distance(start, finish);
+			pit_type const deletepit = pit + len;
+			buf.undo().recordUndo(cur, newpit, deletepit - 1);
 			// If we move an environment upwards, make sure it is
-			// separated from its new neighbour below.
+			// separated from its new neighbour below:
+			// If an environment of the same layout follows, and the moved
+			// paragraph sequence does not end with a separator, insert one.
 			ParagraphList::iterator lastmoved = finish;
 			--lastmoved;
 			if (start->layout().isEnvironment()
-				&& dest->layout() == start->layout()
-				&& !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) {
-				cur.pit() = distance(bgn, finish);
-				cur.pos() = 0;
-				lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
-				DocumentClass const & tc = buf.params().documentClass();
-				lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
-							  + from_ascii("\" ignoreautonests")));
-				lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
-				++finish;
+			    && dest->layout() == start->layout()
+			    && !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) {
+				cur.pit() = distance(bgn, lastmoved);
+				cur.pos() = cur.lastpos();
+				insertSeparator(cur, current_depth);
 				cur.pit() = pit;
 			}
-			pit_type const newpit = distance(bgn, dest);
-			pit_type const len = distance(start, finish);
-			pit_type const deletepit = pit + len;
-			buf.undo().recordUndo(cur, newpit, deletepit - 1);
+			// Likewise, if we moved an environment upwards, make sure it
+			// is separated from its new neighbour above.
+			// The paragraph before the target of movement
+			if (dest != bgn) {
+				ParagraphList::iterator before = dest;
+				--before;
+				// Get the parent paragraph (outer in nested context)
+				pit_type const parent =
+					before->params().depth() > current_depth
+						? text->depthHook(distance(bgn, before), current_depth)
+						: distance(bgn, before);
+				// If a environment with same layout preceeds the moved one in the new
+				// position, and there is no separator yet, insert one.
+				if (start->layout().isEnvironment()
+				    && pars[parent].layout() == start->layout()
+				    && !before->isEnvSeparator(before->beginOfBody())) {
+					cur.pit() = distance(bgn, before);
+					cur.pos() = cur.lastpos();
+					insertSeparator(cur, current_depth);
+					cur.pit() = pit;
+				}
+			}
+			newpit = distance(bgn, dest);
 			pars.splice(dest, start, finish);
 			cur.pit() = newpit;
 			break;
@@ -449,26 +484,45 @@ static void outline(OutlineOp mode, Cursor & cur)
 				      && toclevel <= thistoclevel)
 					break;
 			}
-			// One such was found:
+			// One such was found, so go on...
 			// If we move an environment downwards, make sure it is
-			// separated from its new neighbour below.
+			// separated from its new neighbour above.
+			pit_type newpit = distance(bgn, dest);
+			buf.undo().recordUndo(cur, pit, newpit - 1);
+			// The paragraph before the target of movement
+			ParagraphList::iterator before = dest;
+			--before;
+			// Get the parent paragraph (outer in nested context)
+			pit_type const parent =
+				before->params().depth() > current_depth
+					? text->depthHook(distance(bgn, before), current_depth)
+					: distance(bgn, before);
+			// If a environment with same layout preceeds the moved one in the new
+			// position, and there is no separator yet, insert one.
+			if (start->layout().isEnvironment()
+			    && pars[parent].layout() == start->layout()
+			    && !before->isEnvSeparator(before->beginOfBody())) {
+				cur.pit() = distance(bgn, before);
+				cur.pos() = cur.lastpos();
+				insertSeparator(cur, current_depth);
+				cur.pit() = pit;
+			}
+			// Likewise, make sure moved environments are separated
+			// from their new neighbour below:
+			// If an environment of the same layout follows, and the moved
+			// paragraph sequence does not end with a separator, insert one.
 			ParagraphList::iterator lastmoved = finish;
 			--lastmoved;
-			if (start->layout().isEnvironment()
-				&& dest->layout() == start->layout()
-				&& !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) {
-				cur.pit() = distance(bgn, finish);
-				cur.pos() = 0;
-				lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
-				DocumentClass const & tc = buf.params().documentClass();
-				lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
-							  + from_ascii("\" ignoreautonests")));
-				lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
-				++finish;
+			if (dest != end
+			    && start->layout().isEnvironment()
+			    && dest->layout() == start->layout()
+			    && !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) {
+				cur.pit() = distance(bgn, lastmoved);
+				cur.pos() = cur.lastpos();
+				insertSeparator(cur, current_depth);
 				cur.pit() = pit;
 			}
-			pit_type newpit = distance(bgn, dest);
-			buf.undo().recordUndo(cur, pit, newpit - 1);
+			newpit = distance(bgn, dest);
 			pit_type const len = distance(start, finish);
 			pars.splice(dest, start, finish);
 			cur.pit() = newpit - len;
@@ -484,16 +538,14 @@ static void outline(OutlineOp mode, Cursor & cur)
 					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;
 					}
 				}
@@ -512,18 +564,67 @@ 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());
 }
 
 
 namespace {
 
-	Language const * getLanguage(Cursor const & cur, string const & lang) {
-		return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang);
+Language const * getLanguage(Cursor const & cur, string const & lang)
+{
+	return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang);
+}
+
+
+docstring resolveLayout(docstring layout, DocIterator const & dit)
+{
+	Paragraph const & par = dit.paragraph();
+	DocumentClass const & tclass = dit.buffer()->params().documentClass();
+
+	if (layout.empty())
+		layout = tclass.defaultLayoutName();
+
+	if (dit.inset().forcePlainLayout(dit.idx()))
+		// in this case only the empty layout is allowed
+		layout = tclass.plainLayoutName();
+	else if (par.usePlainLayout()) {
+		// in this case, default layout maps to empty layout
+		if (layout == tclass.defaultLayoutName())
+			layout = tclass.plainLayoutName();
+	} else {
+		// otherwise, the empty layout maps to the default
+		if (layout == tclass.plainLayoutName())
+			layout = tclass.defaultLayoutName();
+	}
+
+	// If the entry is obsolete, use the new one instead.
+	if (tclass.hasLayout(layout)) {
+		docstring const & obs = tclass[layout].obsoleted_by();
+		if (!obs.empty())
+			layout = obs;
 	}
+	if (!tclass.hasLayout(layout))
+		layout.clear();
+	return layout;
+}
+
+
+bool isAlreadyLayout(docstring const & layout, CursorData const & cur)
+{
+	ParagraphList const & pars = cur.text()->paragraphs();
+
+	pit_type pit = cur.selBegin().pit();
+	pit_type const epit = cur.selEnd().pit() + 1;
+	for ( ; pit != epit; ++pit)
+		if (pars[pit].layout().name() != layout)
+			return false;
+
+	return true;
+}
+
 
 } // namespace
 
@@ -573,7 +674,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();
@@ -618,7 +718,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_WORD_DELETE_FORWARD:
 		if (cur.selection())
-			cutSelection(cur, true, false);
+			cutSelection(cur, false);
 		else
 			deleteWordForward(cur, cmd.getArg(0) == "force");
 		finishChange(cur, false);
@@ -626,7 +726,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_WORD_DELETE_BACKWARD:
 		if (cur.selection())
-			cutSelection(cur, true, false);
+			cutSelection(cur, false);
 		else
 			deleteWordBackward(cur, cmd.getArg(0) == "force");
 		finishChange(cur, false);
@@ -634,7 +734,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_LINE_DELETE_FORWARD:
 		if (cur.selection())
-			cutSelection(cur, true, false);
+			cutSelection(cur, false);
 		else
 			tm->deleteLineForward(cur);
 		finishChange(cur, false);
@@ -827,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);
@@ -857,7 +965,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();
@@ -1001,7 +1109,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
@@ -1036,8 +1144,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		} else {
 			// Maybe we shouldn't allow tabs within a line, because they
 			// are not (yet) aligned as one might do expect.
-			FuncRequest cmd(LFUN_SELF_INSERT, from_ascii("\t"));
-			dispatch(cur, cmd);
+			FuncRequest ncmd(LFUN_SELF_INSERT, from_ascii("\t"));
+			dispatch(cur, ncmd);
 		}
 		break;
 	}
@@ -1112,7 +1220,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			needsUpdate |= erase(cur);
 			cur.resetAnchor();
 		} else {
-			cutSelection(cur, true, false);
+			cutSelection(cur, false);
+			cur.setCurrentFont();
 			singleParUpdate = false;
 		}
 		moveCursor(cur, false);
@@ -1142,7 +1251,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				}
 			}
 		} else {
-			cutSelection(cur, true, false);
+			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;
@@ -1155,7 +1271,8 @@ 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()
 		    && pars_[prev].layout().isEnvironment()
@@ -1183,13 +1300,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// If we have a list and autoinsert item insets,
 		// insert them now.
 		Layout::LaTeXArgMap args = par.layout().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 (arg.autoinsert && prefixIs((*lait).first, "item:")) {
-				FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first);
-				lyx::dispatch(cmd);
+		for (auto const & thearg : args) {
+			Layout::latexarg arg = thearg.second;
+			if (arg.autoinsert && prefixIs(thearg.first, "item:")) {
+				FuncRequest cmd2(LFUN_ARGUMENT_INSERT, thearg.first);
+				lyx::dispatch(cmd2);
 			}
 		}
 		break;
@@ -1229,7 +1344,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 			*/
 			if (cur.selection())
-				cutSelection(cur, true, false);
+				cutSelection(cur, false);
 			cur.insert(inset);
 			cur.forceBufferUpdate();
 			if (inset->editable() && inset->asInsetText())
@@ -1256,7 +1371,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	case LFUN_SET_GRAPHICS_GROUP: {
+	case LFUN_INSET_SPLIT: {
+		if (splitInset(cur)) {
+			needsUpdate = true;
+			cur.forceBufferUpdate();
+		}
+		break;
+	}
+
+	case LFUN_GRAPHICS_SET_GROUP: {
 		InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
 		if (!ins)
 			break;
@@ -1415,21 +1538,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		}
 
 		bv->buffer().errors("Paste");
+		bv->buffer().updatePreviews(); // bug 11619
 		cur.clearSelection(); // bug 393
 		cur.finishUndo();
 		break;
 	}
 
 	case LFUN_CUT:
-		cutSelection(cur, true, true);
+		cutSelection(cur, true);
 		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()))
@@ -1453,67 +1572,37 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		cur.message(cur.paragraph().layout().name());
 		break;
 
-	case LFUN_LAYOUT: {
+	case LFUN_LAYOUT:
+	case LFUN_LAYOUT_TOGGLE: {
 		bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests";
-		docstring layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
-		LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout));
-
-		Paragraph const & para = cur.paragraph();
-		docstring const old_layout = para.layout().name();
-		DocumentClass const & tclass = bv->buffer().params().documentClass();
-
-		if (layout.empty())
-			layout = tclass.defaultLayoutName();
-
-		if (owner_->forcePlainLayout())
-			// in this case only the empty layout is allowed
-			layout = tclass.plainLayoutName();
-		else if (para.usePlainLayout()) {
-			// in this case, default layout maps to empty layout
-			if (layout == tclass.defaultLayoutName())
-				layout = tclass.plainLayoutName();
-		} else {
-			// otherwise, the empty layout maps to the default
-			if (layout == tclass.plainLayoutName())
-				layout = tclass.defaultLayoutName();
-		}
+		docstring req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
+		LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(req_layout));
 
-		bool hasLayout = tclass.hasLayout(layout);
-
-		// If the entry is obsolete, use the new one instead.
-		if (hasLayout) {
-			docstring const & obs = tclass[layout].obsoleted_by();
-			if (!obs.empty())
-				layout = obs;
-		}
-
-		if (!hasLayout) {
-			cur.errorMessage(from_utf8(N_("Layout ")) + cmd.argument() +
+		docstring layout = resolveLayout(req_layout, cur);
+		if (layout.empty()) {
+			cur.errorMessage(from_utf8(N_("Layout ")) + req_layout +
 				from_utf8(N_(" not known")));
 			break;
 		}
 
-		bool change_layout = (old_layout != layout);
+		docstring const old_layout = cur.paragraph().layout().name();
+		bool change_layout = !isAlreadyLayout(layout, cur);
 
-		if (!change_layout && cur.selection() &&
-			cur.selBegin().pit() != cur.selEnd().pit())
-		{
-			pit_type spit = cur.selBegin().pit();
-			pit_type epit = cur.selEnd().pit() + 1;
-			while (spit != epit) {
-				if (pars_[spit].layout().name() != old_layout) {
-					change_layout = true;
-					break;
-				}
-				++spit;
-			}
+		if (cmd.action() == LFUN_LAYOUT_TOGGLE && !change_layout) {
+			change_layout = true;
+			layout = resolveLayout(docstring(), cur);
 		}
 
 		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()
@@ -1522,14 +1611,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		}
 
-		Layout::LaTeXArgMap args = tclass[layout].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;
+		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) {
-				FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first);
-				lyx::dispatch(cmd);
+				// 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;
 			}
 		}
 
@@ -1546,7 +1641,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();
@@ -1571,9 +1666,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);
@@ -1588,6 +1694,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		DocumentClass const & tc = bv->buffer().params().documentClass();
 		lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
 					  + from_ascii("\" ignoreautonests")));
+		// FIXME: Bibitem mess!
+		if (cur.prevInset() && cur.prevInset()->lyxCode() == BIBITEM_CODE)
+			lyx::dispatch(FuncRequest(LFUN_CHAR_DELETE_BACKWARD));
 		lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
 		if (before) {
 			cur.backwardPos();
@@ -1598,13 +1707,21 @@ 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))
-				lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+			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);
 		}
 
@@ -1639,21 +1756,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bv->buffer().errors("Paste");
 		break;
 
-	case LFUN_UNICODE_INSERT: {
-		if (cmd.argument().empty())
-			break;
-		docstring hexstring = cmd.argument();
-		if (isHex(hexstring)) {
-			char_type c = hexToInt(hexstring);
-			if (c >= 32 && c < 0x10ffff) {
-				lyxerr << "Inserting c: " << c << endl;
-				docstring s = docstring(1, c);
-				lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, s));
-			}
-		}
-		break;
-	}
-
 	case LFUN_QUOTE_INSERT: {
 		cap::replaceSelection(cur);
 		cur.recordUndo();
@@ -1697,27 +1799,22 @@ 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();
 		break;
 	}
 
-	case LFUN_DATE_INSERT: {
-		string const format = cmd.argument().empty()
-			? lyxrc.date_insert_format : to_utf8(cmd.argument());
-		string const time = formatted_time(current_time(), format);
-		lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, time));
-		break;
-	}
-
 	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;
 		}
@@ -1761,7 +1858,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;
 			}
@@ -1874,15 +1971,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// "auto_region_delete", which defaults to
 		// true (on).
 
-		if (lyxrc.auto_region_delete && cur.selection())
-			cutSelection(cur, false, false);
-
+		if (lyxrc.auto_region_delete && cur.selection()) {
+			cutSelection(cur, false);
+			cur.setCurrentFont();
+		}
 		cur.clearSelection();
 
-		docstring::const_iterator cit = cmd.argument().begin();
-		docstring::const_iterator const end = cmd.argument().end();
-		for (; cit != end; ++cit)
-			bv->translateAndInsert(*cit, this, cur);
+		for (char_type c : cmd.argument())
+			bv->translateAndInsert(c, this, cur);
 
 		cur.resetAnchor();
 		moveCursor(cur, false);
@@ -1955,22 +2051,18 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_INFO_INSERT: {
-		Inset * inset;
-		if (cmd.argument().empty() && cur.selection()) {
-			// if command argument is empty use current selection as parameter.
-			docstring ds = cur.selectionAsString(false);
-			cutSelection(cur, true, false);
-			FuncRequest cmd0(cmd, ds);
-			inset = createInset(cur.buffer(), cmd0);
+		if (cmd.argument().empty()) {
+			bv->showDialog("info", cur.current_font.language()->lang());
 		} else {
+			Inset * inset;
 			inset = createInset(cur.buffer(), cmd);
+			if (!inset)
+				break;
+			cur.recordUndo();
+			insertInset(cur, inset);
+			cur.forceBufferUpdate();
+			cur.posForward();
 		}
-		if (!inset)
-			break;
-		cur.recordUndo();
-		insertInset(cur, inset);
-		cur.forceBufferUpdate();
-		cur.posForward();
 		break;
 	}
 	case LFUN_CAPTION_INSERT:
@@ -1991,6 +2083,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// inside it.
 		doInsertInset(cur, this, cmd, true, true);
 		cur.posForward();
+		/* The font of the inset is computed 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 correct. 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();
@@ -2002,18 +2101,31 @@ 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();
-		Layout::LaTeXArgMap::const_iterator lait = args.begin();
-		Layout::LaTeXArgMap::const_iterator const laend = args.end();
-		for (; lait != laend; ++lait) {
-			Layout::latexarg arg = (*lait).second;
+		bool autoargs = false, inautoarg = false;
+		Layout::LaTeXArgMap args = cur.inset().getLayout().args();
+		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);
+			}
 			if (arg.autoinsert) {
 				// The cursor might have been invalidated by the replaceSelection.
 				cur.buffer()->changed(true);
-				FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first);
-				lyx::dispatch(cmd);
+				// 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, argt.first);
+				lyx::dispatch(cmd2);
 				autoargs = true;
+				inautoarg = true;
 			}
 		}
 		if (!autoargs) {
@@ -2027,14 +2139,77 @@ 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);
+		string const rows = cmd.getArg(1);
+		string const cols = cmd.getArg(2);
+		if (cols.empty() || !isStrInt(cols)
+		    || rows.empty() || !isStrInt(rows))
+			break;
+		int const r = convert<int>(rows);
+		int const c = convert<int>(cols);
+
+		string suffix;
+		if (r == 1)
+			suffix = "_1x1";
+		else if (r == 2)
+			suffix = "_1x2";
+		FileName const tabstyle = libFileSearch("tabletemplates",
+							style + suffix + ".lyx", "lyx");
+		if (tabstyle.empty())
+			    break;
+		UndoGroupHelper ugh(cur.buffer());
+		cur.recordUndo();
+		FuncRequest cmd2(LFUN_FILE_INSERT, tabstyle.absFileName() + " ignorelang");
+		lyx::dispatch(cmd2);
+		// go into table
+		cur.backwardPos();
+		if (r > 2) {
+			// move one cell up to middle cell
+			cur.up();
+			// add the missing rows
+			int const addrows = r - 3;
+			for (int i = 0 ; i < addrows ; ++i) {
+				FuncRequest fr(LFUN_TABULAR_FEATURE, "append-row");
+				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();
 		break;
+	}
 
 	case LFUN_FLOAT_INSERT:
 	case LFUN_FLOAT_WIDE_INSERT:
@@ -2091,9 +2266,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_NOMENCL_INSERT: {
 		InsetCommandParams p(NOMENCL_CODE);
-		if (cmd.argument().empty())
-			p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor());
-		else
+		if (cmd.argument().empty()) {
+			p["symbol"] =
+				bv->cursor().innerText()->getStringForDialog(bv->cursor());
+			cur.clearSelection();
+		} else
 			p["symbol"] = cmd.argument();
 		string const data = InsetCommand::params2string(p);
 		bv->showDialog("nomenclature", data);
@@ -2298,6 +2475,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());
@@ -2319,27 +2503,51 @@ 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;
 	}
 
-	case LFUN_TEXTSTYLE_APPLY:
-		toggleAndShow(cur, this, freefont, toggleall);
-		cur.message(_("Character set"));
+	case LFUN_TEXTSTYLE_APPLY: {
+		unsigned int num = 0;
+		string const arg = to_utf8(cmd.argument());
+		// Argument?
+		if (!arg.empty()) {
+			if (isStrUnsignedInt(arg)) {
+				num = convert<uint>(arg);
+				if (num >= freeFonts.size()) {
+					cur.message(_("Invalid argument (number exceeds stack size)!"));
+					break;
+				}
+			} else {
+				cur.message(_("Invalid argument (must be a non-negative number)!"));
+				break;
+			}
+		}
+		toggleAndShow(cur, this, freeFonts[num].second, toggleall);
+		cur.message(bformat(_("Text properties applied: %1$s"), freeFonts[num].first));
 		break;
+	}
 
 	// Set the freefont using the contents of \param data dispatched from
 	// the frontends and apply it at the current cursor location.
 	case LFUN_TEXTSTYLE_UPDATE: {
-		Font font;
+		Font font(ignore_font, ignore_language);
 		bool toggle;
 		if (font.fromString(to_utf8(cmd.argument()), toggle)) {
-			freefont = font;
+			docstring const props = font.stateText(&bv->buffer().params(), true);
+			freeFonts.push(make_pair(props, font));
 			toggleall = toggle;
-			toggleAndShow(cur, this, freefont, toggleall);
-			cur.message(_("Character set"));
-		} else {
-			lyxerr << "Argument not ok";
-		}
+			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");
 		break;
 	}
 
@@ -2426,7 +2634,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (tclass.floats().typeExist(to_utf8(cmd.argument()))) {
 			cur.recordUndo();
 			if (cur.selection())
-				cutSelection(cur, true, false);
+				cutSelection(cur, false);
 			breakParagraph(cur);
 
 			if (cur.lastpos() != 0) {
@@ -2470,8 +2678,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);
@@ -2516,6 +2731,75 @@ 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
+			WordLangTuple wl;
+			docstring_list suggestions;
+			Paragraph const & par = cur.paragraph();
+			pos_type from = cur.pos();
+			pos_type to = from;
+			par.spellCheck(from, to, wl, suggestions, true, true);
+		}
+		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
+			WordLangTuple wl;
+			docstring_list suggestions;
+			Paragraph const & par = cur.paragraph();
+			pos_type from = cur.pos();
+			pos_type to = from;
+			par.spellCheck(from, to, wl, suggestions, true, true);
+		}
+		break;
+	}
+
+
 	case LFUN_SPELLING_IGNORE: {
 		Language const * language = getLanguage(cur, cmd.getArg(1));
 		docstring word = from_utf8(cmd.getArg(0));
@@ -2584,83 +2868,60 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 
 	case LFUN_OUTLINE_UP: {
-		outline(OutlineUp, cur);
-		setCursor(cur, cur.pit(), 0);
-		// If we moved an environment upwards, make sure it is
-		// separated from its new neighbour above.
-		pit_type pit = cur.pit();
-		if (pit > 0 && pars_[pit].layout().isEnvironment()
-			&& pars_[pit - 1].layout() == pars_[pit].layout()) {
-			lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
-			DocumentClass const & tc = bv->buffer().params().documentClass();
-			lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
-						  + from_ascii("\" ignoreautonests")));
-			lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
-			setCursor(cur, pit + 1, 0);
-		}
+		pos_type const opos = cur.pos();
+		outline(OutlineUp, cur, this);
+		setCursor(cur, cur.pit(), opos);
 		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 	}
 
 	case LFUN_OUTLINE_DOWN: {
-		outline(OutlineDown, cur);
-		setCursor(cur, cur.pit(), 0);
-		// If we moved an environment downwards, make sure it is
-		// separated from its new neighbour above.
-		pit_type pit = cur.pit();
-		if (pit > 0 && pars_[pit].layout().isEnvironment()
-			&& pars_[pit - 1].layout() == pars_[pit].layout()) {
-			lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
-			DocumentClass const & tc = bv->buffer().params().documentClass();
-			lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
-						  + from_ascii("\" ignoreautonests")));
-			lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
-			setCursor(cur, pit + 1, 0);
-		}
+		pos_type const opos = cur.pos();
+		outline(OutlineDown, cur, this);
+		setCursor(cur, cur.pit(), opos);
 		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 	}
 
 	case LFUN_OUTLINE_IN:
-		outline(OutlineIn, cur);
+		outline(OutlineIn, cur, this);
 		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 
 	case LFUN_OUTLINE_OUT:
-		outline(OutlineOut, cur);
+		outline(OutlineOut, cur, this);
 		cur.forceBufferUpdate();
 		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");
@@ -2725,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());
 
@@ -2748,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:
@@ -2823,6 +3084,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_TABULAR_INSERT:
 		code = TABULAR_CODE;
 		break;
+	case LFUN_TABULAR_STYLE_INSERT:
+		code = TABULAR_CODE;
+		break;
 	case LFUN_MARGINALNOTE_INSERT:
 		code = MARGIN_CODE;
 		break;
@@ -2875,7 +3139,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;
 			}
@@ -2895,21 +3159,15 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	}
 	case LFUN_NOTE_INSERT:
 		code = NOTE_CODE;
-		// in commands (sections etc.) and description items,
-		// only Notes are allowed
-		enable = (cmd.argument().empty() || cmd.getArg(0) == "Note" ||
-			  (!cur.paragraph().layout().isCommand()
-			   && !inDescriptionItem(cur)));
 		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)
+		if (il.lyxtype() != InsetLyXType::CHARSTYLE &&
+		    il.lyxtype() != InsetLyXType::CUSTOM &&
+		    il.lyxtype ()!= InsetLyXType::STANDARD)
 			enable = false;
 		break;
 		}
@@ -2933,6 +3191,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 	case LFUN_INFO_INSERT:
 		code = INFO_CODE;
+		enable = cmd.argument().empty()
+			|| infoparams.validateArgument(cur.buffer(), cmd.argument(), true);
 		break;
 	case LFUN_ARGUMENT_INSERT: {
 		code = ARG_CODE;
@@ -3063,43 +3323,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;
 
@@ -3183,17 +3442,41 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_CHANGE_ACCEPT:
 	case LFUN_CHANGE_REJECT:
-		// In principle, these LFUNs should only be enabled if there
-		// is a change at the current position/in the current selection.
-		// However, without proper optimizations, this will inevitably
-		// result in unacceptable performance - just imagine a user who
-		// wants to select the complete content of a long document.
 		if (!cur.selection())
 			enable = cur.paragraph().isChanged(cur.pos());
-		else
-			// TODO: context-sensitive enabling of LFUN_CHANGE_ACCEPT/REJECT
-			// for selections.
-			enable = true;
+		else {
+			// will enable if there is a change in the selection
+			enable = false;
+
+			// cheap improvement for efficiency: using cached
+			// buffer variable, if there is no change in the
+			// document, no need to check further.
+			if (!cur.buffer()->areChangesPresent())
+				break;
+
+			for (DocIterator it = cur.selectionBegin(); ; it.forwardPar()) {
+				pos_type const beg = it.pos();
+				pos_type end;
+				bool const in_last_par = (it.pit() == cur.selectionEnd().pit() &&
+							  it.idx() == cur.selectionEnd().idx());
+				if (in_last_par)
+					end = cur.selectionEnd().pos();
+				else
+					// 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;
+			}
+		}
 		break;
 
 	case LFUN_OUTLINE_UP:
@@ -3221,12 +3504,12 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		enable = cur.paragraph().isPassThru();
 		break;
 
-	case LFUN_SET_GRAPHICS_GROUP: {
+	case LFUN_GRAPHICS_SET_GROUP: {
 		InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
 		if (!ins)
 			enable = false;
 		else
-			flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
+			status.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
 		break;
 	}
 
@@ -3236,16 +3519,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		enable = !inDescriptionItem(cur);
 		break;
 
-	case LFUN_DATE_INSERT: {
-		string const format = cmd.argument().empty()
-			? lyxrc.date_insert_format : to_utf8(cmd.argument());
-		enable = support::os::is_valid_strftime(format);
-		break;
-	}
-
 	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:
@@ -3253,25 +3529,26 @@ 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;
 
-	case LFUN_LAYOUT: {
-		DocumentClass const & tclass = cur.buffer()->params().documentClass();
+	case LFUN_LAYOUT:
+	case LFUN_LAYOUT_TOGGLE: {
 		bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests";
-		docstring layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
-		if (layout.empty())
-			layout = tclass.defaultLayoutName();
-		enable = !owner_->forcePlainLayout() && tclass.hasLayout(layout);
+		docstring const req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
+		docstring const layout = resolveLayout(req_layout, cur);
 
-		flag.setOnOff(layout == cur.paragraph().layout().name());
+		enable = !owner_->forcePlainLayout() && !layout.empty();
+		status.setOnOff(!owner_->forcePlainLayout() && isAlreadyLayout(layout, cur));
 		break;
 	}
 
@@ -3343,7 +3620,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_ACCENT_UMLAUT:
 	case LFUN_ACCENT_UNDERBAR:
 	case LFUN_ACCENT_UNDERDOT:
-	case LFUN_FONT_DEFAULT:
 	case LFUN_FONT_FRAK:
 	case LFUN_FONT_SIZE:
 	case LFUN_FONT_STATE:
@@ -3352,11 +3628,47 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_FONT_CROSSOUT:
 	case LFUN_FONT_UNDERUNDERLINE:
 	case LFUN_FONT_UNDERWAVE:
-	case LFUN_TEXTSTYLE_APPLY:
+	case LFUN_FONT_NO_SPELLCHECK:
 	case LFUN_TEXTSTYLE_UPDATE:
 		enable = !cur.paragraph().isPassThru();
 		break;
 
+	case LFUN_FONT_DEFAULT: {
+		Font font(inherit_font, ignore_language);
+		BufferParams const & bp = cur.buffer()->masterParams();
+		if (cur.selection()) {
+			enable = false;
+			// Check if we have a non-default font attribute
+			// in the selection range.
+			DocIterator const from = cur.selectionBegin();
+			DocIterator const to = cur.selectionEnd();
+			for (DocIterator dit = from ; dit != to && !dit.atEnd(); ) {
+				if (!dit.inTexted()) {
+					dit.forwardPos();
+					continue;
+				}
+				Paragraph const & par = dit.paragraph();
+				pos_type const pos = dit.pos();
+				Font tmp = par.getFontSettings(bp, pos);
+				if (tmp.fontInfo() != font.fontInfo()
+				    || tmp.language() != bp.language) {
+					enable = true;
+					break;
+				}
+				dit.forwardPos();
+			}
+			break;
+		}
+		// Disable if all is default already.
+		enable = (cur.current_font.fontInfo() != font.fontInfo()
+			  || cur.current_font.language() != bp.language);
+		break;
+	}
+
+	case LFUN_TEXTSTYLE_APPLY:
+		enable = !freeFonts.empty();
+		break;
+
 	case LFUN_WORD_DELETE_FORWARD:
 	case LFUN_WORD_DELETE_BACKWARD:
 	case LFUN_LINE_DELETE_FORWARD:
@@ -3376,6 +3688,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:
@@ -3429,6 +3742,12 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 	}
 
+	case LFUN_SEARCH_IGNORE: {
+		bool const value = cmd.getArg(1) == "true";
+		setIgnoreFormat(cmd.getArg(0), value);
+		break;
+	}
+
 	default:
 		return false;
 	}
@@ -3439,7 +3758,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;
 }
 
@@ -3458,9 +3777,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();
 
@@ -3474,4 +3793,15 @@ bool Text::inDescriptionItem(Cursor & cur) const
 		    && (pos == 0 || par.getChar(pos - 1) != ' ')));
 }
 
+
+std::vector<docstring> Text::getFreeFonts() const
+{
+	vector<docstring> ffList;
+
+	for (auto const & f : freeFonts)
+		ffList.push_back(f.first);
+
+	return ffList;
+}
+
 } // namespace lyx