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