qfont.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#include "qfont.h"
#include "qdebug.h"
#include "qpaintdevice.h"
#include "qfontdatabase.h"
#include "qfontmetrics.h"
#include "qfontinfo.h"
#include "qpainter.h"
#include "qhash.h"
#include "qdatastream.h"
#include "qguiapplication.h"
#include "qstringlist.h"
#include "qscreen.h"
 
#include "qthread.h"
#include "qthreadstorage.h"
 
#include "qfont_p.h"
#include <private/qfontengine_p.h>
#include <private/qpainter_p.h>
#include <private/qtextengine_p.h>
#include <limits.h>
 
#include <qpa/qplatformscreen.h>
#include <qpa/qplatformintegration.h>
#include <qpa/qplatformfontdatabase.h>
#include <QtGui/private/qguiapplication_p.h>
 
#include <QtCore/QMutexLocker>
#include <QtCore/QMutex>
 
// #define QFONTCACHE_DEBUG
#ifdef QFONTCACHE_DEBUG
#  define FC_DEBUG qDebug
#else
#  define FC_DEBUG if (false) qDebug
#endif
 
QT_BEGIN_NAMESPACE
 
#ifndef QFONTCACHE_DECREASE_TRIGGER_LIMIT
#  define QFONTCACHE_DECREASE_TRIGGER_LIMIT 256
#endif
 
bool QFontDef::exactMatch(const QFontDef &other) const
{
    /*
      QFontDef comparison is more complicated than just simple
      per-member comparisons.
 
      When comparing point/pixel sizes, either point or pixelsize
      could be -1.  in This case we have to compare the non negative
      size value.
 
      This test will fail if the point-sizes differ by 1/2 point or
      more or they do not round to the same value.  We have to do this
      since our API still uses 'int' point-sizes in the API, but store
      deci-point-sizes internally.
 
      To compare the family members, we need to parse the font names
      and compare the family/foundry strings separately.  This allows
      us to compare e.g. "Helvetica" and "Helvetica [Adobe]" with
      positive results.
    */
    if (pixelSize != -1 && other.pixelSize != -1) {
        if (pixelSize != other.pixelSize)
            return false;
    } else if (pointSize != -1 && other.pointSize != -1) {
        if (pointSize != other.pointSize)
            return false;
    } else {
        return false;
    }
 
    if (!ignorePitch && !other.ignorePitch && fixedPitch != other.fixedPitch)
        return false;
 
    if (stretch != 0 && other.stretch != 0 && stretch != other.stretch)
        return false;
 
    QString this_family, this_foundry, other_family, other_foundry;
    for (int i = 0; i < families.size(); ++i) {
        QFontDatabasePrivate::parseFontName(families.at(i), this_foundry, this_family);
        QFontDatabasePrivate::parseFontName(other.families.at(i), other_foundry, other_family);
        if (this_family != other_family || this_foundry != other_foundry)
            return false;
    }
 
    return (styleHint     == other.styleHint
            && styleStrategy == other.styleStrategy
            && weight        == other.weight
            && style        == other.style
            && this_family   == other_family
            && (styleName.isEmpty() || other.styleName.isEmpty() || styleName == other.styleName)
            && (this_foundry.isEmpty()
                || other_foundry.isEmpty()
                || this_foundry == other_foundry)
       );
}
 
extern bool qt_is_tty_app;
 
Q_GUI_EXPORT int qt_defaultDpiX()
{
    if (QCoreApplication::instance()->testAttribute(Qt::AA_Use96Dpi))
        return 96;
 
    if (qt_is_tty_app)
        return 75;
 
    if (const QScreen *screen = QGuiApplication::primaryScreen())
        return qRound(screen->logicalDotsPerInchX());
 
    //PI has not been initialised, or it is being initialised. Give a default dpi
    return 100;
}
 
Q_GUI_EXPORT int qt_defaultDpiY()
{
    if (QCoreApplication::instance()->testAttribute(Qt::AA_Use96Dpi))
        return 96;
 
    if (qt_is_tty_app)
        return 75;
 
    if (const QScreen *screen = QGuiApplication::primaryScreen())
        return qRound(screen->logicalDotsPerInchY());
 
    //PI has not been initialised, or it is being initialised. Give a default dpi
    return 100;
}
 
Q_GUI_EXPORT int qt_defaultDpi()
{
    return qt_defaultDpiY();
}
 
/* Helper function to convert between legacy Qt and OpenType font weights. */
static int convertWeights(int weight, bool inverted)
{
    static const QVarLengthArray<QPair<int, int>, 9> legacyToOpenTypeMap = {
        { 0, QFont::Thin },    { 12, QFont::ExtraLight }, { 25, QFont::Light },
        { 50, QFont::Normal }, { 57, QFont::Medium },     { 63, QFont::DemiBold },
        { 75, QFont::Bold },   { 81, QFont::ExtraBold },  { 87, QFont::Black },
    };
 
    int closestDist = INT_MAX;
    int result = -1;
 
    // Go through and find the closest mapped value
    for (auto mapping : legacyToOpenTypeMap) {
        const int weightOld = inverted ? mapping.second : mapping.first;
        const int weightNew = inverted ? mapping.first : mapping.second;
        const int dist = qAbs(weightOld - weight);
        if (dist < closestDist) {
            result = weightNew;
            closestDist = dist;
        } else {
            // Break early since following values will be further away
            break;
        }
    }
 
    return result;
}
 
// Splits the family string on a comma and returns the list based on that
static QStringList splitIntoFamilies(const QString &family)
{
    QStringList familyList;
    if (family.isEmpty())
        return familyList;
    const auto list = QStringView{family}.split(QLatin1Char(','));
    const int numFamilies = list.size();
    familyList.reserve(numFamilies);
    for (int i = 0; i < numFamilies; ++i) {
        auto str = list.at(i).trimmed();
        if ((str.startsWith(QLatin1Char('"')) && str.endsWith(QLatin1Char('"')))
            || (str.startsWith(QLatin1Char('\'')) && str.endsWith(QLatin1Char('\'')))) {
            str = str.mid(1, str.length() - 2);
        }
        familyList << str.toString();
    }
    return familyList;
}
 
/* Converts from legacy Qt font weight (Qt < 6.0) to OpenType font weight (Qt >= 6.0) */
Q_GUI_EXPORT int qt_legacyToOpenTypeWeight(int weight)
{
    return convertWeights(weight, false);
}
 
/* Converts from  OpenType font weight (Qt >= 6.0) to legacy Qt font weight (Qt < 6.0) */
Q_GUI_EXPORT int qt_openTypeToLegacyWeight(int weight)
{
    return convertWeights(weight, true);
}
 
QFontPrivate::QFontPrivate()
    : engineData(nullptr), dpi(qt_defaultDpi()),
      underline(false), overline(false), strikeOut(false), kerning(true),
      capital(0), letterSpacingIsAbsolute(false), scFont(nullptr)
{
}
 
QFontPrivate::QFontPrivate(const QFontPrivate &other)
    : request(other.request), engineData(nullptr), dpi(other.dpi),
      underline(other.underline), overline(other.overline),
      strikeOut(other.strikeOut), kerning(other.kerning),
      capital(other.capital), letterSpacingIsAbsolute(other.letterSpacingIsAbsolute),
      letterSpacing(other.letterSpacing), wordSpacing(other.wordSpacing),
      scFont(other.scFont)
{
    if (scFont && scFont != this)
        scFont->ref.ref();
}
 
QFontPrivate::~QFontPrivate()
{
    if (engineData && !engineData->ref.deref())
        delete engineData;
    engineData = nullptr;
    if (scFont && scFont != this) {
        if (!scFont->ref.deref())
            delete scFont;
    }
    scFont = nullptr;
}
 
extern QRecursiveMutex *qt_fontdatabase_mutex();
 
#define QT_FONT_ENGINE_FROM_DATA(data, script) data->engines[script]
 
QFontEngine *QFontPrivate::engineForScript(int script) const
{
    QMutexLocker locker(qt_fontdatabase_mutex());
    if (script <= QChar::Script_Latin)
        script = QChar::Script_Common;
    if (engineData && engineData->fontCacheId != QFontCache::instance()->id()) {
        // throw out engineData that came from a different thread
        if (!engineData->ref.deref())
            delete engineData;
        engineData = nullptr;
    }
    if (!engineData || !QT_FONT_ENGINE_FROM_DATA(engineData, script))
        QFontDatabasePrivate::load(this, script);
    return QT_FONT_ENGINE_FROM_DATA(engineData, script);
}
 
void QFontPrivate::alterCharForCapitalization(QChar &c) const {
    switch (capital) {
    case QFont::AllUppercase:
    case QFont::SmallCaps:
        c = c.toUpper();
        break;
    case QFont::AllLowercase:
        c = c.toLower();
        break;
    case QFont::MixedCase:
        break;
    }
}
 
QFontPrivate *QFontPrivate::smallCapsFontPrivate() const
{
    if (scFont)
        return scFont;
    QFont font(const_cast<QFontPrivate *>(this));
    qreal pointSize = font.pointSizeF();
    if (pointSize > 0)
        font.setPointSizeF(pointSize * .7);
    else
        font.setPixelSize((font.pixelSize() * 7 + 5) / 10);
    scFont = font.d.data();
    if (scFont != this)
        scFont->ref.ref();
    return scFont;
}
 
 
void QFontPrivate::resolve(uint mask, const QFontPrivate *other)
{
    Q_ASSERT(other != nullptr);
 
    dpi = other->dpi;
 
    if ((mask & QFont::AllPropertiesResolved) == QFont::AllPropertiesResolved) return;
 
    // assign the unset-bits with the set-bits of the other font def
    if (!(mask & QFont::FamiliesResolved))
        request.families = other->request.families;
 
    if (! (mask & QFont::StyleNameResolved))
        request.styleName = other->request.styleName;
 
    if (! (mask & QFont::SizeResolved)) {
        request.pointSize = other->request.pointSize;
        request.pixelSize = other->request.pixelSize;
    }
 
    if (! (mask & QFont::StyleHintResolved))
        request.styleHint = other->request.styleHint;
 
    if (! (mask & QFont::StyleStrategyResolved))
        request.styleStrategy = other->request.styleStrategy;
 
    if (! (mask & QFont::WeightResolved))
        request.weight = other->request.weight;
 
    if (! (mask & QFont::StyleResolved))
        request.style = other->request.style;
 
    if (! (mask & QFont::FixedPitchResolved))
        request.fixedPitch = other->request.fixedPitch;
 
    if (! (mask & QFont::StretchResolved))
        request.stretch = other->request.stretch;
 
    if (! (mask & QFont::HintingPreferenceResolved))
        request.hintingPreference = other->request.hintingPreference;
 
    if (! (mask & QFont::UnderlineResolved))
        underline = other->underline;
 
    if (! (mask & QFont::OverlineResolved))
        overline = other->overline;
 
    if (! (mask & QFont::StrikeOutResolved))
        strikeOut = other->strikeOut;
 
    if (! (mask & QFont::KerningResolved))
        kerning = other->kerning;
 
    if (! (mask & QFont::LetterSpacingResolved)) {
        letterSpacing = other->letterSpacing;
        letterSpacingIsAbsolute = other->letterSpacingIsAbsolute;
    }
    if (! (mask & QFont::WordSpacingResolved))
        wordSpacing = other->wordSpacing;
    if (! (mask & QFont::CapitalizationResolved))
        capital = other->capital;
}
 
 
 
 
QFontEngineData::QFontEngineData()
    : ref(0), fontCacheId(QFontCache::instance()->id())
{
    memset(engines, 0, QChar::ScriptCount * sizeof(QFontEngine *));
}
 
QFontEngineData::~QFontEngineData()
{
    Q_ASSERT(ref.loadRelaxed() == 0);
    for (int i = 0; i < QChar::ScriptCount; ++i) {
        if (engines[i]) {
            if (!engines[i]->ref.deref())
                delete engines[i];
            engines[i] = nullptr;
        }
    }
}
 
 
 
 
QFont::QFont(const QFont &font, const QPaintDevice *pd)
    : resolve_mask(font.resolve_mask)
{
    Q_ASSERT(pd);
    const int dpi = pd->logicalDpiY();
    if (font.d->dpi != dpi) {
        d = new QFontPrivate(*font.d);
        d->dpi = dpi;
    } else {
        d = font.d;
    }
}
 
QFont::QFont(QFontPrivate *data)
    : d(data), resolve_mask(QFont::AllPropertiesResolved)
{
}
 
void QFont::detach()
{
    if (d->ref.loadRelaxed() == 1) {
        if (d->engineData && !d->engineData->ref.deref())
            delete d->engineData;
        d->engineData = nullptr;
        if (d->scFont && d->scFont != d.data()) {
            if (!d->scFont->ref.deref())
                delete d->scFont;
        }
        d->scFont = nullptr;
        return;
    }
 
    d.detach();
}
 
void QFontPrivate::detachButKeepEngineData(QFont *font)
{
    if (font->d->ref.loadRelaxed() == 1)
        return;
 
    QFontEngineData *engineData = font->d->engineData;
    if (engineData)
        engineData->ref.ref();
    font->d.detach();
    font->d->engineData = engineData;
}
 
QFont::QFont()
    : d(QGuiApplicationPrivate::instance() ? QGuiApplication::font().d.data() : new QFontPrivate()), resolve_mask(0)
{
}
 
QFont::QFont(const QString &family, int pointSize, int weight, bool italic)
    : d(new QFontPrivate()), resolve_mask(QFont::FamiliesResolved)
{
    if (pointSize <= 0) {
        pointSize = 12;
    } else {
        resolve_mask |= QFont::SizeResolved;
    }
 
    if (weight < 0) {
        weight = Normal;
    } else {
        resolve_mask |= QFont::WeightResolved | QFont::StyleResolved;
    }
 
    if (italic)
        resolve_mask |= QFont::StyleResolved;
 
    d->request.families = splitIntoFamilies(family);
    d->request.pointSize = qreal(pointSize);
    d->request.pixelSize = -1;
    d->request.weight = weight;
    d->request.style = italic ? QFont::StyleItalic : QFont::StyleNormal;
}
 
QFont::QFont(const QStringList &families, int pointSize, int weight, bool italic)
    : d(new QFontPrivate()), resolve_mask(QFont::FamiliesResolved)
{
    if (pointSize <= 0)
        pointSize = 12;
    else
        resolve_mask |= QFont::SizeResolved;
 
    if (weight < 0)
        weight = Normal;
    else
        resolve_mask |= QFont::WeightResolved | QFont::StyleResolved;
 
    if (italic)
        resolve_mask |= QFont::StyleResolved;
 
    d->request.families = families;
    d->request.pointSize = qreal(pointSize);
    d->request.pixelSize = -1;
    d->request.weight = weight;
    d->request.style = italic ? QFont::StyleItalic : QFont::StyleNormal;
}
 
QFont::QFont(const QFont &font)
    : d(font.d), resolve_mask(font.resolve_mask)
{
}
 
QFont::~QFont()
{
}
 
QFont &QFont::operator=(const QFont &font)
{
    d = font.d;
    resolve_mask = font.resolve_mask;
    return *this;
}
 
QString QFont::family() const
{
    return d->request.families.isEmpty() ? QString() : d->request.families.first();
}
 
void QFont::setFamily(const QString &family)
{
#ifdef QT_DEBUG
    if (family.contains(QLatin1Char(','))) {
        qWarning("From Qt 6.2, QFont::setFamily() will no long split the family string on the comma"
                 " and will keep it as a single family");
    }
#endif
    setFamilies(splitIntoFamilies(family));
}
 
QString QFont::styleName() const
{
    return d->request.styleName;
}
 
void QFont::setStyleName(const QString &styleName)
{
    if ((resolve_mask & QFont::StyleNameResolved) && d->request.styleName == styleName)
        return;
 
    detach();
 
    d->request.styleName = styleName;
    resolve_mask |= QFont::StyleNameResolved;
}
 
int QFont::pointSize() const
{
    return qRound(d->request.pointSize);
}
 
void QFont::setHintingPreference(HintingPreference hintingPreference)
{
    if ((resolve_mask & QFont::HintingPreferenceResolved) && d->request.hintingPreference == hintingPreference)
        return;
 
    detach();
 
    d->request.hintingPreference = hintingPreference;
 
    resolve_mask |= QFont::HintingPreferenceResolved;
}
 
QFont::HintingPreference QFont::hintingPreference() const
{
    return QFont::HintingPreference(d->request.hintingPreference);
}
 
void QFont::setPointSize(int pointSize)
{
    if (pointSize <= 0) {
        qWarning("QFont::setPointSize: Point size <= 0 (%d), must be greater than 0", pointSize);
        return;
    }
 
    if ((resolve_mask & QFont::SizeResolved) && d->request.pointSize == qreal(pointSize))
        return;
 
    detach();
 
    d->request.pointSize = qreal(pointSize);
    d->request.pixelSize = -1;
 
    resolve_mask |= QFont::SizeResolved;
}
 
void QFont::setPointSizeF(qreal pointSize)
{
    if (pointSize <= 0) {
        qWarning("QFont::setPointSizeF: Point size <= 0 (%f), must be greater than 0", pointSize);
        return;
    }
 
    if ((resolve_mask & QFont::SizeResolved) && d->request.pointSize == pointSize)
        return;
 
    detach();
 
    d->request.pointSize = pointSize;
    d->request.pixelSize = -1;
 
    resolve_mask |= QFont::SizeResolved;
}
 
qreal QFont::pointSizeF() const
{
    return d->request.pointSize;
}
 
void QFont::setPixelSize(int pixelSize)
{
    if (pixelSize <= 0) {
        qWarning("QFont::setPixelSize: Pixel size <= 0 (%d)", pixelSize);
        return;
    }
 
    if ((resolve_mask & QFont::SizeResolved) && d->request.pixelSize == qreal(pixelSize))
        return;
 
    detach();
 
    d->request.pixelSize = pixelSize;
    d->request.pointSize = -1;
 
    resolve_mask |= QFont::SizeResolved;
}
 
int QFont::pixelSize() const
{
    return d->request.pixelSize;
}
 
QFont::Style QFont::style() const
{
    return (QFont::Style)d->request.style;
}
 
 
void QFont::setStyle(Style style)
{
    if ((resolve_mask & QFont::StyleResolved) && d->request.style == style)
        return;
 
    detach();
 
    d->request.style = style;
    resolve_mask |= QFont::StyleResolved;
}
 
QFont::Weight QFont::weight() const
{
    return static_cast<Weight>(d->request.weight);
}
 
#if QT_DEPRECATED_SINCE(6, 0)
void QFont::setLegacyWeight(int legacyWeight)
{
    setWeight(QFont::Weight(qt_legacyToOpenTypeWeight(legacyWeight)));
}
 
int QFont::legacyWeight() const
{
    return qt_openTypeToLegacyWeight(weight());
}
#endif // QT_DEPRECATED_SINCE(6, 0)
 
void QFont::setWeight(QFont::Weight weight)
{
    const int weightValue = qBound(QFONT_WEIGHT_MIN, static_cast<int>(weight), QFONT_WEIGHT_MAX);
    if (weightValue != static_cast<int>(weight)) {
        qWarning() << "QFont::setWeight: Weight must be between 1 and 1000, attempted to set "
                   << static_cast<int>(weight);
    }
 
    if ((resolve_mask & QFont::WeightResolved) && d->request.weight == weightValue)
        return;
 
    detach();
 
    d->request.weight = weightValue;
    resolve_mask |= QFont::WeightResolved;
}
 
bool QFont::underline() const
{
    return d->underline;
}
 
void QFont::setUnderline(bool enable)
{
    if ((resolve_mask & QFont::UnderlineResolved) && d->underline == enable)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->underline = enable;
    resolve_mask |= QFont::UnderlineResolved;
}
 
bool QFont::overline() const
{
    return d->overline;
}
 
void QFont::setOverline(bool enable)
{
    if ((resolve_mask & QFont::OverlineResolved) && d->overline == enable)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->overline = enable;
    resolve_mask |= QFont::OverlineResolved;
}
 
bool QFont::strikeOut() const
{
    return d->strikeOut;
}
 
void QFont::setStrikeOut(bool enable)
{
    if ((resolve_mask & QFont::StrikeOutResolved) && d->strikeOut == enable)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->strikeOut = enable;
    resolve_mask |= QFont::StrikeOutResolved;
}
 
bool QFont::fixedPitch() const
{
    return d->request.fixedPitch;
}
 
void QFont::setFixedPitch(bool enable)
{
    if ((resolve_mask & QFont::FixedPitchResolved) && d->request.fixedPitch == enable)
        return;
 
    detach();
 
    d->request.fixedPitch = enable;
    d->request.ignorePitch = false;
    resolve_mask |= QFont::FixedPitchResolved;
}
 
bool QFont::kerning() const
{
    return d->kerning;
}
 
void QFont::setKerning(bool enable)
{
    if ((resolve_mask & QFont::KerningResolved) && d->kerning == enable)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->kerning = enable;
    resolve_mask |= QFont::KerningResolved;
}
 
QFont::StyleStrategy QFont::styleStrategy() const
{
    return (StyleStrategy) d->request.styleStrategy;
}
 
QFont::StyleHint QFont::styleHint() const
{
    return (StyleHint) d->request.styleHint;
}
 
void QFont::setStyleHint(StyleHint hint, StyleStrategy strategy)
{
    if ((resolve_mask & (QFont::StyleHintResolved | QFont::StyleStrategyResolved)) &&
         (StyleHint) d->request.styleHint == hint &&
         (StyleStrategy) d->request.styleStrategy == strategy)
        return;
 
    detach();
 
    d->request.styleHint = hint;
    d->request.styleStrategy = strategy;
    resolve_mask |= QFont::StyleHintResolved;
    resolve_mask |= QFont::StyleStrategyResolved;
 
}
 
void QFont::setStyleStrategy(StyleStrategy s)
{
    if ((resolve_mask & QFont::StyleStrategyResolved) &&
         s == (StyleStrategy)d->request.styleStrategy)
        return;
 
    detach();
 
    d->request.styleStrategy = s;
    resolve_mask |= QFont::StyleStrategyResolved;
}
 
 
int QFont::stretch() const
{
    return d->request.stretch;
}
 
void QFont::setStretch(int factor)
{
    if (factor < 0 || factor > 4000) {
        qWarning("QFont::setStretch: Parameter '%d' out of range", factor);
        return;
    }
 
    if ((resolve_mask & QFont::StretchResolved) &&
         d->request.stretch == (uint)factor)
        return;
 
    detach();
 
    d->request.stretch = (uint)factor;
    resolve_mask |= QFont::StretchResolved;
}
 
qreal QFont::letterSpacing() const
{
    return d->letterSpacing.toReal();
}
 
void QFont::setLetterSpacing(SpacingType type, qreal spacing)
{
    const QFixed newSpacing = QFixed::fromReal(spacing);
    const bool absoluteSpacing = type == AbsoluteSpacing;
    if ((resolve_mask & QFont::LetterSpacingResolved) &&
        d->letterSpacingIsAbsolute == absoluteSpacing &&
        d->letterSpacing == newSpacing)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->letterSpacing = newSpacing;
    d->letterSpacingIsAbsolute = absoluteSpacing;
    resolve_mask |= QFont::LetterSpacingResolved;
}
 
QFont::SpacingType QFont::letterSpacingType() const
{
    return d->letterSpacingIsAbsolute ? AbsoluteSpacing : PercentageSpacing;
}
 
qreal QFont::wordSpacing() const
{
    return d->wordSpacing.toReal();
}
 
void QFont::setWordSpacing(qreal spacing)
{
    const QFixed newSpacing = QFixed::fromReal(spacing);
    if ((resolve_mask & QFont::WordSpacingResolved) &&
        d->wordSpacing == newSpacing)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->wordSpacing = newSpacing;
    resolve_mask |= QFont::WordSpacingResolved;
}
 
void QFont::setCapitalization(Capitalization caps)
{
    if ((resolve_mask & QFont::CapitalizationResolved) &&
        capitalization() == caps)
        return;
 
    QFontPrivate::detachButKeepEngineData(this);
 
    d->capital = caps;
    resolve_mask |= QFont::CapitalizationResolved;
}
 
QFont::Capitalization QFont::capitalization() const
{
    return static_cast<QFont::Capitalization> (d->capital);
}
 
bool QFont::exactMatch() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return d->request.exactMatch(engine->fontDef);
}
 
bool QFont::operator==(const QFont &f) const
{
    return (f.d == d
            || (f.d->request   == d->request
                && f.d->request.pointSize == d->request.pointSize
                && f.d->underline == d->underline
                && f.d->overline  == d->overline
                && f.d->strikeOut == d->strikeOut
                && f.d->kerning == d->kerning
                && f.d->capital == d->capital
                && f.d->letterSpacingIsAbsolute == d->letterSpacingIsAbsolute
                && f.d->letterSpacing == d->letterSpacing
                && f.d->wordSpacing == d->wordSpacing
            ));
}
 
 
bool QFont::operator<(const QFont &f) const
{
    if (f.d == d) return false;
    // the < operator for fontdefs ignores point sizes.
    const QFontDef &r1 = f.d->request;
    const QFontDef &r2 = d->request;
    if (r1.pointSize != r2.pointSize) return r1.pointSize < r2.pointSize;
    if (r1.pixelSize != r2.pixelSize) return r1.pixelSize < r2.pixelSize;
    if (r1.weight != r2.weight) return r1.weight < r2.weight;
    if (r1.style != r2.style) return r1.style < r2.style;
    if (r1.stretch != r2.stretch) return r1.stretch < r2.stretch;
    if (r1.styleHint != r2.styleHint) return r1.styleHint < r2.styleHint;
    if (r1.styleStrategy != r2.styleStrategy) return r1.styleStrategy < r2.styleStrategy;
    if (r1.families != r2.families) return r1.families < r2.families;
    if (f.d->capital != d->capital) return f.d->capital < d->capital;
 
    if (f.d->letterSpacingIsAbsolute != d->letterSpacingIsAbsolute) return f.d->letterSpacingIsAbsolute < d->letterSpacingIsAbsolute;
    if (f.d->letterSpacing != d->letterSpacing) return f.d->letterSpacing < d->letterSpacing;
    if (f.d->wordSpacing != d->wordSpacing) return f.d->wordSpacing < d->wordSpacing;
 
    int f1attrs = (f.d->underline << 3) + (f.d->overline << 2) + (f.d->strikeOut<<1) + f.d->kerning;
    int f2attrs = (d->underline << 3) + (d->overline << 2) + (d->strikeOut<<1) + d->kerning;
    return f1attrs < f2attrs;
}
 
 
bool QFont::operator!=(const QFont &f) const
{
    return !(operator==(f));
}
 
QFont::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
bool QFont::isCopyOf(const QFont & f) const
{
    return d == f.d;
}
 
QFont QFont::resolve(const QFont &other) const
{
    if (resolve_mask == 0 || (resolve_mask == other.resolve_mask && *this == other)) {
        QFont o(other);
        o.resolve_mask = resolve_mask;
        return o;
    }
 
    QFont font(*this);
    font.detach();
    font.d->resolve(resolve_mask, other.d.data());
 
    return font;
}
 
/*****************************************************************************
  QFont substitution management
 *****************************************************************************/
 
typedef QHash<QString, QStringList> QFontSubst;
Q_GLOBAL_STATIC(QFontSubst, globalFontSubst)
 
 
QString QFont::substitute(const QString &familyName)
{
    QFontSubst *fontSubst = globalFontSubst();
    Q_ASSERT(fontSubst != nullptr);
    QFontSubst::ConstIterator it = fontSubst->constFind(familyName.toLower());
    if (it != fontSubst->constEnd() && !(*it).isEmpty())
        return (*it).first();
 
    return familyName;
}
 
 
QStringList QFont::substitutes(const QString &familyName)
{
    QFontSubst *fontSubst = globalFontSubst();
    Q_ASSERT(fontSubst != nullptr);
    return fontSubst->value(familyName.toLower(), QStringList());
}
 
 
void QFont::insertSubstitution(const QString &familyName,
                               const QString &substituteName)
{
    QFontSubst *fontSubst = globalFontSubst();
    Q_ASSERT(fontSubst != nullptr);
    QStringList &list = (*fontSubst)[familyName.toLower()];
    QString s = substituteName.toLower();
    if (!list.contains(s))
        list.append(s);
}
 
 
void QFont::insertSubstitutions(const QString &familyName,
                                const QStringList &substituteNames)
{
    QFontSubst *fontSubst = globalFontSubst();
    Q_ASSERT(fontSubst != nullptr);
    QStringList &list = (*fontSubst)[familyName.toLower()];
    for (const QString &substituteName : substituteNames) {
        const QString lowerSubstituteName = substituteName.toLower();
        if (!list.contains(lowerSubstituteName))
            list.append(lowerSubstituteName);
    }
}
 
void QFont::removeSubstitutions(const QString &familyName)
{
    QFontSubst *fontSubst = globalFontSubst();
    Q_ASSERT(fontSubst != nullptr);
    fontSubst->remove(familyName.toLower());
}
 
QStringList QFont::substitutions()
{
    QFontSubst *fontSubst = globalFontSubst();
    Q_ASSERT(fontSubst != nullptr);
    QStringList ret = fontSubst->keys();
 
    ret.sort();
    return ret;
}
 
#ifndef QT_NO_DATASTREAM
/*  \internal
    Internal function. Converts boolean font settings to an unsigned
    8-bit number. Used for serialization etc.
*/
static quint8 get_font_bits(int version, const QFontPrivate *f)
{
    Q_ASSERT(f != nullptr);
    quint8 bits = 0;
    if (f->request.style)
        bits |= 0x01;
    if (f->underline)
        bits |= 0x02;
    if (f->overline)
        bits |= 0x40;
    if (f->strikeOut)
        bits |= 0x04;
    if (f->request.fixedPitch)
        bits |= 0x08;
    // if (f.hintSetByUser)
    // bits |= 0x10;
    if (version >= QDataStream::Qt_4_0) {
        if (f->kerning)
            bits |= 0x10;
    }
    if (f->request.style == QFont::StyleOblique)
        bits |= 0x80;
    return bits;
}
 
static quint8 get_extended_font_bits(const QFontPrivate *f)
{
    Q_ASSERT(f != nullptr);
    quint8 bits = 0;
    if (f->request.ignorePitch)
        bits |= 0x01;
    if (f->letterSpacingIsAbsolute)
        bits |= 0x02;
    return bits;
}
 
/*  \internal
    Internal function. Sets boolean font settings from an unsigned
    8-bit number. Used for serialization etc.
*/
static void set_font_bits(int version, quint8 bits, QFontPrivate *f)
{
    Q_ASSERT(f != nullptr);
    f->request.style         = (bits & 0x01) != 0 ? QFont::StyleItalic : QFont::StyleNormal;
    f->underline             = (bits & 0x02) != 0;
    f->overline              = (bits & 0x40) != 0;
    f->strikeOut             = (bits & 0x04) != 0;
    f->request.fixedPitch    = (bits & 0x08) != 0;
    // f->hintSetByUser      = (bits & 0x10) != 0;
    if (version >= QDataStream::Qt_4_0)
        f->kerning               = (bits & 0x10) != 0;
    if ((bits & 0x80) != 0)
        f->request.style         = QFont::StyleOblique;
}
 
static void set_extended_font_bits(quint8 bits, QFontPrivate *f)
{
    Q_ASSERT(f != nullptr);
    f->request.ignorePitch = (bits & 0x01) != 0;
    f->letterSpacingIsAbsolute = (bits & 0x02) != 0;
}
#endif
 
QString QFont::key() const
{
    return toString();
}
 
QString QFont::toString() const
{
    const QChar comma(QLatin1Char(','));
    QString fontDescription = family() + comma +
        QString::number(     pointSizeF()) + comma +
        QString::number(      pixelSize()) + comma +
        QString::number((int) styleHint()) + comma +
        QString::number(         weight()) + comma +
        QString::number((int)     style()) + comma +
        QString::number((int) underline()) + comma +
        QString::number((int) strikeOut()) + comma +
        QString::number((int)fixedPitch()) + comma +
        QString::number((int)   false) + comma +
        QString::number((int)capitalization()) + comma +
        QString::number((int)letterSpacingType()) + comma +
        QString::number(letterSpacing()) + comma +
        QString::number(wordSpacing()) + comma +
        QString::number(stretch()) + comma +
        QString::number((int)styleStrategy());
 
    QString fontStyle = styleName();
    if (!fontStyle.isEmpty())
        fontDescription += comma + fontStyle;
 
    return fontDescription;
}
 
size_t qHash(const QFont &font, size_t seed) noexcept
{
    return qHash(QFontPrivate::get(font)->request, seed);
}
 
 
bool QFont::fromString(const QString &descrip)
{
    const auto sr = QStringView(descrip).trimmed();
    const auto l = sr.split(QLatin1Char(','));
    const int count = l.count();
    if (!count || (count > 2 && count < 9) || count == 9 || count > 17 ||
        l.first().isEmpty()) {
        qWarning("QFont::fromString: Invalid description '%s'",
                 descrip.isEmpty() ? "(empty)" : descrip.toLatin1().data());
        return false;
    }
 
    setFamily(l[0].toString());
    if (count > 1 && l[1].toDouble() > 0.0)
        setPointSizeF(l[1].toDouble());
    if (count == 9) {
        setStyleHint((StyleHint) l[2].toInt());
        setWeight(QFont::Weight(l[3].toInt()));
        setItalic(l[4].toInt());
        setUnderline(l[5].toInt());
        setStrikeOut(l[6].toInt());
        setFixedPitch(l[7].toInt());
    } else if (count >= 10) {
        if (l[2].toInt() > 0)
            setPixelSize(l[2].toInt());
        setStyleHint((StyleHint) l[3].toInt());
        if (count >= 16)
            setWeight(QFont::Weight(l[4].toInt()));
        else
            setWeight(QFont::Weight(qt_legacyToOpenTypeWeight(l[4].toInt())));
        setStyle((QFont::Style)l[5].toInt());
        setUnderline(l[6].toInt());
        setStrikeOut(l[7].toInt());
        setFixedPitch(l[8].toInt());
        if (count >= 16) {
            setCapitalization((Capitalization)l[10].toInt());
            setLetterSpacing((SpacingType)l[11].toInt(), l[12].toDouble());
            setWordSpacing(l[13].toDouble());
            setStretch(l[14].toInt());
            setStyleStrategy((StyleStrategy)l[15].toInt());
        }
        if (count == 11 || count == 17)
            d->request.styleName = l[count - 1].toString();
        else
            d->request.styleName.clear();
    }
 
    if (count >= 9 && !d->request.fixedPitch) // assume 'false' fixedPitch equals default
        d->request.ignorePitch = true;
 
    return true;
}
 
void QFont::initialize()
{
}
 
void QFont::cleanup()
{
    QFontCache::cleanup();
}
 
void QFont::cacheStatistics()
{
}
 
 
extern QStringList qt_fallbacksForFamily(const QString &family, QFont::Style style,
                                         QFont::StyleHint styleHint, QChar::Script script);
 
QString QFont::defaultFamily() const
{
    const QStringList fallbacks = qt_fallbacksForFamily(QString(), QFont::StyleNormal
                                      , QFont::StyleHint(d->request.styleHint), QChar::Script_Common);
    if (!fallbacks.isEmpty())
        return fallbacks.first();
    return QString();
}
 
QStringList QFont::families() const
{
    return d->request.families;
}
 
void QFont::setFamilies(const QStringList &families)
{
    if ((resolve_mask & QFont::FamiliesResolved) && d->request.families == families)
        return;
    detach();
    d->request.families = families;
    resolve_mask |= QFont::FamiliesResolved;
}
 
 
/*****************************************************************************
  QFont stream functions
 *****************************************************************************/
#ifndef QT_NO_DATASTREAM
 
QDataStream &operator<<(QDataStream &s, const QFont &font)
{
    if (s.version() == 1) {
        s << font.d->request.families.first().toLatin1();
    } else {
        s << font.d->request.families.first();
        if (s.version() >= QDataStream::Qt_5_4)
            s << font.d->request.styleName;
    }
 
    if (s.version() >= QDataStream::Qt_4_0) {
        // 4.0
        double pointSize = font.d->request.pointSize;
        qint32 pixelSize = font.d->request.pixelSize;
        s << pointSize;
        s << pixelSize;
    } else if (s.version() <= 3) {
        qint16 pointSize = (qint16) (font.d->request.pointSize * 10);
        if (pointSize < 0) {
            pointSize = (qint16)QFontInfo(font).pointSize() * 10;
        }
        s << pointSize;
    } else {
        s << (qint16) (font.d->request.pointSize * 10);
        s << (qint16) font.d->request.pixelSize;
    }
 
    s << (quint8) font.d->request.styleHint;
    if (s.version() >= QDataStream::Qt_3_1) {
        // Continue writing 8 bits for versions < 5.4 so that we don't write too much,
        // even though we need 16 to store styleStrategy, so there is some data loss.
        if (s.version() >= QDataStream::Qt_5_4)
            s << (quint16) font.d->request.styleStrategy;
        else
            s << (quint8) font.d->request.styleStrategy;
    }
 
    if (s.version() < QDataStream::Qt_6_0)
        s << quint8(0) << quint8(qt_openTypeToLegacyWeight(font.d->request.weight));
    else
        s << quint16(font.d->request.weight);
 
    s << get_font_bits(s.version(), font.d.data());
    if (s.version() >= QDataStream::Qt_4_3)
        s << (quint16)font.d->request.stretch;
    if (s.version() >= QDataStream::Qt_4_4)
        s << get_extended_font_bits(font.d.data());
    if (s.version() >= QDataStream::Qt_4_5) {
        s << font.d->letterSpacing.value();
        s << font.d->wordSpacing.value();
    }
    if (s.version() >= QDataStream::Qt_5_4)
        s << (quint8)font.d->request.hintingPreference;
    if (s.version() >= QDataStream::Qt_5_6)
        s << (quint8)font.d->capital;
    if (s.version() >= QDataStream::Qt_5_13) {
        if (s.version() < QDataStream::Qt_6_0)
            s << font.d->request.families.mid(1);
        else
            s << font.d->request.families;
    }
    return s;
}
 
 
QDataStream &operator>>(QDataStream &s, QFont &font)
{
    font.d = new QFontPrivate;
    font.resolve_mask = QFont::AllPropertiesResolved;
 
    quint8 styleHint, bits;
    quint16 styleStrategy = QFont::PreferDefault;
 
    if (s.version() == 1) {
        QByteArray fam;
        s >> fam;
        font.d->request.families = QStringList(QString::fromLatin1(fam));
    } else {
        QString fam;
        s >> fam;
        font.d->request.families = QStringList(fam);
        if (s.version() >= QDataStream::Qt_5_4)
            s >> font.d->request.styleName;
    }
 
    if (s.version() >= QDataStream::Qt_4_0) {
        // 4.0
        double pointSize;
        qint32 pixelSize;
        s >> pointSize;
        s >> pixelSize;
        font.d->request.pointSize = qreal(pointSize);
        font.d->request.pixelSize = pixelSize;
    } else {
        qint16 pointSize, pixelSize = -1;
        s >> pointSize;
        if (s.version() >= 4)
            s >> pixelSize;
        font.d->request.pointSize = qreal(pointSize / 10.);
        font.d->request.pixelSize = pixelSize;
    }
    s >> styleHint;
    if (s.version() >= QDataStream::Qt_3_1) {
        if (s.version() >= QDataStream::Qt_5_4) {
            s >> styleStrategy;
        } else {
            quint8 tempStyleStrategy;
            s >> tempStyleStrategy;
            styleStrategy = tempStyleStrategy;
        }
    }
 
    if (s.version() < QDataStream::Qt_6_0) {
        quint8 charSet;
        quint8 weight;
        s >> charSet;
        s >> weight;
        font.d->request.weight = qt_legacyToOpenTypeWeight(weight);
    } else {
        quint16 weight;
        s >> weight;
        font.d->request.weight = weight;
    }
 
    s >> bits;
 
    font.d->request.styleHint = styleHint;
    font.d->request.styleStrategy = styleStrategy;
 
    set_font_bits(s.version(), bits, font.d.data());
 
    if (s.version() >= QDataStream::Qt_4_3) {
        quint16 stretch;
        s >> stretch;
        font.d->request.stretch = stretch;
    }
 
    if (s.version() >= QDataStream::Qt_4_4) {
        quint8 extendedBits;
        s >> extendedBits;
        set_extended_font_bits(extendedBits, font.d.data());
    }
    if (s.version() >= QDataStream::Qt_4_5) {
        int value;
        s >> value;
        font.d->letterSpacing.setValue(value);
        s >> value;
        font.d->wordSpacing.setValue(value);
    }
    if (s.version() >= QDataStream::Qt_5_4) {
        quint8 value;
        s >> value;
        font.d->request.hintingPreference = QFont::HintingPreference(value);
    }
    if (s.version() >= QDataStream::Qt_5_6) {
        quint8 value;
        s >> value;
        font.d->capital = QFont::Capitalization(value);
    }
    if (s.version() >= QDataStream::Qt_5_13) {
        QStringList value;
        s >> value;
        if (s.version() < QDataStream::Qt_6_0)
            font.d->request.families.append(value);
        else
            font.d->request.families = value;
    }
    return s;
}
 
#endif // QT_NO_DATASTREAM
 
 
/*****************************************************************************
  QFontInfo member functions
 *****************************************************************************/
 
QFontInfo::QFontInfo(const QFont &font)
    : d(font.d)
{
}
 
QFontInfo::QFontInfo(const QFontInfo &fi)
    : d(fi.d)
{
}
 
QFontInfo::~QFontInfo()
{
}
 
QFontInfo &QFontInfo::operator=(const QFontInfo &fi)
{
    d = fi.d;
    return *this;
}
 
QString QFontInfo::family() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->fontDef.families.isEmpty() ? QString() : engine->fontDef.families.first();
}
 
QString QFontInfo::styleName() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->fontDef.styleName;
}
 
int QFontInfo::pointSize() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->fontDef.pointSize);
}
 
qreal QFontInfo::pointSizeF() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->fontDef.pointSize;
}
 
int QFontInfo::pixelSize() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->fontDef.pixelSize;
}
 
bool QFontInfo::italic() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->fontDef.style != QFont::StyleNormal;
}
 
QFont::Style QFontInfo::style() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return (QFont::Style)engine->fontDef.style;
}
 
 
#if QT_DEPRECATED_SINCE(6, 0)
int QFontInfo::legacyWeight() const
{
    return qt_openTypeToLegacyWeight(weight());
}
#endif // QT_DEPRECATED_SINCE(6, 0)
 
 
int QFontInfo::weight() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->fontDef.weight;
 
}
 
bool QFontInfo::underline() const
{
    return d->underline;
}
 
bool QFontInfo::overline() const
{
    return d->overline;
}
 
bool QFontInfo::strikeOut() const
{
    return d->strikeOut;
}
 
bool QFontInfo::fixedPitch() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
#ifdef Q_OS_MAC
    if (!engine->fontDef.fixedPitchComputed) {
        QChar ch[2] = { QLatin1Char('i'), QLatin1Char('m') };
        QGlyphLayoutArray<2> g;
        int l = 2;
        if (!engine->stringToCMap(ch, 2, &g, &l, {}))
            Q_UNREACHABLE();
        Q_ASSERT(l == 2);
        engine->fontDef.fixedPitch = g.advances[0] == g.advances[1];
        engine->fontDef.fixedPitchComputed = true;
    }
#endif
    return engine->fontDef.fixedPitch;
}
 
QFont::StyleHint QFontInfo::styleHint() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return (QFont::StyleHint) engine->fontDef.styleHint;
}
 
bool QFontInfo::exactMatch() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return d->request.exactMatch(engine->fontDef);
}
 
 
 
 
// **********************************************************************
// QFontCache
// **********************************************************************
 
#ifdef QFONTCACHE_DEBUG
// fast timeouts for debugging
static const int fast_timeout =   1000;  // 1s
static const int slow_timeout =   5000;  // 5s
#else
static const int fast_timeout =  10000; // 10s
static const int slow_timeout = 300000; //  5m
#endif // QFONTCACHE_DEBUG
 
#ifndef QFONTCACHE_MIN_COST
#  define QFONTCACHE_MIN_COST 4*1024 // 4mb
#endif
const uint QFontCache::min_cost = QFONTCACHE_MIN_COST;
Q_GLOBAL_STATIC(QThreadStorage<QFontCache *>, theFontCache)
 
QFontCache *QFontCache::instance()
{
    QFontCache *&fontCache = theFontCache()->localData();
    if (!fontCache)
        fontCache = new QFontCache;
    return fontCache;
}
 
void QFontCache::cleanup()
{
    QThreadStorage<QFontCache *> *cache = nullptr;
    QT_TRY {
        cache = theFontCache();
    } QT_CATCH (const std::bad_alloc &) {
        // no cache - just ignore
    }
    if (cache && cache->hasLocalData())
        cache->setLocalData(nullptr);
}
 
static QBasicAtomicInt font_cache_id = Q_BASIC_ATOMIC_INITIALIZER(0);
 
QFontCache::QFontCache()
    : QObject(), total_cost(0), max_cost(min_cost),
      current_timestamp(0), fast(false),
      autoClean(QGuiApplication::instance()
                && (QGuiApplication::instance()->thread() == QThread::currentThread())),
      timer_id(-1),
      m_id(font_cache_id.fetchAndAddRelaxed(1) + 1)
{
}
 
QFontCache::~QFontCache()
{
    clear();
}
 
void QFontCache::clear()
{
    {
        EngineDataCache::Iterator it = engineDataCache.begin(),
                                 end = engineDataCache.end();
        while (it != end) {
            QFontEngineData *data = it.value();
            for (int i = 0; i < QChar::ScriptCount; ++i) {
                if (data->engines[i]) {
                    if (!data->engines[i]->ref.deref()) {
                        Q_ASSERT(engineCacheCount.value(data->engines[i]) == 0);
                        delete data->engines[i];
                    }
                    data->engines[i] = nullptr;
                }
            }
            if (!data->ref.deref()) {
                delete data;
            } else {
                FC_DEBUG("QFontCache::clear: engineData %p still has refcount %d",
                         data, data->ref.loadRelaxed());
            }
            ++it;
        }
    }
 
    engineDataCache.clear();
 
 
    bool mightHaveEnginesLeftForCleanup;
    do {
        mightHaveEnginesLeftForCleanup = false;
        for (EngineCache::Iterator it = engineCache.begin(), end = engineCache.end();
             it != end; ++it) {
            QFontEngine *engine = it.value().data;
            if (engine) {
                const int cacheCount = --engineCacheCount[engine];
                Q_ASSERT(cacheCount >= 0);
                if (!engine->ref.deref()) {
                    Q_ASSERT(cacheCount == 0);
                    mightHaveEnginesLeftForCleanup = engine->type() == QFontEngine::Multi;
                    delete engine;
                } else if (cacheCount == 0) {
                    FC_DEBUG("QFontCache::clear: engine %p still has refcount %d",
                             engine, engine->ref.loadRelaxed());
                }
                it.value().data = nullptr;
            }
        }
    } while (mightHaveEnginesLeftForCleanup);
 
    engineCache.clear();
    engineCacheCount.clear();
 
 
    total_cost = 0;
    max_cost = min_cost;
}
 
 
QFontEngineData *QFontCache::findEngineData(const QFontDef &def) const
{
    EngineDataCache::ConstIterator it = engineDataCache.constFind(def);
    if (it == engineDataCache.constEnd())
        return nullptr;
 
    // found
    return it.value();
}
 
void QFontCache::insertEngineData(const QFontDef &def, QFontEngineData *engineData)
{
#ifdef QFONTCACHE_DEBUG
    FC_DEBUG("QFontCache: inserting new engine data %p", engineData);
    if (engineDataCache.contains(def)) {
        FC_DEBUG("   QFontCache already contains engine data %p for key=(%g %g %d %d %d)",
                 engineDataCache.value(def), def.pointSize,
                 def.pixelSize, def.weight, def.style, def.fixedPitch);
    }
#endif
    Q_ASSERT(!engineDataCache.contains(def));
 
    engineData->ref.ref();
    // Decrease now rather than waiting
    if (total_cost > min_cost * 2 && engineDataCache.size() >= QFONTCACHE_DECREASE_TRIGGER_LIMIT)
        decreaseCache();
 
    engineDataCache.insert(def, engineData);
    increaseCost(sizeof(QFontEngineData));
}
 
QFontEngine *QFontCache::findEngine(const Key &key)
{
    EngineCache::Iterator it = engineCache.find(key),
                         end = engineCache.end();
    if (it == end) return nullptr;
 
    Q_ASSERT(it.value().data != nullptr);
    Q_ASSERT(key.multi == (it.value().data->type() == QFontEngine::Multi));
 
    // found... update the hitcount and timestamp
    updateHitCountAndTimeStamp(it.value());
 
    return it.value().data;
}
 
void QFontCache::updateHitCountAndTimeStamp(Engine &value)
{
    value.hits++;
    value.timestamp = ++current_timestamp;
 
    FC_DEBUG("QFontCache: found font engine\n"
             "  %p: timestamp %4u hits %3u ref %2d/%2d, type %d",
             value.data, value.timestamp, value.hits,
             value.data->ref.loadRelaxed(), engineCacheCount.value(value.data),
             value.data->type());
}
 
void QFontCache::insertEngine(const Key &key, QFontEngine *engine, bool insertMulti)
{
    Q_ASSERT(engine != nullptr);
    Q_ASSERT(key.multi == (engine->type() == QFontEngine::Multi));
 
#ifdef QFONTCACHE_DEBUG
    FC_DEBUG("QFontCache: inserting new engine %p, refcount %d", engine, engine->ref.loadRelaxed());
    if (!insertMulti && engineCache.contains(key)) {
        FC_DEBUG("   QFontCache already contains engine %p for key=(%g %g %d %d %d)",
                 engineCache.value(key).data, key.def.pointSize,
                 key.def.pixelSize, key.def.weight, key.def.style, key.def.fixedPitch);
    }
#endif
    engine->ref.ref();
    // Decrease now rather than waiting
    if (total_cost > min_cost * 2 && engineCache.size() >= QFONTCACHE_DECREASE_TRIGGER_LIMIT)
        decreaseCache();
 
    Engine data(engine);
    data.timestamp = ++current_timestamp;
 
    if (insertMulti)
        engineCache.insert(key, data);
    else
        engineCache.replace(key, data);
    // only increase the cost if this is the first time we insert the engine
    if (++engineCacheCount[engine] == 1)
        increaseCost(engine->cache_cost);
}
 
void QFontCache::increaseCost(uint cost)
{
    cost = (cost + 512) / 1024; // store cost in kb
    cost = cost > 0 ? cost : 1;
    total_cost += cost;
 
    FC_DEBUG("  COST: increased %u kb, total_cost %u kb, max_cost %u kb",
            cost, total_cost, max_cost);
 
    if (total_cost > max_cost) {
        max_cost = total_cost;
 
        if (!autoClean)
            return;
 
        if (timer_id == -1 || ! fast) {
            FC_DEBUG("  TIMER: starting fast timer (%d ms)", fast_timeout);
 
            if (timer_id != -1)
                killTimer(timer_id);
            timer_id = startTimer(fast_timeout);
            fast = true;
        }
    }
}
 
void QFontCache::decreaseCost(uint cost)
{
    cost = (cost + 512) / 1024; // cost is stored in kb
    cost = cost > 0 ? cost : 1;
    Q_ASSERT(cost <= total_cost);
    total_cost -= cost;
 
    FC_DEBUG("  COST: decreased %u kb, total_cost %u kb, max_cost %u kb",
            cost, total_cost, max_cost);
}
 
void QFontCache::timerEvent(QTimerEvent *)
{
    FC_DEBUG("QFontCache::timerEvent: performing cache maintenance (timestamp %u)",
              current_timestamp);
 
    if (total_cost <= max_cost && max_cost <= min_cost) {
        FC_DEBUG("  cache redused sufficiently, stopping timer");
 
        killTimer(timer_id);
        timer_id = -1;
        fast = false;
 
        return;
    }
    decreaseCache();
}
 
void QFontCache::decreaseCache()
{
    // go through the cache and count up everything in use
    uint in_use_cost = 0;
 
    {
        FC_DEBUG("  SWEEP engine data:");
 
        // make sure the cost of each engine data is at least 1kb
        const uint engine_data_cost =
            sizeof(QFontEngineData) > 1024 ? sizeof(QFontEngineData) : 1024;
 
        EngineDataCache::ConstIterator it = engineDataCache.constBegin(),
                                      end = engineDataCache.constEnd();
        for (; it != end; ++it) {
            FC_DEBUG("    %p: ref %2d", it.value(), int(it.value()->ref.loadRelaxed()));
 
            if (it.value()->ref.loadRelaxed() != 1)
                in_use_cost += engine_data_cost;
        }
    }
 
    {
        FC_DEBUG("  SWEEP engine:");
 
        EngineCache::ConstIterator it = engineCache.constBegin(),
                                  end = engineCache.constEnd();
        for (; it != end; ++it) {
            FC_DEBUG("    %p: timestamp %4u hits %2u ref %2d/%2d, cost %u bytes",
                     it.value().data, it.value().timestamp, it.value().hits,
                     it.value().data->ref.loadRelaxed(), engineCacheCount.value(it.value().data),
                     it.value().data->cache_cost);
 
            if (it.value().data->ref.loadRelaxed() > engineCacheCount.value(it.value().data))
                in_use_cost += it.value().data->cache_cost / engineCacheCount.value(it.value().data);
        }
 
        // attempt to make up for rounding errors
        in_use_cost += engineCache.size();
    }
 
    in_use_cost = (in_use_cost + 512) / 1024; // cost is stored in kb
 
    /*
      calculate the new maximum cost for the cache
 
      NOTE: in_use_cost is *not* correct due to rounding errors in the
      above algorithm.  instead of worrying about getting the
      calculation correct, we are more interested in speed, and use
      in_use_cost as a floor for new_max_cost
    */
    uint new_max_cost = qMax(qMax(max_cost / 2, in_use_cost), min_cost);
 
    FC_DEBUG("  after sweep, in use %u kb, total %u kb, max %u kb, new max %u kb",
              in_use_cost, total_cost, max_cost, new_max_cost);
 
    if (autoClean) {
        if (new_max_cost == max_cost) {
            if (fast) {
                FC_DEBUG("  cannot shrink cache, slowing timer");
 
                if (timer_id != -1) {
                    killTimer(timer_id);
                timer_id = startTimer(slow_timeout);
                fast = false;
            }
 
            return;
        } else if (! fast) {
            FC_DEBUG("  dropping into passing gear");
 
            if (timer_id != -1)
                killTimer(timer_id);
            timer_id = startTimer(fast_timeout);
            fast = true;        }
        }
    }
 
    max_cost = new_max_cost;
 
    {
        FC_DEBUG("  CLEAN engine data:");
 
        // clean out all unused engine data
        EngineDataCache::Iterator it = engineDataCache.begin();
        while (it != engineDataCache.end()) {
            if (it.value()->ref.loadRelaxed() == 1) {
                FC_DEBUG("    %p", it.value());
                decreaseCost(sizeof(QFontEngineData));
                it.value()->ref.deref();
                delete it.value();
                it = engineDataCache.erase(it);
            } else {
                ++it;
            }
        }
    }
 
    FC_DEBUG("  CLEAN engine:");
 
    // clean out the engine cache just enough to get below our new max cost
    bool cost_decreased;
    do {
        cost_decreased = false;
 
        EngineCache::Iterator it = engineCache.begin(),
                             end = engineCache.end();
        // determine the oldest and least popular of the unused engines
        uint oldest = ~0u;
        uint least_popular = ~0u;
 
        EngineCache::Iterator jt = end;
 
        for ( ; it != end; ++it) {
            if (it.value().data->ref.loadRelaxed() != engineCacheCount.value(it.value().data))
                continue;
 
            if (it.value().timestamp < oldest && it.value().hits <= least_popular) {
                oldest = it.value().timestamp;
                least_popular = it.value().hits;
                jt = it;
            }
        }
 
        it = jt;
        if (it != end) {
            FC_DEBUG("    %p: timestamp %4u hits %2u ref %2d/%2d, type %d",
                     it.value().data, it.value().timestamp, it.value().hits,
                     it.value().data->ref.loadRelaxed(), engineCacheCount.value(it.value().data),
                     it.value().data->type());
 
            QFontEngine *fontEngine = it.value().data;
            // get rid of all occurrences
            it = engineCache.begin();
            while (it != engineCache.end()) {
                if (it.value().data == fontEngine) {
                    fontEngine->ref.deref();
                    it = engineCache.erase(it);
                } else {
                    ++it;
                }
            }
            // and delete the last occurrence
            Q_ASSERT(fontEngine->ref.loadRelaxed() == 0);
            decreaseCost(fontEngine->cache_cost);
            delete fontEngine;
            engineCacheCount.remove(fontEngine);
 
            cost_decreased = true;
        }
    } while (cost_decreased && total_cost > max_cost);
}
 
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug stream, const QFont &font)
{
    QDebugStateSaver saver(stream);
    stream.nospace().noquote();
    stream << "QFont(";
 
    if (stream.verbosity() == QDebug::DefaultVerbosity) {
        stream << font.toString() << ")";
        return stream;
    }
 
    QString fontDescription;
    QDebug debug(&fontDescription);
    debug.nospace();
 
    const QFont defaultFont(new QFontPrivate);
 
    for (int property = QFont::SizeResolved; property < QFont::AllPropertiesResolved; property <<= 1) {
        const bool resolved = (font.resolve_mask & property) != 0;
        if (!resolved && stream.verbosity() == QDebug::MinimumVerbosity)
            continue;
 
        #define QFONT_DEBUG_SKIP_DEFAULT(prop) \
            if ((font.prop() == defaultFont.prop()) && stream.verbosity() == 1) \
                continue;
 
        QDebugStateSaver saver(debug);
 
        switch (property) {
        case QFont::SizeResolved:
            if (font.pointSizeF() >= 0)
                debug << font.pointSizeF() << "pt";
            else if (font.pixelSize() >= 0)
                debug << font.pixelSize() << "px";
            else
                Q_UNREACHABLE();
            break;
        case QFont::StyleHintResolved:
            QFONT_DEBUG_SKIP_DEFAULT(styleHint);
            debug.verbosity(1) << font.styleHint(); break;
        case QFont::StyleStrategyResolved:
            QFONT_DEBUG_SKIP_DEFAULT(styleStrategy);
            debug.verbosity(1) << font.styleStrategy(); break;
        case QFont::WeightResolved:
            debug.verbosity(1) << QFont::Weight(font.weight()); break;
        case QFont::StyleResolved:
            QFONT_DEBUG_SKIP_DEFAULT(style);
            debug.verbosity(0) << font.style(); break;
        case QFont::UnderlineResolved:
            QFONT_DEBUG_SKIP_DEFAULT(underline);
            debug << "underline=" << font.underline(); break;
        case QFont::OverlineResolved:
            QFONT_DEBUG_SKIP_DEFAULT(overline);
            debug << "overline=" << font.overline(); break;
        case QFont::StrikeOutResolved:
            QFONT_DEBUG_SKIP_DEFAULT(strikeOut);
            debug << "strikeOut=" << font.strikeOut(); break;
        case QFont::FixedPitchResolved:
            QFONT_DEBUG_SKIP_DEFAULT(fixedPitch);
            debug << "fixedPitch=" << font.fixedPitch(); break;
        case QFont::StretchResolved:
            QFONT_DEBUG_SKIP_DEFAULT(stretch);
            debug.verbosity(0) << QFont::Stretch(font.stretch()); break;
        case QFont::KerningResolved:
            QFONT_DEBUG_SKIP_DEFAULT(kerning);
            debug << "kerning=" << font.kerning(); break;
        case QFont::CapitalizationResolved:
            QFONT_DEBUG_SKIP_DEFAULT(capitalization);
            debug.verbosity(0) << font.capitalization(); break;
        case QFont::LetterSpacingResolved:
            QFONT_DEBUG_SKIP_DEFAULT(letterSpacing);
            debug << "letterSpacing=" << font.letterSpacing();
            debug.verbosity(0) << " (" << font.letterSpacingType() << ")";
            break;
        case QFont::HintingPreferenceResolved:
            QFONT_DEBUG_SKIP_DEFAULT(hintingPreference);
            debug.verbosity(0) << font.hintingPreference(); break;
        case QFont::StyleNameResolved:
            QFONT_DEBUG_SKIP_DEFAULT(styleName);
            debug << "styleName=" << font.styleName(); break;
        default:
            continue;
        };
 
        #undef QFONT_DEBUG_SKIP_DEFAULT
 
        debug << ", ";
    }
 
    if (stream.verbosity() > QDebug::MinimumVerbosity)
        debug.verbosity(0) << "resolveMask=" << QFlags<QFont::ResolveProperties>(font.resolve_mask);
    else
        fontDescription.chop(2); // Last ', '
 
    stream << fontDescription << ')';
 
    return stream;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qfont.cpp"