Merge lp:~osomon/unity-2d/dnd2 into lp:unity-2d/3.0

[Olivier Tilloy]

[launcher] Support dragging files to the trash.

This changeset also implements the generic infrastructure needed to delegate drag’n’drop events’ handling to launcher items.

[Aurélien Gâteau (agateau)]

# Functional

It works well, but the cursor behavior is a bit weird. If I drag a file from Dolphin to the trash, I get the correct "Move" cursor, but if I drag it from Nautilus I get the "Copy" action. Not sure what is wrong here. Maybe Nautilus does not put "Move" in the proposed actions?

# Code

90 +
91 +public Q_SLOTS:
92 + /* Default implementation of drag’n’drop handling, should be overridden in
93 + subclasses to implement custom behaviours. */
94 + /* The 'event' parameters should be DeclarativeDragDropEvent*, but because
95 + of http://bugreports.qt.nokia.com/browse/QTBUG-13047 they need to be
96 + passed around from QML to C++ as QObject*. This is fixed in Qt 4.7.1. */
97 + virtual void onDragEnter(QObject* event);
98 + virtual void onDrop(QObject* event);

We ship Qt 4.7.1 in Natty, so you should already be able to use DeclarativeDragDropEvent* instead of QObject*.

I think you don't need to call setAccepted() in drop methods (onDrop() or dropEvent()). It only matters in drag methods (onDragEnter(), dragEnterEvent(), ondragMove(), dragMoveEvent()).

From what I understand, the dnd events are received in the C++ side, then forwarded to the QML side, which forwards them again back to C++. Which raise a question: is it necessary at all to go through QML?

Usual nitpick: "}\nelse {" => "} else {" :)

review: Needs Fixing

[Olivier Tilloy (osomon)]

> It works well, but the cursor behavior is a bit weird. If I drag a file from
> Dolphin to the trash, I get the correct "Move" cursor, but if I drag it from
> Nautilus I get the "Copy" action. Not sure what is wrong here. Maybe Nautilus
> does not put "Move" in the proposed actions?

That’s exactly what happens. Not much we can do, apart from patching Nautilus itself…

[Olivier Tilloy (osomon)]

> We ship Qt 4.7.1 in Natty, so you should already be able to use
> DeclarativeDragDropEvent* instead of QObject*.

Right. For some reason I thought we may want to backport this feature to maverick, which is mostly why I kept this workaround. I also must admit it is very convenient to be able to develop on maverick while I haven’t migrated to natty yet.

[Olivier Tilloy (osomon)]

> From what I understand, the dnd events are received in the C++ side, then
> forwarded to the QML side, which forwards them again back to C++. Which raise
> a question: is it necessary at all to go through QML?

That’s how it works indeed, and I’d be more than happy to find a solution that would avoid the roundtrip between C++ and QML and back, which on top of this is perceivably slow. The issue is that the LauncherView doesn’t have direct knowledge of the list model, and much less of how to associate a mouse position to a LauncherItem. Any suggestion?

[Olivier Tilloy (osomon)]

> We ship Qt 4.7.1 in Natty, so you should already be able to use
> DeclarativeDragDropEvent* instead of QObject*.

Fixed.

> I think you don't need to call setAccepted() in drop methods (onDrop() or
> dropEvent()). It only matters in drag methods (onDragEnter(),
> dragEnterEvent(), ondragMove(), dragMoveEvent()).

Verified and fixed, thanks for the tip!

> Usual nitpick: "}\nelse {" => "} else {" :)

Fixed too. I’ll never get used to it :/

All your comments have been addressed except the C++ to QML to C++ roundtrip, for which I welcome implementation ideas.

[Aurélien Gâteau (agateau)]

Let's keep that way for now. Approved.

review: Approve

[Florian Boucault (fboucault)]

How slow is "perceivably slow"? I doubt that if anything looking slow is because of the roundtrip between C++ and QML.

[Florian Boucault (fboucault)]

Please make my life easier and readd the workaround for Qt 4.7

review: Needs Fixing

[Florian Boucault (fboucault)]

Ignore my last comment, this feature will not be backported to Maverick.
Let's advise future OEM projects on Maverick or Lucid to use Qt 4.7.1

[Florian Boucault (fboucault)]

I understand now why it's "perceivably slow". In LauncherView::launcherItemAt you go through the whole scenegraph for _every_ move of the mouse. That is absolutely not acceptable.

I do not understand why the plan has changed:
LauncherView should not know about the list of LauncherItems at all. The LauncherItem should take care of their own drag&drop events, not only the actions on drop but also the detection of the drag. Why are not we creating a QML item that is able to do that similar to what is done in:

https://bitbucket.org/gregschlom/qml-drag-drop/src/e5dbe26c3073/DeclarativeDropArea.cpp

It would be less code, faster and also above all it will allow much greater flexibility.

review: Needs Fixing (functional code)

[Olivier Tilloy (osomon)]

Have a look at the revisions in my branch, that is how I had implemented it first.

It is not less code.

And it handles drag events only for launcher items, meaning that other (empty) areas of the launcher cannot receive drag events, which breaks the current functionality (drag’n’drop of desktop files and URLs).

[Florian Boucault (fboucault)]

It will be faster and more flexible.

I don't understand why can't you have the drag'n'drop of desktop files and URLs as you have them today, in the LauncherView and the rest in custom QML items.

[Olivier Tilloy (osomon)]

Because if the LauncherView reimplements drag and drop event slots, it will eat the events and they won’t be propagated to the launcher items.

Also, I changed the implementation so as to allow implementing bug #607782: if we want "capable" launcher items to stand out when something is dragged over the launcher, the event needs to be handled by the view.

=== modified file 'launcher/CMakeLists.txt'
--- launcher/CMakeLists.txt	2011-01-14 20:42:44 +0000
+++ launcher/CMakeLists.txt	2011-02-16 11:14:09 +0000
@@ -1,5 +1,9 @@
 project(unity-2d-launcher)
 
+include_directories(
+    ${libunity-2d-private_SOURCE_DIR}/src
+    )
+
 # Source
 add_subdirectory(UnityApplications)
 add_subdirectory(app)

=== modified file 'launcher/Launcher.qml'
--- launcher/Launcher.qml	2011-02-15 11:48:13 +0000
+++ launcher/Launcher.qml	2011-02-16 11:14:09 +0000
@@ -1,5 +1,6 @@
 import Qt 4.7
 import UnityApplications 1.0
+import Unity2d 1.0 /* required for drag’n’drop handling */
 
 Item {
     id: launcher
@@ -47,6 +48,10 @@
 
             Binding { target: item.menu; property: "title"; value: item.name }
 
+            /* Drag’n’drop handling */
+            function dragEnterEvent(event) { item.onDragEnter(event) }
+            function dropEvent(event) { item.onDrop(event) }
+
             function showMenu() {
                 /* Prevent the simultaneous display of multiple menus */
                 if (list.visibleMenu != item.menu && list.visibleMenu != undefined) {

=== modified file 'launcher/LauncherItem.qml'
--- launcher/LauncherItem.qml	2011-02-15 12:02:56 +0000
+++ launcher/LauncherItem.qml	2011-02-16 11:14:09 +0000
@@ -29,6 +29,10 @@
 */
 Item {
     id: item
+    /* The object name is used by the launcher view to find the current
+       launcher item under the mouse cursor during a drag’n’drop event. */
+    objectName: "launcherItem"
+
     anchors.horizontalCenter: parent.horizontalCenter
 
     property int tileSize

=== modified file 'launcher/UnityApplications/launcheritem.cpp'
--- launcher/UnityApplications/launcheritem.cpp	2010-12-16 11:07:52 +0000
+++ launcher/UnityApplications/launcheritem.cpp	2011-02-16 11:14:09 +0000
@@ -36,3 +36,18 @@
 {
     return m_menu;
 }
+
+void
+LauncherItem::onDragEnter(DeclarativeDragDropEvent* event)
+{
+    Q_UNUSED(event)
+    /* Default to doing nothing, i.e. refusing the event. */
+}
+
+void
+LauncherItem::onDrop(DeclarativeDragDropEvent* event)
+{
+    Q_UNUSED(event)
+    /* Default to doing nothing. */
+}
+

=== modified file 'launcher/UnityApplications/launcheritem.h'
--- launcher/UnityApplications/launcheritem.h	2011-02-10 01:00:41 +0000
+++ launcher/UnityApplications/launcheritem.h	2011-02-16 11:14:09 +0000
@@ -23,6 +23,8 @@
 #include <QObject>
 #include <QString>
 
+#include "dragdropevent.h"
+
 class LauncherContextualMenu;
 
 class LauncherItem : public QObject
@@ -69,6 +71,12 @@
     void iconChanged(QString);
     void launchingChanged(bool);
     void menuChanged(QObject*);
+
+public Q_SLOTS:
+    /* Default implementation of drag’n’drop handling, should be overridden in
+       subclasses to implement custom behaviours. */
+    virtual void onDragEnter(DeclarativeDragDropEvent*);
+    virtual void onDrop(DeclarativeDragDropEvent*);
 };
 
 #endif // LAUNCHERITEM_H

=== modified file 'launcher/UnityApplications/trash.cpp'
--- launcher/UnityApplications/trash.cpp	2011-02-10 11:36:14 +0000
+++ launcher/UnityApplications/trash.cpp	2011-02-16 11:14:09 +0000
@@ -214,6 +214,32 @@
     empty();
 }
 
+void
+Trash::onDragEnter(DeclarativeDragDropEvent* event)
+{
+    Q_FOREACH(QUrl url, event->mimeData()->urls()) {
+        if (url.scheme() == "file") {
+            event->setDropAction(Qt::MoveAction);
+            event->setAccepted(true);
+            return;
+        }
+    }
+}
+
+void
+Trash::onDrop(DeclarativeDragDropEvent* event)
+{
+    Q_FOREACH(QUrl url, event->mimeData()->urls()) {
+        if (url.scheme() == "file") {
+            GFile* file = g_file_new_for_path(url.toLocalFile().toUtf8().constData());
+            if (!g_file_trash(file, NULL, NULL)) {
+                qWarning() << "Unable to send" << url << "to the trash";
+            }
+            g_object_unref(file);
+        }
+    }
+}
+
 
 Trashes::Trashes(QObject* parent) :
     QAbstractListModel(parent)

=== modified file 'launcher/UnityApplications/trash.h'
--- launcher/UnityApplications/trash.h	2011-02-10 01:00:41 +0000
+++ launcher/UnityApplications/trash.h	2011-02-16 11:14:09 +0000
@@ -49,6 +49,12 @@
     Q_INVOKABLE virtual void activate();
     Q_INVOKABLE virtual void createMenuActions();
 
+public Q_SLOTS:
+    /* Custom implementation of drag’n’drop handling. Dropping files on the
+       trash will… move them to the trash! */
+    void onDragEnter(DeclarativeDragDropEvent*);
+    void onDrop(DeclarativeDragDropEvent*);
+
 private slots:
     void onEmptyTriggered();
 

=== modified file 'launcher/app/launcherview.cpp'
--- launcher/app/launcherview.cpp	2011-02-15 12:06:55 +0000
+++ launcher/app/launcherview.cpp	2011-02-16 11:14:09 +0000
@@ -28,16 +28,59 @@
 #include <QDeclarativeEngine>
 #include <QDeclarativeContext>
 #include <QDeclarativeImageProvider>
+#include <QGraphicsObject>
+#include <QMetaObject>
 
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 
+#include "dragdropevent.h"
+
 LauncherView::LauncherView() :
-    QDeclarativeView(), m_resizing(false), m_reserved(false)
+    QDeclarativeView(), m_resizing(false), m_reserved(false),
+    m_dndCurrentLauncherItem(NULL), m_dndCurrentLauncherItemAccepted(false),
+    m_dndAccepted(false)
 {
     setAcceptDrops(true);
 }
 
+QGraphicsObject*
+LauncherView::launcherItemAt(const QPoint& pos) const
+{
+    QGraphicsItem* item = itemAt(pos);
+    while(item != NULL) {
+        QGraphicsObject* object = qgraphicsitem_cast<QGraphicsObject*>(item);
+        if (object->objectName() == "launcherItem") {
+            return object;
+        }
+        item = item->parentItem();
+    }
+    return NULL;
+}
+
+void
+LauncherView::delegateDragEventHandlingToItem(QDropEvent* event, QGraphicsObject* item)
+{
+    if (item == NULL) {
+        return;
+    }
+    DeclarativeDragDropEvent dde(event, this);
+    QMetaObject::invokeMethod(item, "dragEnterEvent",
+                              Q_ARG(QVariant, QVariant::fromValue(&dde)));
+}
+
+bool
+LauncherView::acceptDndEvent(QDragEnterEvent* event)
+{
+    Q_FOREACH(QUrl url, getEventUrls(event)) {
+        if ((url.scheme() == "file" && url.path().endsWith(".desktop")) ||
+            url.scheme().startsWith("http")) {
+            return true;
+        }
+    }
+    return false;
+}
+
 QList<QUrl>
 LauncherView::getEventUrls(QDropEvent* event)
 {
@@ -63,51 +106,62 @@
             return urls;
         }
     }
-
     return QList<QUrl>();
 }
 
-void LauncherView::dragEnterEvent(QDragEnterEvent *event)
-{
-    // Check that data has a list of URLs and that at least one is either
-    // a desktop file or a web page.
-    QList<QUrl> urls = getEventUrls(event);
-
-    if (urls.isEmpty()) {
-        return;
-    }
-
-    foreach (QUrl url, urls) {
-        if ((url.scheme() == "file" && url.path().endsWith(".desktop")) ||
-            url.scheme().startsWith("http")) {
-            event->acceptProposedAction();
-            break;
-        }
-    }
-}
-
-void LauncherView::dragMoveEvent(QDragMoveEvent *event)
-{
-    event->acceptProposedAction();
-}
-
-void LauncherView::dropEvent(QDropEvent *event)
-{
-    bool accepted = false;
-
-    QList<QUrl> urls = getEventUrls(event);
-    foreach (QUrl url, urls) {
-        if (url.scheme() == "file" && url.path().endsWith(".desktop")) {
-            emit desktopFileDropped(url.path());
-            accepted = true;
-        }
-        else if (url.scheme().startsWith("http")) {
-            emit webpageUrlDropped(url);
-            accepted = true;
-        }
-    }
-
-    if (accepted) event->accept();
+void
+LauncherView::dragEnterEvent(QDragEnterEvent* event)
+{
+    m_dndCurrentLauncherItem = NULL;
+    m_dndCurrentLauncherItemAccepted = false;
+    /* Compute whether the launcher itself accepts the event only once for this
+       given event. */
+    m_dndAccepted = acceptDndEvent(event);
+    /* Always accept the event so that subsequent move events are received. */
+    event->setAccepted(true);
+}
+
+void
+LauncherView::dragMoveEvent(QDragMoveEvent* event)
+{
+    QGraphicsObject* launcherItem = launcherItemAt(event->pos());
+    if (launcherItem == m_dndCurrentLauncherItem) {
+        if (m_dndCurrentLauncherItemAccepted || m_dndAccepted) {
+            event->setAccepted(true);
+        }
+    } else {
+        m_dndCurrentLauncherItem = launcherItem;
+        m_dndCurrentLauncherItemAccepted = false;
+
+        if (m_dndCurrentLauncherItem != NULL) {
+            delegateDragEventHandlingToItem(event, m_dndCurrentLauncherItem);
+            if (event->isAccepted()) {
+                m_dndCurrentLauncherItemAccepted = true;
+            }
+        } else {
+            if (m_dndAccepted) {
+                event->setAccepted(true);
+            }
+        }
+    }
+}
+
+void
+LauncherView::dropEvent(QDropEvent* event)
+{
+    if (m_dndCurrentLauncherItemAccepted) {
+        DeclarativeDragDropEvent dde(event, this);
+        QMetaObject::invokeMethod(m_dndCurrentLauncherItem, "dropEvent",
+                                  Q_ARG(QVariant, QVariant::fromValue(&dde)));
+    } else if (m_dndAccepted) {
+        Q_FOREACH(QUrl url, getEventUrls(event)) {
+            if (url.scheme() == "file" && url.path().endsWith(".desktop")) {
+                emit desktopFileDropped(url.path());
+            } else if (url.scheme().startsWith("http")) {
+                emit webpageUrlDropped(url);
+            }
+        }
+    }
 }
 
 /* Calculates both the background color and the glow color of a launcher tile

=== modified file 'launcher/app/launcherview.h'
--- launcher/app/launcherview.h	2011-02-10 16:57:57 +0000
+++ launcher/app/launcherview.h	2011-02-16 11:14:09 +0000
@@ -22,8 +22,10 @@
 
 #include <QDeclarativeView>
 #include <QUrl>
+#include <QList>
 #include <QDragEnterEvent>
-#include <QList>
+
+class QGraphicsObject;
 
 class LauncherView : public QDeclarativeView
 {
@@ -40,15 +42,27 @@
 private:
     QList<QUrl> getEventUrls(QDropEvent*);
 
-    void dragEnterEvent(QDragEnterEvent *event);
-    void dropEvent(QDropEvent *event);
-    void dragMoveEvent(QDragMoveEvent *event);
-
     /* Whether the launcher is already being resized */
     bool m_resizing;
 
     /* Whether space at the left of the screen has already been reserved */
     bool m_reserved;
+
+    /* Custom drag’n’drop handling */
+    void dragEnterEvent(QDragEnterEvent*);
+    void dragMoveEvent(QDragMoveEvent*);
+    void dropEvent(QDropEvent*);
+
+    QGraphicsObject* launcherItemAt(const QPoint&) const;
+    void delegateDragEventHandlingToItem(QDropEvent*, QGraphicsObject*);
+    bool acceptDndEvent(QDragEnterEvent*);
+
+    /* The launcher item currently under the mouse cursor during a dnd event */
+    QGraphicsObject* m_dndCurrentLauncherItem;
+    /* Whether it accepted the event */
+    bool m_dndCurrentLauncherItemAccepted;
+    /* Whether the launcher itself handles the current dnd event */
+    bool m_dndAccepted;
 };
 
 #endif // LAUNCHERVIEW

=== modified file 'libunity-2d-private/Unity2d/CMakeLists.txt'
--- libunity-2d-private/Unity2d/CMakeLists.txt	2011-02-10 08:40:03 +0000
+++ libunity-2d-private/Unity2d/CMakeLists.txt	2011-02-16 11:14:09 +0000
@@ -39,6 +39,7 @@
     ${WNCK_INCLUDE_DIRS}
     ${QTBAMF_INCLUDE_DIRS}
     ${QTGCONF_INCLUDE_DIRS}
+    ${libunity-2d-private_SOURCE_DIR}/src
     )
 
 target_link_libraries(unity-2d-private-qml
@@ -48,6 +49,7 @@
     ${WNCK_LDFLAGS}
     ${QTBAMF_LDFLAGS}
     ${QTGCONF_LDFLAGS}
+    unity-2d-private
     )
 
 # Install

=== modified file 'libunity-2d-private/Unity2d/plugin.cpp'
--- libunity-2d-private/Unity2d/plugin.cpp	2011-02-08 11:48:16 +0000
+++ libunity-2d-private/Unity2d/plugin.cpp	2011-02-16 11:14:09 +0000
@@ -32,6 +32,9 @@
 #include "plugin.h"
 #include "cacheeffect.h"
 
+#include "mimedata.h"
+#include "dragdropevent.h"
+
 #include <QtDeclarative/qdeclarative.h>
 #include <QDeclarativeEngine>
 #include <QDeclarativeContext>
@@ -66,6 +69,10 @@
     qmlRegisterType<WorkspacesInfo>(); // Register the type as non creatable
 
     qmlRegisterType<CacheEffect>(uri, 0, 1, "CacheEffect");
+
+    /* Custom drag’n’drop implementation in QML */
+    qmlRegisterType<DeclarativeMimeData>();
+    qmlRegisterType<DeclarativeDragDropEvent>();
 }
 
 void Unity2dPlugin::initializeEngine(QDeclarativeEngine *engine, const char *uri)

=== modified file 'libunity-2d-private/src/CMakeLists.txt'
--- libunity-2d-private/src/CMakeLists.txt	2011-02-10 08:40:03 +0000
+++ libunity-2d-private/src/CMakeLists.txt	2011-02-16 11:14:09 +0000
@@ -4,6 +4,8 @@
     keyboardmodifiersmonitor.cpp
     unity2dapplication.cpp
     unity2dpanel.cpp
+    mimedata.cpp
+    dragdropevent.cpp
     )
 
 # Build

=== added file 'libunity-2d-private/src/dragdropevent.cpp'
--- libunity-2d-private/src/dragdropevent.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/dragdropevent.cpp	2011-02-16 11:14:09 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Olivier Tilloy <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dragdropevent.h"
+
+DeclarativeDragDropEvent::DeclarativeDragDropEvent(QDropEvent* event, QObject* parent)
+    : QObject(parent)
+    , m_event(event)
+    , m_mimeData(event->mimeData())
+{
+    /* By default the event is not accepted, let the receiver decide. */
+    m_event->setAccepted(false);
+}
+
+bool
+DeclarativeDragDropEvent::accepted() const
+{
+    return m_event->isAccepted();
+}
+
+void
+DeclarativeDragDropEvent::setAccepted(bool accepted)
+{
+    m_event->setAccepted(accepted);
+}
+
+Qt::DropAction
+DeclarativeDragDropEvent::dropAction() const
+{
+    return m_event->dropAction();
+}
+
+void
+DeclarativeDragDropEvent::setDropAction(Qt::DropAction action)
+{
+    m_event->setDropAction(action);
+}
+
+#include "dragdropevent.moc"
+

=== added file 'libunity-2d-private/src/dragdropevent.h'
--- libunity-2d-private/src/dragdropevent.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/dragdropevent.h	2011-02-16 11:14:09 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Olivier Tilloy <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Original ideas for drag’n’drop implementation by Grégory Schlomoff
+   (https://bitbucket.org/gregschlom/qml-drag-drop/). */
+
+#ifndef DeclarativeDragDropEvent_H
+#define DeclarativeDragDropEvent_H
+
+#include "mimedata.h"
+
+#include <QtGui/QDropEvent>
+#include <QtCore/Qt>
+
+class DeclarativeDragDropEvent : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(DeclarativeMimeData* mimeData READ mimeData)
+    Q_PROPERTY(bool accepted READ accepted WRITE setAccepted)
+    Q_PROPERTY(Qt::DropAction dropAction READ dropAction WRITE setDropAction)
+
+public:
+    DeclarativeDragDropEvent(QDropEvent* event, QObject* parent=0);
+
+    /* getters */
+    DeclarativeMimeData* mimeData() { return &m_mimeData; }
+    bool accepted() const;
+    Qt::DropAction dropAction() const;
+
+    /* setters */
+    void setAccepted(bool accepted);
+    void setDropAction(Qt::DropAction action);
+
+private:
+    QDropEvent* m_event;
+    DeclarativeMimeData m_mimeData;
+};
+
+Q_DECLARE_METATYPE(DeclarativeDragDropEvent*)
+
+#endif // DeclarativeDragDropEvent
+

=== added file 'libunity-2d-private/src/mimedata.cpp'
--- libunity-2d-private/src/mimedata.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/mimedata.cpp	2011-02-16 11:14:09 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Olivier Tilloy <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mimedata.h"
+
+DeclarativeMimeData::DeclarativeMimeData(const QMimeData* data)
+    : QMimeData()
+{
+    Q_FOREACH(QString format, data->formats()) {
+        setData(format, data->data(format));
+    }
+}
+
+#include "mimedata.moc"
+

=== added file 'libunity-2d-private/src/mimedata.h'
--- libunity-2d-private/src/mimedata.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/mimedata.h	2011-02-16 11:14:09 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Olivier Tilloy <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Original ideas for drag’n’drop implementation by Grégory Schlomoff
+   (https://bitbucket.org/gregschlom/qml-drag-drop/). */
+
+#ifndef DeclarativeMimeData_H
+#define DeclarativeMimeData_H
+
+#include <QtCore/QMimeData>
+#include <QtCore/QStringList>
+#include <QtCore/QString>
+#include <QtCore/QList>
+#include <QtCore/QUrl>
+
+class DeclarativeMimeData : public QMimeData
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QStringList formats READ formats)
+    Q_PROPERTY(QString text READ text)
+    Q_PROPERTY(QString html READ html)
+    Q_PROPERTY(QList<QUrl> urls READ urls)
+
+public:
+    DeclarativeMimeData(const QMimeData* data);
+};
+
+Q_DECLARE_METATYPE(DeclarativeMimeData*)
+
+#endif // DeclarativeMimeData
+