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

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite 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 <QtTest/QtTest>

#include <qpixmap.h>

#include <qbitmap.h>

#include <qimage.h>

#include <qmatrix.h>

#include <qdesktopwidget.h>

#include <qpaintengine.h>

#include <qsplashscreen.h>

#include <private/qpixmapdata_p.h>

#include <QSet>

#ifdef Q_WS_WIN

#include <windows.h>

#endif

#ifdef Q_WS_QWS

#include <qscreen_qws.h>

#endif

#ifdef Q_OS_SYMBIAN

#include <e32std.h>

#include <fbs.h>

#include <gdi.h>

#include <bitdev.h>

#endif

#ifdef Q_WS_X11

#include <QX11Info>

#endif

//TESTED_CLASS=

//TESTED_FILES=

#if defined(Q_OS_SYMBIAN)

# define SRCDIR ""

#endif

Q_DECLARE_METATYPE(QImage::Format)

class tst_QPixmap : public QObject

{

    Q_OBJECT

public:

    tst_QPixmap();

    virtual ~tst_QPixmap();

public slots:

    void init();

    void cleanup();

private slots:

    void setAlphaChannel_data();

    void setAlphaChannel();

    void fromImage_data();

    void fromImage();

    void fromUninitializedImage_data();

    void fromUninitializedImage();

    void convertFromImage_data();

    void convertFromImage();

    void testMetrics();

    void scroll_data();

    void scroll();

    void fill_data();

    void fill();

    void fill_transparent();

    void createMaskFromColor();

    void mask();

    void bitmapMask();

    void setGetMask_data();

    void setGetMask();

    void cacheKey();

    void drawBitmap();

    void grabWidget();

    void grabWindow();

    void isNull();

    void task_246446();

#ifdef Q_WS_QWS

    void convertFromImageNoDetach();

#endif

    void convertFromImageDetach();

#if defined(Q_WS_WIN)

    void toWinHBITMAP_data();

    void toWinHBITMAP();

    void fromWinHBITMAP_data();

    void fromWinHBITMAP();

    void toWinHICON_data();

    void toWinHICON();

    void fromWinHICON_data();

    void fromWinHICON();

#endif

    void fromSymbianCFbsBitmap_data();

    void fromSymbianCFbsBitmap();

#endif

    void onlyNullPixmapsOutsideGuiThread();

    void refUnref();

    void copy();

    void depthOfNullObjects();

#ifdef QT3_SUPPORT

    void resize();

    void resizePreserveMask();

#endif

    void transformed();

    void transformed2();

    void fromImage_crash();

    void fromData();

    void loadFromDataNullValues();

    void preserveDepth();

    void splash_crash();

};

static bool lenientCompare(const QPixmap &actual, const QPixmap &expected)

{

    QImage expectedImage = expected.toImage().convertToFormat(QImage::Format_RGB32);

    QImage actualImage = actual.toImage().convertToFormat(QImage::Format_RGB32);

    if (expectedImage.size() != actualImage.size())

        return false;

    int size = actual.width() * actual.height();

    int threshold = 2;

#ifdef Q_WS_X11

    if (QX11Info::appDepth() == 16)

        threshold = 10;

#endif

    QRgb *a = (QRgb *)actualImage.bits();

    QRgb *e = (QRgb *)expectedImage.bits();

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

        QColor ca(a[i]);

        QColor ce(e[i]);

        bool result = true;

        if (qAbs(ca.red() - ce.red()) > threshold)

            result = false;

        if (qAbs(ca.green() - ce.green()) > threshold)

            result = false;

        if (qAbs(ca.blue() - ce.blue()) > threshold)

            result = false;

        if (!result)

            return false;

    }

    return true;

}

Q_DECLARE_METATYPE(QImage)

Q_DECLARE_METATYPE(QPixmap)

Q_DECLARE_METATYPE(QMatrix)

Q_DECLARE_METATYPE(QBitmap)

tst_QPixmap::tst_QPixmap()

{

}

tst_QPixmap::~tst_QPixmap()

{

}

void tst_QPixmap::init()

{

}

void tst_QPixmap::cleanup()

{

}

void tst_QPixmap::setAlphaChannel_data()

{

    QTest::addColumn<int>("red");

    QTest::addColumn<int>("green");

    QTest::addColumn<int>("blue");

    QTest::addColumn<int>("alpha");

    QTest::newRow("red 0") << 255 << 0 << 0 << 0;

    QTest::newRow("red 24") << 255 << 0 << 0 << 24;

    QTest::newRow("red 124") << 255 << 0 << 0 << 124;

    QTest::newRow("red 255") << 255 << 0 << 0 << 255;

    QTest::newRow("green 0") << 0 << 255 << 0 << 0;

    QTest::newRow("green 24") << 0 << 255 << 0 << 24;

    QTest::newRow("green 124") << 0 << 255 << 0 << 124;

    QTest::newRow("green 255") << 0 << 255 << 0 << 255;

    QTest::newRow("blue 0") << 0 << 0 << 255 << 0;

    QTest::newRow("blue 24") << 0 << 0 << 255 << 24;

    QTest::newRow("blue 124") << 0 << 0 << 255 << 124;

    QTest::newRow("blue 255") << 0 << 0 << 255 << 255;

}

void tst_QPixmap::setAlphaChannel()

{

    QFETCH(int, red);

    QFETCH(int, green);

    QFETCH(int, blue);

    QFETCH(int, alpha);

    int width = 100;

    int height = 100;

    QPixmap pixmap(width, height);

    pixmap.fill(QColor(red, green, blue));

    QPixmap alphaChannel(width, height);

    alphaChannel.fill(QColor(alpha, alpha, alpha));

    pixmap.setAlphaChannel(alphaChannel);

#ifdef Q_WS_X11

    if (pixmap.pixmapData()->classId() == QPixmapData::X11Class && !pixmap.x11PictureHandle())

        QSKIP("Requires XRender support", SkipAll);

#endif

    QImage result;

    bool ok = true;

    QPixmap outAlpha = pixmap.alphaChannel();

    QCOMPARE(outAlpha.size(), pixmap.size());

    result = outAlpha.toImage().convertToFormat(QImage::Format_ARGB32);;

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

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

            ok &= qGray(result.pixel(x, y)) == alpha;

        }

    }

    QVERIFY(ok);

    result = pixmap.toImage().convertToFormat(QImage::Format_ARGB32);

    QRgb expected = alpha == 0 ? 0 : qRgba(red, green, blue, alpha);

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

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

            if (result.colorCount() > 0) {

                ok &= result.pixelIndex(x, y) == expected;

            } else {

                ok &= result.pixel(x, y) == expected;

            }

        }

    }

    QVERIFY(ok);

}

void tst_QPixmap::fromImage_data()

{

    bool is16bit = false;

#ifdef Q_WS_X11

    if (QX11Info::appDepth() == 16)

        is16bit = true;

#endif

    QTest::addColumn<QImage::Format>("format");

    QTest::newRow("Format_Mono") << QImage::Format_Mono;

    QTest::newRow("Format_MonoLSB") << QImage::Format_MonoLSB;

//    QTest::newRow("Format_Indexed8") << QImage::Format_Indexed8;

    if (!is16bit)

        QTest::newRow("Format_RGB32") << QImage::Format_RGB32;

    QTest::newRow("Format_ARGB32") << QImage::Format_ARGB32;

    QTest::newRow("Format_ARGB32_Premultiplied") << QImage::Format_ARGB32_Premultiplied;

    if (!is16bit)

        QTest::newRow("Format_RGB16") << QImage::Format_RGB16;

}

void tst_QPixmap::fromImage()

{

    QFETCH(QImage::Format, format);

    QImage image(37, 16, format);

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

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

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

    }

    image.fill(0x7f7f7f7f);

    const QPixmap pixmap = QPixmap::fromImage(image);

#ifdef Q_WS_X11

    if (pixmap.pixmapData()->classId() == QPixmapData::X11Class && !pixmap.x11PictureHandle())

        QSKIP("Requires XRender support", SkipAll);

#endif

    const QImage result = pixmap.toImage();

    image = image.convertToFormat(result.format());

    QCOMPARE(result, image);

}

void tst_QPixmap::fromUninitializedImage_data()

{

    QTest::addColumn<QImage::Format>("format");

    QTest::newRow("Format_Mono") << QImage::Format_Mono;

    QTest::newRow("Format_MonoLSB") << QImage::Format_MonoLSB;

    QTest::newRow("Format_Indexed8") << QImage::Format_Indexed8;

    QTest::newRow("Format_RGB32") << QImage::Format_RGB32;

    QTest::newRow("Format_ARGB32") << QImage::Format_ARGB32;

    QTest::newRow("Format_ARGB32_Premultiplied") << QImage::Format_ARGB32_Premultiplied;

    QTest::newRow("Format_RGB16") << QImage::Format_RGB16;

}

void tst_QPixmap::fromUninitializedImage()

{

    QFETCH(QImage::Format, format);

    QImage image(100, 100, format);

    QPixmap pix = QPixmap::fromImage(image);

    // it simply shouldn't crash...

    QVERIFY(true);

}

void tst_QPixmap::convertFromImage_data()

{

    QTest::addColumn<QImage>("img1");

    QTest::addColumn<QImage>("img2");

#ifdef Q_OS_SYMBIAN

    const QString prefix = QLatin1String(SRCDIR) + "convertFromImage";

#else

    const QString prefix = QLatin1String(SRCDIR) + "/convertFromImage";

#endif

    {

        QImage img1;

        QImage img2;

        QVERIFY(img1.load(prefix + "/task31722_0/img1.png"));

        QVERIFY(img2.load(prefix + "/task31722_0/img2.png"));

        QVERIFY(img1.load(prefix + "/task31722_0/img1.png"));

        QVERIFY(img2.load(prefix + "/task31722_0/img2.png"));

        QTest::newRow("Task 31722 0") << img1 << img2;

    }

    {

        QImage img1;

        QImage img2;

        QVERIFY(img1.load(prefix + "/task31722_1/img1.png"));

        QVERIFY(img2.load(prefix + "/task31722_1/img2.png"));

        QTest::newRow("Task 31722 1") << img1 << img2;

    }

}

void tst_QPixmap::convertFromImage()

{

    QFETCH(QImage, img1);

    QFETCH(QImage, img2);

    QPixmap pix = QPixmap::fromImage(img1);

    pix = QPixmap::fromImage(img2);

    QPixmap res = QPixmap::fromImage(img2);

    QVERIFY( pixmapsAreEqual(&pix, &res) );

}

void tst_QPixmap::scroll_data()

{

    QTest::addColumn<QImage>("input");

    QTest::addColumn<int>("dx");

    QTest::addColumn<int>("dy");

    QTest::addColumn<QRect>("rect");

    QTest::addColumn<QRegion>("exposed");

    QTest::addColumn<bool>("newPix");

    QImage input(":/images/designer.png");

    // Noop tests

    QTest::newRow("null") << QImage() << 0 << 0 << QRect() << QRegion() << false;

    QTest::newRow("dx_0_dy_0_null") << input << 0 << 0 << QRect() << QRegion() << false;

    QTest::newRow("dx_1_dy_0_null") << input << 1 << 0 << QRect() << QRegion() << false;

    QTest::newRow("dx_0_dy_1_null") << input << 0 << 1 << QRect() << QRegion() << false;

    QTest::newRow("dx_0_dy_0_x_y_w_h") << input << 0 << 0 << input.rect() << QRegion() << false;

    QRegion r;

    // Scroll whole pixmap

    r = QRegion(); r += QRect(0, 0, 128, 10);

    QTest::newRow("dx_0_dy_10_x_y_w_h") << input << 0 << 10 << input.rect() << r << true;

    r = QRegion(); r += QRect(0, 0, 10, 128);

    QTest::newRow("dx_10_dy_0_x_y_w_h") << input << 10 << 0 << input.rect() << r << true;

    r = QRegion(); r += QRect(0, 0, 128, 10); r += QRect(0, 10, 10, 118);

    QTest::newRow("dx_10_dy_10_x_y_w_h") << input << 10 << 10 << input.rect() << r << true;

    r = QRegion(); r += QRect(118, 0, 10, 128);

    QTest::newRow("dx_-10_dy_0_x_y_w_h") << input << -10 << 0 << input.rect() << r << true;

    r = QRegion(); r += QRect(0, 118, 128, 10);

    QTest::newRow("dx_0_dy_-10_x_y_w_h") << input << 0 << -10 << input.rect() << r << true;

    r = QRegion(); r += QRect(118, 0, 10, 118); r += QRect(0, 118, 128, 10);

    QTest::newRow("dx_-10_dy_-10_x_y_w_h") << input << -10 << -10 << input.rect() << r << true;

    // Scroll part of pixmap

    QTest::newRow("dx_0_dy_0_50_50_100_100") << input << 0 << 0 << QRect(50, 50, 100, 100) << QRegion() << false;

    r = QRegion(); r += QRect(50, 50, 10, 78);

    QTest::newRow("dx_10_dy_0_50_50_100_100") << input << 10 << 0 << QRect(50, 50, 100, 100) << r << true;

    r = QRegion(); r += QRect(50, 50, 78, 10);

    QTest::newRow("dx_0_dy_10_50_50_100_100") << input << 0 << 10 << QRect(50, 50, 100, 100) << r << true;

    r = QRegion(); r += QRect(50, 50, 78, 10); r += QRect(50, 60, 10, 68);

    QTest::newRow("dx_10_dy_10_50_50_100_100") << input << 10 << 10 << QRect(50, 50, 100, 100) << r << true;

    r = QRegion(); r += QRect(118, 50, 10, 78);

    QTest::newRow("dx_-10_dy_0_50_50_100_100") << input << -10 << 0 << QRect(50, 50, 100, 100) << r << true;

    r = QRegion(); r += QRect(50, 118, 78, 10);

    QTest::newRow("dx_0_dy_-10_50_50_100_100") << input << 0 << -10 << QRect(50, 50, 100, 100) << r << true;

    r = QRegion(); r += QRect(118, 50, 10, 68); r += QRect(50, 118, 78, 10);

    QTest::newRow("dx_-10_dy_-10_50_50_100_100") << input << -10 << -10 << QRect(50, 50, 100, 100) << r << true;

    // Scroll away the whole pixmap

    r = input.rect();

    QTest::newRow("dx_128_dy_0_x_y_w_h") << input << 128 << 0 << input.rect() << r << false;

    QTest::newRow("dx_0_dy_128_x_y_w_h") << input << 0 << 128 << input.rect() << r << false;

    QTest::newRow("dx_128_dy_128_x_y_w_h") << input << 128 << 128 << input.rect() << r << false;

    QTest::newRow("dx_-128_dy_0_x_y_w_h") << input << -128 << 0 << input.rect() << r << false;

    QTest::newRow("dx_0_dy_-128_x_y_w_h") << input << 0 << -128 << input.rect() << r << false;

    QTest::newRow("dx_-128_dy_-128_x_y_w_h") << input << -128 << -128 << input.rect() << r << false;

    // Scroll away part of the pixmap

    r = QRegion(); r += QRect(64, 64, 64, 64);

    QTest::newRow("dx_128_dy_128_64_64_128_128") << input << 128 << 128 << QRect(64, 64, 128, 128) << r << false;

}

void tst_QPixmap::scroll()

{

    QFETCH(QImage, input);

    QFETCH(int, dx);

    QFETCH(int, dy);

    QFETCH(QRect, rect);

    QFETCH(QRegion, exposed);

    QFETCH(bool, newPix);

    QPixmap pixmap = QPixmap::fromImage(input);

    QRegion exp;

    qint64 oldKey = pixmap.cacheKey();

    pixmap.scroll(dx, dy, rect, &exp);

    if (!newPix)

        QCOMPARE(pixmap.cacheKey(), oldKey);

    else

        QVERIFY(pixmap.cacheKey() != oldKey);

#if 0

    // Remember to add to resources.

    QString fileName = QString("images/%1.png").arg(QTest::currentDataTag());

    pixmap.toImage().save(fileName);

#else

    QString fileName = QString(":/images/%1.png").arg(QTest::currentDataTag());

#endif

    QPixmap output(fileName);

    QVERIFY(input.isNull() == output.isNull());

    QVERIFY(lenientCompare(pixmap, output));

    QCOMPARE(exp, exposed);

}

void tst_QPixmap::fill_data()

{

    QTest::addColumn<uint>("pixel");

    QTest::addColumn<bool>("syscolor");

    QTest::addColumn<bool>("bitmap");

    for (int color = Qt::black; color < Qt::darkYellow; ++color)

        QTest::newRow(QString("syscolor_%1").arg(color).toLatin1())

            << uint(color) << true << false;

#ifdef Q_WS_QWS

    if (QScreen::instance()->depth() >= 24) {

#elif defined (Q_WS_X11)

    QPixmap pm(1, 1);

    if (pm.x11PictureHandle()) {