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