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

**

** 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 <QtTest/QtTest>

#include <qgraphicsgridlayout.h>

#include <qgraphicswidget.h>

#include <qgraphicsscene.h>

#include <qgraphicsview.h>

class tst_QGraphicsGridLayout : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void qgraphicsgridlayout_data();

    void qgraphicsgridlayout();

    void addItem_data();

    void addItem();

    void alignment();

    void alignment2();

    void alignment2_data();

    void columnAlignment();

    void columnCount();

    void columnMaximumWidth();

    void columnMinimumWidth();

    void columnPreferredWidth();

    void setColumnFixedWidth();

    void columnSpacing();

    void columnStretchFactor();

    void count();

    void contentsMargins();

    void horizontalSpacing_data();

    void horizontalSpacing();

    void itemAt();

    void removeAt();

    void rowAlignment();

    void rowCount();

    void rowMaximumHeight();

    void rowMinimumHeight();

    void rowPreferredHeight();

    void rowSpacing();

    void rowStretchFactor();

    void setColumnSpacing_data();

    void setColumnSpacing();

    void setGeometry_data();

    void setGeometry();

    void setRowFixedHeight();

    void setRowSpacing_data();

    void setRowSpacing();

    void setSpacing_data();

    void setSpacing();

    void sizeHint_data();

    void sizeHint();

    void verticalSpacing_data();

    void verticalSpacing();

    void layoutDirection();

    void removeLayout();

    void defaultStretchFactors_data();

    void defaultStretchFactors();

    void geometries_data();

    void geometries();

    void avoidRecursionInInsertItem();

    void styleInfoLeak();

    void task236367_maxSizeHint();

};

class RectWidget : public QGraphicsWidget

{

public:

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

    {

        Q_UNUSED(option);

        Q_UNUSED(widget);

        painter->drawRoundRect(rect());

        painter->drawLine(rect().topLeft(), rect().bottomRight());

        painter->drawLine(rect().bottomLeft(), rect().topRight());

    }

    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

    {

            return m_sizeHints[which];

        }

        return QGraphicsWidget::sizeHint(which, constraint);

    }

    void setSizeHint(Qt::SizeHint which, const QSizeF &size) {

        m_sizeHints[which] = size;

        updateGeometry();

    }

    QSizeF m_sizeHints[Qt::NSizeHints];

};

struct ItemDesc

{

    ItemDesc(int row, int col)

    : m_pos(qMakePair(row, col)),

      m_rowSpan(1),

      m_colSpan(1),

      m_sizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred)),

    {

    }

    ItemDesc &rowSpan(int span) {

        m_rowSpan = span;

        return (*this);

    }

    ItemDesc &colSpan(int span) {

        m_colSpan = span;

        return (*this);

    }

    ItemDesc &sizePolicy(const QSizePolicy &sp) {

        m_sizePolicy = sp;

        return (*this);

    }

    ItemDesc &sizePolicy(QSizePolicy::Policy horAndVer) {

        m_sizePolicy = QSizePolicy(horAndVer, horAndVer);

        return (*this);

    }

    ItemDesc &sizePolicyH(QSizePolicy::Policy hor) {

        m_sizePolicy.setHorizontalPolicy(hor);

        return (*this);

    }

    ItemDesc &sizePolicyV(QSizePolicy::Policy ver) {

        m_sizePolicy.setVerticalPolicy(ver);

        return (*this);

    }

    ItemDesc &sizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver) {

        m_sizePolicy = QSizePolicy(hor, ver);

        return (*this);

    }

    ItemDesc &sizeHint(Qt::SizeHint which, const QSizeF &sh) {

        m_sizeHints[which] = sh;

        return (*this);

    }

    ItemDesc &preferredSizeHint(const QSizeF &sh) {

        m_sizeHints[Qt::PreferredSize] = sh;

        return (*this);

    }

    ItemDesc &minSize(const QSizeF &sz) {

        m_sizes[Qt::MinimumSize] = sz;

        return (*this);

    }

    ItemDesc &preferredSize(const QSizeF &sz) {

        m_sizes[Qt::PreferredSize] = sz;

        return (*this);

    }

    ItemDesc &maxSize(const QSizeF &sz) {

        m_sizes[Qt::MaximumSize] = sz;

        return (*this);

    }

    ItemDesc &alignment(Qt::Alignment alignment) {

        m_align = alignment;

        return (*this);

    }

    void apply(QGraphicsGridLayout *layout, QGraphicsWidget *item) {

        for (int i = 0; i < Qt::NSizeHints; ++i) {

            if (!m_sizes[i].isValid())

                continue;

            switch ((Qt::SizeHint)i) {

            case Qt::MinimumSize:

                item->setMinimumSize(m_sizes[i]);

                break;

            case Qt::PreferredSize:

                item->setPreferredSize(m_sizes[i]);

                break;

            case Qt::MaximumSize:

                item->setMaximumSize(m_sizes[i]);

                break;

            default:

                qWarning("not implemented");

                break;

            }

        }

        layout->addItem(item, m_pos.first, m_pos.second, m_rowSpan, m_colSpan);

        layout->setAlignment(item, m_align);

    }

    void apply(QGraphicsGridLayout *layout, RectWidget *item) {

        for (int i = 0; i < Qt::NSizeHints; ++i)

            item->setSizeHint((Qt::SizeHint)i, m_sizeHints[i]);

        apply(layout, static_cast<QGraphicsWidget*>(item));

    }

//private:

    QPair<int,int> m_pos; // row,col

    int m_rowSpan;

    int m_colSpan;

    QSizePolicy m_sizePolicy;

    QSizeF m_sizeHints[Qt::NSizeHints];

    QSizeF m_sizes[Qt::NSizeHints];

    Qt::Alignment m_align;

};

typedef QList<ItemDesc> ItemList;

Q_DECLARE_METATYPE(ItemList);

typedef QList<QSizeF> SizeList;

Q_DECLARE_METATYPE(SizeList);

// This will be called before the first test function is executed.

// It is only called once.

void tst_QGraphicsGridLayout::initTestCase()

{

}

// This will be called after the last test function is executed.

// It is only called once.

void tst_QGraphicsGridLayout::cleanupTestCase()

{

}

// This will be called before each test function is executed.

void tst_QGraphicsGridLayout::init()

{

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

// This will be called after every test function.

void tst_QGraphicsGridLayout::cleanup()

{

}

void tst_QGraphicsGridLayout::qgraphicsgridlayout_data()

{

}

void tst_QGraphicsGridLayout::qgraphicsgridlayout()

{

    QGraphicsGridLayout layout;

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: invalid row span/column span: 0");

    layout.addItem(0, 0, 0, 0, 0);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: cannot add null item");

    layout.addItem(0, 0, 0);

    layout.alignment(0);

    layout.columnAlignment(0);

    layout.columnCount();

    layout.columnMaximumWidth(0);

    layout.columnMinimumWidth(0);

    layout.columnPreferredWidth(0);

    layout.columnSpacing(0);

    layout.columnStretchFactor(0);

    layout.count();

    layout.horizontalSpacing();

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::itemAt: invalid row, column 0, 0");

    layout.itemAt(0, 0);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::itemAt: invalid index 0");

    layout.itemAt(0);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::removeAt: invalid index 0");

    layout.removeAt(0);

    layout.rowAlignment(0);

    layout.rowCount();

    layout.rowMaximumHeight(0);

    layout.rowMinimumHeight(0);

    layout.rowPreferredHeight(0);

    layout.rowSpacing(0);

    layout.rowStretchFactor(0);

    layout.setAlignment(0, Qt::AlignRight);

    layout.setColumnAlignment(0, Qt::AlignRight);

    layout.setColumnFixedWidth(0, 0);

    layout.setColumnMaximumWidth(0, 0);

    layout.setColumnMinimumWidth(0, 0);

    layout.setColumnPreferredWidth(0, 0);

    layout.setColumnSpacing(0, 0);

    layout.setColumnStretchFactor(0, 0);

    layout.setGeometry(QRectF());

    layout.setHorizontalSpacing(0);

    layout.setRowAlignment(0, 0);

    layout.setRowFixedHeight(0, 0);

    layout.setRowMaximumHeight(0, 0);

    layout.setRowMinimumHeight(0, 0);

    layout.setRowPreferredHeight(0, 0);

    layout.setRowSpacing(0, 0);

    layout.setRowStretchFactor(0, 0);

    layout.setSpacing(0);

    layout.setVerticalSpacing(0);

    layout.sizeHint(Qt::MinimumSize);

    layout.verticalSpacing();

}

static void populateLayout(QGraphicsGridLayout *gridLayout, int width, int height)

{

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

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

            QGraphicsWidget *item = new RectWidget();

            item->setMinimumSize(10, 10);

            item->setPreferredSize(25, 25);

            item->setMaximumSize(50, 50);

            gridLayout->addItem(item, y, x);

        }

    }

}

/** populates \a gridLayout with a 3x2 layout:

 * +----+----+----+

 * |+---|---+|xxxx|

 * ||span=2 ||hole|

 * |+---|---+|xxxx|

 * +----+----+----+

 * |xxxx|+---|---+|

 * |hole||span=2 ||

 * |xxxx|+---|---+|

 * +----+----+----+

 */

static void populateLayoutWithSpansAndHoles(QGraphicsGridLayout *gridLayout)

{

    QGraphicsWidget *item = new RectWidget();

    item->setMinimumSize(10, 10);

    item->setPreferredSize(25, 25);

    item->setMaximumSize(50, 50);

    gridLayout->addItem(item, 0, 0, 1, 2);

    item = new RectWidget();

    item->setMinimumSize(10, 10);

    item->setPreferredSize(25, 25);

    item->setMaximumSize(50, 50);

    gridLayout->addItem(item, 1, 1, 1, 2);

}

Q_DECLARE_METATYPE(Qt::Alignment)

void tst_QGraphicsGridLayout::addItem_data()

{

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

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

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

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

    QTest::addColumn<Qt::Alignment>("alignment");

    for (int a = -1; a < 3; ++a) {

    for (int b = -1; b < 2; ++b) {

    for (int c = -1; c < 2; ++c) {

    for (int d = -1; d < 2; ++d) {

    for (int e = 0; e < 9; ++e) {

        int row = a;

        int column = b;

        int rowSpan = c;

        int columnSpan = d;

        QString name = QString::fromAscii("(%1,%2,%3,%4").arg(a).arg(b).arg(c).arg(d);

        Qt::Alignment alignment = Qt::AlignLeft;

        QTest::newRow(name.toLatin1()) << row << column << rowSpan << columnSpan << alignment;

    }}}}}

}

// public void addItem(QGraphicsLayoutItem* item, int row, int column, int rowSpan, int columnSpan, Qt::Alignment alignment = 0)

void tst_QGraphicsGridLayout::addItem()

{

    QFETCH(int, row);

    QFETCH(int, column);

    QFETCH(int, rowSpan);

    QFETCH(int, columnSpan);

    QFETCH(Qt::Alignment, alignment);

    QGraphicsGridLayout *layout = new QGraphicsGridLayout;

    QGraphicsWidget *wid = new QGraphicsWidget;

    if (row < 0 || column < 0) {

        QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: invalid row/column: -1");

    } else if (rowSpan < 1 || columnSpan < 1) {

        char buf[1024];

        ::qsnprintf(buf, sizeof(buf), "QGraphicsGridLayout::addItem: invalid row span/column span: %d",

            rowSpan < 1 ? rowSpan : columnSpan);

        QTest::ignoreMessage(QtWarningMsg, buf);

    }

    layout->addItem(wid, row, column, rowSpan, columnSpan, alignment);

    delete layout;

}

// public Qt::Alignment alignment(QGraphicsLayoutItem* item) const

void tst_QGraphicsGridLayout::alignment()

{

#ifdef Q_WS_MAC

    QSKIP("Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac", SkipAll);

#endif

    QGraphicsScene scene;

    QGraphicsView view(&scene);

    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);

    QGraphicsGridLayout *layout = new QGraphicsGridLayout();

    scene.addItem(widget);

    widget->setLayout(layout);

    populateLayout(layout, 3, 2);

    layout->setContentsMargins(0, 0, 0, 0);

    layout->setSpacing(0);

    view.show();

    widget->show();

    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));

    QApplication::processEvents();

    // no alignment (the default)

    QCOMPARE(layout->itemAt(0, 0)->geometry().left(), 0.0);

    QCOMPARE(layout->itemAt(0, 0)->geometry().right(), layout->itemAt(0, 1)->geometry().left());

    QCOMPARE(layout->itemAt(0, 1)->geometry().left(), 25.0);

    QCOMPARE(layout->itemAt(0, 1)->geometry().right(), layout->itemAt(0, 2)->geometry().left());

    QCOMPARE(layout->itemAt(0, 2)->geometry().left(), 50.0);

    QCOMPARE(layout->itemAt(0, 2)->geometry().right(), 75.0);

    QCOMPARE(layout->itemAt(1, 0)->geometry().left(), 0.0);

    QCOMPARE(layout->itemAt(1, 0)->geometry().right(), layout->itemAt(1, 1)->geometry().left());

    QCOMPARE(layout->itemAt(1, 1)->geometry().left(), 25.0);

    QCOMPARE(layout->itemAt(1, 1)->geometry().right(), layout->itemAt(1, 2)->geometry().left());

    QCOMPARE(layout->itemAt(1, 2)->geometry().left(), 50.0);

    QCOMPARE(layout->itemAt(1, 2)->geometry().right(), 75.0);

    QCOMPARE(layout->itemAt(0, 0)->geometry().top(), 0.0);

    QCOMPARE(layout->itemAt(0, 0)->geometry().bottom(), layout->itemAt(1, 0)->geometry().top());

    QCOMPARE(layout->itemAt(1, 0)->geometry().top(), 25.0);

    QCOMPARE(layout->itemAt(1, 0)->geometry().bottom(), 50.0);

    // align first column left, second hcenter, third right

    layout->setColumnMinimumWidth(0, 100);

    layout->setAlignment(layout->itemAt(0,0), Qt::AlignLeft);

    layout->setAlignment(layout->itemAt(1,0), Qt::AlignLeft);

    layout->setColumnMinimumWidth(1, 100);

    layout->setAlignment(layout->itemAt(0,1), Qt::AlignHCenter);

    layout->setAlignment(layout->itemAt(1,1), Qt::AlignHCenter);

    layout->setColumnMinimumWidth(2, 100);

    layout->setAlignment(layout->itemAt(0,2), Qt::AlignRight);

    layout->setAlignment(layout->itemAt(1,2), Qt::AlignRight);

    widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));

    QApplication::processEvents();