tests/auto/declarative/qsgdroparea/tst_qsgdroparea.cpp

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