X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=900837a49a80d2c26e790ef0de5d81f4f2f965e5;hb=9e1ce30ff75b0282f428738aa3f3562c21ceb9df;hp=4ffd914f3e7943d8599a7727ccf8f55acefb5735;hpb=3d0c8789660dfa279191c4d46c6ccba010e29e41;p=lyx.git

diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C
index 4ffd914f3e..900837a49a 100644
--- a/src/paragraph_pimpl.C
+++ b/src/paragraph_pimpl.C
@@ -14,6 +14,7 @@
 #include <config.h>
 
 #include "paragraph_pimpl.h"
+#include "paragraph.h"
 
 #include "bufferparams.h"
 #include "debug.h"
@@ -28,13 +29,13 @@
 
 #include <boost/next_prior.hpp>
 
-using lyx::pos_type;
+
+namespace lyx {
 
 using std::endl;
 using std::upper_bound;
 using std::lower_bound;
 using std::string;
-using std::ostream;
 
 
 // Initialization of the counter for the paragraph id's,
@@ -44,19 +45,31 @@ namespace {
 
 struct special_phrase {
 	string phrase;
-	string macro;
+	docstring macro;
 	bool builtin;
 };
 
-special_phrase special_phrases[] = {
-	{ "LyX", "\\LyX{}", false },
-	{ "TeX", "\\TeX{}", true },
-	{ "LaTeX2e", "\\LaTeXe{}", true },
-	{ "LaTeX", "\\LaTeX{}", true },
+special_phrase const special_phrases[] = {
+	{ "LyX", from_ascii("\\LyX{}"), false },
+	{ "TeX", from_ascii("\\TeX{}"), true },
+	{ "LaTeX2e", from_ascii("\\LaTeXe{}"), true },
+	{ "LaTeX", from_ascii("\\LaTeX{}"), true },
 };
 
 size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
 
+
+/// Get the real encoding of a character with font \p font.
+/// doc_encoding == bparams.encoding(), but we use a precomputed variable
+/// since bparams.encoding() is expensive
+inline Encoding const & getEncoding(BufferParams const & bparams,
+		Encoding const & doc_encoding, LyXFont const & font)
+{
+	if (bparams.inputenc == "auto" || bparams.inputenc == "default")
+		return *(font.language()->encoding());
+	return doc_encoding;
+}
+
 } // namespace anon
 
 
@@ -69,217 +82,174 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner)
 
 
 Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner)
-	: params(p.params), owner_(owner)
+	: params(p.params), changes_(p.changes_), owner_(owner)
 {
 	inset_owner = p.inset_owner;
 	fontlist = p.fontlist;
 	id_ = paragraph_id++;
-
-	if (p.tracking())
-		changes_.reset(new Changes(*p.changes_.get()));
-}
-
-
-void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par)
-{
-	owner_->text_ = par.text_;
-	if (par.pimpl_->tracking()) {
-		changes_.reset(new Changes(*(par.pimpl_->changes_.get())));
-	}
-}
-
-
-void Paragraph::Pimpl::trackChanges(Change::Type type)
-{
-	if (tracking()) {
-		lyxerr[Debug::CHANGES] << "already tracking for par " << id_ << endl;
-		return;
-	}
-
-	lyxerr[Debug::CHANGES] << "track changes for par "
-		<< id_ << " type " << type << endl;
-	changes_.reset(new Changes(type));
-	changes_->set(type, 0, size() + 1);
-}
-
-
-void Paragraph::Pimpl::untrackChanges()
-{
-	changes_.reset(0);
-}
-
-
-void Paragraph::Pimpl::cleanChanges()
-{
-	// if we're not tracking, we don't want to reset...
-	if (!tracking())
-		return;
-
-	changes_.reset(new Changes(Change::INSERTED));
-	changes_->set(Change::INSERTED, 0, size() + 1);
 }
 
 
 bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
 {
-	if (!tracking())
-		return false;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	return changes_->isChange(start, end);
+	return changes_.isChanged(start, end);
 }
 
 
-bool Paragraph::Pimpl::isChangeEdited(pos_type start, pos_type end) const
-{
-	if (!tracking())
-		return false;
-
-	return changes_->isChangeEdited(start, end);
-}
+bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const {
+	// keep the logic here in sync with the logic of eraseChars()
 
+	if (!trackChanges) {
+		return true;
+	}
 
-void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type)
-{
-	if (!tracking())
-		return;
+	Change change = changes_.lookup(size());
 
-	changes_->set(type, pos);
+	return change.type == Change::INSERTED && change.author == 0;
 }
 
 
-void Paragraph::Pimpl::setChangeFull(pos_type pos, Change change)
+void Paragraph::Pimpl::setChange(Change const & change)
 {
-	if (!tracking())
-		return;
-
-	changes_->set(change, pos);
+	// beware of the imaginary end-of-par character!
+	changes_.set(change, 0, size() + 1);
+
+	/*
+	 * Propagate the change recursively - but not in case of DELETED!
+	 *
+	 * Imagine that your co-author makes changes in an existing inset. He
+	 * sends your document to you and you come to the conclusion that the
+	 * inset should go completely. If you erase it, LyX must not delete all
+	 * text within the inset. Otherwise, the change tracked insertions of
+	 * your co-author get lost and there is no way to restore them later.
+	 *
+	 * Conclusion: An inset's content should remain untouched if you delete it
+	 */
+
+	if (change.type != Change::DELETED) {
+		for (pos_type pos = 0; pos < size(); ++pos) {
+			if (owner_->isInset(pos)) {
+				owner_->getInset(pos)->setChange(change);
+			}
+		}
+	}
 }
 
-Change::Type Paragraph::Pimpl::lookupChange(pos_type pos) const
-{
-	if (!tracking())
-		return Change::UNCHANGED;
 
-	return changes_->lookup(pos);
-}
+void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
+{
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
+	changes_.set(change, pos);
 
-Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const
-{
-	if (!tracking())
-		return Change(Change::UNCHANGED);
+	// see comment in setChange(Change const &) above
 
-	return changes_->lookupFull(pos);
+	if (change.type != Change::DELETED &&
+	    pos < size() && owner_->isInset(pos)) {
+		owner_->getInset(pos)->setChange(change);
+	}
 }
 
 
-void Paragraph::Pimpl::markErased(bool erased)
+Change const & Paragraph::Pimpl::lookupChange(pos_type pos) const
 {
-	BOOST_ASSERT(tracking());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	if (erased) {
-		erase(0, size());
-	} else {
-		for (pos_type i = 0; i < size(); ++i) {
-			changes_->set(Change::UNCHANGED, i);
-			if (owner_->isInset(i))
-				owner_->getInset(i)->markErased(false);
-		}
-	}
+	return changes_.lookup(pos);
 }
 
 
-void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end)
 {
-	if (!tracking())
-		return;
-
-	if (!size()) {
-		changes_.reset(new Changes(Change::UNCHANGED));
-		return;
-	}
-
-	lyxerr[Debug::CHANGES] << "acceptchange" << endl;
-	pos_type i = start;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	for (; i < end; ++i) {
-		switch (lookupChange(i)) {
+	for (pos_type pos = start; pos < end; ++pos) {
+		switch (lookupChange(pos).type) {
 			case Change::UNCHANGED:
+				// accept changes in nested inset
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->acceptChanges(bparams);
+				}
+
 				break;
 
 			case Change::INSERTED:
-				changes_->set(Change::UNCHANGED, i);
+				changes_.set(Change(Change::UNCHANGED), pos);
+				// also accept changes in nested inset
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->acceptChanges(bparams);
+				}
 				break;
 
 			case Change::DELETED:
-				// Suppress access to nonexistent 
-				// "end-of-paragraph char":
-				if (i < size()) {
-					eraseIntern(i);
-					changes_->erase(i);
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
 					--end;
-					--i;
+					--pos;
 				}
 				break;
 		}
-	}
 
-	lyxerr[Debug::CHANGES] << "endacceptchange" << endl;
-	changes_->reset(Change::UNCHANGED);
+	}
 }
 
 
-void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end)
 {
-	if (!tracking())
-		return;
-
-	if (!size()) {
-		changes_.reset(new Changes(Change::UNCHANGED));
-		return;
-	}
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	pos_type i = start;
-
-	for (; i < end; ++i) {
-		switch (lookupChange(i)) {
+	for (pos_type pos = start; pos < end; ++pos) {
+		switch (lookupChange(pos).type) {
 			case Change::UNCHANGED:
+				// reject changes in nested inset
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->rejectChanges(bparams);
+				}
 				break;
 
 			case Change::INSERTED:
-				if (i < size()) {
-					eraseIntern(i);
-					changes_->erase(i);
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
 					--end;
-					--i;
+					--pos;
 				}
 				break;
 
 			case Change::DELETED:
-				changes_->set(Change::UNCHANGED, i);
-				// No real char at position size():
-				if (i < size() && owner_->isInset(i))
-					owner_->getInset(i)->markErased(false);
+				changes_.set(Change(Change::UNCHANGED), pos);
+
+				// Do NOT reject changes within a deleted inset!
+				// There may be insertions of a co-author inside of it!
+
 				break;
 		}
 	}
-	changes_->reset(Change::UNCHANGED);
 }
 
 
 Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const
 {
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
 	return owner_->getChar(pos);
 }
 
 
-void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change change)
+void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change)
 {
-	BOOST_ASSERT(pos <= size());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	if (tracking()) {
-		changes_->record(change, pos);
-	}
+	// track change
+	changes_.insert(change, pos);
 
 	// This is actually very common when parsing buffers (and
 	// maybe inserting ascii text)
@@ -293,9 +263,8 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change change)
 
 	// Update the font table.
 	FontTable search_font(pos, LyXFont());
-	for (FontList::iterator it = lower_bound(fontlist.begin(),
-						      fontlist.end(),
-						      search_font, matchFT());
+	for (FontList::iterator it 
+	      = lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT());
 	     it != fontlist.end(); ++it)
 	{
 		it->pos(it->pos() + 1);
@@ -306,11 +275,11 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change change)
 }
 
 
-void Paragraph::Pimpl::insertInset(pos_type pos,
-				   InsetBase * inset, Change change)
+void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset,
+                                   Change const & change)
 {
 	BOOST_ASSERT(inset);
-	BOOST_ASSERT(pos <= size());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
 	insertChar(pos, META_INSET, change);
 	BOOST_ASSERT(owner_->text_[pos] == META_INSET);
@@ -320,8 +289,39 @@ void Paragraph::Pimpl::insertInset(pos_type pos,
 }
 
 
-void Paragraph::Pimpl::eraseIntern(pos_type pos)
+bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges)
 {
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
+	// keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
+
+	if (trackChanges) {
+		Change change = changes_.lookup(pos);
+
+		// set the character to DELETED if 
+		//  a) it was previously unchanged or
+		//  b) it was inserted by a co-author
+
+		if (change.type == Change::UNCHANGED ||
+		    (change.type == Change::INSERTED && change.author != 0)) {
+			setChange(pos, Change(Change::DELETED));
+			return false;
+		}
+
+		if (change.type == Change::DELETED)
+			return false;
+	}
+
+	// Don't physically access the imaginary end-of-paragraph character.
+	// eraseChar() can only mark it as DELETED. A physical deletion of
+	// end-of-par must be handled externally.
+	if (pos == size()) {
+		return false;
+	}
+
+	// track change
+	changes_.erase(pos);
+
 	// if it is an inset, delete the inset entry
 	if (owner_->text_[pos] == Paragraph::META_INSET) {
 		owner_->insetlist.erase(pos);
@@ -354,63 +354,73 @@ void Paragraph::Pimpl::eraseIntern(pos_type pos)
 		}
 	}
 
-	// Update all other entries.
+	// Update all other entries
 	FontList::iterator fend = fontlist.end();
 	for (; it != fend; ++it)
 		it->pos(it->pos() - 1);
 
-	// Update the insetlist.
+	// Update the insetlist
 	owner_->insetlist.decreasePosAfterPos(pos);
-}
-
-
-bool Paragraph::Pimpl::erase(pos_type pos)
-{
-	BOOST_ASSERT(pos <= size());
-
-	if (tracking()) {
-		Change::Type changetype(changes_->lookup(pos));
-		changes_->record(Change(Change::DELETED), pos);
-
-		// only allow the actual removal if it was /new/ text
-		if (changetype != Change::INSERTED) {
-			if (pos < size() && owner_->isInset(pos))
-				owner_->getInset(pos)->markErased(true);
-			return false;
-		}
-	}
-
-	// Don't physically access nonexistent end-of-paragraph char
-	if (pos < size()) {
-		eraseIntern(pos);
-		return true;
-	}
 
-	return false;
+	return true;
 }
 
 
-int Paragraph::Pimpl::erase(pos_type start, pos_type end)
+int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges)
 {
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end >= start && end <= size() + 1);
+
 	pos_type i = start;
 	for (pos_type count = end - start; count; --count) {
-		if (!erase(i))
+		if (!eraseChar(i, trackChanges))
 			++i;
 	}
 	return end - i;
 }
 
 
-void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow,
-				       pos_type const i,
+int Paragraph::Pimpl::latexSurrogatePair(odocstream & os, value_type c,
+		value_type next, Encoding const & encoding)
+{
+	// Writing next here may circumvent a possible font change between
+	// c and next. Since next is only output if it forms a surrogate pair
+	// with c we can ignore this:
+	// A font change inside a surrogate pair does not make sense and is
+	// hopefully impossible to input.
+	// FIXME: change tracking
+	// Is this correct WRT change tracking?
+	docstring const latex1 = encoding.latexChar(next);
+	docstring const latex2 = encoding.latexChar(c);
+	os << latex1 << '{' << latex2 << '}';
+	return latex1.length() + latex2.length() + 2;
+}
+
+
+bool Paragraph::Pimpl::simpleTeXBlanks(BufferParams const & bparams,
+                                       Encoding const & doc_encoding,
+                                       odocstream & os, TexRow & texrow,
+                                       pos_type & i,
 				       unsigned int & column,
 				       LyXFont const & font,
 				       LyXLayout const & style)
 {
 	if (style.pass_thru)
-		return;
+		return false;
+
+	if (i < size() - 1) {
+		char_type next = getChar(i + 1);
+		if (Encodings::isCombiningChar(next)) {
+			// This space has an accent, so we must always output it.
+			Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+			column += latexSurrogatePair(os, ' ', next, encoding) - 1;
+			++i;
+			return true;
+		}
+	}
 
-	if (column > lyxrc.ascii_linelen
+	if (lyxrc.plaintext_linelen > 0
+	    && column > lyxrc.plaintext_linelen
 	    && i
 	    && getChar(i - 1) != ' '
 	    && (i < size() - 1)
@@ -432,6 +442,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow,
 	} else {
 		os << ' ';
 	}
+	return false;
 }
 
 
@@ -445,6 +456,8 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
 	// does the wanted text start at point?
 	for (string::size_type i = 0; i < str.length(); ++i) {
+		// Caution: direct comparison of characters works only
+		// because str is pure ASCII.
 		if (str[i] != owner_->text_[pos + i])
 			return false;
 	}
@@ -465,7 +478,8 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
 void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 					     BufferParams const & bparams,
-					     ostream & os,
+					     Encoding const & doc_encoding,
+					     odocstream & os,
 					     TexRow & texrow,
 					     OutputParams const & runparams,
 					     LyXFont & font,
@@ -482,10 +496,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 	if (style.pass_thru) {
 		if (c != Paragraph::META_INSET) {
 			if (c != '\0')
-				os << c;
-		} else {
+				// FIXME UNICODE: This can fail if c cannot
+				// be encoded in the current encoding.
+				os.put(c);
+		} else
 			owner_->getInset(i)->plaintext(buf, os, runparams);
-		}
 		return;
 	}
 
@@ -508,7 +523,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 				os << '\n';
 			} else {
 				if (open_font) {
-					column += running_font.latexWriteEndChanges(os, basefont, basefont);
+					column += running_font.latexWriteEndChanges(
+						os, basefont, basefont, bparams);
 					open_font = false;
 				}
 				basefont = owner_->getLayoutFont(bparams, outerfont);
@@ -531,8 +547,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 		// output change tracking marks only if desired,
 		// if dvipost is installed,
 		// and with dvi/ps (other formats don't work)
-		LaTeXFeatures features(buf, bparams, runparams.nice);
-		bool const output = bparams.output_changes
+		LaTeXFeatures features(buf, bparams, runparams);
+		bool const output = bparams.outputChanges
 			&& runparams.flavor == OutputParams::LATEX
 			&& features.isAvailable("dvipost");
 
@@ -543,7 +559,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 		}
 
 		bool close = false;
-		ostream::pos_type const len = os.tellp();
+		odocstream::pos_type const len = os.tellp();
 
 		if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE
 		     || inset->lyxCode() == InsetBase::MATH_CODE
@@ -561,10 +577,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 #endif
 		// some insets cannot be inside a font change command
 		if (open_font && inset->noFontChange()) {
-			column +=running_font.
-				latexWriteEndChanges(os,
-						     basefont,
-						     basefont);
+			column += running_font.latexWriteEndChanges(
+					os, basefont, basefont, bparams);
 			open_font = false;
 			basefont = owner_->getLayoutFont(bparams, outerfont);
 			running_font = basefont;
@@ -596,46 +610,32 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 15;
 			break;
 
-		case '±': case '²': case '³':
-		case '×': case '÷': case '¹':
-		case '¬': case 'µ':
-			if ((bparams.inputenc == "latin1" ||
-			     bparams.inputenc == "latin9") ||
-			    (bparams.inputenc == "auto" &&
-			     (font.language()->encoding()->LatexName()
-			      == "latin1" ||
-			      font.language()->encoding()->LatexName()
-			      == "latin9"))) {
-				os << "\\ensuremath{"
-				   << c
-				   << '}';
-				column += 13;
-			} else {
-				os << c;
-			}
-			break;
-
+		// The following characters could be written literally in latin1, but they
+		// would be wrongly converted on systems where char is signed, so we give
+		// the code points.
+		// This also makes us independant from the encoding of this source file.
 		case '|': case '<': case '>':
 			// In T1 encoding, these characters exist
 			if (lyxrc.fontenc == "T1") {
-				os << c;
+				os.put(c);
 				//... but we should avoid ligatures
 				if ((c == '>' || c == '<')
 				    && i <= size() - 2
 				    && getChar(i + 1) == c) {
 					//os << "\\textcompwordmark{}";
+					//column += 19;
 					// Jean-Marc, have a look at
 					// this. I think this works
 					// equally well:
 					os << "\\,{}";
 					// Lgb
-					column += 19;
+					column += 3;
 				}
 				break;
 			}
 			// Typewriter font also has them
 			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
-				os << c;
+				os.put(c);
 				break;
 			}
 			// Otherwise, we use what LaTeX
@@ -672,19 +672,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 9;
 			break;
 
-		case '£':
-			if (bparams.inputenc == "default") {
-				os << "\\pounds{}";
-				column += 8;
-			} else {
-				os << c;
-			}
-			break;
-
 		case '$': case '&':
 		case '%': case '#': case '{':
 		case '}': case '_':
-			os << '\\' << c;
+			os << '\\';
+			os.put(c);
 			column += 1;
 			break;
 
@@ -700,7 +692,9 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 
 		case '*': case '[':
 			// avoid being mistaken for optional arguments
-			os << '{' << c << '}';
+			os << '{';
+			os.put(c);
+			os << '}';
 			column += 2;
 			break;
 
@@ -715,9 +709,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 		default:
 
 			// I assume this is hack treating typewriter as verbatim
+			// FIXME UNICODE: This can fail if c cannot be encoded
+			// in the current encoding.
 			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
 				if (c != '\0') {
-					os << c;
+					os.put(c);
 				}
 				break;
 			}
@@ -742,7 +738,27 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			}
 
 			if (pnr == phrases_nr && c != '\0') {
-				os << c;
+				Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+				if (i < size() - 1) {
+					char_type next = getChar(i + 1);
+					if (Encodings::isCombiningChar(next)) {
+						column += latexSurrogatePair(os, c, next, encoding) - 1;
+						++i;
+						break;
+					}
+				}
+				docstring const latex = encoding.latexChar(c);
+				if (latex.length() > 1 &&
+				    latex[latex.length() - 1] != '}') {
+					// Prevent eating of a following
+					// space or command corruption by
+					// following characters
+					column += latex.length() + 1;
+					os << latex << "{}";
+				} else {
+					column += latex.length() - 1;
+					os << latex;
+				}
 			}
 			break;
 		}
@@ -774,7 +790,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 					     << endl;
 			features.require("noun");
 			lyxerr[Debug::LATEX] << "Noun enabled. Font: "
-					     << fcit->font().stateText(0)
+					     << to_utf8(fcit->font().stateText(0))
 					     << endl;
 		}
 		switch (fcit->font().color()) {
@@ -789,7 +805,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 		default:
 			features.require("color");
 			lyxerr[Debug::LATEX] << "Color enabled. Font: "
-					     << fcit->font().stateText(0)
+					     << to_utf8(fcit->font().stateText(0))
 					     << endl;
 		}
 
@@ -820,6 +836,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 	}
 
 	// then the contents
+	Encoding const & doc_encoding = bparams.encoding();
 	for (pos_type i = 0; i < size() ; ++i) {
 		for (size_t pnr = 0; pnr < phrases_nr; ++pnr) {
 			if (!special_phrases[pnr].builtin
@@ -828,5 +845,14 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 				break;
 			}
 		}
+		// We do not need the completely realized font, since we are
+		// only interested in the language, and that is never inherited.
+		// Therefore we can use getFontSettings instead of getFont.
+		LyXFont const & font = owner_->getFontSettings(bparams, i);
+		Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+		encoding.validate(getChar(i), features);
 	}
 }
+
+
+} // namespace lyx