Changeset 50305 in vbox for trunk/src/VBox/Frontends

Timestamp:

Feb 3, 2014 10:47:45 AM (11 years ago)

Author:

vboxsync

Message:

DnD: Update.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (1 diff)
• src/runtime/UIDnDHandler.cpp (modified) (6 diffs)
• src/runtime/UIDnDHandler.h (modified) (3 diffs)
• src/runtime/UIDnDMIMEData.cpp (modified) (7 diffs)
• src/runtime/UIDnDMIMEData.h (modified) (3 diffs)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -451 +451 @@
 
 ifdef VBOX_WITH_DRAG_AND_DROP
+ VirtualBox_QT_MOCHDRS += \
+        src/runtime/UIDnDHandler.h
  ifdef VBOX_WITH_DRAG_AND_DROP_GH
   VirtualBox_QT_MOCHDRS += \

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIDnDHandler.cpp

@@ -23 +23 @@
 #include <QStringList>
 #include <QTimer>
+#include <QUrl>
 
 #ifdef LOG_GROUP
@@ -168 +169 @@
      * Do guest -> host format conversion, if needed.
      * On X11 this already maps to the Xdnd protocol.
-     ** @todo What about MacOS X Carbon Drag Manager?
+     ** @todo What about the MacOS Carbon Drag Manager? Needs testing.
      *
      * See: https://www.iana.org/assignments/media-types/media-types.xhtml
@@ -176 +177 @@
     for (int i = 0; i < vecFmtGuest.size(); i++)
     {
-        const QString &strFmt = vecFmtGuest.at(i);
+        const QString &strFmtGuest = vecFmtGuest.at(i);
         LogFlowFunc(("\tFormat %d: %s\n", i,
-                     strFmt.toAscii().constData()));
+                     strFmtGuest.toAscii().constData()));
 #ifdef RT_OS_WINDOWS
-        if (   strFmt.contains("text", Qt::CaseInsensitive)
+        /* CF_TEXT */
+        if (   strFmtGuest.contains("text/plain", Qt::CaseInsensitive)
             && !lstFmtNative.contains("text/plain"))
         {
             lstFmtNative << "text/plain";
         }
+        /* CF_HDROP */
+        else if (   strFmtGuest.contains("text/uri-list", Qt::CaseInsensitive)
+                 && !lstFmtNative.contains("text/uri-list"))
+        {
+            lstFmtNative << "text/uri-list";
+        }
 #else
-        lstFmtNative << strFmt;
+        /* On non-Windows just do a 1:1 mapping. */
+        lstFmtNative << strFmtGuest;
+# ifdef RT_OS_MACOS
+        /** @todo Does the mapping apply here? Don't think so ... */
+# endif
 #endif
     }
@@ -204 +216 @@
 
             /* pMData is transfered to the QDrag object, so no need for deletion. */
-            UIDnDMimeData *pMData = new UIDnDMimeData(session, lstFmtNative,
+            pMData = new UIDnDMimeData(session, lstFmtNative,
                                                       toQtDnDAction(defaultAction),
                                                       toQtDnDActions(vecActions), pParent);
+
+            /* Inform this object that MIME data from the guest is available so that
+             * it can update the MIME data object accordingly. */
+            connect(pMData, SIGNAL(sigDataAvailable(QString)),
+                    this, SLOT(sltDataAvailable(QString)), Qt::DirectConnection);
 
             /* Inform the MIME data object of any changes in the current action. */
@@ -218 +235 @@
              * is finished. */
             pDrag->setMimeData(pMData);
-            pDrag->exec(toQtDnDActions(vecActions), toQtDnDAction(defaultAction));
-
+            Qt::DropAction dropAction =
+                 pDrag->exec(toQtDnDActions(vecActions), toQtDnDAction(defaultAction));
+            LogFlowFunc(("dropAction=%ld\n", toVBoxDnDAction(dropAction)));
+#ifdef RT_OS_WINDOWS
+            /* Since the QDrag::exec() call above was blocking on Windows, decide what
+             * to do now, e.g. if there was a "drop" action.
+             *
+             * Note: The UIDnDMimeData object will not be not accessible here anymore,
+             *       since QDrag had its ownership and deleted it after the (blocking)
+             *       QDrag::exec() call. */
+#endif
             rc = VINF_SUCCESS;
         }
@@ -310 +336 @@
 }
 
+void UIDnDHandler::sltDataAvailable(const QString &mimeType)
+{
+    LogFlowFunc(("pMData=0x%p, mimeType=%s\n",
+                 pMData, mimeType.toAscii().constData()));
+
+    if (pMData)
+        pMData->setData(mimeType);
+}
+
 #include "UIDnDHandler.moc"
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIDnDHandler.h

@@ -24 +24 @@
 #include "COMEnums.h"
 
-/* Forward declarations. */
+/* Forward declarations: */
 class QMimeData;
 class CSession;
 class CGuest;
+class UIDnDMimeData;
 
-/** @todo Check for making this a full static class when possible. */
 class UIDnDHandler: public QObject
 {
+    Q_OBJECT;
+
 public:
     /* Singleton factory. */
@@ -58 +60 @@
     int            dragGHPending(CSession &session, ulong screenId, QWidget *pParent = NULL);
 
+public slots:
+
+    void sltDataAvailable(const QString &mimetype);
+
 private:
     static UIDnDHandler *m_pInstance;
@@ -70 +76 @@
     static Qt::DropActions             toQtDnDActions(const QVector<KDragAndDropAction> &vecActions);
 
+    UIDnDMimeData *pMData;
+
     friend class UIDnDMimeData;
 };

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIDnDMIMEData.cpp

@@ -24 +24 @@
 #include <QStringList>
 #include <QTimer>
+#include <QUrl>
 
 #ifdef LOG_GROUP
@@ -107 +108 @@
                                      QVariant::Type type) const
 {
-    LogFlowFunc(("m_enmState=%d, mimeType=%s, type=%d\n",
-                 m_enmState, mimeType.toStdString().c_str(), type));
+    LogFlowFunc(("m_enmState=%d, mimeType=%s, type=%d (%s)\n",
+                 m_enmState, mimeType.toStdString().c_str(),
+                 type, QVariant::typeToName(type)));
 
     bool fCanDrop = true;
@@ -132 +134 @@
      * So just update our internal state to reflect the same as on other
      * platforms. */
-    m_enmState = Dropped;
+    fCanDrop = true;
 #else
     /* Mouse button released? See eventFilter for more information. */
@@ -139 +141 @@
 #endif
 
-#if defined (RT_OS_WINDOWS) || defined (RT_OS_MACOS)
-    /* Special MIME handling. Later. */
-#endif
-
     /* Do we support the requested MIME type? */
     if (   fCanDrop
@@ -154 +152 @@
     /* Supported types. See below in the switch statement. */
     if (   fCanDrop
-        && !(   /* Regular text. */
+        && !(
+             /* Plain text. */
                 type == QVariant::String
              /* Binary data. */
@@ -170 +169 @@
         LogFlowFunc(("Skipping request, m_enmState=%d ...\n",
                      m_enmState));
-        return QVariant();
-    }
-
-    CGuest guest = m_session.GetConsole().GetGuest();
-    /* Start getting the data from the guest. First inform the guest we
-     * want the data in the specified MIME type. */
-    CProgress progress = guest.DragGHDropped(mimeType,
-                                             UIDnDHandler::toVBoxDnDAction(m_defAction));
-    if (guest.isOk())
-    {
-        msgCenter().showModalProgressDialog(progress,
-                                            tr("Retrieving data ..."), ":/progress_dnd_gh_90px.png",
-                                            m_pParent);
-        if (!progress.GetCanceled())
-        {
-            if (   progress.isOk()
-                && progress.GetResultCode() == 0)
-            {
-                /** @todo What about retrieving bigger files? Loop? */
-
-                /* After the data successfully arrived from the guest, we query it from Main. */
-                QVector<uint8_t> data = guest.DragGHGetData();
-                if (!data.isEmpty())
+        return QMimeData::retrieveData(mimeType, type);
+    }
+
+    if (m_enmState == Dragging)
+    {
+        int rc = VINF_SUCCESS;
+
+        CGuest guest = m_session.GetConsole().GetGuest();
+        /* Start getting the data from the guest. First inform the guest we
+         * want the data in the specified MIME type. */
+        CProgress progress = guest.DragGHDropped(mimeType,
+                                                 UIDnDHandler::toVBoxDnDAction(m_defAction));
+        if (guest.isOk())
+        {
+            msgCenter().showModalProgressDialog(progress,
+                                                tr("Retrieving data ..."), ":/progress_dnd_gh_90px.png",
+                                                m_pParent);
+            if (!progress.GetCanceled())
+            {
+                if (   progress.isOk()
+                    && progress.GetResultCode() == 0)
                 {
-                    switch (type)
+                    /** @todo What about retrieving bigger files? Loop? */
+
+                    /* After the data successfully arrived from the guest, we query it from Main. */
+                    QVector<uint8_t> data = guest.DragGHGetData();
+                    if (!data.isEmpty())
                     {
-                        case QVariant::String:
+                        switch (type)
                         {
-                            m_data = QVariant(QString(reinterpret_cast<const char*>(data.data())));
-                            break;
+                            case QVariant::String:
+                            {
+                                m_data = QVariant(QString(reinterpret_cast<const char*>(data.data())));
+                                break;
+                            }
+
+                            case QVariant::ByteArray:
+                            {
+                                QByteArray ba(reinterpret_cast<const char*>(data.constData()), data.size());
+                                m_data = QVariant(ba);
+                                break;
+                            }
+
+                            case QVariant::List:
+                            {
+                                QString strData = QString(reinterpret_cast<const char*>(data.data()));
+                                QStringList lstString = strData.split("\r\n", QString::SkipEmptyParts);
+
+                                m_data = QVariant(lstString);
+                                break;
+                            }
+
+                            default:
+                                AssertMsgFailed(("Should never happen, d'oh!\n"));
+                                rc = VERR_NOT_SUPPORTED;
+                                break;
                         }
-
-                        case QVariant::ByteArray:
-                        {
-                            QByteArray ba(reinterpret_cast<const char*>(data.constData()), data.size());
-                            m_data = QVariant(ba);
-                            break;
-                        }
-
-                        case QVariant::List:
-                        {
-                            /** @todo Support URIs. */
-                            break;
-                        }
-
-                        default:
-                            AssertMsgFailed(("Should never happen, d'oh!\n"));
-                            break;
                     }
+                    /** @todo How often to retry on empty data received? */
+
+                    if (RT_SUCCESS(rc))
+                        emit sigDataAvailable(mimeType);
+
+                    m_enmState = DataRetrieved;
                 }
-                /** @todo How often to retry on empty data received? */
-
-                m_enmState = Finished;
+                else
+                    msgCenter().cannotDropData(progress, m_pParent);
             }
             else
-                msgCenter().cannotDropData(progress, m_pParent);
+                m_enmState = Canceled;
         }
         else
-            m_enmState = Canceled;
-    }
-    else
-        msgCenter().cannotDropData(guest, m_pParent);
-
+            msgCenter().cannotDropData(guest, m_pParent);
+    }
+
+    //return QMimeData::retrieveData(mimeType, type);
     return m_data;
 }
@@ -288 +300 @@
 #endif /* RT_OS_WINDOWS */
 
+int UIDnDMimeData::setData(const QString &mimeType)
+{
+    LogFlowFunc(("mimeType=%s, dataType=%s\n",
+                 mimeType.toAscii().constData(), m_data.typeName()));
+
+    int rc = VINF_SUCCESS;
+
+    switch (m_data.type())
+    {
+        case QVariant::String: /* Plain text. */
+        {
+            QMimeData::setText(m_data.toString());
+            break;
+        }
+
+        case QVariant::ByteArray: /* Raw byte data. */
+        {
+            QMimeData::setData(mimeType, m_data.toByteArray());
+            break;
+        }
+
+        case QVariant::StringList: /* URI. */
+        {
+            QList<QVariant> lstData = m_data.toList();
+            QList<QUrl> lstURL;
+            for (int i = 0; i < lstData.size(); i++)
+            {
+                QString strURL = lstData.at(i).toString();
+                LogFlowFunc(("\tURL: %s\n",
+                             strURL.toAscii().constData()));
+                lstURL << QUrl(strURL.toAscii());
+            }
+            LogFlowFunc(("Number of URLs: %d\n",  lstURL.size()));
+
+            QMimeData::setUrls(f);
+            break;
+        }
+
+        default:
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+#include "UIDnDMIMEData.moc"
+

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIDnDMIMEData.h

@@ -46 +46 @@
     {
         Dragging = 0,
+        DataRetrieved,
         Dropped,
-        Finished,
         Canceled
     };
@@ -56 +56 @@
                   Qt::DropAction defAction,
                   Qt::DropActions actions, QWidget *pParent);
+
+    int setData(const QString &mimeType);
 
 public slots:
@@ -74 +76 @@
 #endif
     /** @}  */
+
+signals:
+
+    void sigDataAvailable(const QString &mimeType) const;
 
 private slots: