qrawfont.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qglobal.h"
 
#if !defined(QT_NO_RAWFONT)
 
#include "qrawfont.h"
#include "qrawfont_p.h"
#include "qplatformfontdatabase.h"
 
#include <private/qguiapplication_p.h>
#include <qpa/qplatformintegration.h>
#include <qpa/qplatformfontdatabase.h>
 
#include <QtCore/qendian.h>
#include <QtCore/qfile.h>
#include <QtGui/qpainterpath.h>
 
QT_BEGIN_NAMESPACE
 
QRawFont::QRawFont()
    : d(new QRawFontPrivate)
{
}
 
QRawFont::QRawFont(const QString &fileName,
                   qreal pixelSize,
                   QFont::HintingPreference hintingPreference)
    : d(new QRawFontPrivate)
{
    loadFromFile(fileName, pixelSize, hintingPreference);
}
 
QRawFont::QRawFont(const QByteArray &fontData,
                   qreal pixelSize,
                   QFont::HintingPreference hintingPreference)
    : d(new QRawFontPrivate)
{
    loadFromData(fontData, pixelSize, hintingPreference);
}
 
QRawFont::QRawFont(const QRawFont &other)
{
    d = other.d;
}
 
QRawFont::~QRawFont()
{
}
 
QRawFont &QRawFont::operator=(const QRawFont &other)
{
    d = other.d;
    return *this;
}
 
bool QRawFont::isValid() const
{
    return d->isValid();
}
 
void QRawFont::loadFromFile(const QString &fileName,
                            qreal pixelSize,
                            QFont::HintingPreference hintingPreference)
{
    QFile file(fileName);
    if (file.open(QIODevice::ReadOnly))
        loadFromData(file.readAll(), pixelSize, hintingPreference);
}
 
void QRawFont::loadFromData(const QByteArray &fontData,
                            qreal pixelSize,
                            QFont::HintingPreference hintingPreference)
{
    d.detach();
    d->cleanUp();
    d->hintingPreference = hintingPreference;
    d->loadFromData(fontData, pixelSize, hintingPreference);
}
 
QImage QRawFont::alphaMapForGlyph(quint32 glyphIndex, AntialiasingType antialiasingType,
                                  const QTransform &transform) const
{
    if (!d->isValid())
        return QImage();
 
    if (d->fontEngine->glyphFormat == QFontEngine::Format_ARGB)
        return d->fontEngine->bitmapForGlyph(glyphIndex, QFixedPoint(), transform);
 
    if (antialiasingType == SubPixelAntialiasing)
        return d->fontEngine->alphaRGBMapForGlyph(glyphIndex, QFixedPoint(), transform);
 
    return d->fontEngine->alphaMapForGlyph(glyphIndex, QFixedPoint(), transform);
}
 
QPainterPath QRawFont::pathForGlyph(quint32 glyphIndex) const
{
    if (!d->isValid())
        return QPainterPath();
 
    QFixedPoint position;
    QPainterPath path;
    d->fontEngine->addGlyphsToPath(&glyphIndex, &position, 1, &path, { });
    return path;
}
 
bool QRawFont::operator==(const QRawFont &other) const
{
    return d->fontEngine == other.d->fontEngine;
}
 
size_t qHash(const QRawFont &font, size_t seed) noexcept
{
    return qHash(QRawFontPrivate::get(font)->fontEngine, seed);
}
 
 
qreal QRawFont::ascent() const
{
    return d->isValid() ? d->fontEngine->ascent().toReal() : 0.0;
}
 
qreal QRawFont::capHeight() const
{
    return d->isValid() ? d->fontEngine->capHeight().toReal() : 0.0;
}
 
qreal QRawFont::descent() const
{
    return d->isValid() ? d->fontEngine->descent().toReal() : 0.0;
}
 
qreal QRawFont::xHeight() const
{
    return d->isValid() ? d->fontEngine->xHeight().toReal() : 0.0;
}
 
qreal QRawFont::leading() const
{
    return d->isValid() ? d->fontEngine->leading().toReal() : 0.0;
}
 
qreal QRawFont::averageCharWidth() const
{
    return d->isValid() ? d->fontEngine->averageCharWidth().toReal() : 0.0;
}
 
qreal QRawFont::maxCharWidth() const
{
    return d->isValid() ? d->fontEngine->maxCharWidth() : 0.0;
}
 
qreal QRawFont::pixelSize() const
{
    return d->isValid() ? d->fontEngine->fontDef.pixelSize : 0.0;
}
 
qreal QRawFont::unitsPerEm() const
{
    return d->isValid() ? d->fontEngine->emSquareSize().toReal() : 0.0;
}
 
qreal QRawFont::lineThickness() const
{
    return d->isValid() ? d->fontEngine->lineThickness().toReal() : 0.0;
}
 
qreal QRawFont::underlinePosition() const
{
    return d->isValid() ? d->fontEngine->underlinePosition().toReal() : 0.0;
}
 
QString QRawFont::familyName() const
{
    return d->isValid() ? d->fontEngine->fontDef.families.first() : QString();
}
 
QString QRawFont::styleName() const
{
    return d->isValid() ? d->fontEngine->fontDef.styleName : QString();
}
 
QFont::Style QRawFont::style() const
{
    return d->isValid() ? QFont::Style(d->fontEngine->fontDef.style) : QFont::StyleNormal;
}
 
int QRawFont::weight() const
{
    return d->isValid() ? int(d->fontEngine->fontDef.weight) : -1;
}
 
QList<quint32> QRawFont::glyphIndexesForString(const QString &text) const
{
    QList<quint32> glyphIndexes;
    if (!d->isValid() || text.isEmpty())
        return glyphIndexes;
 
    int numGlyphs = text.size();
    glyphIndexes.resize(numGlyphs);
 
    QGlyphLayout glyphs;
    glyphs.numGlyphs = numGlyphs;
    glyphs.glyphs = glyphIndexes.data();
    if (!d->fontEngine->stringToCMap(text.data(), text.size(), &glyphs, &numGlyphs, QFontEngine::GlyphIndicesOnly))
        Q_UNREACHABLE();
 
    glyphIndexes.resize(numGlyphs);
    return glyphIndexes;
}
 
bool QRawFont::glyphIndexesForChars(const QChar *chars, int numChars, quint32 *glyphIndexes, int *numGlyphs) const
{
    Q_ASSERT(numGlyphs);
    if (!d->isValid() || numChars <= 0) {
        *numGlyphs = 0;
        return false;
    }
 
    if (*numGlyphs <= 0 || !glyphIndexes) {
        *numGlyphs = numChars;
        return false;
    }
 
    QGlyphLayout glyphs;
    glyphs.numGlyphs = *numGlyphs;
    glyphs.glyphs = glyphIndexes;
    return d->fontEngine->stringToCMap(chars, numChars, &glyphs, numGlyphs, QFontEngine::GlyphIndicesOnly);
}
 
bool QRawFont::advancesForGlyphIndexes(const quint32 *glyphIndexes, QPointF *advances, int numGlyphs, LayoutFlags layoutFlags) const
{
    if (!d->isValid() || numGlyphs <= 0)
        return false;
    Q_ASSERT(glyphIndexes && advances);
 
    QVarLengthArray<QFixed> tmpAdvances(numGlyphs);
 
    QGlyphLayout glyphs;
    glyphs.glyphs = const_cast<glyph_t *>(glyphIndexes);
    glyphs.numGlyphs = numGlyphs;
    glyphs.advances = tmpAdvances.data();
 
    bool design = layoutFlags & UseDesignMetrics;
 
    d->fontEngine->recalcAdvances(&glyphs, design ? QFontEngine::DesignMetrics : QFontEngine::ShaperFlag(0));
    if (layoutFlags & KernedAdvances)
        d->fontEngine->doKerning(&glyphs, design ? QFontEngine::DesignMetrics : QFontEngine::ShaperFlag(0));
 
    for (int i=0; i<numGlyphs; ++i)
        advances[i] = QPointF(tmpAdvances[i].toReal(), 0.0);
 
    return true;
}
 
bool QRawFont::advancesForGlyphIndexes(const quint32 *glyphIndexes, QPointF *advances, int numGlyphs) const
{
    return QRawFont::advancesForGlyphIndexes(glyphIndexes, advances, numGlyphs, SeparateAdvances);
}
 
QFont::HintingPreference QRawFont::hintingPreference() const
{
    return d->isValid() ? d->hintingPreference : QFont::PreferDefaultHinting;
}
 
QByteArray QRawFont::fontTable(const char *tagName) const
{
    if (!d->isValid())
        return QByteArray();
 
    return d->fontEngine->getSfntTable(MAKE_TAG(tagName[0], tagName[1], tagName[2], tagName[3]));
}
 
QList<QFontDatabase::WritingSystem> QRawFont::supportedWritingSystems() const
{
    QList<QFontDatabase::WritingSystem> writingSystems;
    if (d->isValid()) {
        QByteArray os2Table = fontTable("OS/2");
        if (os2Table.size() > 86) {
            const uchar * const data = reinterpret_cast<const uchar *>(os2Table.constData());
            const uchar * const bigEndianUnicodeRanges  = data + 42;
            const uchar * const bigEndianCodepageRanges = data + 78;
 
            quint32 unicodeRanges[4];
            quint32 codepageRanges[2];
 
            for (size_t i = 0; i < sizeof unicodeRanges / sizeof *unicodeRanges; ++i)
                unicodeRanges[i] = qFromBigEndian<quint32>(bigEndianUnicodeRanges + i * sizeof(quint32));
 
            for (size_t i = 0; i < sizeof codepageRanges / sizeof *codepageRanges; ++i)
                codepageRanges[i] = qFromBigEndian<quint32>(bigEndianCodepageRanges + i * sizeof(quint32));
 
            QSupportedWritingSystems ws = QPlatformFontDatabase::writingSystemsFromTrueTypeBits(unicodeRanges, codepageRanges);
            for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
                if (ws.supported(QFontDatabase::WritingSystem(i)))
                    writingSystems.append(QFontDatabase::WritingSystem(i));
            }
        }
    }
 
    return writingSystems;
}
 
bool QRawFont::supportsCharacter(QChar character) const
{
    return supportsCharacter(character.unicode());
}
 
bool QRawFont::supportsCharacter(uint ucs4) const
{
    return d->isValid() && d->fontEngine->canRender(ucs4);
}
 
// qfontdatabase.cpp
extern int qt_script_for_writing_system(QFontDatabase::WritingSystem writingSystem);
 
QRawFont QRawFont::fromFont(const QFont &font, QFontDatabase::WritingSystem writingSystem)
{
    QRawFont rawFont;
    const QFontPrivate *font_d = QFontPrivate::get(font);
    int script = qt_script_for_writing_system(writingSystem);
    QFontEngine *fe = font_d->engineForScript(script);
 
    if (fe != nullptr && fe->type() == QFontEngine::Multi) {
        QFontEngineMulti *multiEngine = static_cast<QFontEngineMulti *>(fe);
        fe = multiEngine->engine(0);
 
        if (script > QChar::Script_Latin) {
            // keep in sync with QFontEngineMulti::loadEngine()
            QFontDef request(multiEngine->fontDef);
            request.styleStrategy |= QFont::NoFontMerging;
 
            if (QFontEngine *engine = QFontDatabasePrivate::findFont(request, script, true)) {
                if (request.weight > QFont::Normal)
                    engine->fontDef.weight = request.weight;
                if (request.style > QFont::StyleNormal)
                    engine->fontDef.style = request.style;
                fe = engine;
            }
        }
        Q_ASSERT(fe);
    }
 
    if (fe != nullptr) {
        rawFont.d.data()->setFontEngine(fe);
        rawFont.d.data()->hintingPreference = font.hintingPreference();
    }
    return rawFont;
}
 
void QRawFont::setPixelSize(qreal pixelSize)
{
    if (!d->isValid() || qFuzzyCompare(d->fontEngine->fontDef.pixelSize, pixelSize))
        return;
 
    d.detach();
    d->setFontEngine(d->fontEngine->cloneWithSize(pixelSize));
}
 
void QRawFontPrivate::loadFromData(const QByteArray &fontData, qreal pixelSize,
                                           QFont::HintingPreference hintingPreference)
{
    Q_ASSERT(fontEngine == nullptr);
 
    QPlatformFontDatabase *pfdb = QGuiApplicationPrivate::platformIntegration()->fontDatabase();
    setFontEngine(pfdb->fontEngine(fontData, pixelSize, hintingPreference));
}
 
QRectF QRawFont::boundingRect(quint32 glyphIndex) const
{
    if (!d->isValid())
        return QRectF();
 
    glyph_metrics_t gm = d->fontEngine->boundingBox(glyphIndex);
    return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());
}
 
#endif // QT_NO_RAWFONT
 
QT_END_NAMESPACE