X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FParagraph.cpp;h=150c28d6a9adafe53b8be2cdc7d224dbf3d297e9;hb=69036ced3765f40048d62be800c98af3ea2d1b4a;hp=4a2149adea0e1f8d4524d60256ff755025f12620;hpb=7771fedf9c122bf583e7b9f8c05e36821fb85f7d;p=lyx.git

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index 4a2149adea..150c28d6a9 100644
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -5,6 +5,7 @@
  *
  * \author Asger Alstrup
  * \author Lars Gullik Bjønnes
+ * \author Richard Heck (XHTML output)
  * \author Jean-Marc Lasgouttes
  * \author Angus Leeming
  * \author John Levon
@@ -36,7 +37,6 @@
 #include "OutputParams.h"
 #include "output_latex.h"
 #include "output_xhtml.h"
-#include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
 #include "SpellChecker.h"
 #include "sgml.h"
@@ -164,8 +164,7 @@ public:
 		OutputParams const & runparams);
 
 	///
-	void validate(LaTeXFeatures & features,
-		      Layout const & layout) const;
+	void validate(LaTeXFeatures & features) const;
 
 	/// Checks if the paragraph contains only text and no inset or font change.
 	bool onlyText(Buffer const & buf, Font const & outerfont,
@@ -173,6 +172,12 @@ public:
 
 	/// match a string against a particular point in the paragraph
 	bool isTextAt(string const & str, pos_type pos) const;
+
+
+	InsetCode ownerCode() const
+	{
+		return inset_owner_ ? inset_owner_->lyxCode() : NO_CODE;
+	}
 	
 	/// Which Paragraph owns us?
 	Paragraph * owner_;
@@ -184,9 +189,8 @@ public:
 	FontList fontlist_;
 
 	///
-	unsigned int id_;
-	///
-	static unsigned int paragraph_id;
+	int id_;
+
 	///
 	ParagraphParameters params_;
 
@@ -203,17 +207,15 @@ public:
 	///
 	TextContainer text_;
 	
-	typedef std::set<docstring> Words;
+	typedef set<docstring> Words;
+	typedef map<Language, Words> LangWordsMap;
 	///
-	Words words_;
+	LangWordsMap words_;
 	///
 	Layout const * layout_;
 };
 
 
-// Initialization of the counter for the paragraph id's,
-unsigned int Paragraph::Private::paragraph_id = 0;
-
 namespace {
 
 struct special_phrase {
@@ -235,20 +237,26 @@ size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
 
 
 Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
-	: owner_(owner), inset_owner_(0), begin_of_body_(0), layout_(&layout)
+	: owner_(owner), inset_owner_(0), id_(-1), begin_of_body_(0), layout_(&layout)
 {
-	id_ = paragraph_id++;
 	text_.reserve(100);
 }
 
 
+// Initialization of the counter for the paragraph id's,
+//
+// FIXME: There should be a more intelligent way to generate and use the
+// paragraph ids per buffer instead a global static counter for all InsetText
+// in the running program.
+static int paragraph_id = -1;
+
 Paragraph::Private::Private(Private const & p, Paragraph * owner)
 	: owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_), 
 	  params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_),
 	  begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
 	  layout_(p.layout_)
 {
-	id_ = paragraph_id++;
+	id_ = ++paragraph_id;
 }
 
 
@@ -260,7 +268,7 @@ Paragraph::Private::Private(Private const & p, Paragraph * owner,
 	  begin_of_body_(p.begin_of_body_), words_(p.words_),
 	  layout_(p.layout_)
 {
-	id_ = paragraph_id++;
+	id_ = ++paragraph_id;
 	if (beg >= pos_type(p.text_.size()))
 		return;
 	text_ = p.text_.substr(beg, end - beg);
@@ -288,12 +296,12 @@ void Paragraph::addChangesToToc(DocIterator const & cdit,
 }
 
 
-bool Paragraph::isFullyDeleted(pos_type start, pos_type end) const
+bool Paragraph::isDeleted(pos_type start, pos_type end) const
 {
 	LASSERT(start >= 0 && start <= size(), /**/);
 	LASSERT(end > start && end <= size() + 1, /**/);
 
-	return d->changes_.isFullyDeleted(start, end);
+	return d->changes_.isDeleted(start, end);
 }
 
 
@@ -313,7 +321,7 @@ bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges) const
 		return true;
 
 	Change const change = d->changes_.lookup(size());
-	return change.type == Change::INSERTED && change.author == 0;
+	return change.inserted() && change.currentAuthor();
 }
 
 
@@ -334,7 +342,7 @@ void Paragraph::setChange(Change const & change)
 	 * Conclusion: An inset's content should remain untouched if you delete it
 	 */
 
-	if (change.type != Change::DELETED) {
+	if (!change.deleted()) {
 		for (pos_type pos = 0; pos < size(); ++pos) {
 			if (Inset * inset = getInset(pos))
 				inset->setChange(change);
@@ -349,7 +357,7 @@ void Paragraph::setChange(pos_type pos, Change const & change)
 	d->changes_.set(change, pos);
 
 	// see comment in setChange(Change const &) above
-	if (change.type != Change::DELETED && pos < size())
+	if (!change.deleted() && pos < size())
 			if (Inset * inset = getInset(pos))
 				inset->setChange(change);
 }
@@ -491,13 +499,13 @@ bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
 		//  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)) {
+		if (!change.changed() ||
+		      (change.inserted() && !change.currentAuthor())) {
 			setChange(pos, Change(Change::DELETED));
 			return false;
 		}
 
-		if (change.type == Change::DELETED)
+		if (change.deleted())
 			return false;
 	}
 
@@ -588,8 +596,8 @@ bool Paragraph::Private::simpleTeXBlanks(OutputParams const & runparams,
 		}
 	}
 
-	if (lyxrc.plaintext_linelen > 0
-	    && column > lyxrc.plaintext_linelen
+	if (runparams.linelen > 0
+	    && column > runparams.linelen
 	    && i
 	    && text_[i - 1] != ' '
 	    && (i + 1 < int(text_.size()))
@@ -759,14 +767,14 @@ void Paragraph::Private::latexInset(
 		column = 0;
 	}
 
-	if (owner_->lookupChange(i).type == Change::DELETED) {
+	if (owner_->isDeleted(i)) {
 		if( ++runparams.inDeletedInset == 1)
 			runparams.changeOfDeletedInset = owner_->lookupChange(i);
 	}
 
 	if (inset->canTrackChanges()) {
 		column += Changes::latexMarkChange(os, bparams, running_change,
-			Change(Change::UNCHANGED));
+			Change(Change::UNCHANGED), runparams);
 		running_change = Change(Change::UNCHANGED);
 	}
 
@@ -839,16 +847,14 @@ void Paragraph::Private::latexInset(
 	}
 
 	if (tmp) {
-		for (int j = 0; j < tmp; ++j)
-			texrow.newline();
-
+		texrow.newlines(tmp);
 		texrow.start(owner_->id(), i + 1);
 		column = 0;
 	} else {
 		column += os.tellp() - len;
 	}
 
-	if (owner_->lookupChange(i).type == Change::DELETED)
+	if (owner_->isDeleted(i))
 		--runparams.inDeletedInset;
 }
 
@@ -1065,15 +1071,37 @@ bool Paragraph::Private::latexSpecialPhrase(odocstream & os, pos_type & i,
 }
 
 
-void Paragraph::Private::validate(LaTeXFeatures & features,
-				Layout const & layout) const
-{
+void Paragraph::Private::validate(LaTeXFeatures & features) const
+{
+	if (layout_->inpreamble && inset_owner_) {
+		Buffer const & buf = inset_owner_->buffer();
+		BufferParams const & bp = buf.params();
+		Font f;
+		TexRow tr;
+		odocstringstream ods;
+		// we have to provide all the optional arguments here, even though
+		// the last one is the only one we care about.
+		owner_->latex(bp, f, ods, tr, features.runparams(), 0, -1, true);
+		docstring const d = ods.str();
+		if (!d.empty()) {
+			// this will have "{" at the beginning, but not at the end
+			string const content = to_utf8(d);
+			string const cmd = layout_->latexname();
+			features.addPreambleSnippet("\\" + cmd + content + "}");
+		}
+	}
+	
+	if (features.runparams().flavor == OutputParams::HTML 
+	    && layout_->htmltitle()) {
+		features.setHTMLTitle(owner_->asString(AS_STR_INSETS));
+	}
+	
 	// check the params.
 	if (!params_.spacing().isDefault())
 		features.require("setspace");
 
 	// then the layouts
-	features.useLayout(layout.name());
+	features.useLayout(layout_->name());
 
 	// then the fonts
 	fontlist_.validate(features);
@@ -1088,7 +1116,7 @@ void Paragraph::Private::validate(LaTeXFeatures & features,
 	for (; icit != iend; ++icit) {
 		if (icit->inset) {
 			icit->inset->validate(features);
-			if (layout.needprotect &&
+			if (layout_->needprotect &&
 			    icit->inset->lyxCode() == FOOT_CODE)
 				features.require("NeedLyXFootnoteCode");
 		}
@@ -1163,6 +1191,18 @@ Paragraph::~Paragraph()
 }
 
 
+namespace {
+
+// this shall be called just before every "os << ..." action.
+void flushString(ostream & os, docstring & s)
+{
+	os << to_utf8(s);
+	s.erase();
+}
+
+}
+
+
 void Paragraph::write(ostream & os, BufferParams const & bparams,
 	depth_type & dth) const
 {
@@ -1190,10 +1230,16 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 
 	Change running_change = Change(Change::UNCHANGED);
 
+	// this string is used as a buffer to avoid repetitive calls
+	// to to_utf8(), which turn out to be expensive (JMarc)
+	docstring write_buffer;
+
 	int column = 0;
 	for (pos_type i = 0; i <= size(); ++i) {
 
 		Change const change = lookupChange(i);
+		if (change != running_change)
+			flushString(os, write_buffer);
 		Changes::lyxMarkChange(os, bparams, column, running_change, change);
 		running_change = change;
 
@@ -1204,6 +1250,7 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 		Font font2 = getFontSettings(bparams, i);
 		font2.setMisspelled(false);
 		if (font2 != font1) {
+			flushString(os, write_buffer);
 			font2.lyxWriteChanges(font1, os);
 			column = 0;
 			font1 = font2;
@@ -1213,6 +1260,7 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 		switch (c) {
 		case META_INSET:
 			if (Inset const * inset = getInset(i)) {
+				flushString(os, write_buffer);
 				if (inset->directWrite()) {
 					// international char, let it write
 					// code directly so it's shorter in
@@ -1229,10 +1277,12 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 			}
 			break;
 		case '\\':
+			flushString(os, write_buffer);
 			os << "\n\\backslash\n";
 			column = 0;
 			break;
 		case '.':
+			flushString(os, write_buffer);
 			if (i + 1 < size() && d->text_[i + 1] == ' ') {
 				os << ".\n";
 				column = 0;
@@ -1242,13 +1292,14 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 		default:
 			if ((column > 70 && c == ' ')
 			    || column > 79) {
+				flushString(os, write_buffer);
 				os << '\n';
 				column = 0;
 			}
 			// this check is to amend a bug. LyX sometimes
 			// inserts '\0' this could cause problems.
 			if (c != '\0')
-				os << to_utf8(docstring(1, c));
+				write_buffer.push_back(c);
 			else
 				LYXERR0("NUL char in structure.");
 			++column;
@@ -1256,13 +1307,14 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 		}
 	}
 
+	flushString(os, write_buffer);
 	os << "\n\\end_layout\n";
 }
 
 
 void Paragraph::validate(LaTeXFeatures & features) const
 {
-	d->validate(features, *d->layout_);
+	d->validate(features);
 }
 
 
@@ -1609,7 +1661,21 @@ void Paragraph::setLabelWidthString(docstring const & s)
 }
 
 
-docstring Paragraph::expandLabel(Layout const & layout,
+docstring Paragraph::expandLabel(Layout const & layout, 
+		BufferParams const & bparams) const
+{ 
+	return expandParagraphLabel(layout, bparams, true); 
+}
+
+
+docstring Paragraph::expandDocBookLabel(Layout const & layout, 
+		BufferParams const & bparams) const
+{
+	return expandParagraphLabel(layout, bparams, false);
+}
+
+
+docstring Paragraph::expandParagraphLabel(Layout const & layout,
 		BufferParams const & bparams, bool process_appendix) const
 {
 	DocumentClass const & tclass = bparams.documentClass();
@@ -1630,7 +1696,7 @@ docstring Paragraph::expandLabel(Layout const & layout,
 			docstring parent(fmt, i + 1, j - i - 1);
 			docstring label = from_ascii("??");
 			if (tclass.hasLayout(parent))
-				docstring label = expandLabel(tclass[parent], bparams,
+				docstring label = expandParagraphLabel(tclass[parent], bparams,
 						      process_appendix);
 			fmt = docstring(fmt, 0, i) + label 
 				+ docstring(fmt, j + 1, docstring::npos);
@@ -1695,12 +1761,6 @@ void Paragraph::setBeginOfBody()
 }
 
 
-bool Paragraph::forcePlainLayout() const
-{
-	return inInset().forcePlainLayout();
-}
-
-
 bool Paragraph::allowParagraphCustomization() const
 {
 	return inInset().allowParagraphCustomization();
@@ -1795,6 +1855,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
 	case LYX_ALIGN_BLOCK:
 	case LYX_ALIGN_LAYOUT:
 	case LYX_ALIGN_SPECIAL:
+	case LYX_ALIGN_DECIMAL:
 		break;
 	case LYX_ALIGN_LEFT:
 	case LYX_ALIGN_RIGHT:
@@ -1807,7 +1868,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
 	}
 
 	string const begin_tag = "\\begin";
-	InsetCode code = owner_->ownerCode();
+	InsetCode code = ownerCode();
 	bool const lastpar = runparams.isLastPar;
 
 	switch (curAlign) {
@@ -1815,6 +1876,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
 	case LYX_ALIGN_BLOCK:
 	case LYX_ALIGN_LAYOUT:
 	case LYX_ALIGN_SPECIAL:
+	case LYX_ALIGN_DECIMAL:
 		break;
 	case LYX_ALIGN_LEFT: {
 		string output;
@@ -1863,6 +1925,7 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
 	case LYX_ALIGN_BLOCK:
 	case LYX_ALIGN_LAYOUT:
 	case LYX_ALIGN_SPECIAL:
+	case LYX_ALIGN_DECIMAL:
 		break;
 	case LYX_ALIGN_LEFT:
 	case LYX_ALIGN_RIGHT:
@@ -1875,7 +1938,7 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
 	}
 
 	string const end_tag = "\n\\par\\end";
-	InsetCode code = owner_->ownerCode();
+	InsetCode code = ownerCode();
 	bool const lastpar = runparams.isLastPar;
 
 	switch (curAlign) {
@@ -1883,6 +1946,7 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
 	case LYX_ALIGN_BLOCK:
 	case LYX_ALIGN_LAYOUT:
 	case LYX_ALIGN_SPECIAL:
+	case LYX_ALIGN_DECIMAL:
 		break;
 	case LYX_ALIGN_LEFT: {
 		string output;
@@ -1916,23 +1980,24 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
 
 
 // This one spits out the text of the paragraph
-bool Paragraph::latex(BufferParams const & bparams,
+void Paragraph::latex(BufferParams const & bparams,
 	Font const & outerfont,
 	odocstream & os, TexRow & texrow,
 	OutputParams const & runparams,
-	int start_pos, int end_pos) const
+	int start_pos, int end_pos, bool force) const
 {
 	LYXERR(Debug::LATEX, "Paragraph::latex...     " << this);
 
-	bool return_value = false;
-
-	bool const allowcust = allowParagraphCustomization();
-
 	// FIXME This check should not be needed. Perhaps issue an
 	// error if it triggers.
-	Layout const & style = forcePlainLayout() ?
+	Layout const & style = inInset().forcePlainLayout() ?
 		bparams.documentClass().plainLayout() : *d->layout_;
 
+	if (!force && style.inpreamble)
+		return;
+
+	bool const allowcust = allowParagraphCustomization();
+
 	// Current base font for all inherited font changes, without any
 	// change caused by an individual character, except for the language:
 	// It is set to the language of the first character.
@@ -1946,8 +2011,10 @@ bool Paragraph::latex(BufferParams const & bparams,
 	unsigned int column = 0;
 
 	if (body_pos > 0) {
-		os << '[';
-		column += 1;
+		// the optional argument is kept in curly brackets in
+		// case it contains a ']'
+		os << "[{";
+		column += 2;
 		basefont = getLabelFont(bparams, outerfont);
 	} else {
 		basefont = getLayoutFont(bparams, outerfont);
@@ -1989,11 +2056,12 @@ bool Paragraph::latex(BufferParams const & bparams,
 				running_font = basefont;
 
 				column += Changes::latexMarkChange(os, bparams,
-						runningChange, Change(Change::UNCHANGED));
+						runningChange, Change(Change::UNCHANGED),
+						runparams);
 				runningChange = Change(Change::UNCHANGED);
 
-				os << "] ";
-				column +=2;
+				os << "}] ";
+				column +=3;
 			}
 			if (style.isCommand()) {
 				os << '{';
@@ -2018,13 +2086,14 @@ bool Paragraph::latex(BufferParams const & bparams,
 			basefont = getLayoutFont(bparams, outerfont);
 			running_font = basefont;
 
-			column += Changes::latexMarkChange(os, bparams, runningChange, change);
+			column += Changes::latexMarkChange(os, bparams, runningChange,
+							   change, runparams);
 			runningChange = change;
 		}
 
 		// do not output text which is marked deleted
 		// if change tracking output is disabled
-		if (!bparams.outputChanges && change.type == Change::DELETED) {
+		if (!bparams.outputChanges && change.deleted()) {
 			continue;
 		}
 
@@ -2163,9 +2232,8 @@ bool Paragraph::latex(BufferParams const & bparams,
 	if (open_font) {
 #ifdef FIXED_LANGUAGE_END_DETECTION
 		if (next_) {
-			running_font
-				.latexWriteEndChanges(os, bparams, runparams,
-					basefont,
+			running_font.latexWriteEndChanges(os, bparams,
+					runparams, basefont,
 					next_->getFont(bparams, 0, outerfont));
 		} else {
 			running_font.latexWriteEndChanges(os, bparams,
@@ -2180,19 +2248,22 @@ bool Paragraph::latex(BufferParams const & bparams,
 #endif
 	}
 
-	column += Changes::latexMarkChange(os, bparams, runningChange, Change(Change::UNCHANGED));
+	column += Changes::latexMarkChange(os, bparams, runningChange,
+					   Change(Change::UNCHANGED), runparams);
 
 	// Needed if there is an optional argument but no contents.
 	if (body_pos > 0 && body_pos == size()) {
-		os << "]~";
-		return_value = false;
+		os << "}]~";
 	}
 
-	if (allowcust && d->endTeXParParams(bparams, os, texrow, runparams))
+	if (allowcust && d->endTeXParParams(bparams, os, texrow, runparams)
+	    && runparams.encoding != prev_encoding) {
 		runparams.encoding = prev_encoding;
+		if (!bparams.useXetex)
+			os << setEncoding(prev_encoding->iconvName());
+	}
 
 	LYXERR(Debug::LATEX, "Paragraph::latex... done " << this);
-	return return_value;
 }
 
 
@@ -2257,18 +2328,18 @@ pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runpa
 }
 
 
-pos_type Paragraph::firstWordLyXHTML(odocstream & os, OutputParams const & runparams)
+pos_type Paragraph::firstWordLyXHTML(XHTMLStream & xs, OutputParams const & runparams)
 	const
 {
 	pos_type i;
 	for (i = 0; i < size(); ++i) {
 		if (Inset const * inset = getInset(i)) {
-			inset->xhtml(os, runparams);
+			inset->xhtml(xs, runparams);
 		} else {
 			char_type c = d->text_[i];
 			if (c == ' ')
 				break;
-			os << html::escapeChar(c);
+			xs << c;
 		}
 	}
 	return i;
@@ -2347,59 +2418,76 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf,
 
 
 docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
-				    odocstream & os,
+				    XHTMLStream & xs,
 				    OutputParams const & runparams,
 				    Font const & outerfont,
 				    pos_type initial) const
 {
 	docstring retval;
 
-	// FIXME We really need to manage the tag nesting here.
-	// Probably in the same sort of way as in output_xhtml.
 	bool emph_flag = false;
 	bool bold_flag = false;
-	std::string closing_tag;
+	string closing_tag;
 
 	Layout const & style = *d->layout_;
+
+	if (!runparams.for_toc && runparams.html_make_pars) {
+		// generate a magic label for this paragraph
+		string const attr = "id='" + magicLabel() + "'";
+		xs << html::CompTag("a", attr);
+	}
+
 	FontInfo font_old =
 		style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
 
-	//if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
-	//	os << "]]>";
-
 	// parsing main loop
 	for (pos_type i = initial; i < size(); ++i) {
+		// let's not show deleted material in the output
+		if (isDeleted(i))
+			continue;
+	
 		Font font = getFont(buf.params(), i, outerfont);
 
 		// emphasis
 		if (font_old.emph() != font.fontInfo().emph()) {
 			if (font.fontInfo().emph() == FONT_ON) {
-				os << "<em>";
+				xs << html::StartTag("em");
 				emph_flag = true;
 			} else if (emph_flag && i != initial) {
-				os << "</em>";
+				xs << html::EndTag("em");
 				emph_flag = false;
 			}
 		}
 		// bold
 		if (font_old.series() != font.fontInfo().series()) {
 			if (font.fontInfo().series() == BOLD_SERIES) {
-				os << "<strong>";
+				xs << html::StartTag("strong");
 				bold_flag = true;
 			} else if (bold_flag && i != initial) {
-				os << "</strong>";
+				xs << html::EndTag("strong");
 				bold_flag = false;
 			}
 		}
-		// FIXME Other such tags? 
-
-		if (Inset const * inset = getInset(i)) {
-			retval += inset->xhtml(os, runparams);
+		// FIXME XHTML
+		// Other such tags? What about the other text ranges?
+
+		Inset const * inset = getInset(i);
+		if (inset) {
+			InsetCommand const * ic = inset->asInsetCommand();
+			InsetLayout const & il = inset->getLayout();
+			InsetMath const * im = inset->asInsetMath();
+			if (!runparams.for_toc 
+			    || im || il.isInToc() || (ic && ic->isInToc())) {
+				OutputParams np = runparams;
+				if (!il.htmlisblock())
+					np.html_in_par = true;
+				retval += inset->xhtml(xs, np);
+			}
 		} else {
 			char_type c = d->text_[i];
 
 			if (style.pass_thru)
-				os.put(c);
+				xs << c;
 			else if (c == '-') {
 				docstring str;
 				int j = i + 1;
@@ -2415,19 +2503,17 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
 				}
 				else
 					str += c;
-				os << str;
+				// We don't want to escape the entities. Note that
+				// it is safe to do this, since str can otherwise
+				// only be "-". E.g., it can't be "<".
+				xs << XHTMLStream::NextRaw() << str;
 			} else
-				os << html::escapeChar(c);
+				xs << c;
 		}
 		font_old = font.fontInfo();
 	}
 
-	// FIXME This could be out of order. See above.
-	if (emph_flag)
-		os << "</em>";
-	if (bold_flag)
-		os << "</strong>";
-
+	xs.closeFontTags();
 	return retval;
 }
 
@@ -2521,7 +2607,7 @@ void Paragraph::changeLanguage(BufferParams const & bparams,
 
 bool Paragraph::isMultiLingual(BufferParams const & bparams) const
 {
-	Language const * doc_language =	bparams.language;
+	Language const * doc_language = bparams.language;
 	FontList::const_iterator cit = d->fontlist_.begin();
 	FontList::const_iterator end = d->fontlist_.end();
 
@@ -2534,6 +2620,20 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) const
 }
 
 
+void Paragraph::getLanguages(std::set<Language const *> & languages) const
+{
+	FontList::const_iterator cit = d->fontlist_.begin();
+	FontList::const_iterator end = d->fontlist_.end();
+
+	for (; cit != end; ++cit) {
+		Language const * lang = cit->font().language();
+		if (lang != ignore_language &&
+		    lang != latex_language)
+			languages.insert(lang);
+	}
+}
+
+
 docstring Paragraph::asString(int options) const
 {
 	return asString(0, size(), options);
@@ -2545,8 +2645,8 @@ docstring Paragraph::asString(pos_type beg, pos_type end, int options) const
 	odocstringstream os;
 
 	if (beg == 0 
-		&& options & AS_STR_LABEL
-		&& !d->params_.labelString().empty())
+	    && options & AS_STR_LABEL
+	    && !d->params_.labelString().empty())
 		os << d->params_.labelString() << ' ';
 
 	for (pos_type i = beg; i < end; ++i) {
@@ -2600,6 +2700,12 @@ int Paragraph::id() const
 }
 
 
+void Paragraph::setId(int id)
+{
+	d->id_ = id;
+}
+
+
 Layout const & Paragraph::layout() const
 {
 	return *d->layout_;
@@ -2641,12 +2747,6 @@ Inset const & Paragraph::inInset() const
 }
 
 
-InsetCode Paragraph::ownerCode() const
-{
-	return d->inset_owner_ ? d->inset_owner_->lyxCode() : NO_CODE;
-}
-
-
 ParagraphParameters & Paragraph::params()
 {
 	return d->params_;
@@ -2773,7 +2873,7 @@ int Paragraph::checkBiblio(Buffer const & buffer)
 	// There was no inset at the beginning, so we need to create one with
 	// the key and label of the one we erased.
 	InsetBibitem * inset = 
-		new InsetBibitem(buffer, InsetCommandParams(BIBITEM_CODE));
+		new InsetBibitem(const_cast<Buffer *>(&buffer), InsetCommandParams(BIBITEM_CODE));
 	// restore values of previously deleted item in this par.
 	if (!oldkey.empty())
 		inset->setParam("key", oldkey);
@@ -2791,21 +2891,21 @@ void Paragraph::checkAuthors(AuthorList const & authorList)
 }
 
 
-bool Paragraph::isUnchanged(pos_type pos) const
+bool Paragraph::isChanged(pos_type pos) const
 {
-	return lookupChange(pos).type == Change::UNCHANGED;
+	return lookupChange(pos).changed();
 }
 
 
 bool Paragraph::isInserted(pos_type pos) const
 {
-	return lookupChange(pos).type == Change::INSERTED;
+	return lookupChange(pos).inserted();
 }
 
 
 bool Paragraph::isDeleted(pos_type pos) const
 {
-	return lookupChange(pos).type == Change::DELETED;
+	return lookupChange(pos).deleted();
 }
 
 
@@ -2974,10 +3074,15 @@ bool Paragraph::isSeparator(pos_type pos) const
 
 void Paragraph::deregisterWords()
 {
-	Private::Words::const_iterator it;
-	WordList & wl = theWordList();
-	for (it = d->words_.begin(); it != d->words_.end(); ++it)
-		wl.remove(*it);
+	Private::LangWordsMap::const_iterator itl = d->words_.begin();
+	Private::LangWordsMap::const_iterator ite = d->words_.end();
+	for (; itl != ite; ++itl) {
+		WordList * wl = theWordList(itl->first);
+		Private::Words::const_iterator it = (itl->second).begin();
+		Private::Words::const_iterator et = (itl->second).end();
+		for (; it != et; ++it)
+			wl->remove(*it);
+	}
 	d->words_.clear();
 }
 
@@ -3021,22 +3126,22 @@ void Paragraph::locateWord(pos_type & from, pos_type & to,
 
 void Paragraph::collectWords()
 {
+	// This is the value that needs to be exposed in the preferences
+	// to resolve bug #6760.
+	static int minlength = 6;
 	pos_type n = size();
-	WordLangTuple wl;
-	docstring_list suggestions;
 	for (pos_type pos = 0; pos < n; ++pos) {
 		if (isWordSeparator(pos))
 			continue;
 		pos_type from = pos;
 		locateWord(from, pos, WHOLE_WORD);
-		if (pos - from >= 6) {
+		if (pos - from >= minlength) {
 			docstring word = asString(from, pos, AS_STR_NONE);
-			d->words_.insert(word);
-		}
-		if (lyxrc.spellcheck_continuously
-		    && spellCheck(from, pos, wl, suggestions)) {
-			for (size_t i = 0; i != suggestions.size(); ++i)
-				d->words_.insert(suggestions[i]);
+			FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
+			if (cit == d->fontlist_.end())
+				return;
+			Language const * lang = cit->font().language();
+			d->words_[*lang].insert(word);
 		}
 	}
 }
@@ -3044,10 +3149,15 @@ void Paragraph::collectWords()
 
 void Paragraph::registerWords()
 {
-	Private::Words::const_iterator it;
-	WordList & wl = theWordList();
-	for (it = d->words_.begin(); it != d->words_.end(); ++it)
-		wl.insert(*it);
+	Private::LangWordsMap::const_iterator itl = d->words_.begin();
+	Private::LangWordsMap::const_iterator ite = d->words_.end();
+	for (; itl != ite; ++itl) {
+		WordList * wl = theWordList(itl->first);
+		Private::Words::const_iterator it = (itl->second).begin();
+		Private::Words::const_iterator et = (itl->second).end();
+		for (; it != et; ++it)
+			wl->insert(*it);
+	}
 }
 
 
@@ -3066,21 +3176,40 @@ bool Paragraph::spellCheck(pos_type & from, pos_type & to, WordLangTuple & wl,
 	if (!speller)
 		return false;
 
+	if (!d->layout_->spellcheck || !inInset().allowSpellCheck())
+		return false;
+
 	locateWord(from, to, WHOLE_WORD);
 	if (from == to || from >= pos_type(d->text_.size()))
 		return false;
 
 	docstring word = asString(from, to, AS_STR_INSETS);
-	string const lang_code = lyxrc.spellchecker_alt_lang.empty()
-		? getFontSettings(d->inset_owner_->buffer().params(), from).language()->code()
-		: lyxrc.spellchecker_alt_lang;
-	wl = WordLangTuple(word, lang_code);
-	SpellChecker::Result res = speller->check(wl);
+	// Ignore words with digits
+	// FIXME: make this customizable
+	// (note that hunspell ignores words with digits by default)
+	bool const ignored = hasDigit(word);
+	Language * lang = const_cast<Language *>(getFontSettings(
+		    d->inset_owner_->buffer().params(), from).language());
+	if (lang == d->inset_owner_->buffer().params().language
+	    && !lyxrc.spellchecker_alt_lang.empty()) {
+		string lang_code;
+		string const lang_variety =
+			split(lyxrc.spellchecker_alt_lang, lang_code, '-');
+		lang->setCode(lang_code);
+		lang->setVariety(lang_variety);
+	}
+	wl = WordLangTuple(word, lang);
+	SpellChecker::Result res = ignored ?
+		SpellChecker::OK : speller->check(wl);
+#if 0
+// FIXME: the code below makes aspell abort if a word in an unknown
+//	  language is checked.
 	// Just ignore any error that the spellchecker reports.
 	// FIXME: we should through out an exception and catch it in the GUI to
 	// display the error.
 	if (!speller->error().empty())
 		return false;
+#endif
 
 	bool const misspelled = res != SpellChecker::OK
 		&& res != SpellChecker::IGNORED_WORD;
@@ -3107,4 +3236,12 @@ bool Paragraph::isMisspelled(pos_type pos) const
 }
 
 
+string Paragraph::magicLabel() const
+{
+	stringstream ss;
+	ss << "magicparlabel-" << id();
+	return ss.str();
+}
+
+
 } // namespace lyx