X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=9dce9f546ec3599fe3a5f67f9882e5cb51f19e77;hb=69bee02a8901793b34ac5ca6d07e93910cef4005;hp=b53949fd30a8556f4d3ec3aee142d3bd0dee2f32;hpb=fc1437e74ea488d6a70eb846eb9bef7e84c8e82f;p=lyx.git

diff --git a/src/paragraph.C b/src/paragraph.C
index b53949fd30..9dce9f546e 100644
--- a/src/paragraph.C
+++ b/src/paragraph.C
@@ -22,14 +22,17 @@
 
 #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 "lyxfont.h"
 #include "lyxrc.h"
 #include "lyxrow.h"
+#include "outputparams.h"
+#include "paragraph_funcs.h"
+#include "sgml.h"
 #include "texrow.h"
 #include "vspace.h"
 
@@ -37,8 +40,15 @@
 #include "insets/insetoptarg.h"
 
 #include "support/lstrings.h"
-#include "support/textutils.h"
 #include "support/std_sstream.h"
+#include "support/textutils.h"
+#include "support/tostr.h"
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/bind.hpp>
+
+#include <list>
+#include <stack>
 
 using lyx::pos_type;
 
@@ -46,29 +56,33 @@ using lyx::support::contains;
 using lyx::support::subst;
 
 using std::endl;
+using std::list;
+using std::stack;
 using std::string;
 using std::ostream;
 using std::ostringstream;
 
 
 Paragraph::Paragraph()
-	: y(0), pimpl_(new Paragraph::Pimpl(this))
+	: y(0), height(0), begin_of_body_(0),
+	  pimpl_(new Paragraph::Pimpl(this))
 {
 	itemdepth = 0;
 	params().clear();
 }
 
 
-Paragraph::Paragraph(Paragraph const & lp)
-	: y(0), text_(lp.text_), pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
+Paragraph::Paragraph(Paragraph const & par)
+	: y(0), height(0), 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();
+	layout_ = par.layout();
 
 	// copy everything behind the break-position to the new paragraph
-	insetlist = lp.insetlist;
+	insetlist = par.insetlist;
 	InsetList::iterator it = insetlist.begin();
 	InsetList::iterator end = insetlist.end();
 	for (; it != end; ++it) {
@@ -78,26 +92,26 @@ Paragraph::Paragraph(Paragraph const & lp)
 }
 
 
-void Paragraph::operator=(Paragraph const & lp)
+void Paragraph::operator=(Paragraph const & par)
 {
 	// needed as we will destroy the pimpl_ before copying it
-	if (&lp != this)
+	if (&par != this)
 		return;
 
 	lyxerr << "Paragraph::operator=()" << endl;
 
-	text_ = lp.text_;
+	text_ = par.text_;
 
 	delete pimpl_;
-	pimpl_ = new Pimpl(*lp.pimpl_, this);
+	pimpl_ = new Pimpl(*par.pimpl_, this);
 
-	itemdepth = lp.itemdepth;
+	itemdepth = par.itemdepth;
 	// this is because of the dummy layout of the paragraphs that
 	// follow footnotes
-	layout_ = lp.layout();
+	layout_ = par.layout();
 
 	// copy everything behind the break-position to the new paragraph
-	insetlist = lp.insetlist;
+	insetlist = par.insetlist;
 	InsetList::iterator it = insetlist.begin();
 	InsetList::iterator end = insetlist.end();
 	for (; it != end; ++it) {
@@ -105,7 +119,7 @@ void Paragraph::operator=(Paragraph const & lp)
 	}
 }
 
-// the destructor removes the new paragraph from the list
+
 Paragraph::~Paragraph()
 {
 	delete pimpl_;
@@ -248,10 +262,17 @@ 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)
+{
+	int size = str.size();
+	for (int i = 0 ; i < size ; ++i)
+		insertChar(start + i, str[i], font);
+}
+
+
+bool Paragraph::checkInsertChar(LyXFont &)
 {
-	if (pimpl_->inset_owner)
-		return pimpl_->inset_owner->checkInsertChar(font);
 	return true;
 }
 
@@ -366,7 +387,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)
@@ -374,12 +395,12 @@ LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 	else
 		layoutfont = lout->font;
 
-	LyXFont tmpfont = getFontSettings(bparams, pos);
-	tmpfont.realize(layoutfont);
-	tmpfont.realize(outerfont);
-	tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+	LyXFont font = getFontSettings(bparams, pos);
+	font.realize(layoutfont);
+	font.realize(outerfont);
+	font.realize(bparams.getLyXTextClass().defaultfont());
 
-	return tmpfont;
+	return font;
 }
 
 
@@ -414,7 +435,7 @@ Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
 		return def_size;
 
 	Pimpl::FontList::const_iterator end_it = pimpl_->fontlist.begin();
-	Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
+	Pimpl::FontList::const_iterator const end = pimpl_->fontlist.end();
 	for (; end_it != end; ++end_it) {
 		if (end_it->pos() >= endpos)
 			break;
@@ -487,7 +508,7 @@ void Paragraph::setFont(pos_type pos, LyXFont const & font)
 	BOOST_ASSERT(pos <= size());
 
 	// First, reduce font against layout/label font
-	// Update: The SetCharFont() routine in text2.C already
+	// Update: The setCharFont() routine in text2.C already
 	// reduces font, so we don't need to do that here. (Asger)
 	// No need to simplify this because it will disappear
 	// in a new kernel. (Asger)
@@ -570,9 +591,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 +643,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
+int 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
+	// 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,7 +684,7 @@ int Paragraph::beginningOfBody() const
 		}
 	}
 
-	return i;
+	begin_of_body_ = i;
 }
 
 
@@ -678,17 +703,19 @@ 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()) {
+		InsetOld * inset = insetlist.begin()->inset;
+		if (inset->lyxCode() == InsetOld::BIBTEX_CODE)
+			return static_cast<InsetBibitem *>(inset);
+	}
 	return 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)
 {
@@ -859,7 +886,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 				BufferParams const & bparams,
 				LyXFont const & outerfont,
 				ostream & os, TexRow & texrow,
-				LatexRunParams const & runparams)
+				OutputParams const & runparams)
 {
 	lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 
@@ -883,16 +910,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 	LyXFont basefont;
 
 	// Maybe we have to create a optional argument.
-	pos_type body_pos;
-
-	// FIXME: can we actually skip this check and just call
-	// beginningOfBody() ??
-	if (style->labeltype != LABEL_MANUAL) {
-		body_pos = 0;
-	} else {
-		body_pos = beginningOfBody();
-	}
-
+	pos_type body_pos = beginOfBody();
 	unsigned int column = 0;
 
 	if (body_pos > 0) {
@@ -923,7 +941,6 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 		}
 		if (!asdefault)
 			column += startTeXParParams(bparams, os, moving_arg);
-
 	}
 
 	for (pos_type i = 0; i < size(); ++i) {
@@ -962,8 +979,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;
 			}
 		}
@@ -1005,7 +1021,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 		column += Changes::latexMarkChange(os, running_change, change);
 		running_change = change;
 
-		LatexRunParams rp = runparams;
+		OutputParams rp = runparams;
 		rp.moving_arg = moving_arg;
 		rp.free_spacing = style->free_spacing;
 		pimpl_->simpleTeXSpecialChars(buf, bparams,
@@ -1056,6 +1072,381 @@ bool Paragraph::simpleTeXOnePar(Buffer const & buf,
 }
 
 
+namespace {
+
+// 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 {
+	NONE=0,
+	TT = 1,
+	SF = 2,
+	BF = 4,
+	IT = 8,
+	SL = 16,
+	EM = 32
+};
+
+
+string tag_name(PAR_TAG const & pt) {
+	switch (pt) {
+	case 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
+void operator|=(PAR_TAG & p1, PAR_TAG const & p2)
+{
+	p1 = static_cast<PAR_TAG>(p1 | p2);
+}
+
+
+inline
+void reset(PAR_TAG & p1, PAR_TAG const & p2)
+{
+	p1 = static_cast<PAR_TAG>(p1 & ~p2);
+}
+
+} // anon
+
+
+// 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
+{
+	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 = 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) << '>';
+		}
+
+		char 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>";
+	}
+}
+
+
+void Paragraph::simpleDocBookOnePar(Buffer const & buf,
+				    ostream & os,
+				    LyXFont const & outerfont,
+				    OutputParams const & runparams,
+				    lyx::depth_type depth,
+				    bool labelid) const
+{
+	bool emph_flag = false;
+
+	LyXLayout_ptr const & style = layout();
+	LyXLayout_ptr const & defaultstyle =
+		buf.params().getLyXTextClass().defaultLayout();
+
+	LyXFont font_old =
+		style->labeltype == LABEL_MANUAL ? style->labelfont : style->font;
+
+	int char_line_count = depth;
+	bool label_closed = true;
+	bool para_closed = true;
+	
+	if (style->latextype == LATEX_ITEM_ENVIRONMENT) {
+		string ls = "";
+		Counters & counters = buf.params().getLyXTextClass().counters();
+		if (!style->free_spacing)
+			os << string(depth,' ');
+		if (!style->labeltag().empty()) {
+			os << "<" << style->labeltag() << ">\n";
+			label_closed = false;
+		} else {
+			if (!defaultstyle->latexparam().empty()) {
+				counters.step("para");
+				ls = tostr(counters.value("para"));
+				ls = " id=\"" 
+					+ subst(defaultstyle->latexparam(), "#", ls) + '"';
+			}
+			os << "<" << style->itemtag() << ">\n" 
+			   << string(depth, ' ') << "<" 
+			   << defaultstyle->latexname() << ls << ">\n";
+			para_closed = false;
+		}
+	}
+
+	// parsing main loop
+	for (pos_type i = 0; i < size(); ++i) {
+		LyXFont font = getFont(buf.params(), i, outerfont);
+
+		// handle <emphasis> tag
+		if (font_old.emph() != font.emph()) {
+			if (font.emph() == LyXFont::ON) {
+				if (style->latexparam() == "CDATA")
+					os << "]]>";
+				os << "<emphasis>";
+				if (style->latexparam() == "CDATA")
+					os << "<![CDATA[";
+				emph_flag = true;
+			} else if (i) {
+				if (style->latexparam() == "CDATA")
+					os << "]]>";
+				os << "</emphasis>";
+				if (style->latexparam() == "CDATA")
+					os << "<![CDATA[";
+				emph_flag = false;
+			}
+		}
+
+
+		if (isInset(i)) {
+			InsetOld const * inset = getInset(i);
+			// don't print the inset in position 0 if desc_on == 3 (label)
+			//if (i || desc_on != 3) {
+			if (!labelid) {
+				if (style->latexparam() == "CDATA")
+					os << "]]>";
+				inset->docbook(buf, os, runparams);
+				if (style->latexparam() == "CDATA")
+					os << "<![CDATA[";
+			}
+		} else {
+			char c = getChar(i);
+			bool ws;
+			string str;
+			boost::tie(ws, str) = sgml::escapeChar(c);
+
+			if (style->pass_thru) {
+				os << c;
+			} else if (isFreeSpacing() || c != ' ') {
+					os << str;
+			} else if (!style->labeltag().empty() && !label_closed) {
+				++char_line_count;
+				os << "\n</" << style->labeltag() << "><" 
+				   << style->itemtag() << "><" 
+				   << defaultstyle->latexname() << ">";
+				label_closed = true;
+				para_closed = false;
+			} else {
+				os << ' ';
+			}
+		}
+		font_old = font;
+	}
+
+	if (emph_flag) {
+		if (style->latexparam() == "CDATA")
+			os << "]]>";
+		os << "</emphasis>";
+		if (style->latexparam() == "CDATA")
+			os << "<![CDATA[";
+	}
+
+	// resets description flag correctly
+	if (!label_closed) {
+		// <term> not closed...
+		os << "</" << style->labeltag() << ">\n<" 
+		   << style->itemtag() << "><" 
+		   << defaultstyle->latexname() << ">&nbsp;";
+	}
+	if (!para_closed) {
+		os << "\n" << string(depth, ' ') << "</" 
+		   << defaultstyle->latexname() << ">\n";
+	}
+	if (style->free_spacing)
+		os << '\n';
+}
+
+
 namespace {
 
 /// return true if the char is a meta-character for an inset
@@ -1182,7 +1573,17 @@ 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
+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;
@@ -1195,16 +1596,16 @@ string const Paragraph::asString(Buffer const & buffer, bool label) const
 			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',' ');
+			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 +1614,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,7 +1634,7 @@ string const Paragraph::asString(Buffer const & buffer,
 		if (IsPrintable(c))
 			os << c;
 		else if (c == META_INSET)
-			getInset(i)->ascii(buffer, os);
+			getInset(i)->plaintext(buffer, os, runparams);
 	}
 
 	return os.str();
@@ -1241,12 +1652,6 @@ void Paragraph::setInsetOwner(UpdatableInset * inset)
 }
 
 
-void Paragraph::deleteInsetsLyXText(BufferView * bv)
-{
-	insetlist.deleteInsetsLyXText(bv);
-}
-
-
 void Paragraph::setContentsFromPar(Paragraph const & par)
 {
 	pimpl_->setContentsFromPar(par);
@@ -1327,12 +1732,14 @@ 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);
 	BOOST_ASSERT(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';
 	}
 
@@ -1346,12 +1753,6 @@ int Paragraph::id() const
 }
 
 
-void Paragraph::id(int i)
-{
-	pimpl_->id_ = i;
-}
-
-
 LyXLayout_ptr const & Paragraph::layout() const
 {
 /*
@@ -1420,3 +1821,50 @@ bool Paragraph::allowEmpty() const
 		return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE;
 	return false;
 }
+
+
+RowList::iterator Paragraph::getRow(pos_type pos)
+{
+	RowList::iterator rit = rows.end();
+	RowList::iterator const begin = rows.begin();
+
+	for (--rit; rit != begin && rit->pos() > pos; --rit)
+		;
+
+	return rit;
+}
+
+
+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);
+	}
+}