tests/auto/quick/qquickdroparea/tst_qquickdroparea.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the test suite of the Qt Toolkit.
   7 **
   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.
  16 **
  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.
  20 **
  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.
  28 **
  29 ** Other Usage
  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.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtTest/QtTest>
  43 #include <QtTest/QSignalSpy>
  44 #include <QtQuick/qquickitem.h>
  45 #include <QtQuick/qquickview.h>
  46 #include <QtQml/qqmlcontext.h>
  47 #include <QtQml/qqmlengine.h>
  48 #include <QtQml/qqmlexpression.h>
  49
  50 #include <qpa/qplatformdrag.h>
  51
  52 template <typename T> static T evaluate(QObject *scope, const QString &expression)
  53 {
  54     QQmlExpression expr(qmlContext(scope), scope, expression);
  55     QVariant result = expr.evaluate();
  56     if (expr.hasError())
  57         qWarning() << expr.error().toString();
  58     return result.value<T>();
  59 }
  60
  61 template <> void evaluate<void>(QObject *scope, const QString &expression)
  62 {
  63     QQmlExpression expr(qmlContext(scope), scope, expression);
  64     expr.evaluate();
  65     if (expr.hasError())
  66         qWarning() << expr.error().toString();
  67 }
  68
  69 class tst_QQuickDropArea: public QObject
  70 {
  71     Q_OBJECT
  72 private slots:
  73     void initTestCase();
  74     void cleanupTestCase();
  75
  76     void containsDrag_internal();
  77     void containsDrag_external();
  78     void keys_internal();
  79     void keys_external();
  80     void source_internal();
  81 //    void source_external();
  82     void position_internal();
  83     void position_external();
  84     void drop_internal();
  85 //    void drop_external();
  86     void simultaneousDrags();
  87
  88 private:
  89     QQmlEngine engine;
  90 };
  91
  92 void tst_QQuickDropArea::initTestCase()
  93 {
  94
  95 }
  96
  97 void tst_QQuickDropArea::cleanupTestCase()
  98 {
  99
 100 }
 101
 102 void tst_QQuickDropArea::containsDrag_internal()
 103 {
 104     QQuickCanvas canvas;
 105     QQmlComponent component(&engine);
 106     component.setData(
 107             "import QtQuick 2.0\n"
 108             "DropArea {\n"
 109                 "property bool hasDrag: containsDrag\n"
 110                 "property int enterEvents: 0\n"
 111                 "property int exitEvents: 0\n"
 112                 "width: 100; height: 100\n"
 113                 "onEntered: {++enterEvents}\n"
 114                 "onExited: {++exitEvents}\n"
 115                 "Item {\n"
 116                     "objectName: \"dragItem\"\n"
 117                     "x: 50; y: 50\n"
 118                     "width: 10; height: 10\n"
 119                 "}\n"
 120             "}", QUrl());
 121     QScopedPointer<QObject> object(component.create());
 122     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 123     QVERIFY(dropArea);
 124     dropArea->setParentItem(canvas.rootItem());
 125
 126     QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
 127     QVERIFY(dragItem);
 128
 129     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 130     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 131
 132     evaluate<void>(dragItem, "Drag.active = true");
 133     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 134     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), true);
 135     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 136     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
 137
 138     evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
 139     evaluate<void>(dragItem, "Drag.active = false");
 140     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 141     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 142     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 143     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 1);
 144
 145     evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
 146
 147     dragItem->setPos(QPointF(150, 50));
 148     evaluate<void>(dragItem, "Drag.active = true");
 149     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 150     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 151     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 152     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
 153
 154     dragItem->setPos(QPointF(50, 50));
 155     QCoreApplication::processEvents();
 156     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 157     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), true);
 158     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 159     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
 160
 161     evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
 162     dragItem->setPos(QPointF(150, 50));
 163     QCoreApplication::processEvents();
 164
 165     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 166     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 167     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 168     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 1);
 169
 170     evaluate<void>(dragItem, "Drag.active = false");
 171 }
 172
 173 void tst_QQuickDropArea::containsDrag_external()
 174 {
 175     QQuickCanvas canvas;
 176     QQmlComponent component(&engine);
 177     component.setData(
 178             "import QtQuick 2.0\n"
 179             "DropArea {\n"
 180                 "property bool hasDrag: containsDrag\n"
 181                 "property int enterEvents: 0\n"
 182                 "property int exitEvents: 0\n"
 183                 "width: 100; height: 100\n"
 184                 "onEntered: {++enterEvents}\n"
 185                 "onExited: {++exitEvents}\n"
 186             "}", QUrl());
 187     QScopedPointer<QObject> object(component.create());
 188     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 189     QVERIFY(dropArea);
 190     dropArea->setParentItem(canvas.rootItem());
 191
 192     QMimeData data;
 193     QQuickCanvas alternateCanvas;
 194
 195     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 196     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 197
 198     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 199     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 200     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), true);
 201     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 202     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
 203
 204     evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
 205     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 206     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 207     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 208     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 209     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 1);
 210
 211     evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
 212
 213     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(150, 50), Qt::CopyAction);
 214     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 215     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 216     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 217     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
 218
 219     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 220     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 221     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), true);
 222     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 223     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
 224
 225     evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
 226
 227     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(150, 50), Qt::CopyAction);
 228     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 229     QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
 230     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 231     QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 1);
 232
 233     QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(150, 50), Qt::CopyAction);
 234 }
 235
 236 void tst_QQuickDropArea::keys_internal()
 237 {
 238     QQuickCanvas canvas;
 239     QQmlComponent component(&engine);
 240     component.setData(
 241             "import QtQuick 2.0\n"
 242             "DropArea {\n"
 243                 "property variant dragKeys\n"
 244                 "property variant dropKeys: keys\n"
 245                 "property int enterEvents: 0\n"
 246                 "width: 100; height: 100\n"
 247                 "onEntered: {++enterEvents; dragKeys = drag.keys }\n"
 248                 "Item {\n"
 249                     "objectName: \"dragItem\"\n"
 250                     "x: 50; y: 50\n"
 251                     "width: 10; height: 10\n"
 252                     "Drag.keys: [\"red\", \"blue\"]\n"
 253                 "}\n"
 254             "}", QUrl());
 255     QScopedPointer<QObject> object(component.create());
 256     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 257     QVERIFY(dropArea);
 258     dropArea->setParentItem(canvas.rootItem());
 259
 260     QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
 261     QVERIFY(dragItem);
 262
 263     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 264
 265     evaluate<void>(dragItem, "Drag.active = true");
 266     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 267     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 268     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "red" << "blue");
 269
 270     evaluate<void>(dragItem, "Drag.active = false");
 271     evaluate<void>(dropArea, "keys = \"blue\"");
 272     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "blue");
 273     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "blue");
 274     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 275     evaluate<void>(dragItem, "Drag.active = true");
 276     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 277     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 278     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "red" << "blue");
 279
 280     evaluate<void>(dragItem, "Drag.active = false");
 281     evaluate<void>(dropArea, "keys = \"red\"");
 282     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "red");
 283     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "red");
 284     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 285     evaluate<void>(dragItem, "Drag.active = true");
 286     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 287     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 288     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "red" << "blue");
 289
 290     evaluate<void>(dragItem, "Drag.active = false");
 291     evaluate<void>(dropArea, "keys = \"green\"");
 292     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "green");
 293     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "green");
 294     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 295     evaluate<void>(dragItem, "Drag.active = true");
 296     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 297     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 298
 299     evaluate<void>(dragItem, "Drag.active = false");
 300     evaluate<void>(dropArea, "keys = [\"red\", \"green\"]");
 301     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "red" << "green");
 302     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "red" << "green");
 303     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 304     evaluate<void>(dragItem, "Drag.active = true");
 305     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 306     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 307     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "red" << "blue");
 308
 309     evaluate<void>(dragItem, "Drag.active = false");
 310     evaluate<void>(dragItem, "Drag.keys = []");
 311     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 312     evaluate<void>(dragItem, "Drag.active = true");
 313     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 314     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 315
 316     evaluate<void>(dragItem, "Drag.active = false");
 317     evaluate<void>(dropArea, "keys = []");
 318     QCOMPARE(dropArea->property("keys").toStringList(), QStringList());
 319     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList());
 320     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 321     evaluate<void>(dragItem, "Drag.active = true");
 322     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 323     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 324     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList());
 325
 326     evaluate<void>(dragItem, "Drag.active = false");
 327     evaluate<void>(dropArea, "keys = []");
 328     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 329     evaluate<void>(dragItem, "Drag.active = true");
 330     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 331     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 332     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList());
 333
 334     evaluate<void>(dragItem, "Drag.active = false");
 335     evaluate<void>(dragItem, "Drag.keys = [\"red\", \"blue\"]");
 336     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 337     evaluate<void>(dragItem, "Drag.active = true");
 338     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 339     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 340     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "red" << "blue");
 341 }
 342
 343 void tst_QQuickDropArea::keys_external()
 344 {
 345     QQuickCanvas canvas;
 346     QQmlComponent component(&engine);
 347     component.setData(
 348             "import QtQuick 2.0\n"
 349             "DropArea {\n"
 350                 "property variant dragKeys\n"
 351                 "property variant dropKeys: keys\n"
 352                 "property int enterEvents: 0\n"
 353                 "width: 100; height: 100\n"
 354                 "onEntered: {++enterEvents; dragKeys = drag.keys }\n"
 355             "}", QUrl());
 356     QScopedPointer<QObject> object(component.create());
 357     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 358     dropArea->setParentItem(canvas.rootItem());
 359
 360     QMimeData data;
 361     QQuickCanvas alternateCanvas;
 362
 363     data.setData("text/x-red", "red");
 364     data.setData("text/x-blue", "blue");
 365
 366     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 367
 368     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 369     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 370     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 371     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
 372
 373     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 374     evaluate<void>(dropArea, "keys = \"text/x-blue\"");
 375     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-blue");
 376     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-blue");
 377     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 378     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 379     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 380     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 381     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
 382
 383     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 384     evaluate<void>(dropArea, "keys = \"text/x-red\"");
 385     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-red");
 386     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-red");
 387     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 388     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 389     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 390     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 391     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
 392
 393     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 394     evaluate<void>(dropArea, "keys = \"text/x-green\"");
 395     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-green");
 396     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-green");
 397     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 398     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 399     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 400     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 401
 402     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 403     evaluate<void>(dropArea, "keys = [\"text/x-red\", \"text/x-green\"]");
 404     QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-red" << "text/x-green");
 405     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-red" << "text/x-green");
 406     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 407     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 408     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 409     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 410     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
 411
 412     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 413     data.removeFormat("text/x-red");
 414     data.removeFormat("text/x-blue");
 415     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 416     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 417     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
 418     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 419
 420     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 421     evaluate<void>(dropArea, "keys = []");
 422     QCOMPARE(dropArea->property("keys").toStringList(), QStringList());
 423     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList());
 424     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 425     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 426     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 427     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 428     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList());
 429
 430     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 431     data.setData("text/x-red", "red");
 432     data.setData("text/x-blue", "blue");
 433     QCOMPARE(dropArea->property("keys").toStringList(), QStringList());
 434     QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList());
 435     evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
 436     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 437     QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
 438     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 439     QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
 440
 441     QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 442 }
 443
 444 void tst_QQuickDropArea::source_internal()
 445 {
 446     QQuickCanvas canvas;
 447     QQmlComponent component(&engine);
 448     component.setData(
 449             "import QtQuick 2.0\n"
 450             "DropArea {\n"
 451                 "property Item source: drag.source\n"
 452                 "property Item eventSource\n"
 453                 "width: 100; height: 100\n"
 454                 "onEntered: {eventSource = drag.source}\n"
 455                 "Item {\n"
 456                     "objectName: \"dragItem\"\n"
 457                     "x: 50; y: 50\n"
 458                     "width: 10; height: 10\n"
 459                 "}\n"
 460                 "Item { id: dragSource; objectName: \"dragSource\" }\n"
 461             "}", QUrl());
 462     QScopedPointer<QObject> object(component.create());
 463     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 464     QVERIFY(dropArea);
 465     dropArea->setParentItem(canvas.rootItem());
 466
 467     QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
 468     QVERIFY(dragItem);
 469
 470     QQuickItem *dragSource = dropArea->findChild<QQuickItem *>("dragSource");
 471     QVERIFY(dragSource);
 472
 473     QCOMPARE(evaluate<QObject *>(dropArea, "source"), static_cast<QObject *>(0));
 474     QCOMPARE(evaluate<QObject *>(dropArea, "drag.source"), static_cast<QObject *>(0));
 475
 476     evaluate<void>(dragItem, "Drag.active = true");
 477     QCOMPARE(evaluate<QObject *>(dropArea, "source"), static_cast<QObject *>(dragItem));
 478     QCOMPARE(evaluate<QObject *>(dropArea, "drag.source"), static_cast<QObject *>(dragItem));
 479     QCOMPARE(evaluate<QObject *>(dropArea, "eventSource"), static_cast<QObject *>(dragItem));
 480
 481     evaluate<void>(dragItem, "Drag.active = false");
 482     QCOMPARE(evaluate<QObject *>(dropArea, "source"), static_cast<QObject *>(0));
 483     QCOMPARE(evaluate<QObject *>(dropArea, "drag.source"), static_cast<QObject *>(0));
 484
 485
 486     evaluate<void>(dropArea, "{ eventSource = null }");
 487     evaluate<void>(dragItem, "Drag.source = dragSource");
 488
 489     evaluate<void>(dragItem, "Drag.active = true");
 490     QCOMPARE(evaluate<QObject *>(dropArea, "source"), static_cast<QObject *>(dragSource));
 491     QCOMPARE(evaluate<QObject *>(dropArea, "drag.source"), static_cast<QObject *>(dragSource));
 492     QCOMPARE(evaluate<QObject *>(dropArea, "eventSource"), static_cast<QObject *>(dragSource));
 493
 494     evaluate<void>(dragItem, "Drag.active = false");
 495     QCOMPARE(evaluate<QObject *>(dropArea, "source"), static_cast<QObject *>(0));
 496     QCOMPARE(evaluate<QObject *>(dropArea, "drag.source"), static_cast<QObject *>(0));
 497 }
 498
 499 // Setting a source can't be emulated using the QWindowSystemInterface API.
 500
 501 //void tst_QQuickDropArea::source_external()
 502 //{
 503 //}
 504
 505 void tst_QQuickDropArea::position_internal()
 506 {
 507     QQuickCanvas canvas;
 508     QQmlComponent component(&engine);
 509     component.setData(
 510             "import QtQuick 2.0\n"
 511             "DropArea {\n"
 512                 "property real dragX: drag.x\n"
 513                 "property real dragY: drag.y\n"
 514                 "property real eventX\n"
 515                 "property real eventY\n"
 516                 "property int enterEvents: 0\n"
 517                 "property int moveEvents: 0\n"
 518                 "width: 100; height: 100\n"
 519                 "onEntered: {++enterEvents; eventX = drag.x; eventY = drag.y}\n"
 520                 "onPositionChanged: {++moveEvents; eventX = drag.x; eventY = drag.y}\n"
 521                 "Item {\n"
 522                     "objectName: \"dragItem\"\n"
 523                     "x: 50; y: 50\n"
 524                     "width: 10; height: 10\n"
 525                 "}\n"
 526             "}", QUrl());
 527     QScopedPointer<QObject> object(component.create());
 528     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 529     QVERIFY(dropArea);
 530     dropArea->setParentItem(canvas.rootItem());
 531
 532     QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
 533     QVERIFY(dragItem);
 534
 535     evaluate<void>(dragItem, "Drag.active = true");
 536     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 537     QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 0);
 538     QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(50));
 539     QCOMPARE(evaluate<qreal>(dropArea, "drag.y"), qreal(50));
 540     QCOMPARE(evaluate<qreal>(dropArea, "dragX"), qreal(50));
 541     QCOMPARE(evaluate<qreal>(dropArea, "dragY"), qreal(50));
 542     QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(50));
 543     QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(50));
 544
 545     evaluate<void>(dropArea, "{ enterEvents = 0; moveEvents = 0; eventX = -1; eventY = -1 }");
 546     dragItem->setPos(QPointF(40, 50));
 547     QCoreApplication::processEvents();
 548     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 549     QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
 550     QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(40));
 551     QCOMPARE(evaluate<qreal>(dropArea, "drag.y"), qreal(50));
 552     QCOMPARE(evaluate<qreal>(dropArea, "dragX"), qreal(40));
 553     QCOMPARE(evaluate<qreal>(dropArea, "dragY"), qreal(50));
 554     QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(40));
 555     QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(50));
 556
 557     evaluate<void>(dropArea, "{ enterEvents = 0; moveEvents = 0; eventX = -1; eventY = -1 }");
 558     dragItem->setPos(QPointF(75, 25));
 559     QCoreApplication::processEvents();
 560     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 561     QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
 562     QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(75));
 563     QCOMPARE(evaluate<qreal>(dropArea, "drag.y"), qreal(25));
 564     QCOMPARE(evaluate<qreal>(dropArea, "dragX"), qreal(75));
 565     QCOMPARE(evaluate<qreal>(dropArea, "dragY"), qreal(25));
 566     QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(75));
 567     QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(25));
 568
 569     evaluate<void>(dragItem, "Drag.active = false");
 570 }
 571
 572 void tst_QQuickDropArea::position_external()
 573 {
 574     QQuickCanvas canvas;
 575     QQmlComponent component(&engine);
 576     component.setData(
 577             "import QtQuick 2.0\n"
 578             "DropArea {\n"
 579                 "property real dragX: drag.x\n"
 580                 "property real dragY: drag.y\n"
 581                 "property real eventX\n"
 582                 "property real eventY\n"
 583                 "property int enterEvents: 0\n"
 584                 "property int moveEvents: 0\n"
 585                 "width: 100; height: 100\n"
 586                 "onEntered: {++enterEvents; eventX = drag.x; eventY = drag.y}\n"
 587                 "onPositionChanged: {++moveEvents; eventX = drag.x; eventY = drag.y}\n"
 588             "}", QUrl());
 589     QScopedPointer<QObject> object(component.create());
 590     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 591     QVERIFY(dropArea);
 592     dropArea->setParentItem(canvas.rootItem());
 593
 594     QMimeData data;
 595
 596     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 597     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
 598     QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
 599     QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(50));
 600     QCOMPARE(evaluate<qreal>(dropArea, "drag.y"), qreal(50));
 601     QCOMPARE(evaluate<qreal>(dropArea, "dragX"), qreal(50));
 602     QCOMPARE(evaluate<qreal>(dropArea, "dragY"), qreal(50));
 603     QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(50));
 604     QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(50));
 605
 606     evaluate<void>(dropArea, "{ enterEvents = 0; moveEvents = 0; eventX = -1; eventY = -1 }");
 607     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(40, 50), Qt::CopyAction);
 608     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 609     QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
 610     QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(40));
 611     QCOMPARE(evaluate<qreal>(dropArea, "drag.y"), qreal(50));
 612     QCOMPARE(evaluate<qreal>(dropArea, "dragX"), qreal(40));
 613     QCOMPARE(evaluate<qreal>(dropArea, "dragY"), qreal(50));
 614     QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(40));
 615     QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(50));
 616
 617     evaluate<void>(dropArea, "{ enterEvents = 0; moveEvents = 0; eventX = -1; eventY = -1 }");
 618     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(75, 25), Qt::CopyAction);
 619     QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
 620     QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
 621     QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(75));
 622     QCOMPARE(evaluate<qreal>(dropArea, "drag.y"), qreal(25));
 623     QCOMPARE(evaluate<qreal>(dropArea, "dragX"), qreal(75));
 624     QCOMPARE(evaluate<qreal>(dropArea, "dragY"), qreal(25));
 625     QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(75));
 626     QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(25));
 627
 628     QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(75, 25), Qt::CopyAction);
 629 }
 630
 631 void tst_QQuickDropArea::drop_internal()
 632 {
 633     QQuickCanvas canvas;
 634     QQmlComponent component(&engine);
 635     component.setData(
 636             "import QtQuick 2.0\n"
 637             "DropArea {\n"
 638                 "property bool accept: false\n"
 639                 "property bool setAccepted: false\n"
 640                 "property bool acceptDropAction: false\n"
 641                 "property bool setDropAction: false\n"
 642                 "property int dropAction: Qt.IgnoreAction\n"
 643                 "property int proposedAction: Qt.IgnoreAction\n"
 644                 "property int supportedActions: Qt.IgnoreAction\n"
 645                 "property int dropEvents: 0\n"
 646                 "width: 100; height: 100\n"
 647                 "onDropped: {\n"
 648                     "++dropEvents\n"
 649                     "supportedActions = drop.supportedActions\n"
 650                     "proposedAction = drop.action\n"
 651                     "if (setDropAction)\n"
 652                         "drop.action = dropAction\n"
 653                     "if (acceptDropAction)\n"
 654                         "drop.accept(dropAction)\n"
 655                     "else if (setAccepted)\n"
 656                         "drop.accepted = accept\n"
 657                     "else if (accept)\n"
 658                         "drop.accept()\n"
 659                 "}\n"
 660                 "Item {\n"
 661                     "objectName: \"dragItem\"\n"
 662                     "x: 50; y: 50\n"
 663                     "width: 10; height: 10\n"
 664                 "}\n"
 665             "}", QUrl());
 666     QScopedPointer<QObject> object(component.create());
 667     QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
 668     QVERIFY(dropArea);
 669     dropArea->setParentItem(canvas.rootItem());
 670
 671     QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
 672     QVERIFY(dragItem);
 673
 674     evaluate<void>(dragItem, "Drag.active = true");
 675     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::IgnoreAction));
 676     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 677     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 678     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 679
 680     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 681     evaluate<void>(dropArea, "{ accept = true; setDropAction = true; dropAction = Qt.LinkAction }");
 682     evaluate<void>(dragItem, "Drag.active = true");
 683     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::LinkAction));
 684     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 685     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 686     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 687
 688     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 689     evaluate<void>(dropArea, "{ setAccepted = true; }");
 690     evaluate<void>(dragItem, "Drag.active = true");
 691     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::LinkAction));
 692     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 693     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 694     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 695
 696     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 697     evaluate<void>(dropArea, "{ accept = false; setAccepted = true; }");
 698     evaluate<void>(dragItem, "Drag.active = true");
 699     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::IgnoreAction));
 700     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 701     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 702     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 703
 704     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 705     evaluate<void>(dropArea, "{ setAccepted = false; setDropAction = false; acceptDropAction = true; }");
 706     evaluate<void>(dragItem, "Drag.active = true");
 707     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::LinkAction));
 708     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 709     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 710     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 711
 712     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 713     evaluate<void>(dropArea, "{ acceptDropAction = false; dropAction = Qt.IgnoreAction; accept = true }");
 714     evaluate<void>(dragItem, "Drag.active = true");
 715     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::MoveAction));
 716     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 717     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 718     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 719
 720     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 721     evaluate<void>(dropArea, "{ setAccepted = true }");
 722     evaluate<void>(dragItem, "Drag.active = true");
 723     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::MoveAction));
 724     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 725     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::CopyAction | Qt::MoveAction | Qt::LinkAction));
 726     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 727
 728     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 729     evaluate<void>(dropArea, "{ setAccepted = false }");
 730     evaluate<void>(dragItem, "Drag.supportedActions = Qt.LinkAction");
 731     evaluate<void>(dragItem, "Drag.active = true");
 732     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::MoveAction));
 733     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 734     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::LinkAction));
 735     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 736
 737     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 738     evaluate<void>(dropArea, "{ setAccepted = true }");
 739     evaluate<void>(dragItem, "Drag.active = true");
 740     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::MoveAction));
 741     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 742     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::LinkAction));
 743     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::MoveAction));
 744
 745     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 746     evaluate<void>(dropArea, "{ setAccepted = false }");
 747     evaluate<void>(dragItem, "Drag.proposedAction = Qt.LinkAction");
 748     evaluate<void>(dragItem, "Drag.active = true");
 749     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::LinkAction));
 750     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 751     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::LinkAction));
 752     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::LinkAction));
 753
 754     evaluate<void>(dropArea, "{ dropEvents = 0; proposedAction = Qt.IgnoreAction; supportedActions = Qt.IgnoreAction }");
 755     evaluate<void>(dropArea, "{ setAccepted = true }");
 756     evaluate<void>(dragItem, "Drag.active = true");
 757     QCOMPARE(evaluate<int>(dragItem, "Drag.drop()"), int(Qt::LinkAction));
 758     QCOMPARE(evaluate<int>(dropArea, "dropEvents"), 1);
 759     QCOMPARE(evaluate<int>(dropArea, "supportedActions"), int(Qt::LinkAction));
 760     QCOMPARE(evaluate<int>(dropArea, "proposedAction"), int(Qt::LinkAction));
 761 }
 762
 763 // Setting the supportedActions can't be emulated using the QWindowSystemInterface API.
 764
 765 //void tst_QQuickDropArea::drop_external()
 766 //{
 767 //}
 768
 769 void tst_QQuickDropArea::simultaneousDrags()
 770 {
 771     QQuickCanvas canvas;
 772     QQmlComponent component(&engine);
 773     component.setData(
 774             "import QtQuick 2.0\n"
 775             "DropArea {\n"
 776                 "property int enterEvents: 0\n"
 777                 "property int exitEvents: 0\n"
 778                 "width: 100; height: 100\n"
 779                 "keys: [\"red\", \"text/x-red\"]\n"
 780                 "onEntered: {++enterEvents}\n"
 781                 "onExited: {++exitEvents}\n"
 782                 "DropArea {\n"
 783                     "objectName: \"dropArea2\"\n"
 784                     "property int enterEvents: 0\n"
 785                     "property int exitEvents: 0\n"
 786                     "width: 100; height: 100\n"
 787                     "keys: [\"blue\", \"text/x-blue\"]\n"
 788                     "onEntered: {++enterEvents}\n"
 789                     "onExited: {++exitEvents}\n"
 790                 "}\n"
 791                 "Item {\n"
 792                     "objectName: \"dragItem1\"\n"
 793                     "x: 50; y: 50\n"
 794                     "width: 10; height: 10\n"
 795                     "Drag.keys: [\"red\", \"blue\"]"
 796                 "}\n"
 797                 "Item {\n"
 798                     "objectName: \"dragItem2\"\n"
 799                     "x: 50; y: 50\n"
 800                     "width: 10; height: 10\n"
 801                     "Drag.keys: [\"red\", \"blue\"]"
 802                 "}\n"
 803             "}", QUrl());
 804
 805     QScopedPointer<QObject> object(component.create());
 806     QQuickItem *dropArea1 = qobject_cast<QQuickItem *>(object.data());
 807     QVERIFY(dropArea1);
 808     dropArea1->setParentItem(canvas.rootItem());
 809
 810     QQuickItem *dropArea2 = dropArea1->findChild<QQuickItem *>("dropArea2");
 811     QVERIFY(dropArea2);
 812
 813     QQuickItem *dragItem1 = dropArea1->findChild<QQuickItem *>("dragItem1");
 814     QVERIFY(dragItem1);
 815
 816     QQuickItem *dragItem2 = dropArea1->findChild<QQuickItem *>("dragItem2");
 817     QVERIFY(dragItem2);
 818
 819     QMimeData data;
 820     data.setData("text/x-red", "red");
 821     data.setData("text/x-blue", "blue");
 822
 823     QQuickCanvas alternateCanvas;
 824
 825     // Mixed internal drags.
 826     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 827     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 828     evaluate<void>(dragItem1, "Drag.active = true");
 829     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 830     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 1);
 831     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 832     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 833     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
 834     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 835
 836     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 837     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 838     evaluate<void>(dragItem2, "Drag.active = true");
 839     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 840     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 841     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 842     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 843     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 844     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 845
 846     evaluate<void>(dragItem2, "Drag.active = false");
 847     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 848     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 849     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 850     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 851     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 852     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 853
 854     evaluate<void>(dragItem2, "Drag.active = true");
 855     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 856     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 857     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 858     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 859     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 860     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 861
 862     evaluate<void>(dragItem1, "Drag.active = false");
 863     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
 864     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 865     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 1);
 866     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
 867     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 868     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
 869
 870     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 871     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 872     evaluate<void>(dragItem2, "Drag.active = false");
 873     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
 874     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 875     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 876     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
 877     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 878     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 879
 880     // internal then external.
 881     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 882     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 883     evaluate<void>(dragItem1, "Drag.active = true");
 884     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 885     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 1);
 886     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 887     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 888     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
 889     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 890
 891     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 892     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 893     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 894     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 895     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 896     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 897     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 898     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 899     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 900
 901     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 902     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 903     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 904     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 905     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 906     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 907     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 908
 909     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 910     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 911     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 912     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 913     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 914     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 915     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 916
 917     evaluate<void>(dragItem1, "Drag.active = false");
 918     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
 919     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 920     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 1);
 921     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
 922     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 923     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
 924
 925     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 926     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 927     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 928     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
 929     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 930     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 931     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
 932     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 933     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 934
 935     // external then internal.
 936     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 937     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 938     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
 939     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 940     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 1);
 941     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 942     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 943     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
 944     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 945
 946     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 947     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 948     evaluate<void>(dragItem2, "Drag.active = true");
 949     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 950     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 951     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 952     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 953     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 954     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 955
 956     evaluate<void>(dragItem2, "Drag.active = false");
 957     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 958     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 959     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 960     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 961     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 962     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 963
 964     evaluate<void>(dragItem2, "Drag.active = true");
 965     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 966     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 967     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 968     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
 969     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 970     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 971
 972     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
 973     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
 974     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 975     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 1);
 976     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
 977     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 978     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
 979
 980     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 981     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 982     evaluate<void>(dragItem2, "Drag.active = false");
 983     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
 984     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
 985     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
 986     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
 987     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
 988     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
 989
 990     // Different acceptance
 991     evaluate<void>(dragItem1, "Drag.keys = \"red\"");
 992     evaluate<void>(dragItem2, "Drag.keys = \"blue\"");
 993     data.removeFormat("text/x-red");
 994
 995     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
 996     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
 997     evaluate<void>(dragItem1, "Drag.active = true");
 998     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
 999     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 1);
1000     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1001     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
1002     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1003     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1004
1005     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1006     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1007     evaluate<void>(dragItem2, "Drag.active = true");
1008     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1009     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1010     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1011     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
1012     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
1013     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1014
1015     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1016     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1017     evaluate<void>(dragItem2, "Drag.active = false");
1018     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1019     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1020     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1021     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
1022     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1023     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
1024
1025     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1026     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1027     evaluate<void>(dragItem2, "Drag.active = true");
1028     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1029     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1030     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1031     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
1032     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
1033     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1034
1035     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1036     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1037     evaluate<void>(dragItem1, "Drag.active = false");
1038     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
1039     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1040     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 1);
1041     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
1042     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1043     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1044
1045     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1046     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1047     evaluate<void>(dragItem2, "Drag.active = false");
1048     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
1049     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1050     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1051     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
1052     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1053     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
1054
1055     // internal then external
1056     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1057     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1058     evaluate<void>(dragItem1, "Drag.active = true");
1059     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1060     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 1);
1061     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1062     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
1063     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1064     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1065
1066     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1067     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1068     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
1069     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1070     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1071     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1072     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
1073     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
1074     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1075
1076     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1077     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1078     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
1079     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1080     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1081     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1082     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
1083     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1084     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
1085
1086     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1087     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1088     QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
1089     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
1090     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1091     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1092     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
1093     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 1);
1094     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1095
1096     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1097     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1098     evaluate<void>(dragItem1, "Drag.active = false");
1099     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
1100     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1101     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 1);
1102     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), true);
1103     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1104     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
1105
1106     evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
1107     evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
1108     QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
1109     QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
1110     QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
1111     QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
1112     QCOMPARE(evaluate<bool>(dropArea2, "containsDrag"), false);
1113     QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
1114     QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
1115
1116     QWindowSystemInterface::handleDrop(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
1117 }
1118
1119 QTEST_MAIN(tst_QQuickDropArea)
1120
1121 #include "tst_qquickdroparea.moc"