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

**

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