X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=5579d6deeea234e75227382628a16d643d69cfa7;hb=131eabe56c437ebb740950a17b6226914153f2df;hp=ad90baabfdc910980836242b02aaa21993c9960a;hpb=ebc4d99eaa5d860fedfe509bd1b2a26938d95082;p=lyx.git

diff --git a/src/paragraph.C b/src/paragraph.C
index ad90baabfd..5579d6deee 100644
--- a/src/paragraph.C
+++ b/src/paragraph.C
@@ -12,22 +12,27 @@
 
 #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 "changes.h"
 #include "encoding.h"
-#include "ParameterStruct.h"
+#include "debug.h"
 #include "gettext.h"
-#include "changes.h"
+#include "language.h"
+#include "latexrunparams.h"
+#include "layout.h"
+#include "lyxrc.h"
+#include "paragraph_funcs.h"
+#include "ParameterStruct.h"
+#include "texrow.h"
+
+#include "Lsstream.h"
 
 #include "insets/insetbibitem.h"
 #include "insets/insetoptarg.h"
+#include "insets/insetenv.h"
 
 #include "support/filetools.h"
 #include "support/lstrings.h"
@@ -41,6 +46,8 @@
 #include <csignal>
 #include <ctime>
 
+using namespace lyx::support;
+
 using std::ostream;
 using std::endl;
 using std::fstream;
@@ -57,58 +64,53 @@ namespace {
 
 char minibuffer_char;
 LyXFont minibuffer_font;
-Inset * minibuffer_inset;
+InsetOld * minibuffer_inset;
 
 } // namespace anon
 
 
-extern BufferView * current_view;
-
-
 Paragraph::Paragraph()
 	: pimpl_(new Paragraph::Pimpl(this))
 {
-#ifndef NO_NEXT
-	next_ = 0;
-	previous_ = 0;
-#endif
 	enumdepth = 0;
 	itemdepth = 0;
 	params().clear();
 }
 
 
-#ifndef NO_NEXT
-// This constructor inserts the new paragraph in a list.
-// It is placed after par.
-Paragraph::Paragraph(Paragraph * par)
-	: pimpl_(new Paragraph::Pimpl(this))
+Paragraph::Paragraph(Paragraph const & lp)
+	: 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
-
-	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());
+		// tell the new inset who is the boss now
+		it->inset->parOwner(this);
+	}
 }
-#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=()\n";
+	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();
@@ -118,24 +120,15 @@ Paragraph::Paragraph(Paragraph const & lp, bool same_ids)
 	InsetList::iterator it = insetlist.begin();
 	InsetList::iterator end = insetlist.end();
 	for (; it != end; ++it) {
-		it.setInset(it.getInset()->clone(*current_view->buffer(),
-						 same_ids));
+		it->inset = static_cast<InsetOld*>(it->inset->clone().release());
 		// tell the new inset who is the boss now
-		it.getInset()->parOwner(this);
+		it->inset->parOwner(this);
 	}
 }
 
-
 // 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
-
 	delete pimpl_;
 	//
 	//lyxerr << "Paragraph::paragraph_id = "
@@ -163,60 +156,9 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 	}
 
 	// First write the layout
-	os << "\n\\layout " << layout()->name() << '\n';
+	os << "\n\\begin_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] << ' ';
-	}
+	params().write(os);
 
 	LyXFont font1(LyXFont::ALL_INHERIT, bparams.language);
 
@@ -246,7 +188,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
@@ -261,14 +203,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;
@@ -306,6 +240,8 @@ void Paragraph::write(Buffer const * buf, ostream & os,
 	}
 	Changes::lyxMarkChange(os, column, curtime,
 		running_change, Change(Change::UNCHANGED));
+
+	os << "\n\\end_layout\n";
 }
 
 
@@ -325,7 +261,7 @@ void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const
 	minibuffer_inset = 0;
 	if (minibuffer_char == Paragraph::META_INSET) {
 		if (getInset(pos)) {
-			minibuffer_inset = getInset(pos)->clone(buffer);
+			minibuffer_inset = static_cast<InsetOld *>(getInset(pos)->clone().release());
 		} else {
 			minibuffer_inset = 0;
 			minibuffer_char = ' ';
@@ -350,25 +286,20 @@ void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos)
 			minibuffer_char = ' ';
 			// This reflects what GetInset() does (ARRae)
 		}
-
 	}
-
-	// Erase(pos); now the caller is responsible for that.
 }
 
 
 bool Paragraph::insertFromMinibuffer(pos_type pos)
 {
 	if (minibuffer_char == Paragraph::META_INSET) {
-		if (!insetAllowed(minibuffer_inset->lyxCode())) {
+		if (!insetAllowed(minibuffer_inset->lyxCode()))
 			return false;
-		}
 		insertInset(pos, minibuffer_inset, minibuffer_font);
 	} else {
 		LyXFont f = minibuffer_font;
-		if (!checkInsertChar(f)) {
+		if (!checkInsertChar(f))
 			return false;
-		}
 		insertChar(pos, minibuffer_char, f);
 	}
 	return true;
@@ -383,13 +314,13 @@ void Paragraph::eraseIntern(lyx::pos_type pos)
 }
 
 
-void Paragraph::erase(pos_type pos)
+bool Paragraph::erase(pos_type pos)
 {
-	pimpl_->erase(pos);
+	return pimpl_->erase(pos);
 }
 
 
-bool Paragraph::erase(pos_type start, pos_type end)
+int Paragraph::erase(pos_type start, pos_type end)
 {
 	return pimpl_->erase(start, end);
 }
@@ -405,8 +336,7 @@ 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));
 }
 
 
@@ -417,41 +347,37 @@ void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
 }
 
 
-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, Change change)
+void Paragraph::insertInset(pos_type pos, InsetOld * inset, LyXFont const & font, Change change)
 {
 	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());
-
+	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());
-
+	Assert(pos < size());
 	return insetlist.get(pos);
 }
 
@@ -460,24 +386,38 @@ Inset const * Paragraph::getInset(pos_type pos) const
 LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 					 pos_type pos) const
 {
-	lyx::Assert(pos <= size());
+	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));
+	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
+{
+	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 << "Pararaph::getEndPosOfFontSpan: This should not happen!\n";
+	return pos;
 }
 
 
@@ -496,49 +436,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);
+	Assert(pos >= 0);
 
 	LyXLayout_ptr const & lout = layout();
 
-	pos_type const 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);
 	tmpfont.realize(layoutfont);
+	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;
 }
 
 
@@ -621,7 +561,7 @@ Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 
 void Paragraph::setFont(pos_type pos, LyXFont const & font)
 {
-	lyx::Assert(pos <= size());
+	Assert(pos <= size());
 
 	// First, reduce font against layout/label font
 	// Update: The SetCharFont() routine in text2.C already
@@ -682,61 +622,18 @@ 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()
+void Paragraph::makeSameLayout(Paragraph const & par)
 {
-	return previous_;
-}
-
-
-// This function is able to hide closed footnotes.
-Paragraph const * Paragraph::previous() const
-{
-	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))) {
@@ -748,40 +645,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());
 }
 
 
@@ -793,15 +661,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();
@@ -841,14 +707,7 @@ 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;
@@ -857,19 +716,22 @@ int Paragraph::beginningOfMainBody() const
 	// 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;
+				}
 			}
 		}
 	}
@@ -878,78 +740,24 @@ 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();
+	InsetList::const_iterator it = insetlist.begin();
+	InsetList::const_iterator end = insetlist.end();
 	for (; it != end; ++it)
-		if (it.getInset() == inset)
-			return it.getPos();
+		if (it->inset == inset)
+			return it->pos;
 	return -1;
 }
 
 
-InsetBibitem * Paragraph::bibitem()
+InsetBibitem * Paragraph::bibitem() const
 {
-	InsetList::iterator it = insetlist.begin();
-	if (it != insetlist.end() && it.getInset()->lyxCode() == Inset::BIBTEX_CODE)
-		return static_cast<InsetBibitem *>(it.getInset());
+	InsetList::const_iterator it = insetlist.begin();
+	if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
+		return static_cast<InsetBibitem *>(it->inset);
 	return 0;
 }
 
@@ -1074,8 +882,9 @@ int Paragraph::endTeXParParams(BufferParams const & bparams,
 // This one spits out the text of the paragraph
 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;
 
@@ -1099,26 +908,27 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 	LyXFont basefont;
 
 	// Maybe we have to create a optional argument.
-	pos_type main_body;
+	pos_type body_pos;
 
 	// FIXME: can we actually skip this check and just call
-	// beginningOfMainBody() ??
+	// beginningOfBody() ??
 	if (style->labeltype != LABEL_MANUAL) {
-		main_body = 0;
+		body_pos = 0;
 	} else {
-		main_body = beginningOfMainBody();
+		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?
@@ -1128,7 +938,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 
 	Change::Type running_change = Change::UNCHANGED;
 
-	texrow.start(this, 0);
+	texrow.start(id(), 0);
 
 	// if the paragraph is empty, the loop will not be entered at all
 	if (empty()) {
@@ -1144,13 +954,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;
@@ -1168,7 +978,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;
 
@@ -1176,7 +986,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;
@@ -1190,7 +1000,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;
 		}
@@ -1198,7 +1008,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);
 			}
@@ -1207,7 +1017,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);
@@ -1220,38 +1030,15 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 		column += Changes::latexMarkChange(os, running_change, change);
 		running_change = change;
 
-		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 ";
-
-				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,
-						      running_change,
-						      *style, i, column, c);
-		}
+		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,
@@ -1264,7 +1051,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);
@@ -1280,7 +1067,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;
 	}
@@ -1298,7 +1085,8 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 
 bool Paragraph::isHfill(pos_type pos) const
 {
-	return IsHfillChar(getChar(pos));
+	return IsInsetChar(getChar(pos))
+	       && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
 }
 
 
@@ -1310,7 +1098,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;
 }
 
 
@@ -1358,12 +1147,10 @@ bool Paragraph::isWord(pos_type pos) const
 Language const *
 Paragraph::getParLanguage(BufferParams const & bparams) const
 {
-	if (!empty()) {
+	if (!empty())
 		return getFirstFontSettings().language();
-	} 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;
 }
 
 
@@ -1372,12 +1159,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);
@@ -1408,6 +1195,7 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams)
 // Used for building the table of contents
 string const Paragraph::asString(Buffer const * buffer, bool label) const
 {
+#if 0
 	string s;
 	if (label && !params().labelString().empty())
 		s += params().labelString() + ' ';
@@ -1417,7 +1205,7 @@ string const Paragraph::asString(Buffer const * buffer, bool label) const
 		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(STRCONV(ost.str()),'\n',' ');
@@ -1425,61 +1213,58 @@ string const Paragraph::asString(Buffer const * buffer, bool label) const
 	}
 
 	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) 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);
 		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 STRCONV(ost.str());
+	return STRCONV(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)
 {
-	// then the insets
 	insetlist.resizeInsetsLyXText(bv);
 }
 
 
-void Paragraph::setContentsFromPar(Paragraph * par)
+void Paragraph::setContentsFromPar(Paragraph const & par)
 {
 	pimpl_->setContentsFromPar(par);
 }
@@ -1505,14 +1290,14 @@ void Paragraph::cleanChanges()
 
 Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
 {
-	lyx::Assert(!size() || pos < size());
+	Assert(!size() || pos < size());
 	return pimpl_->lookupChange(pos);
 }
 
 
 Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
 {
-	lyx::Assert(!size() || pos < size());
+	Assert(!size() || pos < size());
 	return pimpl_->lookupChangeFull(pos);
 }
 
@@ -1578,28 +1363,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;
 }
@@ -1630,9 +1417,29 @@ ParagraphParameters const & Paragraph::params() const
 
 bool Paragraph::isFreeSpacing() const
 {
+	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 Inset::() too.
+	// 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::allowEmpty() const
+{
+	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;
 }
+
+
+bool operator==(Paragraph const & lhs, Paragraph const & rhs)
+{
+#warning FIXME this implementatoin must be completely wrong...
+	return &lhs == &rhs;
+}