--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,3090 @@
+/****************************************************************************
+**
+** 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();
+
+ TestWidget *widget1 = new TestWidget();
+ TestWidget *widget2 = new TestWidget();
+
+ // Vertically the layout has floating items. Therefore, we have a conflict
+ layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+ layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, -0.1);
+
+ // Horizontally the layout has floating items. Therefore, we have a conflict
+ layout->setAnchor(layout, Qt::AnchorTop, widget2, Qt::AnchorTop, 0.1);
+ layout->setAnchor(layout, Qt::AnchorBottom, widget2, Qt::AnchorBottom, -0.1);
+
+ widget->setLayout(layout);
+
+ widget->setGeometry(QRectF(0,0,100,100));
+ QCOMPARE(layout->isValid(), false);
+ delete widget;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testSpecialCases()
+{
+ // One widget, setLayout before defining layouts
+ {
+#ifdef QT_DEBUG
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
+ " in wrong parent; moved to correct parent");
+#endif
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout();
+ widget->setLayout(layout);
+
+ TestWidget *widget1 = new TestWidget();
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+ layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+ layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+ layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+ widget->setGeometry(QRectF(0,0,100,100));
+ QCOMPARE(widget1->geometry(), QRectF(1,1,98,98));
+ delete widget1;
+ delete widget;
+ }
+
+ // One widget, layout inside layout, layout inside layout inside layout
+ {
+#ifdef QT_DEBUG
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
+ " in wrong parent; moved to correct parent");
+#endif
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout();
+ widget->setLayout(layout);
+
+ TheAnchorLayout *layout1 = new TheAnchorLayout();
+ TestWidget *widget1 = new TestWidget();
+ layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+ layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+ layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+ layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+ TheAnchorLayout *layout2 = new TheAnchorLayout();
+ TestWidget *widget2 = new TestWidget();
+ layout2->setAnchor(layout2, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 1);
+ layout2->setAnchor(layout2, Qt::AnchorTop, widget2, Qt::AnchorTop, 1);
+ layout2->setAnchor(widget2, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+ layout2->setAnchor(widget2, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+ layout1->setAnchor(layout1, Qt::AnchorLeft, layout2, Qt::AnchorLeft, 1);
+ layout1->setAnchor(layout1, Qt::AnchorTop, layout2, Qt::AnchorTop, 1);
+ layout1->setAnchor(layout2, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+ layout1->setAnchor(layout2, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+ layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+ layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+ layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+ layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+ // remove and add again to improve test coverage.
+ layout->removeItem(layout1);
+
+ layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+ layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+ layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+ layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+ widget->setGeometry(QRectF(0,0,100,100));
+ QCOMPARE(widget1->geometry(), QRectF(2,2,96,96));
+ QCOMPARE(widget2->geometry(), QRectF(3,3,94,94));
+ delete widget;
+ }
+
+ // One widget, layout inside layout, setLayout after layout definition
+ {
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout();
+
+ TheAnchorLayout *layout1 = new TheAnchorLayout();
+
+ TestWidget *widget1 = new TestWidget();
+ layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+ layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+ layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+ layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+ layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+ layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+ layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+ layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+ widget->setLayout(layout);
+ widget->setGeometry(QRectF(0,0,100,100));
+ QCOMPARE(widget1->geometry(), QRectF(2,2,96,96));
+ delete widget;
+ }
+
+ // One widget, layout inside layout, setLayout after layout definition, widget transferred from
+ // one layout to another
+ {
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout();
+ widget->setLayout(layout);
+
+ TheAnchorLayout *layout1 = new TheAnchorLayout();
+ TestWidget *widget1 = new TestWidget();
+
+ // Additional layout + widget to improve coverage.
+ TheAnchorLayout *layout0 = new TheAnchorLayout();
+ TestWidget *widget0 = new TestWidget();
+
+ // widget0 to layout0
+ layout0->setAnchor(layout0, Qt::AnchorLeft, widget0, Qt::AnchorLeft, 1);
+ layout0->setAnchor(layout0, Qt::AnchorTop, widget0, Qt::AnchorTop, 1);
+ layout0->setAnchor(widget0, Qt::AnchorRight, layout0, Qt::AnchorRight, 1);
+ layout0->setAnchor(widget0, Qt::AnchorBottom, layout0, Qt::AnchorBottom, 1);
+
+ // layout0 to layout
+ layout->setAnchor(layout, Qt::AnchorLeft, layout0, Qt::AnchorLeft, 1);
+ layout->setAnchor(layout, Qt::AnchorTop, layout0, Qt::AnchorTop, 1);
+ layout->setAnchor(layout0, Qt::AnchorRight, layout, Qt::AnchorRight, 50);
+ layout->setAnchor(layout0, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+ // widget1 to layout1
+ layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+ layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+ layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+ layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+ // layout1 to layout
+ layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+ layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+ layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 50);
+ layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+ TheAnchorLayout *layout2 = new TheAnchorLayout();
+
+ // layout2 to layout
+ layout->setAnchor(layout, Qt::AnchorLeft, layout2, Qt::AnchorLeft, 50);
+ layout->setAnchor(layout, Qt::AnchorTop, layout2, Qt::AnchorTop, 1);
+ layout->setAnchor(layout2, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+ layout->setAnchor(layout2, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+ // transfer widget1 to layout2
+ layout2->setAnchor(layout2, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+ layout2->setAnchor(layout2, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+ layout2->setAnchor(widget1, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+ layout2->setAnchor(widget1, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+ // ###: uncomment when simplification bug is solved
+ //widget->setGeometry(QRectF(0,0,100,100));
+ //QCOMPARE(widget1->geometry(), QRectF(51,2,47,96));
+ delete widget;
+ }
+
+ // One widget, set first to one layout then to another. Child reparented.
+ // In addition widget as a direct child of another widget. Child reparented.
+ {
+ QGraphicsWidget *widget1 = new QGraphicsWidget;
+ TheAnchorLayout *layout1 = new TheAnchorLayout();
+ widget1->setLayout(layout1);
+
+ TestWidget *childWidget = new TestWidget();
+
+ // childWidget to layout1
+ layout1->setAnchor(layout1, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 1);
+ layout1->setAnchor(layout1, Qt::AnchorTop, childWidget, Qt::AnchorTop, 1);
+ layout1->setAnchor(childWidget, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+ layout1->setAnchor(childWidget, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+ widget1->setGeometry(QRectF(0,0,100,100));
+ QCOMPARE(childWidget->geometry(), QRectF(1,1,98,98));
+ QVERIFY(childWidget->parentLayoutItem() == layout1);
+ QGraphicsWidget *widget2 = new QGraphicsWidget;
+ TheAnchorLayout *layout2 = new TheAnchorLayout();
+ widget2->setLayout(layout2);
+
+ // childWidget to layout2
+ layout2->setAnchor(layout2, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 1);
+ layout2->setAnchor(layout2, Qt::AnchorTop, childWidget, Qt::AnchorTop, 1);
+ layout2->setAnchor(childWidget, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+ layout2->setAnchor(childWidget, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+ QGraphicsWidget *widget3 = new QGraphicsWidget;
+ QGraphicsWidget *widget4 = new QGraphicsWidget;
+ // widget4 is a direct child of widget3 (i.e. not in any layout)
+ widget4->setParentItem(widget3);
+
+ // widget4 to layout2
+ layout2->setAnchor(layout2, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 1);
+ layout2->setAnchor(layout2, Qt::AnchorTop, widget4, Qt::AnchorTop, 1);
+ layout2->setAnchor(widget4, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+ layout2->setAnchor(widget4, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+ widget2->setGeometry(QRectF(0,0,100,100));
+ QCOMPARE(childWidget->geometry(), QRectF(1,1,98,98));
+ QVERIFY(childWidget->parentLayoutItem() == layout2);
+ QCOMPARE(widget4->geometry(), QRectF(1,1,98,98));
+ QVERIFY(widget4->parentLayoutItem() == layout2);
+ QVERIFY(widget4->parentItem() == widget2);
+
+ delete widget4;
+ delete widget3;
+ delete widget1;
+ delete childWidget;
+ delete widget2;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testBasicLayout_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ // One widget, basic
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 30)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 40)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(20, 10, 150, 50) )
+ ;
+
+ QTest::newRow("One, simple") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // One widget, duplicates
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 30)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 40)
+
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 0)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(0, 0, 200, 100) )
+ ;
+
+ QTest::newRow("One, duplicates") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // One widget, mixed
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 80)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 150)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorRight, 150)
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorBottom, 80)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(50, 20, 100, 60) )
+ ;
+
+ QTest::newRow("One, mixed") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets (same layout), different ordering
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 180, 80) )
+ << BasicResult(1, QRectF(10, 10, 180, 80) )
+ ;
+
+ QTest::newRow("Two, orderings") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, duplicate anchors
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 30)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(30, 10, 160, 70) )
+ << BasicResult(1, QRectF(10, 0, 190, 90) )
+ ;
+
+ QTest::newRow("Two, duplicates") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, mixed
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 90)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 190)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorRight, 190)
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorBottom, 90)
+
+ << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorBottom, 20)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 20)
+ ;
+
+ // ### SIMPLIFICATION BUG FOR ITEM 1
+ // ### remove this when bug is solved
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 180, 80) )
+ << BasicResult(1, QRectF(10, 80, 10, 10) )
+ ;
+
+ QTest::newRow("Two, mixed") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 1 horizontal connection, first completely defined
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 10, 80) )
+ << BasicResult(1, QRectF(30, 10, 160, 70) )
+ ;
+
+ QTest::newRow("Two, 1h connected") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 2 horizontal connections, first completely defined
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+ // ### QGAL is not sensible to the argument order in this case
+ // To achieve the desired result we must explicitly set a negative
+ // spacing.
+ // << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, 100)
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, -100)
+
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 30)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 10, 80) )
+ << BasicResult(1, QRectF(50, 10, 60, 70) )
+ ;
+
+ QTest::newRow("Two, 2h connected") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 1 vertical connection, first completely defined
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 30)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 10, 80) )
+ << BasicResult(1, QRectF(30, 20, 160, 60) )
+ ;
+
+ QTest::newRow("Two, 1v connected") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 2 vertical connections, first completely defined
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 30)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 20)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 10, 80) )
+ << BasicResult(1, QRectF(30, 20, 160, 50) )
+ ;
+
+ QTest::newRow("Two, 2v connected") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 1 horizontal and 1 vertical connection, first completely defined
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 80)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 100)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 10)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 10, 80) )
+ << BasicResult(1, QRectF(80, 10, 40, 70) )
+ ;
+
+ QTest::newRow("Two, 1h+1v connected") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 2 horizontal and 2 vertical connections, first completely defined
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 80)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 100)
+ << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 10)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 10, 80) )
+ << BasicResult(1, QRectF(90, 20, 30, 60) )
+ ;
+
+ QTest::newRow("Two, 2h+2v connected") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 2 horizontal and 2 vertical connections, dependent on each other.
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 150)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 10)
+
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 90)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 30, 60) )
+ << BasicResult(1, QRectF(100, 20, 90, 60) )
+ ;
+
+ QTest::newRow("Two, 2h+2v connected2") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, connected, overlapping
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ // << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, 30)
+ // ### QGAL has different semantics and assumes right edges are always
+ // to the left of left edges. Thus we need the minus sign here.
+ << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -30)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 40)
+
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 40)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 10, 60, 40) )
+ << BasicResult(1, QRectF(40, 20, 150, 70) )
+ ;
+
+ QTest::newRow("Two, connected overlapping") << QSizeF(200, 100) << theData << theResult;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testNegativeSpacing_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ // One widget, negative spacing
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ /// ### QGAL assumes items are always inside the layout.
+ // In this case, the negative spacing would make the item
+ // grow beyond the layout edges, which is OK, but gives a
+ // different result.
+ // Changing the direction of anchors (-1 to 0 or vice-versa)
+ // has no effect in this case.
+
+ theData
+ // << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ // << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -20)
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -30)
+ // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -40)
+
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, -10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, -20)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, -30)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, -40)
+
+ ;
+
+ theResult
+ // << BasicResult(0, QRectF(20, 10, 150, 50) )
+ << BasicResult(0, QRectF(-20, -10, 250, 150) )
+ ;
+
+ QTest::newRow("One, simple (n)") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // One widget, duplicates, negative spacing
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -20)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -20)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -30)
+ << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -40)
+
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -10)
+ << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+ ;
+
+ theResult
+ // ### Same as above...
+ // << BasicResult(0, QRectF(10, 10, 180, 80) )
+ << BasicResult(0, QRectF(-10, -10, 220, 120) )
+ ;
+
+ QTest::newRow("One, duplicates (n)") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // One widget, mixed, negative spacing
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // ### All anchors of negative spacing between the layout and an
+ // item are handled as to make sure the item is _outside_ the
+ // layout.
+ // To keep it inside, one _must_ use positive spacings.
+ // << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorTop, -80)
+ // << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorLeft, -150)
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorLeft, -150)
+ // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorTop, -80)
+
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorTop, 80)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorLeft, 150)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorLeft, 150)
+ << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorTop, 80)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(50, 20, 100, 60) )
+ ;
+
+ QTest::newRow("One, mixed (n)") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 1 horizontal connection, first completely defined, negative spacing
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+ // << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -180)
+
+ // << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -10)
+ // << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+ // << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ // << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
+
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 180)
+
+ << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -10)
+ << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+ << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
+
+ ;
+
+ theResult
+ // << BasicResult(0, QRectF(10, 10, 10, 80) )
+ // << BasicResult(1, QRectF(30, 10, 160, 70) )
+
+ << BasicResult(0, QRectF(-10, -10, 30, 120) )
+ << BasicResult(1, QRectF(10, -10, 200, 130) )
+ ;
+
+ QTest::newRow("Two, 1h connected (n)") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Basic case - two widgets, 2 horizontal and 2 vertical connections, dependent on each other, negative spacing
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+ << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorRight, -150)
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+
+ << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorLeft, -90)
+ << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+ << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorTop, -10)
+ << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
+ ;
+
+ theResult
+ // << BasicResult(0, QRectF(10, 10, 30, 60) )
+ // << BasicResult(1, QRectF(100, 20, 90, 60) )
+ << BasicResult(0, QRectF(-10, -10, 70, 120) )
+ << BasicResult(1, QRectF(80, 0, 130, 120) )
+ ;
+
+ QTest::newRow("Two, 2h+2v connected2 (n)") << QSizeF(200, 100) << theData << theResult;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testMixedSpacing_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ // Two widgets, partial overlapping
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -50)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 50)
+ << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorRight, 15)
+
+ // << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorBottom, 5)
+ << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorBottom, -5)
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, -10)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 20)
+ << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -5)
+ ;
+
+ theResult
+ // << BasicResult(0, QRectF(50, 10, 45, 40) )
+ // << BasicResult(1, QRectF(40, 45, 40, 50) )
+ << BasicResult(0, QRectF(-50, 10, 145, 40) )
+ << BasicResult(1, QRectF(-60, 45, 140, 60) )
+ ;
+
+ QTest::newRow("Two, partial overlap") << QSizeF(100, 100) << theData << theResult;
+ }
+
+ // Two widgets, complete overlapping
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 5)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+ << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+ << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 25)
+
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+ << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorRight, 50)
+ << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(65, 5, 35, 35) )
+ << BasicResult(1, QRectF(40, 5, 60, 35) )
+ ;
+
+ QTest::newRow("Two, complete overlap") << QSizeF(90, 45) << theData << theResult;
+ }
+
+ // Five widgets, v shaped, edges shared
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // edges shared
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 0)
+ << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 0)
+ << BasicData(2, Qt::AnchorRight, 3, Qt::AnchorLeft, 0)
+ << BasicData(3, Qt::AnchorRight, 4, Qt::AnchorLeft, 0)
+ << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 0)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 0)
+ << BasicData(3, Qt::AnchorBottom, 2, Qt::AnchorTop, 0)
+ << BasicData(4, Qt::AnchorBottom, 3, Qt::AnchorTop, 0)
+ << BasicData(0, Qt::AnchorBottom, 4, Qt::AnchorBottom, 0)
+ << BasicData(1, Qt::AnchorBottom, 3, Qt::AnchorBottom, 0)
+ << BasicData(0, Qt::AnchorTop, 4, Qt::AnchorTop, 0)
+ << BasicData(1, Qt::AnchorTop, 3, Qt::AnchorTop, 0)
+
+ // margins
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 5)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 5)
+ << BasicData(2, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+ // << BasicData(-1, Qt::AnchorRight, 4, Qt::AnchorRight, -5)
+ << BasicData(-1, Qt::AnchorRight, 4, Qt::AnchorRight, 5)
+
+ // additional details for exact size determination easily
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 25)
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 50)
+ // << BasicData(-1, Qt::AnchorRight, 3, Qt::AnchorRight, -25)
+ // << BasicData(-1, Qt::AnchorRight, 2, Qt::AnchorRight, -50)
+ << BasicData(-1, Qt::AnchorRight, 3, Qt::AnchorRight, 25)
+ << BasicData(-1, Qt::AnchorRight, 2, Qt::AnchorRight, 50)
+ << BasicData(-1, Qt::AnchorTop, 3, Qt::AnchorBottom, 50)
+ // << BasicData(-1, Qt::AnchorBottom, 3, Qt::AnchorTop, -50)
+ << BasicData(-1, Qt::AnchorBottom, 3, Qt::AnchorTop, 50)
+
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(5,5,20,20))
+ << BasicResult(1, QRectF(25,25,25,25))
+ << BasicResult(2, QRectF(50,50,25,20))
+ << BasicResult(3, QRectF(75,25,25,25))
+ << BasicResult(4, QRectF(100,5,20,20))
+ ;
+
+ QTest::newRow("Five, V shape") << QSizeF(125, 75) << theData << theResult;
+ }
+
+ // ### The behavior is different in QGraphicsAnchorLayout. What happens here is
+ // that when the above anchors are set, the layout size hints are changed.
+ // In the example, the minimum item width is 5, thus the minimum layout width
+ // becomes 105 (50 + 5 + 50). Once that size hint is set, trying to set
+ // the widget size to (10, 10) is not possible because
+ // QGraphicsWidget::setGeometry() will enforce the minimum is respected.
+ if (0)
+ // One widget, unsolvable
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 50)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
+ ;
+ theResult
+ << BasicResult(0, QRectF(0,0,0,0))
+ ;
+
+ QTest::newRow("One widget, unsolvable") << QSizeF(10, 10) << theData << theResult;
+ }
+
+ // Two widgets, one has fixed size
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 50)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
+ // not supported, use sizePolicy instead
+ // << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorRight, 50)
+
+ << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 50)
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
+ ;
+ theResult
+ << BasicResult(0, QRectF(50,0,50,50))
+ << BasicResult(1, QRectF(50,0,50,50))
+ ;
+
+ QTest::newRow("Two widgets, one has fixed size") << QSizeF(150, 150) << theData << theResult;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testMulti_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ // Multiple widgets, all overllapping
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ const int n = 30;
+ for ( int i = 0 ; i < n; i++ ) {
+ theData
+ << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, 20)
+ << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, 10)
+ // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -40)
+ // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -30);
+ << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, 40)
+ << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, 30);
+
+ theResult
+ << BasicResult(i, QRectF(10, 20, 160, 40) );
+ }
+
+
+ QTest::newRow("Overlapping multi") << QSizeF(200, 100) << theData << theResult;
+ }
+
+ // Multiple widgets, linear order
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ const qreal height = 1000.f;
+ const qreal width = 2000.f;
+
+ const int n = 30;
+
+ const qreal verticalStep = height/qreal(n+2);
+ const qreal horizontalStep = width/qreal(n+2);
+
+ for ( int i = 0 ; i < n; i++ ) {
+
+ if ( i == 0 ) {
+ // First item
+ theData
+ << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+
+ } else if ( i == n-1 ) {
+ // Last item
+ theData
+ << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep)
+ << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, horizontalStep);
+ // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+
+ } else {
+ // items in the middle
+ theData
+ << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+ // << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ // << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+
+ }
+
+ theResult
+ << BasicResult(i, QRectF((i+1)*horizontalStep, (i+1)*verticalStep, horizontalStep, verticalStep) );
+ }
+
+
+ QTest::newRow("Linear multi") << QSizeF(width, height) << theData << theResult;
+ }
+
+ // Multiple widgets, V shape
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ const qreal height = 100.f;
+ const qreal width = 200.f;
+
+ const int n = 31; // odd number please (3,5,7... )
+
+ const qreal verticalStep = height/(2.f+(n+1)/2.f);
+ const qreal horizontalStep = width/(n+2.f);
+
+ for ( int i = 0 ; i < n; i++ ) {
+
+ if ( i == 0 ) {
+ // First item
+ theData
+ << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+
+ } else if ( i == n-1 ) {
+ // Last item
+ theData
+ << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, -verticalStep)
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(i, Qt::AnchorRight, -1, Qt::AnchorRight, horizontalStep);
+ } else if ( i == ((n-1)/2) ) {
+ // midway
+ theData
+ << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep)
+ << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+ } else if ( i < ((n-1)/2) ) {
+ // before midway - going down
+ theData
+ << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+
+ } else {
+ // after midway - going up
+ theData
+ << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, -verticalStep)
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+
+ }
+
+ if ( i <= ((n-1)/2) ) {
+ // until midway
+ theResult
+ << BasicResult(i, QRectF((i+1)*horizontalStep, (i+1)*verticalStep, horizontalStep, verticalStep) );
+ } else {
+ // after midway
+ theResult
+ << BasicResult(i, QRectF((i+1)*horizontalStep, (n-i)*verticalStep, horizontalStep, verticalStep) );
+ }
+
+ }
+ QTest::newRow("V multi") << QSizeF(width, height) << theData << theResult;
+ }
+
+ // Multiple widgets, grid
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ const qreal height = 100.f;
+ const qreal width = 200.f;
+
+ const int d = 10; // items per dimension
+ const int n = d*d;
+
+ const qreal verticalStep = height/(d+2.f);
+ const qreal horizontalStep = width/(d+2.f);
+
+ for ( int i = 0 ; i < n; i++ ) {
+ if ( i%d == 0 ) {
+ // left side item
+ theData
+ << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+ } else if ( (i+1)%d == 0 ) {
+ // rigth side item
+ theData
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+ << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, horizontalStep);
+ } else {
+ // horizontal middle
+ theData
+ << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+ << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+ }
+
+ if ( i < d ) {
+ // top line
+ theData
+ << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(i+d, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep);
+ } else if ( i >= (d-1)*d ){
+ // bottom line
+ theData
+ << BasicData(i-d, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+ << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep);
+ } else {
+ // vertical middle
+ theData
+ << BasicData(i-d, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+ << BasicData(i+d, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep);
+ }
+
+ theResult
+ << BasicResult(i, QRectF(((i%d)+1)*horizontalStep, ((i/d)+1)*verticalStep, horizontalStep, verticalStep) );
+ }
+
+ QTest::newRow("Grid multi") << QSizeF(200, 100) << theData << theResult;
+ }
+}
+
+inline QGraphicsLayoutItem *getItem(
+ int index,
+ const QList<QGraphicsWidget *>& widgets,
+ QGraphicsLayoutItem *defaultItem)
+{
+ if (index < 0) {
+ return defaultItem;
+ }
+
+ return widgets[index];
+}
+
+void tst_QGraphicsAnchorLayout1::testBasicLayout()
+{
+ QFETCH(QSizeF, size);
+ QFETCH(BasicLayoutTestDataList, data);
+ QFETCH(BasicLayoutTestResultList, result);
+
+ QGraphicsWidget *widget = new QGraphicsWidget;
+
+ // Determine amount of widgets to add.
+ int widgetCount = -1;
+ for (int i = 0; i < data.count(); ++i) {
+ const BasicLayoutTestData item = data[i];
+ widgetCount = qMax(widgetCount, item.firstIndex);
+ widgetCount = qMax(widgetCount, item.secondIndex);
+ }
+ ++widgetCount; // widgetCount is max of indices.
+
+ // Create dummy widgets
+ QList<QGraphicsWidget *> widgets;
+ for (int i = 0; i < widgetCount; ++i) {
+ TestWidget *w = new TestWidget;
+ widgets << w;
+ }
+
+ // Setup anchor layout
+ TheAnchorLayout *layout = new TheAnchorLayout;
+
+ for (int i = 0; i < data.count(); ++i) {
+ const BasicLayoutTestData item = data[i];
+ layout->setAnchor(
+ getItem(item.firstIndex, widgets, layout),
+ item.firstEdge,
+ getItem(item.secondIndex, widgets, layout),
+ item.secondEdge,
+ item.spacing );
+ }
+
+ widget->setLayout(layout);
+ widget->setContentsMargins(0,0,0,0);
+
+ widget->setMinimumSize(size);
+ widget->setMaximumSize(size);
+
+// QTest::qWait(500); // layouting is asynchronous..
+
+ // Validate
+ for (int i = 0; i < result.count(); ++i) {
+ const BasicLayoutTestResult item = result[i];
+ QCOMPARE(widgets[item.index]->geometry(), item.rect);
+ }
+
+ // ###: not supported yet
+/*
+ // Test mirrored mode
+ widget->setLayoutDirection(Qt::RightToLeft);
+ layout->activate();
+ // Validate
+ for (int j = 0; j < result.count(); ++j) {
+ const BasicLayoutTestResult item = result[j];
+ QRectF mirroredRect(item.rect);
+ // only valid cases are mirrored
+ if (mirroredRect.isValid()){
+ mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
+ }
+ QCOMPARE(widgets[item.index]->geometry(), mirroredRect);
+ delete widgets[item.index];
+ }
+*/
+ delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testNegativeSpacing()
+{
+ // use the same frame
+ testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testMixedSpacing()
+{
+ // use the same frame
+ testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testMulti()
+{
+ // use the same frame
+ testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testCenterAnchors_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ // Basic center case
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5);
+
+ theResult
+ << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+ QTest::newRow("center, basic") << QSizeF(20, 20) << theData << theResult;
+ }
+
+ // Basic center case, with invalid (shouldn't affect on result)
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+
+ // bogus definitions
+ << BasicData(0, Qt::AnchorHorizontalCenter, -1, Qt::AnchorBottom, 5)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorVerticalCenter, 5)
+ << BasicData(0, Qt::AnchorVerticalCenter, -1, Qt::AnchorRight, 5)
+ << BasicData(0, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 666)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 999)
+ << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorLeft, 333)
+ << BasicData(-1, Qt::AnchorRight, -1, Qt::AnchorRight, 222)
+ << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorTop, 111)
+ << BasicData(0, Qt::AnchorBottom, 0, Qt::AnchorBottom, 444);
+
+ theResult
+ << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::newRow("center, basic with invalid") << QSizeF(20, 20) << theData << theResult;
+ }
+
+ // Basic center case 2
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
+ // Not supported << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 0)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, -5);
+
+ theResult
+ << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+ QTest::newRow("center, basic 2") << QSizeF(20, 20) << theData << theResult;
+ }
+
+ // Basic center case, overrides
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 10)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 20)
+ << BasicData(0, Qt::AnchorHorizontalCenter, -1, Qt::AnchorHorizontalCenter, 30)
+ << BasicData(0, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 40)
+ // actual data:
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 0)
+ // << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, -5);
+
+ theResult
+ << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+ QTest::newRow("center, overrides") << QSizeF(20, 20) << theData << theResult;
+ }
+
+ // Two nested
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorLeft, 0)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 0)
+ << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorTop, 0)
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 0)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 0);
+
+ theResult
+ << BasicResult(0, QRectF(20, 0, 20, 40))
+ << BasicResult(1, QRectF(20, 20, 20, 20));
+
+ QTest::newRow("center, two nested") << QSizeF(40, 40) << theData << theResult;
+ }
+
+ // Two overlap
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ // theData
+ // // horizontal
+ // << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+ // << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 0)
+ // << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, -5)
+ // << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ // << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 10)
+ // // vertical is pretty much same as horizontal, just roles swapped
+ // << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+ // << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, 0)
+ // << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorBottom, -5)
+ // << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+ // << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorBottom, 10);
+
+ theData
+ // horizontal
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 0)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorHorizontalCenter, 5)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 20)
+ // vertical
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+ << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, 0)
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorVerticalCenter, 5)
+ << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 20);
+
+ theResult
+ << BasicResult(0, QRectF(20, 30, 20, 30))
+ << BasicResult(1, QRectF(30, 20, 30, 20));
+
+ QTest::newRow("center, two overlap") << QSizeF(70, 70) << theData << theResult;
+ }
+
+ // Three
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorHorizontalCenter, 75)
+ << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+ << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -30)
+ << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 0)
+ << BasicData(1, Qt::AnchorLeft, 1, Qt::AnchorRight, 30)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+
+ << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+ << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 35)
+ << BasicData(1, Qt::AnchorVerticalCenter, 2, Qt::AnchorVerticalCenter, 15)
+ << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 5)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+ << BasicData(2, Qt::AnchorBottom, 0, Qt::AnchorTop, 5)
+ << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 20);
+
+ theResult
+ << BasicResult(0, QRectF(0, 30, 10, 20))
+ << BasicResult(1, QRectF(20, 0, 30, 10))
+ << BasicResult(2, QRectF(60, 15, 40, 10));
+
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+
+ QTest::newRow("center, three") << QSizeF(100, 50) << theData << theResult;
+ }
+
+ // Two, parent center
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // vertical is pretty much same as horizontal, just roles swapped
+ << BasicData(-1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, -15)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 10)
+ << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
+ << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+ // horizontal
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -15)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 10)
+ << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 0);
+
+ theResult
+ << BasicResult(0, QRectF(20, 20, 30, 80))
+ << BasicResult(1, QRectF(20, 20, 80, 30));
+
+ QTest::newRow("center, parent") << QSizeF(100, 100) << theData << theResult;
+ }
+
+ // Two, parent center 2
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorHorizontalCenter, 15)
+ << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorHorizontalCenter, -15)
+ << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 5)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorRight, -5)
+ // vertical
+ << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 20)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 20)
+ << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 10);
+
+ theResult
+ << BasicResult(0, QRectF(30, 10, 15, 10))
+ << BasicResult(1, QRectF(10, 30, 10, 10));
+
+ QTest::newRow("center, parent 2") << QSizeF(50, 50) << theData << theResult;
+ }
+
+ // Two, parent center 3
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, -5)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 5)
+ // << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, 100)
+ << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, -100)
+ << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, 0)
+
+ // vertical
+ << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55)
+ << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+ << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+ << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 10)
+ // << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 45)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 45)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(0, 0, 45, 45))
+ << BasicResult(1, QRectF(55, 55, 45, 45));
+
+ QTest::newRow("center, parent 3") << QSizeF(100, 100) << theData << theResult;
+ }
+
+}
+
+void tst_QGraphicsAnchorLayout1::testCenterAnchors()
+{
+ // use the same frame
+ testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<BasicLayoutTestDataList>("removeData");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestDataList theRemoveData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 66)
+ << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 99)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 33)
+ ;
+
+ theRemoveData
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 0)
+ << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 0)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 0);
+
+ theResult
+ << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+ QTest::newRow("remove, center, basic") << QSizeF(20, 20) << theData
+ << theRemoveData << theResult;
+ }
+
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestDataList theRemoveData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorHorizontalCenter, 75)
+ << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+ << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -30)
+ << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 0)
+ << BasicData(1, Qt::AnchorLeft, 1, Qt::AnchorRight, 30)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+
+ // extra:
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 66)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 33)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 55)
+ << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55)
+
+ << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+ << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 35)
+ << BasicData(1, Qt::AnchorVerticalCenter, 2, Qt::AnchorVerticalCenter, 15)
+ << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 5)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+ << BasicData(2, Qt::AnchorBottom, 0, Qt::AnchorTop, 5)
+ << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 20);
+
+ theRemoveData
+ << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 66)
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 33)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 55)
+ << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55);
+
+ theResult
+ << BasicResult(0, QRectF(0, 30, 10, 20))
+ << BasicResult(1, QRectF(20, 0, 30, 10))
+ << BasicResult(2, QRectF(60, 15, 40, 10));
+
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+
+ QTest::newRow("remove, center, three") << QSizeF(100, 50) << theData << theRemoveData << theResult;
+ }
+
+ // add edge (item0,edge0,item1,edge1), remove (item1,edge1,item0,edge0)
+ {
+ BasicLayoutTestDataList theData;
+ BasicLayoutTestDataList theRemoveData;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+ << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+ << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+
+ << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 66)
+ << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 99)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 33)
+ << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorRight, 22)
+ << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 11)
+ ;
+
+ theRemoveData
+ << BasicData(1, Qt::AnchorHorizontalCenter, -1, Qt::AnchorHorizontalCenter, 0)
+ << BasicData(-1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 0)
+ << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
+ << BasicData(0, Qt::AnchorRight, 0, Qt::AnchorLeft, 0)
+ << BasicData(0, Qt::AnchorBottom, 0, Qt::AnchorTop, 0)
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+ QTest::newRow("remove, center, basic 2") << QSizeF(20, 20) << theData
+ << theRemoveData << theResult;
+ }
+
+}
+
+void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor()
+{
+ QFETCH(QSizeF, size);
+ QFETCH(BasicLayoutTestDataList, data);
+ QFETCH(BasicLayoutTestDataList, removeData);
+ QFETCH(BasicLayoutTestResultList, result);
+
+ QGraphicsWidget *widget = new QGraphicsWidget;
+
+ // Determine amount of widgets to add.
+ int widgetCount = -1;
+ for (int i = 0; i < data.count(); ++i) {
+ const BasicLayoutTestData item = data[i];
+ widgetCount = qMax(widgetCount, item.firstIndex);
+ widgetCount = qMax(widgetCount, item.secondIndex);
+ }
+ ++widgetCount; // widgetCount is max of indices.
+
+ // Create dummy widgets
+ QList<QGraphicsWidget *> widgets;
+ for (int i = 0; i < widgetCount; ++i) {
+ TestWidget *w = new TestWidget;
+ widgets << w;
+ }
+
+ // Setup anchor layout
+ TheAnchorLayout *layout = new TheAnchorLayout;
+
+ for (int i = 0; i < data.count(); ++i) {
+ const BasicLayoutTestData item = data[i];
+ layout->setAnchor(
+ getItem(item.firstIndex, widgets, layout),
+ item.firstEdge,
+ getItem(item.secondIndex, widgets, layout),
+ item.secondEdge,
+ item.spacing );
+ }
+
+ for (int i = 0; i < removeData.count(); ++i) {
+ const BasicLayoutTestData item = removeData[i];
+ layout->removeAnchor(
+ getItem(item.firstIndex, widgets, layout),
+ item.firstEdge,
+ getItem(item.secondIndex, widgets, layout),
+ item.secondEdge);
+ }
+
+ widget->setLayout(layout);
+ widget->setContentsMargins(0,0,0,0);
+
+ widget->setMinimumSize(size);
+ widget->setMaximumSize(size);
+
+ // Validate
+ for (int i = 0; i < result.count(); ++i) {
+ const BasicLayoutTestResult item = result[i];
+
+ QCOMPARE(widgets[item.index]->geometry(), item.rect);
+ delete widgets[item.index];
+ }
+ delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testSingleSizePolicy_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<QSizePolicy>("policy");
+ QTest::addColumn<bool>("valid");
+
+// FIXED
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ QTest::newRow("single size policy: fixed ok") << QSizeF(70, 70) << sizePolicy << true;
+ }
+/*
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ QTest::newRow("single size policy: fixed too big") << QSizeF(100, 100) << sizePolicy << false;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ QTest::newRow("single size policy: fixed too small") << QSizeF(50, 50) << sizePolicy << false;
+ }
+*/
+// MINIMUM
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+ QTest::newRow("single size policy: minimum bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+ QTest::newRow("single size policy: minimum limit ok") << QSizeF(70, 70) << sizePolicy << true;
+ }
+/*
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+ QTest::newRow("single size policy: minimum too small") << QSizeF(50, 50) << sizePolicy << false;
+ }
+*/
+// MAXIMUM
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
+ QTest::newRow("single size policy: maximum small ok") << QSizeF(50, 50) << sizePolicy << true;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
+ QTest::newRow("single size policy: maximum limit ok") << QSizeF(70, 70) << sizePolicy << true;
+ }
+/*
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
+ QTest::newRow("single size policy: maximum bigger fail") << QSizeF(100, 100) << sizePolicy << false;
+ }
+*/
+// PREFERRED
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ QTest::newRow("single size policy: preferred bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ QTest::newRow("single size policy: preferred smaller ok") << QSizeF(50, 50) << sizePolicy << true;
+ }
+/*
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ QTest::newRow("single size policy: preferred too big") << QSizeF(700, 700) << sizePolicy << false;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ QTest::newRow("single size policy: preferred too small") << QSizeF(21, 21) << sizePolicy << false;
+ }
+*/
+// MINIMUMEXPANDING
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+ QTest::newRow("single size policy: min.expanding bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+ QTest::newRow("single size policy: min.expanding limit ok") << QSizeF(70, 70) << sizePolicy << true;
+ }
+
+ /*{
+ QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+ QTest::newRow("single size policy: min.expanding too small") << QSizeF(50, 50) << sizePolicy << false;
+ }*/
+
+// EXPANDING
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
+ QTest::newRow("single size policy: expanding bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
+ QTest::newRow("single size policy: expanding smaller ok") << QSizeF(50, 50) << sizePolicy << true;
+ }
+
+ // IGNORED
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
+ QTest::newRow("single size policy: ignored bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+ }
+
+ {
+ QSizePolicy sizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
+ QTest::newRow("single size policy: ignored smaller ok") << QSizeF(50, 50) << sizePolicy << true;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testSingleSizePolicy()
+{
+ QFETCH(QSizeF, size);
+ QFETCH(QSizePolicy, policy);
+ QFETCH(bool, valid);
+
+ // create objects
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout;
+ TestWidget *childWidget = new TestWidget;
+
+ // set anchors
+ layout->setAnchor( layout, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 10 );
+ layout->setAnchor( childWidget, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
+ layout->setAnchor( layout, Qt::AnchorTop, childWidget, Qt::AnchorTop, 10 );
+ layout->setAnchor( childWidget, Qt::AnchorBottom, layout, Qt::AnchorBottom, 10 );
+
+ widget->setLayout( layout );
+
+ // set test case specific: policy and size
+ childWidget->setSizePolicy( policy );
+ widget->setGeometry( QRectF( QPoint(0,0), size ) );
+
+ QCOMPARE( layout->isValid() , valid );
+
+ const QRectF childRect = childWidget->geometry();
+ Q_UNUSED( childRect );
+}
+
+void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy_data()
+{
+ // tests only horizontal direction
+ QTest::addColumn<QSizePolicy>("policy1");
+ QTest::addColumn<QSizePolicy>("policy2");
+ QTest::addColumn<qreal>("width1");
+ QTest::addColumn<qreal>("width2");
+
+ // layout size always 100x100 and size hints for items are 5<50<500
+ // gabs: 10-item1-10-item2-10
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 50;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: fixed-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Minimum, QSizePolicy::Minimum );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 50;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: minimum-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Maximum, QSizePolicy::Maximum );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 35;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: maximum-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 35;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: preferred-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 50;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: min.expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Expanding, QSizePolicy::Expanding );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 35;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
+ QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ const qreal width1 = 35;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: ignored-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ /*{
+ QSizePolicy sizePolicy1( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = -1;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: fixed-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }*/
+
+ /*{
+ QSizePolicy sizePolicy1( QSizePolicy::Minimum, QSizePolicy::Minimum );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = -1;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: minimum-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }*/
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Maximum, QSizePolicy::Maximum );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = 20;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: maximum-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Preferred, QSizePolicy::Preferred );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = 20;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: preferred-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ /*{
+ QSizePolicy sizePolicy1( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = -1;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: min.expanding-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }*/
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Expanding, QSizePolicy::Expanding );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = 20;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: expanding-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+
+ {
+ QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
+ QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+ const qreal width1 = 20;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("double size policy: ignored-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy()
+{
+ // ### Size policy is not yet supported
+ return;
+
+ QFETCH(QSizePolicy, policy1);
+ QFETCH(QSizePolicy, policy2);
+ QFETCH(qreal, width1);
+ QFETCH(qreal, width2);
+
+ // create objects
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout;
+ TestWidget *childWidget1 = new TestWidget;
+ TestWidget *childWidget2 = new TestWidget;
+
+ // set anchors
+ layout->setAnchor( layout, Qt::AnchorLeft, childWidget1, Qt::AnchorLeft, 10 );
+ layout->setAnchor( childWidget1, Qt::AnchorRight, childWidget2, Qt::AnchorLeft, 10 );
+ layout->setAnchor( childWidget2, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
+
+ widget->setLayout( layout );
+
+ // set test case specific: policy
+ childWidget1->setSizePolicy( policy1 );
+ childWidget2->setSizePolicy( policy2 );
+
+ widget->setGeometry( QRectF( QPoint(0,0), QSize( 100,100 ) ) );
+
+ // check results:
+ if ( width1 == -1.0f ) {
+ // invalid
+ QCOMPARE( layout->isValid() , false );
+ } else {
+ // valid
+ QCOMPARE( childWidget1->geometry().width(), width1 );
+ QCOMPARE( childWidget2->geometry().width(), width2 );
+ }
+}
+
+typedef QMap<int,qreal> SizeHintArray;
+Q_DECLARE_METATYPE(SizeHintArray)
+
+void tst_QGraphicsAnchorLayout1::testSizeDistribution_data()
+{
+ // tests only horizontal direction
+ QTest::addColumn<SizeHintArray>("sizeHints1");
+ QTest::addColumn<SizeHintArray>("sizeHints2");
+ QTest::addColumn<qreal>("width1");
+ QTest::addColumn<qreal>("width2");
+
+ // layout size always 100x100 and size policy for items is preferred-preferred
+ // gabs: 10-item1-10-item2-10
+
+ {
+ SizeHintArray sizeHints1;
+ sizeHints1.insert( Qt::MinimumSize, 30 );
+ sizeHints1.insert( Qt::PreferredSize, 35 );
+ sizeHints1.insert( Qt::MaximumSize, 40 );
+ Q_ASSERT( sizeHints1.value( Qt::MinimumSize ) <= sizeHints1.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints1.value( Qt::PreferredSize ) <= sizeHints1.value( Qt::MaximumSize ) );
+
+ SizeHintArray sizeHints2;
+ sizeHints2.insert( Qt::MinimumSize, 5 );
+ sizeHints2.insert( Qt::PreferredSize, 35 );
+ sizeHints2.insert( Qt::MaximumSize, 300 );
+ Q_ASSERT( sizeHints2.value( Qt::MinimumSize ) <= sizeHints2.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints2.value( Qt::PreferredSize ) <= sizeHints2.value( Qt::MaximumSize ) );
+
+ const qreal width1 = 35;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("size distribution: preferred equal") << sizeHints1 << sizeHints2 << width1 << width2;
+ }
+
+ {
+ SizeHintArray sizeHints1;
+ sizeHints1.insert( Qt::MinimumSize, 0 );
+ sizeHints1.insert( Qt::PreferredSize, 20 );
+ sizeHints1.insert( Qt::MaximumSize, 100 );
+ Q_ASSERT( sizeHints1.value( Qt::MinimumSize ) <= sizeHints1.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints1.value( Qt::PreferredSize ) <= sizeHints1.value( Qt::MaximumSize ) );
+
+ SizeHintArray sizeHints2;
+ sizeHints2.insert( Qt::MinimumSize, 0 );
+ sizeHints2.insert( Qt::PreferredSize, 50 );
+ sizeHints2.insert( Qt::MaximumSize, 100 );
+ Q_ASSERT( sizeHints2.value( Qt::MinimumSize ) <= sizeHints2.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints2.value( Qt::PreferredSize ) <= sizeHints2.value( Qt::MaximumSize ) );
+
+ const qreal width1 = 20;
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("size distribution: preferred non-equal") << sizeHints1 << sizeHints2 << width1 << width2;
+ }
+
+ {
+ SizeHintArray sizeHints1;
+ sizeHints1.insert( Qt::MinimumSize, 0 );
+ sizeHints1.insert( Qt::PreferredSize, 40 );
+ sizeHints1.insert( Qt::MaximumSize, 100 );
+ Q_ASSERT( sizeHints1.value( Qt::MinimumSize ) <= sizeHints1.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints1.value( Qt::PreferredSize ) <= sizeHints1.value( Qt::MaximumSize ) );
+
+ SizeHintArray sizeHints2;
+ sizeHints2.insert( Qt::MinimumSize, 0 );
+ sizeHints2.insert( Qt::PreferredSize, 60 );
+ sizeHints2.insert( Qt::MaximumSize, 100 );
+ Q_ASSERT( sizeHints2.value( Qt::MinimumSize ) <= sizeHints2.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints2.value( Qt::PreferredSize ) <= sizeHints2.value( Qt::MaximumSize ) );
+
+ const qreal width1 = 28; // got from manual calculation
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("size distribution: below preferred") << sizeHints1 << sizeHints2 << width1 << width2;
+ }
+
+ {
+ SizeHintArray sizeHints1;
+ sizeHints1.insert( Qt::MinimumSize, 0 );
+ sizeHints1.insert( Qt::PreferredSize, 10 );
+ sizeHints1.insert( Qt::MaximumSize, 100 );
+ Q_ASSERT( sizeHints1.value( Qt::MinimumSize ) <= sizeHints1.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints1.value( Qt::PreferredSize ) <= sizeHints1.value( Qt::MaximumSize ) );
+
+ SizeHintArray sizeHints2;
+ sizeHints2.insert( Qt::MinimumSize, 0 );
+ sizeHints2.insert( Qt::PreferredSize, 40 );
+ sizeHints2.insert( Qt::MaximumSize, 100 );
+ Q_ASSERT( sizeHints2.value( Qt::MinimumSize ) <= sizeHints2.value( Qt::PreferredSize ) );
+ Q_ASSERT( sizeHints2.value( Qt::PreferredSize ) <= sizeHints2.value( Qt::MaximumSize ) );
+
+ const qreal width1 = 22; // got from manual calculation
+ const qreal width2 = 100-10-10-10-width1;
+ QTest::newRow("size distribution: above preferred") << sizeHints1 << sizeHints2 << width1 << width2;
+ }
+
+}
+
+void tst_QGraphicsAnchorLayout1::testSizeDistribution()
+{
+ QFETCH(SizeHintArray, sizeHints1);
+ QFETCH(SizeHintArray, sizeHints2);
+ QFETCH(qreal, width1);
+ QFETCH(qreal, width2);
+
+ // create objects
+ QGraphicsWidget *widget = new QGraphicsWidget;
+ TheAnchorLayout *layout = new TheAnchorLayout;
+ TestWidget *childWidget1 = new TestWidget;
+ TestWidget *childWidget2 = new TestWidget;
+
+ // set anchors
+ layout->setAnchor( layout, Qt::AnchorLeft, childWidget1, Qt::AnchorLeft, 10 );
+ layout->setAnchor( childWidget1, Qt::AnchorRight, childWidget2, Qt::AnchorLeft, 10 );
+ layout->setAnchor( childWidget2, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
+
+ widget->setLayout( layout );
+
+ // set test case specific: size hints
+ childWidget1->setMinimumWidth( sizeHints1.value( Qt::MinimumSize ) );
+ childWidget1->setPreferredWidth( sizeHints1.value( Qt::PreferredSize ) );
+ childWidget1->setMaximumWidth( sizeHints1.value( Qt::MaximumSize ) );
+
+ childWidget2->setMinimumWidth( sizeHints2.value( Qt::MinimumSize ) );
+ childWidget2->setPreferredWidth( sizeHints2.value( Qt::PreferredSize ) );
+ childWidget2->setMaximumWidth( sizeHints2.value( Qt::MaximumSize ) );
+
+ widget->setGeometry( QRectF( QPoint(0,0), QSize( 100,100 ) ) );
+
+ // check results:
+ if ( width1 == -1.0f ) {
+ // invalid
+ QCOMPARE( layout->isValid() , false );
+ } else {
+ // valid
+ QCOMPARE( float(childWidget1->geometry().width()), float(width1) );
+ QCOMPARE( float(childWidget2->geometry().width()), float(width2) );
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testSizeHint()
+{
+ QGraphicsWidget *widget[5];
+
+ for( int i = 0; i < 5; i++ ) {
+ widget[i] = new QGraphicsWidget;
+ widget[i]->setMinimumSize( 10, 10 );
+ widget[i]->setPreferredSize( 20, 20 );
+ widget[i]->setMaximumSize( 40, 40 );
+ }
+
+ // one, basic
+ {
+ TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+ layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 0 );
+
+ layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+ layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+
+ QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() );
+ QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() );
+ QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() );
+
+
+ delete layout;
+ }
+
+ // one, basic again
+ {
+ TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 10 );
+ // layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, -10 );
+ layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 10 );
+
+ layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 10 );
+ // layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, -10 );
+ layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 10 );
+
+ QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() + QSizeF( 20, 20 ) );
+ QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() + QSizeF( 20, 20 ) );
+ QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() + QSizeF( 20, 20 ) );
+
+ delete layout;
+ }
+
+ // two, serial
+ {
+ TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+ layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+ layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+
+ layout->setAnchor(widget[0], Qt::AnchorRight, widget[1], Qt::AnchorLeft, 0 );
+ layout->setAnchor(widget[1], Qt::AnchorRight, layout, Qt::AnchorRight, 0 );
+
+
+ QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() + QSizeF( widget[1]->minimumWidth(), 0 ) );
+ QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() + QSizeF( widget[1]->preferredWidth(), 0 ) );
+ QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() + QSizeF( widget[1]->maximumWidth(), 0 ) );
+
+ delete layout;
+ }
+
+ // two, parallel
+ {
+ TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+ layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+ layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+ layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 0 );
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget[1], Qt::AnchorLeft, 0 );
+ layout->setAnchor(layout, Qt::AnchorTop, widget[1], Qt::AnchorTop, 0 );
+ layout->setAnchor(layout, Qt::AnchorBottom, widget[1], Qt::AnchorBottom, 0 );
+ layout->setAnchor(layout, Qt::AnchorRight, widget[1], Qt::AnchorRight, 0 );
+
+ QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() );
+ QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() );
+ QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() );
+
+ delete layout;
+ }
+
+ // five, serial
+ {
+ TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+ layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+ layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+ layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+
+ layout->setAnchor(widget[0], Qt::AnchorRight, widget[1], Qt::AnchorLeft, 0 );
+ layout->setAnchor(widget[1], Qt::AnchorRight, widget[2], Qt::AnchorLeft, 0 );
+ layout->setAnchor(widget[2], Qt::AnchorRight, widget[3], Qt::AnchorLeft, 0 );
+ layout->setAnchor(widget[3], Qt::AnchorRight, widget[4], Qt::AnchorLeft, 0 );
+ layout->setAnchor(widget[4], Qt::AnchorRight, layout, Qt::AnchorRight, 0 );
+
+
+ QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() +
+ QSizeF( widget[1]->minimumWidth() +
+ widget[2]->minimumWidth() +
+ widget[3]->minimumWidth() +
+ widget[4]->minimumWidth(), 0 ) );
+
+ QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() +
+ QSizeF( widget[1]->preferredWidth() +
+ widget[2]->preferredWidth() +
+ widget[3]->preferredWidth() +
+ widget[4]->preferredWidth(), 0 ) );
+
+ QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() +
+ QSizeF( widget[1]->maximumWidth() +
+ widget[2]->maximumWidth() +
+ widget[3]->maximumWidth() +
+ widget[4]->maximumWidth(), 0 ) );
+
+ delete layout;
+ }
+
+
+ for( int i = 0; i < 5; i++ ) {
+ delete widget[i];
+ }
+}
+
+#ifdef TEST_COMPLEX_CASES
+
+void tst_QGraphicsAnchorLayout1::testComplexCases_data()
+{
+ QTest::addColumn<QSizeF>("size");
+ QTest::addColumn<BasicLayoutTestDataList>("data");
+ QTest::addColumn<AnchorItemSizeHintList>("sizehint");
+ QTest::addColumn<BasicLayoutTestResultList>("result");
+
+ typedef BasicLayoutTestData BasicData;
+ typedef BasicLayoutTestResult BasicResult;
+
+ // Three widgets, the same sizehint
+ {
+ BasicLayoutTestDataList theData;
+ AnchorItemSizeHintList theSizeHint;
+ BasicLayoutTestResultList theResult1;
+ BasicLayoutTestResultList theResult2;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+ ;
+
+ theSizeHint
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ ;
+ theResult1
+ << BasicResult(0, QRectF(10, 0, 30, 50) )
+ << BasicResult(1, QRectF(50, 0, 30, 50) )
+ << BasicResult(2, QRectF(50, 0, 30, 50) )
+ ;
+
+ theResult2
+ << BasicResult(0, QRectF(10, 0, 60, 50) )
+ << BasicResult(1, QRectF(80, 0, 60, 50) )
+ << BasicResult(2, QRectF(80, 0, 60, 50) )
+ ;
+
+ QTest::newRow("Three, the same sizehint(1)") << QSizeF(90, 50) << theData << theSizeHint << theResult1;
+ QTest::newRow("Three, the same sizehint(2)") << QSizeF(150, 50) << theData << theSizeHint << theResult2;
+ }
+
+ // Three widgets, serial is bigger
+ {
+ BasicLayoutTestDataList theData;
+ AnchorItemSizeHintList theSizeHint;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+ ;
+
+ theSizeHint
+ << AnchorItemSizeHint( 0, 100, 200, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ ;
+
+ theResult
+ << BasicResult(0, QRectF(10, 0, 70, 50) )
+ << BasicResult(1, QRectF(90, 0, 35, 50) )
+ << BasicResult(2, QRectF(90, 0, 35, 50) );
+
+ QTest::newRow("Three, serial is bigger") << QSizeF(135, 50) << theData << theSizeHint << theResult;
+
+ // theResult
+ // << BasicResult(0, QRectF(10, 0, 80, 50) )
+ // << BasicResult(1, QRectF(100, 0, 60, 50) )
+ // << BasicResult(2, QRectF(100, 0, 60, 50) )
+ // ;
+
+ // QTest::newRow("Three, serial is bigger") << QSizeF(170, 50) << theData << theSizeHint << theResult;
+ }
+
+
+ // Three widgets, parallel is bigger
+ {
+ BasicLayoutTestDataList theData;
+ AnchorItemSizeHintList theSizeHint;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+ ;
+
+ theSizeHint
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 100, 200, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ ;
+
+ // ### QGAL uses a different preferred size calculation algorithm.
+ // This algorithm was discussed with Jan-Arve and tries to grow
+ // items instead of shrinking them.
+ // In this case, the preferred size of each item becomes:
+ // Item 0: 50
+ // Item 1: 100 (grows to avoid shrinking item 2)
+ // Item 2: 100
+ // Therefore, the preferred size of the parent widget becomes
+ // 180 == (10 + 50 + 10 + 100 + 10)
+ // As we set its size to 150, each widget is shrinked in the same
+ // ratio, in order to achieve the width of 150 == (10 + 40 + 10 + 80 + 10)
+
+ theResult
+ << BasicResult(0, QRectF(10, 0, 40, 50) )
+ << BasicResult(1, QRectF(60, 0, 80, 50) )
+ << BasicResult(2, QRectF(60, 0, 80, 50) )
+ ;
+
+ QTest::newRow("Three, parallel is bigger") << QSizeF(150, 50) << theData << theSizeHint << theResult;
+
+ // #ifdef PREFERRED_IS_AVERAGE
+ // theResult
+ // << BasicResult(0, QRectF(10, 0, 50, 50) )
+ // << BasicResult(1, QRectF(70, 0, 75, 50) )
+ // << BasicResult(2, QRectF(70, 0, 75, 50) )
+ // ;
+
+ // QTest::newRow("Three, parallel is bigger") << QSizeF(155, 50) << theData << theSizeHint << theResult;
+ // #else
+ // theResult
+ // << BasicResult(0, QRectF(10, 0, 50, 50) )
+ // << BasicResult(1, QRectF(70, 0, 66.66666666666666, 50) )
+ // << BasicResult(2, QRectF(70, 0, 60.66666666666666, 50) )
+ // ;
+
+ // QTest::newRow("Three, parallel is bigger") << QSizeF(146.66666666666666, 50) << theData << theSizeHint << theResult;
+ // #endif
+ }
+
+ // Three widgets, the same sizehint, one center anchor
+ {
+ BasicLayoutTestDataList theData;
+ AnchorItemSizeHintList theSizeHint;
+ BasicLayoutTestResultList theResult;
+
+ theData
+ << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+ << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorLeft, 10)
+
+ << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+ << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+ << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+ << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+ ;
+
+ theSizeHint
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+ ;
+ theResult
+ << BasicResult(0, QRectF(10, 0, 40, 50) )
+ << BasicResult(1, QRectF(60, 0, 40, 50) )
+ << BasicResult(2, QRectF(40, 0, 60, 50) )
+ ;
+
+ ;
+
+ QTest::newRow("Three, the same sizehint, one center anchor") << QSizeF(110, 50) << theData << theSizeHint << theResult;
+ }
+}
+
+void tst_QGraphicsAnchorLayout1::testComplexCases()
+{
+ QFETCH(QSizeF, size);
+ QFETCH(BasicLayoutTestDataList, data);
+ QFETCH(AnchorItemSizeHintList, sizehint);
+ QFETCH(BasicLayoutTestResultList, result);
+
+ QGraphicsWidget *widget = new QGraphicsWidget;
+
+ // Determine amount of widgets to add.
+ int widgetCount = -1;
+ for (int i = 0; i < data.count(); ++i) {
+ const BasicLayoutTestData item = data[i];
+ widgetCount = qMax(widgetCount, item.firstIndex);
+ widgetCount = qMax(widgetCount, item.secondIndex);
+ }
+ ++widgetCount; // widgetCount is max of indices.
+
+ // Create dummy widgets
+ QList<QGraphicsWidget *> widgets;
+ for (int i = 0; i < widgetCount; ++i) {
+ TestWidget *w = new TestWidget;
+
+ w->setMinimumWidth( sizehint[i].hmin );
+ w->setPreferredWidth( sizehint[i].hpref );
+ w->setMaximumWidth( sizehint[i].hmax );
+
+ w->setMinimumHeight( sizehint[i].vmin );
+ w->setPreferredHeight( sizehint[i].vpref );
+ w->setMaximumHeight( sizehint[i].vmax );
+
+ widgets << w;
+ }
+
+ // Setup anchor layout
+ TheAnchorLayout *layout = new TheAnchorLayout;
+
+ for (int i = 0; i < data.count(); ++i) {
+ const BasicLayoutTestData item = data[i];
+ layout->setAnchor(
+ getItem(item.firstIndex, widgets, layout),
+ item.firstEdge,
+ getItem(item.secondIndex, widgets, layout),
+ item.secondEdge,
+ item.spacing );
+ }
+
+ widget->setLayout(layout);
+ widget->setContentsMargins(0,0,0,0);
+
+ widget->setMinimumSize(size);
+ widget->setMaximumSize(size);
+
+// QTest::qWait(500); // layouting is asynchronous..
+
+ // Validate
+ for (int i = 0; i < result.count(); ++i) {
+ const BasicLayoutTestResult item = result[i];
+ QCOMPARE(widgets[item.index]->geometry(), item.rect);
+ }
+
+ // Test mirrored mode
+ widget->setLayoutDirection(Qt::RightToLeft);
+ layout->activate();
+ // Validate
+ for (int j = 0; j < result.count(); ++j) {
+ const BasicLayoutTestResult item = result[j];
+ QRectF mirroredRect(item.rect);
+ // only valid cases are mirrored
+ if (mirroredRect.isValid()){
+ mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
+ }
+ QCOMPARE(widgets[item.index]->geometry(), mirroredRect);
+ delete widgets[item.index];
+ }
+
+ delete widget;
+}
+#endif //TEST_COMPLEX_CASES
+
+
+QTEST_MAIN(tst_QGraphicsAnchorLayout1)
+#include "tst_qgraphicsanchorlayout1.moc"
+//-----------------------------------------------------------------------------
+