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

**

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

#include <QtGui/qgraphicsanchorlayout.h>

#include <private/qgraphicsanchorlayout_p.h>

#include <QtGui/qgraphicswidget.h>

#include <QtGui/qgraphicsproxywidget.h>

#include <QtGui/qgraphicsview.h>

class tst_QGraphicsAnchorLayout : public QObject {

    Q_OBJECT;

public:

    tst_QGraphicsAnchorLayout() : QObject() {

        hasSimplification = qgetenv("QT_ANCHORLAYOUT_NO_SIMPLIFICATION").isEmpty();

    }

private:

    bool hasSimplification;

private slots:

    void simple();

    void simple_center();

    void simple_semifloat();

    void layoutDirection();

    void diagonal();

    void parallel();

    void parallel2();

    void snake();

    void snakeOppositeDirections();

    void fairDistribution();

    void fairDistributionOppositeDirections();

    void proportionalPreferred();

    void example();

    void setSpacing();

    void hardComplexS60();

    void stability();

    void delete_anchor();

    void conflicts();

    void sizePolicy();

    void expandingSequence();

    void expandingSequenceFairDistribution();

    void expandingParallel();

    void floatConflict();

    void infiniteMaxSizes();

};

class RectWidget : public QGraphicsWidget

{

public:

    RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent){}

    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());

    }

};

static QGraphicsWidget *createItem(const QSizeF &minimum = QSizeF(100.0, 100.0),

                                   const QSizeF &preferred = QSize(150.0, 100.0),

                                   const QSizeF &maximum = QSizeF(200.0, 100.0),

                                   const QString &name = QString())

{

    QGraphicsWidget *w = new RectWidget;

    w->setMinimumSize(minimum);

    w->setPreferredSize(preferred);

    w->setMaximumSize(maximum);

    w->setData(0, name);

    return w;

}

static void setAnchor(QGraphicsAnchorLayout *l,

                      QGraphicsLayoutItem *firstItem,

                      Qt::AnchorPoint firstEdge,

                      QGraphicsLayoutItem *secondItem,

                      Qt::AnchorPoint secondEdge,

                      qreal spacing = 0)

{

    QGraphicsAnchor *anchor = l->addAnchor(firstItem, firstEdge, secondItem, secondEdge);

    anchor->setSpacing(spacing);

}

static bool checkReverseDirection(QGraphicsWidget *w)

{

    QGraphicsLayout *l = w->layout();

    Q_ASSERT(l);

    qreal left, top, right, bottom;

    l->getContentsMargins(&left, &top, &right, &bottom);

    w->setLayoutDirection(Qt::LeftToRight);

    QApplication::processEvents();

    const QRectF lg = l->geometry();

    QMap<QGraphicsLayoutItem *, QRectF> geometries;

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

        QGraphicsLayoutItem *w = l->itemAt(i);

        geometries.insert(w, w->geometry());

    }

    w->setLayoutDirection(Qt::RightToLeft);

    QApplication::processEvents();

    lg.adjusted(+right, +top, -left, -bottom);

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

        QGraphicsLayoutItem *w = l->itemAt(i);

        const QRectF rtlGeom = w->geometry();

        const QRectF ltrGeom = geometries.value(w);

        QRectF expectedGeom = ltrGeom;

        expectedGeom.moveRight(lg.right() - (0 + ltrGeom.left()));

        if (expectedGeom != rtlGeom) {

            qDebug() << "layout->geometry():" << lg

                     << "expected:" << expectedGeom

                     << "actual:" << rtlGeom;

            return false;

        }

    }

    return true;

}

static bool layoutHasConflict(QGraphicsAnchorLayout *l)

{

    return QGraphicsAnchorLayoutPrivate::get(l)->hasConflicts();

}

static bool usedSimplex(QGraphicsAnchorLayout *l, Qt::Orientation o)

{

    QGraphicsAnchorLayoutPrivate::Orientation oo = (o == Qt::Horizontal) ?

        QGraphicsAnchorLayoutPrivate::Horizontal :

        QGraphicsAnchorLayoutPrivate::Vertical;

    return QGraphicsAnchorLayoutPrivate::get(l)->lastCalculationUsedSimplex[oo];

}

void tst_QGraphicsAnchorLayout::simple()

{

    QGraphicsWidget *w1 = createItem();

    QGraphicsWidget *w2 = createItem();

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;

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

    // Horizontal

    l->addAnchor(l, Qt::AnchorLeft, w1, Qt::AnchorLeft);

    l->addAnchor(w1, Qt::AnchorRight, w2, Qt::AnchorLeft);

    l->addAnchor(w2, Qt::AnchorRight, l, Qt::AnchorRight);

    // Vertical

    l->addAnchors(l, w1, Qt::Vertical);

    l->addAnchors(l, w2, Qt::Vertical);

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

    QGraphicsWidget p;

    p.setLayout(l);

    p.adjustSize();

    if (hasSimplification) {

        QVERIFY(!usedSimplex(l, Qt::Horizontal));

        QVERIFY(!usedSimplex(l, Qt::Vertical));

    }

}

void tst_QGraphicsAnchorLayout::simple_center()

{

    QSizeF min(10, 10);

    QSizeF pref(50, 10);

    QSizeF max(100, 10);

    QGraphicsWidget *a = createItem(min, pref, max, "a");

    QGraphicsWidget *b = createItem(min, pref, max, "b");

    QGraphicsWidget *c = createItem(min, pref, max, "c");

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;

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

    // horizontal

    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);

    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);

    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight, 0);

    setAnchor(l, a, Qt::AnchorHorizontalCenter, c, Qt::AnchorLeft, 0);

    setAnchor(l, c, Qt::AnchorRight, b, Qt::AnchorHorizontalCenter, 0);

    // vertical

    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop, 0);

    setAnchor(l, l, Qt::AnchorTop, b, Qt::AnchorTop, 0);

    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorTop, 0);

    setAnchor(l, b, Qt::AnchorBottom, c, Qt::AnchorTop, 0);

    setAnchor(l, c, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);

    QCOMPARE(l->count(), 3);

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

    p->setLayout(l);

    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);

    QCOMPARE(layoutMinimumSize, QSizeF(20, 20));

    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);

    QCOMPARE(layoutMaximumSize, QSizeF(200, 20));

    if (hasSimplification) {

        QVERIFY(usedSimplex(l, Qt::Horizontal));

        QVERIFY(!usedSimplex(l, Qt::Vertical));

    }

    delete p;

}

void tst_QGraphicsAnchorLayout::simple_semifloat()

{

    // Useful for testing simplification between A_left and B_left.

    // Unfortunately the only way to really test that now is to manually inspect the

    // simplified graph.

    QSizeF min(10, 10);

    QSizeF pref(50, 10);

    QSizeF max(100, 10);

    QGraphicsWidget *A = createItem(min, pref, max, "A");

    QGraphicsWidget *B = createItem(min, pref, max, "B");

    QGraphicsWidget *a = createItem(min, pref, max, "a");

    QGraphicsWidget *b = createItem(min, pref, max, "b");

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;

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

    // horizontal

    setAnchor(l, l, Qt::AnchorLeft, A, Qt::AnchorLeft, 0);

    setAnchor(l, A, Qt::AnchorRight, B, Qt::AnchorLeft, 0);

    setAnchor(l, B, Qt::AnchorRight, l, Qt::AnchorRight, 0);

    setAnchor(l, A, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);

    setAnchor(l, B, Qt::AnchorLeft, b, Qt::AnchorLeft, 0);

    // vertical

    setAnchor(l, l, Qt::AnchorTop, A, Qt::AnchorTop, 0);

    setAnchor(l, l, Qt::AnchorTop, B, Qt::AnchorTop, 0);

    setAnchor(l, A, Qt::AnchorBottom, a, Qt::AnchorTop, 0);

    setAnchor(l, B, Qt::AnchorBottom, b, Qt::AnchorTop, 0);

    setAnchor(l, a, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);

    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);

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

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

    p->setLayout(l);

    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);

    QCOMPARE(layoutMinimumSize, QSizeF(20, 20));

    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(100, 20));

    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);

    QCOMPARE(layoutMaximumSize, QSizeF(200, 20));

    delete p;

}

void tst_QGraphicsAnchorLayout::layoutDirection()

{

    QSizeF min(10, 10);

    QSizeF pref(50, 10);

    QSizeF max(100, 10);

    QGraphicsWidget *a = createItem(min, pref, max, "a");

    QGraphicsWidget *b = createItem(min, pref, max, "b");

    QGraphicsWidget *c = createItem(min, pref, QSizeF(100, 20), "c");

    a->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

    b->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

    c->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;

    l->setContentsMargins(0, 5, 10, 15);

    // horizontal

    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);

    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);

    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight, 0);

    setAnchor(l, a, Qt::AnchorHorizontalCenter, c, Qt::AnchorLeft, 0);

    setAnchor(l, c, Qt::AnchorRight, b, Qt::AnchorHorizontalCenter, 0);

    // vertical

    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop, 0);

    setAnchor(l, l, Qt::AnchorTop, b, Qt::AnchorTop, 0);

    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorTop, 0);

    setAnchor(l, b, Qt::AnchorBottom, c, Qt::AnchorTop, 0);

    setAnchor(l, c, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);

    QCOMPARE(l->count(), 3);

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

    p->setLayoutDirection(Qt::LeftToRight);

    p->setLayout(l);

    QGraphicsScene scene;

    QGraphicsView *view = new QGraphicsView(&scene);

    scene.addItem(p);

    p->show();

    view->show();

    QCOMPARE(checkReverseDirection(p), true);

    QVERIFY(usedSimplex(l, Qt::Horizontal));

    QVERIFY(!usedSimplex(l, Qt::Vertical));

    delete p;

    delete view;

}

void tst_QGraphicsAnchorLayout::diagonal()

{

    QSizeF min(10, 100);

    QSizeF pref(70, 100);

    QSizeF max(100, 100);

    QGraphicsWidget *a = createItem(min, pref, max, "A");

    QGraphicsWidget *b = createItem(min, pref, max, "B");

    QGraphicsWidget *c = createItem(min, pref, max, "C");

    QGraphicsWidget *d = createItem(min, pref, max, "D");

    QGraphicsWidget *e = createItem(min, pref, max, "E");

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;

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

    l->setSpacing(0);

    // vertical

    l->addAnchor(a, Qt::AnchorTop, l, Qt::AnchorTop);

    l->addAnchor(b, Qt::AnchorTop, l, Qt::AnchorTop);

    l->addAnchor(c, Qt::AnchorTop, a, Qt::AnchorBottom);

    l->addAnchor(c, Qt::AnchorTop, b, Qt::AnchorBottom);

    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);

    l->addAnchor(c, Qt::AnchorBottom, e, Qt::AnchorTop);

    l->addAnchor(d, Qt::AnchorBottom, l, Qt::AnchorBottom);

    l->addAnchor(e, Qt::AnchorBottom, l, Qt::AnchorBottom);

    // horizontal

    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);

    l->addAnchor(l, Qt::AnchorLeft, d, Qt::AnchorLeft);

    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);

    l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);

    l->addAnchor(c, Qt::AnchorRight, e, Qt::AnchorLeft);

    l->addAnchor(b, Qt::AnchorRight, l, Qt::AnchorRight);

    l->addAnchor(e, Qt::AnchorRight, l, Qt::AnchorRight);

    l->addAnchor(d, Qt::AnchorRight, e, Qt::AnchorLeft);

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

    QGraphicsWidget p;

    p.setLayout(l);

    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);

    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);

    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);

    QCOMPARE(layoutMinimumSize, QSizeF(30.0, 300.0));

    QCOMPARE(layoutPreferredSize, QSizeF(170.0, 300.0));

    QCOMPARE(layoutMaximumSize, QSizeF(190.0, 300.0));

    p.resize(layoutMinimumSize);

    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 10.0, 100.0));

    QCOMPARE(b->geometry(), QRectF(10.0, 0.0, 20.0, 100.0));

    QCOMPARE(c->geometry(), QRectF(10.0, 100.0, 10.0, 100.0));

    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 20.0, 100.0));

    QCOMPARE(e->geometry(), QRectF(20.0, 200.0, 10.0, 100.0));

    QCOMPARE(p.size(), layoutMinimumSize);

    p.resize(layoutPreferredSize);

    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 70.0, 100.0));

    QCOMPARE(b->geometry(), QRectF(70.0, 0.0, 100.0, 100.0));

    QCOMPARE(c->geometry(), QRectF(70.0, 100.0, 30.0, 100.0));

    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 100.0, 100.0));

    QCOMPARE(e->geometry(), QRectF(100.0, 200.0, 70.0, 100.0));

    QCOMPARE(p.size(), layoutPreferredSize);

    p.resize(layoutMaximumSize);

    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 90.0, 100.0));

    QCOMPARE(b->geometry(), QRectF(90.0, 0.0, 100.0, 100.0));

    QCOMPARE(c->geometry(), QRectF(90.0, 100.0, 10.0, 100.0));

    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 100.0, 100.0));

    QCOMPARE(e->geometry(), QRectF(100.0, 200.0, 90.0, 100.0));

    QCOMPARE(p.size(), layoutMaximumSize);

    QSizeF testA(175.0, 300.0);

    p.resize(testA);

    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 75.0, 100.0));

    QCOMPARE(b->geometry(), QRectF(75.0, 0.0, 100.0, 100.0));

    QCOMPARE(c->geometry(), QRectF(75.0, 100.0, 25.0, 100.0));

    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 100.0, 100.0));

    QCOMPARE(e->geometry(), QRectF(100.0, 200.0, 75.0, 100.0));

    QCOMPARE(p.size(), testA);

    if (hasSimplification) {

        QVERIFY(usedSimplex(l, Qt::Horizontal));

        QVERIFY(!usedSimplex(l, Qt::Vertical));

    }

    QCOMPARE(checkReverseDirection(&p), true);

    c->setMinimumWidth(300);

    QVERIFY(layoutHasConflict(l));

}

void tst_QGraphicsAnchorLayout::parallel()

{

    QGraphicsWidget *a = createItem(QSizeF(100, 100),

                                    QSizeF(150, 100),

                                    QSizeF(200, 100), "A");

    QGraphicsWidget *b = createItem(QSizeF(100, 100),

                                    QSizeF(150, 100),

                                    QSizeF(300, 100), "B");

    QGraphicsWidget *c = createItem(QSizeF(100, 100),

                                    QSizeF(200, 100),

                                    QSizeF(350, 100), "C");

    QGraphicsWidget *d = createItem(QSizeF(100, 100),

                                    QSizeF(170, 100),

                                    QSizeF(200, 100), "D");

    QGraphicsWidget *e = createItem(QSizeF(150, 100),

                                    QSizeF(150, 100),

                                    QSizeF(200, 100), "E");

    QGraphicsWidget *f = createItem(QSizeF(100, 100),

                                    QSizeF(150, 100),

                                    QSizeF(200, 100), "F");

    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;

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

    l->setSpacing(0);

    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);

    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);

    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);

    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);

    l->addAnchor(d, Qt::AnchorBottom, e, Qt::AnchorTop);

    l->addAnchor(e, Qt::AnchorBottom, f, Qt::AnchorTop);

    l->addAnchor(f, Qt::AnchorBottom, l, Qt::AnchorBottom);

    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);

    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);

    l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);

    l->addAnchor(b, Qt::AnchorRight, d, Qt::AnchorLeft);

    l->addAnchor(b, Qt::AnchorRight, e, Qt::AnchorLeft);

    l->addAnchor(c, Qt::AnchorRight, f, Qt::AnchorLeft);

    l->addAnchor(d, Qt::AnchorRight, f, Qt::AnchorLeft);

    l->addAnchor(e, Qt::AnchorRight, f, Qt::AnchorLeft);

    l->addAnchor(f, Qt::AnchorRight, l, Qt::AnchorRight);

    QCOMPARE(l->count(), 6);

    QGraphicsWidget p;

    p.setLayout(l);

    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);

    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);

    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);

    QCOMPARE(layoutMinimumSize, QSizeF(450, 600));

    QCOMPARE(layoutPreferredSize, QSizeF(620, 600));

    QCOMPARE(layoutMaximumSize, QSizeF(750, 600));

    p.resize(layoutMinimumSize);

    QCOMPARE(a->geometry(), QRectF(0, 0, 100, 100));

    QCOMPARE(b->geometry(), QRectF(100, 100, 100, 100));

    QCOMPARE(c->geometry(), QRectF(100, 200, 250, 100));

    QCOMPARE(d->geometry(), QRectF(200, 300, 150, 100));

    QCOMPARE(e->geometry(), QRectF(200, 400, 150, 100));

    QCOMPARE(f->geometry(), QRectF(350, 500, 100, 100));

    QCOMPARE(p.size(), layoutMinimumSize);

    if (!hasSimplification)

        return;

    p.resize(layoutPreferredSize);

    QCOMPARE(a->geometry(), QRectF(0, 0, 150, 100));

    QCOMPARE(b->geometry(), QRectF(150, 100, 150, 100));

    QCOMPARE(c->geometry(), QRectF(150, 200, 320, 100));

    QCOMPARE(d->geometry(), QRectF(300, 300, 170, 100));

    QCOMPARE(e->geometry(), QRectF(300, 400, 170, 100));

    QCOMPARE(f->geometry(), QRectF(470, 500, 150, 100));

    QCOMPARE(p.size(), layoutPreferredSize);

    // Maximum size depends on simplification / fair distribution

    // Without that, test may or may not pass, depending on the

    // solution found by the solver at runtime.

    p.resize(layoutMaximumSize);