← Back to branch summary

~loic.molinari/+junk/qtdeclarative-shadereffectsource-changes

« back to all changes in this revision

Viewing changes to tests/auto/quick/qquickdroparea/tst_qquickdroparea.cpp

  • Committer: Loïc Molinari
  • Date: 2012-04-21 17:59:51 UTC
  • Revision ID: loic.molinari@canonical.com-20120421175951-bqx68caaf5zrp76l
Initial import

Show diffs side-by-side

added added

removed removed

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