diff options
Diffstat (limited to 'src/quick/items/qquickdrag.cpp')
-rw-r--r-- | src/quick/items/qquickdrag.cpp | 462 |
1 files changed, 462 insertions, 0 deletions
diff --git a/src/quick/items/qquickdrag.cpp b/src/quick/items/qquickdrag.cpp new file mode 100644 index 0000000000..12d8cbea98 --- /dev/null +++ b/src/quick/items/qquickdrag.cpp @@ -0,0 +1,462 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickdrag_p.h" + +#include <private/qquickitem_p.h> +#include <QtQuick/private/qquickevents_p_p.h> +#include <private/qquickitemchangelistener_p.h> +#include <private/qv8engine_p.h> + +#include <QtGui/qevent.h> + +QT_BEGIN_NAMESPACE + +class QQuickDragAttachedPrivate : public QObjectPrivate, public QQuickItemChangeListener +{ + Q_DECLARE_PUBLIC(QQuickDragAttached) +public: + static QQuickDragAttachedPrivate *get(QQuickDragAttached *attached) { + return static_cast<QQuickDragAttachedPrivate *>(QObjectPrivate::get(attached)); } + + QQuickDragAttachedPrivate() + : attachedItem(0) + , mimeData(0) + , proposedAction(Qt::MoveAction) + , supportedActions(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction) + , active(false) + , listening(false) + { + } + + void itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &); + void start() { start(supportedActions); } + void start(Qt::DropActions supportedActions); + void setTarget(QQuickItem *item); + + QQuickDragGrabber dragGrabber; + + QDeclarativeGuard<QObject> source; + QDeclarativeGuard<QObject> target; + QQuickItem *attachedItem; + QQuickDragMimeData *mimeData; + Qt::DropAction proposedAction; + Qt::DropActions supportedActions; + bool active : 1; + bool listening : 1; + QPointF hotSpot; + QStringList keys; +}; + +/*! + \qmlclass Drag QQuickDrag + \inqmlmodule QtQuick 2 + \brief The Drag attached property provides drag and drop events for moved Items. + + Using the Drag attached property any Item can made a source of drag and drop + events within a scene. + + When a drag is \l active on an item any change in that items position will + generate a drag events that will be sent to any DropArea that intersects + the with new position of the item. Other items which implement drag and + drop event handlers can also receive these events. + + The following snippet shows how an item can be dragged with a MouseArea. + However, dragging is not limited to mouse drags, anything that can move an item + can generate drag events, this can include touch events, animations and bindings. + + \snippet doc/src/snippets/declarative/drag.qml 0 + + A drag can be terminated either by canceling it with Drag.cancel() or setting + Drag.active to false, or it can be terminated with a drop event by calling + Drag.drop(). If the drop event is accepted Drag.drop() will return the + \l {supportedActions}{drop action} chosen by the recipient of the event, + otherwise it will return Qt.IgnoreAction. + +*/ + +void QQuickDragAttachedPrivate::itemGeometryChanged(QQuickItem *, const QRectF &newGeometry, const QRectF &oldGeometry) +{ + Q_Q(QQuickDragAttached); + if (newGeometry.topLeft() == oldGeometry.topLeft() || !active) + return; + + if (QQuickCanvas *canvas = attachedItem->canvas()) { + QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint(); + QDragMoveEvent event(scenePos, mimeData->m_supportedActions, mimeData, Qt::NoButton, Qt::NoModifier); + QQuickDropEventEx::setProposedAction(&event, proposedAction); + QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, &event); + if (target != dragGrabber.target()) { + target = dragGrabber.target(); + emit q->targetChanged(); + } + } +} + +QQuickDragAttached::QQuickDragAttached(QObject *parent) + : QObject(*new QQuickDragAttachedPrivate, parent) +{ + Q_D(QQuickDragAttached); + d->attachedItem = qobject_cast<QQuickItem *>(parent); + d->source = d->attachedItem; +} + +QQuickDragAttached::~QQuickDragAttached() +{ + Q_D(QQuickDragAttached); + delete d->mimeData; +} + +/*! + \qmlattachedproperty bool QtQuick2::Drag::active + + This property holds whether a drag event sequence is currently active. + + Setting this property to true will send a QDragEnter event to the scene + with the item's current position. Setting it to false will send a + QDragLeave event. + + While a drag is active any change in an item's position will send a QDragMove + event with item's new position to the scene. +*/ + +bool QQuickDragAttached::isActive() const +{ + Q_D(const QQuickDragAttached); + return d->active; +} + +void QQuickDragAttached::setActive(bool active) +{ + Q_D(QQuickDragAttached); + if (d->active != active) { + if (active) + d->start(d->supportedActions); + else + cancel(); + } +} + +/*! + \qmlattachedproperty Object QtQuick2::Drag::source + + This property holds an object that is identified to recipients of drag events as + the source of the events. By default this is the item Drag property is attached to. + + Changes to source while a Drag is active don't take effect until a new drag is started. +*/ + +QObject *QQuickDragAttached::source() const +{ + Q_D(const QQuickDragAttached); + return d->source; +} + +void QQuickDragAttached::setSource(QObject *item) +{ + Q_D(QQuickDragAttached); + if (d->source != item) { + d->source = item; + emit sourceChanged(); + } +} + +void QQuickDragAttached::resetSource() +{ + Q_D(QQuickDragAttached); + if (d->source != d->attachedItem) { + d->source = d->attachedItem; + emit sourceChanged(); + } +} + +/*! + \qmlattachedproperty Object QtQuick2::Drag::target + + While a drag is active this property holds the last object to accept an + enter event from the dragged item, if the current drag position doesn't + intersect any accepting targets it is null. + + When a drag is not active this property holds the object that accepted + the drop event that ended the drag, if no object accepted the drop or + the drag was canceled the target will then be null. +*/ + +QObject *QQuickDragAttached::target() const +{ + Q_D(const QQuickDragAttached); + return d->target; +} + +/*! + \qmlattachedproperty QPointF QtQuick2::Drag::hotSpot + + This property holds the drag position relative to the top left of the item. + + By default this is (0, 0). + + Changes to hotSpot will take effect when the next event is sent. +*/ + +QPointF QQuickDragAttached::hotSpot() const +{ + Q_D(const QQuickDragAttached); + return d->hotSpot; +} + +void QQuickDragAttached::setHotSpot(const QPointF &hotSpot) +{ + Q_D(QQuickDragAttached); + if (d->hotSpot != hotSpot) { + d->hotSpot = hotSpot; + emit hotSpotChanged(); + // Send a move event if active? + } +} + +/*! + \qmlattachedproperty stringlist QtQuick2::Drag::keys + + This property holds a list of keys that can be used by a DropArea to filter drag events. + + Changes to keys while a Drag is active don't take effect until a new drag is started. +*/ + +QStringList QQuickDragAttached::keys() const +{ + Q_D(const QQuickDragAttached); + return d->keys; +} + +void QQuickDragAttached::setKeys(const QStringList &keys) +{ + Q_D(QQuickDragAttached); + if (d->keys != keys) { + d->keys = keys; + emit keysChanged(); + } +} + +/*! + \qmlattachedproperty flags QtQuick2::Drag::supportedActions + + This property holds return values of Drag.drop() supported by the drag source. + + Changes to supportedActions while a Drag is active don't take effect + until a new drag is started. +*/ + +Qt::DropActions QQuickDragAttached::supportedActions() const +{ + Q_D(const QQuickDragAttached); + return d->supportedActions; +} + +void QQuickDragAttached::setSupportedActions(Qt::DropActions actions) +{ + Q_D(QQuickDragAttached); + if (d->supportedActions != actions) { + d->supportedActions = actions; + emit supportedActionsChanged(); + } +} + +/*! + \qmlattachedproperty enumeration QtQuick2::Drag::proposedAction + + This property holds an action that is recommended by the drag source as a + return value from Drag.drop(). + + Changes to proposedAction will take effect when the next event is sent. +*/ + +Qt::DropAction QQuickDragAttached::proposedAction() const +{ + Q_D(const QQuickDragAttached); + return d->proposedAction; +} + +void QQuickDragAttached::setProposedAction(Qt::DropAction action) +{ + Q_D(QQuickDragAttached); + if (d->proposedAction != action) { + d->proposedAction = action; + emit proposedActionChanged(); + // send a move event with the new default action if active? + } +} + +void QQuickDragAttachedPrivate::start(Qt::DropActions supportedActions) +{ + Q_Q(QQuickDragAttached); + Q_ASSERT(!active); + + if (QQuickCanvas *canvas = attachedItem ? attachedItem->canvas() : 0) { + if (!mimeData) + mimeData = new QQuickDragMimeData; + if (!listening) { + QQuickItemPrivate::get(attachedItem)->addItemChangeListener(this, QQuickItemPrivate::Geometry); + listening = true; + } + + mimeData->m_source = source; + mimeData->m_supportedActions = supportedActions; + mimeData->m_keys = keys; + active = true; + + QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint(); + QDragEnterEvent event(scenePos, supportedActions, mimeData, Qt::NoButton, Qt::NoModifier); + QQuickDropEventEx::setProposedAction(&event, proposedAction); + QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, &event); + + emit q->activeChanged(); + if (target != dragGrabber.target()) { + target = dragGrabber.target(); + emit q->targetChanged(); + } + } +} + +/*! + \qmlattachedmethod void QtQuick2::Drag::start(flags supportedActions) + + Starts sending drag events. + + The optional \a supportedActions argument can be used to override the \l supportedActions + property for the started sequence. +*/ + +void QQuickDragAttached::start(QDeclarativeV8Function *args) +{ + Q_D(QQuickDragAttached); + if (d->active) + cancel(); + + Qt::DropActions supportedActions = d->supportedActions; + // check arguments for supportedActions, maybe data? + if (args->Length() >= 1) { + v8::Local<v8::Value> v = (*args)[0]; + if (v->IsInt32()) + supportedActions = Qt::DropActions(v->Int32Value()); + } + + d->start(supportedActions); +} + +/*! + \qmlattachedmethod enum QtQuick2::Drag::drop() + + Ends a drag sequence by sending a drop event to the target item. + + Returns the action accepted by the target item. If the target item or a parent doesn't accept + the drop event then Qt.IgnoreAction will be returned. + + The returned drop action may be one of: + + \list + \o Qt.CopyAction Copy the data to the target + \o Qt.MoveAction Move the data from the source to the target + \o Qt.LinkAction Create a link from the source to the target. + \o Qt.IgnoreAction Ignore the action (do nothing with the data). + \endlist + +*/ + +int QQuickDragAttached::drop() +{ + Q_D(QQuickDragAttached); + Qt::DropAction acceptedAction = Qt::IgnoreAction; + + if (!d->active) + return acceptedAction; + + QObject *target = 0; + + if (QQuickCanvas *canvas = d->attachedItem->canvas()) { + QPoint scenePos = d->attachedItem->mapToScene(d->hotSpot).toPoint(); + + QDropEvent event( + scenePos, d->mimeData->m_supportedActions, d->mimeData, Qt::NoButton, Qt::NoModifier); + QQuickDropEventEx::setProposedAction(&event, d->proposedAction); + QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&d->dragGrabber, &event); + + if (event.isAccepted()) { + acceptedAction = event.dropAction(); + target = d->dragGrabber.target(); + } + } + + d->active = false; + if (d->target != target) { + d->target = target; + emit targetChanged(); + } + + emit activeChanged(); + return acceptedAction; +} + +/*! + \qmlattachedmethod void QtQuick2::Drag::cancel() + + Ends a drag sequence. +*/ + +void QQuickDragAttached::cancel() +{ + Q_D(QQuickDragAttached); + if (!d->active) + return; + + if (QQuickCanvas *canvas = d->attachedItem->canvas()) { + QDragLeaveEvent event; + QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&d->dragGrabber, &event); + } + + d->active = false; + if (d->target) { + d->target = 0; + emit targetChanged(); + } + emit activeChanged(); +} + +QT_END_NAMESPACE |