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

**

** 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 "qdir.h"

#include "qscreen_qws.h" //so we can check for rotation

#include "qwindowsystem_qws.h"

#include "qlibraryinfo.h"

#include "qabstractfileengine.h"

#include <QtCore/qsettings.h>

#if !defined(QT_NO_FREETYPE)

#include "qfontengine_ft_p.h"

#include <ft2build.h>

#include FT_FREETYPE_H

#endif

#include "qfontengine_qpf_p.h"

#include "private/qfactoryloader_p.h"

#include "private/qcore_unix_p.h" // overrides QT_OPEN

#include "qabstractfontengine_qws.h"

#include "qabstractfontengine_p.h"

#include <qdatetime.h>

#include "qplatformdefs.h"

// for mmap

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <errno.h>

#ifdef QT_FONTS_ARE_RESOURCES

#include <qresource.h>

#endif

QT_BEGIN_NAMESPACE

#ifndef QT_NO_LIBRARY

Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,

    (QFontEngineFactoryInterface_iid, QLatin1String("/fontengines"), Qt::CaseInsensitive))

#endif

const quint8 DatabaseVersion = 4;

// QFontDatabasePrivate::addFont() went into qfontdatabase.cpp

#ifndef QT_NO_QWS_QPF2

void QFontDatabasePrivate::addQPF2File(const QByteArray &file)

{

#ifndef QT_FONTS_ARE_RESOURCES

    struct stat st;

    if (stat(file.constData(), &st))

        return;

    int f = QT_OPEN(file, O_RDONLY, 0);

    if (f < 0)

        return;

    const uchar *data = (const uchar *)mmap(0, st.st_size, PROT_READ, MAP_SHARED, f, 0);

    const int dataSize = st.st_size;

#else

    QResource res(QLatin1String(file.constData()));

    const uchar *data = res.data();

    const int dataSize = res.size();

    //qDebug() << "addQPF2File" << file << data;

#endif

    if (data && data != (const uchar *)MAP_FAILED) {

        if (QFontEngineQPF::verifyHeader(data, dataSize)) {

            QString fontName = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_FontName).toString();

            int pixelSize = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_PixelSize).toInt();

            QVariant weight = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_Weight);

            QVariant style = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_Style);

            QByteArray writingSystemBits = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_WritingSystems).toByteArray();

            if (!fontName.isEmpty() && pixelSize) {

                int fontWeight = 50;

                if (weight.type() == QVariant::Int || weight.type() == QVariant::UInt)

                    fontWeight = weight.toInt();

                bool italic = static_cast<QFont::Style>(style.toInt()) & QFont::StyleItalic;

                QList<QFontDatabase::WritingSystem> writingSystems;

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

                    uchar currentByte = writingSystemBits.at(i);

                    for (int j = 0; j < 8; ++j) {

                        if (currentByte & 1)

                            writingSystems << QFontDatabase::WritingSystem(i * 8 + j);

                        currentByte >>= 1;

                    }

                }

                addFont(fontName, /*foundry*/ "prerendered", fontWeight, italic,

                        pixelSize, file, /*fileIndex*/ 0,

                        /*antialiased*/ true, writingSystems);

            }

        } else {

            qDebug() << "header verification of QPF2 font" << file << "failed. maybe it is corrupt?";

        }

#ifndef QT_FONTS_ARE_RESOURCES

        munmap((void *)data, st.st_size);

#endif

    }

#ifndef QT_FONTS_ARE_RESOURCES

    QT_CLOSE(f);

#endif

}

#endif // QT_NO_QWS_QPF2

// QFontDatabasePrivate::addTTFile() went into qfontdatabase.cpp

static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt);

extern QString qws_fontCacheDir();

#ifndef QT_FONTS_ARE_RESOURCES

bool QFontDatabasePrivate::loadFromCache(const QString &fontPath)

{

    const bool weAreTheServer = QWSServer::instance();

    QString fontDirFile = fontPath + QLatin1String("/fontdir");

    QFile binaryDb(qws_fontCacheDir() + QLatin1String("/fontdb"));

    if (weAreTheServer) {

        QDateTime dbTimeStamp = QFileInfo(binaryDb.fileName()).lastModified();

        QDateTime fontPathTimeStamp = QFileInfo(fontPath).lastModified();

        if (dbTimeStamp < fontPathTimeStamp)

            return false; // let the caller create the cache

        if (QFile::exists(fontDirFile)) {

            QDateTime fontDirTimeStamp = QFileInfo(fontDirFile).lastModified();

            if (dbTimeStamp < fontDirTimeStamp)

                return false;

        }

    }

    if (!binaryDb.open(QIODevice::ReadOnly)) {

        if (weAreTheServer)

            return false; // let the caller create the cache

        qFatal("QFontDatabase::loadFromCache: Could not open font database cache!");

    }

    QDataStream stream(&binaryDb);

    quint8 version = 0;

    quint8 dataStreamVersion = 0;

    stream >> version >> dataStreamVersion;

    if (version != DatabaseVersion || dataStreamVersion != stream.version()) {

        if (weAreTheServer)

            return false; // let the caller create the cache

        qFatal("QFontDatabase::loadFromCache: Wrong version of the font database cache detected. Found %d/%d expected %d/%d",

               version, dataStreamVersion, DatabaseVersion, stream.version());

    }

    QString originalFontPath;

    stream >> originalFontPath;

    if (originalFontPath != fontPath) {

        if (weAreTheServer)

            return false; // let the caller create the cache

        qFatal("QFontDatabase::loadFromCache: Font path doesn't match. Found %s in database, expected %s", qPrintable(originalFontPath), qPrintable(fontPath));

    }

    QString familyname;

    stream >> familyname;

    //qDebug() << "populating database from" << binaryDb.fileName();

    while (!familyname.isEmpty() && !stream.atEnd()) {

        QString foundryname;

        int weight;

        quint8 italic;

        int pixelSize;

        QByteArray file;

        int fileIndex;

        quint8 antialiased;

        quint8 writingSystemCount;

        QList<QFontDatabase::WritingSystem> writingSystems;

        stream >> foundryname >> weight >> italic >> pixelSize

               >> file >> fileIndex >> antialiased >> writingSystemCount;

        for (quint8 i = 0; i < writingSystemCount; ++i) {

            quint8 ws;

            stream >> ws;

            writingSystems.append(QFontDatabase::WritingSystem(ws));

        }

        addFont(familyname, foundryname.toLatin1().constData(), weight, italic, pixelSize, file, fileIndex, antialiased,

                writingSystems);

        stream >> familyname;

    }

    stream >> fallbackFamilies;

    //qDebug() << "fallback families from cache:" << fallbackFamilies;

    return true;

}

#endif // QT_FONTS_ARE_RESOURCES

/*!

    \internal

*/

static QString qwsFontPath()

{

    QString fontpath = QString::fromLocal8Bit(qgetenv("QT_QWS_FONTDIR"));

    if (fontpath.isEmpty()) {

#ifdef QT_FONTS_ARE_RESOURCES

        fontpath = QLatin1String(":/qt/fonts");

#else

#ifndef QT_NO_SETTINGS

        fontpath = QLibraryInfo::location(QLibraryInfo::LibrariesPath);

        fontpath += QLatin1String("/fonts");

#else

        fontpath = QLatin1String("/lib/fonts");

#endif

#endif //QT_FONTS_ARE_RESOURCES

    }

    return fontpath;

}

#if defined(QFONTDATABASE_DEBUG) && defined(QT_FONTS_ARE_RESOURCES)

class FriendlyResource : public QResource

{

public:

    bool isDir () const { return QResource::isDir(); }

    bool isFile () const { return QResource::isFile(); }

    QStringList children () const { return QResource::children(); }

};

#endif

/*!

    \internal

*/

static void initializeDb()

{

    QFontDatabasePrivate *db = privateDb();

    if (!db || db->count)

        return;

    QString fontpath = qwsFontPath();

#ifndef QT_FONTS_ARE_RESOURCES

    QString fontDirFile = fontpath + QLatin1String("/fontdir");

    if(!QFile::exists(fontpath)) {

        qFatal("QFontDatabase: Cannot find font directory %s - is Qt installed correctly?",

               fontpath.toLocal8Bit().constData());

    }

    const bool loaded = db->loadFromCache(fontpath);

    if (db->reregisterAppFonts) {

        db->reregisterAppFonts = false;

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

            if (!db->applicationFonts.at(i).families.isEmpty()) {

                registerFont(&db->applicationFonts[i]);

            }

    }

    if (loaded)

        return;

    QString dbFileName = qws_fontCacheDir() + QLatin1String("/fontdb");

    QFile binaryDb(dbFileName + QLatin1String(".tmp"));

    binaryDb.open(QIODevice::WriteOnly | QIODevice::Truncate);

    db->stream = new QDataStream(&binaryDb);

    *db->stream << DatabaseVersion << quint8(db->stream->version()) << fontpath;

//    qDebug() << "creating binary database at" << binaryDb.fileName();

    // Load in font definition file

    FILE* fontdef=fopen(fontDirFile.toLocal8Bit().constData(),"r");

    if (fontdef) {

        char buf[200]="";

        char name[200]="";

        char render[200]="";

        char file[200]="";

        char isitalic[10]="";

        char flags[10]="";

        do {

            fgets(buf,200,fontdef);

            if (buf[0] != '#') {

                int weight=50;

                int size=0;

                sscanf(buf,"%s %s %s %s %d %d %s",name,file,render,isitalic,&weight,&size,flags);

                QString filename;

                if (file[0] != '/')

                    filename.append(fontpath).append(QLatin1Char('/'));

                filename += QLatin1String(file);

                bool italic = isitalic[0] == 'y';

                bool smooth = QByteArray(flags).contains('s');

                if (file[0] && QFile::exists(filename))

                    db->addFont(QString::fromUtf8(name), /*foundry*/"", weight, italic, size/10, QFile::encodeName(filename), /*fileIndex*/ 0, smooth);

            }

        } while (!feof(fontdef));

        fclose(fontdef);

    }

    QDir dir(fontpath, QLatin1String("*.qpf"));

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

        int u0 = dir[i].indexOf(QLatin1Char('_'));

        int u1 = dir[i].indexOf(QLatin1Char('_'), u0+1);

        int u2 = dir[i].indexOf(QLatin1Char('_'), u1+1);

        int u3 = dir[i].indexOf(QLatin1Char('.'), u1+1);

        if (u2 < 0) u2 = u3;

        QString familyname = dir[i].left(u0);

        int pixelSize = dir[i].mid(u0+1,u1-u0-1).toInt()/10;

        bool italic = dir[i].mid(u2-1,1) == QLatin1String("i");

        int weight = dir[i].mid(u1+1,u2-u1-1-(italic?1:0)).toInt();

        db->addFont(familyname, /*foundry*/ "qt", weight, italic, pixelSize, QFile::encodeName(dir.absoluteFilePath(dir[i])),

                    /*fileIndex*/ 0, /*antialiased*/ true);

    }

#ifndef QT_NO_FREETYPE

    dir.setNameFilters(QStringList() << QLatin1String("*.ttf")

                       << QLatin1String("*.ttc") << QLatin1String("*.pfa")

                       << QLatin1String("*.pfb"));

    dir.refresh();

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

        const QByteArray file = QFile::encodeName(dir.absoluteFilePath(dir[i]));

//        qDebug() << "looking at" << file;

        db->addTTFile(file);

    }

#endif

#ifndef QT_NO_QWS_QPF2

    dir.setNameFilters(QStringList() << QLatin1String("*.qpf2"));

    dir.refresh();

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

        const QByteArray file = QFile::encodeName(dir.absoluteFilePath(dir[i]));

//        qDebug() << "looking at" << file;

        db->addQPF2File(file);

    }

#endif

#else //QT_FONTS_ARE_RESOURCES

#ifdef QFONTDATABASE_DEBUG

    {

        QResource fontdir(fontpath);

        FriendlyResource *fr = static_cast<FriendlyResource*>(&fontdir);

        qDebug() << "fontdir" << fr->isValid() << fr->isDir() << fr->children();

    }

#endif

    QDir dir(fontpath, QLatin1String("*.qpf2"));

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

        const QByteArray file = QFile::encodeName(dir.absoluteFilePath(dir[i]));

        //qDebug() << "looking at" << file;

        db->addQPF2File(file);

    }

#endif //QT_FONTS_ARE_RESOURCES

#ifdef QFONTDATABASE_DEBUG

    // print the database

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

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

        FD_DEBUG("'%s' %s", qPrintable(family->name), (family->fixedPitch ? "fixed" : ""));

#if 0

        for (int i = 0; i < QFont::LastPrivateScript; ++i) {

            FD_DEBUG("\t%s: %s", qPrintable(QFontDatabase::scriptName((QFont::Script) i)),

                     ((family->scripts[i] & QtFontFamily::Supported) ? "Supported" :

                      (family->scripts[i] & QtFontFamily::UnSupported) == QtFontFamily::UnSupported ?

                      "UnSupported" : "Unknown"));

        }

#endif

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

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

            FD_DEBUG("\t\t'%s'", qPrintable(foundry->name));

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

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

                FD_DEBUG("\t\t\tstyle: style=%d weight=%d\n"

                         "\t\t\tstretch=%d",

                         style->key.style, style->key.weight,

                         style->key.stretch);

                if (style->smoothScalable)

                    FD_DEBUG("\t\t\t\tsmooth scalable");

                else if (style->bitmapScalable)

                    FD_DEBUG("\t\t\t\tbitmap scalable");

                if (style->pixelSizes) {

                    FD_DEBUG("\t\t\t\t%d pixel sizes",  style->count);

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

                        QtFontSize *size = style->pixelSizes + z;

                        FD_DEBUG("\t\t\t\t  size %5d",

                                  size->pixelSize);

                    }

                }

            }

        }

    }

#endif // QFONTDATABASE_DEBUG

#ifndef QT_NO_LIBRARY

    QStringList pluginFoundries = loader()->keys();

//    qDebug() << "plugin foundries:" << pluginFoundries;

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

        const QString foundry(pluginFoundries.at(i));

        QFontEngineFactoryInterface *factory = qobject_cast<QFontEngineFactoryInterface *>(loader()->instance(foundry));

        if (!factory) {

            qDebug() << "Could not load plugin for foundry" << foundry;

            continue;

        }

        QList<QFontEngineInfo> fonts = factory->availableFontEngines();

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

            QFontEngineInfo info = fonts.at(i);

            int weight = info.weight();

            if (weight <= 0)

                weight = QFont::Normal;

            db->addFont(info.family(), foundry.toLatin1().constData(),

                        weight, info.style() != QFont::StyleNormal,

                        qRound(info.pixelSize()), /*file*/QByteArray(),

                        /*fileIndex*/0, /*antiAliased*/true,

                        info.writingSystems());

        }

    }

#endif

#ifndef QT_FONTS_ARE_RESOURCES

    // the empty string/familyname signifies the end of the font list.

    *db->stream << QString();

#endif

    {

        bool coveredWritingSystems[QFontDatabase::WritingSystemsCount] = { 0 };

        db->fallbackFamilies.clear();

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

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

            bool add = false;

            if (family->count == 0)

                continue;

            if (family->bogusWritingSystems)

                continue;

            for (int ws = 1; ws < QFontDatabase::WritingSystemsCount; ++ws) {

                if (coveredWritingSystems[ws])

                    continue;

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

                    coveredWritingSystems[ws] = true;

                    add = true;

                }

            }

            if (add)

                db->fallbackFamilies << family->name;

        }

        //qDebug() << "fallbacks on the server:" << db->fallbackFamilies;

#ifndef QT_FONTS_ARE_RESOURCES

        *db->stream << db->fallbackFamilies;

#endif

    }

#ifndef QT_FONTS_ARE_RESOURCES

    delete db->stream;

    db->stream = 0;

    QFile::remove(dbFileName);

    binaryDb.rename(dbFileName);

#endif

}

// called from qwindowsystem_qws.cpp

void qt_qws_init_fontdb()

{

    initializeDb();

}

#ifndef QT_NO_SETTINGS

// called from qapplication_qws.cpp

void qt_applyFontDatabaseSettings(const QSettings &settings)

{

    initializeDb();

    QFontDatabasePrivate *db = privateDb();

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

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

        if (settings.contains(family->name))

            family->fallbackFamilies = settings.value(family->name).toStringList();

    }

    if (settings.contains(QLatin1String("Global Fallbacks")))

        db->fallbackFamilies = settings.value(QLatin1String("Global Fallbacks")).toStringList();

}

#endif // QT_NO_SETTINGS

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

{

    initializeDb();