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

**

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

#include <QtGui>

static void processEvents()

{

    QApplication::flush();

    QApplication::processEvents();

    QApplication::processEvents();

}

class UpdateWidget : public QWidget

{

public:

    UpdateWidget(int rows, int columns)

        : QWidget(0), rowCount(0), columnCount(0), opaqueChildren(false)

    {

        fill(rows, columns);

    }

    UpdateWidget(QWidget *parent = 0)

        : QWidget(parent), rowCount(0), columnCount(0), opaqueChildren(false) {}

    void fill(int rows, int columns)

    {

        if (rows == rowCount && columns == columnCount)

            return;

        delete layout();

        QGridLayout *layout = new QGridLayout;

        rowCount = rows;

        columnCount = columns;

        for (int row = 0; row < rowCount; ++row) {

            for (int column = 0; column < columnCount; ++column) {

                UpdateWidget *widget = new UpdateWidget;

                widget->setFixedSize(20, 20);

                layout->addWidget(widget, row, column);

                children.append(widget);

            }

        }

        setLayout(layout);

        adjustSize();

        QTest::qWait(250);

        processEvents();

    }

    void setOpaqueChildren(bool enable)

    {

        if (opaqueChildren != enable) {

            foreach (QWidget *w, children)

                w->setAttribute(Qt::WA_OpaquePaintEvent, enable);

            opaqueChildren = enable;

            processEvents();

        }

    }

    void paintEvent(QPaintEvent *)

    {

        static int color = Qt::black;

        QPainter painter(this);

        painter.fillRect(rect(), Qt::GlobalColor(color));

        if (++color > Qt::darkYellow)

            color = Qt::black;

    }

    QRegion updateRegion;

    QList<UpdateWidget*> children;

    int rowCount;

    int columnCount;

    bool opaqueChildren;

};

class tst_QWidget : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void init();

private slots:

    void update_data();

    void update();

    void updatePartial_data();

    void updatePartial();

    void updateComplex_data();

    void updateComplex();

private:

    UpdateWidget widget;

};

void tst_QWidget::initTestCase()

{

    widget.show();

    QTest::qWaitForWindowShown(&widget);

    QTest::qWait(300);

    processEvents();

}

void tst_QWidget::init()

{

    QVERIFY(widget.isVisible());

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

        processEvents();

}

void tst_QWidget::update_data()

{

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

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

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

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

    QTest::newRow("10x10x1 transparent")   << 10 << 10 << 1   << false;

    QTest::newRow("10x10x10 transparent")  << 10 << 10 << 10  << false;

    QTest::newRow("10x10x100 transparent") << 10 << 10 << 100 << false;

    QTest::newRow("10x10x1 opaque")        << 10 << 10 << 1   << true;

    QTest::newRow("10x10x10 opaque")       << 10 << 10 << 10  << true;

    QTest::newRow("10x10x100 opaque")      << 10 << 10 << 100 << true;

    QTest::newRow("25x25x1 transparent ")  << 25 << 25 << 1   << false;

    QTest::newRow("25x25x10 transparent")  << 25 << 25 << 10  << false;

    QTest::newRow("25x25x100 transparent") << 25 << 25 << 100 << false;

    QTest::newRow("25x25x1 opaque")        << 25 << 25 << 1   << true;

    QTest::newRow("25x25x10 opaque")       << 25 << 25 << 10  << true;

    QTest::newRow("25x25x100 opaque")      << 25 << 25 << 100 << true;

}

void tst_QWidget::update()

{

    QFETCH(int, rows);

    QFETCH(int, columns);

    QFETCH(int, numUpdates);

    QFETCH(bool, opaque);

    widget.fill(rows, columns);

    widget.setOpaqueChildren(opaque);

    QBENCHMARK {

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

            for (int j = 0; j < numUpdates; ++j)

                widget.children.at(i)->update();

            QApplication::processEvents();

        }

    }

    QApplication::flush();

}

void tst_QWidget::updatePartial_data()

{

    update_data();

}

void tst_QWidget::updatePartial()

{

    QFETCH(int, rows);

    QFETCH(int, columns);

    QFETCH(int, numUpdates);

    QFETCH(bool, opaque);

    widget.fill(rows, columns);

    widget.setOpaqueChildren(opaque);

    QBENCHMARK {

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

            QWidget *w = widget.children[i];

            const int x = w->width() / 2;

            const int y = w->height() / 2;

            for (int j = 0; j < numUpdates; ++j) {

                w->update(0, 0, x, y);

                w->update(x, 0, x, y);

                w->update(0, y, x, y);

                w->update(x, y, x, y);

            }

            QApplication::processEvents();

        }

    }

}

void tst_QWidget::updateComplex_data()

{

    update_data();

}

void tst_QWidget::updateComplex()

{

    QFETCH(int, rows);

    QFETCH(int, columns);

    QFETCH(int, numUpdates);

    QFETCH(bool, opaque);

    widget.fill(rows, columns);

    widget.setOpaqueChildren(opaque);

    QBENCHMARK {

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

            QWidget *w = widget.children[i];

            const int x = w->width() / 2;

            const int y = w->height() / 2;

            QRegion r1(0, 0, x, y, QRegion::Ellipse);

            QRegion r2(x, y, x, y, QRegion::Ellipse);

            for (int j = 0; j < numUpdates; ++j) {

                w->update(r1);

                w->update(r2);

            }

            QApplication::processEvents();

        }

    }

}

QTEST_MAIN(tst_QWidget)

#include "tst_qwidget.moc"