X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextMetrics.cpp;h=4e70dc0b82091b5b207a45e49d8f3c43d648796d;hb=3d4076b598deb18660e50ec9c327efc3b15f15d0;hp=ce942ce3f2907def24e5020198f4ee53f0b867ec;hpb=f1cba8ff64b369792fd49f5ddf90e8126ab476ac;p=lyx.git

diff --git a/src/TextMetrics.cpp b/src/TextMetrics.cpp
index ce942ce3f2..4e70dc0b82 100644
--- a/src/TextMetrics.cpp
+++ b/src/TextMetrics.cpp
@@ -27,19 +27,21 @@
 #include "CoordCache.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
-#include "FuncRequest.h"
+#include "HSpace.h"
 #include "InsetList.h"
 #include "Layout.h"
 #include "Length.h"
 #include "LyXRC.h"
 #include "MetricsInfo.h"
-#include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
 #include "ParIterator.h"
 #include "rowpainter.h"
 #include "Text.h"
 #include "TextClass.h"
 #include "VSpace.h"
+#include "WordLangTuple.h"
+
+#include "insets/InsetText.h"
 
 #include "mathed/MacroTable.h"
 #include "mathed/MathMacroTemplate.h"
@@ -48,9 +50,12 @@
 #include "frontends/Painter.h"
 
 #include "support/debug.h"
-#include <cstdlib>
+#include "support/docstring_list.h"
+#include "support/gettext.h"
 #include "support/lassert.h"
 
+#include <cstdlib>
+
 using namespace std;
 
 
@@ -124,13 +129,11 @@ static int numberOfHfills(Paragraph const & par, Row const & row)
 TextMetrics::TextMetrics(BufferView * bv, Text * text)
 	: bv_(bv), text_(text)
 {
-	LASSERT(bv_, /**/);
+	LBUFERR(bv_);
 	max_width_ = bv_->workWidth();
 	dim_.wid = max_width_;
 	dim_.asc = 10;
 	dim_.des = 10;
-
-	//text_->updateLabels(bv->buffer());
 }
 
 
@@ -156,6 +159,7 @@ pair<pit_type, ParagraphMetrics const *> TextMetrics::first() const
 
 pair<pit_type, ParagraphMetrics const *> TextMetrics::last() const
 {
+	LBUFERR(!par_metrics_.empty());
 	ParMetricsCache::const_reverse_iterator it = par_metrics_.rbegin();
 	return make_pair(it->first, &it->second);
 }
@@ -174,20 +178,9 @@ ParagraphMetrics & TextMetrics::parMetrics(pit_type pit, bool redo)
 }
 
 
-int TextMetrics::parPosition(pit_type pit) const
-{
-	if (pit < par_metrics_.begin()->first)
-		return -1000000;
-	if (pit > par_metrics_.rbegin()->first)
-		return +1000000;
-
-	return par_metrics_[pit].position();
-}
-
-
 bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim, int min_width)
 {
-	LASSERT(mi.base.textwidth, /**/);
+	LBUFERR(mi.base.textwidth > 0);
 	max_width_ = mi.base.textwidth;
 	// backup old dimension.
 	Dimension const old_dim = dim_;
@@ -239,17 +232,15 @@ int TextMetrics::rightMargin(pit_type const pit) const
 
 void TextMetrics::applyOuterFont(Font & font) const
 {
-	Font lf(font_);
-	lf.fontInfo().reduce(bv_->buffer().params().getFont().fontInfo());
-	lf.fontInfo().realize(font.fontInfo());
-	lf.setLanguage(font.language());
-	font = lf;
+	FontInfo lf(font_.fontInfo());
+	lf.reduce(bv_->buffer().params().getFont().fontInfo());
+	font.fontInfo().realize(lf); 
 }
 
 
 Font TextMetrics::displayFont(pit_type pit, pos_type pos) const
 {
-	LASSERT(pos >= 0, /**/);
+	LASSERT(pos >= 0, { static Font f; return f; });
 
 	ParagraphList const & pars = text_->paragraphs();
 	Paragraph const & par = pars[pit];
@@ -262,7 +253,7 @@ Font TextMetrics::displayFont(pit_type pit, pos_type pos) const
 	// We specialize the 95% common case:
 	if (!par.getDepth()) {
 		Font f = par.getFontSettings(params, pos);
-		if (!text_->isMainText(buffer))
+		if (!text_->isMainText())
 			applyOuterFont(f);
 		bool lab = layout.labeltype == LABEL_MANUAL && pos < body_pos;
 
@@ -283,14 +274,14 @@ Font TextMetrics::displayFont(pit_type pit, pos_type pos) const
 	Font font = par.getFontSettings(params, pos);
 	font.fontInfo().realize(layoutfont);
 
-	if (!text_->isMainText(buffer))
+	if (!text_->isMainText())
 		applyOuterFont(font);
 
 	// Realize against environment font information
 	// NOTE: the cast to pit_type should be removed when pit_type
 	// changes to a unsigned integer.
 	if (pit < pit_type(pars.size()))
-		font.fontInfo().realize(outerFont(pit, pars).fontInfo());
+		font.fontInfo().realize(text_->outerFont(pit).fontInfo());
 
 	// Realize with the fonts of lesser depth.
 	font.fontInfo().realize(params.getFont().fontInfo());
@@ -314,38 +305,60 @@ bool TextMetrics::isRTL(CursorSlice const & sl, bool boundary) const
 
 bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos) const
 {
-	if (!lyxrc.rtl_support)
+	// no RTL boundary at paragraph start
+	if (!lyxrc.rtl_support || pos == 0)
 		return false;
 
-	// no RTL boundary at line start
-	if (pos == 0)
-		return false;
+	Font const & left_font = displayFont(pit, pos - 1);
 
-	Paragraph const & par = text_->getPar(pit);
-
-	bool left = displayFont(pit, pos - 1).isVisibleRightToLeft();
-	bool right;
-	if (pos == par.size())
-		right = par.isRTL(bv_->buffer().params());
-	else
-		right = displayFont(pit, pos).isVisibleRightToLeft();
-	return left != right;
+	return isRTLBoundary(pit, pos, left_font);
 }
 
 
+// isRTLBoundary returns false on a real end-of-line boundary,
+// because otherwise the two boundary types get mixed up.
+// This is the whole purpose of this being in TextMetrics.
 bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos,
 		Font const & font) const
 {
-	if (!lyxrc.rtl_support)
+	if (!lyxrc.rtl_support
+	    // no RTL boundary at paragraph start
+	    || pos == 0
+	    // if the metrics have not been calculated, then we are not
+	    // on screen and can safely ignore issues about boundaries.
+	    || !contains(pit))
+		return false;
+
+	ParagraphMetrics & pm = par_metrics_[pit];
+	// no RTL boundary in empty paragraph
+	if (pm.rows().empty())
+		return false;
+
+	pos_type endpos = pm.getRow(pos - 1, false).endpos();
+	pos_type startpos = pm.getRow(pos, false).pos();
+	// no RTL boundary at line start:
+	// abc\n   -> toggle to RTL ->    abc\n     (and not:    abc\n|
+	// |                              |                               )
+	if (pos == startpos && pos == endpos) // start of cur row, end of prev row
 		return false;
 
 	Paragraph const & par = text_->getPar(pit);
+	// no RTL boundary at line break:
+	// abc|\n    -> move right ->   abc\n       (and not:    abc\n|
+	// FED                          FED|                     FED     )
+	if (startpos == pos && endpos == pos && endpos != par.size() 
+		&& (par.isNewline(pos - 1) 
+			|| par.isLineSeparator(pos - 1) 
+			|| par.isSeparator(pos - 1)))
+		return false;
+	
 	bool left = font.isVisibleRightToLeft();
 	bool right;
 	if (pos == par.size())
 		right = par.isRTL(bv_->buffer().params());
 	else
 		right = displayFont(pit, pos).isVisibleRightToLeft();
+	
 	return left != right;
 }
 
@@ -353,7 +366,7 @@ bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos,
 bool TextMetrics::redoParagraph(pit_type const pit)
 {
 	Paragraph & par = text_->getPar(pit);
-	// IMPORTANT NOTE: We pass 'false' explicitely in order to not call
+	// IMPORTANT NOTE: We pass 'false' explicitly in order to not call
 	// redoParagraph() recursively inside parMetrics.
 	Dimension old_dim = parMetrics(pit, false).dim();
 	ParagraphMetrics & pm = par_metrics_[pit];
@@ -363,19 +376,28 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 	main_text_ = (text_ == &buffer.text());
 	bool changed = false;
 
+	// Check whether there are InsetBibItems that need fixing
 	// FIXME: This check ought to be done somewhere else. It is the reason
-	// why text_ is not	const. But then, where else to do it?
+	// why text_ is not const. But then, where else to do it?
 	// Well, how can you end up with either (a) a biblio environment that
 	// has no InsetBibitem or (b) a biblio environment with more than one
 	// InsetBibitem? I think the answer is: when paragraphs are merged;
 	// when layout is set; when material is pasted.
-	int const moveCursor = par.checkBiblio(buffer);
-	if (moveCursor > 0)
-		const_cast<Cursor &>(bv_->cursor()).posForward();
-	else if (moveCursor < 0) {
-		Cursor & cursor = const_cast<Cursor &>(bv_->cursor());
-		if (cursor.pos() >= -moveCursor)
-			cursor.posBackward();
+	if (par.brokenBiblio()) {
+		Cursor & cur = const_cast<Cursor &>(bv_->cursor());
+		// In some cases, we do not know how to record undo
+		if (&cur.inset() == &text_->inset())
+			cur.recordUndo(ATOMIC_UNDO, pit, pit);
+
+		int const moveCursor = par.fixBiblio(buffer);
+
+		// Is it necessary to update the cursor?
+		if (&cur.inset() == &text_->inset() && cur.pit() == pit) {
+			if (moveCursor > 0)
+				cur.posForward();
+			else if (moveCursor < 0 && cur.pos() >= -moveCursor)
+				cur.posBackward();
+		}
 	}
 
 	// Optimisation: this is used in the next two loops
@@ -390,19 +412,21 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 		LYXERR(Debug::INFO, "MacroContext not initialised!"
 			<< " Going through the buffer again and hope"
 			<< " the context is better then.");
-		updateLabels(bv_->buffer());
+		// FIXME audit updateBuffer calls
+		// This should not be here, but it is not clear yet where else it
+		// should be.
+		bv_->buffer().updateBuffer();
 		parPos = text_->macrocontextPosition();
-		LASSERT(!parPos.empty(), /**/);
+		LBUFERR(!parPos.empty());
 		parPos.pit() = pit;
 	}
 
 	// redo insets
-	// FIXME: We should always use getFont(), see documentation of
-	// noFontChange() in Inset.h.
 	Font const bufferfont = buffer.params().getFont();
 	InsetList::const_iterator ii = par.insetList().begin();
 	InsetList::const_iterator iend = par.insetList().end();
 	for (; ii != iend; ++ii) {
+		// FIXME Doesn't this HAVE to be non-empty?
 		// position already initialized?
 		if (!parPos.empty()) {
 			parPos.pos() = ii->pos;
@@ -419,9 +443,9 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 		Dimension dim;
 		int const w = max_width_ - leftMargin(max_width_, pit, ii->pos)
 			- right_margin;
-		Font const & font = ii->inset->noFontChange() ?
-			bufferfont : displayFont(pit, ii->pos);
-		MacroContext mc(buffer, parPos);
+		Font const & font = ii->inset->inheritFont() ?
+			displayFont(pit, ii->pos) : bufferfont;
+		MacroContext mc(&buffer, parPos);
 		MetricsInfo mi(bv_, font.fontInfo(), w, mc);
 		ii->inset->metrics(mi, dim);
 		Dimension const old_dim = pm.insetDimension(ii->inset);
@@ -498,7 +522,6 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 	row.label_hfill = 0;
 	row.separator = 0;
 
-	Buffer & buffer = bv_->buffer();
 	Paragraph const & par = text_->getPar(pit);
 
 	double w = width - row.width();
@@ -509,7 +532,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 	//lyxerr << "row.width() " << row.width() << endl;
 	//lyxerr << "w " << w << endl;
 
-	bool const is_rtl = text_->isRTL(buffer, par);
+	bool const is_rtl = text_->isRTL(par);
 	if (is_rtl)
 		row.x = rightMargin(pit);
 	else
@@ -553,7 +576,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 			align = par.params().align();
 
 		// handle alignment inside tabular cells
-		Inset const & owner = par.inInset();
+		Inset const & owner = text_->inset();
 		switch (owner.contentAlignment()) {
 			case LYX_ALIGN_CENTER:
 			case LYX_ALIGN_LEFT:
@@ -567,7 +590,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 				break;
 		}
 
-		// Display-style insets should always be on a centred row
+		// Display-style insets should always be on a centered row
 		if (Inset const * inset = par.getInset(row.pos())) {
 			switch (inset->display()) {
 				case Inset::AlignLeft:
@@ -577,12 +600,19 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 					align = LYX_ALIGN_CENTER;
 					break;
 				case Inset::Inline:
-				case Inset::AlignRight:
 					// unchanged (use align)
 					break;
+				case Inset::AlignRight:
+					align = LYX_ALIGN_RIGHT;
+					break;
 			}
 		}
 
+		// Has the user requested we not justify stuff?
+		if (!bv_->buffer().params().justification
+		    && align == LYX_ALIGN_BLOCK)
+			align = LYX_ALIGN_LEFT;
+
 		switch (align) {
 		case LYX_ALIGN_BLOCK: {
 			int const ns = numberOfSeparators(par, row);
@@ -624,7 +654,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 		if (body_pos > 0
 		    && (body_pos > end || !par.isLineSeparator(body_pos - 1)))
 		{
-			row.x += theFontMetrics(text_->labelFont(buffer, par)).
+			row.x += theFontMetrics(text_->labelFont(par)).
 				width(layout.labelsep);
 			if (body_pos <= end)
 				row.x += row.label_hfill;
@@ -660,11 +690,10 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 
 int TextMetrics::labelFill(pit_type const pit, Row const & row) const
 {
-	Buffer & buffer = bv_->buffer();
 	Paragraph const & par = text_->getPar(pit);
 
 	pos_type last = par.beginOfBody();
-	LASSERT(last > 0, /**/);
+	LBUFERR(last > 0);
 
 	// -1 because a label ends with a space that is in the label
 	--last;
@@ -682,12 +711,14 @@ int TextMetrics::labelFill(pit_type const pit, Row const & row) const
 		return 0;
 
 	FontMetrics const & fm
-		= theFontMetrics(text_->labelFont(buffer, par));
+		= theFontMetrics(text_->labelFont(par));
 
 	return max(0, fm.width(label) - w);
 }
 
 
+#if 0
+// Not used, see TextMetrics::rowBreakPoint. 
 // this needs special handling - only newlines count as a break point
 static pos_type addressBreakPoint(pos_type i, Paragraph const & par)
 {
@@ -699,6 +730,7 @@ static pos_type addressBreakPoint(pos_type i, Paragraph const & par)
 
 	return end;
 }
+#endif
 
 
 int TextMetrics::labelEnd(pit_type const pit) const
@@ -739,7 +771,7 @@ public:
 	FontIterator & operator++()
 	{
 		++pos_;
-		if (pos_ > endspan_ || pos_ == bodypos_) {
+		if (pos_ < par_.size() && (pos_ > endspan_ || pos_ == bodypos_)) {
 			font_ = tm_.displayFont(pit_, pos_);
 			endspan_ = par_.fontSpan(pos_).last;
 		}
@@ -768,10 +800,9 @@ private:
 
 } // anon namespace
 
-pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
-		pit_type pos) const
+pos_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
+		pos_type pos) const
 {
-	Buffer & buffer = bv_->buffer();
 	ParagraphMetrics const & pm = par_metrics_[pit];
 	Paragraph const & par = text_->getPar(pit);
 	pos_type const end = par.size();
@@ -780,8 +811,13 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
 
 	Layout const & layout = par.layout();
 
+#if 0
+	//FIXME: As long as leftMargin() is not correctly implemented for 
+	// MARGIN_RIGHT_ADDRESS_BOX, we should also not do this here.
+	// Otherwise, long rows will be painted off the screen.
 	if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX)
 		return addressBreakPoint(pos, par);
+#endif
 
 	pos_type const body_pos = par.beginOfBody();
 
@@ -806,11 +842,24 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
 	// pixel width since last breakpoint
 	int chunkwidth = 0;
 
+	docstring const s(1, char_type(0x00B6));
+	Font f;
+	int par_marker_width = theFontMetrics(f).width(s);
+
 	FontIterator fi = FontIterator(*this, par, pit, pos);
 	pos_type point = end;
 	pos_type i = pos;
+
+	ParagraphList const & pars_ = text_->paragraphs();
+	bool const draw_par_end_marker = lyxrc.paragraph_markers
+		&& size_type(pit + 1) < pars_.size();
+				
 	for ( ; i < end; ++i, ++fi) {
 		int thiswidth = pm.singleWidth(i, *fi);
+		
+		if (draw_par_end_marker && i == end - 1)
+			// enlarge the last character to hold the end-of-par marker
+			thiswidth += par_marker_width;
 
 		// add inline completion width
 		if (inlineCompletionLPos == i) {
@@ -822,7 +871,7 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
 		// add the auto-hfill from label end to the body
 		if (body_pos && i == body_pos) {
 			FontMetrics const & fm = theFontMetrics(
-				text_->labelFont(buffer, par));
+				text_->labelFont(par));
 			int add = fm.width(layout.labelsep);
 			if (par.isLineSeparator(i - 1))
 				add -= singleWidth(pit, i - 1);
@@ -894,7 +943,6 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
 int TextMetrics::rowWidth(int right_margin, pit_type const pit,
 		pos_type const first, pos_type const end) const
 {
-	Buffer & buffer = bv_->buffer();
 	// get the pure distance
 	ParagraphMetrics const & pm = par_metrics_[pit];
 	Paragraph const & par = text_->getPar(pit);
@@ -919,13 +967,18 @@ int TextMetrics::rowWidth(int right_margin, pit_type const pit,
 		for ( ; i < end; ++i, ++fi) {
 			if (body_pos > 0 && i == body_pos) {
 				FontMetrics const & fm = theFontMetrics(
-					text_->labelFont(buffer, par));
+					text_->labelFont(par));
 				w += fm.width(par.layout().labelsep);
 				if (par.isLineSeparator(i - 1))
 					w -= singleWidth(pit, i - 1);
 				w = max(w, label_end);
 			}
-			w += pm.singleWidth(i, *fi);
+			
+			// a line separator at the end of a line (but not at the end of a 
+			// paragraph) will not be drawn and should therefore not count for
+			// the row width.
+			if (!par.isLineSeparator(i) || i != end - 1 || end == par.size())
+				w += pm.singleWidth(i, *fi);
 
 			// add inline completion width
 			if (inlineCompletionLPos == i) {
@@ -936,9 +989,21 @@ int TextMetrics::rowWidth(int right_margin, pit_type const pit,
 		}
 	}
 
+	// count the paragraph end marker.
+	if (end == par.size() && lyxrc.paragraph_markers) {
+		ParagraphList const & pars_ = text_->paragraphs();
+		if (size_type(pit + 1) < pars_.size()) {
+			// enlarge the last character to hold the
+			// end-of-par marker
+			docstring const s(1, char_type(0x00B6));
+			Font f;
+			w += theFontMetrics(f).width(s);
+		}
+	}
+
 	if (body_pos > 0 && body_pos >= end) {
 		FontMetrics const & fm = theFontMetrics(
-			text_->labelFont(buffer, par));
+			text_->labelFont(par));
 		w += fm.width(par.layout().labelsep);
 		if (end > 0 && par.isLineSeparator(end - 1))
 			w -= singleWidth(pit, end - 1);
@@ -970,18 +1035,18 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	Buffer const & buffer = bv_->buffer();
 	Font font = displayFont(pit, first);
 	FontSize const tmpsize = font.fontInfo().size();
-	font.fontInfo() = text_->layoutFont(buffer, pit);
+	font.fontInfo() = text_->layoutFont(pit);
 	FontSize const size = font.fontInfo().size();
 	font.fontInfo().setSize(tmpsize);
 
-	FontInfo labelfont = text_->labelFont(buffer, par);
+	FontInfo labelfont = text_->labelFont(par);
 
 	FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
 	FontMetrics const & fontmetrics = theFontMetrics(font);
 
 	// these are minimum values
 	double const spacing_val = layout.spacing.getValue()
-		* text_->spacing(buffer, par);
+		* text_->spacing(par);
 	//lyxerr << "spacing_val = " << spacing_val << endl;
 	int maxasc  = int(fontmetrics.maxAscent()  * spacing_val);
 	int maxdesc = int(fontmetrics.maxDescent() * spacing_val);
@@ -991,8 +1056,8 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	InsetList::const_iterator ii = par.insetList().begin();
 	InsetList::const_iterator iend = par.insetList().end();
 	for ( ; ii != iend; ++ii) {
-		Dimension const & dim = pm.insetDimension(ii->inset);
 		if (ii->pos >= first && ii->pos < end) {
+			Dimension const & dim = pm.insetDimension(ii->inset);
 			maxasc  = max(maxasc,  dim.ascent());
 			maxdesc = max(maxdesc, dim.descent());
 		}
@@ -1019,46 +1084,34 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	++maxdesc;
 
 	ParagraphList const & pars = text_->paragraphs();
+	Inset const & inset = text_->inset();
 
 	// is it a top line?
 	if (first == 0 && topBottomSpace) {
 		BufferParams const & bufparams = buffer.params();
 		// some parskips VERY EASY IMPLEMENTATION
-		if (bufparams.paragraph_separation
-		    == BufferParams::ParagraphSkipSeparation
-			&& par.ownerCode() != ERT_CODE
-			&& par.ownerCode() != LISTINGS_CODE
-			&& pit > 0
-			&& ((layout.isParagraph() && par.getDepth() == 0)
-			    || (pars[pit - 1].layout().isParagraph()
-				&& pars[pit - 1].getDepth() == 0)))
-		{
-				maxasc += bufparams.getDefSkip().inPixels(*bv_);
+		if (bufparams.paragraph_separation == BufferParams::ParagraphSkipSeparation
+		    && !inset.getLayout().parbreakIsNewline()
+		    && !par.layout().parbreak_is_newline
+		    && pit > 0
+		    && ((layout.isParagraph() && par.getDepth() == 0)
+			|| (pars[pit - 1].layout().isParagraph()
+			    && pars[pit - 1].getDepth() == 0))) {
+			maxasc += bufparams.getDefSkip().inPixels(*bv_);
 		}
 
 		if (par.params().startOfAppendix())
 			maxasc += int(3 * dh);
 
-		// This is special code for the chapter, since the label of this
-		// layout is printed in an extra row
-		if (layout.counter == "chapter"
-		    && !par.params().labelString().empty()) {
-			labeladdon = int(labelfont_metrics.maxHeight()
-				     * layout.spacing.getValue()
-				     * text_->spacing(buffer, par));
-		}
-
 		// special code for the top label
-		if ((layout.labeltype == LABEL_TOP_ENVIRONMENT
-		     || layout.labeltype == LABEL_BIBLIO
-		     || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)
-		    && isFirstInSequence(pit, pars)
+		if (layout.labelIsAbove()
+		    && (!layout.isParagraphGroup() || text_->isFirstInSequence(pit))
 		    && !par.labelString().empty())
 		{
 			labeladdon = int(
 				  labelfont_metrics.maxHeight()
 					* layout.spacing.getValue()
-					* text_->spacing(buffer, par)
+					* text_->spacing(par)
 				+ (layout.topsep + layout.labelbottomsep) * dh);
 		}
 
@@ -1066,7 +1119,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 		// a section, or between the items of a itemize or enumerate
 		// environment.
 
-		pit_type prev = depthHook(pit, pars, par.getDepth());
+		pit_type prev = text_->depthHook(pit, par.getDepth());
 		Paragraph const & prevpar = pars[prev];
 		if (prev != pit
 		    && prevpar.layout() == layout
@@ -1079,7 +1132,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 				layoutasc = layout.topsep * dh;
 		}
 
-		prev = outerHook(pit, pars);
+		prev = text_->outerHook(pit);
 		if (prev != pit_type(pars.size())) {
 			maxasc += int(pars[prev].layout().parsep * dh);
 		} else if (pit != 0) {
@@ -1104,7 +1157,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 
 			if (pars[cpit].getDepth() > pars[nextpit].getDepth()) {
 				usual = pars[cpit].layout().bottomsep * dh;
-				cpit = depthHook(cpit, pars, pars[nextpit].getDepth());
+				cpit = text_->depthHook(cpit, pars[nextpit].getDepth());
 				if (pars[cpit].layout() != pars[nextpit].layout()
 					|| pars[nextpit].getLabelWidthString() != pars[cpit].getLabelWidthString())
 				{
@@ -1179,12 +1232,27 @@ pos_type TextMetrics::getColumnNearX(pit_type const pit,
 		return 0;
 	}
 
+	// This (rtl_support test) is not needed, but gives
+	// some speedup if rtl_support == false
+	bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size();
+
+	// If lastrow is false, we don't need to compute
+	// the value of rtl.
+	bool const rtl_on_lastrow = lastrow ? text_->isRTL(par) : false;
+
+	// if the first character is a separator, and we are in RTL
+	// text, this character will not be painted on screen
+	// and thus we should not count it and skip to the next. Only
+	// in freespacing paragraphs, this first character is painted.
+	if (!par.isFreeSpacing() && par.isSeparator(bidi.vis2log(vc)))
+		++vc;
+
 	while (vc < end && tmpx <= x) {
 		c = bidi.vis2log(vc);
 		last_tmpx = tmpx;
 		if (body_pos > 0 && c == body_pos - 1) {
 			FontMetrics const & fm = theFontMetrics(
-				text_->labelFont(buffer, par));
+				text_->labelFont(par));
 			tmpx += row.label_hfill + fm.width(layout.labelsep);
 			if (par.isLineSeparator(body_pos - 1))
 				tmpx -= singleWidth(pit, body_pos - 1);
@@ -1201,19 +1269,14 @@ pos_type TextMetrics::getColumnNearX(pit_type const pit,
 		left_side = true;
 	}
 
-	LASSERT(vc <= end, /**/);  // This shouldn't happen.
+	// This shouldn't happen. But we can reset and try to continue.
+	LASSERT(vc <= end, vc = end);
 
 	boundary = false;
-	// This (rtl_support test) is not needed, but gives
-	// some speedup if rtl_support == false
-	bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size();
 
-	// If lastrow is false, we don't need to compute
-	// the value of rtl.
-	bool const rtl = lastrow ? text_->isRTL(buffer, par) : false;
 	if (lastrow &&
-	    ((rtl  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
-	     (!rtl && !left_side && vc == end  && x > tmpx + 5))) {
+	    ((rtl_on_lastrow  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
+	     (!rtl_on_lastrow && !left_side && vc == end  && x > tmpx + 5))) {
 		if (!par.isNewline(end - 1))
 			c = end;
 	} else if (vc == row.pos()) {
@@ -1280,7 +1343,7 @@ pos_type TextMetrics::x2pos(pit_type pit, int row, int x) const
 	// upDownInText() while in selection mode.
 	ParagraphMetrics const & pm = parMetrics(pit);
 
-	LASSERT(row < int(pm.rows().size()), /**/);
+	LBUFERR(row < int(pm.rows().size()));
 	bool bound = false;
 	Row const & r = pm.rows()[row];
 	return r.pos() + getColumnNearX(pit, r, x, bound);
@@ -1326,7 +1389,8 @@ pit_type TextMetrics::getPitNearY(int y)
 	int yy = -1;
 	ParMetricsCache::const_iterator it = par_metrics_.begin();
 	ParMetricsCache::const_iterator et = par_metrics_.end();
-	ParMetricsCache::const_iterator last = et; last--;
+	ParMetricsCache::const_iterator last = et;
+	--last;
 
 	ParagraphMetrics const & pm = it->second;
 
@@ -1347,7 +1411,7 @@ pit_type TextMetrics::getPitNearY(int y)
 
 	if (y >= last->second.position() + int(pm_last.descent())) {
 		// We are looking for a position that is after the last paragraph in
-		// the cache (which is in priciple off-screen, that is before the
+		// the cache (which is in priciple off-screen), that is before the
 		// visible part.
 		pit = last->first + 1;
 		if (pit == int(text_->paragraphs().size()))
@@ -1376,25 +1440,54 @@ pit_type TextMetrics::getPitNearY(int y)
 }
 
 
-Row const & TextMetrics::getRowNearY(int y, pit_type pit) const
+Row const & TextMetrics::getPitAndRowNearY(int & y, pit_type & pit,
+	bool assert_in_view, bool up)
 {
 	ParagraphMetrics const & pm = par_metrics_[pit];
 
 	int yy = pm.position() - pm.ascent();
-	LASSERT(!pm.rows().empty(), /**/);
+	LBUFERR(!pm.rows().empty());
 	RowList::const_iterator rit = pm.rows().begin();
 	RowList::const_iterator rlast = pm.rows().end();
 	--rlast;
 	for (; rit != rlast; yy += rit->height(), ++rit)
 		if (yy + rit->height() > y)
 			break;
+
+	if (assert_in_view) {
+		if (!up && yy + rit->height() > y) {
+			if (rit != pm.rows().begin()) {
+				y = yy;
+				--rit;
+			} else if (pit != 0) {
+				--pit;
+				newParMetricsUp();
+				ParagraphMetrics const & pm2 = par_metrics_[pit];
+				rit = pm2.rows().end();
+				--rit;
+				y = yy;
+			}
+		} else if (up && yy != y) {
+			if (rit != rlast) {
+				y = yy + rit->height();
+				++rit;
+			} else if (pit < int(text_->paragraphs().size()) - 1) {
+				++pit;
+				newParMetricsDown();
+				ParagraphMetrics const & pm2 = par_metrics_[pit];
+				rit = pm2.rows().begin();
+				y = pm2.position();
+			}
+		}
+	}
 	return *rit;
 }
 
 
 // x,y are absolute screen coordinates
 // sets cursor recursively descending into nested editable insets
-Inset * TextMetrics::editXY(Cursor & cur, int x, int y)
+Inset * TextMetrics::editXY(Cursor & cur, int x, int y,
+	bool assert_in_view, bool up)
 {
 	if (lyxerr.debugging(Debug::WORKAREA)) {
 		LYXERR0("TextMetrics::editXY(cur, " << x << ", " << y << ")");
@@ -1402,10 +1495,11 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y)
 	}
 	pit_type pit = getPitNearY(y);
 	LASSERT(pit != -1, return 0);
+	
+	int yy = y; // is modified by getPitAndRowNearY
+	Row const & row = getPitAndRowNearY(yy, pit, assert_in_view, up);
 
-	Row const & row = getRowNearY(y, pit);
-	bool bound = false;
-
+	bool bound = false; // is modified by getColumnNearX
 	int xx = x; // is modified by getColumnNearX
 	pos_type const pos = row.pos()
 		+ getColumnNearX(pit, row, xx, bound);
@@ -1415,7 +1509,7 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y)
 	cur.setTargetX(x);
 
 	// try to descend into nested insets
-	Inset * inset = checkInsetHit(x, y);
+	Inset * inset = checkInsetHit(x, yy);
 	//lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
 	if (!inset) {
 		// Either we deconst editXY or better we move current_font
@@ -1427,23 +1521,22 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y)
 	}
 
 	ParagraphList const & pars = text_->paragraphs();
-	Inset const * insetBefore = pos? pars[pit].getInset(pos - 1): 0;
-	//Inset * insetBehind = pars[pit].getInset(pos);
+	Inset const * inset_before = pos ? pars[pit].getInset(pos - 1) : 0;
 
 	// This should be just before or just behind the
 	// cursor position set above.
-	LASSERT((pos != 0 && inset == insetBefore)
-		|| inset == pars[pit].getInset(pos), /**/);
+	LASSERT(inset == inset_before 
+		|| inset == pars[pit].getInset(pos), return 0);
 
 	// Make sure the cursor points to the position before
 	// this inset.
-	if (inset == insetBefore) {
+	if (inset == inset_before) {
 		--cur.pos();
 		cur.boundary(false);
 	}
 
 	// Try to descend recursively inside the inset.
-	inset = inset->editXY(cur, x, y);
+	inset = inset->editXY(cur, x, yy);
 
 	if (cur.top().text() == text_)
 		cur.setCurrentFont();
@@ -1453,8 +1546,8 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y)
 
 void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const y)
 {
-	LASSERT(text_ == cur.text(), /**/);
-	pit_type pit = getPitNearY(y);
+	LASSERT(text_ == cur.text(), return);
+	pit_type const pit = getPitNearY(y);
 	LASSERT(pit != -1, return);
 
 	ParagraphMetrics const & pm = par_metrics_[pit];
@@ -1464,7 +1557,7 @@ void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const
 		" pit: " << pit << " yy: " << yy);
 
 	int r = 0;
-	LASSERT(pm.rows().size(), /**/);
+	LBUFERR(pm.rows().size());
 	for (; r < int(pm.rows().size()) - 1; ++r) {
 		Row const & row = pm.rows()[r];
 		if (int(yy + row.height()) > y)
@@ -1534,7 +1627,7 @@ Inset * TextMetrics::checkInsetHit(int x, int y)
 int TextMetrics::cursorX(CursorSlice const & sl,
 		bool boundary) const
 {
-	LASSERT(sl.text() == text_, /**/);
+	LASSERT(sl.text() == text_, return 0);
 	pit_type const pit = sl.pit();
 	Paragraph const & par = text_->paragraphs()[pit];
 	ParagraphMetrics const & pm = par_metrics_[pit];
@@ -1568,8 +1661,10 @@ int TextMetrics::cursorX(CursorSlice const & sl,
 	if (end <= row_pos)
 		cursor_vpos = row_pos;
 	else if (ppos >= end)
-		cursor_vpos = text_->isRTL(buffer, par) ? row_pos : end;
+		cursor_vpos = text_->isRTL(par) ? row_pos : end;
 	else if (ppos > row_pos && ppos >= end)
+		//FIXME: this code is never reached!
+		//       (see http://www.lyx.org/trac/changeset/8251)
 		// Place cursor after char at (logical) position pos - 1
 		cursor_vpos = (bidi.level(ppos - 1) % 2 == 0)
 			? bidi.log2vis(ppos - 1) + 1 : bidi.log2vis(ppos - 1);
@@ -1604,6 +1699,15 @@ int TextMetrics::cursorX(CursorSlice const & sl,
 	if (end > 0 && end < par.size() && par.isSeparator(end - 1))
 		skipped_sep_vpos = bidi.log2vis(end - 1);
 
+	if (lyxrc.paragraph_markers && text_->isRTL(par)) {
+		ParagraphList const & pars_ = text_->paragraphs();
+		if (size_type(pit + 1) < pars_.size()) {
+			FontInfo f;
+			docstring const s = docstring(1, char_type(0x00B6));
+			x += theFontMetrics(f).width(s);
+		}
+	}
+
 	// Inline completion RTL special case row_pos == cursor_pos:
 	// "__|b" => cursor_pos is right of __
 	if (row_pos == inlineCompletionVPos && row_pos == cursor_vpos) {
@@ -1620,7 +1724,7 @@ int TextMetrics::cursorX(CursorSlice const & sl,
 		pos_type pos = bidi.vis2log(vpos);
 		if (body_pos > 0 && pos == body_pos - 1) {
 			FontMetrics const & labelfm = theFontMetrics(
-				text_->labelFont(buffer, par));
+				text_->labelFont(par));
 			x += row.label_hfill + labelfm.width(par.layout().labelsep);
 			if (par.isLineSeparator(body_pos - 1))
 				x -= singleWidth(pit, body_pos - 1);
@@ -1698,7 +1802,7 @@ int TextMetrics::cursorY(CursorSlice const & sl, bool boundary) const
 
 bool TextMetrics::cursorHome(Cursor & cur)
 {
-	LASSERT(text_ == cur.text(), /**/);
+	LASSERT(text_ == cur.text(), return false);
 	ParagraphMetrics const & pm = par_metrics_[cur.pit()];
 	Row const & row = pm.getRow(cur.pos(),cur.boundary());
 	return text_->setCursor(cur, cur.pit(), row.pos());
@@ -1707,7 +1811,7 @@ bool TextMetrics::cursorHome(Cursor & cur)
 
 bool TextMetrics::cursorEnd(Cursor & cur)
 {
-	LASSERT(text_ == cur.text(), /**/);
+	LASSERT(text_ == cur.text(), return false);
 	// if not on the last row of the par, put the cursor before
 	// the final space exept if I have a spanning inset or one string
 	// is so long that we force a break.
@@ -1729,7 +1833,7 @@ bool TextMetrics::cursorEnd(Cursor & cur)
 
 void TextMetrics::deleteLineForward(Cursor & cur)
 {
-	LASSERT(text_ == cur.text(), /**/);
+	LASSERT(text_ == cur.text(), return);
 	if (cur.lastpos() == 0) {
 		// Paragraph is empty, so we just go forward
 		text_->cursorForward(cur);
@@ -1764,8 +1868,6 @@ bool TextMetrics::isFirstRow(pit_type pit, Row const & row) const
 
 int TextMetrics::leftMargin(int max_width, pit_type pit) const
 {
-	LASSERT(pit >= 0, /**/);
-	LASSERT(pit < int(text_->paragraphs().size()), /**/);
 	return leftMargin(max_width, pit, text_->paragraphs()[pit].size());
 }
 
@@ -1775,11 +1877,11 @@ int TextMetrics::leftMargin(int max_width,
 {
 	ParagraphList const & pars = text_->paragraphs();
 
-	LASSERT(pit >= 0, /**/);
-	LASSERT(pit < int(pars.size()), /**/);
+	LASSERT(pit >= 0, return 0);
+	LASSERT(pit < int(pars.size()), return 0);
 	Paragraph const & par = pars[pit];
-	LASSERT(pos >= 0, /**/);
-	LASSERT(pos <= par.size(), /**/);
+	LASSERT(pos >= 0, return 0);
+	LASSERT(pos <= par.size(), return 0);
 	Buffer const & buffer = bv_->buffer();
 	//lyxerr << "TextMetrics::leftMargin: pit: " << pit << " pos: " << pos << endl;
 	DocumentClass const & tclass = buffer.params().documentClass();
@@ -1789,7 +1891,7 @@ int TextMetrics::leftMargin(int max_width,
 
 	int l_margin = 0;
 
-	if (text_->isMainText(buffer))
+	if (text_->isMainText())
 		l_margin += bv_->leftMargin();
 
 	l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
@@ -1797,7 +1899,7 @@ int TextMetrics::leftMargin(int max_width,
 
 	if (par.getDepth() != 0) {
 		// find the next level paragraph
-		pit_type newpar = outerHook(pit, pars);
+		pit_type newpar = text_->outerHook(pit);
 		if (newpar != pit_type(pars.size())) {
 			if (pars[newpar].layout().isEnvironment()) {
 				l_margin = leftMargin(max_width, newpar);
@@ -1819,7 +1921,7 @@ int TextMetrics::leftMargin(int max_width,
 	    && pit > 0 && pars[pit - 1].layout().nextnoindent)
 		parindent.erase();
 
-	FontInfo const labelfont = text_->labelFont(buffer, par);
+	FontInfo const labelfont = text_->labelFont(par);
 	FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
 
 	switch (layout.margintype) {
@@ -1856,22 +1958,19 @@ int TextMetrics::leftMargin(int max_width,
 
 	case MARGIN_FIRST_DYNAMIC:
 		if (layout.labeltype == LABEL_MANUAL) {
-			if (pos >= par.beginOfBody()) {
+			// if we are at position 0, we are never in the body
+			if (pos > 0 && pos >= par.beginOfBody())
 				l_margin += labelfont_metrics.signedWidth(layout.leftmargin);
-			} else {
+			else
 				l_margin += labelfont_metrics.signedWidth(layout.labelindent);
-			}
 		} else if (pos != 0
 			   // Special case to fix problems with
 			   // theorems (JMarc)
 			   || (layout.labeltype == LABEL_STATIC
 			       && layout.latextype == LATEX_ENVIRONMENT
-			       && !isFirstInSequence(pit, pars))) {
+			       && !text_->isFirstInSequence(pit))) {
 			l_margin += labelfont_metrics.signedWidth(layout.leftmargin);
-		} else if (layout.labeltype != LABEL_TOP_ENVIRONMENT
-			   && layout.labeltype != LABEL_BIBLIO
-			   && layout.labeltype !=
-			   LABEL_CENTERED_TOP_ENVIRONMENT) {
+		} else if (!layout.labelIsAbove()) {
 			l_margin += labelfont_metrics.signedWidth(layout.labelindent);
 			l_margin += labelfont_metrics.width(layout.labelsep);
 			l_margin += labelfont_metrics.width(par.labelString());
@@ -1880,16 +1979,18 @@ int TextMetrics::leftMargin(int max_width,
 
 	case MARGIN_RIGHT_ADDRESS_BOX: {
 #if 0
-		// ok, a terrible hack. The left margin depends on the widest
-		// row in this paragraph.
-		RowList::iterator rit = par.rows().begin();
-		RowList::iterator end = par.rows().end();
-		// FIXME: This is wrong.
+		// The left margin depends on the widest row in this paragraph.
+		// This code is wrong because it depends on the rows, but at the
+		// same time this function is used in redoParagraph to construct
+		// the rows. 
+		ParagraphMetrics const & pm = par_metrics_[pit];
+		RowList::const_iterator rit = pm.rows().begin();
+		RowList::const_iterator end = pm.rows().end();
 		int minfill = max_width;
 		for ( ; rit != end; ++rit)
 			if (rit->fill() < minfill)
 				minfill = rit->fill();
-		l_margin += theFontMetrics(params.getFont()).signedWidth(layout.leftmargin);
+		l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(layout.leftmargin);
 		l_margin += minfill;
 #endif
 		// also wrong, but much shorter.
@@ -1911,28 +2012,34 @@ int TextMetrics::leftMargin(int max_width,
 	// set the correct parindent
 	if (pos == 0
 	    && (layout.labeltype == LABEL_NO_LABEL
-	       || layout.labeltype == LABEL_TOP_ENVIRONMENT
-	       || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT
+	       || layout.labeltype == LABEL_ABOVE
+	       || layout.labeltype == LABEL_CENTERED
 	       || (layout.labeltype == LABEL_STATIC
 	           && layout.latextype == LATEX_ENVIRONMENT
-	           && !isFirstInSequence(pit, pars)))
-	    && align == LYX_ALIGN_BLOCK
+	           && !text_->isFirstInSequence(pit)))
+	    && (align == LYX_ALIGN_BLOCK || align == LYX_ALIGN_LEFT)
 	    && !par.params().noindent()
 	    // in some insets, paragraphs are never indented
-	    && !par.inInset().neverIndent()
+	    && !text_->inset().neverIndent()
 	    // display style insets are always centered, omit indentation
 	    && !(!par.empty()
 		    && par.isInset(pos)
 		    && par.getInset(pos)->display())
 			&& (!(tclass.isDefaultLayout(par.layout())
 	         || tclass.isPlainLayout(par.layout()))
-	        || buffer.params().paragraph_separation == BufferParams::ParagraphIndentSeparation)
+	        || buffer.params().paragraph_separation 
+				== BufferParams::ParagraphIndentSeparation)
 	    )
-	{
-		l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
-			parindent);
-	}
-
+		{
+			// use the parindent of the layout when the default indentation is
+			// used otherwise use the indentation set in the document settings
+			if (buffer.params().getIndentation().asLyXCommand() == "default")
+				l_margin += theFontMetrics(
+					buffer.params().getFont()).signedWidth(parindent);
+			else
+				l_margin += buffer.params().getIndentation().inPixels(*bv_);
+		}
+	
 	return l_margin;
 }
 
@@ -1987,7 +2094,7 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 		// This is our text.
 		&& cur.text() == text_
 		// if the anchor is outside, this is not our selection
-		&& cur.anchor().text() == text_
+		&& cur.normalAnchor().text() == text_
 		&& pit >= sel_beg.pit() && pit <= sel_end.pit();
 
 	// We store the begin and end pos of the selection relative to this par
@@ -2036,6 +2143,11 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 		row.setCrc(pm.computeRowSignature(row, bparams));
 		bool row_has_changed = row.changed();
 
+		// Take this opportunity to spellcheck the row contents.
+		if (row_has_changed && lyxrc.spellcheck_continuously) {
+			text_->getPar(pit).spellCheck();
+		}
+
 		// Don't paint the row if a full repaint has not been requested
 		// and if it has not changed.
 		if (!pi.full_repaint && !row_has_changed) {
@@ -2053,14 +2165,11 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 				width(), row.height(), pi.background_color);
 		}
 		
-		if (row.selection())
-			drawRowSelection(pi, x, row, cur, pit);
-
 		// Instrumentation for testing row cache (see also
 		// 12 lines lower):
 		if (lyxerr.debugging(Debug::PAINTING) && inside
 			&& (row.selection() || pi.full_repaint || row_has_changed)) {
-				string const foreword = text_->isMainText(bv_->buffer()) ?
+				string const foreword = text_->isMainText() ?
 					"main text redraw " : "inset text redraw: ";
 			LYXERR(Debug::PAINTING, foreword << "pit=" << pit << " row=" << i
 				<< " row_selection="	<< row.selection()
@@ -2072,15 +2181,23 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 		// for inner insets as the Row has been cleared out.
 		bool tmp = pi.full_repaint;
 		pi.full_repaint = true;
+
+		rp.paintSelection();
 		rp.paintAppendix();
 		rp.paintDepthBar();
 		rp.paintChangeBar();
-		if (i == 0)
+		bool const is_rtl = text_->isRTL(text_->getPar(pit));
+		if (i == 0 && !is_rtl)
 			rp.paintFirst();
+		if (i == nrows - 1 && is_rtl)
+			rp.paintLast();
 		rp.paintText();
-		if (i == nrows - 1)
+		if (i == nrows - 1 && !is_rtl)
 			rp.paintLast();
+		if (i == 0 && is_rtl)
+			rp.paintFirst();
 		y += row.descent();
+
 		// Restore full_repaint status.
 		pi.full_repaint = tmp;
 	}
@@ -2091,103 +2208,6 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 }
 
 
-void TextMetrics::drawRowSelection(PainterInfo & pi, int x, Row const & row,
-		Cursor const & curs, pit_type pit) const
-{
-	DocIterator beg = curs.selectionBegin();
-	beg.pit() = pit;
-	beg.pos() = row.sel_beg;
-
-	DocIterator end = curs.selectionEnd();
-	end.pit() = pit;
-	end.pos() = row.sel_end;
-
-	bool const begin_boundary = beg.pos() >= row.endpos();
-	bool const end_boundary = row.sel_end == row.endpos();
-
-	Buffer & buffer = bv_->buffer();
-	DocIterator cur = beg;
-	cur.boundary(begin_boundary);
-	int x1 = cursorX(beg.top(), begin_boundary);
-	int x2 = cursorX(end.top(), end_boundary);
-	int const y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent();
-	int const y2 = y1 + row.height();
-
-	int const rm = text_->isMainText(buffer) ? bv_->rightMargin() : 0;
-	int const lm = text_->isMainText(buffer) ? bv_->leftMargin() : 0;
-
-	// draw the margins
-	if (row.begin_margin_sel) {
-		if (text_->isRTL(buffer, beg.paragraph())) {
-			pi.pain.fillRectangle(x + x1, y1,  width() - rm - x1, y2 - y1,
-				Color_selection);
-		} else {
-			pi.pain.fillRectangle(x + lm, y1, x1 - lm, y2 - y1,
-				Color_selection);
-		}
-	}
-
-	if (row.end_margin_sel) {
-		if (text_->isRTL(buffer, beg.paragraph())) {
-			pi.pain.fillRectangle(x + lm, y1, x2 - lm, y2 - y1,
-				Color_selection);
-		} else {
-			pi.pain.fillRectangle(x + x2, y1, width() - rm - x2, y2 - y1,
-				Color_selection);
-		}
-	}
-
-	// if we are on a boundary from the beginning, it's probably
-	// a RTL boundary and we jump to the other side directly as this
-	// segement is 0-size and confuses the logic below
-	if (cur.boundary())
-		cur.boundary(false);
-
-	// go through row and draw from RTL boundary to RTL boundary
-	while (cur < end) {
-		bool drawNow = false;
-
-		// simplified cursorForward code below which does not
-		// descend into insets and which does not go into the
-		// next line. Compare the logic with the original cursorForward
-
-		// if left of boundary -> just jump to right side, but
-		// for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
-		if (cur.boundary()) {
-			cur.boundary(false);
-		}	else if (isRTLBoundary(cur.pit(), cur.pos() + 1)) {
-			// in front of RTL boundary -> Stay on this side of the boundary
-			// because:  ab|cDDEEFFghi -> abc|DDEEFFghi
-			++cur.pos();
-			cur.boundary(true);
-			drawNow = true;
-		} else {
-			// move right
-			++cur.pos();
-
-			// line end?
-			if (cur.pos() == row.endpos())
-				cur.boundary(true);
-		}
-
-		if (x1 == -1) {
-			// the previous segment was just drawn, now the next starts
-			x1 = cursorX(cur.top(), cur.boundary());
-		}
-
-		if (!(cur < end) || drawNow) {
-			x2 = cursorX(cur.top(), cur.boundary());
-			pi.pain.fillRectangle(x + min(x1,x2), y1, abs(x2 - x1), y2 - y1,
-				Color_selection);
-
-			// reset x1, so it is set again next round (which will be on the
-			// right side of a boundary or at the selection end)
-			x1 = -1;
-		}
-	}
-}
-
-
 void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y,
 	Dimension & dim) const
 {
@@ -2199,8 +2219,10 @@ void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y,
 	wordStart.pos() -= word.length();
 
 	// get position on screen of the word start and end
-	Point lxy = cur.bv().getPos(wordStart, false);
-	Point rxy = cur.bv().getPos(bvcur, bvcur.boundary());
+	//FIXME: Is it necessary to explicitly set this to false?
+	wordStart.boundary(false);
+	Point lxy = cur.bv().getPos(wordStart);
+	Point rxy = cur.bv().getPos(bvcur);
 
 	// calculate dimensions of the word
 	dim = rowHeight(bvcur.pit(), wordStart.pos(), bvcur.pos(), false);