/****************************************************************************

**

** Copyright (C) 2012 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$

** GNU Lesser General Public License Usage

** 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.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU General

** Public License version 3.0 as published by the Free Software Foundation

** and appearing in the file LICENSE.GPL included in the packaging of this

** file. Please review the following information to ensure the GNU General

** Public License version 3.0 requirements will be met:

** http://www.gnu.org/copyleft/gpl.html.

**

** Other Usage

** Alternatively, this file may be used in accordance with the terms and

** conditions contained in a signed written agreement between you and Nokia.

**

**

**

**

**

** $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 <private/qt_s60_p.h>

#endif

#ifdef Q_WS_QPA

#include <QtGui/qplatformscreen_qpa.h>

#include <QtGui/private/qapplication_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);

    this_family = QFontDatabase::resolveFontFamilyAlias(this_family);

    other_family = QFontDatabase::resolveFontFamilyAlias(other_family);

    return (styleHint     == other.styleHint

            && styleStrategy == other.styleStrategy

            && weight        == other.weight

            && style        == other.style

            && this_family   == other_family

            && (styleName.isEmpty() || other.styleName.isEmpty() || styleName == other.styleName)

            && (this_foundry.isEmpty()

                || other_foundry.isEmpty()

                || this_foundry == other_foundry)

#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_WS_QPA)

    QPlatformIntegration *pi = QApplicationPrivate::platformIntegration();

    if (pi) {

        QPlatformScreen *screen = QApplicationPrivate::platformIntegration()->screens().at(0);

        const QSize screenSize = screen->geometry().size();

        const QSize physicalSize = screen->physicalSize();

        dpi = qRound(screenSize.width() / (physicalSize.width() / qreal(25.4)));

    } else {

        //PI has not been initialised, or it is being initialised. Give a default dpi

        dpi = 100;

    }

#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_WS_QPA)

    QPlatformIntegration *pi = QApplicationPrivate::platformIntegration();

    if (pi) {

        QPlatformScreen *screen = QApplicationPrivate::platformIntegration()->screens().at(0);

        const QSize screenSize = screen->geometry().size();

        const QSize physicalSize = screen->physicalSize();

        dpi = qRound(screenSize.height() / (physicalSize.height() / qreal(25.4)));

    } else {

        //PI has not been initialised, or it is being initialised. Give a default dpi

        dpi = 100;

    }

#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;

}

extern QMutex *qt_fontdatabase_mutex();

#if !defined(Q_WS_MAC)

#define QT_FONT_ENGINE_FROM_DATA(data, script) data->engines[script]

#else

#define QT_FONT_ENGINE_FROM_DATA(data, script) data->engine

#endif

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 || !QT_FONT_ENGINE_FROM_DATA(engineData, script))

        QFontDatabase::load(this, script);

    return QT_FONT_ENGINE_FROM_DATA(engineData, script);

}

void QFontPrivate::alterCharForCapitalization(QChar &c) const {

    switch (capital) {

    case QFont::AllUppercase:

    case QFont::SmallCaps:

        c = c.toUpper();

        break;

    case QFont::AllLowercase:

        c = c.toLower();

        break;

    case QFont::MixedCase:

        break;

    }

}

QFontPrivate *QFontPrivate::smallCapsFontPrivate() const

{

    if (scFont)

        return scFont;

    QFont font(const_cast<QFontPrivate *>(this));

    qreal pointSize = font.pointSizeF();

    if (pointSize > 0)

        font.setPointSizeF(pointSize * .7);

    else

        font.setPixelSize((font.pixelSize() * 7 + 5) / 10);

    scFont = font.d.data();

    if (scFont != this)

        scFont->ref.ref();

    return scFont;

}

void QFontPrivate::resolve(uint mask, const QFontPrivate *other)

{

    Q_ASSERT(other != 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::StyleNameResolved))

        request.styleName = other->request.styleName;

    if (! (mask & QFont::SizeResolved)) {

        request.pointSize = other->request.pointSize;

        request.pixelSize = other->request.pixelSize;

    }

    if (! (mask & QFont::StyleHintResolved))

        request.styleHint = other->request.styleHint;

    if (! (mask & QFont::StyleStrategyResolved))

        request.styleStrategy = other->request.styleStrategy;

    if (! (mask & QFont::WeightResolved))

        request.weight = other->request.weight;

    if (! (mask & QFont::StyleResolved))

        request.style = other->request.style;

    if (! (mask & QFont::FixedPitchResolved))

        request.fixedPitch = other->request.fixedPitch;

    if (! (mask & QFont::StretchResolved))

        request.stretch = other->request.stretch;

    if (! (mask & QFont::HintingPreferenceResolved))

        request.hintingPreference = other->request.hintingPreference;

    if (! (mask & QFont::UnderlineResolved))

        underline = other->underline;

    if (! (mask & QFont::OverlineResolved))

        overline = other->overline;

    if (! (mask & QFont::StrikeOutResolved))

        strikeOut = other->strikeOut;

    if (! (mask & QFont::KerningResolved))

        kerning = other->kerning;

    if (! (mask & QFont::LetterSpacingResolved)) {

        letterSpacing = other->letterSpacing;

        letterSpacingIsAbsolute = other->letterSpacingIsAbsolute;

    }

    if (! (mask & QFont::WordSpacingResolved))

        wordSpacing = other->wordSpacing;

    if (! (mask & QFont::CapitalizationResolved))

        capital = other->capital;

}

QFontEngineData::QFontEngineData()

    : ref(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;

    }

    if (italic)

        resolve_mask |= 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;

}

/*!

    \since 4.8

    Returns the requested font style name, it will be used to match the

    font with irregular styles (that can't be normalized in other style

    properties). It depends on system font support, thus only works for

    Mac OS X and X11 so far. On Windows irregular styles will be added

    as separate font families so there is no need for this.

    \sa setFamily() setStyle()

*/

QString QFont::styleName() const

{

    return d->request.styleName;

}

/*!

    \since 4.8

    Sets the style name of the font to the given \a styleName.

    When set, other style properties like style() and weight() will be ignored

    for font matching.

    \sa styleName()

*/

void QFont::setStyleName(const QString &styleName)

{

    detach();

    d->request.styleName = styleName;

    resolve_mask |= QFont::StyleNameResolved;

}

/*!

    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);

}

/*!

    \since 4.8

    \enum QFont::HintingPreference

    This enum describes the different levels of hinting that can be applied

    to glyphs to improve legibility on displays where it might be warranted

    by the density of pixels.

    \value PreferDefaultHinting Use the default hinting level for the target platform.

    \value PreferNoHinting If possible, render text without hinting the outlines

           of the glyphs. The text layout will be typographically accurate and

           scalable, using the same metrics as are used e.g. when printing.

    \value PreferVerticalHinting If possible, render text with no horizontal hinting,

           but align glyphs to the pixel grid in the vertical direction. The text will appear

           crisper on displays where the density is too low to give an accurate rendering

           of the glyphs. But since the horizontal metrics of the glyphs are unhinted, the text's

           layout will be scalable to higher density devices (such as printers) without impacting

           details such as line breaks.

    \value PreferFullHinting If possible, render text with hinting in both horizontal and

           vertical directions. The text will be altered to optimize legibility on the target

           device, but since the metrics will depend on the target size of the text, the positions

           of glyphs, line breaks, and other typographical detail will not scale, meaning that a

           text layout may look different on devices with different pixel densities.

    Please note that this enum only describes a preference, as the full range of hinting levels

    are not supported on all of Qt's supported platforms. The following table details the effect

    of a given hinting preference on a selected set of target platforms.

    \table

    \header

    \o

    \o PreferDefaultHinting

    \o PreferNoHinting

    \o PreferVerticalHinting

    \o PreferFullHinting

    \row

    \o Windows Vista (w/o Platform Update) and earlier

    \o Full hinting

    \o Full hinting

    \o Full hinting

    \o Full hinting

    \row

    \o Windows 7 and Windows Vista (w/Platform Update) and DirectWrite enabled in Qt

    \o Full hinting

    \o Vertical hinting

    \o Vertical hinting

    \o Full hinting

    \row

    \o FreeType

    \o Operating System setting

    \o No hinting

    \o Vertical hinting (light)

    \o Full hinting

    \row

    \o Cocoa on Mac OS X

    \o No hinting

    \o No hinting

    \o No hinting

    \o No hinting

    \endtable

    \note Please be aware that altering the hinting preference on Windows is available through

    the DirectWrite font engine. This is available on Windows Vista after installing the platform

    update, and on Windows 7. In order to use this extension, configure Qt using -directwrite.

    The target application will then depend on the availability of DirectWrite on the target

    system.

*/

/*!

    \since 4.8

    Set the preference for the hinting level of the glyphs to \a hintingPreference. This is a hint

    to the underlying font rendering system to use a certain level of hinting, and has varying

    support across platforms. See the table in the documentation for QFont::HintingPreference for

    more details.

    The default hinting preference is QFont::PreferDefaultHinting.

*/

void QFont::setHintingPreference(HintingPreference hintingPreference)

{

    detach();

    d->request.hintingPreference = hintingPreference;

    resolve_mask |= QFont::HintingPreferenceResolved;

}

/*!

    \since 4.8

    Returns the currently preferred hinting level for glyphs rendered with this font.

*/

QFont::HintingPreference QFont::hintingPreference() const

{

    return QFont::HintingPreference(d->request.hintingPreference);

}

/*!

    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 Monospace the font matcher prefers fonts that map to the

    CSS generic font-family 'monospace'.

    \value Fantasy the font matcher prefers fonts that map to the

    CSS generic font-family 'fantasy'.

    \value Cursive the font matcher prefers fonts that map to the

    CSS generic font-family 'cursive'.

    \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 the font selected for a certain writing system

           does not contain a character requested to draw, then Qt automatically chooses a similar

           looking font that contains the character. The NoFontMerging flag disables this feature.

           Please note that enabling this flag will not prevent Qt from automatically picking a

           suitable font when the selected font does not support the writing system of the text.

    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.

    \value ForceIntegerMetrics forces the use of integer values in font engines that support fractional

           font metrics.

*/

/*!

    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;

}

/*!