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

**

** Copyright (C) 2009 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 <QtGui>

#include <QtTest/QtTest>

#include <QTest>

#include <QMetaType>

#include <QtGui/qgraphicsanchorlayout.h>

#include <private/qgraphicsanchorlayout_p.h>

#define TEST_COMPLEX_CASES

//---------------------- AnchorLayout helper class ----------------------------

class TheAnchorLayout : public QGraphicsAnchorLayout

{

public:

    TheAnchorLayout() : QGraphicsAnchorLayout()

    {

        setContentsMargins( 0,0,0,0 );

        setSpacing( 0 );

    }

    bool isValid()

    {

        return !QGraphicsAnchorLayoutPrivate::get(this)->hasConflicts();

    }

    void setAnchor(

        QGraphicsLayoutItem *startItem,

        Qt::AnchorPoint startEdge,

        QGraphicsLayoutItem *endItem,

        Qt::AnchorPoint endEdge,

        qreal value)

        {

            QGraphicsAnchor *anchor = addAnchor( startItem, startEdge, endItem, endEdge);

            if (anchor)

                anchor->setSpacing(value);

        }

    int indexOf(const QGraphicsLayoutItem* item) const

    {

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

            if ( itemAt(i) == item ) {

                return i;

            }

        }

        return -1;

    }

    void removeItem(QGraphicsLayoutItem* item)

    {

        removeAt(indexOf(item));

    }

    void removeAnchor(

        QGraphicsLayoutItem *startItem,

        Qt::AnchorPoint startEdge,

        QGraphicsLayoutItem *endItem,

        Qt::AnchorPoint endEdge)

        {

            delete QGraphicsAnchorLayout::anchor(startItem, startEdge, endItem, endEdge);

        }

};

//-----------------------------------------------------------------------------

struct BasicLayoutTestData

{

    inline BasicLayoutTestData(

        int index1, Qt::AnchorPoint edge1,

        int index2, Qt::AnchorPoint edge2,

        qreal distance)

        : firstIndex(index1), firstEdge(edge1),

          secondIndex(index2), secondEdge(edge2),

          spacing(distance)

        {

        }

    int firstIndex;

    Qt::AnchorPoint firstEdge;

    int secondIndex;

    Qt::AnchorPoint secondEdge;

    qreal spacing;

};

struct AnchorItemSizeHint

{

    inline AnchorItemSizeHint(

        qreal hmin, qreal hpref, qreal hmax,

        qreal vmin, qreal vpref, qreal vmax )

        : hmin(hmin), hpref(hpref), hmax(hmax), vmin(vmin), vpref(vpref), vmax(vmax)

        {

        }

    qreal hmin, hpref, hmax;

    qreal vmin, vpref, vmax;

};

// some test results

struct BasicLayoutTestResult

{

    inline BasicLayoutTestResult(

        int resultIndex, const QRectF& resultRect )

        : index(resultIndex), rect(resultRect)

        {

        }

    int index;

    QRectF rect;

};

typedef QList<BasicLayoutTestData> BasicLayoutTestDataList;

Q_DECLARE_METATYPE(BasicLayoutTestDataList)

typedef QList<BasicLayoutTestResult> BasicLayoutTestResultList;

Q_DECLARE_METATYPE(BasicLayoutTestResultList)

typedef QList<AnchorItemSizeHint> AnchorItemSizeHintList;

Q_DECLARE_METATYPE(AnchorItemSizeHintList)

//---------------------- Test Widget used on all tests ------------------------

class TestWidget : public QGraphicsWidget

{

public:

    inline TestWidget(QGraphicsItem *parent = 0)

        : QGraphicsWidget(parent)

        {

            setContentsMargins( 0,0,0,0 );

        }

    ~TestWidget()

        {

        }

protected:

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

};

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

{

    Q_UNUSED( constraint );

    if (which == Qt::MinimumSize) {

        return QSizeF(5,5);

    }

    if (which == Qt::PreferredSize) {

        return QSizeF(50,50);

    }

    return QSizeF(500,500);

}

//-----------------------------------------------------------------------------

//----------------------------- Test class ------------------------------------

class tst_QGraphicsAnchorLayout1 : public QObject

{

    Q_OBJECT

private slots:

    void testCount();

    void testRemoveAt();

    void testRemoveItem();

    void testItemAt();

    void testIndexOf();

    void testAddAndRemoveAnchor();

    void testIsValid();

    void testSpecialCases();

    void testBasicLayout_data();

    void testBasicLayout();

    void testNegativeSpacing_data();

    void testNegativeSpacing();

    void testMixedSpacing_data();

    void testMixedSpacing();

    void testMulti_data();

    void testMulti();

    void testCenterAnchors_data();

    void testCenterAnchors();

    void testRemoveCenterAnchor_data();

    void testRemoveCenterAnchor();

    void testSingleSizePolicy_data();

    void testSingleSizePolicy();

    void testDoubleSizePolicy_data();

    void testDoubleSizePolicy();

    void testSizeDistribution_data();

    void testSizeDistribution();

    void testSizeHint();

#ifdef TEST_COMPLEX_CASES

    void testComplexCases_data();

    void testComplexCases();

#endif

};

void tst_QGraphicsAnchorLayout1::testCount()

{

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    QVERIFY( layout->count() == 0 );

    TestWidget *widget1 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);

    QCOMPARE( layout->count(), 1 );

    // adding one more anchor for already added widget should not increase the count

    layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, 1);

    QCOMPARE( layout->count(), 1 );

    // create one more widget and attach with anchor layout

    TestWidget *widget2 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 1);

    QCOMPARE( layout->count(), 2 );

    widget->setLayout(layout);

    delete widget;

}

void tst_QGraphicsAnchorLayout1::testRemoveAt()

{

    TheAnchorLayout *layout = new TheAnchorLayout();

    QVERIFY( layout->count() == 0 );

    TestWidget *widget1 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 2);

    QVERIFY( layout->count() == 1 );

    TestWidget *widget2 = new TestWidget();

    layout->setAnchor(widget2, Qt::AnchorLeft, layout, Qt::AnchorLeft, 0.1);

    QVERIFY( layout->count() == 2 );

    layout->removeAt(0);

    QVERIFY( layout->count() == 1 );

    layout->removeAt(-55);

    layout->removeAt(55);

    QVERIFY( layout->count() == 1 );

    layout->removeAt(0);

    QVERIFY( layout->count() == 0 );

    delete layout;

    delete widget1;

    delete widget2;

}

void tst_QGraphicsAnchorLayout1::testRemoveItem()

{

    TheAnchorLayout *layout = new TheAnchorLayout();

    QCOMPARE( layout->count(), 0 );

    TestWidget *widget1 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 2);

    QCOMPARE( layout->count(), 1 );

    TestWidget *widget2 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);

    QCOMPARE( layout->count(), 2 );

    layout->removeItem(0);

    QCOMPARE( layout->count(), 2 );

    layout->removeItem(widget1);

    QCOMPARE( layout->count(), 1 );

    QCOMPARE( layout->indexOf(widget1), -1 );

    QCOMPARE( layout->indexOf(widget2), 0 );

    layout->removeItem(widget1);

    QCOMPARE( layout->count(), 1 );

    layout->removeItem(widget2);

    QVERIFY( layout->count() == 0 );

    delete layout;

    delete widget1;

    delete widget2;

}

void tst_QGraphicsAnchorLayout1::testItemAt()

{

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    TestWidget *widget1 = new TestWidget();

    TestWidget *widget2 = new TestWidget();

    TestWidget *widget3 = new TestWidget();

    TestWidget *widget4 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);

    QVERIFY( layout->itemAt(0) == widget1 );

    layout->removeAt(0);

    QVERIFY( layout->itemAt(0) == widget2 );

    widget->setLayout(layout);

    delete widget;

}

void tst_QGraphicsAnchorLayout1::testIndexOf()

{

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    TestWidget *widget1 = new TestWidget();

    TestWidget *widget2 = new TestWidget();

    TestWidget *widget3 = new TestWidget();

    TestWidget *widget4 = new TestWidget();

    QCOMPARE( layout->indexOf(widget1), -1 );

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 0.1);

    QCOMPARE( layout->indexOf(widget4), -1 );

    layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);

    QCOMPARE( layout->count(), 4 );

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

        QCOMPARE(layout->indexOf(layout->itemAt(i)), i);

    }

    QCOMPARE( layout->indexOf(0), -1 );

    widget->setLayout(layout);

    delete widget;

}

void tst_QGraphicsAnchorLayout1::testAddAndRemoveAnchor()

{

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    TestWidget *widget1 = new TestWidget();

    TestWidget *widget2 = new TestWidget();

    TestWidget *widget3 = new TestWidget();

    TestWidget *widget4 = new TestWidget();

    TestWidget *widget5 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.5);

    layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 10);

    layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);

    QCOMPARE( layout->count(), 4 );

    // test setting invalid anchors

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor NULL items");

    layout->setAnchor(0, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor NULL items");

    layout->setAnchor(layout, Qt::AnchorLeft, 0, Qt::AnchorLeft, 1);

    QCOMPARE( layout->count(), 4 );

    // test removing invalid anchors

    layout->removeAnchor(widget4, Qt::AnchorRight, widget1, Qt::AnchorRight);

    // anchor one horizontal edge with vertical edge. it should not add this widget as a child

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");

    layout->setAnchor(layout, Qt::AnchorLeft, widget5, Qt::AnchorTop, 10);

    QCOMPARE( layout->count(), 4 );

    // ###: NOT SUPPORTED

    // anchor two edges of a widget (to define width / height)

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");

    layout->setAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight, 10);

    // QCOMPARE( layout->count(), 5 );

    QCOMPARE( layout->count(), 4 );

    // anchor yet new widget properly

    layout->setAnchor(layout, Qt::AnchorRight, widget5, Qt::AnchorRight, 20 );

    QCOMPARE( layout->count(), 5 );

    // remove anchor for widget1. widget1 should be removed from layout since the

    // last anchor was removed.

    layout->removeAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft);

    QCOMPARE( layout->count(), 4 );

    QVERIFY( !widget1->parentLayoutItem() );

    // test that item is not removed from layout if other anchors remain set

    layout->setAnchor(widget2, Qt::AnchorLeft, widget3, Qt::AnchorRight, 10);

    layout->removeAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft);

    QCOMPARE( layout->count(), 4 );

    // remove all the anchors

    layout->removeAnchor(widget2, Qt::AnchorLeft, widget3, Qt::AnchorRight);

    layout->removeAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft);

    layout->removeAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft);

    layout->removeAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight);

    layout->removeAnchor(layout, Qt::AnchorRight, widget5, Qt::AnchorRight);

    QCOMPARE( layout->count(), 0 );

    // set one anchor "another way round" to get full coverage for "removeAnchor"

    layout->setAnchor(widget1, Qt::AnchorLeft, layout, Qt::AnchorLeft, 0.1);

    layout->removeAnchor(widget1, Qt::AnchorLeft, layout, Qt::AnchorLeft);

    QCOMPARE( layout->count(), 0 );

    widget->setLayout(layout);

    delete widget;

}

void tst_QGraphicsAnchorLayout1::testIsValid()

{

    // Empty, valid

    {

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    widget->setLayout(layout);

    widget->setGeometry(QRectF(0,0,100,100));

    QCOMPARE(layout->isValid(), true);

    delete widget;

    }

    // One widget, valid

    {

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    TestWidget *widget1 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 0.1);

    layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 0.1);

    layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 0.1);

    widget->setLayout(layout);

    widget->setGeometry(QRectF(0,0,100,100));

    QCOMPARE(layout->isValid(), true);

    delete widget;

    }

    // Overconstrained one widget, invalid

    // ### Our understanding is that this case is valid. What happens though,

    //     is that the layout minimum and maximum vertical size hints become

    //     the same, 10.1. That means its height is fixed.

    //     What will "fail" then is the "setGeometry(0, 0, 100, 100)" call,

    //     after which the layout geometry will be (0, 0, 100, 10.1).

    {

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();

    TestWidget *widget1 = new TestWidget();

    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);

    layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 0.1);

    layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 0.1);

    layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 0.1);

    layout->setAnchor(widget1, Qt::AnchorTop, layout, Qt::AnchorBottom, 10);

    widget->setLayout(layout);

    widget->setGeometry(QRectF(0,0,100,100));

    // ###: this shall change once isValid() is ready

    // QCOMPARE(layout->isValid(), false);

    QCOMPARE(layout->isValid(), true);

    delete widget;

    }

    // Underconstrained two widgets, valid

    {

    QGraphicsWidget *widget = new QGraphicsWidget;

    TheAnchorLayout *layout = new TheAnchorLayout();