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

**

** Copyright (C) 2009 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 <private/qapplication_p.h>

#include <private/qfontengine_p.h>

#include <private/qpainter_p.h>

#include <private/qtextengine_p.h>

#include <qbitmap.h>

#include <private/qpaintengine_mac_p.h>

#include <private/qprintengine_mac_p.h>

#include <private/qpdf_p.h>

#include <qglobal.h>

#include <qpixmap.h>

#include <qpixmapcache.h>

#include <qvarlengtharray.h>

#include <qdebug.h>

#include <qendian.h>

#include <ApplicationServices/ApplicationServices.h>

#include <AppKit/AppKit.h>

QT_BEGIN_NAMESPACE

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

  QFontEngine debug facilities

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

//#define DEBUG_ADVANCES

extern int qt_antialiasing_threshold; // QApplication.cpp

#ifndef FixedToQFixed

#define FixedToQFixed(a) QFixed::fromFixed((a) >> 10)

#define QFixedToFixed(x) ((x).value() << 10)

#endif

class QMacFontPath

{

    float x, y;

    QPainterPath *path;

public:

    inline QMacFontPath(float _x, float _y, QPainterPath *_path) : x(_x), y(_y), path(_path) { }

    inline void setPosition(float _x, float _y) { x = _x; y = _y; }

    inline void advance(float _x) { x += _x; }

    static OSStatus lineTo(const Float32Point *, void *);

    static OSStatus cubicTo(const Float32Point *, const Float32Point *,

                            const Float32Point *, void *);

    static OSStatus moveTo(const Float32Point *, void *);

    static OSStatus closePath(void *);

};

OSStatus QMacFontPath::lineTo(const Float32Point *pt, void *data)

{

    QMacFontPath *p = static_cast<QMacFontPath*>(data);

    p->path->lineTo(p->x + pt->x, p->y + pt->y);

    return noErr;

}

OSStatus QMacFontPath::cubicTo(const Float32Point *cp1, const Float32Point *cp2,

                               const Float32Point *ep, void *data)

{

    QMacFontPath *p = static_cast<QMacFontPath*>(data);

    p->path->cubicTo(p->x + cp1->x, p->y + cp1->y,

                     p->x + cp2->x, p->y + cp2->y,

                     p->x + ep->x, p->y + ep->y);

    return noErr;

}

OSStatus QMacFontPath::moveTo(const Float32Point *pt, void *data)

{

    QMacFontPath *p = static_cast<QMacFontPath*>(data);

    p->path->moveTo(p->x + pt->x, p->y + pt->y);

    return noErr;

}

OSStatus QMacFontPath::closePath(void *data)

{

    static_cast<QMacFontPath*>(data)->path->closeSubpath();

    return noErr;

}

void qmacfontengine_gamma_correct(QImage *image)

{

    extern uchar qt_pow_rgb_gamma[256];

    // gamma correct the pixels back to linear color space...

    int h = image->height();

    int w = image->width();

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

        uint *pixels = (uint *) image->scanLine(y);

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

            uint p = pixels[x];

            uint r = qt_pow_rgb_gamma[qRed(p)];

            uint g = qt_pow_rgb_gamma[qGreen(p)];

            uint b = qt_pow_rgb_gamma[qBlue(p)];

            pixels[x] = (r << 16) | (g << 8) | b | 0xff000000;

        }

    }

}

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

QCoreTextFontEngineMulti::QCoreTextFontEngineMulti(const ATSFontFamilyRef &, const ATSFontRef &atsFontRef, const QFontDef &fontDef, bool kerning)

    : QFontEngineMulti(0)

{

    this->fontDef = fontDef;

    CTFontSymbolicTraits symbolicTraits = 0;

    if (fontDef.weight >= QFont::Bold)

        symbolicTraits |= kCTFontBoldTrait;

    switch (fontDef.style) {

    case QFont::StyleNormal:

        break;

    case QFont::StyleItalic:

    case QFont::StyleOblique:

        symbolicTraits |= kCTFontItalicTrait;

        break;

    }

    QCFString name;

    ATSFontGetName(atsFontRef, kATSOptionFlagsDefault, &name);

    QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithNameAndSize(name, fontDef.pixelSize);

    QCFType<CTFontRef> baseFont = CTFontCreateWithFontDescriptor(descriptor, fontDef.pixelSize, 0);

    ctfont = CTFontCreateCopyWithSymbolicTraits(baseFont, fontDef.pixelSize, 0, symbolicTraits, symbolicTraits);

    // CTFontCreateCopyWithSymbolicTraits returns NULL if we ask for a trait that does

    // not exist for the given font. (for example italic)

    if (ctfont == 0) {

        ctfont = baseFont;

        CFRetain(ctfont);

    }

    attributeDict = CFDictionaryCreateMutable(0, 2,

                                       &kCFTypeDictionaryKeyCallBacks,

                                       &kCFTypeDictionaryValueCallBacks);

    CFDictionaryAddValue(attributeDict, NSFontAttributeName, ctfont);

    if (!kerning) {

        float zero = 0.0;

        QCFType<CFNumberRef> noKern = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &zero);

        CFDictionaryAddValue(attributeDict, kCTKernAttributeName, noKern);

    }

    QCoreTextFontEngine *fe = new QCoreTextFontEngine(ctfont, fontDef, this);

    fe->ref.ref();

    engines.append(fe);

}

QCoreTextFontEngineMulti::~QCoreTextFontEngineMulti()

{

    CFRelease(ctfont);

}

uint QCoreTextFontEngineMulti::fontIndexForFont(CTFontRef id) const

{

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

        if (CFEqual(engineAt(i)->ctfont, id))

            return i;

    }

    QCoreTextFontEngineMulti *that = const_cast<QCoreTextFontEngineMulti *>(this);

    QCoreTextFontEngine *fe = new QCoreTextFontEngine(id, fontDef, that);

    fe->ref.ref();

    that->engines.append(fe);

    return engines.count() - 1;

}

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

                  unsigned short *logClusters, const HB_CharAttributes *) const

{

    QCFType<CFStringRef> cfstring = CFStringCreateWithCharactersNoCopy(0,

                                                               reinterpret_cast<const UniChar *>(str),

                                                               len, kCFAllocatorNull);

    QCFType<CFAttributedStringRef> attributedString = CFAttributedStringCreate(0, cfstring, attributeDict);

    QCFType<CTTypesetterRef> typeSetter = CTTypesetterCreateWithAttributedString(attributedString);

    CFRange range = {0, 0};

    QCFType<CTLineRef> line = CTTypesetterCreateLine(typeSetter, range);

    CFArrayRef array = CTLineGetGlyphRuns(line);

    uint arraySize = CFArrayGetCount(array);

    glyph_t *outGlyphs = glyphs->glyphs;

    HB_GlyphAttributes *outAttributes = glyphs->attributes;

    QFixed *outAdvances_x = glyphs->advances_x;

    QFixed *outAdvances_y = glyphs->advances_y;

    glyph_t *initialGlyph = outGlyphs;

    if (arraySize == 0)

        return false;

    const bool rtl = (CTRunGetStatus(static_cast<CTRunRef>(CFArrayGetValueAtIndex(array, 0))) & kCTRunStatusRightToLeft);

    bool outOBounds = false;

    for (uint i = 0; i < arraySize; ++i) {

        CTRunRef run = static_cast<CTRunRef>(CFArrayGetValueAtIndex(array, rtl ? (arraySize - 1 - i) : i));

        CFIndex glyphCount = CTRunGetGlyphCount(run);

        if (glyphCount == 0)

            continue;

        Q_ASSERT((CTRunGetStatus(run) & kCTRunStatusRightToLeft) == rtl);

        if (!outOBounds && outGlyphs + glyphCount - initialGlyph > *nglyphs) {

            outOBounds = true;

        }

        if (!outOBounds) {

            CFDictionaryRef runAttribs = CTRunGetAttributes(run);

            //NSLog(@"Dictionary %@", runAttribs);

            if (!runAttribs)

                runAttribs = attributeDict;

            CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttribs, NSFontAttributeName));

            const uint fontIndex = (fontIndexForFont(runFont) << 24);

            //NSLog(@"Run Font Name = %@", CTFontCopyFamilyName(runFont));

            QVarLengthArray<CGGlyph, 512> cgglyphs(0);

            const CGGlyph *tmpGlyphs = CTRunGetGlyphsPtr(run);

            if (!tmpGlyphs) {

                cgglyphs.resize(glyphCount);

                CTRunGetGlyphs(run, range, cgglyphs.data());

                tmpGlyphs = cgglyphs.constData();

            }

            QVarLengthArray<CGPoint, 512> cgpoints(0);

            const CGPoint *tmpPoints = CTRunGetPositionsPtr(run);

            if (!tmpPoints) {

                cgpoints.resize(glyphCount);

                CTRunGetPositions(run, range, cgpoints.data());

                tmpPoints = cgpoints.constData();

            }

            const int rtlOffset = rtl ? (glyphCount - 1) : 0;

            const int rtlSign = rtl ? -1 : 1;

            if (logClusters) {

                CFRange stringRange = CTRunGetStringRange(run);

                QVarLengthArray<CFIndex, 512> stringIndices(0);

                const CFIndex *tmpIndices = CTRunGetStringIndicesPtr(run);

                if (!tmpIndices) {

                    stringIndices.resize(glyphCount);

                    CTRunGetStringIndices(run, range, stringIndices.data());

                    tmpIndices = stringIndices.constData();

                }

                const int firstGlyphIndex = outGlyphs - initialGlyph;

                outAttributes[0].clusterStart = true;

                CFIndex k = 0;

                CFIndex i = 0;

                for (i = stringRange.location;

                     (i < stringRange.location + stringRange.length) && (k < glyphCount); ++i) {

                    if (tmpIndices[k * rtlSign + rtlOffset] == i || i == stringRange.location) {

                        logClusters[i] = k + firstGlyphIndex;

                        outAttributes[k].clusterStart = true;

                        ++k;

                    } else {

                        logClusters[i] = k + firstGlyphIndex - 1;

                    }

                }

                // in case of a ligature at the end, fill the remaining logcluster entries

                for (;i < stringRange.location + stringRange.length; i++) {

                    logClusters[i] = k + firstGlyphIndex - 1;

                }

            }

            for (CFIndex i = 0; i < glyphCount - 1; ++i) {

                int idx = rtlOffset + rtlSign * i;

                outGlyphs[idx] = tmpGlyphs[i] | fontIndex;

                outAdvances_x[idx] = QFixed::fromReal(tmpPoints[i + 1].x - tmpPoints[i].x);

                outAdvances_y[idx] = QFixed::fromReal(tmpPoints[i + 1].y - tmpPoints[i].y);

            }

            CGSize lastGlyphAdvance;

            CTFontGetAdvancesForGlyphs(runFont, kCTFontHorizontalOrientation, tmpGlyphs + glyphCount - 1, &lastGlyphAdvance, 1);

            outGlyphs[rtl ? 0 : (glyphCount - 1)] = tmpGlyphs[glyphCount - 1] | fontIndex;

            outAdvances_x[rtl ? 0 : (glyphCount - 1)] = QFixed::fromReal(lastGlyphAdvance.width).ceil();

        }

        outGlyphs += glyphCount;

        outAttributes += glyphCount;

        outAdvances_x += glyphCount;

        outAdvances_y += glyphCount;

    }

    *nglyphs = (outGlyphs - initialGlyph);

    return !outOBounds;

}

bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs,

                                            int *nglyphs, QTextEngine::ShaperFlags flags) const

{

    return stringToCMap(str, len, glyphs, nglyphs, flags, 0, 0);

}

void QCoreTextFontEngineMulti::recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const

{

}

void QCoreTextFontEngineMulti::doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const

{

}

void QCoreTextFontEngineMulti::loadEngine(int)

{

    // Do nothing

    Q_ASSERT(false);

}

QCoreTextFontEngine::QCoreTextFontEngine(CTFontRef font, const QFontDef &def,

                                         QCoreTextFontEngineMulti *multiEngine)

{

    fontDef = def;

    parentEngine = multiEngine;

    synthesisFlags = 0;

    ctfont = font;

    CFRetain(ctfont);

    ATSFontRef atsfont = CTFontGetPlatformFont(ctfont, 0);

    cgFont = CGFontCreateWithPlatformFont(&atsfont);

    CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(ctfont);

    if (fontDef.weight >= QFont::Bold && !(traits & kCTFontBoldTrait)) {

         synthesisFlags |= SynthesizedBold;

    }

    if (fontDef.style != QFont::StyleNormal && !(traits & kCTFontItalicTrait)) {

        synthesisFlags |= SynthesizedItalic;

    }

    QByteArray os2Table = getSfntTable(MAKE_TAG('O', 'S', '/', '2'));

    if (os2Table.size() >= 10)

        fsType = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(os2Table.constData() + 8));

}

QCoreTextFontEngine::~QCoreTextFontEngine()

{

    CFRelease(ctfont);

    CFRelease(cgFont);

}

bool QCoreTextFontEngine::stringToCMap(const QChar *, int, QGlyphLayout *, int *, QTextEngine::ShaperFlags) const

{

    return false;

}

glyph_metrics_t QCoreTextFontEngine::boundingBox(const QGlyphLayout &glyphs)

{

    QFixed w;

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

        w += glyphs.effectiveAdvance(i);

    return glyph_metrics_t(0, -(ascent()), w, ascent()+descent(), w, 0);

}

glyph_metrics_t QCoreTextFontEngine::boundingBox(glyph_t glyph)

{

    glyph_metrics_t ret;

    CGGlyph g = glyph;

    CGRect rect = CTFontGetBoundingRectsForGlyphs(ctfont, kCTFontHorizontalOrientation, &g, 0, 1);

    ret.width = QFixed::fromReal(rect.size.width);

    ret.height = QFixed::fromReal(rect.size.height);

    ret.x = QFixed::fromReal(rect.origin.x);

    ret.y = -QFixed::fromReal(rect.origin.y) - ret.height;

    CGSize advances[1];

    CTFontGetAdvancesForGlyphs(ctfont, kCTFontHorizontalOrientation, &g, advances, 1);

    ret.xoff = QFixed::fromReal(advances[0].width).ceil();

    ret.yoff = QFixed::fromReal(advances[0].height).ceil();

    return ret;

}

QFixed QCoreTextFontEngine::ascent() const

{

    return QFixed::fromReal(CTFontGetAscent(ctfont)).ceil();

}

QFixed QCoreTextFontEngine::descent() const

{

    return QFixed::fromReal(CTFontGetDescent(ctfont)).ceil();

}

QFixed QCoreTextFontEngine::leading() const

{

    return QFixed::fromReal(CTFontGetLeading(ctfont)).ceil();

}

QFixed QCoreTextFontEngine::xHeight() const

{

    return QFixed::fromReal(CTFontGetXHeight(ctfont)).ceil();

}

QFixed QCoreTextFontEngine::averageCharWidth() const

{

    // ### Need to implement properly and get the information from the OS/2 Table.

    return QFontEngine::averageCharWidth();

}

qreal QCoreTextFontEngine::maxCharWidth() const

{

    // ### Max Help!

    return 0;

}

qreal QCoreTextFontEngine::minLeftBearing() const

{

    // ### Min Help!

    return 0;

}

qreal QCoreTextFontEngine::minRightBearing() const

{

    // ### Max Help! (even thought it's right)

    return 0;

}

void QCoreTextFontEngine::draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight)

{

    QVarLengthArray<QFixedPoint> positions;

    QVarLengthArray<glyph_t> glyphs;

    QTransform matrix;

    matrix.translate(x, y);

    getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);

    if (glyphs.size() == 0)

        return;

    CGContextSetFontSize(ctx, fontDef.pixelSize);

    CGAffineTransform oldTextMatrix = CGContextGetTextMatrix(ctx);

    CGAffineTransform cgMatrix = CGAffineTransformMake(1, 0, 0, -1, 0, -paintDeviceHeight);

    CGAffineTransformConcat(cgMatrix, oldTextMatrix);

    if (synthesisFlags & QFontEngine::SynthesizedItalic)

        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, -tanf(14 * acosf(0) / 90), 1, 0, 0));

// ###    cgMatrix = CGAffineTransformConcat(cgMatrix, transform);

    CGContextSetTextMatrix(ctx, cgMatrix);

    CGContextSetTextDrawingMode(ctx, kCGTextFill);

    QVarLengthArray<CGSize> advances(glyphs.size());

    QVarLengthArray<CGGlyph> cgGlyphs(glyphs.size());

    for (int i = 0; i < glyphs.size() - 1; ++i) {

        advances[i].width = (positions[i + 1].x - positions[i].x).toReal();

        advances[i].height = (positions[i + 1].y - positions[i].y).toReal();

        cgGlyphs[i] = glyphs[i];

    }

    advances[glyphs.size() - 1].width = 0;

    advances[glyphs.size() - 1].height = 0;

    cgGlyphs[glyphs.size() - 1] = glyphs[glyphs.size() - 1];

    CGContextSetFont(ctx, cgFont);

    //NSLog(@"Font inDraw %@  ctfont %@", CGFontCopyFullName(cgFont), CTFontCopyFamilyName(ctfont));

    CGContextSetTextPosition(ctx, positions[0].x.toReal(), positions[0].y.toReal());

    CGContextShowGlyphsWithAdvances(ctx, cgGlyphs.data(), advances.data(), glyphs.size());

    if (synthesisFlags & QFontEngine::SynthesizedBold) {

        CGContextSetTextPosition(ctx, positions[0].x.toReal() + 0.5 * lineThickness().toReal(),

                                 positions[0].y.toReal());

        CGContextShowGlyphsWithAdvances(ctx, cgGlyphs.data(), advances.data(), glyphs.size());

    }

    CGContextSetTextMatrix(ctx, oldTextMatrix);

}

struct ConvertPathInfo

{

    ConvertPathInfo(QPainterPath *newPath, const QPointF &newPos) : path(newPath), pos(newPos) {}

    QPainterPath *path;

    QPointF pos;

};

static void convertCGPathToQPainterPath(void *info, const CGPathElement *element)

{

    ConvertPathInfo *myInfo = static_cast<ConvertPathInfo *>(info);

    switch(element->type) {

        case kCGPathElementMoveToPoint:

            myInfo->path->moveTo(element->points[0].x + myInfo->pos.x(),

                                 element->points[0].y + myInfo->pos.y());

            break;

        case kCGPathElementAddLineToPoint:

            myInfo->path->lineTo(element->points[0].x + myInfo->pos.x(),

                                 element->points[0].y + myInfo->pos.y());

            break;

        case kCGPathElementAddQuadCurveToPoint:

            myInfo->path->quadTo(element->points[0].x + myInfo->pos.x(),

                                 element->points[0].y + myInfo->pos.y(),

                                 element->points[1].x + myInfo->pos.x(),

                                 element->points[1].y + myInfo->pos.y());

            break;

        case kCGPathElementAddCurveToPoint:

            myInfo->path->cubicTo(element->points[0].x + myInfo->pos.x(),

                                  element->points[0].y + myInfo->pos.y(),

                                  element->points[1].x + myInfo->pos.x(),

                                  element->points[1].y + myInfo->pos.y(),