1 /****************************************************************************
3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/
6 ** This file is part of the test suite of the Qt Toolkit.
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** GNU Lesser General Public License Usage
10 ** This file may be used under the terms of the GNU Lesser General Public
11 ** License version 2.1 as published by the Free Software Foundation and
12 ** appearing in the file LICENSE.LGPL included in the packaging of this
13 ** file. Please review the following information to ensure the GNU Lesser
14 ** General Public License version 2.1 requirements will be met:
15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 ** In addition, as a special exception, Nokia gives you certain additional
18 ** rights. These rights are described in the Nokia Qt LGPL Exception
19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 ** GNU General Public License Usage
22 ** Alternatively, this file may be used under the terms of the GNU General
23 ** Public License version 3.0 as published by the Free Software Foundation
24 ** and appearing in the file LICENSE.GPL included in the packaging of this
25 ** file. Please review the following information to ensure the GNU General
26 ** Public License version 3.0 requirements will be met:
27 ** http://www.gnu.org/copyleft/gpl.html.
30 ** Alternatively, this file may be used in accordance with the terms and
31 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
44 #include <QtGui/qwindowsysteminterface_qpa.h>
45 #include <QtQuick/qquickitem.h>
46 #include <QtQuick/qquickcanvas.h>
47 #include <QtQuick/qquickview.h>
48 #include <QtWidgets/QGraphicsSceneMouseEvent>
49 #include "private/qquickfocusscope_p.h"
50 #include "private/qquickitem_p.h"
53 #include "../../shared/util.h"
55 class TestItem : public QQuickItem
59 TestItem(QQuickItem *parent = 0)
60 : QQuickItem(parent), focused(false), pressCount(0), releaseCount(0)
61 , wheelCount(0), acceptIncomingTouchEvents(true)
62 , touchEventReached(false) {}
68 bool acceptIncomingTouchEvents;
69 bool touchEventReached;
71 virtual void focusInEvent(QFocusEvent *) { Q_ASSERT(!focused); focused = true; }
72 virtual void focusOutEvent(QFocusEvent *) { Q_ASSERT(focused); focused = false; }
73 virtual void mousePressEvent(QMouseEvent *event) { event->accept(); ++pressCount; }
74 virtual void mouseReleaseEvent(QMouseEvent *event) { event->accept(); ++releaseCount; }
75 virtual void touchEvent(QTouchEvent *event) {
76 touchEventReached = true;
77 event->setAccepted(acceptIncomingTouchEvents);
79 virtual void wheelEvent(QWheelEvent *event) { event->accept(); ++wheelCount; }
82 class TestCanvas: public QQuickCanvas
89 virtual bool event(QEvent *event)
91 return QQuickCanvas::event(event);
95 class TestPolishItem : public QQuickItem
99 TestPolishItem(QQuickItem *parent = 0)
100 : QQuickItem(parent), wasPolished(false) {
107 virtual void updatePolish() {
117 class TestFocusScope : public QQuickFocusScope
121 TestFocusScope(QQuickItem *parent = 0) : QQuickFocusScope(parent), focused(false) {}
125 virtual void focusInEvent(QFocusEvent *) { Q_ASSERT(!focused); focused = true; }
126 virtual void focusOutEvent(QFocusEvent *) { Q_ASSERT(focused); focused = false; }
129 class tst_qquickitem : public QQmlDataTest
140 void addedToCanvas();
142 void multipleFocusClears();
143 void focusSubItemInNonFocusScope();
144 void parentItemWithFocus();
145 void reparentFocusedItem();
148 void setParentItem();
155 void touchEventAcceptIgnore_data();
156 void touchEventAcceptIgnore();
157 void polishOutsideAnimation();
158 void polishOnCompleted();
160 void wheelEvent_data();
162 void hoverEvent_data();
164 void hoverEventInParent();
166 void paintOrder_data();
172 NoOp, Append, Remove, StackBefore, StackAfter, SetZ
175 void ensureFocus(QWindow *w) {
177 w->requestActivateWindow();
178 qApp->processEvents();
182 void tst_qquickitem::initTestCase()
184 QQmlDataTest::initTestCase();
185 qmlRegisterType<TestPolishItem>("Qt.test", 1, 0, "TestPolishItem");
188 // Focus still updates when outside a canvas
189 void tst_qquickitem::noCanvas()
191 QQuickItem *root = new TestItem;
192 QQuickItem *child = new TestItem(root);
193 QQuickItem *scope = new TestItem(root);
194 QQuickFocusScope *scopedChild = new TestFocusScope(scope);
195 QQuickFocusScope *scopedChild2 = new TestFocusScope(scope);
197 QCOMPARE(root->hasFocus(), false);
198 QCOMPARE(child->hasFocus(), false);
199 QCOMPARE(scope->hasFocus(), false);
200 QCOMPARE(scopedChild->hasFocus(), false);
201 QCOMPARE(scopedChild2->hasFocus(), false);
203 root->setFocus(true);
204 scope->setFocus(true);
205 scopedChild2->setFocus(true);
206 QCOMPARE(root->hasFocus(), true);
207 QCOMPARE(child->hasFocus(), false);
208 QCOMPARE(scope->hasFocus(), false);
209 QCOMPARE(scopedChild->hasFocus(), false);
210 QCOMPARE(scopedChild2->hasFocus(), true);
212 root->setFocus(false);
213 child->setFocus(true);
214 scopedChild->setFocus(true);
215 scope->setFocus(false);
216 QCOMPARE(root->hasFocus(), false);
217 QCOMPARE(child->hasFocus(), false);
218 QCOMPARE(scope->hasFocus(), false);
219 QCOMPARE(scopedChild->hasFocus(), true);
220 QCOMPARE(scopedChild2->hasFocus(), false);
226 FocusData() : focus(false), activeFocus(false) {}
228 void set(bool f, bool af) { focus = f; activeFocus = af; }
232 struct FocusState : public QHash<QQuickItem *, FocusData>
234 FocusState() : activeFocusItem(0) {}
235 FocusState &operator<<(QQuickItem *item) {
236 insert(item, FocusData());
240 void active(QQuickItem *i) {
243 QQuickItem *activeFocusItem;
248 if (focusState.activeFocusItem) { \
249 QCOMPARE(canvas.activeFocusItem(), focusState.activeFocusItem); \
250 if (qobject_cast<TestItem *>(canvas.activeFocusItem())) \
251 QCOMPARE(qobject_cast<TestItem *>(canvas.activeFocusItem())->focused, true); \
252 else if (qobject_cast<TestFocusScope *>(canvas.activeFocusItem())) \
253 QCOMPARE(qobject_cast<TestFocusScope *>(canvas.activeFocusItem())->focused, true); \
255 QCOMPARE(canvas.activeFocusItem(), canvas.rootItem()); \
257 for (QHash<QQuickItem *, FocusData>::Iterator iter = focusState.begin(); \
258 iter != focusState.end(); \
260 QCOMPARE(iter.key()->hasFocus(), iter.value().focus); \
261 QCOMPARE(iter.key()->hasActiveFocus(), iter.value().activeFocus); \
265 // Tests a simple set of top-level scoped items
266 void tst_qquickitem::simpleFocus()
269 ensureFocus(&canvas);
272 QSKIP("QTBUG-24094: fails on Mac OS X 10.7");
275 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
277 QQuickItem *l1c1 = new TestItem(canvas.rootItem());
278 QQuickItem *l1c2 = new TestItem(canvas.rootItem());
279 QQuickItem *l1c3 = new TestItem(canvas.rootItem());
281 QQuickItem *l2c1 = new TestItem(l1c1);
282 QQuickItem *l2c2 = new TestItem(l1c1);
283 QQuickItem *l2c3 = new TestItem(l1c3);
285 FocusState focusState;
286 focusState << l1c1 << l1c2 << l1c3
287 << l2c1 << l2c2 << l2c3;
290 l1c1->setFocus(true);
291 focusState[l1c1].set(true, true);
292 focusState.active(l1c1);
295 l2c3->setFocus(true);
296 focusState[l1c1].set(false, false);
297 focusState[l2c3].set(true, true);
298 focusState.active(l2c3);
301 l1c3->setFocus(true);
302 focusState[l2c3].set(false, false);
303 focusState[l1c3].set(true, true);
304 focusState.active(l1c3);
307 l1c2->setFocus(false);
310 l1c3->setFocus(false);
311 focusState[l1c3].set(false, false);
312 focusState.active(0);
315 l2c1->setFocus(true);
316 focusState[l2c1].set(true, true);
317 focusState.active(l2c1);
321 // Items with a focus scope
322 void tst_qquickitem::scopedFocus()
325 ensureFocus(&canvas);
326 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
328 QQuickItem *l1c1 = new TestItem(canvas.rootItem());
329 QQuickItem *l1c2 = new TestItem(canvas.rootItem());
330 QQuickItem *l1c3 = new TestItem(canvas.rootItem());
332 QQuickItem *l2c1 = new TestItem(l1c1);
333 QQuickItem *l2c2 = new TestItem(l1c1);
334 QQuickItem *l2c3 = new TestFocusScope(l1c3);
336 QQuickItem *l3c1 = new TestItem(l2c3);
337 QQuickItem *l3c2 = new TestFocusScope(l2c3);
339 QQuickItem *l4c1 = new TestItem(l3c2);
340 QQuickItem *l4c2 = new TestItem(l3c2);
342 FocusState focusState;
343 focusState << l1c1 << l1c2 << l1c3
344 << l2c1 << l2c2 << l2c3
349 l4c2->setFocus(true);
350 focusState[l4c2].set(true, false);
353 l4c1->setFocus(true);
354 focusState[l4c2].set(false, false);
355 focusState[l4c1].set(true, false);
358 l1c1->setFocus(true);
359 focusState[l1c1].set(true, true);
360 focusState.active(l1c1);
363 l3c2->setFocus(true);
364 focusState[l3c2].set(true, false);
367 l2c3->setFocus(true);
368 focusState[l1c1].set(false, false);
369 focusState[l2c3].set(true, true);
370 focusState[l3c2].set(true, true);
371 focusState[l4c1].set(true, true);
372 focusState.active(l4c1);
375 l3c2->setFocus(false);
376 focusState[l3c2].set(false, false);
377 focusState[l4c1].set(true, false);
378 focusState.active(l2c3);
381 l3c2->setFocus(true);
382 focusState[l3c2].set(true, true);
383 focusState[l4c1].set(true, true);
384 focusState.active(l4c1);
387 l4c1->setFocus(false);
388 focusState[l4c1].set(false, false);
389 focusState.active(l3c2);
392 l1c3->setFocus(true);
393 focusState[l1c3].set(true, true);
394 focusState[l2c3].set(false, false);
395 focusState[l3c2].set(true, false);
396 focusState.active(l1c3);
400 // Tests focus corrects itself when a tree is added to a canvas for the first time
401 void tst_qquickitem::addedToCanvas()
405 ensureFocus(&canvas);
406 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
408 QQuickItem *item = new TestItem;
410 FocusState focusState;
413 item->setFocus(true);
414 focusState[item].set(true, false);
417 item->setParentItem(canvas.rootItem());
418 focusState[item].set(true, true);
419 focusState.active(item);
425 ensureFocus(&canvas);
426 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
428 QQuickItem *item = new TestItem(canvas.rootItem());
430 QQuickItem *tree = new TestItem;
431 QQuickItem *c1 = new TestItem(tree);
432 QQuickItem *c2 = new TestItem(tree);
434 FocusState focusState;
435 focusState << item << tree << c1 << c2;
437 item->setFocus(true);
440 focusState[item].set(true, true);
441 focusState[c1].set(false, false);
442 focusState[c2].set(true, false);
443 focusState.active(item);
446 tree->setParentItem(item);
447 focusState[c1].set(false, false);
448 focusState[c2].set(false, false);
454 ensureFocus(&canvas);
455 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
457 QQuickItem *tree = new TestItem;
458 QQuickItem *c1 = new TestItem(tree);
459 QQuickItem *c2 = new TestItem(tree);
461 FocusState focusState;
462 focusState << tree << c1 << c2;
465 focusState[c1].set(false, false);
466 focusState[c2].set(true, false);
469 tree->setParentItem(canvas.rootItem());
470 focusState[c1].set(false, false);
471 focusState[c2].set(true, true);
472 focusState.active(c2);
478 ensureFocus(&canvas);
479 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
480 QQuickItem *tree = new TestFocusScope;
481 QQuickItem *c1 = new TestItem(tree);
482 QQuickItem *c2 = new TestItem(tree);
484 FocusState focusState;
485 focusState << tree << c1 << c2;
488 focusState[c1].set(false, false);
489 focusState[c2].set(true, false);
492 tree->setParentItem(canvas.rootItem());
493 focusState[c1].set(false, false);
494 focusState[c2].set(true, false);
497 tree->setFocus(true);
498 focusState[tree].set(true, true);
499 focusState[c2].set(true, true);
500 focusState.active(c2);
506 ensureFocus(&canvas);
507 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
508 QQuickItem *tree = new TestFocusScope;
509 QQuickItem *c1 = new TestItem(tree);
510 QQuickItem *c2 = new TestItem(tree);
512 FocusState focusState;
513 focusState << tree << c1 << c2;
514 tree->setFocus(true);
517 focusState[tree].set(true, false);
518 focusState[c1].set(false, false);
519 focusState[c2].set(true, false);
522 tree->setParentItem(canvas.rootItem());
523 focusState[tree].set(true, true);
524 focusState[c1].set(false, false);
525 focusState[c2].set(true, true);
526 focusState.active(c2);
532 ensureFocus(&canvas);
533 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
534 QQuickItem *child = new TestItem(canvas.rootItem());
535 QQuickItem *tree = new TestFocusScope;
536 QQuickItem *c1 = new TestItem(tree);
537 QQuickItem *c2 = new TestItem(tree);
539 FocusState focusState;
540 focusState << child << tree << c1 << c2;
541 child->setFocus(true);
542 tree->setFocus(true);
545 focusState[child].set(true, true);
546 focusState[tree].set(true, false);
547 focusState[c1].set(false, false);
548 focusState[c2].set(true, false);
549 focusState.active(child);
552 tree->setParentItem(canvas.rootItem());
553 focusState[tree].set(false, false);
554 focusState[c1].set(false, false);
555 focusState[c2].set(true, false);
558 tree->setFocus(true);
559 focusState[child].set(false, false);
560 focusState[tree].set(true, true);
561 focusState[c2].set(true, true);
562 focusState.active(c2);
567 void tst_qquickitem::changeParent()
569 // Parent to no parent
572 ensureFocus(&canvas);
573 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
574 QQuickItem *child = new TestItem(canvas.rootItem());
576 FocusState focusState;
580 child->setFocus(true);
581 focusState[child].set(true, true);
582 focusState.active(child);
585 child->setParentItem(0);
586 focusState[child].set(true, false);
587 focusState.active(0);
591 // Different parent, same focus scope
594 ensureFocus(&canvas);
595 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
596 QQuickItem *child = new TestItem(canvas.rootItem());
597 QQuickItem *child2 = new TestItem(canvas.rootItem());
599 FocusState focusState;
600 focusState << child << child2;
603 child->setFocus(true);
604 focusState[child].set(true, true);
605 focusState.active(child);
608 child->setParentItem(child2);
612 // Different parent, different focus scope
615 ensureFocus(&canvas);
616 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
617 QQuickItem *child = new TestItem(canvas.rootItem());
618 QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
619 QQuickItem *item = new TestItem(child);
621 FocusState focusState;
622 focusState << child << child2 << item;
625 item->setFocus(true);
626 focusState[item].set(true, true);
627 focusState.active(item);
630 item->setParentItem(child2);
631 focusState[item].set(true, false);
632 focusState.active(0);
637 ensureFocus(&canvas);
638 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
639 QQuickItem *child = new TestItem(canvas.rootItem());
640 QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
641 QQuickItem *item = new TestItem(child2);
643 FocusState focusState;
644 focusState << child << child2 << item;
647 item->setFocus(true);
648 focusState[item].set(true, false);
649 focusState.active(0);
652 item->setParentItem(child);
653 focusState[item].set(true, true);
654 focusState.active(item);
659 ensureFocus(&canvas);
660 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
661 QQuickItem *child = new TestItem(canvas.rootItem());
662 QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
663 QQuickItem *item = new TestItem(child2);
665 FocusState focusState;
666 focusState << child << child2 << item;
669 child->setFocus(true);
670 item->setFocus(true);
671 focusState[child].set(true, true);
672 focusState[item].set(true, false);
673 focusState.active(child);
676 item->setParentItem(child);
677 focusState[item].set(false, false);
681 // child has active focus, then its fs parent changes parent to 0, then
682 // child is deleted, then its parent changes again to a valid parent
685 ensureFocus(&canvas);
686 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
687 QQuickItem *item = new TestFocusScope(canvas.rootItem());
688 QQuickItem *child = new TestItem(item);
689 QQuickItem *child2 = new TestItem;
691 FocusState focusState;
692 focusState << item << child;
695 item->setFocus(true);
696 child->setFocus(true);
697 focusState[child].set(true, true);
698 focusState[item].set(true, true);
699 focusState.active(child);
702 item->setParentItem(0);
703 focusState[child].set(true, false);
704 focusState[item].set(true, false);
705 focusState.active(0);
708 focusState.remove(child);
710 item->setParentItem(canvas.rootItem());
711 focusState[item].set(true, true);
712 focusState.active(item);
718 void tst_qquickitem::multipleFocusClears()
720 //Multiple clears of focus inside a focus scope shouldn't crash. QTBUG-24714
721 QQuickView *view = new QQuickView;
722 view->setSource(testFileUrl("multipleFocusClears.qml"));
725 QTRY_VERIFY(QGuiApplication::focusWindow() == view);
728 void tst_qquickitem::focusSubItemInNonFocusScope()
730 QQuickView *view = new QQuickView;
731 view->setSource(testFileUrl("focusSubItemInNonFocusScope.qml"));
733 qApp->processEvents();
735 QQuickItem *dummyItem = view->rootObject()->findChild<QQuickItem *>("dummyItem");
738 QQuickItem *textInput = view->rootObject()->findChild<QQuickItem *>("textInput");
741 QVERIFY(dummyItem->hasFocus());
742 QVERIFY(!textInput->hasFocus());
743 QVERIFY(dummyItem->hasActiveFocus());
745 QVERIFY(QMetaObject::invokeMethod(textInput, "forceActiveFocus"));
747 QVERIFY(!dummyItem->hasFocus());
748 QVERIFY(textInput->hasFocus());
749 QVERIFY(textInput->hasActiveFocus());
754 void tst_qquickitem::parentItemWithFocus()
757 ensureFocus(&canvas);
758 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
763 FocusState focusState;
764 focusState << &parent << &child;
767 parent.setFocus(true);
768 child.setFocus(true);
769 focusState[&parent].set(true, false);
770 focusState[&child].set(true, false);
773 child.setParentItem(&parent);
774 focusState[&parent].set(true, false);
775 focusState[&child].set(false, false);
778 parent.setParentItem(canvas.rootItem());
779 focusState[&parent].set(true, true);
780 focusState[&child].set(false, false);
781 focusState.active(&parent);
784 child.forceActiveFocus();
785 focusState[&parent].set(false, false);
786 focusState[&child].set(true, true);
787 focusState.active(&child);
792 QQuickItem grandchild(&child);
794 FocusState focusState;
795 focusState << &parent << &child << &grandchild;
798 parent.setFocus(true);
799 grandchild.setFocus(true);
800 focusState[&parent].set(true, false);
801 focusState[&child].set(false, false);
802 focusState[&grandchild].set(true, false);
805 child.setParentItem(&parent);
806 focusState[&parent].set(true, false);
807 focusState[&child].set(false, false);
808 focusState[&grandchild].set(false, false);
811 parent.setParentItem(canvas.rootItem());
812 focusState[&parent].set(true, true);
813 focusState[&child].set(false, false);
814 focusState[&grandchild].set(false, false);
815 focusState.active(&parent);
818 grandchild.forceActiveFocus();
819 focusState[&parent].set(false, false);
820 focusState[&child].set(false, false);
821 focusState[&grandchild].set(true, true);
822 focusState.active(&grandchild);
827 void tst_qquickitem::reparentFocusedItem()
830 ensureFocus(&canvas);
831 QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
833 QQuickItem parent(canvas.rootItem());
834 QQuickItem child(&parent);
835 QQuickItem sibling(&parent);
836 QQuickItem grandchild(&child);
838 FocusState focusState;
839 focusState << &parent << &child << &sibling << &grandchild;
842 grandchild.setFocus(true);
843 focusState[&parent].set(false, false);
844 focusState[&child].set(false, false);
845 focusState[&sibling].set(false, false);
846 focusState[&grandchild].set(true, true);
847 focusState.active(&grandchild);
850 // Parenting the item to another item within the same focus scope shouldn't change it's focus.
851 child.setParentItem(&sibling);
855 void tst_qquickitem::constructor()
857 QQuickItem *root = new QQuickItem;
858 QVERIFY(root->parent() == 0);
859 QVERIFY(root->parentItem() == 0);
861 QQuickItem *child1 = new QQuickItem(root);
862 QVERIFY(child1->parent() == root);
863 QVERIFY(child1->parentItem() == root);
864 QCOMPARE(root->childItems().count(), 1);
865 QCOMPARE(root->childItems().at(0), child1);
867 QQuickItem *child2 = new QQuickItem(root);
868 QVERIFY(child2->parent() == root);
869 QVERIFY(child2->parentItem() == root);
870 QCOMPARE(root->childItems().count(), 2);
871 QCOMPARE(root->childItems().at(0), child1);
872 QCOMPARE(root->childItems().at(1), child2);
877 void tst_qquickitem::setParentItem()
879 QQuickItem *root = new QQuickItem;
880 QVERIFY(root->parent() == 0);
881 QVERIFY(root->parentItem() == 0);
883 QQuickItem *child1 = new QQuickItem;
884 QVERIFY(child1->parent() == 0);
885 QVERIFY(child1->parentItem() == 0);
887 child1->setParentItem(root);
888 QVERIFY(child1->parent() == 0);
889 QVERIFY(child1->parentItem() == root);
890 QCOMPARE(root->childItems().count(), 1);
891 QCOMPARE(root->childItems().at(0), child1);
893 QQuickItem *child2 = new QQuickItem;
894 QVERIFY(child2->parent() == 0);
895 QVERIFY(child2->parentItem() == 0);
896 child2->setParentItem(root);
897 QVERIFY(child2->parent() == 0);
898 QVERIFY(child2->parentItem() == root);
899 QCOMPARE(root->childItems().count(), 2);
900 QCOMPARE(root->childItems().at(0), child1);
901 QCOMPARE(root->childItems().at(1), child2);
903 child1->setParentItem(0);
904 QVERIFY(child1->parent() == 0);
905 QVERIFY(child1->parentItem() == 0);
906 QCOMPARE(root->childItems().count(), 1);
907 QCOMPARE(root->childItems().at(0), child2);
911 QVERIFY(child1->parent() == 0);
912 QVERIFY(child1->parentItem() == 0);
913 QVERIFY(child2->parent() == 0);
914 QVERIFY(child2->parentItem() == 0);
920 void tst_qquickitem::visible()
922 QQuickItem *root = new QQuickItem;
924 QQuickItem *child1 = new QQuickItem;
925 child1->setParentItem(root);
927 QQuickItem *child2 = new QQuickItem;
928 child2->setParentItem(root);
930 QVERIFY(child1->isVisible());
931 QVERIFY(child2->isVisible());
933 root->setVisible(false);
934 QVERIFY(!child1->isVisible());
935 QVERIFY(!child2->isVisible());
937 root->setVisible(true);
938 QVERIFY(child1->isVisible());
939 QVERIFY(child2->isVisible());
941 child1->setVisible(false);
942 QVERIFY(!child1->isVisible());
943 QVERIFY(child2->isVisible());
945 child2->setParentItem(child1);
946 QVERIFY(!child1->isVisible());
947 QVERIFY(!child2->isVisible());
949 child2->setParentItem(root);
950 QVERIFY(!child1->isVisible());
951 QVERIFY(child2->isVisible());
958 void tst_qquickitem::enabled()
960 QQuickItem *root = new QQuickItem;
962 QQuickItem *child1 = new QQuickItem;
963 child1->setParentItem(root);
965 QQuickItem *child2 = new QQuickItem;
966 child2->setParentItem(root);
968 QVERIFY(child1->isEnabled());
969 QVERIFY(child2->isEnabled());
971 root->setEnabled(false);
972 QVERIFY(!child1->isEnabled());
973 QVERIFY(!child2->isEnabled());
975 root->setEnabled(true);
976 QVERIFY(child1->isEnabled());
977 QVERIFY(child2->isEnabled());
979 child1->setEnabled(false);
980 QVERIFY(!child1->isEnabled());
981 QVERIFY(child2->isEnabled());
983 child2->setParentItem(child1);
984 QVERIFY(!child1->isEnabled());
985 QVERIFY(!child2->isEnabled());
987 child2->setParentItem(root);
988 QVERIFY(!child1->isEnabled());
989 QVERIFY(child2->isEnabled());
996 void tst_qquickitem::enabledFocus()
999 ensureFocus(&canvas);
1001 QQuickFocusScope root;
1003 root.setFocus(true);
1004 root.setEnabled(false);
1006 QCOMPARE(root.isEnabled(), false);
1007 QCOMPARE(root.hasFocus(), true);
1008 QCOMPARE(root.hasActiveFocus(), false);
1010 root.setParentItem(canvas.rootItem());
1012 QCOMPARE(root.isEnabled(), false);
1013 QCOMPARE(root.hasFocus(), true);
1014 QCOMPARE(root.hasActiveFocus(), false);
1015 QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
1017 root.setEnabled(true);
1018 QCOMPARE(root.isEnabled(), true);
1019 QCOMPARE(root.hasFocus(), true);
1020 QCOMPARE(root.hasActiveFocus(), true);
1021 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
1024 child1.setParentItem(&root);
1026 QCOMPARE(child1.isEnabled(), true);
1027 QCOMPARE(child1.hasFocus(), false);
1028 QCOMPARE(child1.hasActiveFocus(), false);
1029 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
1032 child2.setFocus(true);
1033 child2.setParentItem(&root);
1035 QCOMPARE(root.isEnabled(), true);
1036 QCOMPARE(root.hasFocus(), true);
1037 QCOMPARE(root.hasActiveFocus(), true);
1038 QCOMPARE(child2.isEnabled(), true);
1039 QCOMPARE(child2.hasFocus(), true);
1040 QCOMPARE(child2.hasActiveFocus(), true);
1041 QCOMPARE(canvas.activeFocusItem(), &child2);
1043 child2.setEnabled(false);
1045 QCOMPARE(root.isEnabled(), true);
1046 QCOMPARE(root.hasFocus(), true);
1047 QCOMPARE(root.hasActiveFocus(), true);
1048 QCOMPARE(child1.isEnabled(), true);
1049 QCOMPARE(child1.hasFocus(), false);
1050 QCOMPARE(child1.hasActiveFocus(), false);
1051 QCOMPARE(child2.isEnabled(), false);
1052 QCOMPARE(child2.hasFocus(), true);
1053 QCOMPARE(child2.hasActiveFocus(), false);
1054 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
1056 child1.setEnabled(false);
1057 QCOMPARE(child1.isEnabled(), false);
1058 QCOMPARE(child1.hasFocus(), false);
1059 QCOMPARE(child1.hasActiveFocus(), false);
1061 child1.setFocus(true);
1062 QCOMPARE(child1.isEnabled(), false);
1063 QCOMPARE(child1.hasFocus(), true);
1064 QCOMPARE(child1.hasActiveFocus(), false);
1065 QCOMPARE(child2.isEnabled(), false);
1066 QCOMPARE(child2.hasFocus(), false);
1067 QCOMPARE(child2.hasActiveFocus(), false);
1068 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
1070 child1.setEnabled(true);
1071 QCOMPARE(child1.isEnabled(), true);
1072 QCOMPARE(child1.hasFocus(), true);
1073 QCOMPARE(child1.hasActiveFocus(), true);
1074 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&child1));
1076 root.setFocus(false);
1077 QCOMPARE(root.isEnabled(), true);
1078 QCOMPARE(root.hasFocus(), false);
1079 QCOMPARE(root.hasActiveFocus(), false);
1080 QCOMPARE(child1.isEnabled(), true);
1081 QCOMPARE(child1.hasFocus(), true);
1082 QCOMPARE(child1.hasActiveFocus(), false);
1083 QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
1085 child2.forceActiveFocus();
1086 QCOMPARE(root.isEnabled(), true);
1087 QCOMPARE(root.hasFocus(), true);
1088 QCOMPARE(root.hasActiveFocus(), true);
1089 QCOMPARE(child1.isEnabled(), true);
1090 QCOMPARE(child1.hasFocus(), false);
1091 QCOMPARE(child1.hasActiveFocus(), false);
1092 QCOMPARE(child2.isEnabled(), false);
1093 QCOMPARE(child2.hasFocus(), true);
1094 QCOMPARE(child2.hasActiveFocus(), false);
1095 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
1097 root.setEnabled(false);
1098 QCOMPARE(root.isEnabled(), false);
1099 QCOMPARE(root.hasFocus(), true);
1100 QCOMPARE(root.hasActiveFocus(), false);
1101 QCOMPARE(child1.isEnabled(), false);
1102 QCOMPARE(child1.hasFocus(), false);
1103 QCOMPARE(child1.hasActiveFocus(), false);
1104 QCOMPARE(child2.isEnabled(), false);
1105 QCOMPARE(child2.hasFocus(), true);
1106 QCOMPARE(child2.hasActiveFocus(), false);
1107 QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
1109 child1.forceActiveFocus();
1110 QCOMPARE(root.isEnabled(), false);
1111 QCOMPARE(root.hasFocus(), true);
1112 QCOMPARE(root.hasActiveFocus(), false);
1113 QCOMPARE(child1.isEnabled(), false);
1114 QCOMPARE(child1.hasFocus(), true);
1115 QCOMPARE(child1.hasActiveFocus(), false);
1116 QCOMPARE(child2.isEnabled(), false);
1117 QCOMPARE(child2.hasFocus(), false);
1118 QCOMPARE(child2.hasActiveFocus(), false);
1119 QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
1121 root.setEnabled(true);
1122 QCOMPARE(root.isEnabled(), true);
1123 QCOMPARE(root.hasFocus(), true);
1124 QCOMPARE(root.hasActiveFocus(), true);
1125 QCOMPARE(child1.isEnabled(), true);
1126 QCOMPARE(child1.hasFocus(), true);
1127 QCOMPARE(child1.hasActiveFocus(), true);
1128 QCOMPARE(child2.isEnabled(), false);
1129 QCOMPARE(child2.hasFocus(), false);
1130 QCOMPARE(child2.hasActiveFocus(), false);
1131 QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&child1));
1134 void tst_qquickitem::mouseGrab()
1136 QQuickCanvas *canvas = new QQuickCanvas;
1137 canvas->resize(200, 200);
1140 TestItem *child1 = new TestItem;
1141 child1->setAcceptedMouseButtons(Qt::LeftButton);
1142 child1->setSize(QSizeF(200, 100));
1143 child1->setParentItem(canvas->rootItem());
1145 TestItem *child2 = new TestItem;
1146 child2->setAcceptedMouseButtons(Qt::LeftButton);
1148 child2->setSize(QSizeF(200, 100));
1149 child2->setParentItem(canvas->rootItem());
1151 QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
1153 QVERIFY(canvas->mouseGrabberItem() == child1);
1156 QCOMPARE(child1->pressCount, 1);
1157 QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
1159 QVERIFY(canvas->mouseGrabberItem() == 0);
1160 QCOMPARE(child1->releaseCount, 1);
1162 QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
1164 QVERIFY(canvas->mouseGrabberItem() == child1);
1165 QCOMPARE(child1->pressCount, 2);
1166 child1->setEnabled(false);
1167 QVERIFY(canvas->mouseGrabberItem() == 0);
1168 QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
1170 QCOMPARE(child1->releaseCount, 1);
1171 child1->setEnabled(true);
1173 QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
1175 QVERIFY(canvas->mouseGrabberItem() == child1);
1176 QCOMPARE(child1->pressCount, 3);
1177 child1->setVisible(false);
1178 QVERIFY(canvas->mouseGrabberItem() == 0);
1179 QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
1180 QCOMPARE(child1->releaseCount, 1);
1181 child1->setVisible(true);
1183 QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
1185 QVERIFY(canvas->mouseGrabberItem() == child1);
1186 QCOMPARE(child1->pressCount, 4);
1187 child2->grabMouse();
1188 QVERIFY(canvas->mouseGrabberItem() == child2);
1189 QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
1191 QCOMPARE(child1->releaseCount, 1);
1192 QCOMPARE(child2->releaseCount, 1);
1194 child2->grabMouse();
1195 QVERIFY(canvas->mouseGrabberItem() == child2);
1196 QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
1198 QCOMPARE(child1->pressCount, 4);
1199 QCOMPARE(child2->pressCount, 1);
1200 QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
1202 QCOMPARE(child1->releaseCount, 1);
1203 QCOMPARE(child2->releaseCount, 2);
1210 void tst_qquickitem::touchEventAcceptIgnore_data()
1212 QTest::addColumn<bool>("itemSupportsTouch");
1214 QTest::newRow("with touch") << true;
1215 QTest::newRow("without touch") << false;
1218 void tst_qquickitem::touchEventAcceptIgnore()
1220 QFETCH(bool, itemSupportsTouch);
1222 TestCanvas *canvas = new TestCanvas;
1223 canvas->resize(100, 100);
1226 TestItem *item = new TestItem;
1227 item->setSize(QSizeF(100, 100));
1228 item->setParentItem(canvas->rootItem());
1229 item->acceptIncomingTouchEvents = itemSupportsTouch;
1231 static QTouchDevice* device = 0;
1233 device =new QTouchDevice;
1234 device->setType(QTouchDevice::TouchScreen);
1235 QWindowSystemInterface::registerTouchDevice(device);
1238 // Send Begin, Update & End touch sequence
1240 QTouchEvent::TouchPoint point;
1242 point.setPos(QPointF(50, 50));
1243 point.setScreenPos(point.pos());
1244 point.setState(Qt::TouchPointPressed);
1246 QTouchEvent event(QEvent::TouchBegin, device,
1248 Qt::TouchPointPressed,
1249 QList<QTouchEvent::TouchPoint>() << point);
1250 event.setAccepted(true);
1252 item->touchEventReached = false;
1254 bool accepted = canvas->event(&event);
1256 QVERIFY(item->touchEventReached);
1257 QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
1260 QTouchEvent::TouchPoint point;
1262 point.setPos(QPointF(60, 60));
1263 point.setScreenPos(point.pos());
1264 point.setState(Qt::TouchPointMoved);
1266 QTouchEvent event(QEvent::TouchUpdate, device,
1268 Qt::TouchPointMoved,
1269 QList<QTouchEvent::TouchPoint>() << point);
1270 event.setAccepted(true);
1272 item->touchEventReached = false;
1274 bool accepted = canvas->event(&event);
1276 QCOMPARE(item->touchEventReached, itemSupportsTouch);
1277 QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
1280 QTouchEvent::TouchPoint point;
1282 point.setPos(QPointF(60, 60));
1283 point.setScreenPos(point.pos());
1284 point.setState(Qt::TouchPointReleased);
1286 QTouchEvent event(QEvent::TouchEnd, device,
1288 Qt::TouchPointReleased,
1289 QList<QTouchEvent::TouchPoint>() << point);
1290 event.setAccepted(true);
1292 item->touchEventReached = false;
1294 bool accepted = canvas->event(&event);
1296 QCOMPARE(item->touchEventReached, itemSupportsTouch);
1297 QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
1304 void tst_qquickitem::polishOutsideAnimation()
1306 QQuickCanvas *canvas = new QQuickCanvas;
1307 canvas->resize(200, 200);
1310 TestPolishItem *item = new TestPolishItem(canvas->rootItem());
1311 item->setSize(QSizeF(200, 100));
1314 QTimer::singleShot(10, item, SLOT(doPolish()));
1315 QTRY_VERIFY(item->wasPolished);
1321 void tst_qquickitem::polishOnCompleted()
1323 QQuickView *view = new QQuickView;
1324 view->setSource(testFileUrl("polishOnCompleted.qml"));
1327 TestPolishItem *item = qobject_cast<TestPolishItem*>(view->rootObject());
1331 QSKIP("QTBUG-21590 view does not reliably receive polish without a running animation");
1334 QTRY_VERIFY(item->wasPolished);
1339 void tst_qquickitem::wheelEvent_data()
1341 QTest::addColumn<bool>("visible");
1342 QTest::addColumn<bool>("enabled");
1344 QTest::newRow("visible and enabled") << true << true;
1345 QTest::newRow("visible and disabled") << true << false;
1346 QTest::newRow("invisible and enabled") << false << true;
1347 QTest::newRow("invisible and disabled") << false << false;
1350 void tst_qquickitem::wheelEvent()
1352 QFETCH(bool, visible);
1353 QFETCH(bool, enabled);
1355 const bool shouldReceiveWheelEvents = visible && enabled;
1357 QQuickCanvas *canvas = new QQuickCanvas;
1358 canvas->resize(200, 200);
1361 TestItem *item = new TestItem;
1362 item->setSize(QSizeF(200, 100));
1363 item->setParentItem(canvas->rootItem());
1365 item->setEnabled(enabled);
1366 item->setVisible(visible);
1368 QWheelEvent event(QPoint(100, 50), -120, Qt::NoButton, Qt::NoModifier, Qt::Vertical);
1369 event.setAccepted(false);
1370 QGuiApplication::sendEvent(canvas, &event);
1372 if (shouldReceiveWheelEvents) {
1373 QVERIFY(event.isAccepted());
1374 QCOMPARE(item->wheelCount, 1);
1376 QVERIFY(!event.isAccepted());
1377 QCOMPARE(item->wheelCount, 0);
1383 class HoverItem : public QQuickItem
1387 HoverItem(QQuickItem *parent = 0)
1388 : QQuickItem(parent), hoverEnterCount(0), hoverMoveCount(0), hoverLeaveCount(0)
1390 void resetCounters() {
1391 hoverEnterCount = 0;
1393 hoverLeaveCount = 0;
1395 int hoverEnterCount;
1397 int hoverLeaveCount;
1399 virtual void hoverEnterEvent(QHoverEvent *event) {
1403 virtual void hoverMoveEvent(QHoverEvent *event) {
1407 virtual void hoverLeaveEvent(QHoverEvent *event) {
1413 void tst_qquickitem::hoverEvent_data()
1415 QTest::addColumn<bool>("visible");
1416 QTest::addColumn<bool>("enabled");
1417 QTest::addColumn<bool>("acceptHoverEvents");
1419 QTest::newRow("visible, enabled, accept hover") << true << true << true;
1420 QTest::newRow("visible, disabled, accept hover") << true << false << true;
1421 QTest::newRow("invisible, enabled, accept hover") << false << true << true;
1422 QTest::newRow("invisible, disabled, accept hover") << false << false << true;
1424 QTest::newRow("visible, enabled, not accept hover") << true << true << false;
1425 QTest::newRow("visible, disabled, not accept hover") << true << false << false;
1426 QTest::newRow("invisible, enabled, not accept hover") << false << true << false;
1427 QTest::newRow("invisible, disabled, not accept hover") << false << false << false;
1430 // ### For some unknown reason QTest::mouseMove() isn't working correctly.
1431 static void sendMouseMove(QObject *object, const QPoint &position)
1433 QMouseEvent moveEvent(QEvent::MouseMove, position, Qt::NoButton, Qt::NoButton, 0);
1434 QGuiApplication::sendEvent(object, &moveEvent);
1437 void tst_qquickitem::hoverEvent()
1439 QFETCH(bool, visible);
1440 QFETCH(bool, enabled);
1441 QFETCH(bool, acceptHoverEvents);
1443 QQuickCanvas *canvas = new QQuickCanvas();
1444 canvas->resize(200, 200);
1447 HoverItem *item = new HoverItem;
1448 item->setSize(QSizeF(100, 100));
1449 item->setParentItem(canvas->rootItem());
1451 item->setEnabled(enabled);
1452 item->setVisible(visible);
1453 item->setAcceptHoverEvents(acceptHoverEvents);
1455 const QPoint outside(150, 150);
1456 const QPoint inside(50, 50);
1457 const QPoint anotherInside(51, 51);
1459 sendMouseMove(canvas, outside);
1460 item->resetCounters();
1462 // Enter, then move twice inside, then leave.
1463 sendMouseMove(canvas, inside);
1464 sendMouseMove(canvas, anotherInside);
1465 sendMouseMove(canvas, inside);
1466 sendMouseMove(canvas, outside);
1468 const bool shouldReceiveHoverEvents = visible && enabled && acceptHoverEvents;
1469 if (shouldReceiveHoverEvents) {
1470 QCOMPARE(item->hoverEnterCount, 1);
1471 QCOMPARE(item->hoverMoveCount, 2);
1472 QCOMPARE(item->hoverLeaveCount, 1);
1474 QCOMPARE(item->hoverEnterCount, 0);
1475 QCOMPARE(item->hoverMoveCount, 0);
1476 QCOMPARE(item->hoverLeaveCount, 0);
1482 void tst_qquickitem::hoverEventInParent()
1484 QQuickCanvas *canvas = new QQuickCanvas();
1485 canvas->resize(200, 200);
1488 HoverItem *parentItem = new HoverItem(canvas->rootItem());
1489 parentItem->setSize(QSizeF(200, 200));
1490 parentItem->setAcceptHoverEvents(true);
1492 HoverItem *leftItem = new HoverItem(parentItem);
1493 leftItem->setSize(QSizeF(100, 200));
1494 leftItem->setAcceptHoverEvents(true);
1496 HoverItem *rightItem = new HoverItem(parentItem);
1497 rightItem->setSize(QSizeF(100, 200));
1498 rightItem->setPos(QPointF(100, 0));
1499 rightItem->setAcceptHoverEvents(true);
1501 const QPoint insideLeft(50, 100);
1502 const QPoint insideRight(150, 100);
1504 sendMouseMove(canvas, insideLeft);
1505 parentItem->resetCounters();
1506 leftItem->resetCounters();
1507 rightItem->resetCounters();
1509 sendMouseMove(canvas, insideRight);
1510 QCOMPARE(parentItem->hoverEnterCount, 0);
1511 QCOMPARE(parentItem->hoverLeaveCount, 0);
1512 QCOMPARE(leftItem->hoverEnterCount, 0);
1513 QCOMPARE(leftItem->hoverLeaveCount, 1);
1514 QCOMPARE(rightItem->hoverEnterCount, 1);
1515 QCOMPARE(rightItem->hoverLeaveCount, 0);
1517 sendMouseMove(canvas, insideLeft);
1518 QCOMPARE(parentItem->hoverEnterCount, 0);
1519 QCOMPARE(parentItem->hoverLeaveCount, 0);
1520 QCOMPARE(leftItem->hoverEnterCount, 1);
1521 QCOMPARE(leftItem->hoverLeaveCount, 1);
1522 QCOMPARE(rightItem->hoverEnterCount, 1);
1523 QCOMPARE(rightItem->hoverLeaveCount, 1);
1528 void tst_qquickitem::paintOrder_data()
1530 const QUrl order1Url = testFileUrl("order.1.qml");
1531 const QUrl order2Url = testFileUrl("order.2.qml");
1533 QTest::addColumn<QUrl>("source");
1534 QTest::addColumn<int>("op");
1535 QTest::addColumn<QVariant>("param1");
1536 QTest::addColumn<QVariant>("param2");
1537 QTest::addColumn<QStringList>("expected");
1539 QTest::newRow("test 1 noop") << order1Url
1540 << int(NoOp) << QVariant() << QVariant()
1541 << (QStringList() << "1" << "2" << "3");
1542 QTest::newRow("test 1 add") << order1Url
1543 << int(Append) << QVariant("new") << QVariant()
1544 << (QStringList() << "1" << "2" << "3" << "new");
1545 QTest::newRow("test 1 remove") << order1Url
1546 << int(Remove) << QVariant(1) << QVariant()
1547 << (QStringList() << "1" << "3");
1548 QTest::newRow("test 1 stack before") << order1Url
1549 << int(StackBefore) << QVariant(2) << QVariant(1)
1550 << (QStringList() << "1" << "3" << "2");
1551 QTest::newRow("test 1 stack after") << order1Url
1552 << int(StackAfter) << QVariant(0) << QVariant(1)
1553 << (QStringList() << "2" << "1" << "3");
1554 QTest::newRow("test 1 set z") << order1Url
1555 << int(SetZ) << QVariant(1) << QVariant(qreal(1.))
1556 << (QStringList() << "1" << "3" << "2");
1558 QTest::newRow("test 2 noop") << order2Url
1559 << int(NoOp) << QVariant() << QVariant()
1560 << (QStringList() << "1" << "3" << "2");
1561 QTest::newRow("test 2 add") << order2Url
1562 << int(Append) << QVariant("new") << QVariant()
1563 << (QStringList() << "1" << "3" << "new" << "2");
1564 QTest::newRow("test 2 remove 1") << order2Url
1565 << int(Remove) << QVariant(1) << QVariant()
1566 << (QStringList() << "1" << "3");
1567 QTest::newRow("test 2 remove 2") << order2Url
1568 << int(Remove) << QVariant(2) << QVariant()
1569 << (QStringList() << "1" << "2");
1570 QTest::newRow("test 2 stack before 1") << order2Url
1571 << int(StackBefore) << QVariant(1) << QVariant(0)
1572 << (QStringList() << "1" << "3" << "2");
1573 QTest::newRow("test 2 stack before 2") << order2Url
1574 << int(StackBefore) << QVariant(2) << QVariant(0)
1575 << (QStringList() << "3" << "1" << "2");
1576 QTest::newRow("test 2 stack after 1") << order2Url
1577 << int(StackAfter) << QVariant(0) << QVariant(1)
1578 << (QStringList() << "1" << "3" << "2");
1579 QTest::newRow("test 2 stack after 2") << order2Url
1580 << int(StackAfter) << QVariant(0) << QVariant(2)
1581 << (QStringList() << "3" << "1" << "2");
1582 QTest::newRow("test 1 set z") << order1Url
1583 << int(SetZ) << QVariant(2) << QVariant(qreal(2.))
1584 << (QStringList() << "1" << "2" << "3");
1587 void tst_qquickitem::paintOrder()
1589 QFETCH(QUrl, source);
1591 QFETCH(QVariant, param1);
1592 QFETCH(QVariant, param2);
1593 QFETCH(QStringList, expected);
1596 view.setSource(source);
1598 QQuickItem *root = qobject_cast<QQuickItem*>(view.rootObject());
1603 QQuickItem *item = new QQuickItem(root);
1604 item->setObjectName(param1.toString());
1608 QQuickItem *item = root->childItems().at(param1.toInt());
1613 QQuickItem *item1 = root->childItems().at(param1.toInt());
1614 QQuickItem *item2 = root->childItems().at(param2.toInt());
1615 item1->stackBefore(item2);
1619 QQuickItem *item1 = root->childItems().at(param1.toInt());
1620 QQuickItem *item2 = root->childItems().at(param2.toInt());
1621 item1->stackAfter(item2);
1625 QQuickItem *item = root->childItems().at(param1.toInt());
1626 item->setZ(param2.toReal());
1633 QList<QQuickItem*> list = QQuickItemPrivate::get(root)->paintOrderChildItems();
1636 for (int i = 0; i < list.count(); ++i)
1637 items << list.at(i)->objectName();
1639 QCOMPARE(items, expected);
1643 QTEST_MAIN(tst_qquickitem)
1645 #include "tst_qquickitem.moc"