← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/quick/items/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:
src/quick/items/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 QtQml module 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 "qquickdroparea_p.h"
 
43
#include "qquickdrag_p.h"
 
44
#include "qquickitem_p.h"
 
45
#include "qquickcanvas.h"
 
46
 
 
47
#include <private/qqmlengine_p.h>
 
48
 
 
49
QT_BEGIN_NAMESPACE
 
50
 
 
51
QQuickDropAreaDrag::QQuickDropAreaDrag(QQuickDropAreaPrivate *d, QObject *parent)
 
52
    : QObject(parent)
 
53
    , d(d)
 
54
{
 
55
}
 
56
 
 
57
QQuickDropAreaDrag::~QQuickDropAreaDrag()
 
58
{
 
59
}
 
60
 
 
61
class QQuickDropAreaPrivate : public QQuickItemPrivate
 
62
{
 
63
    Q_DECLARE_PUBLIC(QQuickDropArea)
 
64
 
 
65
public:
 
66
    QQuickDropAreaPrivate();
 
67
    ~QQuickDropAreaPrivate();
 
68
 
 
69
    bool hasMatchingKey(const QStringList &keys) const;
 
70
 
 
71
    QStringList getKeys(const QMimeData *mimeData) const;
 
72
 
 
73
    QStringList keys;
 
74
    QRegExp keyRegExp;
 
75
    QPointF dragPosition;
 
76
    QQuickDropAreaDrag *drag;
 
77
    QQmlGuard<QObject> source;
 
78
    QQmlGuard<QMimeData> mimeData;
 
79
};
 
80
 
 
81
QQuickDropAreaPrivate::QQuickDropAreaPrivate()
 
82
    : drag(0)
 
83
{
 
84
}
 
85
 
 
86
QQuickDropAreaPrivate::~QQuickDropAreaPrivate()
 
87
{
 
88
    delete drag;
 
89
}
 
90
 
 
91
/*!
 
92
    \qmlclass DropArea QQuickDropArea
 
93
    \inqmlmodule QtQuick 2
 
94
    \brief The DropArea item provides drag and drop handling.
 
95
 
 
96
    A DropArea is an invisible item which receives events when other items are
 
97
    dragged over it.
 
98
 
 
99
    The Drag attached property can be used to notify the DropArea when an Item is
 
100
    dragged over it.
 
101
 
 
102
    The \l keys property can be used to filter drag events which don't include
 
103
    a matching key.
 
104
 
 
105
    The \l dropItem property is communicated to the source of a drag event as
 
106
    the recipient of a drop on the drag target.
 
107
 
 
108
    The \l delegate property provides a means to specify a component to be
 
109
    instantiated for each active drag over a drag target.
 
110
*/
 
111
 
 
112
QQuickDropArea::QQuickDropArea(QQuickItem *parent)
 
113
    : QQuickItem(*new QQuickDropAreaPrivate, parent)
 
114
{
 
115
    setFlags(ItemAcceptsDrops);
 
116
}
 
117
 
 
118
QQuickDropArea::~QQuickDropArea()
 
119
{
 
120
}
 
121
 
 
122
/*!
 
123
    \qmlproperty bool QtQuick2::DropArea::containsDrag
 
124
 
 
125
    This property identifies whether the DropArea currently contains any
 
126
    dragged items.
 
127
*/
 
128
 
 
129
bool QQuickDropArea::containsDrag() const
 
130
{
 
131
    Q_D(const QQuickDropArea);
 
132
    return d->mimeData;
 
133
}
 
134
 
 
135
/*!
 
136
    \qmlproperty stringlist QtQuick2::DropArea::keys
 
137
 
 
138
    This property holds a list of drag keys a DropArea will accept.
 
139
 
 
140
    If no keys are listed the DropArea will accept events from any drag source,
 
141
    otherwise the drag source must have at least one compatible key.
 
142
 
 
143
    \sa QtQuick2::Drag::keys
 
144
*/
 
145
 
 
146
QStringList QQuickDropArea::keys() const
 
147
{
 
148
    Q_D(const QQuickDropArea);
 
149
    return d->keys;
 
150
}
 
151
 
 
152
void QQuickDropArea::setKeys(const QStringList &keys)
 
153
{
 
154
    Q_D(QQuickDropArea);
 
155
    if (d->keys != keys) {
 
156
        d->keys = keys;
 
157
 
 
158
        if (keys.isEmpty()) {
 
159
            d->keyRegExp = QRegExp();
 
160
        } else {
 
161
            QString pattern = QLatin1Char('(') + QRegExp::escape(keys.first());
 
162
            for (int i = 1; i < keys.count(); ++i)
 
163
                pattern += QLatin1Char('|') + QRegExp::escape(keys.at(i));
 
164
            pattern += QLatin1Char(')');
 
165
            d->keyRegExp = QRegExp(pattern.replace(QLatin1String("\\*"), QLatin1String(".+")));
 
166
        }
 
167
        emit keysChanged();
 
168
    }
 
169
}
 
170
 
 
171
QQuickDropAreaDrag *QQuickDropArea::drag()
 
172
{
 
173
    Q_D(QQuickDropArea);
 
174
    if (!d->drag)
 
175
        d->drag = new QQuickDropAreaDrag(d);
 
176
    return d->drag;
 
177
}
 
178
 
 
179
/*!
 
180
    \qmlproperty Object QtQuick2::DropArea::drag.source
 
181
 
 
182
    This property holds the source of a drag.
 
183
*/
 
184
 
 
185
QObject *QQuickDropAreaDrag::source() const
 
186
{
 
187
    return d->source;
 
188
}
 
189
 
 
190
/*!
 
191
    \qmlproperty qreal QtQuick2::DropArea::drag.x
 
192
    \qmlproperty qreal QtQuick2::DropArea::drag.y
 
193
 
 
194
    These properties hold the coordinates of the last drag event.
 
195
*/
 
196
 
 
197
qreal QQuickDropAreaDrag::x() const
 
198
{
 
199
    return d->dragPosition.x();
 
200
}
 
201
 
 
202
qreal QQuickDropAreaDrag::y() const
 
203
{
 
204
    return d->dragPosition.y();
 
205
}
 
206
 
 
207
/*!
 
208
    \qmlsignal QtQuick2::DropArea::onPositionChanged(DragEvent drag)
 
209
 
 
210
    This handler is called when the position of a drag has changed.
 
211
*/
 
212
 
 
213
void QQuickDropArea::dragMoveEvent(QDragMoveEvent *event)
 
214
{
 
215
    Q_D(QQuickDropArea);
 
216
    if (!d->mimeData)
 
217
        return;
 
218
 
 
219
    d->dragPosition = event->pos();
 
220
    if (d->drag)
 
221
        emit d->drag->positionChanged();
 
222
 
 
223
    event->accept();
 
224
    QQuickDropEvent dragTargetEvent(d, event);
 
225
    emit positionChanged(&dragTargetEvent);
 
226
}
 
227
 
 
228
bool QQuickDropAreaPrivate::hasMatchingKey(const QStringList &keys) const
 
229
{
 
230
    if (keyRegExp.isEmpty())
 
231
        return true;
 
232
 
 
233
    foreach (const QString &key, keys) {
 
234
        if (keyRegExp.exactMatch(key))
 
235
            return true;
 
236
    }
 
237
    return false;
 
238
}
 
239
 
 
240
QStringList QQuickDropAreaPrivate::getKeys(const QMimeData *mimeData) const
 
241
{
 
242
    if (const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(mimeData))
 
243
        return dragMime->keys();
 
244
    return mimeData->formats();
 
245
}
 
246
 
 
247
/*!
 
248
    \qmlsignal QtQuick2::DropArea::onEntered(DragEvent drag)
 
249
 
 
250
    This handler is called when a \a drag enters the bounds of a DropArea.
 
251
*/
 
252
 
 
253
void QQuickDropArea::dragEnterEvent(QDragEnterEvent *event)
 
254
{
 
255
    Q_D(QQuickDropArea);
 
256
    const QMimeData *mimeData = event->mimeData();
 
257
    if (!d->effectiveEnable || d->mimeData || !mimeData || !d->hasMatchingKey(d->getKeys(mimeData)))
 
258
        return;
 
259
 
 
260
    d->dragPosition = event->pos();
 
261
 
 
262
    event->accept();
 
263
    QQuickDropEvent dragTargetEvent(d, event);
 
264
    emit entered(&dragTargetEvent);
 
265
 
 
266
    if (event->isAccepted()) {
 
267
        d->mimeData = const_cast<QMimeData *>(mimeData);
 
268
        if (QQuickDragMimeData *dragMime = qobject_cast<QQuickDragMimeData *>(d->mimeData))
 
269
            d->source = dragMime->source();
 
270
        else
 
271
            d->source = event->source();
 
272
        d->dragPosition = event->pos();
 
273
        if (d->drag) {
 
274
            emit d->drag->positionChanged();
 
275
            emit d->drag->sourceChanged();
 
276
        }
 
277
        emit containsDragChanged();
 
278
    }
 
279
}
 
280
 
 
281
/*!
 
282
    \qmlsignal QtQuick2::DropArea::onExited()
 
283
 
 
284
    This handler is called when a drag exits the bounds of a DropArea.
 
285
*/
 
286
 
 
287
void QQuickDropArea::dragLeaveEvent(QDragLeaveEvent *)
 
288
{
 
289
    Q_D(QQuickDropArea);
 
290
    if (!d->mimeData)
 
291
        return;
 
292
 
 
293
    emit exited();
 
294
 
 
295
    d->mimeData = 0;
 
296
    d->source = 0;
 
297
    emit containsDragChanged();
 
298
    if (d->drag)
 
299
        emit d->drag->sourceChanged();
 
300
}
 
301
 
 
302
/*!
 
303
    \qmlsignal QtQuick2::DropArea::onDropped(DragEvent drop)
 
304
 
 
305
    This handler is called when a drop event occurs within the bounds of a
 
306
    a DropArea.
 
307
*/
 
308
 
 
309
void QQuickDropArea::dropEvent(QDropEvent *event)
 
310
{
 
311
    Q_D(QQuickDropArea);
 
312
    if (!d->mimeData)
 
313
        return;
 
314
 
 
315
    QQuickDropEvent dragTargetEvent(d, event);
 
316
    emit dropped(&dragTargetEvent);
 
317
 
 
318
    d->mimeData = 0;
 
319
    d->source = 0;
 
320
    emit containsDragChanged();
 
321
    if (d->drag)
 
322
        emit d->drag->sourceChanged();
 
323
}
 
324
 
 
325
/*!
 
326
    \qmlclass DragEvent QQuickDragEvent
 
327
    \inqmlmodule QtQuick 2
 
328
    \brief The DragEvent object provides information about a drag event.
 
329
 
 
330
    The position of the drag event can be obtained from the \l x and \l y
 
331
    properties, and the \l keys property identifies the drag keys of the event
 
332
    \l source.
 
333
*/
 
334
 
 
335
/*!
 
336
    \qmlproperty real QtQuick2::DragEvent::x
 
337
 
 
338
    This property holds the x coordinate of a drag event.
 
339
*/
 
340
 
 
341
/*!
 
342
    \qmlproperty real QtQuick2::DragEvent::y
 
343
 
 
344
    This property holds the y coordinate of a drag event.
 
345
*/
 
346
 
 
347
/*!
 
348
    \qmlproperty Object QtQuick2::DragEvent::drag.source
 
349
 
 
350
    This property holds the source of a drag event.
 
351
*/
 
352
 
 
353
QObject *QQuickDropEvent::source()
 
354
{
 
355
    if (const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(event->mimeData()))
 
356
        return dragMime->source();
 
357
    else
 
358
        return event->source();
 
359
}
 
360
 
 
361
/*!
 
362
    \qmlproperty stringlist QtQuick2::DragEvent::keys
 
363
 
 
364
    This property holds a list of keys identifying the data type or source of a
 
365
    drag event.
 
366
*/
 
367
 
 
368
QStringList QQuickDropEvent::keys() const
 
369
{
 
370
    return d->getKeys(event->mimeData());
 
371
}
 
372
 
 
373
/*!
 
374
    \qmlproperty enum QtQuick2::DragEvent::action
 
375
 
 
376
    This property holds the action that the \l source is to perform on an accepted drop.
 
377
 
 
378
    The drop action may be one of:
 
379
 
 
380
    \list
 
381
    \li Qt.CopyAction Copy the data to the target
 
382
    \li Qt.MoveAction Move the data from the source to the target
 
383
    \li Qt.LinkAction Create a link from the source to the target.
 
384
    \li Qt.IgnoreAction Ignore the action (do nothing with the data).
 
385
    \endlist
 
386
*/
 
387
 
 
388
/*!
 
389
    \qmlproperty flags QtQuick2::DragEvent::supportedActions
 
390
 
 
391
    This property holds the set of \l {action}{actions} supported by the
 
392
    drag source.
 
393
*/
 
394
 
 
395
/*!
 
396
    \qmlproperty real QtQuick2::DragEvent::accepted
 
397
 
 
398
    This property holds whether the drag event was accepted by a handler.
 
399
 
 
400
    The default value is true.
 
401
*/
 
402
 
 
403
/*!
 
404
    \qmlmethod void QtQuick2::DragEvent::accept()
 
405
    \qmlmethod void QtQuick2::DragEvent::accept(enum action)
 
406
 
 
407
    Accepts the drag event.
 
408
 
 
409
    If an \a action is specified it will overwrite the value of the \l action property.
 
410
*/
 
411
 
 
412
void QQuickDropEvent::accept(QQmlV8Function *args)
 
413
{
 
414
    Qt::DropAction action = event->dropAction();
 
415
 
 
416
    if (args->Length() >= 1) {
 
417
        v8::Local<v8::Value> v = (*args)[0];
 
418
        if (v->IsInt32())
 
419
            action = Qt::DropAction(v->Int32Value());
 
420
    }
 
421
    // get action from arguments.
 
422
    event->setDropAction(action);
 
423
    event->accept();
 
424
}
 
425
 
 
426
 
 
427
QT_END_NAMESPACE
 
428