X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffrontends%2Fqt4%2FGuiFontMetrics.cpp;h=33df3cf1267a68c5f7a3e51084e150d65b6abc9c;hb=1f10969bb5c5f36017bf5ba8671381b09945cf57;hp=804813a5629b6294ba132bc29df6893bfd3a3566;hpb=f65f3adbf73283a288f5d186b51b6b98c9ecb51d;p=lyx.git

diff --git a/src/frontends/qt4/GuiFontMetrics.cpp b/src/frontends/qt4/GuiFontMetrics.cpp
index 804813a562..33df3cf126 100644
--- a/src/frontends/qt4/GuiFontMetrics.cpp
+++ b/src/frontends/qt4/GuiFontMetrics.cpp
@@ -21,16 +21,53 @@
 
 #include "insets/Inset.h"
 
+#include "support/convert.h"
 #include "support/lassert.h"
 
-#include <QTextLayout>
+#define DISABLE_PMPROF
+#include "support/pmprof.h"
+
+#include <QByteArray>
 
 using namespace std;
 using namespace lyx::support;
 
+namespace std {
+
+/*
+ * Argument-dependent lookup implies that this function shall be
+ * declared in the namespace of its argument. But this is std
+ * namespace, since lyx::docstring is just std::basic_string<wchar_t>.
+ */
+uint qHash(lyx::docstring const & s)
+{
+	return qHash(QByteArray(reinterpret_cast<char const *>(s.data()),
+	                        s.size() * sizeof(lyx::docstring::value_type)));
+}
+
+}
+
 namespace lyx {
 namespace frontend {
 
+
+/*
+ * Limit (strwidth|breakat)_cache_ size to 512kB of string data.
+ * Limit qtextlayout_cache_ size to 500 elements (we do not know the
+ * size of the QTextLayout objects anyway).
+ * Note that all these numbers are arbitrary.
+ * Also, setting size to 0 is tantamount to disabling the cache.
+ */
+int cache_metrics_width_size = 1 << 19;
+int cache_metrics_breakat_size = 1 << 19;
+// Qt 5.x already has its own caching of QTextLayout objects
+#if (QT_VERSION < 0x050000)
+int cache_metrics_qtextlayout_size = 500;
+#else
+int cache_metrics_qtextlayout_size = 0;
+#endif
+
+
 namespace {
 /**
  * Convert a UCS4 character into a QChar.
@@ -53,7 +90,11 @@ inline QChar const ucs4_to_qchar(char_type const ucs4)
 } // anon namespace
 
 
-GuiFontMetrics::GuiFontMetrics(QFont const & font) : font_(font), metrics_(font, 0)
+GuiFontMetrics::GuiFontMetrics(QFont const & font)
+	: font_(font), metrics_(font, 0),
+	  strwidth_cache_(cache_metrics_width_size),
+	  breakat_cache_(cache_metrics_breakat_size),
+	  qtextlayout_cache_(cache_metrics_qtextlayout_size)
 {
 }
 
@@ -78,10 +119,28 @@ int GuiFontMetrics::em() const
 }
 
 
+int GuiFontMetrics::lineWidth() const
+{
+	return metrics_.lineWidth();
+}
+
+
+int GuiFontMetrics::underlinePos() const
+{
+	return metrics_.underlinePos();
+}
+
+
+int GuiFontMetrics::strikeoutPos() const
+{
+	return metrics_.strikeOutPos();
+}
+
+
 int GuiFontMetrics::lbearing(char_type c) const
 {
 	if (!is_utf16(c))
-		// FIXME: QFontMetrics::leftBearingdoes not support the
+		// FIXME: QFontMetrics::leftBearing does not support the
 		//        full unicode range. Once it does, we could use:
 		//return metrics_.leftBearing(toqstr(docstring(1, c)));
 		return 0;
@@ -120,14 +179,32 @@ int GuiFontMetrics::rbearing(char_type c) const
 
 int GuiFontMetrics::width(docstring const & s) const
 {
+	PROFILE_THIS_BLOCK(width);
+	if (strwidth_cache_.contains(s))
+		return strwidth_cache_[s];
+	PROFILE_CACHE_MISS(width);
+	/* For some reason QMetrics::width returns a wrong value with Qt5
+	 * with some arabic text. OTOH, QTextLayout is broken for single
+	 * characters with null width (like \not in mathed). Also, as a
+	 * safety measure, always use QMetrics::width with our math fonts.
+	*/
 	int w = 0;
-	map<docstring, int>::const_iterator it = strwidth_cache_.find(s);
-	if (it != strwidth_cache_.end()) {
-		w = it->second;
-	} else {
+	if (s.length() == 1
+#if QT_VERSION >= 0x040800
+	    || font_.styleName() == "LyX"
+#endif
+	    )
 		w = metrics_.width(toqstr(s));
-		strwidth_cache_[s] = w;
+	else {
+		QTextLayout tl;
+		tl.setText(toqstr(s));
+		tl.setFont(font_);
+		tl.beginLayout();
+		QTextLine line = tl.createLine();
+		tl.endLayout();
+		w = int(line.naturalTextWidth());
 	}
+	strwidth_cache_.insert(s, w, s.size() * sizeof(char_type));
 	return w;
 }
 
@@ -149,61 +226,195 @@ int GuiFontMetrics::signedWidth(docstring const & s) const
 		return width(s);
 }
 
-namespace {
-void setTextLayout(QTextLayout & tl, docstring const & s, QFont const & font,
-			     bool const rtl)
+
+shared_ptr<QTextLayout const>
+GuiFontMetrics::getTextLayout(docstring const & s, bool const rtl,
+                              double const wordspacing) const
 {
-	tl.setText(toqstr(s));
-	tl.setFont(font);
+	PROFILE_THIS_BLOCK(getTextLayout);
+	docstring const s_cache =
+		s + (rtl ? "r" : "l") + convert<docstring>(wordspacing);
+	if (auto ptl = qtextlayout_cache_[s_cache])
+		return ptl;
+	PROFILE_CACHE_MISS(getTextLayout);
+	auto const ptl = make_shared<QTextLayout>();
+	ptl->setCacheEnabled(true);
+	ptl->setText(toqstr(s));
+	QFont copy = font_;
+	copy.setWordSpacing(wordspacing);
+	ptl->setFont(copy);
 	// Note that both setFlags and the enums are undocumented
-	tl.setFlags(rtl ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight);
-	tl.beginLayout();
-	tl.createLine();
-	tl.endLayout();
-}
+	ptl->setFlags(rtl ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight);
+	ptl->beginLayout();
+	ptl->createLine();
+	ptl->endLayout();
+	qtextlayout_cache_.insert(s_cache, ptl);
+	return ptl;
 }
 
 
-int GuiFontMetrics::pos2x(docstring const & s, int const pos, bool const rtl) const
+int GuiFontMetrics::pos2x(docstring const & s, int pos, bool const rtl,
+                          double const wordspacing) const
 {
-	QTextLayout tl;
-	setTextLayout(tl, s, font_, rtl);
-	return static_cast<int>(tl.lineForTextPosition(pos).cursorToX(pos));
+	if (pos <= 0)
+		pos = 0;
+	shared_ptr<QTextLayout const> tl = getTextLayout(s, rtl, wordspacing);
+	/* Since QString is UTF-16 and docstring is UCS-4, the offsets may
+	 * not be the same when there are high-plan unicode characters
+	 * (bug #10443).
+	 */
+	int const qpos = toqstr(s.substr(0, pos)).length();
+	return static_cast<int>(tl->lineForTextPosition(qpos).cursorToX(qpos));
 }
 
 
-int GuiFontMetrics::x2pos(docstring const & s, int & x, bool const rtl) const
+int GuiFontMetrics::x2pos(docstring const & s, int & x, bool const rtl,
+                          double const wordspacing) const
 {
-	QTextLayout tl;
-	setTextLayout(tl, s, font_, rtl);
-	int pos = tl.lineForTextPosition(0).xToCursor(x);
+	shared_ptr<QTextLayout const> tl = getTextLayout(s, rtl, wordspacing);
+	int const qpos = tl->lineForTextPosition(0).xToCursor(x);
 	// correct x value to the actual cursor position.
-	x = static_cast<int>(tl.lineForTextPosition(0).cursorToX(pos));
+	x = static_cast<int>(tl->lineForTextPosition(0).cursorToX(qpos));
+	/* Since QString is UTF-16 and docstring is UCS-4, the offsets may
+	 * not be the same when there are high-plan unicode characters
+	 * (bug #10443).
+	 */
+#if QT_VERSION < 0x040801 || QT_VERSION >= 0x050100
+	return qstring_to_ucs4(tl->text().left(qpos)).length();
+#else
+	/* Due to QTBUG-25536 in 4.8.1 <= Qt < 5.1.0, the string returned
+	 * by QString::toUcs4 (used by qstring_to_ucs4) may have wrong
+	 * length. We work around the problem by trying all docstring
+	 * positions until the right one is found. This is slow only if
+	 * there are many high-plane Unicode characters. It might be
+	 * worthwhile to implement a dichotomy search if this shows up
+	 * under a profiler.
+	 */
+	int pos = min(qpos, static_cast<int>(s.length()));
+	while (pos >= 0 && toqstr(s.substr(0, pos)).length() != qpos)
+		--pos;
+	LASSERT(pos > 0 || qpos == 0, /**/);
 	return pos;
+#endif
 }
 
 
-bool GuiFontMetrics::breakAt(docstring & s, int & x, bool const rtl, bool const force) const
+int GuiFontMetrics::countExpanders(docstring const & str) const
+{
+	// Numbers of characters that are expanded by inter-word spacing.  These
+	// characters are spaces, except for characters 09-0D which are treated
+	// specially.  (From a combination of testing with the notepad found in qt's
+	// examples, and reading the source code.)  In addition, consecutive spaces
+	// only count as one expander.
+	bool wasspace = false;
+	int nexp = 0;
+	for (char_type c : str)
+		if (c > 0x0d && QChar(c).isSpace()) {
+			if (!wasspace) {
+				++nexp;
+				wasspace = true;
+			}
+		} else
+			wasspace = false;
+	return nexp;
+}
+
+
+pair<int, int>
+GuiFontMetrics::breakAt_helper(docstring const & s, int const x,
+                               bool const rtl, bool const force) const
 {
-	if (s.empty())
-		return false;
 	QTextLayout tl;
-	tl.setText(toqstr(s));
-	tl.setFont(font_);
+	/* Qt will not break at a leading or trailing space, and we need
+	 * that sometimes, see http://www.lyx.org/trac/ticket/9921.
+	 *
+	 * To work around the problem, we enclose the string between
+	 * zero-width characters so that the QTextLayout algorithm will
+	 * agree to break the text at these extremal spaces.
+	 */
+	// Unicode character ZERO WIDTH NO-BREAK SPACE
+	QChar const zerow_nbsp(0xfeff);
+	QString qs = zerow_nbsp + toqstr(s) + zerow_nbsp;
+#if 1
+	/* Use unicode override characters to enforce drawing direction
+	 * Source: http://www.iamcal.com/understanding-bidirectional-text/
+	 */
+	if (rtl)
+		// Right-to-left override: forces to draw text right-to-left
+		qs = QChar(0x202E) + qs;
+	else
+		// Left-to-right override: forces to draw text left-to-right
+		qs =  QChar(0x202D) + qs;
+	int const offset = 2;
+#else
+	// Alternative version that breaks with Qt5 and arabic text (#10436)
 	// Note that both setFlags and the enums are undocumented
 	tl.setFlags(rtl ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight);
+	int const offset = 1;
+#endif
+
+	tl.setText(qs);
+	tl.setFont(font_);
 	QTextOption to;
-	to.setWrapMode(force ? QTextOption::WrapAnywhere : QTextOption::WordWrap);
+	to.setWrapMode(force ? QTextOption::WrapAtWordBoundaryOrAnywhere
+	                     : QTextOption::WordWrap);
 	tl.setTextOption(to);
 	tl.beginLayout();
 	QTextLine line = tl.createLine();
 	line.setLineWidth(x);
 	tl.createLine();
 	tl.endLayout();
-	if (int(line.naturalTextWidth()) > x)
+	if ((force && line.textLength() == offset) || int(line.naturalTextWidth()) > x)
+		return {-1, -1};
+	/* Since QString is UTF-16 and docstring is UCS-4, the offsets may
+	 * not be the same when there are high-plan unicode characters
+	 * (bug #10443).
+	 */
+	// The variable `offset' is here to account for the extra leading characters.
+	// The ending character zerow_nbsp has to be ignored if the line is complete.
+	int const qlen = line.textLength() - offset - (line.textLength() == qs.length());
+#if QT_VERSION < 0x040801 || QT_VERSION >= 0x050100
+	int len = qstring_to_ucs4(qs.mid(offset, qlen)).length();
+#else
+	/* Due to QTBUG-25536 in 4.8.1 <= Qt < 5.1.0, the string returned
+	 * by QString::toUcs4 (used by qstring_to_ucs4) may have wrong
+	 * length. We work around the problem by trying all docstring
+	 * positions until the right one is found. This is slow only if
+	 * there are many high-plane Unicode characters. It might be
+	 * worthwhile to implement a dichotomy search if this shows up
+	 * under a profiler.
+	 */
+	int len = min(qlen, static_cast<int>(s.length()));
+	while (len >= 0 && toqstr(s.substr(0, len)).length() != qlen)
+		--len;
+	LASSERT(len > 0 || qlen == 0, /**/);
+#endif
+	// The -1 is here to account for the leading zerow_nbsp.
+	return {len, int(line.naturalTextWidth())};
+}
+
+
+bool GuiFontMetrics::breakAt(docstring & s, int & x, bool const rtl, bool const force) const
+{
+	PROFILE_THIS_BLOCK(breakAt);
+	if (s.empty())
 		return false;
-	x = int(line.naturalTextWidth());
-	s = s.substr(0, line.textLength());
+
+	docstring const s_cache =
+		s + convert<docstring>(x) + (rtl ? "r" : "l") + (force ? "f" : "w");
+	pair<int, int> pp;
+
+	if (breakat_cache_.contains(s_cache))
+		pp = breakat_cache_[s_cache];
+	else {
+		PROFILE_CACHE_MISS(breakAt);
+		pp = breakAt_helper(s, x, rtl, force);
+		breakat_cache_.insert(s_cache, pp, s_cache.size() * sizeof(char_type));
+	}
+	if (pp.first == -1)
+		return false;
+	s = s.substr(0, pp.first);
+	x = pp.second;
 	return true;
 }
 
@@ -219,7 +430,6 @@ void GuiFontMetrics::rectText(docstring const & str,
 }
 
 
-
 void GuiFontMetrics::buttonText(docstring const & str,
 	int & w, int & ascent, int & descent) const
 {