X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextMetrics.cpp;h=52af39a68280af50ab3a1587d29953c96ab8bfa5;hb=f6dd83a93621df9445c99219ab9d3cf1d00c2b82;hp=a5f03648de854271f2261f8fb5d7e03a657f2ad3;hpb=8fb1aa51f8d14747bd21d9e113a8dd301a2f07dc;p=lyx.git

diff --git a/src/TextMetrics.cpp b/src/TextMetrics.cpp
index a5f03648de..52af39a682 100644
--- a/src/TextMetrics.cpp
+++ b/src/TextMetrics.cpp
@@ -28,6 +28,7 @@
 #include "CutAndPaste.h"
 #include "HSpace.h"
 #include "InsetList.h"
+#include "Language.h"
 #include "Layout.h"
 #include "LyXRC.h"
 #include "MetricsInfo.h"
@@ -58,28 +59,6 @@ using frontend::FontMetrics;
 
 namespace {
 
-int numberOfSeparators(Row const & row)
-{
-	int n = 0;
-	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;
-}
-
-
-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)
 {
@@ -101,15 +80,18 @@ int numberOfLabelHfills(Paragraph const & par, Row const & row)
 	return n;
 }
 
-
-int numberOfHfills(Row const & row, pos_type const body_pos)
+// FIXME: this needs to be rewritten, probably by merging it into some
+// code that, besides counting, sets the active status of the space
+// inset in the row element.
+int numberOfHfills(Row const & row, ParagraphMetrics const & pm,
+                   pos_type const body_pos)
 {
 	int n = 0;
 	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())
+		    && cit->inset && pm.hfillExpansion(row, cit->pos))
 			++n;
 	return n;
 }
@@ -385,7 +367,7 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 		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);
+			cur.recordUndo(pit, pit);
 
 		int const moveCursor = par.fixBiblio(buffer);
 
@@ -421,6 +403,7 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 
 	// redo insets
 	Font const bufferfont = buffer.params().getFont();
+	CoordCache::Insets & insetCache = bv_->coordCache().insets();
 	InsetList::const_iterator ii = par.insetList().begin();
 	InsetList::const_iterator iend = par.insetList().end();
 	for (; ii != iend; ++ii) {
@@ -446,9 +429,8 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 		MacroContext mc(&buffer, parPos);
 		MetricsInfo mi(bv_, font.fontInfo(), w, mc);
 		ii->inset->metrics(mi, dim);
-		Dimension const old_dim = pm.insetDimension(ii->inset);
-		if (old_dim != dim) {
-			pm.setInsetDimension(ii->inset, dim);
+		if (!insetCache.has(ii->inset) || insetCache.dim(ii->inset) != dim) {
+			insetCache.add(ii->inset, dim);
 			changed = true;
 		}
 	}
@@ -465,10 +447,17 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 		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.
+		if (row_index || row.endpos() < par.size()
+			|| (row.right_boundary() && par.inInset().lyxCode() != CELL_CODE))
+			/* If there is more than one row or the row has been
+			 * broken by a display inset or a newline, expand the text
+			 * to the full allowable width. This setting here is
+			 * needed for the computeRowMetrics() below. In the case
+			 * of a display inset, we do nothing when inside a table
+			 * cell, because the tabular code is not prepared for
+			 * that, and it triggers when using a caption in a
+			 * longtable (see bugs #9945 and #9757).
+			 */
 			dim_.wid = max_width_;
 		int const max_row_width = max(dim_.wid, row.width());
 		computeRowMetrics(pit, row, max_row_width);
@@ -489,7 +478,7 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 			pm.rows().push_back(Row());
 		Row & row = pm.rows()[row_index];
 		row.pos(first);
-		row.endpos(first);
+		breakRow(row, right_margin, pit);
 		setRowHeight(row, pit);
 		row.setChanged(false);
 		int const max_row_width = max(dim_.wid, row.width());
@@ -506,11 +495,11 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 }
 
 
-int TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
+LyXAlignment TextMetrics::getAlign(Paragraph const & par, Row const & row) const
 {
 	Layout const & layout = par.layout();
 
-	int align;
+	LyXAlignment align;
 	if (par.params().align() == LYX_ALIGN_LAYOUT)
 		align = layout.align;
 	else
@@ -518,7 +507,14 @@ int TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
 
 	// handle alignment inside tabular cells
 	Inset const & owner = text_->inset();
+	bool forced_block = false;
 	switch (owner.contentAlignment()) {
+	case LYX_ALIGN_BLOCK:
+		// In general block align is the default state, but here it is
+		// an explicit choice. Therefore it should not be overridden
+		// later.
+		forced_block = true;
+		// fall through
 	case LYX_ALIGN_CENTER:
 	case LYX_ALIGN_LEFT:
 	case LYX_ALIGN_RIGHT:
@@ -531,7 +527,7 @@ int TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
 	}
 
 	// Display-style insets should always be on a centered row
-	if (Inset const * inset = par.getInset(pos)) {
+	if (Inset const * inset = par.getInset(row.pos())) {
 		switch (inset->display()) {
 		case Inset::AlignLeft:
 			align = LYX_ALIGN_BLOCK;
@@ -548,10 +544,17 @@ int TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
 		}
 	}
 
-	// Has the user requested we not justify stuff?
-	if (!bv_->buffer().params().justification
-	    && align == LYX_ALIGN_BLOCK)
-		align = LYX_ALIGN_LEFT;
+	if (align == LYX_ALIGN_BLOCK) {
+		// If this row has been broken abruptly by a display inset, or
+		// it is the end of the paragraph, or the user requested we
+		// not justify stuff, then don't stretch.
+		// A forced block alignment can only be overridden the 'no
+		// justification on screen' setting.
+		if (((row.right_boundary() || row.endpos() == par.size())
+		     && !forced_block)
+		    || !bv_->buffer().params().justification)
+			align = text_->isRTL(par) ? LYX_ALIGN_RIGHT : LYX_ALIGN_LEFT;
+	}
 
 	return align;
 }
@@ -565,16 +568,10 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 
 	Paragraph const & par = text_->getPar(pit);
 
-	double const w = width - row.right_margin - row.width();
+	int const w = width - row.right_margin - row.width();
 	// FIXME: put back this assertion when the crash on new doc is solved.
 	//LASSERT(w >= 0, /**/);
 
-	bool const is_rtl = text_->isRTL(par);
-	if (is_rtl)
-		row.x = rightMargin(pit);
-	else
-		row.x = leftMargin(max_width_, pit, row.pos());
-
 	// is there a manual margin with a manual label
 	Layout const & layout = par.layout();
 
@@ -596,81 +593,80 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 			row.label_hfill = labelFill(pit, row) / double(nlh);
 	}
 
-	double hfill = 0;
 	// are there any hfills in the 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
-	// if the row is already larger then the permitted width as then
-	// we force the LEFT_ALIGN'edness!
-	} else if (int(row.width()) < max_width_) {
-		// is it block, flushleft or flushright?
-		// set x how you need it
-		switch (getAlign(par, row.pos())) {
+	ParagraphMetrics & pm = par_metrics_[pit];
+	int nh = numberOfHfills(row, pm, par.beginOfBody());
+	int hfill = 0;
+	int hfill_rem = 0;
+
+	// We don't have to look at the alignment if the row is already
+	// larger then the permitted width as then we force the
+	// LEFT_ALIGN'edness!
+	if (int(row.width()) >= max_width_)
+		return;
+
+	if (nh == 0) {
+		// Common case : there is no hfill, and the alignment will be
+		// meaningful
+		switch (getAlign(par, row)) {
 		case LYX_ALIGN_BLOCK: {
-			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.dimension().wid = width;
-				row.x += w;
+			int const ns = row.countSeparators();
+			// If we have separators, then stretch the row
+			if (ns) {
+				row.setSeparatorExtraWidth(double(w) / ns);
+				row.dimension().wid += w;
+			} else if (text_->isRTL(par)) {
+				row.left_margin += w;
+				row.dimension().wid += w;
 			}
 			break;
 		}
 		case LYX_ALIGN_RIGHT:
-			row.x += w;
+			row.left_margin += w;
+			row.dimension().wid += w;
 			break;
 		case LYX_ALIGN_CENTER:
-			row.dimension().wid = width - w / 2;
-			row.x += w / 2;
+			row.dimension().wid += 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;
 		}
+		return;
 	}
 
-#if 0
-	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;
-		}
-	}
-#endif
-
-	// Finally,  handle hfill insets
+	hfill = w / nh;
+	hfill_rem = w % nh;
+	row.dimension().wid += w;
+	// Set size of 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 = 0;
-	ParagraphMetrics & pm = par_metrics_[pit];
+
+	CoordCache::Insets & insetCache = bv_->coordCache().insets();
 	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 -= row.label_hfill * (nlh - 1);
-		if (!cit->inset || !cit->inset->isHfill())
-			continue;
-		if (pm.hfillExpansion(row, cit->pos))
-			cit->dim.wid = int(cit->pos >= body_pos ?
-					   max(hfill, 5.0) : row.label_hfill);
-		else
-			cit->dim.wid = 5;
-		// Cache the inset dimension.
-		bv_->coordCache().insets().add(cit->inset, cit->dim);
-		pm.setInsetDimension(cit->inset, cit->dim);
+			cit->dim.wid -= int(row.label_hfill * (nlh - 1));
+		if (cit->inset && pm.hfillExpansion(row, cit->pos)) {
+			if (cit->pos >= body_pos) {
+				cit->dim.wid += hfill;
+				--nh;
+				if (nh == 0)
+					cit->dim.wid += hfill_rem;
+			} else
+				cit->dim.wid += int(row.label_hfill);
+			// Cache the inset dimension.
+			insetCache.add(cit->inset, cit->dim);
+		}
 	}
 }
 
@@ -686,7 +682,7 @@ int TextMetrics::labelFill(pit_type const pit, Row const & row) const
 	// iterate over elements before main body (except the last one,
 	// which is extra space).
 	while (cit!= end && cit->endpos < par.beginOfBody()) {
-		w += cit->width();
+		w += cit->dim.wid;
 		++cit;
 	}
 
@@ -786,26 +782,28 @@ private:
 
 /** 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
+ * intelligence is also in Row::shortenIfNeeded.
  */
 void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit) const
 {
 	Paragraph const & par = text_->getPar(pit);
 	pos_type const end = par.size();
 	pos_type const pos = row.pos();
-	int const width = max_width_ - right_margin;
 	pos_type const body_pos = par.beginOfBody();
+	bool const is_rtl = text_->isRTL(par);
+	bool need_new_row = false;
+
 	row.clear();
-	row.dimension().wid = leftMargin(max_width_, pit, pos);
+	row.left_margin = leftMargin(max_width_, pit, pos);
 	row.right_margin = right_margin;
+	if (is_rtl)
+		swap(row.left_margin, row.right_margin);
+	// Remember that the row width takes into account the left_margin
+	// but not the right_margin.
+	row.dimension().wid = row.left_margin;
+	// the width available for the row.
+	int const width = max_width_ - row.right_margin;
 
-	if (pos >= end || row.width() > width) {
-		row.dimension().wid += right_margin;
-		row.endpos(end);
-		return;
-	}
-
-	ParagraphMetrics const & pm = par_metrics_[pit];
 	ParagraphList const & pars = text_->paragraphs();
 
 #if 0
@@ -817,25 +815,24 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 #endif
 
 	// 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;
-	}
+	DocIterator const & ic_it = bv_->inlineCompletionPos();
+	pos_type ic_pos = -1;
+	if (ic_it.inTexted() && ic_it.text() == text_ && ic_it.pit() == pit)
+		ic_pos = ic_it.pos();
 
 	// Now we iterate through until we reach the right margin
 	// or the end of the par, then build a representation of the row.
 	pos_type i = pos;
 	FontIterator fi = FontIterator(*this, par, pit, pos);
-	while (i < end && row.width() < width) {
+	do {
+		// this can happen for an empty row after a newline
+		if (i >= end)
+			break;
 		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);
+			Dimension dim = bv_->coordCache().insets().dim(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
@@ -843,29 +840,39 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 			// 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
+		else {
+			// FIXME: please someone fix the Hebrew/Arabic parenthesis mess!
+			// see also Paragraph::getUChar.
+			if (fi->language()->lang() == "hebrew") {
+				if (c == '(')
+					c = ')';
+				else if (c == ')')
+					c = '(';
+			}
 			row.add(i, c, *fi, par.lookupChange(i));
+		}
 
 		// add inline completion width
-		if (inlineCompletionLPos == i &&
-		    !bv_->inlineCompletion().empty()) {
+		// draw logically behind the previous character
+		if (ic_pos == i + 1 && !bv_->inlineCompletion().empty()) {
+			docstring const comp = bv_->inlineCompletion();
+			size_t const uniqueTo =bv_->inlineCompletionUniqueChars();
 			Font f = *fi;
-			f.fontInfo().setColor(Color_inlinecompletion);
-			row.addVirtual(i + 1, bv_->inlineCompletion(),
-					  f, Change());
+
+			if (uniqueTo > 0) {
+				f.fontInfo().setColor(Color_inlinecompletion);
+				row.addVirtual(i + 1, comp.substr(0, uniqueTo), f, Change());
+			}
+			f.fontInfo().setColor(Color_nonunique_inlinecompletion);
+			row.addVirtual(i + 1, comp.substr(uniqueTo), f, Change());
 		}
 
 		// Handle some situations that abruptly terminate the row
@@ -879,18 +886,19 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 		    || (!row.empty() && row.back().inset
 			&& row.back().inset->display())) {
 			row.right_boundary(true);
+			need_new_row = par.isNewline(i);
 			++i;
 			break;
 		}
 
 		++i;
 		++fi;
-	}
+	} while (i < end && row.width() <= width);
 	row.finalizeLast();
 	row.endpos(i);
 
 	// End of paragraph marker
-	if (lyxrc.paragraph_markers
+	if (lyxrc.paragraph_markers && !need_new_row
 	    && 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
@@ -903,17 +911,14 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 		row.addVirtual(end, docstring(1, char_type(0x00B6)), f, Change());
 	}
 
-	// if the row is too large, try to cut at last separator.
-	row.shortenIfNeeded(body_pos, width);
-
-	// 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();
+	// if the row is too large, try to cut at last separator. In case
+	// of success, reset indication that the row was broken abruptly.
+	if (row.shortenIfNeeded(body_pos, width))
+		row.right_boundary(false);
 
 	// make sure that the RTL elements are in reverse ordering
-	row.reverseRTL(text_->isRTL(par));
+	row.reverseRTL(is_rtl);
+	//LYXERR0("breakrow: row is " << row);
 }
 
 
@@ -955,12 +960,12 @@ void TextMetrics::setRowHeight(Row & row, pit_type const pit,
 	int maxdesc = int(fontmetrics.maxDescent() * spacing_val);
 
 	// insets may be taller
-	ParagraphMetrics const & pm = par_metrics_[pit];
+	CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
 	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);
+			Dimension const & dim = insetCache.dim(cit->inset);
 			maxasc  = max(maxasc,  dim.ascent());
 			maxdesc = max(maxdesc, dim.descent());
 		}
@@ -1099,6 +1104,7 @@ void TextMetrics::setRowHeight(Row & row, pit_type const pit,
 pos_type TextMetrics::getPosNearX(Row const & row, int & x,
 				  bool & boundary) const
 {
+	//LYXERR0("getPosNearX(" << x << ") row=" << row);
 	/// 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.
@@ -1108,29 +1114,29 @@ pos_type TextMetrics::getPosNearX(Row const & row, int & x,
 	pos_type pos = row.pos();
 	boundary = false;
 	if (row.empty())
-		x = row.x;
-	else if (x <= row.x) {
+		x = row.left_margin;
+	else if (x <= row.left_margin) {
 		pos = row.front().left_pos();
-		x = row.x;
-	} else if (x >= row.width() - row.right_margin) {
+		x = row.left_margin;
+	} else if (x >= row.width()) {
 		pos = row.back().right_pos();
-		x = row.width() - row.right_margin;
+		x = row.width();
 	} else {
-		double w = row.x;
+		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->width() > x) {
-				double x_offset = x - w;
+			if (w <= x &&  w + cit->full_width() > x) {
+				int x_offset = int(x - w);
 				pos = cit->x2pos(x_offset);
-				x = x_offset + w;
+				x = int(x_offset + w);
 				break;
 			}
-			w += cit->width();
+			w += cit->full_width();
 		}
 		if (cit == row.end()) {
 			pos = row.back().right_pos();
-			x = row.width() - row.right_margin;
+			x = row.width();
 		}
 		/** This tests for the case where the cursor is placed
 		 * just before a font direction change. See comment on
@@ -1139,19 +1145,27 @@ pos_type TextMetrics::getPosNearX(Row const & row, int & x,
 		 */
 		else if (pos == cit->endpos
 			 && cit + 1 != row.end()
-			 && cit->font.isVisibleRightToLeft() != (cit + 1)->font.isVisibleRightToLeft())
+			 && cit->isRTL() != (cit + 1)->isRTL())
 			boundary = true;
 	}
 
 	/** This tests for the case where the cursor is set at the end
-	 * of a row which has been broken due to a display inset on
-	 * next row. This is indicated by Row::right_boundary.
+	 * 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 = row.right_boundary();
-
+	    && row.back().endpos == row.endpos()) {
+		Inset const * inset = row.back().inset;
+		if (inset && (inset->lyxCode() == NEWLINE_CODE
+		              || inset->lyxCode() == SEPARATOR_CODE))
+			pos = row.back().pos;
+		else
+			boundary = row.right_boundary();
+	}
 	x += xo;
+	//LYXERR0("getPosNearX ==> pos=" << pos << ", boundary=" << boundary);
 	return pos;
 }
 
@@ -1345,11 +1359,28 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y,
 	cur.setTargetX(x);
 
 	// Try to descend recursively inside the inset.
-	inset = inset->editXY(cur, x, yy);
+	Inset * edited = inset->editXY(cur, x, yy);
+	if (edited == inset && cur.pos() == it->pos) {
+		// non-editable inset, set cursor after the inset if x is
+		// nearer to that position (bug 9628)
+		CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
+		Dimension const & dim = insetCache.dim(inset);
+		Point p = insetCache.xy(inset);
+		bool const is_rtl = text_->isRTL(text_->getPar(pit));
+		if (is_rtl) {
+			// "in front of" == "right of"
+			if (abs(p.x_ - x) < abs(p.x_ + dim.wid - x))
+				cur.posForward();
+		} else {
+			// "in front of" == "left of"
+			if (abs(p.x_ + dim.wid - x) < abs(p.x_ - x))
+				cur.posForward();
+		}
+	}
 
 	if (cur.top().text() == text_)
 		cur.setCurrentFont();
-	return inset;
+	return edited;
 }
 
 
@@ -1394,7 +1425,7 @@ void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const
 InsetList::InsetTable * TextMetrics::checkInsetHit(pit_type pit, int x, int y)
 {
 	Paragraph const & par = text_->paragraphs()[pit];
-	ParagraphMetrics const & pm = par_metrics_[pit];
+	CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
 
 	LYXERR(Debug::DEBUG, "x: " << x << " y: " << y << "  pit: " << pit);
 
@@ -1405,13 +1436,13 @@ InsetList::InsetTable * TextMetrics::checkInsetHit(pit_type pit, int x, int y)
 
 		LYXERR(Debug::DEBUG, "examining inset " << inset);
 
-		if (!bv_->coordCache().getInsets().has(inset)) {
+		if (!insetCache.has(inset)) {
 			LYXERR(Debug::DEBUG, "inset has no cached position");
 			return 0;
 		}
 
-		Dimension const & dim = pm.insetDimension(inset);
-		Point p = bv_->coordCache().getInsets().xy(inset);
+		Dimension const & dim = insetCache.dim(inset);
+		Point p = insetCache.xy(inset);
 
 		LYXERR(Debug::DEBUG, "xo: " << p.x_ << "..." << p.x_ + dim.wid
 			<< " yo: " << p.y_ - dim.asc << "..." << p.y_ + dim.des);
@@ -1442,17 +1473,10 @@ Inset * TextMetrics::checkInsetHit(int x, int y)
 }
 
 
-int TextMetrics::cursorX(CursorSlice const & sl,
-		bool boundary) const
+Row::const_iterator const
+TextMetrics::findRowElement(Row const & row, pos_type const pos,
+                            bool const boundary, double & x) const
 {
-	LASSERT(sl.text() == text_, return 0);
-
-	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
@@ -1463,36 +1487,57 @@ int TextMetrics::cursorX(CursorSlice const & sl,
 	*/
 	int const boundary_corr = (boundary && pos) ? -1 : 0;
 
+	x = row.left_margin;
+
 	/** 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
+	 * is a quirk here however: 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 int(row.x);
+	    || (pos == row.begin()->left_pos() && !boundary
+			&& !row.begin()->isVirtual()))
+		return row.begin();
 
 	Row::const_iterator cit = row.begin();
-	double x = row.x;
 	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
+		 * boundary into 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)) {
+		    && (pos + boundary_corr < cit->endpos || cit->isVirtual())) {
 				x += cit->pos2x(pos);
 				break;
 		}
-		x += cit->width();
+		x += cit->full_width();
 	}
 
+	if (cit == row.end())
+		--cit;
+
+	return cit;
+}
+
+
+int TextMetrics::cursorX(CursorSlice const & sl,
+		bool boundary) const
+{
+	LASSERT(sl.text() == text_, return 0);
+
+	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();
+
+	double x = 0;
+	findRowElement(row, pos, boundary, x);
 	return int(x);
+
 }
 
 
@@ -1620,12 +1665,16 @@ int TextMetrics::leftMargin(int max_width,
 	l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
 		tclass.leftmargin());
 
-	if (par.getDepth() != 0) {
+	int depth = par.getDepth();
+	if (depth != 0) {
 		// find the next level paragraph
 		pit_type newpar = text_->outerHook(pit);
 		if (newpar != pit_type(pars.size())) {
 			if (pars[newpar].layout().isEnvironment()) {
-				l_margin = leftMargin(max_width, newpar);
+				int nestmargin = depth * nestMargin();
+				if (text_->isMainText())
+					nestmargin += changebarMargin();
+				l_margin = max(leftMargin(max_width, newpar), nestmargin);
 				// Remove the parindent that has been added
 				// if the paragraph was empty.
 				if (pars[newpar].empty() &&
@@ -1740,7 +1789,7 @@ int TextMetrics::leftMargin(int max_width,
 	}
 
 	if (!par.params().leftIndent().zero())
-		l_margin += par.params().leftIndent().inPixels(max_width);
+		l_margin += par.params().leftIndent().inPixels(max_width, labelfont_metrics.em());
 
 	LyXAlignment align;
 
@@ -1807,7 +1856,7 @@ void TextMetrics::draw(PainterInfo & pi, int x, int y) const
 }
 
 
-void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) const
+void TextMetrics::drawParagraph(PainterInfo & pi, pit_type const pit, int const x, int y) const
 {
 	BufferParams const & bparams = bv_->buffer().params();
 	ParagraphMetrics const & pm = par_metrics_[pit];
@@ -1847,14 +1896,25 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 	for (size_t i = 0; i != nrows; ++i) {
 
 		Row const & row = pm.rows()[i];
+		int row_x = x;
 		if (i)
 			y += row.ascent();
 
+		CursorSlice rowSlice(const_cast<InsetText &>(text_->inset()));
+		rowSlice.pit() = pit;
+		rowSlice.pos() = row.pos();
+
 		bool const inside = (y + row.descent() >= 0
 			&& y - row.ascent() < ww);
+
+		// Adapt to cursor row scroll offset if applicable.
+		if (bv_->currentRowSlice() == rowSlice)
+			row_x -= bv_->horizScrollOffset();
+
 		// 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, x, y);
+
+		RowPainter rp(pi, *text_, pit, row, row_x, y);
 
 		if (selection)
 			row.setSelectionAndMargins(sel_beg_par, sel_end_par);
@@ -1871,11 +1931,13 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 		}
 
 		// Row signature; has row changed since last paint?
-		row.setCrc(pm.computeRowSignature(row, bparams));
-		bool row_has_changed = row.changed();
+		if (pi.pain.isDrawingEnabled())
+			row.setCrc(pm.computeRowSignature(row, bparams));
+		bool row_has_changed = row.changed()
+			|| rowSlice == bv_->lastRowSlice();
 
 		// Take this opportunity to spellcheck the row contents.
-		if (row_has_changed && lyxrc.spellcheck_continuously) {
+		if (row_has_changed && pi.do_spellcheck && lyxrc.spellcheck_continuously) {
 			text_->getPar(pit).spellCheck();
 		}
 
@@ -1892,7 +1954,10 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 		// Clear background of this row if paragraph background was not
 		// already cleared because of a full repaint.
 		if (!pi.full_repaint && row_has_changed) {
-			pi.pain.fillRectangle(x, y - row.ascent(),
+			LYXERR(Debug::PAINTING, "Clear rect@("
+			       << max(row_x, 0) << ", " << y - row.ascent() << ")="
+			       << width() << " x " << row.height());
+			pi.pain.fillRectangle(max(row_x, 0), y - row.ascent(),
 				width(), row.height(), pi.background_color);
 		}
 
@@ -1905,7 +1970,8 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 			LYXERR(Debug::PAINTING, foreword << "pit=" << pit << " row=" << i
 				<< " row_selection="	<< row.selection()
 				<< " full_repaint="	<< pi.full_repaint
-				<< " row_has_changed="	<< row_has_changed);
+				<< " row_has_changed="	<< row_has_changed
+				<< " drawingEnabled=" << pi.pain.isDrawingEnabled());
 		}
 
 		// Backup full_repaint status and force full repaint
@@ -1927,6 +1993,8 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co
 			rp.paintLast();
 		if (i == 0 && is_rtl)
 			rp.paintFirst();
+		rp.paintTooLargeMarks(row_x + row.left_x() < 0,
+				      row_x + row.right_x() > bv_->workWidth());
 		y += row.descent();
 
 		// Restore full_repaint status.