/****************************************************************************+
−
**+
−
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+
−
** All rights reserved.+
−
** Contact: Nokia Corporation (qt-info@nokia.com)+
−
**+
−
** This file is part of the QtGui module of the Qt Toolkit.+
−
**+
−
** $QT_BEGIN_LICENSE:LGPL$+
−
** No Commercial Usage+
−
** This file contains pre-release code and may not be distributed.+
−
** You may use this file in accordance with the terms and conditions+
−
** contained in the Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** GNU Lesser General Public License Usage+
−
** Alternatively, this file may be used under the terms of the GNU Lesser+
−
** General Public License version 2.1 as published by the Free Software+
−
** Foundation and appearing in the file LICENSE.LGPL included in the+
−
** packaging of this file.  Please review the following information to+
−
** ensure the GNU Lesser General Public License version 2.1 requirements+
−
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+
−
**+
−
** In addition, as a special exception, Nokia gives you certain additional+
−
** rights.  These rights are described in the Nokia Qt LGPL Exception+
−
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
+
−
#include "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 "qapplication.h"+
−
#include "qstringlist.h"+
−
+
−
#include "qthread.h"+
−
#include "qthreadstorage.h"+
−
+
−
#include <private/qunicodetables_p.h>+
−
#include "qfont_p.h"+
−
#include <private/qfontengine_p.h>+
−
#include <private/qpainter_p.h>+
−
#include <private/qtextengine_p.h>+
−
#include <limits.h>+
−
+
−
#ifdef Q_WS_X11+
−
#include "qx11info_x11.h"+
−
#include <private/qt_x11_p.h>+
−
#endif+
−
#ifdef Q_WS_QWS+
−
#include "qscreen_qws.h"+
−
#if !defined(QT_NO_QWS_QPF2)+
−
#include <qfile.h>+
−
#include "qfontengine_qpf_p.h"+
−
#endif+
−
#endif+
−
#ifdef Q_OS_SYMBIAN+
−
#include "qt_s60_p.h"+
−
#endif+
−
+
−
#include <QMutexLocker>+
−
+
−
// #define QFONTCACHE_DEBUG+
−
#ifdef QFONTCACHE_DEBUG+
−
#  define FC_DEBUG qDebug+
−
#else+
−
#  define FC_DEBUG if (false) qDebug+
−
#endif+
−
+
−
QT_BEGIN_NAMESPACE+
−
+
−
#ifdef Q_WS_WIN+
−
extern HDC shared_dc();+
−
#endif+
−
+
−
#ifdef Q_WS_X11+
−
extern const QX11Info *qt_x11Info(const QPaintDevice *pd);+
−
#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;+
−
    QFontDatabase::parseFontName(family, this_foundry, this_family);+
−
    QFontDatabase::parseFontName(other.family, other_foundry, other_family);+
−
+
−
    return (styleHint     == other.styleHint+
−
            && styleStrategy == other.styleStrategy+
−
            && weight        == other.weight+
−
            && style        == other.style+
−
            && this_family   == other_family+
−
            && (this_foundry.isEmpty()+
−
                || other_foundry.isEmpty()+
−
                || this_foundry == other_foundry)+
−
#ifdef Q_WS_X11+
−
            && addStyle == other.addStyle+
−
#endif // Q_WS_X11+
−
       );+
−
}+
−
+
−
extern bool qt_is_gui_used;+
−
+
−
Q_GUI_EXPORT int qt_defaultDpiX()+
−
{+
−
    if (!qt_is_gui_used)+
−
        return 75;+
−
+
−
    int dpi;+
−
#ifdef Q_WS_X11+
−
    dpi = QX11Info::appDpiX();+
−
#elif defined(Q_WS_WIN)+
−
    dpi = GetDeviceCaps(shared_dc(),LOGPIXELSX);+
−
#elif defined(Q_WS_MAC)+
−
    extern float qt_mac_defaultDpi_x(); //qpaintdevice_mac.cpp+
−
    dpi = qt_mac_defaultDpi_x();+
−
#elif defined(Q_WS_QWS)+
−
    if (!qt_screen)+
−
        return 72;+
−
    QScreen *screen = qt_screen;+
−
    const QList<QScreen*> subScreens = qt_screen->subScreens();+
−
    if (!subScreens.isEmpty())+
−
        screen = subScreens.at(0);+
−
    dpi = qRound(screen->width() / (screen->physicalWidth() / qreal(25.4)));+
−
#elif defined(Q_OS_SYMBIAN)+
−
    dpi = S60->defaultDpiX;+
−
#endif // Q_WS_X11+
−
+
−
    return dpi;+
−
}+
−
+
−
Q_GUI_EXPORT int qt_defaultDpiY()+
−
{+
−
    if (!qt_is_gui_used)+
−
        return 75;+
−
+
−
    int dpi;+
−
#ifdef Q_WS_X11+
−
    dpi = QX11Info::appDpiY();+
−
#elif defined(Q_WS_WIN)+
−
    dpi = GetDeviceCaps(shared_dc(),LOGPIXELSY);+
−
#elif defined(Q_WS_MAC)+
−
    extern float qt_mac_defaultDpi_y(); //qpaintdevice_mac.cpp+
−
    dpi = qt_mac_defaultDpi_y();+
−
#elif defined(Q_WS_QWS)+
−
    if (!qt_screen)+
−
        return 72;+
−
    QScreen *screen = qt_screen;+
−
    const QList<QScreen*> subScreens = qt_screen->subScreens();+
−
    if (!subScreens.isEmpty())+
−
        screen = subScreens.at(0);+
−
    dpi = qRound(screen->height() / (screen->physicalHeight() / qreal(25.4)));+
−
#elif defined(Q_OS_SYMBIAN)+
−
    dpi = S60->defaultDpiY;+
−
#endif // Q_WS_X11+
−
+
−
    return dpi;+
−
}+
−
+
−
Q_GUI_EXPORT int qt_defaultDpi()+
−
{+
−
    return qt_defaultDpiY();+
−
}+
−
+
−
QFontPrivate::QFontPrivate()+
−
    : engineData(0), dpi(qt_defaultDpi()), screen(0),+
−
      rawMode(false), underline(false), overline(false), strikeOut(false), kerning(true),+
−
      capital(0), letterSpacingIsAbsolute(false), scFont(0)+
−
{+
−
#ifdef Q_WS_X11+
−
    if (QX11Info::display())+
−
        screen = QX11Info::appScreen();+
−
    else+
−
        screen = 0;+
−
#endif+
−
#ifdef Q_WS_WIN+
−
    hdc = 0;+
−
#endif+
−
}+
−
+
−
QFontPrivate::QFontPrivate(const QFontPrivate &other)+
−
    : request(other.request), engineData(0), dpi(other.dpi), screen(other.screen),+
−
      rawMode(other.rawMode), 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)+
−
{+
−
#ifdef Q_WS_WIN+
−
    hdc = other.hdc;+
−
#endif+
−
    if (scFont && scFont != this)+
−
        scFont->ref.ref();+
−
}+
−
+
−
QFontPrivate::~QFontPrivate()+
−
{+
−
    if (engineData)+
−
        engineData->ref.deref();+
−
    engineData = 0;+
−
    if (scFont && scFont != this)+
−
        scFont->ref.deref();+
−
    scFont = 0;+
−
}+
−
+
−
#if !defined(Q_WS_MAC)+
−
extern QMutex *qt_fontdatabase_mutex();+
−
+
−
QFontEngine *QFontPrivate::engineForScript(int script) const+
−
{+
−
    QMutexLocker locker(qt_fontdatabase_mutex());+
−
    if (script >= QUnicodeTables::Inherited)+
−
        script = QUnicodeTables::Common;+
−
    if (engineData && engineData->fontCache != QFontCache::instance()) {+
−
        // throw out engineData that came from a different thread+
−
        engineData->ref.deref();+
−
        engineData = 0;+
−
    }+
−
    if (!engineData || !engineData->engines[script])+
−
        QFontDatabase::load(this, script);+
−
    return engineData->engines[script];+
−
}+
−
#else+
−
QFontEngine *QFontPrivate::engineForScript(int script) const+
−
{+
−
    extern QMutex *qt_fontdatabase_mutex();+
−
    QMutexLocker locker(qt_fontdatabase_mutex());+
−
    if (script >= QUnicodeTables::Inherited)+
−
        script = QUnicodeTables::Common;+
−
    if (engineData && engineData->fontCache != QFontCache::instance()) {+
−
        // throw out engineData that came from a different thread+
−
        engineData->ref.deref();+
−
        engineData = 0;+
−
    }+
−
    if (!engineData || !engineData->engine)+
−
        QFontDatabase::load(this, script);+
−
    return engineData->engine;+
−
}+
−
#endif+
−
+
−
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 != 0);+
−
+
−
    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::FamilyResolved))+
−
        request.family = other->request.family;+
−
+
−
    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::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(1), fontCache(QFontCache::instance())+
−
{+
−
#if !defined(Q_WS_MAC)+
−
    memset(engines, 0, QUnicodeTables::ScriptCount * sizeof(QFontEngine *));+
−
#else+
−
    engine = 0;+
−
#endif+
−
}+
−
+
−
QFontEngineData::~QFontEngineData()+
−
{+
−
#if !defined(Q_WS_MAC)+
−
    for (int i = 0; i < QUnicodeTables::ScriptCount; ++i) {+
−
        if (engines[i])+
−
            engines[i]->ref.deref();+
−
        engines[i] = 0;+
−
    }+
−
#else+
−
    if (engine)+
−
        engine->ref.deref();+
−
    engine = 0;+
−
#endif // Q_WS_X11 || Q_WS_WIN || Q_WS_MAC+
−
}+
−
+
−
+
−
+
−
+
−
/*!+
−
    \class QFont+
−
    \reentrant+
−
+
−
    \brief The QFont class specifies a font used for drawing text.+
−
+
−
    \ingroup painting+
−
    \ingroup appearance+
−
    \ingroup shared+
−
    \ingroup richtext-processing+
−
+
−
+
−
    When you create a QFont object you specify various attributes that+
−
    you want the font to have. Qt will use the font with the specified+
−
    attributes, or if no matching font exists, Qt will use the closest+
−
    matching installed font. The attributes of the font that is+
−
    actually used are retrievable from a QFontInfo object. If the+
−
    window system provides an exact match exactMatch() returns true.+
−
    Use QFontMetrics to get measurements, e.g. the pixel length of a+
−
    string using QFontMetrics::width().+
−
+
−
    Note that a QApplication instance must exist before a QFont can be+
−
    used. You can set the application's default font with+
−
    QApplication::setFont().+
−
+
−
    If a chosen font does not include all the characters that+
−
    need to be displayed, QFont will try to find the characters in the+
−
    nearest equivalent fonts. When a QPainter draws a character from a+
−
    font the QFont will report whether or not it has the character; if+
−
    it does not, QPainter will draw an unfilled square.+
−
+
−
    Create QFonts like this:+
−
+
−
    \snippet doc/src/snippets/code/src_gui_text_qfont.cpp 0+
−
+
−
    The attributes set in the constructor can also be set later, e.g.+
−
    setFamily(), setPointSize(), setPointSizeFloat(), setWeight() and+
−
    setItalic(). The remaining attributes must be set after+
−
    contstruction, 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+
−
    attributes. The corresponding "get" functions, e.g. family(),+
−
    pointSize(), etc., return the values that were set, even though+
−
    the values used may differ. The actual values are available from a+
−
    QFontInfo object.+
−
+
−
    If the requested font family is unavailable you can influence the+
−
    \link #fontmatching font matching algorithm\endlink by choosing a+
−
    particular \l{QFont::StyleHint} and \l{QFont::StyleStrategy} with+
−
    setStyleHint(). The default family (corresponding to the current+
−
    style hint) is returned by defaultFamily().+
−
+
−
    The font-matching algorithm has a lastResortFamily() and+
−
    lastResortFont() in cases where a suitable match cannot be found.+
−
    You can provide substitutions for font family names using+
−
    insertSubstitution() and insertSubstitutions(). Substitutions can+
−
    be removed with removeSubstitution(). Use substitute() to retrieve+
−
    a family's first substitute, or the family name itself if it has+
−
    no substitutes. Use substitutes() to retrieve a list of a family's+
−
    substitutes (which may be empty).+
−
+
−
    Every QFont has a key() which you can use, for example, as the key+
−
    in a cache or dictionary. If you want to store a user's font+
−
    preferences you could use QSettings, writing the font information+
−
    with toString() and reading it back with fromString(). The+
−
    operator<<() and operator>>() functions are also available, but+
−
    they work on a data stream.+
−
+
−
    It is possible to set the height of characters shown on the screen+
−
    to a specified number of pixels with setPixelSize(); however using+
−
    setPointSize() has a similar effect and provides device+
−
    independence.+
−
+
−
    In X11 you can set a font using its system+
−
    specific name with setRawName().+
−
+
−
    Loading fonts can be expensive, especially on X11. QFont contains+
−
    extensive optimizations to make the copying of QFont objects fast,+
−
    and to cache the results of the slow window system functions it+
−
    depends upon.+
−
+
−
    \target fontmatching+
−
    The font matching algorithm works as follows:+
−
    \list 1+
−
    \o The specified font family is searched for.+
−
    \o If not found, the styleHint() is used to select a replacement+
−
       family.+
−
    \o Each replacement font family is searched for.+
−
    \o If none of these are found or there was no styleHint(), "helvetica"+
−
       will be searched for.+
−
    \o If "helvetica" isn't found Qt will try the lastResortFamily().+
−
    \o If the lastResortFamily() isn't found Qt will try the+
−
       lastResortFont() which will always return a name of some kind.+
−
    \endlist+
−
+
−
    Note that the actual font matching algorithm varies from platform to platform.+
−
+
−
    In Windows a request for the "Courier" font is automatically changed to+
−
    "Courier New", an improved version of Courier that allows for smooth scaling.+
−
    The older "Courier" bitmap font can be selected by setting the PreferBitmap+
−
    style strategy (see setStyleStrategy()).+
−
+
−
    Once a font is found, the remaining attributes are matched in order of+
−
    priority:+
−
    \list 1+
−
    \o fixedPitch()+
−
    \o pointSize() (see below)+
−
    \o weight()+
−
    \o style()+
−
    \endlist+
−
+
−
    If you have a font which matches on family, even if none of the+
−
    other attributes match, this font will be chosen in preference to+
−
    a font which doesn't match on family but which does match on the+
−
    other attributes. This is because font family is the dominant+
−
    search criteria.+
−
+
−
    The point size is defined to match if it is within 20% of the+
−
    requested point size. When several fonts match and are only+
−
    distinguished by point size, the font with the closest point size+
−
    to the one requested will be chosen.+
−
+
−
    The actual family, font size, weight and other font attributes+
−
    used for drawing text will depend on what's available for the+
−
    chosen family under the window system. A QFontInfo object can be+
−
    used to determine the actual values used for drawing the text.+
−
+
−
    Examples:+
−
+
−
    \snippet doc/src/snippets/code/src_gui_text_qfont.cpp 1+
−
    If you had both an Adobe and a Cronyx Helvetica, you might get+
−
    either.+
−
+
−
    \snippet doc/src/snippets/code/src_gui_text_qfont.cpp 2+
−
+
−
    You can specify the foundry you want in the family name. The font f+
−
    in the above example will be set to "Helvetica+
−
    [Cronyx]".+
−
+
−
    To determine the attributes of the font actually used in the window+
−
    system, use a QFontInfo object, e.g.+
−
+
−
    \snippet doc/src/snippets/code/src_gui_text_qfont.cpp 3+
−
+
−
    To find out font metrics use a QFontMetrics object, e.g.+
−
+
−
    \snippet doc/src/snippets/code/src_gui_text_qfont.cpp 4+
−
+
−
    For more general information on fonts, see the+
−
    \link http://nwalsh.com/comp.fonts/FAQ/ comp.fonts FAQ.\endlink+
−
    Information on encodings can be found from+
−
    \link http://czyborra.com/ Roman Czyborra's\endlink page.+
−
+
−
    \sa QFontComboBox, QFontMetrics, QFontInfo, QFontDatabase, {Character Map Example}+
−
*/+
−
+
−
/*!+
−
    \internal+
−
    \enum QFont::ResolveProperties+
−
+
−
    This enum describes the properties of a QFont that can be set on a font+
−
    individually and then considered resolved.+
−
+
−
    \value FamilyResolved+
−
    \value SizeResolved+
−
    \value StyleHintResolved+
−
    \value StyleStrategyResolved+
−
    \value WeightResolved+
−
    \value StyleResolved+
−
    \value UnderlineResolved+
−
    \value OverlineResolved+
−
    \value StrikeOutResolved+
−
    \value FixedPitchResolved+
−
    \value StretchResolved+
−
    \value KerningResolved+
−
    \value CapitalizationResolved+
−
    \value LetterSpacingResolved+
−
    \value WordSpacingResolved+
−
    \value CompletelyResolved+
−
*/+
−
+
−
/*!+
−
    \enum QFont::Style+
−
+
−
    This enum describes the different styles of glyphs that are used to+
−
    display text.+
−
+
−
    \value StyleNormal  Normal glyphs used in unstyled text.+
−
    \value StyleItalic  Italic glyphs that are specifically designed for+
−
                        the purpose of representing italicized text.+
−
    \value StyleOblique Glyphs with an italic appearance that are typically+
−
                        based on the unstyled glyphs, but are not fine-tuned+
−
                        for the purpose of representing italicized text.+
−
+
−
    \sa Weight+
−
*/+
−
+
−
/*!+
−
    \fn Qt::HANDLE QFont::handle() const+
−
+
−
    Returns the window system handle to the font, for low-level+
−
    access. Using this function is \e not portable.+
−
*/+
−
+
−
/*!+
−
    \fn FT_Face QFont::freetypeFace() const+
−
+
−
    Returns the handle to the primary FreeType face of the font. If font merging is not disabled a+
−
    QFont can contain several physical fonts.+
−
+
−
    Returns 0 if the font does not contain a FreeType face.+
−
+
−
    \note This function is only available on platforms that provide the FreeType library;+
−
    i.e., X11 and some Embedded Linux platforms.+
−
*/+
−
+
−
/*!+
−
    \fn QString QFont::rawName() const+
−
+
−
    Returns the name of the font within the underlying window system.+
−
+
−
    On X11, this function will return an empty string if Qt is built with+
−
    FontConfig support; otherwise the XLFD (X Logical Font Description) is+
−
    returned.+
−
+
−
    Using the return value of this function is usually \e not \e+
−
    portable.+
−
+
−
    \sa setRawName()+
−
*/+
−
+
−
/*!+
−
    \fn void QFont::setRawName(const QString &name)+
−
+
−
    Sets a font by its system specific name. The function is+
−
    particularly useful under X, where system font settings (for+
−
    example X resources) are usually available in XLFD (X Logical Font+
−
    Description) form only. You can pass an XLFD as \a name to this+
−
    function.+
−
+
−
    A font set with setRawName() is still a full-featured QFont. It can+
−
    be queried (for example with italic()) or modified (for example with+
−
    setItalic()) and is therefore also suitable for rendering rich text.+
−
+
−
    If Qt's internal font database cannot resolve the raw name, the+
−
    font becomes a raw font with \a name as its family.+
−
+
−
    Note that the present implementation does not handle wildcards in+
−
    XLFDs well, and that font aliases (file \c fonts.alias in the font+
−
    directory on X11) are not supported.+
−
+
−
    \sa rawName(), setRawMode(), setFamily()+
−
*/+
−
+
−
/*!+
−
    \fn QString QFont::lastResortFamily() const+
−
+
−
    Returns the "last resort" font family name.+
−
+
−
    The current implementation tries a wide variety of common fonts,+
−
    returning the first one it finds. Is is possible that no family is+
−
    found in which case an empty string is returned.+
−
+
−
    \sa lastResortFont()+
−
*/+
−
+
−
/*!+
−
    \fn QString QFont::defaultFamily() const+
−
+
−
    Returns the family name that corresponds to the current style+
−
    hint.+
−
+
−
    \sa StyleHint styleHint() setStyleHint()+
−
*/+
−
+
−
/*!+
−
    \fn QString QFont::lastResortFont() const+
−
+
−
    Returns a "last resort" font name for the font matching algorithm.+
−
    This is used if the last resort family is not available. It will+
−
    always return a name, if necessary returning something like+
−
    "fixed" or "system".+
−
+
−
    The current implementation tries a wide variety of common fonts,+
−
    returning the first one it finds. The implementation may change+
−
    at any time, but this function will always return a string+
−
    containing something.+
−
+
−
    It is theoretically possible that there really isn't a+
−
    lastResortFont() in which case Qt will abort with an error+
−
    message. We have not been able to identify a case where this+
−
    happens. Please \link bughowto.html report it as a bug\endlink if+
−
    it does, preferably with a list of the fonts you have installed.+
−
+
−
    \sa lastResortFamily() rawName()+
−
*/+
−
+
−
/*!+
−
  Constructs a font from \a font for use on the paint device \a pd.+
−
*/+
−
QFont::QFont(const QFont &font, QPaintDevice *pd)+
−
    : resolve_mask(font.resolve_mask)+
−
{+
−
    Q_ASSERT(pd != 0);+
−
    int dpi = pd->logicalDpiY();+
−
#ifdef Q_WS_X11+
−
    const QX11Info *info = qt_x11Info(pd);+
−
    int screen = info ? info->screen() : 0;+
−
#else+
−
    const int screen = 0;+
−
#endif+
−
    if (font.d->dpi != dpi || font.d->screen != screen ) {+
−
        d = new QFontPrivate(*font.d);+
−
        d->dpi = dpi;+
−
        d->screen = screen;+
−
    } else {+
−
        d = font.d.data();+
−
    }+
−
#ifdef Q_WS_WIN+
−
    if (pd->devType() == QInternal::Printer && pd->getDC())+
−
        d->hdc = pd->getDC();+
−
#endif+
−
}+
−
+
−
/*!+
−
  \internal+
−
*/+
−
QFont::QFont(QFontPrivate *data)+
−
    : d(data), resolve_mask(QFont::AllPropertiesResolved)+
−
{+
−
}+
−
+
−
/*! \internal+
−
    Detaches the font object from common font data.+
−
*/+
−
void QFont::detach()+
−
{+
−
    if (d->ref == 1) {+
−
        if (d->engineData)+
−
            d->engineData->ref.deref();+
−
        d->engineData = 0;+
−
        if (d->scFont && d->scFont != d.data())+
−
            d->scFont->ref.deref();+
−
        d->scFont = 0;+
−
        return;+
−
    }+
−
+
−
    d.detach();+
−
}+
−
+
−
/*!+
−
    Constructs a font object that uses the application's default font.+
−
+
−
    \sa QApplication::setFont(), QApplication::font()+
−
*/+
−
QFont::QFont()+
−
    : d(QApplication::font().d.data()), resolve_mask(0)+
−
{+
−
}+
−
+
−
/*!+
−
    Constructs a font object with the specified \a family, \a+
−
    pointSize, \a weight and \a italic settings.+
−
+
−
    If \a pointSize is zero or negative, the point size of the font+
−
    is set to a system-dependent default value. Generally, this is+
−
    12 points, except on Symbian where it is 7 points.+
−
+
−
    The \a family name may optionally also include a foundry name,+
−
    e.g. "Helvetica [Cronyx]". If the \a family is+
−
    available from more than one foundry and the foundry isn't+
−
    specified, an arbitrary foundry is chosen. If the family isn't+
−
    available a family will be set using the \l{QFont}{font matching}+
−
    algorithm.+
−
+
−
    \sa Weight, setFamily(), setPointSize(), setWeight(), setItalic(),+
−
    setStyleHint() QApplication::font()+
−
*/+
−
QFont::QFont(const QString &family, int pointSize, int weight, bool italic)+
−
    : d(new QFontPrivate()), resolve_mask(QFont::FamilyResolved)+
−
{+
−
    if (pointSize <= 0) {+
−
#ifdef Q_OS_SYMBIAN+
−
        pointSize = 7;+
−
#else+
−
        pointSize = 12;+
−
#endif+
−
    } else {+
−
        resolve_mask |= QFont::SizeResolved;+
−
    }+
−
+
−
    if (weight < 0) {+
−
        weight = Normal;+
−
    } else {+
−
        resolve_mask |= QFont::WeightResolved | QFont::StyleResolved;+
−
    }+
−
+
−
    d->request.family = family;+
−
    d->request.pointSize = qreal(pointSize);+
−
    d->request.pixelSize = -1;+
−
    d->request.weight = weight;+
−
    d->request.style = italic ? QFont::StyleItalic : QFont::StyleNormal;+
−
}+
−
+
−
/*!+
−
    Constructs a font that is a copy of \a font.+
−
*/+
−
QFont::QFont(const QFont &font)+
−
    : d(font.d.data()), resolve_mask(font.resolve_mask)+
−
{+
−
}+
−
+
−
/*!+
−
    Destroys the font object and frees all allocated resources.+
−
*/+
−
QFont::~QFont()+
−
{+
−
}+
−
+
−
/*!+
−
    Assigns \a font to this font and returns a reference to it.+
−
*/+
−
QFont &QFont::operator=(const QFont &font)+
−
{+
−
    d = font.d.data();+
−
    resolve_mask = font.resolve_mask;+
−
    return *this;+
−
}+
−
+
−
/*!+
−
    Returns the requested font family name, i.e. the name set in the+
−
    constructor or the last setFont() call.+
−
+
−
    \sa setFamily() substitutes() substitute()+
−
*/+
−
QString QFont::family() const+
−
{+
−
    return d->request.family;+
−
}+
−
+
−
/*!+
−
    Sets the family name of the font. The name is case insensitive and+
−
    may include a foundry name.+
−
+
−
    The \a family name may optionally also include a foundry name,+
−
    e.g. "Helvetica [Cronyx]". If the \a family is+
−
    available from more than one foundry and the foundry isn't+
−
    specified, an arbitrary foundry is chosen. If the family isn't+
−
    available a family will be set using the \l{QFont}{font matching}+
−
    algorithm.+
−
+
−
    \sa family(), setStyleHint(), QFontInfo+
−
*/+
−
void QFont::setFamily(const QString &family)+
−
{+
−
    detach();+
−
+
−
    d->request.family = family;+
−
#if defined(Q_WS_X11)+
−
    d->request.addStyle.clear();+
−
#endif // Q_WS_X11+
−
+
−
    resolve_mask |= QFont::FamilyResolved;+
−
}+
−
+
−
/*!+
−
    Returns the point size of the font. Returns -1 if the font size+
−
    was specified in pixels.+
−
+
−
    \sa setPointSize() pointSizeF()+
−
*/+
−
int QFont::pointSize() const+
−
{+
−
    return qRound(d->request.pointSize);+
−
}+
−
+
−
/*!+
−
    Sets the point size to \a pointSize. The point size must be+
−
    greater than zero.+
−
+
−
    \sa pointSize() setPointSizeF()+
−
*/+
−
void QFont::setPointSize(int pointSize)+
−
{+
−
    if (pointSize <= 0) {+
−
        qWarning("QFont::setPointSize: Point size <= 0 (%d), must be greater than 0", pointSize);+
−
        return;+
−
    }+
−
+
−
    detach();+
−
+
−
    d->request.pointSize = qreal(pointSize);+
−
    d->request.pixelSize = -1;+
−
+
−
    resolve_mask |= QFont::SizeResolved;+
−
}+
−
+
−
/*!+
−
    Sets the point size to \a pointSize. The point size must be+
−
    greater than zero. The requested precision may not be achieved on+
−
    all platforms.+
−
+
−
    \sa pointSizeF() setPointSize() setPixelSize()+
−
*/+
−
void QFont::setPointSizeF(qreal pointSize)+
−
{+
−
    if (pointSize <= 0) {+
−
        qWarning("QFont::setPointSizeF: Point size <= 0 (%f), must be greater than 0", pointSize);+
−
        return;+
−
    }+
−
+
−
    detach();+
−
+
−
    d->request.pointSize = pointSize;+
−
    d->request.pixelSize = -1;+
−
+
−
    resolve_mask |= QFont::SizeResolved;+
−
}+
−
+
−
/*!+
−
    Returns the point size of the font. Returns -1 if the font size was+
−
    specified in pixels.+
−
+
−
    \sa pointSize() setPointSizeF() pixelSize() QFontInfo::pointSize() QFontInfo::pixelSize()+
−
*/+
−
qreal QFont::pointSizeF() const+
−
{+
−
    return d->request.pointSize;+
−
}+
−
+
−
/*!+
−
    Sets the font size to \a pixelSize pixels.+
−
+
−
    Using this function makes the font device dependent. Use+
−
    setPointSize() or setPointSizeF() to set the size of the font+
−
    in a device independent manner.+
−
+
−
    \sa pixelSize()+
−
*/+
−
void QFont::setPixelSize(int pixelSize)+
−
{+
−
    if (pixelSize <= 0) {+
−
        qWarning("QFont::setPixelSize: Pixel size <= 0 (%d)", pixelSize);+
−
        return;+
−
    }+
−
+
−
    detach();+
−
+
−
    d->request.pixelSize = pixelSize;+
−
    d->request.pointSize = -1;+
−
+
−
    resolve_mask |= QFont::SizeResolved;+
−
}+
−
+
−
/*!+
−
    Returns the pixel size of the font if it was set with+
−
    setPixelSize(). Returns -1 if the size was set with setPointSize()+
−
    or setPointSizeF().+
−
+
−
    \sa setPixelSize() pointSize() QFontInfo::pointSize() QFontInfo::pixelSize()+
−
*/+
−
int QFont::pixelSize() const+
−
{+
−
    return d->request.pixelSize;+
−
}+
−
+
−
#ifdef QT3_SUPPORT+
−
/*! \obsolete+
−
+
−
  Sets the logical pixel height of font characters when shown on+
−
  the screen to \a pixelSize.+
−
*/+
−
void QFont::setPixelSizeFloat(qreal pixelSize)+
−
{+
−
    setPixelSize((int)pixelSize);+
−
}+
−
#endif+
−
+
−
/*!+
−
  \fn bool QFont::italic() const+
−
+
−
    Returns true if the style() of the font is not QFont::StyleNormal+
−
+
−
    \sa setItalic() style()+
−
*/+
−
+
−
/*!+
−
  \fn void QFont::setItalic(bool enable)+
−
+
−
  Sets the style() of the font to QFont::StyleItalic if \a enable is true;+
−
  otherwise the style is set to QFont::StyleNormal.+
−
+
−
  \sa italic() QFontInfo+
−
*/+
−
+
−
/*!+
−
    Returns the style of the font.+
−
+
−
    \sa setStyle()+
−
*/+
−
QFont::Style QFont::style() const+
−
{+
−
    return (QFont::Style)d->request.style;+
−
}+
−
+
−
+
−
/*!+
−
  Sets the style of the font to \a style.+
−
+
−
  \sa italic(), QFontInfo+
−
*/+
−
void QFont::setStyle(Style style)+
−
{+
−
    detach();+
−
+
−
    d->request.style = style;+
−
    resolve_mask |= QFont::StyleResolved;+
−
}+
−
+
−
/*!+
−
    Returns the weight of the font which is one of the enumerated+
−
    values from \l{QFont::Weight}.+
−
+
−
    \sa setWeight(), Weight, QFontInfo+
−
*/+
−
int QFont::weight() const+
−
{+
−
    return d->request.weight;+
−
}+
−
+
−
/*!+
−
    \enum QFont::Weight+
−
+
−
    Qt uses a weighting scale from 0 to 99 similar to, but not the+
−
    same as, the scales used in Windows or CSS. A weight of 0 is+
−
    ultralight, whilst 99 will be an extremely black.+
−
+
−
    This enum contains the predefined font weights:+
−
+
−
    \value Light 25+
−
    \value Normal 50+
−
    \value DemiBold 63+
−
    \value Bold 75+
−
    \value Black 87+
−
*/+
−
+
−
/*!+
−
    Sets the weight the font to \a weight, which should be a value+
−
    from the \l QFont::Weight enumeration.+
−
+
−
    \sa weight(), QFontInfo+
−
*/+
−
void QFont::setWeight(int weight)+
−
{+
−
    Q_ASSERT_X(weight >= 0 && weight <= 99, "QFont::setWeight", "Weight must be between 0 and 99");+
−
+
−
    detach();+
−
+
−
    d->request.weight = weight;+
−
    resolve_mask |= QFont::WeightResolved;+
−
}+
−
+
−
/*!+
−
    \fn bool QFont::bold() const+
−
+
−
    Returns true if weight() is a value greater than \link Weight+
−
    QFont::Normal \endlink; otherwise returns false.+
−
+
−
    \sa weight(), setBold(), QFontInfo::bold()+
−
*/+
−
+
−
/*!+
−
    \fn void QFont::setBold(bool enable)+
−
+
−
    If \a enable is true sets the font's weight to \link Weight+
−
    QFont::Bold \endlink; otherwise sets the weight to \link Weight+
−
    QFont::Normal\endlink.+
−
+
−
    For finer boldness control use setWeight().+
−
+
−
    \sa bold(), setWeight()+
−
*/+
−
+
−
/*!+
−
    Returns true if underline has been set; otherwise returns false.+
−
+
−
    \sa setUnderline()+
−
*/+
−
bool QFont::underline() const+
−
{+
−
    return d->underline;+
−
}+
−
+
−
/*!+
−
    If \a enable is true, sets underline on; otherwise sets underline+
−
    off.+
−
+
−
    \sa underline(), QFontInfo+
−
*/+
−
void QFont::setUnderline(bool enable)+
−
{+
−
    detach();+
−
+
−
    d->underline = enable;+
−
    resolve_mask |= QFont::UnderlineResolved;+
−
}+
−
+
−
/*!+
−
    Returns true if overline has been set; otherwise returns false.+
−
+
−
    \sa setOverline()+
−
*/+
−
bool QFont::overline() const+
−
{+
−
    return d->overline;+
−
}+
−
+
−
/*!+
−
  If \a enable is true, sets overline on; otherwise sets overline off.+
−
+
−
  \sa overline(), QFontInfo+
−
*/+
−
void QFont::setOverline(bool enable)+
−
{+
−
    detach();+
−
+
−
    d->overline = enable;+
−
    resolve_mask |= QFont::OverlineResolved;+
−
}+
−
+
−
/*!+
−
    Returns true if strikeout has been set; otherwise returns false.+
−
+
−
    \sa setStrikeOut()+
−
*/+
−
bool QFont::strikeOut() const+
−
{+
−
    return d->strikeOut;+
−
}+
−
+
−
/*!+
−
    If \a enable is true, sets strikeout on; otherwise sets strikeout+
−
    off.+
−
+
−
    \sa strikeOut(), QFontInfo+
−
*/+
−
void QFont::setStrikeOut(bool enable)+
−
{+
−
    detach();+
−
+
−
    d->strikeOut = enable;+
−
    resolve_mask |= QFont::StrikeOutResolved;+
−
}+
−
+
−
/*!+
−
    Returns true if fixed pitch has been set; otherwise returns false.+
−
+
−
    \sa setFixedPitch(), QFontInfo::fixedPitch()+
−
*/+
−
bool QFont::fixedPitch() const+
−
{+
−
    return d->request.fixedPitch;+
−
}+
−
+
−
/*!+
−
    If \a enable is true, sets fixed pitch on; otherwise sets fixed+
−
    pitch off.+
−
+
−
    \sa fixedPitch(), QFontInfo+
−
*/+
−
void QFont::setFixedPitch(bool enable)+
−
{+
−
    detach();+
−
+
−
    d->request.fixedPitch = enable;+
−
    d->request.ignorePitch = false;+
−
    resolve_mask |= QFont::FixedPitchResolved;+
−
}+
−
+
−
/*!+
−
  Returns true if kerning should be used when drawing text with this font.+
−
+
−
  \sa setKerning()+
−
*/+
−
bool QFont::kerning() const+
−
{+
−
    return d->kerning;+
−
}+
−
+
−
/*!+
−
    Enables kerning for this font if \a enable is true; otherwise+
−
    disables it. By default, kerning is enabled.+
−
+
−
    When kerning is enabled, glyph metrics do not add up anymore,+
−
    even for Latin text. In other words, the assumption that+
−
    width('a') + width('b') is equal to width("ab") is not+
−
    neccesairly true.+
−
+
−
    \sa kerning(), QFontMetrics+
−
*/+
−
void QFont::setKerning(bool enable)+
−
{+
−
    detach();+
−
    d->kerning = enable;+
−
    resolve_mask |= QFont::KerningResolved;+
−
}+
−
+
−
/*!+
−
    Returns the StyleStrategy.+
−
+
−
    The style strategy affects the \l{QFont}{font matching} algorithm.+
−
    See \l QFont::StyleStrategy for the list of available strategies.+
−
+
−
    \sa setStyleHint() QFont::StyleHint+
−
*/+
−
QFont::StyleStrategy QFont::styleStrategy() const+
−
{+
−
    return (StyleStrategy) d->request.styleStrategy;+
−
}+
−
+
−
/*!+
−
    Returns the StyleHint.+
−
+
−
    The style hint affects the \l{QFont}{font matching} algorithm.+
−
    See \l QFont::StyleHint for the list of available hints.+
−
+
−
    \sa setStyleHint(), QFont::StyleStrategy QFontInfo::styleHint()+
−
*/+
−
QFont::StyleHint QFont::styleHint() const+
−
{+
−
    return (StyleHint) d->request.styleHint;+
−
}+
−
+
−
/*!+
−
    \enum QFont::StyleHint+
−
+
−
    Style hints are used by the \l{QFont}{font matching} algorithm to+
−
    find an appropriate default family if a selected font family is+
−
    not available.+
−
+
−
    \value AnyStyle leaves the font matching algorithm to choose the+
−
           family. This is the default.+
−
+
−
    \value SansSerif the font matcher prefer sans serif fonts.+
−
    \value Helvetica is a synonym for \c SansSerif.+
−
+
−
    \value Serif the font matcher prefers serif fonts.+
−
    \value Times is a synonym for \c Serif.+
−
+
−
    \value TypeWriter the font matcher prefers fixed pitch fonts.+
−
    \value Courier a synonym for \c TypeWriter.+
−
+
−
    \value OldEnglish the font matcher prefers decorative fonts.+
−
    \value Decorative is a synonym for \c OldEnglish.+
−
+
−
    \value System the font matcher prefers system fonts.+
−
*/+
−
+
−
/*!+
−
    \enum QFont::StyleStrategy+
−
+
−
    The style strategy tells the \l{QFont}{font matching} algorithm+
−
    what type of fonts should be used to find an appropriate default+
−
    family.+
−
+
−
    The following strategies are available:+
−
+
−
    \value PreferDefault the default style strategy. It does not prefer+
−
           any type of font.+
−
    \value PreferBitmap prefers bitmap fonts (as opposed to outline+
−
           fonts).+
−
    \value PreferDevice prefers device fonts.+
−
    \value PreferOutline prefers outline fonts (as opposed to bitmap fonts).+
−
    \value ForceOutline forces the use of outline fonts.+
−
    \value NoAntialias don't antialias the fonts.+
−
    \value PreferAntialias antialias if possible.+
−
    \value OpenGLCompatible forces the use of OpenGL compatible+
−
           fonts.+
−
    \value NoFontMerging If a font does not contain a character requested+
−
           to draw then Qt automatically chooses a similar looking for that contains+
−
           the character. This flag disables this feature.+
−
+
−
    Any of these may be OR-ed with one of these flags:+
−
+
−
    \value PreferMatch prefer an exact match. The font matcher will try to+
−
           use the exact font size that has been specified.+
−
    \value PreferQuality prefer the best quality font. The font matcher+
−
           will use the nearest standard point size that the font+
−
           supports.+
−
*/+
−
+
−
/*!+
−
    Sets the style hint and strategy to \a hint and \a strategy,+
−
    respectively.+
−
+
−
    If these aren't set explicitly the style hint will default to+
−
    \c AnyStyle and the style strategy to \c PreferDefault.+
−
+
−
    Qt does not support style hints on X11 since this information+
−
    is not provided by the window system.+
−
+
−
    \sa StyleHint, styleHint(), StyleStrategy, styleStrategy(), QFontInfo+
−
*/+
−
void QFont::setStyleHint(StyleHint hint, StyleStrategy strategy)+
−
{+
−
    detach();+
−
+
−
    if ((resolve_mask & (QFont::StyleHintResolved | QFont::StyleStrategyResolved)) &&+
−
         (StyleHint) d->request.styleHint == hint &&+
−
         (StyleStrategy) d->request.styleStrategy == strategy)+
−
        return;+
−
+
−
    d->request.styleHint = hint;+
−
    d->request.styleStrategy = strategy;+
−
    resolve_mask |= QFont::StyleHintResolved;+
−
    resolve_mask |= QFont::StyleStrategyResolved;+
−
+
−
#if defined(Q_WS_X11)+
−
    d->request.addStyle.clear();+
−
#endif // Q_WS_X11+
−
}+
−
+
−
/*!+
−
    Sets the style strategy for the font to \a s.+
−
+
−
    \sa QFont::StyleStrategy+
−
*/+
−
void QFont::setStyleStrategy(StyleStrategy s)+
−
{+
−
    detach();+
−
+
−
    if ((resolve_mask & QFont::StyleStrategyResolved) &&+
−
         s == (StyleStrategy)d->request.styleStrategy)+
−
        return;+
−
+
−
    d->request.styleStrategy = s;+
−
    resolve_mask |= QFont::StyleStrategyResolved;+
−
}+
−
+
−
+
−
/*!+
−
    \enum QFont::Stretch+
−
+
−
    Predefined stretch values that follow the CSS naming convention. The higher+
−
    the value, the more stretched the text is.+
−
+
−
    \value UltraCondensed 50+
−
    \value ExtraCondensed 62+
−
    \value Condensed 75+
−
    \value SemiCondensed 87+
−
    \value Unstretched 100+
−
    \value SemiExpanded 112+
−
    \value Expanded 125+
−
    \value ExtraExpanded 150+
−
    \value UltraExpanded 200+
−
+
−
    \sa setStretch() stretch()+
−
*/+
−
+
−
/*!+
−
    Returns the stretch factor for the font.+
−
+
−
    \sa setStretch()+
−
 */+
−
int QFont::stretch() const+
−
{+
−
    return d->request.stretch;+
−
}+
−
+
−
/*!+
−
    Sets the stretch factor for the font.+
−
+
−
    The stretch factor changes the width of all characters in the font+
−
    by \a factor percent.  For example, setting \a factor to 150+
−
    results in all characters in the font being 1.5 times (ie. 150%)+
−
    wider.  The default stretch factor is 100.  The minimum stretch+
−
    factor is 1, and the maximum stretch factor is 4000.+
−
+
−
    The stretch factor is only applied to outline fonts.  The stretch+
−
    factor is ignored for bitmap fonts.+
−
+
−
    NOTE: QFont cannot stretch XLFD fonts.  When loading XLFD fonts on+
−
    X11, the stretch factor is matched against a predefined set of+
−
    values for the SETWIDTH_NAME field of the XLFD.+
−
+
−
    \sa stretch() QFont::Stretch+
−
*/+
−
void QFont::setStretch(int factor)+
−
{+
−
    if (factor < 1 || 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;+
−
}+
−
+
−
/*!+
−
    \enum QFont::SpacingType+
−
    \since 4.4+
−
+
−
    \value PercentageSpacing  A value of 100 will keep the spacing unchanged; a value of 200 will enlarge the+
−
                                                   spacing after a character by the width of the character itself.+
−
    \value AbsoluteSpacing      A positive value increases the letter spacing by the corresponding pixels; a negative+
−
                                                   value decreases the spacing.+
−
*/+
−
+
−
/*!+
−
    \since 4.4+
−
    Returns the letter spacing for the font.+
−
+
−
    \sa setLetterSpacing(), letterSpacingType(), setWordSpacing()+
−
 */+
−
qreal QFont::letterSpacing() const+
−
{+
−
    return d->letterSpacing.toReal();+
−
}+
−
+
−
/*!+
−
    \since 4.4+
−
    Sets the letter spacing for the font to \a spacing and the type+
−
    of spacing to \a type.+
−
+
−
    Letter spacing changes the default spacing between individual+
−
    letters in the font.  The spacing between the letters can be+
−
    made smaller as well as larger.+
−
+
−
    \sa letterSpacing(), letterSpacingType(), setWordSpacing()+
−
*/+
−
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;+
−
+
−
    detach();+
−
+
−
    d->letterSpacing = newSpacing;+
−
    d->letterSpacingIsAbsolute = absoluteSpacing;+
−
    resolve_mask |= QFont::LetterSpacingResolved;+
−
}+
−
+
−
/*!+
−
    \since 4.4+
−
    Returns the spacing type used for letter spacing.+
−
+
−
    \sa letterSpacing(), setLetterSpacing(), setWordSpacing()+
−
*/+
−
QFont::SpacingType QFont::letterSpacingType() const+
−
{+
−
    return d->letterSpacingIsAbsolute ? AbsoluteSpacing : PercentageSpacing;+
−
}+
−
+
−
/*!+
−
    \since 4.4+
−
    Returns the word spacing for the font.+
−
+
−
    \sa setWordSpacing(), setLetterSpacing()+
−
 */+
−
qreal QFont::wordSpacing() const+
−
{+
−
    return d->wordSpacing.toReal();+
−
}+
−
+
−
/*!+
−
    \since 4.4+
−
    Sets the word spacing for the font to \a spacing.+
−
+
−
    Word spacing changes the default spacing between individual+
−
    words. A positive value increases the word spacing+
−
    by a corresponding amount of pixels, while a negative value+
−
    decreases the inter-word spacing accordingly.+
−
+
−
    Word spacing will not apply to writing systems, where indiviaul+
−
    words are not separated by white space.+
−
+
−
    \sa wordSpacing(), setLetterSpacing()+
−
*/+
−
void QFont::setWordSpacing(qreal spacing)+
−
{+
−
    const QFixed newSpacing = QFixed::fromReal(spacing);+
−
    if ((resolve_mask & QFont::WordSpacingResolved) &&+
−
        d->wordSpacing == newSpacing)+
−
        return;+
−
+
−
    detach();+
−
+
−
    d->wordSpacing = newSpacing;+
−
    resolve_mask |= QFont::WordSpacingResolved;+
−
}+
−
+
−
/*!+
−
    \enum QFont::Capitalization+
−
    \since 4.4+
−
+
−
    Rendering option for text this font applies to.+
−
+
−
+
−
    \value MixedCase    This is the normal text rendering option where no capitalization change is applied.+
−
    \value AllUppercase This alters the text to be rendered in all uppercase type.+
−
    \value AllLowercase This alters the text to be rendered in all lowercase type.+
−
    \value SmallCaps    This alters the text to be rendered in small-caps type.+
−
    \value Capitalize   This alters the text to be rendered with the first character of each word as an uppercase character.+
−
*/+
−
+
−
/*!+
−
    \since 4.4+
−
    Sets the capitalization of the text in this font to \a caps.+
−
+
−
    A font's capitalization makes the text appear in the selected capitalization mode.+
−
+
−
    \sa capitalization()+
−
*/+
−
void QFont::setCapitalization(Capitalization caps)+
−
{+
−
    if ((resolve_mask & QFont::CapitalizationResolved) &&+
−
        capitalization() == caps)+
−
        return;+
−
+
−
    detach();+
−
+
−
    d->capital = caps;+
−
    resolve_mask |= QFont::CapitalizationResolved;+
−
}+
−
+
−
/*!+
−
    \since 4.4+
−
    Returns the current capitalization type of the font.+
−
+
−
    \sa setCapitalization()+
−
*/+
−
QFont::Capitalization QFont::capitalization() const+
−
{+
−
    return static_cast<QFont::Capitalization> (d->capital);+
−
}+
−
+
−
+
−
/*!+
−
    If \a enable is true, turns raw mode on; otherwise turns raw mode+
−
    off. This function only has an effect under X11.+
−
+
−
    If raw mode is enabled, Qt will search for an X font with a+
−
    complete font name matching the family name, ignoring all other+
−
    values set for the QFont. If the font name matches several fonts,+
−
    Qt will use the first font returned by X. QFontInfo \e cannot be+
−
    used to fetch information about a QFont using raw mode (it will+
−
    return the values set in the QFont for all parameters, including+
−
    the family name).+
−
+
−
    \warning Do not use raw mode unless you really, really need it! In+
−
    most (if not all) cases, setRawName() is a much better choice.+
−
+
−
    \sa rawMode(), setRawName()+
−
*/+
−
void QFont::setRawMode(bool enable)+
−
{+
−
    detach();+
−
+
−
    if ((bool) d->rawMode == enable) return;+
−
+
−
    d->rawMode = enable;+
−
}+
−
+
−
/*!+
−
    Returns true if a window system font exactly matching the settings+
−
    of this font is available.+
−
+
−
    \sa QFontInfo+
−
*/+
−
bool QFont::exactMatch() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return (d->rawMode+
−
            ? engine->type() != QFontEngine::Box+
−
            : d->request.exactMatch(engine->fontDef));+
−
}+
−
+
−
/*!+
−
    Returns true if this font is equal to \a f; otherwise returns+
−
    false.+
−
+
−
    Two QFonts are considered equal if their font attributes are+
−
    equal. If rawMode() is enabled for both fonts, only the family+
−
    fields are compared.+
−
+
−
    \sa operator!=() isCopyOf()+
−
*/+
−
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+
−
            ));+
−
}+
−
+
−
+
−
/*!+
−
    Provides an arbitrary comparison of this font and font \a f.+
−
    All that is guaranteed is that the operator returns false if both+
−
    fonts are equal and that (f1 \< f2) == !(f2 \< f1) if the fonts+
−
    are not equal.+
−
+
−
    This function is useful in some circumstances, for example if you+
−
    want to use QFont objects as keys in a QMap.+
−
+
−
    \sa operator==() operator!=() isCopyOf()+
−
*/+
−
bool QFont::operator<(const QFont &f) const+
−
{+
−
    if (f.d == d) return false;+
−
    // the < operator for fontdefs ignores point sizes.+
−
    QFontDef &r1 = f.d->request;+
−
    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.family != r2.family) return r1.family < r2.family;+
−
#ifdef Q_WS_X11+
−
    if (r1.addStyle != r2.addStyle) return r1.addStyle < r2.addStyle;+
−
#endif // Q_WS_X11+
−
    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;+
−
}+
−
+
−
+
−
/*!+
−
    Returns true if this font is different from \a f; otherwise+
−
    returns false.+
−
+
−
    Two QFonts are considered to be different if their font attributes+
−
    are different. If rawMode() is enabled for both fonts, only the+
−
    family fields are compared.+
−
+
−
    \sa operator==()+
−
*/+
−
bool QFont::operator!=(const QFont &f) const+
−
{+
−
    return !(operator==(f));+
−
}+
−
+
−
/*!+
−
   Returns the font as a QVariant+
−
*/+
−
QFont::operator QVariant() const+
−
{+
−
    return QVariant(QVariant::Font, this);+
−
}+
−
+
−
/*!+
−
    Returns true if this font and \a f are copies of each other, i.e.+
−
    one of them was created as a copy of the other and neither has+
−
    been modified since. This is much stricter than equality.+
−
+
−
    \sa operator=() operator==()+
−
*/+
−
bool QFont::isCopyOf(const QFont & f) const+
−
{+
−
    return d == f.d;+
−
}+
−
+
−
/*!+
−
    Returns true if raw mode is used for font name matching; otherwise+
−
    returns false.+
−
+
−
    \sa setRawMode() rawName()+
−
*/+
−
bool QFont::rawMode() const+
−
{+
−
    return d->rawMode;+
−
}+
−
+
−
/*!+
−
    Returns a new QFont that has attributes copied from \a other that+
−
    have not been previously set on this font.+
−
*/+
−
QFont QFont::resolve(const QFont &other) const+
−
{+
−
    if (*this == other+
−
        && (resolve_mask == other.resolve_mask || resolve_mask == 0)+
−
        && d->dpi == other.d->dpi) {+
−
        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;+
−
}+
−
+
−
/*!+
−
    \fn uint QFont::resolve() const+
−
    \internal+
−
*/+
−
+
−
/*!+
−
    \fn void QFont::resolve(uint mask)+
−
    \internal+
−
*/+
−
+
−
#ifdef QT3_SUPPORT+
−
+
−
/*! \obsolete+
−
+
−
  Please use QApplication::font() instead.+
−
*/+
−
QFont QFont::defaultFont()+
−
{+
−
    return QApplication::font();+
−
}+
−
+
−
/*! \obsolete+
−
+
−
  Please use QApplication::setFont() instead.+
−
*/+
−
void QFont::setDefaultFont(const QFont &f)+
−
{+
−
    QApplication::setFont(f);+
−
}+
−
+
−
/*!+
−
    \fn qreal QFont::pointSizeFloat() const+
−
    \compat+
−
+
−
    Use pointSizeF() instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QFont::setPointSizeFloat(qreal size)+
−
    \compat+
−
+
−
    Use setPointSizeF() instead.+
−
*/+
−
#endif+
−
+
−
+
−
+
−
+
−
/*****************************************************************************+
−
  QFont substitution management+
−
 *****************************************************************************/+
−
+
−
typedef QHash<QString, QStringList> QFontSubst;+
−
Q_GLOBAL_STATIC(QFontSubst, globalFontSubst)+
−
+
−
// create substitution dict+
−
static void initFontSubst()+
−
{+
−
    // default substitutions+
−
    static const char * const initTbl[] = {+
−
+
−
#if defined(Q_WS_X11)+
−
        "arial",        "helvetica",+
−
        "times new roman", "times",+
−
        "courier new",  "courier",+
−
        "sans serif",   "helvetica",+
−
#elif defined(Q_WS_WIN)+
−
        "times",        "times new roman",+
−
        "courier",      "courier new",+
−
        "helvetica",    "arial",+
−
        "sans serif",   "arial",+
−
#endif+
−
+
−
        0,              0+
−
    };+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    if (!fontSubst->isEmpty())+
−
        return;+
−
#if defined(Q_WS_X11) && !defined(QT_NO_FONTCONFIG)+
−
    if (X11->has_fontconfig)+
−
        return;+
−
#endif+
−
+
−
    for (int i=0; initTbl[i] != 0; i += 2) {+
−
        QStringList &list = (*fontSubst)[QString::fromLatin1(initTbl[i])];+
−
        list.append(QString::fromLatin1(initTbl[i+1]));+
−
    }+
−
}+
−
+
−
/*!+
−
    Returns the first family name to be used whenever \a familyName is+
−
    specified. The lookup is case insensitive.+
−
+
−
    If there is no substitution for \a familyName, \a familyName is+
−
    returned.+
−
+
−
    To obtain a list of substitutions use substitutes().+
−
+
−
    \sa setFamily() insertSubstitutions() insertSubstitution() removeSubstitution()+
−
*/+
−
QString QFont::substitute(const QString &familyName)+
−
{+
−
    initFontSubst();+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    QFontSubst::ConstIterator it = fontSubst->constFind(familyName.toLower());+
−
    if (it != fontSubst->constEnd() && !(*it).isEmpty())+
−
        return (*it).first();+
−
+
−
    return familyName;+
−
}+
−
+
−
+
−
/*!+
−
    Returns a list of family names to be used whenever \a familyName+
−
    is specified. The lookup is case insensitive.+
−
+
−
    If there is no substitution for \a familyName, an empty list is+
−
    returned.+
−
+
−
    \sa substitute() insertSubstitutions() insertSubstitution() removeSubstitution()+
−
 */+
−
QStringList QFont::substitutes(const QString &familyName)+
−
{+
−
    initFontSubst();+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    return fontSubst->value(familyName.toLower(), QStringList());+
−
}+
−
+
−
+
−
/*!+
−
    Inserts \a substituteName into the substitution+
−
    table for the family \a familyName.+
−
+
−
    \sa insertSubstitutions() removeSubstitution() substitutions() substitute() substitutes()+
−
*/+
−
void QFont::insertSubstitution(const QString &familyName,+
−
                               const QString &substituteName)+
−
{+
−
    initFontSubst();+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    QStringList &list = (*fontSubst)[familyName.toLower()];+
−
    QString s = substituteName.toLower();+
−
    if (!list.contains(s))+
−
        list.append(s);+
−
}+
−
+
−
+
−
/*!+
−
    Inserts the list of families \a substituteNames into the+
−
    substitution list for \a familyName.+
−
+
−
    \sa insertSubstitution(), removeSubstitution(), substitutions(), substitute()+
−
*/+
−
void QFont::insertSubstitutions(const QString &familyName,+
−
                                const QStringList &substituteNames)+
−
{+
−
    initFontSubst();+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    QStringList &list = (*fontSubst)[familyName.toLower()];+
−
    QStringList::ConstIterator it = substituteNames.constBegin();+
−
    while (it != substituteNames.constEnd()) {+
−
        QString s = (*it).toLower();+
−
        if (!list.contains(s))+
−
            list.append(s);+
−
        it++;+
−
    }+
−
}+
−
+
−
/*! \fn void QFont::initialize()+
−
  \internal+
−
+
−
  Internal function that initializes the font system.  The font cache+
−
  and font dict do not alloc the keys. The key is a QString which is+
−
  shared between QFontPrivate and QXFontName.+
−
*/+
−
+
−
/*! \fn void QFont::cleanup()+
−
  \internal+
−
+
−
  Internal function that cleans up the font system.+
−
*/+
−
+
−
// ### mark: should be called removeSubstitutions()+
−
/*!+
−
    Removes all the substitutions for \a familyName.+
−
+
−
    \sa insertSubstitutions(), insertSubstitution(), substitutions(), substitute()+
−
*/+
−
void QFont::removeSubstitution(const QString &familyName)+
−
{ // ### function name should be removeSubstitutions() or+
−
  // ### removeSubstitutionList()+
−
    initFontSubst();+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    fontSubst->remove(familyName.toLower());+
−
}+
−
+
−
+
−
/*!+
−
    Returns a sorted list of substituted family names.+
−
+
−
    \sa insertSubstitution(), removeSubstitution(), substitute()+
−
*/+
−
QStringList QFont::substitutions()+
−
{+
−
    initFontSubst();+
−
+
−
    QFontSubst *fontSubst = globalFontSubst();+
−
    Q_ASSERT(fontSubst != 0);+
−
    QStringList ret;+
−
    QFontSubst::ConstIterator it = fontSubst->constBegin();+
−
+
−
    while (it != fontSubst->constEnd()) {+
−
        ret.append(it.key());+
−
        ++it;+
−
    }+
−
+
−
    ret.sort();+
−
    return ret;+
−
}+
−
+
−
+
−
/*  \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 != 0);+
−
    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 (f->rawMode)+
−
        bits |= 0x20;+
−
    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 != 0);+
−
    quint8 bits = 0;+
−
    if (f->request.ignorePitch)+
−
        bits |= 0x01;+
−
    if (f->letterSpacingIsAbsolute)+
−
        bits |= 0x02;+
−
    return bits;+
−
}+
−
+
−
#ifndef QT_NO_DATASTREAM+
−
+
−
/*  \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 != 0);+
−
    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;+
−
    f->rawMode               = (bits & 0x20) != 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 != 0);+
−
    f->request.ignorePitch = (bits & 0x01) != 0;+
−
    f->letterSpacingIsAbsolute = (bits & 0x02) != 0;+
−
}+
−
#endif+
−
+
−
+
−
/*!+
−
    Returns the font's key, a textual representation of a font. It is+
−
    typically used as the key for a cache or dictionary of fonts.+
−
+
−
    \sa QMap+
−
*/+
−
QString QFont::key() const+
−
{+
−
    return toString();+
−
}+
−
+
−
/*!+
−
    Returns a description of the font. The description is a+
−
    comma-separated list of the attributes, perfectly suited for use+
−
    in QSettings.+
−
+
−
    \sa fromString()+
−
 */+
−
QString QFont::toString() const+
−
{+
−
    const QChar comma(QLatin1Char(','));+
−
    return 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)   rawMode());+
−
}+
−
+
−
+
−
/*!+
−
    Sets this font to match the description \a descrip. The description+
−
    is a comma-separated list of the font attributes, as returned by+
−
    toString().+
−
+
−
    \sa toString()+
−
 */+
−
bool QFont::fromString(const QString &descrip)+
−
{+
−
    QStringList l(descrip.split(QLatin1Char(',')));+
−
+
−
    int count = l.count();+
−
    if (!count || (count > 2 && count < 9) || count > 11) {+
−
        qWarning("QFont::fromString: Invalid description '%s'",+
−
                 descrip.isEmpty() ? "(empty)" : descrip.toLatin1().data());+
−
        return false;+
−
    }+
−
+
−
    setFamily(l[0]);+
−
    if (count > 1 && l[1].toDouble() > 0.0)+
−
        setPointSizeF(l[1].toDouble());+
−
    if (count == 9) {+
−
        setStyleHint((StyleHint) l[2].toInt());+
−
        setWeight(qMax(qMin(99, l[3].toInt()), 0));+
−
        setItalic(l[4].toInt());+
−
        setUnderline(l[5].toInt());+
−
        setStrikeOut(l[6].toInt());+
−
        setFixedPitch(l[7].toInt());+
−
        setRawMode(l[8].toInt());+
−
    } else if (count == 10) {+
−
        if (l[2].toInt() > 0)+
−
            setPixelSize(l[2].toInt());+
−
        setStyleHint((StyleHint) l[3].toInt());+
−
        setWeight(qMax(qMin(99, l[4].toInt()), 0));+
−
        setStyle((QFont::Style)l[5].toInt());+
−
        setUnderline(l[6].toInt());+
−
        setStrikeOut(l[7].toInt());+
−
        setFixedPitch(l[8].toInt());+
−
        setRawMode(l[9].toInt());+
−
    }+
−
    if (count >= 9 && !d->request.fixedPitch) // assume 'false' fixedPitch equals default+
−
        d->request.ignorePitch = true;+
−
+
−
    return true;+
−
}+
−
+
−
#if !defined(Q_WS_QWS)+
−
/*! \internal+
−
+
−
  Internal function that dumps font cache statistics.+
−
*/+
−
void QFont::cacheStatistics()+
−
{+
−
+
−
+
−
}+
−
#endif // !Q_WS_QWS+
−
+
−
+
−
+
−
/*****************************************************************************+
−
  QFont stream functions+
−
 *****************************************************************************/+
−
#ifndef QT_NO_DATASTREAM+
−
+
−
/*!+
−
    \relates QFont+
−
+
−
    Writes the font \a font to the data stream \a s. (toString()+
−
    writes to a text stream.)+
−
+
−
    \sa \link datastreamformat.html Format of the QDataStream operators \endlink+
−
*/+
−
QDataStream &operator<<(QDataStream &s, const QFont &font)+
−
{+
−
    if (s.version() == 1) {+
−
        s << font.d->request.family.toLatin1();+
−
    } else {+
−
        s << font.d->request.family;+
−
    }+
−
+
−
    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) {+
−
#ifdef Q_WS_X11+
−
            pointSize = (qint16)(font.d->request.pixelSize*720/QX11Info::appDpiY());+
−
#else+
−
            pointSize = (qint16)QFontInfo(font).pointSize() * 10;+
−
#endif+
−
        }+
−
        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)+
−
        s << (quint8) font.d->request.styleStrategy;+
−
    s << (quint8) 0+
−
      << (quint8) font.d->request.weight+
−
      << 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();+
−
    }+
−
    return s;+
−
}+
−
+
−
+
−
/*!+
−
    \relates QFont+
−
+
−
    Reads the font \a font from the data stream \a s. (fromString()+
−
    reads from a text stream.)+
−
+
−
    \sa \link datastreamformat.html Format of the QDataStream operators \endlink+
−
*/+
−
QDataStream &operator>>(QDataStream &s, QFont &font)+
−
{+
−
    font.d = new QFontPrivate;+
−
    font.resolve_mask = QFont::AllPropertiesResolved;+
−
+
−
    quint8 styleHint, styleStrategy = QFont::PreferDefault, charSet, weight, bits;+
−
+
−
    if (s.version() == 1) {+
−
        QByteArray fam;+
−
        s >> fam;+
−
        font.d->request.family = QString::fromLatin1(fam);+
−
    } else {+
−
        s >> font.d->request.family;+
−
    }+
−
+
−
    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)+
−
        s >> styleStrategy;+
−
+
−
    s >> charSet;+
−
    s >> weight;+
−
    s >> bits;+
−
+
−
    font.d->request.styleHint = styleHint;+
−
    font.d->request.styleStrategy = styleStrategy;+
−
    font.d->request.weight = weight;+
−
+
−
    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);+
−
    }+
−
+
−
    return s;+
−
}+
−
+
−
#endif // QT_NO_DATASTREAM+
−
+
−
+
−
/*****************************************************************************+
−
  QFontInfo member functions+
−
 *****************************************************************************/+
−
+
−
/*!+
−
    \class QFontInfo+
−
    \reentrant+
−
+
−
    \brief The QFontInfo class provides general information about fonts.+
−
+
−
    \ingroup appearance+
−
    \ingroup shared+
−
+
−
    The QFontInfo class provides the same access functions as QFont,+
−
    e.g. family(), pointSize(), italic(), weight(), fixedPitch(),+
−
    styleHint() etc. But whilst the QFont access functions return the+
−
    values that were set, a QFontInfo object returns the values that+
−
    apply to the font that will actually be used to draw the text.+
−
+
−
    For example, when the program asks for a 25pt Courier font on a+
−
    machine that has a non-scalable 24pt Courier font, QFont will+
−
    (normally) use the 24pt Courier for rendering. In this case,+
−
    QFont::pointSize() returns 25 and QFontInfo::pointSize() returns+
−
    24.+
−
+
−
    There are three ways to create a QFontInfo object.+
−
    \list 1+
−
    \o Calling the QFontInfo constructor with a QFont creates a font+
−
    info object for a screen-compatible font, i.e. the font cannot be+
−
    a printer font. If the font is changed later, the font+
−
    info object is \e not updated.+
−
+
−
    (Note: If you use a printer font the values returned may be+
−
    inaccurate. Printer fonts are not always accessible so the nearest+
−
    screen font is used if a printer font is supplied.)+
−
+
−
    \o QWidget::fontInfo() returns the font info for a widget's font.+
−
    This is equivalent to calling QFontInfo(widget->font()). If the+
−
    widget's font is changed later, the font info object is \e not+
−
    updated.+
−
+
−
    \o QPainter::fontInfo() returns the font info for a painter's+
−
    current font. If the painter's font is changed later, the font+
−
    info object is \e not updated.+
−
    \endlist+
−
+
−
    \sa QFont QFontMetrics QFontDatabase+
−
*/+
−
+
−
/*!+
−
    Constructs a font info object for \a font.+
−
+
−
    The font must be screen-compatible, i.e. a font you use when+
−
    drawing text in \link QWidget widgets\endlink or \link QPixmap+
−
    pixmaps\endlink, not QPicture or QPrinter.+
−
+
−
    The font info object holds the information for the font that is+
−
    passed in the constructor at the time it is created, and is not+
−
    updated if the font's attributes are changed later.+
−
+
−
    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.+
−
*/+
−
QFontInfo::QFontInfo(const QFont &font)+
−
    : d(font.d.data())+
−
{+
−
}+
−
+
−
/*!+
−
    Constructs a copy of \a fi.+
−
*/+
−
QFontInfo::QFontInfo(const QFontInfo &fi)+
−
    : d(fi.d.data())+
−
{+
−
}+
−
+
−
/*!+
−
    Destroys the font info object.+
−
*/+
−
QFontInfo::~QFontInfo()+
−
{+
−
}+
−
+
−
/*!+
−
    Assigns the font info in \a fi.+
−
*/+
−
QFontInfo &QFontInfo::operator=(const QFontInfo &fi)+
−
{+
−
    d = fi.d.data();+
−
    return *this;+
−
}+
−
+
−
/*!+
−
    Returns the family name of the matched window system font.+
−
+
−
    \sa QFont::family()+
−
*/+
−
QString QFontInfo::family() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return engine->fontDef.family;+
−
}+
−
+
−
/*!+
−
    Returns the point size of the matched window system font.+
−
+
−
    \sa pointSizeF() QFont::pointSize()+
−
*/+
−
int QFontInfo::pointSize() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return qRound(engine->fontDef.pointSize);+
−
}+
−
+
−
/*!+
−
    Returns the point size of the matched window system font.+
−
+
−
    \sa QFont::pointSizeF()+
−
*/+
−
qreal QFontInfo::pointSizeF() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return engine->fontDef.pointSize;+
−
}+
−
+
−
/*!+
−
    Returns the pixel size of the matched window system font.+
−
+
−
    \sa QFont::pointSize()+
−
*/+
−
int QFontInfo::pixelSize() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return engine->fontDef.pixelSize;+
−
}+
−
+
−
/*!+
−
    Returns the italic value of the matched window system font.+
−
+
−
    \sa QFont::italic()+
−
*/+
−
bool QFontInfo::italic() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return engine->fontDef.style != QFont::StyleNormal;+
−
}+
−
+
−
/*!+
−
    Returns the style value of the matched window system font.+
−
+
−
    \sa QFont::style()+
−
*/+
−
QFont::Style QFontInfo::style() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return (QFont::Style)engine->fontDef.style;+
−
}+
−
+
−
/*!+
−
    Returns the weight of the matched window system font.+
−
+
−
    \sa QFont::weight(), bold()+
−
*/+
−
int QFontInfo::weight() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return engine->fontDef.weight;+
−
+
−
}+
−
+
−
/*!+
−
    \fn bool QFontInfo::bold() const+
−
+
−
    Returns true if weight() would return a value greater than+
−
    QFont::Normal; otherwise returns false.+
−
+
−
    \sa weight(), QFont::bold()+
−
*/+
−
+
−
/*!+
−
    Returns the underline value of the matched window system font.+
−
+
−
  \sa QFont::underline()+
−
+
−
  \internal+
−
+
−
  Here we read the underline flag directly from the QFont.+
−
  This is OK for X11 and for Windows because we always get what we want.+
−
*/+
−
bool QFontInfo::underline() const+
−
{+
−
    return d->underline;+
−
}+
−
+
−
/*!+
−
    Returns the overline value of the matched window system font.+
−
+
−
    \sa QFont::overline()+
−
+
−
    \internal+
−
+
−
    Here we read the overline flag directly from the QFont.+
−
    This is OK for X11 and for Windows because we always get what we want.+
−
*/+
−
bool QFontInfo::overline() const+
−
{+
−
    return d->overline;+
−
}+
−
+
−
/*!+
−
    Returns the strikeout value of the matched window system font.+
−
+
−
  \sa QFont::strikeOut()+
−
+
−
  \internal Here we read the strikeOut flag directly from the QFont.+
−
  This is OK for X11 and for Windows because we always get what we want.+
−
*/+
−
bool QFontInfo::strikeOut() const+
−
{+
−
    return d->strikeOut;+
−
}+
−
+
−
/*!+
−
    Returns the fixed pitch value of the matched window system font.+
−
+
−
    \sa QFont::fixedPitch()+
−
*/+
−
bool QFontInfo::fixedPitch() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
#ifdef Q_OS_MAC+
−
    if (!engine->fontDef.fixedPitchComputed) {+
−
        QChar ch[2] = { QLatin1Char('i'), QLatin1Char('m') };+
−
        QGlyphLayoutArray<2> g;+
−
        int l = 2;+
−
        engine->stringToCMap(ch, 2, &g, &l, 0);+
−
        engine->fontDef.fixedPitch = g.advances_x[0] == g.advances_x[1];+
−
        engine->fontDef.fixedPitchComputed = true;+
−
    }+
−
#endif+
−
    return engine->fontDef.fixedPitch;+
−
}+
−
+
−
/*!+
−
    Returns the style of the matched window system font.+
−
+
−
    Currently only returns the style hint set in QFont.+
−
+
−
    \sa QFont::styleHint() QFont::StyleHint+
−
*/+
−
QFont::StyleHint QFontInfo::styleHint() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return (QFont::StyleHint) engine->fontDef.styleHint;+
−
}+
−
+
−
/*!+
−
    Returns true if the font is a raw mode font; otherwise returns+
−
    false.+
−
+
−
    If it is a raw mode font, all other functions in QFontInfo will+
−
    return the same values set in the QFont, regardless of the font+
−
    actually used.+
−
+
−
    \sa QFont::rawMode()+
−
*/+
−
bool QFontInfo::rawMode() const+
−
{+
−
    return d->rawMode;+
−
}+
−
+
−
/*!+
−
    Returns true if the matched window system font is exactly the same+
−
    as the one specified by the font; otherwise returns false.+
−
+
−
    \sa QFont::exactMatch()+
−
*/+
−
bool QFontInfo::exactMatch() const+
−
{+
−
    QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);+
−
    Q_ASSERT(engine != 0);+
−
    return (d->rawMode+
−
            ? engine->type() != QFontEngine::Box+
−
            : 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+
−
+
−
const uint QFontCache::min_cost = 4*1024; // 4mb+
−
+
−
#ifdef QT_NO_THREAD+
−
Q_GLOBAL_STATIC(QFontCache, theFontCache)+
−
+
−
QFontCache *QFontCache::instance()+
−
{+
−
    return theFontCache();+
−
}+
−
+
−
void QFontCache::cleanup()+
−
{+
−
}+
−
#else+
−
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 = 0;+
−
    QT_TRY {+
−
        cache = theFontCache();+
−
    } QT_CATCH (const std::bad_alloc &) {+
−
        // no cache - just ignore+
−
    }+
−
    if (cache && cache->hasLocalData())+
−
        cache->setLocalData(0);+
−
}+
−
#endif // QT_NO_THREAD+
−
+
−
QFontCache::QFontCache()+
−
    : QObject(), total_cost(0), max_cost(min_cost),+
−
      current_timestamp(0), fast(false), timer_id(-1)+
−
{+
−
}+
−
+
−
QFontCache::~QFontCache()+
−
{+
−
    {+
−
        EngineDataCache::ConstIterator it = engineDataCache.constBegin(),+
−
                                 end = engineDataCache.constEnd();+
−
        while (it != end) {+
−
            if (it.value()->ref == 0)+
−
                delete it.value();+
−
            else+
−
                FC_DEBUG("QFontCache::~QFontCache: engineData %p still has refcount %d",+
−
                         it.value(), int(it.value()->ref));+
−
            ++it;+
−
        }+
−
    }+
−
    EngineCache::ConstIterator it = engineCache.constBegin(),+
−
                         end = engineCache.constEnd();+
−
    while (it != end) {+
−
        if (--it.value().data->cache_count == 0) {+
−
            if (it.value().data->ref == 0) {+
−
                FC_DEBUG("QFontCache::~QFontCache: deleting engine %p key=(%d / %g %g %d %d %d)",+
−
                         it.value().data, it.key().script, it.key().def.pointSize,+
−
                         it.key().def.pixelSize, it.key().def.weight, it.key().def.style,+
−
                         it.key().def.fixedPitch);+
−
+
−
                delete it.value().data;+
−
            } else {+
−
                FC_DEBUG("QFontCache::~QFontCache: engine = %p still has refcount %d",+
−
                         it.value().data, int(it.value().data->ref));+
−
            }+
−
        }+
−
        ++it;+
−
    }+
−
}+
−
+
−
void QFontCache::clear()+
−
{+
−
    {+
−
        EngineDataCache::Iterator it = engineDataCache.begin(),+
−
                                 end = engineDataCache.end();+
−
        while (it != end) {+
−
            QFontEngineData *data = it.value();+
−
#if !defined(Q_WS_MAC)+
−
            for (int i = 0; i < QUnicodeTables::ScriptCount; ++i) {+
−
                if (data->engines[i]) {+
−
                    data->engines[i]->ref.deref();+
−
                    data->engines[i] = 0;+
−
                }+
−
            }+
−
#else+
−
            if (data->engine) {+
−
                data->engine->ref.deref();+
−
                data->engine = 0;+
−
            }+
−
#endif+
−
            ++it;+
−
        }+
−
    }+
−
+
−
    for (EngineCache::Iterator it = engineCache.begin(), end = engineCache.end();+
−
         it != end; ++it) {+
−
        if (it->data->ref == 0) {+
−
            delete it->data;+
−
            it->data = 0;+
−
        }+
−
    }+
−
+
−
    for (EngineCache::Iterator it = engineCache.begin(), end = engineCache.end();+
−
         it != end; ++it) {+
−
        if (it->data && it->data->ref == 0) {+
−
            delete it->data;+
−
            it->data = 0;+
−
        }+
−
    }+
−
+
−
    engineCache.clear();+
−
}+
−
+
−
#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_QPF2)+
−
void QFontCache::removeEngineForFont(const QByteArray &_fontName)+
−
{+
−
+
−
    /* This could be optimized but the code becomes much more complex if we want to handle multi+
−
     * font engines and it is probably not worth it. Therefore we just clear the entire font cache.+
−
     */+
−
    Q_UNUSED(_fontName);+
−
    clear();+
−
}+
−
#endif+
−
+
−
QFontEngineData *QFontCache::findEngineData(const Key &key) const+
−
{+
−
    EngineDataCache::ConstIterator it = engineDataCache.find(key),+
−
                                  end = engineDataCache.end();+
−
    if (it == end) return 0;+
−
+
−
    // found+
−
    return it.value();+
−
}+
−
+
−
void QFontCache::insertEngineData(const Key &key, QFontEngineData *engineData)+
−
{+
−
    FC_DEBUG("QFontCache: inserting new engine data %p", engineData);+
−
+
−
    engineDataCache.insert(key, engineData);+
−
    increaseCost(sizeof(QFontEngineData));+
−
}+
−
+
−
QFontEngine *QFontCache::findEngine(const Key &key)+
−
{+
−
    EngineCache::Iterator it = engineCache.find(key),+
−
                         end = engineCache.end();+
−
    if (it == end) return 0;+
−
+
−
    // found... update the hitcount and timestamp+
−
    it.value().hits++;+
−
    it.value().timestamp = ++current_timestamp;+
−
+
−
    FC_DEBUG("QFontCache: found font engine\n"+
−
             "  %p: timestamp %4u hits %3u ref %2d/%2d, type '%s'",+
−
             it.value().data, it.value().timestamp, it.value().hits,+
−
             int(it.value().data->ref), it.value().data->cache_count,+
−
             it.value().data->name());+
−
+
−
    return it.value().data;+
−
}+
−
+
−
void QFontCache::insertEngine(const Key &key, QFontEngine *engine)+
−
{+
−
    FC_DEBUG("QFontCache: inserting new engine %p", engine);+
−
+
−
    Engine data(engine);+
−
    data.timestamp = ++current_timestamp;+
−
+
−
    engineCache.insert(key, data);+
−
+
−
    // only increase the cost if this is the first time we insert the engine+
−
    if (engine->cache_count == 0)+
−
        increaseCost(engine->cache_cost);+
−
+
−
    ++engine->cache_count;+
−
}+
−
+
−
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 (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);+
−
}+
−
+
−
#if defined(Q_WS_WIN) || defined (Q_WS_QWS)+
−
void QFontCache::cleanupPrinterFonts()+
−
{+
−
    FC_DEBUG("QFontCache::cleanupPrinterFonts");+
−
+
−
    {+
−
        FC_DEBUG("  CLEAN engine data:");+
−
+
−
        // clean out all unused engine data+
−
        EngineDataCache::Iterator it = engineDataCache.begin(),+
−
                                 end = engineDataCache.end();+
−
        while (it != end) {+
−
            if (it.key().screen == 0) {+
−
                ++it;+
−
                continue;+
−
            }+
−
+
−
            if(it.value()->ref != 0) {+
−
                for(int i = 0; i < QUnicodeTables::ScriptCount; ++i) {+
−
                    if(it.value()->engines[i]) {+
−
                        it.value()->engines[i]->ref.deref();+
−
                        it.value()->engines[i] = 0;+
−
                    }+
−
                }+
−
                ++it;+
−
            } else {+
−
+
−
                EngineDataCache::Iterator rem = it++;+
−
+
−
                decreaseCost(sizeof(QFontEngineData));+
−
+
−
                FC_DEBUG("    %p", rem.value());+
−
+
−
                delete rem.value();+
−
                engineDataCache.erase(rem);+
−
            }+
−
        }+
−
    }+
−
+
−
    EngineCache::Iterator it = engineCache.begin(),+
−
                         end = engineCache.end();+
−
    while(it != end) {+
−
        if (it.value().data->ref != 0 || it.key().screen == 0) {+
−
            ++it;+
−
            continue;+
−
        }+
−
+
−
        FC_DEBUG("    %p: timestamp %4u hits %2u ref %2d/%2d, type '%s'",+
−
                 it.value().data, it.value().timestamp, it.value().hits,+
−
                 int(it.value().data->ref), it.value().data->cache_count,+
−
                 it.value().data->name());+
−
+
−
        if (--it.value().data->cache_count == 0) {+
−
            FC_DEBUG("    DELETE: last occurrence in cache");+
−
+
−
            decreaseCost(it.value().data->cache_cost);+
−
            delete it.value().data;+
−
        }+
−
+
−
        engineCache.erase(it++);+
−
    }+
−
}+
−
#endif+
−
+
−
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;+
−
    }+
−
+
−
    // 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) {+
−
#ifdef QFONTCACHE_DEBUG+
−
            FC_DEBUG("    %p: ref %2d", it.value(), int(it.value()->ref));+
−
+
−
#  if defined(Q_WS_X11) || defined(Q_WS_WIN)+
−
            // print out all engines+
−
            for (int i = 0; i < QUnicodeTables::ScriptCount; ++i) {+
−
                if (! it.value()->engines[i])+
−
                    continue;+
−
                FC_DEBUG("      contains %p", it.value()->engines[i]);+
−
            }+
−
#  endif // Q_WS_X11 || Q_WS_WIN+
−
#endif // QFONTCACHE_DEBUG+
−
+
−
            if (it.value()->ref != 0)+
−
                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,+
−
                     int(it.value().data->ref), it.value().data->cache_count,+
−
                     it.value().data->cache_cost);+
−
+
−
            if (it.value().data->ref != 0)+
−
                in_use_cost += it.value().data->cache_cost / it.value().data->cache_count;+
−
        }+
−
+
−
        // 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 (new_max_cost == max_cost) {+
−
        if (fast) {+
−
            FC_DEBUG("  cannot shrink cache, slowing timer");+
−
+
−
            killTimer(timer_id);+
−
            timer_id = startTimer(slow_timeout);+
−
            fast = false;+
−
        }+
−
+
−
        return;+
−
    } else if (! fast) {+
−
        FC_DEBUG("  dropping into passing gear");+
−
+
−
        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(),+
−
                                 end = engineDataCache.end();+
−
        while (it != end) {+
−
            if (it.value()->ref != 0) {+
−
                ++it;+
−
                continue;+
−
            }+
−
+
−
            EngineDataCache::Iterator rem = it++;+
−
+
−
            decreaseCost(sizeof(QFontEngineData));+
−
+
−
            FC_DEBUG("    %p", rem.value());+
−
+
−
            delete rem.value();+
−
            engineDataCache.erase(rem);+
−
        }+
−
    }+
−
+
−
    // clean out the engine cache just enough to get below our new max cost+
−
    uint current_cost;+
−
    do {+
−
        current_cost = total_cost;+
−
+
−
        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;+
−
+
−
        for (; it != end; ++it) {+
−
            if (it.value().data->ref != 0)+
−
                continue;+
−
+
−
            if (it.value().timestamp < oldest &&+
−
                 it.value().hits <= least_popular) {+
−
                oldest = it.value().timestamp;+
−
                least_popular = it.value().hits;+
−
            }+
−
        }+
−
+
−
        FC_DEBUG("    oldest %u least popular %u", oldest, least_popular);+
−
+
−
        for (it = engineCache.begin(); it != end; ++it) {+
−
            if (it.value().data->ref == 0 &&+
−
                 it.value().timestamp == oldest &&+
−
                 it.value().hits == least_popular)+
−
                break;+
−
        }+
−
+
−
        if (it != end) {+
−
            FC_DEBUG("    %p: timestamp %4u hits %2u ref %2d/%2d, type '%s'",+
−
                     it.value().data, it.value().timestamp, it.value().hits,+
−
                     int(it.value().data->ref), it.value().data->cache_count,+
−
                     it.value().data->name());+
−
+
−
            if (--it.value().data->cache_count == 0) {+
−
                FC_DEBUG("    DELETE: last occurrence in cache");+
−
+
−
                decreaseCost(it.value().data->cache_cost);+
−
                delete it.value().data;+
−
            } else {+
−
                /*+
−
                  this particular font engine is in the cache multiple+
−
                  times...  set current_cost to zero, so that we can+
−
                  keep looping to get rid of all occurrences+
−
                */+
−
                current_cost = 0;+
−
            }+
−
+
−
            engineCache.erase(it);+
−
        }+
−
    } while (current_cost != total_cost && total_cost > max_cost);+
−
}+
−
+
−
+
−
#ifndef QT_NO_DEBUG_STREAM+
−
QDebug operator<<(QDebug stream, const QFont &font)+
−
{+
−
    return stream << "QFont(" << font.toString() << ')';+
−
}+
−
#endif+
−
+
−
QT_END_NAMESPACE+
−