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

**

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

#include <qgraphicsproxywidget.h>

#include <qgraphicswidget.h>

#include <qgraphicsscene.h>

#include <qgraphicsview.h>

#include <qapplication.h>

#include <qplastiquestyle.h>

class tst_QGraphicsLinearLayout : public QObject {

Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void qgraphicslinearlayout_data();

    void qgraphicslinearlayout();

    void alignment_data();

    void alignment();

    void count_data();

    void count();

    void dump_data();

    void dump();

    void geometry_data();

    void geometry();

    void insertItem_data();

    void insertItem();

    void insertStretch_data();

    void insertStretch();

    void invalidate_data();

    void invalidate();

    void itemAt_data();

    void itemAt();

    void itemAt_visualOrder();

    void orientation_data();

    void orientation();

    void removeAt_data();

    void removeAt();

    void removeItem_data();

    void removeItem();

    void setGeometry_data();

    void setGeometry();

    void setSpacing_data();

    void setSpacing();

    void setItemSpacing_data();

    void setItemSpacing();

    void itemSpacing();

    void setStretchFactor_data();

    void setStretchFactor();

    void defaultStretchFactors_data();

    void defaultStretchFactors();

    void sizeHint_data();

    void sizeHint();

    void updateGeometry();

    void layoutDirection();

    void removeLayout();

    void avoidRecursionInInsertItem();

    // Task specific tests

    void task218400_insertStretchCrash();

};

// Subclass that exposes the protected functions.

class SubQGraphicsLinearLayout : public QGraphicsLinearLayout {

public:

    SubQGraphicsLinearLayout(Qt::Orientation orientation = Qt::Horizontal) : QGraphicsLinearLayout(orientation),

        graphicsSceneResize(0),

        layoutRequest(0),

        layoutDirectionChange(0)

        { }

    void widgetEvent(QEvent *e)

    {

        switch (e->type()) {

        case QEvent::GraphicsSceneResize:

            graphicsSceneResize++;

            break;

        case QEvent::LayoutRequest:

            layoutRequest++;

            break;

        case QEvent::LayoutDirectionChange:

            layoutDirectionChange++;

            break;

        default:

            break;

        }

        QGraphicsLinearLayout::widgetEvent(e);

    }

    int graphicsSceneResize;

    int layoutRequest;

    int layoutDirectionChange;

};

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

// It is only called once.

void tst_QGraphicsLinearLayout::initTestCase()

{

    // since the style will influence the results, we have to ensure

    // that the tests are run using the same style on all platforms

#if defined( Q_WS_S60 )|| defined (Q_WS_WINCE)

    QApplication::setStyle(new QWindowsStyle);

#else

    QApplication::setStyle(new QPlastiqueStyle);

#endif

}

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

// It is only called once.

void tst_QGraphicsLinearLayout::cleanupTestCase()

{

}

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

void tst_QGraphicsLinearLayout::init()

{

}

// This will be called after every test function.

void tst_QGraphicsLinearLayout::cleanup()

{

}

class RectWidget : public QGraphicsWidget

{

public:

    RectWidget(QGraphicsItem *parent = 0, const QBrush &brush = QBrush()) : QGraphicsWidget(parent){ m_brush = brush;}

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

    {

        Q_UNUSED(option);

        Q_UNUSED(widget);

        painter->setBrush(m_brush);

        painter->drawRoundRect(rect());

    }

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

        m_sizeHints[which] = size;

        updateGeometry();

    }

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

        if (m_sizeHints[which].isValid()) {

            return m_sizeHints[which];

        }

        return QGraphicsWidget::sizeHint(which, constraint);

    }

    QSizeF m_sizeHints[Qt::NSizeHints];

    QBrush m_brush;

};

Q_DECLARE_METATYPE(Qt::Orientation)

void tst_QGraphicsLinearLayout::qgraphicslinearlayout_data()

{

    QTest::addColumn<Qt::Orientation>("orientation");

    QTest::newRow("vertical") << Qt::Vertical;

    QTest::newRow("horizontal") << Qt::Horizontal;

}

void tst_QGraphicsLinearLayout::qgraphicslinearlayout()

{

    QFETCH(Qt::Orientation, orientation);

    SubQGraphicsLinearLayout layout(orientation);

    QVERIFY(layout.isLayout());

    qApp->processEvents();

    QCOMPARE(layout.graphicsSceneResize, 0);

    QCOMPARE(layout.layoutRequest, 0);

    QCOMPARE(layout.layoutDirectionChange, 0);

    layout.setOrientation(Qt::Vertical);

    layout.orientation();

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::insertItem: cannot insert null item");

    QCOMPARE(layout.count(), 0);

    layout.addItem(0);

    QCOMPARE(layout.count(), 0);

    layout.addStretch(0);

    QCOMPARE(layout.count(), 0);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::insertItem: cannot insert null item");

    layout.insertItem(0, 0);

    layout.insertStretch(0, 0);

    layout.removeItem(0);

    QCOMPARE(layout.count(), 0);

    layout.setSpacing(0);

    layout.spacing();

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::setStretchFactor: cannot assign a stretch factor to a null item");

    layout.setStretchFactor(0, 0);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::setStretchFactor: cannot return a stretch factor for a null item");

    layout.stretchFactor(0);

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

    QCOMPARE(layout.alignment(0), 0);

    layout.setGeometry(QRectF());

    layout.geometry();

    QCOMPARE(layout.count(), 0);

    layout.invalidate();

    layout.sizeHint(Qt::MinimumSize, QSizeF());

}

Q_DECLARE_METATYPE(Qt::AlignmentFlag)

void tst_QGraphicsLinearLayout::alignment_data()

{

    QTest::addColumn<Qt::Orientation>("orientation");

    QTest::addColumn<QSize>("newSize");

    QTest::newRow("h-defaultsize") << Qt::Horizontal << QSize();

    QTest::newRow("v-defaultsize") << Qt::Vertical << QSize();

    QTest::newRow("h-300") << Qt::Horizontal << QSize(300,100);

    QTest::newRow("v-300") << Qt::Vertical << QSize(100, 300);

}

void tst_QGraphicsLinearLayout::alignment()

{

    QFETCH(Qt::Orientation, orientation);

    QFETCH(QSize, newSize);

    //if (alignment == Qt::AlignAbsolute)

    //    QApplication::setLayoutDirection(Qt::RightToLeft);

    QGraphicsScene scene;

    QGraphicsView view(&scene);

    view.setSceneRect(0, 0, 320, 240);

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

    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout(orientation));

    scene.addItem(widget);

    widget->setLayout(&layout);

    static const Qt::Alignment alignmentsToTest[] = {

        (Qt::Alignment)0,

        Qt::AlignLeft,

        Qt::AlignRight,

        Qt::AlignHCenter,

        Qt::AlignTop,

        Qt::AlignBottom,

        Qt::AlignVCenter,

        Qt::AlignCenter,

        (Qt::Alignment)0,

        Qt::AlignLeft,

        Qt::AlignRight,

        Qt::AlignHCenter,

        Qt::AlignTop,

        Qt::AlignBottom,

        Qt::AlignVCenter,

        Qt::AlignCenter

    };

    int i;

    bool addWidget = true;

    for (i = 0; i < sizeof(alignmentsToTest)/sizeof(Qt::Alignment); ++i) {

        QGraphicsLayoutItem *loutItem;

        Qt::Alignment align = alignmentsToTest[i];

        if (!align && i > 0)

            addWidget = false;

        if (addWidget)

            loutItem = new RectWidget(widget, QBrush(Qt::blue));

        else {

            SubQGraphicsLinearLayout *lay = new SubQGraphicsLinearLayout(Qt::Vertical);

            lay->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType);

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

            QGraphicsWidget *w = new RectWidget(widget, QBrush(Qt::red));

            if (align) {

                w->setMinimumSize(QSizeF(10,10));

                w->setMaximumSize(QSizeF(10,10));

            } else {

                w->setMinimumSize(QSizeF(50,50));

                w->setMaximumSize(QSizeF(50,50));

            }

            lay->addItem(w);

            loutItem = lay;

        }

        if (align) {

            loutItem->setMinimumSize(QSizeF(10,10));

            loutItem->setMaximumSize(QSizeF(10,10));

        } else {

            loutItem->setMinimumSize(QSizeF(50,50));

            loutItem->setMaximumSize(QSizeF(50,50));

        }

        layout.addItem(loutItem);

        layout.setAlignment(loutItem, align);

    }

    layout.setContentsMargins(0,0,0,0);

    int spacing = 1;

    layout.setSpacing(spacing);

    if (newSize.isValid())

        widget->resize(newSize);

    view.show();

    widget->show();

    QTest::qWaitForWindowShown(&view);

    QApplication::processEvents();

    int x = 0;

    int y = 0;

    for (i = 0; i < layout.count(); ++i) {

        QGraphicsLayoutItem *item = layout.itemAt(i);

        Qt::Alignment align = layout.alignment(item);

        int w = 10;

        int h = 10;

        switch(align) {

            case Qt::AlignLeft:

                break;

            case Qt::AlignRight:

                if (orientation == Qt::Vertical)

                    x += 40;

                break;

            case Qt::AlignHCenter:

                if (orientation == Qt::Vertical)

                    x += 20;

                break;

            case Qt::AlignTop:

                break;

            case Qt::AlignBottom:

                if (orientation == Qt::Horizontal)

                    y += 40;

                break;

            case Qt::AlignVCenter:

                if (orientation == Qt::Horizontal)

                    y += 20;

                break;

            case Qt::AlignCenter:

                if (orientation == Qt::Horizontal)

                    y += 20;

                else

                    x += 20;

                break;

            case 0:

                w = 50;

                h = 50;

                break;

            default:

                break;

        }

        QRectF expectedGeometry(x, y, w, h);

        QCOMPARE(item->geometry(), expectedGeometry);

        if (orientation == Qt::Horizontal) {

            x += w;

            y = 0;

            x += spacing;

        } else {

            x = 0;

            y += h;

            y += spacing;

        }

    }

}

void tst_QGraphicsLinearLayout::count_data()

{

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

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

    QTest::newRow("0, 0") << 0 << 0;

    QTest::newRow("0, 5") << 0 << 5;

    QTest::newRow("5, 0") << 5 << 0;

    QTest::newRow("5, 5") << 5 << 5;

}

// int count() const public

void tst_QGraphicsLinearLayout::count()

{

    QFETCH(int, itemCount);

    QFETCH(int, layoutCount);

    SubQGraphicsLinearLayout layout;

    QCOMPARE(layout.count(), 0);

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

        layout.addItem(new QGraphicsWidget);

    QCOMPARE(layout.count(), itemCount);

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

        layout.addItem(new SubQGraphicsLinearLayout);

    QCOMPARE(layout.count(), itemCount + layoutCount);

    // see also removeAt()

}

void tst_QGraphicsLinearLayout::dump_data()

{

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

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

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

        QTest::newRow(QString("%1, 0, 0").arg(i).toLatin1()) << 0 << 0;

        QTest::newRow(QString("%1, 0, 5").arg(i).toLatin1()) << 5 << 5;

        QTest::newRow(QString("%1, 5, 0").arg(i).toLatin1()) << 5 << 5;

        QTest::newRow(QString("%1, 5, 5").arg(i).toLatin1()) << 5 << 5;

    }

}

// void dump(int indent = 0) const public

void tst_QGraphicsLinearLayout::dump()

{

    QFETCH(int, itemCount);

    QFETCH(int, layoutCount);

    SubQGraphicsLinearLayout layout;

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

        layout.addItem(new QGraphicsWidget);

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

        layout.addItem(new SubQGraphicsLinearLayout);

}

void tst_QGraphicsLinearLayout::geometry_data()

{

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

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

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

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

    QTest::addColumn<Qt::Orientation>("orientation");

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

    QTest::newRow("null") << 0 << 0 << 0 << 0 << Qt::Horizontal << QRectF();

    QTest::newRow("one item") << 1 << 0 << 0 << 0 << Qt::Horizontal << QRectF(0, 0, 10, 10);

    QTest::newRow("one layout") << 0 << 1 << 0 << 0 << Qt::Horizontal << QRectF(0, 0, 10, 10);

    QTest::newRow("two h") << 1 << 1 << 0 << 0 << Qt::Horizontal << QRectF(0, 0, 20, 10);

    QTest::newRow("two v") << 1 << 1 << 0 << 0 << Qt::Vertical << QRectF(0, 0, 10, 20);

    QTest::newRow("two w/itemspacing") << 1 << 1 << 5 << 0 << Qt::Horizontal << QRectF(0, 0, 25, 10);

    QTest::newRow("two w/spacing") << 1 << 1 << 8 << 0 << Qt::Horizontal << QRectF(0, 0, 28, 10);

    QTest::newRow("two w/itemspacing v") << 1 << 1 << 5 << 0 << Qt::Vertical << QRectF(0, 0, 10, 25);

    QTest::newRow("two w/spacing v") << 1 << 1 << 8 << 0 << Qt::Vertical << QRectF(0, 0, 10, 28);

}

// QRectF geometry() const public

void tst_QGraphicsLinearLayout::geometry()

{

    QFETCH(int, itemCount);

    QFETCH(int, layoutCount);

    QFETCH(int, itemSpacing);

    QFETCH(int, spacing);

    QFETCH(Qt::Orientation, orientation);

    QFETCH(QRectF, rect);

    QGraphicsScene scene;

    QGraphicsView view(&scene);

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

    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout(orientation));

    scene.addItem(widget);

    widget->setLayout(&layout);

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

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

        layout.addItem(new QGraphicsWidget);

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

        layout.addItem(new SubQGraphicsLinearLayout);

    for (int i = 0; i < layout.count(); ++i) {

        QGraphicsLayoutItem *item = layout.itemAt(i);

        item->setMaximumSize(10, 10);

        item->setMinimumSize(10, 10);

    }

    layout.setItemSpacing(0, itemSpacing);

    layout.setSpacing(spacing);

    layout.setContentsMargins(0, 0, 0, 0);

    widget->show();

    view.show();

    QApplication::processEvents();

    QCOMPARE(layout.geometry(), rect);

    delete widget;

}

void tst_QGraphicsLinearLayout::insertItem_data()

{

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

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

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

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

    for (int i = -1; i < 4; ++i) {

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

            QTest::newRow(QString("0, 0, %1 %2").arg(i).arg(j).toLatin1()) << 0 << 0 << i << (bool)j;

            QTest::newRow(QString("1, 0, %1 %2").arg(i).arg(j).toLatin1()) << 1 << 0 << i << (bool)j;

            QTest::newRow(QString("0, 1, %1 %2").arg(i).arg(j).toLatin1()) << 0 << 1 << i << (bool)j;

            QTest::newRow(QString("2, 2, %1 %2").arg(i).arg(j).toLatin1()) << 2 << 2 << i << (bool)j;

        }

    }

}

// void insertItem(int index, QGraphicsLayoutItem* item) public

void tst_QGraphicsLinearLayout::insertItem()

{

    QFETCH(int, itemCount);