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

**

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

#include "qtextstream.h"

#include "qvariant.h"

#include "qfontengine_ft_p.h"

#ifndef QT_NO_FREETYPE

#include "qfile.h"

#include "qabstractfileengine.h"

#include "qthreadstorage.h"

#include <qmath.h>

#include <private/qpdf_p.h>

#include <private/qharfbuzz_p.h>

#include "qfontengine_ft_p.h"

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_OUTLINE_H

#include FT_TRUETYPE_TABLES_H

#include FT_TYPE1_TABLES_H

#include FT_GLYPH_H

#if defined(FT_LCD_FILTER_H)

#include FT_LCD_FILTER_H

#endif

#if defined(FT_CONFIG_OPTIONS_H)

#include FT_CONFIG_OPTIONS_H

#endif

#if defined(FT_LCD_FILTER_H) && defined(FT_CONFIG_OPTION_SUBPIXEL_RENDERING)

#define QT_USE_FREETYPE_LCDFILTER

#endif

#ifdef QT_LINUXBASE

#include FT_ERRORS_H

#endif

QT_BEGIN_NAMESPACE

/*

 * Freetype 2.1.7 and earlier used width/height

 * for matching sizes in the BDF and PCF loaders.

 * This has been fixed for 2.1.8.

 */

#if (FREETYPE_MAJOR*10000+FREETYPE_MINOR*100+FREETYPE_PATCH) >= 20105

#define X_SIZE(face,i) ((face)->available_sizes[i].x_ppem)

#define Y_SIZE(face,i) ((face)->available_sizes[i].y_ppem)

#else

#define X_SIZE(face,i) ((face)->available_sizes[i].width << 6)

#define Y_SIZE(face,i) ((face)->available_sizes[i].height << 6)

#endif

#define FLOOR(x)    ((x) & -64)

#define CEIL(x)	    (((x)+63) & -64)

#define TRUNC(x)    ((x) >> 6)

#define ROUND(x)    (((x)+32) & -64)

static HB_Error hb_getSFntTable(void *font, HB_Tag tableTag, HB_Byte *buffer, HB_UInt *length)

{

#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) > 20103

    FT_Face face = (FT_Face)font;

    FT_ULong ftlen = *length;

    FT_Error error = 0;

    if ( !FT_IS_SFNT(face) )

        return HB_Err_Invalid_Argument;

    error = FT_Load_Sfnt_Table(face, tableTag, 0, buffer, &ftlen);

    *length = ftlen;

    return (HB_Error)error;

#else

    return HB_Err_Invalid_Argument;

#endif

}

// -------------------------- Freetype support ------------------------------

class QtFreetypeData

{

public:

    QtFreetypeData()

        : library(0)

    { }

    FT_Library library;

    QHash<QFontEngine::FaceId, QFreetypeFace *> faces;

};

#ifdef QT_NO_THREAD

Q_GLOBAL_STATIC(QtFreetypeData, theFreetypeData)

QtFreetypeData *qt_getFreetypeData()

{

    return theFreetypeData();

}

#else

Q_GLOBAL_STATIC(QThreadStorage<QtFreetypeData *>, theFreetypeData)

QtFreetypeData *qt_getFreetypeData()

{

    QtFreetypeData *&freetypeData = theFreetypeData()->localData();

    if (!freetypeData)

        freetypeData = new QtFreetypeData;

    return freetypeData;

}

#endif

FT_Library qt_getFreetype()

{

    QtFreetypeData *freetypeData = qt_getFreetypeData();

    if (!freetypeData->library)

        FT_Init_FreeType(&freetypeData->library);

    return freetypeData->library;

}

int QFreetypeFace::fsType() const

{

    int fsType = 0;

    TT_OS2 *os2 = (TT_OS2 *)FT_Get_Sfnt_Table(face, ft_sfnt_os2);

    if (os2)

        fsType = os2->fsType;

    return fsType;

}

HB_Error QFreetypeFace::getPointInOutline(HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints)

{

    int load_flags = (flags & HB_ShaperFlag_UseDesignMetrics) ? FT_LOAD_NO_HINTING : FT_LOAD_DEFAULT;

    if (HB_Error error = (HB_Error)FT_Load_Glyph(face, glyph, load_flags))

        return error;

    if (face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)

        return HB_Err_Invalid_SubTable;

    *nPoints = face->glyph->outline.n_points;

    if (!(*nPoints))

        return HB_Err_Ok;

    if (point > *nPoints)

        return HB_Err_Invalid_SubTable;

    *xpos = face->glyph->outline.points[point].x;

    *ypos = face->glyph->outline.points[point].y;

    return HB_Err_Ok;

}

/*

 * One font file can contain more than one font (bold/italic for example)

 * find the right one and return it.

 *

 * Returns the freetype face or 0 in case of an empty file or any other problems

 * (like not being able to open the file)

 */

QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id)

{

    if (face_id.filename.isEmpty())

        return 0;

    QtFreetypeData *freetypeData = qt_getFreetypeData();

    if (!freetypeData->library)

        FT_Init_FreeType(&freetypeData->library);

    QFreetypeFace *freetype = freetypeData->faces.value(face_id, 0);

    if (freetype) {

        freetype->ref.ref();

    } else {

        QScopedPointer<QFreetypeFace> newFreetype(new QFreetypeFace);

        FT_Face face;

        QFile file(QString::fromUtf8(face_id.filename));

        if (face_id.filename.startsWith(":qmemoryfonts/")) {

            // from qfontdatabase.cpp

            extern QByteArray qt_fontdata_from_index(int);

            QByteArray idx = face_id.filename;

            idx.remove(0, 14); // remove ':qmemoryfonts/'

            bool ok = false;

            newFreetype->fontData = qt_fontdata_from_index(idx.toInt(&ok));

            if (!ok)

                newFreetype->fontData = QByteArray();

        } else if (!(file.fileEngine()->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::LocalDiskFlag)) {

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

                return 0;

            }

            newFreetype->fontData = file.readAll();

        }

        if (!newFreetype->fontData.isEmpty()) {

            if (FT_New_Memory_Face(freetypeData->library, (const FT_Byte *)newFreetype->fontData.constData(), newFreetype->fontData.size(), face_id.index, &face)) {

                return 0;

            }

        } else if (FT_New_Face(freetypeData->library, face_id.filename, face_id.index, &face)) {

            return 0;

        }

        newFreetype->face = face;

        newFreetype->hbFace = qHBNewFace(face, hb_getSFntTable);

        Q_CHECK_PTR(newFreetype->hbFace);

        newFreetype->ref = 1;

        newFreetype->xsize = 0;

        newFreetype->ysize = 0;

        newFreetype->matrix.xx = 0x10000;

        newFreetype->matrix.yy = 0x10000;

        newFreetype->matrix.xy = 0;

        newFreetype->matrix.yx = 0;

        newFreetype->unicode_map = 0;

        newFreetype->symbol_map = 0;

#ifndef QT_NO_FONTCONFIG

        newFreetype->charset = 0;

#endif

        memset(newFreetype->cmapCache, 0, sizeof(newFreetype->cmapCache));

        for (int i = 0; i < newFreetype->face->num_charmaps; ++i) {

            FT_CharMap cm = newFreetype->face->charmaps[i];

            switch(cm->encoding) {

            case FT_ENCODING_UNICODE:

                newFreetype->unicode_map = cm;

                break;

            case FT_ENCODING_APPLE_ROMAN:

            case FT_ENCODING_ADOBE_LATIN_1:

                if (!newFreetype->unicode_map || newFreetype->unicode_map->encoding != FT_ENCODING_UNICODE)

                    newFreetype->unicode_map = cm;

                break;

            case FT_ENCODING_ADOBE_CUSTOM:

            case FT_ENCODING_MS_SYMBOL:

                if (!newFreetype->symbol_map)

                    newFreetype->symbol_map = cm;

                break;

            default:

                break;

            }

        }

        if (!FT_IS_SCALABLE(newFreetype->face) && newFreetype->face->num_fixed_sizes == 1)

            FT_Set_Char_Size (face, X_SIZE(newFreetype->face, 0), Y_SIZE(newFreetype->face, 0), 0, 0);

# if 0

        FcChar8 *name;

        FcPatternGetString(pattern, FC_FAMILY, 0, &name);

        qDebug("%s: using maps: default: %x unicode: %x, symbol: %x", name,

               newFreetype->face->charmap ? newFreetype->face->charmap->encoding : 0,

               newFreetype->unicode_map ? newFreetype->unicode_map->encoding : 0,

               newFreetype->symbol_map ? newFreetype->symbol_map->encoding : 0);

        for (int i = 0; i < 256; i += 8)

            qDebug("    %x: %d %d %d %d %d %d %d %d", i,

                   FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i),

                   FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i),

                   FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i),

                   FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i));

#endif

        FT_Set_Charmap(newFreetype->face, newFreetype->unicode_map);

        QT_TRY {

            freetypeData->faces.insert(face_id, newFreetype.data());

        } QT_CATCH(...) {

            newFreetype.take()->release(face_id);

            // we could return null in principle instead of throwing

            QT_RETHROW;

        }

        freetype = newFreetype.take();

    }

    return freetype;

}

void QFreetypeFace::release(const QFontEngine::FaceId &face_id)

{

    QtFreetypeData *freetypeData = qt_getFreetypeData();

    if (!ref.deref()) {

        qHBFreeFace(hbFace);

        FT_Done_Face(face);

#ifndef QT_NO_FONTCONFIG

        if (charset)

            FcCharSetDestroy(charset);

#endif

        if(freetypeData->faces.contains(face_id))

            freetypeData->faces.take(face_id);

        delete this;

    }

    if (freetypeData->faces.isEmpty()) {

        FT_Done_FreeType(freetypeData->library);

        freetypeData->library = 0;

    }

}

void QFreetypeFace::computeSize(const QFontDef &fontDef, int *xsize, int *ysize, bool *outline_drawing)

{

    *ysize = qRound(fontDef.pixelSize * 64);

    *xsize = *ysize * fontDef.stretch / 100;

    *outline_drawing = false;

    /*

     * Bitmap only faces must match exactly, so find the closest

     * one (height dominant search)

     */

    if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) {

        int best = 0;

        for (int i = 1; i < face->num_fixed_sizes; i++) {

            if (qAbs(*ysize -  Y_SIZE(face,i)) <

                qAbs (*ysize - Y_SIZE(face, best)) ||

                (qAbs (*ysize - Y_SIZE(face, i)) ==

                 qAbs (*ysize - Y_SIZE(face, best)) &&

                 qAbs (*xsize - X_SIZE(face, i)) <

                 qAbs (*xsize - X_SIZE(face, best)))) {

                best = i;

            }

        }

        if (FT_Set_Char_Size (face, X_SIZE(face, best), Y_SIZE(face, best), 0, 0) == 0) {

            *xsize = X_SIZE(face, best);

            *ysize = Y_SIZE(face, best);

        } else {

            int err = 1;

            if (!(face->face_flags & FT_FACE_FLAG_SCALABLE) && ysize == 0 && face->num_fixed_sizes >= 1) {

                // work around FT 2.1.10 problem with BDF without PIXEL_SIZE property

                err = FT_Set_Pixel_Sizes(face, face->available_sizes[0].width, face->available_sizes[0].height);

                if (err && face->num_fixed_sizes == 1)

                    err = 0; //even more of a workaround...

            }

            if (err)

                *xsize = *ysize = 0;

        }

    } else {

        *outline_drawing = (*xsize > (64<<6) || *ysize > (64<<6));

    }

}

QFontEngine::Properties QFreetypeFace::properties() const

{

    QFontEngine::Properties p;

    p.postscriptName = FT_Get_Postscript_Name(face);

    PS_FontInfoRec font_info;

    if (FT_Get_PS_Font_Info(face, &font_info) == 0)

        p.copyright = font_info.notice;

    if (FT_IS_SCALABLE(face)) {

        p.ascent = face->ascender;

        p.descent = -face->descender;

        p.leading = face->height - face->ascender + face->descender;

        p.emSquare = face->units_per_EM;

        p.boundingBox = QRectF(face->bbox.xMin, -face->bbox.yMax,

                               face->bbox.xMax - face->bbox.xMin,

                               face->bbox.yMax - face->bbox.yMin);

    } else {

        p.ascent = QFixed::fromFixed(face->size->metrics.ascender);

        p.descent = QFixed::fromFixed(-face->size->metrics.descender);

        p.leading = QFixed::fromFixed(face->size->metrics.height - face->size->metrics.ascender + face->size->metrics.descender);

        p.emSquare = face->size->metrics.y_ppem;

//        p.boundingBox = QRectF(-p.ascent.toReal(), 0, (p.ascent + p.descent).toReal(), face->size->metrics.max_advance/64.);

        p.boundingBox = QRectF(0, -p.ascent.toReal(),

                               face->size->metrics.max_advance/64, (p.ascent + p.descent).toReal() );

    }

    p.italicAngle = 0;

    p.capHeight = p.ascent;

    p.lineWidth = face->underline_thickness;

    return p;

}

bool QFreetypeFace::getSfntTable(uint tag, uchar *buffer, uint *length) const

{

    bool result = false;

#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) > 20103

    if (FT_IS_SFNT(face)) {

        FT_ULong len = *length;

        result = FT_Load_Sfnt_Table(face, tag, 0, buffer, &len) == FT_Err_Ok;

        *length = len;

    }

#endif

    return result;

}

/* Some fonts (such as MingLiu rely on hinting to scale different

   components to their correct sizes. While this is really broken (it

   should be done in the component glyph itself, not the hinter) we

   will have to live with it.

   This means we can not use FT_LOAD_NO_HINTING to get the glyph

   outline. All we can do is to load the unscaled glyph and scale it

   down manually when required.

*/

static void scaleOutline(FT_Face face, FT_GlyphSlot g, FT_Fixed x_scale, FT_Fixed y_scale)

{

    x_scale = FT_MulDiv(x_scale, 1 << 10, face->units_per_EM);

    y_scale = FT_MulDiv(y_scale, 1 << 10, face->units_per_EM);

    FT_Vector *p = g->outline.points;

    const FT_Vector *e = p + g->outline.n_points;

    while (p < e) {

        p->x = FT_MulFix(p->x, x_scale);

        p->y = FT_MulFix(p->y, y_scale);

        ++p;

    }

}

void QFreetypeFace::addGlyphToPath(FT_Face face, FT_GlyphSlot g, const QFixedPoint &point, QPainterPath *path, FT_Fixed x_scale, FT_Fixed y_scale)

{

    const qreal factor = 1/64.;

    scaleOutline(face, g, x_scale, y_scale);

    QPointF cp = point.toPointF();

    // convert the outline to a painter path

    int i = 0;

    for (int j = 0; j < g->outline.n_contours; ++j) {

        int last_point = g->outline.contours[j];

        QPointF start = cp + QPointF(g->outline.points[i].x*factor, -g->outline.points[i].y*factor);

        if(!(g->outline.tags[i] & 1)) {

            start += cp + QPointF(g->outline.points[last_point].x*factor, -g->outline.points[last_point].y*factor);

            start /= 2;

        }

//         qDebug("contour: %d -- %d", i, g->outline.contours[j]);

//         qDebug("first point at %f %f", start.x(), start.y());

        path->moveTo(start);

        QPointF c[4];

        c[0] = start;

        int n = 1;

        while (i < last_point) {

            ++i;

            c[n] = cp + QPointF(g->outline.points[i].x*factor, -g->outline.points[i].y*factor);

//             qDebug() << "    i=" << i << " flag=" << (int)g->outline.tags[i] << "point=" << c[n];

            ++n;

            switch (g->outline.tags[i] & 3) {

            case 2:

                // cubic bezier element

                if (n < 4)

                    continue;

                c[3] = (c[3] + c[2])/2;

                --i;

                break;

            case 0:

                // quadratic bezier element

                if (n < 3)

                    continue;

                c[3] = (c[1] + c[2])/2;

                c[2] = (2*c[1] + c[3])/3;

                c[1] = (2*c[1] + c[0])/3;

                --i;

                break;

            case 1:

            case 3:

                if (n == 2) {

//                     qDebug() << "lineTo" << c[1];

                    path->lineTo(c[1]);

                    c[0] = c[1];

                    n = 1;

                    continue;

                } else if (n == 3) {

                    c[3] = c[2];

                    c[2] = (2*c[1] + c[3])/3;

                    c[1] = (2*c[1] + c[0])/3;

                }

                break;

            }

//             qDebug() << "cubicTo" << c[1] << c[2] << c[3];

            path->cubicTo(c[1], c[2], c[3]);

            c[0] = c[3];

            n = 1;

        }

        if (n == 1) {

//             qDebug() << "closeSubpath";

            path->closeSubpath();

        } else {

            c[3] = start;

            if (n == 2) {

                c[2] = (2*c[1] + c[3])/3;

                c[1] = (2*c[1] + c[0])/3;

            }

//             qDebug() << "cubicTo" << c[1] << c[2] << c[3];

            path->cubicTo(c[1], c[2], c[3]);

        }

        ++i;

    }

}

extern void qt_addBitmapToPath(qreal x0, qreal y0, const uchar *image_data, int bpl, int w, int h, QPainterPath *path);

void QFreetypeFace::addBitmapToPath(FT_GlyphSlot slot, const QFixedPoint &point, QPainterPath *path, bool)

{

    if (slot->format != FT_GLYPH_FORMAT_BITMAP

        || slot->bitmap.pixel_mode != FT_PIXEL_MODE_MONO)

        return;

    QPointF cp = point.toPointF();

    qt_addBitmapToPath(cp.x() + TRUNC(slot->metrics.horiBearingX), cp.y() - TRUNC(slot->metrics.horiBearingY),

                       slot->bitmap.buffer, slot->bitmap.pitch, slot->bitmap.width, slot->bitmap.rows, path);

}