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

diff --git a/src/TextMetrics.cpp b/src/TextMetrics.cpp
index fc5e1c5ac5..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"
@@ -79,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;
 }
@@ -399,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) {
@@ -424,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;
 		}
 	}
@@ -443,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);
@@ -467,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());
@@ -484,7 +495,7 @@ bool TextMetrics::redoParagraph(pit_type const pit)
 }
 
 
-LyXAlignment 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();
 
@@ -496,7 +507,14 @@ LyXAlignment TextMetrics::getAlign(Paragraph const & par, pos_type const pos) co
 
 	// 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:
@@ -509,7 +527,7 @@ LyXAlignment TextMetrics::getAlign(Paragraph const & par, pos_type const pos) co
 	}
 
 	// 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;
@@ -526,10 +544,17 @@ LyXAlignment TextMetrics::getAlign(Paragraph const & par, pos_type const pos) co
 		}
 	}
 
-	// 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;
 }
@@ -568,30 +593,31 @@ 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 = double(w) / 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 = row.countSeparators();
-			/** 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()) {
+			// If we have separators, then stretch the row
+			if (ns) {
 				row.setSeparatorExtraWidth(double(w) / ns);
-				row.dimension().wid = width;
+				row.dimension().wid += w;
 			} else if (text_->isRTL(par)) {
-				row.dimension().wid = width;
 				row.left_margin += w;
+				row.dimension().wid += w;
 			}
 			break;
 		}
@@ -600,7 +626,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 			row.dimension().wid += w;
 			break;
 		case LYX_ALIGN_CENTER:
-			row.dimension().wid = width - w / 2;
+			row.dimension().wid += w / 2;
 			row.left_margin += w / 2;
 			break;
 		case LYX_ALIGN_LEFT:
@@ -610,31 +636,37 @@ void TextMetrics::computeRowMetrics(pit_type const pit,
 		case LYX_ALIGN_DECIMAL:
 			break;
 		}
+		return;
 	}
 
-	// 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 -= int(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);
+		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);
+		}
 	}
 }
 
@@ -759,6 +791,7 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 	pos_type const pos = row.pos();
 	pos_type const body_pos = par.beginOfBody();
 	bool const is_rtl = text_->isRTL(par);
+	bool need_new_row = false;
 
 	row.clear();
 	row.left_margin = leftMargin(max_width_, pit, pos);
@@ -771,12 +804,6 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 	// the width available for the row.
 	int const width = max_width_ - row.right_margin;
 
-	if (pos >= end || row.width() > width) {
-		row.endpos(end);
-		return;
-	}
-
-	ParagraphMetrics const & pm = par_metrics_[pit];
 	ParagraphList const & pars = text_->paragraphs();
 
 #if 0
@@ -797,12 +824,15 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 	// 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
@@ -818,8 +848,17 @@ void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit
 		} 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
 		// draw logically behind the previous character
@@ -847,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
@@ -871,8 +911,10 @@ 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 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(is_rtl);
@@ -918,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());
 		}
@@ -1114,9 +1156,14 @@ pos_type TextMetrics::getPosNearX(Row const & row, int & x,
 	 * row is larger than the end of its last element.
 	 */
 	if (!row.empty() && pos == row.back().endpos
-	    && row.back().endpos == row.endpos())
-		boundary = true;
-
+	    && 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;
@@ -1312,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;
 }
 
 
@@ -1361,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);
 
@@ -1372,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);
@@ -1409,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
@@ -1430,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 row.left_margin;
+	    || (pos == row.begin()->left_pos() && !boundary
+			&& !row.begin()->isVirtual()))
+		return row.begin();
 
 	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
+		 * 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->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);
+
 }
 
 
@@ -1915,8 +1993,8 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type const pit, int const
 			rp.paintLast();
 		if (i == 0 && is_rtl)
 			rp.paintFirst();
-		rp.paintTooLargeMarks(row_x < 0,
-				      row_x + row.width() > bv_->workWidth());
+		rp.paintTooLargeMarks(row_x + row.left_x() < 0,
+				      row_x + row.right_x() > bv_->workWidth());
 		y += row.descent();
 
 		// Restore full_repaint status.