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

**

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

#include "qtextengine_p.h"

#include <qglobal.h>

#include "qt_windows.h"

#include <private/qapplication_p.h>

#include <qlibrary.h>

#include <qpaintdevice.h>

#include <qpainter.h>

#include <limits.h>

#include <qendian.h>

#include <qmath.h>

#include <qthreadstorage.h>

#include <private/qunicodetables_p.h>

#include <qbitmap.h>

#include <private/qpainter_p.h>

#include <private/qpdf_p.h>

#include "qpaintengine.h"

#include "qvarlengtharray.h"

#include <private/qpaintengine_raster_p.h>

#include <private/qnativeimage_p.h>

#if defined(Q_WS_WINCE)

#include "qguifunctions_wince.h"

#endif

//### mingw needed define

#ifndef TT_PRIM_CSPLINE

#define TT_PRIM_CSPLINE 3

#endif

#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)) \

   )

// common DC for all fonts

QT_BEGIN_NAMESPACE

class QtHDC

{

    HDC _hdc;

public:

    QtHDC()

    {

        HDC displayDC = GetDC(0);

        _hdc = CreateCompatibleDC(displayDC);

        ReleaseDC(0, displayDC);

    }

    ~QtHDC()

    {

        if (_hdc)

            DeleteDC(_hdc);

    }

    HDC hdc() const

    {

        return _hdc;

    }

};

#ifndef QT_NO_THREAD

Q_GLOBAL_STATIC(QThreadStorage<QtHDC *>, local_shared_dc)

HDC shared_dc()

{

    QtHDC *&hdc = local_shared_dc()->localData();

    if (!hdc)

        hdc = new QtHDC;

    return hdc->hdc();

}

#else

HDC shared_dc()

{

    return 0;

}

#endif

#ifndef Q_WS_WINCE

typedef BOOL (WINAPI *PtrGetCharWidthI)(HDC, UINT, UINT, LPWORD, LPINT);

static PtrGetCharWidthI ptrGetCharWidthI = 0;

static bool resolvedGetCharWidthI = false;

static void resolveGetCharWidthI()

{

    if (resolvedGetCharWidthI)

        return;

    resolvedGetCharWidthI = true;

    ptrGetCharWidthI = (PtrGetCharWidthI)QLibrary::resolve(QLatin1String("gdi32"), "GetCharWidthI");

}

#endif // !defined(Q_WS_WINCE)

// defined in qtextengine_win.cpp

typedef void *SCRIPT_CACHE;

typedef HRESULT (WINAPI *fScriptFreeCache)(SCRIPT_CACHE *);

extern fScriptFreeCache ScriptFreeCache;

static inline quint32 getUInt(unsigned char *p)

{

    quint32 val;

    val = *p++ << 24;

    val |= *p++ << 16;

    val |= *p++ << 8;

    val |= *p;

    return val;

}

static inline quint16 getUShort(unsigned char *p)

{

    quint16 val;

    val = *p++ << 8;

    val |= *p;

    return val;

}

// general font engine

QFixed QFontEngineWin::lineThickness() const

{

    if(lineWidth > 0)

        return lineWidth;

    return QFontEngine::lineThickness();

}

static OUTLINETEXTMETRIC *getOutlineTextMetric(HDC hdc)

{

    int size;

    size = GetOutlineTextMetrics(hdc, 0, 0);

    OUTLINETEXTMETRIC *otm = (OUTLINETEXTMETRIC *)malloc(size);

    GetOutlineTextMetrics(hdc, size, otm);

    return otm;

}

void QFontEngineWin::getCMap()

{

    ttf = (bool)(tm.tmPitchAndFamily & TMPF_TRUETYPE);

    HDC hdc = shared_dc();

    SelectObject(hdc, hfont);

    bool symb = false;

    if (ttf) {

        cmapTable = getSfntTable(qbswap<quint32>(MAKE_TAG('c', 'm', 'a', 'p')));

        int size = 0;

        cmap = QFontEngine::getCMap(reinterpret_cast<const uchar *>(cmapTable.constData()),

                       cmapTable.size(), &symb, &size);

    }

    if (!cmap) {

        ttf = false;

        symb = false;

    }

    symbol = symb;

    designToDevice = 1;

    _faceId.index = 0;

    if(cmap) {

        OUTLINETEXTMETRIC *otm = getOutlineTextMetric(hdc);

        designToDevice = QFixed((int)otm->otmEMSquare)/int(otm->otmTextMetrics.tmHeight);

        unitsPerEm = otm->otmEMSquare;

        x_height = (int)otm->otmsXHeight;

        loadKerningPairs(designToDevice);

        _faceId.filename = QString::fromWCharArray((wchar_t *)((char *)otm + (int)otm->otmpFullName)).toLatin1();

        lineWidth = otm->otmsUnderscoreSize;

        fsType = otm->otmfsType;

        free(otm);

    } else {

        unitsPerEm = tm.tmHeight;

    }

}

inline unsigned int getChar(const QChar *str, int &i, const int len)

{

    unsigned int uc = str[i].unicode();

    if (uc >= 0xd800 && uc < 0xdc00 && i < len-1) {

        uint low = str[i+1].unicode();

       if (low >= 0xdc00 && low < 0xe000) {

            uc = (uc - 0xd800)*0x400 + (low - 0xdc00) + 0x10000;

            ++i;

        }

    }

    return uc;

}

int QFontEngineWin::getGlyphIndexes(const QChar *str, int numChars, QGlyphLayout *glyphs, bool mirrored) const

{

    int i = 0;

    int glyph_pos = 0;

    if (mirrored) {

#if defined(Q_WS_WINCE)

        {

#else

        if (symbol) {

            for (; i < numChars; ++i, ++glyph_pos) {

                unsigned int uc = getChar(str, i, numChars);

                glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, uc);

                if (!glyphs->glyphs[glyph_pos] && uc < 0x100)

                    glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, uc + 0xf000);

            }

        } else if (ttf) {

            for (; i < numChars; ++i, ++glyph_pos) {

                unsigned int uc = getChar(str, i, numChars);

                glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, QChar::mirroredChar(uc));

            }

        } else {

#endif

            wchar_t first = tm.tmFirstChar;

            wchar_t last = tm.tmLastChar;

            for (; i < numChars; ++i, ++glyph_pos) {

                uint ucs = QChar::mirroredChar(getChar(str, i, numChars));

                if (

#ifdef Q_WS_WINCE

                    tm.tmFirstChar > 60000 || // see line 375

#endif

                        ucs >= first && ucs <= last)

                    glyphs->glyphs[glyph_pos] = ucs;

                else

                    glyphs->glyphs[glyph_pos] = 0;

            }

        }

    } else {

#if defined(Q_WS_WINCE)

        {

#else

        if (symbol) {

            for (; i < numChars; ++i, ++glyph_pos) {

                unsigned int uc = getChar(str, i, numChars);

                glyphs->glyphs[i] = getTrueTypeGlyphIndex(cmap, uc);

                if(!glyphs->glyphs[glyph_pos] && uc < 0x100)

                    glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, uc + 0xf000);

            }

        } else if (ttf) {

            for (; i < numChars; ++i, ++glyph_pos) {

                unsigned int uc = getChar(str, i, numChars);

                glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, uc);

            }

        } else {

#endif

            wchar_t first = tm.tmFirstChar;

            wchar_t last = tm.tmLastChar;

            for (; i < numChars; ++i, ++glyph_pos) {

                uint uc = getChar(str, i, numChars);

                if (

#ifdef Q_WS_WINCE

                    tm.tmFirstChar > 60000 || // see comment in QFontEngineWin

#endif

                        uc >= first && uc <= last)

                    glyphs->glyphs[glyph_pos] = uc;

                else

                    glyphs->glyphs[glyph_pos] = 0;

            }

        }

    }

    glyphs->numGlyphs = glyph_pos;

    return glyph_pos;

}

QFontEngineWin::QFontEngineWin(const QString &name, HFONT _hfont, bool stockFont, LOGFONT lf)

{

    //qDebug("regular windows font engine created: font='%s', size=%d", name, lf.lfHeight);

    _name = name;

    cmap = 0;

    hfont = _hfont;

    logfont = lf;

    HDC hdc = shared_dc();

    SelectObject(hdc, hfont);

    this->stockFont = stockFont;

    fontDef.pixelSize = -lf.lfHeight;

    lbearing = SHRT_MIN;

    rbearing = SHRT_MIN;

    synthesized_flags = -1;

    lineWidth = -1;

    x_height = -1;

    BOOL res = GetTextMetrics(hdc, &tm);

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

    if (!res) {

        qErrnoWarning("QFontEngineWin: GetTextMetrics failed");

        ZeroMemory(&tm, sizeof(TEXTMETRIC));

    }

    cache_cost = tm.tmHeight * tm.tmAveCharWidth * 2000;

    getCMap();

    widthCache = 0;

    widthCacheSize = 0;

    designAdvances = 0;

    designAdvancesSize = 0;

#ifndef Q_WS_WINCE

    if (!resolvedGetCharWidthI)

        resolveGetCharWidthI();

#endif

}

QFontEngineWin::~QFontEngineWin()

{

    if (designAdvances)

        free(designAdvances);

    if (widthCache)

        free(widthCache);

    // make sure we aren't by accident still selected

    SelectObject(shared_dc(), (HFONT)GetStockObject(SYSTEM_FONT));

    if (!stockFont) {

        if (!DeleteObject(hfont))

            qErrnoWarning("QFontEngineWin: failed to delete non-stock font...");

    }

}

HGDIOBJ QFontEngineWin::selectDesignFont() const

{

    LOGFONT f = logfont;

    f.lfHeight = unitsPerEm;

    HFONT designFont = CreateFontIndirect(&f);

    return SelectObject(shared_dc(), designFont);

}

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

{

    if (*nglyphs < len) {

        *nglyphs = len;

        return false;

    }

    *nglyphs = getGlyphIndexes(str, len, glyphs, flags & QTextEngine::RightToLeft);

    if (flags & QTextEngine::GlyphIndicesOnly)

        return true;

    recalcAdvances(glyphs, flags);

    return true;

}

inline void calculateTTFGlyphWidth(HDC hdc, UINT glyph, int &width)

{

#if defined(Q_WS_WINCE)

    GetCharWidth32(hdc, glyph, glyph, &width);

#else

    if (ptrGetCharWidthI)

        ptrGetCharWidthI(hdc, glyph, 1, 0, &width);

#endif

}

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

{

    HGDIOBJ oldFont = 0;

    HDC hdc = shared_dc();

    if (ttf && (flags & QTextEngine::DesignMetrics)) {

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

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

            if(int(glyph) >= designAdvancesSize) {

                int newSize = (glyph + 256) >> 8 << 8;

                designAdvances = q_check_ptr((QFixed *)realloc(designAdvances,

                            newSize*sizeof(QFixed)));

                for(int i = designAdvancesSize; i < newSize; ++i)

                    designAdvances[i] = -1000000;

                designAdvancesSize = newSize;

            }

            if (designAdvances[glyph] < -999999) {

                if (!oldFont)

                    oldFont = selectDesignFont();

                int width = 0;

                calculateTTFGlyphWidth(hdc, glyph, width);

                designAdvances[glyph] = QFixed(width) / designToDevice;

            }

            glyphs->advances_x[i] = designAdvances[glyph];

            glyphs->advances_y[i] = 0;

        }

        if(oldFont)

            DeleteObject(SelectObject(hdc, oldFont));

    } else {

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

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

            glyphs->advances_y[i] = 0;

            if (glyph >= widthCacheSize) {

                int newSize = (glyph + 256) >> 8 << 8;

                widthCache = q_check_ptr((unsigned char *)realloc(widthCache,

                            newSize*sizeof(QFixed)));

                memset(widthCache + widthCacheSize, 0, newSize - widthCacheSize);

                widthCacheSize = newSize;

            }

            glyphs->advances_x[i] = widthCache[glyph];

            // font-width cache failed

            if (glyphs->advances_x[i] == 0) {

                int width = 0;

                if (!oldFont)

                    oldFont = SelectObject(hdc, hfont);

                if (!ttf) {

                    QChar ch[2] = { ushort(glyph), 0 };

                    int chrLen = 1;

                    if (glyph > 0xffff) {

                        ch[0] = QChar::highSurrogate(glyph);

                        ch[1] = QChar::lowSurrogate(glyph);

                        ++chrLen;

                    }

                    SIZE size = {0, 0};

                    GetTextExtentPoint32(hdc, (wchar_t *)ch, chrLen, &size);

                    width = size.cx;

                } else {

                    calculateTTFGlyphWidth(hdc, glyph, width);

                }

                glyphs->advances_x[i] = width;

                // if glyph's within cache range, store it for later

                if (width > 0 && width < 0x100)

                    widthCache[glyph] = width;

            }

        }

        if (oldFont)

            SelectObject(hdc, oldFont);

    }

}

glyph_metrics_t QFontEngineWin::boundingBox(const QGlyphLayout &glyphs)

{

    if (glyphs.numGlyphs == 0)

        return glyph_metrics_t();

    QFixed w = 0;

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

        w += glyphs.effectiveAdvance(i);

    return glyph_metrics_t(0, -tm.tmAscent, w, tm.tmHeight, w, 0);

}

#ifndef Q_WS_WINCE

bool QFontEngineWin::getOutlineMetrics(glyph_t glyph, const QTransform &t, glyph_metrics_t *metrics) const

{

    Q_ASSERT(metrics != 0);

    HDC hdc = shared_dc();

    GLYPHMETRICS gm;

    DWORD res = 0;

    MAT2 mat;

    mat.eM11.value = mat.eM22.value = 1;

    mat.eM11.fract = mat.eM22.fract = 0;

    mat.eM21.value = mat.eM12.value = 0;

    mat.eM21.fract = mat.eM12.fract = 0;

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

        // We need to set the transform using the HDC's world

        // matrix rather than using the MAT2 above, because the

        // results provided when transforming via MAT2 does not

        // match the glyphs that are drawn using a WorldTransform

        XFORM xform;

        xform.eM11 = t.m11();

        xform.eM12 = t.m12();

        xform.eM21 = t.m21();

        xform.eM22 = t.m22();

        xform.eDx = 0;

        xform.eDy = 0;

        SetGraphicsMode(hdc, GM_ADVANCED);

        SetWorldTransform(hdc, &xform);

    }

    uint format = GGO_METRICS;

    if (ttf)

        format |= GGO_GLYPH_INDEX;

    res = GetGlyphOutline(hdc, glyph, format, &gm, 0, 0, &mat);

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

        XFORM xform;