X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextMetrics.cpp;h=874cb17607f716e9551e53720237300f57c1f699;hb=449c766e03d94ddf6c823cfcae845f76f83c0e1c;hp=47745c4a7c9f3cff8df9885ecf15d470cbc1ce44;hpb=742bf1b950cf3863c3ea3c50080d62616408c5e6;p=lyx.git

diff --git a/src/TextMetrics.cpp b/src/TextMetrics.cpp
index 47745c4a7c..874cb17607 100644
--- a/src/TextMetrics.cpp
+++ b/src/TextMetrics.cpp
@@ -19,7 +19,6 @@
 
 #include "TextMetrics.h"
 
-#include "Bidi.h"
 #include "Buffer.h"
 #include "buffer_funcs.h"
 #include "BufferParams.h"
@@ -27,32 +26,29 @@
 #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 "ParagraphParameters.h"
-#include "ParIterator.h"
-#include "rowpainter.h"
+#include "RowPainter.h"
 #include "Text.h"
 #include "TextClass.h"
 #include "VSpace.h"
 
 #include "insets/InsetText.h"
 
-#include "mathed/MacroTable.h"
 #include "mathed/MathMacroTemplate.h"
 
 #include "frontends/FontMetrics.h"
 #include "frontends/Painter.h"
 
 #include "support/debug.h"
-#include <cstdlib>
 #include "support/lassert.h"
 
+#include <cmath>
+
 using namespace std;
 
 
@@ -60,20 +56,32 @@ namespace lyx {
 
 using frontend::FontMetrics;
 
-static int numberOfSeparators(Paragraph const & par, Row const & row)
+namespace {
+
+int numberOfSeparators(Row const & row)
 {
-	pos_type const first = max(row.pos(), par.beginOfBody());
-	pos_type const last = row.endpos() - 1;
 	int n = 0;
-	for (pos_type p = first; p < last; ++p) {
-		if (par.isSeparator(p))
+	Row::const_iterator cit = row.begin();
+	Row::const_iterator const end = row.end();
+	for ( ; cit != end ; ++cit)
+		if (cit->type == Row::SEPARATOR)
 			++n;
-	}
 	return n;
 }
 
 
-static int numberOfLabelHfills(Paragraph const & par, Row const & row)
+void setSeparatorWidth(Row & row, double w)
+{
+	row.separator = w;
+	Row::iterator it = row.begin();
+	Row::iterator const end = row.end();
+	for ( ; it != end ; ++it)
+		if (it->type == Row::SEPARATOR)
+			it->extra = w;
+}
+
+
+int numberOfLabelHfills(Paragraph const & par, Row const & row)
 {
 	pos_type last = row.endpos() - 1;
 	pos_type first = row.pos();
@@ -94,28 +102,21 @@ static int numberOfLabelHfills(Paragraph const & par, Row const & row)
 }
 
 
-static int numberOfHfills(Paragraph const & par, Row const & row)
+int numberOfHfills(Row const & row, pos_type const body_pos)
 {
-	pos_type const last = row.endpos();
-	pos_type first = row.pos();
-
-	// hfill *DO* count at the beginning of paragraphs!
-	if (first) {
-		while (first < last && par.isHfill(first))
-			++first;
-	}
-
-	first = max(first, par.beginOfBody());
-
 	int n = 0;
-	for (pos_type p = first; p < last; ++p) {
-		if (par.isHfill(p))
+	Row::const_iterator cit = row.begin();
+	Row::const_iterator const end = row.end();
+	for ( ; cit != end ; ++cit)
+		if (cit->pos >= body_pos
+		    && cit->inset && cit->inset->isHfill())
 			++n;
-	}
 	return n;
 }
 
 
+}
+
 /////////////////////////////////////////////////////////////////////
 //
 // TextMetrics
@@ -126,13 +127,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());
 }
 
 
@@ -158,6 +157,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);
 }
@@ -176,20 +176,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 > 0, /**/);
+	LBUFERR(mi.base.textwidth > 0);
 	max_width_ = mi.base.textwidth;
 	// backup old dimension.
 	Dimension const old_dim = dim_;
@@ -241,17 +230,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];
@@ -303,7 +290,7 @@ Font TextMetrics::displayFont(pit_type pit, pos_type pos) const
 
 bool TextMetrics::isRTL(CursorSlice const & sl, bool boundary) const
 {
-	if (!lyxrc.rtl_support || !sl.text())
+	if (!sl.text())
 		return false;
 
 	int correction = 0;
@@ -316,9 +303,6 @@ bool TextMetrics::isRTL(CursorSlice const & sl, bool boundary) const
 
 bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos) const
 {
-	if (!lyxrc.rtl_support)
-		return false;
-
 	// no RTL boundary at paragraph start
 	if (pos == 0)
 		return false;
@@ -329,16 +313,19 @@ bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos) const
 }
 
 
+// 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 (// 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;
 
-	// no RTL boundary at paragraph start
-	if (pos == 0)
-		return false;
-	
 	ParagraphMetrics & pm = par_metrics_[pit];
 	// no RTL boundary in empty paragraph
 	if (pm.rows().empty())
@@ -353,22 +340,23 @@ bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos,
 		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.isEnvSeparator(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();
-	
-	// 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;
-	
+
 	return left != right;
 }
 
@@ -376,7 +364,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];
@@ -386,19 +374,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
@@ -413,19 +410,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.");
-		bv_->buffer().updateLabels();
+		// 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;
@@ -442,9 +441,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);
@@ -458,32 +457,26 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 	pos_type first = 0;
 	size_t row_index = 0;
 	// maximum pixel width of a row
-	int width = max_width_ - right_margin; // - leftMargin(max_width_, pit, row);
 	do {
-		Dimension dim;
-		pos_type end = rowBreakPoint(width, pit, first);
-		if (row_index || end < par.size())
-			// If there is more than one row, expand the text to
-			// the full allowable width. This setting here is needed
-			// for the computeRowMetrics() below.
-			dim_.wid = max_width_;
-
-		dim = rowHeight(pit, first, end);
-		dim.wid = rowWidth(right_margin, pit, first, end);
 		if (row_index == pm.rows().size())
 			pm.rows().push_back(Row());
 		Row & row = pm.rows()[row_index];
-		row.setChanged(false);
 		row.pos(first);
-		row.endpos(end);
-		row.setDimension(dim);
-		int const max_row_width = max(dim_.wid, dim.wid);
+		breakRow(row, right_margin, pit);
+		setRowHeight(row, pit);
+		row.setChanged(false);
+		if (row_index || row.endpos() < par.size())
+			// If there is more than one row, expand the text to
+			// the full allowable width. This setting here is needed
+			// for the computeRowMetrics() below.
+			dim_.wid = max_width_;
+		int const max_row_width = max(dim_.wid, row.width());
 		computeRowMetrics(pit, row, max_row_width);
-		first = end;
+		first = row.endpos();
 		++row_index;
 
-		pm.dim().wid = max(pm.dim().wid, dim.wid);
-		pm.dim().des += dim.height();
+		pm.dim().wid = max(pm.dim().wid, row.width());
+		pm.dim().des += row.height();
 	} while (first < par.size());
 
 	if (row_index < pm.rows().size())
@@ -492,18 +485,16 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 	// Make sure that if a par ends in newline, there is one more row
 	// under it
 	if (first > 0 && par.isNewline(first - 1)) {
-		Dimension dim = rowHeight(pit, first, first);
-		dim.wid = rowWidth(right_margin, pit, first, first);
 		if (row_index == pm.rows().size())
 			pm.rows().push_back(Row());
 		Row & row = pm.rows()[row_index];
-		row.setChanged(false);
 		row.pos(first);
 		row.endpos(first);
-		row.setDimension(dim);
-		int const max_row_width = max(dim_.wid, dim.wid);
+		setRowHeight(row, pit);
+		row.setChanged(false);
+		int const max_row_width = max(dim_.wid, row.width());
 		computeRowMetrics(pit, row, max_row_width);
-		pm.dim().des += dim.height();
+		pm.dim().des += row.height();
 	}
 
 	pm.dim().asc += pm.rows()[0].ascent();
@@ -515,6 +506,57 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 }
 
 
+LyXAlignment TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
+{
+	Layout const & layout = par.layout();
+
+	LyXAlignment align;
+	if (par.params().align() == LYX_ALIGN_LAYOUT)
+		align = layout.align;
+	else
+		align = par.params().align();
+
+	// handle alignment inside tabular cells
+	Inset const & owner = text_->inset();
+	switch (owner.contentAlignment()) {
+	case LYX_ALIGN_CENTER:
+	case LYX_ALIGN_LEFT:
+	case LYX_ALIGN_RIGHT:
+		if (align == LYX_ALIGN_NONE || align == LYX_ALIGN_BLOCK)
+			align = owner.contentAlignment();
+		break;
+	default:
+		// unchanged (use align)
+		break;
+	}
+
+	// Display-style insets should always be on a centered row
+	if (Inset const * inset = par.getInset(pos)) {
+		switch (inset->display()) {
+		case Inset::AlignLeft:
+			align = LYX_ALIGN_BLOCK;
+			break;
+		case Inset::AlignCenter:
+			align = LYX_ALIGN_CENTER;
+			break;
+		case Inset::Inline:
+			// 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;
+
+	return align;
+}
+
+
 void TextMetrics::computeRowMetrics(pit_type const pit,
 		Row & row, int width) const
 {
@@ -523,27 +565,24 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 
 	Paragraph const & par = text_->getPar(pit);
 
-	double w = width - row.width();
+	double const w = width - row.right_margin - row.width();
 	// FIXME: put back this assertion when the crash on new doc is solved.
 	//LASSERT(w >= 0, /**/);
 
-	//lyxerr << "\ndim_.wid " << dim_.wid << endl;
-	//lyxerr << "row.width() " << row.width() << endl;
-	//lyxerr << "w " << w << endl;
-
 	bool const is_rtl = text_->isRTL(par);
 	if (is_rtl)
-		row.x = rightMargin(pit);
+		row.left_margin = rightMargin(pit);
 	else
-		row.x = leftMargin(max_width_, pit, row.pos());
+		row.left_margin = leftMargin(max_width_, pit, row.pos());
 
 	// is there a manual margin with a manual label
 	Layout const & layout = par.layout();
 
+	int nlh = 0;
 	if (layout.margintype == MARGIN_MANUAL
 	    && layout.labeltype == LABEL_MANUAL) {
 		/// We might have real hfills in the label part
-		int nlh = numberOfLabelHfills(par, row);
+		nlh = numberOfLabelHfills(par, row);
 
 		// A manual label par (e.g. List) has an auto-hfill
 		// between the label text and the body of the
@@ -559,7 +598,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 
 	double hfill = 0;
 	// are there any hfills in the row?
-	if (int const nh = numberOfHfills(par, row)) {
+	if (int const nh = numberOfHfills(row, par.beginOfBody())) {
 		if (w > 0)
 			hfill = w / double(nh);
 	// we don't have to look at the alignment if it is ALIGN_LEFT and
@@ -568,116 +607,61 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 	} else if (int(row.width()) < max_width_) {
 		// is it block, flushleft or flushright?
 		// set x how you need it
-		int align;
-		if (par.params().align() == LYX_ALIGN_LAYOUT)
-			align = layout.align;
-		else
-			align = par.params().align();
-
-		// handle alignment inside tabular cells
-		Inset const & owner = text_->inset();
-		switch (owner.contentAlignment()) {
-			case LYX_ALIGN_CENTER:
-			case LYX_ALIGN_LEFT:
-			case LYX_ALIGN_RIGHT:
-				if (align == LYX_ALIGN_NONE 
-				    || align == LYX_ALIGN_BLOCK)
-					align = owner.contentAlignment();
-				break;
-			default:
-				// unchanged (use align)
-				break;
-		}
-
-		// Display-style insets should always be on a centered row
-		if (Inset const * inset = par.getInset(row.pos())) {
-			switch (inset->display()) {
-				case Inset::AlignLeft:
-					align = LYX_ALIGN_BLOCK;
-					break;
-				case Inset::AlignCenter:
-					align = LYX_ALIGN_CENTER;
-					break;
-				case Inset::Inline:
-					// unchanged (use align)
-					break;
-				case Inset::AlignRight:
-					align = LYX_ALIGN_RIGHT;
-					break;
-			}
-		}
-
-		switch (align) {
+		switch (getAlign(par, row.pos())) {
 		case LYX_ALIGN_BLOCK: {
-			int const ns = numberOfSeparators(par, row);
-			bool disp_inset = false;
-			if (row.endpos() < par.size()) {
-				Inset const * in = par.getInset(row.endpos());
-				if (in)
-					disp_inset = in->display();
-			}
-			// If we have separators, this is not the last row of a
-			// par, does not end in newline, and is not row above a
-			// display inset... then stretch it
-			if (ns
-			    && row.endpos() < par.size()
-			    && !par.isNewline(row.endpos() - 1)
-			    && !disp_inset
-				) {
-				row.separator = w / ns;
-				//lyxerr << "row.separator " << row.separator << endl;
-				//lyxerr << "ns " << ns << endl;
+			int const ns = numberOfSeparators(row);
+			/** If we have separators, and this row has
+			 * not be broken abruptly by a display inset
+			 * or newline, then stretch it */
+			if (ns && !row.right_boundary()
+			    && row.endpos() != par.size()) {
+				setSeparatorWidth(row, w / ns);
+				row.dimension().wid = width;
 			} else if (is_rtl) {
-				row.x += w;
+				row.dimension().wid = width;
+				row.left_margin += w;
 			}
 			break;
 		}
 		case LYX_ALIGN_RIGHT:
-			row.x += w;
+			row.left_margin += w;
 			break;
 		case LYX_ALIGN_CENTER:
-			row.x += w / 2;
+			row.dimension().wid = width - int(w / 2);
+			row.left_margin += w / 2;
+			break;
+		case LYX_ALIGN_LEFT:
+		case LYX_ALIGN_NONE:
+		case LYX_ALIGN_LAYOUT:
+		case LYX_ALIGN_SPECIAL:
+		case LYX_ALIGN_DECIMAL:
 			break;
 		}
 	}
 
-	if (is_rtl) {
-		pos_type body_pos = par.beginOfBody();
-		pos_type end = row.endpos();
-
-		if (body_pos > 0
-		    && (body_pos > end || !par.isLineSeparator(body_pos - 1)))
-		{
-			row.x += theFontMetrics(text_->labelFont(par)).
-				width(layout.labelsep);
-			if (body_pos <= end)
-				row.x += row.label_hfill;
-		}
-	}
-
+	// Finally,  handle hfill insets
 	pos_type const endpos = row.endpos();
 	pos_type body_pos = par.beginOfBody();
 	if (body_pos > 0
-		&& (body_pos > endpos || !par.isLineSeparator(body_pos - 1)))
+	    && (body_pos > endpos || !par.isLineSeparator(body_pos - 1)))
 		body_pos = 0;
-
 	ParagraphMetrics & pm = par_metrics_[pit];
-	InsetList::const_iterator ii = par.insetList().begin();
-	InsetList::const_iterator iend = par.insetList().end();
-	for ( ; ii != iend; ++ii) {
-		if (ii->pos >= endpos || ii->pos < row.pos()
-			|| (ii->inset->lyxCode() != SPACE_CODE ||
-			    !ii->inset->isStretchableSpace()))
+	Row::iterator cit = row.begin();
+	Row::iterator const cend = row.end();
+	for ( ; cit != cend; ++cit) {
+		if (row.label_hfill && cit->endpos == body_pos
+		    && cit->type == Row::SPACE)
+			cit->dim.wid -= int(row.label_hfill * (nlh - 1));
+		if (!cit->inset || !cit->inset->isHfill())
 			continue;
-		Dimension dim = row.dimension();
-		if (pm.hfillExpansion(row, ii->pos))
-			dim.wid = int(ii->pos >= body_pos ?
-				max(hfill, 5.0) : row.label_hfill);
+		if (pm.hfillExpansion(row, cit->pos))
+			cit->dim.wid = int(cit->pos >= body_pos ?
+					   max(hfill, 5.0) : row.label_hfill);
 		else
-			dim.wid = 5;
+			cit->dim.wid = 5;
 		// Cache the inset dimension.
-		bv_->coordCache().insets().add(ii->inset, dim);
-		pm.setInsetDimension(ii->inset, dim);
+		bv_->coordCache().insets().add(cit->inset, cit->dim);
+		pm.setInsetDimension(cit->inset, cit->dim);
 	}
 }
 
@@ -685,20 +669,17 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 int TextMetrics::labelFill(pit_type const pit, Row const & row) const
 {
 	Paragraph const & par = text_->getPar(pit);
-
-	pos_type last = par.beginOfBody();
-	LASSERT(last > 0, /**/);
-
-	// -1 because a label ends with a space that is in the label
-	--last;
-
-	// a separator at this end does not count
-	if (par.isLineSeparator(last))
-		--last;
+	LBUFERR(par.beginOfBody() > 0 || par.isEnvSeparator(0));
 
 	int w = 0;
-	for (pos_type i = row.pos(); i <= last; ++i)
-		w += singleWidth(pit, i);
+	Row::const_iterator cit = row.begin();
+	Row::const_iterator const end = row.end();
+	// iterate over elements before main body (except the last one,
+	// which is extra space).
+	while (cit!= end && cit->endpos < par.beginOfBody()) {
+		w += cit->dim.wid;
+		++cit;
+	}
 
 	docstring const & label = par.params().labelWidthString();
 	if (label.empty())
@@ -711,6 +692,8 @@ int TextMetrics::labelFill(pit_type const pit, Row const & row) const
 }
 
 
+#if 0
+// Not used, see TextMetrics::breakRow
 // this needs special handling - only newlines count as a break point
 static pos_type addressBreakPoint(pos_type i, Paragraph const & par)
 {
@@ -722,6 +705,7 @@ static pos_type addressBreakPoint(pos_type i, Paragraph const & par)
 
 	return end;
 }
+#endif
 
 
 int TextMetrics::labelEnd(pit_type const pit) const
@@ -762,7 +746,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;
 		}
@@ -791,21 +775,38 @@ private:
 
 } // anon namespace
 
-pos_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
-		pos_type pos) const
+/** This is the function where the hard work is done. The code here is
+ * very sensitive to small changes :) Note that part of the
+ * intelligence is also in Row::shorten_if_needed
+ */
+void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit) const
 {
-	ParagraphMetrics const & pm = par_metrics_[pit];
 	Paragraph const & par = text_->getPar(pit);
 	pos_type const end = par.size();
-	if (pos == end || width < 0)
-		return end;
+	pos_type const pos = row.pos();
+	int const width = max_width_ - right_margin;
+	pos_type const body_pos = par.beginOfBody();
+	row.clear();
+	// This make get changed in computeRowMetrics depending on RTL
+	row.left_margin = leftMargin(max_width_, pit, pos);
+	row.dimension().wid = row.left_margin;
+	row.right_margin = right_margin;
 
-	Layout const & layout = par.layout();
+	if (pos >= end || row.width() > width) {
+		row.endpos(end);
+		return;
+	}
 
-	if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX)
-		return addressBreakPoint(pos, par);
+	ParagraphMetrics const & pm = par_metrics_[pit];
+	ParagraphList const & pars = text_->paragraphs();
 
-	pos_type const body_pos = par.beginOfBody();
+#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 (par.layout().margintype == MARGIN_RIGHT_ADDRESS_BOX)
+		return addressBreakPoint(pos, par);
+#endif
 
 	// check for possible inline completion
 	DocIterator const & inlineCompletionPos = bv_->inlineCompletionPos();
@@ -818,165 +819,100 @@ pos_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
 	}
 
 	// Now we iterate through until we reach the right margin
-	// or the end of the par, then choose the possible break
-	// nearest that.
-
-	int label_end = labelEnd(pit);
-	int const left = leftMargin(max_width_, pit, pos);
-	int x = left;
-
-	// pixel width since last breakpoint
-	int chunkwidth = 0;
-
-	FontIterator fi = FontIterator(*this, par, pit, pos);
-	pos_type point = end;
+	// or the end of the par, then build a representation of the row.
 	pos_type i = pos;
-	for ( ; i < end; ++i, ++fi) {
-		int thiswidth = pm.singleWidth(i, *fi);
+	FontIterator fi = FontIterator(*this, par, pit, pos);
+	while (i < end && row.width() < width) {
+		char_type c = par.getChar(i);
+		// The most special cases are handled first.
+		if (par.isInset(i)) {
+			Inset const * ins = par.getInset(i);
+			Dimension dim = pm.insetDimension(ins);
+			row.add(i, ins, dim, *fi, par.lookupChange(i));
+		} else if (c == ' ' && i + 1 == body_pos) {
+			// There is a space at i, but it should not be
+			// added as a separator, because it is just
+			// before body_pos. Instead, insert some spacing to
+			// align text
+			FontMetrics const & fm = theFontMetrics(text_->labelFont(par));
+			// this is needed to make sure that the row width is correct
+			row.finalizeLast();
+			int const add = max(fm.width(par.layout().labelsep),
+					    labelEnd(pit) - row.width());
+			row.addSpace(i, add, *fi, par.lookupChange(i));
+		} else if (par.isLineSeparator(i)) {
+			// In theory, no inset has this property. If
+			// this is done, a new addSeparator which
+			// takes an inset as parameter should be
+			// added.
+			LATTEST(!par.isInset(i));
+			row.addSeparator(i, c, *fi, par.lookupChange(i));
+		} else if (c == '\t')
+			row.addSpace(i, theFontMetrics(*fi).width(from_ascii("    ")),
+				     *fi, par.lookupChange(i));
+		else
+			row.add(i, c, *fi, par.lookupChange(i));
 
 		// add inline completion width
-		if (inlineCompletionLPos == i) {
-			docstring const & completion = bv_->inlineCompletion();
-			if (completion.length() > 0)
-				thiswidth += theFontMetrics(*fi).width(completion);
-		}
-
-		// add the auto-hfill from label end to the body
-		if (body_pos && i == body_pos) {
-			FontMetrics const & fm = theFontMetrics(
-				text_->labelFont(par));
-			int add = fm.width(layout.labelsep);
-			if (par.isLineSeparator(i - 1))
-				add -= singleWidth(pit, i - 1);
-
-			add = max(add, label_end - x);
-			thiswidth += add;
+		if (inlineCompletionLPos == i &&
+		    !bv_->inlineCompletion().empty()) {
+			Font f = *fi;
+			f.fontInfo().setColor(Color_inlinecompletion);
+			row.addVirtual(i + 1, bv_->inlineCompletion(),
+					  f, Change());
 		}
 
-		x += thiswidth;
-		chunkwidth += thiswidth;
-
-		// break before a character that will fall off
-		// the right of the row
-		if (x >= width) {
-			// if no break before, break here
-			if (point == end || chunkwidth >= width - left) {
-				if (i > pos)
-					point = i;
-				else
-					point = i + 1;
-			}
-			// exit on last registered breakpoint:
-			break;
-		}
-
-		if (par.isNewline(i)) {
-			point = i + 1;
-			break;
-		}
+		// Handle some situations that abruptly terminate the row
+		// - A newline inset
+		// - Before a display inset
+		// - After a display inset
 		Inset const * inset = 0;
-		// Break before...
-		if (i + 1 < end) {
-			if ((inset = par.getInset(i + 1)) && inset->display()) {
-				point = i + 1;
-				break;
-			}
-			// ...and after.
-			if ((inset = par.getInset(i)) && inset->display()) {
-				point = i + 1;
-				break;
-			}
+		if (par.isNewline(i) || par.isEnvSeparator(i)
+		    || (i + 1 < end && (inset = par.getInset(i + 1))
+			&& inset->display())
+		    || (!row.empty() && row.back().inset
+			&& row.back().inset->display())) {
+			row.right_boundary(true);
+			++i;
+			break;
 		}
 
-		inset = par.getInset(i);
-		if (!inset || inset->isChar()) {
-			// some insets are line separators too
-			if (par.isLineSeparator(i)) {
-				// register breakpoint:
-				point = i + 1;
-				chunkwidth = 0;
-			}
-		}
+		++i;
+		++fi;
 	}
-
-	// maybe found one, but the par is short enough.
-	if (i == end && x < width)
-		point = end;
-
-	// manual labels cannot be broken in LaTeX. But we
-	// want to make our on-screen rendering of footnotes
-	// etc. still break
-	if (body_pos && point < body_pos)
-		point = body_pos;
-
-	return point;
-}
-
-
-int TextMetrics::rowWidth(int right_margin, pit_type const pit,
-		pos_type const first, pos_type const end) const
-{
-	// get the pure distance
-	ParagraphMetrics const & pm = par_metrics_[pit];
-	Paragraph const & par = text_->getPar(pit);
-	int w = leftMargin(max_width_, pit, first);
-	int label_end = labelEnd(pit);
-
-	// check for possible inline completion
-	DocIterator const & inlineCompletionPos = bv_->inlineCompletionPos();
-	pos_type inlineCompletionLPos = -1;
-	if (inlineCompletionPos.inTexted()
-	    && inlineCompletionPos.text() == text_
-	    && inlineCompletionPos.pit() == pit) {
-		// draw logically behind the previous character
-		inlineCompletionLPos = inlineCompletionPos.pos() - 1;
+	row.finalizeLast();
+	row.endpos(i);
+
+	// End of paragraph marker
+	if (lyxrc.paragraph_markers
+	    && i == end && size_type(pit + 1) < pars.size()) {
+		// add a virtual element for the end-of-paragraph
+		// marker; it is shown on screen, but does not exist
+		// in the paragraph.
+		Font f(text_->layoutFont(pit));
+		f.fontInfo().setColor(Color_paragraphmarker);
+		BufferParams const & bparams
+			= text_->inset().buffer().params();
+		f.setLanguage(par.getParLanguage(bparams));
+		row.addVirtual(end, docstring(1, char_type(0x00B6)), f, Change());
 	}
 
-	pos_type const body_pos = par.beginOfBody();
-	pos_type i = first;
-
-	if (i < end) {
-		FontIterator fi = FontIterator(*this, par, pit, i);
-		for ( ; i < end; ++i, ++fi) {
-			if (body_pos > 0 && i == body_pos) {
-				FontMetrics const & fm = theFontMetrics(
-					text_->labelFont(par));
-				w += fm.width(par.layout().labelsep);
-				if (par.isLineSeparator(i - 1))
-					w -= singleWidth(pit, i - 1);
-				w = max(w, label_end);
-			}
-			
-			// 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) {
-				docstring const & completion = bv_->inlineCompletion();
-				if (completion.length() > 0)
-					w += theFontMetrics(*fi).width(completion);
-			}
-		}
-	}
+	// if the row is too large, try to cut at last separator.
+	row.shortenIfNeeded(body_pos, width);
 
-	if (body_pos > 0 && body_pos >= end) {
-		FontMetrics const & fm = theFontMetrics(
-			text_->labelFont(par));
-		w += fm.width(par.layout().labelsep);
-		if (end > 0 && par.isLineSeparator(end - 1))
-			w -= singleWidth(pit, end - 1);
-		w = max(w, label_end);
-	}
+	// if the row ends with a separator that is not at end of
+	// paragraph, remove it
+	if (!row.empty() && row.back().type == Row::SEPARATOR
+	    && row.endpos() < par.size())
+		row.pop_back();
 
-	return w + right_margin;
+	// make sure that the RTL elements are in reverse ordering
+	row.reverseRTL(text_->isRTL(par));
 }
 
 
-Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
-		pos_type const end, bool topBottomSpace) const
+void TextMetrics::setRowHeight(Row & row, pit_type const pit,
+				    bool topBottomSpace) const
 {
 	Paragraph const & par = text_->getPar(pit);
 	// get the maximum ascent and the maximum descent
@@ -994,7 +930,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	// start with so we don't have to do the assignment below too
 	// often.
 	Buffer const & buffer = bv_->buffer();
-	Font font = displayFont(pit, first);
+	Font font = displayFont(pit, row.pos());
 	FontSize const tmpsize = font.fontInfo().size();
 	font.fontInfo() = text_->layoutFont(pit);
 	FontSize const size = font.fontInfo().size();
@@ -1014,11 +950,11 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 
 	// insets may be taller
 	ParagraphMetrics const & pm = par_metrics_[pit];
-	InsetList::const_iterator ii = par.insetList().begin();
-	InsetList::const_iterator iend = par.insetList().end();
-	for ( ; ii != iend; ++ii) {
-		if (ii->pos >= first && ii->pos < end) {
-			Dimension const & dim = pm.insetDimension(ii->inset);
+	Row::const_iterator cit = row.begin();
+	Row::const_iterator cend = row.end();
+	for ( ; cit != cend; ++cit) {
+		if (cit->inset) {
+			Dimension const & dim = pm.insetDimension(cit->inset);
 			maxasc  = max(maxasc,  dim.ascent());
 			maxdesc = max(maxdesc, dim.descent());
 		}
@@ -1030,7 +966,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	int labeladdon = 0;
 
 	FontSize maxsize =
-		par.highestFontInRange(first, end, size);
+		par.highestFontInRange(row.pos(), row.endpos(), size);
 	if (maxsize > font.fontInfo().size()) {
 		// use standard paragraph font with the maximal size
 		FontInfo maxfont = font.fontInfo();
@@ -1048,40 +984,26 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	Inset const & inset = text_->inset();
 
 	// is it a top line?
-	if (first == 0 && topBottomSpace) {
+	if (row.pos() == 0 && topBottomSpace) {
 		BufferParams const & bufparams = buffer.params();
 		// some parskips VERY EASY IMPLEMENTATION
-		if (bufparams.paragraph_separation
-		    == BufferParams::ParagraphSkipSeparation
-			&& inset.lyxCode() != ERT_CODE
-			&& inset.lyxCode() != 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(par));
-		}
-
 		// special code for the top label
-		if ((layout.labeltype == LABEL_TOP_ENVIRONMENT
-		     || layout.labeltype == LABEL_BIBLIO
-		     || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)
-		    && text_->isFirstInSequence(pit)
-		    && !par.labelString().empty())
-		{
+		if (layout.labelIsAbove()
+		    && (!layout.isParagraphGroup() || text_->isFirstInSequence(pit))
+		    && !par.labelString().empty()) {
 			labeladdon = int(
 				  labelfont_metrics.maxHeight()
 					* layout.spacing.getValue()
@@ -1101,7 +1023,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 		    && prevpar.getLabelWidthString()
 					== par.getLabelWidthString()) {
 			layoutasc = layout.itemsep * dh;
-		} else if (pit != 0 || first != 0) {
+		} else if (pit != 0 || row.pos() != 0) {
 			if (layout.topsep > 0)
 				layoutasc = layout.topsep * dh;
 		}
@@ -1119,24 +1041,21 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	}
 
 	// is it a bottom line?
-	if (end >= par.size() && topBottomSpace) {
+	if (row.endpos() >= par.size() && topBottomSpace) {
 		// add the layout spaces, for example before and after
 		// a section, or between the items of a itemize or enumerate
 		// environment
 		pit_type nextpit = pit + 1;
 		if (nextpit != pit_type(pars.size())) {
 			pit_type cpit = pit;
-			double usual = 0;
-			double unusual = 0;
 
 			if (pars[cpit].getDepth() > pars[nextpit].getDepth()) {
-				usual = pars[cpit].layout().bottomsep * dh;
+				double usual = pars[cpit].layout().bottomsep * dh;
+				double unusual = 0;
 				cpit = text_->depthHook(cpit, pars[nextpit].getDepth());
 				if (pars[cpit].layout() != pars[nextpit].layout()
-					|| pars[nextpit].getLabelWidthString() != pars[cpit].getLabelWidthString())
-				{
+				    || pars[nextpit].getLabelWidthString() != pars[cpit].getLabelWidthString())
 					unusual = pars[cpit].layout().bottomsep * dh;
-				}
 				layoutdesc = max(unusual, usual);
 			} else if (pars[cpit].getDepth() == pars[nextpit].getDepth()) {
 				if (pars[cpit].layout() != pars[nextpit].layout()
@@ -1155,147 +1074,81 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
 	// main Text. The following test is thus bogus.
 	// Top and bottom margin of the document (only at top-level)
 	if (main_text_ && topBottomSpace) {
-		if (pit == 0 && first == 0)
+		if (pit == 0 && row.pos() == 0)
 			maxasc += 20;
 		if (pit + 1 == pit_type(pars.size()) &&
-		    end == par.size() &&
-				!(end > 0 && par.isNewline(end - 1)))
+		    row.endpos() == par.size() &&
+				!(row.endpos() > 0 && par.isNewline(row.endpos() - 1)))
 			maxdesc += 20;
 	}
 
-	return Dimension(0, maxasc + labeladdon, maxdesc);
+	row.dimension().asc = maxasc + labeladdon;
+	row.dimension().des = maxdesc;
 }
 
 
 // x is an absolute screen coord
 // returns the column near the specified x-coordinate of the row
 // x is set to the real beginning of this column
-pos_type TextMetrics::getColumnNearX(pit_type const pit,
-		Row const & row, int & x, bool & boundary) const
+pos_type TextMetrics::getPosNearX(Row const & row, int & x,
+				  bool & boundary) const
 {
-	Buffer const & buffer = bv_->buffer();
-
 	/// For the main Text, it is possible that this pit is not
 	/// yet in the CoordCache when moving cursor up.
 	/// x Paragraph coordinate is always 0 for main text anyway.
 	int const xo = origin_.x_;
 	x -= xo;
-	Paragraph const & par = text_->getPar(pit);
-	Bidi bidi;
-	bidi.computeTables(par, buffer, row);
-
-	pos_type vc = row.pos();
-	pos_type end = row.endpos();
-	pos_type c = 0;
-	Layout const & layout = par.layout();
-
-	bool left_side = false;
-
-	pos_type body_pos = par.beginOfBody();
-
-	double tmpx = row.x;
-	double last_tmpx = tmpx;
-
-	if (body_pos > 0 &&
-	    (body_pos > end || !par.isLineSeparator(body_pos - 1)))
-		body_pos = 0;
-
-	// check for empty row
-	if (vc == end) {
-		x = int(tmpx) + xo;
-		return 0;
-	}
-
-	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(par));
-			tmpx += row.label_hfill + fm.width(layout.labelsep);
-			if (par.isLineSeparator(body_pos - 1))
-				tmpx -= singleWidth(pit, body_pos - 1);
-		}
-
-		tmpx += singleWidth(pit, c);
-		if (par.isSeparator(c) && c >= body_pos)
-				tmpx += row.separator;
-		++vc;
-	}
-
-	if ((tmpx + last_tmpx) / 2 > x) {
-		tmpx = last_tmpx;
-		left_side = true;
-	}
-
-	LASSERT(vc <= end, /**/);  // This shouldn't happen.
 
+	pos_type pos = row.pos();
 	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(par) : false;
-	if (lastrow &&
-	    ((rtl  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
-	     (!rtl && !left_side && vc == end  && x > tmpx + 5))) {
-		if (!par.isNewline(end - 1))
-			c = end;
-	} else if (vc == row.pos()) {
-		c = bidi.vis2log(vc);
-		if (bidi.level(c) % 2 == 1)
-			++c;
+	if (row.empty())
+		x = row.left_margin;
+	else if (x <= row.left_margin) {
+		pos = row.front().left_pos();
+		x = row.left_margin;
+	} else if (x >= row.width()) {
+		pos = row.back().right_pos();
+		x = row.width();
 	} else {
-		c = bidi.vis2log(vc - 1);
-		bool const rtl = (bidi.level(c) % 2 == 1);
-		if (left_side == rtl) {
-			++c;
-			boundary = isRTLBoundary(pit, c);
+		double w = row.left_margin;
+		Row::const_iterator cit = row.begin();
+		Row::const_iterator cend = row.end();
+		for ( ; cit != cend; ++cit) {
+			if (w <= x &&  w + cit->full_width() > x) {
+				int x_offset = int(x - w);
+				pos = cit->x2pos(x_offset);
+				x = int(x_offset + w);
+				break;
+			}
+			w += cit->full_width();
 		}
+		if (cit == row.end()) {
+			pos = row.back().right_pos();
+			x = row.width();
+		}
+		/** This tests for the case where the cursor is placed
+		 * just before a font direction change. See comment on
+		 * the boundary_ member in DocIterator.h to understand
+		 * how boundary helps here.
+		 */
+		else if (pos == cit->endpos
+			 && cit + 1 != row.end()
+			 && cit->font.isVisibleRightToLeft() != (cit + 1)->font.isVisibleRightToLeft())
+			boundary = true;
 	}
 
-// I believe this code is not needed anymore (Jug 20050717)
-#if 0
-	// The following code is necessary because the cursor position past
-	// the last char in a row is logically equivalent to that before
-	// the first char in the next row. That's why insets causing row
-	// divisions -- Newline and display-style insets -- must be treated
-	// specially, so cursor up/down doesn't get stuck in an air gap -- MV
-	// Newline inset, air gap below:
-	if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
-		if (bidi.level(end -1) % 2 == 0)
-			tmpx -= singleWidth(pit, end - 1);
-		else
-			tmpx += singleWidth(pit, end - 1);
-		c = end - 1;
-	}
-
-	// Air gap above display inset:
-	if (row.pos() < end && c >= end && end < par.size()
-	    && par.isInset(end) && par.getInset(end)->display()) {
-		c = end - 1;
-	}
-	// Air gap below display inset:
-	if (row.pos() < end && c >= end && par.isInset(end - 1)
-	    && par.getInset(end - 1)->display()) {
-		c = end - 1;
-	}
-#endif
-
-	x = int(tmpx) + xo;
-	pos_type const col = c - row.pos();
-
-	if (!c || end == par.size())
-		return col;
-
-	if (c==end && !par.isLineSeparator(c-1) && !par.isNewline(c-1)) {
+	/** This tests for the case where the cursor is set at the end
+	 * of a row which has been broken due something else than a
+	 * separator (a display inset or a forced breaking of the
+	 * row). We know that there is a separator when the end of the
+	 * row is larger than the end of its last element.
+	 */
+	if (!row.empty() && pos == row.back().endpos
+	    && row.back().endpos == row.endpos())
 		boundary = true;
-		return col;
-	}
 
-	return min(col, end - 1 - row.pos());
+	x += xo;
+	return pos;
 }
 
 
@@ -1307,10 +1160,10 @@ 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);
+	return getPosNearX(r, x, bound);
 }
 
 
@@ -1353,7 +1206,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;
 
@@ -1403,13 +1257,13 @@ pit_type TextMetrics::getPitNearY(int y)
 }
 
 
-Row const & TextMetrics::getPitAndRowNearY(int y, pit_type & pit,
+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;
@@ -1417,25 +1271,29 @@ Row const & TextMetrics::getPitAndRowNearY(int y, pit_type & pit,
 		if (yy + rit->height() > y)
 			break;
 
-	if (assert_in_view && yy + rit->height() != y) {
-		if (!up) {
-			if (rit != pm.rows().begin())
+	if (assert_in_view) {
+		if (!up && yy + rit->height() > y) {
+			if (rit != pm.rows().begin()) {
+				y = yy;
 				--rit;
-			else if (pit != 0) {
+			} else if (pit != 0) {
 				--pit;
 				newParMetricsUp();
 				ParagraphMetrics const & pm2 = par_metrics_[pit];
 				rit = pm2.rows().end();
 				--rit;
+				y = yy;
 			}
-		} else  {
-			if (rit != rlast)
+		} else if (up && yy != y) {
+			if (rit != rlast) {
+				y = yy + rit->height();
 				++rit;
-			else if (pit != int(par_metrics_.size())) {
+			} else if (pit < int(text_->paragraphs().size()) - 1) {
 				++pit;
 				newParMetricsDown();
 				ParagraphMetrics const & pm2 = par_metrics_[pit];
 				rit = pm2.rows().begin();
+				y = pm2.position();
 			}
 		}
 	}
@@ -1455,47 +1313,35 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y,
 	pit_type pit = getPitNearY(y);
 	LASSERT(pit != -1, return 0);
 
-	Row const & row = getPitAndRowNearY(y, pit, assert_in_view, up);
-	bool bound = false;
+	int yy = y; // is modified by getPitAndRowNearY
+	Row const & row = getPitAndRowNearY(yy, pit, assert_in_view, up);
 
-	int xx = x; // is modified by getColumnNearX
-	pos_type const pos = row.pos()
-		+ getColumnNearX(pit, row, xx, bound);
 	cur.pit() = pit;
-	cur.pos() = pos;
-	cur.boundary(bound);
-	cur.setTargetX(x);
 
-	// try to descend into nested insets
-	Inset * inset = checkInsetHit(x, y);
-	//lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
-	if (!inset) {
-		// Either we deconst editXY or better we move current_font
-		// and real_current_font to Cursor
-		// FIXME: what is needed now that current_font and real_current_font
-		// are transferred?
+	// Do we cover an inset?
+	InsetList::InsetTable * it = checkInsetHit(pit, x, yy);
+
+	if (!it) {
+		// No inset, set position in the text
+		bool bound = false; // is modified by getPosNearX
+		int xx = x; // is modified by getPosNearX
+		cur.pos() = getPosNearX(row, xx, bound);
+		cur.boundary(bound);
 		cur.setCurrentFont();
+		cur.setTargetX(xx);
 		return 0;
 	}
 
-	ParagraphList const & pars = text_->paragraphs();
-	Inset const * insetBefore = pos ? pars[pit].getInset(pos - 1) : 0;
-	//Inset * insetBehind = pars[pit].getInset(pos);
-
-	// This should be just before or just behind the
-	// cursor position set above.
-	LASSERT((pos != 0 && inset == insetBefore)
-		|| inset == pars[pit].getInset(pos), /**/);
-
-	// Make sure the cursor points to the position before
-	// this inset.
-	if (inset == insetBefore) {
-		--cur.pos();
-		cur.boundary(false);
-	}
+	Inset * inset = it->inset;
+	//lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
+
+	// Set position in front of inset
+	cur.pos() = it->pos;
+	cur.boundary(false);
+	cur.setTargetX(x);
 
 	// 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();
@@ -1505,8 +1351,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];
@@ -1516,7 +1362,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)
@@ -1530,7 +1376,7 @@ void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const
 
 	bool bound = false;
 	int xx = x;
-	pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+	pos_type const pos = getPosNearX(row, xx, bound);
 
 	LYXERR(Debug::DEBUG, "setting cursor pit: " << pit << " pos: " << pos);
 
@@ -1541,11 +1387,8 @@ void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const
 
 
 //takes screen x,y coordinates
-Inset * TextMetrics::checkInsetHit(int x, int y)
+InsetList::InsetTable * TextMetrics::checkInsetHit(pit_type pit, int x, int y)
 {
-	pit_type pit = getPitNearY(y);
-	LASSERT(pit != -1, return 0);
-
 	Paragraph const & par = text_->paragraphs()[pit];
 	ParagraphMetrics const & pm = par_metrics_[pit];
 
@@ -1569,12 +1412,10 @@ Inset * TextMetrics::checkInsetHit(int x, int y)
 		LYXERR(Debug::DEBUG, "xo: " << p.x_ << "..." << p.x_ + dim.wid
 			<< " yo: " << p.y_ - dim.asc << "..." << p.y_ + dim.des);
 
-		if (x >= p.x_
-			&& x <= p.x_ + dim.wid
-			&& y >= p.y_ - dim.asc
-			&& y <= p.y_ + dim.des) {
+		if (x >= p.x_ && x <= p.x_ + dim.wid
+		    && y >= p.y_ - dim.asc && y <= p.y_ + dim.des) {
 			LYXERR(Debug::DEBUG, "Hit inset: " << inset);
-			return inset;
+			return const_cast<InsetList::InsetTable *>(&(*iit));
 		}
 	}
 
@@ -1583,139 +1424,68 @@ Inset * TextMetrics::checkInsetHit(int x, int y)
 }
 
 
-int TextMetrics::cursorX(CursorSlice const & sl,
-		bool boundary) const
+//takes screen x,y coordinates
+Inset * TextMetrics::checkInsetHit(int x, int y)
 {
-	LASSERT(sl.text() == text_, /**/);
-	pit_type const pit = sl.pit();
-	Paragraph const & par = text_->paragraphs()[pit];
-	ParagraphMetrics const & pm = par_metrics_[pit];
-	if (pm.rows().empty())
-		return 0;
-
-	pos_type ppos = sl.pos();
-	// Correct position in front of big insets
-	bool const boundary_correction = ppos != 0 && boundary;
-	if (boundary_correction)
-		--ppos;
-
-	Row const & row = pm.getRow(sl.pos(), boundary);
-
-	pos_type cursor_vpos = 0;
-
-	Buffer const & buffer = bv_->buffer();
-	double x = row.x;
-	Bidi bidi;
-	bidi.computeTables(par, buffer, row);
-
-	pos_type const row_pos  = row.pos();
-	pos_type const end      = row.endpos();
-	// Spaces at logical line breaks in bidi text must be skipped during
-	// cursor positioning. However, they may appear visually in the middle
-	// of a row; they must be skipped, wherever they are...
-	// * logically "abc_[HEBREW_\nHEBREW]"
-	// * visually "abc_[_WERBEH\nWERBEH]"
-	pos_type skipped_sep_vpos = -1;
-
-	if (end <= row_pos)
-		cursor_vpos = row_pos;
-	else if (ppos >= end)
-		cursor_vpos = text_->isRTL(par) ? row_pos : end;
-	else if (ppos > row_pos && ppos >= end)
-		// 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);
-	else
-		// Place cursor before char at (logical) position ppos
-		cursor_vpos = (bidi.level(ppos) % 2 == 0)
-			? bidi.log2vis(ppos) : bidi.log2vis(ppos) + 1;
-
-	pos_type body_pos = par.beginOfBody();
-	if (body_pos > 0 &&
-	    (body_pos > end || !par.isLineSeparator(body_pos - 1)))
-		body_pos = 0;
-
-	// check for possible inline completion in this row
-	DocIterator const & inlineCompletionPos = bv_->inlineCompletionPos();
-	pos_type inlineCompletionVPos = -1;
-	if (inlineCompletionPos.inTexted()
-	    && inlineCompletionPos.text() == text_
-	    && inlineCompletionPos.pit() == pit
-	    && inlineCompletionPos.pos() - 1 >= row_pos
-	    && inlineCompletionPos.pos() - 1 < end) {
-		// draw logically behind the previous character
-		inlineCompletionVPos = bidi.log2vis(inlineCompletionPos.pos() - 1);
-	}
-
-	// Use font span to speed things up, see below
-	FontSpan font_span;
-	Font font;
-
-	// If the last logical character is a separator, skip it, unless
-	// it's in the last row of a paragraph; see skipped_sep_vpos declaration
-	if (end > 0 && end < par.size() && par.isSeparator(end - 1))
-		skipped_sep_vpos = bidi.log2vis(end - 1);
-
-	// Inline completion RTL special case row_pos == cursor_pos:
-	// "__|b" => cursor_pos is right of __
-	if (row_pos == inlineCompletionVPos && row_pos == cursor_vpos) {
-		font = displayFont(pit, row_pos + 1);
-		docstring const & completion = bv_->inlineCompletion();
-		if (font.isRightToLeft() && completion.length() > 0)
-			x += theFontMetrics(font.fontInfo()).width(completion);
-	}
+	pit_type const pit = getPitNearY(y);
+	LASSERT(pit != -1, return 0);
+	InsetList::InsetTable * it = checkInsetHit(pit, x, y);
 
-	for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
-		// Skip the separator which is at the logical end of the row
-		if (vpos == skipped_sep_vpos)
-			continue;
-		pos_type pos = bidi.vis2log(vpos);
-		if (body_pos > 0 && pos == body_pos - 1) {
-			FontMetrics const & labelfm = theFontMetrics(
-				text_->labelFont(par));
-			x += row.label_hfill + labelfm.width(par.layout().labelsep);
-			if (par.isLineSeparator(body_pos - 1))
-				x -= singleWidth(pit, body_pos - 1);
-		}
+	if (!it)
+		return 0;
 
-		// Use font span to speed things up, see above
-		if (pos < font_span.first || pos > font_span.last) {
-			font_span = par.fontSpan(pos);
-			font = displayFont(pit, pos);
-		}
+	return it->inset;
+}
 
-		x += pm.singleWidth(pos, font);
 
-		// Inline completion RTL case:
-		// "a__|b", __ of b => non-boundary a-pos is right of __
-		if (vpos + 1 == inlineCompletionVPos
-		    && (vpos + 1 < cursor_vpos || !boundary_correction)) {
-			font = displayFont(pit, vpos + 1);
-			docstring const & completion = bv_->inlineCompletion();
-			if (font.isRightToLeft() && completion.length() > 0)
-				x += theFontMetrics(font.fontInfo()).width(completion);
-		}
+int TextMetrics::cursorX(CursorSlice const & sl,
+		bool boundary) const
+{
+	LASSERT(sl.text() == text_, return 0);
 
-		//  Inline completion LTR case:
-		// "b|__a", __ of b => non-boundary a-pos is in front of __
-		if (vpos == inlineCompletionVPos
-		    && (vpos + 1 < cursor_vpos || boundary_correction)) {
-			font = displayFont(pit, vpos);
-			docstring const & completion = bv_->inlineCompletion();
-			if (!font.isRightToLeft() && completion.length() > 0)
-				x += theFontMetrics(font.fontInfo()).width(completion);
+	ParagraphMetrics const & pm = par_metrics_[sl.pit()];
+	if (pm.rows().empty())
+		return 0;
+	Row const & row = pm.getRow(sl.pos(), boundary);
+	pos_type const pos = sl.pos();
+
+	/**
+	 * When boundary is true, position i is in the row element (pos, endpos)
+	 * if
+	 *    pos < i <= endpos
+	 * whereas, when boundary is false, the test is
+	 *    pos <= i < endpos
+	 * The correction below allows to handle both cases.
+	*/
+	int const boundary_corr = (boundary && pos) ? -1 : 0;
+
+	/** Early return in trivial cases
+	 * 1) the row is empty
+	 * 2) the position is the left-most position of the row; there
+	 * is a quirck herehowever: if the first element is virtual
+	 * (end-of-par marker for example), then we have to look
+	 * closer
+	 */
+	if (row.empty()
+	    || (pos == row.begin()->left_pos()
+		&& pos != row.begin()->right_pos()))
+		return row.left_margin;
+
+	Row::const_iterator cit = row.begin();
+	double x = row.left_margin;
+	for ( ; cit != row.end() ; ++cit) {
+		/** Look whether the cursor is inside the element's
+		 * span. Note that it is necessary to take the
+		 * boundary in account, and to accept virtual
+		 * elements, which have pos == endpos.
+		 */
+		if (pos + boundary_corr >= cit->pos
+		    && (pos + boundary_corr < cit->endpos
+			|| cit->pos == cit->endpos)) {
+				x += cit->pos2x(pos);
+				break;
 		}
-
-		if (par.isSeparator(pos) && pos >= body_pos)
-			x += row.separator;
-	}
-
-	// see correction above
-	if (boundary_correction) {
-		if (isRTL(sl, boundary))
-			x -= singleWidth(pit, ppos);
-		else
-			x += singleWidth(pit, ppos);
+		x += cit->full_width();
 	}
 
 	return int(x);
@@ -1750,7 +1520,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());
@@ -1759,7 +1529,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.
@@ -1770,7 +1540,8 @@ bool TextMetrics::cursorEnd(Cursor & cur)
 	bool boundary = false;
 	if (end != cur.lastpos()) {
 		if (!cur.paragraph().isLineSeparator(end-1)
-		    && !cur.paragraph().isNewline(end-1))
+		    && !cur.paragraph().isNewline(end-1)
+		    && !cur.paragraph().isEnvSeparator(end-1))
 			boundary = true;
 		else
 			--end;
@@ -1781,7 +1552,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);
@@ -1816,8 +1587,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());
 }
 
@@ -1827,11 +1596,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();
@@ -1853,6 +1622,15 @@ int TextMetrics::leftMargin(int max_width,
 		if (newpar != pit_type(pars.size())) {
 			if (pars[newpar].layout().isEnvironment()) {
 				l_margin = leftMargin(max_width, newpar);
+				// Remove the parindent that has been added
+				// if the paragraph was empty.
+				if (pars[newpar].empty() &&
+				    buffer.params().paragraph_separation ==
+				    BufferParams::ParagraphIndentSeparation) {
+					docstring pi = pars[newpar].layout().parindent;
+					l_margin -= theFontMetrics(
+						buffer.params().getFont()).signedWidth(pi);
+				}
 			}
 			if (tclass.isDefaultLayout(par.layout())
 			    || tclass.isPlainLayout(par.layout())) {
@@ -1864,12 +1642,20 @@ int TextMetrics::leftMargin(int max_width,
 		}
 	}
 
-	// This happens after sections in standard classes. The 1.3.x
-	// code compared depths too, but it does not seem necessary
-	// (JMarc)
-	if (tclass.isDefaultLayout(par.layout())
-	    && pit > 0 && pars[pit - 1].layout().nextnoindent)
+	// This happens after sections or environments in standard classes.
+	// We have to check the previous layout at same depth.
+	if (buffer.params().paragraph_separation ==
+			BufferParams::ParagraphSkipSeparation)
 		parindent.erase();
+	else if (pit > 0 && pars[pit - 1].getDepth() >= par.getDepth()) {
+		pit_type prev = text_->depthHook(pit, par.getDepth());
+		if (par.layout() == pars[prev].layout()) {
+			if (prev != pit - 1
+			    && pars[pit - 1].layout().nextnoindent)
+				parindent.erase();
+		} else if (pars[prev].layout().nextnoindent)
+			parindent.erase();
+	}
 
 	FontInfo const labelfont = text_->labelFont(par);
 	FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
@@ -1920,10 +1706,7 @@ int TextMetrics::leftMargin(int max_width,
 			       && layout.latextype == LATEX_ENVIRONMENT
 			       && !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());
@@ -1932,16 +1715,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.
@@ -1963,42 +1748,35 @@ 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_STATIC
-	           && layout.latextype == LATEX_ENVIRONMENT
-	           && !text_->isFirstInSequence(pit)))
-	    && align == LYX_ALIGN_BLOCK
+		|| layout.labeltype == LABEL_ABOVE
+		|| layout.labeltype == LABEL_CENTERED
+		|| (layout.labeltype == LABEL_STATIC
+		    && layout.latextype == LATEX_ENVIRONMENT
+		    && !text_->isFirstInSequence(pit)))
+	    && (align == LYX_ALIGN_BLOCK || align == LYX_ALIGN_LEFT)
 	    && !par.params().noindent()
 	    // in some insets, paragraphs are never indented
 	    && !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)
-	    )
-		{
-			// use the parindent of the layout when the default indentation is used
-			// otherwise use the indentation set in the document settings
+		 && par.isInset(pos)
+		 && par.getInset(pos)->display())
+	    && (!(tclass.isDefaultLayout(par.layout())
+		  || tclass.isPlainLayout(par.layout()))
+	        || buffer.params().paragraph_separation
+				== BufferParams::ParagraphIndentSeparation)) {
+			// 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);
+				l_margin += theFontMetrics(
+					buffer.params().getFont()).signedWidth(parindent);
 			else
 				l_margin += buffer.params().getIndentation().inPixels(*bv_);
 		}
-	
-	return l_margin;
-}
-
-
-int TextMetrics::singleWidth(pit_type pit, pos_type pos) const
-{
-	ParagraphMetrics const & pm = par_metrics_[pit];
 
-	return pm.singleWidth(pos, displayFont(pit, pos));
+	return l_margin;
 }
 
 
@@ -2032,7 +1810,6 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 	if (pm.rows().empty())
 		return;
 
-	Bidi bidi;
 	bool const original_drawing_state = pi.pain.isDrawingEnabled();
 	int const ww = bv_->workHeight();
 	size_t const nrows = pm.rows().size();
@@ -2044,13 +1821,13 @@ 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
 	DocIterator sel_beg_par = cur.selectionBegin();
 	DocIterator sel_end_par = cur.selectionEnd();
-	
+
 	// We care only about visible selection.
 	if (selection) {
 		if (pit != sel_beg.pit()) {
@@ -2073,13 +1850,13 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 			&& y - row.ascent() < ww);
 		// It is not needed to draw on screen if we are not inside.
 		pi.pain.setDrawingEnabled(inside && original_drawing_state);
-		RowPainter rp(pi, *text_, pit, row, bidi, x, y);
+		RowPainter rp(pi, *text_, pit, row, x, y);
 
 		if (selection)
 			row.setSelectionAndMargins(sel_beg_par, sel_end_par);
 		else
 			row.setSelection(-1, -1);
-		
+
 		// The row knows nothing about the paragraph, so we have to check
 		// whether this row is the first or last and update the margins.
 		if (row.selection()) {
@@ -2093,6 +1870,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) {
@@ -2109,9 +1891,6 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 			pi.pain.fillRectangle(x, y - row.ascent(),
 				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):
@@ -2129,15 +1908,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;
 	}
@@ -2148,102 +1935,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();
-
-	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() ? bv_->rightMargin() : 0;
-	int const lm = text_->isMainText() ? bv_->leftMargin() : 0;
-
-	// draw the margins
-	if (row.begin_margin_sel) {
-		if (text_->isRTL(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(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
 {
@@ -2255,11 +1946,17 @@ 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);
+	Row row;
+	row.pos(wordStart.pos());
+	row.endpos(bvcur.pos());
+	setRowHeight(row, bvcur.pit(), false);
+	dim = row.dimension();
 	dim.wid = abs(rxy.x_ - lxy.x_);
 
 	// calculate position of word
@@ -2270,15 +1967,6 @@ void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y,
 	//lyxerr << " wordstart=" << wordStart << " bvcur=" << bvcur << " cur=" << cur << std::endl;
 }
 
-//int TextMetrics::pos2x(pit_type pit, pos_type pos) const
-//{
-//	ParagraphMetrics const & pm = par_metrics_[pit];
-//	Row const & r = pm.rows()[row];
-//	int x = 0;
-//	pos -= r.pos();
-//}
-
-
 int defaultRowHeight()
 {
 	return int(theFontMetrics(sane_font).maxHeight() *  1.2);