X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=227568b43f2067155a02c48d60358c590768753c;hb=37d42d45f3f4a5d3e916a080af50b37ae4a9d118;hp=32be0295c65e3403a1205603541c9b13e2830528;hpb=5be51b4fb77a6b13170d180f32d69745714b0b8e;p=lyx.git

diff --git a/src/paragraph.C b/src/paragraph.C
index 32be0295c6..227568b43f 100644
--- a/src/paragraph.C
+++ b/src/paragraph.C
@@ -22,14 +22,19 @@
 
 #include "buffer.h"
 #include "bufferparams.h"
+#include "counters.h"
 #include "encoding.h"
 #include "debug.h"
 #include "gettext.h"
 #include "language.h"
-#include "latexrunparams.h"
+#include "LaTeXFeatures.h"
 #include "lyxfont.h"
 #include "lyxrc.h"
 #include "lyxrow.h"
+#include "outputparams.h"
+#include "paragraph_funcs.h"
+#include "ParagraphList_fwd.h"
+#include "sgml.h"
 #include "texrow.h"
 #include "vspace.h"
 
@@ -38,74 +43,83 @@
 
 #include "support/lstrings.h"
 #include "support/textutils.h"
-#include "support/std_sstream.h"
+#include "support/convert.h"
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/bind.hpp>
+
+#include <algorithm>
+#include <list>
+#include <stack>
+#include <sstream>
 
 using lyx::pos_type;
 
-using lyx::support::contains;
 using lyx::support::subst;
 
+using std::distance;
 using std::endl;
+using std::list;
+using std::stack;
 using std::string;
 using std::ostream;
 using std::ostringstream;
 
 
+ParagraphList::ParagraphList()
+{}
+
+
 Paragraph::Paragraph()
-	: y(0), height(0), pimpl_(new Paragraph::Pimpl(this))
+	: begin_of_body_(0), pimpl_(new Paragraph::Pimpl(this))
 {
 	itemdepth = 0;
 	params().clear();
 }
 
 
-Paragraph::Paragraph(Paragraph const & lp)
-	: y(0), height(0), text_(lp.text_), pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
+Paragraph::Paragraph(Paragraph const & par)
+	:	itemdepth(par.itemdepth), insetlist(par.insetlist),
+		dim_(par.dim_),
+		rows_(par.rows_), rowSignature_(par.rowSignature_), 
+		layout_(par.layout_),
+		text_(par.text_), begin_of_body_(par.begin_of_body_),
+	  pimpl_(new Paragraph::Pimpl(*par.pimpl_, this))
 {
-	itemdepth = 0;
-	// this is because of the dummy layout of the paragraphs that
-	// follow footnotes
-	layout_ = lp.layout();
-
-	// copy everything behind the break-position to the new paragraph
-	insetlist = lp.insetlist;
+	//lyxerr << "Paragraph::Paragraph(Paragraph const&)" << endl;
 	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());
-	}
+	for (; it != end; ++it)
+		it->inset = it->inset->clone().release();
 }
 
 
-void Paragraph::operator=(Paragraph const & lp)
+Paragraph & Paragraph::operator=(Paragraph const & par)
 {
 	// needed as we will destroy the pimpl_ before copying it
-	if (&lp != this)
-		return;
-
-	lyxerr << "Paragraph::operator=()" << endl;
-
-	text_ = lp.text_;
-
-	delete pimpl_;
-	pimpl_ = new Pimpl(*lp.pimpl_, this);
-
-	itemdepth = lp.itemdepth;
-	// this is because of the dummy layout of the paragraphs that
-	// follow footnotes
-	layout_ = lp.layout();
-
-	// copy everything behind the break-position to the new paragraph
-	insetlist = lp.insetlist;
-	InsetList::iterator it = insetlist.begin();
-	InsetList::iterator end = insetlist.end();
-	for (; it != end; ++it) {
-		it->inset = static_cast<InsetOld*>(it->inset->clone().release());
+	if (&par != this) {
+		itemdepth = par.itemdepth;
+
+		insetlist = par.insetlist;
+		InsetList::iterator it = insetlist.begin();
+		InsetList::iterator end = insetlist.end();
+		for (; it != end; ++it)
+			it->inset = it->inset->clone().release();
+
+		rows_ = par.rows_;
+		dim_ = par.dim_;
+		rowSignature_ = par.rowSignature_;
+		layout_ = par.layout();
+		text_ = par.text_;
+		begin_of_body_ = par.begin_of_body_;
+
+		delete pimpl_;
+		pimpl_ = new Pimpl(*par.pimpl_, this);
 	}
+	return *this;
 }
 
-// the destructor removes the new paragraph from the list
+
 Paragraph::~Paragraph()
 {
 	delete pimpl_;
@@ -123,12 +137,12 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 	if (dth != params().depth()) {
 		if (params().depth() > dth) {
 			while (params().depth() > dth) {
-				os << "\n\\begin_deeper ";
+				os << "\n\\begin_deeper";
 				++dth;
 			}
 		} else {
 			while (params().depth() < dth) {
-				os << "\n\\end_deeper ";
+				os << "\n\\end_deeper";
 				--dth;
 			}
 		}
@@ -146,10 +160,6 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 
 	int column = 0;
 	for (pos_type i = 0; i < size(); ++i) {
-		if (!i) {
-			os << '\n';
-			column = 0;
-		}
 
 		Change change = pimpl_->lookupChangeFull(i);
 		Changes::lyxMarkChange(os, column, curtime, running_change, change);
@@ -167,7 +177,7 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 		switch (c) {
 		case META_INSET:
 		{
-			InsetOld const * inset = getInset(i);
+			InsetBase const * inset = getInset(i);
 			if (inset)
 				if (inset->directWrite()) {
 					// international char, let it write
@@ -175,15 +185,17 @@ void Paragraph::write(Buffer const & buf, ostream & os,
 					// the file
 					inset->write(buf, os);
 				} else {
-					os << "\n\\begin_inset ";
+					if (i)
+						os << '\n';
+					os << "\\begin_inset ";
 					inset->write(buf, os);
-					os << "\n\\end_inset \n\n";
+					os << "\n\\end_inset\n\n";
 					column = 0;
 				}
 		}
 		break;
 		case '\\':
-			os << "\n\\backslash \n";
+			os << "\n\\backslash\n";
 			column = 0;
 			break;
 		case '.':
@@ -248,60 +260,46 @@ int Paragraph::erase(pos_type start, pos_type end)
 }
 
 
-bool Paragraph::checkInsertChar(LyXFont & font)
+void Paragraph::insert(pos_type start, string const & str,
+		       LyXFont const & font)
 {
-	if (pimpl_->inset_owner)
-		return pimpl_->inset_owner->checkInsertChar(font);
-	return true;
+	for (size_t i = 0, n = str.size(); i != n ; ++i)
+		insertChar(start + i, str[i], font);
 }
 
 
-void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
+void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
+			   Change change)
 {
-	insertChar(pos, c, LyXFont(LyXFont::ALL_INHERIT));
+	pimpl_->insertChar(pos, c, change);
 }
 
 
 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
 			   LyXFont const & font, Change change)
 {
-	pimpl_->insertChar(pos, c, font, change);
+	pimpl_->insertChar(pos, c, change);
+	setFont(pos, font);
 }
 
 
-void Paragraph::insertInset(pos_type pos, InsetOld * inset)
+void Paragraph::insertInset(pos_type pos, InsetBase * inset, Change change)
 {
-	insertInset(pos, inset, LyXFont(LyXFont::ALL_INHERIT));
+	pimpl_->insertInset(pos, inset, change);
 }
 
 
-void Paragraph::insertInset(pos_type pos, InsetOld * inset,
-	LyXFont const & font, Change change)
+void Paragraph::insertInset(pos_type pos, InsetBase * inset,
+			    LyXFont const & font, Change change)
 {
-	pimpl_->insertInset(pos, inset, font, change);
+	pimpl_->insertInset(pos, inset, change);
+	setFont(pos, font);
 }
 
 
-bool Paragraph::insetAllowed(InsetOld_code code)
+bool Paragraph::insetAllowed(InsetBase_code code)
 {
-	//lyxerr << "Paragraph::InsertInsetAllowed" << endl;
-	if (pimpl_->inset_owner)
-		return pimpl_->inset_owner->insetAllowed(code);
-	return true;
-}
-
-
-InsetOld * Paragraph::getInset(pos_type pos)
-{
-	BOOST_ASSERT(pos < size());
-	return insetlist.get(pos);
-}
-
-
-InsetOld const * Paragraph::getInset(pos_type pos) const
-{
-	BOOST_ASSERT(pos < size());
-	return insetlist.get(pos);
+	return !pimpl_->inset_owner || pimpl_->inset_owner->insetAllowed(code);
 }
 
 
@@ -309,7 +307,10 @@ InsetOld const * Paragraph::getInset(pos_type pos) const
 LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 					 pos_type pos) const
 {
-	BOOST_ASSERT(pos <= size());
+	if (pos > size()) {
+		lyxerr << " pos: " << pos << " size: " << size() << endl;
+		BOOST_ASSERT(pos <= size());
+	}
 
 	Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 	Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
@@ -327,20 +328,30 @@ LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 }
 
 
-lyx::pos_type Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
+FontSpan Paragraph::fontSpan(lyx::pos_type pos) const
 {
 	BOOST_ASSERT(pos <= size());
+	lyx::pos_type start = 0;
 
 	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();
+	for (; cit != end; ++cit) {
+		if (cit->pos() >= pos) {
+			if (pos >= beginOfBody())
+				return FontSpan(std::max(start, beginOfBody()),
+						cit->pos());
+			else
+				return FontSpan(start, 
+						std::min(beginOfBody() - 1, 
+							 cit->pos()));
+		}
+		start = cit->pos() + 1;
+	}
 
 	// This should not happen, but if so, we take no chances.
 	//lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!"
 	//      << endl;
-	return pos;
+	return FontSpan(pos, pos);
 }
 
 
@@ -366,7 +377,7 @@ LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 
 	LyXLayout_ptr const & lout = layout();
 
-	pos_type const body_pos = beginningOfBody();
+	pos_type const body_pos = beginOfBody();
 
 	LyXFont layoutfont;
 	if (pos < body_pos)
@@ -383,8 +394,8 @@ LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 }
 
 
-LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
-				      LyXFont const & outerfont) const
+LyXFont const Paragraph::getLabelFont
+	(BufferParams const & bparams, LyXFont const & outerfont) const
 {
 	LyXFont tmpfont = layout()->labelfont;
 	tmpfont.setLanguage(getParLanguage(bparams));
@@ -394,8 +405,8 @@ LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
 }
 
 
-LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
-				       LyXFont const & outerfont) const
+LyXFont const Paragraph::getLayoutFont
+	(BufferParams const & bparams, LyXFont const & outerfont) const
 {
 	LyXFont tmpfont = layout()->font;
 	tmpfont.setLanguage(getParLanguage(bparams));
@@ -406,9 +417,8 @@ LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
 
 
 /// Returns the height of the highest font in range
-LyXFont_size
-Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
-			      LyXFont_size def_size) const
+LyXFont_size Paragraph::highestFontInRange
+	(pos_type startpos, pos_type endpos, LyXFont_size def_size) const
 {
 	if (pimpl_->fontlist.empty())
 		return def_size;
@@ -500,7 +510,7 @@ void Paragraph::setFont(pos_type pos, LyXFont const & font)
 		if (it->pos() >= pos)
 			break;
 	}
-	unsigned int i = std::distance(beg, it);
+	size_t const i = distance(beg, it);
 	bool notfound = (it == endit);
 
 	if (!notfound && pimpl_->fontlist[i].font() == font)
@@ -560,7 +570,9 @@ int Paragraph::stripLeadingSpaces()
 
 	int i = 0;
 	while (!empty() && (isNewline(0) || isLineSeparator(0))) {
-		pimpl_->eraseIntern(0);
+		// Set Change::Type to Change::INSERTED to quietly remove it
+		setChange(0, Change::INSERTED);
+		erase(0);
 		++i;
 	}
 
@@ -570,9 +582,7 @@ int Paragraph::stripLeadingSpaces()
 
 bool Paragraph::hasSameLayout(Paragraph const & par) const
 {
-	return
-		par.layout() == layout() &&
-		params().sameLayout(par.params());
+	return par.layout() == layout() && params().sameLayout(par.params());
 }
 
 
@@ -624,34 +634,40 @@ void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
 	layout(new_layout);
 	params().labelWidthString(string());
 	params().align(LYX_ALIGN_LAYOUT);
-	params().spaceTop(VSpace(VSpace::NONE));
-	params().spaceBottom(VSpace(VSpace::NONE));
 	params().spacing(Spacing(Spacing::Default));
 }
 
 
-int Paragraph::beginningOfBody() const
+pos_type Paragraph::beginOfBody() const
 {
-	if (layout()->labeltype != LABEL_MANUAL)
-		return 0;
+	return begin_of_body_;
+}
+
+
+void Paragraph::setBeginOfBody()
+{
+	if (layout()->labeltype != LABEL_MANUAL) {
+		begin_of_body_ = 0;
+		return;
+	}
 
 	// Unroll the first two cycles of the loop
 	// and remember the previous character to
 	// remove unnecessary getChar() calls
 	pos_type i = 0;
-	if (i < size() && !isNewline(i)) {
+	pos_type end = size();
+	if (i < end && !isNewline(i)) {
 		++i;
 		char previous_char = 0;
 		char temp = 0;
-		if (i < size()) {
-			previous_char = getChar(i);
+		if (i < end) {
+			previous_char = text_[i];
 			if (!isNewline(i)) {
 				++i;
-				while (i < size() && previous_char != ' ') {
-					temp = getChar(i);
+				while (i < end && previous_char != ' ') {
+					temp = text_[i];
 					if (isNewline(i))
 						break;
-
 					++i;
 					previous_char = temp;
 				}
@@ -659,12 +675,12 @@ int Paragraph::beginningOfBody() const
 		}
 	}
 
-	return i;
+	begin_of_body_ = i;
 }
 
 
 // returns -1 if inset not found
-int Paragraph::getPositionOfInset(InsetOld const * inset) const
+int Paragraph::getPositionOfInset(InsetBase const * inset) const
 {
 	// Find the entry.
 	InsetList::const_iterator it = insetlist.begin();
@@ -678,26 +694,29 @@ int Paragraph::getPositionOfInset(InsetOld const * inset) const
 
 InsetBibitem * Paragraph::bibitem() const
 {
-	InsetList::const_iterator it = insetlist.begin();
-	if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
-		return static_cast<InsetBibitem *>(it->inset);
+	if (!insetlist.empty()) {
+		InsetBase * inset = insetlist.begin()->inset;
+		if (inset->lyxCode() == InsetBase::BIBITEM_CODE)
+			return static_cast<InsetBibitem *>(inset);
+	}
 	return 0;
 }
 
 
+bool Paragraph::forceDefaultParagraphs() const
+{
+	return inInset() && inInset()->forceDefaultParagraphs(0);
+}
+
+
 namespace {
 
-/* paragraphs inside floats need different alignment tags to avoid
-unwanted space */
+// paragraphs inside floats need different alignment tags to avoid
+// unwanted space
 
-bool noTrivlistCentering(UpdatableInset const * inset)
+bool noTrivlistCentering(InsetBase::Code code)
 {
-	if (inset && inset->owner()) {
-		InsetOld::Code const code = inset->owner()->lyxCode();
-		return code == InsetOld::FLOAT_CODE ||
-			code == InsetOld::WRAP_CODE;
-	}
-	return false;
+	return code == InsetBase::FLOAT_CODE || code == InsetBase::WRAP_CODE;
 }
 
 
@@ -714,10 +733,10 @@ string correction(string const & orig)
 
 
 string const corrected_env(string const & suffix, string const & env,
-			   UpdatableInset const * inset)
+	InsetBase::Code code)
 {
 	string output = suffix + "{";
-	if (noTrivlistCentering(inset))
+	if (noTrivlistCentering(code))
 		output += correction(env);
 	else
 		output += env;
@@ -749,7 +768,7 @@ int Paragraph::startTeXParParams(BufferParams const & bparams,
 	case LYX_ALIGN_CENTER:
 		if (moving_arg) {
 			os << "\\protect";
-			column = 8;
+			column += 8;
 		}
 		break;
 	}
@@ -762,27 +781,25 @@ int Paragraph::startTeXParParams(BufferParams const & bparams,
 		break;
 	case LYX_ALIGN_LEFT: {
 		string output;
-		UpdatableInset const * const inset = pimpl_->inset_owner;
 		if (getParLanguage(bparams)->babel() != "hebrew")
-			output = corrected_env("\\begin", "flushleft", inset);
+			output = corrected_env("\\begin", "flushleft", ownerCode());
 		else
-			output = corrected_env("\\begin", "flushright", inset);
+			output = corrected_env("\\begin", "flushright", ownerCode());
 		os << output;
 		column += output.size();
 		break;
 	} case LYX_ALIGN_RIGHT: {
 		string output;
-		UpdatableInset const * const inset = pimpl_->inset_owner;
 		if (getParLanguage(bparams)->babel() != "hebrew")
-			output = corrected_env("\\begin", "flushright", inset);
+			output = corrected_env("\\begin", "flushright", ownerCode());
 		else
-			output = corrected_env("\\begin", "flushleft", inset);
+			output = corrected_env("\\begin", "flushleft", ownerCode());
 		os << output;
 		column += output.size();
 		break;
 	} case LYX_ALIGN_CENTER: {
 		string output;
-		output = corrected_env("\\begin", "center", pimpl_->inset_owner);
+		output = corrected_env("\\begin", "center", ownerCode());
 		os << output;
 		column += output.size();
 		break;
@@ -823,27 +840,25 @@ int Paragraph::endTeXParParams(BufferParams const & bparams,
 		break;
 	case LYX_ALIGN_LEFT: {
 		string output;
-		UpdatableInset const * const inset = pimpl_->inset_owner;
 		if (getParLanguage(bparams)->babel() != "hebrew")
-			output = corrected_env("\\par\\end", "flushleft", inset);
+			output = corrected_env("\\par\\end", "flushleft", ownerCode());
 		else
-			output = corrected_env("\\par\\end", "flushright", inset);
+			output = corrected_env("\\par\\end", "flushright", ownerCode());
 		os << output;
 		column += output.size();
 		break;
 	} case LYX_ALIGN_RIGHT: {
 		string output;
-		UpdatableInset const * const inset = pimpl_->inset_owner;
 		if (getParLanguage(bparams)->babel() != "hebrew")
-			output = corrected_env("\\par\\end", "flushright", inset);
+			output = corrected_env("\\par\\end", "flushright", ownerCode());
 		else
-			output = corrected_env("\\par\\end", "flushleft", inset);
+			output = corrected_env("\\par\\end", "flushleft", ownerCode());
 		os << output;
 		column += output.size();
 		break;
 	} case LYX_ALIGN_CENTER: {
 		string output;
-		output = corrected_env("\\par\\end", "center", pimpl_->inset_owner);
+		output = corrected_env("\\par\\end", "center", ownerCode());
 		os << output;
 		column += output.size();
 		break;
@@ -859,7 +874,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 				BufferParams const & bparams,
 				LyXFont const & outerfont,
 				ostream & os, TexRow & texrow,
-				LatexRunParams const & runparams)
+				OutputParams const & runparams) const
 {
 	lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 
@@ -871,8 +886,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 	// 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!
-	bool asdefault =
-		(inInset() && inInset()->forceDefaultParagraphs(inInset()));
+	bool asdefault = forceDefaultParagraphs();
 
 	if (asdefault) {
 		style = bparams.getLyXTextClass().defaultLayout();
@@ -882,30 +896,29 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 
 	LyXFont basefont;
 
-	// Maybe we have to create a optional argument.
-	pos_type body_pos;
+	LaTeXFeatures features(buf, bparams, runparams.nice);
 
-	// FIXME: can we actually skip this check and just call
-	// beginningOfBody() ??
-	if (style->labeltype != LABEL_MANUAL) {
-		body_pos = 0;
-	} else {
-		body_pos = beginningOfBody();
-	}
+	// output change tracking marks only if desired,
+	// if dvipost is installed,
+	// and with dvi/ps (other formats don't work)
+	bool const output = bparams.output_changes
+		&& runparams.flavor == OutputParams::LATEX
+		&& features.isAvailable("dvipost");
 
+	// Maybe we have to create a optional argument.
+	pos_type body_pos = beginOfBody();
 	unsigned int column = 0;
 
 	if (body_pos > 0) {
-		os << '[';
-		++column;
+		// the optional argument is kept in curly brackets in
+		// case it contains a ']'
+		os << "[{";
+		column += 2;
 		basefont = getLabelFont(bparams, outerfont);
 	} else {
 		basefont = getLayoutFont(bparams, outerfont);
 	}
 
-	bool moving_arg = runparams.moving_arg;
-	moving_arg |= style->needprotect;
-
 	// Which font is currently active?
 	LyXFont running_font(basefont);
 	// Do we have an open font change?
@@ -922,8 +935,8 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 			++column;
 		}
 		if (!asdefault)
-			column += startTeXParParams(bparams, os, moving_arg);
-
+			column += startTeXParParams(bparams, os,
+						    runparams.moving_arg);
 	}
 
 	for (pos_type i = 0; i < size(); ++i) {
@@ -937,8 +950,8 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 				}
 				basefont = getLayoutFont(bparams, outerfont);
 				running_font = basefont;
-				os << ']';
-				++column;
+				os << "}] ";
+				column +=3;
 			}
 			if (style->isCommand()) {
 				os << '{';
@@ -947,7 +960,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 
 			if (!asdefault)
 				column += startTeXParParams(bparams, os,
-							    moving_arg);
+							    runparams.moving_arg);
 		}
 
 		value_type c = getChar(i);
@@ -962,8 +975,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 		// rather than "\textXX{text }". (Asger)
 		if (open_font && c == ' ' && i <= size() - 2) {
 			LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
-			if (next_font != running_font
-			    && next_font != font) {
+			if (next_font != running_font && next_font != font) {
 				font = next_font;
 			}
 		}
@@ -1002,22 +1014,28 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 
 		Change::Type change = pimpl_->lookupChange(i);
 
-		column += Changes::latexMarkChange(os, running_change, change);
+		column += Changes::latexMarkChange(os, running_change,
+			change, output);
 		running_change = change;
 
-		LatexRunParams rp = runparams;
-		rp.moving_arg = moving_arg;
-		rp.free_spacing = style->free_spacing;
-		pimpl_->simpleTeXSpecialChars(buf, bparams,
-					      os, texrow, runparams,
-					      font, running_font,
-					      basefont, outerfont, open_font,
-					      running_change,
-					      *style, i, column, c);
+		// do not output text which is marked deleted
+		// if change tracking output is not desired
+		if (output || running_change != Change::DELETED) {
+			OutputParams rp = runparams;
+			rp.free_spacing = style->free_spacing;
+			rp.local_font = &font;
+			rp.intitle = style->intitle;
+			pimpl_->simpleTeXSpecialChars(buf, bparams,
+						os, texrow, rp,
+						font, running_font,
+						basefont, outerfont, open_font,
+						running_change,
+						*style, i, column, c);
+		}
 	}
 
 	column += Changes::latexMarkChange(os,
-			running_change, Change::UNCHANGED);
+			running_change, Change::UNCHANGED, output);
 
 	// If we have an open font definition, we have to close it
 	if (open_font) {
@@ -1043,12 +1061,12 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 
 	// Needed if there is an optional argument but no contents.
 	if (body_pos > 0 && body_pos == size()) {
-		os << "]~";
+		os << "}]~";
 		return_value = false;
 	}
 
 	if (!asdefault) {
-		column += endTeXParParams(bparams, os, moving_arg);
+		column += endTeXParParams(bparams, os, runparams.moving_arg);
 	}
 
 	lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
@@ -1058,78 +1076,417 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 
 namespace {
 
-/// return true if the char is a meta-character for an inset
+// checks, if newcol chars should be put into this line
+// writes newline, if necessary.
+void sgmlLineBreak(ostream & os, string::size_type & colcount,
+			  string::size_type newcol)
+{
+	colcount += newcol;
+	if (colcount > lyxrc.ascii_linelen) {
+		os << "\n";
+		colcount = newcol; // assume write after this call
+	}
+}
+
+enum PAR_TAG {
+	PAR_NONE=0,
+	TT = 1,
+	SF = 2,
+	BF = 4,
+	IT = 8,
+	SL = 16,
+	EM = 32
+};
+
+
+string tag_name(PAR_TAG const & pt) {
+	switch (pt) {
+	case PAR_NONE: return "!-- --";
+	case TT: return "tt";
+	case SF: return "sf";
+	case BF: return "bf";
+	case IT: return "it";
+	case SL: return "sl";
+	case EM: return "em";
+	}
+	return "";
+}
+
+
 inline
-bool IsInsetChar(char c)
+void operator|=(PAR_TAG & p1, PAR_TAG const & p2)
 {
-	return (c == Paragraph::META_INSET);
+	p1 = static_cast<PAR_TAG>(p1 | p2);
 }
 
-} // namespace anon
 
+inline
+void reset(PAR_TAG & p1, PAR_TAG const & p2)
+{
+	p1 = static_cast<PAR_TAG>(p1 & ~p2);
+}
+
+} // anon
 
 
-bool Paragraph::isHfill(pos_type pos) const
+// Handle internal paragraph parsing -- layout already processed.
+void Paragraph::simpleLinuxDocOnePar(Buffer const & buf,
+				     ostream & os,
+				     LyXFont const & outerfont,
+				     OutputParams const & runparams,
+				     lyx::depth_type /*depth*/) const
 {
-	return IsInsetChar(getChar(pos))
-	       && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
+	LyXLayout_ptr const & style = layout();
+
+	string::size_type char_line_count = 5;     // Heuristic choice ;-)
+
+	// gets paragraph main font
+	LyXFont font_old;
+	bool desc_on;
+	if (style->labeltype == LABEL_MANUAL) {
+		font_old = style->labelfont;
+		desc_on = true;
+	} else {
+		font_old = style->font;
+		desc_on = false;
+	}
+
+	LyXFont::FONT_FAMILY family_type = LyXFont::ROMAN_FAMILY;
+	LyXFont::FONT_SERIES series_type = LyXFont::MEDIUM_SERIES;
+	LyXFont::FONT_SHAPE  shape_type  = LyXFont::UP_SHAPE;
+	bool is_em = false;
+
+	stack<PAR_TAG> tag_state;
+	// parsing main loop
+	for (pos_type i = 0; i < size(); ++i) {
+
+		PAR_TAG tag_close = PAR_NONE;
+		list < PAR_TAG > tag_open;
+
+		LyXFont const font = getFont(buf.params(), i, outerfont);
+
+		if (font_old.family() != font.family()) {
+			switch (family_type) {
+			case LyXFont::SANS_FAMILY:
+				tag_close |= SF;
+				break;
+			case LyXFont::TYPEWRITER_FAMILY:
+				tag_close |= TT;
+				break;
+			default:
+				break;
+			}
+
+			family_type = font.family();
+
+			switch (family_type) {
+			case LyXFont::SANS_FAMILY:
+				tag_open.push_back(SF);
+				break;
+			case LyXFont::TYPEWRITER_FAMILY:
+				tag_open.push_back(TT);
+				break;
+			default:
+				break;
+			}
+		}
+
+		if (font_old.series() != font.series()) {
+			switch (series_type) {
+			case LyXFont::BOLD_SERIES:
+				tag_close |= BF;
+				break;
+			default:
+				break;
+			}
+
+			series_type = font.series();
+
+			switch (series_type) {
+			case LyXFont::BOLD_SERIES:
+				tag_open.push_back(BF);
+				break;
+			default:
+				break;
+			}
+
+		}
+
+		if (font_old.shape() != font.shape()) {
+			switch (shape_type) {
+			case LyXFont::ITALIC_SHAPE:
+				tag_close |= IT;
+				break;
+			case LyXFont::SLANTED_SHAPE:
+				tag_close |= SL;
+				break;
+			default:
+				break;
+			}
+
+			shape_type = font.shape();
+
+			switch (shape_type) {
+			case LyXFont::ITALIC_SHAPE:
+				tag_open.push_back(IT);
+				break;
+			case LyXFont::SLANTED_SHAPE:
+				tag_open.push_back(SL);
+				break;
+			default:
+				break;
+			}
+		}
+		// handle <em> tag
+		if (font_old.emph() != font.emph()) {
+			if (font.emph() == LyXFont::ON) {
+				tag_open.push_back(EM);
+				is_em = true;
+			}
+			else if (is_em) {
+				tag_close |= EM;
+				is_em = false;
+			}
+		}
+
+		list < PAR_TAG > temp;
+		while (!tag_state.empty() && tag_close) {
+			PAR_TAG k =  tag_state.top();
+			tag_state.pop();
+			os << "</" << tag_name(k) << '>';
+			if (tag_close & k)
+				reset(tag_close,k);
+			else
+				temp.push_back(k);
+		}
+
+		for(list< PAR_TAG >::const_iterator j = temp.begin();
+		    j != temp.end(); ++j) {
+			tag_state.push(*j);
+			os << '<' << tag_name(*j) << '>';
+		}
+
+		for(list< PAR_TAG >::const_iterator j = tag_open.begin();
+		    j != tag_open.end(); ++j) {
+			tag_state.push(*j);
+			os << '<' << tag_name(*j) << '>';
+		}
+
+		value_type c = getChar(i);
+
+
+		if (c == Paragraph::META_INSET) {
+			getInset(i)->linuxdoc(buf, os, runparams);
+			font_old = font;
+			continue;
+		}
+
+		if (style->latexparam() == "CDATA") {
+			// "TeX"-Mode on == > SGML-Mode on.
+			if (c != '\0')
+				os << c;
+			++char_line_count;
+		} else {
+			bool ws;
+			string str;
+			boost::tie(ws, str) = sgml::escapeChar(c);
+			if (ws && !isFreeSpacing()) {
+				// in freespacing mode, spaces are
+				// non-breaking characters
+				if (desc_on) { // if char is ' ' then...
+					++char_line_count;
+					sgmlLineBreak(os, char_line_count, 6);
+					os << "</tag>";
+					desc_on = false;
+				} else  {
+					sgmlLineBreak(os, char_line_count, 1);
+					os << c;
+				}
+			} else {
+				os << str;
+				char_line_count += str.length();
+			}
+		}
+		font_old = font;
+	}
+
+	while (!tag_state.empty()) {
+		os << "</" << tag_name(tag_state.top()) << '>';
+		tag_state.pop();
+	}
+
+	// resets description flag correctly
+	if (desc_on) {
+		// <tag> not closed...
+		sgmlLineBreak(os, char_line_count, 6);
+		os << "</tag>";
+	}
 }
 
 
-bool Paragraph::isInset(pos_type pos) const
+bool Paragraph::emptyTag() const
 {
-	return IsInsetChar(getChar(pos));
+	for (pos_type i = 0; i < size(); ++i) {
+		if (isInset(i)) {
+			InsetBase const * inset = getInset(i);
+			InsetBase::Code lyx_code = inset->lyxCode();
+			if (lyx_code != InsetBase::TOC_CODE &&
+			    lyx_code != InsetBase::INCLUDE_CODE &&
+			    lyx_code != InsetBase::GRAPHICS_CODE &&
+			    lyx_code != InsetBase::ERT_CODE &&
+			    lyx_code != InsetBase::FLOAT_CODE &&
+			    lyx_code != InsetBase::TABULAR_CODE) {
+				return false;
+			}
+		} else {
+			value_type c = getChar(i);
+			if (c != ' ' && c != '\t')
+				return false;
+		}
+	}
+	return true;
 }
 
 
-bool Paragraph::isNewline(pos_type pos) const
+string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) const
 {
-	return IsInsetChar(getChar(pos))
-	       && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE;
+	for (pos_type i = 0; i < size(); ++i) {
+		if (isInset(i)) {
+			InsetBase const * inset = getInset(i);
+			InsetBase::Code lyx_code = inset->lyxCode();
+			if (lyx_code == InsetBase::LABEL_CODE) {
+				string const id = static_cast<InsetCommand const *>(inset)->getContents();
+				return "id=\"" + sgml::cleanID(buf, runparams, id) + "\"";
+			}
+		}
+
+	}
+	return string();
 }
 
 
-bool Paragraph::isSeparator(pos_type pos) const
+pos_type Paragraph::getFirstWord(Buffer const & buf, ostream & os, OutputParams const & runparams) const
 {
-	return IsSeparatorChar(getChar(pos));
+	pos_type i;
+	for (i = 0; i < size(); ++i) {
+		if (isInset(i)) {
+			InsetBase const * inset = getInset(i);
+			inset->docbook(buf, os, runparams);
+		} else {
+			value_type c = getChar(i);
+			if (c == ' ')
+				break;
+			bool ws;
+			string str;
+			boost::tie(ws, str) = sgml::escapeChar(c);
+
+			os << str;
+		}
+	}
+	return i;
 }
 
 
-bool Paragraph::isLineSeparator(pos_type pos) const
+bool Paragraph::onlyText(Buffer const & buf, LyXFont const & outerfont, pos_type initial) const
 {
-	value_type const c = getChar(pos);
-	return IsLineSeparatorChar(c)
-		|| (IsInsetChar(c) && getInset(pos) &&
-		getInset(pos)->isLineSeparator());
+	LyXFont font_old;
+
+	for (pos_type i = initial; i < size(); ++i) {
+		LyXFont font = getFont(buf.params(), i, outerfont);
+		if (isInset(i))
+			return false;
+		if (i != initial && font != font_old)
+			return false;
+		font_old = font;
+	}
+
+	return true;
 }
 
 
-bool Paragraph::isKomma(pos_type pos) const
+void Paragraph::simpleDocBookOnePar(Buffer const & buf,
+				    ostream & os,
+				    OutputParams const & runparams,
+				    LyXFont const & outerfont,
+				    pos_type initial) const
 {
-	return IsKommaChar(getChar(pos));
+	bool emph_flag = false;
+
+	LyXLayout_ptr const & style = layout();
+	LyXFont font_old =
+		style->labeltype == LABEL_MANUAL ? style->labelfont : style->font;
+
+	if (style->pass_thru && !onlyText(buf, outerfont, initial))
+		os << "]]>";
+
+	// parsing main loop
+	for (pos_type i = initial; i < size(); ++i) {
+		LyXFont font = getFont(buf.params(), i, outerfont);
+
+		// handle <emphasis> tag
+		if (font_old.emph() != font.emph()) {
+			if (font.emph() == LyXFont::ON) {
+				os << "<emphasis>";
+				emph_flag = true;
+			} else if (i != initial) {
+				os << "</emphasis>";
+				emph_flag = false;
+			}
+		}
+
+		if (isInset(i)) {
+			InsetBase const * inset = getInset(i);
+			inset->docbook(buf, os, runparams);
+		} else {
+			value_type c = getChar(i);
+			bool ws;
+			string str;
+			boost::tie(ws, str) = sgml::escapeChar(c);
+
+			if (style->pass_thru)
+				os << c;
+			else
+				os << str;
+		}
+		font_old = font;
+	}
+
+	if (emph_flag) {
+		os << "</emphasis>";
+	}
+
+	if (style->free_spacing)
+		os << '\n';
+	if (style->pass_thru && !onlyText(buf, outerfont, initial))
+		os << "<![CDATA[";
 }
 
 
-/// Used by the spellchecker
-bool Paragraph::isLetter(pos_type pos) const
+bool Paragraph::isNewline(pos_type pos) const
+{
+	return isInset(pos)
+		&& getInset(pos)->lyxCode() == InsetBase::NEWLINE_CODE;
+}
+
+
+bool Paragraph::isLineSeparator(pos_type pos) const
 {
 	value_type const c = getChar(pos);
-	if (IsLetterChar(c))
-		return true;
-	if (isInset(pos))
-		return getInset(pos)->isLetter();
-	// We want to pass the ' and escape chars to ispell
-	string const extra = lyxrc.isp_esc_chars + '\'';
-	return contains(extra, c);
+	return IsLineSeparatorChar(c)
+		|| (c == Paragraph::META_INSET && getInset(pos) &&
+		getInset(pos)->isLineSeparator());
 }
 
 
-bool Paragraph::isWord(pos_type pos) const
+/// Used by the spellchecker
+bool Paragraph::isLetter(pos_type pos) const
 {
-	unsigned char const c = getChar(pos);
-	return !(IsSeparatorChar(c)
-		  || IsKommaChar(c)
-		  || IsInsetChar(c));
+	if (isInset(pos))
+		return getInset(pos)->isLetter();
+	else {
+		value_type const c = getChar(pos);
+		return IsLetterChar(c) || IsDigit(c);
+	}
 }
 
 
@@ -1138,7 +1495,9 @@ Paragraph::getParLanguage(BufferParams const & bparams) const
 {
 	if (!empty())
 		return getFirstFontSettings().language();
+#ifdef WITH_WARNINGS
 #warning FIXME we should check the prev par as well (Lgb)
+#endif
 	return bparams.language;
 }
 
@@ -1147,8 +1506,7 @@ bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
 {
 	return lyxrc.rtl_support
 		&& getParLanguage(bparams)->RightToLeft()
-		&& !(inInset() && inInset()->owner() &&
-		     inInset()->owner()->lyxCode() == InsetOld::ERT_CODE);
+		&& ownerCode() != InsetBase::ERT_CODE;
 }
 
 
@@ -1165,7 +1523,7 @@ void Paragraph::changeLanguage(BufferParams const & bparams,
 }
 
 
-bool Paragraph::isMultiLingual(BufferParams const & bparams)
+bool Paragraph::isMultiLingual(BufferParams const & bparams) const
 {
 	Language const * doc_language =	bparams.language;
 	Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
@@ -1183,6 +1541,15 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams)
 // Convert the paragraph to a string.
 // Used for building the table of contents
 string const Paragraph::asString(Buffer const & buffer, bool label) const
+{
+	OutputParams runparams;
+	return asString(buffer, runparams, label);
+}
+
+
+string const Paragraph::asString(Buffer const & buffer,
+				 OutputParams const & runparams,
+				 bool label) const
 {
 #if 0
 	string s;
@@ -1194,17 +1561,17 @@ string const Paragraph::asString(Buffer const & buffer, bool label) const
 		if (IsPrintable(c))
 			s += c;
 		else if (c == META_INSET &&
-			 getInset(i)->lyxCode() == InsetOld::MATH_CODE) {
-			ostringstream ost;
-			getInset(i)->ascii(buffer, ost);
-			s += subst(STRCONV(ost.str()),'\n',' ');
+			 getInset(i)->lyxCode() == InsetBase::MATH_CODE) {
+			ostringstream os;
+			getInset(i)->plaintext(buffer, os, runparams);
+			s += subst(STRCONV(os.str()),'\n',' ');
 		}
 	}
 
 	return s;
 #else
 	// This should really be done by the caller and not here.
-	string ret(asString(buffer, 0, size(), label));
+	string ret = asString(buffer, runparams, 0, size(), label);
 	return subst(ret, '\n', ' ');
 #endif
 }
@@ -1213,6 +1580,16 @@ string const Paragraph::asString(Buffer const & buffer, bool label) const
 string const Paragraph::asString(Buffer const & buffer,
 				 pos_type beg, pos_type end, bool label) const
 {
+
+	OutputParams const runparams;
+	return asString(buffer, runparams, beg, end, label);
+}
+
+
+string const Paragraph::asString(Buffer const & buffer,
+				 OutputParams const & runparams,
+				 pos_type beg, pos_type end, bool label) const
+{
 	ostringstream os;
 
 	if (beg == 0 && label && !params().labelString().empty())
@@ -1223,27 +1600,16 @@ string const Paragraph::asString(Buffer const & buffer,
 		if (IsPrintable(c))
 			os << c;
 		else if (c == META_INSET)
-			getInset(i)->ascii(buffer, os);
+			getInset(i)->textString(buffer, os, runparams);
 	}
 
 	return os.str();
 }
 
 
-void Paragraph::setInsetOwner(UpdatableInset * inset)
+void Paragraph::setInsetOwner(InsetBase * inset)
 {
 	pimpl_->inset_owner = inset;
-	InsetList::iterator it = insetlist.begin();
-	InsetList::iterator end = insetlist.end();
-	for (; it != end; ++it)
-		if (it->inset)
-			it->inset->setOwner(inset);
-}
-
-
-void Paragraph::deleteInsetsLyXText(BufferView * bv)
-{
-	insetlist.deleteInsetsLyXText(bv);
 }
 
 
@@ -1273,14 +1639,14 @@ void Paragraph::cleanChanges()
 
 Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
 {
-	BOOST_ASSERT(!size() || pos < size());
+	BOOST_ASSERT(empty() || pos < size());
 	return pimpl_->lookupChange(pos);
 }
 
 
 Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
 {
-	BOOST_ASSERT(!size() || pos < size());
+	BOOST_ASSERT(empty() || pos < size());
 	return pimpl_->lookupChangeFull(pos);
 }
 
@@ -1300,13 +1666,12 @@ bool Paragraph::isChangeEdited(pos_type start, pos_type end) const
 void Paragraph::setChange(lyx::pos_type pos, Change::Type type)
 {
 	pimpl_->setChange(pos, type);
-
 }
 
 
-void Paragraph::markErased()
+void Paragraph::markErased(bool erased)
 {
-	pimpl_->markErased();
+	pimpl_->markErased(erased);
 }
 
 
@@ -1322,44 +1687,14 @@ void Paragraph::rejectChange(pos_type start, pos_type end)
 }
 
 
-Paragraph::value_type Paragraph::getChar(pos_type pos) const
-{
-	// This is in the critical path!
-	pos_type const siz = text_.size();
-
-	BOOST_ASSERT(0 <= pos && pos <= siz);
-
-	if (pos == siz) {
-		lyxerr << "getChar() on pos " << pos << " in par id "
-		       << id() << " of size " << siz
-		       << "  is a bit silly !" << endl;
-		BOOST_ASSERT(false);
-		return '\0';
-	}
-
-	return text_[pos];
-}
-
-
 int Paragraph::id() const
 {
 	return pimpl_->id_;
 }
 
 
-void Paragraph::id(int i)
-{
-	pimpl_->id_ = i;
-}
-
-
 LyXLayout_ptr const & Paragraph::layout() const
 {
-/*
-	InsetOld * inset = inInset();
-	if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE)
-		return static_cast<InsetEnvironment*>(inset)->layout();
-*/
 	return layout_;
 }
 
@@ -1370,12 +1705,19 @@ void Paragraph::layout(LyXLayout_ptr const & new_layout)
 }
 
 
-UpdatableInset * Paragraph::inInset() const
+InsetBase * Paragraph::inInset() const
 {
 	return pimpl_->inset_owner;
 }
 
 
+InsetBase::Code Paragraph::ownerCode() const
+{
+	return pimpl_->inset_owner
+		? pimpl_->inset_owner->lyxCode() : InsetBase::NO_CODE;
+}
+
+
 void Paragraph::clearContents()
 {
 	text_.clear();
@@ -1406,10 +1748,8 @@ bool Paragraph::isFreeSpacing() const
 		return true;
 
 	// for now we just need this, later should we need this in some
-	// other way we can always add a function to InsetOld too.
-	if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
-		return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE;
-	return false;
+	// other way we can always add a function to InsetBase too.
+	return ownerCode() == InsetBase::ERT_CODE;
 }
 
 
@@ -1417,19 +1757,102 @@ bool Paragraph::allowEmpty() const
 {
 	if (layout()->keepempty)
 		return true;
-	if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
-		return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE;
-	return false;
+	return ownerCode() == InsetBase::ERT_CODE;
 }
 
 
-RowList::iterator Paragraph::getRow(pos_type pos)
+Row & Paragraph::getRow(pos_type pos, bool boundary)
 {
-	RowList::iterator rit = rows.end();
-	RowList::iterator const begin = rows.begin();
+	BOOST_ASSERT(!rows().empty());
+
+	// If boundary is set we should return the row on which
+	// the character before is inside.
+	if (pos > 0 && boundary)
+		--pos;
+
+	RowList::iterator rit = rows_.end();
+	RowList::iterator const begin = rows_.begin();
 
 	for (--rit; rit != begin && rit->pos() > pos; --rit)
 		;
 
-	return rit;
+	return *rit;
+}
+
+
+Row const & Paragraph::getRow(pos_type pos, bool boundary) const
+{
+	BOOST_ASSERT(!rows().empty());
+
+	// If boundary is set we should return the row on which
+	// the character before is inside.
+	if (pos > 0 && boundary)
+		--pos;
+
+	RowList::const_iterator rit = rows_.end();
+	RowList::const_iterator const begin = rows_.begin();
+
+	for (--rit; rit != begin && rit->pos() > pos; --rit)
+		;
+
+	return *rit;
+}
+
+
+size_t Paragraph::pos2row(pos_type pos) const
+{
+	BOOST_ASSERT(!rows().empty());
+
+	RowList::const_iterator rit = rows_.end();
+	RowList::const_iterator const begin = rows_.begin();
+
+	for (--rit; rit != begin && rit->pos() > pos; --rit)
+		;
+
+	return rit - begin;
+}
+
+
+unsigned char Paragraph::transformChar(unsigned char c, pos_type pos) const
+{
+	if (!Encodings::is_arabic(c))
+		if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && IsDigit(c))
+			return c + (0xb0 - '0');
+		else
+			return c;
+
+	unsigned char const prev_char = pos > 0 ? getChar(pos - 1) : ' ';
+	unsigned char next_char = ' ';
+
+	for (pos_type i = pos + 1, end = size(); i < end; ++i) {
+		unsigned char const par_char = getChar(i);
+		if (!Encodings::IsComposeChar_arabic(par_char)) {
+			next_char = par_char;
+			break;
+		}
+	}
+
+	if (Encodings::is_arabic(next_char)) {
+		if (Encodings::is_arabic(prev_char) &&
+			!Encodings::is_arabic_special(prev_char))
+			return Encodings::TransformChar(c, Encodings::FORM_MEDIAL);
+		else
+			return Encodings::TransformChar(c, Encodings::FORM_INITIAL);
+	} else {
+		if (Encodings::is_arabic(prev_char) &&
+			!Encodings::is_arabic_special(prev_char))
+			return Encodings::TransformChar(c, Encodings::FORM_FINAL);
+		else
+			return Encodings::TransformChar(c, Encodings::FORM_ISOLATED);
+	}
+}
+
+
+void Paragraph::dump() const
+{
+	lyxerr << "Paragraph::dump: rows.size(): " << rows_.size() << endl;
+	for (size_t i = 0; i != rows_.size(); ++i) {
+		lyxerr << "  row " << i << ":   ";
+		rows_[i].dump();
+	}
 }