QtBase  v6.3.1
tst_qgraphicsanchorlayout1.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see https://www.qt.io/terms-conditions. For further
15 ** information use the contact form at https://www.qt.io/contact-us.
16 **
17 ** GNU General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU
19 ** General Public License version 3 as published by the Free Software
20 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
21 ** included in the packaging of this file. Please review the following
22 ** information to ensure the GNU General Public License requirements will
23 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
24 **
25 ** $QT_END_LICENSE$
26 **
27 ****************************************************************************/
28 
29 #include <QtGui>
30 #include <QTest>
31 #include <QTest>
32 #include <QMetaType>
33 #include <QtWidgets/qgraphicsanchorlayout.h>
34 #include <private/qgraphicsanchorlayout_p.h>
35 
36 #define TEST_COMPLEX_CASES
37 
38 
39 //---------------------- AnchorLayout helper class ----------------------------
40 class TheAnchorLayout : public QGraphicsAnchorLayout
41 {
42 public:
43  TheAnchorLayout() : QGraphicsAnchorLayout()
44  {
45  setContentsMargins( 0,0,0,0 );
46  setSpacing( 0 );
47  }
48 
49  bool isValid()
50  {
51  return !QGraphicsAnchorLayoutPrivate::get(this)->hasConflicts();
52  }
53 
54  void setAnchor(
55  QGraphicsLayoutItem *startItem,
56  Qt::AnchorPoint startEdge,
57  QGraphicsLayoutItem *endItem,
58  Qt::AnchorPoint endEdge,
59  qreal value)
60  {
61  QGraphicsAnchor *anchor = addAnchor( startItem, startEdge, endItem, endEdge);
62  if (anchor)
63  anchor->setSpacing(value);
64  }
65 
66  int indexOf(const QGraphicsLayoutItem* item) const
67  {
68  for ( int i=0; i< count(); i++) {
69  if ( itemAt(i) == item ) {
70  return i;
71  }
72  }
73  return -1;
74  }
75 
76  void removeItem(QGraphicsLayoutItem* item)
77  {
78  removeAt(indexOf(item));
79  }
80 
81  void removeAnchor(
82  QGraphicsLayoutItem *startItem,
83  Qt::AnchorPoint startEdge,
84  QGraphicsLayoutItem *endItem,
85  Qt::AnchorPoint endEdge)
86  {
87  delete QGraphicsAnchorLayout::anchor(startItem, startEdge, endItem, endEdge);
88  }
89 };
90 //-----------------------------------------------------------------------------
91 
92 
93 struct BasicLayoutTestData
94 {
95  inline BasicLayoutTestData(
96  int index1, Qt::AnchorPoint edge1,
97  int index2, Qt::AnchorPoint edge2,
98  qreal distance)
99  : firstIndex(index1), firstEdge(edge1),
100  secondIndex(index2), secondEdge(edge2),
101  spacing(distance)
102  {
103  }
104 
105  int firstIndex;
106  Qt::AnchorPoint firstEdge;
107  int secondIndex;
108  Qt::AnchorPoint secondEdge;
109  qreal spacing;
110 };
111 
112 struct AnchorItemSizeHint
113 {
114  inline AnchorItemSizeHint(
115  qreal hmin, qreal hpref, qreal hmax,
116  qreal vmin, qreal vpref, qreal vmax )
117  : hmin(hmin), hpref(hpref), hmax(hmax), vmin(vmin), vpref(vpref), vmax(vmax)
118  {
119  }
120  qreal hmin, hpref, hmax;
121  qreal vmin, vpref, vmax;
122 };
123 
124 // some test results
125 
126 struct BasicLayoutTestResult
127 {
128  inline BasicLayoutTestResult(
129  int resultIndex, const QRectF& resultRect )
130  : index(resultIndex), rect(resultRect)
131  {
132  }
133 
134  int index;
135  QRectF rect;
136 };
137 
138 typedef QList<BasicLayoutTestData> BasicLayoutTestDataList;
139 Q_DECLARE_METATYPE(BasicLayoutTestDataList)
140 
141 typedef QList<BasicLayoutTestResult> BasicLayoutTestResultList;
142 Q_DECLARE_METATYPE(BasicLayoutTestResultList)
143 
144 typedef QList<AnchorItemSizeHint> AnchorItemSizeHintList;
145 Q_DECLARE_METATYPE(AnchorItemSizeHintList)
146 
147 
148 //---------------------- Test Widget used on all tests ------------------------
149 class TestWidget : public QGraphicsWidget
150 {
151 public:
152  inline TestWidget(QGraphicsItem *parent = nullptr, const QString &name = QString())
153  : QGraphicsWidget(parent)
154  {
155  setContentsMargins( 0,0,0,0 );
156  if (name.isEmpty())
157  setData(0, QLatin1Char('w') + QString::number(quintptr(this)));
158  else
159  setData(0, name);
160  }
161  ~TestWidget()
162  {
163  }
164 
165 protected:
166  QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const override;
167 };
168 
169 QSizeF TestWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
170 {
171  Q_UNUSED( constraint );
172  if (which == Qt::MinimumSize) {
173  return QSizeF(5,5);
174  }
175 
176  if (which == Qt::PreferredSize) {
177  return QSizeF(50,50);
178  }
179 
180  return QSizeF(500,500);
181 }
182 //-----------------------------------------------------------------------------
183 
184 
185 
186 //----------------------------- Test class ------------------------------------
187 class tst_QGraphicsAnchorLayout1 : public QObject
188 {
189  Q_OBJECT
190 
191 private slots:
192  void testCount();
193 
194  void testRemoveAt();
195  void testRemoveItem();
196 
197  void testItemAt();
198  void testIndexOf();
199 
200  void testAddAndRemoveAnchor();
201  void testIsValid();
202  void testSpecialCases();
203 
204  void testBasicLayout_data();
205  void testBasicLayout();
206 
207  void testNegativeSpacing_data();
208  void testNegativeSpacing();
209 
210  void testMixedSpacing_data();
211  void testMixedSpacing();
212 
213  void testMulti_data();
214  void testMulti();
215 
216  void testCenterAnchors_data();
217  void testCenterAnchors();
218 
219  void testRemoveCenterAnchor_data();
220  void testRemoveCenterAnchor();
221 
222  void testSingleSizePolicy_data();
223  void testSingleSizePolicy();
224 
225  void testDoubleSizePolicy_data();
226  void testDoubleSizePolicy();
227 
228  void testSizeDistribution_data();
229  void testSizeDistribution();
230 
231  void testSizeHint();
232 
233 #ifdef TEST_COMPLEX_CASES
234  void testComplexCases_data();
235  void testComplexCases();
236 #endif
237 };
238 
239 
240 void tst_QGraphicsAnchorLayout1::testCount()
241 {
242  QGraphicsWidget *widget = new QGraphicsWidget;
243 
244  TheAnchorLayout *layout = new TheAnchorLayout();
245  QVERIFY( layout->count() == 0 );
246 
247  TestWidget *widget1 = new TestWidget();
248  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
249  QCOMPARE( layout->count(), 1 );
250 
251  // adding one more anchor for already added widget should not increase the count
252  layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, 1);
253  QCOMPARE( layout->count(), 1 );
254 
255  // create one more widget and attach with anchor layout
256  TestWidget *widget2 = new TestWidget();
257  layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 1);
258  QCOMPARE( layout->count(), 2 );
259 
260  widget->setLayout(layout);
261  delete widget;
262 }
263 
264 void tst_QGraphicsAnchorLayout1::testRemoveAt()
265 {
266  TheAnchorLayout *layout = new TheAnchorLayout();
267  QVERIFY( layout->count() == 0 );
268 
269  TestWidget *widget1 = new TestWidget();
270  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 2);
271  QVERIFY( layout->count() == 1 );
272 
273  TestWidget *widget2 = new TestWidget();
274  layout->setAnchor(widget2, Qt::AnchorLeft, layout, Qt::AnchorLeft, 0.1);
275  QVERIFY( layout->count() == 2 );
276 
277  layout->removeAt(0);
278  QVERIFY( layout->count() == 1 );
279 
280  layout->removeAt(-55);
281  layout->removeAt(55);
282  QVERIFY( layout->count() == 1 );
283 
284  layout->removeAt(0);
285  QVERIFY( layout->count() == 0 );
286 
287  delete layout;
288  delete widget1;
289  delete widget2;
290 }
291 
292 void tst_QGraphicsAnchorLayout1::testRemoveItem()
293 {
294  TheAnchorLayout *layout = new TheAnchorLayout();
295  QCOMPARE( layout->count(), 0 );
296 
297  TestWidget *widget1 = new TestWidget();
298  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 2);
299  QCOMPARE( layout->count(), 1 );
300 
301  TestWidget *widget2 = new TestWidget();
302  layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);
303  QCOMPARE( layout->count(), 2 );
304 
305  layout->removeItem(0);
306  QCOMPARE( layout->count(), 2 );
307 
308  layout->removeItem(widget1);
309  QCOMPARE( layout->count(), 1 );
310  QCOMPARE( layout->indexOf(widget1), -1 );
311  QCOMPARE( layout->indexOf(widget2), 0 );
312 
313  layout->removeItem(widget1);
314  QCOMPARE( layout->count(), 1 );
315 
316  layout->removeItem(widget2);
317  QVERIFY( layout->count() == 0 );
318 
319  delete layout;
320  delete widget1;
321  delete widget2;
322 }
323 
324 void tst_QGraphicsAnchorLayout1::testItemAt()
325 {
326  QGraphicsWidget *widget = new QGraphicsWidget;
327 
328  TheAnchorLayout *layout = new TheAnchorLayout();
329 
330  TestWidget *widget1 = new TestWidget();
331  TestWidget *widget2 = new TestWidget();
332  TestWidget *widget3 = new TestWidget();
333  TestWidget *widget4 = new TestWidget();
334 
335  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
336  layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);
337  layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 0.1);
338  layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);
339 
340  QVERIFY( layout->itemAt(0) == widget1 );
341 
342  layout->removeAt(0);
343 
344  QVERIFY( layout->itemAt(0) == widget2 );
345 
346  delete widget1;
347 
348  widget->setLayout(layout);
349  delete widget;
350 }
351 
352 void tst_QGraphicsAnchorLayout1::testIndexOf()
353 {
354  QGraphicsWidget *widget = new QGraphicsWidget;
355 
356  TheAnchorLayout *layout = new TheAnchorLayout();
357 
358  TestWidget *widget1 = new TestWidget();
359  TestWidget *widget2 = new TestWidget();
360  TestWidget *widget3 = new TestWidget();
361  TestWidget *widget4 = new TestWidget();
362 
363  QCOMPARE( layout->indexOf(widget1), -1 );
364 
365  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
366  layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);
367  layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 0.1);
368 
369  QCOMPARE( layout->indexOf(widget4), -1 );
370  layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);
371 
372  QCOMPARE( layout->count(), 4 );
373  for (int i = 0; i < layout->count(); ++i) {
374  QCOMPARE(layout->indexOf(layout->itemAt(i)), i);
375  }
376 
377  QCOMPARE( layout->indexOf(0), -1 );
378  widget->setLayout(layout);
379  delete widget;
380 }
381 
382 void tst_QGraphicsAnchorLayout1::testAddAndRemoveAnchor()
383 {
384  QGraphicsWidget *widget = new QGraphicsWidget;
385 
386  TheAnchorLayout *layout = new TheAnchorLayout();
387 
388  TestWidget *widget1 = new TestWidget();
389  TestWidget *widget2 = new TestWidget();
390  TestWidget *widget3 = new TestWidget();
391  TestWidget *widget4 = new TestWidget();
392  TestWidget *widget5 = new TestWidget();
393 
394  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
395  layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.5);
396  layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 10);
397  layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);
398  QCOMPARE( layout->count(), 4 );
399 
400  // test setting invalid anchors
401  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor NULL items");
402  layout->setAnchor(0, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
403  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor NULL items");
404  layout->setAnchor(layout, Qt::AnchorLeft, 0, Qt::AnchorLeft, 1);
405  QCOMPARE( layout->count(), 4 );
406 
407  // test removing invalid anchors
408  layout->removeAnchor(widget4, Qt::AnchorRight, widget1, Qt::AnchorRight);
409 
410  // anchor one horizontal edge with vertical edge. it should not add this widget as a child
411  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
412  layout->setAnchor(layout, Qt::AnchorLeft, widget5, Qt::AnchorTop, 10);
413  QCOMPARE( layout->count(), 4 );
414 
415  // anchor two edges of a widget (to define width / height)
416  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
417  layout->setAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight, 10);
418  // QCOMPARE( layout->count(), 5 );
419  QCOMPARE( layout->count(), 4 );
420 
421  // anchor yet new widget properly
422  layout->setAnchor(layout, Qt::AnchorRight, widget5, Qt::AnchorRight, 20 );
423  QCOMPARE( layout->count(), 5 );
424 
425  // remove anchor for widget1. widget1 should be removed from layout since the
426  // last anchor was removed.
427  layout->removeAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft);
428 
429  QCOMPARE( layout->count(), 4 );
430  QVERIFY( !widget1->parentLayoutItem() );
431 
432  // test that item is not removed from layout if other anchors remain set
433  layout->setAnchor(widget2, Qt::AnchorLeft, widget3, Qt::AnchorRight, 10);
434  layout->removeAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft);
435  QCOMPARE( layout->count(), 4 );
436 
437  // remove all the anchors
438  layout->removeAnchor(widget2, Qt::AnchorLeft, widget3, Qt::AnchorRight);
439  layout->removeAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft);
440  layout->removeAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft);
441  layout->removeAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight);
442  layout->removeAnchor(layout, Qt::AnchorRight, widget5, Qt::AnchorRight);
443 
444  QCOMPARE( layout->count(), 0 );
445 
446  // set one anchor "another way round" to get full coverage for "removeAnchor"
447  layout->setAnchor(widget1, Qt::AnchorLeft, layout, Qt::AnchorLeft, 0.1);
448  layout->removeAnchor(widget1, Qt::AnchorLeft, layout, Qt::AnchorLeft);
449 
450  QCOMPARE( layout->count(), 0 );
451 
452  delete widget1;
453  delete widget2;
454  delete widget3;
455  delete widget4;
456  delete widget5;
457 
458  widget->setLayout(layout);
459  delete widget;
460 }
461 
462 void tst_QGraphicsAnchorLayout1::testIsValid()
463 {
464  // Empty, valid
465  {
466  QGraphicsWidget *widget = new QGraphicsWidget;
467  TheAnchorLayout *layout = new TheAnchorLayout();
468  widget->setLayout(layout);
469  widget->setGeometry(QRectF(0,0,100,100));
470 
471  QCOMPARE(layout->isValid(), true);
472  delete widget;
473  }
474 
475  // One widget, valid
476  {
477  QGraphicsWidget *widget = new QGraphicsWidget;
478  TheAnchorLayout *layout = new TheAnchorLayout();
479 
480  TestWidget *widget1 = new TestWidget();
481 
482  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
483  layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 0.1);
484  layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 0.1);
485  layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 0.1);
486 
487  widget->setLayout(layout);
488 
489  widget->setGeometry(QRectF(0,0,100,100));
490  QCOMPARE(layout->isValid(), true);
491  delete widget;
492  }
493 
494  // Overconstrained one widget, invalid
495  // ### Our understanding is that this case is valid. What happens though,
496  // is that the layout minimum and maximum vertical size hints become
497  // the same, 10.1. That means its height is fixed.
498  // What will "fail" then is the "setGeometry(0, 0, 100, 100)" call,
499  // after which the layout geometry will be (0, 0, 100, 10.1).
500 
501  {
502  QGraphicsWidget *widget = new QGraphicsWidget;
503  TheAnchorLayout *layout = new TheAnchorLayout();
504 
505  TestWidget *widget1 = new TestWidget();
506 
507  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
508  layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 0.1);
509  layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 0.1);
510  layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 0.1);
511 
512  layout->setAnchor(widget1, Qt::AnchorTop, layout, Qt::AnchorBottom, 10);
513 
514  widget->setLayout(layout);
515 
516  widget->setGeometry(QRectF(0,0,100,100));
517  QCOMPARE(layout->isValid(), true);
518  delete widget;
519  }
520 
521  // Underconstrained two widgets, valid
522  {
523  QGraphicsWidget *widget = new QGraphicsWidget;
524  TheAnchorLayout *layout = new TheAnchorLayout();
525 
526  TestWidget *widget1 = new TestWidget();
527  TestWidget *widget2 = new TestWidget();
528 
529  // Vertically the layout has floating items. Therefore, we have a conflict
530  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
531  layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, -0.1);
532 
533  // Horizontally the layout has floating items. Therefore, we have a conflict
534  layout->setAnchor(layout, Qt::AnchorTop, widget2, Qt::AnchorTop, 0.1);
535  layout->setAnchor(layout, Qt::AnchorBottom, widget2, Qt::AnchorBottom, -0.1);
536 
537  widget->setLayout(layout);
538 
539  widget->setGeometry(QRectF(0,0,100,100));
540  QCOMPARE(layout->isValid(), false);
541  delete widget;
542  }
543 }
544 
545 void tst_QGraphicsAnchorLayout1::testSpecialCases()
546 {
547  // One widget, setLayout before defining layouts
548  {
549  if (QLibraryInfo::isDebugBuild())
550  QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
551  " in wrong parent; moved to correct parent");
552  QGraphicsWidget *widget = new QGraphicsWidget;
553  TheAnchorLayout *layout = new TheAnchorLayout();
554  widget->setLayout(layout);
555 
556  TestWidget *widget1 = new TestWidget();
557 
558  layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
559  layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
560  layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
561  layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
562  widget->setGeometry(QRectF(0,0,100,100));
563  QCOMPARE(widget1->geometry(), QRectF(1,1,98,98));
564  delete widget1;
565  delete widget;
566  }
567 
568  // One widget, layout inside layout, layout inside layout inside layout
569  {
570  if (QLibraryInfo::isDebugBuild())
571  QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
572  " in wrong parent; moved to correct parent");
573  QGraphicsWidget *widget = new QGraphicsWidget;
574  TheAnchorLayout *layout = new TheAnchorLayout();
575  widget->setLayout(layout);
576 
577  TheAnchorLayout *layout1 = new TheAnchorLayout();
578  TestWidget *widget1 = new TestWidget();
579  layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
580  layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
581  layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
582  layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
583 
584  TheAnchorLayout *layout2 = new TheAnchorLayout();
585  TestWidget *widget2 = new TestWidget();
586  layout2->setAnchor(layout2, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 1);
587  layout2->setAnchor(layout2, Qt::AnchorTop, widget2, Qt::AnchorTop, 1);
588  layout2->setAnchor(widget2, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
589  layout2->setAnchor(widget2, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
590 
591  layout1->setAnchor(layout1, Qt::AnchorLeft, layout2, Qt::AnchorLeft, 1);
592  layout1->setAnchor(layout1, Qt::AnchorTop, layout2, Qt::AnchorTop, 1);
593  layout1->setAnchor(layout2, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
594  layout1->setAnchor(layout2, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
595 
596  layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
597  layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
598  layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
599  layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
600 
601  // remove and add again to improve test coverage.
602  layout->removeItem(layout1);
603 
604  layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
605  layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
606  layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
607  layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
608 
609  widget->setGeometry(QRectF(0,0,100,100));
610  QCOMPARE(widget1->geometry(), QRectF(2,2,96,96));
611  QCOMPARE(widget2->geometry(), QRectF(3,3,94,94));
612  delete widget;
613  }
614 
615  // One widget, layout inside layout, setLayout after layout definition
616  {
617  QGraphicsWidget *widget = new QGraphicsWidget;
618  TheAnchorLayout *layout = new TheAnchorLayout();
619 
620  TheAnchorLayout *layout1 = new TheAnchorLayout();
621 
622  TestWidget *widget1 = new TestWidget();
623  layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
624  layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
625  layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
626  layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
627 
628  layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
629  layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
630  layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
631  layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
632 
633  widget->setLayout(layout);
634  widget->setGeometry(QRectF(0,0,100,100));
635  QCOMPARE(widget1->geometry(), QRectF(2,2,96,96));
636  delete widget;
637  }
638 
639  // One widget, layout inside layout, setLayout after layout definition, widget transferred from
640  // one layout to another
641  {
642  QGraphicsWidget *widget = new QGraphicsWidget;
643  TheAnchorLayout *layout = new TheAnchorLayout();
644  widget->setLayout(layout);
645 
646  TheAnchorLayout *layout1 = new TheAnchorLayout();
647  TestWidget *widget1 = new TestWidget();
648 
649  // Additional layout + widget to improve coverage.
650  TheAnchorLayout *layout0 = new TheAnchorLayout();
651  TestWidget *widget0 = new TestWidget();
652 
653  // widget0 to layout0
654  layout0->setAnchor(layout0, Qt::AnchorLeft, widget0, Qt::AnchorLeft, 1);
655  layout0->setAnchor(layout0, Qt::AnchorTop, widget0, Qt::AnchorTop, 1);
656  layout0->setAnchor(widget0, Qt::AnchorRight, layout0, Qt::AnchorRight, 1);
657  layout0->setAnchor(widget0, Qt::AnchorBottom, layout0, Qt::AnchorBottom, 1);
658 
659  // layout0 to layout
660  layout->setAnchor(layout, Qt::AnchorLeft, layout0, Qt::AnchorLeft, 1);
661  layout->setAnchor(layout, Qt::AnchorTop, layout0, Qt::AnchorTop, 1);
662  layout->setAnchor(layout0, Qt::AnchorRight, layout, Qt::AnchorRight, 50);
663  layout->setAnchor(layout0, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
664 
665  // widget1 to layout1
666  layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
667  layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
668  layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
669  layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
670 
671  // layout1 to layout
672  layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
673  layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
674  layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 50);
675  layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
676 
677  TheAnchorLayout *layout2 = new TheAnchorLayout();
678 
679  // layout2 to layout
680  layout->setAnchor(layout, Qt::AnchorLeft, layout2, Qt::AnchorLeft, 50);
681  layout->setAnchor(layout, Qt::AnchorTop, layout2, Qt::AnchorTop, 1);
682  layout->setAnchor(layout2, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
683  layout->setAnchor(layout2, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
684 
685  // transfer widget1 to layout2
686  layout2->setAnchor(layout2, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
687  layout2->setAnchor(layout2, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
688  layout2->setAnchor(widget1, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
689  layout2->setAnchor(widget1, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
690 
691  widget->setGeometry(QRectF(0,0,100,100));
692  QCOMPARE(widget1->geometry(), QRectF(51,2,47,96));
693  delete widget;
694  }
695 
696  // One widget, set first to one layout then to another. Child reparented.
697  // In addition widget as a direct child of another widget. Child reparented.
698  {
699  QGraphicsWidget *widget1 = new QGraphicsWidget;
700  TheAnchorLayout *layout1 = new TheAnchorLayout();
701  widget1->setLayout(layout1);
702 
703  TestWidget *childWidget = new TestWidget();
704 
705  // childWidget to layout1
706  layout1->setAnchor(layout1, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 1);
707  layout1->setAnchor(layout1, Qt::AnchorTop, childWidget, Qt::AnchorTop, 1);
708  layout1->setAnchor(childWidget, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
709  layout1->setAnchor(childWidget, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
710 
711  widget1->setGeometry(QRectF(0,0,100,100));
712  QCOMPARE(childWidget->geometry(), QRectF(1,1,98,98));
713  QCOMPARE(childWidget->parentLayoutItem(), layout1);
714  QGraphicsWidget *widget2 = new QGraphicsWidget;
715  TheAnchorLayout *layout2 = new TheAnchorLayout();
716  widget2->setLayout(layout2);
717 
718  // childWidget to layout2
719  layout2->setAnchor(layout2, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 1);
720  layout2->setAnchor(layout2, Qt::AnchorTop, childWidget, Qt::AnchorTop, 1);
721  layout2->setAnchor(childWidget, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
722  layout2->setAnchor(childWidget, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
723 
724  QGraphicsWidget *widget3 = new QGraphicsWidget;
725  QGraphicsWidget *widget4 = new QGraphicsWidget;
726  // widget4 is a direct child of widget3 (i.e. not in any layout)
727  widget4->setParentItem(widget3);
728 
729  // widget4 to layout2
730  layout2->setAnchor(layout2, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 1);
731  layout2->setAnchor(layout2, Qt::AnchorTop, widget4, Qt::AnchorTop, 1);
732  layout2->setAnchor(widget4, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
733  layout2->setAnchor(widget4, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
734 
735  widget2->setGeometry(QRectF(0,0,100,100));
736  QCOMPARE(childWidget->geometry(), QRectF(1,1,98,98));
737  QCOMPARE(childWidget->parentLayoutItem(), layout2);
738  QCOMPARE(widget4->geometry(), QRectF(1,1,98,98));
739  QCOMPARE(widget4->parentLayoutItem(), layout2);
740  QCOMPARE(widget4->parentItem(), widget2);
741 
742  delete widget4;
743  delete widget3;
744  delete widget1;
745  delete childWidget;
746  delete widget2;
747  }
748 }
749 
750 void tst_QGraphicsAnchorLayout1::testBasicLayout_data()
751 {
752  QTest::addColumn<QSizeF>("size");
753  QTest::addColumn<BasicLayoutTestDataList>("data");
754  QTest::addColumn<BasicLayoutTestResultList>("result");
755 
756  typedef BasicLayoutTestData BasicData;
757  typedef BasicLayoutTestResult BasicResult;
758 
759  // One widget, basic
760  {
761  BasicLayoutTestDataList theData;
762  BasicLayoutTestResultList theResult;
763 
764  theData
765  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
766  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
767  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 30)
768  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 40)
769  ;
770 
771  theResult
772  << BasicResult(0, QRectF(20, 10, 150, 50) )
773  ;
774 
775  QTest::newRow("One, simple") << QSizeF(200, 100) << theData << theResult;
776  }
777 
778  // One widget, duplicates
779  {
780  BasicLayoutTestDataList theData;
781  BasicLayoutTestResultList theResult;
782 
783  theData
784  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
785  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
786  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 30)
787  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 40)
788 
789  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
790  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
791  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 0)
792  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
793  ;
794 
795  theResult
796  << BasicResult(0, QRectF(0, 0, 200, 100) )
797  ;
798 
799  QTest::newRow("One, duplicates") << QSizeF(200, 100) << theData << theResult;
800  }
801 
802  // One widget, mixed
803  {
804  BasicLayoutTestDataList theData;
805  BasicLayoutTestResultList theResult;
806 
807  theData
808  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 80)
809  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 150)
810  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorRight, 150)
811  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorBottom, 80)
812  ;
813 
814  theResult
815  << BasicResult(0, QRectF(50, 20, 100, 60) )
816  ;
817 
818  QTest::newRow("One, mixed") << QSizeF(200, 100) << theData << theResult;
819  }
820 
821  // Basic case - two widgets (same layout), different ordering
822  {
823  BasicLayoutTestDataList theData;
824  BasicLayoutTestResultList theResult;
825 
826  theData
827  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
828  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
829  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
830  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
831 
832  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
833  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
834  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
835  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
836  ;
837 
838  theResult
839  << BasicResult(0, QRectF(10, 10, 180, 80) )
840  << BasicResult(1, QRectF(10, 10, 180, 80) )
841  ;
842 
843  QTest::newRow("Two, orderings") << QSizeF(200, 100) << theData << theResult;
844  }
845 
846  // Basic case - two widgets, duplicate anchors
847  {
848  BasicLayoutTestDataList theData;
849  BasicLayoutTestResultList theResult;
850 
851  theData
852  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
853  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
854  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
855  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
856  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 30)
857  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
858 
859  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
860  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
861  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
862  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
863  << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
864  << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
865  ;
866 
867  theResult
868  << BasicResult(0, QRectF(30, 10, 160, 70) )
869  << BasicResult(1, QRectF(10, 0, 190, 90) )
870  ;
871 
872  QTest::newRow("Two, duplicates") << QSizeF(200, 100) << theData << theResult;
873  }
874 
875  // Basic case - two widgets, mixed
876  {
877  BasicLayoutTestDataList theData;
878  BasicLayoutTestResultList theResult;
879 
880  theData
881  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 90)
882  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 190)
883  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorRight, 190)
884  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorBottom, 90)
885 
886  << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorBottom, 20)
887  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
888  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
889  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 20)
890  ;
891 
892  theResult
893  << BasicResult(0, QRectF(10, 10, 180, 80) )
894  << BasicResult(1, QRectF(10, 80, 10, 10) )
895  ;
896 
897  QTest::newRow("Two, mixed") << QSizeF(200, 100) << theData << theResult;
898  }
899 
900  // Basic case - two widgets, 1 horizontal connection, first completely defined
901  {
902  BasicLayoutTestDataList theData;
903  BasicLayoutTestResultList theResult;
904 
905  theData
906  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
907  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
908  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
909  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
910 
911  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
912  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
913  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
914  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
915  ;
916 
917  theResult
918  << BasicResult(0, QRectF(10, 10, 10, 80) )
919  << BasicResult(1, QRectF(30, 10, 160, 70) )
920  ;
921 
922  QTest::newRow("Two, 1h connected") << QSizeF(200, 100) << theData << theResult;
923  }
924 
925  // Basic case - two widgets, 2 horizontal connections, first completely defined
926  {
927  BasicLayoutTestDataList theData;
928  BasicLayoutTestResultList theResult;
929 
930  theData
931  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
932  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
933  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
934  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
935 
936  // ### QGAL is not sensible to the argument order in this case
937  // To achieve the desired result we must explicitly set a negative
938  // spacing.
939  // << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, 100)
940  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, -100)
941 
942  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 30)
943  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
944  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
945  ;
946 
947  theResult
948  << BasicResult(0, QRectF(10, 10, 10, 80) )
949  << BasicResult(1, QRectF(50, 10, 60, 70) )
950  ;
951 
952  QTest::newRow("Two, 2h connected") << QSizeF(200, 100) << theData << theResult;
953  }
954 
955  // Basic case - two widgets, 1 vertical connection, first completely defined
956  {
957  BasicLayoutTestDataList theData;
958  BasicLayoutTestResultList theResult;
959 
960  theData
961  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
962  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
963  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
964  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
965 
966  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 30)
967  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
968  << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
969  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
970  ;
971 
972  theResult
973  << BasicResult(0, QRectF(10, 10, 10, 80) )
974  << BasicResult(1, QRectF(30, 20, 160, 60) )
975  ;
976 
977  QTest::newRow("Two, 1v connected") << QSizeF(200, 100) << theData << theResult;
978  }
979 
980  // Basic case - two widgets, 2 vertical connections, first completely defined
981  {
982  BasicLayoutTestDataList theData;
983  BasicLayoutTestResultList theResult;
984 
985  theData
986  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
987  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
988  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
989  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
990 
991  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 30)
992  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
993  << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
994  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 20)
995  ;
996 
997  theResult
998  << BasicResult(0, QRectF(10, 10, 10, 80) )
999  << BasicResult(1, QRectF(30, 20, 160, 50) )
1000  ;
1001 
1002  QTest::newRow("Two, 2v connected") << QSizeF(200, 100) << theData << theResult;
1003  }
1004 
1005  // Basic case - two widgets, 1 horizontal and 1 vertical connection, first completely defined
1006  {
1007  BasicLayoutTestDataList theData;
1008  BasicLayoutTestResultList theResult;
1009 
1010  theData
1011  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
1012  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
1013  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
1014  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
1015 
1016  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 80)
1017  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 100)
1018  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
1019  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 10)
1020  ;
1021 
1022  theResult
1023  << BasicResult(0, QRectF(10, 10, 10, 80) )
1024  << BasicResult(1, QRectF(80, 10, 40, 70) )
1025  ;
1026 
1027  QTest::newRow("Two, 1h+1v connected") << QSizeF(200, 100) << theData << theResult;
1028  }
1029 
1030  // Basic case - two widgets, 2 horizontal and 2 vertical connections, first completely defined
1031  {
1032  BasicLayoutTestDataList theData;
1033  BasicLayoutTestResultList theResult;
1034 
1035  theData
1036  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
1037  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
1038  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
1039  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
1040 
1041  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 80)
1042  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 100)
1043  << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
1044  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 10)
1045  ;
1046 
1047  theResult
1048  << BasicResult(0, QRectF(10, 10, 10, 80) )
1049  << BasicResult(1, QRectF(90, 20, 30, 60) )
1050  ;
1051 
1052  QTest::newRow("Two, 2h+2v connected") << QSizeF(200, 100) << theData << theResult;
1053  }
1054 
1055  // Basic case - two widgets, 2 horizontal and 2 vertical connections, dependent on each other.
1056  {
1057  BasicLayoutTestDataList theData;
1058  BasicLayoutTestResultList theResult;
1059 
1060  theData
1061  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
1062  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 150)
1063  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
1064  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 10)
1065 
1066  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 90)
1067  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
1068  << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
1069  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
1070  ;
1071 
1072  theResult
1073  << BasicResult(0, QRectF(10, 10, 30, 60) )
1074  << BasicResult(1, QRectF(100, 20, 90, 60) )
1075  ;
1076 
1077  QTest::newRow("Two, 2h+2v connected2") << QSizeF(200, 100) << theData << theResult;
1078  }
1079 
1080  // Basic case - two widgets, connected, overlapping
1081  {
1082  BasicLayoutTestDataList theData;
1083  BasicLayoutTestResultList theResult;
1084 
1085  theData
1086  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
1087  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
1088  // << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, 30)
1089  // ### QGAL has different semantics and assumes right edges are always
1090  // to the left of left edges. Thus we need the minus sign here.
1091  << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -30)
1092  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 40)
1093 
1094  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 40)
1095  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
1096  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
1097  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
1098  ;
1099 
1100  theResult
1101  << BasicResult(0, QRectF(10, 10, 60, 40) )
1102  << BasicResult(1, QRectF(40, 20, 150, 70) )
1103  ;
1104 
1105  QTest::newRow("Two, connected overlapping") << QSizeF(200, 100) << theData << theResult;
1106  }
1107 }
1108 
1109 void tst_QGraphicsAnchorLayout1::testNegativeSpacing_data()
1110 {
1111  QTest::addColumn<QSizeF>("size");
1112  QTest::addColumn<BasicLayoutTestDataList>("data");
1113  QTest::addColumn<BasicLayoutTestResultList>("result");
1114 
1115  typedef BasicLayoutTestData BasicData;
1116  typedef BasicLayoutTestResult BasicResult;
1117 
1118  // One widget, negative spacing
1119  {
1120  BasicLayoutTestDataList theData;
1121  BasicLayoutTestResultList theResult;
1122 
1124  // In this case, the negative spacing would make the item
1125  // grow beyond the layout edges, which is OK, but gives a
1126  // different result.
1127  // Changing the direction of anchors (-1 to 0 or vice-versa)
1128  // has no effect in this case.
1129 
1130  theData
1131  // << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1132  // << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -20)
1133  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -30)
1134  // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -40)
1135 
1136  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, -10)
1137  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, -20)
1138  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, -30)
1139  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, -40)
1140 
1141  ;
1142 
1143  theResult
1144  // << BasicResult(0, QRectF(20, 10, 150, 50) )
1145  << BasicResult(0, QRectF(-20, -10, 250, 150) )
1146  ;
1147 
1148  QTest::newRow("One, simple (n)") << QSizeF(200, 100) << theData << theResult;
1149  }
1150 
1151  // One widget, duplicates, negative spacing
1152  {
1153  BasicLayoutTestDataList theData;
1154  BasicLayoutTestResultList theResult;
1155 
1156  theData
1157  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -20)
1158  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -20)
1159  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -30)
1160  << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -40)
1161 
1162  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1163  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
1164  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -10)
1165  << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
1166  ;
1167 
1168  theResult
1169  // ### Same as above...
1170  // << BasicResult(0, QRectF(10, 10, 180, 80) )
1171  << BasicResult(0, QRectF(-10, -10, 220, 120) )
1172  ;
1173 
1174  QTest::newRow("One, duplicates (n)") << QSizeF(200, 100) << theData << theResult;
1175  }
1176 
1177  // One widget, mixed, negative spacing
1178  {
1179  BasicLayoutTestDataList theData;
1180  BasicLayoutTestResultList theResult;
1181 
1182  theData
1183  // ### All anchors of negative spacing between the layout and an
1184  // item are handled as to make sure the item is _outside_ the
1185  // layout.
1186  // To keep it inside, one _must_ use positive spacings.
1187  // << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorTop, -80)
1188  // << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorLeft, -150)
1189  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorLeft, -150)
1190  // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorTop, -80)
1191 
1192  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorTop, 80)
1193  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorLeft, 150)
1194  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorLeft, 150)
1195  << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorTop, 80)
1196  ;
1197 
1198  theResult
1199  << BasicResult(0, QRectF(50, 20, 100, 60) )
1200  ;
1201 
1202  QTest::newRow("One, mixed (n)") << QSizeF(200, 100) << theData << theResult;
1203  }
1204 
1205  // Basic case - two widgets, 1 horizontal connection, first completely defined, negative spacing
1206  {
1207  BasicLayoutTestDataList theData;
1208  BasicLayoutTestResultList theResult;
1209 
1210  theData
1211  // << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1212  // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
1213  // << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
1214  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -180)
1215 
1216  // << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -10)
1217  // << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
1218  // << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1219  // << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
1220 
1221  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1222  << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
1223  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
1224  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 180)
1225 
1226  << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -10)
1227  << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
1228  << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1229  << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
1230 
1231  ;
1232 
1233  theResult
1234  // << BasicResult(0, QRectF(10, 10, 10, 80) )
1235  // << BasicResult(1, QRectF(30, 10, 160, 70) )
1236 
1237  << BasicResult(0, QRectF(-10, -10, 30, 120) )
1238  << BasicResult(1, QRectF(10, -10, 200, 130) )
1239  ;
1240 
1241  QTest::newRow("Two, 1h connected (n)") << QSizeF(200, 100) << theData << theResult;
1242  }
1243 
1244  // Basic case - two widgets, 2 horizontal and 2 vertical connections, dependent on each other, negative spacing
1245  {
1246  BasicLayoutTestDataList theData;
1247  BasicLayoutTestResultList theResult;
1248 
1249  theData
1250  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
1251  << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorRight, -150)
1252  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
1253  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
1254 
1255  << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorLeft, -90)
1256  << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
1257  << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorTop, -10)
1258  << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
1259  ;
1260 
1261  theResult
1262  // << BasicResult(0, QRectF(10, 10, 30, 60) )
1263  // << BasicResult(1, QRectF(100, 20, 90, 60) )
1264  << BasicResult(0, QRectF(-10, -10, 70, 120) )
1265  << BasicResult(1, QRectF(80, 0, 130, 120) )
1266  ;
1267 
1268  QTest::newRow("Two, 2h+2v connected2 (n)") << QSizeF(200, 100) << theData << theResult;
1269  }
1270 }
1271 
1272 void tst_QGraphicsAnchorLayout1::testMixedSpacing_data()
1273 {
1274  QTest::addColumn<QSizeF>("size");
1275  QTest::addColumn<BasicLayoutTestDataList>("data");
1276  QTest::addColumn<BasicLayoutTestResultList>("result");
1277 
1278  typedef BasicLayoutTestData BasicData;
1279  typedef BasicLayoutTestResult BasicResult;
1280 
1281  // Two widgets, partial overlapping
1282  {
1283  BasicLayoutTestDataList theData;
1284  BasicLayoutTestResultList theResult;
1285 
1286  theData
1287  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
1288  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -50)
1289  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 50)
1290  << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorRight, 15)
1291 
1292  // << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorBottom, 5)
1293  << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorBottom, -5)
1294  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, -10)
1295  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 20)
1296  << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -5)
1297  ;
1298 
1299  theResult
1300  // << BasicResult(0, QRectF(50, 10, 45, 40) )
1301  // << BasicResult(1, QRectF(40, 45, 40, 50) )
1302  << BasicResult(0, QRectF(-50, 10, 145, 40) )
1303  << BasicResult(1, QRectF(-60, 45, 140, 60) )
1304  ;
1305 
1306  QTest::newRow("Two, partial overlap") << QSizeF(100, 100) << theData << theResult;
1307  }
1308 
1309  // Two widgets, complete overlapping
1310  {
1311  BasicLayoutTestDataList theData;
1312  BasicLayoutTestResultList theResult;
1313 
1314  theData
1315  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 5)
1316  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
1317  << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
1318  << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 25)
1319 
1320  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
1321  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
1322  << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorRight, 50)
1323  << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
1324  ;
1325 
1326  theResult
1327  << BasicResult(0, QRectF(65, 5, 35, 35) )
1328  << BasicResult(1, QRectF(40, 5, 60, 35) )
1329  ;
1330 
1331  QTest::newRow("Two, complete overlap") << QSizeF(90, 45) << theData << theResult;
1332  }
1333 
1334  // Five widgets, v shaped, edges shared
1335  {
1336  BasicLayoutTestDataList theData;
1337  BasicLayoutTestResultList theResult;
1338 
1339  theData
1340  // edges shared
1341  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 0)
1342  << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 0)
1343  << BasicData(2, Qt::AnchorRight, 3, Qt::AnchorLeft, 0)
1344  << BasicData(3, Qt::AnchorRight, 4, Qt::AnchorLeft, 0)
1345  << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 0)
1346  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 0)
1347  << BasicData(3, Qt::AnchorBottom, 2, Qt::AnchorTop, 0)
1348  << BasicData(4, Qt::AnchorBottom, 3, Qt::AnchorTop, 0)
1349  << BasicData(0, Qt::AnchorBottom, 4, Qt::AnchorBottom, 0)
1350  << BasicData(1, Qt::AnchorBottom, 3, Qt::AnchorBottom, 0)
1351  << BasicData(0, Qt::AnchorTop, 4, Qt::AnchorTop, 0)
1352  << BasicData(1, Qt::AnchorTop, 3, Qt::AnchorTop, 0)
1353 
1354  // margins
1355  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 5)
1356  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 5)
1357  << BasicData(2, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
1358  // << BasicData(-1, Qt::AnchorRight, 4, Qt::AnchorRight, -5)
1359  << BasicData(-1, Qt::AnchorRight, 4, Qt::AnchorRight, 5)
1360 
1361  // additional details for exact size determination easily
1362  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 25)
1363  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 50)
1364  // << BasicData(-1, Qt::AnchorRight, 3, Qt::AnchorRight, -25)
1365  // << BasicData(-1, Qt::AnchorRight, 2, Qt::AnchorRight, -50)
1366  << BasicData(-1, Qt::AnchorRight, 3, Qt::AnchorRight, 25)
1367  << BasicData(-1, Qt::AnchorRight, 2, Qt::AnchorRight, 50)
1368  << BasicData(-1, Qt::AnchorTop, 3, Qt::AnchorBottom, 50)
1369  // << BasicData(-1, Qt::AnchorBottom, 3, Qt::AnchorTop, -50)
1370  << BasicData(-1, Qt::AnchorBottom, 3, Qt::AnchorTop, 50)
1371 
1372  ;
1373 
1374  theResult
1375  << BasicResult(0, QRectF(5,5,20,20))
1376  << BasicResult(1, QRectF(25,25,25,25))
1377  << BasicResult(2, QRectF(50,50,25,20))
1378  << BasicResult(3, QRectF(75,25,25,25))
1379  << BasicResult(4, QRectF(100,5,20,20))
1380  ;
1381 
1382  QTest::newRow("Five, V shape") << QSizeF(125, 75) << theData << theResult;
1383  }
1384 
1385  // ### The behavior is different in QGraphicsAnchorLayout. What happens here is
1386  // that when the above anchors are set, the layout size hints are changed.
1387  // In the example, the minimum item width is 5, thus the minimum layout width
1388  // becomes 105 (50 + 5 + 50). Once that size hint is set, trying to set
1389  // the widget size to (10, 10) is not possible because
1390  // QGraphicsWidget::setGeometry() will enforce the minimum is respected.
1391  if (0)
1392  // One widget, unsolvable
1393  {
1394  BasicLayoutTestDataList theData;
1395  BasicLayoutTestResultList theResult;
1396 
1397  theData
1398  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 50)
1399  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
1400  ;
1401  theResult
1402  << BasicResult(0, QRectF(0,0,0,0))
1403  ;
1404 
1405  QTest::newRow("One widget, unsolvable") << QSizeF(10, 10) << theData << theResult;
1406  }
1407 
1408  // Two widgets, one has fixed size
1409  {
1410  BasicLayoutTestDataList theData;
1411  BasicLayoutTestResultList theResult;
1412 
1413  theData
1414  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 50)
1415  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
1416  // not supported, use sizePolicy instead
1417  // << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorRight, 50)
1418 
1419  << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 50)
1420  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
1421  ;
1422  theResult
1423  << BasicResult(0, QRectF(50,0,50,50))
1424  << BasicResult(1, QRectF(50,0,50,50))
1425  ;
1426 
1427  QTest::newRow("Two widgets, one has fixed size") << QSizeF(150, 150) << theData << theResult;
1428  }
1429 }
1430 
1431 void tst_QGraphicsAnchorLayout1::testMulti_data()
1432 {
1433  QTest::addColumn<QSizeF>("size");
1434  QTest::addColumn<BasicLayoutTestDataList>("data");
1435  QTest::addColumn<BasicLayoutTestResultList>("result");
1436 
1437  typedef BasicLayoutTestData BasicData;
1438  typedef BasicLayoutTestResult BasicResult;
1439 
1440  // Multiple widgets, all overllapping
1441  {
1442  BasicLayoutTestDataList theData;
1443  BasicLayoutTestResultList theResult;
1444 
1445  const int n = 30;
1446  for ( int i = 0 ; i < n; i++ ) {
1447  theData
1448  << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, 20)
1449  << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, 10)
1450  // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -40)
1451  // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -30);
1452  << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, 40)
1453  << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, 30);
1454 
1455  theResult
1456  << BasicResult(i, QRectF(10, 20, 160, 40) );
1457  }
1458 
1459 
1460  QTest::newRow("Overlapping multi") << QSizeF(200, 100) << theData << theResult;
1461  }
1462 
1463  // Multiple widgets, linear order
1464  {
1465  BasicLayoutTestDataList theData;
1466  BasicLayoutTestResultList theResult;
1467 
1468  const qreal height = 1000.f;
1469  const qreal width = 2000.f;
1470 
1471  const int n = 30;
1472 
1473  const qreal verticalStep = height/qreal(n+2);
1474  const qreal horizontalStep = width/qreal(n+2);
1475 
1476  for ( int i = 0 ; i < n; i++ ) {
1477 
1478  if ( i == 0 ) {
1479  // First item
1480  theData
1481  << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1482  << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1483  << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1484  << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1485 
1486  } else if ( i == n-1 ) {
1487  // Last item
1488  theData
1489  << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1490  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1491  << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep)
1492  << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, horizontalStep);
1493  // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1494  // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1495 
1496  } else {
1497  // items in the middle
1498  theData
1499  << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1500  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1501  << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1502  << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1503  // << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1504  // << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1505 
1506  }
1507 
1508  theResult
1509  << BasicResult(i, QRectF((i+1)*horizontalStep, (i+1)*verticalStep, horizontalStep, verticalStep) );
1510  }
1511 
1512 
1513  if (sizeof(qreal) == 4) {
1514  qDebug("Linear multi: Skipping! (qreal has too little precision, result will be wrong)");
1515  } else {
1516  QTest::newRow("Linear multi") << QSizeF(width, height) << theData << theResult;
1517  }
1518  }
1519 
1520  // Multiple widgets, V shape
1521  {
1522  BasicLayoutTestDataList theData;
1523  BasicLayoutTestResultList theResult;
1524 
1525  const qreal height = 100.f;
1526  const qreal width = 200.f;
1527 
1528  const int n = 31; // odd number please (3,5,7... )
1529 
1530  const qreal verticalStep = height/(2.f+(n+1)/2.f);
1531  const qreal horizontalStep = width/(n+2.f);
1532 
1533  for ( int i = 0 ; i < n; i++ ) {
1534 
1535  if ( i == 0 ) {
1536  // First item
1537  theData
1538  << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1539  << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1540  << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1541  << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
1542 
1543  } else if ( i == n-1 ) {
1544  // Last item
1545  theData
1546  << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, -verticalStep)
1547  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1548  << BasicData(i-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1549  << BasicData(i, Qt::AnchorRight, -1, Qt::AnchorRight, horizontalStep);
1550  } else if ( i == ((n-1)/2) ) {
1551  // midway
1552  theData
1553  << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1554  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1555  // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1556  << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep)
1557  << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
1558  } else if ( i < ((n-1)/2) ) {
1559  // before midway - going down
1560  theData
1561  << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1562  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1563  << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1564  << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
1565 
1566  } else {
1567  // after midway - going up
1568  theData
1569  << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, -verticalStep)
1570  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1571  << BasicData(i-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1572  << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
1573 
1574  }
1575 
1576  if ( i <= ((n-1)/2) ) {
1577  // until midway
1578  theResult
1579  << BasicResult(i, QRectF((i+1)*horizontalStep, (i+1)*verticalStep, horizontalStep, verticalStep) );
1580  } else {
1581  // after midway
1582  theResult
1583  << BasicResult(i, QRectF((i+1)*horizontalStep, (n-i)*verticalStep, horizontalStep, verticalStep) );
1584  }
1585 
1586  }
1587  if (sizeof(qreal) == 4) {
1588  qDebug("V multi: Skipping! (qreal has too little precision, result will be wrong)");
1589  } else {
1590  QTest::newRow("V multi") << QSizeF(width, height) << theData << theResult;
1591  }
1592  }
1593 
1594  // Multiple widgets, grid
1595  {
1596  BasicLayoutTestDataList theData;
1597  BasicLayoutTestResultList theResult;
1598 
1599  const qreal height = 100.f;
1600  const qreal width = 200.f;
1601 
1602  const int d = 10; // items per dimension
1603  const int n = d*d;
1604 
1605  const qreal verticalStep = height/(d+2.f);
1606  const qreal horizontalStep = width/(d+2.f);
1607 
1608  for ( int i = 0 ; i < n; i++ ) {
1609  if ( i%d == 0 ) {
1610  // left side item
1611  theData
1612  << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1613  << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1614  } else if ( (i+1)%d == 0 ) {
1615  // rigth side item
1616  theData
1617  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1618  // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1619  << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, horizontalStep);
1620  } else {
1621  // horizontal middle
1622  theData
1623  << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
1624  << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
1625  }
1626 
1627  if ( i < d ) {
1628  // top line
1629  theData
1630  << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1631  << BasicData(i+d, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep);
1632  } else if ( i >= (d-1)*d ){
1633  // bottom line
1634  theData
1635  << BasicData(i-d, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1636  // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
1637  << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep);
1638  } else {
1639  // vertical middle
1640  theData
1641  << BasicData(i-d, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
1642  << BasicData(i+d, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep);
1643  }
1644 
1645  theResult
1646  << BasicResult(i, QRectF(((i%d)+1)*horizontalStep, ((i/d)+1)*verticalStep, horizontalStep, verticalStep) );
1647  }
1648 
1649  if (sizeof(qreal) == 4) {
1650  qDebug("Grid multi: Skipping! (qreal has too little precision, result will be wrong)");
1651  } else {
1652  QTest::newRow("Grid multi") << QSizeF(200, 100) << theData << theResult;
1653  }
1654  }
1655 }
1656 
1657 inline QGraphicsLayoutItem *getItem(
1658  int index,
1659  const QList<QGraphicsWidget *>& widgets,
1660  QGraphicsLayoutItem *defaultItem)
1661 {
1662  if (index < 0) {
1663  return defaultItem;
1664  }
1665 
1666  return widgets[index];
1667 }
1668 
1669 static bool fuzzierCompare(qreal a, qreal b)
1670 {
1671  return qAbs(a - b) <= qreal(0.0001);
1672 }
1673 
1674 static bool fuzzierCompare(const QRectF &r1, const QRectF &r2)
1675 {
1676 
1677  return fuzzierCompare(r1.x(), r2.x()) && fuzzierCompare(r1.y(), r2.y())
1678  && fuzzierCompare(r1.width(), r2.width()) && fuzzierCompare(r1.height(), r2.height());
1679 }
1680 
1681 void tst_QGraphicsAnchorLayout1::testBasicLayout()
1682 {
1683  QFETCH(QSizeF, size);
1684  QFETCH(BasicLayoutTestDataList, data);
1685  QFETCH(BasicLayoutTestResultList, result);
1686 
1687  QGraphicsWidget *widget = new QGraphicsWidget;
1688 
1689  // Determine amount of widgets to add.
1690  int widgetCount = -1;
1691  for (int i = 0; i < data.count(); ++i) {
1692  const BasicLayoutTestData item = data[i];
1693  widgetCount = qMax(widgetCount, item.firstIndex);
1694  widgetCount = qMax(widgetCount, item.secondIndex);
1695  }
1696  ++widgetCount; // widgetCount is max of indices.
1697 
1698  // Create dummy widgets
1699  QList<QGraphicsWidget *> widgets;
1700  for (int i = 0; i < widgetCount; ++i)
1701  widgets << new TestWidget(0, QLatin1Char('W') + QString::number(i));
1702 
1703  // Setup anchor layout
1704  TheAnchorLayout *layout = new TheAnchorLayout;
1705 
1706  for (int i = 0; i < data.count(); ++i) {
1707  const BasicLayoutTestData item = data[i];
1708  layout->setAnchor(
1709  getItem(item.firstIndex, widgets, layout),
1710  item.firstEdge,
1711  getItem(item.secondIndex, widgets, layout),
1712  item.secondEdge,
1713  item.spacing );
1714  }
1715 
1716  widget->setLayout(layout);
1717  widget->setContentsMargins(0,0,0,0);
1718 
1719  widget->resize(size);
1720  QCOMPARE(widget->size(), size);
1721 
1722  // Validate
1723  for (int i = 0; i < result.count(); ++i) {
1724  const BasicLayoutTestResult item = result[i];
1725  QRectF expected = item.rect;
1726  QRectF actual = widgets[item.index]->geometry();
1727 
1728  QVERIFY(fuzzierCompare(actual, expected));
1729  }
1730 
1731  // Test mirrored mode
1732  widget->setLayoutDirection(Qt::RightToLeft);
1733  layout->activate();
1734  // Validate
1735  for (int j = 0; j < result.count(); ++j) {
1736  const BasicLayoutTestResult item = result[j];
1737  QRectF mirroredRect(item.rect);
1738  // only valid cases are mirrored
1739  if (mirroredRect.isValid()){
1740  mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
1741  }
1742  QRectF expected = mirroredRect;
1743  QRectF actual = widgets[item.index]->geometry();
1744 
1745  QVERIFY(fuzzierCompare(actual, expected));
1746  }
1747 
1748  qDeleteAll(widgets);
1749  delete widget;
1750 }
1751 
1752 void tst_QGraphicsAnchorLayout1::testNegativeSpacing()
1753 {
1754  // use the same frame
1755  testBasicLayout();
1756 }
1757 
1758 void tst_QGraphicsAnchorLayout1::testMixedSpacing()
1759 {
1760  // use the same frame
1761  testBasicLayout();
1762 }
1763 
1764 void tst_QGraphicsAnchorLayout1::testMulti()
1765 {
1766  // use the same frame
1767  testBasicLayout();
1768 }
1769 
1770 void tst_QGraphicsAnchorLayout1::testCenterAnchors_data()
1771 {
1772  QTest::addColumn<QSizeF>("size");
1773  QTest::addColumn<BasicLayoutTestDataList>("data");
1774  QTest::addColumn<BasicLayoutTestResultList>("result");
1775 
1776  typedef BasicLayoutTestData BasicData;
1777  typedef BasicLayoutTestResult BasicResult;
1778 
1779  // Basic center case
1780  {
1781  BasicLayoutTestDataList theData;
1782  BasicLayoutTestResultList theResult;
1783 
1784  theData
1785  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
1786  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
1787  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
1788  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
1789  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5);
1790 
1791  theResult
1792  << BasicResult(0, QRectF(5, 5, 10, 10) );
1793 
1794  QTest::newRow("center, basic") << QSizeF(20, 20) << theData << theResult;
1795  }
1796 
1797  // Basic center case, with invalid (shouldn't affect on result)
1798  {
1799  BasicLayoutTestDataList theData;
1800  BasicLayoutTestResultList theResult;
1801 
1802  theData
1803  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
1804  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
1805  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
1806  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
1807  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
1808 
1809  // bogus definitions
1810  << BasicData(0, Qt::AnchorHorizontalCenter, -1, Qt::AnchorBottom, 5)
1811  << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorVerticalCenter, 5)
1812  << BasicData(0, Qt::AnchorVerticalCenter, -1, Qt::AnchorRight, 5)
1813  << BasicData(0, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 666)
1814  << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 999)
1815  << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorLeft, 333)
1816  << BasicData(-1, Qt::AnchorRight, -1, Qt::AnchorRight, 222)
1817  << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorTop, 111)
1818  << BasicData(0, Qt::AnchorBottom, 0, Qt::AnchorBottom, 444);
1819 
1820  theResult
1821  << BasicResult(0, QRectF(5, 5, 10, 10) );
1822 
1823  QTest::newRow("center, basic with invalid") << QSizeF(20, 20) << theData << theResult;
1824  }
1825 
1826  // Basic center case 2
1827  {
1828  BasicLayoutTestDataList theData;
1829  BasicLayoutTestResultList theResult;
1830 
1831  theData
1832  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
1833  // Not supported << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
1834  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
1835  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 0)
1836  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, -5);
1837 
1838  theResult
1839  << BasicResult(0, QRectF(5, 5, 10, 10) );
1840 
1841  QTest::newRow("center, basic 2") << QSizeF(20, 20) << theData << theResult;
1842  }
1843 
1844  // Basic center case, overrides
1845  {
1846  BasicLayoutTestDataList theData;
1847  BasicLayoutTestResultList theResult;
1848 
1849  theData
1850  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 10)
1851  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 20)
1852  << BasicData(0, Qt::AnchorHorizontalCenter, -1, Qt::AnchorHorizontalCenter, 30)
1853  << BasicData(0, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 40)
1854  // actual data:
1855  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
1856  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 0)
1857  // << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
1858  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
1859  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, -5);
1860 
1861  theResult
1862  << BasicResult(0, QRectF(5, 5, 10, 10) );
1863 
1864  QTest::newRow("center, overrides") << QSizeF(20, 20) << theData << theResult;
1865  }
1866 
1867  // Two nested
1868  {
1869  BasicLayoutTestDataList theData;
1870  BasicLayoutTestResultList theResult;
1871 
1872  theData
1873  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorLeft, 0)
1874  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
1875  << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
1876  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 0)
1877  << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorTop, 0)
1878  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 0)
1879  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
1880  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 0);
1881 
1882  theResult
1883  << BasicResult(0, QRectF(20, 0, 20, 40))
1884  << BasicResult(1, QRectF(20, 20, 20, 20));
1885 
1886  QTest::newRow("center, two nested") << QSizeF(40, 40) << theData << theResult;
1887  }
1888 
1889  // Two overlap
1890  {
1891  BasicLayoutTestDataList theData;
1892  BasicLayoutTestResultList theResult;
1893 
1894  // theData
1895  // // horizontal
1896  // << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
1897  // << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 0)
1898  // << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, -5)
1899  // << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
1900  // << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 10)
1901  // // vertical is pretty much same as horizontal, just roles swapped
1902  // << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
1903  // << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, 0)
1904  // << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorBottom, -5)
1905  // << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
1906  // << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorBottom, 10);
1907 
1908  theData
1909  // horizontal
1910  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
1911  << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 0)
1912  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorHorizontalCenter, 5)
1913  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 20)
1914  // vertical
1915  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
1916  << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, 0)
1917  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorVerticalCenter, 5)
1918  << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 20);
1919 
1920  theResult
1921  << BasicResult(0, QRectF(20, 30, 20, 30))
1922  << BasicResult(1, QRectF(30, 20, 30, 20));
1923 
1924  QTest::newRow("center, two overlap") << QSizeF(70, 70) << theData << theResult;
1925  }
1926 
1927  // Three
1928  {
1929  BasicLayoutTestDataList theData;
1930  BasicLayoutTestResultList theResult;
1931 
1932  theData
1933  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
1934  << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorHorizontalCenter, 75)
1935  << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
1936  << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -30)
1937  << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 0)
1938  << BasicData(1, Qt::AnchorLeft, 1, Qt::AnchorRight, 30)
1939  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
1940 
1941  << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
1942  << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 35)
1943  << BasicData(1, Qt::AnchorVerticalCenter, 2, Qt::AnchorVerticalCenter, 15)
1944  << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 5)
1945  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
1946  << BasicData(2, Qt::AnchorBottom, 0, Qt::AnchorTop, 5)
1947  << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 20);
1948 
1949  theResult
1950  << BasicResult(0, QRectF(0, 30, 10, 20))
1951  << BasicResult(1, QRectF(20, 0, 30, 10))
1952  << BasicResult(2, QRectF(60, 15, 40, 10));
1953 
1954  QTest::newRow("center, three") << QSizeF(100, 50) << theData << theResult;
1955  }
1956 
1957  // Two, parent center
1958  {
1959  BasicLayoutTestDataList theData;
1960  BasicLayoutTestResultList theResult;
1961 
1962  theData
1963  // vertical is pretty much same as horizontal, just roles swapped
1964  << BasicData(-1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, -15)
1965  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 10)
1966  << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
1967  << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
1968  // horizontal
1969  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -15)
1970  << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 10)
1971  << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
1972  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 0);
1973 
1974  theResult
1975  << BasicResult(0, QRectF(20, 20, 30, 80))
1976  << BasicResult(1, QRectF(20, 20, 80, 30));
1977 
1978  QTest::newRow("center, parent") << QSizeF(100, 100) << theData << theResult;
1979  }
1980 
1981  // Two, parent center 2
1982  {
1983  BasicLayoutTestDataList theData;
1984  BasicLayoutTestResultList theResult;
1985 
1986  theData
1987  // << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorHorizontalCenter, 15)
1988  << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorHorizontalCenter, -15)
1989  << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorLeft, 10)
1990  << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 5)
1991  << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorRight, -5)
1992  // vertical
1993  << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 20)
1994  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
1995  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 20)
1996  << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
1997  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 10);
1998 
1999  theResult
2000  << BasicResult(0, QRectF(30, 10, 15, 10))
2001  << BasicResult(1, QRectF(10, 30, 10, 10));
2002 
2003  QTest::newRow("center, parent 2") << QSizeF(50, 50) << theData << theResult;
2004  }
2005 
2006  // Two, parent center 3
2007  {
2008  BasicLayoutTestDataList theData;
2009  BasicLayoutTestResultList theResult;
2010 
2011  theData
2012  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, -5)
2013  << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 5)
2014  // << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, 100)
2015  << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, -100)
2016  << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, 0)
2017 
2018  // vertical
2019  << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55)
2020  << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
2021  << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
2022  << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 10)
2023  // << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 45)
2024  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 45)
2025  ;
2026 
2027  theResult
2028  << BasicResult(0, QRectF(0, 0, 45, 45))
2029  << BasicResult(1, QRectF(55, 55, 45, 45));
2030 
2031  QTest::newRow("center, parent 3") << QSizeF(100, 100) << theData << theResult;
2032  }
2033 
2034 }
2035 
2036 void tst_QGraphicsAnchorLayout1::testCenterAnchors()
2037 {
2038  if (strcmp(QTest::currentDataTag(), "center, basic with invalid") == 0) {
2039  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
2040  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
2041  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
2042  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2043  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2044  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2045  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2046  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2047  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2048  } else if (strcmp(QTest::currentDataTag(), "center, three") == 0) {
2049  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2050  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2051  }
2052 
2053  // use the same frame
2054  testBasicLayout();
2055 }
2056 
2057 void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor_data()
2058 {
2059  QTest::addColumn<QSizeF>("size");
2060  QTest::addColumn<BasicLayoutTestDataList>("data");
2061  QTest::addColumn<BasicLayoutTestDataList>("removeData");
2062  QTest::addColumn<BasicLayoutTestResultList>("result");
2063 
2064  typedef BasicLayoutTestData BasicData;
2065  typedef BasicLayoutTestResult BasicResult;
2066 
2067  {
2068  BasicLayoutTestDataList theData;
2069  BasicLayoutTestDataList theRemoveData;
2070  BasicLayoutTestResultList theResult;
2071 
2072  theData
2073  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
2074  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
2075  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
2076  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
2077  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
2078 
2079  << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 66)
2080  << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 99)
2081  << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 33)
2082  ;
2083 
2084  theRemoveData
2085  << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 0)
2086  << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 0)
2087  << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 0);
2088 
2089  theResult
2090  << BasicResult(0, QRectF(5, 5, 10, 10) );
2091 
2092  QTest::newRow("remove, center, basic") << QSizeF(20, 20) << theData
2093  << theRemoveData << theResult;
2094  }
2095 
2096  {
2097  BasicLayoutTestDataList theData;
2098  BasicLayoutTestDataList theRemoveData;
2099  BasicLayoutTestResultList theResult;
2100 
2101  theData
2102  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
2103  << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorHorizontalCenter, 75)
2104  << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
2105  << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -30)
2106  << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 0)
2107  << BasicData(1, Qt::AnchorLeft, 1, Qt::AnchorRight, 30)
2108  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
2109 
2110  // extra:
2111  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 66)
2112  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 33)
2113  << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 55)
2114  << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55)
2115 
2116  << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
2117  << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 35)
2118  << BasicData(1, Qt::AnchorVerticalCenter, 2, Qt::AnchorVerticalCenter, 15)
2119  << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 5)
2120  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
2121  << BasicData(2, Qt::AnchorBottom, 0, Qt::AnchorTop, 5)
2122  << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 20);
2123 
2124  theRemoveData
2125  << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 66)
2126  << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 33)
2127  << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 55)
2128  << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55);
2129 
2130  theResult
2131  << BasicResult(0, QRectF(0, 30, 10, 20))
2132  << BasicResult(1, QRectF(20, 0, 30, 10))
2133  << BasicResult(2, QRectF(60, 15, 40, 10));
2134 
2135  QTest::newRow("remove, center, three") << QSizeF(100, 50) << theData << theRemoveData << theResult;
2136  }
2137 
2138  // add edge (item0,edge0,item1,edge1), remove (item1,edge1,item0,edge0)
2139  {
2140  BasicLayoutTestDataList theData;
2141  BasicLayoutTestDataList theRemoveData;
2142  BasicLayoutTestResultList theResult;
2143 
2144  theData
2145  // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
2146  << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
2147  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
2148  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
2149  << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
2150 
2151  << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 66)
2152  << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 99)
2153  << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 33)
2154  << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorRight, 22)
2155  << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 11)
2156  ;
2157 
2158  theRemoveData
2159  << BasicData(1, Qt::AnchorHorizontalCenter, -1, Qt::AnchorHorizontalCenter, 0)
2160  << BasicData(-1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 0)
2161  << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
2162  << BasicData(0, Qt::AnchorRight, 0, Qt::AnchorLeft, 0)
2163  << BasicData(0, Qt::AnchorBottom, 0, Qt::AnchorTop, 0)
2164  ;
2165 
2166  theResult
2167  << BasicResult(0, QRectF(5, 5, 10, 10) );
2168 
2169  QTest::newRow("remove, center, basic 2") << QSizeF(20, 20) << theData
2170  << theRemoveData << theResult;
2171  }
2172 
2173 }
2174 
2175 void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor()
2176 {
2177  if (strcmp(QTest::currentDataTag(), "remove, center, three") == 0) {
2178  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2179  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2180  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2181  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2182  } else if (strcmp(QTest::currentDataTag(), "remove, center, basic 2") == 0) {
2183  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2184  QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
2185  }
2186 
2187  QFETCH(QSizeF, size);
2188  QFETCH(BasicLayoutTestDataList, data);
2189  QFETCH(BasicLayoutTestDataList, removeData);
2190  QFETCH(BasicLayoutTestResultList, result);
2191 
2192  QGraphicsWidget *widget = new QGraphicsWidget;
2193 
2194  // Determine amount of widgets to add.
2195  int widgetCount = -1;
2196  for (int i = 0; i < data.count(); ++i) {
2197  const BasicLayoutTestData item = data[i];
2198  widgetCount = qMax(widgetCount, item.firstIndex);
2199  widgetCount = qMax(widgetCount, item.secondIndex);
2200  }
2201  ++widgetCount; // widgetCount is max of indices.
2202 
2203  // Create dummy widgets
2204  QList<QGraphicsWidget *> widgets;
2205  for (int i = 0; i < widgetCount; ++i) {
2206  TestWidget *w = new TestWidget;
2207  widgets << w;
2208  }
2209 
2210  // Setup anchor layout
2211  TheAnchorLayout *layout = new TheAnchorLayout;
2212 
2213  for (int i = 0; i < data.count(); ++i) {
2214  const BasicLayoutTestData item = data[i];
2215  layout->setAnchor(
2216  getItem(item.firstIndex, widgets, layout),
2217  item.firstEdge,
2218  getItem(item.secondIndex, widgets, layout),
2219  item.secondEdge,
2220  item.spacing );
2221  }
2222 
2223  for (int i = 0; i < removeData.count(); ++i) {
2224  const BasicLayoutTestData item = removeData[i];
2225  layout->removeAnchor(
2226  getItem(item.firstIndex, widgets, layout),
2227  item.firstEdge,
2228  getItem(item.secondIndex, widgets, layout),
2229  item.secondEdge);
2230  }
2231 
2232  widget->setLayout(layout);
2233  widget->setContentsMargins(0,0,0,0);
2234 
2235  widget->resize(size);
2236  QCOMPARE(widget->size(), size);
2237 
2238  // Validate
2239  for (int i = 0; i < result.count(); ++i) {
2240  const BasicLayoutTestResult item = result[i];
2241 
2242  QCOMPARE(widgets[item.index]->geometry(), item.rect);
2243  }
2244 
2245  qDeleteAll(widgets);
2246  delete widget;
2247 }
2248 
2249 void tst_QGraphicsAnchorLayout1::testSingleSizePolicy_data()
2250 {
2251  QTest::addColumn<QSizeF>("size");
2252  QTest::addColumn<QSizePolicy>("policy");
2253  QTest::addColumn<bool>("valid");
2254 
2255 // FIXED
2256  {
2257  QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
2258  QTest::newRow("single size policy: fixed ok") << QSizeF(70, 70) << sizePolicy << true;
2259  }
2260 /*
2261  {
2262  QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
2263  QTest::newRow("single size policy: fixed too big") << QSizeF(100, 100) << sizePolicy << false;
2264  }
2265 
2266  {
2267  QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
2268  QTest::newRow("single size policy: fixed too small") << QSizeF(50, 50) << sizePolicy << false;
2269  }
2270 */
2271 // MINIMUM
2272  {
2273  QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
2274  QTest::newRow("single size policy: minimum bigger ok") << QSizeF(100, 100) << sizePolicy << true;
2275  }
2276 
2277  {
2278  QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
2279  QTest::newRow("single size policy: minimum limit ok") << QSizeF(70, 70) << sizePolicy << true;
2280  }
2281 /*
2282  {
2283  QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
2284  QTest::newRow("single size policy: minimum too small") << QSizeF(50, 50) << sizePolicy << false;
2285  }
2286 */
2287 // MAXIMUM
2288  {
2289  QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
2290  QTest::newRow("single size policy: maximum small ok") << QSizeF(50, 50) << sizePolicy << true;
2291  }
2292 
2293  {
2294  QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
2295  QTest::newRow("single size policy: maximum limit ok") << QSizeF(70, 70) << sizePolicy << true;
2296  }
2297 /*
2298  {
2299  QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
2300  QTest::newRow("single size policy: maximum bigger fail") << QSizeF(100, 100) << sizePolicy << false;
2301  }
2302 */
2303 // PREFERRED
2304  {
2305  QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
2306  QTest::newRow("single size policy: preferred bigger ok") << QSizeF(100, 100) << sizePolicy << true;
2307  }
2308 
2309  {
2310  QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
2311  QTest::newRow("single size policy: preferred smaller ok") << QSizeF(50, 50) << sizePolicy << true;
2312  }
2313 /*
2314  {
2315  QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
2316  QTest::newRow("single size policy: preferred too big") << QSizeF(700, 700) << sizePolicy << false;
2317  }
2318 
2319  {
2320  QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
2321  QTest::newRow("single size policy: preferred too small") << QSizeF(21, 21) << sizePolicy << false;
2322  }
2323 */
2324 // MINIMUMEXPANDING
2325 
2326  {
2327  QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
2328  QTest::newRow("single size policy: min.expanding bigger ok") << QSizeF(100, 100) << sizePolicy << true;
2329  }
2330 
2331  {
2332  QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
2333  QTest::newRow("single size policy: min.expanding limit ok") << QSizeF(70, 70) << sizePolicy << true;
2334  }
2335 
2336  /*{
2337  QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
2338  QTest::newRow("single size policy: min.expanding too small") << QSizeF(50, 50) << sizePolicy << false;
2339  }*/
2340 
2341 // EXPANDING
2342 
2343  {
2344  QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
2345  QTest::newRow("single size policy: expanding bigger ok") << QSizeF(100, 100) << sizePolicy << true;
2346  }
2347 
2348  {
2349  QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
2350  QTest::newRow("single size policy: expanding smaller ok") << QSizeF(50, 50) << sizePolicy << true;
2351  }
2352 
2353  // IGNORED
2354 
2355  {
2356  QSizePolicy sizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
2357  QTest::newRow("single size policy: ignored bigger ok") << QSizeF(100, 100) << sizePolicy << true;
2358  }
2359 
2360  {
2361  QSizePolicy sizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
2362  QTest::newRow("single size policy: ignored smaller ok") << QSizeF(50, 50) << sizePolicy << true;
2363  }
2364 }
2365 
2366 void tst_QGraphicsAnchorLayout1::testSingleSizePolicy()
2367 {
2368  QFETCH(QSizeF, size);
2369  QFETCH(QSizePolicy, policy);
2370  QFETCH(bool, valid);
2371 
2372  // create objects
2373  QGraphicsWidget widget;
2374  TheAnchorLayout *layout = new TheAnchorLayout;
2375  TestWidget *childWidget = new TestWidget;
2376 
2377  // set anchors
2378  layout->setAnchor( layout, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 10 );
2379  layout->setAnchor( childWidget, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
2380  layout->setAnchor( layout, Qt::AnchorTop, childWidget, Qt::AnchorTop, 10 );
2381  layout->setAnchor( childWidget, Qt::AnchorBottom, layout, Qt::AnchorBottom, 10 );
2382 
2383  widget.setLayout( layout );
2384 
2385  // set test case specific: policy and size
2386  childWidget->setSizePolicy( policy );
2387  widget.setGeometry( QRectF( QPoint(0,0), size ) );
2388 
2389  QCOMPARE( layout->isValid() , valid );
2390 
2391  const QRectF childRect = childWidget->geometry();
2392  Q_UNUSED( childRect );
2393 }
2394 
2395 void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy_data()
2396 {
2397  // tests only horizontal direction
2398  QTest::addColumn<QSizePolicy>("policy1");
2399  QTest::addColumn<QSizePolicy>("policy2");
2400  QTest::addColumn<qreal>("width1");
2401  QTest::addColumn<qreal>("width2");
2402 
2403  // layout size always 100x100 and size hints for items are 5<50<500
2404  // gabs: 10-item1-10-item2-10
2405 
2406  {
2407  QSizePolicy sizePolicy1( QSizePolicy::Fixed, QSizePolicy::Fixed );
2408  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2409  const qreal width1 = 50;
2410  const qreal width2 = 100-10-10-10-width1;
2411  QTest::newRow("double size policy: fixed-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2412  }
2413 
2414  {
2415  QSizePolicy sizePolicy1( QSizePolicy::Minimum, QSizePolicy::Minimum );
2416  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2417  const qreal width1 = 50;
2418  const qreal width2 = 100-10-10-10-width1;
2419  QTest::newRow("double size policy: minimum-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2420  }
2421 
2422  {
2423  QSizePolicy sizePolicy1( QSizePolicy::Maximum, QSizePolicy::Maximum );
2424  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2425  const qreal width1 = 35;
2426  const qreal width2 = 100-10-10-10-width1;
2427  QTest::newRow("double size policy: maximum-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2428  }
2429 
2430  {
2431  QSizePolicy sizePolicy1( QSizePolicy::Preferred, QSizePolicy::Preferred );
2432  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2433  const qreal width1 = 35;
2434  const qreal width2 = 100-10-10-10-width1;
2435  QTest::newRow("double size policy: preferred-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2436  }
2437 
2438  {
2439  QSizePolicy sizePolicy1( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
2440  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2441  const qreal width1 = 50;
2442  const qreal width2 = 100-10-10-10-width1;
2443  QTest::newRow("double size policy: min.expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2444  }
2445 
2446  {
2447  QSizePolicy sizePolicy1( QSizePolicy::Expanding, QSizePolicy::Expanding );
2448  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2449  const qreal width1 = 35;
2450  const qreal width2 = 100-10-10-10-width1;
2451  QTest::newRow("double size policy: expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2452  }
2453 
2454  // QGAL handling of ignored flag is different
2455  if (0)
2456  {
2457  QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
2458  QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
2459  const qreal width1 = 35;
2460  const qreal width2 = 100-10-10-10-width1;
2461  QTest::newRow("double size policy: ignored-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
2462  }
2463 
2464  /*{
2465  QSizePolicy sizePolicy1( QSizePolicy::Fixed, QSizePolicy::Fixed );
2466  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2467  const qreal width1 = -1;
2468  const qreal width2 = 100-10-10-10-width1;
2469  QTest::newRow("double size policy: fixed-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
2470  }*/
2471 
2472  /*{
2473  QSizePolicy sizePolicy1( QSizePolicy::Minimum, QSizePolicy::Minimum );
2474  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2475  const qreal width1 = -1;
2476  const qreal width2 = 100-10-10-10-width1;
2477  QTest::newRow("double size policy: minimum-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
2478  }*/
2479 
2480  {
2481  QSizePolicy sizePolicy1( QSizePolicy::Maximum, QSizePolicy::Maximum );
2482  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2483  const qreal width1 = 20;
2484  const qreal width2 = 100-10-10-10-width1;
2485  QTest::newRow("double size policy: maximum-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
2486  }
2487 
2488  {
2489  QSizePolicy sizePolicy1( QSizePolicy::Preferred, QSizePolicy::Preferred );
2490  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2491  const qreal width1 = 20;
2492  const qreal width2 = 100-10-10-10-width1;
2493  QTest::newRow("double size policy: preferred-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
2494  }
2495 
2496  /*{
2497  QSizePolicy sizePolicy1( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
2498  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2499  const qreal width1 = -1;
2500  const qreal width2 = 100-10-10-10-width1;
2501  QTest::newRow("double size policy: min.expanding-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
2502  }*/
2503 
2504  {
2505  QSizePolicy sizePolicy1( QSizePolicy::Expanding, QSizePolicy::Expanding );
2506  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2507  const qreal width1 = 20;
2508  const qreal width2 = 100-10-10-10-width1;
2509  QTest::newRow("double size policy: expanding-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
2510  }
2511 
2512  {
2513  QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
2514  QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
2515  const qreal width1 = 20;
2516  const qreal width2 = 100-10-10-10-width1;
2517  QTest::newRow("double size policy: ignored-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
2518  }
2519 }
2520 
2521 void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy()
2522 {
2523  QFETCH(QSizePolicy, policy1);
2524  QFETCH(QSizePolicy, policy2);
2525  QFETCH(qreal, width1);
2526  QFETCH(qreal, width2);
2527 
2528  // create objects
2529  QGraphicsWidget widget;
2530  TheAnchorLayout *layout = new TheAnchorLayout;
2531  TestWidget *childWidget1 = new TestWidget;
2532  TestWidget *childWidget2 = new TestWidget;
2533 
2534  // set anchors
2535  layout->setAnchor( layout, Qt::AnchorLeft, childWidget1, Qt::AnchorLeft, 10 );
2536  layout->setAnchor( childWidget1, Qt::AnchorRight, childWidget2, Qt::AnchorLeft, 10 );
2537  layout->setAnchor( childWidget2, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
2538 
2539  widget.setLayout( layout );
2540 
2541  // set test case specific: policy
2542  childWidget1->setSizePolicy( policy1 );
2543  childWidget2->setSizePolicy( policy2 );
2544 
2545  widget.setGeometry( QRectF( QPoint(0,0), QSize( 100,100 ) ) );
2546 
2547  // check results:
2548  if ( width1 == -1.0f ) {
2549  // invalid
2550  QCOMPARE( layout->isValid() , false );
2551  } else {
2552  // valid
2553  QCOMPARE( childWidget1->geometry().width(), width1 );
2554  QCOMPARE( childWidget2->geometry().width(), width2 );
2555  }
2556 }
2557 
2558 typedef QMap<int,qreal> SizeHintArray;
2559 Q_DECLARE_METATYPE(SizeHintArray)
2560 
2561 void tst_QGraphicsAnchorLayout1::testSizeDistribution_data()
2562 {
2563  // tests only horizontal direction
2564  QTest::addColumn<SizeHintArray>("sizeHints1");
2565  QTest::addColumn<SizeHintArray>("sizeHints2");
2566  QTest::addColumn<qreal>("width1");
2567  QTest::addColumn<qreal>("width2");
2568 
2569  // layout size always 100x100 and size policy for items is preferred-preferred
2570  // gabs: 10-item1-10-item2-10
2571 
2572  {
2573  SizeHintArray sizeHints1;
2574  sizeHints1.insert( Qt::MinimumSize, 30 );
2575  sizeHints1.insert( Qt::PreferredSize, 35 );
2576  sizeHints1.insert( Qt::MaximumSize, 40 );
2577 
2578  SizeHintArray sizeHints2;
2579  sizeHints2.insert( Qt::MinimumSize, 5 );
2580  sizeHints2.insert( Qt::PreferredSize, 35 );
2581  sizeHints2.insert( Qt::MaximumSize, 300 );
2582 
2583  const qreal width1 = 35;
2584  const qreal width2 = 100-10-10-10-width1;
2585  QTest::newRow("size distribution: preferred equal") << sizeHints1 << sizeHints2 << width1 << width2;
2586  }
2587 
2588  {
2589  SizeHintArray sizeHints1;
2590  sizeHints1.insert( Qt::MinimumSize, 0 );
2591  sizeHints1.insert( Qt::PreferredSize, 20 );
2592  sizeHints1.insert( Qt::MaximumSize, 100 );
2593 
2594  SizeHintArray sizeHints2;
2595  sizeHints2.insert( Qt::MinimumSize, 0 );
2596  sizeHints2.insert( Qt::PreferredSize, 50 );
2597  sizeHints2.insert( Qt::MaximumSize, 100 );
2598 
2599  const qreal width1 = 20;
2600  const qreal width2 = 100-10-10-10-width1;
2601  QTest::newRow("size distribution: preferred non-equal") << sizeHints1 << sizeHints2 << width1 << width2;
2602  }
2603 
2604  {
2605  SizeHintArray sizeHints1;
2606  sizeHints1.insert( Qt::MinimumSize, 0 );
2607  sizeHints1.insert( Qt::PreferredSize, 40 );
2608  sizeHints1.insert( Qt::MaximumSize, 100 );
2609 
2610  SizeHintArray sizeHints2;
2611  sizeHints2.insert( Qt::MinimumSize, 0 );
2612  sizeHints2.insert( Qt::PreferredSize, 60 );
2613  sizeHints2.insert( Qt::MaximumSize, 100 );
2614 
2615  const qreal width1 = 28; // got from manual calculation
2616  const qreal width2 = 100-10-10-10-width1;
2617  QTest::newRow("size distribution: below preferred") << sizeHints1 << sizeHints2 << width1 << width2;
2618  }
2619 
2620  {
2621  SizeHintArray sizeHints1;
2622  sizeHints1.insert( Qt::MinimumSize, 0 );
2623  sizeHints1.insert( Qt::PreferredSize, 10 );
2624  sizeHints1.insert( Qt::MaximumSize, 100 );
2625 
2626  SizeHintArray sizeHints2;
2627  sizeHints2.insert( Qt::MinimumSize, 0 );
2628  sizeHints2.insert( Qt::PreferredSize, 40 );
2629  sizeHints2.insert( Qt::MaximumSize, 100 );
2630 
2631  const qreal width1 = 22; // got from manual calculation
2632  const qreal width2 = 100-10-10-10-width1;
2633  QTest::newRow("size distribution: above preferred") << sizeHints1 << sizeHints2 << width1 << width2;
2634  }
2635 
2636 }
2637 
2638 void tst_QGraphicsAnchorLayout1::testSizeDistribution()
2639 {
2640  QFETCH(SizeHintArray, sizeHints1);
2641  QFETCH(SizeHintArray, sizeHints2);
2642  QFETCH(qreal, width1);
2643  QFETCH(qreal, width2);
2644 
2645  // sanity-check the test data - MinimumSize <= PreferredSize <= MaximumSize
2646  QVERIFY( sizeHints1.value( Qt::MinimumSize ) <= sizeHints1.value( Qt::PreferredSize ) );
2647  QVERIFY( sizeHints1.value( Qt::PreferredSize ) <= sizeHints1.value( Qt::MaximumSize ) );
2648  QVERIFY( sizeHints2.value( Qt::MinimumSize ) <= sizeHints2.value( Qt::PreferredSize ) );
2649  QVERIFY( sizeHints2.value( Qt::PreferredSize ) <= sizeHints2.value( Qt::MaximumSize ) );
2650 
2651  // create objects
2652  QGraphicsWidget widget;
2653  TheAnchorLayout *layout = new TheAnchorLayout;
2654  TestWidget *childWidget1 = new TestWidget;
2655  TestWidget *childWidget2 = new TestWidget;
2656 
2657  // set anchors
2658  layout->setAnchor( layout, Qt::AnchorLeft, childWidget1, Qt::AnchorLeft, 10 );
2659  layout->setAnchor( childWidget1, Qt::AnchorRight, childWidget2, Qt::AnchorLeft, 10 );
2660  layout->setAnchor( childWidget2, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
2661 
2662  widget.setLayout( layout );
2663 
2664  // set test case specific: size hints
2665  childWidget1->setMinimumWidth( sizeHints1.value( Qt::MinimumSize ) );
2666  childWidget1->setPreferredWidth( sizeHints1.value( Qt::PreferredSize ) );
2667  childWidget1->setMaximumWidth( sizeHints1.value( Qt::MaximumSize ) );
2668 
2669  childWidget2->setMinimumWidth( sizeHints2.value( Qt::MinimumSize ) );
2670  childWidget2->setPreferredWidth( sizeHints2.value( Qt::PreferredSize ) );
2671  childWidget2->setMaximumWidth( sizeHints2.value( Qt::MaximumSize ) );
2672 
2673  widget.setGeometry( QRectF( QPoint(0,0), QSize( 100,100 ) ) );
2674 
2675  // check results:
2676  if ( width1 == -1.0f ) {
2677  // invalid
2678  QCOMPARE( layout->isValid() , false );
2679  } else {
2680  // valid
2681  QCOMPARE( float(childWidget1->geometry().width()), float(width1) );
2682  QCOMPARE( float(childWidget2->geometry().width()), float(width2) );
2683  }
2684 }
2685 
2686 void tst_QGraphicsAnchorLayout1::testSizeHint()
2687 {
2688  QGraphicsWidget *widget[5];
2689 
2690  for( int i = 0; i < 5; i++ ) {
2691  widget[i] = new QGraphicsWidget;
2692  widget[i]->setMinimumSize( 10, 10 );
2693  widget[i]->setPreferredSize( 20, 20 );
2694  widget[i]->setMaximumSize( 40, 40 );
2695  }
2696 
2697  // one, basic
2698  {
2699  TheAnchorLayout *layout = new TheAnchorLayout();
2700 
2701 
2702  layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
2703  layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 0 );
2704 
2705  layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
2706  layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
2707 
2708  QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() );
2709  QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() );
2710  QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() );
2711 
2712 
2713  delete layout;
2714  }
2715 
2716  // one, basic again
2717  {
2718  TheAnchorLayout *layout = new TheAnchorLayout();
2719 
2720 
2721  layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 10 );
2722  // layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, -10 );
2723  layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 10 );
2724 
2725  layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 10 );
2726  // layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, -10 );
2727  layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 10 );
2728 
2729  QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() + QSizeF( 20, 20 ) );
2730  QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() + QSizeF( 20, 20 ) );
2731  QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() + QSizeF( 20, 20 ) );
2732 
2733  delete layout;
2734  }
2735 
2736  // two, serial
2737  {
2738  TheAnchorLayout *layout = new TheAnchorLayout();
2739 
2740 
2741  layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
2742  layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
2743  layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
2744 
2745  layout->setAnchor(widget[0], Qt::AnchorRight, widget[1], Qt::AnchorLeft, 0 );
2746  layout->setAnchor(widget[1], Qt::AnchorRight, layout, Qt::AnchorRight, 0 );
2747 
2748 
2749  QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() + QSizeF( widget[1]->minimumWidth(), 0 ) );
2750  QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() + QSizeF( widget[1]->preferredWidth(), 0 ) );
2751  QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() + QSizeF( widget[1]->maximumWidth(), 0 ) );
2752 
2753  delete layout;
2754  }
2755 
2756  // two, parallel
2757  {
2758  TheAnchorLayout *layout = new TheAnchorLayout();
2759 
2760 
2761  layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
2762  layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
2763  layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
2764  layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 0 );
2765 
2766  layout->setAnchor(layout, Qt::AnchorLeft, widget[1], Qt::AnchorLeft, 0 );
2767  layout->setAnchor(layout, Qt::AnchorTop, widget[1], Qt::AnchorTop, 0 );
2768  layout->setAnchor(layout, Qt::AnchorBottom, widget[1], Qt::AnchorBottom, 0 );
2769  layout->setAnchor(layout, Qt::AnchorRight, widget[1], Qt::AnchorRight, 0 );
2770 
2771  QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() );
2772  QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() );
2773  QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() );
2774 
2775  delete layout;
2776  }
2777 
2778  // five, serial
2779  {
2780  TheAnchorLayout *layout = new TheAnchorLayout();
2781 
2782 
2783  layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
2784  layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
2785  layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
2786 
2787  layout->setAnchor(widget[0], Qt::AnchorRight, widget[1], Qt::AnchorLeft, 0 );
2788  layout->setAnchor(widget[1], Qt::AnchorRight, widget[2], Qt::AnchorLeft, 0 );
2789  layout->setAnchor(widget[2], Qt::AnchorRight, widget[3], Qt::AnchorLeft, 0 );
2790  layout->setAnchor(widget[3], Qt::AnchorRight, widget[4], Qt::AnchorLeft, 0 );
2791  layout->setAnchor(widget[4], Qt::AnchorRight, layout, Qt::AnchorRight, 0 );
2792 
2793 
2794  QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() +
2795  QSizeF( widget[1]->minimumWidth() +
2796  widget[2]->minimumWidth() +
2797  widget[3]->minimumWidth() +
2798  widget[4]->minimumWidth(), 0 ) );
2799 
2800  QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() +
2801  QSizeF( widget[1]->preferredWidth() +
2802  widget[2]->preferredWidth() +
2803  widget[3]->preferredWidth() +
2804  widget[4]->preferredWidth(), 0 ) );
2805 
2806  QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() +
2807  QSizeF( widget[1]->maximumWidth() +
2808  widget[2]->maximumWidth() +
2809  widget[3]->maximumWidth() +
2810  widget[4]->maximumWidth(), 0 ) );
2811 
2812  delete layout;
2813  }
2814 
2815 
2816  for( int i = 0; i < 5; i++ ) {
2817  delete widget[i];
2818  }
2819 }
2820 
2821 #ifdef TEST_COMPLEX_CASES
2822 
2823 void tst_QGraphicsAnchorLayout1::testComplexCases_data()
2824 {
2825  QTest::addColumn<QSizeF>("size");
2826  QTest::addColumn<BasicLayoutTestDataList>("data");
2827  QTest::addColumn<AnchorItemSizeHintList>("sizehint");
2828  QTest::addColumn<BasicLayoutTestResultList>("result");
2829 
2830  typedef BasicLayoutTestData BasicData;
2831  typedef BasicLayoutTestResult BasicResult;
2832 
2833  // Three widgets, the same sizehint
2834  {
2835  BasicLayoutTestDataList theData;
2836  AnchorItemSizeHintList theSizeHint;
2837  BasicLayoutTestResultList theResult1;
2838  BasicLayoutTestResultList theResult2;
2839 
2840  theData
2841  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
2842  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
2843  << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
2844 
2845  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2846  << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2847 
2848  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
2849  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
2850  << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
2851  ;
2852 
2853  theSizeHint
2854  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2855  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2856  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2857  ;
2858  theResult1
2859  << BasicResult(0, QRectF(10, 0, 30, 50) )
2860  << BasicResult(1, QRectF(50, 0, 30, 50) )
2861  << BasicResult(2, QRectF(50, 0, 30, 50) )
2862  ;
2863 
2864  theResult2
2865  << BasicResult(0, QRectF(10, 0, 60, 50) )
2866  << BasicResult(1, QRectF(80, 0, 60, 50) )
2867  << BasicResult(2, QRectF(80, 0, 60, 50) )
2868  ;
2869 
2870  QTest::newRow("Three, the same sizehint(1)") << QSizeF(90, 50) << theData << theSizeHint << theResult1;
2871  QTest::newRow("Three, the same sizehint(2)") << QSizeF(150, 50) << theData << theSizeHint << theResult2;
2872  }
2873 
2874  // Three widgets, serial is bigger
2875  {
2876  BasicLayoutTestDataList theData;
2877  AnchorItemSizeHintList theSizeHint;
2878  BasicLayoutTestResultList theResult;
2879 
2880  theData
2881  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
2882  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
2883  << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
2884 
2885  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2886  << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2887 
2888  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
2889  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
2890  << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
2891  ;
2892 
2893  theSizeHint
2894  << AnchorItemSizeHint( 0, 100, 200, 0, 50, 100 )
2895  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2896  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2897  ;
2898 
2899  theResult
2900  << BasicResult(0, QRectF(10, 0, 70, 50) )
2901  << BasicResult(1, QRectF(90, 0, 35, 50) )
2902  << BasicResult(2, QRectF(90, 0, 35, 50) );
2903 
2904  QTest::newRow("Three, serial is bigger") << QSizeF(135, 50) << theData << theSizeHint << theResult;
2905 
2906  // theResult
2907  // << BasicResult(0, QRectF(10, 0, 80, 50) )
2908  // << BasicResult(1, QRectF(100, 0, 60, 50) )
2909  // << BasicResult(2, QRectF(100, 0, 60, 50) )
2910  // ;
2911 
2912  // QTest::newRow("Three, serial is bigger") << QSizeF(170, 50) << theData << theSizeHint << theResult;
2913  }
2914 
2915 
2916  // Three widgets, parallel is bigger
2917  {
2918  BasicLayoutTestDataList theData;
2919  AnchorItemSizeHintList theSizeHint;
2920  BasicLayoutTestResultList theResult;
2921 
2922  theData
2923  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
2924  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
2925  << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
2926 
2927  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2928  << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2929 
2930  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
2931  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
2932  << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
2933  ;
2934 
2935  theSizeHint
2936  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2937  << AnchorItemSizeHint( 0, 100, 200, 0, 50, 100 )
2938  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
2939  ;
2940 
2941  // ### QGAL uses a different preferred size calculation algorithm.
2942  // This algorithm was discussed with Jan-Arve and tries to grow
2943  // items instead of shrinking them.
2944  // In this case, the preferred size of each item becomes:
2945  // Item 0: 50
2946  // Item 1: 100 (grows to avoid shrinking item 2)
2947  // Item 2: 100
2948  // Therefore, the preferred size of the parent widget becomes
2949  // 180 == (10 + 50 + 10 + 100 + 10)
2950  // As we set its size to 150, each widget is shrinked in the same
2951  // ratio, in order to achieve the width of 150 == (10 + 40 + 10 + 80 + 10)
2952 
2953  theResult
2954  << BasicResult(0, QRectF(10, 0, 40, 50) )
2955  << BasicResult(1, QRectF(60, 0, 80, 50) )
2956  << BasicResult(2, QRectF(60, 0, 80, 50) )
2957  ;
2958 
2959  QTest::newRow("Three, parallel is bigger") << QSizeF(150, 50) << theData << theSizeHint << theResult;
2960 
2961  // #ifdef PREFERRED_IS_AVERAGE
2962  // theResult
2963  // << BasicResult(0, QRectF(10, 0, 50, 50) )
2964  // << BasicResult(1, QRectF(70, 0, 75, 50) )
2965  // << BasicResult(2, QRectF(70, 0, 75, 50) )
2966  // ;
2967 
2968  // QTest::newRow("Three, parallel is bigger") << QSizeF(155, 50) << theData << theSizeHint << theResult;
2969  // #else
2970  // theResult
2971  // << BasicResult(0, QRectF(10, 0, 50, 50) )
2972  // << BasicResult(1, QRectF(70, 0, 66.66666666666666, 50) )
2973  // << BasicResult(2, QRectF(70, 0, 60.66666666666666, 50) )
2974  // ;
2975 
2976  // QTest::newRow("Three, parallel is bigger") << QSizeF(146.66666666666666, 50) << theData << theSizeHint << theResult;
2977  // #endif
2978  }
2979 
2980  // Three widgets, the same sizehint, one center anchor
2981  {
2982  BasicLayoutTestDataList theData;
2983  AnchorItemSizeHintList theSizeHint;
2984  BasicLayoutTestResultList theResult;
2985 
2986  theData
2987  << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
2988  << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
2989  << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorLeft, 10)
2990 
2991  << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2992  << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
2993 
2994  << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
2995  << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
2996  << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
2997  ;
2998 
2999  theSizeHint
3000  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
3001  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
3002  << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
3003  ;
3004  theResult
3005  << BasicResult(0, QRectF(10, 0, 40, 50) )
3006  << BasicResult(1, QRectF(60, 0, 40, 50) )
3007  << BasicResult(2, QRectF(40, 0, 60, 50) )
3008  ;
3009 
3010  ;
3011 
3012  QTest::newRow("Three, the same sizehint, one center anchor") << QSizeF(110, 50) << theData << theSizeHint << theResult;
3013  }
3014 }
3015 
3016 void tst_QGraphicsAnchorLayout1::testComplexCases()
3017 {
3018  QFETCH(QSizeF, size);
3019  QFETCH(BasicLayoutTestDataList, data);
3020  QFETCH(AnchorItemSizeHintList, sizehint);
3021  QFETCH(BasicLayoutTestResultList, result);
3022 
3023  QGraphicsWidget *widget = new QGraphicsWidget;
3024 
3025  // Determine amount of widgets to add.
3026  int widgetCount = -1;
3027  for (int i = 0; i < data.count(); ++i) {
3028  const BasicLayoutTestData item = data[i];
3029  widgetCount = qMax(widgetCount, item.firstIndex);
3030  widgetCount = qMax(widgetCount, item.secondIndex);
3031  }
3032  ++widgetCount; // widgetCount is max of indices.
3033 
3034  // Create dummy widgets
3035  QList<QGraphicsWidget *> widgets;
3036  for (int i = 0; i < widgetCount; ++i) {
3037  TestWidget *w = new TestWidget;
3038 
3039  w->setMinimumWidth( sizehint[i].hmin );
3040  w->setPreferredWidth( sizehint[i].hpref );
3041  w->setMaximumWidth( sizehint[i].hmax );
3042 
3043  w->setMinimumHeight( sizehint[i].vmin );
3044  w->setPreferredHeight( sizehint[i].vpref );
3045  w->setMaximumHeight( sizehint[i].vmax );
3046 
3047  widgets << w;
3048  }
3049 
3050  // Setup anchor layout
3051  TheAnchorLayout *layout = new TheAnchorLayout;
3052 
3053  for (int i = 0; i < data.count(); ++i) {
3054  const BasicLayoutTestData item = data[i];
3055  layout->setAnchor(
3056  getItem(item.firstIndex, widgets, layout),
3057  item.firstEdge,
3058  getItem(item.secondIndex, widgets, layout),
3059  item.secondEdge,
3060  item.spacing );
3061  }
3062 
3063  widget->setLayout(layout);
3064  widget->setContentsMargins(0,0,0,0);
3065 
3066  widget->resize(size);
3067  QCOMPARE(widget->size(), size);
3068 
3069  // Validate
3070  for (int i = 0; i < result.count(); ++i) {
3071  const BasicLayoutTestResult item = result[i];
3072  QCOMPARE(widgets[item.index]->geometry(), item.rect);
3073  }
3074 
3075  // Test mirrored mode
3076  widget->setLayoutDirection(Qt::RightToLeft);
3077  layout->activate();
3078  // Validate
3079  for (int j = 0; j < result.count(); ++j) {
3080  const BasicLayoutTestResult item = result[j];
3081  QRectF mirroredRect(item.rect);
3082  // only valid cases are mirrored
3083  if (mirroredRect.isValid()){
3084  mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
3085  }
3086  QCOMPARE(widgets[item.index]->geometry(), mirroredRect);
3087  delete widgets[item.index];
3088  }
3089 
3090  delete widget;
3091 }
3092 #endif //TEST_COMPLEX_CASES
3093 
3094 
3095 QTEST_MAIN(tst_QGraphicsAnchorLayout1)
3096 #include "tst_qgraphicsanchorlayout1.moc"
3097 //-----------------------------------------------------------------------------
3098 
i
small capitals from c petite p scientific i
[1]
Definition: afcover.h:80
QBoxLayout::minimumSize
QSize minimumSize() const override
Definition: qboxlayout.cpp:626
QBoxLayout::count
int count() const override
Definition: qboxlayout.cpp:707
QBoxLayout::maximumSize
QSize maximumSize() const override
Definition: qboxlayout.cpp:637
QBoxLayout::itemAt
QLayoutItem * itemAt(int) const override
Definition: qboxlayout.cpp:716
QGraphicsAnchor
The QGraphicsAnchor class represents an anchor between two items in a QGraphicsAnchorLayout.
Definition: qgraphicsanchorlayout.h:56
QGraphicsAnchor::setSpacing
void setSpacing(qreal spacing)
Definition: qgraphicsanchorlayout.cpp:192
QGraphicsAnchorLayout
The QGraphicsAnchorLayout class provides a layout where one can anchor widgets together in Graphics V...
Definition: qgraphicsanchorlayout.h:76
QGraphicsAnchorLayout::addAnchor
QGraphicsAnchor * addAnchor(QGraphicsLayoutItem *firstItem, Qt::AnchorPoint firstEdge, QGraphicsLayoutItem *secondItem, Qt::AnchorPoint secondEdge)
Definition: qgraphicsanchorlayout.cpp:270
QGraphicsAnchorLayout::setSpacing
void setSpacing(qreal spacing)
Definition: qgraphicsanchorlayout.cpp:403
QGraphicsAnchorLayout::itemAt
QGraphicsLayoutItem * itemAt(int index) const override
Definition: qgraphicsanchorlayout.cpp:484
QGraphicsAnchorLayout::anchor
QGraphicsAnchor * anchor(QGraphicsLayoutItem *firstItem, Qt::AnchorPoint firstEdge, QGraphicsLayoutItem *secondItem, Qt::AnchorPoint secondEdge)
Definition: qgraphicsanchorlayout.cpp:284
QGraphicsAnchorLayout::removeAt
void removeAt(int index) override
Definition: qgraphicsanchorlayout.cpp:454
QGraphicsAnchorLayout::count
int count() const override
Definition: qgraphicsanchorlayout.cpp:475
QGraphicsAnchorLayoutPrivate::get
static QGraphicsAnchorLayoutPrivate * get(QGraphicsAnchorLayout *q)
Definition: qgraphicsanchorlayout_p.h:402
QGraphicsItem
The QGraphicsItem class is the base class for all graphical items in a QGraphicsScene.
Definition: qgraphicsitem.h:83
QGraphicsItem::setParentItem
void setParentItem(QGraphicsItem *parent)
Definition: qgraphicsitem.cpp:1825
QGraphicsItem::parentItem
QGraphicsItem * parentItem() const
Definition: qgraphicsitem.cpp:1689
QGraphicsLayout::setContentsMargins
void setContentsMargins(qreal left, qreal top, qreal right, qreal bottom)
Definition: qgraphicslayout.cpp:217
QGraphicsLayoutItem
The QGraphicsLayoutItem class can be inherited to allow your custom items to be managed by layouts.
Definition: qgraphicslayoutitem.h:55
QGraphicsLayoutItem::setPreferredWidth
void setPreferredWidth(qreal width)
Definition: qgraphicslayoutitem.cpp:591
QGraphicsLayoutItem::parentLayoutItem
QGraphicsLayoutItem * parentLayoutItem() const
Definition: qgraphicslayoutitem.cpp:857
QGraphicsWidget
The QGraphicsWidget class is the base class for all widget items in a QGraphicsScene.
Definition: qgraphicswidget.h:68
QGraphicsWidget::setLayout
void setLayout(QGraphicsLayout *layout)
Definition: qgraphicswidget.cpp:825
QGraphicsWidget::geometry
QRectF geometry
the geometry of the widget
Definition: qgraphicswidget.h:83
QGraphicsWidget::setGeometry
void setGeometry(const QRectF &rect) override
Definition: qgraphicswidget.cpp:353
QLayout::activate
bool activate()
Definition: qlayout.cpp:1028
QLayout::removeItem
void removeItem(QLayoutItem *)
Definition: qlayout.cpp:1384
QLayout::indexOf
virtual int indexOf(const QWidget *) const
Definition: qlayout.cpp:1210
QLibraryInfo::isDebugBuild
static bool isDebugBuild()
Definition: qlibraryinfo.cpp:294
QList
Definition: qlist.h:108
QMap
Definition: qmap.h:222
QMap::insert
iterator insert(const Key &key, const T &value)
Definition: qmap.h:719
QObject
The QObject class is the base class of all Qt objects.
Definition: qobject.h:125
QPoint
The QPoint class defines a point in the plane using integer precision.
Definition: qpoint.h:52
QRectF
The QRectF class defines a finite rectangle in the plane using floating point precision.
Definition: qrect.h:511
QRect::height
constexpr int height() const noexcept
Definition: qrect.h:266
QRect::x
constexpr int x() const noexcept
Definition: qrect.h:212
QRect::width
constexpr int width() const noexcept
Definition: qrect.h:263
QRect::y
constexpr int y() const noexcept
Definition: qrect.h:215
QSizeF
The QSizeF class defines the size of a two-dimensional object using floating point precision.
Definition: qsize.h:235
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:55
QSizePolicy
The QSizePolicy class is a layout attribute describing horizontal and vertical resizing policy.
Definition: qsizepolicy.h:54
QSizePolicy::MinimumExpanding
@ MinimumExpanding
Definition: qsizepolicy.h:70
QString
The QString class provides a Unicode character string.
Definition: qstring.h:388
QString::number
static QString number(int, int base=10)
Definition: qstring.cpp:7538
QWidget::setLayout
void setLayout(QLayout *)
Definition: qwidget.cpp:10146
QWidget::setGeometry
void setGeometry(int x, int y, int w, int h)
Definition: qwidget.h:919
QWidget::setContentsMargins
void setContentsMargins(int left, int top, int right, int bottom)
Definition: qwidget.cpp:7545
QWidget::setMinimumSize
void setMinimumSize(const QSize &)
Definition: qwidget.h:865
QWidget::setSizePolicy
void setSizePolicy(QSizePolicy)
QWidget::setMinimumWidth
void setMinimumWidth(int minw)
Definition: qwidget.cpp:4118
QWidget::size
QSize size
the size of the widget excluding any window frame
Definition: qwidget.h:147
QWidget::minimumSize
QSize minimumSize
the widget's minimum size
Definition: qwidget.h:154
QWidget::geometry
QRect geometry
the geometry of the widget relative to its parent and excluding the window frame
Definition: qwidget.h:140
QWidget::maximumSize
QSize maximumSize
the widget's maximum size in pixels
Definition: qwidget.h:155
QWidget::setLayoutDirection
void setLayoutDirection(Qt::LayoutDirection direction)
Definition: qwidget.cpp:4885
QWidget::setMaximumSize
void setMaximumSize(const QSize &)
Definition: qwidget.h:868
QWidget::resize
void resize(int w, int h)
Definition: qwidget.h:916
QWidget::setMaximumWidth
void setMaximumWidth(int maxw)
Definition: qwidget.cpp:4136
TestWidget::sizeHint
QSize sizeHint() const override
Definition: tst_qwidgetrepaintmanager.cpp:51
TestWidget::TestWidget
TestWidget(QGraphicsItem *parent=nullptr, const QString &name=QString())
Definition: tst_qgraphicsanchorlayout1.cpp:152
TheAnchorLayout::removeAnchor
void removeAnchor(QGraphicsLayoutItem *startItem, Qt::AnchorPoint startEdge, QGraphicsLayoutItem *endItem, Qt::AnchorPoint endEdge)
Definition: tst_qgraphicsanchorlayout1.cpp:81
TheAnchorLayout::setAnchor
void setAnchor(QGraphicsLayoutItem *startItem, Qt::AnchorPoint startEdge, QGraphicsLayoutItem *endItem, Qt::AnchorPoint endEdge, qreal value)
Definition: tst_qgraphicsanchorlayout1.cpp:54
TheAnchorLayout::removeItem
void removeItem(QGraphicsLayoutItem *item)
Definition: tst_qgraphicsanchorlayout1.cpp:76
TheAnchorLayout::indexOf
int indexOf(const QGraphicsLayoutItem *item) const
Definition: tst_qgraphicsanchorlayout1.cpp:66
tst_QGraphicsAnchorLayout1
Definition: tst_qgraphicsanchorlayout1.cpp:188
widget
QOpenGLWidget * widget
[1]
Definition: doc_gui_widgets_qopenglwidget.cpp:100
j
int j
Definition: doc_src_containers.cpp:314
qDeleteAll
qDeleteAll(list.begin(), list.end())
QCOMPARE
QCOMPARE(spy.count(), 1)
QTest::newRow
Q_TESTLIB_EXPORT QTestData & newRow(const char *dataTag)
Definition: qtestcase.cpp:2658
QTest::ignoreMessage
Q_TESTLIB_EXPORT void ignoreMessage(QtMsgType type, const char *message)
Definition: qtestcase.cpp:2292
QTest::currentDataTag
Q_TESTLIB_EXPORT const char * currentDataTag()
Definition: qtestcase.cpp:2758
Qt::RightToLeft
@ RightToLeft
Definition: qnamespace.h:1464
Qt::AnchorPoint
AnchorPoint
Definition: qnamespace.h:1469
Qt::AnchorRight
@ AnchorRight
Definition: qnamespace.h:1472
Qt::AnchorVerticalCenter
@ AnchorVerticalCenter
Definition: qnamespace.h:1474
Qt::AnchorBottom
@ AnchorBottom
Definition: qnamespace.h:1475
Qt::AnchorTop
@ AnchorTop
Definition: qnamespace.h:1473
Qt::AnchorHorizontalCenter
@ AnchorHorizontalCenter
Definition: qnamespace.h:1471
Qt::AnchorLeft
@ AnchorLeft
Definition: qnamespace.h:1470
Qt::SizeHint
SizeHint
Definition: qnamespace.h:1589
Qt::MaximumSize
@ MaximumSize
Definition: qnamespace.h:1592
Qt::PreferredSize
@ PreferredSize
Definition: qnamespace.h:1591
Qt::MinimumSize
@ MinimumSize
Definition: qnamespace.h:1590
language::sizePolicy
const char * sizePolicy(int v)
Definition: language.cpp:146
QString
#define QString()
Definition: parse-defines.h:51
strcmp
int PRIV() strcmp(PCRE2_SPTR str1, PCRE2_SPTR str2)
Definition: pcre2_string_utils.c:102
value
EGLOutputLayerEXT EGLint EGLAttrib value
Definition: qeglstreamconvenience_p.h:82
quintptr
size_t quintptr
Definition: qglobal.h:310
qreal
QT_END_INCLUDE_NAMESPACE typedef double qreal
Definition: qglobal.h:341
qDebug
#define qDebug
[1]
Definition: qlogging.h:177
QtWarningMsg
@ QtWarningMsg
Definition: qlogging.h:62
Q_DECLARE_METATYPE
#define Q_DECLARE_METATYPE(TYPE)
Definition: qmetatype.h:1417
b
GLboolean GLboolean GLboolean b
Definition: qopengles2ext.h:337
w
GLfloat GLfloat GLfloat w
[0]
Definition: qopengles2ext.h:789
height
GLint GLsizei GLsizei height
Definition: qopengles2ext.h:206
a
GLboolean GLboolean GLboolean GLboolean a
[7]
Definition: qopengles2ext.h:337
size
GLenum GLuint GLintptr GLsizeiptr size
[1]
Definition: qopengles2ext.h:660
index
GLuint index
[2]
Definition: qopengles2ext.h:331
distance
GLsizei GLsizei GLfloat distance
Definition: qopengles2ext.h:3202
width
GLint GLsizei width
Definition: qopengles2ext.h:206
data
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
Definition: qopengles2ext.h:206
name
GLuint name
Definition: qopengles2ext.h:156
n
GLfloat n
Definition: qopengles2ext.h:795
result
GLuint64EXT * result
[6]
Definition: qopenglext.h:10932
qAbs
QPointF qAbs(const QPointF &p)
Definition: qscroller.cpp:119
QTEST_MAIN
#define QTEST_MAIN(TestObject)
Definition: qtest.h:664
QFETCH
#define QFETCH(Type, name)
Definition: qtestcase.h:230
QVERIFY
#define QVERIFY(statement)
Definition: qtestcase.h:64
Q_OBJECT
#define Q_OBJECT
Definition: qtmetamacros.h:158
slots
#define slots
Definition: qtmetamacros.h:76
Q_UNUSED
Q_UNUSED(salary)
[21]
setData
mimeData setData("text/csv", csvData)
widgets
QList< QWidget * > widgets
[11]
Definition: src_corelib_kernel_qobject.cpp:197
layout
QVBoxLayout * layout
Definition: src_corelib_kernel_qobject.cpp:85
d
double d
Definition: src_corelib_text_qlocale.cpp:56
r1
QRect r1(100, 200, 11, 16)
[0]
r2
QRect r2(QPoint(100, 200), QSize(11, 16))
item
QGraphicsItem * item
Definition: src_gui_graphicsview_qgraphicsitem.cpp:172
policy
QSizePolicy policy
Definition: src_gui_widgets_qsplitter.cpp:53
AnchorItemSizeHint::AnchorItemSizeHint
AnchorItemSizeHint(qreal hmin, qreal hpref, qreal hmax, qreal vmin, qreal vpref, qreal vmax)
Definition: tst_qgraphicsanchorlayout1.cpp:114
BasicLayoutTestData::BasicLayoutTestData
BasicLayoutTestData(int index1, Qt::AnchorPoint edge1, int index2, Qt::AnchorPoint edge2, qreal distance)
Definition: tst_qgraphicsanchorlayout1.cpp:95
BasicLayoutTestResult::BasicLayoutTestResult
BasicLayoutTestResult(int resultIndex, const QRectF &resultRect)
Definition: tst_qgraphicsanchorlayout1.cpp:128
QLatin1Char
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:53
childRect
QRect childRect(QAccessibleInterface *iface, int index=0)
Definition: tst_qaccessibility.cpp:171
SizeHintArray
QMap< int, qreal > SizeHintArray
Definition: tst_qgraphicsanchorlayout1.cpp:2558
getItem
QGraphicsLayoutItem * getItem(int index, const QList< QGraphicsWidget * > &widgets, QGraphicsLayoutItem *defaultItem)
Definition: tst_qgraphicsanchorlayout1.cpp:1657
BasicLayoutTestDataList
QList< BasicLayoutTestData > BasicLayoutTestDataList
Definition: tst_qgraphicsanchorlayout1.cpp:138
parent
IUIAutomationTreeWalker __RPC__deref_out_opt IUIAutomationElement ** parent
Definition: uiaclientinterfaces_p.h:245
Generated by doxygen 1.9.1