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

**

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

#include "qpixmap_raster_p.h"

#include "qnativeimage_p.h"

#include "qimage_p.h"

#include "qbitmap.h"

#include "qimage.h"

#include <private/qwidget_p.h>

#include <private/qdrawhelper_p.h>

QT_BEGIN_NAMESPACE

const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,

                                     0x10, 0x20, 0x40, 0x80 };

QPixmap qt_toRasterPixmap(const QImage &image)

{

    QPixmapData *data =

        new QRasterPixmapData(image.depth() == 1

                           ? QPixmapData::BitmapType

                           : QPixmapData::PixmapType);

    data->fromImage(image, Qt::AutoColor);

    return QPixmap(data);

}

QPixmap qt_toRasterPixmap(const QPixmap &pixmap)

{

    if (pixmap.isNull())

        return QPixmap();

    if (QPixmap(pixmap).data_ptr()->classId() == QPixmapData::RasterClass)

        return pixmap;

    return qt_toRasterPixmap(pixmap.toImage());

}

QRasterPixmapData::QRasterPixmapData(PixelType type)

    : QPixmapData(type, RasterClass)

{

}

QRasterPixmapData::~QRasterPixmapData()

{

}

QPixmapData *QRasterPixmapData::createCompatiblePixmapData() const

{

    return new QRasterPixmapData(pixelType());

}

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

{

    QImage::Format format;

#ifdef Q_WS_QWS

    if (pixelType() == BitmapType) {

        format = QImage::Format_Mono;

    } else {

        format = QScreen::instance()->pixelFormat();

        if (format == QImage::Format_Invalid)

            format = QImage::Format_ARGB32_Premultiplied;

        else if (format == QImage::Format_Indexed8) // currently not supported

            format = QImage::Format_RGB444;

    }

#else

    if (pixelType() == BitmapType)

        format = QImage::Format_MonoLSB;

    else

        format = QNativeImage::systemFormat();

#endif

    image = QImage(width, height, format);

    w = width;

    h = height;

    d = image.depth();

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

    if (pixelType() == BitmapType && !image.isNull()) {

        image.setColorCount(2);

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

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

    }

    setSerialNumber(image.serialNumber());

}

void QRasterPixmapData::fromImage(const QImage &sourceImage,

                                  Qt::ImageConversionFlags flags)

{

    Q_UNUSED(flags);

#ifdef Q_WS_QWS

    QImage::Format format;

    if (pixelType() == BitmapType) {

        format = QImage::Format_Mono;

    } else {

        format = QScreen::instance()->pixelFormat();

        if (format == QImage::Format_Invalid)

            format = QImage::Format_ARGB32_Premultiplied;

        else if (format == QImage::Format_Indexed8) // currently not supported

            format = QImage::Format_RGB444;

    }

    if (sourceImage.hasAlphaChannel()

        && ((flags & Qt::NoOpaqueDetection)

            || const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {

        switch (format) {

            case QImage::Format_RGB16:

                format = QImage::Format_ARGB8565_Premultiplied;

                break;

            case QImage::Format_RGB666:

                format = QImage::Format_ARGB6666_Premultiplied;

                break;

            case QImage::Format_RGB555:

                format = QImage::Format_ARGB8555_Premultiplied;

                break;

            case QImage::Format_RGB444:

                format = QImage::Format_ARGB4444_Premultiplied;

                break;

            default:

                format = QImage::Format_ARGB32_Premultiplied;

                break;

        }

    } else if (format == QImage::Format_Invalid) {

        format = QImage::Format_ARGB32_Premultiplied;

    }

    image = sourceImage.convertToFormat(format);

#else

    if (pixelType() == BitmapType) {

        image = sourceImage.convertToFormat(QImage::Format_MonoLSB);

    } else {

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

            image = sourceImage.hasAlphaChannel()

                    ? sourceImage.convertToFormat(QImage::Format_ARGB32_Premultiplied)

                    : sourceImage.convertToFormat(QImage::Format_RGB32);

        } else {

            QImage::Format opaqueFormat = QNativeImage::systemFormat();

            QImage::Format alphaFormat = QImage::Format_ARGB32_Premultiplied;

            switch (opaqueFormat) {

            case QImage::Format_RGB16:

                alphaFormat = QImage::Format_ARGB8565_Premultiplied;

                break;

            default: // We don't care about the others...

                break;

            }

            if (!sourceImage.hasAlphaChannel()

                || ((flags & Qt::NoOpaqueDetection) == 0

                    && !const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {

                image = sourceImage.convertToFormat(opaqueFormat);

            } else {

                image = sourceImage.convertToFormat(alphaFormat);

            }

        }

    }

#endif

    if (image.d) {

        w = image.d->width;

        h = image.d->height;

        d = image.d->depth;

    } else {

        w = h = d = 0;

    }

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

    setSerialNumber(image.serialNumber());

}

// from qwindowsurface.cpp

extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);

bool QRasterPixmapData::scroll(int dx, int dy, const QRect &rect)

{

    if (!image.isNull())

        qt_scrollRectInImage(image, rect, QPoint(dx, dy));

    return true;

}

void QRasterPixmapData::fill(const QColor &color)

{

    uint pixel;

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

        int gray = qGray(color.rgba());

        // Pick the best approximate color in the image's colortable.

        if (qAbs(qGray(image.color(0)) - gray) < qAbs(qGray(image.color(1)) - gray))

            pixel = 0;

        else

            pixel = 1;

    } else if (image.depth() >= 15) {

        int alpha = color.alpha();

        if (alpha != 255) {

            if (!image.hasAlphaChannel()) {

                QImage::Format toFormat;

                if (image.format() == QImage::Format_RGB16)

                    toFormat = QImage::Format_ARGB8565_Premultiplied;

                else if (image.format() == QImage::Format_RGB666)

                    toFormat = QImage::Format_ARGB6666_Premultiplied;

                else if (image.format() == QImage::Format_RGB555)

                    toFormat = QImage::Format_ARGB8555_Premultiplied;

                else if (image.format() == QImage::Format_RGB444)

                    toFormat = QImage::Format_ARGB4444_Premultiplied;

                else

                    toFormat = QImage::Format_ARGB32_Premultiplied;

                image = QImage(image.width(), image.height(), toFormat);

            }

            switch (image.format()) {

            case QImage::Format_ARGB8565_Premultiplied:

                pixel = qargb8565(color.rgba()).rawValue();

                break;

            case QImage::Format_ARGB8555_Premultiplied:

                pixel = qargb8555(color.rgba()).rawValue();

                break;

            case QImage::Format_ARGB6666_Premultiplied:

                pixel = qargb6666(color.rgba()).rawValue();

                break;

            case QImage::Format_ARGB4444_Premultiplied:

                pixel = qargb4444(color.rgba()).rawValue();

                break;

            default:

                pixel = PREMUL(color.rgba());

                break;

            }

        } else {

            switch (image.format()) {

            case QImage::Format_RGB16:

                pixel = qt_colorConvert<quint16, quint32>(color.rgba(), 0);

                break;

            case QImage::Format_RGB444:

                pixel = qrgb444(color.rgba()).rawValue();

                break;

            case QImage::Format_RGB555:

                pixel = qrgb555(color.rgba()).rawValue();

                break;

            case QImage::Format_RGB666:

                pixel = qrgb666(color.rgba()).rawValue();

                break;

            case QImage::Format_RGB888:

                pixel = qrgb888(color.rgba()).rawValue();

                break;

            default:

                pixel = color.rgba();

                break;

            }

        }

    } else {

        pixel = 0;

        // ### what about 8 bits

    }

    image.fill(pixel);

}

void QRasterPixmapData::setMask(const QBitmap &mask)

{

    if (mask.size().isEmpty()) {

        if (image.depth() != 1) { // hw: ????

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

        }

    } else {

        const int w = image.width();

        const int h = image.height();

        switch (image.depth()) {

        case 1: {

            const QImage imageMask = mask.toImage().convertToFormat(image.format());

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

                const uchar *mscan = imageMask.scanLine(y);

                uchar *tscan = image.scanLine(y);

                int bytesPerLine = image.bytesPerLine();

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

                    tscan[i] &= mscan[i];

            }

            break;

        }

        default: {

            const QImage imageMask = mask.toImage().convertToFormat(QImage::Format_MonoLSB);

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

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

                const uchar *mscan = imageMask.scanLine(y);

                QRgb *tscan = (QRgb *)image.scanLine(y);

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

                    if (!(mscan[x>>3] & qt_pixmap_bit_mask[x&7]))

                        tscan[x] = 0;

                }

            }

            break;

        }

        }

    }

}

bool QRasterPixmapData::hasAlphaChannel() const

{

    return image.hasAlphaChannel();

}

QImage QRasterPixmapData::toImage() const

{

    return image;

}

void QRasterPixmapData::setAlphaChannel(const QPixmap &alphaChannel)

{

    image.setAlphaChannel(alphaChannel.toImage());

}

QPaintEngine* QRasterPixmapData::paintEngine() const

{

    return image.paintEngine();

}

extern int qt_defaultDpiX();

extern int qt_defaultDpiY();

int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const

{

    QImageData *d = image.d;

    if (!d)

        return 0;

    // override the image dpi with the screen dpi when rendering to a pixmap

    switch (metric) {

    case QPaintDevice::PdmWidth:

        return w;

    case QPaintDevice::PdmHeight:

        return h;

    case QPaintDevice::PdmWidthMM:

        return qRound(d->width * 25.4 / qt_defaultDpiX());

    case QPaintDevice::PdmHeightMM:

        return qRound(d->height * 25.4 / qt_defaultDpiY());

    case QPaintDevice::PdmNumColors:

        return d->colortable.size();

    case QPaintDevice::PdmDepth:

        return this->d;

    case QPaintDevice::PdmDpiX: // fall-through

    case QPaintDevice::PdmPhysicalDpiX:

        return qt_defaultDpiX();

    case QPaintDevice::PdmDpiY: // fall-through

    case QPaintDevice::PdmPhysicalDpiY:

        return qt_defaultDpiY();

    default:

        qWarning("QRasterPixmapData::metric(): Unhandled metric type %d", metric);

        break;

    }

    return 0;

}

QImage* QRasterPixmapData::buffer()

{

    return ℑ

}

QT_END_NAMESPACE