Changeset 50265 in vbox

Timestamp:

Jan 29, 2014 11:12:44 AM (11 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

91898

Message:

DnD: First working implementation for Windows guest->host support; still work in progress. As for now only pure text data can be dragged over.

Location:

trunk

Files:

• include/VBox/HostServices/DragAndDropSvc.h (modified) (6 diffs)
• src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.cpp (modified) (14 diffs)
• src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.h (modified) (2 diffs)
• src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp (modified) (9 diffs)
• src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibDragAndDrop.cpp (modified) (7 diffs)
• src/VBox/Additions/x11/VBoxClient/draganddrop.cpp (modified) (5 diffs)
• src/VBox/Frontends/VirtualBox/Makefile.kmk (modified) (7 diffs)
• src/VBox/Frontends/VirtualBox/src/runtime/UIDnDHandler.cpp (modified) (11 diffs)
• src/VBox/Frontends/VirtualBox/src/runtime/UIDnDHandler.h (modified) (4 diffs)
• src/VBox/Frontends/VirtualBox/src/runtime/UIDnDMIMEData.cpp (added)
• src/VBox/Frontends/VirtualBox/src/runtime/UIDnDMIMEData.h (added)
• src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp (modified) (1 diff)
• src/VBox/HostServices/DragAndDrop/service.cpp (modified) (2 diffs)
• src/VBox/Main/src-client/GuestDnDImpl.cpp (modified) (24 diffs)

trunk/include/VBox/HostServices/DragAndDropSvc.h

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2011-2013 Oracle Corporation
+ * Copyright (C) 2011-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -61 +61 @@
 /**
  * The service functions which are callable by host.
+ * Note: When adding new functions to this table, make sure that the actual ID
+ *       does *not* overlap with the eGuestFn enumeration below!
  */
 enum eHostFn
@@ -82 +84 @@
 
     /* G->H */
-    HOST_DND_GH_REQ_PENDING            = 300,
+    /** The host asks the guest whether a DnD operation
+     *  is in progress when the mouse leaves the guest window. */
+    HOST_DND_GH_REQ_PENDING            = 600,
+    /** The host informs the guest that a DnD drop operation
+     *  has been started and that the host wants the data in
+     *  a specific mime-type. */
     HOST_DND_GH_EVT_DROPPED
 };
@@ -88 +95 @@
 /**
  * The service functions which are called by guest.
+ * Note: When adding new functions to this table, make sure that the actual ID
+ *       does *not* overlap with the eGuestFn enumeration above!
  */
 enum eGuestFn
 {
     /**
-     * Guest waits for a new message the host wants to process on the guest side.
-     * This is a blocking call and can be deferred.
+     * Guest waits for a new message the host wants to process
+     * on the guest side. This can be a blocking call.
      */
     GUEST_DND_GET_NEXT_HOST_MSG        = 300,
@@ -103 +112 @@
 
     /* G->H */
+    /**
+     * The guests acknowledges that it currently has a drag'n drop
+     * operation in progress on the guest, which eventually could be
+     * dragged over to the host.
+     */
     GUEST_DND_GH_ACK_PENDING           = 500,
     GUEST_DND_GH_SND_DATA,
@@ -416 +430 @@
     void     *pvData;
     uint32_t  cbData;
-    uint32_t  cbAllSize;
+    uint32_t  cbAllSize; /** @todo Why is this transmitted every time? */
 } VBOXDNDCBSNDDATADATA;
 typedef VBOXDNDCBSNDDATADATA *PVBOXDNDCBSNDDATADATA;

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.cpp

@@ -229 +229 @@
         } while (RT_SUCCESS(rc));
 
+        int rc2 = pThis->UnregisterAsDropTarget();
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+
         OleUninitialize();
     }
@@ -405 +409 @@
                     reset();
 
-                    Assert(mMode == Unknown);
                     mMode = HG;
 
@@ -464 +467 @@
 
                     rc = OnHgCancel();
-
-                    reset();
                     break;
                 }
@@ -473 +474 @@
                     LogFlowThisFunc(("HOST_DND_GH_REQ_PENDING\n"));
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
-                    Assert(   mMode == Unknown
-                           || mMode == GH);
-                    mMode = GH;
-                    rc = OnGhIsDnDPending(pEvent->Event.uScreenId);
+                    if (   mMode == Unknown
+                        /* There can be more than one HOST_DND_GH_REQ_PENDING
+                         * messages coming in. */
+                        || mMode == GH)
+                    {
+                        mMode = GH;
+                        rc = OnGhIsDnDPending(pEvent->Event.uScreenId);
+                    }
+                    else
+                        rc = VERR_WRONG_ORDER;
 #else
                     rc = VERR_NOT_SUPPORTED;
@@ -487 +494 @@
                     LogFlowThisFunc(("HOST_DND_GH_EVT_DROPPED\n"));
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
-                    Assert(mMode == GH);
-                    rc = OnGhDropped(pEvent->Event.pszFormats,
-                                     pEvent->Event.cbFormats,
-                                     pEvent->Event.u.a.uDefAction);
-                    mMode = Unknown;
+                    if (mMode == GH)
+                    {
+                        rc = OnGhDropped(pEvent->Event.pszFormats,
+                                         pEvent->Event.cbFormats,
+                                         pEvent->Event.u.a.uDefAction);
+                    }
+                    else
+                        rc = VERR_WRONG_ORDER;
 #else
                     rc = VERR_NOT_SUPPORTED;
@@ -585 +595 @@
         }
         else
+        {
             rc = VINF_SUCCESS;
+        }
     }
     catch (std::bad_alloc)
@@ -598 +610 @@
 int VBoxDnDWnd::UnregisterAsDropTarget(void)
 {
+    LogFlowFuncEnter();
+
     if (!pDropTarget) /* No drop target? Bail out. */
         return VINF_SUCCESS;
@@ -606 +620 @@
                                   TRUE /* fLastUnlockReleases */);
     if (SUCCEEDED(hr))
-        pDropTarget->Release();
+    {
+        ULONG cRefs = pDropTarget->Release();
+
+        Assert(cRefs == 0);
+        pDropTarget = NULL;
+    }
 
     int rc = SUCCEEDED(hr)
@@ -652 +671 @@
      */
     const RTCList<RTCString> lstAllowedMimeTypes = RTCList<RTCString>()
-        /* Uri's */
+        /* URI's */
         << "text/uri-list"
         /* Text */
@@ -661 +680 @@
         << "TEXT"
         << "STRING"
-        /* OpenOffice formates */
+        /* OpenOffice formats */
         << "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\""
         << "application/x-openoffice-drawing;windows_formatname=\"Drawing Format\"";
@@ -855 +874 @@
     if (RT_SUCCESS(rc))
         rc = rc2;
+
+    reset();
 
     return rc;
@@ -959 +980 @@
     if (RT_SUCCESS(rc))
     {
+        AssertPtr(pDropTarget);
+
         uint32_t uDefAction = DND_IGNORE_ACTION;
         RTCString strFormat = "unknown";
-        if (   pDropTarget
-            && pDropTarget->HasData())
+        if (pDropTarget->HasData())
         {
             uDefAction = DND_COPY_ACTION;
@@ -970 +992 @@
              *        with \r\n. */
             strFormat = "text/plain;charset=utf-8";
-        }
-
-        LogFlowFunc(("Acknowledging pDropTarget=0x%p, uDefAction=0x%x, uAllActions=0x%x, strFormat=%s\n",
-                     pDropTarget, uDefAction, uAllActions, strFormat.c_str()));
-        rc = VbglR3DnDGHAcknowledgePending(mClientID,
-                                           uDefAction, uAllActions, strFormat.c_str());
+
+            LogFlowFunc(("Acknowledging pDropTarget=0x%p, uDefAction=0x%x, uAllActions=0x%x, strFormat=%s\n",
+                         pDropTarget, uDefAction, uAllActions, strFormat.c_str()));
+            rc = VbglR3DnDGHAcknowledgePending(mClientID,
+                                               uDefAction, uAllActions, strFormat.c_str());
+        }
     }
 
@@ -985 +1007 @@
                             uint32_t uDefAction)
 {
-    LogFlowThisFunc(("mMode=%ld, mState=%ld, cbFormats=%RU32, uDefAction=0x%x\n",
-                     mMode, mState, cbFormats, uDefAction));
+    LogFlowThisFunc(("mMode=%ld, mState=%ld, pDropTarget=0x%p, cbFormats=%RU32, uDefAction=0x%x\n",
+                     mMode, mState, pDropTarget, cbFormats, uDefAction));
     int rc;
     if (mState == Dragging)
     {
         AssertPtr(pDropTarget);
+        rc = pDropTarget->WaitForDrop(30 * 1000 /* Timeout */);
+        if (RT_SUCCESS(rc))
+        {
+            /** @todo Respect uDefAction. */
+            /** @todo Do data checking / conversion based on pszFormats. */
+
+            void *pvData = pDropTarget->DataMutableRaw();
+            AssertPtr(pvData);
+            uint32_t cbData = pDropTarget->DataSize();
+            Assert(cbData);
+
+            rc = VbglR3DnDGHSendData(mClientID, pvData, cbData);
+            LogFlowFunc(("Sent pvData=0x%p, cbData=%RU32, rc=%Rrc\n",
+                         pvData, cbData, rc));
+        }
+
+        reset();
     }
     else

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.h

@@ -151 +151 @@
 
     static DWORD GetDropEffect(DWORD grfKeyState, DWORD dwAllowedEffects);
-
-public:
-
-    const IDataObject *GetDataObject(void) { return mpDataObject; }
-    bool HasData(void) { return mfHasDropData; }
+    void reset(void);
+
+public:
+
+    bool HasData(void) { return RT_BOOL(mFormatEtc.cfFormat != 0); }
+    void *DataMutableRaw(void) { return mpvData; }
+    uint32_t DataSize(void) { return mcbData; }
+    int WaitForDrop(RTMSINTERVAL msTimeout);
 
 protected:
@@ -163 +166 @@
     uint32_t mClientID;
     DWORD mdwCurEffect;
-    IDataObject *mpDataObject;
-    bool mfHasDropData;
+    /** Copy of the data object's FORMATETC struct.
+     *  Note: We don't keep the pointer of the
+     *        DVTARGETDEVICE here! */
+    FORMATETC mFormatEtc;
+    void *mpvData;
+    uint32_t mcbData;
+    RTSEMEVENT hEventDrop;
 };
 

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp

@@ -31 +31 @@
       mClientID(UINT32_MAX),
       mdwCurEffect(0),
-      mpDataObject(NULL),
-      mfHasDropData(false)
+      mpvData(NULL),
+      mcbData(0),
+      hEventDrop(NIL_RTSEMEVENT)
 {
     int rc = VbglR3DnDConnect(&mClientID);
+    if (RT_SUCCESS(rc))
+        rc = RTSemEventCreate(&hEventDrop);
 
     LogFlowFunc(("clientID=%RU32, rc=%Rrc\n",
@@ -42 +45 @@
 VBoxDnDDropTarget::~VBoxDnDDropTarget(void)
 {
-    int rc = VbglR3DnDDisconnect(mClientID);
-
-    LogFlowFunc(("rc=%Rrc, mRefCount=%RI32\n", rc, mRefCount));
+    reset();
+
+    int rc2 = VbglR3DnDDisconnect(mClientID);
+    AssertRC(rc2);
+    rc2 = RTSemEventDestroy(hEventDrop);
+    AssertRC(rc2);
+
+    LogFlowFunc(("rc=%Rrc, mRefCount=%RI32\n", rc2, mRefCount));
 }
 
@@ -94 +102 @@
     AssertPtrReturn(pdwEffect, E_INVALIDARG);
 
-    LogFlowFunc(("mfHasDropData=%RTbool, pDataObject=0x%p, grfKeyState=0x%x, x=%ld, y=%ld, dwEffect=%RU32\n",
-                 mfHasDropData, pDataObject, grfKeyState, pt.x, pt.y, *pdwEffect));
-
-    FORMATETC fmtetc = { CF_TEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
-
-    /* We only handle CF_HDROP in an HGLOBAL medium at the moment. */
-    HRESULT hr = pDataObject->QueryGetData(&fmtetc);
-    mfHasDropData = hr == S_OK;
-
-    if (mfHasDropData)
-    {
+    LogFlowFunc(("pDataObject=0x%p, grfKeyState=0x%x, x=%ld, y=%ld, dwEffect=%RU32\n",
+                 pDataObject, grfKeyState, pt.x, pt.y, *pdwEffect));
+
+    reset();
+
+    /* Try different formats. CF_HDROP is the most common one, so start
+     * with this. */
+    /** @todo At the moment we only support TYMED_HGLOBAL. */
+    FORMATETC fmtEtc = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+    HRESULT hr = pDataObject->QueryGetData(&fmtEtc);
+    if (hr != S_OK)
+    {
+        LogFlowFunc(("CF_HDROP not supported, hr=%Rhrc\n", hr));
+
+        /* So we couldn't retrieve the data in CF_HDROP format; try with
+         * CF_TEXT format now. Rest stays the same. */
+        fmtEtc.cfFormat = CF_TEXT;
+        hr = pDataObject->QueryGetData(&fmtEtc);
+        if (hr != S_OK)
+        {
+            LogFlowFunc(("CF_TEXT not supported, hr=%Rhrc\n", hr));
+            fmtEtc.cfFormat = 0; /* Mark it to not supported. */
+        }
+    }
+
+    /* Did we find a format that we support? */
+    if (fmtEtc.cfFormat)
+    {
+        LogFlowFunc(("Found supported format %RI16\n", fmtEtc.cfFormat));
+
+        /* Make a copy of the FORMATETC structure so that we later can
+         * use this for comparrison and stuff. */
+        /** Note: The DVTARGETDEVICE member only is a shallow copy! */
+        memcpy(&mFormatEtc, &fmtEtc, sizeof(FORMATETC));
+
         /* Which drop effect we're going to use? */
         /* Note: pt is not used since we don't need to differentiate within our
@@ -114 +146 @@
         /* No or incompatible data -- so no drop effect required. */
         *pdwEffect = DROPEFFECT_NONE;
-    }
-
-    LogFlowFunc(("Returning mfHasDropData=%RTbool, pdwEffect=%ld, hr=%Rhrc\n",
-                 mfHasDropData, *pdwEffect, hr));
+
+        switch (hr)
+        {
+            case ERROR_INVALID_FUNCTION:
+            {
+                LogRel(("DnD: Drag'n drop format is not supported by VBoxTray\n"));
+
+                /* Enumerate supported source formats. This shouldn't happen too often
+                 * on day to day use, but still keep it in here. */
+                IEnumFORMATETC *pEnumFormats;
+                HRESULT hr2 = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormats);
+                if (SUCCEEDED(hr2))
+                {
+                    LogRel(("DnD: The following formats were offered to us:\n"));
+
+                    FORMATETC curFormatEtc;
+                    while (pEnumFormats->Next(1, &curFormatEtc,
+                                              NULL /* pceltFetched */) == S_OK)
+                        {
+                        WCHAR wszCfName[128]; /* 128 chars should be enough, rest will be truncated. */
+                        hr2 = GetClipboardFormatNameW(curFormatEtc.cfFormat, wszCfName,
+                                                      sizeof(wszCfName) / sizeof(WCHAR));
+                        LogRel(("\tcfFormat=%RI16, tyMed=%RI32, dwAspect=%RI32, strCustomName=%ls, hr=%Rhrc\n",
+                                curFormatEtc.cfFormat,
+                                curFormatEtc.tymed,
+                                curFormatEtc.dwAspect,
+                                wszCfName, hr2));
+                    }
+
+                    pEnumFormats->Release();
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    LogFlowFunc(("Returning cfFormat=%RI16, pdwEffect=%ld, hr=%Rhrc\n",
+                 fmtEtc.cfFormat, *pdwEffect, hr));
     return hr;
 }
@@ -126 +196 @@
 
 #ifdef DEBUG_andy
-    LogFlowFunc(("mfHasDropData=%RTbool, grfKeyState=0x%x, x=%ld, y=%ld\n",
-                 mfHasDropData, grfKeyState, pt.x, pt.y));
+    LogFlowFunc(("cfFormat=%RI16, grfKeyState=0x%x, x=%ld, y=%ld\n",
+                 mFormatEtc.cfFormat, grfKeyState, pt.x, pt.y));
 #endif
 
-    if (mfHasDropData)
+    if (mFormatEtc.cfFormat)
     {
         /* Note: pt is not used since we don't need to differentiate within our
@@ -150 +220 @@
 {
 #ifdef DEBUG_andy
-    LogFlowFunc(("mfHasDropData=%RTbool\n", mfHasDropData));
+    LogFlowFunc(("cfFormat=%RI16\n", mFormatEtc.cfFormat));
 #endif
 
-    mpWndParent->hide();
+    if (mpWndParent)
+        mpWndParent->hide();
 
     return S_OK;
@@ -165 +236 @@
 
 #ifdef DEBUG
-    LogFlowFunc(("mfHasDropData=%RTbool, pDataObject=0x%p, grfKeyState=0x%x, x=%ld, y=%ld\n",
-                 mfHasDropData, pDataObject, grfKeyState, pt.x, pt.y));
+    LogFlowFunc(("mFormatEtc.cfFormat=%RI16, pDataObject=0x%p, grfKeyState=0x%x, x=%ld, y=%ld\n",
+                 mFormatEtc.cfFormat, pDataObject, grfKeyState, pt.x, pt.y));
 #endif
+    HRESULT hr = S_OK;
+
     bool fCanDrop = false;
-    if (mfHasDropData)
-    {
-        FORMATETC fmtEtc = { CF_TEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+    if (mFormatEtc.cfFormat) /* Did we get a supported format yet? */
+    {
+        /* Make sure the data object's data format is still the same
+         * as we got it in DragEnter(). */
+        hr = pDataObject->QueryGetData(&mFormatEtc);
+        AssertMsg(SUCCEEDED(hr),
+                  ("Data format changed between DragEnter() and Drop(), cfFormat=%RI16, hr=%Rhrc\n",
+                  mFormatEtc.cfFormat, hr));
+    }
+
+    if (SUCCEEDED(hr))
+    {
         STGMEDIUM stgMed;
-
-        AssertPtr(pDataObject);
-        if (   (pDataObject->QueryGetData(&fmtEtc)     == S_OK)
-            && (pDataObject->GetData(&fmtEtc, &stgMed) == S_OK))
+        hr = pDataObject->GetData(&mFormatEtc, &stgMed);
+        if (SUCCEEDED(hr))
         {
-            PVOID pvData = GlobalLock(stgMed.hGlobal);
-#ifdef DEBUG
-            if (fmtEtc.cfFormat == CF_TEXT)
-                LogFlowFunc(("pvData=%s\n", (char*)pvData));
-#endif
-            GlobalUnlock(stgMed.hGlobal);
+            /*
+             * First stage: Prepare the access to the storage medium.
+             *              For now we only support HGLOBAL stuff.
+             */
+            PVOID pvData = NULL; /** @todo Put this in an own union? */
+
+            switch (mFormatEtc.tymed)
+            {
+                case TYMED_HGLOBAL:
+                    pvData = GlobalLock(stgMed.hGlobal);
+                    if (!pvData)
+                    {
+                        LogFlowFunc(("Locking HGLOBAL storage failed with %Rrc\n",
+                                     RTErrConvertFromWin32(GetLastError())));
+                        hr = ERROR_INVALID_HANDLE;
+                    }
+                    break;
+
+                default:
+                    AssertMsgFailed(("Storage medium type %RI32 supported\n",
+                                     mFormatEtc.tymed));
+                    hr = ERROR_NOT_SUPPORTED;
+                    break;
+            }
+
+            if (SUCCEEDED(hr))
+            {
+                /* Second stage: Do the actual copying of the data object's data,
+                                 based on the storage medium type. */
+                switch (mFormatEtc.cfFormat)
+                {
+                    case CF_TEXT:
+                    {
+                        LogFlowFunc(("pvData=%s\n", (char*)pvData));
+
+                        uint32_t cbSize = strlen((char*)pvData); /** @todo Evil hack, fix this! */
+                        mpvData = RTMemDup(pvData, cbSize);
+                        mcbData = cbSize;
+                        break;
+                    }
+
+                    case CF_HDROP:
+                        break;
+
+                    default:
+                        AssertMsgFailed(("Format of type %RI16 supported\n",
+                                         mFormatEtc.cfFormat));
+                        hr = ERROR_NOT_SUPPORTED;
+                        break;
+                }
+            }
+
+            /*
+             * Third stage: Release access to the storage medium again.
+             */
+            switch (mFormatEtc.tymed)
+            {
+                case TYMED_HGLOBAL:
+                    GlobalUnlock(stgMed.hGlobal);
+                    break;
+
+                default:
+                    AssertMsgFailed(("Storage medium type %RI32 supported\n",
+                                     mFormatEtc.tymed));
+                    hr = ERROR_NOT_SUPPORTED;
+                    break;
+            }
 
             /* Release storage medium again. */
             ReleaseStgMedium(&stgMed);
 
-            fCanDrop = true;
+            if (SUCCEEDED(hr))
+            {
+                RTSemEventSignal(hEventDrop);
+                fCanDrop = true;
+            }
         }
     }
@@ -201 +346 @@
         *pdwEffect = DROPEFFECT_NONE;
 
-    LogFlowFunc(("Returning with mfHasDropData=%RTbool, fCanDrop=%RTbool, *pdwEffect=%RI32\n",
-                 mfHasDropData, fCanDrop, *pdwEffect));
-    return S_OK;
+    if (mpWndParent)
+        mpWndParent->hide();
+
+    LogFlowFunc(("Returning with mFormatEtc.cfFormat=%RI16, fCanDrop=%RTbool, *pdwEffect=%RI32\n",
+                 mFormatEtc.cfFormat, fCanDrop, *pdwEffect));
+    return hr;
 }
 
@@ -235 +383 @@
 }
 
+void VBoxDnDDropTarget::reset(void)
+{
+    LogFlowFuncEnter();
+
+    if (mpvData)
+    {
+        RTMemFree(mpvData);
+        mpvData = NULL;
+    }
+
+    mcbData = 0;
+    RT_ZERO(mFormatEtc);
+}
+
+int VBoxDnDDropTarget::WaitForDrop(RTMSINTERVAL msTimeout)
+{
+    LogFlowFunc(("msTimeout=%RU32\n", msTimeout));
+    int rc = RTSemEventWait(hEventDrop, msTimeout);
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibDragAndDrop.cpp

@@ -882 +882 @@
                 break;
             }
-#ifdef VBOX_WITH_DRAG_AND_DROP_GH
             case DragAndDropSvc::HOST_DND_GH_REQ_PENDING:
             {
@@ -905 +904 @@
                 break;
             }
-#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
             default:
-                AssertMsgFailedReturn(("Message %u isn't expected in this context", uMsg),
-                                      VERR_INVALID_PARAMETER);
+                rc = VERR_NOT_SUPPORTED;
                 break;
         }
@@ -944 +941 @@
     Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_HG_REQ_DATA;
     Msg.hdr.cParms      = 1;
+    /* Initialize parameter */
+    Msg.pFormat.SetPtr((void*)pcszFormat, (uint32_t)strlen(pcszFormat) + 1);
     /* Do request */
-    Msg.pFormat.SetPtr((void*)pcszFormat, (uint32_t)strlen(pcszFormat) + 1);
     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     if (RT_SUCCESS(rc))
@@ -968 +966 @@
     Msg.uDefAction.SetUInt32(uDefAction);
     Msg.uAllActions.SetUInt32(uAllActions);
-    Msg.pFormat.SetPtr((void*)pcszFormat, static_cast<uint32_t>(strlen(pcszFormat) + 1));
+    Msg.pFormat.SetPtr((void*)pcszFormat, (uint32_t)strlen(pcszFormat) + 1);
     /* Do request */
     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
@@ -982 +980 @@
     AssertReturn(cbData,    VERR_INVALID_PARAMETER);
 
-    /* Todo: URI support. Currently only data is send over to the host. For URI
-     * support basically the same as in the H->G case (see
-     * HostServices/DragAndDrop/dndmanager.h/cpp) has to be done:
-     * 1. Parse the urilist
-     * 2. Recursively send "create dir" and "transfer file" msg to the host
-     * 3. Patch the urilist by removing all base dirnames
-     * 4. On the host all needs to received and the urilist patched afterwards
-     *    to point to the new location
+    /** @todo Add URI support. Currently only data is send over to the host. For URI
+     *        support basically the same as in the H->G case (see
+     *        HostServices/DragAndDrop/dndmanager.h/cpp) has to be done:
+     *        1. Parse the urilist
+     *        2. Recursively send "create dir" and "transfer file" msg to the host
+     *        3. Patch the urilist by removing all base dirnames
+     *        4. On the host all needs to received and the urilist patched afterwards
+     *           to point to the new location
      */
 
@@ -999 +997 @@
     Msg.hdr.cParms      = 2;
     Msg.uSize.SetUInt32(cbData);
+
     int rc          = VINF_SUCCESS;
-    uint32_t cbMax  = _1M;
-    uint32_t cbSend = 0;
-    while(cbSend < cbData)
+    uint32_t cbMax  = _1M; /** @todo Remove 1 MB limit. */
+    uint32_t cbSent = 0;
+
+    while (cbSent < cbData)
     {
         /* Initialize parameter */
-        uint32_t cbToSend = RT_MIN(cbData - cbSend, cbMax);
-        Msg.pData.SetPtr(static_cast<uint8_t*>(pvData) + cbSend, cbToSend);
+        uint32_t cbToSend = RT_MIN(cbData - cbSent, cbMax);
+        Msg.pData.SetPtr(static_cast<uint8_t*>(pvData) + cbSent, cbToSend);
         /* Do request */
         rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
@@ -1018 +1018 @@
         else
             break;
-        cbSend += cbToSend;
+        cbSent += cbToSend;
 //        RTThreadSleep(500);
     }

trunk/src/VBox/Additions/x11/VBoxClient/draganddrop.cpp

@@ -498 +498 @@
         XDestroyWindow(m_pDisplay, m_wndProxy);
 
-    if (m_uClientID) 
+    if (m_uClientID)
     {
         VbglR3DnDDisconnect(m_uClientID);
@@ -1613 +1613 @@
 
         m_pCurDnD = new DragInstance(m_pDisplay, this);
-        if (!m_pCurDnD) 
+        if (!m_pCurDnD)
         {
             rc = VERR_NO_MEMORY;
@@ -1829 +1829 @@
     }
 
+    /* Number of invalid messages skipped in a row. */
+    int cMsgSkippedInvalid = 0;
+
     do
     {
@@ -1837 +1840 @@
         if (RT_SUCCESS(rc))
         {
+            cMsgSkippedInvalid = 0; /* Reset skipped messages count. */
+
             pThis->m_eventQueue.append(e);
             rc = RTSemEventSignal(pThis->m_hEventSem);
@@ -1842 +1847 @@
                 return rc;
         }
+        else
+        {
+            /* Old(er) hosts either are broken regarding DnD support or otherwise
+             * don't support the stuff we do on the guest side, so make sure we
+             * don't process invalid messages forever. */
+            if (rc == VERR_INVALID_PARAMETER)
+                cMsgSkippedInvalid++;
+            if (cMsgSkippedInvalid > 3)
+            {
+                LogFlowFunc(("Too many invalid/skipped messages from host, exiting ...\n"));
+                break;
+            }
+        }
+
     } while (!ASMAtomicReadBool(&pThis->m_fSrvStopping));
 

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

@@ -5 +5 @@
 
 #
-# Copyright (C) 2006-2013 Oracle Corporation
+# Copyright (C) 2006-2014 Oracle Corporation
 #
 # This file is part of VirtualBox Open Source Edition (OSE), as
@@ -176 +176 @@
         ./src/net
 endif
-        
+
 VirtualBox_INCS = \
         $(VBOX_GUI_INC_DIRS) \
@@ -390 +390 @@
         src/widgets/VBoxOSTypeSelectorButton.h \
         src/widgets/UINameAndSystemEditor.h \
-    src/widgets/UIWarningPane.h \
+        src/widgets/UIWarningPane.h \
         src/widgets/UIFilmContainer.h \
         src/widgets/graphics/UIGraphicsButton.h \
@@ -433 +433 @@
 
 ifdef VBOX_GUI_WITH_NETWORK_MANAGER
-VirtualBox_QT_MOCHDRS += \
+ VirtualBox_QT_MOCHDRS += \
         src/net/UINetworkManager.h \
         src/net/UINetworkManagerDialog.h \
@@ -448 +448 @@
         src/settings/global/UIGlobalSettingsProxy.h \
         src/settings/global/UIGlobalSettingsUpdate.h
+endif
+
+ifdef VBOX_WITH_DRAG_AND_DROP
+ ifdef VBOX_WITH_DRAG_AND_DROP_GH
+  VirtualBox_QT_MOCHDRS += \
+        src/runtime/UIDnDMIMEData.h
+ endif
 endif
 
@@ -477 +484 @@
 
 ifdef VBOX_GUI_WITH_NETWORK_MANAGER
-VirtualBox_QT_MOCSRCS += \
+ VirtualBox_QT_MOCSRCS += \
         src/net/UINetworkReply.cpp \
         src/net/UIUpdateManager.cpp
+endif
+
+ifdef VBOX_WITH_DRAG_AND_DROP
+ ifdef VBOX_WITH_DRAG_AND_DROP_GH
+  VirtualBox_QT_MOCSRCS += \
+        src/runtime/UIDnDMIMEData.cpp
+ endif
 endif
 
@@ -763 +777 @@
  VirtualBox_QT_MOCSRCS += \
         src/runtime/UIDnDHandler.cpp
+ ifdef VBOX_WITH_DRAG_AND_DROP_GH
+  VirtualBox_SOURCES += \
+        src/runtime/UIDnDMIMEData.cpp
+  VirtualBox_QT_MOCSRCS += \
+        src/runtime/UIDnDMIMEData.cpp
+ endif
 endif
 

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2011-2013 Oracle Corporation
+ * Copyright (C) 2011-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -21 +21 @@
 #include <QApplication>
 #include <QKeyEvent>
-#include <QMimeData>
 #include <QStringList>
 #include <QTimer>
@@ -33 +32 @@
 /* GUI includes: */
 #include "UIDnDHandler.h"
+#ifdef VBOX_WITH_DRAG_AND_DROP_GH
+# include "UIDnDMIMEData.h"
+#endif
 #include "UIMessageCenter.h"
 
@@ -40 +42 @@
 #include "CGuest.h"
 
-UIDnDHandler *UIDnDHandler::m_pInstance = 0;
-
-UIDnDHandler::UIDnDHandler()
+UIDnDHandler *UIDnDHandler::m_pInstance = NULL;
+
+UIDnDHandler::UIDnDHandler(void)
 {
 }
@@ -50 +52 @@
  */
 
-Qt::DropAction UIDnDHandler::dragHGEnter(CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget * /* pParent = 0 */)
+Qt::DropAction UIDnDHandler::dragHGEnter(CGuest &guest, ulong screenId, int x, int y,
+                                         Qt::DropAction proposedAction, Qt::DropActions possibleActions,
+                                         const QMimeData *pMimeData, QWidget * /* pParent = NULL */)
 {
     LogFlowFunc(("screenId=%RU32, x=%d, y=%d, action=%ld\n",
@@ -66 +70 @@
 }
 
-Qt::DropAction UIDnDHandler::dragHGMove(CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget * /* pParent = 0 */)
+Qt::DropAction UIDnDHandler::dragHGMove(CGuest &guest, ulong screenId, int x, int y,
+                                        Qt::DropAction proposedAction, Qt::DropActions possibleActions,
+                                        const QMimeData *pMimeData, QWidget * /* pParent = NULL */)
 {
 #ifdef DEBUG_andy
@@ -85 +91 @@
 }
 
-Qt::DropAction UIDnDHandler::dragHGDrop(CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent /* = 0 */)
+Qt::DropAction UIDnDHandler::dragHGDrop(CGuest &guest, ulong screenId, int x, int y,
+                                        Qt::DropAction proposedAction, Qt::DropActions possibleActions,
+                                        const QMimeData *pMimeData, QWidget *pParent /* = NULL */)
 {
     LogFlowFunc(("screenId=%RU32, x=%d, y=%d, action=%ld\n",
@@ -132 +140 @@
 }
 
-void UIDnDHandler::dragHGLeave(CGuest &guest, ulong screenId, QWidget * /* pParent = 0 */)
+void UIDnDHandler::dragHGLeave(CGuest &guest, ulong screenId, QWidget * /* pParent = NULL */)
 {
     LogFlowFunc(("screenId=%RU32\n", screenId));
@@ -138 +146 @@
 }
 
-/*
- * Guest -> Host
- */
-
-class UIDnDMimeData: public QMimeData
-{
-    Q_OBJECT;
-
-    enum State
-    {
-        Dragging,
-        Dropped,
-        Finished,
-        Canceled
-    };
-
-public:
-    UIDnDMimeData(CSession &session, QStringList formats, Qt::DropAction defAction, Qt::DropActions actions, QWidget *pParent)
-      : m_pParent(pParent)
-      , m_session(session)
-      , m_formats(formats)
-      , m_defAction(defAction)
-      , m_actions(actions)
-      , m_fState(Dragging)
-    {
-        /*
-         * This is unbelievable hacky, but I didn't find another way. Stupid
-         * Qt QDrag interface is so less verbose, that we in principle know
-         * nothing about what happens when the user drag something around. It
-         * is possible that the target request data (s. retrieveData) while the
-         * mouse button is still pressed. This isn't something we can support,
-         * cause it would mean transferring the data from the guest while the
-         * mouse is still moving (thing of a 2GB file ...). So the idea is to
-         * detect the mouse release event and only after this happened, allow
-         * data to be retrieved. Unfortunately the QDrag object eats all events
-         * while a drag is going on (see QDragManager in the Qt src's). So what
-         * we do, is installing an event filter after the QDrag::exec is called
-         * to be last in the event filter queue and therefore called before the
-         * one installed by the QDrag object.
-         *
-         ** @todo: Test this on all supported platforms (X11 works).
-         */
-        QTimer::singleShot(0, this, SLOT(sltInstallEventFilter()));
-    }
-
-    virtual QStringList formats() const { return m_formats; }
-    virtual bool hasFormat(const QString &mimeType) const { return m_formats.contains(mimeType); }
-
-public slots:
-    void sltActionChanged(Qt::DropAction action) { m_defAction = action; }
-
-protected:
-    virtual QVariant retrieveData(const QString &mimeType, QVariant::Type type) const
-    {
-        /* Mouse button released? */
-        if (m_fState != Dropped)
-            return m_data;
-
-        /* Supported types. See below in the switch statement. */
-        if (!(   type == QVariant::String
-              || type == QVariant::ByteArray))
-            return QVariant();
-
-        CGuest guest = m_session.GetConsole().GetGuest();
-        /* No, 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("Dropping data ..."), ":/progress_dnd_gh_90px.png", m_pParent);
-            if (!progress.GetCanceled())
-            {
-                if (progress.isOk() && progress.GetResultCode() == 0)
-                {
-                    /* After the data is successfully arrived from the guest, we query it from Main. */
-                    QVector<uint8_t> data = guest.DragGHGetData();
-                    if (!data.isEmpty())
-                    {
-                        /* Todo: not sure what to add here more: needs more testing. */
-                        switch (type)
-                        {
-                            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;
-                            }
-                            default: break;
-                        }
-                    }
-                    m_fState = Finished;
-                }
-                else
-                    msgCenter().cannotDropData(progress, m_pParent);
-            }
-            else
-                m_fState = Canceled;
-        }
-        else
-            msgCenter().cannotDropData(guest, m_pParent);
-        return m_data;
-    }
-
-    bool eventFilter(QObject * /* pObject */, QEvent *pEvent)
-    {
-        switch (pEvent->type())
-        {
-            case QEvent::MouseButtonRelease: m_fState = Dropped; break;
-            case QEvent::KeyPress:
-            {
-                if (static_cast<QKeyEvent*>(pEvent)->key() == Qt::Key_Escape)
-                    m_fState = Canceled;
-                break;
-            }
-        }
-
-        /* Propagate the event further. */
-        return false;
-    }
-
-private slots:
-    void sltInstallEventFilter() { qApp->installEventFilter(this); }
-
-private:
-    /* Private members. */
-    QWidget          *m_pParent;
-    CSession          m_session;
-    QStringList       m_formats;
-    Qt::DropAction    m_defAction;
-    Qt::DropActions   m_actions;
-    mutable State     m_fState;
-    mutable QVariant  m_data;
-};
-
-void UIDnDHandler::dragGHPending(CSession &session, ulong screenId, QWidget *pParent /* = 0 */)
-{
+int UIDnDHandler::dragGHPending(CSession &session, ulong screenId, QWidget *pParent /* = NULL */)
+{
+    int rc;
+#ifdef VBOX_WITH_DRAG_AND_DROP_GH
     /*
      * How this works: Host is asking the guest if there is any DnD
@@ -289 +160 @@
      */
     CGuest guest = session.GetConsole().GetGuest();
-    QVector<QString> formats;
-    QVector<KDragAndDropAction> actions;
-    KDragAndDropAction defaultAction = guest.DragGHPending(screenId, formats, actions);
+    QVector<QString> vecFmtGuest;
+    QVector<KDragAndDropAction> vecActions;
+    KDragAndDropAction defaultAction = guest.DragGHPending(screenId, vecFmtGuest, vecActions);
+    LogFlowFunc(("defaultAction=%d, numFormats=%d\n", defaultAction, vecFmtGuest.size()));
+
+    /*
+     * Do guest -> host format conversion, if needed.
+     * On X11 this already maps to the Xdnd protocol.
+     ** @todo What about MacOS X Carbon Drag Manager?
+     *
+     * See: https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    LogFlowFunc(("Number of guest formats: %d\n", vecFmtGuest.size()));
+    QStringList lstFmtNative;
+    for (int i = 0; i < vecFmtGuest.size(); i++)
+    {
+        const QString &strFmt = vecFmtGuest.at(i);
+        LogFlowFunc(("\tFormat %d: %s\n", i,
+                     strFmt.toAscii().constData()));
+#ifdef RT_OS_WINDOWS
+        if (   strFmt.contains("text", Qt::CaseInsensitive)
+            && !lstFmtNative.contains("text/plain"))
+        {
+            lstFmtNative << "text/plain";
+        }
+#else
+        lstFmtNative << strFmt;
+#endif
+    }
+
+    LogFlowFunc(("Number of native formats: %d\n", lstFmtNative.size()));
+#ifdef DEBUG
+    for (int i = 0; i < lstFmtNative.size(); i++)
+        LogFlowFunc(("\tFormat %d: %s\n", i, lstFmtNative.at(i).toAscii().constData()));
+#endif
 
     if (    defaultAction != KDragAndDropAction_Ignore
-        && !formats.isEmpty())
+        && !lstFmtNative.isEmpty())
     {
-        QDrag *pDrag = new QDrag(pParent);
-        /* pMData is transfered to the QDrag object, so no need for deletion. */
-        UIDnDMimeData *pMData = new UIDnDMimeData(session, formats.toList(), toQtDnDAction(defaultAction), toQtDnDActions(actions), pParent);
-        /* Inform the mime data object of any changes in the current action. */
-        connect(pDrag, SIGNAL(actionChanged(Qt::DropAction)),
-                pMData, SLOT(sltActionChanged(Qt::DropAction)));
-        pDrag->setMimeData(pMData);
-        /* Fire it up. */
-        pDrag->exec(toQtDnDActions(actions), toQtDnDAction(defaultAction));
+        try
+        {
+            QDrag *pDrag = new QDrag(pParent);
+
+            /* pMData is transfered to the QDrag object, so no need for deletion. */
+            UIDnDMimeData *pMData = new UIDnDMimeData(session, lstFmtNative,
+                                                      toQtDnDAction(defaultAction),
+                                                      toQtDnDActions(vecActions), pParent);
+
+            /* Inform the MIME data object of any changes in the current action. */
+            connect(pDrag, SIGNAL(actionChanged(Qt::DropAction)),
+                    pMData, SLOT(sltDropActionChanged(Qt::DropAction)));
+
+            /* Fire it up.
+             *
+             * On Windows this will start a modal operation using OLE's
+             * DoDragDrop() method, so this call will block until the DnD operation
+             * is finished. */
+            pDrag->setMimeData(pMData);
+            pDrag->exec(toQtDnDActions(vecActions), toQtDnDAction(defaultAction));
+
+            rc = VINF_SUCCESS;
+        }
+        catch (std::bad_alloc)
+        {
+            rc = VERR_NO_MEMORY;
+        }
     }
+    else
+        rc = VINF_SUCCESS;
+#else
+    rc = VERR_NOT_SUPPORTED;
+#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -341 +270 @@
 Qt::DropAction UIDnDHandler::toQtDnDAction(KDragAndDropAction action)
 {
+    Qt::DropAction dropAct = Qt::IgnoreAction;
     if (action == KDragAndDropAction_Copy)
-        return Qt::CopyAction;
+        dropAct = Qt::CopyAction;
     if (action == KDragAndDropAction_Move)
-        return Qt::MoveAction;
+        dropAct = Qt::MoveAction;
     if (action == KDragAndDropAction_Link)
-        return Qt::LinkAction;
-
-    return Qt::IgnoreAction;
-}
-
-Qt::DropActions UIDnDHandler::toQtDnDActions(const QVector<KDragAndDropAction> &actions)
-{
-    Qt::DropActions a = 0;
-    for (int i = 0; i < actions.size(); ++i)
+        dropAct = Qt::LinkAction;
+
+    LogFlowFunc(("dropAct=0x%x\n", dropAct));
+    return dropAct;
+}
+
+Qt::DropActions UIDnDHandler::toQtDnDActions(const QVector<KDragAndDropAction> &vecActions)
+{
+    Qt::DropActions dropActs = Qt::IgnoreAction;
+    for (int i = 0; i < vecActions.size(); i++)
     {
-        switch (actions.at(i))
-        {
-            case KDragAndDropAction_Ignore: a |= Qt::IgnoreAction; break;
-            case KDragAndDropAction_Copy:   a |= Qt::CopyAction; break;
-            case KDragAndDropAction_Move:   a |= Qt::MoveAction; break;
-            case KDragAndDropAction_Link:   a |= Qt::LinkAction; break;
+        switch (vecActions.at(i))
+        {
+            case KDragAndDropAction_Ignore:
+                dropActs |= Qt::IgnoreAction;
+                break;
+            case KDragAndDropAction_Copy:
+                dropActs |= Qt::CopyAction;
+                break;
+            case KDragAndDropAction_Move:
+                dropActs |= Qt::MoveAction;
+                break;
+            case KDragAndDropAction_Link:
+                dropActs |= Qt::LinkAction;
+                break;
+            default:
+                break;
         }
     }
-    return a;
+
+    LogFlowFunc(("dropActions=0x%x\n", dropActs));
+    return dropActs;
 }
 

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

@@ +1 @@
+/* $Id$ */
 /** @file
  *
@@ -6 +7 @@
 
 /*
- * Copyright (C) 2011-2012 Oracle Corporation
+ * Copyright (C) 2011-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -23 +24 @@
 #include "COMEnums.h"
 
-/* Forward declarations: */
+/* Forward declarations. */
 class QMimeData;
 class CSession;
 class CGuest;
 
-/* Todo: check for making this a full static class when possible. */
+/** @todo Check for making this a full static class when possible. */
 class UIDnDHandler: public QObject
 {
 public:
-    /* Singleton */
-    static UIDnDHandler* instance()
+    /* Singleton factory. */
+    static UIDnDHandler* instance(void)
     {
         if (!m_pInstance)
@@ -39 +40 @@
         return m_pInstance;
     }
-    static void destroy() { delete m_pInstance; m_pInstance = 0; }
+    static void destroy(void)
+    {
+        if (m_pInstance)
+        {
+            delete m_pInstance;
+            m_pInstance = NULL;
+        }
+    }
 
-    /* Host -> Guest */
-    Qt::DropAction dragHGEnter(CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent = 0);
-    Qt::DropAction dragHGMove (CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent = 0);
-    Qt::DropAction dragHGDrop (CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent = 0);
-    void           dragHGLeave(CGuest &guest, ulong screenId, QWidget *pParent = 0);
+    /* Host -> Guest. */
+    Qt::DropAction dragHGEnter(CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent = NULL);
+    Qt::DropAction dragHGMove (CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent = NULL);
+    Qt::DropAction dragHGDrop (CGuest &guest, ulong screenId, int x, int y, Qt::DropAction proposedAction, Qt::DropActions possibleActions, const QMimeData *pMimeData, QWidget *pParent = NULL);
+    void           dragHGLeave(CGuest &guest, ulong screenId, QWidget *pParent = NULL);
 
-    /* Guest -> Host */
-    void           dragGHPending(CSession &session, ulong screenId, QWidget *pParent = 0);
+    /* Guest -> Host. */
+    int            dragGHPending(CSession &session, ulong screenId, QWidget *pParent = NULL);
 
 private:
     static UIDnDHandler *m_pInstance;
 
-    UIDnDHandler();
-    ~UIDnDHandler() {}
+    UIDnDHandler(void);
+    virtual ~UIDnDHandler(void) {}
 
-    /* Private helpers */
+    /* Private helpers. */
     static KDragAndDropAction          toVBoxDnDAction(Qt::DropAction action);
     static QVector<KDragAndDropAction> toVBoxDnDActions(Qt::DropActions actions);
     static Qt::DropAction              toQtDnDAction(KDragAndDropAction action);
-    static Qt::DropActions             toQtDnDActions(const QVector<KDragAndDropAction> &actions);
+    static Qt::DropActions             toQtDnDActions(const QVector<KDragAndDropAction> &vecActions);
 
     friend class UIDnDMimeData;

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

@@ -1169 +1169 @@
 }
 
-void UIMachineView::handleGHDnd()
+void UIMachineView::handleGHDnd(void)
 {
     /* The guest object to talk to. */

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

@@ -907 +907 @@
                 || cpnt.y() > iCh - 1)
             {
-                if ((mouseButtons.testFlag(Qt::LeftButton)))
+                bool fHandledGHDnD
+                    = RT_BOOL(mouseButtons.testFlag(Qt::LeftButton));
+                if (fHandledGHDnD)
                 {
                     m_views[uScreenId]->handleGHDnd();
-
-                    return false;
+                    return true;
                 }
             }

trunk/src/VBox/HostServices/DragAndDrop/service.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2011-2013 Oracle Corporation
+ * Copyright (C) 2011-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -177 +177 @@
     switch (u32Function)
     {
+        /* Note: Older VBox versions with enabled DnD guest->host support (< 4.4)
+         *       used the same ID (300) for GUEST_DND_GET_NEXT_HOST_MSG and
+         *       HOST_DND_GH_REQ_PENDING, which led this service returning
+         *       VERR_INVALID_PARAMETER when the guest wanted to actually
+         *       handle HOST_DND_GH_REQ_PENDING. */
         case DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG:
         {

trunk/src/VBox/Main/src-client/GuestDnDImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2011-2013 Oracle Corporation
+ * Copyright (C) 2011-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -167 +167 @@
 class DnDGuestResponse
 {
+
 public:
+
     DnDGuestResponse(const ComObjPtr<Guest>& pGuest);
-    ~DnDGuestResponse();
-
-    int notifyAboutGuestResponse();
-    int waitForGuestResponse();
+
+    virtual ~DnDGuestResponse(void);
+
+public:
+
+    int notifyAboutGuestResponse(void);
+    int waitForGuestResponse(RTMSINTERVAL msTimeout = 500);
 
     void setDefAction(uint32_t a) { m_defAction = a; }
-    uint32_t defAction() const { return m_defAction; }
+    uint32_t defAction(void) const { return m_defAction; }
 
     void setAllActions(uint32_t a) { m_allActions = a; }
@@ -181 +186 @@
 
     void setFormat(const Utf8Str &strFormat) { m_strFormat = strFormat; }
-    Utf8Str format() const { return m_strFormat; }
-
-    int addData(void *pvData, uint32_t cbData, uint32_t *pcbCurSize);
-    void resetData();
-    void data(void **ppvData, uint32_t *pcbData) const { *ppvData = m_pvData; *pcbData = m_cbData; }
-    bool hasData() const { return m_pvData != NULL; }
+    Utf8Str format(void) const { return m_strFormat; }
+
+    int dataAdd(void *pvData, uint32_t cbData, uint32_t *pcbCurSize);
+    void reset(void);
+    const void *data(void) { return m_pvData; }
+    size_t size(void) const { return m_cbData; }
 
     int setProgress(unsigned uPercentage, uint32_t uState, int rcOp = VINF_SUCCESS);
@@ -213 +218 @@
         , m_pDnDResponse(new DnDGuestResponse(pGuest))
     {}
-    ~GuestDnDPrivate() { delete m_pDnDResponse; }
-
-    DnDGuestResponse *response() const { return m_pDnDResponse; }
+    virtual ~GuestDnDPrivate(void) { delete m_pDnDResponse; }
+
+    DnDGuestResponse *response(void) const { return m_pDnDResponse; }
 
     void adjustCoords(ULONG uScreenId, ULONG *puX, ULONG *puY) const;
@@ -274 +279 @@
 DnDGuestResponse::~DnDGuestResponse()
 {
-    resetData();
+    reset();
     int rc = RTSemEventDestroy(m_EventSem);
     AssertRC(rc);
@@ -284 +289 @@
 }
 
-int DnDGuestResponse::waitForGuestResponse()
-{
-    int vrc = RTSemEventWait(m_EventSem, 300);
+int DnDGuestResponse::waitForGuestResponse(RTMSINTERVAL msTimeout /*= 500 */)
+{
+    int vrc = RTSemEventWait(m_EventSem, msTimeout);
 #ifdef DEBUG_andy
-    LogFlowFunc(("rc=%Rrc\n", vrc));
+    LogFlowFunc(("msTimeout=%RU32, rc=%Rrc\n", msTimeout, vrc));
 #endif
     return vrc;
 }
 
-int DnDGuestResponse::addData(void *pvData, uint32_t cbData, uint32_t *pcbCurSize)
+int DnDGuestResponse::dataAdd(void *pvData, uint32_t cbData, uint32_t *pcbCurSize)
 {
     int rc = VINF_SUCCESS;
+
+    /** @todo Make reallocation scheme a bit smarter here. */
     m_pvData = RTMemRealloc(m_pvData, m_cbData + cbData);
     if (m_pvData)
     {
-        memcpy(&static_cast<uint8_t*>(m_pvData)[m_cbData], pvData, cbData);
-        m_cbData    += cbData;
-        *pcbCurSize  = m_cbData;
+        memcpy(&static_cast<uint8_t*>(m_pvData)[m_cbData],
+               pvData, cbData);
+        m_cbData += cbData;
+
+        if (pcbCurSize)
+            *pcbCurSize = m_cbData;
     }
     else
@@ -309 +319 @@
 }
 
-void DnDGuestResponse::resetData()
+void DnDGuestResponse::reset(void)
 {
     if (m_pvData)
@@ -316 +326 @@
         m_pvData = NULL;
     }
+
     m_cbData = 0;
 }
@@ -747 +758 @@
 }
 
-HRESULT GuestDnD::dragHGPutData(ULONG uScreenId, IN_BSTR bstrFormat, ComSafeArrayIn(BYTE, data), IProgress **ppProgress)
+HRESULT GuestDnD::dragHGPutData(ULONG uScreenId, IN_BSTR bstrFormat,
+                                ComSafeArrayIn(BYTE, data), IProgress **ppProgress)
 {
     DPTR(GuestDnD);
@@ -786 +798 @@
 }
 
-# ifdef VBOX_WITH_DRAG_AND_DROP_GH
-HRESULT GuestDnD::dragGHPending(ULONG uScreenId, ComSafeArrayOut(BSTR, formats), ComSafeArrayOut(DragAndDropAction_T, allowedActions), DragAndDropAction_T *pDefaultAction)
+#ifdef VBOX_WITH_DRAG_AND_DROP_GH
+HRESULT GuestDnD::dragGHPending(ULONG uScreenId,
+                                ComSafeArrayOut(BSTR, formats),
+                                ComSafeArrayOut(DragAndDropAction_T, allowedActions),
+                                DragAndDropAction_T *pDefaultAction)
 {
     DPTR(GuestDnD);
@@ -821 +836 @@
         /* Convert the action bit field to a vector of actions. */
         d->toMainActions(pDnD->allActions(), ComSafeArrayOutArg(allowedActions));
+
+        LogFlowFunc(("*pDefaultAction=0x%x\n", *pDefaultAction));
     }
     catch (HRESULT rc2)
@@ -830 +847 @@
 }
 
-HRESULT GuestDnD::dragGHDropped(IN_BSTR bstrFormat, DragAndDropAction_T action, IProgress **ppProgress)
+HRESULT GuestDnD::dragGHDropped(IN_BSTR bstrFormat, DragAndDropAction_T action,
+                                IProgress **ppProgress)
 {
     DPTR(GuestDnD);
@@ -845 +863 @@
     try
     {
+        LogFlowFunc(("strFormat=%s, uAction=0x%x\n", strFormat.c_str(), uAction));
+
         VBOXHGCMSVCPARM paParms[3];
         int i = 0;
@@ -853 +873 @@
         DnDGuestResponse *pDnD = d->response();
         /* Reset any old data and the progress status. */
-        pDnD->resetData();
+        pDnD->reset();
         pDnD->resetProgress(p);
 
@@ -879 +899 @@
 
     DnDGuestResponse *pDnD = d->response();
-    /* Is there data at all? */
-    if (pDnD->hasData())
-    {
-        /* Copy the data into an safe array of bytes. */
-        void     *pvData = 0;
-        uint32_t  cbData = 0;
-        pDnD->data(&pvData, &cbData);
-        com::SafeArray<BYTE> sfaData(cbData);
-        memcpy(sfaData.raw(), pvData, cbData);
+    if (pDnD)
+    {
+        com::SafeArray<BYTE> sfaData;
+
+        uint32_t cbData = pDnD->size();
+        if (cbData)
+        {
+            /* Copy the data into an safe array of bytes. */
+            const void *pvData = pDnD->data();
+            if (sfaData.resize(cbData))
+                memcpy(sfaData.raw(), pvData, cbData);
+            else
+                rc = E_OUTOFMEMORY;
+        }
+
+#ifdef DEBUG_andy
+        LogFlowFunc(("Received %RU32 bytes\n", cbData));
+#endif
+        /* Detach in any case, regardless of data size. */
         sfaData.detachTo(ComSafeArrayOutArg(data));
+
         /* Delete the data. */
-        pDnD->resetData();
+        pDnD->reset();
     }
     else
@@ -897 +928 @@
     return rc;
 }
-
-# endif /* VBOX_WITH_DRAG_AND_DROP_GH */
+#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
 
 DECLCALLBACK(int) GuestDnD::notifyGuestDragAndDropEvent(void *pvExtension, uint32_t u32Function, void *pvParms, uint32_t cbParms)
@@ -929 +959 @@
             break;
         }
+
         case DragAndDropSvc::GUEST_DND_HG_REQ_DATA:
         {
@@ -939 +970 @@
             break;
         }
+
         case DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS:
         {
@@ -948 +980 @@
             break;
         }
+
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
         case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING:
@@ -961 +994 @@
             break;
         }
+
         case DragAndDropSvc::GUEST_DND_GH_SND_DATA:
         {
@@ -967 +1001 @@
             AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
             uint32_t cbCurSize = 0;
-            pResp->addData(pCBData->pvData, pCBData->cbData, &cbCurSize);
-            rc = pResp->setProgress(100.0 / pCBData->cbAllSize * cbCurSize, (pCBData->cbAllSize == cbCurSize ? DragAndDropSvc::DND_PROGRESS_COMPLETE : DragAndDropSvc::DND_PROGRESS_RUNNING));
+            rc = pResp->dataAdd(pCBData->pvData, pCBData->cbData, &cbCurSize);
+            if (RT_SUCCESS(rc))
+            {
+                uint32_t cbTotalSize = pCBData->cbAllSize;
+                unsigned int cPercentage;
+                if (!cbTotalSize) /* Watch out for division by zero. */
+                    cPercentage = 100;
+                else
+                    cPercentage = cbCurSize * 100.0 / cbTotalSize;
+
+                /** @todo Don't use anonymous enums. */
+                uint32_t uState = DragAndDropSvc::DND_PROGRESS_RUNNING;
+                if (   pCBData->cbAllSize == cbCurSize
+                    /* Empty data? Should not happen, but anyway ... */
+                    || !pCBData->cbAllSize)
+                {
+                    uState = DragAndDropSvc::DND_PROGRESS_COMPLETE;
+                }
+
+                rc = pResp->setProgress(cPercentage, uState);
+            }
             /* Todo: for now we instantly confirm the cancel. Check if the
              * guest should first clean up stuff itself and than really confirm
@@ -977 +1031 @@
             break;
         }
+
         case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR:
         {
@@ -983 +1038 @@
             AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
             /* Cleanup */
-            pResp->resetData();
+            pResp->reset();
             rc = pResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc);
             break;
@@ -990 +1046 @@
 #endif /* VBOX_WITH_DRAG_AND_DROP_GH */
         default:
-            AssertMsgFailedReturn(("Function %RU32 not supported\n", u32Function), VERR_NOT_SUPPORTED);
+            rc = VERR_NOT_SUPPORTED; /* Tell the guest. */
             break;
     }