Changeset 50265 in vbox for trunk/src/VBox/Additions/WINNT

Timestamp:

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

Author:

vboxsync

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/src/VBox/Additions/WINNT/VBoxTray

Files:

• VBoxDnD.cpp (modified) (14 diffs)
• VBoxDnD.h (modified) (2 diffs)
• VBoxDnDDropTarget.cpp (modified) (9 diffs)

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;
+}
+