X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=730b7d0159785ab38a5dd73d88407faae3e7740b;hb=cd03e2b7db8379a91f3d31eac2c5bc25b159c541;hp=01f2f542fd85e966e03d423d9f9e22577683fb4a;hpb=fd1a4f75e897c8d0894d7c3247fafa964eb44b6d;p=lyx.git

diff --git a/src/paragraph.C b/src/paragraph.C
index 01f2f542fd..730b7d0159 100644
--- a/src/paragraph.C
+++ b/src/paragraph.C
@@ -1,161 +1,113 @@
-/* This file is part of
- * ======================================================
+/**
+ * \file paragraph.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- *           LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
  *
- *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
 
 #include <config.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include "paragraph.h"
 #include "paragraph_pimpl.h"
-#include "lyxrc.h"
-#include "layout.h"
-#include "language.h"
-#include "tex-strings.h"
+
 #include "buffer.h"
 #include "bufferparams.h"
-#include "debug.h"
-#include "texrow.h"
-#include "BufferView.h"
 #include "encoding.h"
-#include "ParameterStruct.h"
+#include "debug.h"
 #include "gettext.h"
+#include "language.h"
+#include "latexrunparams.h"
+#include "lyxrc.h"
+#include "lyxrow.h"
+#include "texrow.h"
+#include "vspace.h"
 
-#include "insets/insetinclude.h"
-#include "insets/insetbib.h"
-#include "insets/insettext.h"
+#include "insets/insetbibitem.h"
+#include "insets/insetoptarg.h"
 
-#include "support/filetools.h"
 #include "support/lstrings.h"
-#include "support/lyxmanip.h"
-#include "support/FileInfo.h"
-#include "support/LAssert.h"
 #include "support/textutils.h"
-
-#include <algorithm>
-#include <fstream>
-#include <csignal>
-
-using std::ostream;
-using std::endl;
-using std::fstream;
-using std::ios;
-using std::lower_bound;
-using std::upper_bound;
-using std::reverse;
+#include "support/std_sstream.h"
 
 using lyx::pos_type;
 
-// this is a bad idea, but how can Paragraph find its buffer to get
-// parameters? (JMarc)
-
-extern string bibitemWidest(Buffer const *);
-
-// this is a minibuffer
-
-namespace {
-
-char minibuffer_char;
-LyXFont minibuffer_font;
-Inset * minibuffer_inset;
-
-} // namespace anon
+using lyx::support::contains;
+using lyx::support::subst;
 
+using std::endl;
 
-extern BufferView * current_view;
+using std::ostream;
+using std::ostringstream;
 
 
 Paragraph::Paragraph()
-	: pimpl_(new Paragraph::Pimpl(this))
+	: y(0), pimpl_(new Paragraph::Pimpl(this))
 {
-#ifndef NO_NEXT
-	next_ = 0;
-	previous_ = 0;
-#endif
 	enumdepth = 0;
 	itemdepth = 0;
-	bibkey = 0; // ale970302
 	params().clear();
 }
 
 
-#ifndef NO_NEXT
-// This constructor inserts the new paragraph in a list.
-Paragraph::Paragraph(Paragraph * par)
-	: pimpl_(new Paragraph::Pimpl(this))
+Paragraph::Paragraph(Paragraph const & lp)
+	: y(0), pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
 {
 	enumdepth = 0;
 	itemdepth = 0;
+	// this is because of the dummy layout of the paragraphs that
+	// follow footnotes
+	layout_ = lp.layout();
 
-	// double linked list begin
-	next_ = par->next_;
-	if (next_)
-		next_->previous_ = this;
-	previous_ = par;
-	previous_->next_ = this;
-	// end
-
-	bibkey = 0; // ale970302
-	params().clear();
+	// copy everything behind the break-position to the new paragraph
+	insetlist = lp.insetlist;
+	InsetList::iterator it = insetlist.begin();
+	InsetList::iterator end = insetlist.end();
+	for (; it != end; ++it) {
+		// currently we hold Inset*, not InsetBase*
+		it->inset = static_cast<InsetOld*>(it->inset->clone().release());
+	}
 }
-#endif
 
 
-Paragraph::Paragraph(Paragraph const & lp, bool same_ids)
-	: pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids))
+void Paragraph::operator=(Paragraph const & lp)
 {
-	enumdepth = 0;
-	itemdepth = 0;
-#ifndef NO_NEXT
-	next_     = 0;
-	previous_ = 0;
-#endif
+	// needed as we will destroy the pimpl_ before copying it
+	if (&lp != this)
+		return;
+
+	lyxerr << "Paragraph::operator=()" << endl;
+
+	delete pimpl_;
+	pimpl_ = new Pimpl(*lp.pimpl_, this);
+
+	enumdepth = lp.enumdepth;
+	itemdepth = lp.itemdepth;
 	// this is because of the dummy layout of the paragraphs that
 	// follow footnotes
 	layout_ = lp.layout();
 
-	// ale970302
-	if (lp.bibkey) {
-		bibkey = static_cast<InsetBibKey *>
-			(lp.bibkey->clone(*current_view->buffer()));
-	} else {
-		bibkey = 0;
-	}
-
 	// copy everything behind the break-position to the new paragraph
 	insetlist = lp.insetlist;
 	InsetList::iterator it = insetlist.begin();
 	InsetList::iterator end = insetlist.end();
 	for (; it != end; ++it) {
-		it.setInset(it.getInset()->clone(*current_view->buffer(),
-						 same_ids));
-		// tell the new inset who is the boss now
-		it.getInset()->parOwner(this);
+		it->inset = static_cast<InsetOld*>(it->inset->clone().release());
 	}
 }
 
-
 // the destructor removes the new paragraph from the list
 Paragraph::~Paragraph()
 {
-#ifndef NO_NEXT
-	if (previous_)
-		previous_->next_ = next_;
-	if (next_)
-		next_->previous_ = previous_;
-#endif
-
-	// ale970302
-	delete bibkey;
-
 	delete pimpl_;
 	//
 	//lyxerr << "Paragraph::paragraph_id = "
@@ -163,9 +115,9 @@ Paragraph::~Paragraph()
 }
 
 
-void Paragraph::write(Buffer const * buf, ostream & os,
+void Paragraph::write(Buffer const & buf, ostream & os,
 			  BufferParams const & bparams,
-			  depth_type dth) const
+			  depth_type & dth) const
 {
 	// The beginning or end of a deeper (i.e. nested) area?
 	if (dth != params().depth()) {
@@ -183,81 +135,30 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 	}
 
 	// First write the layout
-	os << "\n\\layout " << layout()->name() << "\n";
-
-	// Maybe some vertical spaces.
-	if (params().spaceTop().kind() != VSpace::NONE)
-		os << "\\added_space_top "
-		   << params().spaceTop().asLyXCommand() << " ";
-	if (params().spaceBottom().kind() != VSpace::NONE)
-		os << "\\added_space_bottom "
-		   << params().spaceBottom().asLyXCommand() << " ";
-
-	// Maybe the paragraph has special spacing
-	params().spacing().writeFile(os, true);
-
-	// The labelwidth string used in lists.
-	if (!params().labelWidthString().empty())
-		os << "\\labelwidthstring "
-		   << params().labelWidthString() << '\n';
-
-	// Lines above or below?
-	if (params().lineTop())
-		os << "\\line_top ";
-	if (params().lineBottom())
-		os << "\\line_bottom ";
-
-	// Pagebreaks above or below?
-	if (params().pagebreakTop())
-		os << "\\pagebreak_top ";
-	if (params().pagebreakBottom())
-		os << "\\pagebreak_bottom ";
-
-	// Start of appendix?
-	if (params().startOfAppendix())
-		os << "\\start_of_appendix ";
-
-	// Noindent?
-	if (params().noindent())
-		os << "\\noindent ";
-
-	// Do we have a manual left indent?
-	if (!params().leftIndent().zero())
-		os << "\\leftindent " << params().leftIndent().asString() << " ";
-
-	// Alignment?
-	if (params().align() != LYX_ALIGN_LAYOUT) {
-		int h = 0;
-		switch (params().align()) {
-		case LYX_ALIGN_LEFT: h = 1; break;
-		case LYX_ALIGN_RIGHT: h = 2; break;
-		case LYX_ALIGN_CENTER: h = 3; break;
-		default: h = 0; break;
-		}
-		os << "\\align " << string_align[h] << " ";
-	}
+	os << "\n\\begin_layout " << layout()->name() << '\n';
 
-	// bibitem  ale970302
-	if (bibkey)
-		bibkey->write(buf, os);
+	params().write(os);
 
 	LyXFont font1(LyXFont::ALL_INHERIT, bparams.language);
 
+	Change running_change = Change(Change::UNCHANGED);
+	lyx::time_type const curtime(lyx::current_time());
+
 	int column = 0;
 	for (pos_type i = 0; i < size(); ++i) {
 		if (!i) {
-			os << "\n";
+			os << '\n';
 			column = 0;
 		}
 
+		Change change = pimpl_->lookupChangeFull(i);
+		Changes::lyxMarkChange(os, column, curtime, running_change, change);
+		running_change = change;
+
 		// Write font changes
 		LyXFont font2 = getFontSettings(bparams, i);
 		if (font2 != font1) {
-#ifndef INHERIT_LANGUAGE
 			font2.lyxWriteChanges(font1, os);
-#else
-			font2.lyxWriteChanges(font1, bparams.language, os);
-#endif
 			column = 0;
 			font1 = font2;
 		}
@@ -266,7 +167,7 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 		switch (c) {
 		case META_INSET:
 		{
-			Inset const * inset = getInset(i);
+			InsetOld const * inset = getInset(i);
 			if (inset)
 				if (inset->directWrite()) {
 					// international char, let it write
@@ -281,14 +182,6 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 				}
 		}
 		break;
-		case META_NEWLINE:
-			os << "\n\\newline \n";
-			column = 0;
-			break;
-		case META_HFILL:
-			os << "\n\\hfill \n";
-			column = 0;
-			break;
 		case '\\':
 			os << "\n\\backslash \n";
 			column = 0;
@@ -298,12 +191,12 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 				os << ".\n";
 				column = 0;
 			} else
-				os << ".";
+				os << '.';
 			break;
 		default:
 			if ((column > 70 && c == ' ')
 			    || column > 79) {
-				os << "\n";
+				os << '\n';
 				column = 0;
 			}
 			// this check is to amend a bug. LyX sometimes
@@ -317,80 +210,41 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 			break;
 		}
 	}
-}
 
+	// to make reading work properly
+	if (!size()) {
+		running_change = pimpl_->lookupChange(0);
+		Changes::lyxMarkChange(os, column, curtime,
+			Change(Change::UNCHANGED), running_change);
+	}
+	Changes::lyxMarkChange(os, column, curtime,
+		running_change, Change(Change::UNCHANGED));
 
-void Paragraph::validate(LaTeXFeatures & features) const
-{
-	pimpl_->validate(features, *layout());
+	os << "\n\\end_layout\n";
 }
 
 
-// First few functions needed for cut and paste and paragraph breaking.
-void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const
+void Paragraph::validate(LaTeXFeatures & features) const
 {
-	BufferParams bparams = buffer.params;
-
-	minibuffer_char = getChar(pos);
-	minibuffer_font = getFontSettings(bparams, pos);
-	minibuffer_inset = 0;
-	if (minibuffer_char == Paragraph::META_INSET) {
-		if (getInset(pos)) {
-			minibuffer_inset = getInset(pos)->clone(buffer);
-		} else {
-			minibuffer_inset = 0;
-			minibuffer_char = ' ';
-			// This reflects what GetInset() does (ARRae)
-		}
-	}
+	pimpl_->validate(features, *layout());
 }
 
 
-void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos)
+void Paragraph::eraseIntern(lyx::pos_type pos)
 {
-	minibuffer_char = getChar(pos);
-	minibuffer_font = getFontSettings(bparams, pos);
-	minibuffer_inset = 0;
-	if (minibuffer_char == Paragraph::META_INSET) {
-		if (getInset(pos)) {
-			// the inset is not in a paragraph anymore
-			minibuffer_inset = insetlist.release(pos);
-			minibuffer_inset->parOwner(0);
-		} else {
-			minibuffer_inset = 0;
-			minibuffer_char = ' ';
-			// This reflects what GetInset() does (ARRae)
-		}
-
-	}
-
-	// Erase(pos); now the caller is responsible for that.
+	pimpl_->eraseIntern(pos);
 }
 
 
-bool Paragraph::insertFromMinibuffer(pos_type pos)
+bool Paragraph::erase(pos_type pos)
 {
-	if (minibuffer_char == Paragraph::META_INSET) {
-		if (!insetAllowed(minibuffer_inset->lyxCode())) {
-			return false;
-		}
-		insertInset(pos, minibuffer_inset, minibuffer_font);
-	} else {
-		LyXFont f = minibuffer_font;
-		if (!checkInsertChar(f)) {
-			return false;
-		}
-		insertChar(pos, minibuffer_char, f);
-	}
-	return true;
+	return pimpl_->erase(pos);
 }
 
-// end of minibuffer
 
-
-void Paragraph::erase(pos_type pos)
+int Paragraph::erase(pos_type start, pos_type end)
 {
-	pimpl_->erase(pos);
+	return pimpl_->erase(start, end);
 }
 
 
@@ -404,53 +258,49 @@ bool Paragraph::checkInsertChar(LyXFont & font)
 
 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
 {
-	LyXFont const f(LyXFont::ALL_INHERIT);
-	insertChar(pos, c, f);
+	insertChar(pos, c, LyXFont(LyXFont::ALL_INHERIT));
 }
 
 
 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
-			   LyXFont const & font)
+			   LyXFont const & font, Change change)
 {
-	pimpl_->insertChar(pos, c, font);
+	pimpl_->insertChar(pos, c, font, change);
 }
 
 
-void Paragraph::insertInset(pos_type pos, Inset * inset)
+void Paragraph::insertInset(pos_type pos, InsetOld * inset)
 {
-	LyXFont const f(LyXFont::ALL_INHERIT);
-	insertInset(pos, inset, f);
+	insertInset(pos, inset, LyXFont(LyXFont::ALL_INHERIT));
 }
 
 
-void Paragraph::insertInset(pos_type pos, Inset * inset, LyXFont const & font)
+void Paragraph::insertInset(pos_type pos, InsetOld * inset,
+	LyXFont const & font, Change change)
 {
-	pimpl_->insertInset(pos, inset, font);
+	pimpl_->insertInset(pos, inset, font, change);
 }
 
 
-bool Paragraph::insetAllowed(Inset::Code code)
+bool Paragraph::insetAllowed(InsetOld::Code code)
 {
 	//lyxerr << "Paragraph::InsertInsetAllowed" << endl;
-
 	if (pimpl_->inset_owner)
 		return pimpl_->inset_owner->insetAllowed(code);
 	return true;
 }
 
 
-Inset * Paragraph::getInset(pos_type pos)
+InsetOld * Paragraph::getInset(pos_type pos)
 {
-	lyx::Assert(pos < size());
-
+	BOOST_ASSERT(pos < size());
 	return insetlist.get(pos);
 }
 
 
-Inset const * Paragraph::getInset(pos_type pos) const
+InsetOld const * Paragraph::getInset(pos_type pos) const
 {
-	lyx::Assert(pos < size());
-
+	BOOST_ASSERT(pos < size());
 	return insetlist.get(pos);
 }
 
@@ -459,28 +309,38 @@ Inset const * Paragraph::getInset(pos_type pos) const
 LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 					 pos_type pos) const
 {
-	lyx::Assert(pos <= size());
+	BOOST_ASSERT(pos <= size());
 
 	Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 	Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
-	for (; cit != end; ++cit) {
+	for (; cit != end; ++cit)
 		if (cit->pos() >= pos)
 			break;
-	}
 
-	LyXFont retfont;
-	if (cit != end) {
-		retfont = cit->font();
-	} else if (pos == size() && !empty()) {
-		retfont = getFontSettings(bparams, pos - 1);
-	} else
-		retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
-#ifdef INHERIT_LANGUAGE
-	if (retfont.language() == inherit_language)
-		retfont.setLanguage(bparams.language);
-#endif
+	if (cit != end)
+		return cit->font();
+
+	if (pos == size() && !empty())
+		return getFontSettings(bparams, pos - 1);
+
+	return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
+}
+
+
+lyx::pos_type Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
+{
+	BOOST_ASSERT(pos <= size());
+
+	Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
+	Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
+	for (; cit != end; ++cit)
+		if (cit->pos() >= pos)
+			return cit->pos();
 
-	return retfont;
+	// This should not happen, but if so, we take no chances.
+	//lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!"
+	//      << endl;
+	return pos;
 }
 
 
@@ -499,55 +359,49 @@ LyXFont const Paragraph::getFirstFontSettings() const
 // The difference is that this one is used for generating the LaTeX file,
 // and thus cosmetic "improvements" are disallowed: This has to deliver
 // the true picture of the buffer. (Asger)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const Paragraph::getFont(BufferParams const & bparams,
-				 pos_type pos) const
+LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
+				 LyXFont const & outerfont) const
 {
-	lyx::Assert(pos >= 0);
+	BOOST_ASSERT(pos >= 0);
 
 	LyXLayout_ptr const & lout = layout();
 
-	pos_type main_body = 0;
-	if (lout->labeltype == LABEL_MANUAL)
-		main_body = beginningOfMainBody();
+	pos_type const body_pos = beginningOfBody();
 
 	LyXFont layoutfont;
-	if (pos < main_body)
+	if (pos < body_pos)
 		layoutfont = lout->labelfont;
 	else
 		layoutfont = lout->font;
 
 	LyXFont tmpfont = getFontSettings(bparams, pos);
-#ifndef INHERIT_LANGUAGE
 	tmpfont.realize(layoutfont);
-#else
-	tmpfont.realize(layoutfont, bparams.language);
-#endif
+	tmpfont.realize(outerfont);
+	tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 
-	return pimpl_->realizeFont(tmpfont, bparams);
+	return tmpfont;
 }
 
 
-LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const
+LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
+				      LyXFont const & outerfont) const
 {
-	LyXLayout_ptr const & lout = layout();
-
-	LyXFont tmpfont = lout->labelfont;
+	LyXFont tmpfont = layout()->labelfont;
 	tmpfont.setLanguage(getParLanguage(bparams));
-
-	return pimpl_->realizeFont(tmpfont, bparams);
+	tmpfont.realize(outerfont);
+	tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+	return tmpfont;
 }
 
 
-LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const
+LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
+				       LyXFont const & outerfont) const
 {
-	LyXLayout_ptr const & lout = layout();
-
-	LyXFont tmpfont = lout->font;
+	LyXFont tmpfont = layout()->font;
 	tmpfont.setLanguage(getParLanguage(bparams));
-
-	return pimpl_->realizeFont(tmpfont, bparams);
+	tmpfont.realize(outerfont);
+	tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+	return tmpfont;
 }
 
 
@@ -630,7 +484,7 @@ Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 
 void Paragraph::setFont(pos_type pos, LyXFont const & font)
 {
-	lyx::Assert(pos <= size());
+	BOOST_ASSERT(pos <= size());
 
 	// First, reduce font against layout/label font
 	// Update: The SetCharFont() routine in text2.C already
@@ -691,65 +545,22 @@ void Paragraph::setFont(pos_type pos, LyXFont const & font)
 }
 
 
-#ifndef NO_NEXT
-void Paragraph::next(Paragraph * p)
-{
-	next_ = p;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph * Paragraph::next()
-{
-	return next_;
-}
-
-
-Paragraph const * Paragraph::next() const
-{
-	return next_;
-}
-
-
-void Paragraph::previous(Paragraph * p)
-{
-	previous_ = p;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph * Paragraph::previous()
-{
-	return previous_;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph const * Paragraph::previous() const
+void Paragraph::makeSameLayout(Paragraph const & par)
 {
-	return previous_;
-}
-#endif
-
-
-void Paragraph::makeSameLayout(Paragraph const * par)
-{
-	layout(par->layout());
+	layout(par.layout());
 	// move to pimpl?
-	params() = par->params();
+	params() = par.params();
 }
 
 
 int Paragraph::stripLeadingSpaces()
 {
-	if (layout()->free_spacing ||
-	    isFreeSpacing()) {
+	if (isFreeSpacing())
 		return 0;
-	}
 
 	int i = 0;
 	while (!empty() && (isNewline(0) || isLineSeparator(0))) {
-		erase(0);
+		pimpl_->eraseIntern(0);
 		++i;
 	}
 
@@ -757,40 +568,11 @@ int Paragraph::stripLeadingSpaces()
 }
 
 
-bool Paragraph::hasSameLayout(Paragraph const * par) const
+bool Paragraph::hasSameLayout(Paragraph const & par) const
 {
 	return
-		par->layout() == layout() &&
-		params().sameLayout(par->params());
-}
-
-
-int Paragraph::getEndLabel() const
-{
-	Paragraph const * par = this;
-	depth_type par_depth = getDepth();
-	while (par) {
-		LyXLayout_ptr const & layout = par->layout();
-		int const endlabeltype = layout->endlabeltype;
-
-		if (endlabeltype != END_LABEL_NO_LABEL) {
-			if (!next_)
-				return endlabeltype;
-
-			depth_type const next_depth = next_->getDepth();
-			if (par_depth > next_depth ||
-			    (par_depth == next_depth
-			     && layout != next_->layout()))
-				return endlabeltype;
-			break;
-		}
-		if (par_depth == 0)
-			break;
-		par = par->outerHook();
-		if (par)
-			par_depth = par->getDepth();
-	}
-	return END_LABEL_NO_LABEL;
+		par.layout() == layout() &&
+		params().sameLayout(par.params());
 }
 
 
@@ -802,15 +584,13 @@ Paragraph::depth_type Paragraph::getDepth() const
 
 Paragraph::depth_type Paragraph::getMaxDepthAfter() const
 {
-	bool const isenv = layout()->isEnvironment();
-
-	if (isenv)
+	if (layout()->isEnvironment())
 		return params().depth() + 1;
 	else
 		return params().depth();
-
 }
 
+
 char Paragraph::getAlign() const
 {
 	return params().align();
@@ -850,32 +630,31 @@ void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
 }
 
 
-// if the layout of a paragraph contains a manual label, the beginning of the
-// main body is the beginning of the second word. This is what the par-
-// function returns. If the layout does not contain a label, the main
-// body always starts with position 0. This differentiation is necessary,
-// because there cannot be a newline or a blank <= the beginning of the
-// main body in TeX.
-
-int Paragraph::beginningOfMainBody() const
+int Paragraph::beginningOfBody() const
 {
+	if (layout()->labeltype != LABEL_MANUAL)
+		return 0;
+
 	// Unroll the first two cycles of the loop
 	// and remember the previous character to
 	// remove unnecessary GetChar() calls
 	pos_type i = 0;
-	if (i < size() && getChar(i) != Paragraph::META_NEWLINE) {
+	if (i < size() && !isNewline(i)) {
 		++i;
 		char previous_char = 0;
 		char temp = 0;
-		if (i < size()
-		    && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) {
-			// Yes, this  ^ is supposed to be "= " not "=="
-			++i;
-			while (i < size()
-			       && previous_char != ' '
-			       && (temp = getChar(i)) != Paragraph::META_NEWLINE) {
+		if (i < size()) {
+			previous_char = getChar(i);
+			if (!isNewline(i)) {
 				++i;
-				previous_char = temp;
+				while (i < size() && previous_char != ' ') {
+					temp = getChar(i);
+					if (isNewline(i))
+						break;
+
+					++i;
+					previous_char = temp;
+				}
 			}
 		}
 	}
@@ -884,299 +663,29 @@ int Paragraph::beginningOfMainBody() const
 }
 
 
-Paragraph * Paragraph::depthHook(depth_type depth)
-{
-	Paragraph * newpar = this;
-
-	do {
-		newpar = newpar->previous();
-	} while (newpar && newpar->getDepth() > depth);
-
-	if (!newpar) {
-		if (previous() || getDepth())
-			lyxerr << "ERROR (Paragraph::DepthHook): "
-				"no hook." << endl;
-		newpar = this;
-	}
-
-	return newpar;
-}
-
-
-Paragraph const * Paragraph::depthHook(depth_type depth) const
-{
-	Paragraph const * newpar = this;
-
-	do {
-		newpar = newpar->previous();
-	} while (newpar && newpar->getDepth() > depth);
-
-	if (!newpar) {
-		if (previous() || getDepth())
-			lyxerr << "ERROR (Paragraph::DepthHook): "
-				"no hook." << endl;
-		newpar = this;
-	}
-
-	return newpar;
-}
-
-
-Paragraph * Paragraph::outerHook()
-{
-	if (!getDepth())
-		return 0;
-	return depthHook(depth_type(getDepth() - 1));
-}
-
-
-Paragraph const * Paragraph::outerHook() const
-{
-	if (!getDepth())
-		return 0;
-	return depthHook(depth_type(getDepth() - 1));
-}
-
-
 // returns -1 if inset not found
-int Paragraph::getPositionOfInset(Inset const * inset) const
+int Paragraph::getPositionOfInset(InsetOld const * inset) const
 {
 	// Find the entry.
-	InsetList::iterator it = insetlist.begin();
-	InsetList::iterator end = insetlist.end();
-	for (; it != end; ++it) {
-		if (it.getInset() == inset) {
-			return it.getPos();
-		}
-	}
-	if (inset == bibkey)
-		return 0;
-
+	InsetList::const_iterator it = insetlist.begin();
+	InsetList::const_iterator end = insetlist.end();
+	for (; it != end; ++it)
+		if (it->inset == inset)
+			return it->pos;
 	return -1;
 }
 
 
-Paragraph * Paragraph::TeXOnePar(Buffer const * buf,
-				 BufferParams const & bparams,
-				 ostream & os, TexRow & texrow,
-				 bool moving_arg)
+InsetBibitem * Paragraph::bibitem() const
 {
-	lyxerr[Debug::LATEX] << "TeXOnePar...     " << this << endl;
-	Inset const * in = inInset();
-	bool further_blank_line = false;
-	LyXLayout_ptr style;
-
-	// well we have to check if we are in an inset with unlimited
-	// lenght (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 then "Standard" to be valid!
-	if ((in == 0) || !in->forceDefaultParagraphs(in)) {
-		style = layout();
-
-		if (params().startOfAppendix()) {
-			os << "\\appendix\n";
-			texrow.newline();
-		}
-
-		if (!params().spacing().isDefault()
-			&& (!previous() || !previous()->hasSameLayout(this))) {
-			os << params().spacing().writeEnvirBegin() << "\n";
-			texrow.newline();
-		}
-
-		if (style->isCommand()) {
-			os << '\n';
-			texrow.newline();
-		}
-
-		if (params().pagebreakTop()) {
-			os << "\\newpage";
-			further_blank_line = true;
-		}
-		if (params().spaceTop().kind() != VSpace::NONE) {
-			os << params().spaceTop().asLatexCommand(bparams);
-			further_blank_line = true;
-		}
-
-		if (params().lineTop()) {
-			os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}'
-			   << "\\vspace{-1\\parskip}";
-			further_blank_line = true;
-		}
-
-		if (further_blank_line) {
-			os << '\n';
-			texrow.newline();
-		}
-	} else {
-		style = bparams.getLyXTextClass().defaultLayout();
-	}
-
-	Language const * language = getParLanguage(bparams);
-	Language const * doc_language = bparams.language;
-	Language const * previous_language = previous()
-		? previous()->getParLanguage(bparams) : doc_language;
-
-	if (language->babel() != previous_language->babel()
-	    // check if we already put language command in TeXEnvironment()
-	    && !(style->isEnvironment()
-		 && (!previous() || previous()->layout() != layout() ||
-			 previous()->params().depth() != params().depth())))
-	{
-		if (!lyxrc.language_command_end.empty() &&
-		    previous_language->babel() != doc_language->babel())
-		{
-			os << subst(lyxrc.language_command_end, "$$lang",
-				    previous_language->babel())
-			   << endl;
-			texrow.newline();
-		}
-
-		if (lyxrc.language_command_end.empty() ||
-		    language->babel() != doc_language->babel())
-		{
-			os << subst(lyxrc.language_command_begin, "$$lang",
-				    language->babel())
-			   << endl;
-			texrow.newline();
-		}
-	}
-
-	if (bparams.inputenc == "auto" &&
-	    language->encoding() != previous_language->encoding()) {
-		os << "\\inputencoding{"
-		   << language->encoding()->LatexName()
-		   << "}" << endl;
-		texrow.newline();
-	}
-
-	switch (style->latextype) {
-	case LATEX_COMMAND:
-		os << '\\'
-		   << style->latexname()
-		   << style->latexparam();
-		break;
-	case LATEX_ITEM_ENVIRONMENT:
-		if (bibkey) {
-			bibkey->latex(buf, os, false, false);
-		} else
-			os << "\\item ";
-		break;
-	case LATEX_LIST_ENVIRONMENT:
-		os << "\\item ";
-		break;
-	default:
-		break;
-	}
-
-	bool need_par = simpleTeXOnePar(buf, bparams, os, texrow, moving_arg);
-
-	// Make sure that \\par is done with the font of the last
-	// character if this has another size as the default.
-	// This is necessary because LaTeX (and LyX on the screen)
-	// calculates the space between the baselines according
-	// to this font. (Matthias)
-	//
-	// Is this really needed ? (Dekel)
-	// We do not need to use to change the font for the last paragraph
-	// or for a command.
-	LyXFont const font =
-		(empty()
-		 ? getLayoutFont(bparams) : getFont(bparams, size() - 1));
-
-	bool is_command = style->isCommand();
-
-	if (style->resfont.size() != font.size() && next_ && !is_command) {
-		if (!need_par)
-			os << "{";
-		os << "\\" << font.latexSize() << " \\par}";
-	} else if (need_par) {
-		os << "\\par}";
-	} else if (is_command)
-		os << "}";
-
-	switch (style->latextype) {
-	case LATEX_ITEM_ENVIRONMENT:
-	case LATEX_LIST_ENVIRONMENT:
-		if (next_ && (params().depth() < next_->params().depth())) {
-			os << '\n';
-			texrow.newline();
-		}
-		break;
-	case LATEX_ENVIRONMENT:
-		// if its the last paragraph of the current environment
-		// skip it otherwise fall through
-		if (next_
-		    && (next_->layout() != layout()
-			|| next_->params().depth() != params().depth()))
-			break;
-		// fall through possible
-	default:
-		// we don't need it for the last paragraph!!!
-		if (next_) {
-			os << '\n';
-			texrow.newline();
-		}
-	}
-
-	if ((in == 0) || !in->forceDefaultParagraphs(in)) {
-		further_blank_line = false;
-		if (params().lineBottom()) {
-			os << "\\lyxline{\\" << font.latexSize() << '}';
-			further_blank_line = true;
-		}
-
-		if (params().spaceBottom().kind() != VSpace::NONE) {
-			os << params().spaceBottom().asLatexCommand(bparams);
-			further_blank_line = true;
-		}
-
-		if (params().pagebreakBottom()) {
-			os << "\\newpage";
-			further_blank_line = true;
-		}
-
-		if (further_blank_line) {
-			os << '\n';
-			texrow.newline();
-		}
-
-		if (!params().spacing().isDefault()
-			&& (!next_ || !next_->hasSameLayout(this))) {
-			os << params().spacing().writeEnvirEnd() << "\n";
-			texrow.newline();
-		}
-	}
-
-	// we don't need it for the last paragraph!!!
-	if (next_) {
-		os << '\n';
-		texrow.newline();
-	} else {
-		// Since \selectlanguage write the language to the aux file,
-		// we need to reset the language at the end of footnote or
-		// float.
-
-		if (language->babel() != doc_language->babel()) {
-			if (lyxrc.language_command_end.empty())
-				os << subst(lyxrc.language_command_begin,
-					    "$$lang",
-					    doc_language->babel())
-				   << endl;
-			else
-				os << subst(lyxrc.language_command_end,
-					    "$$lang",
-					    language->babel())
-				   << endl;
-			texrow.newline();
-		}
-	}
-
-	lyxerr[Debug::LATEX] << "TeXOnePar...done " << next_ << endl;
-	return next_;
+	InsetList::const_iterator it = insetlist.begin();
+	if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
+		return static_cast<InsetBibitem *>(it->inset);
+	return 0;
 }
 
 
+
 // This could go to ParagraphParameters if we want to
 int Paragraph::startTeXParParams(BufferParams const & bparams,
 				 ostream & os, bool moving_arg) const
@@ -1294,10 +803,11 @@ int Paragraph::endTeXParParams(BufferParams const & bparams,
 
 
 // This one spits out the text of the paragraph
-bool Paragraph::simpleTeXOnePar(Buffer const * buf,
+bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 				BufferParams const & bparams,
+				LyXFont const & outerfont,
 				ostream & os, TexRow & texrow,
-				bool moving_arg)
+				LatexRunParams const & runparams)
 {
 	lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 
@@ -1321,22 +831,27 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 	LyXFont basefont;
 
 	// Maybe we have to create a optional argument.
-	pos_type main_body;
-	if (style->labeltype != LABEL_MANUAL)
-		main_body = 0;
-	else
-		main_body = beginningOfMainBody();
+	pos_type body_pos;
 
-	int column = 0;
+	// FIXME: can we actually skip this check and just call
+	// beginningOfBody() ??
+	if (style->labeltype != LABEL_MANUAL) {
+		body_pos = 0;
+	} else {
+		body_pos = beginningOfBody();
+	}
+
+	unsigned int column = 0;
 
-	if (main_body > 0) {
+	if (body_pos > 0) {
 		os << '[';
 		++column;
-		basefont = getLabelFont(bparams);
+		basefont = getLabelFont(bparams, outerfont);
 	} else {
-		basefont = getLayoutFont(bparams);
+		basefont = getLayoutFont(bparams, outerfont);
 	}
 
+	bool moving_arg = runparams.moving_arg;
 	moving_arg |= style->needprotect;
 
 	// Which font is currently active?
@@ -1344,7 +859,9 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 	// Do we have an open font change?
 	bool open_font = false;
 
-	texrow.start(this, 0);
+	Change::Type running_change = Change::UNCHANGED;
+
+	texrow.start(id(), 0);
 
 	// if the paragraph is empty, the loop will not be entered at all
 	if (empty()) {
@@ -1360,13 +877,13 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 	for (pos_type i = 0; i < size(); ++i) {
 		++column;
 		// First char in paragraph or after label?
-		if (i == main_body) {
-			if (main_body > 0) {
+		if (i == body_pos) {
+			if (body_pos > 0) {
 				if (open_font) {
 					column += running_font.latexWriteEndChanges(os, basefont, basefont);
 					open_font = false;
 				}
-				basefont = getLayoutFont(bparams);
+				basefont = getLayoutFont(bparams, outerfont);
 				running_font = basefont;
 				os << ']';
 				++column;
@@ -1384,7 +901,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 		value_type c = getChar(i);
 
 		// Fully instantiated font
-		LyXFont font = getFont(bparams, i);
+		LyXFont font = getFont(bparams, i, outerfont);
 
 		LyXFont const last_font = running_font;
 
@@ -1392,7 +909,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 		// outside font change, i.e. we write "\textXX{text} "
 		// rather than "\textXX{text }". (Asger)
 		if (open_font && c == ' ' && i <= size() - 2) {
-			LyXFont const & next_font = getFont(bparams, i + 1);
+			LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
 			if (next_font != running_font
 			    && next_font != font) {
 				font = next_font;
@@ -1406,7 +923,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 		{
 			column += running_font.latexWriteEndChanges(os,
 								    basefont,
-								    (i == main_body-1) ? basefont : font);
+								    (i == body_pos-1) ? basefont : font);
 			running_font = basefont;
 			open_font = false;
 		}
@@ -1414,7 +931,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 		// Blanks are printed before start of fontswitch
 		if (c == ' ') {
 			// Do not print the separation of the optional argument
-			if (i != main_body - 1) {
+			if (i != body_pos - 1) {
 				pimpl_->simpleTeXBlanks(os, texrow, i,
 						       column, font, *style);
 			}
@@ -1423,7 +940,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 		// Do we need to change font?
 		if ((font != running_font ||
 		     font.language() != running_font.language()) &&
-			i != main_body - 1)
+			i != body_pos - 1)
 		{
 			column += font.latexWriteStartChanges(os, basefont,
 							      last_font);
@@ -1431,39 +948,25 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 			open_font = true;
 		}
 
-		if (c == Paragraph::META_NEWLINE) {
-			// 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);
-					open_font = false;
-				}
-				basefont = getLayoutFont(bparams);
-				running_font = basefont;
-				if (font.family() ==
-				    LyXFont::TYPEWRITER_FAMILY) {
-					os << "~";
-				}
-				if (moving_arg)
-					os << "\\protect ";
+		Change::Type change = pimpl_->lookupChange(i);
 
-				os << "\\\\\n";
-			}
-			texrow.newline();
-			texrow.start(this, i + 1);
-			column = 0;
-		} else {
-			pimpl_->simpleTeXSpecialChars(buf, bparams,
-						      os, texrow, moving_arg,
-						      font, running_font,
-						      basefont, open_font,
-						      *style, i, column, c);
-		}
+		column += Changes::latexMarkChange(os, running_change, change);
+		running_change = change;
+
+		LatexRunParams rp = runparams;
+		rp.moving_arg = moving_arg;
+		rp.free_spacing = style->free_spacing;
+		pimpl_->simpleTeXSpecialChars(buf, bparams,
+					      os, texrow, runparams,
+					      font, running_font,
+					      basefont, outerfont, open_font,
+					      running_change,
+					      *style, i, column, c);
 	}
 
+	column += Changes::latexMarkChange(os,
+			running_change, Change::UNCHANGED);
+
 	// If we have an open font definition, we have to close it
 	if (open_font) {
 #ifdef FIXED_LANGUAGE_END_DETECTION
@@ -1471,7 +974,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 			running_font
 				.latexWriteEndChanges(os, basefont,
 						      next_->getFont(bparams,
-						      0));
+						      0, outerfont));
 		} else {
 			running_font.latexWriteEndChanges(os, basefont,
 							  basefont);
@@ -1487,7 +990,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 	}
 
 	// Needed if there is an optional argument but no contents.
-	if (main_body > 0 && main_body == size()) {
+	if (body_pos > 0 && body_pos == size()) {
 		os << "]~";
 		return_value = false;
 	}
@@ -1501,111 +1004,12 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 }
 
 
-Paragraph * Paragraph::TeXEnvironment(Buffer const * buf,
-					    BufferParams const & bparams,
-					    ostream & os, TexRow & texrow)
-{
-	lyxerr[Debug::LATEX] << "TeXEnvironment...     " << this << endl;
-
-	LyXLayout_ptr const & style = layout();
-
-	Language const * language = getParLanguage(bparams);
-	Language const * doc_language = bparams.language;
-	Language const * previous_language = previous_
-		? previous_->getParLanguage(bparams) : doc_language;
-	if (language->babel() != previous_language->babel()) {
-
-		if (!lyxrc.language_command_end.empty() &&
-		    previous_language->babel() != doc_language->babel()) {
-			os << subst(lyxrc.language_command_end, "$$lang",
-				    previous_language->babel())
-			   << endl;
-			texrow.newline();
-		}
-
-		if (lyxrc.language_command_end.empty() ||
-		    language->babel() != doc_language->babel()) {
-			os << subst(lyxrc.language_command_begin, "$$lang",
-				    language->babel())
-			   << endl;
-			texrow.newline();
-		}
-	}
-
-	bool leftindent_open = false;
-	if (!params().leftIndent().zero()) {
-		os << "\\begin{LyXParagraphLeftIndent}{" <<
-			params().leftIndent().asLatexString() << "}\n";
-		texrow.newline();
-		leftindent_open = true;
-	}
-
-	if (style->isEnvironment()) {
-		if (style->latextype == LATEX_LIST_ENVIRONMENT) {
-			os << "\\begin{" << style->latexname() << "}{"
-			   << params().labelWidthString() << "}\n";
-		} else if (style->labeltype == LABEL_BIBLIO) {
-			// ale970405
-			os << "\\begin{" << style->latexname() << "}{"
-			   <<  bibitemWidest(buf)
-			   << "}\n";
-		} else if (style->latextype == LATEX_ITEM_ENVIRONMENT) {
-			os << "\\begin{" << style->latexname() << '}'
-			   << style->latexparam() << '\n';
-		} else
-			os << "\\begin{" << style->latexname() << '}'
-			   << style->latexparam() << '\n';
-		texrow.newline();
-	}
-	Paragraph * par = this;
-	do {
-		par = par->TeXOnePar(buf, bparams, os, texrow, false);
-
-		if (par && par->params().depth() > params().depth()) {
-			    if (par->layout()->isParagraph()) {
-
-			    // Thinko!
-			    // How to handle this? (Lgb)
-			    //&& !suffixIs(os, "\n\n")
-				    //) {
-				// There should be at least one '\n' already
-				// but we need there to be two for Standard
-				// paragraphs that are depth-increment'ed to be
-				// output correctly.  However, tables can
-				// also be paragraphs so don't adjust them.
-				// ARRae
-				// Thinkee:
-				// Will it ever harm to have one '\n' too
-				// many? i.e. that we sometimes will have
-				// three in a row. (Lgb)
-				os << '\n';
-				texrow.newline();
-			}
-			par = par->pimpl_->TeXDeeper(buf, bparams, os, texrow);
-		}
-	} while (par
-		 && par->layout() == layout()
-		 && par->params().depth() == params().depth()
-		 && par->params().leftIndent() == params().leftIndent());
-
-	if (style->isEnvironment()) {
-		os << "\\end{" << style->latexname() << "}\n";
-		texrow.newline();
-	}
-
-	if (leftindent_open) {
-		os << "\\end{LyXParagraphLeftIndent}\n";
-		texrow.newline();
-	}
-
-	lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl;
-	return par;  // ale970302
-}
 
 
 bool Paragraph::isHfill(pos_type pos) const
 {
-	return IsHfillChar(getChar(pos));
+	return IsInsetChar(getChar(pos))
+	       && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
 }
 
 
@@ -1617,7 +1021,8 @@ bool Paragraph::isInset(pos_type pos) const
 
 bool Paragraph::isNewline(pos_type pos) const
 {
-	return pos >= 0 && IsNewlineChar(getChar(pos));
+	return IsInsetChar(getChar(pos))
+	       && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE;
 }
 
 
@@ -1665,22 +1070,10 @@ bool Paragraph::isWord(pos_type pos) const
 Language const *
 Paragraph::getParLanguage(BufferParams const & bparams) const
 {
-	if (!empty()) {
-#ifndef INHERIT_LANGUAGE
+	if (!empty())
 		return getFirstFontSettings().language();
-#else
-		Language const * lang = getFirstFontSettings().language();
-#ifdef WITH_WARNINGS
-#warning We should make this somewhat better, any ideas? (Jug)
-#endif
-		if (lang == inherit_language || lang == ignore_language)
-			lang = bparams.language;
-		return lang;
-#endif
-	} else if (previous_)
-		return previous_->getParLanguage(bparams);
-	else
-		return bparams.language;
+#warning FIXME we should check the prev par as well (Lgb)
+	return bparams.language;
 }
 
 
@@ -1689,12 +1082,12 @@ bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
 	return lyxrc.rtl_support
 		&& getParLanguage(bparams)->RightToLeft()
 		&& !(inInset() && inInset()->owner() &&
-		     inInset()->owner()->lyxCode() == Inset::ERT_CODE);
+		     inInset()->owner()->lyxCode() == InsetOld::ERT_CODE);
 }
 
 
 void Paragraph::changeLanguage(BufferParams const & bparams,
-				  Language const * from, Language const * to)
+			       Language const * from, Language const * to)
 {
 	for (pos_type i = 0; i < size(); ++i) {
 		LyXFont font = getFontSettings(bparams, i);
@@ -1715,10 +1108,7 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams)
 	for (; cit != end; ++cit)
 		if (cit->font().language() != ignore_language &&
 		    cit->font().language() != latex_language &&
-#ifdef INHERIT_LANGUAGE
-			cit->font().language() != inherit_language &&
-#endif
-			cit->font().language() != doc_language)
+		    cit->font().language() != doc_language)
 			return true;
 	return false;
 }
@@ -1726,87 +1116,143 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams)
 
 // Convert the paragraph to a string.
 // Used for building the table of contents
-string const Paragraph::asString(Buffer const * buffer, bool label)
+string const Paragraph::asString(Buffer const & buffer, bool label) const
 {
-	BufferParams const & bparams = buffer->params;
+#if 0
 	string s;
 	if (label && !params().labelString().empty())
 		s += params().labelString() + ' ';
-	string::size_type const len = s.size();
 
 	for (pos_type i = 0; i < size(); ++i) {
 		value_type c = getChar(i);
 		if (IsPrintable(c))
 			s += c;
 		else if (c == META_INSET &&
-			 getInset(i)->lyxCode() == Inset::MATH_CODE) {
+			 getInset(i)->lyxCode() == InsetOld::MATH_CODE) {
 			ostringstream ost;
 			getInset(i)->ascii(buffer, ost);
-			s += subst(ost.str().c_str(),'\n',' ');
+			s += subst(STRCONV(ost.str()),'\n',' ');
 		}
 	}
 
-	if (isRightToLeftPar(bparams))
-		reverse(s.begin() + len,s.end());
-
 	return s;
+#else
+	// This should really be done by the caller and not here.
+	string ret(asString(buffer, 0, size(), label));
+	return subst(ret, '\n', ' ');
+#endif
 }
 
 
-string const Paragraph::asString(Buffer const * buffer,
-				 pos_type beg, pos_type end, bool label)
+string const Paragraph::asString(Buffer const & buffer,
+				 pos_type beg, pos_type end, bool label) const
 {
-	ostringstream ost;
+	ostringstream os;
 
 	if (beg == 0 && label && !params().labelString().empty())
-		ost << params().labelString() << ' ';
+		os << params().labelString() << ' ';
 
 	for (pos_type i = beg; i < end; ++i) {
-		value_type const c = getUChar(buffer->params, i);
+		value_type const c = getUChar(buffer.params(), i);
 		if (IsPrintable(c))
-			ost << c;
-		else if (c == META_NEWLINE)
-			ost << '\n';
-		else if (c == META_HFILL)
-			ost << '\t';
-		else if (c == META_INSET) {
-			getInset(i)->ascii(buffer, ost);
-		}
+			os << c;
+		else if (c == META_INSET)
+			getInset(i)->ascii(buffer, os);
 	}
 
-	return ost.str().c_str();
+	return os.str();
 }
 
 
-void Paragraph::setInsetOwner(Inset * i)
+void Paragraph::setInsetOwner(UpdatableInset * inset)
 {
-	pimpl_->inset_owner = i;
+	pimpl_->inset_owner = inset;
 	InsetList::iterator it = insetlist.begin();
 	InsetList::iterator end = insetlist.end();
-	for (; it != end; ++it) {
-		if (it.getInset())
-			it.getInset()->setOwner(i);
-	}
+	for (; it != end; ++it)
+		if (it->inset)
+			it->inset->setOwner(inset);
 }
 
 
 void Paragraph::deleteInsetsLyXText(BufferView * bv)
 {
-	// then the insets
 	insetlist.deleteInsetsLyXText(bv);
 }
 
 
-void Paragraph::resizeInsetsLyXText(BufferView * bv)
+void Paragraph::setContentsFromPar(Paragraph const & par)
 {
-	// then the insets
-	insetlist.resizeInsetsLyXText(bv);
+	pimpl_->setContentsFromPar(par);
 }
 
 
-void Paragraph::setContentsFromPar(Paragraph * par)
+void Paragraph::trackChanges(Change::Type type)
 {
-	pimpl_->setContentsFromPar(par);
+	pimpl_->trackChanges(type);
+}
+
+
+void Paragraph::untrackChanges()
+{
+	pimpl_->untrackChanges();
+}
+
+
+void Paragraph::cleanChanges()
+{
+	pimpl_->cleanChanges();
+}
+
+
+Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
+{
+	BOOST_ASSERT(!size() || pos < size());
+	return pimpl_->lookupChange(pos);
+}
+
+
+Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
+{
+	BOOST_ASSERT(!size() || pos < size());
+	return pimpl_->lookupChangeFull(pos);
+}
+
+
+bool Paragraph::isChanged(pos_type start, pos_type end) const
+{
+	return pimpl_->isChanged(start, end);
+}
+
+
+bool Paragraph::isChangeEdited(pos_type start, pos_type end) const
+{
+	return pimpl_->isChangeEdited(start, end);
+}
+
+
+void Paragraph::setChange(lyx::pos_type pos, Change::Type type)
+{
+	pimpl_->setChange(pos, type);
+
+}
+
+
+void Paragraph::markErased()
+{
+	pimpl_->markErased();
+}
+
+
+void Paragraph::acceptChange(pos_type start, pos_type end)
+{
+	return pimpl_->acceptChange(start, end);
+}
+
+
+void Paragraph::rejectChange(pos_type start, pos_type end)
+{
+	return pimpl_->rejectChange(start, end);
 }
 
 
@@ -1834,28 +1280,30 @@ int Paragraph::id() const
 }
 
 
-LyXLayout_ptr const & Paragraph::layout() const
+void Paragraph::id(int i)
 {
-	return layout_;
+	pimpl_->id_ = i;
 }
 
 
-void Paragraph::layout(LyXLayout_ptr const & new_layout)
+LyXLayout_ptr const & Paragraph::layout() const
 {
-	layout_ = new_layout;
+/*
+	InsetOld * inset = inInset();
+	if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE)
+		return static_cast<InsetEnvironment*>(inset)->layout();
+*/
+	return layout_;
 }
 
 
-bool Paragraph::isFirstInSequence() const
+void Paragraph::layout(LyXLayout_ptr const & new_layout)
 {
-	Paragraph const * dhook = depthHook(getDepth());
-	return (dhook == this
-		|| dhook->layout() != layout()
-		|| dhook->getDepth() != getDepth());
+	layout_ = new_layout;
 }
 
 
-Inset * Paragraph::inInset() const
+UpdatableInset * Paragraph::inInset() const
 {
 	return pimpl_->inset_owner;
 }
@@ -1884,17 +1332,24 @@ ParagraphParameters const & Paragraph::params() const
 }
 
 
-Paragraph * Paragraph::getParFromID(int id) const
+bool Paragraph::isFreeSpacing() const
 {
-	return pimpl_->getParFromID(id);
+	if (layout()->free_spacing)
+		return true;
+
+	// for now we just need this, later should we need this in some
+	// other way we can always add a function to InsetOld too.
+	if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
+		return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE;
+	return false;
 }
 
 
-bool Paragraph::isFreeSpacing() const
+bool Paragraph::allowEmpty() const
 {
-	// for now we just need this, later should we need this in some
-	// other way we can always add a function to Inset::() too.
+	if (layout()->keepempty)
+		return true;
 	if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
-		return (pimpl_->inset_owner->owner()->lyxCode() == Inset::ERT_CODE);
+		return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE;
 	return false;
 }