Restore smooth-scaled drawing of 0.5x-2.0x scaled glyphs in the GL engine

Commit b5922c89ba942 (Add support for retina glyph-based text drawing
in the GL engine), and commit 155a20628b91 (Use QPaintEngineEx to decide
if font is too big for using the glyph cache) together changed the
behavior of drawing scaled cached glyphs in the GL engine, producing
blocky text drawing when using the FreeType font engine.

Whereas before we would cache all glyphs without any transform, and
let the paint engine take care of the transform, commit b5922c added
support for a scaled GL glyph cache, resulting in a 2x cache, drawn
at 1x for example. The problem was that the FreeType engine claimed
to support producing glyphs at 2x, but did that using the QFontEngine
baseclass implementations, which use a simple fast-transform to scale
up the glyphs. The result was a 2x cache with horrible looking glyphs.

The first step in fixing this issue was to have the FreeType engine
claim to only support translations. This would then make the paint
engine choose path-based drawing for all scaled text, which is slow.

To restore the optimization that we would draw 0.5x-2.0x scaled text
using a smooth-scale in the GL engine (which was removed in 155a206),
we then needed to extend shouldDrawCachedGlyphs() and add a special
condition for this, coupled with a bit of logic in drawCachedGlyphs()
that ensures we don't propagate the painter scale to the glyph cache
if the engine is not able to produce scaled glyphs for it. This
means we get the old behavior of the GL engine doing a smooth scale
of the 1x glyph in the cache.

Finally, since the raster engine also checks if the font engine
supports the current transform, but for FreeType then ends up in
a separate code path when actually drawing the glyphs (as the
FreeType font engine supports internal glyph caching), we need
to add a corresponding check for hasInternalCaching() in the
shouldDrawCachedGlyphs() function, now that the FreeType engine
only reports that it supports translations.

Change-Id: Id03de896dec5f29535b281fb235332ef018045d8
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>

2 files changed, 10 insertions, 0 deletions

diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index 4545645dc6..7b4925a9c8 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -1437,6 +1437,14 @@ void QFontEngineFT::getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_me
     unlockFace();
 }
 
+bool QFontEngineFT::supportsTransformation(const QTransform &transform) const
+{
+    // The freetype engine falls back to QFontEngine for tranformed glyphs,
+    // which uses fast-tranform and produces very ugly results, so we claim
+    // to support just translations.
+    return transform.type() <= QTransform::TxTranslate;
+}
+
 static inline unsigned int getChar(const QChar *str, int &i, const int len)
 {
     uint ucs4 = str[i].unicode();
diff --git a/src/gui/text/qfontengine_ft_p.h b/src/gui/text/qfontengine_ft_p.h
index e09fa6f94f..bd4c855b91 100644
--- a/src/gui/text/qfontengine_ft_p.h
+++ b/src/gui/text/qfontengine_ft_p.h
@@ -233,6 +233,8 @@ private:
 
     virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
 
+    virtual bool supportsTransformation(const QTransform &transform) const;
+
     virtual bool canRender(const QChar *string, int len);
 
     virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs,