X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tests%2Fauto%2Fquick%2Fqquickitem%2Ftst_qquickitem.cpp;h=0eb9d3e755abbef59f771c7789e407245a7a83d3;hb=feb996e3ab44e68082c97102556ea396f5df3f44;hp=9fdfa785595fed8eaea493c07dc325b32d834af9;hpb=67f589209dc856be3ac6261f51023125343812ce;p=profile%2Fivi%2Fqtdeclarative.git

diff --git a/tests/auto/quick/qquickitem/tst_qquickitem.cpp b/tests/auto/quick/qquickitem/tst_qquickitem.cpp
index 9fdfa78..0eb9d3e 100644
--- a/tests/auto/quick/qquickitem/tst_qquickitem.cpp
+++ b/tests/auto/quick/qquickitem/tst_qquickitem.cpp
@@ -42,7 +42,7 @@
 #include <qtest.h>
 
 #include <QtQuick/qquickitem.h>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
 #include <QtQuick/qquickview.h>
 #include <QtWidgets/QGraphicsSceneMouseEvent>
 #include "private/qquickfocusscope_p.h"
@@ -78,16 +78,16 @@ protected:
     virtual void wheelEvent(QWheelEvent *event) { event->accept(); ++wheelCount; }
 };
 
-class TestCanvas: public QQuickCanvas
+class TestWindow: public QQuickWindow
 {
 public:
-    TestCanvas()
-        : QQuickCanvas()
+    TestWindow()
+        : QQuickWindow()
     {}
 
     virtual bool event(QEvent *event)
     {
-        return QQuickCanvas::event(event);
+        return QQuickWindow::event(event);
     }
 };
 
@@ -133,12 +133,15 @@ public:
 private slots:
     void initTestCase();
 
-    void noCanvas();
+    void noWindow();
     void simpleFocus();
     void scopedFocus();
-    void addedToCanvas();
+    void addedToWindow();
     void changeParent();
     void multipleFocusClears();
+    void focusSubItemInNonFocusScope();
+    void parentItemWithFocus();
+    void reparentFocusedItem();
 
     void constructor();
     void setParentItem();
@@ -162,6 +165,8 @@ private slots:
     void paintOrder_data();
     void paintOrder();
 
+    void acceptedMouseButtons();
+
 private:
 
     enum PaintOrderOp {
@@ -171,7 +176,7 @@ private:
     void ensureFocus(QWindow *w) {
         w->show();
         w->requestActivateWindow();
-        qApp->processEvents();
+        QTest::qWaitForWindowActive(w);
     }
 };
 
@@ -181,8 +186,8 @@ void tst_qquickitem::initTestCase()
     qmlRegisterType<TestPolishItem>("Qt.test", 1, 0, "TestPolishItem");
 }
 
-// Focus has no effect when outside a canvas
-void tst_qquickitem::noCanvas()
+// Focus still updates when outside a window
+void tst_qquickitem::noWindow()
 {
     QQuickItem *root = new TestItem;
     QQuickItem *child = new TestItem(root);
@@ -199,9 +204,9 @@ void tst_qquickitem::noCanvas()
     root->setFocus(true);
     scope->setFocus(true);
     scopedChild2->setFocus(true);
-    QCOMPARE(root->hasFocus(), true);
+    QCOMPARE(root->hasFocus(), false);
     QCOMPARE(child->hasFocus(), false);
-    QCOMPARE(scope->hasFocus(), true);
+    QCOMPARE(scope->hasFocus(), false);
     QCOMPARE(scopedChild->hasFocus(), false);
     QCOMPARE(scopedChild2->hasFocus(), true);
 
@@ -210,10 +215,10 @@ void tst_qquickitem::noCanvas()
     scopedChild->setFocus(true);
     scope->setFocus(false);
     QCOMPARE(root->hasFocus(), false);
-    QCOMPARE(child->hasFocus(), true);
+    QCOMPARE(child->hasFocus(), false);
     QCOMPARE(scope->hasFocus(), false);
     QCOMPARE(scopedChild->hasFocus(), true);
-    QCOMPARE(scopedChild2->hasFocus(), true);
+    QCOMPARE(scopedChild2->hasFocus(), false);
 
     delete root;
 }
@@ -242,13 +247,13 @@ struct FocusState : public QHash<QQuickItem *, FocusData>
 #define FVERIFY() \
     do { \
         if (focusState.activeFocusItem) { \
-            QCOMPARE(canvas.activeFocusItem(), focusState.activeFocusItem); \
-            if (qobject_cast<TestItem *>(canvas.activeFocusItem())) \
-                QCOMPARE(qobject_cast<TestItem *>(canvas.activeFocusItem())->focused, true); \
-            else if (qobject_cast<TestFocusScope *>(canvas.activeFocusItem())) \
-                QCOMPARE(qobject_cast<TestFocusScope *>(canvas.activeFocusItem())->focused, true); \
+            QCOMPARE(window.activeFocusItem(), focusState.activeFocusItem); \
+            if (qobject_cast<TestItem *>(window.activeFocusItem())) \
+                QCOMPARE(qobject_cast<TestItem *>(window.activeFocusItem())->focused, true); \
+            else if (qobject_cast<TestFocusScope *>(window.activeFocusItem())) \
+                QCOMPARE(qobject_cast<TestFocusScope *>(window.activeFocusItem())->focused, true); \
         } else { \
-            QCOMPARE(canvas.activeFocusItem(), canvas.rootItem()); \
+            QCOMPARE(window.activeFocusItem(), window.rootItem()); \
         } \
         for (QHash<QQuickItem *, FocusData>::Iterator iter = focusState.begin(); \
             iter != focusState.end(); \
@@ -261,18 +266,18 @@ struct FocusState : public QHash<QQuickItem *, FocusData>
 // Tests a simple set of top-level scoped items
 void tst_qquickitem::simpleFocus()
 {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
 
 #ifdef Q_OS_MAC
     QSKIP("QTBUG-24094: fails on Mac OS X 10.7");
 #endif
 
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
 
-    QQuickItem *l1c1 = new TestItem(canvas.rootItem());
-    QQuickItem *l1c2 = new TestItem(canvas.rootItem());
-    QQuickItem *l1c3 = new TestItem(canvas.rootItem());
+    QQuickItem *l1c1 = new TestItem(window.rootItem());
+    QQuickItem *l1c2 = new TestItem(window.rootItem());
+    QQuickItem *l1c3 = new TestItem(window.rootItem());
 
     QQuickItem *l2c1 = new TestItem(l1c1);
     QQuickItem *l2c2 = new TestItem(l1c1);
@@ -317,13 +322,13 @@ void tst_qquickitem::simpleFocus()
 // Items with a focus scope
 void tst_qquickitem::scopedFocus()
 {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
 
-    QQuickItem *l1c1 = new TestItem(canvas.rootItem());
-    QQuickItem *l1c2 = new TestItem(canvas.rootItem());
-    QQuickItem *l1c3 = new TestItem(canvas.rootItem());
+    QQuickItem *l1c1 = new TestItem(window.rootItem());
+    QQuickItem *l1c2 = new TestItem(window.rootItem());
+    QQuickItem *l1c3 = new TestItem(window.rootItem());
 
     QQuickItem *l2c1 = new TestItem(l1c1);
     QQuickItem *l2c2 = new TestItem(l1c1);
@@ -393,13 +398,13 @@ void tst_qquickitem::scopedFocus()
     FVERIFY();
 }
 
-// Tests focus corrects itself when a tree is added to a canvas for the first time
-void tst_qquickitem::addedToCanvas()
+// Tests focus corrects itself when a tree is added to a window for the first time
+void tst_qquickitem::addedToWindow()
 {
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
 
     QQuickItem *item = new TestItem;
 
@@ -410,18 +415,18 @@ void tst_qquickitem::addedToCanvas()
     focusState[item].set(true, false);
     FVERIFY();
 
-    item->setParentItem(canvas.rootItem());
+    item->setParentItem(window.rootItem());
     focusState[item].set(true, true);
     focusState.active(item);
     FVERIFY();
     }
 
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
 
-    QQuickItem *item = new TestItem(canvas.rootItem());
+    QQuickItem *item = new TestItem(window.rootItem());
 
     QQuickItem *tree = new TestItem;
     QQuickItem *c1 = new TestItem(tree);
@@ -434,7 +439,7 @@ void tst_qquickitem::addedToCanvas()
     c1->setFocus(true);
     c2->setFocus(true);
     focusState[item].set(true, true);
-    focusState[c1].set(true, false);
+    focusState[c1].set(false, false);
     focusState[c2].set(true, false);
     focusState.active(item);
     FVERIFY();
@@ -446,9 +451,9 @@ void tst_qquickitem::addedToCanvas()
     }
 
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
 
     QQuickItem *tree = new TestItem;
     QQuickItem *c1 = new TestItem(tree);
@@ -458,21 +463,21 @@ void tst_qquickitem::addedToCanvas()
     focusState << tree << c1 << c2;
     c1->setFocus(true);
     c2->setFocus(true);
-    focusState[c1].set(true, false);
+    focusState[c1].set(false, false);
     focusState[c2].set(true, false);
     FVERIFY();
 
-    tree->setParentItem(canvas.rootItem());
-    focusState[c1].set(true, true);
-    focusState[c2].set(false, false);
-    focusState.active(c1);
+    tree->setParentItem(window.rootItem());
+    focusState[c1].set(false, false);
+    focusState[c2].set(true, true);
+    focusState.active(c2);
     FVERIFY();
     }
 
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
     QQuickItem *tree = new TestFocusScope;
     QQuickItem *c1 = new TestItem(tree);
     QQuickItem *c2 = new TestItem(tree);
@@ -481,26 +486,26 @@ void tst_qquickitem::addedToCanvas()
     focusState << tree << c1 << c2;
     c1->setFocus(true);
     c2->setFocus(true);
-    focusState[c1].set(true, false);
+    focusState[c1].set(false, false);
     focusState[c2].set(true, false);
     FVERIFY();
 
-    tree->setParentItem(canvas.rootItem());
-    focusState[c1].set(true, false);
-    focusState[c2].set(false, false);
+    tree->setParentItem(window.rootItem());
+    focusState[c1].set(false, false);
+    focusState[c2].set(true, false);
     FVERIFY();
 
     tree->setFocus(true);
     focusState[tree].set(true, true);
-    focusState[c1].set(true, true);
-    focusState.active(c1);
+    focusState[c2].set(true, true);
+    focusState.active(c2);
     FVERIFY();
     }
 
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
     QQuickItem *tree = new TestFocusScope;
     QQuickItem *c1 = new TestItem(tree);
     QQuickItem *c2 = new TestItem(tree);
@@ -511,23 +516,23 @@ void tst_qquickitem::addedToCanvas()
     c1->setFocus(true);
     c2->setFocus(true);
     focusState[tree].set(true, false);
-    focusState[c1].set(true, false);
+    focusState[c1].set(false, false);
     focusState[c2].set(true, false);
     FVERIFY();
 
-    tree->setParentItem(canvas.rootItem());
+    tree->setParentItem(window.rootItem());
     focusState[tree].set(true, true);
-    focusState[c1].set(true, true);
-    focusState[c2].set(false, false);
-    focusState.active(c1);
+    focusState[c1].set(false, false);
+    focusState[c2].set(true, true);
+    focusState.active(c2);
     FVERIFY();
     }
 
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
-    QQuickItem *child = new TestItem(canvas.rootItem());
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *child = new TestItem(window.rootItem());
     QQuickItem *tree = new TestFocusScope;
     QQuickItem *c1 = new TestItem(tree);
     QQuickItem *c2 = new TestItem(tree);
@@ -540,22 +545,22 @@ void tst_qquickitem::addedToCanvas()
     c2->setFocus(true);
     focusState[child].set(true, true);
     focusState[tree].set(true, false);
-    focusState[c1].set(true, false);
+    focusState[c1].set(false, false);
     focusState[c2].set(true, false);
     focusState.active(child);
     FVERIFY();
 
-    tree->setParentItem(canvas.rootItem());
+    tree->setParentItem(window.rootItem());
     focusState[tree].set(false, false);
-    focusState[c1].set(true, false);
-    focusState[c2].set(false, false);
+    focusState[c1].set(false, false);
+    focusState[c2].set(true, false);
     FVERIFY();
 
     tree->setFocus(true);
     focusState[child].set(false, false);
     focusState[tree].set(true, true);
-    focusState[c1].set(true, true);
-    focusState.active(c1);
+    focusState[c2].set(true, true);
+    focusState.active(c2);
     FVERIFY();
     }
 }
@@ -564,10 +569,10 @@ void tst_qquickitem::changeParent()
 {
     // Parent to no parent
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
-    QQuickItem *child = new TestItem(canvas.rootItem());
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *child = new TestItem(window.rootItem());
 
     FocusState focusState;
     focusState << child;
@@ -586,11 +591,11 @@ void tst_qquickitem::changeParent()
 
     // Different parent, same focus scope
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
-    QQuickItem *child = new TestItem(canvas.rootItem());
-    QQuickItem *child2 = new TestItem(canvas.rootItem());
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *child = new TestItem(window.rootItem());
+    QQuickItem *child2 = new TestItem(window.rootItem());
 
     FocusState focusState;
     focusState << child << child2;
@@ -607,11 +612,11 @@ void tst_qquickitem::changeParent()
 
     // Different parent, different focus scope
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
-    QQuickItem *child = new TestItem(canvas.rootItem());
-    QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *child = new TestItem(window.rootItem());
+    QQuickItem *child2 = new TestFocusScope(window.rootItem());
     QQuickItem *item = new TestItem(child);
 
     FocusState focusState;
@@ -629,11 +634,11 @@ void tst_qquickitem::changeParent()
     FVERIFY();
     }
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
-    QQuickItem *child = new TestItem(canvas.rootItem());
-    QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *child = new TestItem(window.rootItem());
+    QQuickItem *child2 = new TestFocusScope(window.rootItem());
     QQuickItem *item = new TestItem(child2);
 
     FocusState focusState;
@@ -651,11 +656,11 @@ void tst_qquickitem::changeParent()
     FVERIFY();
     }
     {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
-    QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
-    QQuickItem *child = new TestItem(canvas.rootItem());
-    QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *child = new TestItem(window.rootItem());
+    QQuickItem *child2 = new TestFocusScope(window.rootItem());
     QQuickItem *item = new TestItem(child2);
 
     FocusState focusState;
@@ -674,6 +679,41 @@ void tst_qquickitem::changeParent()
     FVERIFY();
     }
 
+    // child has active focus, then its fs parent changes parent to 0, then
+    // child is deleted, then its parent changes again to a valid parent
+    {
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    QQuickItem *item = new TestFocusScope(window.rootItem());
+    QQuickItem *child = new TestItem(item);
+    QQuickItem *child2 = new TestItem;
+
+    FocusState focusState;
+    focusState << item << child;
+    FVERIFY();
+
+    item->setFocus(true);
+    child->setFocus(true);
+    focusState[child].set(true, true);
+    focusState[item].set(true, true);
+    focusState.active(child);
+    FVERIFY();
+
+    item->setParentItem(0);
+    focusState[child].set(true, false);
+    focusState[item].set(true, false);
+    focusState.active(0);
+    FVERIFY();
+
+    focusState.remove(child);
+    delete child;
+    item->setParentItem(window.rootItem());
+    focusState[item].set(true, true);
+    focusState.active(item);
+    FVERIFY();
+    delete child2;
+    }
 }
 
 void tst_qquickitem::multipleFocusClears()
@@ -686,6 +726,159 @@ void tst_qquickitem::multipleFocusClears()
     QTRY_VERIFY(QGuiApplication::focusWindow() == view);
 }
 
+void tst_qquickitem::focusSubItemInNonFocusScope()
+{
+    QQuickView *view = new QQuickView;
+    view->setSource(testFileUrl("focusSubItemInNonFocusScope.qml"));
+    view->show();
+    qApp->processEvents();
+
+    QQuickItem *dummyItem = view->rootObject()->findChild<QQuickItem *>("dummyItem");
+    QVERIFY(dummyItem);
+
+    QQuickItem *textInput = view->rootObject()->findChild<QQuickItem *>("textInput");
+    QVERIFY(textInput);
+
+    QVERIFY(dummyItem->hasFocus());
+    QVERIFY(!textInput->hasFocus());
+    QVERIFY(dummyItem->hasActiveFocus());
+
+    QVERIFY(QMetaObject::invokeMethod(textInput, "forceActiveFocus"));
+
+    QVERIFY(!dummyItem->hasFocus());
+    QVERIFY(textInput->hasFocus());
+    QVERIFY(textInput->hasActiveFocus());
+
+    delete view;
+}
+
+void tst_qquickitem::parentItemWithFocus()
+{
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+    {
+    QQuickItem parent;
+    QQuickItem child;
+
+    FocusState focusState;
+    focusState << &parent << &child;
+    FVERIFY();
+
+    parent.setFocus(true);
+    child.setFocus(true);
+    focusState[&parent].set(true, false);
+    focusState[&child].set(true, false);
+    FVERIFY();
+
+    child.setParentItem(&parent);
+    focusState[&parent].set(true, false);
+    focusState[&child].set(false, false);
+    FVERIFY();
+
+    parent.setParentItem(window.rootItem());
+    focusState[&parent].set(true, true);
+    focusState[&child].set(false, false);
+    focusState.active(&parent);
+    FVERIFY();
+
+    child.forceActiveFocus();
+    focusState[&parent].set(false, false);
+    focusState[&child].set(true, true);
+    focusState.active(&child);
+    FVERIFY();
+    } {
+    QQuickItem parent;
+    QQuickItem child;
+    QQuickItem grandchild(&child);
+
+    FocusState focusState;
+    focusState << &parent << &child << &grandchild;
+    FVERIFY();
+
+    parent.setFocus(true);
+    grandchild.setFocus(true);
+    focusState[&parent].set(true, false);
+    focusState[&child].set(false, false);
+    focusState[&grandchild].set(true, false);
+    FVERIFY();
+
+    child.setParentItem(&parent);
+    focusState[&parent].set(true, false);
+    focusState[&child].set(false, false);
+    focusState[&grandchild].set(false, false);
+    FVERIFY();
+
+    parent.setParentItem(window.rootItem());
+    focusState[&parent].set(true, true);
+    focusState[&child].set(false, false);
+    focusState[&grandchild].set(false, false);
+    focusState.active(&parent);
+    FVERIFY();
+
+    grandchild.forceActiveFocus();
+    focusState[&parent].set(false, false);
+    focusState[&child].set(false, false);
+    focusState[&grandchild].set(true, true);
+    focusState.active(&grandchild);
+    FVERIFY();
+    }
+
+    {
+    QQuickItem parent;
+    QQuickItem child1;
+    QQuickItem child2;
+
+    FocusState focusState;
+    focusState << &parent << &child1 << &child2;
+    parent.setFocus(true);
+    child1.setParentItem(&parent);
+    child2.setParentItem(&parent);
+    focusState[&parent].set(true, false);
+    focusState[&child1].set(false, false);
+    focusState[&child2].set(false, false);
+    FVERIFY();
+
+    child1.setFocus(true);
+    focusState[&parent].set(false, false);
+    focusState[&child1].set(true, false);
+    FVERIFY();
+
+    parent.setFocus(true);
+    focusState[&parent].set(true, false);
+    focusState[&child1].set(false, false);
+    FVERIFY();
+    }
+}
+
+void tst_qquickitem::reparentFocusedItem()
+{
+    QQuickWindow window;
+    ensureFocus(&window);
+    QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+
+    QQuickItem parent(window.rootItem());
+    QQuickItem child(&parent);
+    QQuickItem sibling(&parent);
+    QQuickItem grandchild(&child);
+
+    FocusState focusState;
+    focusState << &parent << &child << &sibling << &grandchild;
+    FVERIFY();
+
+    grandchild.setFocus(true);
+    focusState[&parent].set(false, false);
+    focusState[&child].set(false, false);
+    focusState[&sibling].set(false, false);
+    focusState[&grandchild].set(true, true);
+    focusState.active(&grandchild);
+    FVERIFY();
+
+    // Parenting the item to another item within the same focus scope shouldn't change it's focus.
+    child.setParentItem(&sibling);
+    FVERIFY();
+}
+
 void tst_qquickitem::constructor()
 {
     QQuickItem *root = new QQuickItem;
@@ -829,8 +1022,8 @@ void tst_qquickitem::enabled()
 
 void tst_qquickitem::enabledFocus()
 {
-    QQuickCanvas canvas;
-    ensureFocus(&canvas);
+    QQuickWindow window;
+    ensureFocus(&window);
 
     QQuickFocusScope root;
 
@@ -841,18 +1034,18 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(root.hasFocus(), true);
     QCOMPARE(root.hasActiveFocus(), false);
 
-    root.setParentItem(canvas.rootItem());
+    root.setParentItem(window.rootItem());
 
     QCOMPARE(root.isEnabled(), false);
     QCOMPARE(root.hasFocus(), true);
     QCOMPARE(root.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+    QCOMPARE(window.activeFocusItem(), window.rootItem());
 
     root.setEnabled(true);
     QCOMPARE(root.isEnabled(), true);
     QCOMPARE(root.hasFocus(), true);
     QCOMPARE(root.hasActiveFocus(), true);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
 
     QQuickItem child1;
     child1.setParentItem(&root);
@@ -860,7 +1053,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child1.isEnabled(), true);
     QCOMPARE(child1.hasFocus(), false);
     QCOMPARE(child1.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
 
     QQuickItem child2;
     child2.setFocus(true);
@@ -872,7 +1065,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), true);
     QCOMPARE(child2.hasFocus(), true);
     QCOMPARE(child2.hasActiveFocus(), true);
-    QCOMPARE(canvas.activeFocusItem(), &child2);
+    QCOMPARE(window.activeFocusItem(), &child2);
 
     child2.setEnabled(false);
 
@@ -885,7 +1078,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), false);
     QCOMPARE(child2.hasFocus(), true);
     QCOMPARE(child2.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
 
     child1.setEnabled(false);
     QCOMPARE(child1.isEnabled(), false);
@@ -899,13 +1092,13 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), false);
     QCOMPARE(child2.hasFocus(), false);
     QCOMPARE(child2.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
 
     child1.setEnabled(true);
     QCOMPARE(child1.isEnabled(), true);
     QCOMPARE(child1.hasFocus(), true);
     QCOMPARE(child1.hasActiveFocus(), true);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&child1));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&child1));
 
     root.setFocus(false);
     QCOMPARE(root.isEnabled(), true);
@@ -914,7 +1107,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child1.isEnabled(), true);
     QCOMPARE(child1.hasFocus(), true);
     QCOMPARE(child1.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+    QCOMPARE(window.activeFocusItem(), window.rootItem());
 
     child2.forceActiveFocus();
     QCOMPARE(root.isEnabled(), true);
@@ -926,7 +1119,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), false);
     QCOMPARE(child2.hasFocus(), true);
     QCOMPARE(child2.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
 
     root.setEnabled(false);
     QCOMPARE(root.isEnabled(), false);
@@ -938,7 +1131,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), false);
     QCOMPARE(child2.hasFocus(), true);
     QCOMPARE(child2.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+    QCOMPARE(window.activeFocusItem(), window.rootItem());
 
     child1.forceActiveFocus();
     QCOMPARE(root.isEnabled(), false);
@@ -950,7 +1143,7 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), false);
     QCOMPARE(child2.hasFocus(), false);
     QCOMPARE(child2.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+    QCOMPARE(window.activeFocusItem(), window.rootItem());
 
     root.setEnabled(true);
     QCOMPARE(root.isEnabled(), true);
@@ -962,83 +1155,83 @@ void tst_qquickitem::enabledFocus()
     QCOMPARE(child2.isEnabled(), false);
     QCOMPARE(child2.hasFocus(), false);
     QCOMPARE(child2.hasActiveFocus(), false);
-    QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&child1));
+    QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&child1));
 }
 
 void tst_qquickitem::mouseGrab()
 {
-    QQuickCanvas *canvas = new QQuickCanvas;
-    canvas->resize(200, 200);
-    canvas->show();
+    QQuickWindow *window = new QQuickWindow;
+    window->resize(200, 200);
+    window->show();
 
     TestItem *child1 = new TestItem;
     child1->setAcceptedMouseButtons(Qt::LeftButton);
     child1->setSize(QSizeF(200, 100));
-    child1->setParentItem(canvas->rootItem());
+    child1->setParentItem(window->rootItem());
 
     TestItem *child2 = new TestItem;
     child2->setAcceptedMouseButtons(Qt::LeftButton);
     child2->setY(51);
     child2->setSize(QSizeF(200, 100));
-    child2->setParentItem(canvas->rootItem());
+    child2->setParentItem(window->rootItem());
 
-    QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(100);
-    QVERIFY(canvas->mouseGrabberItem() == child1);
+    QVERIFY(window->mouseGrabberItem() == child1);
     QTest::qWait(100);
 
     QCOMPARE(child1->pressCount, 1);
-    QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
-    QVERIFY(canvas->mouseGrabberItem() == 0);
+    QVERIFY(window->mouseGrabberItem() == 0);
     QCOMPARE(child1->releaseCount, 1);
 
-    QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
-    QVERIFY(canvas->mouseGrabberItem() == child1);
+    QVERIFY(window->mouseGrabberItem() == child1);
     QCOMPARE(child1->pressCount, 2);
     child1->setEnabled(false);
-    QVERIFY(canvas->mouseGrabberItem() == 0);
-    QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QVERIFY(window->mouseGrabberItem() == 0);
+    QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
     QCOMPARE(child1->releaseCount, 1);
     child1->setEnabled(true);
 
-    QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
-    QVERIFY(canvas->mouseGrabberItem() == child1);
+    QVERIFY(window->mouseGrabberItem() == child1);
     QCOMPARE(child1->pressCount, 3);
     child1->setVisible(false);
-    QVERIFY(canvas->mouseGrabberItem() == 0);
-    QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QVERIFY(window->mouseGrabberItem() == 0);
+    QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
     QCOMPARE(child1->releaseCount, 1);
     child1->setVisible(true);
 
-    QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
-    QVERIFY(canvas->mouseGrabberItem() == child1);
+    QVERIFY(window->mouseGrabberItem() == child1);
     QCOMPARE(child1->pressCount, 4);
     child2->grabMouse();
-    QVERIFY(canvas->mouseGrabberItem() == child2);
-    QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QVERIFY(window->mouseGrabberItem() == child2);
+    QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
     QCOMPARE(child1->releaseCount, 1);
     QCOMPARE(child2->releaseCount, 1);
 
     child2->grabMouse();
-    QVERIFY(canvas->mouseGrabberItem() == child2);
-    QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QVERIFY(window->mouseGrabberItem() == child2);
+    QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
     QCOMPARE(child1->pressCount, 4);
     QCOMPARE(child2->pressCount, 1);
-    QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+    QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
     QTest::qWait(50);
     QCOMPARE(child1->releaseCount, 1);
     QCOMPARE(child2->releaseCount, 2);
 
     delete child1;
     delete child2;
-    delete canvas;
+    delete window;
 }
 
 void tst_qquickitem::touchEventAcceptIgnore_data()
@@ -1053,13 +1246,13 @@ void tst_qquickitem::touchEventAcceptIgnore()
 {
     QFETCH(bool, itemSupportsTouch);
 
-    TestCanvas *canvas = new TestCanvas;
-    canvas->resize(100, 100);
-    canvas->show();
+    TestWindow *window = new TestWindow;
+    window->resize(100, 100);
+    window->show();
 
     TestItem *item = new TestItem;
     item->setSize(QSizeF(100, 100));
-    item->setParentItem(canvas->rootItem());
+    item->setParentItem(window->rootItem());
     item->acceptIncomingTouchEvents = itemSupportsTouch;
 
     static QTouchDevice* device = 0;
@@ -1085,7 +1278,7 @@ void tst_qquickitem::touchEventAcceptIgnore()
 
         item->touchEventReached = false;
 
-        bool accepted = canvas->event(&event);
+        bool accepted = window->event(&event);
 
         QVERIFY(item->touchEventReached);
         QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
@@ -1105,7 +1298,7 @@ void tst_qquickitem::touchEventAcceptIgnore()
 
         item->touchEventReached = false;
 
-        bool accepted = canvas->event(&event);
+        bool accepted = window->event(&event);
 
         QCOMPARE(item->touchEventReached, itemSupportsTouch);
         QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
@@ -1125,23 +1318,23 @@ void tst_qquickitem::touchEventAcceptIgnore()
 
         item->touchEventReached = false;
 
-        bool accepted = canvas->event(&event);
+        bool accepted = window->event(&event);
 
         QCOMPARE(item->touchEventReached, itemSupportsTouch);
         QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
     }
 
     delete item;
-    delete canvas;
+    delete window;
 }
 
 void tst_qquickitem::polishOutsideAnimation()
 {
-    QQuickCanvas *canvas = new QQuickCanvas;
-    canvas->resize(200, 200);
-    canvas->show();
+    QQuickWindow *window = new QQuickWindow;
+    window->resize(200, 200);
+    window->show();
 
-    TestPolishItem *item = new TestPolishItem(canvas->rootItem());
+    TestPolishItem *item = new TestPolishItem(window->rootItem());
     item->setSize(QSizeF(200, 100));
     QTest::qWait(50);
 
@@ -1149,7 +1342,7 @@ void tst_qquickitem::polishOutsideAnimation()
     QTRY_VERIFY(item->wasPolished);
 
     delete item;
-    delete canvas;
+    delete window;
 }
 
 void tst_qquickitem::polishOnCompleted()
@@ -1161,10 +1354,6 @@ void tst_qquickitem::polishOnCompleted()
     TestPolishItem *item = qobject_cast<TestPolishItem*>(view->rootObject());
     QVERIFY(item);
 
-#ifdef Q_OS_MAC
-    QSKIP("QTBUG-21590 view does not reliably receive polish without a running animation");
-#endif
-
     QTRY_VERIFY(item->wasPolished);
 
     delete view;
@@ -1188,20 +1377,20 @@ void tst_qquickitem::wheelEvent()
 
     const bool shouldReceiveWheelEvents = visible && enabled;
 
-    QQuickCanvas *canvas = new QQuickCanvas;
-    canvas->resize(200, 200);
-    canvas->show();
+    QQuickWindow *window = new QQuickWindow;
+    window->resize(200, 200);
+    window->show();
 
     TestItem *item = new TestItem;
     item->setSize(QSizeF(200, 100));
-    item->setParentItem(canvas->rootItem());
+    item->setParentItem(window->rootItem());
 
     item->setEnabled(enabled);
     item->setVisible(visible);
 
     QWheelEvent event(QPoint(100, 50), -120, Qt::NoButton, Qt::NoModifier, Qt::Vertical);
     event.setAccepted(false);
-    QGuiApplication::sendEvent(canvas, &event);
+    QGuiApplication::sendEvent(window, &event);
 
     if (shouldReceiveWheelEvents) {
         QVERIFY(event.isAccepted());
@@ -1211,7 +1400,7 @@ void tst_qquickitem::wheelEvent()
         QCOMPARE(item->wheelCount, 0);
     }
 
-    delete canvas;
+    delete window;
 }
 
 class HoverItem : public QQuickItem
@@ -1274,13 +1463,13 @@ void tst_qquickitem::hoverEvent()
     QFETCH(bool, enabled);
     QFETCH(bool, acceptHoverEvents);
 
-    QQuickCanvas *canvas = new QQuickCanvas();
-    canvas->resize(200, 200);
-    canvas->show();
+    QQuickWindow *window = new QQuickWindow();
+    window->resize(200, 200);
+    window->show();
 
     HoverItem *item = new HoverItem;
     item->setSize(QSizeF(100, 100));
-    item->setParentItem(canvas->rootItem());
+    item->setParentItem(window->rootItem());
 
     item->setEnabled(enabled);
     item->setVisible(visible);
@@ -1290,14 +1479,14 @@ void tst_qquickitem::hoverEvent()
     const QPoint inside(50, 50);
     const QPoint anotherInside(51, 51);
 
-    sendMouseMove(canvas, outside);
+    sendMouseMove(window, outside);
     item->resetCounters();
 
     // Enter, then move twice inside, then leave.
-    sendMouseMove(canvas, inside);
-    sendMouseMove(canvas, anotherInside);
-    sendMouseMove(canvas, inside);
-    sendMouseMove(canvas, outside);
+    sendMouseMove(window, inside);
+    sendMouseMove(window, anotherInside);
+    sendMouseMove(window, inside);
+    sendMouseMove(window, outside);
 
     const bool shouldReceiveHoverEvents = visible && enabled && acceptHoverEvents;
     if (shouldReceiveHoverEvents) {
@@ -1310,16 +1499,16 @@ void tst_qquickitem::hoverEvent()
         QCOMPARE(item->hoverLeaveCount, 0);
     }
 
-    delete canvas;
+    delete window;
 }
 
 void tst_qquickitem::hoverEventInParent()
 {
-    QQuickCanvas *canvas = new QQuickCanvas();
-    canvas->resize(200, 200);
-    canvas->show();
+    QQuickWindow *window = new QQuickWindow();
+    window->resize(200, 200);
+    window->show();
 
-    HoverItem *parentItem = new HoverItem(canvas->rootItem());
+    HoverItem *parentItem = new HoverItem(window->rootItem());
     parentItem->setSize(QSizeF(200, 200));
     parentItem->setAcceptHoverEvents(true);
 
@@ -1335,12 +1524,12 @@ void tst_qquickitem::hoverEventInParent()
     const QPoint insideLeft(50, 100);
     const QPoint insideRight(150, 100);
 
-    sendMouseMove(canvas, insideLeft);
+    sendMouseMove(window, insideLeft);
     parentItem->resetCounters();
     leftItem->resetCounters();
     rightItem->resetCounters();
 
-    sendMouseMove(canvas, insideRight);
+    sendMouseMove(window, insideRight);
     QCOMPARE(parentItem->hoverEnterCount, 0);
     QCOMPARE(parentItem->hoverLeaveCount, 0);
     QCOMPARE(leftItem->hoverEnterCount, 0);
@@ -1348,7 +1537,7 @@ void tst_qquickitem::hoverEventInParent()
     QCOMPARE(rightItem->hoverEnterCount, 1);
     QCOMPARE(rightItem->hoverLeaveCount, 0);
 
-    sendMouseMove(canvas, insideLeft);
+    sendMouseMove(window, insideLeft);
     QCOMPARE(parentItem->hoverEnterCount, 0);
     QCOMPARE(parentItem->hoverLeaveCount, 0);
     QCOMPARE(leftItem->hoverEnterCount, 1);
@@ -1356,7 +1545,7 @@ void tst_qquickitem::hoverEventInParent()
     QCOMPARE(rightItem->hoverEnterCount, 1);
     QCOMPARE(rightItem->hoverLeaveCount, 1);
 
-    delete canvas;
+    delete window;
 }
 
 void tst_qquickitem::paintOrder_data()
@@ -1473,6 +1662,67 @@ void tst_qquickitem::paintOrder()
     QCOMPARE(items, expected);
 }
 
+void tst_qquickitem::acceptedMouseButtons()
+{
+    TestItem item;
+    QCOMPARE(item.acceptedMouseButtons(), Qt::MouseButtons(Qt::NoButton));
+
+    QQuickWindow window;
+    item.setSize(QSizeF(200,100));
+    item.setParentItem(window.rootItem());
+
+    QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 0);
+    QCOMPARE(item.releaseCount, 0);
+
+    QTest::mousePress(&window, Qt::RightButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::RightButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 0);
+    QCOMPARE(item.releaseCount, 0);
+
+    QTest::mousePress(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 0);
+    QCOMPARE(item.releaseCount, 0);
+
+    item.setAcceptedMouseButtons(Qt::LeftButton);
+    QCOMPARE(item.acceptedMouseButtons(), Qt::MouseButtons(Qt::LeftButton));
+
+    QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 1);
+    QCOMPARE(item.releaseCount, 1);
+
+    QTest::mousePress(&window, Qt::RightButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::RightButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 1);
+    QCOMPARE(item.releaseCount, 1);
+
+    QTest::mousePress(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 1);
+    QCOMPARE(item.releaseCount, 1);
+
+    item.setAcceptedMouseButtons(Qt::RightButton | Qt::MiddleButton);
+    QCOMPARE(item.acceptedMouseButtons(), Qt::MouseButtons(Qt::RightButton | Qt::MiddleButton));
+
+    QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 1);
+    QCOMPARE(item.releaseCount, 1);
+
+    QTest::mousePress(&window, Qt::RightButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::RightButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 2);
+    QCOMPARE(item.releaseCount, 2);
+
+    QTest::mousePress(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+    QTest::mouseRelease(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+    QCOMPARE(item.pressCount, 3);
+    QCOMPARE(item.releaseCount, 3);
+}
+
 
 QTEST_MAIN(tst_qquickitem)