AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
7dc5973bf1
qt5base-lts/tests/auto/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp
Jason McDonald 253497b744 Avoid using QSKIP in lieu of compile-time checks 
QSKIP is intended to be used to skip test functions that are found at
run-time to be inapplicable or unsafe.  If a test function can be
determined to be inapplicable at compile-time, the entire test function
should be omitted instead of replacing the body of the test function
with a QSKIP, which only serves to slow down test runs and to inflate
test run-rates with empty, inapplicable tests.

Task-number: QTQAINFRA-278

Change-Id: I582732e3dd657df834f9a98fd52d7ee368f2f29b
Reviewed-on: http://codereview.qt-project.org/5946
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-10-05 06:15:00 +02:00

3466 lines
139 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2011 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$
** GNU Lesser General Public License Usage
** 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.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <qgraphicsgridlayout.h>
#include <qgraphicswidget.h>
#include <qgraphicsscene.h>
#include <qgraphicsview.h>
class tst_QGraphicsGridLayout : public QObject
{
Q_OBJECT
public slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
private slots:
void qgraphicsgridlayout_data();
void qgraphicsgridlayout();
void addItem_data();
void addItem();
#ifndef Q_WS_MAC
void alignment_data();
void alignment();
#endif
void alignment2();
void alignment2_data();
#ifndef Q_WS_MAC
void columnAlignment_data();
void columnAlignment();
#endif
void columnCount_data();
void columnCount();
void columnMaximumWidth_data();
void columnMaximumWidth();
void columnMinimumWidth_data();
void columnMinimumWidth();
void columnPreferredWidth_data();
void columnPreferredWidth();
void setColumnFixedWidth();
void columnSpacing();
void columnStretchFactor();
void count();
void contentsMargins();
void horizontalSpacing_data();
void horizontalSpacing();
void itemAt();
void removeAt();
void removeItem();
void rowAlignment_data();
void rowAlignment();
void rowCount_data();
void rowCount();
void rowMaximumHeight_data();
void rowMaximumHeight();
void rowMinimumHeight_data();
void rowMinimumHeight();
void rowPreferredHeight_data();
void rowPreferredHeight();
void rowSpacing();
void rowStretchFactor_data();
void rowStretchFactor();
void setColumnSpacing_data();
void setColumnSpacing();
void setGeometry_data();
void setGeometry();
void setRowFixedHeight();
void setRowSpacing_data();
void setRowSpacing();
void setSpacing_data();
void setSpacing();
void sizeHint_data();
void sizeHint();
void verticalSpacing_data();
void verticalSpacing();
void layoutDirection_data();
void layoutDirection();
void removeLayout();
void defaultStretchFactors_data();
void defaultStretchFactors();
void geometries_data();
void geometries();
void avoidRecursionInInsertItem();
void styleInfoLeak();
void task236367_maxSizeHint();
void spanningItem2x2_data();
void spanningItem2x2();
void spanningItem2x3_data();
void spanningItem2x3();
void spanningItem();
void heightForWidth();
void widthForHeight();
void heightForWidthWithSpanning();
void stretchAndHeightForWidth();
void testDefaultAlignment();
};
class RectWidget : public QGraphicsWidget
{
public:
RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent), m_fnConstraint(0) {}
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->drawRoundRect(rect());
painter->drawLine(rect().topLeft(), rect().bottomRight());
painter->drawLine(rect().bottomLeft(), rect().topRight());
}
QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
{
if (constraint.width() < 0 && constraint.height() < 0 && m_sizeHints[which].isValid()) {
return m_sizeHints[which];
}
if (m_fnConstraint) {
return m_fnConstraint(which, constraint);
}
return QGraphicsWidget::sizeHint(which, constraint);
}
void setSizeHint(Qt::SizeHint which, const QSizeF &size) {
m_sizeHints[which] = size;
updateGeometry();
}
void setConstraintFunction(QSizeF (*fnConstraint)(Qt::SizeHint, const QSizeF &)) {
m_fnConstraint = fnConstraint;
}
QSizeF m_sizeHints[Qt::NSizeHints];
QSizeF (*m_fnConstraint)(Qt::SizeHint, const QSizeF &);
};
struct ItemDesc
{
ItemDesc(int row, int col)
: m_pos(qMakePair(row, col)),
m_rowSpan(1),
m_colSpan(1),
m_sizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred)),
m_align(0),
m_fnConstraint(0)
{
}
ItemDesc &rowSpan(int span) {
m_rowSpan = span;
return (*this);
}
ItemDesc &colSpan(int span) {
m_colSpan = span;
return (*this);
}
ItemDesc &sizePolicy(const QSizePolicy &sp) {
m_sizePolicy = sp;
return (*this);
}
ItemDesc &sizePolicy(QSizePolicy::Policy horAndVer) {
m_sizePolicy = QSizePolicy(horAndVer, horAndVer);
return (*this);
}
ItemDesc &sizePolicyH(QSizePolicy::Policy hor) {
m_sizePolicy.setHorizontalPolicy(hor);
return (*this);
}
ItemDesc &sizePolicyV(QSizePolicy::Policy ver) {
m_sizePolicy.setVerticalPolicy(ver);
return (*this);
}
ItemDesc &sizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver) {
m_sizePolicy = QSizePolicy(hor, ver);
return (*this);
}
ItemDesc &sizeHint(Qt::SizeHint which, const QSizeF &sh) {
m_sizeHints[which] = sh;
return (*this);
}
ItemDesc &preferredSizeHint(const QSizeF &sh) {
m_sizeHints[Qt::PreferredSize] = sh;
return (*this);
}
ItemDesc &minSize(const QSizeF &sz) {
m_sizes[Qt::MinimumSize] = sz;
return (*this);
}
ItemDesc &preferredSize(const QSizeF &sz) {
m_sizes[Qt::PreferredSize] = sz;
return (*this);
}
ItemDesc &maxSize(const QSizeF &sz) {
m_sizes[Qt::MaximumSize] = sz;
return (*this);
}
ItemDesc &alignment(Qt::Alignment alignment) {
m_align = alignment;
return (*this);
}
ItemDesc &dynamicConstraint(QSizeF (*fnConstraint)(Qt::SizeHint, const QSizeF &),
Qt::Orientation orientation) {
m_fnConstraint = fnConstraint;
m_constraintOrientation = orientation;
return (*this);
}
void apply(QGraphicsGridLayout *layout, QGraphicsWidget *item) {
QSizePolicy sp = m_sizePolicy;
if (m_fnConstraint) {
sp.setHeightForWidth(m_constraintOrientation == Qt::Vertical);
sp.setWidthForHeight(m_constraintOrientation == Qt::Horizontal);
}
item->setSizePolicy(sp);
for (int i = 0; i < Qt::NSizeHints; ++i) {
if (!m_sizes[i].isValid())
continue;
switch ((Qt::SizeHint)i) {
case Qt::MinimumSize:
item->setMinimumSize(m_sizes[i]);
break;
case Qt::PreferredSize:
item->setPreferredSize(m_sizes[i]);
break;
case Qt::MaximumSize:
item->setMaximumSize(m_sizes[i]);
break;
default:
qWarning("not implemented");
break;
}
}
layout->addItem(item, m_pos.first, m_pos.second, m_rowSpan, m_colSpan);
layout->setAlignment(item, m_align);
}
void apply(QGraphicsGridLayout *layout, RectWidget *item) {
for (int i = 0; i < Qt::NSizeHints; ++i)
item->setSizeHint((Qt::SizeHint)i, m_sizeHints[i]);
item->setConstraintFunction(m_fnConstraint);
apply(layout, static_cast<QGraphicsWidget*>(item));
}
//private:
QPair<int,int> m_pos; // row,col
int m_rowSpan;
int m_colSpan;
QSizePolicy m_sizePolicy;
QSizeF m_sizeHints[Qt::NSizeHints];
QSizeF m_sizes[Qt::NSizeHints];
Qt::Alignment m_align;
Qt::Orientation m_constraintOrientation;
QSizeF (*m_fnConstraint)(Qt::SizeHint, const QSizeF &);
};
typedef QList<ItemDesc> ItemList;
Q_DECLARE_METATYPE(ItemList);
typedef QList<QSizeF> SizeList;
Q_DECLARE_METATYPE(SizeList);
// This will be called before the first test function is executed.
// It is only called once.
void tst_QGraphicsGridLayout::initTestCase()
{
}
// This will be called after the last test function is executed.
// It is only called once.
void tst_QGraphicsGridLayout::cleanupTestCase()
{
}
// This will be called before each test function is executed.
void tst_QGraphicsGridLayout::init()
{
#ifdef Q_OS_WINCE //disable magic for WindowsCE
qApp->setAutoMaximizeThreshold(-1);
#endif
}
// This will be called after every test function.
void tst_QGraphicsGridLayout::cleanup()
{
}
void tst_QGraphicsGridLayout::qgraphicsgridlayout_data()
{
}
void tst_QGraphicsGridLayout::qgraphicsgridlayout()
{
QGraphicsGridLayout layout;
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: invalid row span/column span: 0");
layout.addItem(0, 0, 0, 0, 0);
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: cannot add null item");
layout.addItem(0, 0, 0);
layout.alignment(0);
layout.columnAlignment(0);
layout.columnCount();
layout.columnMaximumWidth(0);
layout.columnMinimumWidth(0);
layout.columnPreferredWidth(0);
layout.columnSpacing(0);
layout.columnStretchFactor(0);
layout.count();
layout.horizontalSpacing();
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::itemAt: invalid row, column 0, 0");
layout.itemAt(0, 0);
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::itemAt: invalid index 0");
layout.itemAt(0);
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::removeAt: invalid index 0");
layout.removeAt(0);
layout.rowAlignment(0);
layout.rowCount();
layout.rowMaximumHeight(0);
layout.rowMinimumHeight(0);
layout.rowPreferredHeight(0);
layout.rowSpacing(0);
layout.rowStretchFactor(0);
layout.setAlignment(0, Qt::AlignRight);
layout.setColumnAlignment(0, Qt::AlignRight);
layout.setColumnFixedWidth(0, 0);
layout.setColumnMaximumWidth(0, 0);
layout.setColumnMinimumWidth(0, 0);
layout.setColumnPreferredWidth(0, 0);
layout.setColumnSpacing(0, 0);
layout.setColumnStretchFactor(0, 0);
layout.setGeometry(QRectF());
layout.setHorizontalSpacing(0);
layout.setRowAlignment(0, 0);
layout.setRowFixedHeight(0, 0);
layout.setRowMaximumHeight(0, 0);
layout.setRowMinimumHeight(0, 0);
layout.setRowPreferredHeight(0, 0);
layout.setRowSpacing(0, 0);
layout.setRowStretchFactor(0, 0);
layout.setSpacing(0);
layout.setVerticalSpacing(0);
layout.sizeHint(Qt::MinimumSize);
layout.verticalSpacing();
}
static void populateLayout(QGraphicsGridLayout *gridLayout, int width, int height, bool hasHeightForWidth = false)
{
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
QGraphicsWidget *item = new RectWidget();
item->setMinimumSize(10, 10);
item->setPreferredSize(25, 25);
item->setMaximumSize(50, 50);
gridLayout->addItem(item, y, x);
QSizePolicy policy = item->sizePolicy();
policy.setHeightForWidth(hasHeightForWidth);
item->setSizePolicy(policy);
}
}
}
/** populates \a gridLayout with a 3x2 layout:
* +----+----+----+
* |+---|---+|xxxx|
* ||span=2 ||hole|
* |+---|---+|xxxx|
* +----+----+----+
* |xxxx|+---|---+|
* |hole||span=2 ||
* |xxxx|+---|---+|
* +----+----+----+
*/
static void populateLayoutWithSpansAndHoles(QGraphicsGridLayout *gridLayout, bool hasHeightForWidth = false)
{
QGraphicsWidget *item = new RectWidget();
item->setMinimumSize(10, 10);
item->setPreferredSize(25, 25);
item->setMaximumSize(50, 50);
QSizePolicy sizepolicy = item->sizePolicy();
sizepolicy.setHeightForWidth(hasHeightForWidth);
item->setSizePolicy(sizepolicy);
gridLayout->addItem(item, 0, 0, 1, 2);
item = new RectWidget();
item->setMinimumSize(10, 10);
item->setPreferredSize(25, 25);
item->setMaximumSize(50, 50);
item->setSizePolicy(sizepolicy);
gridLayout->addItem(item, 1, 1, 1, 2);
}
Q_DECLARE_METATYPE(Qt::Alignment)
void tst_QGraphicsGridLayout::addItem_data()
{
QTest::addColumn<int>("row");
QTest::addColumn<int>("column");
QTest::addColumn<int>("rowSpan");
QTest::addColumn<int>("columnSpan");
QTest::addColumn<Qt::Alignment>("alignment");
for (int a = -1; a < 3; ++a) {
for (int b = -1; b < 2; ++b) {
for (int c = -1; c < 2; ++c) {
for (int d = -1; d < 2; ++d) {
for (int e = 0; e < 9; ++e) {
int row = a;
int column = b;
int rowSpan = c;
int columnSpan = d;
QString name = QString::fromAscii("(%1,%2,%3,%4").arg(a).arg(b).arg(c).arg(d);
Qt::Alignment alignment = Qt::AlignLeft;
QTest::newRow(name.toLatin1()) << row << column << rowSpan << columnSpan << alignment;
}}}}}
}
// public void addItem(QGraphicsLayoutItem* item, int row, int column, int rowSpan, int columnSpan, Qt::Alignment alignment = 0)
void tst_QGraphicsGridLayout::addItem()
{
QFETCH(int, row);
QFETCH(int, column);
QFETCH(int, rowSpan);
QFETCH(int, columnSpan);
QFETCH(Qt::Alignment, alignment);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
QGraphicsWidget *wid = new QGraphicsWidget;
if (row < 0 || column < 0) {
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: invalid row/column: -1");
} else if (rowSpan < 1 || columnSpan < 1) {
char buf[1024];
::qsnprintf(buf, sizeof(buf), "QGraphicsGridLayout::addItem: invalid row span/column span: %d",
rowSpan < 1 ? rowSpan : columnSpan);
QTest::ignoreMessage(QtWarningMsg, buf);
}
layout->addItem(wid, row, column, rowSpan, columnSpan, alignment);
delete layout;
}
// Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac.
#ifndef Q_WS_MAC
void tst_QGraphicsGridLayout::alignment_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public Qt::Alignment alignment(QGraphicsLayoutItem* item) const
void tst_QGraphicsGridLayout::alignment()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
// no alignment (the default)
QCOMPARE(layout->itemAt(0, 0)->geometry().left(), 0.0);
QCOMPARE(layout->itemAt(0, 0)->geometry().right(), layout->itemAt(0, 1)->geometry().left());
QCOMPARE(layout->itemAt(0, 1)->geometry().left(), 25.0);
QCOMPARE(layout->itemAt(0, 1)->geometry().right(), layout->itemAt(0, 2)->geometry().left());
QCOMPARE(layout->itemAt(0, 2)->geometry().left(), 50.0);
QCOMPARE(layout->itemAt(0, 2)->geometry().right(), 75.0);
QCOMPARE(layout->itemAt(1, 0)->geometry().left(), 0.0);
QCOMPARE(layout->itemAt(1, 0)->geometry().right(), layout->itemAt(1, 1)->geometry().left());
QCOMPARE(layout->itemAt(1, 1)->geometry().left(), 25.0);
QCOMPARE(layout->itemAt(1, 1)->geometry().right(), layout->itemAt(1, 2)->geometry().left());
QCOMPARE(layout->itemAt(1, 2)->geometry().left(), 50.0);
QCOMPARE(layout->itemAt(1, 2)->geometry().right(), 75.0);
QCOMPARE(layout->itemAt(0, 0)->geometry().top(), 0.0);
QCOMPARE(layout->itemAt(0, 0)->geometry().bottom(), layout->itemAt(1, 0)->geometry().top());
QCOMPARE(layout->itemAt(1, 0)->geometry().top(), 25.0);
QCOMPARE(layout->itemAt(1, 0)->geometry().bottom(), 50.0);
// align first column left, second hcenter, third right
layout->setColumnMinimumWidth(0, 100);
layout->setAlignment(layout->itemAt(0,0), Qt::AlignLeft);
layout->setAlignment(layout->itemAt(1,0), Qt::AlignLeft);
layout->setColumnMinimumWidth(1, 100);
layout->setAlignment(layout->itemAt(0,1), Qt::AlignHCenter);
layout->setAlignment(layout->itemAt(1,1), Qt::AlignHCenter);
layout->setColumnMinimumWidth(2, 100);
layout->setAlignment(layout->itemAt(0,2), Qt::AlignRight);
layout->setAlignment(layout->itemAt(1,2), Qt::AlignRight);
widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 50, 50));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 50, 50, 50));
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(125, 0, 50, 50));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(125, 50, 50, 50));
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(250, 0, 50, 50));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(250, 50, 50, 50));
delete widget;
}
#endif
// Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac.
#ifndef Q_WS_MAC
void tst_QGraphicsGridLayout::columnAlignment_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public void setColumnAlignment(int column, Qt::Alignment alignment)
// public Qt::Alignment columnAlignment(int column) const
void tst_QGraphicsGridLayout::columnAlignment()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(1);
widget->setContentsMargins(0, 0, 0, 0);
layout->setColumnMinimumWidth(0, 100);
layout->setColumnMinimumWidth(1, 100);
layout->setColumnMinimumWidth(2, 100);
view.resize(450,150);
widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
view.show();
widget->show();
QApplication::sendPostedEvents(0, 0);
// Check default
QCOMPARE(layout->columnAlignment(0), 0);
QCOMPARE(layout->columnAlignment(1), 0);
QCOMPARE(layout->columnAlignment(2), 0);
layout->setColumnAlignment(0, Qt::AlignLeft);
layout->setColumnAlignment(1, Qt::AlignHCenter);
layout->setColumnAlignment(2, Qt::AlignRight);
// see if item alignment takes preference over columnAlignment
layout->setAlignment(layout->itemAt(1,0), Qt::AlignHCenter);
layout->setAlignment(layout->itemAt(1,1), Qt::AlignRight);
layout->setAlignment(layout->itemAt(1,2), Qt::AlignLeft);
QApplication::sendPostedEvents(0, 0); // process LayoutRequest
/*
+----------+------------+---------+
| Left | HCenter | Right |
+----------+------------+---------+
| HCenter | Right | Left |
+---------------------------------+
*/
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 50, 50));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(25, 51, 50, 50)); // item is king
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(126, 0, 50, 50));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(151, 51, 50, 50)); // item is king
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(252, 0, 50, 50));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(202, 51, 50, 50)); // item is king
delete widget;
}
#endif
void tst_QGraphicsGridLayout::columnCount_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public int columnCount() const
void tst_QGraphicsGridLayout::columnCount()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
widget->setContentsMargins(0, 0, 0, 0);
view.show();
widget->show();
QApplication::processEvents();
QCOMPARE(layout->columnCount(), 0);
layout->addItem(new RectWidget(widget), 0, 0);
QCOMPARE(layout->columnCount(), 1);
layout->addItem(new RectWidget(widget), 1, 1);
QCOMPARE(layout->columnCount(), 2);
layout->addItem(new RectWidget(widget), 0, 2);
QCOMPARE(layout->columnCount(), 3);
layout->addItem(new RectWidget(widget), 1, 0);
QCOMPARE(layout->columnCount(), 3);
layout->addItem(new RectWidget(widget), 0, 1);
QCOMPARE(layout->columnCount(), 3);
layout->addItem(new RectWidget(widget), 1, 2);
QCOMPARE(layout->columnCount(), 3);
// ### Talk with Jasmin. Not sure if removeAt() should adjust columnCount().
widget->setLayout(0);
layout = new QGraphicsGridLayout();
populateLayout(layout, 3, 2, hasHeightForWidth);
QCOMPARE(layout->columnCount(), 3);
layout->removeAt(5);
layout->removeAt(3);
QCOMPARE(layout->columnCount(), 3);
layout->removeAt(1);
QCOMPARE(layout->columnCount(), 3);
layout->removeAt(0);
QCOMPARE(layout->columnCount(), 3);
layout->removeAt(0);
QCOMPARE(layout->columnCount(), 2);
delete widget;
}
void tst_QGraphicsGridLayout::columnMaximumWidth_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public qreal columnMaximumWidth(int column) const
void tst_QGraphicsGridLayout::columnMaximumWidth()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QCOMPARE(layout->minimumSize(), QSizeF(10+10+10, 10+10));
QCOMPARE(layout->preferredSize(), QSizeF(25+25+25, 25+25));
QCOMPARE(layout->maximumSize(), QSizeF(50+50+50, 50+50));
// should at least be a very large number
QVERIFY(layout->columnMaximumWidth(0) >= 10000);
QCOMPARE(layout->columnMaximumWidth(0), layout->columnMaximumWidth(1));
QCOMPARE(layout->columnMaximumWidth(1), layout->columnMaximumWidth(2));
layout->setColumnMaximumWidth(0, 20);
layout->setColumnMaximumWidth(2, 60);
QCOMPARE(layout->minimumSize(), QSizeF(10+10+10, 10+10));
QCOMPARE(layout->preferredSize(), QSizeF(20+25+25, 25+25));
QCOMPARE(layout->maximumSize(), QSizeF(20+50+60, 50+50));
QCOMPARE(layout->maximumSize(), widget->maximumSize());
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
layout->activate();
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 25));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 25, 20, 25));
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 25, 25));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 25, 25, 25));
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(45, 0, 25, 25));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(45, 25, 25, 25));
layout->setColumnAlignment(2, Qt::AlignCenter);
widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
layout->activate();
QCOMPARE(layout->geometry(), QRectF(0,0,20+50+60, 50+50));
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 50));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 50, 20, 50));
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 50, 50));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 50, 50, 50));
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(75, 0, 50, 50));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(75, 50, 50, 50));
for (int i = 0; i < layout->count(); i++)
layout->setAlignment(layout->itemAt(i), Qt::AlignRight | Qt::AlignBottom);
layout->activate();
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 50));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 50, 20, 50));
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 50, 50));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 50, 50, 50));
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(80, 0, 50, 50));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(80, 50, 50, 50));
for (int i = 0; i < layout->count(); i++)
layout->setAlignment(layout->itemAt(i), Qt::AlignCenter);
layout->setMaximumSize(layout->maximumSize() + QSizeF(60,60));
widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
layout->activate();
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 15, 20, 50));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 95, 20, 50));
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20+30, 15, 50, 50));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20+30, 95, 50, 50));
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(20+60+50+5, 15, 50, 50));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(20+60+50+5, 95, 50, 50));
layout->setMaximumSize(layout->preferredSize() + QSizeF(20,20));
widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
layout->activate();
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 35));
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 35, 20, 35));
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 35, 35));
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 35, 35, 35));
QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(55, 0, 35, 35));
QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(55, 35, 35, 35));
delete widget;
}
void tst_QGraphicsGridLayout::columnMinimumWidth_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public qreal columnMinimumWidth(int column) const
void tst_QGraphicsGridLayout::columnMinimumWidth()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
// should at least be a very large number
QCOMPARE(layout->columnMinimumWidth(0), 0.0);
QCOMPARE(layout->columnMinimumWidth(0), layout->columnMinimumWidth(1));
QCOMPARE(layout->columnMinimumWidth(1), layout->columnMinimumWidth(2));
layout->setColumnMinimumWidth(0, 20);
layout->setColumnMinimumWidth(2, 40);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(1,0)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(0,1)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(0,2)->geometry().width(), 40.0);
QCOMPARE(layout->itemAt(1,2)->geometry().width(), 40.0);
delete widget;
}
void tst_QGraphicsGridLayout::columnPreferredWidth_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public qreal columnPreferredWidth(int column) const
void tst_QGraphicsGridLayout::columnPreferredWidth()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
// default preferred width ??
QCOMPARE(layout->columnPreferredWidth(0), 0.0);
QCOMPARE(layout->columnPreferredWidth(0), layout->columnPreferredWidth(1));
QCOMPARE(layout->columnPreferredWidth(1), layout->columnPreferredWidth(2));
layout->setColumnPreferredWidth(0, 20);
layout->setColumnPreferredWidth(2, 40);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(1,0)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(0,1)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(0,2)->geometry().width(), 40.0);
QCOMPARE(layout->itemAt(1,2)->geometry().width(), 40.0);
delete widget;
}
// public void setColumnFixedWidth(int row, qreal height)
void tst_QGraphicsGridLayout::setColumnFixedWidth()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setColumnFixedWidth(0, 20);
layout->setColumnFixedWidth(2, 40);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().width(), 20.0);
QCOMPARE(layout->itemAt(1,0)->geometry().width(), 20.0);
QCOMPARE(layout->itemAt(0,1)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().width(), 25.0);
QCOMPARE(layout->itemAt(0,2)->geometry().width(), 40.0);
QCOMPARE(layout->itemAt(1,2)->geometry().width(), 40.0);
delete widget;
}
// public qreal columnSpacing(int column) const
void tst_QGraphicsGridLayout::columnSpacing()
{
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QCOMPARE(layout->columnSpacing(0), 0.0);
layout->setColumnSpacing(0, 20);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().left(), 0.0);
QCOMPARE(layout->itemAt(0,0)->geometry().right(), 25.0);
QCOMPARE(layout->itemAt(0,1)->geometry().left(), 45.0);
QCOMPARE(layout->itemAt(0,1)->geometry().right(), 70.0);
QCOMPARE(layout->itemAt(0,2)->geometry().left(), 70.0);
QCOMPARE(layout->itemAt(0,2)->geometry().right(), 95.0);
delete widget;
}
{
// don't include items and spacings that was previously part of the layout
// (horizontal)
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
populateLayout(layout, 3, 1);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setColumnSpacing(0, 10);
layout->setColumnSpacing(1, 10);
layout->setColumnSpacing(2, 10);
layout->setColumnSpacing(3, 10);
QCOMPARE(layout->preferredSize(), QSizeF(95, 25));
layout->removeAt(2);
QCOMPARE(layout->preferredSize(), QSizeF(60, 25));
layout->removeAt(1);
QCOMPARE(layout->preferredSize(), QSizeF(25, 25));
delete layout;
}
{
// don't include items and spacings that was previously part of the layout
// (vertical)
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
populateLayout(layout, 2, 2);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setColumnSpacing(0, 10);
layout->setColumnSpacing(1, 10);
layout->setRowSpacing(0, 10);
layout->setRowSpacing(1, 10);
QCOMPARE(layout->preferredSize(), QSizeF(60, 60));
layout->removeAt(3);
QCOMPARE(layout->preferredSize(), QSizeF(60, 60));
layout->removeAt(2);
QCOMPARE(layout->preferredSize(), QSizeF(60, 25));
layout->removeAt(1);
QCOMPARE(layout->preferredSize(), QSizeF(25, 25));
delete layout;
}
}
// public int columnStretchFactor(int column) const
void tst_QGraphicsGridLayout::columnStretchFactor()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setColumnStretchFactor(0, 1);
layout->setColumnStretchFactor(1, 2);
layout->setColumnStretchFactor(2, 3);
view.show();
widget->show();
widget->resize(130, 50);
QApplication::processEvents();
QVERIFY(layout->itemAt(0,0)->geometry().width() < layout->itemAt(0,1)->geometry().width());
QVERIFY(layout->itemAt(0,1)->geometry().width() < layout->itemAt(0,2)->geometry().width());
QVERIFY(layout->itemAt(1,0)->geometry().width() < layout->itemAt(1,1)->geometry().width());
QVERIFY(layout->itemAt(1,1)->geometry().width() < layout->itemAt(1,2)->geometry().width());
delete widget;
}
// public int count() const
void tst_QGraphicsGridLayout::count()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
QCOMPARE(layout->count(), 6);
layout->removeAt(5);
layout->removeAt(3);
QCOMPARE(layout->count(), 4);
layout->removeAt(1);
QCOMPARE(layout->count(), 3);
layout->removeAt(0);
QCOMPARE(layout->count(), 2);
layout->removeAt(0);
QCOMPARE(layout->count(), 1);
layout->removeAt(0);
QCOMPARE(layout->count(), 0);
delete widget;
}
void tst_QGraphicsGridLayout::horizontalSpacing_data()
{
QTest::addColumn<qreal>("horizontalSpacing");
QTest::newRow("zero") << qreal(0.0);
QTest::newRow("10") << qreal(10.0);
}
// public qreal horizontalSpacing() const
void tst_QGraphicsGridLayout::horizontalSpacing()
{
QFETCH(qreal, horizontalSpacing);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
layout->setContentsMargins(0, 0, 0, 0);
qreal w = layout->sizeHint(Qt::PreferredSize, QSizeF()).width();
qreal oldSpacing = layout->horizontalSpacing();
if (oldSpacing != -1) {
layout->setHorizontalSpacing(horizontalSpacing);
QApplication::processEvents();
qreal new_w = layout->sizeHint(Qt::PreferredSize, QSizeF()).width();
QCOMPARE(new_w, w - (3-1)*(oldSpacing - horizontalSpacing));
} else {
QSKIP("The current style uses non-uniform layout spacing", SkipAll);
}
delete widget;
}
void tst_QGraphicsGridLayout::contentsMargins()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
QGraphicsGridLayout *sublayout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
layout->addItem(sublayout,0, 1);
qreal left, top, right, bottom;
// sublayouts have 0 margin
sublayout->getContentsMargins(&left, &top, &right, &bottom);
QCOMPARE(left, 0.0);
QCOMPARE(top, 0.0);
QCOMPARE(right, 0.0);
QCOMPARE(bottom, 0.0);
// top level layouts have style dependent margins.
// we'll just check if its different from 0. (applies to all our styles)
layout->getContentsMargins(&left, &top, &right, &bottom);
QVERIFY(left >= 0.0);
QVERIFY(top >= 0.0);
QVERIFY(right >= 0.0);
QVERIFY(bottom >= 0.0);
delete widget;
}
// public QGraphicsLayoutItem* itemAt(int index) const
void tst_QGraphicsGridLayout::itemAt()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayoutWithSpansAndHoles(layout);
//itemAt(int row, int column)
QVERIFY( layout->itemAt(0,0));
QVERIFY( layout->itemAt(0,1));
QCOMPARE(layout->itemAt(0,2), static_cast<QGraphicsLayoutItem*>(0));
QCOMPARE(layout->itemAt(1,0), static_cast<QGraphicsLayoutItem*>(0));
QVERIFY( layout->itemAt(1,1));
QVERIFY( layout->itemAt(1,2));
//itemAt(int index)
for (int i = -2; i < layout->count() + 2; ++i) {
if (i >= 0 && i < layout->count()) {
QVERIFY(layout->itemAt(i));
} else {
QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::itemAt: invalid index %1").arg(i).toLatin1().constData());
QCOMPARE(layout->itemAt(i), static_cast<QGraphicsLayoutItem*>(0));
}
}
delete widget;
}
// public void removeAt(int index)
void tst_QGraphicsGridLayout::removeAt()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
QCOMPARE(layout->count(), 6);
layout->removeAt(5);
layout->removeAt(3);
QCOMPARE(layout->count(), 4);
layout->removeAt(1);
QCOMPARE(layout->count(), 3);
layout->removeAt(0);
QCOMPARE(layout->count(), 2);
layout->removeAt(0);
QCOMPARE(layout->count(), 1);
QGraphicsLayoutItem *item0 = layout->itemAt(0);
QCOMPARE(item0->parentLayoutItem(), static_cast<QGraphicsLayoutItem *>(layout));
layout->removeAt(0);
QCOMPARE(item0->parentLayoutItem(), static_cast<QGraphicsLayoutItem *>(0));
QCOMPARE(layout->count(), 0);
QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::removeAt: invalid index 0").toLatin1().constData());
layout->removeAt(0);
QCOMPARE(layout->count(), 0);
delete widget;
}
void tst_QGraphicsGridLayout::removeItem()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
scene.addItem(widget);
QGraphicsGridLayout *l = new QGraphicsGridLayout();
widget->setLayout(l);
populateLayout(l, 3, 2);
QCOMPARE(l->count(), 6);
l->removeItem(l->itemAt(5));
l->removeItem(l->itemAt(4));
QCOMPARE(l->count(), 4);
// Avoid crashing. Note that the warning message might change in the future.
QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::removeAt: invalid index -1").toLatin1().constData());
l->removeItem(0);
QCOMPARE(l->count(), 4);
QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::removeAt: invalid index -1").toLatin1().constData());
l->removeItem(new QGraphicsWidget);
QCOMPARE(l->count(), 4);
}
void tst_QGraphicsGridLayout::rowAlignment_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public Qt::Alignment rowAlignment(int row) const
void tst_QGraphicsGridLayout::rowAlignment()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(1);
widget->setContentsMargins(0, 0, 0, 0);
view.resize(330,450);
widget->resize(300, 400);
view.show();
widget->show();
QApplication::sendPostedEvents(0, 0);
// Check default
QCOMPARE(layout->rowAlignment(0), 0);
QCOMPARE(layout->rowAlignment(1), 0);
QCOMPARE(layout->rowAlignment(2), 0);
// make the grids larger than the items, so that alignment kicks in
layout->setRowMinimumHeight(0, 100.0);
layout->setRowMinimumHeight(1, 100.0);
layout->setRowMinimumHeight(2, 100.0);
// expand columns also, so we can test combination of horiz and vertical alignment
layout->setColumnMinimumWidth(0, 100.0);
layout->setColumnMinimumWidth(1, 100.0);
layout->setRowAlignment(0, Qt::AlignBottom);
layout->setRowAlignment(1, Qt::AlignVCenter);
layout->setRowAlignment(2, Qt::AlignTop);
// see if item alignment takes preference over rowAlignment
layout->setAlignment(layout->itemAt(0,0), Qt::AlignRight);
layout->setAlignment(layout->itemAt(1,0), Qt::AlignTop);
layout->setAlignment(layout->itemAt(2,0), Qt::AlignHCenter);
QApplication::sendPostedEvents(0, 0); // process LayoutRequest
QCOMPARE(layout->alignment(layout->itemAt(0,0)), Qt::AlignRight); //Qt::AlignRight | Qt::AlignBottom
QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(50, 50, 50, 50));
QCOMPARE(layout->rowAlignment(0), Qt::AlignBottom);
QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(101, 50, 50, 50));
QCOMPARE(layout->alignment(layout->itemAt(1,0)), Qt::AlignTop);
QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 101, 50, 50));
QCOMPARE(layout->rowAlignment(1), Qt::AlignVCenter);
QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(101, 126, 50, 50));
QCOMPARE(layout->alignment(layout->itemAt(2,0)), Qt::AlignHCenter);
QCOMPARE(layout->itemAt(2,0)->geometry(), QRectF(25, 202, 50, 50));
QCOMPARE(layout->rowAlignment(2), Qt::AlignTop);
QCOMPARE(layout->itemAt(2,1)->geometry(), QRectF(101,202, 50, 50));
delete widget;
}
void tst_QGraphicsGridLayout::rowCount_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public int rowCount() const
// public int columnCount() const
void tst_QGraphicsGridLayout::rowCount()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
widget->setContentsMargins(0, 0, 0, 0);
QCOMPARE(layout->rowCount(), 3);
QCOMPARE(layout->columnCount(), 2);
// with spans and holes...
widget->setLayout(0);
layout = new QGraphicsGridLayout();
populateLayoutWithSpansAndHoles(layout, hasHeightForWidth);
QCOMPARE(layout->rowCount(), 2);
QCOMPARE(layout->columnCount(), 3);
delete widget;
}
void tst_QGraphicsGridLayout::rowMaximumHeight_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public qreal rowMaximumHeight(int row) const
void tst_QGraphicsGridLayout::rowMaximumHeight()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
// should at least be a very large number
QVERIFY(layout->rowMaximumHeight(0) >= 10000);
QCOMPARE(layout->rowMaximumHeight(0), layout->rowMaximumHeight(1));
QCOMPARE(layout->rowMaximumHeight(1), layout->rowMaximumHeight(2));
layout->setRowMaximumHeight(0, 20);
layout->setRowMaximumHeight(2, 60);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().height(), 20.0);
QCOMPARE(layout->itemAt(0,1)->geometry().height(), 20.0);
QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(2,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(2,1)->geometry().height(), 25.0);
delete widget;
}
void tst_QGraphicsGridLayout::rowMinimumHeight_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public qreal rowMinimumHeight(int row) const
void tst_QGraphicsGridLayout::rowMinimumHeight()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
// should at least be a very large number
QCOMPARE(layout->rowMinimumHeight(0), 0.0);
QCOMPARE(layout->rowMinimumHeight(0), layout->rowMinimumHeight(1));
QCOMPARE(layout->rowMinimumHeight(1), layout->rowMinimumHeight(2));
layout->setRowMinimumHeight(0, 20);
layout->setRowMinimumHeight(2, 40);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(0,1)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(2,0)->geometry().height(), 40.0);
QCOMPARE(layout->itemAt(2,1)->geometry().height(), 40.0);
delete widget;
}
void tst_QGraphicsGridLayout::rowPreferredHeight_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public qreal rowPreferredHeight(int row) const
void tst_QGraphicsGridLayout::rowPreferredHeight()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
// default preferred height ??
QCOMPARE(layout->rowPreferredHeight(0), 0.0);
QCOMPARE(layout->rowPreferredHeight(0), layout->rowPreferredHeight(1));
QCOMPARE(layout->rowPreferredHeight(1), layout->rowPreferredHeight(2));
layout->setRowPreferredHeight(0, 20);
layout->setRowPreferredHeight(2, 40);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
// ### Jasmin: Should rowPreferredHeight have precedence over sizeHint(Qt::PreferredSize) ?
QCOMPARE(layout->itemAt(0,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(0,1)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(2,0)->geometry().height(), 40.0);
QCOMPARE(layout->itemAt(2,1)->geometry().height(), 40.0);
delete widget;
}
// public void setRowFixedHeight(int row, qreal height)
void tst_QGraphicsGridLayout::setRowFixedHeight()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setRowFixedHeight(0, 20.);
layout->setRowFixedHeight(2, 40.);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().height(), 20.0);
QCOMPARE(layout->itemAt(0,1)->geometry().height(), 20.0);
QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
QCOMPARE(layout->itemAt(2,0)->geometry().height(), 40.0);
QCOMPARE(layout->itemAt(2,1)->geometry().height(), 40.0);
delete widget;
}
// public qreal rowSpacing(int row) const
void tst_QGraphicsGridLayout::rowSpacing()
{
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QCOMPARE(layout->columnSpacing(0), 0.0);
layout->setColumnSpacing(0, 20);
view.show();
widget->show();
widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
QApplication::processEvents();
QCOMPARE(layout->itemAt(0,0)->geometry().left(), 0.0);
QCOMPARE(layout->itemAt(0,0)->geometry().right(), 25.0);
QCOMPARE(layout->itemAt(0,1)->geometry().left(), 45.0);
QCOMPARE(layout->itemAt(0,1)->geometry().right(), 70.0);
QCOMPARE(layout->itemAt(0,2)->geometry().left(), 70.0);
QCOMPARE(layout->itemAt(0,2)->geometry().right(), 95.0);
delete widget;
}
void tst_QGraphicsGridLayout::rowStretchFactor_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
// public int rowStretchFactor(int row) const
void tst_QGraphicsGridLayout::rowStretchFactor()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 2, 3, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setRowStretchFactor(0, 1);
layout->setRowStretchFactor(1, 2);
layout->setRowStretchFactor(2, 3);
view.show();
widget->show();
widget->resize(50, 130);
QApplication::processEvents();
QVERIFY(layout->itemAt(0,0)->geometry().height() < layout->itemAt(1,0)->geometry().height());
QVERIFY(layout->itemAt(1,0)->geometry().height() < layout->itemAt(2,0)->geometry().height());
QVERIFY(layout->itemAt(0,1)->geometry().height() < layout->itemAt(1,1)->geometry().height());
QVERIFY(layout->itemAt(1,1)->geometry().height() < layout->itemAt(2,1)->geometry().height());
delete widget;
}
void tst_QGraphicsGridLayout::setColumnSpacing_data()
{
QTest::addColumn<int>("column");
QTest::addColumn<qreal>("spacing");
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("null") << 0 << qreal(0.0) << false;
QTest::newRow("10") << 0 << qreal(10.0) << false;
QTest::newRow("null, hasHeightForWidth") << 0 << qreal(0.0) << true;
QTest::newRow("10, hasHeightForWidth") << 0 << qreal(10.0) << true;
}
// public void setColumnSpacing(int column, qreal spacing)
void tst_QGraphicsGridLayout::setColumnSpacing()
{
QFETCH(int, column);
QFETCH(qreal, spacing);
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
qreal oldSpacing = layout->columnSpacing(column);
QCOMPARE(oldSpacing, 0.0);
qreal w = layout->sizeHint(Qt::PreferredSize, QSizeF()).width();
layout->setColumnSpacing(column, spacing);
QApplication::processEvents();
QCOMPARE(layout->sizeHint(Qt::PreferredSize, QSizeF()).width(), w + spacing);
}
void tst_QGraphicsGridLayout::setGeometry_data()
{
QTest::addColumn<QRectF>("rect");
QTest::newRow("null") << QRectF();
QTest::newRow("normal") << QRectF(0,0, 50, 50);
}
// public void setGeometry(QRectF const& rect)
void tst_QGraphicsGridLayout::setGeometry()
{
QFETCH(QRectF, rect);
QGraphicsWidget *window = new QGraphicsWidget;
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
window->setLayout(layout);
QGraphicsGridLayout *layout2 = new QGraphicsGridLayout();
layout2->setMaximumSize(100, 100);
layout->addItem(layout2, 0, 0);
layout2->setGeometry(rect);
QCOMPARE(layout2->geometry(), rect);
}
void tst_QGraphicsGridLayout::setRowSpacing_data()
{
QTest::addColumn<int>("row");
QTest::addColumn<qreal>("spacing");
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("null") << 0 << qreal(0.0) << false;
QTest::newRow("10") << 0 << qreal(10.0) << false;
QTest::newRow("null, hasHeightForWidth") << 0 << qreal(0.0) << true;
QTest::newRow("10, hasHeightForWidth") << 0 << qreal(10.0) << true;
}
// public void setRowSpacing(int row, qreal spacing)
void tst_QGraphicsGridLayout::setRowSpacing()
{
QFETCH(int, row);
QFETCH(qreal, spacing);
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
qreal oldSpacing = layout->rowSpacing(row);
QCOMPARE(oldSpacing, 0.0);
qreal h = layout->sizeHint(Qt::PreferredSize, QSizeF()).height();
layout->setRowSpacing(row, spacing);
QApplication::processEvents();
QCOMPARE(layout->sizeHint(Qt::PreferredSize, QSizeF()).height(), h + spacing);
}
void tst_QGraphicsGridLayout::setSpacing_data()
{
QTest::addColumn<qreal>("spacing");
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("zero") << qreal(0.0) << false;
QTest::newRow("17") << qreal(17.0) << false;
QTest::newRow("zero, hasHeightForWidth") << qreal(0.0) << true;
QTest::newRow("17, hasHeightForWidth") << qreal(17.0) << true;
}
// public void setSpacing(qreal spacing)
void tst_QGraphicsGridLayout::setSpacing()
{
QFETCH(qreal, spacing);
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2, hasHeightForWidth);
layout->setContentsMargins(0, 0, 0, 0);
QSizeF sh = layout->sizeHint(Qt::PreferredSize, QSizeF());
qreal oldVSpacing = layout->verticalSpacing();
qreal oldHSpacing = layout->horizontalSpacing();
if (oldVSpacing != -1) {
layout->setSpacing(spacing);
QApplication::processEvents();
QSizeF newSH = layout->sizeHint(Qt::PreferredSize, QSizeF());
QCOMPARE(newSH.height(), sh.height() - (2-1)*(oldVSpacing - spacing));
QCOMPARE(newSH.width(), sh.width() - (3-1)*(oldHSpacing - spacing));
} else {
QSKIP("The current style uses non-uniform layout spacing", SkipAll);
}
delete widget;
}
void tst_QGraphicsGridLayout::sizeHint_data()
{
QTest::addColumn<ItemList>("itemDescriptions");
QTest::addColumn<QSizeF>("expectedMinimumSizeHint");
QTest::addColumn<QSizeF>("expectedPreferredSizeHint");
QTest::addColumn<QSizeF>("expectedMaximumSizeHint");
QTest::newRow("rowSpan_larger_than_rows") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(50,300))
.maxSize(QSizeF(50,300))
.rowSpan(2)
<< ItemDesc(0,1)
.minSize(QSizeF(50,0))
.preferredSize(QSizeF(50,50))
.maxSize(QSize(50, 1000))
<< ItemDesc(1,1)
.minSize(QSizeF(50,0))
.preferredSize(QSizeF(50,50))
.maxSize(QSize(50, 1000))
)
<< QSizeF(100, 300)
<< QSizeF(100, 300)
<< QSizeF(100, 2000);
QTest::newRow("rowSpan_smaller_than_rows") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(50, 0))
.preferredSize(QSizeF(50, 50))
.maxSize(QSizeF(50, 300))
.rowSpan(2)
<< ItemDesc(0,1)
.minSize(QSizeF(50, 50))
.preferredSize(QSizeF(50, 50))
.maxSize(QSize(50, 50))
<< ItemDesc(1,1)
.minSize(QSizeF(50, 50))
.preferredSize(QSizeF(50, 50))
.maxSize(QSize(50, 50))
)
<< QSizeF(100, 100)
<< QSizeF(100, 100)
<< QSizeF(100, 100);
}
// public QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const
void tst_QGraphicsGridLayout::sizeHint()
{
QFETCH(ItemList, itemDescriptions);
QFETCH(QSizeF, expectedMinimumSizeHint);
QFETCH(QSizeF, expectedPreferredSizeHint);
QFETCH(QSizeF, expectedMaximumSizeHint);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
scene.addItem(widget);
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0.0);
widget->setContentsMargins(0, 0, 0, 0);
int i;
for (i = 0; i < itemDescriptions.count(); ++i) {
ItemDesc desc = itemDescriptions.at(i);
RectWidget *item = new RectWidget(widget);
desc.apply(layout, item);
}
QApplication::sendPostedEvents(0, 0);
widget->show();
view.show();
view.resize(400,300);
QCOMPARE(layout->sizeHint(Qt::MinimumSize), expectedMinimumSizeHint);
QCOMPARE(layout->sizeHint(Qt::PreferredSize), expectedPreferredSizeHint);
QCOMPARE(layout->sizeHint(Qt::MaximumSize), expectedMaximumSizeHint);
}
void tst_QGraphicsGridLayout::verticalSpacing_data()
{
QTest::addColumn<qreal>("verticalSpacing");
QTest::newRow("zero") << qreal(0.0);
QTest::newRow("17") << qreal(10.0);
}
// public qreal verticalSpacing() const
void tst_QGraphicsGridLayout::verticalSpacing()
{
QFETCH(qreal, verticalSpacing);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout();
scene.addItem(widget);
widget->setLayout(layout);
populateLayout(layout, 3, 2);
layout->setContentsMargins(0, 0, 0, 0);
qreal h = layout->sizeHint(Qt::PreferredSize, QSizeF()).height();
qreal oldSpacing = layout->verticalSpacing();
if (oldSpacing != -1) {
layout->setVerticalSpacing(verticalSpacing);
QApplication::processEvents();
qreal new_h = layout->sizeHint(Qt::PreferredSize, QSizeF()).height();
QCOMPARE(new_h, h - (2-1)*(oldSpacing - verticalSpacing));
} else {
QSKIP("The current style uses non-uniform layout spacing", SkipAll);
}
delete widget;
}
void tst_QGraphicsGridLayout::layoutDirection_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
QTest::newRow("") << false;
QTest::newRow("hasHeightForWidth") << true;
}
void tst_QGraphicsGridLayout::layoutDirection()
{
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
layout->setContentsMargins(1, 2, 3, 4);
layout->setSpacing(6);
RectWidget *w1 = new RectWidget;
w1->setMinimumSize(30, 20);
layout->addItem(w1, 0, 0);
RectWidget *w2 = new RectWidget;
w2->setMinimumSize(20, 20);
w2->setMaximumSize(20, 20);
layout->addItem(w2, 0, 1);
RectWidget *w3 = new RectWidget;
w3->setMinimumSize(20, 20);
w3->setMaximumSize(20, 20);
layout->addItem(w3, 1, 0);
RectWidget *w4 = new RectWidget;
w4->setMinimumSize(30, 20);
layout->addItem(w4, 1, 1);
QSizePolicy policy = w1->sizePolicy();
policy.setHeightForWidth(hasHeightForWidth);
w1->setSizePolicy(policy);
w2->setSizePolicy(policy);
w4->setSizePolicy(policy);
layout->setAlignment(w2, Qt::AlignRight);
layout->setAlignment(w3, Qt::AlignLeft);
scene.addItem(window);
window->setLayout(layout);
view.show();
window->resize(70, 52);
QApplication::processEvents();
QCOMPARE(w1->geometry().left(), 1.0);
QCOMPARE(w1->geometry().right(), 31.0);
QCOMPARE(w2->geometry().left(), 47.0);
QCOMPARE(w2->geometry().right(), 67.0);
QCOMPARE(w3->geometry().left(), 1.0);
QCOMPARE(w3->geometry().right(), 21.0);
QCOMPARE(w4->geometry().left(), 37.0);
QCOMPARE(w4->geometry().right(), 67.0);
window->setLayoutDirection(Qt::RightToLeft);
QApplication::processEvents();
QCOMPARE(w1->geometry().left(), 39.0);
QCOMPARE(w1->geometry().right(), 69.0);
QCOMPARE(w2->geometry().left(), 3.0);
QCOMPARE(w2->geometry().right(), 23.0);
QCOMPARE(w3->geometry().left(), 49.0);
QCOMPARE(w3->geometry().right(), 69.0);
QCOMPARE(w4->geometry().left(), 3.0);
QCOMPARE(w4->geometry().right(), 33.0);
delete window;
}
void tst_QGraphicsGridLayout::removeLayout()
{
QGraphicsScene scene;
RectWidget *textEdit = new RectWidget;
RectWidget *pushButton = new RectWidget;
scene.addItem(textEdit);
scene.addItem(pushButton);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
layout->addItem(textEdit, 0, 0);
layout->addItem(pushButton, 1, 0);
QGraphicsWidget *form = new QGraphicsWidget;
form->setLayout(layout);
scene.addItem(form);
QGraphicsView view(&scene);
view.show();
QTest::qWait(20);
QRectF r1 = textEdit->geometry();
QRectF r2 = pushButton->geometry();
form->setLayout(0);
//documentation of QGraphicsWidget::setLayout:
//If layout is 0, the widget is left without a layout. Existing subwidgets' geometries will remain unaffected.
QCOMPARE(textEdit->geometry(), r1);
QCOMPARE(pushButton->geometry(), r2);
}
void tst_QGraphicsGridLayout::defaultStretchFactors_data()
{
QTest::addColumn<ItemList>("itemDescriptions");
QTest::addColumn<QSizeF>("newSize");
QTest::addColumn<SizeList>("expectedSizes");
QTest::newRow("usepreferredsize") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignoreitem01") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignoreitem01_resize120x40") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(20,10))
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(30,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(20,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(30,10))
)
<< QSizeF(120, 40)
<< (SizeList()
<< QSizeF(20,20) << QSizeF(40,20) << QSizeF(60,20)
<< QSizeF(20,20) << QSizeF(40,20) << QSizeF(60,20)
);
QTest::newRow("ignoreitem11_resize120x40") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(20,10))
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(30,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,20))
<< ItemDesc(1,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(20,20))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(30,20))
)
<< QSizeF(120, 60)
<< (SizeList()
<< QSizeF(20,20) << QSizeF(40,20) << QSizeF(60,20)
<< QSizeF(20,40) << QSizeF(40,40) << QSizeF(60,40)
);
QTest::newRow("ignoreitem01_span01_resize70x60") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(20,10))
.sizePolicy(QSizePolicy::Ignored)
.rowSpan(2)
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(30,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,20))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(30,20))
)
<< QSizeF(70, 60)
<< (SizeList()
<< QSizeF(20,20) << QSizeF(10,60) << QSizeF(40,20)
<< QSizeF(20,40) << QSizeF(40,40)
);
QTest::newRow("ignoreitem10_resize40x120") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,20))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,20))
<< ItemDesc(2,0)
.preferredSizeHint(QSizeF(10,30))
<< ItemDesc(2,1)
.preferredSizeHint(QSizeF(10,30))
)
<< QSizeF(40, 120)
<< (SizeList()
<< QSizeF(20,20) << QSizeF(20,20)
<< QSizeF(20,40) << QSizeF(20,40)
<< QSizeF(20,60) << QSizeF(20,60)
);
QTest::newRow("ignoreitem01_span02") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,20))
.rowSpan(2)
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,10) << QSizeF(0,20) << QSizeF(10,10)
<< QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignoreitem02_span02") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,2)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,20))
.rowSpan(2)
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(0,20)
<< QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignoreitem02_span00_span02") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
.rowSpan(2)
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,2)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,20))
.rowSpan(2)
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,20) << QSizeF(10,10) << QSizeF(0,20)
<< QSizeF(10,10)
);
QTest::newRow("ignoreitem00_colspan00") << (ItemList()
<< ItemDesc(0,0)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,20))
.colSpan(2)
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(20,10) << QSizeF(10,10) << QSizeF(10,10)
<< QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignoreitem01_colspan01") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,20))
.colSpan(2)
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,10) << QSizeF(20,10) << QSizeF(10,10)
<< QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignorecolumn1_resize70x60") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(20,10))
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(30,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,20))
<< ItemDesc(1,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(20,20))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(30,20))
)
<< QSizeF(70, 60)
<< (SizeList()
<< QSizeF(20,20) << QSizeF(10,20) << QSizeF(40,20)
<< QSizeF(20,40) << QSizeF(10,40) << QSizeF(40,40)
);
QTest::newRow("ignorerow0") << (ItemList()
<< ItemDesc(0,0)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,2)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,0) << QSizeF(10,0) << QSizeF(10,0)
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
);
QTest::newRow("ignorerow1") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,2)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,0)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(1,2)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
)
<< QSizeF()
<< (SizeList()
<< QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
<< QSizeF(10,0) << QSizeF(10,0) << QSizeF(10,0)
);
QTest::newRow("ignorerow0_resize60x50") << (ItemList()
<< ItemDesc(0,0)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(10,10))
<< ItemDesc(0,1)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(20,10))
<< ItemDesc(0,2)
.sizePolicy(QSizePolicy::Ignored)
.preferredSizeHint(QSizeF(30,10))
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,30))
<< ItemDesc(1,1)
.preferredSizeHint(QSizeF(20,30))
<< ItemDesc(1,2)
.preferredSizeHint(QSizeF(30,30))
)
<< QSizeF(60, 50)
<< (SizeList()
<< QSizeF(10,10) << QSizeF(20,10) << QSizeF(30,10)
<< QSizeF(10,40) << QSizeF(20,40) << QSizeF(30,40)
);
}
void tst_QGraphicsGridLayout::defaultStretchFactors()
{
QFETCH(ItemList, itemDescriptions);
QFETCH(QSizeF, newSize);
QFETCH(SizeList, expectedSizes);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
scene.addItem(widget);
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0.0);
widget->setContentsMargins(0, 0, 0, 0);
int i;
for (i = 0; i < itemDescriptions.count(); ++i) {
ItemDesc desc = itemDescriptions.at(i);
RectWidget *item = new RectWidget(widget);
desc.apply(layout, item);
}
QApplication::sendPostedEvents(0, 0);
widget->show();
view.show();
view.resize(400,300);
if (newSize.isValid())
widget->resize(newSize);
QApplication::sendPostedEvents(0, 0);
for (i = 0; i < expectedSizes.count(); ++i) {
QSizeF itemSize = layout->itemAt(i)->geometry().size();
QCOMPARE(itemSize, expectedSizes.at(i));
}
delete widget;
}
typedef QList<QRectF> RectList;
Q_DECLARE_METATYPE(RectList);
void tst_QGraphicsGridLayout::alignment2_data()
{
QTest::addColumn<ItemList>("itemDescriptions");
QTest::addColumn<QSizeF>("newSize");
QTest::addColumn<RectList>("expectedGeometries");
QTest::newRow("hor_sizepolicy_fixed") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,20))
.sizePolicyV(QSizePolicy::Fixed)
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyV(QSizePolicy::Fixed)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 10,20) << QRectF(10, 0, 10,10)
);
QTest::newRow("hor_sizepolicy_fixed_alignvcenter") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,20))
.sizePolicyV(QSizePolicy::Fixed)
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyV(QSizePolicy::Fixed)
.alignment(Qt::AlignVCenter)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 10,20) << QRectF(10, 5, 10,10)
);
QTest::newRow("hor_sizepolicy_fixed_aligntop") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,20))
.sizePolicyV(QSizePolicy::Fixed)
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyV(QSizePolicy::Fixed)
.alignment(Qt::AlignTop)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 10,20) << QRectF(10, 0, 10,10)
);
QTest::newRow("hor_sizepolicy_fixed_alignbottom") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(10,20))
.sizePolicyV(QSizePolicy::Fixed)
<< ItemDesc(0,1)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyV(QSizePolicy::Fixed)
.alignment(Qt::AlignBottom)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 10,20) << QRectF(10, 10, 10,10)
);
QTest::newRow("ver_sizepolicy_fixed") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(20,10))
.sizePolicyH(QSizePolicy::Fixed)
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyH(QSizePolicy::Fixed)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 20,10) << QRectF(0, 10, 10,10)
);
QTest::newRow("ver_sizepolicy_fixed_alignhcenter") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(20,10))
.sizePolicyH(QSizePolicy::Fixed)
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyH(QSizePolicy::Fixed)
.alignment(Qt::AlignHCenter)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 20,10) << QRectF(5, 10, 10,10)
);
QTest::newRow("ver_sizepolicy_fixed_alignleft") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(20,10))
.sizePolicyH(QSizePolicy::Fixed)
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyH(QSizePolicy::Fixed)
.alignment(Qt::AlignLeft)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 20,10) << QRectF(0, 10, 10,10)
);
QTest::newRow("ver_sizepolicy_fixed_alignright") << (ItemList()
<< ItemDesc(0,0)
.preferredSizeHint(QSizeF(20,10))
.sizePolicyH(QSizePolicy::Fixed)
<< ItemDesc(1,0)
.preferredSizeHint(QSizeF(10,10))
.sizePolicyH(QSizePolicy::Fixed)
.alignment(Qt::AlignRight)
)
<< QSizeF()
<< (RectList()
<< QRectF(0, 0, 20,10) << QRectF(10, 10, 10,10)
);
}
void tst_QGraphicsGridLayout::alignment2()
{
QFETCH(ItemList, itemDescriptions);
QFETCH(QSizeF, newSize);
QFETCH(RectList, expectedGeometries);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
scene.addItem(widget);
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0.0);
widget->setContentsMargins(0, 0, 0, 0);
int i;
for (i = 0; i < itemDescriptions.count(); ++i) {
ItemDesc desc = itemDescriptions.at(i);
RectWidget *item = new RectWidget(widget);
desc.apply(layout, item);
}
QApplication::sendPostedEvents(0, 0);
widget->show();
view.resize(400,300);
view.show();
if (newSize.isValid())
widget->resize(newSize);
QApplication::sendPostedEvents(0, 0);
for (i = 0; i < expectedGeometries.count(); ++i) {
QRectF itemRect = layout->itemAt(i)->geometry();
QCOMPARE(itemRect, expectedGeometries.at(i));
}
delete widget;
}
static QSizeF hfw1(Qt::SizeHint, const QSizeF &constraint)
{
QSizeF result(constraint);
const qreal ch = constraint.height();
const qreal cw = constraint.width();
if (cw < 0 && ch < 0) {
return QSizeF(50, 400);
} else if (cw > 0) {
result.setHeight(20000./cw);
}
return result;
}
static QSizeF wfh1(Qt::SizeHint, const QSizeF &constraint)
{
QSizeF result(constraint);
const qreal ch = constraint.height();
const qreal cw = constraint.width();
if (cw < 0 && ch < 0) {
return QSizeF(400, 50);
} else if (ch > 0) {
result.setWidth(20000./ch);
}
return result;
}
static QSizeF wfh2(Qt::SizeHint, const QSizeF &constraint)
{
QSizeF result(constraint);
const qreal ch = constraint.height();
const qreal cw = constraint.width();
if (ch < 0 && cw < 0)
return QSizeF(50, 50);
if (ch >= 0)
result.setWidth(ch);
return result;
}
static QSizeF hfw3(Qt::SizeHint, const QSizeF &constraint)
{
QSizeF result(constraint);
const qreal ch = constraint.height();
const qreal cw = constraint.width();
if (cw < 0 && ch < 0) {
return QSizeF(10, 10);
} else if (cw > 0) {
result.setHeight(100./cw);
}
return result;
}
static QSizeF hfw2(Qt::SizeHint /*which*/, const QSizeF &constraint)
{
return QSizeF(constraint.width(), constraint.width());
}
void tst_QGraphicsGridLayout::geometries_data()
{
QTest::addColumn<ItemList>("itemDescriptions");
QTest::addColumn<QSizeF>("newSize");
QTest::addColumn<RectList>("expectedGeometries");
QTest::newRow("combine_max_sizes") << (ItemList()
<< ItemDesc(0,0)
.maxSize(QSizeF(50,10))
<< ItemDesc(1,0)
.maxSize(QSizeF(10,10))
)
<< QSizeF(50, 20)
<< (RectList()
<< QRectF(0, 0, 50,10) << QRectF(0, 10, 10,10)
);
QTest::newRow("combine_min_sizes") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(50,10))
<< ItemDesc(1,0)
.minSize(QSizeF(10,10))
)
<< QSizeF(60, 20)
<< (RectList()
<< QRectF(0, 0, 60,10) << QRectF(0, 10, 60,10)
);
// change layout height and verify
QTest::newRow("hfw-100x401") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.minSize(QSizeF(40,-1))
.preferredSize(QSizeF(50,-1))
.maxSize(QSizeF(500, -1))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 401)
<< (RectList()
<< QRectF(0, 0, 50, 1) << QRectF(50, 0, 50, 1)
<< QRectF(0, 1, 50,100) << QRectF(50, 1, 50,400)
);
QTest::newRow("hfw-h408") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(500, 500))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 408)
<< (RectList()
<< QRectF(0, 0, 50, 8) << QRectF(50, 0, 50, 8)
<< QRectF(0, 8, 50,100) << QRectF(50, 8, 50,400)
);
QTest::newRow("hfw-h410") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.minSize(QSizeF(40,40))
.preferredSize(QSizeF(50,400))
.maxSize(QSizeF(500, 500))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 410)
<< (RectList()
<< QRectF(0, 0, 50,10) << QRectF(50, 0, 50,10)
<< QRectF(0, 10, 50,100) << QRectF(50, 10, 50,400)
);
QTest::newRow("hfw-100x470") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(500,500))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 470)
<< (RectList()
<< QRectF(0, 0, 50,70) << QRectF(50, 0, 50,70)
<< QRectF(0, 70, 50,100) << QRectF(50, 70, 50,400)
);
// change layout width and verify
QTest::newRow("hfw-100x401") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.minSize(QSizeF(-1,-1))
.preferredSize(QSizeF(-1,-1))
.maxSize(QSizeF(-1, -1))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 401)
<< (RectList()
<< QRectF( 0, 0, 50, 1) << QRectF( 50, 0, 50, 1)
<< QRectF( 0, 1, 50, 100) << QRectF( 50, 1, 50, 400)
);
QTest::newRow("hfw-160x350") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(160, 350)
<< (RectList()
<< QRectF( 0, 0, 80, 100) << QRectF( 80, 0, 80, 100)
<< QRectF( 0, 100, 80, 100) << QRectF( 80, 100, 80, 250)
);
QTest::newRow("hfw-160x300") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(5000, 5000))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(160, 300)
<< (RectList()
<< QRectF( 0, 0, 80, 50) << QRectF( 80, 0, 80, 50)
<< QRectF( 0, 50, 80, 100) << QRectF( 80, 50, 80, 250)
);
QTest::newRow("hfw-20x40") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,10))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(1, 1))
.sizeHint(Qt::PreferredSize, QSizeF(50, 50))
.sizeHint(Qt::MaximumSize, QSizeF(100, 100))
.dynamicConstraint(hfw3, Qt::Vertical)
)
<< QSizeF(20, 40)
<< (RectList()
<< QRectF(0, 0, 10, 20) << QRectF(10, 0, 10, 20)
<< QRectF(0, 20, 10, 20) << QRectF(10, 20, 10, 10)
);
QTest::newRow("wfh-300x160") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(10,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(10,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(10,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(10,10))
.sizeHint(Qt::PreferredSize, QSizeF(400,50))
.sizeHint(Qt::MaximumSize, QSizeF(5000, 5000))
.dynamicConstraint(wfh1, Qt::Horizontal)
)
<< QSizeF(300, 160)
<< (RectList()
<< QRectF( 0, 0, 50, 80) << QRectF( 50, 0, 100, 80)
<< QRectF( 0, 80, 50, 80) << QRectF( 50, 80, 250, 80)
);
QTest::newRow("wfh-40x20") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
// Note, must be 10 in order to match stretching of wfh item
// below (the same stretch makes it easier to test)
.minSize(QSizeF(10,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(1,1))
.sizeHint(Qt::PreferredSize, QSizeF(50,50))
.sizeHint(Qt::MaximumSize, QSizeF(100, 100))
.dynamicConstraint(wfh2, Qt::Horizontal)
)
<< QSizeF(40, 20)
<< (RectList()
<< QRectF(0, 0, 20, 10) << QRectF(20, 0, 20, 10)
<< QRectF(0, 10, 20, 10) << QRectF(20, 10, 10, 10)
);
QTest::newRow("wfh-400x160") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(1,1))
.sizeHint(Qt::PreferredSize, QSizeF(50,50))
.sizeHint(Qt::MaximumSize, QSizeF(100, 100))
.dynamicConstraint(wfh2, Qt::Horizontal)
)
<< QSizeF(400, 160)
<< (RectList()
<< QRectF(0, 0, 100, 80) << QRectF(100, 0, 100, 80)
<< QRectF(0, 80, 100, 80) << QRectF(100, 80, 80, 80)
);
QTest::newRow("wfh-160x100") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
// Note, preferred width must be 50 in order to match
// preferred width of wfh item below.
// (The same preferred size makes the stretch the same, and
// makes it easier to test) (The stretch algorithm is a
// blackbox)
.preferredSize(QSizeF(50,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(10,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(10,50))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(1,1))
.sizeHint(Qt::PreferredSize, QSizeF(10,50))
.sizeHint(Qt::MaximumSize, QSizeF(500, 500))
.dynamicConstraint(wfh2, Qt::Horizontal)
)
<< QSizeF(160, 100)
<< (RectList()
<< QRectF(0, 0, 80, 50) << QRectF( 80, 0, 80, 50)
<< QRectF(0, 50, 80, 50) << QRectF( 80, 50, 50, 50)
);
QTest::newRow("hfw-h470") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(500,500))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 470)
<< (RectList()
<< QRectF(0, 0, 50,70) << QRectF(50, 0, 50,70)
<< QRectF(0, 70, 50,100) << QRectF(50, 70, 50,400)
);
// change layout width and verify
QTest::newRow("hfw-w100") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(100, 401)
<< (RectList()
<< QRectF( 0, 0, 50, 1) << QRectF( 50, 0, 50, 1)
<< QRectF( 0, 1, 50, 100) << QRectF( 50, 1, 50, 400)
);
QTest::newRow("hfw-w160") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(160, 350)
<< (RectList()
<< QRectF( 0, 0, 80, 100) << QRectF( 80, 0, 80, 100)
<< QRectF( 0, 100, 80, 100) << QRectF( 80, 100, 80, 250)
);
QTest::newRow("hfw-w500") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(0,1)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,0)
.minSize(QSizeF(1,1))
.preferredSize(QSizeF(50,10))
.maxSize(QSizeF(100, 100))
<< ItemDesc(1,1)
.sizeHint(Qt::MinimumSize, QSizeF(40,40))
.sizeHint(Qt::PreferredSize, QSizeF(50,400))
.sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
.dynamicConstraint(hfw1, Qt::Vertical)
)
<< QSizeF(500, 200)
<< (RectList()
<< QRectF( 0, 0, 100, 100) << QRectF(100, 0, 100, 100)
<< QRectF( 0, 100, 100, 100) << QRectF(100, 100, 400, 50)
);
QTest::newRow("hfw-alignment-defaults") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(100, 100))
.maxSize(QSizeF(100, 100))
.dynamicConstraint(hfw2, Qt::Vertical)
<< ItemDesc(1,0)
.minSize(QSizeF(200, 200))
.maxSize(QSizeF(200, 200))
.dynamicConstraint(hfw2, Qt::Vertical)
<< ItemDesc(2,0)
.minSize(QSizeF(300, 300))
.maxSize(QSizeF(300, 300))
)
<< QSizeF(300, 600)
<< (RectList()
<< QRectF(0, 0, 100, 100)
<< QRectF(0, 100, 200, 200)
<< QRectF(0, 300, 300, 300)
);
QTest::newRow("hfw-alignment2") << (ItemList()
<< ItemDesc(0,0)
.minSize(QSizeF(100, 100))
.maxSize(QSizeF(100, 100))
.dynamicConstraint(hfw2, Qt::Vertical)
.alignment(Qt::AlignRight)
<< ItemDesc(1,0)
.minSize(QSizeF(200, 200))
.maxSize(QSizeF(200, 200))
.dynamicConstraint(hfw2, Qt::Vertical)
.alignment(Qt::AlignHCenter)
<< ItemDesc(2,0)
.minSize(QSizeF(300, 300))
.maxSize(QSizeF(300, 300))
)
<< QSizeF(300, 600)
<< (RectList()
<< QRectF(200, 0, 100, 100)
<< QRectF( 50, 100, 200, 200)
<< QRectF( 0, 300, 300, 300)
);
}
void tst_QGraphicsGridLayout::geometries()
{
QFETCH(ItemList, itemDescriptions);
QFETCH(QSizeF, newSize);
QFETCH(RectList, expectedGeometries);
QGraphicsScene scene;
QGraphicsView view(&scene);
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
scene.addItem(widget);
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0.0);
widget->setContentsMargins(0, 0, 0, 0);
int i;
for (i = 0; i < itemDescriptions.count(); ++i) {
ItemDesc desc = itemDescriptions.at(i);
RectWidget *item = new RectWidget(widget);
desc.apply(layout, item);
}
QApplication::processEvents();
widget->show();
view.resize(400,300);
view.show();
if (newSize.isValid())
widget->resize(newSize);
QApplication::processEvents();
for (i = 0; i < expectedGeometries.count(); ++i) {
QRectF itemRect = layout->itemAt(i)->geometry();
QCOMPARE(itemRect, expectedGeometries.at(i));
}
delete widget;
}
void tst_QGraphicsGridLayout::avoidRecursionInInsertItem()
{
QGraphicsWidget window(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout(&window);
QCOMPARE(layout->count(), 0);
QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: cannot insert itself");
layout->addItem(layout, 0, 0);
QCOMPARE(layout->count(), 0);
}
void tst_QGraphicsGridLayout::styleInfoLeak()
{
QGraphicsGridLayout grid;
grid.horizontalSpacing();
}
void tst_QGraphicsGridLayout::task236367_maxSizeHint()
{
QGraphicsWidget *widget = new QGraphicsWidget;
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
int w = 203;
int h = 204;
widget->resize(w, h);
QCOMPARE(widget->size(), QSizeF(w, h));
}
static QSizeF hfw(Qt::SizeHint /*which*/, const QSizeF &constraint)
{
QSizeF result(constraint);
const qreal cw = constraint.width();
const qreal ch = constraint.height();
if (cw < 0 && ch < 0) {
return QSizeF(200, 100);
} else if (cw >= 0) {
result.setHeight(20000./cw);
} else if (cw == 0) {
result.setHeight(20000);
} else if (ch >= 0) {
result.setWidth(20000./ch);
} else if (ch == 0) {
result.setWidth(20000);
}
return result;
}
static QSizeF wfh(Qt::SizeHint /*which*/, const QSizeF &constraint)
{
QSizeF result(constraint);
const qreal ch = constraint.height();
if (ch >= 0) {
result.setWidth(ch);
}
return result;
}
bool qFuzzyCompare(const QSizeF &a, const QSizeF &b)
{
return qFuzzyCompare(a.width(), b.width()) && qFuzzyCompare(a.height(), b.height());
}
void tst_QGraphicsGridLayout::heightForWidth()
{
QGraphicsWidget *widget = new QGraphicsWidget;
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
RectWidget *w00 = new RectWidget;
w00->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
w00->setSizeHint(Qt::PreferredSize, QSizeF(10,10));
w00->setSizeHint(Qt::MaximumSize, QSizeF(100,100));
layout->addItem(w00, 0, 0);
RectWidget *w01 = new RectWidget;
w01->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
w01->setSizeHint(Qt::PreferredSize, QSizeF(10,10));
w01->setSizeHint(Qt::MaximumSize, QSizeF(100,100));
layout->addItem(w01, 0, 1);
RectWidget *w10 = new RectWidget;
w10->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
w10->setSizeHint(Qt::PreferredSize, QSizeF(10,10));
w10->setSizeHint(Qt::MaximumSize, QSizeF(100,100));
layout->addItem(w10, 1, 0);
RectWidget *w11 = new RectWidget;
w11->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
w11->setSizeHint(Qt::MaximumSize, QSizeF(30000,30000));
w11->setConstraintFunction(hfw);
QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
sp.setHeightForWidth(true);
w11->setSizePolicy(sp);
layout->addItem(w11, 1, 1);
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1)), QSizeF(2, 2));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1)), QSizeF(210, 110));
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, -1)), QSizeF(30100, 30100));
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(2, -1)), QSizeF(2, 20001));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(2, -1)), QSizeF(2, 20010));
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(2, -1)), QSizeF(2, 20100));
// Since 20 is somewhere between "minimum width hint" (2) and
// "preferred width hint" (210), it will try to do distribution by
// stretching them with different factors.
// Since column 1 has a "preferred width" of 200 it means that
// column 1 will be a bit wider than column 0. Thus it will also be a bit
// shorter than 2001, (the expected height if all columns had width=10)
QSizeF sh = layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(20, -1));
// column 1 cannot be wider than 19, which means that it must be taller than 20000/19~=1052
QVERIFY(sh.height() < 2000 + 1 && sh.height() > 1052 + 1);
sh = layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(20, -1));
QVERIFY(sh.height() < 2000 + 10 && sh.height() > 1052 + 10);
sh = layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(20, -1));
QVERIFY(sh.height() < 2000 + 100 && sh.height() > 1052 + 100);
// the height of the hfw widget is shorter than the one to the left, which is 100, so
// the total height of the last row is 100 (which leaves the layout height to be 200)
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(500, -1)), QSizeF(500, 100 + 100));
}
void tst_QGraphicsGridLayout::widthForHeight()
{
QGraphicsWidget *widget = new QGraphicsWidget;
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
RectWidget *w00 = new RectWidget;
w00->setMinimumSize(1, 1);
w00->setPreferredSize(50, 50);
w00->setMaximumSize(100, 100);
layout->addItem(w00, 0, 0);
RectWidget *w01 = new RectWidget;
w01->setMinimumSize(1,1);
w01->setPreferredSize(50,50);
w01->setMaximumSize(100,100);
layout->addItem(w01, 0, 1);
RectWidget *w10 = new RectWidget;
w10->setMinimumSize(1,1);
w10->setPreferredSize(50,50);
w10->setMaximumSize(100,100);
layout->addItem(w10, 1, 0);
RectWidget *w11 = new RectWidget;
w11->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
w11->setSizeHint(Qt::PreferredSize, QSizeF(50,50));
w11->setSizeHint(Qt::MaximumSize, QSizeF(30000,30000));
// This will make sure its always square.
w11->setConstraintFunction(wfh);
QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
sp.setWidthForHeight(true);
w11->setSizePolicy(sp);
layout->addItem(w11, 1, 1);
/*
| 1, 50, 100 | 1, 50, 100 |
-----+--------------+--------------+
1| | |
50| | |
100| | |
-----|--------------+--------------+
1| | |
50| | WFH |
100| | |
-----------------------------------+
*/
QSizeF prefSize = layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
QCOMPARE(prefSize, QSizeF(50+50, 50+50));
// wfh(1): = 1
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 2)), QSizeF(1 + 1, 2));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 2)), QSizeF(50 + 50, 2));
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 2)), QSizeF(100 + 100, 2));
// wfh(40) = 40
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 80)), QSizeF(1 + 40, 80));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 80)), QSizeF(50 + 50, 80));
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 80)), QSizeF(100 + 100, 80));
// wfh(80) = 80
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 160)), QSizeF(1 + 80, 160));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 160)), QSizeF(50 + 80, 160));
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 160)), QSizeF(100 + 100, 160));
// wfh(200) = 200
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 300)), QSizeF(1 + 200, 300));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 300)), QSizeF(50 + 200, 300));
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 300)), QSizeF(100 + 200, 300));
}
void tst_QGraphicsGridLayout::heightForWidthWithSpanning()
{
QGraphicsWidget *widget = new QGraphicsWidget;
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
RectWidget *w = new RectWidget;
w->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
w->setSizeHint(Qt::MaximumSize, QSizeF(30000,30000));
w->setConstraintFunction(hfw);
QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
sp.setHeightForWidth(true);
w->setSizePolicy(sp);
layout->addItem(w, 0,0,2,2);
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1)), QSizeF(1, 1));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1)), QSizeF(200, 100));
QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, -1)), QSizeF(30000, 30000));
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(200, -1)), QSizeF(200, 100));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(200, -1)), QSizeF(200, 100));
QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(200, -1)), QSizeF(200, 100));
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(2, -1)), QSizeF(2, 10000));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(2, -1)), QSizeF(2, 10000));
QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(2, -1)), QSizeF(2, 10000));
QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(200, -1)), QSizeF(200, 100));
QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(200, -1)), QSizeF(200, 100));
QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(200, -1)), QSizeF(200, 10000));
}
Q_DECLARE_METATYPE(QSizePolicy::Policy)
void tst_QGraphicsGridLayout::spanningItem2x2_data()
{
QTest::addColumn<QSizePolicy::Policy>("sizePolicy");
QTest::addColumn<int>("itemHeight");
QTest::addColumn<int>("expectedHeight");
QTest::newRow("A larger spanning item with 2 widgets with fixed policy") << QSizePolicy::Fixed << 39 << 80;
QTest::newRow("A larger spanning item with 2 widgets with preferred policy") << QSizePolicy::Preferred << 39 << 80;
QTest::newRow("An equally-sized spanning item with 2 widgets with fixed policy") << QSizePolicy::Fixed << 40 << 80;
QTest::newRow("An equally-sized spanning item with 2 widgets with preferred policy") << QSizePolicy::Preferred << 40 << 80;
QTest::newRow("A smaller spanning item with 2 widgets with fixed policy") << QSizePolicy::Fixed << 41 << 82;
QTest::newRow("A smaller spanning item with 2 widgets with preferred policy") << QSizePolicy::Preferred << 41 << 82;
}
void tst_QGraphicsGridLayout::spanningItem2x2()
{
QFETCH(QSizePolicy::Policy, sizePolicy);
QFETCH(int, itemHeight);
QFETCH(int, expectedHeight);
QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout(form);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QGraphicsWidget *w1 = new QGraphicsWidget;
w1->setMinimumSize(80,80);
w1->setMaximumSize(80,80);
QGraphicsWidget *w2 = new QGraphicsWidget;
w2->setMinimumSize(80,itemHeight);
w2->setPreferredSize(80,itemHeight);
w2->setSizePolicy(QSizePolicy::Fixed, sizePolicy);
QGraphicsWidget *w3 = new QGraphicsWidget;
w3->setMinimumSize(80,itemHeight);
w3->setPreferredSize(80,itemHeight);
w3->setSizePolicy(QSizePolicy::Fixed, sizePolicy);
layout->addItem(w1, 0, 0, 2, 1);
layout->addItem(w2, 0, 1);
layout->addItem(w3, 1, 1);
QCOMPARE(layout->minimumSize(), QSizeF(160,expectedHeight));
if(sizePolicy == QSizePolicy::Fixed)
QCOMPARE(layout->maximumSize(), QSizeF(160,expectedHeight));
else
QCOMPARE(layout->maximumSize(), QSizeF(160,QWIDGETSIZE_MAX));
}
void tst_QGraphicsGridLayout::spanningItem2x3_data()
{
QTest::addColumn<bool>("w1_fixed");
QTest::addColumn<bool>("w2_fixed");
QTest::addColumn<bool>("w3_fixed");
QTest::addColumn<bool>("w4_fixed");
QTest::addColumn<bool>("w5_fixed");
for(int w1 = 0; w1 < 2; w1++)
for(int w2 = 0; w2 < 2; w2++)
for(int w3 = 0; w3 < 2; w3++)
for(int w4 = 0; w4 < 2; w4++)
for(int w5 = 0; w5 < 2; w5++) {
QString description = QString("Fixed sizes:") + (w1?" w1":"") + (w2?" w2":"") + (w3?" w3":"") + (w4?" w4":"") + (w5?" w5":"");
QTest::newRow(description.toLatin1()) << (bool)w1 << (bool)w2 << (bool)w3 << (bool)w4 << (bool)w5;
}
}
void tst_QGraphicsGridLayout::spanningItem2x3()
{
QFETCH(bool, w1_fixed);
QFETCH(bool, w2_fixed);
QFETCH(bool, w3_fixed);
QFETCH(bool, w4_fixed);
QFETCH(bool, w5_fixed);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QGraphicsWidget *w1 = new QGraphicsWidget;
w1->setMinimumSize(80,80);
w1->setMaximumSize(80,80);
if (w1_fixed)
w1->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
QGraphicsWidget *w2 = new QGraphicsWidget;
w2->setMinimumSize(80,48);
w2->setPreferredSize(80,48);
if (w2_fixed)
w2->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
QGraphicsWidget *w3 = new QGraphicsWidget;
w3->setMinimumSize(80,30);
w3->setPreferredSize(80,30);
if (w3_fixed)
w3->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
QGraphicsWidget *w4 = new QGraphicsWidget;
w4->setMinimumSize(80,30);
w4->setMaximumSize(80,30);
if (w4_fixed)
w4->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
QGraphicsWidget *w5 = new QGraphicsWidget;
w5->setMinimumSize(40,24);
w5->setMaximumSize(40,24);
if (w5_fixed)
w5->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
layout->addItem(w1, 0, 0, 2, 1);
layout->addItem(w2, 0, 1);
layout->addItem(w3, 1, 1);
layout->addItem(w4, 0, 2);
layout->addItem(w5, 1, 2);
QCOMPARE(layout->minimumSize(), QSizeF(240,80));
// Only w2 and w3 grow vertically, so when they have a fixed vertical size policy,
// the whole layout cannot grow vertically.
if (w2_fixed && w3_fixed)
QCOMPARE(layout->maximumSize(), QSizeF(QWIDGETSIZE_MAX,80));
else
QCOMPARE(layout->maximumSize(), QSizeF(QWIDGETSIZE_MAX,QWIDGETSIZE_MAX));
}
void tst_QGraphicsGridLayout::spanningItem()
{
QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout(form);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QGraphicsWidget *w1 = new QGraphicsWidget;
w1->setMinimumSize(80,80);
w1->setMaximumSize(80,80);
QGraphicsWidget *w2 = new QGraphicsWidget;
w2->setMinimumSize(80,38);
w2->setPreferredSize(80,38);
w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
QGraphicsWidget *w3 = new QGraphicsWidget;
w3->setMinimumSize(80,38);
w3->setPreferredSize(80,38);
w3->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
layout->addItem(w1, 0, 0, 2, 1);
layout->addItem(w2, 0, 1);
layout->addItem(w3, 1, 1);
QCOMPARE(layout->minimumSize(), QSizeF(160,80));
QCOMPARE(layout->maximumSize(), QSizeF(160,80));
}
void tst_QGraphicsGridLayout::stretchAndHeightForWidth()
{
QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
QGraphicsGridLayout *layout = new QGraphicsGridLayout;
widget->setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
RectWidget *w1 = new RectWidget;
w1->setSizeHint(Qt::MinimumSize, QSizeF(10, 10));
w1->setSizeHint(Qt::PreferredSize, QSizeF(100, 100));
w1->setSizeHint(Qt::MaximumSize, QSizeF(500, 500));
layout->addItem(w1, 0,0,1,1);
RectWidget *w2 = new RectWidget;
w2->setSizeHint(Qt::MinimumSize, QSizeF(10, 10));
w2->setSizeHint(Qt::PreferredSize, QSizeF(100, 100));
w2->setSizeHint(Qt::MaximumSize, QSizeF(500, 500));
layout->addItem(w2, 0,1,1,1);
layout->setColumnStretchFactor(1, 2);
QApplication::sendPostedEvents();
QGraphicsScene scene;
QGraphicsView *view = new QGraphicsView(&scene);
scene.addItem(widget);
view->show();
widget->resize(500, 100);
// w1 should stay at its preferred size
QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
QCOMPARE(w2->geometry(), QRectF(100, 0, 400, 100));
// only w1 has hfw
w1->setConstraintFunction(hfw);
QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
sp.setHeightForWidth(true);
w1->setSizePolicy(sp);
QApplication::sendPostedEvents();
QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 200));
QCOMPARE(w2->geometry(), QRectF(100, 0, 400, 200));
// only w2 has hfw
w2->setConstraintFunction(hfw);
w2->setSizePolicy(sp);
w1->setConstraintFunction(0);
sp.setHeightForWidth(false);
w1->setSizePolicy(sp);
QApplication::sendPostedEvents();
QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
QCOMPARE(w2->geometry(), QRectF(100, 0, 400, 50));
}
void tst_QGraphicsGridLayout::testDefaultAlignment()
{
QGraphicsWidget *widget = new QGraphicsWidget;
QGraphicsGridLayout *layout = new QGraphicsGridLayout(widget);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
QGraphicsWidget *w = new QGraphicsWidget;
w->setMinimumSize(50,50);
w->setMaximumSize(50,50);
layout->addItem(w,0,0);
//Default alignment should be to the top-left
//First, check by forcing the layout to be bigger
layout->setMinimumSize(100,100);
layout->activate();
QCOMPARE(layout->geometry(), QRectF(0,0,100,100));
QCOMPARE(w->geometry(), QRectF(0,0,50,50));
layout->setMinimumSize(-1,-1);
//Second, check by forcing the column and row to be bigger instead
layout->setColumnMinimumWidth(0, 100);
layout->setRowMinimumHeight(0, 100);
layout->activate();
QCOMPARE(layout->geometry(), QRectF(0,0,100,100));
QCOMPARE(w->geometry(), QRectF(0,0,50,50));
layout->setMinimumSize(-1,-1);
layout->setColumnMinimumWidth(0, 0);
layout->setRowMinimumHeight(0, 0);
//Third, check by adding a larger item in the column
QGraphicsWidget *w2 = new QGraphicsWidget;
w2->setMinimumSize(100,100);
w2->setMaximumSize(100,100);
layout->addItem(w2,1,0);
layout->activate();
QCOMPARE(layout->geometry(), QRectF(0,0,100,150));
QCOMPARE(w->geometry(), QRectF(0,0,50,50));
QCOMPARE(w2->geometry(), QRectF(0,50,100,100));
}
QTEST_MAIN(tst_QGraphicsGridLayout)
#include "tst_qgraphicsgridlayout.moc"
Reference in New Issue View Git Blame Copy Permalink