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

**

** 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 <qdebug.h>

#include <private/qfontengine_p.h>

#include "qbitmap.h"

#include "qpainter.h"

#include "qpainterpath.h"

#include "qvarlengtharray.h"

#include <private/qpdf_p.h>

#include <qmath.h>

#include <qendian.h>

#include <private/qharfbuzz_p.h>

QT_BEGIN_NAMESPACE

static inline bool qtransform_equals_no_translate(const QTransform &a, const QTransform &b)

{

    if (a.type() <= QTransform::TxTranslate && b.type() <= QTransform::TxTranslate) {

        return true;

    } else {

        // We always use paths for perspective text anyway, so no

        // point in checking the full matrix...

        Q_ASSERT(a.type() < QTransform::TxProject);

        Q_ASSERT(b.type() < QTransform::TxProject);

        return a.m11() == b.m11()

            && a.m12() == b.m12()

            && a.m21() == b.m21()

            && a.m22() == b.m22();

    }

}

// Harfbuzz helper functions

static HB_Bool hb_stringToGlyphs(HB_Font font, const HB_UChar16 *string, hb_uint32 length, HB_Glyph *glyphs, hb_uint32 *numGlyphs, HB_Bool rightToLeft)

{

    QFontEngine *fe = (QFontEngine *)font->userData;

    QVarLengthGlyphLayoutArray qglyphs(*numGlyphs);

    QTextEngine::ShaperFlags shaperFlags(QTextEngine::GlyphIndicesOnly);

    if (rightToLeft)

        shaperFlags |= QTextEngine::RightToLeft;

    int nGlyphs = *numGlyphs;

    bool result = fe->stringToCMap(reinterpret_cast<const QChar *>(string), length, &qglyphs, &nGlyphs, shaperFlags);

    *numGlyphs = nGlyphs;

    if (!result)

        return false;

    for (hb_uint32 i = 0; i < *numGlyphs; ++i)

        glyphs[i] = qglyphs.glyphs[i];

    return true;

}

static void hb_getAdvances(HB_Font font, const HB_Glyph *glyphs, hb_uint32 numGlyphs, HB_Fixed *advances, int flags)

{

    QFontEngine *fe = (QFontEngine *)font->userData;

    QVarLengthGlyphLayoutArray qglyphs(numGlyphs);

    for (hb_uint32 i = 0; i < numGlyphs; ++i)

        qglyphs.glyphs[i] = glyphs[i];

    fe->recalcAdvances(&qglyphs, flags & HB_ShaperFlag_UseDesignMetrics ? QFlags<QTextEngine::ShaperFlag>(QTextEngine::DesignMetrics) : QFlags<QTextEngine::ShaperFlag>(0));

    for (hb_uint32 i = 0; i < numGlyphs; ++i)

        advances[i] = qglyphs.advances_x[i].value();

}

static HB_Bool hb_canRender(HB_Font font, const HB_UChar16 *string, hb_uint32 length)

{

    QFontEngine *fe = (QFontEngine *)font->userData;

    return fe->canRender(reinterpret_cast<const QChar *>(string), length);

}

static void hb_getGlyphMetrics(HB_Font font, HB_Glyph glyph, HB_GlyphMetrics *metrics)

{

    QFontEngine *fe = (QFontEngine *)font->userData;

    glyph_metrics_t m = fe->boundingBox(glyph);

    metrics->x = m.x.value();

    metrics->y = m.y.value();

    metrics->width = m.width.value();

    metrics->height = m.height.value();

    metrics->xOffset = m.xoff.value();

    metrics->yOffset = m.yoff.value();

}

static HB_Fixed hb_getFontMetric(HB_Font font, HB_FontMetric metric)

{

    if (metric == HB_FontAscent) {

        QFontEngine *fe = (QFontEngine *)font->userData;

        return fe->ascent().value();

    }

    return 0;

}

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

{

    Q_UNUSED(glyph)

    Q_UNUSED(flags)

    Q_UNUSED(point)

    Q_UNUSED(xpos)

    Q_UNUSED(ypos)

    Q_UNUSED(nPoints)

    return HB_Err_Not_Covered;

}

static HB_Error hb_getPointInOutline(HB_Font font, HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints)

{

    QFontEngine *fe = (QFontEngine *)font->userData;

    return fe->getPointInOutline(glyph, flags, point, xpos, ypos, nPoints);

}

static const HB_FontClass hb_fontClass = {

    hb_stringToGlyphs, hb_getAdvances, hb_canRender, hb_getPointInOutline,

    hb_getGlyphMetrics, hb_getFontMetric

};

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

{

    QFontEngine *fe = (QFontEngine *)font;

    if (!fe->getSfntTableData(tableTag, buffer, length))

        return HB_Err_Invalid_Argument;

    return HB_Err_Ok;

}

// QFontEngine

QFontEngine::QFontEngine()

    : QObject()

{

    ref = 0;

    cache_count = 0;

    fsType = 0;

    symbol = false;

    memset(&hbFont, 0, sizeof(hbFont));

    hbFont.klass = &hb_fontClass;

    hbFont.userData = this;

    hbFace = 0;

    glyphFormat = -1;

}

QFontEngine::~QFontEngine()

{

    for (QLinkedList<GlyphCacheEntry>::const_iterator it = m_glyphCaches.constBegin(),

            end = m_glyphCaches.constEnd(); it != end; ++it) {

        delete it->cache;

    }

    m_glyphCaches.clear();

    qHBFreeFace(hbFace);

}

QFixed QFontEngine::lineThickness() const

{

    // ad hoc algorithm

    int score = fontDef.weight * fontDef.pixelSize;

    int lw = score / 700;

    // looks better with thicker line for small pointsizes

    if (lw < 2 && score >= 1050) lw = 2;

    if (lw == 0) lw = 1;

    return lw;

}

QFixed QFontEngine::underlinePosition() const

{

    return ((lineThickness() * 2) + 3) / 6;

}

HB_Font QFontEngine::harfbuzzFont() const

{

    if (!hbFont.x_ppem) {

        QFixed emSquare = emSquareSize();

        hbFont.x_ppem = fontDef.pixelSize;

        hbFont.y_ppem = fontDef.pixelSize * fontDef.stretch / 100;

        hbFont.x_scale = (QFixed(hbFont.x_ppem * (1 << 16)) / emSquare).value();

        hbFont.y_scale = (QFixed(hbFont.y_ppem * (1 << 16)) / emSquare).value();

    }

    return &hbFont;

}

HB_Face QFontEngine::harfbuzzFace() const

{

    if (!hbFace) {

        hbFace = qHBNewFace(const_cast<QFontEngine *>(this), hb_getSFntTable);

        Q_CHECK_PTR(hbFace);

    }

    return hbFace;

}

glyph_metrics_t QFontEngine::boundingBox(glyph_t glyph, const QTransform &matrix)

{

    glyph_metrics_t metrics = boundingBox(glyph);

    if (matrix.type() > QTransform::TxTranslate) {

        return metrics.transformed(matrix);

    }

    return metrics;

}

QFixed QFontEngine::xHeight() const

{

    QGlyphLayoutArray<8> glyphs;

    int nglyphs = 7;

    QChar x((ushort)'x');

    stringToCMap(&x, 1, &glyphs, &nglyphs, QTextEngine::GlyphIndicesOnly);

    glyph_metrics_t bb = const_cast<QFontEngine *>(this)->boundingBox(glyphs.glyphs[0]);

    return bb.height;

}

QFixed QFontEngine::averageCharWidth() const

{

    QGlyphLayoutArray<8> glyphs;

    int nglyphs = 7;

    QChar x((ushort)'x');

    stringToCMap(&x, 1, &glyphs, &nglyphs, QTextEngine::GlyphIndicesOnly);

    glyph_metrics_t bb = const_cast<QFontEngine *>(this)->boundingBox(glyphs.glyphs[0]);

    return bb.xoff;

}

void QFontEngine::getGlyphPositions(const QGlyphLayout &glyphs, const QTransform &matrix, QTextItem::RenderFlags flags,

                                    QVarLengthArray<glyph_t> &glyphs_out, QVarLengthArray<QFixedPoint> &positions)

{

    QFixed xpos;

    QFixed ypos;

    const bool transform = matrix.m11() != 1.

                           || matrix.m12() != 0.

                           || matrix.m21() != 0.

                           || matrix.m22() != 1.;

    if (!transform) {

        xpos = QFixed::fromReal(matrix.dx());

        ypos = QFixed::fromReal(matrix.dy());

    }

    int current = 0;

    if (flags & QTextItem::RightToLeft) {

        int i = glyphs.numGlyphs;

        int totalKashidas = 0;

        while(i--) {

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

            ypos += glyphs.advances_y[i];

            totalKashidas += glyphs.justifications[i].nKashidas;

        }

        positions.resize(glyphs.numGlyphs+totalKashidas);

        glyphs_out.resize(glyphs.numGlyphs+totalKashidas);

        i = 0;

        while(i < glyphs.numGlyphs) {

            if (glyphs.attributes[i].dontPrint) {

                ++i;

                continue;

            }

            xpos -= glyphs.advances_x[i];

            ypos -= glyphs.advances_y[i];

            QFixed gpos_x = xpos + glyphs.offsets[i].x;

            QFixed gpos_y = ypos + glyphs.offsets[i].y;

            if (transform) {

                QPointF gpos(gpos_x.toReal(), gpos_y.toReal());

                gpos = gpos * matrix;

                gpos_x = QFixed::fromReal(gpos.x());

                gpos_y = QFixed::fromReal(gpos.y());

            }

            positions[current].x = gpos_x;

            positions[current].y = gpos_y;

            glyphs_out[current] = glyphs.glyphs[i];

            ++current;

            if (glyphs.justifications[i].nKashidas) {

                QChar ch(0x640); // Kashida character

                QGlyphLayoutArray<8> g;

                int nglyphs = 7;

                stringToCMap(&ch, 1, &g, &nglyphs, 0);

                for (uint k = 0; k < glyphs.justifications[i].nKashidas; ++k) {

                    xpos -= g.advances_x[0];

                    ypos -= g.advances_y[0];

                    QFixed gpos_x = xpos + glyphs.offsets[i].x;

                    QFixed gpos_y = ypos + glyphs.offsets[i].y;

                    if (transform) {

                        QPointF gpos(gpos_x.toReal(), gpos_y.toReal());

                        gpos = gpos * matrix;

                        gpos_x = QFixed::fromReal(gpos.x());

                        gpos_y = QFixed::fromReal(gpos.y());

                    }

                    positions[current].x = gpos_x;

                    positions[current].y = gpos_y;

                    glyphs_out[current] = g.glyphs[0];

                    ++current;

                }

            } else {

                xpos -= QFixed::fromFixed(glyphs.justifications[i].space_18d6);

            }

            ++i;

        }

    } else {

        positions.resize(glyphs.numGlyphs);

        glyphs_out.resize(glyphs.numGlyphs);

        int i = 0;

        if (!transform) {

            while (i < glyphs.numGlyphs) {

                if (!glyphs.attributes[i].dontPrint) {

                    positions[current].x = xpos + glyphs.offsets[i].x;

                    positions[current].y = ypos + glyphs.offsets[i].y;

                    glyphs_out[current] = glyphs.glyphs[i];

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

                    ypos += glyphs.advances_y[i];

                    ++current;

                }

                ++i;

            }

        } else {

            while (i < glyphs.numGlyphs) {

                if (!glyphs.attributes[i].dontPrint) {

                    QFixed gpos_x = xpos + glyphs.offsets[i].x;

                    QFixed gpos_y = ypos + glyphs.offsets[i].y;

                    QPointF gpos(gpos_x.toReal(), gpos_y.toReal());

                    gpos = gpos * matrix;

                    positions[current].x = QFixed::fromReal(gpos.x());

                    positions[current].y = QFixed::fromReal(gpos.y());

                    glyphs_out[current] = glyphs.glyphs[i];

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

                    ypos += glyphs.advances_y[i];

                    ++current;

                }

                ++i;

            }

        }

    }

    positions.resize(current);

    glyphs_out.resize(current);

    Q_ASSERT(positions.size() == glyphs_out.size());

}

glyph_metrics_t QFontEngine::tightBoundingBox(const QGlyphLayout &glyphs)

{

    glyph_metrics_t overall;

    QFixed ymax = 0;

    QFixed xmax = 0;

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

        glyph_metrics_t bb = boundingBox(glyphs.glyphs[i]);

        QFixed x = overall.xoff + glyphs.offsets[i].x + bb.x;

        QFixed y = overall.yoff + glyphs.offsets[i].y + bb.y;

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

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

        xmax = qMax(xmax, x + bb.width);

        ymax = qMax(ymax, y + bb.height);

        overall.xoff += bb.xoff;

        overall.yoff += bb.yoff;

    }

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

    overall.width = xmax - overall.x;

    return overall;

}

void QFontEngine::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path,

                                   QTextItem::RenderFlags flags)

{

    if (!glyphs.numGlyphs)

        return;

    QVarLengthArray<QFixedPoint> positions;

    QVarLengthArray<glyph_t> positioned_glyphs;

    QTransform matrix = QTransform::fromTranslate(x, y);

    getGlyphPositions(glyphs, matrix, flags, positioned_glyphs, positions);

    addGlyphsToPath(positioned_glyphs.data(), positions.data(), positioned_glyphs.size(), path, flags);

}

#define GRID(x, y) grid[(y)*(w+1) + (x)]

#define SET(x, y) (*(image_data + (y)*bpl + ((x) >> 3)) & (0x80 >> ((x) & 7)))

enum { EdgeRight = 0x1,

       EdgeDown = 0x2,

       EdgeLeft = 0x4,

       EdgeUp = 0x8

};

static void collectSingleContour(qreal x0, qreal y0, uint *grid, int x, int y, int w, int h, QPainterPath *path)

{

    Q_UNUSED(h);

    path->moveTo(x + x0, y + y0);

    while (GRID(x, y)) {

        if (GRID(x, y) & EdgeRight) {

            while (GRID(x, y) & EdgeRight) {

                GRID(x, y) &= ~EdgeRight;

                ++x;

            }

            Q_ASSERT(x <= w);

            path->lineTo(x + x0, y + y0);

            continue;

        }

        if (GRID(x, y) & EdgeDown) {

            while (GRID(x, y) & EdgeDown) {

                GRID(x, y) &= ~EdgeDown;

                ++y;

            }

            Q_ASSERT(y <= h);

            path->lineTo(x + x0, y + y0);

            continue;

        }

        if (GRID(x, y) & EdgeLeft) {

            while (GRID(x, y) & EdgeLeft) {

                GRID(x, y) &= ~EdgeLeft;

                --x;

            }

            Q_ASSERT(x >= 0);

            path->lineTo(x + x0, y + y0);

            continue;

        }

        if (GRID(x, y) & EdgeUp) {

            while (GRID(x, y) & EdgeUp) {

                GRID(x, y) &= ~EdgeUp;

                --y;

            }

            Q_ASSERT(y >= 0);

            path->lineTo(x + x0, y + y0);

            continue;

        }

    }

    path->closeSubpath();

}

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

{

    uint *grid = new uint[(w+1)*(h+1)];

    // set up edges

    for (int y = 0; y <= h; ++y) {

        for (int x = 0; x <= w; ++x) {

            bool topLeft = (x == 0)|(y == 0) ? false : SET(x - 1, y - 1);

            bool topRight = (x == w)|(y == 0) ? false : SET(x, y - 1);

            bool bottomLeft = (x == 0)|(y == h) ? false : SET(x - 1, y);

            bool bottomRight = (x == w)|(y == h) ? false : SET(x, y);

            GRID(x, y) = 0;

            if ((!topRight) & bottomRight)

                GRID(x, y) |= EdgeRight;

            if ((!bottomRight) & bottomLeft)

                GRID(x, y) |= EdgeDown;

            if ((!bottomLeft) & topLeft)

                GRID(x, y) |= EdgeLeft;

            if ((!topLeft) & topRight)

                GRID(x, y) |= EdgeUp;

        }

    }

    // collect edges

    for (int y = 0; y < h; ++y) {

        for (int x = 0; x < w; ++x) {

            if (!GRID(x, y))

                continue;

            // found start of a contour, follow it

            collectSingleContour(x0, y0, grid, x, y, w, h, path);

        }

    }

    delete [] grid;

}

#undef GRID

#undef SET

void QFontEngine::addBitmapFontToPath(qreal x, qreal y, const QGlyphLayout &glyphs,

                                      QPainterPath *path, QTextItem::RenderFlags flags)

{

// TODO what to do with 'flags' ??

    Q_UNUSED(flags);

    QFixed advanceX = QFixed::fromReal(x);

    QFixed advanceY = QFixed::fromReal(y);

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

        glyph_metrics_t metrics = boundingBox(glyphs.glyphs[i]);

        if (metrics.width.value() == 0 || metrics.height.value() == 0) {

            advanceX += glyphs.advances_x[i];

            advanceY += glyphs.advances_y[i];

            continue;

        }