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

**

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

// #define FONTENGINE_DEBUG

#include <qapplication.h>

#include <qbytearray.h>

#include <qdebug.h>

#include <qtextcodec.h>

#include <qthread.h>

#include "qfontdatabase.h"

#include "qpaintdevice.h"

#include "qpainter.h"

#include "qvarlengtharray.h"

#include "qwidget.h"

#include "qsettings.h"

#include "qfile.h"

#include <private/qpaintengine_x11_p.h>

#include "qfont.h"

#include "qfont_p.h"

#include "qfontengine_p.h"

#include <qhash.h>

#include <private/qpainter_p.h>

#include <private/qunicodetables_p.h>

#include <private/qt_x11_p.h>

#include <private/qpixmap_x11_p.h>

#include "qx11info_x11.h"

#include "qfontengine_x11_p.h"

#include <limits.h>

#include <ft2build.h>

#if defined(FT_LCD_FILTER_H)

#include FT_LCD_FILTER_H

#endif

#if defined(FC_LCD_FILTER)

#ifndef FC_LCD_FILTER_NONE

#define FC_LCD_FILTER_NONE FC_LCD_NONE

#endif

#ifndef FC_LCD_FILTER_DEFAULT

#define FC_LCD_FILTER_DEFAULT FC_LCD_DEFAULT

#endif

#ifndef FC_LCD_FILTER_LIGHT

#define FC_LCD_FILTER_LIGHT FC_LCD_LIGHT

#endif

#ifndef FC_LCD_FILTER_LEGACY

#define FC_LCD_FILTER_LEGACY FC_LCD_LEGACY

#endif

#endif

QT_BEGIN_NAMESPACE

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

// Multi XLFD engine

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

QFontEngineMultiXLFD::QFontEngineMultiXLFD(const QFontDef &r, const QList<int> &l, int s)

    : QFontEngineMulti(l.size()), encodings(l), screen(s), request(r)

{

    loadEngine(0);

    fontDef = engines[0]->fontDef;

}

QFontEngineMultiXLFD::~QFontEngineMultiXLFD()

{ }

void QFontEngineMultiXLFD::loadEngine(int at)

{

    Q_ASSERT(at < engines.size());

    Q_ASSERT(engines.at(at) == 0);

    const int encoding = encodings.at(at);

    QFontEngine *fontEngine = QFontDatabase::loadXlfd(0, QUnicodeTables::Common, request, encoding);

    Q_ASSERT(fontEngine != 0);

    fontEngine->ref.ref();

    engines[at] = fontEngine;

}

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

// Xlfd font engine

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

#ifndef QT_NO_FREETYPE

static QStringList *qt_fontpath = 0;

static QStringList fontPath()

{

    if (qt_fontpath)

        return *qt_fontpath;

    // append qsettings fontpath

    QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));

    settings.beginGroup(QLatin1String("Qt"));

    QStringList fontpath;

    int npaths;

    char** font_path;

    font_path = XGetFontPath(X11->display, &npaths);

    bool xfsconfig_read = false;

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

        // If we're using xfs, append font paths from /etc/X11/fs/config

        // can't hurt, and chances are we'll get all fonts that way.

        if (((font_path[i])[0] != '/') && !xfsconfig_read) {

            // We're using xfs -> read its config

            bool finished = false;

            QFile f(QLatin1String("/etc/X11/fs/config"));

            if (!f.exists())

                f.setFileName(QLatin1String("/usr/X11R6/lib/X11/fs/config"));

            if (!f.exists())

                f.setFileName(QLatin1String("/usr/X11/lib/X11/fs/config"));

            if (f.exists()) {

                f.open(QIODevice::ReadOnly);

                while (f.error()==QFile::NoError && !finished) {

                    QString fs = QString::fromLocal8Bit(f.readLine(1024));

                    fs=fs.trimmed();

                    if (fs.left(9)==QLatin1String("catalogue") && fs.contains(QLatin1Char('='))) {

                        fs = fs.mid(fs.indexOf(QLatin1Char('=')) + 1).trimmed();

                        bool end = false;

                        while (f.error()==QFile::NoError && !end) {

                            if (fs[int(fs.length())-1] == QLatin1Char(','))

                                fs = fs.left(fs.length()-1);

                            else

                                end = true;

                            fs = fs.left(fs.indexOf(QLatin1String(":unscaled")));

                            if (fs[0] != QLatin1Char('#'))

                                fontpath += fs;

                            fs = QLatin1String(f.readLine(1024));

                            fs = fs.trimmed();

                            if (fs.isEmpty())

                                end = true;

                        }

                        finished = true;

                    }

                }

                f.close();

            }

            xfsconfig_read = true;

        } else {

            QString fs = QString::fromLocal8Bit(font_path[i]);

            fontpath += fs.left(fs.indexOf(QLatin1String(":unscaled")));

        }

    }

    XFreeFontPath(font_path);

    // append qsettings fontpath

    QStringList fp = settings.value(QLatin1String("fontPath")).toStringList();

    if (!fp.isEmpty())

        fontpath += fp;

    qt_fontpath = new QStringList(fontpath);

    return fontpath;

}

static QFontEngine::FaceId fontFile(const QByteArray &_xname, QFreetypeFace **freetype, int *synth)

{

    *freetype = 0;

    *synth = 0;

    QByteArray xname = _xname.toLower();

    int pos = 0;

    int minus = 0;

    while (minus < 5 && (pos = xname.indexOf('-', pos + 1)))

        ++minus;

    QByteArray searchname = xname.left(pos);

    while (minus < 12 && (pos = xname.indexOf('-', pos + 1)))

        ++minus;

    QByteArray encoding = xname.mid(pos + 1);

    //qDebug("xname='%s', searchname='%s', encoding='%s'", xname.data(), searchname.data(), encoding.data());

    QStringList fontpath = fontPath();

    QFontEngine::FaceId face_id;

    face_id.index = 0;

    QByteArray best_mapping;

    for (QStringList::ConstIterator it = fontpath.constBegin(); it != fontpath.constEnd(); ++it) {

        if (!(*it).startsWith(QLatin1Char('/')))

            continue; // not a path name, a font server

        QString fontmapname;

        int num = 0;

        // search font.dir and font.scale for the right file

        while (num < 2) {

            if (num == 0)

                fontmapname = (*it) + QLatin1String("/fonts.scale");

            else

                fontmapname = (*it) + QLatin1String("/fonts.dir");

            ++num;

            //qWarning(fontmapname);

            QFile fontmap(fontmapname);

            if (!fontmap.open(QIODevice::ReadOnly))

                continue;

            while (!fontmap.atEnd()) {

                QByteArray mapping = fontmap.readLine();

                QByteArray lmapping = mapping.toLower();

                //qWarning(xfontname);

                //qWarning(mapping);

                if (!lmapping.contains(searchname))

                    continue;

                int index = mapping.indexOf(' ');

                QByteArray ffn = mapping.mid(0,index);

                // remove bitmap formats freetype can't handle

                if (ffn.contains(".spd") || ffn.contains(".phont"))

                    continue;

                bool best_match = false;

                if (!best_mapping.isEmpty()) {

                    if (lmapping.contains("-0-0-0-0-")) { // scalable font

                        best_match = true;

                        goto found;

                    }

                    if (lmapping.contains(encoding) && !best_mapping.toLower().contains(encoding))

                        goto found;

                    continue;

                }

            found:

                int colon = ffn.lastIndexOf(':');

                if (colon != -1) {

                    QByteArray s = ffn.left(colon);

                    ffn = ffn.mid(colon + 1);

                    if (s.contains("ds="))

                        *synth |= QFontEngine::SynthesizedBold;

                    if (s.contains("ai="))

                        *synth |= QFontEngine::SynthesizedItalic;

                }

                face_id.filename = (*it).toLocal8Bit() + '/' + ffn;

                best_mapping = mapping;

                if (best_match)

                    goto end;

            }

        }

    }

end:

//     qDebug("fontfile for %s is from '%s'\n    got %s synth=%d", xname.data(),

//            best_mapping.data(), face_id.filename.data(), *synth);

    *freetype = QFreetypeFace::getFace(face_id);

    if (!*freetype) {

        face_id.index = 0;

        face_id.filename = QByteArray();

    }

    return face_id;

}

#endif // QT_NO_FREETYPE

// defined in qfontdatabase_x11.cpp

extern int qt_mib_for_xlfd_encoding(const char *encoding);

extern int qt_xlfd_encoding_id(const char *encoding);

static inline XCharStruct *charStruct(XFontStruct *xfs, uint ch)

{

    XCharStruct *xcs = 0;

    unsigned char r = ch>>8;

    unsigned char c = ch&0xff;

    if (xfs->per_char &&

         r >= xfs->min_byte1 &&

         r <= xfs->max_byte1 &&

         c >= xfs->min_char_or_byte2 &&

         c <= xfs->max_char_or_byte2) {

        xcs = xfs->per_char + ((r - xfs->min_byte1) *

                               (xfs->max_char_or_byte2 -

                                xfs->min_char_or_byte2 + 1)) +

              (c - xfs->min_char_or_byte2);

        if (xcs->width == 0 && xcs->ascent == 0 &&  xcs->descent == 0)

            xcs = 0;

    }

    return xcs;

}

QFontEngineXLFD::QFontEngineXLFD(XFontStruct *fs, const QByteArray &name, int mib)

    : _fs(fs), _name(name), _codec(0), _cmap(mib)

{

    if (_cmap) _codec = QTextCodec::codecForMib(_cmap);

    cache_cost = (((fs->max_byte1 - fs->min_byte1) *

                   (fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1)) +

                  fs->max_char_or_byte2 - fs->min_char_or_byte2);

    cache_cost = ((fs->max_bounds.ascent + fs->max_bounds.descent) *

                  (fs->max_bounds.width * cache_cost / 8));

    lbearing = SHRT_MIN;

    rbearing = SHRT_MIN;

    face_id.index = -1;

    freetype = 0;

    synth = 0;

}

QFontEngineXLFD::~QFontEngineXLFD()

{

    XFreeFont(QX11Info::display(), _fs);

    _fs = 0;

#ifndef QT_NO_FREETYPE

    if (freetype)

        freetype->release(face_id);

#endif

}

bool QFontEngineXLFD::stringToCMap(const QChar *s, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const

{

    if (*nglyphs < len) {

        *nglyphs = len;

        return false;

    }

    // filter out surrogates, we can't handle them anyway with XLFD fonts

    QVarLengthArray<ushort> _s(len);

    QChar *str = (QChar *)_s.data();

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

        if (i < len - 1

            && s[i].unicode() >= 0xd800 && s[i].unicode() < 0xdc00

            && s[i+1].unicode() >= 0xdc00 && s[i].unicode() < 0xe000) {

            *str = QChar();

            ++i;

        } else {

            *str = s[i];

        }

        ++str;

    }

    len = str - (QChar *)_s.data();

    str = (QChar *)_s.data();

    bool mirrored = flags & QTextEngine::RightToLeft;

    if (_codec) {

        bool haveNbsp = false;

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

            if (str[i].unicode() == 0xa0) {

                haveNbsp = true;

                break;

            }

        QVarLengthArray<unsigned short> ch(len);

        QChar *chars = (QChar *)ch.data();

        if (haveNbsp || mirrored) {

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

                chars[i] = (str[i].unicode() == 0xa0 ? 0x20 :

                            (mirrored ? QChar::mirroredChar(str[i].unicode()) : str[i].unicode()));

        } else {

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

                chars[i] = str[i].unicode();

        }

        QTextCodec::ConverterState state;

        state.flags = QTextCodec::ConvertInvalidToNull;

        QByteArray ba = _codec->fromUnicode(chars, len, &state);

        if (ba.length() == 2*len) {

            // double byte encoding

            const uchar *data = (const uchar *)ba.constData();

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

                glyphs->glyphs[i] = ((ushort)data[0] << 8) + data[1];

                data += 2;

            }

        } else {

            const uchar *data = (const uchar *)ba.constData();

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

                glyphs->glyphs[i] = (ushort)data[i];

        }

    } else {

        int i = len;

        const QChar *c = str + len;

        if (mirrored) {

            while (c != str)

                glyphs->glyphs[--i] = (--c)->unicode() == 0xa0 ? 0x20 : QChar::mirroredChar(c->unicode());

        } else {

            while (c != str)

                glyphs->glyphs[--i] = (--c)->unicode() == 0xa0 ? 0x20 : c->unicode();

        }

    }

    *nglyphs = len;

    glyphs->numGlyphs = len;

    if (!(flags & QTextEngine::GlyphIndicesOnly))

        recalcAdvances(glyphs, flags);

    return true;

}

void QFontEngineXLFD::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags /*flags*/) const

{

    int i = glyphs->numGlyphs;

    XCharStruct *xcs;

    // inlined for better perfomance

    if (!_fs->per_char) {

        xcs = &_fs->min_bounds;

        while (i != 0) {

            --i;

            const unsigned char r = glyphs->glyphs[i] >> 8;

            const unsigned char c = glyphs->glyphs[i] & 0xff;

            if (r >= _fs->min_byte1 &&

                r <= _fs->max_byte1 &&

                c >= _fs->min_char_or_byte2 &&

                c <= _fs->max_char_or_byte2) {

                glyphs->advances_x[i] = xcs->width;

            } else {

                glyphs->glyphs[i] = 0;

            }

        }

    }

    else if (!_fs->max_byte1) {

        XCharStruct *base = _fs->per_char - _fs->min_char_or_byte2;

        while (i != 0) {

            unsigned int gl = glyphs->glyphs[--i];

            xcs = (gl >= _fs->min_char_or_byte2 && gl <= _fs->max_char_or_byte2) ?

                  base + gl : 0;

            if (!xcs || (!xcs->width && !xcs->ascent && !xcs->descent)) {

                glyphs->glyphs[i] = 0;

            } else {

                glyphs->advances_x[i] = xcs->width;

            }

        }

    }

    else {

        while (i != 0) {

            xcs = charStruct(_fs, glyphs->glyphs[--i]);

            if (!xcs) {

                glyphs->glyphs[i] = 0;

            } else {

                glyphs->advances_x[i] = xcs->width;

            }

        }

    }

}

glyph_metrics_t QFontEngineXLFD::boundingBox(const QGlyphLayout &glyphs)

{

    int i;

    glyph_metrics_t overall;

    // initialize with line height, we get the same behaviour on all platforms

    overall.y = -ascent();

    overall.height = ascent() + descent() + 1;

    QFixed ymax;

    QFixed xmax;

    for (i = 0; i < glyphs.numGlyphs; i++) {

        XCharStruct *xcs = charStruct(_fs, glyphs.glyphs[i]);

        if (xcs) {

            QFixed x = overall.xoff + glyphs.offsets[i].x + xcs->lbearing;

            QFixed y = overall.yoff + glyphs.offsets[i].y - xcs->ascent;

            overall.x = qMin(overall.x, x);

            overall.y = qMin(overall.y, y);

            // XCharStruct::rbearing is defined as distance from left edge to rightmost pixel

            xmax = qMax(xmax, overall.xoff + glyphs.offsets[i].x + xcs->rbearing);

            ymax = qMax(ymax, y + xcs->ascent + xcs->descent);

            overall.xoff += glyphs.advances_x[i] + QFixed::fromFixed(glyphs.justifications[i].space_18d6);

        } else {

            QFixed size = _fs->ascent;

            overall.x = qMin(overall.x, overall.xoff);

            overall.y = qMin(overall.y, overall.yoff - size);

            ymax = qMax(ymax, overall.yoff);

            overall.xoff += size;

            xmax = qMax(xmax, overall.xoff);

        }

    }

    overall.height = qMax(overall.height, ymax - overall.y);

    overall.width = xmax - overall.x;

    return overall;

}

glyph_metrics_t QFontEngineXLFD::boundingBox(glyph_t glyph)

{

    glyph_metrics_t gm;

    XCharStruct *xcs = charStruct(_fs, glyph);

    if (xcs) {

        // XCharStruct::rbearing is defined as distance from left edge to rightmost pixel

        // XCharStruct::width is defined as the advance

        gm = glyph_metrics_t(xcs->lbearing, -xcs->ascent, xcs->rbearing- xcs->lbearing, xcs->ascent + xcs->descent,

                              xcs->width, 0);

    } else {

        QFixed size = ascent();

        gm = glyph_metrics_t(0, size, size, size, size, 0);

    }

    return gm;

}

QFixed QFontEngineXLFD::ascent() const

{

    return _fs->ascent;