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

**

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

#include "qimage.h"

#include "qapplication.h"

#include "qbitmap.h"

#include "qmatrix.h"

#include "qtransform.h"

#include "qlibrary.h"

#include "qvarlengtharray.h"

#include "qdebug.h"

#include <private/qdrawhelper_p.h>

#include <private/qpixmap_mac_p.h>

#include <private/qpixmap_raster_p.h>

#include <private/qpaintengine_mac_p.h>

#include <private/qt_mac_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#include <limits.h>

#include <string.h>

QT_BEGIN_NAMESPACE

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

  Externals

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

extern const uchar *qt_get_bitflip_array(); //qimage.cpp

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

extern RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp

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

extern QRegion qt_mac_convert_mac_region(RgnHandle rgn); //qregion_mac.cpp

static int qt_pixmap_serial = 0;

Q_GUI_EXPORT quint32 *qt_mac_pixmap_get_base(const QPixmap *pix)

{

    return static_cast<QMacPixmapData*>(pix->data.data())->pixels;

}

Q_GUI_EXPORT int qt_mac_pixmap_get_bytes_per_line(const QPixmap *pix)

{

    return static_cast<QMacPixmapData*>(pix->data.data())->bytesPerRow;

}

void qt_mac_cgimage_data_free(void *info, const void *memoryToFree, size_t)

{

    QMacPixmapData *pmdata = static_cast<QMacPixmapData *>(info);

    if (!pmdata) {

        free(const_cast<void *>(memoryToFree));

    } else {

        if (QMacPixmapData::validDataPointers.contains(pmdata) == false) {

            free(const_cast<void *>(memoryToFree));

            return;

        }

        if (pmdata->pixels == pmdata->pixelsToFree) {

            // something we aren't expecting, just free it.

            Q_ASSERT(memoryToFree != pmdata->pixelsToFree);

            free(const_cast<void *>(memoryToFree));

        } else {

            free(pmdata->pixelsToFree);

            pmdata->pixelsToFree = static_cast<quint32 *>(const_cast<void *>(memoryToFree));

        }

        pmdata->cg_dataBeingReleased = 0;

    }

}

CGImageRef qt_mac_image_to_cgimage(const QImage &image)

{

    int bitsPerColor = 8;

    int bitsPerPixel = 32;

    if (image.depth() == 1) {

        bitsPerColor = 1;

        bitsPerPixel = 1;

    }

    QCFType<CGDataProviderRef> provider =

        CGDataProviderCreateWithData(0, image.bits(), image.bytesPerLine() * image.height(),

                                     0);

    uint cgflags = kCGImageAlphaPremultipliedFirst;

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

    cgflags |= kCGBitmapByteOrder32Host;

#endif

    CGImageRef cgImage = CGImageCreate(image.width(), image.height(), bitsPerColor, bitsPerPixel,

                                       image.bytesPerLine(),

                                       QCoreGraphicsPaintEngine::macGenericColorSpace(),

                                       cgflags, provider,

                                       0,

                                       0,

                                       kCGRenderingIntentDefault);

    return cgImage;

}

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

  QPixmap member functions

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

static inline QRgb qt_conv16ToRgb(ushort c) {

    static const int qt_rbits = (565/100);

    static const int qt_gbits = (565/10%10);

    static const int qt_bbits = (565%10);

    static const int qt_red_shift = qt_bbits+qt_gbits-(8-qt_rbits);

    static const int qt_green_shift = qt_bbits-(8-qt_gbits);

    static const int qt_neg_blue_shift = 8-qt_bbits;

    static const int qt_blue_mask = (1<<qt_bbits)-1;

    static const int qt_green_mask = (1<<(qt_gbits+qt_bbits))-((1<<qt_bbits)-1);

    static const int qt_red_mask = (1<<(qt_rbits+qt_gbits+qt_bbits))-(1<<(qt_gbits+qt_bbits));

    const int r=(c & qt_red_mask);

    const int g=(c & qt_green_mask);

    const int b=(c & qt_blue_mask);

    const int tr = r >> qt_red_shift;

    const int tg = g >> qt_green_shift;

    const int tb = b << qt_neg_blue_shift;

    return qRgb(tr,tg,tb);

}

QSet<QMacPixmapData*> QMacPixmapData::validDataPointers;

QMacPixmapData::QMacPixmapData(PixelType type)

    : QPixmapData(type, MacClass), has_alpha(0), has_mask(0),

      uninit(true), pixels(0), pixelsToFree(0), bytesPerRow(0),

      cg_data(0), cg_dataBeingReleased(0), cg_mask(0),

      pengine(0)

{

}

QPixmapData *QMacPixmapData::createCompatiblePixmapData() const

{

    return new QMacPixmapData(pixelType());

}

#define BEST_BYTE_ALIGNMENT 16

#define COMPTUE_BEST_BYTES_PER_ROW(bpr) \

    (((bpr) + (BEST_BYTE_ALIGNMENT - 1)) & ~(BEST_BYTE_ALIGNMENT - 1))

void QMacPixmapData::resize(int width, int height)

{

    setSerialNumber(++qt_pixmap_serial);

    w = width;

    h = height;

    is_null = (w <= 0 || h <= 0);

    d = (pixelType() == BitmapType ? 1 : 32);

    bool make_null = w <= 0 || h <= 0;                // create null pixmap

    if (make_null || d == 0) {

        w = 0;

        h = 0;

        is_null = true;

        d = 0;

        if (!make_null)

            qWarning("Qt: QPixmap: Invalid pixmap parameters");

        return;

    }

    if (w < 1 || h < 1)

        return;

    //create the pixels

    bytesPerRow = w * sizeof(quint32);  // Minimum bytes per row.

    // Quartz2D likes things as a multple of 16 (for now).

    bytesPerRow = COMPTUE_BEST_BYTES_PER_ROW(bytesPerRow);

    macCreatePixels();

}

#undef COMPUTE_BEST_BYTES_PER_ROW

void QMacPixmapData::fromImage(const QImage &img,

                               Qt::ImageConversionFlags flags)

{

    setSerialNumber(++qt_pixmap_serial);

    // the conversion code only handles format >=

    // Format_ARGB32_Premultiplied at the moment..

    if (img.format() > QImage::Format_ARGB32_Premultiplied) {

        QImage image;

        if (img.hasAlphaChannel())

            image = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);

        else

            image = img.convertToFormat(QImage::Format_RGB32);

        fromImage(image, flags);

        return;

    }

    w = img.width();

    h = img.height();

    is_null = (w <= 0 || h <= 0);

    d = (pixelType() == BitmapType ? 1 : img.depth());

    QImage image = img;

    int dd = QPixmap::defaultDepth();

    bool force_mono = (dd == 1 ||

                       (flags & Qt::ColorMode_Mask)==Qt::MonoOnly);

    if (force_mono) {                         // must be monochrome

        if (d != 1) {

            image = image.convertToFormat(QImage::Format_MonoLSB, flags);  // dither

            d = 1;

        }

    } else {                                    // can be both

        bool conv8 = false;

        if(d > 8 && dd <= 8) {               // convert to 8 bit

            if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)

                flags = (flags & ~Qt::DitherMode_Mask)

                                   | Qt::PreferDither;

            conv8 = true;

        } else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {

            conv8 = d == 1;                     // native depth wanted

        } else if (d == 1) {

            if (image.numColors() == 2) {

                QRgb c0 = image.color(0);       // Auto: convert to best

                QRgb c1 = image.color(1);

                conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);

            } else {

                // eg. 1-color monochrome images (they do exist).

                conv8 = true;

            }

        }

        if (conv8) {

            image = image.convertToFormat(QImage::Format_Indexed8, flags);

            d = 8;

        }

    }

    if (image.depth()==1) {

        image.setColor(0, QColor(Qt::color0).rgba());

        image.setColor(1, QColor(Qt::color1).rgba());

    }

    if (d == 16 || d == 24) {

        image = image.convertToFormat(QImage::Format_RGB32, flags);

        fromImage(image, flags);

        return;

    }

    // different size or depth, make a new pixmap

    resize(w, h);

    quint32 *dptr = pixels, *drow;

    const uint dbpr = bytesPerRow;

    const QImage::Format sfmt = image.format();

    const unsigned short sbpr = image.bytesPerLine();

    // use const_cast to prevent a detach

    const uchar *sptr = const_cast<const QImage &>(image).bits(), *srow;

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

        drow = dptr + (y * (dbpr / 4));

        srow = sptr + (y * sbpr);

        switch(sfmt) {

        case QImage::Format_MonoLSB:

        case QImage::Format_Mono:{

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

                char one_bit = *(srow + (x / 8));

                if (sfmt == QImage::Format_Mono)

                    one_bit = one_bit >> (7 - (x % 8));

                else

                    one_bit = one_bit >> (x % 8);

                if ((one_bit & 0x01))

                    *(drow+x) = 0xFF000000;

                else

                    *(drow+x) = 0xFFFFFFFF;

            }

            break;

        }

        case QImage::Format_Indexed8:

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

                *(drow+x) = PREMUL(image.color(*(srow + x)));

            }

            break;

        case QImage::Format_RGB32:

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

                *(drow+x) = *(((quint32*)srow) + x) | 0xFF000000;

            break;

        case QImage::Format_ARGB32:

        case QImage::Format_ARGB32_Premultiplied:

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

                if(sfmt == QImage::Format_RGB32)

                    *(drow+x) = 0xFF000000 | (*(((quint32*)srow) + x) & 0x00FFFFFF);

                else if(sfmt == QImage::Format_ARGB32_Premultiplied)

                    *(drow+x) = *(((quint32*)srow) + x);

                else

                    *(drow+x) = PREMUL(*(((quint32*)srow) + x));

            }

            break;

        default:

            qWarning("Qt: internal: Oops: Forgot a format [%d] %s:%d", sfmt,

                     __FILE__, __LINE__);

            break;

        }

    }

    if (sfmt != QImage::Format_RGB32) { //setup the alpha

        bool alphamap = image.depth() == 32;

        if (sfmt == QImage::Format_Indexed8) {

            const QVector<QRgb> rgb = image.colorTable();

            for (int i = 0, count = image.numColors(); i < count; ++i) {

                const int alpha = qAlpha(rgb[i]);

                if (alpha != 0xff) {

                    alphamap = true;

                    break;

                }

            }

        }

        macSetHasAlpha(alphamap);

    }

    uninit = false;

}

int get_index(QImage * qi,QRgb mycol)

{

    int loopc;

    for(loopc=0;loopc<qi->numColors();loopc++) {

        if(qi->color(loopc)==mycol)

            return loopc;

    }

    qi->setNumColors(qi->numColors()+1);

    qi->setColor(qi->numColors(),mycol);

    return qi->numColors();

}

QImage QMacPixmapData::toImage() const

{

    QImage::Format format = QImage::Format_MonoLSB;

    if (d != 1) //Doesn't support index color modes

        format = (has_alpha ? QImage::Format_ARGB32_Premultiplied :

                  QImage::Format_RGB32);

    QImage image(w, h, format);

    quint32 *sptr = pixels, *srow;

    const uint sbpr = bytesPerRow;

    if (format == QImage::Format_MonoLSB) {

        image.fill(0);

        image.setNumColors(2);

        image.setColor(0, QColor(Qt::color0).rgba());

        image.setColor(1, QColor(Qt::color1).rgba());

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

            uchar *scanLine = image.scanLine(y);

            srow = sptr + (y * (sbpr/4));

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

                if (!(*(srow + x) & RGB_MASK))

                    scanLine[x >> 3] |= (1 << (x & 7));

            }

        }

    } else {

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

            srow = sptr + (y * (sbpr / 4));

            memcpy(image.scanLine(y), srow, w * 4);

        }

    }

    return image;

}

void QMacPixmapData::fill(const QColor &fillColor)

{

    { //we don't know what backend to use so we cannot paint here

        quint32 *dptr = pixels;

        Q_ASSERT_X(dptr, "QPixmap::fill", "No dptr");

        const quint32 colr = PREMUL(fillColor.rgba());

        const int nbytes = bytesPerRow * h;

        if (!colr) {

            memset(dptr, 0, nbytes);

        } else {

            for (uint i = 0; i < nbytes / sizeof(quint32); ++i)

                *(dptr + i) = colr;

        }

    }

    macSetHasAlpha(fillColor.alpha() != 255);

}

QPixmap QMacPixmapData::alphaChannel() const

{

    if (!has_alpha)

        return QPixmap();

    QMacPixmapData *alpha = new QMacPixmapData(PixmapType);

    alpha->resize(w, h);

    macGetAlphaChannel(alpha, false);

    return QPixmap(alpha);

}

void QMacPixmapData::setAlphaChannel(const QPixmap &alpha)

{

    has_mask = true;

    QMacPixmapData *alphaData = static_cast<QMacPixmapData*>(alpha.data.data());

    macSetAlphaChannel(alphaData, false);

}

QBitmap QMacPixmapData::mask() const

{

    if (!has_mask && !has_alpha)

        return QBitmap();

    QMacPixmapData *mask = new QMacPixmapData(BitmapType);

    mask->resize(w, h);

    macGetAlphaChannel(mask, true);

    return QPixmap(mask);

}

void QMacPixmapData::setMask(const QBitmap &mask)

{

    if (mask.isNull()) {

        QMacPixmapData opaque(PixmapType);

        opaque.resize(w, h);

        opaque.fill(QColor(255, 255, 255, 255));

        macSetAlphaChannel(&opaque, true);

        has_alpha = has_mask = false;

        return;

    }

    has_alpha = false;

    has_mask = true;

    QMacPixmapData *maskData = static_cast<QMacPixmapData*>(mask.data.data());

    macSetAlphaChannel(maskData, true);

}

int QMacPixmapData::metric(QPaintDevice::PaintDeviceMetric theMetric) const

{

    switch (theMetric) {

    case QPaintDevice::PdmWidth:

        return w;

    case QPaintDevice::PdmHeight:

        return h;

    case QPaintDevice::PdmWidthMM:

        return qRound(metric(QPaintDevice::PdmWidth) * 25.4 / qreal(metric(QPaintDevice::PdmDpiX)));

    case QPaintDevice::PdmHeightMM:

        return qRound(metric(QPaintDevice::PdmHeight) * 25.4 / qreal(metric(QPaintDevice::PdmDpiY)));

    case QPaintDevice::PdmNumColors:

        return 1 << d;

    case QPaintDevice::PdmDpiX:

    case QPaintDevice::PdmPhysicalDpiX: {

        extern float qt_mac_defaultDpi_x(); //qpaintdevice_mac.cpp

        return int(qt_mac_defaultDpi_x());

    }

    case QPaintDevice::PdmDpiY:

    case QPaintDevice::PdmPhysicalDpiY: {

        extern float qt_mac_defaultDpi_y(); //qpaintdevice_mac.cpp

        return int(qt_mac_defaultDpi_y());

    }

    case QPaintDevice::PdmDepth:

        return d;

    default:

        qWarning("QPixmap::metric: Invalid metric command");

    }

    return 0;

}

QMacPixmapData::~QMacPixmapData()

{

    validDataPointers.remove(this);

    if (cg_mask) {

        CGImageRelease(cg_mask);

        cg_mask = 0;

    }

    delete pengine;  // Make sure we aren't drawing on the context anymore.

    if (cg_data) {

        CGImageRelease(cg_data);

    } else if (!cg_dataBeingReleased && pixels != pixelsToFree) {

        free(pixels);

    }

    free(pixelsToFree);

}

void QMacPixmapData::macSetAlphaChannel(const QMacPixmapData *pix, bool asMask)

{

    if (!pixels || !h || !w || pix->w != w || pix->h != h)

        return;

    quint32 *dptr = pixels, *drow;

    const uint dbpr = bytesPerRow;

    const unsigned short sbpr = pix->bytesPerRow;

    quint32 *sptr = pix->pixels, *srow;

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

        drow = dptr + (y * (dbpr/4));

        srow = sptr + (y * (sbpr/4));

        if(d == 1) {

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

                if((*(srow+x) & RGB_MASK))

                    *(drow+x) = 0xFFFFFFFF;

            }

        } else if(d == 8) {

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

                *(drow+x) = (*(drow+x) & RGB_MASK) | (*(srow+x) << 24);