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

**

** Copyright (C) 2009 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 "qt_windows.h"

#include <private/qapplication_p.h>

#include "qfont_p.h"

#include "qfontengine_p.h"

#include "qpaintdevice.h"

#include "qlibrary.h"

#include "qabstractfileengine.h"

#include "qendian.h"

#ifdef Q_OS_WINCE

#   include <QTemporaryFile>

#endif

QT_BEGIN_NAMESPACE

extern HDC   shared_dc();                // common dc for all fonts

#ifdef MAKE_TAG

#undef MAKE_TAG

#endif

// GetFontData expects the tags in little endian ;(

#define MAKE_TAG(ch1, ch2, ch3, ch4) (\

    (((quint32)(ch4)) << 24) | \

    (((quint32)(ch3)) << 16) | \

    (((quint32)(ch2)) << 8) | \

    ((quint32)(ch1)) \

   )

static HFONT stock_sysfont  = 0;

static bool localizedName(const QString &name)

{

    const QChar *c = name.unicode();

    for(int i = 0; i < name.length(); ++i) {

        if(c[i].unicode() >= 0x100)

            return true;

    }

    return false;

}

static inline quint16 getUShort(const unsigned char *p)

{

    quint16 val;

    val = *p++ << 8;

    val |= *p;

    return val;

}

static QString getEnglishName(const uchar *table, quint32 bytes)

{

    QString i18n_name;

    enum {

        NameRecordSize = 12,

        FamilyId = 1,

        MS_LangIdEnglish = 0x009

    };

    // get the name table

    quint16 count;

    quint16 string_offset;

    const unsigned char *names;

    int microsoft_id = -1;

    int apple_id = -1;

    int unicode_id = -1;

    if(getUShort(table) != 0)

        goto error;

    count = getUShort(table+2);

    string_offset = getUShort(table+4);

    names = table + 6;

    if(string_offset >= bytes || 6 + count*NameRecordSize > string_offset)

        goto error;

    for(int i = 0; i < count; ++i) {

        // search for the correct name entry

        quint16 platform_id = getUShort(names + i*NameRecordSize);

        quint16 encoding_id = getUShort(names + 2 + i*NameRecordSize);

        quint16 language_id = getUShort(names + 4 + i*NameRecordSize);

        quint16 name_id = getUShort(names + 6 + i*NameRecordSize);

        if(name_id != FamilyId)

            continue;

        enum {

            PlatformId_Unicode = 0,

            PlatformId_Apple = 1,

            PlatformId_Microsoft = 3

        };

        quint16 length = getUShort(names + 8 + i*NameRecordSize);

        quint16 offset = getUShort(names + 10 + i*NameRecordSize);

        if(DWORD(string_offset + offset + length) >= bytes)

            continue;

        if ((platform_id == PlatformId_Microsoft

            && (encoding_id == 0 || encoding_id == 1))

            && (language_id & 0x3ff) == MS_LangIdEnglish

            && microsoft_id == -1)

            microsoft_id = i;

            // not sure if encoding id 4 for Unicode is utf16 or ucs4...

        else if(platform_id == PlatformId_Unicode && encoding_id < 4 && unicode_id == -1)

            unicode_id = i;

        else if(platform_id == PlatformId_Apple && encoding_id == 0 && language_id == 0)

            apple_id = i;

    }

    {

        bool unicode = false;

        int id = -1;

        if(microsoft_id != -1) {

            id = microsoft_id;

            unicode = true;

        } else if(apple_id != -1) {

            id = apple_id;

            unicode = false;

        } else if (unicode_id != -1) {

            id = unicode_id;

            unicode = true;

        }

        if(id != -1) {

            quint16 length = getUShort(names + 8 + id*NameRecordSize);

            quint16 offset = getUShort(names + 10 + id*NameRecordSize);

            if(unicode) {

                // utf16

                length /= 2;

                i18n_name.resize(length);

                QChar *uc = (QChar *) i18n_name.unicode();

                const unsigned char *string = table + string_offset + offset;

                for(int i = 0; i < length; ++i)

                    uc[i] = getUShort(string + 2*i);

            } else {

                // Apple Roman

                i18n_name.resize(length);

                QChar *uc = (QChar *) i18n_name.unicode();

                const unsigned char *string = table + string_offset + offset;

                for(int i = 0; i < length; ++i)

                    uc[i] = QLatin1Char(string[i]);

            }

        }

    }

  error:

    //qDebug("got i18n name of '%s' for font '%s'", i18n_name.latin1(), familyName.toLocal8Bit().data());

    return i18n_name;

}

static QString getEnglishName(const QString &familyName)

{

    QString i18n_name;

    HDC hdc = GetDC( 0 );

    LOGFONT lf;

    memset(&lf, 0, sizeof(LOGFONT));

    memcpy(lf.lfFaceName, familyName.utf16(), qMin(LF_FACESIZE, familyName.length()) * sizeof(wchar_t));

    lf.lfCharSet = DEFAULT_CHARSET;

    HFONT hfont = CreateFontIndirect(&lf);

    if(!hfont) {

        ReleaseDC(0, hdc);

        return QString();

    }

    HGDIOBJ oldobj = SelectObject( hdc, hfont );

    const DWORD name_tag = MAKE_TAG( 'n', 'a', 'm', 'e' );

    // get the name table

    unsigned char *table = 0;

    DWORD bytes = GetFontData( hdc, name_tag, 0, 0, 0 );

    if ( bytes == GDI_ERROR ) {

        // ### Unused variable

        /* int err = GetLastError(); */

        goto error;

    }

    table = new unsigned char[bytes];

    GetFontData(hdc, name_tag, 0, table, bytes);

    if ( bytes == GDI_ERROR )

        goto error;

    i18n_name = getEnglishName(table, bytes);

error:

    delete [] table;

    SelectObject( hdc, oldobj );

    DeleteObject( hfont );

    ReleaseDC( 0, hdc );

    //qDebug("got i18n name of '%s' for font '%s'", i18n_name.latin1(), familyName.toLocal8Bit().data());

    return i18n_name;

}

static

void addFontToDatabase(QString familyName, const QString &scriptName,

                       TEXTMETRIC *textmetric,

                       const FONTSIGNATURE *signature,

                       int type)

{

    const int script = -1;

    const QString foundryName;

    Q_UNUSED(script);

    bool italic = false;

    int weight;

    bool fixed;

    bool ttf;

    bool scalable;

    int size;

//    QString escript = QString::fromWCharArray(f->elfScript);

//    qDebug("script=%s", escript.latin1());

    NEWTEXTMETRIC *tm = (NEWTEXTMETRIC *)textmetric;

    fixed = !(tm->tmPitchAndFamily & TMPF_FIXED_PITCH);

    ttf = (tm->tmPitchAndFamily & TMPF_TRUETYPE);

    scalable = tm->tmPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE);

    size = scalable ? SMOOTH_SCALABLE : tm->tmHeight;

    italic = tm->tmItalic;

    weight = tm->tmWeight;

    // the "@family" fonts are just the same as "family". Ignore them.

    if (familyName[0] != QLatin1Char('@') && !familyName.startsWith(QLatin1String("WST_"))) {

        QtFontStyle::Key styleKey;

        styleKey.style = italic ? QFont::StyleItalic : QFont::StyleNormal;

        if (weight < 400)

            styleKey.weight = QFont::Light;

        else if (weight < 600)

            styleKey.weight = QFont::Normal;

        else if (weight < 700)

            styleKey.weight = QFont::DemiBold;

        else if (weight < 800)

            styleKey.weight = QFont::Bold;

        else

            styleKey.weight = QFont::Black;

        QtFontFamily *family = privateDb()->family(familyName, true);

        if(ttf && localizedName(familyName) && family->english_name.isEmpty())

            family->english_name = getEnglishName(familyName);

        QtFontFoundry *foundry = family->foundry(foundryName, true);

        QtFontStyle *style = foundry->style(styleKey, true);

        style->smoothScalable = scalable;

        style->pixelSize( size, TRUE);

        // add fonts windows can generate for us:

        if (styleKey.weight <= QFont::DemiBold) {

            QtFontStyle::Key key(styleKey);

            key.weight = QFont::Bold;

            QtFontStyle *style = foundry->style(key, true);

            style->smoothScalable = scalable;

            style->pixelSize( size, TRUE);

        }

        if (styleKey.style != QFont::StyleItalic) {

            QtFontStyle::Key key(styleKey);

            key.style = QFont::StyleItalic;

            QtFontStyle *style = foundry->style(key, true);

            style->smoothScalable = scalable;

            style->pixelSize( size, TRUE);

        }

        if (styleKey.weight <= QFont::DemiBold && styleKey.style != QFont::StyleItalic) {

            QtFontStyle::Key key(styleKey);

            key.weight = QFont::Bold;

            key.style = QFont::StyleItalic;

            QtFontStyle *style = foundry->style(key, true);

            style->smoothScalable = scalable;

            style->pixelSize( size, TRUE);

        }

        family->fixedPitch = fixed;

        if (!family->writingSystemCheck && type & TRUETYPE_FONTTYPE) {

            quint32 unicodeRange[4] = {

                signature->fsUsb[0], signature->fsUsb[1],

                signature->fsUsb[2], signature->fsUsb[3]

            };

#ifdef Q_WS_WINCE

            if (signature->fsUsb[0] == 0) {

                // If the unicode ranges bit mask is zero then

                // EnumFontFamiliesEx failed to determine it properly.

                // In this case we just pretend that the font supports all languages.

                unicodeRange[0] = 0xbfffffff;   // second most significant bit must be zero

                unicodeRange[1] = 0xffffffff;

                unicodeRange[2] = 0xffffffff;

                unicodeRange[3] = 0xffffffff;

            }

#endif

            quint32 codePageRange[2] = {

                signature->fsCsb[0], signature->fsCsb[1]

            };

            QList<QFontDatabase::WritingSystem> systems = determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange);

            for (int i = 0; i < systems.count(); ++i)

                family->writingSystems[systems.at(i)] = QtFontFamily::Supported;

        } else if (!family->writingSystemCheck) {

            //qDebug("family='%s' script=%s", family->name.latin1(), script.latin1());

            if (scriptName == QLatin1String("Western")

                || scriptName == QLatin1String("Baltic")

                || scriptName == QLatin1String("Central European")

                || scriptName == QLatin1String("Turkish")

                || scriptName == QLatin1String("Vietnamese"))

                family->writingSystems[QFontDatabase::Latin] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Thai"))

                family->writingSystems[QFontDatabase::Thai] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Symbol")

                     || scriptName == QLatin1String("Other"))

                family->writingSystems[QFontDatabase::Symbol] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("OEM/Dos"))

                family->writingSystems[QFontDatabase::Latin] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("CHINESE_GB2312"))

                family->writingSystems[QFontDatabase::SimplifiedChinese] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("CHINESE_BIG5"))

                family->writingSystems[QFontDatabase::TraditionalChinese] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Cyrillic"))

                family->writingSystems[QFontDatabase::Cyrillic] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Hangul"))

                family->writingSystems[QFontDatabase::Korean] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Hebrew"))

                family->writingSystems[QFontDatabase::Hebrew] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Greek"))

                family->writingSystems[QFontDatabase::Greek] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Japanese"))

                family->writingSystems[QFontDatabase::Japanese] = QtFontFamily::Supported;

            else if (scriptName == QLatin1String("Arabic"))

                family->writingSystems[QFontDatabase::Arabic] = QtFontFamily::Supported;

        }

    }

}

static

int CALLBACK

storeFont(ENUMLOGFONTEX* f, NEWTEXTMETRICEX *textmetric, int type, LPARAM /*p*/)

{

    QString familyName = QString::fromWCharArray(f->elfLogFont.lfFaceName);

    QString script = QString::fromWCharArray(f->elfScript);

    FONTSIGNATURE signature = textmetric->ntmFontSig;

    // NEWTEXTMETRICEX is a NEWTEXTMETRIC, which according to the documentation is

    // identical to a TEXTMETRIC except for the last four members, which we don't use

    // anyway

    addFontToDatabase(familyName, script, (TEXTMETRIC *)textmetric, &signature, type);

    // keep on enumerating

    return 1;

}

static

void populate_database(const QString& fam)

{

    QFontDatabasePrivate *d = privateDb();

    if (!d)

        return;

    QtFontFamily *family = 0;

    if(!fam.isEmpty()) {

        family = d->family(fam);

        if(family && family->loaded)

            return;

    } else if (d->count) {

        return;

    }

    HDC dummy = GetDC(0);

    LOGFONT lf;

    lf.lfCharSet = DEFAULT_CHARSET;

    if (fam.isNull()) {

        lf.lfFaceName[0] = 0;

    } else {

        memcpy(lf.lfFaceName, fam.utf16(), sizeof(wchar_t) * qMin(fam.length() + 1, 32));  // 32 = Windows hard-coded

    }

    lf.lfPitchAndFamily = 0;

    EnumFontFamiliesEx(dummy, &lf,

        (FONTENUMPROC)storeFont, (LPARAM)privateDb(), 0);

    ReleaseDC(0, dummy);

    for (int i = 0; i < d->applicationFonts.count(); ++i) {

        QFontDatabasePrivate::ApplicationFont fnt = d->applicationFonts.at(i);

        if (!fnt.memoryFont)

            continue;

        for (int j = 0; j < fnt.families.count(); ++j) {

            const QString familyName = fnt.families.at(j);

            HDC hdc = GetDC(0);

            LOGFONT lf;

            memset(&lf, 0, sizeof(LOGFONT));

            memcpy(lf.lfFaceName, familyName.utf16(), sizeof(wchar_t) * qMin(LF_FACESIZE, familyName.size()));

            lf.lfCharSet = DEFAULT_CHARSET;

            HFONT hfont = CreateFontIndirect(&lf);

            HGDIOBJ oldobj = SelectObject(hdc, hfont);

            TEXTMETRIC textMetrics;

            GetTextMetrics(hdc, &textMetrics);

            addFontToDatabase(familyName, QString(),

                              &textMetrics,

                              &fnt.signatures.at(j),

                              TRUETYPE_FONTTYPE);

            SelectObject(hdc, oldobj);

            DeleteObject(hfont);

            ReleaseDC(0, hdc);

        }

    }

    if(!fam.isEmpty()) {

        family = d->family(fam);

        if(family) {

            if(!family->writingSystemCheck) {

            }

            family->loaded = true;

        }

    }

}

static void initializeDb()

{

    QFontDatabasePrivate *db = privateDb();

    if (!db || db->count)

        return;

    populate_database(QString());

#ifdef QFONTDATABASE_DEBUG

    // print the database

    for (int f = 0; f < db->count; f++) {

        QtFontFamily *family = db->families[f];

        qDebug("    %s: %p", qPrintable(family->name), family);

        populate_database(family->name);

#if 0

        qDebug("        scripts supported:");

        for (int i = 0; i < QUnicodeTables::ScriptCount; i++)

            if(family->writingSystems[i] & QtFontFamily::Supported)

                qDebug("            %d", i);

        for (int fd = 0; fd < family->count; fd++) {

            QtFontFoundry *foundry = family->foundries[fd];

            qDebug("        %s", foundry->name.latin1());

            for (int s = 0; s < foundry->count; s++) {

                QtFontStyle *style = foundry->styles[s];

                qDebug("            style: style=%d weight=%d smooth=%d",  style->key.style,

                       style->key.weight, style->smoothScalable );

                if(!style->smoothScalable) {

                    for(int i = 0; i < style->count; ++i) {

                        qDebug("                %d", style->pixelSizes[i].pixelSize);

                    }

                }

            }

        }

#endif

    }

#endif // QFONTDATABASE_DEBUG

}

static inline void load(const QString &family = QString(), int = -1)

{

    populate_database(family);

}

// --------------------------------------------------------------------------------------

// font loader

// --------------------------------------------------------------------------------------

static void initFontInfo(QFontEngineWin *fe, const QFontDef &request, const QFontPrivate *fp)

{

    fe->fontDef = request;                                // most settings are equal

    HDC dc = ((request.styleStrategy & QFont::PreferDevice) && fp->hdc) ? fp->hdc : shared_dc();

    SelectObject(dc, fe->hfont);

    wchar_t n[64];

    GetTextFace(dc, 64, n);

    fe->fontDef.family = QString::fromWCharArray(n);

    fe->fontDef.fixedPitch = !(fe->tm.tmPitchAndFamily & TMPF_FIXED_PITCH);

    if (fe->fontDef.pointSize < 0) {

        fe->fontDef.pointSize = fe->fontDef.pixelSize * 72. / fp->dpi;