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

diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C
index 8c0573d7ee..900837a49a 100644
--- a/src/paragraph_pimpl.C
+++ b/src/paragraph_pimpl.C
@@ -14,28 +14,30 @@
 #include <config.h>
 
 #include "paragraph_pimpl.h"
+#include "paragraph.h"
 
 #include "bufferparams.h"
 #include "debug.h"
 #include "encoding.h"
 #include "language.h"
 #include "LaTeXFeatures.h"
-#include "latexrunparams.h"
+#include "LColor.h"
+#include "lyxlength.h"
 #include "lyxrc.h"
-#include "paragraph_funcs.h"
+#include "outputparams.h"
 #include "texrow.h"
 
-#include "support/LAssert.h"
+#include <boost/next_prior.hpp>
+
+
+namespace lyx {
 
-using namespace lyx::support;
-using lyx::pos_type;
 using std::endl;
-using std::ostream;
 using std::upper_bound;
 using std::lower_bound;
+using std::string;
+
 
-// Initialize static member.
-ShareContainer<LyXFont> Paragraph::Pimpl::FontTable::container;
 // Initialization of the counter for the paragraph id's,
 unsigned int Paragraph::Pimpl::paragraph_id = 0;
 
@@ -43,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
 
 
@@ -68,246 +82,189 @@ 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;
-	text = p.text;
 	fontlist = p.fontlist;
 	id_ = paragraph_id++;
-
-	if (p.tracking())
-		changes_.reset(new Changes(*p.changes_.get()));
-}
-
-
-void Paragraph::Pimpl::clear()
-{
-	text.clear();
-#warning changes ?
-}
-
-
-void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par)
-{
-	text = par.pimpl_->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());
-}
-
-
-void Paragraph::Pimpl::untrackChanges()
-{
-	changes_.reset(0);
-}
-
-
-void Paragraph::Pimpl::cleanChanges()
+bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
 {
-	// if we're not tracking, we don't want to reset...
-	if (!tracking())
-		return;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	changes_.reset(new Changes(Change::INSERTED));
-	changes_->set(Change::INSERTED, 0, size());
+	return changes_.isChanged(start, end);
 }
 
 
-bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
-{
-	if (!tracking())
-		return false;
-
-	return changes_->isChange(start, end);
-}
+bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const {
+	// keep the logic here in sync with the logic of eraseChars()
 
+	if (!trackChanges) {
+		return true;
+	}
 
-bool Paragraph::Pimpl::isChangeEdited(pos_type start, pos_type end) const
-{
-	if (!tracking())
-		return false;
+	Change change = changes_.lookup(size());
 
-	return changes_->isChangeEdited(start, end);
+	return change.type == Change::INSERTED && change.author == 0;
 }
 
 
-void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type)
+void Paragraph::Pimpl::setChange(Change const & change)
 {
-	if (!tracking())
-		return;
-
-	changes_->set(type, 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
+void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
 {
-	if (!tracking())
-		return Change::UNCHANGED;
-
-	return changes_->lookup(pos);
-}
+	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()
+Change const & Paragraph::Pimpl::lookupChange(pos_type pos) const
 {
-	Assert(tracking());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	// FIXME: we should actually remove INSERTED chars.
-	// difficult because owning insettexts/tabulars need
-	// to update themselves when rows etc. change
-	changes_->set(Change::DELETED, 0, size());
-	changes_->reset(Change::DELETED);
+	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;
-	}
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	lyxerr << "acceptchange" << endl;
-	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:
+				// 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:
-				eraseIntern(i);
-				changes_->erase(i);
-				--end;
-				--i;
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
+					--end;
+					--pos;
+				}
 				break;
 		}
-	}
 
-	lyxerr << "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;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	if (!size()) {
-		changes_.reset(new Changes(Change::UNCHANGED));
-		return;
-	}
-
-	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:
-				eraseIntern(i);
-				changes_->erase(i);
-				--end;
-				--i;
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
+					--end;
+					--pos;
+				}
 				break;
 
 			case Change::DELETED:
-				changes_->set(Change::UNCHANGED, i);
+				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
 {
-#if 1
-	// This is in the critical path for loading!
-	pos_type const siz = size();
-
-	Assert(pos <= siz);
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	if (pos == siz) {
-		lyxerr << "getChar() on pos " << pos << " in par id "
-		       << owner_->id() << " of size " << siz
-		       << "  is a bit silly !" << endl;
-		return '\0';
-	}
-
-	return text[pos];
-#else
-	Assert(pos < size());
-	return text[pos];
-#endif
+	return owner_->getChar(pos);
 }
 
 
-void Paragraph::Pimpl::setChar(pos_type pos, value_type c)
+void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change)
 {
-#warning changes
-	text[pos] = c;
-}
-
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
-				  LyXFont const & font, Change change)
-{
-	Assert(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)
 	if (pos == size()) {
 		// when appending characters, no need to update tables
-		text.push_back(c);
-		owner_->setFont(pos, font);
+		owner_->text_.push_back(c);
 		return;
 	}
 
-	text.insert(text.begin() + pos, c);
+	owner_->text_.insert(owner_->text_.begin() + pos, c);
 
 	// 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);
@@ -315,36 +272,62 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
 
 	// Update the insets
 	owner_->insetlist.increasePosAfterPos(pos);
-
-	owner_->setFont(pos, font);
 }
 
 
-void Paragraph::Pimpl::insertInset(pos_type pos,
-				   InsetOld * inset, LyXFont const & font, Change change)
+void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset,
+                                   Change const & change)
 {
-	Assert(inset);
-	Assert(pos <= size());
+	BOOST_ASSERT(inset);
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	insertChar(pos, META_INSET, font, change);
-	Assert(text[pos] == META_INSET);
+	insertChar(pos, META_INSET, change);
+	BOOST_ASSERT(owner_->text_[pos] == META_INSET);
 
 	// Add a new entry in the insetlist.
 	owner_->insetlist.insert(inset, pos);
-
-	if (inset_owner)
-		inset->setOwner(inset_owner);
 }
 
 
-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 (text[pos] == Paragraph::META_INSET) {
+	if (owner_->text_[pos] == Paragraph::META_INSET) {
 		owner_->insetlist.erase(pos);
 	}
 
-	text.erase(text.begin() + pos);
+	owner_->text_.erase(owner_->text_.begin() + pos);
 
 	// Erase entries in the tables.
 	FontTable search_font(pos, LyXFont());
@@ -371,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)
-{
-	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 (text[pos] == Paragraph::META_INSET) {
-				InsetOld * i(owner_->getInset(pos));
-				i->markErased();
-			}
-			return false;
-		}
-	}
-
-	eraseIntern(pos);
 	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;
-	pos_type count = end - start;
-	while (count) {
-		if (!erase(i)) {
+	for (pos_type count = end - start; count; --count) {
+		if (!eraseChar(i, trackChanges))
 			++i;
-		}
-		--count;
 	}
 	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)
@@ -449,6 +442,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow,
 	} else {
 		os << ' ';
 	}
+	return false;
 }
 
 
@@ -462,7 +456,9 @@ 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) {
-		if (str[i] != text[pos + i])
+		// Caution: direct comparison of characters works only
+		// because str is pure ASCII.
+		if (str[i] != owner_->text_[pos + i])
 			return false;
 	}
 
@@ -482,9 +478,10 @@ 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,
-					     LatexRunParams const & runparams,
+					     OutputParams const & runparams,
 					     LyXFont & font,
 					     LyXFont & running_font,
 					     LyXFont & basefont,
@@ -499,11 +496,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 	if (style.pass_thru) {
 		if (c != Paragraph::META_INSET) {
 			if (c != '\0')
-				os << c;
-		} else {
-			InsetOld const * inset = owner_->getInset(i);
-			inset->ascii(buf, os, 0);
-		}
+				// 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;
 	}
 
@@ -512,21 +509,22 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 	// and then split to handle the two modes separately.
 	switch (c) {
 	case Paragraph::META_INSET: {
-		InsetOld * inset = owner_->getInset(i);
+		InsetBase * inset = owner_->getInset(i);
 
 		// FIXME: remove this check
 		if (!inset)
 			break;
 
 		// FIXME: move this to InsetNewline::latex
-		if (inset->lyxCode() == InsetOld::NEWLINE_CODE) {
+		if (inset->lyxCode() == InsetBase::NEWLINE_CODE) {
 			// newlines are handled differently here than
 			// the default in simpleTeXSpecialChars().
 			if (!style.newline_allowed) {
 				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);
@@ -546,18 +544,26 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			break;
 		}
 
-		if (inset->isTextInset()) {
+		// 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);
+		bool const output = bparams.outputChanges
+			&& runparams.flavor == OutputParams::LATEX
+			&& features.isAvailable("dvipost");
+
+		if (inset->canTrackChanges()) {
 			column += Changes::latexMarkChange(os, running_change,
-				Change::UNCHANGED);
+				Change::UNCHANGED, output);
 			running_change = Change::UNCHANGED;
 		}
 
 		bool close = false;
-		int const len = os.tellp();
-		//ostream::pos_type const len = os.tellp();
-		if ((inset->lyxCode() == InsetOld::GRAPHICS_CODE
-		     || inset->lyxCode() == InsetOld::MATH_CODE
-		     || inset->lyxCode() == InsetOld::URL_CODE)
+		odocstream::pos_type const len = os.tellp();
+
+		if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE
+		     || inset->lyxCode() == InsetBase::MATH_CODE
+		     || inset->lyxCode() == InsetBase::URL_CODE)
 		    && running_font.isRightToLeft()) {
 			os << "\\L{";
 			close = true;
@@ -571,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;
@@ -592,7 +596,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			texrow.start(owner_->id(), i + 1);
 			column = 0;
 		} else {
-			column += int(os.tellp()) - len;
+			column += os.tellp() - len;
 		}
 	}
 	break;
@@ -606,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
@@ -682,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;
 
@@ -708,9 +690,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 17;
 			break;
 
-		case '*': case '[': case ']':
+		case '*': case '[':
 			// avoid being mistaken for optional arguments
-			os << '{' << c << '}';
+			os << '{';
+			os.put(c);
+			os << '}';
 			column += 2;
 			break;
 
@@ -725,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;
 			}
@@ -752,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;
 		}
@@ -766,8 +772,6 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 	BufferParams const & bparams = features.bufferParams();
 
 	// check the params.
-	if (params.lineTop() || params.lineBottom())
-		features.require("lyxline");
 	if (!params.spacing().isDefault())
 		features.require("setspace");
 
@@ -786,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()) {
@@ -801,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,18 +824,19 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 		features.require("ParagraphLeftIndent");
 
 	// then the insets
-	InsetList::iterator icit = owner_->insetlist.begin();
-	InsetList::iterator iend = owner_->insetlist.end();
+	InsetList::const_iterator icit = owner_->insetlist.begin();
+	InsetList::const_iterator iend = owner_->insetlist.end();
 	for (; icit != iend; ++icit) {
 		if (icit->inset) {
 			icit->inset->validate(features);
 			if (layout.needprotect &&
-			    icit->inset->lyxCode() == InsetOld::FOOT_CODE)
+			    icit->inset->lyxCode() == InsetBase::FOOT_CODE)
 				features.require("NeedLyXFootnoteCode");
 		}
 	}
 
 	// 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
@@ -840,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