diff options
Diffstat (limited to 'src/gui/text/qfont.cpp')
| -rw-r--r-- | src/gui/text/qfont.cpp | 754 |
1 files changed, 620 insertions, 134 deletions
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp index 45310d0406..bf89905c53 100644 --- a/src/gui/text/qfont.cpp +++ b/src/gui/text/qfont.cpp @@ -1,41 +1,5 @@ -/**************************************************************************** -** -** 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$ -** -****************************************************************************/ +// Copyright (C) 2019 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 "qfont.h" #include "qdebug.h" @@ -67,6 +31,8 @@ #include <QtCore/QMutexLocker> #include <QtCore/QMutex> +#include <array> + // #define QFONTCACHE_DEBUG #ifdef QFONTCACHE_DEBUG # define FC_DEBUG qDebug @@ -124,6 +90,9 @@ bool QFontDef::exactMatch(const QFontDef &other) const return false; } + if (variableAxisValues != other.variableAxisValues) + return false; + return (styleHint == other.styleHint && styleStrategy == other.styleStrategy && weight == other.weight @@ -136,14 +105,14 @@ bool QFontDef::exactMatch(const QFontDef &other) const ); } -extern bool qt_is_gui_used; +extern bool qt_is_tty_app; Q_GUI_EXPORT int qt_defaultDpiX() { if (QCoreApplication::instance()->testAttribute(Qt::AA_Use96Dpi)) return 96; - if (!qt_is_gui_used) + if (qt_is_tty_app) return 75; if (const QScreen *screen = QGuiApplication::primaryScreen()) @@ -158,7 +127,7 @@ Q_GUI_EXPORT int qt_defaultDpiY() if (QCoreApplication::instance()->testAttribute(Qt::AA_Use96Dpi)) return 96; - if (!qt_is_gui_used) + if (qt_is_tty_app) return 75; if (const QScreen *screen = QGuiApplication::primaryScreen()) @@ -176,7 +145,7 @@ Q_GUI_EXPORT int qt_defaultDpi() /* 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 = { + static constexpr std::array<int, 2> 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 }, @@ -187,8 +156,8 @@ static int convertWeights(int weight, bool inverted) // 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 weightOld = mapping[ inverted]; + const int weightNew = mapping[!inverted]; const int dist = qAbs(weightOld - weight); if (dist < closestDist) { result = weightNew; @@ -208,14 +177,14 @@ static QStringList splitIntoFamilies(const QString &family) QStringList familyList; if (family.isEmpty()) return familyList; - const auto list = QStringView{family}.split(QLatin1Char(',')); + const auto list = QStringView{family}.split(u','); 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); + if ((str.startsWith(u'"') && str.endsWith(u'"')) + || (str.startsWith(u'\'') && str.endsWith(u'\''))) { + str = str.mid(1, str.size() - 2); } familyList << str.toString(); } @@ -247,7 +216,7 @@ QFontPrivate::QFontPrivate(const QFontPrivate &other) strikeOut(other.strikeOut), kerning(other.kerning), capital(other.capital), letterSpacingIsAbsolute(other.letterSpacingIsAbsolute), letterSpacing(other.letterSpacing), wordSpacing(other.wordSpacing), - scFont(other.scFont) + features(other.features), scFont(other.scFont) { if (scFont && scFont != this) scFont->ref.ref(); @@ -258,8 +227,10 @@ QFontPrivate::~QFontPrivate() if (engineData && !engineData->ref.deref()) delete engineData; engineData = nullptr; - if (scFont && scFont != this) - scFont->ref.deref(); + if (scFont && scFont != this) { + if (!scFont->ref.deref()) + delete scFont; + } scFont = nullptr; } @@ -375,9 +346,38 @@ void QFontPrivate::resolve(uint mask, const QFontPrivate *other) wordSpacing = other->wordSpacing; if (! (mask & QFont::CapitalizationResolved)) capital = other->capital; + + if (!(mask & QFont::FeaturesResolved)) + features = other->features; + + if (!(mask & QFont::VariableAxesResolved)) + request.variableAxisValues = other->request.variableAxisValues; } +bool QFontPrivate::hasVariableAxis(QFont::Tag tag, float value) const +{ + return request.variableAxisValues.contains(tag) && request.variableAxisValues.value(tag) == value; +} + +void QFontPrivate::setVariableAxis(QFont::Tag tag, float value) +{ + request.variableAxisValues.insert(tag, value); +} + +void QFontPrivate::unsetVariableAxis(QFont::Tag tag) +{ + request.variableAxisValues.remove(tag); +} + +void QFontPrivate::setFeature(QFont::Tag tag, quint32 value) +{ + features.insert(tag, value); +} +void QFontPrivate::unsetFeature(QFont::Tag tag) +{ + features.remove(tag); +} QFontEngineData::QFontEngineData() @@ -447,7 +447,7 @@ QFontEngineData::~QFontEngineData() The attributes set in the constructor can also be set later, e.g. setFamily(), setPointSize(), setPointSizeF(), setWeight() and setItalic(). The remaining attributes must be set after - contstruction, e.g. setBold(), setUnderline(), setOverline(), + construction, e.g. setBold(), setUnderline(), setOverline(), setStrikeOut() and setFixedPitch(). QFontInfo objects should be created \e after the font's attributes have been set. A QFontInfo object will not change, even if you change the font's @@ -492,8 +492,6 @@ QFontEngineData::~QFontEngineData() The font matching algorithm works as follows: \list 1 \li The specified font families (set by setFamilies()) are searched for. - \li If not found, then if set the specified font family exists and can be used to represent - the writing system in use, it will be selected. \li If not, a replacement font that supports the writing system is selected. The font matching algorithm will try to find the best match for all the properties set in the QFont. How this is @@ -560,10 +558,10 @@ QFontEngineData::~QFontEngineData() For more general information on fonts, see the \l{comp.fonts FAQ}{comp.fonts FAQ}. - Information on encodings can be found from - \l{Roman Czyborra's} page. + Information on encodings can be found from the + \l{UTR17} page. - \sa QFontMetrics, QFontInfo, QFontDatabase, {Character Map Example} + \sa QFontMetrics, QFontInfo, QFontDatabase */ /*! @@ -616,16 +614,6 @@ QFontEngineData::~QFontEngineData() \since 5.2 */ -#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) -/* - \obsolete - Constructs a font from \a font for use on the paint device \a pd. -*/ -QFont::QFont(const QFont &font, QPaintDevice *pd) - : QFont(font, static_cast<const QPaintDevice*>(pd)) -{} -#endif - /*! \since 5.13 Constructs a font from \a font for use on the paint device \a pd. @@ -660,8 +648,10 @@ void QFont::detach() if (d->engineData && !d->engineData->ref.deref()) delete d->engineData; d->engineData = nullptr; - if (d->scFont && d->scFont != d.data()) - d->scFont->ref.deref(); + if (d->scFont && d->scFont != d.data()) { + if (!d->scFont->ref.deref()) + delete d->scFont; + } d->scFont = nullptr; return; } @@ -698,7 +688,6 @@ QFont::QFont() } /*! - \obsolete Constructs a font object with the specified \a family, \a pointSize, \a weight and \a italic settings. @@ -827,7 +816,7 @@ QFont &QFont::operator=(const QFont &font) */ QString QFont::family() const { - return d->request.families.isEmpty() ? QString() : d->request.families.first(); + return d->request.families.isEmpty() ? QString() : d->request.families.constFirst(); } /*! @@ -841,22 +830,11 @@ QString QFont::family() const available a family will be set using the \l{QFont}{font matching} algorithm. - This will split the family string on a comma and call setFamilies() with the - resulting list. To preserve a font that uses a comma in it's name then use - setFamilies() directly. From Qt 6.2 this behavior will no longer happen and - \a family will be passed as a single family. - \sa family(), setStyleHint(), setFamilies(), families(), QFontInfo */ 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)); + setFamilies(QStringList(family)); } /*! @@ -945,13 +923,7 @@ int QFont::pointSize() const \li PreferVerticalHinting \li PreferFullHinting \row - \li Windows Vista (w/o Platform Update) and earlier - \li Full hinting - \li Full hinting - \li Full hinting - \li Full hinting - \row - \li Windows 7 and Windows Vista (w/Platform Update) and DirectWrite enabled in Qt + \li Windows and DirectWrite enabled in Qt \li Full hinting \li Vertical hinting \li Vertical hinting @@ -970,12 +942,6 @@ int QFont::pointSize() const \li No hinting \endtable - \note Please be aware that altering the hinting preference on Windows is available through - the DirectWrite font engine. This is available on Windows Vista after installing the platform - update, and on Windows 7. In order to use this extension, configure Qt using -directwrite. - The target application will then depend on the availability of DirectWrite on the target - system. - */ /*! @@ -1071,7 +1037,8 @@ qreal QFont::pointSizeF() const } /*! - Sets the font size to \a pixelSize pixels. + Sets the font size to \a pixelSize pixels, with a maxiumum size + of an unsigned 16-bit integer. Using this function makes the font device dependent. Use setPointSize() or setPointSizeF() to set the size of the font @@ -1189,7 +1156,7 @@ QFont::Weight QFont::weight() const #if QT_DEPRECATED_SINCE(6, 0) /*! - \obsolete Use setWeight() instead. + \deprecated [6.0] Use setWeight() instead. Sets the weight of the font to \a legacyWeight using the legacy font weight scale of Qt 5 and previous versions. @@ -1201,7 +1168,7 @@ QFont::Weight QFont::weight() const \note If styleName() is set, this value may be ignored for font selection. - \sa setWeight(), weight(), legacyWeight(), QFontInfo + \sa setWeight(), weight(), QFontInfo */ void QFont::setLegacyWeight(int legacyWeight) { @@ -1209,7 +1176,7 @@ void QFont::setLegacyWeight(int legacyWeight) } /*! - \obsolete Use weight() instead. + \deprecated [6.0] Use weight() instead. Returns the weight of the font converted to the non-standard font weight scale used in Qt 5 and earlier versions. @@ -1805,6 +1772,7 @@ bool QFont::operator==(const QFont &f) const && f.d->letterSpacingIsAbsolute == d->letterSpacingIsAbsolute && f.d->letterSpacing == d->letterSpacing && f.d->wordSpacing == d->wordSpacing + && f.d->features == d->features )); } @@ -1842,7 +1810,37 @@ bool QFont::operator<(const QFont &f) const 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; + if (f1attrs != f2attrs) return f1attrs < f2attrs; + + if (d->features.size() != f.d->features.size()) + return f.d->features.size() < d->features.size(); + + { + auto it = d->features.constBegin(); + auto jt = f.d->features.constBegin(); + for (; it != d->features.constEnd(); ++it, ++jt) { + if (it.key() != jt.key()) + return jt.key() < it.key(); + if (it.value() != jt.value()) + return jt.value() < it.value(); + } + } + + if (r1.variableAxisValues.size() != r2.variableAxisValues.size()) + return r1.variableAxisValues.size() < r2.variableAxisValues.size(); + + { + auto it = r1.variableAxisValues.constBegin(); + auto jt = r2.variableAxisValues.constBegin(); + for (; it != r1.variableAxisValues.constEnd(); ++it, ++jt) { + if (it.key() != jt.key()) + return jt.key() < it.key(); + if (it.value() != jt.value()) + return jt.value() < it.value(); + } + } + + return false; } @@ -2136,7 +2134,7 @@ QString QFont::key() const */ QString QFont::toString() const { - const QChar comma(QLatin1Char(',')); + const QChar comma(u','); QString fontDescription = family() + comma + QString::number( pointSizeF()) + comma + QString::number( pixelSize()) + comma + @@ -2184,8 +2182,8 @@ size_t qHash(const QFont &font, size_t seed) noexcept bool QFont::fromString(const QString &descrip) { const auto sr = QStringView(descrip).trimmed(); - const auto l = sr.split(QLatin1Char(',')); - const int count = l.count(); + const auto l = sr.split(u','); + const int count = l.size(); if (!count || (count > 2 && count < 9) || count == 9 || count > 17 || l.first().isEmpty()) { qWarning("QFont::fromString: Invalid description '%s'", @@ -2263,6 +2261,404 @@ void QFont::cacheStatistics() { } +/*! + \class QFont::Tag + \brief The QFont::Tag type provides access to advanced font features. + \since 6.7 + \inmodule QtGui + + QFont provides access to advanced features when shaping text. A feature is defined + by a tag, which can be represented as a four-character string, or as a 32bit integer + value. This type represents such a tag in a type-safe way. It can be constructed from + a four-character, 8bit string literal, or from a corresponding 32bit integer value. + Using a shorter or longer string literal will result in a compile-time error. + + \code + QFont font; + // Correct + font.setFeature("frac"); + + // Wrong - won't compile + font.setFeature("fraction"); + + // Wrong - will produce runtime warning and fail + font.setFeature(u"fraction"_s); + \endcode + + The named constructors allow to create a tag from an 32bit integer or string value, + and will return a \c std::nullopt when the input is invalid. + + \sa QFont::setFeature(), QFont::featureTags() +*/ + +/*! + \fn QFont::Tag::Tag() + + Default constructor, producing an invalid tag. +*/ + +/*! + \fn template <size_t N> QFont::Tag::Tag(const char (&str)[N]) noexcept + + Constructs a tag from a string literal, \a str. The literal must be exactly four + characters long. + + \code + font.setFeature("frac", 1); + \endcode + + \sa fromString(), fromValue() +*/ + +/*! + \fn bool QFont::Tag::comparesEqual(const QFont::Tag &lhs, const QFont::Tag &rhs) noexcept + \fn Qt::strong_ordering QFont::Tag::compareThreeWay(const QFont::Tag &lhs, const QFont::Tag &rhs) noexcept + + Compare \a lhs with \a rhs for equality and ordering. +*/ + +/*! + \fn size_t QFont::Tag::qHash(QFont::Tag key, size_t seed) noexcept + + Returns the hash value for \a key, using \a seed to seed the calculation. +*/ + +/*! + \fn quint32 QFont::Tag::value() const noexcept + + Returns the numerical value of this tag. + + \sa isValid(), fromValue() +*/ + +/*! + \fn bool QFont::Tag::isValid() const noexcept + + Returns whether the tag is valid. A tag is valid if its value is not zero. + + \sa value(), fromValue(), fromString() +*/ + +/*! + \fn QByteArray QFont::Tag::toString() const noexcept + + Returns the string representation of this tag as a byte array. + + \sa fromString() +*/ + +/*! + \fn std::optional<QFont::Tag> QFont::Tag::fromValue(quint32 value) noexcept + + Returns a tag constructed from \a value, or \c std::nullopt if the tag produced + would be invalid. + + \sa isValid() +*/ + +/*! + Returns a tag constructed from the string in \a view. The string must be exactly + four characters long. + + Returns \c std::nullopt if the input is not four characters long, or if the tag + produced would be invalid. + + \sa isValid(), fromValue() +*/ +std::optional<QFont::Tag> QFont::Tag::fromString(QAnyStringView view) noexcept +{ + if (view.size() != 4) { + qWarning("The tag name must be exactly 4 characters long!"); + return std::nullopt; + } + const QFont::Tag maybeTag = view.visit([](auto view) { + using CharType = decltype(view.at(0)); + if constexpr (std::is_same_v<CharType, char>) { + const char bytes[5] = { view.at(0), view.at(1), view.at(2), view.at(3), 0 }; + return Tag(bytes); + } else { + const char bytes[5] = { view.at(0).toLatin1(), view.at(1).toLatin1(), + view.at(2).toLatin1(), view.at(3).toLatin1(), 0 }; + return Tag(bytes); + } + }); + return maybeTag.isValid() ? std::optional<Tag>(maybeTag) : std::nullopt; +} + +/*! + \fn QDataStream &operator<<(QDataStream &, QFont::Tag) + \fn QDataStream &operator>>(QDataStream &, QFont::Tag &) + \relates QFont::Tag + + Data stream operators for QFont::Tag. +*/ + +/*! + \since 6.7 + + Applies a \a value to the variable axis corresponding to \a tag. + + Variable fonts provide a way to store multiple variations (with different weights, widths + or styles) in the same font file. The variations are given as floating point values for + a pre-defined set of parameters, called "variable axes". Specific instances are typically + given names by the font designer, and, in Qt, these can be selected using setStyleName() + just like traditional sub-families. + + In some cases, it is also useful to provide arbitrary values for the different axes. For + instance, if a font has a Regular and Bold sub-family, you may want a weight in-between these. + You could then manually request this by supplying a custom value for the "wght" axis in the + font. + + \code + QFont font; + font.setVariableAxis("wght", (QFont::Normal + QFont::Bold) / 2.0f); + \endcode + + If the "wght" axis is supported by the font and the given value is within its defined range, + a font corresponding to the weight 550.0 will be provided. + + There are a few standard axes than many fonts provide, such as "wght" (weight), "wdth" (width), + "ital" (italic) and "opsz" (optical size). They each have indivdual ranges defined in the font + itself. For instance, "wght" may span from 100 to 900 (QFont::Thin to QFont::Black) whereas + "ital" can span from 0 to 1 (from not italic to fully italic). + + A font may also choose to define custom axes; the only limitation is that the name has to + meet the requirements for a QFont::Tag (sequence of four latin-1 characters.) + + By default, no variable axes are set. + + \note In order to use variable axes on Windows, the application has to run with either the + FreeType or DirectWrite font databases. See the documentation for + QGuiApplication::QGuiApplication() for more information on how to select these technologies. + + \sa unsetVariableAxis + */ +void QFont::setVariableAxis(Tag tag, float value) +{ + if (tag.isValid()) { + if (resolve_mask & QFont::VariableAxesResolved && d->hasVariableAxis(tag, value)) + return; + + detach(); + + d->setVariableAxis(tag, value); + resolve_mask |= QFont::VariableAxesResolved; + } +} + +/*! + \since 6.7 + + Unsets a previously set variable axis value given by \a tag. + + \note If no value has previously been given for this tag, the QFont will still consider its + variable axes as set when resolving against other QFont values. + + \sa setVariableAxis +*/ +void QFont::unsetVariableAxis(Tag tag) +{ + if (tag.isValid()) { + detach(); + + d->unsetVariableAxis(tag); + resolve_mask |= QFont::VariableAxesResolved; + } +} + +/*! + \since 6.7 + + Returns a list of tags for all variable axes currently set on this QFont. + + See \l{QFont::}{setVariableAxis()} for more details on variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), isVariableAxisSet(), clearVariableAxes() +*/ +QList<QFont::Tag> QFont::variableAxisTags() const +{ + return d->request.variableAxisValues.keys(); +} + +/*! + \since 6.7 + + Returns the value set for a specific variable axis \a tag. If the tag has not been set, 0.0 will + be returned instead. + + See \l{QFont::}{setVariableAxis()} for more details on variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), isVariableAxisSet(), clearVariableAxes() +*/ +float QFont::variableAxisValue(Tag tag) const +{ + return d->request.variableAxisValues.value(tag); +} + +/*! + \since 6.7 + + Returns true if a value for the variable axis given by \a tag has been set on the QFont, + otherwise returns false. + + See \l{QFont::}{setVariableAxis()} for more details on font variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), variableAxisValue(), clearVariableAxes() +*/ +bool QFont::isVariableAxisSet(Tag tag) const +{ + return d->request.variableAxisValues.contains(tag); +} + +/*! + \since 6.7 + + Clears any previously set variable axis values on the QFont. + + See \l{QFont::}{setVariableAxis()} for more details on variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), isVariableAxisSet(), variableAxisValue() +*/ +void QFont::clearVariableAxes() +{ + if (d->request.variableAxisValues.isEmpty()) + return; + + detach(); + d->request.variableAxisValues.clear(); +} + + +/*! + \since 6.7 + \overload + + Applies an integer value to the typographical feature specified by \a tag when shaping the + text. This provides advanced access to the font shaping process, and can be used to support + font features that are otherwise not covered in the API. + + The feature is specified by a \l{QFont::Tag}{tag}, which is typically encoded from the + four-character feature name in the font feature map. + + This integer \a value passed along with the tag in most cases represents a boolean value: A zero + value means the feature is disabled, and a non-zero value means it is enabled. For certain + font features, however, it may have other interpretations. For example, when applied to the + \c salt feature, the value is an index that specifies the stylistic alternative to use. + + For example, the \c frac font feature will convert diagonal fractions separated with a slash + (such as \c 1/2) with a different representation. Typically this will involve baking the full + fraction into a single character width (such as \c ½). + + If a font supports the \c frac feature, then it can be enabled in the shaper by setting + \c{features["frac"] = 1} in the font feature map. + + \note By default, Qt will enable and disable certain font features based on other font + properties. In particular, the \c kern feature will be enabled/disabled depending on the + \l kerning() property of the QFont. In addition, all ligature features + (\c liga, \c clig, \c dlig, \c hlig) will be disabled if a \l letterSpacing() is applied, + but only for writing systems where the use of ligature is cosmetic. For writing systems where + ligatures are required, the features will remain in their default state. The values set using + setFeature() and related functions will override the default behavior. If, for instance, + the feature "kern" is set to 1, then kerning will always be enabled, regardless of whether the + kerning property is set to false. Similarly, if it is set to 0, then it will always be disabled. + To reset a font feature to its default behavior, you can unset it using unsetFeature(). + + \sa QFont::Tag, clearFeatures(), setFeature(), unsetFeature(), featureTags() +*/ +void QFont::setFeature(Tag tag, quint32 value) +{ + if (tag.isValid()) { + d->detachButKeepEngineData(this); + d->setFeature(tag, value); + resolve_mask |= QFont::FeaturesResolved; + } +} + +/*! + \since 6.7 + \overload + + Unsets the \a tag from the map of explicitly enabled/disabled features. + + \note Even if the feature has not previously been added, this will mark the font features map + as modified in this QFont, so that it will take precedence when resolving against other fonts. + + Unsetting an existing feature on the QFont reverts behavior to the default. + + See \l setFeature() for more details on font features. + + \sa QFont::Tag, clearFeatures(), setFeature(), featureTags(), featureValue() +*/ +void QFont::unsetFeature(Tag tag) +{ + if (tag.isValid()) { + d->detachButKeepEngineData(this); + d->unsetFeature(tag); + resolve_mask |= QFont::FeaturesResolved; + } +} + +/*! + \since 6.7 + + Returns a list of tags for all font features currently set on this QFont. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), isFeatureSet(), clearFeatures() +*/ +QList<QFont::Tag> QFont::featureTags() const +{ + return d->features.keys(); +} + +/*! + \since 6.7 + + Returns the value set for a specific feature \a tag. If the tag has not been set, 0 will be + returned instead. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), featureTags(), isFeatureSet() +*/ +quint32 QFont::featureValue(Tag tag) const +{ + return d->features.value(tag); +} + +/*! + \since 6.7 + + Returns true if a value for the feature given by \a tag has been set on the QFont, otherwise + returns false. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), featureTags(), featureValue() +*/ +bool QFont::isFeatureSet(Tag tag) const +{ + return d->features.contains(tag); +} + +/*! + \since 6.7 + + Clears any previously set features on the QFont. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), featureTags(), featureValue() +*/ +void QFont::clearFeatures() +{ + if (d->features.isEmpty()) + return; + + d->detachButKeepEngineData(this); + d->features.clear(); +} extern QStringList qt_fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script); @@ -2342,9 +2738,9 @@ void QFont::setFamilies(const QStringList &families) QDataStream &operator<<(QDataStream &s, const QFont &font) { if (s.version() == 1) { - s << font.d->request.families.first().toLatin1(); + s << font.d->request.families.constFirst().toLatin1(); } else { - s << font.d->request.families.first(); + s << font.d->request.families.constFirst(); if (s.version() >= QDataStream::Qt_5_4) s << font.d->request.styleName; } @@ -2394,8 +2790,16 @@ QDataStream &operator<<(QDataStream &s, const QFont &font) 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) - s << font.d->request.families; + 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; + } + if (s.version() >= QDataStream::Qt_6_6) + s << font.d->features; + if (s.version() >= QDataStream::Qt_6_7) + s << font.d->request.variableAxisValues; return s; } @@ -2505,11 +2909,40 @@ QDataStream &operator>>(QDataStream &s, QFont &font) if (s.version() >= QDataStream::Qt_5_13) { QStringList value; s >> value; - font.d->request.families = value; + if (s.version() < QDataStream::Qt_6_0) + font.d->request.families.append(value); + else + font.d->request.families = value; } + if (s.version() >= QDataStream::Qt_6_6) { + font.d->features.clear(); + s >> font.d->features; + } + if (s.version() >= QDataStream::Qt_6_7) { + font.d->request.variableAxisValues.clear(); + s >> font.d->request.variableAxisValues; + } + return s; } +QDataStream &operator<<(QDataStream &stream, QFont::Tag tag) +{ + stream << tag.value(); + return stream; +} + +QDataStream &operator>>(QDataStream &stream, QFont::Tag &tag) +{ + quint32 value; + stream >> value; + if (const auto maybeTag = QFont::Tag::fromValue(value)) + tag = *maybeTag; + else + stream.setStatus(QDataStream::ReadCorruptData); + return stream; +} + #endif // QT_NO_DATASTREAM @@ -2560,6 +2993,35 @@ QDataStream &operator>>(QDataStream &s, QFont &font) info object is \e not updated. \endlist + \section1 Checking for the existence of a font + + Sometimes it can be useful to check if a font exists before attempting + to use it. The most thorough way of doing so is by using \l {exactMatch()}: + + \code + const QFont segoeFont(QLatin1String("Segoe UI")); + if (QFontInfo(segoeFont).exactMatch()) { + // Use the font... + } + \endcode + + However, this deep search of families can be expensive on some platforms. + \c QFontDatabase::families().contains() is a faster, but less thorough + alternative: + + \code + const QLatin1String segoeUiFamilyName("Segoe UI"); + if (QFontDatabase::families().contains(segoeUiFamilyName)) { + const QFont segoeFont(segoeUiFamilyName); + // Use the font... + } + \endcode + + It's less thorough because it's not a complete search: some font family + aliases may be missing from the list. However, this approach results in + faster application startup times, and so should always be preferred if + possible. + \sa QFont, QFontMetrics, QFontDatabase */ @@ -2576,6 +3038,8 @@ QDataStream &operator>>(QDataStream &s, QFont &font) Use QPainter::fontInfo() to get the font info when painting. This will give correct results also when painting on paint device that is not screen-compatible. + + \sa {Checking for the existence of a font} */ QFontInfo::QFontInfo(const QFont &font) : d(font.d) @@ -2617,13 +3081,13 @@ QFontInfo &QFontInfo::operator=(const QFontInfo &fi) /*! Returns the family name of the matched window system font. - \sa QFont::family() + \sa QFont::family(), {Checking for the existence of a font} */ 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(); + return engine->fontDef.families.isEmpty() ? QString() : engine->fontDef.families.constFirst(); } /*! @@ -2704,7 +3168,7 @@ QFont::Style QFontInfo::style() const #if QT_DEPRECATED_SINCE(6, 0) /*! - \obsolete Use weight() instead. + \deprecated Use weight() instead. Returns the weight of the font converted to the non-standard font weight scale used in Qt 5 and earlier versions. @@ -2799,7 +3263,7 @@ bool QFontInfo::fixedPitch() const Q_ASSERT(engine != nullptr); #ifdef Q_OS_MAC if (!engine->fontDef.fixedPitchComputed) { - QChar ch[2] = { QLatin1Char('i'), QLatin1Char('m') }; + QChar ch[2] = { u'i', u'm' }; QGlyphLayoutArray<2> g; int l = 2; if (!engine->stringToCMap(ch, 2, &g, &l, {})) @@ -2846,13 +3310,15 @@ bool QFontInfo::exactMatch() const // QFontCache // ********************************************************************** +using namespace std::chrono_literals; + #ifdef QFONTCACHE_DEBUG // fast timeouts for debugging -static const int fast_timeout = 1000; // 1s -static const int slow_timeout = 5000; // 5s +static constexpr auto fast_timeout = 1s; +static constexpr auto slow_timeout = 5s; #else -static const int fast_timeout = 10000; // 10s -static const int slow_timeout = 300000; // 5m +static constexpr auto fast_timeout = 10s; +static constexpr auto slow_timeout = 5min; #endif // QFONTCACHE_DEBUG #ifndef QFONTCACHE_MIN_COST @@ -2881,11 +3347,14 @@ void QFontCache::cleanup() cache->setLocalData(nullptr); } -static QBasicAtomicInt font_cache_id = Q_BASIC_ATOMIC_INITIALIZER(0); +Q_CONSTINIT 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), timer_id(-1), + current_timestamp(0), fast(false), + autoClean(QGuiApplication::instance() + && (QGuiApplication::instance()->thread() == QThread::currentThread())), + timer_id(-1), m_id(font_cache_id.fetchAndAddRelaxed(1) + 1) { } @@ -3055,10 +3524,14 @@ void QFontCache::increaseCost(uint 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); + FC_DEBUG(" TIMER: starting fast timer (%d s)", static_cast<int>(fast_timeout.count())); - if (timer_id != -1) killTimer(timer_id); + if (timer_id != -1) + killTimer(timer_id); timer_id = startTimer(fast_timeout); fast = true; } @@ -3149,22 +3622,26 @@ void QFontCache::decreaseCache() 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 (new_max_cost == max_cost) { - if (fast) { - FC_DEBUG(" cannot shrink cache, slowing timer"); + if (autoClean) { + if (new_max_cost == max_cost) { + if (fast) { + FC_DEBUG(" cannot shrink cache, slowing timer"); - killTimer(timer_id); - timer_id = startTimer(slow_timeout); - fast = false; - } + if (timer_id != -1) { + killTimer(timer_id); + timer_id = startTimer(slow_timeout); + fast = false; + } - return; - } else if (! fast) { - FC_DEBUG(" dropping into passing gear"); + return; + } else if (! fast) { + FC_DEBUG(" dropping into passing gear"); - killTimer(timer_id); - timer_id = startTimer(fast_timeout); - fast = true; + if (timer_id != -1) + killTimer(timer_id); + timer_id = startTimer(fast_timeout); + fast = true; } + } } max_cost = new_max_cost; @@ -3342,6 +3819,15 @@ QDebug operator<<(QDebug stream, const QFont &font) return stream; } + +QDebug operator<<(QDebug debug, QFont::Tag tag) +{ + QDebugStateSaver saver(debug); + debug.noquote() << tag.toString(); + return debug; +} #endif QT_END_NAMESPACE + +#include "moc_qfont.cpp" |