X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText.cpp;h=8f30f4eb7c151f0c6a9d8c1986252949445d3c24;hb=7a000652c02f98dcff4d3c611b22af244409df73;hp=dc296384b266a22f76fecdd688677d12ccd1f048;hpb=5fc2662b1301a8e04db0fa8695e06b363c1de60e;p=lyx.git

diff --git a/src/Text.cpp b/src/Text.cpp
index dc296384b2..8f30f4eb7c 100644
--- a/src/Text.cpp
+++ b/src/Text.cpp
@@ -22,51 +22,43 @@
 
 #include "Author.h"
 #include "Buffer.h"
-#include "buffer_funcs.h"
 #include "BufferParams.h"
 #include "BufferView.h"
 #include "Changes.h"
 #include "CompletionList.h"
 #include "Cursor.h"
+#include "CursorSlice.h"
 #include "CutAndPaste.h"
-#include "DispatchResult.h"
 #include "Encoding.h"
 #include "ErrorList.h"
-#include "FuncRequest.h"
 #include "factory.h"
-#include "InsetList.h"
+#include "Font.h"
+#include "FuncRequest.h"
 #include "Language.h"
 #include "Layout.h"
-#include "Length.h"
 #include "Lexer.h"
 #include "lyxfind.h"
 #include "LyXRC.h"
 #include "Paragraph.h"
 #include "ParagraphParameters.h"
-#include "ParIterator.h"
 #include "TextClass.h"
 #include "TextMetrics.h"
-#include "WordLangTuple.h"
 #include "WordList.h"
 
+#include "insets/Inset.h"
 #include "insets/InsetText.h"
-#include "insets/InsetBibitem.h"
 #include "insets/InsetCaption.h"
-#include "insets/InsetNewline.h"
-#include "insets/InsetNewpage.h"
-#include "insets/InsetArgument.h"
 #include "insets/InsetIPAMacro.h"
-#include "insets/InsetSpace.h"
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetTabular.h"
 
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
+#include "support/docstring.h"
 #include "support/gettext.h"
 #include "support/lassert.h"
 #include "support/lstrings.h"
-#include "support/lyxalgo.h"
 #include "support/lyxtime.h"
 #include "support/textutils.h"
 #include "support/unique_ptr.h"
@@ -113,8 +105,7 @@ void breakParagraphConservative(BufferParams const & bparams,
 	ParagraphList & pars, pit_type pit, pos_type pos)
 {
 	// create a new paragraph
-	Paragraph & tmp = *pars.insert(lyx::next(pars.begin(), pit + 1),
-				       Paragraph());
+	Paragraph & tmp = *pars.insert(pars.iterator_at(pit + 1), Paragraph());
 	Paragraph & par = pars[pit];
 
 	tmp.setInsetOwner(&par.inInset());
@@ -169,7 +160,7 @@ void mergeParagraph(BufferParams const & bparams,
 	// move the change of the end-of-paragraph character
 	par.setChange(par.size(), change);
 
-	pars.erase(lyx::next(pars.begin(), par_offset + 1));
+	pars.erase(pars.iterator_at(par_offset + 1));
 }
 
 
@@ -190,10 +181,8 @@ Text::Text(InsetText * owner, bool use_default_layout)
 Text::Text(InsetText * owner, Text const & text)
 	: owner_(owner), pars_(text.pars_)
 {
-	ParagraphList::iterator const end = pars_.end();
-	ParagraphList::iterator it = pars_.begin();
-	for (; it != end; ++it)
-		it->setInsetOwner(owner);
+	for (auto & p : pars_)
+		p.setInsetOwner(owner);
 }
 
 
@@ -622,7 +611,8 @@ void Text::readParagraph(Paragraph & par, Lexer & lex,
 		}
 	}
 	// Final change goes to paragraph break:
-	par.setChange(par.size(), change);
+	if (inset().allowMultiPar())
+		par.setChange(par.size(), change);
 
 	// Initialize begin_of_body_ on load; redoParagraph maintains
 	par.setBeginOfBody();
@@ -643,14 +633,14 @@ public:
 	virtual ~TextCompletionList() {}
 
 	///
-	virtual bool sorted() const { return true; }
+	bool sorted() const override { return true; }
 	///
-	virtual size_t size() const
+	size_t size() const override
 	{
 		return list_.size();
 	}
 	///
-	virtual docstring const & data(size_t idx) const
+	docstring const & data(size_t idx) const override
 	{
 		return list_.word(idx);
 	}
@@ -693,8 +683,7 @@ static void breakParagraph(Text & text, pit_type par_offset, pos_type pos,
 	ParagraphList & pars = text.paragraphs();
 	// create a new paragraph, and insert into the list
 	ParagraphList::iterator tmp =
-		pars.insert(lyx::next(pars.begin(), par_offset + 1),
-			    Paragraph());
+		pars.insert(pars.iterator_at(par_offset + 1), Paragraph());
 
 	Paragraph & par = pars[par_offset];
 
@@ -725,6 +714,7 @@ static void breakParagraph(Text & text, pit_type par_offset, pos_type pos,
 
 		tmp->params().depth(par.params().depth());
 		tmp->params().noindent(par.params().noindent());
+		tmp->params().spacing(par.params().spacing());
 
 		// move everything behind the break position
 		// to the new paragraph
@@ -868,12 +858,19 @@ void Text::insertStringAsLines(Cursor & cur, docstring const & str,
 	pit_type pit = cur.pit();
 	pos_type pos = cur.pos();
 
+	// The special chars we handle
+	static map<wchar_t, InsetSpecialChar::Kind> specialchars = {
+		{ 0x200c, InsetSpecialChar::LIGATURE_BREAK },
+		{ 0x200b, InsetSpecialChar::ALLOWBREAK },
+		{ 0x2026, InsetSpecialChar::LDOTS },
+		{ 0x2011, InsetSpecialChar::NOBREAKDASH }
+	};
+
 	// insert the string, don't insert doublespace
 	bool space_inserted = true;
-	for (docstring::const_iterator cit = str.begin();
-	    cit != str.end(); ++cit) {
+	for (auto const & ch : str) {
 		Paragraph & par = pars_[pit];
-		if (*cit == '\n') {
+		if (ch == '\n') {
 			if (inset().allowMultiPar() && (!par.empty() || par.allowEmpty())) {
 				lyx::breakParagraph(*this, pit, pos,
 					par.layout().isEnvironment());
@@ -884,28 +881,35 @@ void Text::insertStringAsLines(Cursor & cur, docstring const & str,
 				continue;
 			}
 		// do not insert consecutive spaces if !free_spacing
-		} else if ((*cit == ' ' || *cit == '\t') &&
+		} else if ((ch == ' ' || ch == '\t') &&
 			   space_inserted && !par.isFreeSpacing()) {
 			continue;
-		} else if (*cit == '\t') {
+		} else if (ch == '\t') {
 			if (!par.isFreeSpacing()) {
 				// tabs are like spaces here
 				par.insertChar(pos, ' ', font, bparams.track_changes);
 				++pos;
 				space_inserted = true;
 			} else {
-				par.insertChar(pos, *cit, font, bparams.track_changes);
+				par.insertChar(pos, ch, font, bparams.track_changes);
 				++pos;
 				space_inserted = true;
 			}
-		} else if (!isPrintable(*cit)) {
-			// Ignore unprintables
+		} else if (specialchars.find(ch) != specialchars.end()
+			   && (par.insertInset(pos, new InsetSpecialChar(specialchars.find(ch)->second),
+					       font, bparams.track_changes
+					       ? Change(Change::INSERTED)
+					       : Change(Change::UNCHANGED)))) {
+			++pos;
+			space_inserted = false;
+		} else if (!isPrintable(ch)) {
+			// Ignore (other) unprintables
 			continue;
 		} else {
 			// just insert the character
-			par.insertChar(pos, *cit, font, bparams.track_changes);
+			par.insertChar(pos, ch, font, bparams.track_changes);
 			++pos;
-			space_inserted = (*cit == ' ');
+			space_inserted = (ch == ' ');
 		}
 	}
 	setCursor(cur, pit, pos);
@@ -1001,11 +1005,11 @@ void Text::insertChar(Cursor & cur, char_type c)
 		static docstring const number_operators = from_ascii("+-/*");
 		static docstring const number_unary_operators = from_ascii("+-");
 
-		// European Number Separators: comma, dot etc.
+		// Common Number Separators: comma, dot etc.
 		// European Number Terminators: percent, permille, degree, euro etc.
 		if (cur.current_font.fontInfo().number() == FONT_ON) {
 			if (!isDigitASCII(c) && !contains(number_operators, c) &&
-			    !(isEuropeanNumberSeparator(c) &&
+			    !(isCommonNumberSeparator(c) &&
 			      cur.pos() != 0 &&
 			      cur.pos() != cur.lastpos() &&
 			      tm.displayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
@@ -1030,7 +1034,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 				  ) {
 					setCharFont(pit, cur.pos() - 1, cur.current_font,
 						tm.font_);
-				} else if (isEuropeanNumberSeparator(ch)
+				} else if (isCommonNumberSeparator(ch)
 				     && cur.pos() >= 2
 				     && tm.displayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
 					setCharFont(pit, cur.pos() - 1, cur.current_font,
@@ -1123,7 +1127,7 @@ void Text::charInserted(Cursor & cur)
 	    && par.isWordSeparator(cur.pos() - 1)) {
 		// get the word in front of cursor
 		LBUFERR(this == cur.text());
-		cur.paragraph().updateWords();
+		par.updateWords();
 	}
 }
 
@@ -1135,30 +1139,53 @@ bool Text::cursorForwardOneWord(Cursor & cur)
 {
 	LBUFERR(this == cur.text());
 
-	pos_type const lastpos = cur.lastpos();
-	pit_type pit = cur.pit();
-	pos_type pos = cur.pos();
-	Paragraph const & par = cur.paragraph();
-
-	// Paragraph boundary is a word boundary
-	if (pos == lastpos || (pos + 1 == lastpos && par.isEnvSeparator(pos))) {
-		if (pit != cur.lastpit())
-			return setCursor(cur, pit + 1, 0);
-		else
-			return false;
-	}
-
 	if (lyxrc.mac_like_cursor_movement) {
-		// Skip through trailing punctuation and spaces.
-		while (pos != lastpos && (par.isChar(pos) || par.isSpace(pos)))
-			++pos;
-
-		// Skip over either a non-char inset or a full word
-		if (pos != lastpos && par.isWordSeparator(pos))
-			++pos;
-		else while (pos != lastpos && !par.isWordSeparator(pos))
-			     ++pos;
+		DocIterator dit(cur);
+		DocIterator prv(cur);
+		bool inword = false;
+		bool intext = dit.inTexted();
+		while (!dit.atEnd()) {
+			if (dit.inTexted()) { // no paragraphs in mathed
+				Paragraph const & par = dit.paragraph();
+				pos_type const pos = dit.pos();
+
+				if (!par.isDeleted(pos)) {
+					bool wordsep = par.isWordSeparator(pos);
+					if (inword && wordsep)
+						break; // stop at word end
+					else if (!inword && !wordsep)
+						inword = true;
+				}
+				intext = true;
+			} else if (intext) {
+				// move to end of math
+				while (!dit.inTexted() && !dit.atEnd()) dit.forwardPos();
+				break;
+			}
+			prv = dit;
+			dit.forwardPosIgnoreCollapsed();
+		}
+		if (dit.atEnd()) dit = prv;
+		if (dit == cur) return false; // we didn't move
+		Cursor orig(cur);
+		cur.setCursor(dit);
+		// see comment above
+		cur.bv().checkDepm(cur, orig);
+		return true;
 	} else {
+		pos_type const lastpos = cur.lastpos();
+		pit_type pit = cur.pit();
+		pos_type pos = cur.pos();
+		Paragraph const & par = cur.paragraph();
+
+		// Paragraph boundary is a word boundary
+		if (pos == lastpos || (pos + 1 == lastpos && par.isEnvSeparator(pos))) {
+			if (pit != cur.lastpit())
+				return setCursor(cur, pit + 1, 0);
+			else
+				return false;
+		}
+
 		LASSERT(pos < lastpos, return false); // see above
 		if (!par.isWordSeparator(pos))
 			while (pos != lastpos && !par.isWordSeparator(pos))
@@ -1172,13 +1199,13 @@ bool Text::cursorForwardOneWord(Cursor & cur)
 		// Skip over white space
 		while (pos != lastpos && par.isSpace(pos))
 			     ++pos;
-	}
 
-	// Don't skip a separator inset at the end of a paragraph
-	if (pos == lastpos && pos && par.isEnvSeparator(pos - 1))
-		--pos;
+		// Don't skip a separator inset at the end of a paragraph
+		if (pos == lastpos && pos && par.isEnvSeparator(pos - 1))
+			--pos;
 
-	return setCursor(cur, pit, pos);
+		return setCursor(cur, pit, pos);
+	}
 }
 
 
@@ -1186,34 +1213,55 @@ bool Text::cursorBackwardOneWord(Cursor & cur)
 {
 	LBUFERR(this == cur.text());
 
-	pit_type pit = cur.pit();
-	pos_type pos = cur.pos();
-	Paragraph & par = cur.paragraph();
-
-	// Paragraph boundary is a word boundary
-	if (pos == 0 && pit != 0) {
-		Paragraph & prevpar = getPar(pit - 1);
-		pos = prevpar.size();
-		// Don't stop after an environment separator
-		if (pos && prevpar.isEnvSeparator(pos - 1))
-			--pos;
-		return setCursor(cur, pit - 1, pos);
-	}
-
 	if (lyxrc.mac_like_cursor_movement) {
-		// Skip through punctuation and spaces.
-		while (pos != 0 && (par.isChar(pos - 1) || par.isSpace(pos - 1)))
-			--pos;
-
-		// Skip over either a non-char inset or a full word
-		if (pos != 0 && par.isWordSeparator(pos - 1) && !par.isChar(pos - 1))
-			--pos;
-		else while (pos != 0 && !par.isWordSeparator(pos - 1))
-			     --pos;
+		DocIterator dit(cur);
+		bool inword = false;
+		bool intext = dit.inTexted();
+		while (!dit.atBegin()) {
+			DocIterator prv(dit);
+			dit.backwardPosIgnoreCollapsed();
+			if (dit.inTexted()) { // no paragraphs in mathed
+				Paragraph const & par = dit.paragraph();
+				pos_type pos = dit.pos();
+
+				if (!par.isDeleted(pos)) {
+					bool wordsep = par.isWordSeparator(pos);
+					if (inword && wordsep) {
+						dit = prv;
+						break; // stop at word begin
+					} else if (!inword && !wordsep)
+						inword = true;
+				}
+				intext = true;
+			} else if (intext) {
+				// move to begin of math
+				while (!dit.inTexted() && !dit.atBegin()) dit.backwardPos();
+				break;
+			}
+		}
+		if (dit == cur) return false; // we didn't move
+		Cursor orig(cur);
+		cur.setCursor(dit);
+		// see comment above cursorForwardOneWord
+		cur.bv().checkDepm(cur, orig);
+		return true;
 	} else {
+		Paragraph const & par = cur.paragraph();
+		pit_type const pit = cur.pit();
+		pos_type pos = cur.pos();
+
+		// Paragraph boundary is a word boundary
+		if (pos == 0 && pit != 0) {
+			Paragraph & prevpar = getPar(pit - 1);
+			pos = prevpar.size();
+			// Don't stop after an environment separator
+			if (pos && prevpar.isEnvSeparator(pos - 1))
+				--pos;
+			return setCursor(cur, pit - 1, pos);
+		}
 		// Skip over white space
 		while (pos != 0 && par.isSpace(pos - 1))
-			     --pos;
+			--pos;
 
 		if (pos != 0 && !par.isWordSeparator(pos - 1))
 			while (pos != 0 && !par.isWordSeparator(pos - 1))
@@ -1223,9 +1271,9 @@ bool Text::cursorBackwardOneWord(Cursor & cur)
 				--pos;
 		else if (pos != 0 && !par.isSpace(pos - 1)) // non-char inset
 			--pos;
-	}
 
-	return setCursor(cur, pit, pos);
+		return setCursor(cur, pit, pos);
+	}
 }
 
 
@@ -1448,7 +1496,8 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op)
 	}
 
 	// finally, invoke the DEPM
-	deleteEmptyParagraphMechanism(begPit, endPit, cur.buffer()->params().track_changes);
+	deleteEmptyParagraphMechanism(begPit, endPit, begPos, endPos,
+				      cur.buffer()->params().track_changes);
 
 	cur.finishUndo();
 	cur.clearSelection();
@@ -1674,10 +1723,7 @@ bool Text::backspacePos0(Cursor & cur)
 	if (cur.pit() == 0)
 		return false;
 
-	bool needsUpdate = false;
-
 	BufferParams const & bufparams = cur.buffer()->params();
-	DocumentClass const & tclass = bufparams.documentClass();
 	ParagraphList & plist = cur.text()->paragraphs();
 	Paragraph const & par = cur.paragraph();
 	Cursor prevcur = cur;
@@ -1689,15 +1735,13 @@ bool Text::backspacePos0(Cursor & cur)
 	if (cur.lastpos() == 0
 	    || (cur.lastpos() == 1 && par.isSeparator(0))) {
 		cur.recordUndo(prevcur.pit());
-		plist.erase(lyx::next(plist.begin(), cur.pit()));
-		needsUpdate = true;
+		plist.erase(plist.iterator_at(cur.pit()));
 	}
 	// is previous par empty?
 	else if (prevcur.lastpos() == 0
 		 || (prevcur.lastpos() == 1 && prevpar.isSeparator(0))) {
 		cur.recordUndo(prevcur.pit());
-		plist.erase(lyx::next(plist.begin(), prevcur.pit()));
-		needsUpdate = true;
+		plist.erase(plist.iterator_at(prevcur.pit()));
 	}
 	// FIXME: Do we really not want to allow this???
 	// Pasting is not allowed, if the paragraphs have different
@@ -1705,20 +1749,15 @@ bool Text::backspacePos0(Cursor & cur)
 	// word processors to allow it. It confuses the user.
 	// Correction: Pasting is always allowed with standard-layout
 	// or the empty layout.
-	else if (par.layout() == prevpar.layout()
-		 || tclass.isDefaultLayout(par.layout())
-		 || tclass.isPlainLayout(par.layout())) {
+	else {
 		cur.recordUndo(prevcur.pit());
 		mergeParagraph(bufparams, plist, prevcur.pit());
-		needsUpdate = true;
 	}
 
-	if (needsUpdate) {
-		cur.forceBufferUpdate();
-		setCursorIntern(cur, prevcur.pit(), prevcur.pos());
-	}
+	cur.forceBufferUpdate();
+	setCursorIntern(cur, prevcur.pit(), prevcur.pos());
 
-	return needsUpdate;
+	return true;
 }
 
 
@@ -1733,7 +1772,7 @@ bool Text::backspace(Cursor & cur)
 		Cursor prev_cur = cur;
 		--prev_cur.pit();
 
-		if (cur.paragraph().size() > 0
+		if (!cur.paragraph().empty()
 		    && !prev_cur.paragraph().isMergedOnEndOfParDeletion(cur.buffer()->params().track_changes)) {
 			cur.recordUndo(prev_cur.pit(), prev_cur.pit());
 			prev_cur.paragraph().setChange(prev_cur.lastpos(), Change(Change::DELETED));
@@ -1788,9 +1827,7 @@ bool Text::dissolveInset(Cursor & cur)
 	// save position inside inset
 	pos_type spos = cur.pos();
 	pit_type spit = cur.pit();
-	ParagraphList plist;
-	if (cur.lastpit() != 0 || cur.lastpos() != 0)
-		plist = paragraphs();
+	bool const inset_non_empty = cur.lastpit() != 0 || cur.lastpos() != 0;
 	cur.popBackward();
 	// update cursor offset
 	if (spit == 0)
@@ -1803,7 +1840,8 @@ bool Text::dissolveInset(Cursor & cur)
 	++cur.pos();
 
 	Buffer & b = *cur.buffer();
-	if (!plist.empty()) {
+	// Is there anything in this text?
+	if (inset_non_empty) {
 		// see bug 7319
 		// we clear the cache so that we won't get conflicts with labels
 		// that get pasted into the buffer. we should update this before
@@ -1813,6 +1851,7 @@ bool Text::dissolveInset(Cursor & cur)
 		// but we'll try the cheaper solution here.
 		cur.buffer()->clearReferenceCache();
 
+		ParagraphList & plist = paragraphs();
 		if (!lyxrc.ct_markup_copied)
 			// Do not revive deleted text
 			lyx::acceptChanges(plist, b.params());
@@ -1820,10 +1859,8 @@ bool Text::dissolveInset(Cursor & cur)
 		// ERT paragraphs have the Language latex_language.
 		// This is invalid outside of ERT, so we need to
 		// change it to the buffer language.
-		ParagraphList::iterator it = plist.begin();
-		ParagraphList::iterator it_end = plist.end();
-		for (; it != it_end; ++it)
-			it->changeLanguage(b.params(), latex_language, b.language());
+		for (auto & p : plist)
+			p.changeLanguage(b.params(), latex_language, b.language());
 
 		/* If the inset is the only thing in paragraph and the layout
 		 * is not plain, then the layout of the first paragraph of
@@ -1834,10 +1871,18 @@ bool Text::dissolveInset(Cursor & cur)
 		 */
 		DocumentClass const & tclass = cur.buffer()->params().documentClass();
 		if (inset_it.lastpos() == 1
-		    && plist[0].layout().name() != tclass.plainLayoutName())
-			cur.paragraph().makeSameLayout(plist[0]);
+		    && !tclass.isPlainLayout(plist[0].layout())
+		    && !tclass.isDefaultLayout(plist[0].layout())) {
+			// Copy all parameters except depth.
+			Paragraph & par = cur.paragraph();
+			par.setLayout(plist[0].layout());
+			depth_type const dpth = par.getDepth();
+			par.params() = plist[0].params();
+			par.params().depth(dpth);
+		}
 
 		pasteParagraphList(cur, plist, b.params().documentClassPtr(),
+				   b.params().authors(),
 				   b.errorList("Paste"));
 	}
 
@@ -1857,6 +1902,88 @@ bool Text::dissolveInset(Cursor & cur)
 }
 
 
+bool Text::splitInset(Cursor & cur)
+{
+	LASSERT(this == cur.text(), return false);
+
+	if (isMainText() || cur.inset().nargs() != 1)
+		return false;
+
+	cur.recordUndo();
+	if (cur.selection()) {
+		// start from selection begin
+		setCursor(cur, cur.selBegin().pit(), cur.selBegin().pos());
+		cur.clearSelection();
+	}
+	// save split position inside inset
+	// (we need to copy the whole inset first)
+	pos_type spos = cur.pos();
+	pit_type spit = cur.pit();
+	// some things only need to be done if the inset has content
+	bool const inset_non_empty = cur.lastpit() != 0 || cur.lastpos() != 0;
+
+	// move right before the inset
+	cur.popBackward();
+	cur.resetAnchor();
+	// remember position outside inset
+	pos_type ipos = cur.pos();
+	pit_type ipit = cur.pit();
+	// select inset ...
+	++cur.pos();
+	cur.setSelection();
+	// ... and copy
+	cap::copySelectionToTemp(cur);
+	cur.clearSelection();
+	cur.resetAnchor();
+	// paste copied inset
+	cap::pasteFromTemp(cur, cur.buffer()->errorList("Paste"));
+	cur.forceBufferUpdate();
+
+	// if the inset has text, cut after split position
+	// and paste to new inset
+	if (inset_non_empty) {
+		// go back to first inset
+		cur.text()->setCursor(cur, ipit, ipos);
+		cur.forwardPos();
+		setCursor(cur, spit, spos);
+		cur.resetAnchor();
+		setCursor(cur, cur.lastpit(), getPar(cur.lastpit()).size());
+		cur.setSelection();
+		cap::cutSelectionToTemp(cur);
+		cur.setMark(false);
+		cur.selHandle(false);
+		cur.resetAnchor();
+		bool atlastpos = false;
+		if (cur.pos() == 0 && cur.pit() > 0) {
+			// if we are at par start, remove this par
+			cur.text()->backspace(cur);
+			cur.forceBufferUpdate();
+		} else if (cur.pos() == cur.lastpos())
+			atlastpos = true;
+		// Move out of and jump over inset
+		cur.popBackward();
+		++cur.pos();
+
+		// enter new inset
+		cur.forwardPos();
+		cur.setCursor(cur);
+		cur.resetAnchor();
+		cur.text()->selectAll(cur);
+		cutSelection(cur, false);
+		cap::pasteFromTemp(cur, cur.buffer()->errorList("Paste"));
+		cur.text()->setCursor(cur, 0, 0);
+		if (atlastpos && cur.paragraph().isFreeSpacing() && cur.paragraph().empty()) {
+			// We started from par end, remove extra empty par in free spacing insets
+			cur.text()->erase(cur);
+			cur.forceBufferUpdate();
+		}
+	}
+
+	cur.finishUndo();
+	return true;
+}
+
+
 void Text::getWord(CursorSlice & from, CursorSlice & to,
 	word_location const loc) const
 {
@@ -1947,7 +2074,7 @@ bool Text::read(Lexer & lex,
 }
 
 
-// Returns the current font and depth as a message.
+// Returns the current state (font, depth etc.) as a message for status bar.
 docstring Text::currentState(CursorData const & cur, bool devel_mode) const
 {
 	LBUFERR(this == cur.text());
@@ -1977,7 +2104,7 @@ docstring Text::currentState(CursorData const & cur, bool devel_mode) const
 	os << bformat(_("Font: %1$s"), font.stateText(&buf.params()));
 
 	// The paragraph depth
-	int depth = cur.paragraph().getDepth();
+	int depth = par.getDepth();
 	if (depth > 0)
 		os << bformat(_(", Depth: %1$d"), depth);
 
@@ -2005,6 +2132,11 @@ docstring Text::currentState(CursorData const & cur, bool devel_mode) const
 		}
 	}
 
+	// Custom text style
+	InsetLayout const & layout = cur.inset().getLayout();
+	if (layout.lyxtype() == InsetLyXType::CHARSTYLE)
+		os << _(", Style: ") << translateIfPossible(layout.labelstring());
+
 	if (devel_mode) {
 		os << _(", Inset: ") << &cur.inset();
 		if (cur.lastidx() > 0)
@@ -2229,19 +2361,6 @@ void Text::setMacrocontextPosition(DocIterator const & pos)
 }
 
 
-docstring Text::previousWord(CursorSlice const & sl) const
-{
-	CursorSlice from = sl;
-	CursorSlice to = sl;
-	getWord(from, to, PREVIOUS_WORD);
-	if (sl == from || to == from)
-		return docstring();
-
-	Paragraph const & par = sl.paragraph();
-	return par.asString(from.pos(), to.pos());
-}
-
-
 bool Text::completionSupported(Cursor const & cur) const
 {
 	Paragraph const & par = cur.paragraph();
@@ -2272,7 +2391,11 @@ bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/
 
 docstring Text::completionPrefix(Cursor const & cur) const
 {
-	return previousWord(cur.top());
+	CursorSlice from = cur.top();
+	CursorSlice to = from;
+	getWord(from, to, PREVIOUS_WORD);
+
+	return cur.paragraph().asString(from.pos(), to.pos());
 }
 
 } // namespace lyx