X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FParagraph.cpp;h=991ab14a7527d65083207e171b9e34b8fb720fce;hb=ea6aed5b8bf38366aaa1eb15ce1b9f13de76987f;hp=1a1f2e814a314f1970de4b5902f7141a7695c995;hpb=040f3431e7a2350806594319704ff97a0284e9c1;p=lyx.git

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index 1a1f2e814a..991ab14a75 100644
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -19,6 +19,7 @@
 
 #include "Paragraph.h"
 
+#include "LayoutFile.h"
 #include "Buffer.h"
 #include "BufferParams.h"
 #include "Changes.h"
@@ -39,14 +40,16 @@
 #include "sgml.h"
 #include "TextClass.h"
 #include "TexRow.h"
+#include "Text.h"
 #include "VSpace.h"
+#include "WordList.h"
 
 #include "frontends/alert.h"
-#include "frontends/FontMetrics.h"
 
 #include "insets/InsetBibitem.h"
 #include "insets/InsetLabel.h"
 
+#include "support/lassert.h"
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/gettext.h"
@@ -77,9 +80,11 @@ class Paragraph::Private
 {
 public:
 	///
-	Private(Paragraph * owner);
+	Private(Paragraph * owner, Layout const & layout);
 	/// "Copy constructor"
 	Private(Private const &, Paragraph * owner);
+	/// Copy constructor from \p beg  to \p end
+	Private(Private const &, Paragraph * owner, pos_type beg, pos_type end);
 
 	///
 	void insertChar(pos_type pos, char_type c, Change const & change);
@@ -114,7 +119,7 @@ public:
 			    bool) const;
 
 	///
-	void latexInset(Buffer const &, BufferParams const &,
+	void latexInset(BufferParams const &,
 				   odocstream &,
 				   TexRow & texrow, OutputParams &,
 				   Font & running_font,
@@ -188,15 +193,18 @@ public:
 	///
 	InsetList insetlist_;
 
-	///
-	LayoutPtr layout_;
-
 	/// end of label
 	pos_type begin_of_body_;
 
 	typedef docstring TextContainer;
 	///
 	TextContainer text_;
+	
+	typedef std::set<docstring> Words;
+	///
+	Words words_;
+	///
+	Layout const * layout_;
 };
 
 
@@ -223,8 +231,8 @@ size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
 } // namespace anon
 
 
-Paragraph::Private::Private(Paragraph * owner)
-	: owner_(owner), inset_owner_(0), begin_of_body_(0)
+Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
+	: owner_(owner), inset_owner_(0), begin_of_body_(0), layout_(&layout)
 {
 	id_ = paragraph_id++;
 	text_.reserve(100);
@@ -234,16 +242,46 @@ Paragraph::Private::Private(Paragraph * owner)
 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_),
-	  layout_(p.layout_), begin_of_body_(p.begin_of_body_), text_(p.text_)
+	  begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
+	  layout_(p.layout_)
 {
 	id_ = paragraph_id++;
 }
 
 
+Paragraph::Private::Private(Private const & p, Paragraph * owner,
+	pos_type beg, pos_type end)
+	: owner_(owner), inset_owner_(p.inset_owner_),
+	  insetlist_(p.insetlist_, beg, end),
+	  params_(p.params_), changes_(p.changes_),
+	  begin_of_body_(p.begin_of_body_), words_(p.words_),
+	  layout_(p.layout_)
+{
+	id_ = paragraph_id++;
+	if (beg >= pos_type(p.text_.size()))
+		return;
+	text_ = p.text_.substr(beg, end - beg);
+
+	FontList::const_iterator fcit = fontlist_.begin();
+	FontList::const_iterator fend = fontlist_.end();
+	for (; fcit != fend; ++fcit) {
+		if (fcit->pos() < beg)
+			continue;
+		if (fcit->pos() >= end) {
+			// Add last entry in the fontlist_.
+			fontlist_.set(text_.size() - 1, fcit->font());
+			break;
+		}
+		// Add a new entry in the fontlist_.
+		fontlist_.set(fcit->pos() - beg, fcit->font());
+	}
+}
+
+
 bool Paragraph::isChanged(pos_type start, pos_type end) const
 {
-	BOOST_ASSERT(start >= 0 && start <= size());
-	BOOST_ASSERT(end > start && end <= size() + 1);
+	LASSERT(start >= 0 && start <= size(), /**/);
+	LASSERT(end > start && end <= size() + 1, /**/);
 
 	return d->changes_.isChanged(start, end);
 }
@@ -288,7 +326,7 @@ void Paragraph::setChange(Change const & change)
 
 void Paragraph::setChange(pos_type pos, Change const & change)
 {
-	BOOST_ASSERT(pos >= 0 && pos <= size());
+	LASSERT(pos >= 0 && pos <= size(), /**/);
 	d->changes_.set(change, pos);
 
 	// see comment in setChange(Change const &) above
@@ -300,7 +338,7 @@ void Paragraph::setChange(pos_type pos, Change const & change)
 
 Change const & Paragraph::lookupChange(pos_type pos) const
 {
-	BOOST_ASSERT(pos >= 0 && pos <= size());
+	LASSERT(pos >= 0 && pos <= size(), /**/);
 	return d->changes_.lookup(pos);
 }
 
@@ -308,8 +346,8 @@ Change const & Paragraph::lookupChange(pos_type pos) const
 void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start,
 		pos_type end)
 {
-	BOOST_ASSERT(start >= 0 && start <= size());
-	BOOST_ASSERT(end > start && end <= size() + 1);
+	LASSERT(start >= 0 && start <= size(), /**/);
+	LASSERT(end > start && end <= size() + 1, /**/);
 
 	for (pos_type pos = start; pos < end; ++pos) {
 		switch (lookupChange(pos).type) {
@@ -344,8 +382,8 @@ void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start,
 void Paragraph::rejectChanges(BufferParams const & bparams,
 		pos_type start, pos_type end)
 {
-	BOOST_ASSERT(start >= 0 && start <= size());
-	BOOST_ASSERT(end > start && end <= size() + 1);
+	LASSERT(start >= 0 && start <= size(), /**/);
+	LASSERT(end > start && end <= size() + 1, /**/);
 
 	for (pos_type pos = start; pos < end; ++pos) {
 		switch (lookupChange(pos).type) {
@@ -380,7 +418,7 @@ void Paragraph::rejectChanges(BufferParams const & bparams,
 void Paragraph::Private::insertChar(pos_type pos, char_type c,
 		Change const & change)
 {
-	BOOST_ASSERT(pos >= 0 && pos <= int(text_.size()));
+	LASSERT(pos >= 0 && pos <= int(text_.size()), /**/);
 
 	// track change
 	changes_.insert(change, pos);
@@ -406,11 +444,11 @@ void Paragraph::Private::insertChar(pos_type pos, char_type c,
 void Paragraph::insertInset(pos_type pos, Inset * inset,
 				   Change const & change)
 {
-	BOOST_ASSERT(inset);
-	BOOST_ASSERT(pos >= 0 && pos <= size());
+	LASSERT(inset, /**/);
+	LASSERT(pos >= 0 && pos <= size(), /**/);
 
 	d->insertChar(pos, META_INSET, change);
-	BOOST_ASSERT(d->text_[pos] == META_INSET);
+	LASSERT(d->text_[pos] == META_INSET, /**/);
 
 	// Add a new entry in the insetlist_.
 	d->insetlist_.insert(inset, pos);
@@ -419,7 +457,7 @@ void Paragraph::insertInset(pos_type pos, Inset * inset,
 
 bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
 {
-	BOOST_ASSERT(pos >= 0 && pos <= size());
+	LASSERT(pos >= 0 && pos <= size(), /**/);
 
 	// keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
 
@@ -468,8 +506,8 @@ bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
 
 int Paragraph::eraseChars(pos_type start, pos_type end, bool trackChanges)
 {
-	BOOST_ASSERT(start >= 0 && start <= size());
-	BOOST_ASSERT(end >= start && end <= size() + 1);
+	LASSERT(start >= 0 && start <= size(), /**/);
+	LASSERT(end >= start && end <= size() + 1, /**/);
 
 	pos_type i = start;
 	for (pos_type count = end - start; count; --count) {
@@ -492,7 +530,12 @@ int Paragraph::Private::latexSurrogatePair(odocstream & os, char_type c,
 	// Is this correct WRT change tracking?
 	docstring const latex1 = encoding.latexChar(next);
 	docstring const latex2 = encoding.latexChar(c);
-	os << latex1 << '{' << latex2 << '}';
+	if (docstring(1, next) == latex1) {
+		// the encoding supports the combination
+		os << latex2 << latex1;
+		return latex1.length() + latex2.length();
+	} else
+		os << latex1 << '{' << latex2 << '}';
 	return latex1.length() + latex2.length() + 2;
 }
 
@@ -554,9 +597,10 @@ int Paragraph::Private::writeScriptChars(odocstream & os,
 
 	// We only arrive here when a proper language for character text_[i] has
 	// not been specified (i.e., it could not be translated in the current
-	// latex encoding) and it belongs to a known script.
-	// Parameter ltx contains the latex translation of text_[i] as specified in
-	// the unicodesymbols file and is something like "\textXXX{<spec>}".
+	// latex encoding) or its latex translation has been forced, and it
+	// belongs to a known script.
+	// Parameter ltx contains the latex translation of text_[i] as specified
+	// in the unicodesymbols file and is something like "\textXXX{<spec>}".
 	// The latex macro name "textXXX" specifies the script to which text_[i]
 	// belongs and we use it in order to check whether characters from the
 	// same script immediately follow, such that we can collect them in a
@@ -565,8 +609,16 @@ int Paragraph::Private::writeScriptChars(odocstream & os,
 	docstring::size_type const brace1 = ltx.find_first_of(from_ascii("{"));
 	docstring::size_type const brace2 = ltx.find_last_of(from_ascii("}"));
 	string script = to_ascii(ltx.substr(1, brace1 - 1));
-	int length = ltx.substr(0, brace2).length();
-	os << ltx.substr(0, brace2);
+	int pos = 0;
+	int length = brace2;
+	bool closing_brace = true;
+	if (script == "textgreek" && encoding.latexName() == "iso-8859-7") {
+		// Correct encoding is being used, so we can avoid \textgreek.
+		pos = brace1 + 1;
+		length -= pos;
+		closing_brace = false;
+	}
+	os << ltx.substr(pos, length);
 	int size = text_.size();
 	while (i + 1 < size) {
 		char_type const next = text_[i + 1];
@@ -600,8 +652,10 @@ int Paragraph::Private::writeScriptChars(odocstream & os,
 		length += len;
 		++i;
 	}
-	os << '}';
-	++length;
+	if (closing_brace) {
+		os << '}';
+		++length;
+	}
 	return length;
 }
 
@@ -626,7 +680,7 @@ bool Paragraph::Private::isTextAt(string const & str, pos_type pos) const
 }
 
 
-void Paragraph::Private::latexInset(Buffer const & buf,
+void Paragraph::Private::latexInset(
 					     BufferParams const & bparams,
 					     odocstream & os,
 					     TexRow & texrow,
@@ -641,10 +695,10 @@ void Paragraph::Private::latexInset(Buffer const & buf,
 					     unsigned int & column)
 {
 	Inset * inset = owner_->getInset(i);
-	BOOST_ASSERT(inset);
+	LASSERT(inset, /**/);
 
 	if (style.pass_thru) {
-		inset->plaintext(buf, os, runparams);
+		inset->plaintext(os, runparams);
 		return;
 	}
 
@@ -737,7 +791,16 @@ void Paragraph::Private::latexInset(Buffer const & buf,
 		}
 	}
 
-	int tmp = inset->latex(buf, os, runparams);
+	int tmp;
+
+	try {
+		tmp = inset->latex(os, runparams);
+	} catch (EncodingException & e) {
+		// add location information and throw again.
+		e.par_id = id_;
+		e.pos = i;
+		throw(e);
+	}
 
 	if (close) {
     	if (running_font.language()->lang() == "farsi")
@@ -781,6 +844,8 @@ void Paragraph::Private::latexSpecialChar(
 	}
 
 	if (runparams.verbatim) {
+		// FIXME UNICODE: This can fail if c cannot
+		// be encoded in the current encoding.
 		os.put(c);
 		return;
 	}
@@ -853,7 +918,6 @@ void Paragraph::Private::latexSpecialChar(
 		break;
 
 	default:
-
 		// LyX, LaTeX etc.
 		if (latexSpecialPhrase(os, i, column, runparams))
 			return;
@@ -902,11 +966,8 @@ bool Paragraph::Private::latexSpecialT1(char_type const c, odocstream & os,
 		// but we should avoid ligatures
 		if (i + 1 >= int(text_.size()) || text_[i + 1] != c)
 			return true;
-		os << "\\,{}";
-		column += 3;
-		// Alternative code:
-		//os << "\\textcompwordmark{}";
-		//column += 19;
+		os << "\\textcompwordmark{}";
+		column += 19;
 		return true;
 	case '|':
 		os.put(c);
@@ -922,37 +983,19 @@ bool Paragraph::Private::latexSpecialTypewriter(char_type const c, odocstream &
 {
 	switch (c) {
 	case '-':
+		// within \ttfamily, "--" is merged to "-" (no endash)
+		// so we avoid this rather irritating ligature
 		if (i + 1 < int(text_.size()) && text_[i + 1] == '-') {
-			// "--" in Typewriter mode -> "-{}-"
 			os << "-{}";
 			column += 2;
 		} else
 			os << '-';
 		return true;
 
-	// I assume this is hack treating typewriter as verbatim
-	// FIXME UNICODE: This can fail if c cannot be encoded
-	// in the current encoding.
-
-	case '\0':
-		return true;
-
-	// Those characters are not directly supported.
-	case '\\':
-	case '\"':
-	case '$': case '&':
-	case '%': case '#': case '{':
-	case '}': case '_':
-	case '~':
-	case '^':
-	case '*': case '[':
-	case ' ':
-		return false;
-
+	// everything else has to be checked separately
+	// (depending on the encoding)
 	default:
-		// With Typewriter font, these characters exist.
-		os.put(c);
-		return true;
+		return false;
 	}
 }
 
@@ -1028,8 +1071,12 @@ void Paragraph::Private::validate(LaTeXFeatures & features,
 //
 /////////////////////////////////////////////////////////////////////
 
-Paragraph::Paragraph()
-	: d(new Paragraph::Private(this))
+namespace {
+	Layout const emptyParagraphLayout;
+}
+
+Paragraph::Paragraph() 
+	: d(new Paragraph::Private(this, emptyParagraphLayout))
 {
 	itemdepth = 0;
 	d->params_.clear();
@@ -1040,6 +1087,15 @@ Paragraph::Paragraph(Paragraph const & par)
 	: itemdepth(par.itemdepth),
 	d(new Paragraph::Private(*par.d, this))
 {
+	registerWords();
+}
+
+
+Paragraph::Paragraph(Paragraph const & par, pos_type beg, pos_type end)
+	: itemdepth(par.itemdepth),
+	d(new Paragraph::Private(*par.d, this, beg, end))
+{
+	registerWords();
 }
 
 
@@ -1049,8 +1105,10 @@ Paragraph & Paragraph::operator=(Paragraph const & par)
 	if (&par != this) {
 		itemdepth = par.itemdepth;
 
+		deregisterWords();
 		delete d;
 		d = new Private(*par.d, this);
+		registerWords();
 	}
 	return *this;
 }
@@ -1058,23 +1116,23 @@ Paragraph & Paragraph::operator=(Paragraph const & par)
 
 Paragraph::~Paragraph()
 {
+	deregisterWords();
 	delete d;
 }
 
 
-void Paragraph::write(Buffer const & buf, ostream & os,
-			  BufferParams const & bparams,
-			  depth_type & dth) const
+void Paragraph::write(ostream & os, BufferParams const & bparams,
+	depth_type & dth) const
 {
 	// The beginning or end of a deeper (i.e. nested) area?
-	if (dth != params().depth()) {
-		if (params().depth() > dth) {
-			while (params().depth() > dth) {
+	if (dth != d->params_.depth()) {
+		if (d->params_.depth() > dth) {
+			while (d->params_.depth() > dth) {
 				os << "\n\\begin_deeper";
 				++dth;
 			}
 		} else {
-			while (params().depth() < dth) {
+			while (d->params_.depth() < dth) {
 				os << "\n\\end_deeper";
 				--dth;
 			}
@@ -1082,9 +1140,9 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 	}
 
 	// First write the layout
-	os << "\n\\begin_layout " << to_utf8(layout()->name()) << '\n';
+	os << "\n\\begin_layout " << to_utf8(d->layout_->name()) << '\n';
 
-	params().write(os);
+	d->params_.write(os);
 
 	Font font1(inherit_font, bparams.language);
 
@@ -1116,12 +1174,12 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 					// international char, let it write
 					// code directly so it's shorter in
 					// the file
-					inset->write(buf, os);
+					inset->write(os);
 				} else {
 					if (i)
 						os << '\n';
 					os << "\\begin_inset ";
-					inset->write(buf, os);
+					inset->write(os);
 					os << "\n\\end_inset\n\n";
 					column = 0;
 				}
@@ -1149,8 +1207,7 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 			if (c != '\0')
 				os << to_utf8(docstring(1, c));
 			else
-				lyxerr << "ERROR (Paragraph::writeFile):"
-					" NULL char in structure." << endl;
+				LYXERR0("NUL char in structure.");
 			++column;
 			break;
 		}
@@ -1162,7 +1219,7 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 
 void Paragraph::validate(LaTeXFeatures & features) const
 {
-	d->validate(features, *layout());
+	d->validate(features, *d->layout_);
 }
 
 
@@ -1199,7 +1256,7 @@ void Paragraph::appendString(docstring const & s, Font const & font,
 	d->text_.append(s);
 
 	// FIXME: Optimize this!
-	for (pos_type i = 0; i != end; ++i) {
+	for (pos_type i = oldsize; i != newsize; ++i) {
 		// track change
 		d->changes_.insert(change, i);
 	}
@@ -1260,8 +1317,8 @@ Font const Paragraph::getFontSettings(BufferParams const & bparams,
 					 pos_type pos) const
 {
 	if (pos > size()) {
-		lyxerr << " pos: " << pos << " size: " << size() << endl;
-		BOOST_ASSERT(pos <= size());
+		LYXERR0("pos: " << pos << " size: " << size());
+		LASSERT(pos <= size(), /**/);
 	}
 
 	FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
@@ -1277,7 +1334,7 @@ Font const Paragraph::getFontSettings(BufferParams const & bparams,
 
 FontSpan Paragraph::fontSpan(pos_type pos) const
 {
-	BOOST_ASSERT(pos <= size());
+	LASSERT(pos <= size(), /**/);
 	pos_type start = 0;
 
 	FontList::const_iterator cit = d->fontlist_.begin();
@@ -1296,8 +1353,7 @@ FontSpan Paragraph::fontSpan(pos_type pos) const
 	}
 
 	// This should not happen, but if so, we take no chances.
-	//lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!"
-	//      << endl;
+	// LYXERR0("Paragraph::getEndPosOfFontSpan: This should not happen!");
 	return FontSpan(pos, pos);
 }
 
@@ -1320,7 +1376,7 @@ Font const Paragraph::getFirstFontSettings(BufferParams const & bparams) const
 Font const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 				 Font const & outerfont) const
 {
-	BOOST_ASSERT(pos >= 0);
+	LASSERT(pos >= 0, /**/);
 
 	Font font = getFontSettings(bparams, pos);
 
@@ -1340,7 +1396,7 @@ Font const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 Font const Paragraph::getLabelFont
 	(BufferParams const & bparams, Font const & outerfont) const
 {
-	FontInfo tmpfont = layout()->labelfont;
+	FontInfo tmpfont = d->layout_->labelfont;
 	tmpfont.realize(outerfont.fontInfo());
 	tmpfont.realize(bparams.getFont().fontInfo());
 	return Font(tmpfont, getParLanguage(bparams));
@@ -1350,7 +1406,7 @@ Font const Paragraph::getLabelFont
 Font const Paragraph::getLayoutFont
 	(BufferParams const & bparams, Font const & outerfont) const
 {
-	FontInfo tmpfont = layout()->font;
+	FontInfo tmpfont = d->layout_->font;
 	tmpfont.realize(outerfont.fontInfo());
 	tmpfont.realize(bparams.getFont().fontInfo());
 	return Font(tmpfont, getParLanguage(bparams));
@@ -1365,8 +1421,7 @@ FontSize Paragraph::highestFontInRange
 }
 
 
-char_type
-Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
+char_type Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 {
 	char_type c = d->text_[pos];
 	if (!lyxrc.rtl_support)
@@ -1401,14 +1456,13 @@ Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 	}
 	if (uc != c && getFontSettings(bparams, pos).isRightToLeft())
 		return uc;
-	else
-		return c;
+	return c;
 }
 
 
 void Paragraph::setFont(pos_type pos, Font const & font)
 {
-	BOOST_ASSERT(pos <= size());
+	LASSERT(pos <= size(), /**/);
 
 	// First, reduce font against layout/label font
 	// Update: The setCharFont() routine in text2.cpp already
@@ -1420,9 +1474,8 @@ void Paragraph::setFont(pos_type pos, Font const & font)
 
 void Paragraph::makeSameLayout(Paragraph const & par)
 {
-	layout(par.layout());
-	// move to pimpl?
-	d->params_ = par.params();
+	d->layout_ = par.d->layout_;
+	d->params_ = par.d->params_;
 }
 
 
@@ -1447,45 +1500,46 @@ bool Paragraph::stripLeadingSpaces(bool trackChanges)
 
 bool Paragraph::hasSameLayout(Paragraph const & par) const
 {
-	return par.layout() == layout() && d->params_.sameLayout(par.params());
+	return par.d->layout_ == d->layout_
+		&& d->params_.sameLayout(par.d->params_);
 }
 
 
 depth_type Paragraph::getDepth() const
 {
-	return params().depth();
+	return d->params_.depth();
 }
 
 
 depth_type Paragraph::getMaxDepthAfter() const
 {
-	if (layout()->isEnvironment())
-		return params().depth() + 1;
+	if (d->layout_->isEnvironment())
+		return d->params_.depth() + 1;
 	else
-		return params().depth();
+		return d->params_.depth();
 }
 
 
 char Paragraph::getAlign() const
 {
-	if (params().align() == LYX_ALIGN_LAYOUT)
-		return layout()->align;
+	if (d->params_.align() == LYX_ALIGN_LAYOUT)
+		return d->layout_->align;
 	else
-		return params().align();
+		return d->params_.align();
 }
 
 
-docstring const & Paragraph::getLabelstring() const
+docstring const & Paragraph::labelString() const
 {
-	return params().labelString();
+	return d->params_.labelString();
 }
 
 
 // the next two functions are for the manual labels
 docstring const Paragraph::getLabelWidthString() const
 {
-	if (layout()->margintype == MARGIN_MANUAL)
-		return params().labelWidthString();
+	if (d->layout_->margintype == MARGIN_MANUAL)
+		return d->params_.labelWidthString();
 	else
 		return _("Senseless with this layout!");
 }
@@ -1493,7 +1547,7 @@ docstring const Paragraph::getLabelWidthString() const
 
 void Paragraph::setLabelWidthString(docstring const & s)
 {
-	params().labelWidthString(s);
+	d->params_.labelWidthString(s);
 }
 
 
@@ -1511,21 +1565,21 @@ docstring const Paragraph::translateIfPossible(docstring const & s,
 }
 
 
-docstring Paragraph::expandLabel(LayoutPtr const & layout,
+docstring Paragraph::expandLabel(Layout const & layout,
 		BufferParams const & bparams, bool process_appendix) const
 {
-	TextClass const & tclass = bparams.getTextClass();
+	DocumentClass const & tclass = bparams.documentClass();
 
 	docstring fmt;
-	if (process_appendix && params().appendix())
-		fmt = translateIfPossible(layout->labelstring_appendix(),
+	if (process_appendix && d->params_.appendix())
+		fmt = translateIfPossible(layout.labelstring_appendix(),
 			bparams);
 	else
-		fmt = translateIfPossible(layout->labelstring(), bparams);
+		fmt = translateIfPossible(layout.labelstring(), bparams);
 
-	if (fmt.empty() && layout->labeltype == LABEL_COUNTER 
-	    && !layout->counter.empty())
-		fmt = "\\the" + layout->counter;
+	if (fmt.empty() && layout.labeltype == LABEL_COUNTER 
+	    && !layout.counter.empty())
+		fmt = "\\the" + layout.counter;
 
 	// handle 'inherited level parts' in 'fmt',
 	// i.e. the stuff between '@' in   '@Section@.\arabic{subsection}'
@@ -1547,15 +1601,15 @@ docstring Paragraph::expandLabel(LayoutPtr const & layout,
 }
 
 
-void Paragraph::applyLayout(LayoutPtr const & new_layout)
+void Paragraph::applyLayout(Layout const & new_layout)
 {
-	layout(new_layout);
-	LyXAlignment const oldAlign = params().align();
+	d->layout_ = &new_layout;
+	LyXAlignment const oldAlign = d->params_.align();
 	
-	if (!(oldAlign & layout()->alignpossible)) {
+	if (!(oldAlign & d->layout_->alignpossible)) {
 		frontend::Alert::warning(_("Alignment not permitted"), 
 			_("The new layout does not permit the alignment previously used.\nSetting to default."));
-		params().align(LYX_ALIGN_LAYOUT);
+		d->params_.align(LYX_ALIGN_LAYOUT);
 	}
 }
 
@@ -1568,7 +1622,7 @@ pos_type Paragraph::beginOfBody() const
 
 void Paragraph::setBeginOfBody()
 {
-	if (layout()->labeltype != LABEL_MANUAL) {
+	if (d->layout_->labeltype != LABEL_MANUAL) {
 		d->begin_of_body_ = 0;
 		return;
 	}
@@ -1601,21 +1655,30 @@ void Paragraph::setBeginOfBody()
 }
 
 
-bool Paragraph::forceEmptyLayout() const
+bool Paragraph::forcePlainLayout() const
 {
-	return inInset() && inInset()->forceEmptyLayout();
+	Inset const * const inset = inInset();
+	if (!inset)
+		return true;
+	return inset->forcePlainLayout();
 }
 
 
 bool Paragraph::allowParagraphCustomization() const
 {
-	return inInset() && inInset()->allowParagraphCustomization(0);
+	Inset const * const inset = inInset();
+	if (!inset)
+		return true;
+	return inset->allowParagraphCustomization();
 }
 
 
-bool Paragraph::useEmptyLayout() const
+bool Paragraph::usePlainLayout() const
 {
-	return inInset() && inInset()->useEmptyLayout();
+	Inset const * const inset = inInset();
+	if (!inset)
+		return false;
+	return inset->usePlainLayout();
 }
 
 
@@ -1800,8 +1863,7 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
 
 
 // This one spits out the text of the paragraph
-bool Paragraph::latex(Buffer const & buf,
-				BufferParams const & bparams,
+bool Paragraph::latex(BufferParams const & bparams,
 				Font const & outerfont,
 				odocstream & os, TexRow & texrow,
 				OutputParams const & runparams) const
@@ -1810,20 +1872,11 @@ bool Paragraph::latex(Buffer const & buf,
 
 	bool return_value = false;
 
-	LayoutPtr style;
+	bool asdefault = forcePlainLayout();
 
-	// well we have to check if we are in an inset with unlimited
-	// length (all in one row) if that is true then we don't allow
-	// any special options in the paragraph and also we don't allow
-	// any environment other than the default layout of the text class
-	// to be valid!
-	bool asdefault = forceEmptyLayout();
-
-	if (asdefault) {
-		style = bparams.getTextClass().defaultLayout();
-	} else {
-		style = layout();
-	}
+	Layout const & style = asdefault ?
+		bparams.documentClass().plainLayout() :
+		*d->layout_;
 
 	// Current base font for all inherited font changes, without any
 	// change caused by an individual character, except for the language:
@@ -1858,7 +1911,7 @@ bool Paragraph::latex(Buffer const & buf,
 
 	// if the paragraph is empty, the loop will not be entered at all
 	if (empty()) {
-		if (style->isCommand()) {
+		if (style.isCommand()) {
 			os << '{';
 			++column;
 		}
@@ -1887,7 +1940,7 @@ bool Paragraph::latex(Buffer const & buf,
 				os << "}] ";
 				column +=3;
 			}
-			if (style->isCommand()) {
+			if (style.isCommand()) {
 				os << '{';
 				++column;
 			}
@@ -1951,8 +2004,8 @@ bool Paragraph::latex(Buffer const & buf,
 
 		// Switch file encoding if necessary (and allowed)
 		if (!runparams.verbatim && 
-		    runparams.encoding->package() == Encoding::none &&
-		    font.language()->encoding()->package() == Encoding::none) {
+		    runparams.encoding->package() != Encoding::none &&
+		    font.language()->encoding()->package() != Encoding::none) {
 			pair<bool, int> const enc_switch = switchEncoding(os, bparams,
 					runparams, *(font.language()->encoding()));
 			if (enc_switch.first) {
@@ -1987,13 +2040,13 @@ bool Paragraph::latex(Buffer const & buf,
 		if (c == ' ') {
 			// FIXME: integrate this case in latexSpecialChar
 			// Do not print the separation of the optional argument
-			// if style->pass_thru is false. This works because
+			// if style.pass_thru is false. This works because
 			// latexSpecialChar ignores spaces if
-			// style->pass_thru is false.
+			// style.pass_thru is false.
 			if (i != body_pos - 1) {
 				if (d->simpleTeXBlanks(
 						runparams, os, texrow,
-						i, column, font, *style)) {
+						i, column, font, style)) {
 					// A surrogate pair was output. We
 					// must not call latexSpecialChar
 					// in this iteration, since it would output
@@ -2005,22 +2058,22 @@ bool Paragraph::latex(Buffer const & buf,
 		}
 
 		OutputParams rp = runparams;
-		rp.free_spacing = style->free_spacing;
+		rp.free_spacing = style.free_spacing;
 		rp.local_font = &font;
-		rp.intitle = style->intitle;
+		rp.intitle = style.intitle;
 
 		// Two major modes:  LaTeX or plain
 		// Handle here those cases common to both modes
 		// and then split to handle the two modes separately.
 		if (c == META_INSET)
-			d->latexInset(buf, bparams, os,
+			d->latexInset(bparams, os,
 					texrow, rp, running_font,
 					basefont, outerfont, open_font,
-					runningChange, *style, i, column);
+					runningChange, style, i, column);
 		else {
 			try {
 				d->latexSpecialChar(os, rp, running_font, runningChange,
-					*style, i, column);
+					style, i, column);
 			} catch (EncodingException & e) {
 				if (runparams.dryrun) {
 					os << "<" << _("LyX Warning: ")
@@ -2036,7 +2089,7 @@ bool Paragraph::latex(Buffer const & buf,
 			}
 		}
 
-		// Set the encoding to that returned from simpleTeXSpecialChars (see
+		// Set the encoding to that returned from latexSpecialChar (see
 		// comment for encoding member in OutputParams.h)
 		runparams.encoding = rp.encoding;
 	}
@@ -2104,7 +2157,8 @@ bool Paragraph::emptyTag() const
 }
 
 
-string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) const
+string Paragraph::getID(Buffer const & buf, OutputParams const & runparams)
+	const
 {
 	for (pos_type i = 0; i < size(); ++i) {
 		if (Inset const * inset = getInset(i)) {
@@ -2120,12 +2174,13 @@ string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) cons
 }
 
 
-pos_type Paragraph::getFirstWord(Buffer const & buf, odocstream & os, OutputParams const & runparams) const
+pos_type Paragraph::firstWord(odocstream & os, OutputParams const & runparams)
+	const
 {
 	pos_type i;
 	for (i = 0; i < size(); ++i) {
 		if (Inset const * inset = getInset(i)) {
-			inset->docbook(buf, os, runparams);
+			inset->docbook(os, runparams);
 		} else {
 			char_type c = d->text_[i];
 			if (c == ' ')
@@ -2162,11 +2217,11 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf,
 {
 	bool emph_flag = false;
 
-	LayoutPtr const & style = layout();
+	Layout const & style = *d->layout_;
 	FontInfo font_old =
-		style->labeltype == LABEL_MANUAL ? style->labelfont : style->font;
+		style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
 
-	if (style->pass_thru && !d->onlyText(buf, outerfont, initial))
+	if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
 		os << "]]>";
 
 	// parsing main loop
@@ -2185,11 +2240,11 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf,
 		}
 
 		if (Inset const * inset = getInset(i)) {
-			inset->docbook(buf, os, runparams);
+			inset->docbook(os, runparams);
 		} else {
 			char_type c = d->text_[i];
 
-			if (style->pass_thru)
+			if (style.pass_thru)
 				os.put(c);
 			else
 				os << sgml::escapeChar(c);
@@ -2201,9 +2256,9 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf,
 		os << "</emphasis>";
 	}
 
-	if (style->free_spacing)
+	if (style.free_spacing)
 		os << '\n';
-	if (style->pass_thru && !d->onlyText(buf, outerfont, initial))
+	if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
 		os << "<![CDATA[";
 }
 
@@ -2211,7 +2266,8 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf,
 bool Paragraph::isHfill(pos_type pos) const
 {
 	Inset const * inset = getInset(pos);
-	return inset && inset->lyxCode() == HFILL_CODE;
+	return inset && (inset->lyxCode() == SPACE_CODE &&
+			 inset->isStretchableSpace());
 }
 
 
@@ -2242,6 +2298,24 @@ bool Paragraph::isLetter(pos_type pos) const
 }
 
 
+bool Paragraph::isChar(pos_type pos) const
+{
+	if (Inset const * inset = getInset(pos))
+		return inset->isChar();
+	char_type const c = d->text_[pos];
+	return !isLetterChar(c) && !isDigit(c) && !lyx::isSpace(c);
+}
+
+
+bool Paragraph::isSpace(pos_type pos) const
+{
+	if (Inset const * inset = getInset(pos))
+		return inset->isSpace();
+	char_type const c = d->text_[pos];
+	return lyx::isSpace(c);
+}
+
+
 Language const *
 Paragraph::getParLanguage(BufferParams const & bparams) const
 {
@@ -2290,29 +2364,27 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) const
 }
 
 
-// Convert the paragraph to a string.
-// Used for building the table of contents
-docstring const Paragraph::asString(Buffer const & buffer, bool label) const
+docstring Paragraph::asString(int options) const
 {
-	return asString(buffer, 0, size(), label);
+	return asString(0, size(), options);
 }
 
 
-docstring const Paragraph::asString(Buffer const & buffer,
-				 pos_type beg, pos_type end, bool label) const
+docstring Paragraph::asString(pos_type beg, pos_type end, int options) const
 {
-
 	odocstringstream os;
 
-	if (beg == 0 && label && !params().labelString().empty())
-		os << params().labelString() << ' ';
+	if (beg == 0 
+		&& options & AS_STR_LABEL
+		&& !d->params_.labelString().empty())
+		os << d->params_.labelString() << ' ';
 
 	for (pos_type i = beg; i < end; ++i) {
 		char_type const c = d->text_[i];
 		if (isPrintable(c))
 			os.put(c);
-		else if (c == META_INSET)
-			getInset(i)->textString(buffer, os);
+		else if (c == META_INSET && options & AS_STR_INSETS)
+			getInset(i)->textString(os);
 	}
 
 	return os.str();
@@ -2331,15 +2403,24 @@ int Paragraph::id() const
 }
 
 
-LayoutPtr const & Paragraph::layout() const
+Layout const & Paragraph::layout() const
 {
-	return d->layout_;
+	return *d->layout_;
 }
 
 
-void Paragraph::layout(LayoutPtr const & new_layout)
+void Paragraph::setLayout(Layout const & layout)
 {
-	d->layout_ = new_layout;
+	d->layout_ = &layout;
+}
+
+
+void Paragraph::setPlainOrDefaultLayout(DocumentClass const & tclass)
+{
+	if (usePlainLayout())
+		setLayout(tclass.plainLayout());
+	else
+		setLayout(tclass.defaultLayout());
 }
 
 
@@ -2369,7 +2450,7 @@ ParagraphParameters const & Paragraph::params() const
 
 bool Paragraph::isFreeSpacing() const
 {
-	if (layout()->free_spacing)
+	if (d->layout_->free_spacing)
 		return true;
 	return d->inset_owner_ && d->inset_owner_->isFreeSpacing();
 }
@@ -2377,7 +2458,7 @@ bool Paragraph::isFreeSpacing() const
 
 bool Paragraph::allowEmpty() const
 {
-	if (layout()->keepempty)
+	if (d->layout_->keepempty)
 		return true;
 	return d->inset_owner_ && d->inset_owner_->allowEmpty();
 }
@@ -2385,7 +2466,7 @@ bool Paragraph::allowEmpty() const
 
 char_type Paragraph::transformChar(char_type c, pos_type pos) const
 {
-	if (!Encodings::is_arabic(c))
+	if (!Encodings::isArabicChar(c))
 		return c;
 
 	char_type prev_char = ' ';
@@ -2393,7 +2474,7 @@ char_type Paragraph::transformChar(char_type c, pos_type pos) const
 
 	for (pos_type i = pos - 1; i >= 0; --i) {
 		char_type const par_char = d->text_[i];
-		if (!Encodings::isComposeChar_arabic(par_char)) {
+		if (!Encodings::isArabicComposeChar(par_char)) {
 			prev_char = par_char;
 			break;
 		}
@@ -2401,21 +2482,21 @@ char_type Paragraph::transformChar(char_type c, pos_type pos) const
 
 	for (pos_type i = pos + 1, end = size(); i < end; ++i) {
 		char_type const par_char = d->text_[i];
-		if (!Encodings::isComposeChar_arabic(par_char)) {
+		if (!Encodings::isArabicComposeChar(par_char)) {
 			next_char = par_char;
 			break;
 		}
 	}
 
-	if (Encodings::is_arabic(next_char)) {
-		if (Encodings::is_arabic(prev_char) &&
-			!Encodings::is_arabic_special(prev_char))
+	if (Encodings::isArabicChar(next_char)) {
+		if (Encodings::isArabicChar(prev_char) &&
+			!Encodings::isArabicSpecialChar(prev_char))
 			return Encodings::transformChar(c, Encodings::FORM_MEDIAL);
 		else
 			return Encodings::transformChar(c, Encodings::FORM_INITIAL);
 	} else {
-		if (Encodings::is_arabic(prev_char) &&
-			!Encodings::is_arabic_special(prev_char))
+		if (Encodings::isArabicChar(prev_char) &&
+			!Encodings::isArabicSpecialChar(prev_char))
 			return Encodings::transformChar(c, Encodings::FORM_FINAL);
 		else
 			return Encodings::transformChar(c, Encodings::FORM_ISOLATED);
@@ -2423,14 +2504,14 @@ char_type Paragraph::transformChar(char_type c, pos_type pos) const
 }
 
 
-int Paragraph::checkBiblio(bool track_changes)
+int Paragraph::checkBiblio(Buffer const & buffer)
 {
-	//FIXME From JS:
-	//This is getting more and more a mess. ...We really should clean
-	//up this bibitem issue for 1.6. See also bug 2743.
+	// FIXME From JS:
+	// This is getting more and more a mess. ...We really should clean
+	// up this bibitem issue for 1.6. See also bug 2743.
 
 	// Add bibitem insets if necessary
-	if (layout()->labeltype != LABEL_BIBLIO)
+	if (d->layout_->labeltype != LABEL_BIBLIO)
 		return 0;
 
 	bool hasbibitem = !d->insetlist_.empty()
@@ -2438,6 +2519,8 @@ int Paragraph::checkBiblio(bool track_changes)
 		&& d->text_[0] == META_INSET
 		&& d->insetlist_.begin()->inset->lyxCode() == BIBITEM_CODE;
 
+	bool track_changes = buffer.params().trackChanges;
+
 	docstring oldkey;
 	docstring oldlabel;
 
@@ -2460,13 +2543,13 @@ int Paragraph::checkBiblio(bool track_changes)
 			break;
 	}
 
-	//There was an InsetBibitem at the beginning, and we didn't
-	//have to erase one.
+	// There was an InsetBibitem at the beginning, and we didn't
+	// have to erase one.
 	if (hasbibitem && erasedInsetPosition < 0)
 			return 0;
 
-	//There was an InsetBibitem at the beginning and we did have to
-	//erase one. So we give its properties to the beginning inset.
+	// There was an InsetBibitem at the beginning and we did have to
+	// erase one. So we give its properties to the beginning inset.
 	if (hasbibitem) {
 		InsetBibitem * inset =
 			static_cast<InsetBibitem *>(d->insetlist_.begin()->inset);
@@ -2476,9 +2559,10 @@ int Paragraph::checkBiblio(bool track_changes)
 		return -erasedInsetPosition;
 	}
 
-	//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(InsetCommandParams(BIBITEM_CODE)));
+	// 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));
 	// restore values of previously deleted item in this par.
 	if (!oldkey.empty())
 		inset->setParam("key", oldkey);
@@ -2520,6 +2604,12 @@ InsetList const & Paragraph::insetList() const
 }
 
 
+void Paragraph::setBuffer(Buffer & b)
+{
+	d->insetlist_.setBuffer(b);
+}
+
+
 Inset * Paragraph::releaseInset(pos_type pos)
 {
 	Inset * inset = d->insetlist_.release(pos);
@@ -2672,4 +2762,66 @@ 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);
+	d->words_.clear();
+}
+
+
+void Paragraph::collectWords(CursorSlice const & sl)
+{
+	// find new words
+	bool inword = false;
+
+	//lyxerr << "Words: ";
+	pos_type n = size();
+	for (pos_type pos = 0; pos != n; ++pos) {
+		if (isDeleted(pos))
+			continue;
+
+		if (!isLetter(pos)) {
+			inword = false;
+			continue;
+		}
+
+		if (inword)
+			continue;
+
+		inword = true;
+		CursorSlice from = sl;
+		CursorSlice to = sl;
+		from.pos() = pos;
+		to.pos() = pos;
+		from.text()->getWord(from, to, WHOLE_WORD);
+		if (to.pos() - from.pos() < 6)
+			continue;
+		docstring word = asString(from.pos(), to.pos(), false);
+		d->words_.insert(word);
+		//lyxerr << word << " ";
+	}
+	//lyxerr << std::endl;
+}
+
+
+void Paragraph::registerWords()
+{
+	Private::Words::const_iterator it;
+	WordList & wl = theWordList();
+	for (it = d->words_.begin(); it != d->words_.end(); ++it)
+		wl.insert(*it);
+}
+
+
+void Paragraph::updateWords(CursorSlice const & sl)
+{
+	LASSERT(&sl.paragraph() == this, /**/);
+	deregisterWords();
+	collectWords(sl);
+	registerWords();
+}
+
 } // namespace lyx