106 void geometries(); |
106 void geometries(); |
107 void avoidRecursionInInsertItem(); |
107 void avoidRecursionInInsertItem(); |
108 void task236367_maxSizeHint(); |
108 void task236367_maxSizeHint(); |
109 }; |
109 }; |
110 |
110 |
|
111 class RectWidget : public QGraphicsWidget |
|
112 { |
|
113 public: |
|
114 RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent){} |
|
115 |
|
116 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) |
|
117 { |
|
118 Q_UNUSED(option); |
|
119 Q_UNUSED(widget); |
|
120 painter->drawRoundRect(rect()); |
|
121 painter->drawLine(rect().topLeft(), rect().bottomRight()); |
|
122 painter->drawLine(rect().bottomLeft(), rect().topRight()); |
|
123 } |
|
124 |
|
125 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const |
|
126 { |
|
127 if (m_sizeHints[which].isValid()) { |
|
128 return m_sizeHints[which]; |
|
129 } |
|
130 return QGraphicsWidget::sizeHint(which, constraint); |
|
131 } |
|
132 |
|
133 void setSizeHint(Qt::SizeHint which, const QSizeF &size) { |
|
134 m_sizeHints[which] = size; |
|
135 updateGeometry(); |
|
136 } |
|
137 |
|
138 QSizeF m_sizeHints[Qt::NSizeHints]; |
|
139 }; |
|
140 |
|
141 struct ItemDesc |
|
142 { |
|
143 ItemDesc(int row, int col) |
|
144 : m_pos(qMakePair(row, col)), |
|
145 m_rowSpan(1), |
|
146 m_colSpan(1), |
|
147 m_sizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred)), |
|
148 m_align(0) |
|
149 { |
|
150 } |
|
151 |
|
152 ItemDesc &rowSpan(int span) { |
|
153 m_rowSpan = span; |
|
154 return (*this); |
|
155 } |
|
156 |
|
157 ItemDesc &colSpan(int span) { |
|
158 m_colSpan = span; |
|
159 return (*this); |
|
160 } |
|
161 |
|
162 ItemDesc &sizePolicy(const QSizePolicy &sp) { |
|
163 m_sizePolicy = sp; |
|
164 return (*this); |
|
165 } |
|
166 |
|
167 ItemDesc &sizePolicy(QSizePolicy::Policy horAndVer) { |
|
168 m_sizePolicy = QSizePolicy(horAndVer, horAndVer); |
|
169 return (*this); |
|
170 } |
|
171 |
|
172 ItemDesc &sizePolicyH(QSizePolicy::Policy hor) { |
|
173 m_sizePolicy.setHorizontalPolicy(hor); |
|
174 return (*this); |
|
175 } |
|
176 |
|
177 ItemDesc &sizePolicyV(QSizePolicy::Policy ver) { |
|
178 m_sizePolicy.setVerticalPolicy(ver); |
|
179 return (*this); |
|
180 } |
|
181 |
|
182 ItemDesc &sizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver) { |
|
183 m_sizePolicy = QSizePolicy(hor, ver); |
|
184 return (*this); |
|
185 } |
|
186 |
|
187 ItemDesc &sizeHint(Qt::SizeHint which, const QSizeF &sh) { |
|
188 m_sizeHints[which] = sh; |
|
189 return (*this); |
|
190 } |
|
191 |
|
192 ItemDesc &preferredSizeHint(const QSizeF &sh) { |
|
193 m_sizeHints[Qt::PreferredSize] = sh; |
|
194 return (*this); |
|
195 } |
|
196 |
|
197 ItemDesc &minSize(const QSizeF &sz) { |
|
198 m_sizes[Qt::MinimumSize] = sz; |
|
199 return (*this); |
|
200 } |
|
201 ItemDesc &preferredSize(const QSizeF &sz) { |
|
202 m_sizes[Qt::PreferredSize] = sz; |
|
203 return (*this); |
|
204 } |
|
205 ItemDesc &maxSize(const QSizeF &sz) { |
|
206 m_sizes[Qt::MaximumSize] = sz; |
|
207 return (*this); |
|
208 } |
|
209 |
|
210 ItemDesc &alignment(Qt::Alignment alignment) { |
|
211 m_align = alignment; |
|
212 return (*this); |
|
213 } |
|
214 |
|
215 void apply(QGraphicsGridLayout *layout, QGraphicsWidget *item) { |
|
216 item->setSizePolicy(m_sizePolicy); |
|
217 for (int i = 0; i < Qt::NSizeHints; ++i) { |
|
218 if (!m_sizes[i].isValid()) |
|
219 continue; |
|
220 switch ((Qt::SizeHint)i) { |
|
221 case Qt::MinimumSize: |
|
222 item->setMinimumSize(m_sizes[i]); |
|
223 break; |
|
224 case Qt::PreferredSize: |
|
225 item->setPreferredSize(m_sizes[i]); |
|
226 break; |
|
227 case Qt::MaximumSize: |
|
228 item->setMaximumSize(m_sizes[i]); |
|
229 break; |
|
230 default: |
|
231 qWarning("not implemented"); |
|
232 break; |
|
233 } |
|
234 } |
|
235 layout->addItem(item, m_pos.first, m_pos.second, m_rowSpan, m_colSpan); |
|
236 layout->setAlignment(item, m_align); |
|
237 } |
|
238 |
|
239 void apply(QGraphicsGridLayout *layout, RectWidget *item) { |
|
240 for (int i = 0; i < Qt::NSizeHints; ++i) |
|
241 item->setSizeHint((Qt::SizeHint)i, m_sizeHints[i]); |
|
242 apply(layout, static_cast<QGraphicsWidget*>(item)); |
|
243 } |
|
244 |
|
245 //private: |
|
246 QPair<int,int> m_pos; // row,col |
|
247 int m_rowSpan; |
|
248 int m_colSpan; |
|
249 QSizePolicy m_sizePolicy; |
|
250 QSizeF m_sizeHints[Qt::NSizeHints]; |
|
251 QSizeF m_sizes[Qt::NSizeHints]; |
|
252 Qt::Alignment m_align; |
|
253 }; |
|
254 |
|
255 typedef QList<ItemDesc> ItemList; |
|
256 Q_DECLARE_METATYPE(ItemList); |
|
257 |
|
258 typedef QList<QSizeF> SizeList; |
|
259 Q_DECLARE_METATYPE(SizeList); |
|
260 |
|
261 |
111 // This will be called before the first test function is executed. |
262 // This will be called before the first test function is executed. |
112 // It is only called once. |
263 // It is only called once. |
113 void tst_QGraphicsGridLayout::initTestCase() |
264 void tst_QGraphicsGridLayout::initTestCase() |
114 { |
265 { |
115 } |
266 } |
188 layout.setVerticalSpacing(0); |
339 layout.setVerticalSpacing(0); |
189 layout.sizeHint(Qt::MinimumSize); |
340 layout.sizeHint(Qt::MinimumSize); |
190 layout.verticalSpacing(); |
341 layout.verticalSpacing(); |
191 } |
342 } |
192 |
343 |
193 class RectWidget : public QGraphicsWidget |
|
194 { |
|
195 public: |
|
196 RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent){} |
|
197 |
|
198 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) |
|
199 { |
|
200 Q_UNUSED(option); |
|
201 Q_UNUSED(widget); |
|
202 painter->drawRoundRect(rect()); |
|
203 painter->drawLine(rect().topLeft(), rect().bottomRight()); |
|
204 painter->drawLine(rect().bottomLeft(), rect().topRight()); |
|
205 } |
|
206 |
|
207 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const |
|
208 { |
|
209 if (m_sizeHints[which].isValid()) { |
|
210 return m_sizeHints[which]; |
|
211 } |
|
212 return QGraphicsWidget::sizeHint(which, constraint); |
|
213 } |
|
214 |
|
215 void setSizeHint(Qt::SizeHint which, const QSizeF &size) { |
|
216 m_sizeHints[which] = size; |
|
217 updateGeometry(); |
|
218 } |
|
219 |
|
220 QSizeF m_sizeHints[Qt::NSizeHints]; |
|
221 }; |
|
222 |
|
223 static void populateLayout(QGraphicsGridLayout *gridLayout, int width, int height) |
344 static void populateLayout(QGraphicsGridLayout *gridLayout, int width, int height) |
224 { |
345 { |
225 for (int y = 0; y < height; ++y) { |
346 for (int y = 0; y < height; ++y) { |
226 for (int x = 0; x < width; ++x) { |
347 for (int x = 0; x < width; ++x) { |
227 QGraphicsWidget *item = new RectWidget(); |
348 QGraphicsWidget *item = new RectWidget(); |
1231 delete widget; |
1352 delete widget; |
1232 } |
1353 } |
1233 |
1354 |
1234 void tst_QGraphicsGridLayout::sizeHint_data() |
1355 void tst_QGraphicsGridLayout::sizeHint_data() |
1235 { |
1356 { |
1236 |
1357 QTest::addColumn<ItemList>("itemDescriptions"); |
1237 /* |
1358 QTest::addColumn<QSizeF>("expectedMinimumSizeHint"); |
1238 QTest::addColumn<Qt::SizeHint>("which"); |
1359 QTest::addColumn<QSizeF>("expectedPreferredSizeHint"); |
1239 QTest::addColumn<QSizeF>("constraint"); |
1360 QTest::addColumn<QSizeF>("expectedMaximumSizeHint"); |
1240 QTest::addColumn<QSizeF>("sizeHint"); |
1361 |
1241 QTest::newRow("null") << 0; |
1362 QTest::newRow("rowSpan_larger_than_rows") << (ItemList() |
1242 */ |
1363 << ItemDesc(0,0) |
|
1364 .minSize(QSizeF(50,300)) |
|
1365 .maxSize(QSizeF(50,300)) |
|
1366 .rowSpan(2) |
|
1367 << ItemDesc(0,1) |
|
1368 .minSize(QSizeF(50,0)) |
|
1369 .preferredSize(QSizeF(50,50)) |
|
1370 .maxSize(QSize(50, 1000)) |
|
1371 << ItemDesc(1,1) |
|
1372 .minSize(QSizeF(50,0)) |
|
1373 .preferredSize(QSizeF(50,50)) |
|
1374 .maxSize(QSize(50, 1000)) |
|
1375 ) |
|
1376 << QSizeF(100, 300) |
|
1377 << QSizeF(100, 300) |
|
1378 << QSizeF(100, 2000); |
|
1379 |
|
1380 QTest::newRow("rowSpan_smaller_than_rows") << (ItemList() |
|
1381 << ItemDesc(0,0) |
|
1382 .minSize(QSizeF(50, 0)) |
|
1383 .preferredSize(QSizeF(50, 50)) |
|
1384 .maxSize(QSizeF(50, 300)) |
|
1385 .rowSpan(2) |
|
1386 << ItemDesc(0,1) |
|
1387 .minSize(QSizeF(50, 50)) |
|
1388 .preferredSize(QSizeF(50, 50)) |
|
1389 .maxSize(QSize(50, 50)) |
|
1390 << ItemDesc(1,1) |
|
1391 .minSize(QSizeF(50, 50)) |
|
1392 .preferredSize(QSizeF(50, 50)) |
|
1393 .maxSize(QSize(50, 50)) |
|
1394 ) |
|
1395 << QSizeF(100, 100) |
|
1396 << QSizeF(100, 100) |
|
1397 << QSizeF(100, 100); |
|
1398 |
1243 } |
1399 } |
1244 |
1400 |
1245 // public QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const |
1401 // public QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const |
1246 void tst_QGraphicsGridLayout::sizeHint() |
1402 void tst_QGraphicsGridLayout::sizeHint() |
1247 { |
1403 { |
1248 /* |
1404 QFETCH(ItemList, itemDescriptions); |
1249 QFETCH(Qt::SizeHint, which); |
1405 QFETCH(QSizeF, expectedMinimumSizeHint); |
1250 QFETCH(QSizeF, constraint); |
1406 QFETCH(QSizeF, expectedPreferredSizeHint); |
1251 QFETCH(QSizeF, sizeHint); |
1407 QFETCH(QSizeF, expectedMaximumSizeHint); |
1252 |
1408 |
1253 QGraphicsGridLayout layout; |
1409 QGraphicsScene scene; |
1254 |
1410 QGraphicsView view(&scene); |
1255 layout.sizeHint(); |
1411 QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window); |
1256 */ |
1412 QGraphicsGridLayout *layout = new QGraphicsGridLayout; |
1257 QSKIP("Test unimplemented", SkipSingle); |
1413 scene.addItem(widget); |
|
1414 widget->setLayout(layout); |
|
1415 layout->setContentsMargins(0, 0, 0, 0); |
|
1416 layout->setSpacing(0.0); |
|
1417 widget->setContentsMargins(0, 0, 0, 0); |
|
1418 |
|
1419 int i; |
|
1420 for (i = 0; i < itemDescriptions.count(); ++i) { |
|
1421 ItemDesc desc = itemDescriptions.at(i); |
|
1422 RectWidget *item = new RectWidget(widget); |
|
1423 desc.apply(layout, item); |
|
1424 } |
|
1425 |
|
1426 QApplication::sendPostedEvents(0, 0); |
|
1427 |
|
1428 widget->show(); |
|
1429 view.show(); |
|
1430 view.resize(400,300); |
|
1431 QCOMPARE(layout->sizeHint(Qt::MinimumSize), expectedMinimumSizeHint); |
|
1432 QCOMPARE(layout->sizeHint(Qt::PreferredSize), expectedPreferredSizeHint); |
|
1433 QCOMPARE(layout->sizeHint(Qt::MaximumSize), expectedMaximumSizeHint); |
|
1434 |
1258 } |
1435 } |
1259 |
1436 |
1260 void tst_QGraphicsGridLayout::verticalSpacing_data() |
1437 void tst_QGraphicsGridLayout::verticalSpacing_data() |
1261 { |
1438 { |
1262 QTest::addColumn<qreal>("verticalSpacing"); |
1439 QTest::addColumn<qreal>("verticalSpacing"); |
1371 //If layout is 0, the widget is left without a layout. Existing subwidgets' geometries will remain unaffected. |
1548 //If layout is 0, the widget is left without a layout. Existing subwidgets' geometries will remain unaffected. |
1372 QCOMPARE(textEdit->geometry(), r1); |
1549 QCOMPARE(textEdit->geometry(), r1); |
1373 QCOMPARE(pushButton->geometry(), r2); |
1550 QCOMPARE(pushButton->geometry(), r2); |
1374 } |
1551 } |
1375 |
1552 |
1376 struct ItemDesc |
|
1377 { |
|
1378 ItemDesc(int row, int col) |
|
1379 : m_pos(qMakePair(row, col)), |
|
1380 m_rowSpan(1), |
|
1381 m_colSpan(1), |
|
1382 m_sizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred)), |
|
1383 m_align(0) |
|
1384 { |
|
1385 } |
|
1386 |
|
1387 ItemDesc &rowSpan(int span) { |
|
1388 m_rowSpan = span; |
|
1389 return (*this); |
|
1390 } |
|
1391 |
|
1392 ItemDesc &colSpan(int span) { |
|
1393 m_colSpan = span; |
|
1394 return (*this); |
|
1395 } |
|
1396 |
|
1397 ItemDesc &sizePolicy(const QSizePolicy &sp) { |
|
1398 m_sizePolicy = sp; |
|
1399 return (*this); |
|
1400 } |
|
1401 |
|
1402 ItemDesc &sizePolicy(QSizePolicy::Policy horAndVer) { |
|
1403 m_sizePolicy = QSizePolicy(horAndVer, horAndVer); |
|
1404 return (*this); |
|
1405 } |
|
1406 |
|
1407 ItemDesc &sizePolicyH(QSizePolicy::Policy hor) { |
|
1408 m_sizePolicy.setHorizontalPolicy(hor); |
|
1409 return (*this); |
|
1410 } |
|
1411 |
|
1412 ItemDesc &sizePolicyV(QSizePolicy::Policy ver) { |
|
1413 m_sizePolicy.setVerticalPolicy(ver); |
|
1414 return (*this); |
|
1415 } |
|
1416 |
|
1417 ItemDesc &sizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver) { |
|
1418 m_sizePolicy = QSizePolicy(hor, ver); |
|
1419 return (*this); |
|
1420 } |
|
1421 |
|
1422 ItemDesc &sizeHint(Qt::SizeHint which, const QSizeF &sh) { |
|
1423 m_sizeHints[which] = sh; |
|
1424 return (*this); |
|
1425 } |
|
1426 |
|
1427 ItemDesc &preferredSizeHint(const QSizeF &sh) { |
|
1428 m_sizeHints[Qt::PreferredSize] = sh; |
|
1429 return (*this); |
|
1430 } |
|
1431 |
|
1432 ItemDesc &minSize(const QSizeF &sz) { |
|
1433 m_sizes[Qt::MinimumSize] = sz; |
|
1434 return (*this); |
|
1435 } |
|
1436 ItemDesc &preferredSize(const QSizeF &sz) { |
|
1437 m_sizes[Qt::PreferredSize] = sz; |
|
1438 return (*this); |
|
1439 } |
|
1440 ItemDesc &maxSize(const QSizeF &sz) { |
|
1441 m_sizes[Qt::MaximumSize] = sz; |
|
1442 return (*this); |
|
1443 } |
|
1444 |
|
1445 ItemDesc &alignment(Qt::Alignment alignment) { |
|
1446 m_align = alignment; |
|
1447 return (*this); |
|
1448 } |
|
1449 |
|
1450 void apply(QGraphicsGridLayout *layout, RectWidget *item) { |
|
1451 item->setSizePolicy(m_sizePolicy); |
|
1452 for (int i = 0; i < Qt::NSizeHints; ++i) { |
|
1453 item->setSizeHint((Qt::SizeHint)i, m_sizeHints[i]); |
|
1454 if (!m_sizes[i].isValid()) |
|
1455 continue; |
|
1456 switch ((Qt::SizeHint)i) { |
|
1457 case Qt::MinimumSize: |
|
1458 item->setMinimumSize(m_sizes[i]); |
|
1459 break; |
|
1460 case Qt::PreferredSize: |
|
1461 item->setPreferredSize(m_sizes[i]); |
|
1462 break; |
|
1463 case Qt::MaximumSize: |
|
1464 item->setMaximumSize(m_sizes[i]); |
|
1465 break; |
|
1466 default: |
|
1467 qWarning("not implemented"); |
|
1468 break; |
|
1469 } |
|
1470 } |
|
1471 layout->addItem(item, m_pos.first, m_pos.second, m_rowSpan, m_colSpan); |
|
1472 layout->setAlignment(item, m_align); |
|
1473 } |
|
1474 |
|
1475 //private: |
|
1476 QPair<int,int> m_pos; // row,col |
|
1477 int m_rowSpan; |
|
1478 int m_colSpan; |
|
1479 QSizePolicy m_sizePolicy; |
|
1480 QSizeF m_sizeHints[Qt::NSizeHints]; |
|
1481 QSizeF m_sizes[Qt::NSizeHints]; |
|
1482 Qt::Alignment m_align; |
|
1483 }; |
|
1484 |
|
1485 typedef QList<ItemDesc> ItemList; |
|
1486 Q_DECLARE_METATYPE(ItemList); |
|
1487 |
|
1488 typedef QList<QSizeF> SizeList; |
|
1489 Q_DECLARE_METATYPE(SizeList); |
|
1490 |
|
1491 void tst_QGraphicsGridLayout::defaultStretchFactors_data() |
1553 void tst_QGraphicsGridLayout::defaultStretchFactors_data() |
1492 { |
1554 { |
1493 QTest::addColumn<ItemList>("itemDescriptions"); |
1555 QTest::addColumn<ItemList>("itemDescriptions"); |
1494 QTest::addColumn<QSizeF>("newSize"); |
1556 QTest::addColumn<QSizeF>("newSize"); |
1495 QTest::addColumn<SizeList>("expectedSizes"); |
1557 QTest::addColumn<SizeList>("expectedSizes"); |