summaryrefslogtreecommitdiffstats
path: root/src/gui/text/qabstractfontengine_qws.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/gui/text/qabstractfontengine_qws.cpp')
-rw-r--r--src/gui/text/qabstractfontengine_qws.cpp776
1 files changed, 776 insertions, 0 deletions
diff --git a/src/gui/text/qabstractfontengine_qws.cpp b/src/gui/text/qabstractfontengine_qws.cpp
new file mode 100644
index 0000000000..7cb868f655
--- /dev/null
+++ b/src/gui/text/qabstractfontengine_qws.cpp
@@ -0,0 +1,776 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qabstractfontengine_qws.h"
+#include "qabstractfontengine_p.h"
+
+#include <private/qtextengine_p.h>
+#include <private/qpaintengine_raster_p.h>
+
+#include <qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+class QFontEngineInfoPrivate
+{
+public:
+ inline QFontEngineInfoPrivate()
+ : pixelSize(0), weight(QFont::Normal), style(QFont::StyleNormal)
+ {}
+
+ QString family;
+ qreal pixelSize;
+ int weight;
+ QFont::Style style;
+ QList<QFontDatabase::WritingSystem> writingSystems;
+};
+
+/*!
+ \class QFontEngineInfo
+ \preliminary
+ \brief The QFontEngineInfo class describes a specific font provided by a font engine plugin.
+ \since 4.3
+ \ingroup qws
+
+ \tableofcontents
+
+ QFontEngineInfo is used to describe a request of a font to a font engine plugin as well as to
+ describe the actual fonts a plugin provides.
+
+ \sa QAbstractFontEngine, QFontEnginePlugin
+*/
+
+/*!
+ Constructs a new empty QFontEngineInfo.
+*/
+QFontEngineInfo::QFontEngineInfo()
+{
+ d = new QFontEngineInfoPrivate;
+}
+
+/*!
+ Constructs a new QFontEngineInfo with the specified \a family.
+ The resulting object represents a freely scalable font with normal
+ weight and style.
+*/
+QFontEngineInfo::QFontEngineInfo(const QString &family)
+{
+ d = new QFontEngineInfoPrivate;
+ d->family = family;
+}
+
+/*!
+ Creates a new font engine info object with the same attributes as \a other.
+*/
+QFontEngineInfo::QFontEngineInfo(const QFontEngineInfo &other)
+ : d(new QFontEngineInfoPrivate(*other.d))
+{
+}
+
+/*!
+ Assigns \a other to this font engine info object, and returns a reference
+ to this.
+*/
+QFontEngineInfo &QFontEngineInfo::operator=(const QFontEngineInfo &other)
+{
+ *d = *other.d;
+ return *this;
+}
+
+/*!
+ Destroys this QFontEngineInfo object.
+*/
+QFontEngineInfo::~QFontEngineInfo()
+{
+ delete d;
+}
+
+/*!
+ \property QFontEngineInfo::family
+ the family name of the font
+*/
+
+void QFontEngineInfo::setFamily(const QString &family)
+{
+ d->family = family;
+}
+
+QString QFontEngineInfo::family() const
+{
+ return d->family;
+}
+
+/*!
+ \property QFontEngineInfo::pixelSize
+ the pixel size of the font
+
+ A pixel size of 0 represents a freely scalable font.
+*/
+
+void QFontEngineInfo::setPixelSize(qreal size)
+{
+ d->pixelSize = size;
+}
+
+qreal QFontEngineInfo::pixelSize() const
+{
+ return d->pixelSize;
+}
+
+/*!
+ \property QFontEngineInfo::weight
+ the weight of the font
+
+ The value should be from the \l{QFont::Weight} enumeration.
+*/
+
+void QFontEngineInfo::setWeight(int weight)
+{
+ d->weight = weight;
+}
+
+int QFontEngineInfo::weight() const
+{
+ return d->weight;
+}
+
+/*!
+ \property QFontEngineInfo::style
+ the style of the font
+*/
+
+void QFontEngineInfo::setStyle(QFont::Style style)
+{
+ d->style = style;
+}
+
+QFont::Style QFontEngineInfo::style() const
+{
+ return d->style;
+}
+
+/*!
+ \property QFontEngineInfo::writingSystems
+ the writing systems supported by the font
+
+ An empty list means that any writing system is supported.
+*/
+
+QList<QFontDatabase::WritingSystem> QFontEngineInfo::writingSystems() const
+{
+ return d->writingSystems;
+}
+
+void QFontEngineInfo::setWritingSystems(const QList<QFontDatabase::WritingSystem> &writingSystems)
+{
+ d->writingSystems = writingSystems;
+}
+
+class QFontEnginePluginPrivate : public QObjectPrivate
+{
+ Q_DECLARE_PUBLIC(QFontEnginePlugin)
+
+ QString foundry;
+};
+
+/*!
+ \class QFontEnginePlugin
+ \preliminary
+ \brief The QFontEnginePlugin class is the base class for font engine factory plugins in Qt for Embedded Linux.
+ \since 4.3
+ \ingroup qws
+ \ingroup plugins
+
+ \tableofcontents
+
+ QFontEnginePlugin is provided by font engine plugins to create
+ instances of subclasses of QAbstractFontEngine.
+
+ The member functions create() and availableFontEngines() must be
+ implemented.
+
+ \sa QAbstractFontEngine, QFontEngineInfo
+*/
+
+/*!
+ Creates a font engine plugin that creates font engines with the
+ specified \a foundry and \a parent.
+*/
+QFontEnginePlugin::QFontEnginePlugin(const QString &foundry, QObject *parent)
+ : QObject(*new QFontEnginePluginPrivate, parent)
+{
+ Q_D(QFontEnginePlugin);
+ d->foundry = foundry;
+}
+
+/*!
+ Destroys this font engine plugin.
+*/
+QFontEnginePlugin::~QFontEnginePlugin()
+{
+}
+
+/*!
+ Returns a list of foundries the font engine plugin provides.
+ The default implementation returns the foundry specified with the constructor.
+*/
+QStringList QFontEnginePlugin::keys() const
+{
+ Q_D(const QFontEnginePlugin);
+ return QStringList(d->foundry);
+}
+
+/*!
+ \fn QAbstractFontEngine *QFontEnginePlugin::create(const QFontEngineInfo &info)
+
+ Implemented in subclasses to create a new font engine that provides a font that
+ matches \a info.
+*/
+
+/*!
+ \fn QList<QFontEngineInfo> QFontEnginePlugin::availableFontEngines() const
+
+ Implemented in subclasses to return a list of QFontEngineInfo objects that represents all font
+ engines the plugin can create.
+*/
+
+class QAbstractFontEnginePrivate : public QObjectPrivate
+{
+ Q_DECLARE_PUBLIC(QAbstractFontEngine)
+public:
+};
+
+//The <classname> class is|provides|contains|specifies...
+/*!
+ \class QAbstractFontEngine
+ \preliminary
+ \brief The QAbstractFontEngine class is the base class for font engine plugins in Qt for Embedded Linux.
+ \since 4.3
+ \ingroup qws
+
+ \tableofcontents
+
+ QAbstractFontEngine is implemented by font engine plugins through QFontEnginePlugin.
+
+ \sa QFontEnginePlugin, QFontEngineInfo
+*/
+
+/*!
+ \enum QAbstractFontEngine::Capability
+
+ This enum describes the capabilities of a font engine.
+
+ \value CanRenderGlyphs_Gray The font engine can render individual glyphs into 8 bpp images.
+ \value CanRenderGlyphs_Mono The font engine can render individual glyphs into 1 bpp images.
+ \value CanRenderGlyphs The font engine can render individual glyphs into images.
+ \value CanOutlineGlyphs The font engine can convert glyphs to painter paths.
+*/
+
+/*!
+ \enum QAbstractFontEngine::FontProperty
+
+ This enum describes the properties of a font provided by a font engine.
+
+ \value Ascent The ascent of the font, specified as a 26.6 fixed point value.
+ \value Descent The descent of the font, specified as a 26.6 fixed point value.
+ \value Leading The leading of the font, specified as a 26.6 fixed point value.
+ \value XHeight The 'x' height of the font, specified as a 26.6 fixed point value.
+ \value AverageCharWidth The average character width of the font, specified as a 26.6 fixed point value.
+ \value LineThickness The thickness of the underline and strikeout lines for the font, specified as a 26.6 fixed point value.
+ \value UnderlinePosition The distance from the base line to the underline position for the font, specified as a 26.6 fixed point value.
+ \value MaxCharWidth The width of the widest character in the font, specified as a 26.6 fixed point value.
+ \value MinLeftBearing The minimum left bearing of the font, specified as a 26.6 fixed point value.
+ \value MinRightBearing The maximum right bearing of the font, specified as a 26.6 fixed point value.
+ \value GlyphCount The number of glyphs in the font, specified as an integer value.
+ \value CacheGlyphsHint A boolean value specifying whether rendered glyphs should be cached by Qt.
+ \value OutlineGlyphsHint A boolean value specifying whether the font engine prefers outline drawing over image rendering for uncached glyphs.
+*/
+
+/*!
+ \enum QAbstractFontEngine::TextShapingFlag
+
+ This enum describes flags controlling conversion of characters to glyphs and their metrics.
+
+ \value RightToLeft The text is used in a right-to-left context.
+ \value ReturnDesignMetrics Return font design metrics instead of pixel metrics.
+*/
+
+/*!
+ \typedef QAbstractFontEngine::Fixed
+
+ This type is \c int, interpreted as a 26.6 fixed point value.
+*/
+
+/*!
+ \class QAbstractFontEngine::GlyphMetrics
+ \brief QAbstractFontEngine::GlyphMetrics defines the metrics of a single glyph.
+ \preliminary
+ \since 4.3
+*/
+
+/*!
+ \variable QAbstractFontEngine::GlyphMetrics::x
+
+ The horizontal offset from the origin.
+*/
+
+/*!
+ \fn QAbstractFontEngine::GlyphMetrics::GlyphMetrics()
+
+ Constructs an empty glyph metrics object with all values
+ set to zero.
+*/
+
+/*!
+ \variable QAbstractFontEngine::GlyphMetrics::y
+
+ The vertical offset from the origin (baseline).
+*/
+
+/*!
+ \variable QAbstractFontEngine::GlyphMetrics::width
+
+ The width of the glyph.
+*/
+
+/*!
+ \variable QAbstractFontEngine::GlyphMetrics::height
+
+ The height of the glyph.
+*/
+
+/*!
+ \variable QAbstractFontEngine::GlyphMetrics::advance
+
+ The advance of the glyph.
+*/
+
+/*!
+ \class QAbstractFontEngine::FixedPoint
+ \brief QAbstractFontEngine::FixedPoint defines a point in the place using 26.6 fixed point precision.
+ \preliminary
+ \since 4.3
+*/
+
+/*!
+ \variable QAbstractFontEngine::FixedPoint::x
+
+ The x coordinate of this point.
+*/
+
+/*!
+ \variable QAbstractFontEngine::FixedPoint::y
+
+ The y coordinate of this point.
+*/
+
+/*!
+ Constructs a new QAbstractFontEngine with the given \a parent.
+*/
+QAbstractFontEngine::QAbstractFontEngine(QObject *parent)
+ : QObject(*new QAbstractFontEnginePrivate, parent)
+{
+}
+
+/*!
+ Destroys this QAbstractFontEngine object.
+*/
+QAbstractFontEngine::~QAbstractFontEngine()
+{
+}
+
+/*!
+ \fn QAbstractFontEngine::Capabilities QAbstractFontEngine::capabilities() const
+
+ Implemented in subclasses to specify the font engine's capabilities. The return value
+ may be cached by the caller and is expected not to change during the lifetime of the
+ font engine.
+*/
+
+/*!
+ \fn QVariant QAbstractFontEngine::fontProperty(FontProperty property) const
+
+ Implemented in subclasses to return the value of the font attribute \a property. The return
+ value may be cached by the caller and is expected not to change during the lifetime of the font
+ engine.
+*/
+
+/*!
+ \fn bool QAbstractFontEngine::convertStringToGlyphIndices(const QChar *string, int length, uint *glyphs, int *numGlyphs, TextShapingFlags flags) const
+
+ Implemented in subclasses to convert the characters specified by \a string and \a length to
+ glyph indicies, using \a flags. The glyph indicies should be returned in the \a glyphs array
+ provided by the caller. The maximum size of \a glyphs is specified by the value pointed to by \a
+ numGlyphs. If successful, the subclass implementation sets the value pointed to by \a numGlyphs
+ to the actual number of glyph indices generated, and returns true. Otherwise, e.g. if there is
+ not enough space in the provided \a glyphs array, it should set \a numGlyphs to the number of
+ glyphs needed for the conversion and return false.
+*/
+
+/*!
+ \fn void QAbstractFontEngine::getGlyphAdvances(const uint *glyphs, int numGlyphs, Fixed *advances, TextShapingFlags flags) const
+
+ Implemented in subclasses to retrieve the advances of the array specified by \a glyphs and \a
+ numGlyphs, using \a flags. The result is returned in \a advances, which is allocated by the
+ caller and contains \a numGlyphs elements.
+*/
+
+/*!
+ \fn QAbstractFontEngine::GlyphMetrics QAbstractFontEngine::glyphMetrics(uint glyph) const
+
+ Implemented in subclass to return the metrics for \a glyph.
+*/
+
+/*!
+ Implemented in subclasses to render the specified \a glyph into a \a buffer with the given \a depth ,
+ \a bytesPerLine and \a height.
+
+ Returns true if rendering succeeded, false otherwise.
+*/
+bool QAbstractFontEngine::renderGlyph(uint glyph, int depth, int bytesPerLine, int height, uchar *buffer)
+{
+ Q_UNUSED(glyph)
+ Q_UNUSED(depth)
+ Q_UNUSED(bytesPerLine)
+ Q_UNUSED(height)
+ Q_UNUSED(buffer)
+ qWarning("QAbstractFontEngine: renderGlyph is not implemented in font plugin!");
+ return false;
+}
+
+/*!
+ Implemented in subclasses to add the outline of the glyphs specified by \a glyphs and \a
+ numGlyphs at the specified \a positions to the painter path \a path.
+*/
+void QAbstractFontEngine::addGlyphOutlinesToPath(uint *glyphs, int numGlyphs, FixedPoint *positions, QPainterPath *path)
+{
+ Q_UNUSED(glyphs)
+ Q_UNUSED(numGlyphs)
+ Q_UNUSED(positions)
+ Q_UNUSED(path)
+ qWarning("QAbstractFontEngine: addGlyphOutlinesToPath is not implemented in font plugin!");
+}
+
+/*
+bool QAbstractFontEngine::supportsExtension(Extension extension) const
+{
+ Q_UNUSED(extension)
+ return false;
+}
+
+QVariant QAbstractFontEngine::extension(Extension extension, const QVariant &argument)
+{
+ Q_UNUSED(argument)
+ Q_UNUSED(extension)
+ return QVariant();
+}
+*/
+
+QProxyFontEngine::QProxyFontEngine(QAbstractFontEngine *customEngine, const QFontDef &def)
+ : engine(customEngine)
+{
+ fontDef = def;
+ engineCapabilities = engine->capabilities();
+}
+
+QProxyFontEngine::~QProxyFontEngine()
+{
+ delete engine;
+}
+
+bool QProxyFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const
+{
+ if (*nglyphs < len) {
+ *nglyphs = len;
+ return false;
+ }
+
+ QVarLengthArray<uint> glyphIndicies(*nglyphs);
+ if (!engine->convertStringToGlyphIndices(str, len, glyphIndicies.data(), nglyphs, QAbstractFontEngine::TextShapingFlags(int(flags))))
+ return false;
+
+ // ### use memcopy instead
+ for (int i = 0; i < *nglyphs; ++i) {
+ glyphs->glyphs[i] = glyphIndicies[i];
+ }
+ glyphs->numGlyphs = *nglyphs;
+
+ recalcAdvances(glyphs, flags);
+ return true;
+}
+
+void QProxyFontEngine::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const
+{
+ const int nglyphs = glyphs->numGlyphs;
+
+ QVarLengthArray<QAbstractFontEngine::Fixed> advances(nglyphs);
+ engine->getGlyphAdvances(glyphs->glyphs, nglyphs, advances.data(), QAbstractFontEngine::TextShapingFlags(int(flags)));
+
+
+ // ### use memcopy instead
+ for (int i = 0; i < nglyphs; ++i) {
+ glyphs->advances_x[i] = QFixed::fromFixed(advances[i]);
+ glyphs->advances_y[i] = 0;
+ }
+}
+
+
+static QImage alphaMapFromPath(QFontEngine *fe, glyph_t glyph)
+{
+ glyph_metrics_t gm = fe->boundingBox(glyph);
+ int glyph_x = qFloor(gm.x.toReal());
+ int glyph_y = qFloor(gm.y.toReal());
+ int glyph_width = qCeil((gm.x + gm.width).toReal()) - glyph_x;
+ int glyph_height = qCeil((gm.y + gm.height).toReal()) - glyph_y;
+
+ if (glyph_width <= 0 || glyph_height <= 0)
+ return QImage();
+ QFixedPoint pt;
+ pt.x = 0;
+ pt.y = -glyph_y; // the baseline
+ QPainterPath path;
+ QImage im(glyph_width + qAbs(glyph_x) + 4, glyph_height, QImage::Format_ARGB32_Premultiplied);
+ im.fill(Qt::transparent);
+ QPainter p(&im);
+ p.setRenderHint(QPainter::Antialiasing);
+ fe->addGlyphsToPath(&glyph, &pt, 1, &path, 0);
+ p.setPen(Qt::NoPen);
+ p.setBrush(Qt::black);
+ p.drawPath(path);
+ p.end();
+
+ QImage indexed(im.width(), im.height(), QImage::Format_Indexed8);
+ QVector<QRgb> colors(256);
+ for (int i=0; i<256; ++i)
+ colors[i] = qRgba(0, 0, 0, i);
+ indexed.setColorTable(colors);
+
+ for (int y=0; y<im.height(); ++y) {
+ uchar *dst = (uchar *) indexed.scanLine(y);
+ uint *src = (uint *) im.scanLine(y);
+ for (int x=0; x<im.width(); ++x)
+ dst[x] = qAlpha(src[x]);
+ }
+
+ return indexed;
+}
+
+
+QImage QProxyFontEngine::alphaMapForGlyph(glyph_t glyph)
+{
+ if (!(engineCapabilities & QAbstractFontEngine::CanRenderGlyphs_Gray))
+ return alphaMapFromPath(this, glyph);
+
+ QAbstractFontEngine::GlyphMetrics metrics = engine->glyphMetrics(glyph);
+ if (metrics.width <= 0 || metrics.height <= 0)
+ return QImage();
+
+ QImage img(metrics.width >> 6, metrics.height >> 6, QImage::Format_Indexed8);
+
+ // ### we should have QImage::Format_GrayScale8
+ static QVector<QRgb> colorMap;
+ if (colorMap.isEmpty()) {
+ colorMap.resize(256);
+ for (int i=0; i<256; ++i)
+ colorMap[i] = qRgba(0, 0, 0, i);
+ }
+
+ img.setColorTable(colorMap);
+
+ engine->renderGlyph(glyph, /*depth*/8, img.bytesPerLine(), img.height(), img.bits());
+
+ return img;
+}
+
+void QProxyFontEngine::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs, QPainterPath *path, QTextItem::RenderFlags flags)
+{
+ if (engineCapabilities & QAbstractFontEngine::CanOutlineGlyphs)
+ engine->addGlyphOutlinesToPath(glyphs, nglyphs, reinterpret_cast<QAbstractFontEngine::FixedPoint *>(positions), path);
+ else
+ QFontEngine::addGlyphsToPath(glyphs, positions, nglyphs, path, flags);
+}
+
+glyph_metrics_t QProxyFontEngine::boundingBox(const QGlyphLayout &glyphs)
+{
+ if (glyphs.numGlyphs == 0)
+ return glyph_metrics_t();
+
+ QFixed w = 0;
+ for (int i = 0; i < glyphs.numGlyphs; ++i)
+ w += glyphs.effectiveAdvance(i);
+
+ return glyph_metrics_t(0, -ascent(), w, ascent() + descent(), w, 0);
+}
+
+glyph_metrics_t QProxyFontEngine::boundingBox(glyph_t glyph)
+{
+ glyph_metrics_t m;
+
+ QAbstractFontEngine::GlyphMetrics metrics = engine->glyphMetrics(glyph);
+ m.x = QFixed::fromFixed(metrics.x);
+ m.y = QFixed::fromFixed(metrics.y);
+ m.width = QFixed::fromFixed(metrics.width);
+ m.height = QFixed::fromFixed(metrics.height);
+ m.xoff = QFixed::fromFixed(metrics.advance);
+
+ return m;
+}
+
+QFixed QProxyFontEngine::ascent() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::Ascent).toInt());
+}
+
+QFixed QProxyFontEngine::descent() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::Descent).toInt());
+}
+
+QFixed QProxyFontEngine::leading() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::Leading).toInt());
+}
+
+QFixed QProxyFontEngine::xHeight() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::XHeight).toInt());
+}
+
+QFixed QProxyFontEngine::averageCharWidth() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::AverageCharWidth).toInt());
+}
+
+QFixed QProxyFontEngine::lineThickness() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::LineThickness).toInt());
+}
+
+QFixed QProxyFontEngine::underlinePosition() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::UnderlinePosition).toInt());
+}
+
+qreal QProxyFontEngine::maxCharWidth() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::MaxCharWidth).toInt()).toReal();
+}
+
+qreal QProxyFontEngine::minLeftBearing() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::MinLeftBearing).toInt()).toReal();
+}
+
+qreal QProxyFontEngine::minRightBearing() const
+{
+ return QFixed::fromFixed(engine->fontProperty(QAbstractFontEngine::MinRightBearing).toInt()).toReal();
+}
+
+int QProxyFontEngine::glyphCount() const
+{
+ return engine->fontProperty(QAbstractFontEngine::GlyphCount).toInt();
+}
+
+bool QProxyFontEngine::canRender(const QChar *string, int len)
+{
+ QVarLengthArray<uint> glyphs(len);
+ int numGlyphs = len;
+
+ if (!engine->convertStringToGlyphIndices(string, len, glyphs.data(), &numGlyphs, /*flags*/0))
+ return false;
+
+ for (int i = 0; i < numGlyphs; ++i)
+ if (!glyphs[i])
+ return false;
+
+ return true;
+}
+
+void QProxyFontEngine::draw(QPaintEngine *p, qreal _x, qreal _y, const QTextItemInt &si)
+{
+ QPaintEngineState *pState = p->state;
+ QRasterPaintEngine *paintEngine = static_cast<QRasterPaintEngine*>(p);
+
+ QTransform matrix = pState->transform();
+ matrix.translate(_x, _y);
+ QFixed x = QFixed::fromReal(matrix.dx());
+ QFixed y = QFixed::fromReal(matrix.dy());
+
+ QVarLengthArray<QFixedPoint> positions;
+ QVarLengthArray<glyph_t> glyphs;
+ getGlyphPositions(si.glyphs, matrix, si.flags, glyphs, positions);
+ if (glyphs.size() == 0)
+ return;
+
+ for(int i = 0; i < glyphs.size(); i++) {
+ QImage glyph = alphaMapForGlyph(glyphs[i]);
+ if (glyph.isNull())
+ continue;
+
+ if (glyph.format() != QImage::Format_Indexed8
+ && glyph.format() != QImage::Format_Mono)
+ continue;
+
+ QAbstractFontEngine::GlyphMetrics metrics = engine->glyphMetrics(glyphs[i]);
+
+ int depth = glyph.format() == QImage::Format_Mono ? 1 : 8;
+ paintEngine->alphaPenBlt(glyph.bits(), glyph.bytesPerLine(), depth,
+ qRound(positions[i].x + QFixed::fromFixed(metrics.x)),
+ qRound(positions[i].y + QFixed::fromFixed(metrics.y)),
+ glyph.width(), glyph.height());
+ }
+}
+
+/*
+ * This is only called when we use the proxy fontengine directly (without sharing the rendered
+ * glyphs). So we prefer outline rendering over rendering of unshared glyphs. That decision is
+ * done in qfontdatabase_qws.cpp by looking at the ShareGlyphsHint and the pixel size of the font.
+ */
+bool QProxyFontEngine::drawAsOutline() const
+{
+ if (!(engineCapabilities & QAbstractFontEngine::CanOutlineGlyphs))
+ return false;
+
+ QVariant outlineHint = engine->fontProperty(QAbstractFontEngine::OutlineGlyphsHint);
+ return !outlineHint.isValid() || outlineHint.toBool();
+}
+
+QT_END_NAMESPACE