X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_funcs.C;h=8def8c6f228526645b12cf7cc5b613f76d5c00d4;hb=37e82a546392d43f787826b85481a11f2a27af15;hp=5796f158c1bfac6ac855efc9ceaec1b4fa758f09;hpb=ebc4d99eaa5d860fedfe509bd1b2a26938d95082;p=lyx.git

diff --git a/src/paragraph_funcs.C b/src/paragraph_funcs.C
index 5796f158c1..8def8c6f22 100644
--- a/src/paragraph_funcs.C
+++ b/src/paragraph_funcs.C
@@ -5,46 +5,106 @@
  *
  * \author Lars Gullik Bjønnes
  *
- * Full author contact details are available in file CREDITS
+ * Full author contact details are available in file CREDITS.
  */
 
 #include <config.h>
 
 #include "paragraph_funcs.h"
-#include "paragraph_pimpl.h"
+
 #include "buffer.h"
-#include "ParagraphParameters.h"
-#include "lyxtextclasslist.h"
+#include "bufferparams.h"
+
 #include "debug.h"
-#include "language.h"
 #include "encoding.h"
-#include "lyxrc.h"
+#include "gettext.h"
+#include "language.h"
+#include "lyxrow.h"
+#include "lyxtext.h"
+#include "outputparams.h"
+#include "paragraph_pimpl.h"
+#include "pariterator.h"
+#include "sgml.h"
+#include "texrow.h"
+#include "vspace.h"
+
+#include "support/filetools.h"
 #include "support/lstrings.h"
-#include "insets/insetoptarg.h"
+#include "support/lyxlib.h"
 
-extern string bibitemWidest(Buffer const *);
+#include <sstream>
+#include <vector>
 
 using lyx::pos_type;
-//using lyx::layout_type;
+using lyx::pit_type;
+
+using lyx::support::ascii_lowercase;
+using lyx::support::bformat;
+using lyx::support::compare_ascii_no_case;
+using lyx::support::compare_no_case;
+using lyx::support::contains;
+using lyx::support::split;
+using lyx::support::subst;
+
+using std::auto_ptr;
 using std::endl;
+using std::string;
+using std::vector;
+using std::istringstream;
 using std::ostream;
+using std::pair;
+
+
+namespace {
 
-void breakParagraph(Buffer * buf,
-		    ParagraphList::iterator par,
-		    pos_type pos,
-		    int flag)
+bool moveItem(Paragraph & from, Paragraph & to,
+	BufferParams const & params, pos_type i, pos_type j)
 {
-	BufferParams const & bparams = buf->params;
+	Paragraph::value_type const tmpchar = from.getChar(i);
+	LyXFont tmpfont = from.getFontSettings(params, i);
+
+	if (tmpchar == Paragraph::META_INSET) {
+		InsetBase * tmpinset = 0;
+		if (from.getInset(i)) {
+			// the inset is not in a paragraph anymore
+			tmpinset = from.insetlist.release(i);
+			from.insetlist.erase(i);
+		}
+
+		if (!to.insetAllowed(tmpinset->lyxCode())) {
+			delete tmpinset;
+			return false;
+		}
+		if (tmpinset)
+			to.insertInset(j, tmpinset, tmpfont);
+	} else {
+		if (!to.checkInsertChar(tmpfont))
+			return false;
+		to.insertChar(j, tmpchar, tmpfont);
+	}
+	return true;
+}
+
+}
+
 
+void breakParagraph(BufferParams const & bparams,
+	ParagraphList & pars, pit_type par_offset, pos_type pos, int flag)
+{
 	// create a new paragraph, and insert into the list
-	ParagraphList::iterator tmp = buf->paragraphs.insert(boost::next(par),
-							     new Paragraph);
+	ParagraphList::iterator tmp =
+		pars.insert(pars.begin() + par_offset + 1, Paragraph());
+
+	Paragraph & par = pars[par_offset];
+
+	// we will invalidate the row cache
+	par.rows().clear();
 
 	// without doing that we get a crash when typing <Return> at the
 	// end of a paragraph
 	tmp->layout(bparams.getLyXTextClass().defaultLayout());
 	// remember to set the inset_owner
-	tmp->setInsetOwner(par->inInset());
+	tmp->setInsetOwner(par.inInset());
 
 	if (bparams.tracking_changes)
 		tmp->trackChanges();
@@ -54,75 +114,70 @@ void breakParagraph(Buffer * buf,
 
 	// layout stays the same with latex-environments
 	if (flag) {
-		tmp->layout(par->layout());
-		tmp->setLabelWidthString(par->params().labelWidthString());
+		tmp->layout(par.layout());
+		tmp->setLabelWidthString(par.params().labelWidthString());
 	}
 
-	bool const isempty = (par->layout()->keepempty && par->empty());
-
-	if (!isempty && (par->size() > pos || par->empty() || flag == 2)) {
-		tmp->layout(par->layout());
-		tmp->params().align(par->params().align());
-		tmp->setLabelWidthString(par->params().labelWidthString());
+	bool const isempty = (par.allowEmpty() && par.empty());
 
-		tmp->params().lineBottom(par->params().lineBottom());
-		par->params().lineBottom(false);
-		tmp->params().pagebreakBottom(par->params().pagebreakBottom());
-		par->params().pagebreakBottom(false);
-		tmp->params().spaceBottom(par->params().spaceBottom());
-		par->params().spaceBottom(VSpace(VSpace::NONE));
+	if (!isempty && (par.size() > pos || par.empty() || flag == 2)) {
+		tmp->layout(par.layout());
+		tmp->params().align(par.params().align());
+		tmp->setLabelWidthString(par.params().labelWidthString());
 
-		tmp->params().depth(par->params().depth());
-		tmp->params().noindent(par->params().noindent());
+		tmp->params().depth(par.params().depth());
+		tmp->params().noindent(par.params().noindent());
 
 		// copy everything behind the break-position
 		// to the new paragraph
 
-#ifdef WITH_WARNINGS
-#warning this seems wrong
-#endif
-		/* FIXME: if !keepempty, empty() == true, then we reach
-		 * here with size() == 0. So pos_end becomes - 1. Why
-		 * doesn't this cause problems ???
+		/* Note: if !keepempty, empty() == true, then we reach
+		 * here with size() == 0. So pos_end becomes - 1. This
+		 * doesn't cause problems because both loops below
+		 * enforce pos <= pos_end and 0 <= pos
 		 */
-		pos_type pos_end = par->size() - 1;
-		pos_type i = pos;
-		pos_type j = pos;
-
-		for (; i <= pos_end; ++i) {
-			Change::Type change(par->lookupChange(i));
-			par->cutIntoMinibuffer(bparams, i);
-			if (tmp->insertFromMinibuffer(j - pos)) {
+		pos_type pos_end = par.size() - 1;
+
+		for (pos_type i = pos, j = pos; i <= pos_end; ++i) {
+			Change::Type change = par.lookupChange(i);
+			if (moveItem(par, *tmp, bparams, i, j - pos)) {
 				tmp->setChange(j - pos, change);
 				++j;
 			}
 		}
-		for (i = pos_end; i >= pos; --i) {
-			par->eraseIntern(i);
-		}
+
+		for (pos_type i = pos_end; i >= pos; --i)
+			par.eraseIntern(i);
 	}
 
-	if (pos)
+	if (pos) {
+		// Make sure that we keep the language when
+		// breaking paragrpah.
+		if (tmp->empty()) {
+			LyXFont changed = tmp->getFirstFontSettings();
+			LyXFont old = par.getFontSettings(bparams, par.size());
+			changed.setLanguage(old.language());
+			tmp->setFont(0, changed);
+		}
+
 		return;
+	}
 
-	tmp->params().lineTop(par->params().lineTop());
-	tmp->params().pagebreakTop(par->params().pagebreakTop());
-	tmp->params().spaceTop(par->params().spaceTop());
-	par->params().clear();
+	par.params().clear();
 
-	par->layout(bparams.getLyXTextClass().defaultLayout());
+	par.layout(bparams.getLyXTextClass().defaultLayout());
 
 	// layout stays the same with latex-environments
 	if (flag) {
-		par->layout(tmp->layout());
-		par->setLabelWidthString(tmp->params().labelWidthString());
-		par->params().depth(tmp->params().depth());
+		par.layout(tmp->layout());
+		par.setLabelWidthString(tmp->params().labelWidthString());
+		par.params().depth(tmp->params().depth());
 	}
 
 	// subtle, but needed to get empty pars working right
 	if (bparams.tracking_changes) {
-		if (!par->size()) {
-			par->cleanChanges();
+		if (!par.size()) {
+			par.cleanChanges();
 		} else if (!tmp->size()) {
 			tmp->cleanChanges();
 		}
@@ -130,500 +185,151 @@ void breakParagraph(Buffer * buf,
 }
 
 
-void breakParagraphConservative(Buffer * buf,
-				ParagraphList::iterator par,
-				pos_type pos)
+void breakParagraphConservative(BufferParams const & bparams,
+	ParagraphList & pars, pit_type par_offset, pos_type pos)
 {
-	BufferParams const & bparams = buf->params;
-
 	// create a new paragraph
-	ParagraphList::iterator tmp = buf->paragraphs.insert(boost::next(par),
-							     new Paragraph);
-	tmp->makeSameLayout(&*par);
+	Paragraph & tmp = *pars.insert(pars.begin() + par_offset + 1, Paragraph());
+	Paragraph & par = pars[par_offset];
+
+	tmp.makeSameLayout(par);
 
-	// When can pos > Last()?
-	// I guess pos == Last() is possible.
-	if (par->size() > pos) {
+	// When can pos > size()?
+	// I guess pos == size() is possible.
+	if (par.size() > pos) {
 		// copy everything behind the break-position to the new
 		// paragraph
-		pos_type pos_end = par->size() - 1;
+		pos_type pos_end = par.size() - 1;
 
-		for (pos_type i = pos, j = pos; i <= pos_end; ++i) {
-			par->cutIntoMinibuffer(bparams, i);
-			if (tmp->insertFromMinibuffer(j - pos))
+		for (pos_type i = pos, j = pos; i <= pos_end; ++i)
+			if (moveItem(par, tmp, bparams, i, j - pos))
 				++j;
-		}
 
-		for (pos_type k = pos_end; k >= pos; --k) {
-			par->erase(k);
-		}
+		for (pos_type k = pos_end; k >= pos; --k)
+			par.erase(k);
 	}
 }
 
 
-void mergeParagraph(Buffer * buf, ParagraphList::iterator par)
+void mergeParagraph(BufferParams const & bparams,
+	ParagraphList & pars, pit_type par_offset)
 {
-	BufferParams const & bparams = buf->params;
-
-	ParagraphList::iterator the_next = boost::next(par);
+	Paragraph & next = pars[par_offset + 1];
+	Paragraph & par = pars[par_offset];
 
-	// first the DTP-stuff
-	par->params().lineBottom(the_next->params().lineBottom());
-	par->params().spaceBottom(the_next->params().spaceBottom());
-	par->params().pagebreakBottom(the_next->params().pagebreakBottom());
-
-	pos_type pos_end = the_next->size() - 1;
-	pos_type pos_insert = par->size();
+	pos_type pos_end = next.size() - 1;
+	pos_type pos_insert = par.size();
 
 	// ok, now copy the paragraph
-	for (pos_type i = 0, j = 0; i <= pos_end; ++i) {
-		the_next->cutIntoMinibuffer(bparams, i);
-		if (par->insertFromMinibuffer(pos_insert + j))
+	for (pos_type i = 0, j = 0; i <= pos_end; ++i)
+		if (moveItem(next, par, bparams, i, pos_insert + j))
 			++j;
-	}
 
-	buf->paragraphs.erase(the_next);
+	pars.erase(pars.begin() + par_offset + 1);
 }
 
 
-#if 0
-Paragraph * depthHook(Paragraph * par, Paragraph::depth_type depth)
+pit_type depthHook(pit_type pit,
+	ParagraphList const & pars, Paragraph::depth_type depth)
 {
-	Paragraph * newpar = par;
+	pit_type newpit = pit;
 
-	do {
-		newpar = newpar->previous();
-	} while (newpar && newpar->getDepth() > depth);
+	if (newpit != 0)
+		--newpit;
 
-	if (!newpar) {
-		if (par->previous() || par->getDepth())
-			lyxerr << "Error (depthHook): "
-			       << "no hook." << endl;
-		newpar = par;
-	}
-	return newpar;
+	while (newpit != 0 && pars[newpit].getDepth() > depth)
+		--newpit;
+
+	if (pars[newpit].getDepth() > depth)
+		return pit;
+
+	return newpit;
 }
 
 
-Paragraph * outerHook(Paragraph * par)
+pit_type outerHook(pit_type par_offset, ParagraphList const & pars)
 {
-	if (!par->getDepth())
-		return 0;
-	return depthHook(par, Paragraph::depth_type(par->getDepth() - 1));
+	Paragraph const & par = pars[par_offset];
+
+	if (par.getDepth() == 0)
+		return pars.size();
+	return depthHook(par_offset, pars, Paragraph::depth_type(par.getDepth() - 1));
 }
 
 
-bool isFirstInSequence(Paragraph * par)
+bool isFirstInSequence(pit_type par_offset, ParagraphList const & pars)
 {
-	Paragraph const * dhook = depthHook(par, par->getDepth());
-	return (dhook == par
-		|| dhook->getLayout() != par->getLayout()
-		|| dhook->getDepth() != par->getDepth());
+	Paragraph const & par = pars[par_offset];
+
+	pit_type dhook_offset = depthHook(par_offset, pars, par.getDepth());
+
+	Paragraph const & dhook = pars[dhook_offset];
+
+	return dhook_offset == par_offset
+		|| dhook.layout() != par.layout()
+		|| dhook.getDepth() != par.getDepth();
 }
 
 
-int getEndLabel(Paragraph * para, BufferParams const & bparams)
+int getEndLabel(pit_type p, ParagraphList const & pars)
 {
-	Paragraph * par = para;
-	while (par) {
-		Paragraph::depth_type par_depth = par->getDepth();
-		layout_type layout = par->getLayout();
-		int const endlabeltype =
-			textclasslist.Style(bparams.textclass,
-					    layout).endlabeltype;
+	pit_type pit = p;
+	Paragraph::depth_type par_depth = pars[p].getDepth();
+	while (pit != pit_type(pars.size())) {
+		LyXLayout_ptr const & layout = pars[pit].layout();
+		int const endlabeltype = layout->endlabeltype;
+
 		if (endlabeltype != END_LABEL_NO_LABEL) {
-			if (!para->next())
+			if (p + 1 == pit_type(pars.size()))
 				return endlabeltype;
 
 			Paragraph::depth_type const next_depth =
-				para->next()->getDepth();
+				pars[p + 1].getDepth();
 			if (par_depth > next_depth ||
-			    (par_depth == next_depth
-			     && layout != para->next()->getLayout()))
+			    (par_depth == next_depth && layout != pars[p + 1].layout()))
 				return endlabeltype;
 			break;
 		}
 		if (par_depth == 0)
 			break;
-		par = outerHook(par);
+		pit = outerHook(pit, pars);
+		if (pit != pit_type(pars.size()))
+			par_depth = pars[pit].getDepth();
 	}
 	return END_LABEL_NO_LABEL;
 }
-#endif
 
 
-ParagraphList::iterator
-TeXDeeper(Buffer const * buf,
-	  BufferParams const & bparams,
-	  ParagraphList::iterator pit,
-	  ostream & os, TexRow & texrow)
+LyXFont const outerFont(pit_type par_offset, ParagraphList const & pars)
 {
-	lyxerr[Debug::LATEX] << "TeXDeeper...     " << &*pit << endl;
-	ParagraphList::iterator par = pit;
-
-	while (par != buf->paragraphs.end()&& par->params().depth() == pit->params().depth()) {
-		if (par->layout()->isEnvironment()) {
-			par = TeXEnvironment(buf, bparams, par,
-						  os, texrow);
-		} else {
-			par = TeXOnePar(buf, bparams, par,
-					     os, texrow, false);
+	Paragraph::depth_type par_depth = pars[par_offset].getDepth();
+	LyXFont tmpfont(LyXFont::ALL_INHERIT);
+
+	// Resolve against environment font information
+	while (par_offset != pit_type(pars.size())
+	       && par_depth
+	       && !tmpfont.resolved()) {
+		par_offset = outerHook(par_offset, pars);
+		if (par_offset != pit_type(pars.size())) {
+			tmpfont.realize(pars[par_offset].layout()->font);
+			par_depth = pars[par_offset].getDepth();
 		}
 	}
-	lyxerr[Debug::LATEX] << "TeXDeeper...done " << &*par << endl;
 
-	return par;
+	return tmpfont;
 }
 
 
-ParagraphList::iterator
-TeXEnvironment(Buffer const * buf,
-	       BufferParams const & bparams,
-	       ParagraphList::iterator pit,
-	       ostream & os, TexRow & texrow)
+/// return the number of InsetOptArg in a paragraph
+int numberOfOptArgs(Paragraph const & par)
 {
-	lyxerr[Debug::LATEX] << "TeXEnvironment...     " << &*pit << endl;
-
-	LyXLayout_ptr const & style = pit->layout();
-
-	Language const * language = pit->getParLanguage(bparams);
-	Language const * doc_language = bparams.language;
-	Language const * previous_language = pit->previous()
-		? pit->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();
-		}
+	int num = 0;
 
-		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 (!pit->params().leftIndent().zero()) {
-		os << "\\begin{LyXParagraphLeftIndent}{" <<
-			pit->params().leftIndent().asLatexString() << "}\n";
-		texrow.newline();
-		leftindent_open = true;
+	InsetList::const_iterator it = par.insetlist.begin();
+	InsetList::const_iterator end = par.insetlist.end();
+	for (; it != end ; ++it) {
+		if (it->inset->lyxCode() == InsetBase::OPTARG_CODE)
+			++num;
 	}
-
-	if (style->isEnvironment()) {
-		if (style->latextype == LATEX_LIST_ENVIRONMENT) {
-			os << "\\begin{" << style->latexname() << "}{"
-			   << pit->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();
-	}
-	ParagraphList::iterator par = pit;
-	do {
-		par = TeXOnePar(buf, bparams, par, os, texrow, false);
-
-		if (par != buf->paragraphs.end()&& par->params().depth() > pit->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 = TeXDeeper(buf, bparams, par, os, texrow);
-		}
-	} while (par != buf->paragraphs.end()
-		 && par->layout() == pit->layout()
-		 && par->params().depth() == pit->params().depth()
-		 && par->params().leftIndent() == pit->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
-}
-
-
-namespace {
-
-InsetOptArg * optArgInset(Paragraph const & par)
-{
-	// Find the entry.
-	InsetList::iterator it = par.insetlist.begin();
-	InsetList::iterator end = par.insetlist.end();
-	for (; it != end; ++it) {
-		Inset * ins = it.getInset();
-		if (ins->lyxCode() == Inset::OPTARG_CODE) {
-			return static_cast<InsetOptArg *>(ins);
-		}
-	}
-	return 0;
-}
-
-} // end namespace
-
-
-ParagraphList::iterator
-TeXOnePar(Buffer const * buf,
-	  BufferParams const & bparams,
-	  ParagraphList::iterator pit,
-	  ostream & os, TexRow & texrow,
-	  bool moving_arg)
-{
-	lyxerr[Debug::LATEX] << "TeXOnePar...     " << &*pit << endl;
-	Inset const * in = pit->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 = pit->layout();
-
-		if (pit->params().startOfAppendix()) {
-			os << "\\appendix\n";
-			texrow.newline();
-		}
-
-		if (!pit->params().spacing().isDefault()
-			&& (!pit->previous() || !pit->previous()->hasSameLayout(&*pit))) {
-			os << pit->params().spacing().writeEnvirBegin() << '\n';
-			texrow.newline();
-		}
-
-		if (style->isCommand()) {
-			os << '\n';
-			texrow.newline();
-		}
-
-		if (pit->params().pagebreakTop()) {
-			os << "\\newpage";
-			further_blank_line = true;
-		}
-		if (pit->params().spaceTop().kind() != VSpace::NONE) {
-			os << pit->params().spaceTop().asLatexCommand(bparams);
-			further_blank_line = true;
-		}
-
-		if (pit->params().lineTop()) {
-			os << "\\lyxline{\\" << pit->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 = pit->getParLanguage(bparams);
-	Language const * doc_language = bparams.language;
-	Language const * previous_language = pit->previous()
-		? pit->previous()->getParLanguage(bparams) : doc_language;
-
-	if (language->babel() != previous_language->babel()
-	    // check if we already put language command in TeXEnvironment()
-	    && !(style->isEnvironment()
-		 && (!pit->previous() ||
-		     (pit->previous()->layout() != pit->layout() &&
-		      pit->previous()->getDepth() <= pit->getDepth())
-		     || pit->previous()->getDepth() < pit->getDepth())))
-	{
-		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()
-		   << "}\n";
-		texrow.newline();
-	}
-
-	switch (style->latextype) {
-	case LATEX_COMMAND:
-		os << '\\' << style->latexname();
-
-		// Separate handling of optional argument inset.
-		if (style->optionalargs == 1) {
-			InsetOptArg * it = optArgInset(*pit);
-			if (it)
-				it->latexOptional(buf, os, false, false);
-		}
-		else
-			os << style->latexparam();
-		break;
-	case LATEX_ITEM_ENVIRONMENT:
-	case LATEX_LIST_ENVIRONMENT:
-		os << "\\item ";
-		break;
-	case LATEX_BIB_ENVIRONMENT:
-		// ignore this, the inset will write itself
-		break;
-	default:
-		break;
-	}
-
-	bool need_par = pit->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 =
-		(pit->empty()
-		 ? pit->getLayoutFont(bparams) : pit->getFont(bparams, pit->size() - 1));
-
-	bool is_command = style->isCommand();
-
-	if (style->resfont.size() != font.size() && pit->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 (pit->next() && (pit->params().depth() < pit->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 (pit->next()
-		    && (pit->next()->layout() != pit->layout()
-			|| pit->next()->params().depth() != pit->params().depth()))
-			break;
-		// fall through possible
-	default:
-		// we don't need it for the last paragraph!!!
-		if (pit->next()) {
-			os << '\n';
-			texrow.newline();
-		}
-	}
-
-	if ((in == 0) || !in->forceDefaultParagraphs(in)) {
-		further_blank_line = false;
-		if (pit->params().lineBottom()) {
-			os << "\\lyxline{\\" << font.latexSize() << '}';
-			further_blank_line = true;
-		}
-
-		if (pit->params().spaceBottom().kind() != VSpace::NONE) {
-			os << pit->params().spaceBottom().asLatexCommand(bparams);
-			further_blank_line = true;
-		}
-
-		if (pit->params().pagebreakBottom()) {
-			os << "\\newpage";
-			further_blank_line = true;
-		}
-
-		if (further_blank_line) {
-			os << '\n';
-			texrow.newline();
-		}
-
-		if (!pit->params().spacing().isDefault()
-			&& (!pit->next() || !pit->next()->hasSameLayout(&*pit))) {
-			os << pit->params().spacing().writeEnvirEnd() << '\n';
-			texrow.newline();
-		}
-	}
-
-	// we don't need it for the last paragraph!!!
-	if (pit->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 " << pit->next() << endl;
-	return ++pit;
+	return num;
 }