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

**

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

#include <qpaintdevice.h>

#include <private/qpaintengine_mac_p.h>

#include <qpainterpath.h>

#include <qpixmapcache.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qprintengine_mac_p.h>

#include <qprinter.h>

#include <qstack.h>

#include <qtextcodec.h>

#include <qwidget.h>

#include <qvarlengtharray.h>

#include <qdebug.h>

#include <qcoreapplication.h>

#include <qmath.h>

#include <private/qfont_p.h>

#include <private/qfontengine_p.h>

#include <private/qnumeric_p.h>

#include <private/qpainter_p.h>

#include <private/qpainterpath_p.h>

#include <private/qpixmap_mac_p.h>

#include <private/qt_mac_p.h>

#include <private/qtextengine_p.h>

#include <private/qwidget_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#include <string.h>

QT_BEGIN_NAMESPACE

extern int qt_antialiasing_threshold; // QApplication.cpp

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

  External functions

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

extern CGImageRef qt_mac_create_imagemask(const QPixmap &px, const QRectF &sr); //qpixmap_mac.cpp

extern QPoint qt_mac_posInWindow(const QWidget *w); //qwidget_mac.cpp

extern OSWindowRef qt_mac_window_for(const QWidget *); //qwidget_mac.cpp

extern CGContextRef qt_mac_cg_context(const QPaintDevice *); //qpaintdevice_mac.cpp

extern void qt_mac_dispose_rgn(RgnHandle r); //qregion_mac.cpp

extern QPixmap qt_pixmapForBrush(int, bool); //qbrush.cpp

void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform);

//Implemented for qt_mac_p.h

QMacCGContext::QMacCGContext(QPainter *p)

{

    QPaintEngine *pe = p->paintEngine();

    if (pe->type() == QPaintEngine::MacPrinter)

        pe = static_cast<QMacPrintEngine*>(pe)->paintEngine();

    pe->syncState();

    context = 0;

    if(pe->type() == QPaintEngine::CoreGraphics)

        context = static_cast<QCoreGraphicsPaintEngine*>(pe)->handle();

    int devType = p->device()->devType();

    if (pe->type() == QPaintEngine::Raster

            && (devType == QInternal::Widget || devType == QInternal::Pixmap)) {

        extern CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *paintDevice);

        CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pe->paintDevice());

        uint flags = kCGImageAlphaPremultipliedFirst;

#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version

        flags |= kCGBitmapByteOrder32Host;

#endif

        const QImage *image = (const QImage *) pe->paintDevice();

        context = CGBitmapContextCreate((void *) image->bits(), image->width(), image->height(),

                                        8, image->bytesPerLine(), colorspace, flags);

        CGContextTranslateCTM(context, 0, image->height());

        CGContextScaleCTM(context, 1, -1);

        if (devType == QInternal::Widget) {

            QRegion clip = p->paintEngine()->systemClip();

            QTransform native = p->deviceTransform();

            QTransform logical = p->combinedTransform();

            if (p->hasClipping()) {

                QRegion r = p->clipRegion();

                r.translate(native.dx() - logical.dx(), native.dy() - logical.dy());

                if (clip.isEmpty())

                    clip = r;

                else

                    clip &= r;

            }

            qt_mac_clip_cg(context, clip, 0);

            QPainterState *state = static_cast<QPainterState *>(pe->state);

            Q_ASSERT(state);

            if (!state->redirectionMatrix.isIdentity())

                CGContextTranslateCTM(context, state->redirectionMatrix.dx(), state->redirectionMatrix.dy());

        }

    }

    CGContextRetain(context);

}

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

  QCoreGraphicsPaintEngine utility functions

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

//conversion

inline static float qt_mac_convert_color_to_cg(int c) { return ((float)c * 1000 / 255) / 1000; }

inline static int qt_mac_convert_color_from_cg(float c) { return qRound(c * 255); }

CGAffineTransform qt_mac_convert_transform_to_cg(const QTransform &t) {

    return CGAffineTransformMake(t.m11(), t.m12(), t.m21(), t.m22(), t.dx(),  t.dy());

}

CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *paintDevice)

{

    bool isWidget = (paintDevice->devType() == QInternal::Widget);

    return QCoreGraphicsPaintEngine::macDisplayColorSpace(isWidget ? static_cast<const QWidget *>(paintDevice)

                                                                   : 0);

}

inline static QCFType<CGColorRef> cgColorForQColor(const QColor &col, QPaintDevice *pdev)

{

    CGFloat components[] = {

        qt_mac_convert_color_to_cg(col.red()),

        qt_mac_convert_color_to_cg(col.green()),

        qt_mac_convert_color_to_cg(col.blue()),

        qt_mac_convert_color_to_cg(col.alpha())

    };

    return CGColorCreate(qt_mac_colorSpaceForDeviceType(pdev), components);

}

// There's architectural problems with using native gradients

// on the Mac at the moment, so disable them.

// #define QT_MAC_USE_NATIVE_GRADIENTS

#ifdef QT_MAC_USE_NATIVE_GRADIENTS

static bool drawGradientNatively(const QGradient *gradient)

{

    return gradient->spread() == QGradient::PadSpread;

}

// gradiant callback

static void qt_mac_color_gradient_function(void *info, const CGFloat *in, CGFloat *out)

{

    QBrush *brush = static_cast<QBrush *>(info);

    Q_ASSERT(brush && brush->gradient());

    const QGradientStops stops = brush->gradient()->stops();

    const int n = stops.count();

    Q_ASSERT(n >= 1);

    const QGradientStop *begin = stops.constBegin();

    const QGradientStop *end = begin + n;

    qreal p = in[0];

    const QGradientStop *i = begin;

    while (i != end && i->first < p)

        ++i;

    QRgb c;

    if (i == begin) {

        c = begin->second.rgba();

    } else if (i == end) {

        c = (end - 1)->second.rgba();

    } else {

        const QGradientStop &s1 = *(i - 1);

        const QGradientStop &s2 = *i;

        qreal p1 = s1.first;

        qreal p2 = s2.first;

        QRgb c1 = s1.second.rgba();

        QRgb c2 = s2.second.rgba();

        int idist = 256 * (p - p1) / (p2 - p1);

        int dist = 256 - idist;

        c = qRgba(INTERPOLATE_PIXEL_256(qRed(c1), dist, qRed(c2), idist),

                  INTERPOLATE_PIXEL_256(qGreen(c1), dist, qGreen(c2), idist),

                  INTERPOLATE_PIXEL_256(qBlue(c1), dist, qBlue(c2), idist),

                  INTERPOLATE_PIXEL_256(qAlpha(c1), dist, qAlpha(c2), idist));

    }

    out[0] = qt_mac_convert_color_to_cg(qRed(c));

    out[1] = qt_mac_convert_color_to_cg(qGreen(c));

    out[2] = qt_mac_convert_color_to_cg(qBlue(c));

    out[3] = qt_mac_convert_color_to_cg(qAlpha(c));

}

#endif

//clipping handling

void QCoreGraphicsPaintEnginePrivate::resetClip()

{

    static bool inReset = false;

    if (inReset)

        return;

    inReset = true;

    CGAffineTransform old_xform = CGContextGetCTM(hd);

    //setup xforms

    CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));

    while (stackCount > 0) {

        restoreGraphicsState();

    }

    saveGraphicsState();

    inReset = false;

    //reset xforms

    CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));

    CGContextConcatCTM(hd, old_xform);

}

static CGRect qt_mac_compose_rect(const QRectF &r, float off=0)

{

    return CGRectMake(r.x()+off, r.y()+off, r.width(), r.height());

}

static CGMutablePathRef qt_mac_compose_path(const QPainterPath &p, float off=0)

{

    CGMutablePathRef ret = CGPathCreateMutable();

    QPointF startPt;

    for (int i=0; i<p.elementCount(); ++i) {

        const QPainterPath::Element &elm = p.elementAt(i);

        switch (elm.type) {

            case QPainterPath::MoveToElement:

                if(i > 0

                        && p.elementAt(i - 1).x == startPt.x()

                        && p.elementAt(i - 1).y == startPt.y())

                    CGPathCloseSubpath(ret);

                startPt = QPointF(elm.x, elm.y);

                CGPathMoveToPoint(ret, 0, elm.x+off, elm.y+off);

                break;

            case QPainterPath::LineToElement:

                CGPathAddLineToPoint(ret, 0, elm.x+off, elm.y+off);

                break;

            case QPainterPath::CurveToElement:

                Q_ASSERT(p.elementAt(i+1).type == QPainterPath::CurveToDataElement);

                Q_ASSERT(p.elementAt(i+2).type == QPainterPath::CurveToDataElement);

                CGPathAddCurveToPoint(ret, 0,

                        elm.x+off, elm.y+off,

                        p.elementAt(i+1).x+off, p.elementAt(i+1).y+off,

                        p.elementAt(i+2).x+off, p.elementAt(i+2).y+off);

                i+=2;

                break;

            default:

                qFatal("QCoreGraphicsPaintEngine::drawPath(), unhandled type: %d", elm.type);

                break;

        }

    }

    if(!p.isEmpty()

            && p.elementAt(p.elementCount() - 1).x == startPt.x()

            && p.elementAt(p.elementCount() - 1).y == startPt.y())

        CGPathCloseSubpath(ret);

    return ret;

}

CGColorSpaceRef QCoreGraphicsPaintEngine::m_genericColorSpace = 0;

QHash<CGDirectDisplayID, CGColorSpaceRef> QCoreGraphicsPaintEngine::m_displayColorSpaceHash;

bool QCoreGraphicsPaintEngine::m_postRoutineRegistered = false;

CGColorSpaceRef QCoreGraphicsPaintEngine::macGenericColorSpace()

{

#if 0

    if (!m_genericColorSpace) {

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4

        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {

            m_genericColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);

        } else

#endif

        {

            m_genericColorSpace = CGColorSpaceCreateDeviceRGB();

        }

        if (!m_postRoutineRegistered) {

            m_postRoutineRegistered = true;

            qAddPostRoutine(QCoreGraphicsPaintEngine::cleanUpMacColorSpaces);

        }

    }

    return m_genericColorSpace;

#else

    // Just return the main display colorspace for the moment.

    return macDisplayColorSpace();

#endif

}

/*

    Ideally, we should pass the widget in here, and use CGGetDisplaysWithRect() etc.

    to support multiple displays correctly.

*/

CGColorSpaceRef QCoreGraphicsPaintEngine::macDisplayColorSpace(const QWidget *widget)

{

    CGColorSpaceRef colorSpace;

    CGDirectDisplayID displayID;

    CMProfileRef displayProfile = 0;

    if (widget == 0) {

        displayID = CGMainDisplayID();

    } else {

        const QRect &qrect = widget->window()->geometry();

        CGRect rect = CGRectMake(qrect.x(), qrect.y(), qrect.width(), qrect.height());

        CGDisplayCount throwAway;

        CGDisplayErr dErr = CGGetDisplaysWithRect(rect, 1, &displayID, &throwAway);

        if (dErr != kCGErrorSuccess)

            return macDisplayColorSpace(0); // fall back on main display

    }

    if ((colorSpace = m_displayColorSpaceHash.value(displayID)))

        return colorSpace;

    CMError err = CMGetProfileByAVID((CMDisplayIDType)displayID, &displayProfile);

    if (err == noErr) {

        colorSpace = CGColorSpaceCreateWithPlatformColorSpace(displayProfile);

    } else if (widget) {

        return macDisplayColorSpace(0); // fall back on main display

    }

    if (colorSpace == 0)

        colorSpace = CGColorSpaceCreateDeviceRGB();

    m_displayColorSpaceHash.insert(displayID, colorSpace);

    CMCloseProfile(displayProfile);

    if (!m_postRoutineRegistered) {

        m_postRoutineRegistered = true;

        qAddPostRoutine(QCoreGraphicsPaintEngine::cleanUpMacColorSpaces);

    }

    return colorSpace;

}

void QCoreGraphicsPaintEngine::cleanUpMacColorSpaces()

{

    if (m_genericColorSpace) {

        CFRelease(m_genericColorSpace);

        m_genericColorSpace = 0;

    }

    QHash<CGDirectDisplayID, CGColorSpaceRef>::const_iterator it = m_displayColorSpaceHash.constBegin();

    while (it != m_displayColorSpaceHash.constEnd()) {

        if (it.value())

            CFRelease(it.value());

        ++it;

    }

    m_displayColorSpaceHash.clear();

}

void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform)

{

    CGAffineTransform old_xform = CGAffineTransformIdentity;

    if(orig_xform) { //setup xforms

        old_xform = CGContextGetCTM(hd);

        CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));

        CGContextConcatCTM(hd, *orig_xform);

    }

    //do the clipping

    CGContextBeginPath(hd);

    if(rgn.isEmpty()) {

        CGContextAddRect(hd, CGRectMake(0, 0, 0, 0));

    } else {

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)

        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {

            QCFType<HIMutableShapeRef> shape = rgn.toHIMutableShape();

            Q_ASSERT(!HIShapeIsEmpty(shape));

            HIShapeReplacePathInCGContext(shape, hd);

        } else

#endif

        {

            QVector<QRect> rects = rgn.rects();

            const int count = rects.size();

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

                const QRect &r = rects[i];

                CGRect mac_r = CGRectMake(r.x(), r.y(), r.width(), r.height());

                CGContextAddRect(hd, mac_r);

            }

        }

    }

    CGContextClip(hd);

    if(orig_xform) {//reset xforms

        CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));

        CGContextConcatCTM(hd, old_xform);

    }

}

//pattern handling (tiling)

#if 1

#  define QMACPATTERN_MASK_MULTIPLIER 32

#else

#  define QMACPATTERN_MASK_MULTIPLIER 1

#endif

class QMacPattern

{

public:

    QMacPattern() : as_mask(false), pdev(0), image(0) { data.bytes = 0; }

    ~QMacPattern() { CGImageRelease(image); }

    int width() {

        if(image)

            return CGImageGetWidth(image);

        if(data.bytes)

            return 8*QMACPATTERN_MASK_MULTIPLIER;

        return data.pixmap.width();

    }

    int height() {

        if(image)

            return CGImageGetHeight(image);

        if(data.bytes)

            return 8*QMACPATTERN_MASK_MULTIPLIER;

        return data.pixmap.height();

    }

    //input

    QColor foreground;

    bool as_mask;

    struct {

        QPixmap pixmap;

        const uchar *bytes;

    } data;

    QPaintDevice *pdev;

    //output

    CGImageRef image;

};

static void qt_mac_draw_pattern(void *info, CGContextRef c)

{

    QMacPattern *pat = (QMacPattern*)info;

    int w = 0, h = 0;

    bool isBitmap = (pat->data.pixmap.depth() == 1);

    if(!pat->image) { //lazy cache

        if(pat->as_mask) {

            Q_ASSERT(pat->data.bytes);

            w = h = 8;

#if (QMACPATTERN_MASK_MULTIPLIER == 1)

            CGDataProviderRef provider = CGDataProviderCreateWithData(0, pat->data.bytes, w*h, 0);

            pat->image = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);

            CGDataProviderRelease(provider);

#else

            const int numBytes = (w*h)/sizeof(uchar);

            uchar xor_bytes[numBytes];

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

                xor_bytes[i] = pat->data.bytes[i] ^ 0xFF;

            CGDataProviderRef provider = CGDataProviderCreateWithData(0, xor_bytes, w*h, 0);

            CGImageRef swatch = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);

            CGDataProviderRelease(provider);

            const QColor c0(0, 0, 0, 0), c1(255, 255, 255, 255);

            QPixmap pm(w*QMACPATTERN_MASK_MULTIPLIER, h*QMACPATTERN_MASK_MULTIPLIER);

            pm.fill(c0);

            CGContextRef pm_ctx = qt_mac_cg_context(&pm);

            CGContextSetFillColorWithColor(c, cgColorForQColor(c1, pat->pdev));

            CGRect rect = CGRectMake(0, 0, w, h);

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

                rect.origin.x = x * w;

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

                    rect.origin.y = y * h;

                    qt_mac_drawCGImage(pm_ctx, &rect, swatch);

                }

            }

            pat->image = qt_mac_create_imagemask(pm, pm.rect());

            CGImageRelease(swatch);

            CGContextRelease(pm_ctx);

            w *= QMACPATTERN_MASK_MULTIPLIER;

            h *= QMACPATTERN_MASK_MULTIPLIER;

#endif

        } else {

            w = pat->data.pixmap.width();

            h = pat->data.pixmap.height();

            if (isBitmap)

                pat->image = qt_mac_create_imagemask(pat->data.pixmap, pat->data.pixmap.rect());

            else

                pat->image = (CGImageRef)pat->data.pixmap.macCGHandle();

        }

    } else {

        w = CGImageGetWidth(pat->image);

        h = CGImageGetHeight(pat->image);

    }

    //draw

    bool needRestore = false;

    if (CGImageIsMask(pat->image)) {

        CGContextSaveGState(c);

        CGContextSetFillColorWithColor(c, cgColorForQColor(pat->foreground, pat->pdev));

    }

    CGRect rect = CGRectMake(0, 0, w, h);

    qt_mac_drawCGImage(c, &rect, pat->image);

    if(needRestore)

        CGContextRestoreGState(c);

}

static void qt_mac_dispose_pattern(void *info)

{

    QMacPattern *pat = (QMacPattern*)info;

    delete pat;

}

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

  QCoreGraphicsPaintEngine member functions

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

inline static QPaintEngine::PaintEngineFeatures qt_mac_cg_features()