lyx_mirror/src/paragraph_funcs.C

/**
 * \file paragraph_funcs.C
 * This file is part of LyX, the document processor.
 * Licence details can be found in the file COPYING.
 *
 * \author Lars Gullik Bj<EFBFBD>nnes
 *
 * Full author contact details are available in file CREDITS.
 */

#include <config.h>

#include "paragraph_funcs.h"

#include "buffer.h"
#include "bufferparams.h"

#include "debug.h"
#include "encoding.h"
#include "errorlist.h"
#include "factory.h"
#include "gettext.h"
#include "iterators.h"
#include "language.h"
#include "latexrunparams.h"
#include "lyxlex.h"
#include "lyxrc.h"
#include "paragraph_pimpl.h"
#include "sgml.h"
#include "texrow.h"
#include "vspace.h"

#include "insets/insetbibitem.h"
#include "insets/insethfill.h"
#include "insets/insetlatexaccent.h"
#include "insets/insetline.h"
#include "insets/insetnewline.h"
#include "insets/insetpagebreak.h"
#include "insets/insetoptarg.h"
#include "insets/insetspace.h"
#include "insets/insetspecialchar.h"
#include "insets/insettabular.h"

#include "support/filetools.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
#include "support/std_sstream.h"

#include <vector>

using lyx::pos_type;

using lyx::support::ascii_lowercase;
using lyx::support::atoi;
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::endl;
using std::string;
using std::vector;
using std::istringstream;
using std::ostream;
using std::pair;

extern string bibitemWidest(Buffer const &);


namespace {

bool moveItem(Paragraph & from, Paragraph & to,
	BufferParams const & params, pos_type i, pos_type j)
{
	char const tmpchar = from.getChar(i);
	LyXFont tmpfont = from.getFontSettings(params, i);

	if (tmpchar == Paragraph::META_INSET) {
		InsetOld * tmpinset = 0;
		if (from.getInset(i)) {
			// the inset is not in a paragraph anymore
			tmpinset = from.insetlist.release(i);
		}

		if (!to.insetAllowed(tmpinset->lyxCode()))
			return false;
		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 & paragraphs,
		    ParagraphList::iterator par,
		    pos_type pos,
		    int flag)
{
	// create a new paragraph, and insert into the list
	ParagraphList::iterator tmp = paragraphs.insert(boost::next(par),
							Paragraph());

	// 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());

	if (bparams.tracking_changes)
		tmp->trackChanges();

	// this is an idea for a more userfriendly layout handling, I will
	// see what the users say

	// layout stays the same with latex-environments
	if (flag) {
		tmp->layout(par->layout());
		tmp->setLabelWidthString(par->params().labelWidthString());
	}

	bool const isempty = (par->allowEmpty() && 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());

		tmp->params().spaceBottom(par->params().spaceBottom());
		par->params().spaceBottom(VSpace(VSpace::NONE));

		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 ???
		 */
		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);
			if (moveItem(*par, *tmp, bparams, i, j - pos)) {
				tmp->setChange(j - pos, change);
				++j;
			}
		}

		for (i = pos_end; i >= pos; --i)
			par->eraseIntern(i);
	}

	if (pos)
		return;

	tmp->params().spaceTop(par->params().spaceTop());
	par->params().clear();

	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());
	}

	// subtle, but needed to get empty pars working right
	if (bparams.tracking_changes) {
		if (!par->size()) {
			par->cleanChanges();
		} else if (!tmp->size()) {
			tmp->cleanChanges();
		}
	}
}


void breakParagraphConservative(BufferParams const & bparams,
				ParagraphList & paragraphs,
				ParagraphList::iterator par,
				pos_type pos)
{
	// create a new paragraph
	ParagraphList::iterator tmp = paragraphs.insert(boost::next(par),
							Paragraph());
	tmp->makeSameLayout(*par);

	// 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;

		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);
	}
}


void mergeParagraph(BufferParams const & bparams,
		    ParagraphList & paragraphs,
		    ParagraphList::iterator par)
{
	ParagraphList::iterator the_next = boost::next(par);

	// first the DTP-stuff
	par->params().spaceBottom(the_next->params().spaceBottom());

	pos_type pos_end = the_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)
		if (moveItem(*the_next, *par, bparams, i, pos_insert + j))
			++j;

	paragraphs.erase(the_next);
}


ParagraphList::iterator depthHook(ParagraphList::iterator pit,
				  ParagraphList const & plist,
				  Paragraph::depth_type depth)
{
	ParagraphList::iterator newpit = pit;
	ParagraphList::iterator beg = const_cast<ParagraphList&>(plist).begin();

	if (newpit != beg)
		--newpit;

	while (newpit != beg && newpit->getDepth() > depth) {
		--newpit;
	}

	if (newpit->getDepth() > depth)
		return pit;

	return newpit;
}


ParagraphList::iterator outerHook(ParagraphList::iterator pit,
				  ParagraphList const & plist)
{
	if (!pit->getDepth())
		return const_cast<ParagraphList&>(plist).end();
	return depthHook(pit, plist,
			 Paragraph::depth_type(pit->getDepth() - 1));
}


bool isFirstInSequence(ParagraphList::iterator pit,
		       ParagraphList const & plist)
{
	ParagraphList::iterator dhook = depthHook(pit, plist, pit->getDepth());
	return (dhook == pit
		|| dhook->layout() != pit->layout()
		|| dhook->getDepth() != pit->getDepth());
}


int getEndLabel(ParagraphList::iterator p, ParagraphList const & plist)
{
	ParagraphList::iterator pit = p;
	Paragraph::depth_type par_depth = p->getDepth();
	while (pit != const_cast<ParagraphList&>(plist).end()) {
		LyXLayout_ptr const & layout = pit->layout();
		int const endlabeltype = layout->endlabeltype;

		if (endlabeltype != END_LABEL_NO_LABEL) {
			if (boost::next(p) == const_cast<ParagraphList&>(plist).end())
				return endlabeltype;

			Paragraph::depth_type const next_depth = boost::next(p)->getDepth();
			if (par_depth > next_depth ||
			    (par_depth == next_depth &&
			     layout != boost::next(p)->layout()))
				return endlabeltype;
			break;
		}
		if (par_depth == 0)
			break;
		pit = outerHook(pit, plist);
		if (pit != const_cast<ParagraphList&>(plist).end())
			par_depth = pit->getDepth();
	}
	return END_LABEL_NO_LABEL;
}


namespace {

ParagraphList::iterator
TeXEnvironment(Buffer const & buf,
	       ParagraphList const & paragraphs,
	       ParagraphList::iterator pit,
	       ostream & os, TexRow & texrow,
	       LatexRunParams const & runparams);

ParagraphList::iterator
TeXOnePar(Buffer const & buf,
	  ParagraphList const & paragraphs,
	  ParagraphList::iterator pit,
	  ostream & os, TexRow & texrow,
	  LatexRunParams const & runparams,
	  string const & everypar = string());


ParagraphList::iterator
TeXDeeper(Buffer const & buf,
	  ParagraphList const & paragraphs,
	  ParagraphList::iterator pit,
	  ostream & os, TexRow & texrow,
	  LatexRunParams const & runparams)
{
	lyxerr[Debug::LATEX] << "TeXDeeper...     " << &*pit << endl;
	ParagraphList::iterator par = pit;

	while (par != const_cast<ParagraphList&>(paragraphs).end() &&
		     par->params().depth() == pit->params().depth()) {
		if (par->layout()->isEnvironment()) {
			par = TeXEnvironment(buf, paragraphs, par,
					     os, texrow, runparams);
		} else {
			par = TeXOnePar(buf, paragraphs, par,
					     os, texrow, runparams);
		}
	}
	lyxerr[Debug::LATEX] << "TeXDeeper...done " << &*par << endl;

	return par;
}


ParagraphList::iterator
TeXEnvironment(Buffer const & buf,
	       ParagraphList const & paragraphs,
	       ParagraphList::iterator pit,
	       ostream & os, TexRow & texrow,
	       LatexRunParams const & runparams)
{
	lyxerr[Debug::LATEX] << "TeXEnvironment...     " << &*pit << endl;

	BufferParams const & bparams = buf.params();

	LyXLayout_ptr const & style = pit->layout();

	Language const * language = pit->getParLanguage(bparams);
	Language const * doc_language = bparams.language;
	Language const * previous_language =
		(pit != const_cast<ParagraphList&>(paragraphs).begin())
		? boost::prior(pit)->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 (!pit->params().leftIndent().zero()) {
		os << "\\begin{LyXParagraphLeftIndent}{" <<
			pit->params().leftIndent().asLatexString() << "}\n";
		texrow.newline();
		leftindent_open = true;
	}

	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, paragraphs, par, os, texrow, runparams);

		if (par != const_cast<ParagraphList&>(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, paragraphs, par, os, texrow,
					runparams);
		}
	} while (par != const_cast<ParagraphList&>(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
}


InsetOptArg * optArgInset(Paragraph const & par)
{
	// Find the entry.
	InsetList::const_iterator it = par.insetlist.begin();
	InsetList::const_iterator end = par.insetlist.end();
	for (; it != end; ++it) {
		InsetOld * ins = it->inset;
		if (ins->lyxCode() == InsetOld::OPTARG_CODE) {
			return static_cast<InsetOptArg *>(ins);
		}
	}
	return 0;
}


ParagraphList::iterator
TeXOnePar(Buffer const & buf,
	  ParagraphList const & paragraphs,
	  ParagraphList::iterator pit,
	  ostream & os, TexRow & texrow,
	  LatexRunParams const & runparams,
	  string const & everypar)
{
	lyxerr[Debug::LATEX] << "TeXOnePar...     " << &*pit << " '"
		<< everypar << "'" << endl;
	BufferParams const & bparams = buf.params();

	InsetOld 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
	// length (all in one row) if that is true then we don't allow
	// any special options in the paragraph and also we don't allow
	// any environment other 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 == const_cast<ParagraphList&>(paragraphs).begin()
			    || !boost::prior(pit)->hasSameLayout(*pit)))
		{
			os << pit->params().spacing().writeEnvirBegin() << '\n';
			texrow.newline();
		}

		if (style->isCommand()) {
			os << '\n';
			texrow.newline();
		}

		if (pit->params().spaceTop().kind() != VSpace::NONE) {
			os << pit->params().spaceTop().asLatexCommand(bparams);
			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 != const_cast<ParagraphList&>(paragraphs).begin())
		? boost::prior(pit)->getParLanguage(bparams)
		: doc_language;

	if (language->babel() != previous_language->babel()
	    // check if we already put language command in TeXEnvironment()
	    && !(style->isEnvironment()
		 && (pit == const_cast<ParagraphList&>(paragraphs).begin() ||
		     (boost::prior(pit)->layout() != pit->layout() &&
		      boost::prior(pit)->getDepth() <= pit->getDepth())
		     || boost::prior(pit)->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, runparams);
		}
		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;
	}

	os << everypar;
	bool need_par = pit->simpleTeXOnePar(buf, bparams,
					     outerFont(pit, paragraphs),
					     os, texrow, runparams);

	// 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 outerfont(outerFont(pit, paragraphs));

	LyXFont const font =
		(pit->empty()
		 ? pit->getLayoutFont(bparams, outerfont)
		 : pit->getFont(bparams, pit->size() - 1, outerfont));

	bool is_command = style->isCommand();

	if (style->resfont.size() != font.size()
	    && boost::next(pit) != const_cast<ParagraphList&>(paragraphs).end()
	    && !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 (boost::next(pit) != const_cast<ParagraphList&>(paragraphs).end()
		    && (pit->params().depth() < boost::next(pit)->params().depth())) {
			os << '\n';
			texrow.newline();
		}
		break;
	case LATEX_ENVIRONMENT: {
		// if its the last paragraph of the current environment
		// skip it otherwise fall through
		ParagraphList::iterator next = boost::next(pit);

		if (next != const_cast<ParagraphList&>(paragraphs).end()
		    && (next->layout() != pit->layout()
			|| next->params().depth() != pit->params().depth()))
			break;
	}

		// fall through possible
	default:
		// we don't need it for the last paragraph!!!
		if (boost::next(pit) != const_cast<ParagraphList&>(paragraphs).end()) {
			os << '\n';
			texrow.newline();
		}
	}

	if (in == 0 || !in->forceDefaultParagraphs(in)) {
		further_blank_line = false;

		if (pit->params().spaceBottom().kind() != VSpace::NONE) {
			os << pit->params().spaceBottom().asLatexCommand(bparams);
			further_blank_line = true;
		}

		if (further_blank_line) {
			os << '\n';
			texrow.newline();
		}

		if (!pit->params().spacing().isDefault()
			&& (boost::next(pit) == const_cast<ParagraphList&>(paragraphs).end()
			    || !boost::next(pit)->hasSameLayout(*pit)))
		{
			os << pit->params().spacing().writeEnvirEnd() << '\n';
			texrow.newline();
		}
	}

	// we don't need it for the last paragraph!!!
	if (boost::next(pit) != const_cast<ParagraphList&>(paragraphs).end()) {
		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 " << &*boost::next(pit) << endl;
	return ++pit;
}

} // anon namespace


//
// LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end
//
void latexParagraphs(Buffer const & buf,
		     ParagraphList const & paragraphs,
		     ostream & os,
		     TexRow & texrow,
		     LatexRunParams const & runparams,
		     string const & everypar)
{
	bool was_title = false;
	bool already_title = false;
	LyXTextClass const & tclass = buf.params().getLyXTextClass();
	ParagraphList::iterator par = const_cast<ParagraphList&>(paragraphs).begin();
	ParagraphList::iterator endpar = const_cast<ParagraphList&>(paragraphs).end();

	// if only_body
	while (par != endpar) {
		InsetOld * in = par->inInset();
		// well we have to check if we are in an inset with unlimited
		// length (all in one row) if that is true then we don't allow
		// any special options in the paragraph and also we don't allow
		// any environment other then "Standard" to be valid!
		if (in == 0 || !in->forceDefaultParagraphs(in)) {
			LyXLayout_ptr const & layout = par->layout();

			if (layout->intitle) {
				if (already_title) {
					lyxerr <<"Error in latexParagraphs: You"
						" should not mix title layouts"
						" with normal ones." << endl;
				} else if (!was_title) {
					was_title = true;
					if (tclass.titletype() == TITLE_ENVIRONMENT) {
						os << "\\begin{"
						    << tclass.titlename()
						    << "}\n";
						texrow.newline();
					}
				}
			} else if (was_title && !already_title) {
				if (tclass.titletype() == TITLE_ENVIRONMENT) {
					os << "\\end{" << tclass.titlename()
					    << "}\n";
				}
				else {
					os << "\\" << tclass.titlename()
					    << "\n";
				}
				texrow.newline();
				already_title = true;
				was_title = false;
			}

			if (layout->is_environment) {
				par = TeXOnePar(buf, paragraphs, par, os, texrow,
				                runparams, everypar);
			} else if (layout->isEnvironment() ||
				!par->params().leftIndent().zero())
			{
				par = TeXEnvironment(buf, paragraphs, par, os,
						     texrow, runparams);
			} else {
				par = TeXOnePar(buf, paragraphs, par, os, texrow,
				                runparams, everypar);
			}
		} else {
			par = TeXOnePar(buf, paragraphs, par, os, texrow,
			                runparams, everypar);
		}
	}
	// It might be that we only have a title in this document
	if (was_title && !already_title) {
		if (tclass.titletype() == TITLE_ENVIRONMENT) {
			os << "\\end{" << tclass.titlename()
			    << "}\n";
		}
		else {
			os << "\\" << tclass.titlename()
			    << "\n";
				}
		texrow.newline();
	}
}


namespace {

pair<int, string> const addDepth(int depth, int ldepth)
{
	int d = depth * 2;
	if (ldepth > depth)
		d += (ldepth - depth) * 2;
	return make_pair(d, string(d, ' '));
}

}


void asciiParagraph(Buffer const & buf,
		    Paragraph const & par,
		    ostream & os,
		    LatexRunParams const & runparams,
		    bool noparbreak)
{
	int ltype = 0;
	Paragraph::depth_type ltype_depth = 0;
	bool ref_printed = false;
	Paragraph::depth_type depth = par.params().depth();

	// First write the layout
	string const & tmp = par.layout()->name();
	if (compare_no_case(tmp, "itemize") == 0) {
		ltype = 1;
		ltype_depth = depth + 1;
	} else if (compare_ascii_no_case(tmp, "enumerate") == 0) {
		ltype = 2;
		ltype_depth = depth + 1;
	} else if (contains(ascii_lowercase(tmp), "ection")) {
		ltype = 3;
		ltype_depth = depth + 1;
	} else if (contains(ascii_lowercase(tmp), "aragraph")) {
		ltype = 4;
		ltype_depth = depth + 1;
	} else if (compare_ascii_no_case(tmp, "description") == 0) {
		ltype = 5;
		ltype_depth = depth + 1;
	} else if (compare_ascii_no_case(tmp, "abstract") == 0) {
		ltype = 6;
		ltype_depth = 0;
	} else if (compare_ascii_no_case(tmp, "bibliography") == 0) {
		ltype = 7;
		ltype_depth = 0;
	} else {
		ltype = 0;
		ltype_depth = 0;
	}

	/* maybe some vertical spaces */

	/* the labelwidthstring used in lists */

	/* some lines? */

	/* some pagebreaks? */

	/* noindent ? */

	/* what about the alignment */

	// runparams.linelen <= 0 is special and means we don't have paragraph breaks

	string::size_type currlinelen = 0;

	if (!noparbreak) {
		if (runparams.linelen > 0)
			os << "\n\n";

		os << string(depth * 2, ' ');
		currlinelen += depth * 2;

		//--
		// we should probably change to the paragraph language in the
		// gettext here (if possible) so that strings are outputted in
		// the correct language! (20012712 Jug)
		//--
		switch (ltype) {
		case 0: // Standard
		case 4: // (Sub)Paragraph
		case 5: // Description
			break;
		case 6: // Abstract
			if (runparams.linelen > 0) {
				os << _("Abstract") << "\n\n";
				currlinelen = 0;
			} else {
				string const abst = _("Abstract: ");
				os << abst;
				currlinelen += abst.length();
			}
			break;
		case 7: // Bibliography
			if (!ref_printed) {
				if (runparams.linelen > 0) {
					os << _("References") << "\n\n";
					currlinelen = 0;
				} else {
					string const refs = _("References: ");
					os << refs;
					currlinelen += refs.length();
				}

				ref_printed = true;
			}
			break;
		default:
		{
			string const parlab = par.params().labelString();
			os << parlab << ' ';
			currlinelen += parlab.length() + 1;
		}
		break;

		}
	}

	if (!currlinelen) {
		pair<int, string> p = addDepth(depth, ltype_depth);
		os << p.second;
		currlinelen += p.first;
	}

	// this is to change the linebreak to do it by word a bit more
	// intelligent hopefully! (only in the case where we have a
	// max runparams.linelength!) (Jug)

	string word;

	for (pos_type i = 0; i < par.size(); ++i) {
		char c = par.getUChar(buf.params(), i);
		switch (c) {
		case Paragraph::META_INSET:
		{
			InsetOld const * inset = par.getInset(i);
			if (inset) {
				if (runparams.linelen > 0) {
					os << word;
					currlinelen += word.length();
					word.erase();
				}
				if (inset->ascii(buf, os, runparams)) {
					// to be sure it breaks paragraph
					currlinelen += runparams.linelen;
				}
			}
		}
		break;

		default:
			if (c == ' ') {
				if (runparams.linelen > 0 &&
				    currlinelen + word.length() > runparams.linelen - 10) {
					os << "\n";
					pair<int, string> p = addDepth(depth, ltype_depth);
					os << p.second;
					currlinelen = p.first;
				}

				os << word << ' ';
				currlinelen += word.length() + 1;
				word.erase();

			} else {
				if (c != '\0') {
					word += c;
				} else {
					lyxerr[Debug::INFO] <<
						"writeAsciiFile: NULL char in structure." << endl;
				}
				if ((runparams.linelen > 0) &&
					(currlinelen + word.length()) > runparams.linelen)
				{
					os << "\n";

					pair<int, string> p =
						addDepth(depth, ltype_depth);
					os << p.second;
					currlinelen = p.first;
				}
			}
			break;
		}
	}
	os << word;
}


void linuxdocParagraphs(Buffer const & buf,
			ParagraphList const & paragraphs,
			ostream & os,
			LatexRunParams const & runparams)
{
	
	Paragraph::depth_type depth = 0; // paragraph depth
	string item_name;
	vector<string> environment_stack(5);

	ParagraphList::iterator pit = const_cast<ParagraphList&>(paragraphs).begin();
	ParagraphList::iterator pend = const_cast<ParagraphList&>(paragraphs).end();
	for (; pit != pend; ++pit) {
		LyXLayout_ptr const & style = pit->layout();
		// treat <toc> as a special case for compatibility with old code
		if (pit->isInset(0)) {
			InsetOld * inset = pit->getInset(0);
			InsetOld::Code lyx_code = inset->lyxCode();
			if (lyx_code == InsetOld::TOC_CODE) {
				string const temp = "toc";
				sgml::openTag(os, depth, false, temp);
				continue;
			}
		}

		// environment tag closing
		for (; depth > pit->params().depth(); --depth) {
			sgml::closeTag(os, depth, false, environment_stack[depth]);
			environment_stack[depth].erase();
		}

		// write opening SGML tags
		switch (style->latextype) {
		case LATEX_PARAGRAPH:
			if (depth == pit->params().depth()
			   && !environment_stack[depth].empty()) {
				sgml::closeTag(os, depth, false, environment_stack[depth]);
				environment_stack[depth].erase();
				if (depth)
					--depth;
				else
					os << "</p>";
			}
			sgml::openTag(os, depth, false, style->latexname());
			break;

		case LATEX_COMMAND:
			if (depth != 0)
				//error(ErrorItem(_("Error:"), _("Wrong depth for LatexType Command.\n"), pit->id(), 0, pit->size()));
				;

			if (!environment_stack[depth].empty()) {
				sgml::closeTag(os, depth, false, environment_stack[depth]);
				os << "</p>";
			}

			environment_stack[depth].erase();
			sgml::openTag(os, depth, false, style->latexname());
			break;

		case LATEX_ENVIRONMENT:
		case LATEX_ITEM_ENVIRONMENT:
		case LATEX_BIB_ENVIRONMENT:
		{
			string const & latexname = style->latexname();

			if (depth == pit->params().depth()
			    && environment_stack[depth] != latexname) {
				sgml::closeTag(os, depth, false,
					     environment_stack[depth]);
				environment_stack[depth].erase();
			}
			if (depth < pit->params().depth()) {
			       depth = pit->params().depth();
			       environment_stack[depth].erase();
			}
			if (environment_stack[depth] != latexname) {
				if (depth == 0) {
					sgml::openTag(os, depth, false, "p");
				}
				sgml::openTag(os, depth, false, latexname);

				if (environment_stack.size() == depth + 1)
					environment_stack.push_back("!-- --");
				environment_stack[depth] = latexname;
			}

			if (style->latexparam() == "CDATA")
				os << "<![CDATA[";

			if (style->latextype == LATEX_ENVIRONMENT) break;

			if (style->labeltype == LABEL_MANUAL)
				item_name = "tag";
			else
				item_name = "item";

			sgml::openTag(os, depth + 1, false, item_name);
		}
		break;

		default:
			sgml::openTag(os, depth, false, style->latexname());
			break;
		}

		pit->simpleLinuxDocOnePar(buf, os, outerFont(pit, paragraphs),
					  runparams, depth);

		os << "\n";
		// write closing SGML tags
		switch (style->latextype) {
		case LATEX_COMMAND:
			break;
		case LATEX_ENVIRONMENT:
		case LATEX_ITEM_ENVIRONMENT:
		case LATEX_BIB_ENVIRONMENT:
			if (style->latexparam() == "CDATA")
				os << "]]>";
			break;
		default:
			sgml::closeTag(os, depth, false, style->latexname());
			break;
		}
	}

	// Close open tags
	for (int i = depth; i >= 0; --i)
		sgml::closeTag(os, depth, false, environment_stack[i]);
}


void docbookParagraphs(Buffer const & buf,
		       ParagraphList const & paragraphs,
		       ostream & os,
		       LatexRunParams const & runparams)
{
	vector<string> environment_stack(10);
	vector<string> environment_inner(10);
	vector<string> command_stack(10);

	bool command_flag = false;
	Paragraph::depth_type command_depth = 0;
	Paragraph::depth_type command_base = 0;
	Paragraph::depth_type cmd_depth = 0;
	Paragraph::depth_type depth = 0; // paragraph depth

	string item_name;
	string command_name;

	ParagraphList::iterator par = const_cast<ParagraphList&>(paragraphs).begin();
	ParagraphList::iterator pend = const_cast<ParagraphList&>(paragraphs).end();

	for (; par != pend; ++par) {
		string sgmlparam;
		string c_depth;
		string c_params;
		int desc_on = 0; // description mode

		LyXLayout_ptr const & style = par->layout();

		// environment tag closing
		for (; depth > par->params().depth(); --depth) {
			if (!environment_inner[depth].empty()) 
			sgml::closeEnvTags(os, false, environment_inner[depth], 
					command_depth + depth);
			sgml::closeTag(os, depth + command_depth, false, environment_stack[depth]);
			environment_stack[depth].erase();
			environment_inner[depth].erase();
		}

		if (depth == par->params().depth()
		   && environment_stack[depth] != style->latexname()
		   && !environment_stack[depth].empty()) {
				sgml::closeEnvTags(os, false, environment_inner[depth], 
					command_depth + depth);
			sgml::closeTag(os, depth + command_depth, false, environment_stack[depth]);

			environment_stack[depth].erase();
			environment_inner[depth].erase();
		}

		// Write opening SGML tags.
		switch (style->latextype) {
		case LATEX_PARAGRAPH:
			sgml::openTag(os, depth + command_depth,
				    false, style->latexname());
			break;

		case LATEX_COMMAND:
			if (depth != 0)
				//error(ErrorItem(_("Error"), _("Wrong depth for LatexType Command."), par->id(), 0, par->size()));
				;
			
			command_name = style->latexname();

			sgmlparam = style->latexparam();
			c_params = split(sgmlparam, c_depth,'|');

			cmd_depth = atoi(c_depth);

			if (command_flag) {
				if (cmd_depth < command_base) {
					for (Paragraph::depth_type j = command_depth;
					     j >= command_base; --j) {
						sgml::closeTag(os, j, false, command_stack[j]);
						os << endl;
					}
					command_depth = command_base = cmd_depth;
				} else if (cmd_depth <= command_depth) {
					for (int j = command_depth;
					     j >= int(cmd_depth); --j) {
						sgml::closeTag(os, j, false, command_stack[j]);
						os << endl;
					}
					command_depth = cmd_depth;
				} else
					command_depth = cmd_depth;
			} else {
				command_depth = command_base = cmd_depth;
				command_flag = true;
			}
			if (command_stack.size() == command_depth + 1)
				command_stack.push_back(string());
			command_stack[command_depth] = command_name;

			// treat label as a special case for
			// more WYSIWYM handling.
			// This is a hack while paragraphs can't have
			// attributes, like id in this case.
			if (par->isInset(0)) {
				InsetOld * inset = par->getInset(0);
				InsetOld::Code lyx_code = inset->lyxCode();
				if (lyx_code == InsetOld::LABEL_CODE) {
					command_name += " id=\"";
					command_name += (static_cast<InsetCommand *>(inset))->getContents();
					command_name += '"';
					desc_on = 3;
				}
			}

			sgml::openTag(os, depth + command_depth, false, command_name);

			item_name = c_params.empty() ? "title" : c_params;
			sgml::openTag(os, depth + 1 + command_depth, false, item_name);
			break;

		case LATEX_ENVIRONMENT:
		case LATEX_ITEM_ENVIRONMENT:
			if (depth < par->params().depth()) {
				depth = par->params().depth();
				environment_stack[depth].erase();
			}

			if (environment_stack[depth] != style->latexname()) {
				if (environment_stack.size() == depth + 1) {
					environment_stack.push_back("!-- --");
					environment_inner.push_back("!-- --");
				}
				environment_stack[depth] = style->latexname();
				environment_inner[depth] = "!-- --";
				sgml::openTag(os, depth + command_depth, false, environment_stack[depth]);
			} else {
					sgml::closeEnvTags(os, false, environment_inner[depth], 
						command_depth + depth);
			}

			if (style->latextype == LATEX_ENVIRONMENT) {
				if (!style->latexparam().empty()) {
					if (style->latexparam() == "CDATA")
						os << "<![CDATA[";
					else
						sgml::openTag(os, depth + command_depth, false, style->latexparam());
				}
				break;
			}

			desc_on = (style->labeltype == LABEL_MANUAL);

			environment_inner[depth] = desc_on ? "varlistentry" : "listitem";
			sgml::openTag(os, depth + 1 + command_depth,
				    false, environment_inner[depth]);

			item_name = desc_on ? "term" : "para";
			sgml::openTag(os, depth + 1 + command_depth,
				    false, item_name);
			break;
		default:
			sgml::openTag(os, depth + command_depth,
				    false, style->latexname());
			break;
		}

		par->simpleDocBookOnePar(buf, os, outerFont(par, paragraphs), desc_on,
					 runparams, depth + 1 + command_depth);

		string end_tag;
		// write closing SGML tags
		switch (style->latextype) {
		case LATEX_COMMAND:
			end_tag = c_params.empty() ? "title" : c_params;
			sgml::closeTag(os, depth + command_depth,
				     false, end_tag);
			break;
		case LATEX_ENVIRONMENT:
			if (!style->latexparam().empty()) {
				if (style->latexparam() == "CDATA")
					os << "]]>";
				else
					sgml::closeTag(os, depth + command_depth, false, style->latexparam());
			}
			break;
		case LATEX_ITEM_ENVIRONMENT:
			if (desc_on == 1) break;
			end_tag = "para";
			sgml::closeTag(os, depth + 1 + command_depth, false, end_tag);
			break;
		case LATEX_PARAGRAPH:
			sgml::closeTag(os, depth + command_depth, false, style->latexname());
			break;
		default:
			sgml::closeTag(os, depth + command_depth, false, style->latexname());
			break;
		}
	}

	// Close open tags
	for (int d = depth; d >= 0; --d) {
		if (!environment_stack[depth].empty()) {
				sgml::closeEnvTags(os, false, environment_inner[depth], 
					command_depth + depth);
		}
	}

	for (int j = command_depth; j >= 0 ; --j)
		if (!command_stack[j].empty()) {
			sgml::closeTag(os, j, false, command_stack[j]);
			os << endl;
		}
}

namespace {

int readParToken(Buffer & buf, Paragraph & par, LyXLex & lex, string const & token)
{
	static LyXFont font;
	static Change change;

	BufferParams const & bp = buf.params();

	if (token[0] != '\\') {
		string::const_iterator cit = token.begin();
		for (; cit != token.end(); ++cit) {
			par.insertChar(par.size(), (*cit), font, change);
		}
	} else if (token == "\\begin_layout") {
		lex.eatLine();
		string layoutname = lex.getString();

		font = LyXFont(LyXFont::ALL_INHERIT, bp.language);
		change = Change();

		LyXTextClass const & tclass = bp.getLyXTextClass();

		if (layoutname.empty()) {
			layoutname = tclass.defaultLayoutName();
		}

		bool hasLayout = tclass.hasLayout(layoutname);

		if (!hasLayout) {
			lyxerr << "Layout '" << layoutname << "' does not"
			       << " exist in textclass '" << tclass.name()
			       << "'." << endl;
			lyxerr << "Trying to use default layout instead."
			       << endl;
			layoutname = tclass.defaultLayoutName();
		}

		par.layout(bp.getLyXTextClass()[layoutname]);

		// Test whether the layout is obsolete.
		LyXLayout_ptr const & layout = par.layout();
		if (!layout->obsoleted_by().empty())
			par.layout(bp.getLyXTextClass()[layout->obsoleted_by()]);

		par.params().read(lex);

	} else if (token == "\\end_layout") {
		lyxerr << "Solitary \\end_layout in line " << lex.getLineNo() << "\n"
		       << "Missing \\begin_layout?.\n";
	} else if (token == "\\end_inset") {
		lyxerr << "Solitary \\end_inset in line " << lex.getLineNo() << "\n"
		       << "Missing \\begin_inset?.\n";
	} else if (token == "\\begin_inset") {
		InsetOld * inset = readInset(lex, buf);
		if (inset)
			par.insertInset(par.size(), inset, font, change);
		else {
			lex.eatLine();
			string line = lex.getString();
			buf.error(ErrorItem(_("Unknown Inset"), line,
					    buf.paragraphs().back().id(),
					    0, par.size()));
			return 1;
		}
	} else if (token == "\\family") {
		lex.next();
		font.setLyXFamily(lex.getString());
	} else if (token == "\\series") {
		lex.next();
		font.setLyXSeries(lex.getString());
	} else if (token == "\\shape") {
		lex.next();
		font.setLyXShape(lex.getString());
	} else if (token == "\\size") {
		lex.next();
		font.setLyXSize(lex.getString());
	} else if (token == "\\lang") {
		lex.next();
		string const tok = lex.getString();
		Language const * lang = languages.getLanguage(tok);
		if (lang) {
			font.setLanguage(lang);
		} else {
			font.setLanguage(bp.language);
			lex.printError("Unknown language `$$Token'");
		}
	} else if (token == "\\numeric") {
		lex.next();
		font.setNumber(font.setLyXMisc(lex.getString()));
	} else if (token == "\\emph") {
		lex.next();
		font.setEmph(font.setLyXMisc(lex.getString()));
	} else if (token == "\\bar") {
		lex.next();
		string const tok = lex.getString();

		if (tok == "under")
			font.setUnderbar(LyXFont::ON);
		else if (tok == "no")
			font.setUnderbar(LyXFont::OFF);
		else if (tok == "default")
			font.setUnderbar(LyXFont::INHERIT);
		else
			lex.printError("Unknown bar font flag "
				       "`$$Token'");
	} else if (token == "\\noun") {
		lex.next();
		font.setNoun(font.setLyXMisc(lex.getString()));
	} else if (token == "\\color") {
		lex.next();
		font.setLyXColor(lex.getString());
	} else if (token == "\\InsetSpace" || token == "\\SpecialChar") {

		// Insets don't make sense in a free-spacing context! ---Kayvan
		if (par.isFreeSpacing()) {
			if (token == "\\InsetSpace")
				par.insertChar(par.size(), ' ', font, change);
			else if (lex.isOK()) {
				lex.next();
				string const next_token = lex.getString();
				if (next_token == "\\-")
					par.insertChar(par.size(), '-', font, change);
				else {
					lex.printError("Token `$$Token' "
						       "is in free space "
						       "paragraph layout!");
				}
			}
		} else {
			InsetOld * inset = 0;
			if (token == "\\SpecialChar" )
				inset = new InsetSpecialChar;
			else
				inset = new InsetSpace;
			inset->read(buf, lex);
			par.insertInset(par.size(), inset, font, change);
		}
	} else if (token == "\\i") {
		InsetOld * inset = new InsetLatexAccent;
		inset->read(buf, lex);
		par.insertInset(par.size(), inset, font, change);
	} else if (token == "\\backslash") {
		par.insertChar(par.size(), '\\', font, change);
	} else if (token == "\\newline") {
		InsetOld * inset = new InsetNewline;
		inset->read(buf, lex);
		par.insertInset(par.size(), inset, font, change);
	} else if (token == "\\LyXTable") {
		InsetOld * inset = new InsetTabular(buf);
		inset->read(buf, lex);
		par.insertInset(par.size(), inset, font, change);
	} else if (token == "\\bibitem") {
		InsetCommandParams p("bibitem", "dummy");
		InsetBibitem * inset = new InsetBibitem(p);
		inset->read(buf, lex);
		par.insertInset(par.size(), inset, font, change);
	} else if (token == "\\hfill") {
		par.insertInset(par.size(), new InsetHFill, font, change);
	} else if (token == "\\lyxline") {
		par.insertInset(par.size(), new InsetLine, font, change);
	} else if (token == "\\newpage") {
		par.insertInset(par.size(), new InsetPagebreak, font, change);
	} else if (token == "\\change_unchanged") {
		// Hack ! Needed for empty paragraphs :/
		// FIXME: is it still ??
		if (!par.size())
			par.cleanChanges();
		change = Change(Change::UNCHANGED);
	} else if (token == "\\change_inserted") {
		lex.nextToken();
		istringstream is(lex.getString());
		int aid;
		lyx::time_type ct;
		is >> aid >> ct;
		change = Change(Change::INSERTED, bp.author_map[aid], ct);
	} else if (token == "\\change_deleted") {
		lex.nextToken();
		istringstream is(lex.getString());
		int aid;
		lyx::time_type ct;
		is >> aid >> ct;
		change = Change(Change::DELETED, bp.author_map[aid], ct);
	} else {
		lex.eatLine();
		string const s = bformat(_("Unknown token: %1$s %2$s\n"),
			token, lex.getString());

		buf.error(ErrorItem(_("Unknown token"), s,
				    buf.paragraphs().back().id(),
				    0, par.size()));
		return 1;
	}
	return 0;
}

}


int readParagraph(Buffer & buf, Paragraph & par, LyXLex & lex)
{
	int unknown = 0;

	lex.nextToken();
	string token = lex.getString();

	while (lex.isOK()) {

		unknown += readParToken(buf, par, lex, token);

		lex.nextToken();
		token = lex.getString();

		if (token.empty())
			continue;

		if (token == "\\end_layout") {
			//Ok, paragraph finished
			break;
		}

		lyxerr[Debug::PARSER] << "Handling paragraph token: `"
				      << token << '\'' << endl;
		if (token == "\\begin_layout" || token == "\\end_document"
		    || token == "\\end_inset" || token == "\\begin_deeper"
		    || token == "\\end_deeper") {
			lex.pushToken(token);
			lyxerr << "Paragraph ended in line "
			       << lex.getLineNo() << "\n"
			       << "Missing \\end_layout.\n";
			break;
		}
	}

	return unknown;
}


LyXFont const outerFont(ParagraphList::iterator pit,
			ParagraphList const & plist)
{
	Paragraph::depth_type par_depth = pit->getDepth();
	LyXFont tmpfont(LyXFont::ALL_INHERIT);

	// Resolve against environment font information
	while (pit != const_cast<ParagraphList&>(plist).end() &&
	       par_depth && !tmpfont.resolved()) {
		pit = outerHook(pit, plist);
		if (pit != const_cast<ParagraphList&>(plist).end()) {
			tmpfont.realize(pit->layout()->font);
			par_depth = pit->getDepth();
		}
	}

	return tmpfont;
}


ParagraphList::iterator outerPar(Buffer const & buf, InsetOld const * inset)
{
	ParIterator pit = const_cast<Buffer &>(buf).par_iterator_begin();
	ParIterator end = const_cast<Buffer &>(buf).par_iterator_end();
	for ( ; pit != end; ++pit) {

		ParagraphList * plist;
		// the second '=' below is intentional
		for (int i = 0; (plist = inset->getParagraphs(i)); ++i)
			if (plist == &pit.plist())
				return pit.outerPar();

		InsetList::iterator ii = pit->insetlist.begin();
		InsetList::iterator iend = pit->insetlist.end();
		for ( ; ii != iend; ++ii)
			if (ii->inset == inset)
				return pit.outerPar();
	}
	lyxerr << "outerPar: should not happen" << endl;
	BOOST_ASSERT(false);
	return const_cast<Buffer &>(buf).paragraphs().end(); // shut up compiler
}


Paragraph const & ownerPar(Buffer const & buf, InsetOld const * inset)
{
	ParConstIterator pit = buf.par_iterator_begin();
	ParConstIterator end = buf.par_iterator_end();
	for ( ; pit != end; ++pit) {
		ParagraphList * plist;
		// the second '=' below is intentional
		for (int i = 0; (plist = inset->getParagraphs(i)); ++i)
			if (plist == &pit.plist())
				return *pit.pit();

		InsetList::const_iterator ii = pit->insetlist.begin();
		InsetList::const_iterator iend = pit->insetlist.end();
		for ( ; ii != iend; ++ii)
			if (ii->inset == inset)
				return *pit.pit();
	}
	lyxerr << "ownerPar: should not happen" << endl;
	BOOST_ASSERT(false);
	return buf.paragraphs().front(); // shut up compiler
}