Changeset 58212 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Oct 13, 2015 11:49:33 AM (9 years ago)

Author:

vboxsync

Message:

DnD: Updates.

• Introduced protocol changelog in DragAndDropSvc.h.
• Implemented protocol v3 with HOST_DND_HG_SND_DATA_HDR message for doing proper object accounting, among other parameters like checksumming and compression flags.
• Encapsulated a lot of functionality in class hierarchies.
• Renamed a lot of functions to make the usage more clear.
• Various other bugfixes.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/runtime

Files:

• UIDnDDataObject_win.cpp (modified) (25 diffs)
• UIDnDDataObject_win.h (modified) (2 diffs)
• UIDnDDropSource_win.cpp (modified) (7 diffs)
• UIDnDDropSource_win.h (modified) (2 diffs)
• UIDnDHandler.cpp (modified) (1 diff)
• UIDnDMIMEData.cpp (modified) (3 diffs)
• UIMachineView.cpp (modified) (1 diff)

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

@@ -42 +42 @@
 UIDnDDataObject::UIDnDDataObject(UIDnDHandler *pDnDHandler, const QStringList &lstFormats)
     : m_pDnDHandler(pDnDHandler)
-    , mStatus(Uninitialized)
-    , mRefCount(1)
-    , mcFormats(0)
-    , mpFormatEtc(NULL)
-    , mpStgMedium(NULL)
-    , mSemEvent(NIL_RTSEMEVENT)
-    , mpvData(NULL)
-    , mcbData(0)
+    , m_enmStatus(DnDDataObjectStatus_Uninitialized)
+    , m_cRefs(1)
+    , m_cFormats(0)
+    , m_pFormatEtc(NULL)
+    , m_pStgMedium(NULL)
+    , m_SemEvent(NIL_RTSEMEVENT)
+    , m_fDataRetrieved(false)
+    , m_pvData(NULL)
+    , m_cbData(0)
 {
     HRESULT hr;
@@ -58 +59 @@
     try
     {
-        mpFormatEtc = new FORMATETC[cMaxFormats];
-        RT_BZERO(mpFormatEtc, sizeof(FORMATETC) * cMaxFormats);
-        mpStgMedium = new STGMEDIUM[cMaxFormats];
-        RT_BZERO(mpStgMedium, sizeof(STGMEDIUM) * cMaxFormats);
+        m_pFormatEtc = new FORMATETC[cMaxFormats];
+        RT_BZERO(m_pFormatEtc, sizeof(FORMATETC) * cMaxFormats);
+        m_pStgMedium = new STGMEDIUM[cMaxFormats];
+        RT_BZERO(m_pStgMedium, sizeof(STGMEDIUM) * cMaxFormats);
 
         for (int i = 0;
@@ -68 +69 @@
         {
             const QString &strFormat = lstFormats.at(i);
-            if (mlstFormats.contains(strFormat))
+            if (m_lstFormats.contains(strFormat))
                 continue;
 
@@ -74 +75 @@
             if (strFormat.contains("text/uri-list", Qt::CaseInsensitive))
             {
-                RegisterFormat(&mpFormatEtc[cRegisteredFormats], CF_TEXT);
-                mpStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
-                RegisterFormat(&mpFormatEtc[cRegisteredFormats], CF_UNICODETEXT);
-                mpStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
-                RegisterFormat(&mpFormatEtc[cRegisteredFormats], CF_HDROP);
-                mpStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
-
-                mlstFormats << strFormat;
+                RegisterFormat(&m_pFormatEtc[cRegisteredFormats], CF_TEXT);
+                m_pStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
+                RegisterFormat(&m_pFormatEtc[cRegisteredFormats], CF_UNICODETEXT);
+                m_pStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
+                RegisterFormat(&m_pFormatEtc[cRegisteredFormats], CF_HDROP);
+                m_pStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
+
+                m_lstFormats << strFormat;
             }
             /* Plain text ("text/plain"). */
             if (strFormat.contains("text/plain", Qt::CaseInsensitive))
             {
-                RegisterFormat(&mpFormatEtc[cRegisteredFormats], CF_TEXT);
-                mpStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
-                RegisterFormat(&mpFormatEtc[cRegisteredFormats], CF_UNICODETEXT);
-                mpStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
-
-                mlstFormats << strFormat;
+                RegisterFormat(&m_pFormatEtc[cRegisteredFormats], CF_TEXT);
+                m_pStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
+                RegisterFormat(&m_pFormatEtc[cRegisteredFormats], CF_UNICODETEXT);
+                m_pStgMedium[cRegisteredFormats++].tymed = TYMED_HGLOBAL;
+
+                m_lstFormats << strFormat;
             }
         }
@@ -106 +107 @@
     if (SUCCEEDED(hr))
     {
-        int rc2 = RTSemEventCreate(&mSemEvent);
+        int rc2 = RTSemEventCreate(&m_SemEvent);
         AssertRC(rc2);
 
@@ -130 +131 @@
                        RegisterClipboardFormat(CFSTR_SHELLIDLISTOFFSET));
 #endif
-        mcFormats = cRegisteredFormats;
-        mStatus   = Dropped;
+        m_cFormats  = cRegisteredFormats;
+        m_enmStatus = DnDDataObjectStatus_Dropping;
     }
 
@@ -139 +140 @@
 UIDnDDataObject::~UIDnDDataObject(void)
 {
-    if (mpFormatEtc)
-        delete[] mpFormatEtc;
-
-    if (mpStgMedium)
-        delete[] mpStgMedium;
-
-    if (mpvData)
-        RTMemFree(mpvData);
-
-    if (mSemEvent != NIL_RTSEMEVENT)
-        RTSemEventDestroy(mSemEvent);
-
-    LogFlowFunc(("mRefCount=%RI32\n", mRefCount));
+    if (m_pFormatEtc)
+        delete[] m_pFormatEtc;
+
+    if (m_pStgMedium)
+        delete[] m_pStgMedium;
+
+    if (m_pvData)
+        RTMemFree(m_pvData);
+
+    if (m_SemEvent != NIL_RTSEMEVENT)
+        RTSemEventDestroy(m_SemEvent);
+
+    LogFlowFunc(("mRefCount=%RI32\n", m_cRefs));
 }
 
@@ -160 +161 @@
 STDMETHODIMP_(ULONG) UIDnDDataObject::AddRef(void)
 {
-    return InterlockedIncrement(&mRefCount);
+    return InterlockedIncrement(&m_cRefs);
 }
 
 STDMETHODIMP_(ULONG) UIDnDDataObject::Release(void)
 {
-    LONG lCount = InterlockedDecrement(&mRefCount);
+    LONG lCount = InterlockedDecrement(&m_cRefs);
     if (lCount == 0)
     {
@@ -210 +211 @@
     LPSTGMEDIUM pThisMedium = NULL;
 
+    LogFlowThisFunc(("\n"));
+
     /* Format supported? */
     ULONG lIndex;
     if (   LookupFormatEtc(pFormatEtc, &lIndex)
-        && lIndex < mcFormats) /* Paranoia. */
-    {
-        pThisMedium = &mpStgMedium[lIndex];
+        && lIndex < m_cFormats) /* Paranoia. */
+    {
+        pThisMedium = &m_pStgMedium[lIndex];
         AssertPtr(pThisMedium);
-        pThisFormat = &mpFormatEtc[lIndex];
+        pThisFormat = &m_pFormatEtc[lIndex];
         AssertPtr(pThisFormat);
 
-        LogFlowFunc(("pThisMedium=%p, pThisFormat=%p\n", pThisMedium, pThisFormat));
-        LogFlowFunc(("mStatus=%ld\n", mStatus));
-        switch (mStatus)
+        LogFlowThisFunc(("pThisMedium=%p, pThisFormat=%p\n", pThisMedium, pThisFormat));
+        LogFlowThisFunc(("mStatus=%RU32\n", m_enmStatus));
+        switch (m_enmStatus)
         {
-            case Dropping:
+            case DnDDataObjectStatus_Dropping:
             {
-                    LogRel3(("DnD: Dropping\n"));
-                    LogFlowFunc(("Waiting for event ...\n"));
-                    int rc2 = RTSemEventWait(mSemEvent, RT_INDEFINITE_WAIT);
-                    LogFlowFunc(("rc=%Rrc, mStatus=%ld\n", rc2, mStatus));
+#if 0
+                LogRel3(("DnD: Dropping\n"));
+                LogFlowFunc(("Waiting for event ...\n"));
+                int rc2 = RTSemEventWait(m_SemEvent, RT_INDEFINITE_WAIT);
+                LogFlowFunc(("rc=%Rrc, mStatus=%RU32\n", rc2, m_enmStatus));
+#endif
+                break;
             }
 
-            case Dropped:
+            case DnDDataObjectStatus_Dropped:
             {
                 LogRel3(("DnD: Dropped\n"));
@@ -239 +245 @@
                          pThisFormat->tymed, pThisFormat->dwAspect));
                 LogRel3(("DnD: Got strFormat=%s, pvData=%p, cbData=%RU32\n",
-                         mstrFormat.toAscii().constData(), mpvData, mcbData));
+                         m_strFormat.toAscii().constData(), m_pvData, m_cbData));
 
                 QVariant::Type vaType;
@@ -288 +294 @@
 
                 int rc;
-                if (!mVaData.isValid())
+
+                if (!m_fDataRetrieved)
                 {
-                    /* Note:  We're usig Qt::MoveAction because this speeds up the whole operation
-                     *        significantly: Instead of copying the data from the temporary location to
-                     *        the final destination we just move it.
-                     *
-                     * Note2: The Qt::MoveAction *only* affects the behavior on the host! The desired
-                     *        action for the guest (e.g. moving a file from guest to host) is not affected
-                     *        by this setting. */
-                    rc = m_pDnDHandler->retrieveData(Qt::MoveAction,
-                                                     strMIMEType, vaType, mVaData);
+                    if (m_pDnDHandler)
+                    {
+                        rc = m_pDnDHandler->retrieveData(Qt::CopyAction,
+                                                         strMIMEType, vaType, m_vaData);
+                    }
+                    else
+                        rc = VERR_NOT_FOUND;
+
+                    m_fDataRetrieved = true;
+                    LogFlowFunc(("Retrieving data ended with %Rrc\n", rc));
                 }
-                else
-                    rc = VINF_SUCCESS; /* Data already retrieved. */
-
-                if (RT_SUCCESS(rc))
+                else /* Data already been retrieved. */
+                    rc = VINF_SUCCESS;
+
+                if (   RT_SUCCESS(rc)
+                    && m_vaData.isValid())
                 {
                     if (   strMIMEType.startsWith("text/uri-list")
                                /* One item. */
-                        && (   mVaData.canConvert(QVariant::String)
+                        && (   m_vaData.canConvert(QVariant::String)
                                /* Multiple items. */
-                            || mVaData.canConvert(QVariant::StringList))
+                            || m_vaData.canConvert(QVariant::StringList))
                        )
                     {
-                        QStringList lstFilesURI = mVaData.toStringList();
+                        QStringList lstFilesURI = m_vaData.toStringList();
                         QStringList lstFiles;
                         for (size_t i = 0; i < lstFilesURI.size(); i++)
@@ -331 +340 @@
 
                         size_t cFiles = lstFiles.size();
+                        LogFlowThisFunc(("Files (%zu)\n", cFiles));
                         if (   RT_SUCCESS(rc)
                             && cFiles)
                         {
-#ifdef DEBUG
-                            LogFlowFunc(("Files (%zu)\n", cFiles));
-                            for (size_t i = 0; i < cFiles; i++)
-                                LogFlowFunc(("\tFile: %s\n", lstFiles.at(i).toAscii().constData()));
-#endif
-                            size_t cchFiles = 0; /* Number of ASCII characters. */
+                            size_t cchFiles = 0; /* Number of characters. */
                             for (size_t i = 0; i < cFiles; i++)
                             {
-                                cchFiles += strlen(lstFiles.at(i).toAscii().constData());
+                                const char *pszFile = lstFiles.at(i).toAscii().constData();
+                                cchFiles += strlen(pszFile);
                                 cchFiles += 1; /* Terminating '\0'. */
+                                LogFlowThisFunc(("\tFile: %s (cchFiles=%zu)\n", pszFile, cchFiles));
                             }
 
-                            size_t cbBuf = sizeof(DROPFILES) + ((cchFiles + 1) * sizeof(RTUTF16));
+                            /* List termination with '\0'. */
+                            cchFiles++;
+
+                            size_t cbBuf = sizeof(DROPFILES) + (cchFiles * sizeof(RTUTF16));
                             DROPFILES *pDropFiles = (DROPFILES *)RTMemAllocZ(cbBuf);
                             if (pDropFiles)
                             {
-                                pDropFiles->pFiles = sizeof(DROPFILES);
-                                pDropFiles->fWide = 1; /* We use unicode. Always. */
+                                /* Put the files list right after our DROPFILES structure. */
+                                pDropFiles->pFiles = sizeof(DROPFILES); /* Offset to file list. */
+                                pDropFiles->fWide  = 1;                 /* We use Unicode. Always. */
 
                                 uint8_t *pCurFile = (uint8_t *)pDropFiles + pDropFiles->pFiles;
                                 AssertPtr(pCurFile);
 
+                                LogFlowThisFunc(("Encoded:\n"));
                                 for (size_t i = 0; i < cFiles; i++)
                                 {
+                                    const char *pszFile = lstFiles.at(i).toUtf8().constData();
+                                    Assert(strlen(pszFile));
+
                                     size_t cchCurFile;
                                     PRTUTF16 pwszFile;
-                                    rc = RTStrToUtf16(lstFiles.at(i).toAscii().constData(), &pwszFile);
+                                    rc = RTStrToUtf16(pszFile, &pwszFile);
                                     if (RT_SUCCESS(rc))
                                     {
@@ -376 +391 @@
                                     *pCurFile = L'\0';
                                     pCurFile += sizeof(RTUTF16);
+
+                                    LogFlowThisFunc(("\t#%zu: cchCurFile=%zu\n", i, cchCurFile));
                                 }
 
@@ -382 +399 @@
                                     *pCurFile = L'\0'; /* Final list terminator. */
 
-                                    pMedium->tymed = TYMED_HGLOBAL;
+                                    /*
+                                     * Fill out the medium structure we're going to report back.
+                                     */
+                                    pMedium->tymed          = TYMED_HGLOBAL;
                                     pMedium->pUnkForRelease = NULL;
-                                    pMedium->hGlobal = GlobalAlloc(  GMEM_ZEROINIT
-                                                                   | GMEM_MOVEABLE
-                                                                   | GMEM_DDESHARE, cbBuf);
+                                    pMedium->hGlobal        = GlobalAlloc(  GMEM_ZEROINIT
+                                                                          | GMEM_MOVEABLE
+                                                                          | GMEM_DDESHARE, cbBuf);
                                     if (pMedium->hGlobal)
                                     {
@@ -402 +422 @@
                                     else
                                         rc = VERR_NO_MEMORY;
+
+                                    LogFlowThisFunc(("Copying to TYMED_HGLOBAL (%zu bytes): %Rrc\n", cbBuf, rc));
                                 }
 
                                 RTMemFree(pDropFiles);
                             }
+                            else
+                                rc = VERR_NO_MEMORY;
+
+                            if (RT_FAILURE(rc))
+                                LogFlowThisFunc(("Failed with %Rrc\n", rc));
                         }
                     }
                     else if (   strMIMEType.startsWith("text/plain")
-                             && mVaData.canConvert(QVariant::String))
+                             && m_vaData.canConvert(QVariant::String))
                     {
-                        bool fUnicode = pFormatEtc->cfFormat == CF_UNICODETEXT;
-                        int cbCh = fUnicode
-                                 ? sizeof(WCHAR) : sizeof(char);
-
-                        QString strText = mVaData.toString();
+                        const bool fUnicode = pFormatEtc->cfFormat == CF_UNICODETEXT;
+                        const size_t cbCh   = fUnicode
+                                            ? sizeof(WCHAR) : sizeof(char);
+
+                        QString strText = m_vaData.toString();
                         size_t cbSrc = strText.length() * cbCh;
                         Assert(cbSrc);
@@ -423 +450 @@
                         AssertPtr(pvSrc);
 
-                        LogFlowFunc(("pvSrc=0x%p, cbSrc=%zu, cbch=%d, fUnicode=%RTbool\n",
+                        LogFlowFunc(("pvSrc=0x%p, cbSrc=%zu, cbCh=%zu, fUnicode=%RTbool\n",
                                      pvSrc, cbSrc, cbCh, fUnicode));
 
-                        pMedium->tymed = TYMED_HGLOBAL;
+                        pMedium->tymed          = TYMED_HGLOBAL;
                         pMedium->pUnkForRelease = NULL;
-                        pMedium->hGlobal = GlobalAlloc(  GMEM_ZEROINIT
-                                                       | GMEM_MOVEABLE
-                                                       | GMEM_DDESHARE,
-                                                       cbSrc);
+                        pMedium->hGlobal        = GlobalAlloc(GHND | GMEM_SHARE, cbSrc);
                         if (pMedium->hGlobal)
                         {
@@ -449 +473 @@
                     }
                     else
-                        LogFlowFunc(("MIME type=%s not supported\n",
-                                     strMIMEType.toAscii().constData()));
-
-                    LogFlowFunc(("Handling formats ended with rc=%Rrc\n", rc));
+                        LogRel2(("DnD: MIME type '%s' not supported\n", strMIMEType.toAscii().constData()));
+
+                    LogFlowThisFunc(("Handling formats ended with rc=%Rrc\n", rc));
                 }
+
+                break;
             }
 
@@ -488 +513 @@
     }
 
-    LogFlowFunc(("Returning hr=%Rhrc\n", hr));
+    LogFlowThisFunc(("Returning hr=%Rhrc\n", hr));
     return hr;
 }
@@ -535 +560 @@
 {
     LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n",
-                 dwDirection, mcFormats, mpFormatEtc));
+                 dwDirection, m_cFormats, m_pFormatEtc));
 
     HRESULT hr;
     if (dwDirection == DATADIR_GET)
     {
-        hr = UIDnDEnumFormatEtc::CreateEnumFormatEtc(mcFormats, mpFormatEtc, ppEnumFormatEtc);
+        hr = UIDnDEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc);
     }
     else
@@ -571 +596 @@
 {
     LogFlowFunc(("Aborting ...\n"));
-    mStatus = Aborted;
-    return RTSemEventSignal(mSemEvent);
+    m_enmStatus = DnDDataObjectStatus_Aborted;
+    return RTSemEventSignal(m_SemEvent);
 }
 
@@ -661 +686 @@
     /* puIndex is optional. */
 
-    for (ULONG i = 0; i < mcFormats; i++)
-    {
-        if(    (pFormatEtc->tymed & mpFormatEtc[i].tymed)
-            && pFormatEtc->cfFormat == mpFormatEtc[i].cfFormat
-            && pFormatEtc->dwAspect == mpFormatEtc[i].dwAspect)
+    for (ULONG i = 0; i < m_cFormats; i++)
+    {
+        if(    (pFormatEtc->tymed & m_pFormatEtc[i].tymed)
+            && pFormatEtc->cfFormat == m_pFormatEtc[i].cfFormat
+            && pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect)
         {
             LogRel3(("DnD: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
-                     pFormatEtc->tymed, pFormatEtc->cfFormat, UIDnDDataObject::ClipboardFormatToString(mpFormatEtc[i].cfFormat),
+                     pFormatEtc->tymed, pFormatEtc->cfFormat, UIDnDDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat),
                      pFormatEtc->dwAspect, i));
 
@@ -677 +702 @@
     }
 
+#if 0
     LogRel3(("DnD: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
              pFormatEtc->tymed, pFormatEtc->cfFormat, UIDnDDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
              pFormatEtc->dwAspect));
+#endif
 
     return false;
-}
-
-/* static */
-HGLOBAL UIDnDDataObject::MemDup(HGLOBAL hMemSource)
-{
-    DWORD dwLen    = GlobalSize(hMemSource);
-    AssertReturn(dwLen, NULL);
-    PVOID pvSource = GlobalLock(hMemSource);
-    if (pvSource)
-    {
-        PVOID pvDest = GlobalAlloc(GMEM_FIXED, dwLen);
-        if (pvDest)
-            memcpy(pvDest, pvSource, dwLen);
-
-        GlobalUnlock(hMemSource);
-        return pvDest;
-    }
-
-    return NULL;
 }
 
@@ -719 +727 @@
 }
 
-void UIDnDDataObject::SetStatus(Status status)
-{
-    LogFlowFunc(("Setting status to %ld\n", status));
-    mStatus = status;
+void UIDnDDataObject::SetStatus(DnDDataObjectStatus enmStatus)
+{
+    LogFlowFunc(("Setting status to %RU32\n", enmStatus));
+    m_enmStatus = enmStatus;
+}
+
+void UIDnDDataObject::Signal(void)
+{
+    SetStatus(DnDDataObjectStatus_Dropped);
 }
 
@@ -732 +745 @@
     int rc;
 
-    SetStatus(Dropped);
-
-    mstrFormat = strFormat;
     if (cbData)
     {
-        mpvData = RTMemAlloc(cbData);
-        if (mpvData)
+        m_pvData = RTMemAlloc(cbData);
+        if (m_pvData)
         {
-            memcpy(mpvData, pvData, cbData);
-            mcbData = cbData;
+            memcpy(m_pvData, pvData, cbData);
+            m_cbData = cbData;
             rc = VINF_SUCCESS;
         }
@@ -750 +760 @@
         rc = VINF_SUCCESS;
 
-    if (RT_FAILURE(rc))
-        mStatus = Aborted;
+    if (RT_SUCCESS(rc))
+    {
+        m_strFormat = strFormat;
+        SetStatus(DnDDataObjectStatus_Dropped);
+    }
+    else
+        SetStatus(DnDDataObjectStatus_Aborted);
 
     /* Signal in any case. */
-    int rc2 = RTSemEventSignal(mSemEvent);
+    int rc2 = RTSemEventSignal(m_SemEvent);
     if (RT_SUCCESS(rc))
         rc = rc2;

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

@@ -37 +37 @@
 public:
 
-    enum Status
+    enum DnDDataObjectStatus
     {
-        Uninitialized = 0,
-        Initialized,
-        Dropping,
-        Dropped,
-        Aborted
+        DnDDataObjectStatus_Uninitialized = 0,
+        DnDDataObjectStatus_Initialized,
+        DnDDataObjectStatus_Dropping,
+        DnDDataObjectStatus_Dropped,
+        DnDDataObjectStatus_Aborted,
+        DnDDataObjectStatus_32Bit_Hack = 0x7fffffff
     };
 
@@ -71 +72 @@
 public:
 
-    static const char* ClipboardFormatToString(CLIPFORMAT fmt);
+    static const char *ClipboardFormatToString(CLIPFORMAT fmt);
 
     int Abort(void);
-    void SetStatus(Status status);
+    void Signal(void);
     int Signal(const QString &strFormat, const void *pvData, uint32_t cbData);
 
 protected:
 
+    void SetStatus(DnDDataObjectStatus enmStatus);
+
     bool LookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex);
-    static HGLOBAL MemDup(HGLOBAL hMemSource);
     void RegisterFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat, TYMED tyMed = TYMED_HGLOBAL,
                         LONG lindex = -1, DWORD dwAspect = DVASPECT_CONTENT, DVTARGETDEVICE *pTargetDevice = NULL);
 
-    UIDnDHandler   *m_pDnDHandler;
-
-    Status          mStatus;
-    LONG            mRefCount;
+    /** Pointe rto drag and drop handler. */
+    UIDnDHandler           *m_pDnDHandler;
+    /** Current drag and drop status. */
+    DnDDataObjectStatus     m_enmStatus;
+    /** Internal reference count of this object. */
+    LONG                    m_cRefs;
     /** Number of native formats registered. This can be a different number than supplied with mlstFormats. */
-    ULONG           mcFormats;
-    FORMATETC      *mpFormatEtc;
-    STGMEDIUM      *mpStgMedium;
-    RTSEMEVENT      mSemEvent;
-    QStringList     mlstFormats;
-    QString         mstrFormat;
+    ULONG                   m_cFormats;
+    FORMATETC              *m_pFormatEtc;
+    STGMEDIUM              *m_pStgMedium;
+    RTSEMEVENT              m_SemEvent;
+    QStringList             m_lstFormats;
+    QString                 m_strFormat;
     /** The retrieved data as a QVariant. Needed for buffering in case a second format needs the same data,
      *  e.g. CF_TEXT and CF_UNICODETEXT. */
-    QVariant        mVaData;
+    QVariant                m_vaData;
+    /** Whether the data already was retrieved or not. */
+    bool                    m_fDataRetrieved;
     /** The retrieved data as a raw buffer. */
-    void           *mpvData;
+    void                   *m_pvData;
     /** Raw buffer size (in bytes). */
-    uint32_t        mcbData;
+    uint32_t                m_cbData;
 };
 

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

@@ -24 +24 @@
 #include <iprt/thread.h>
 
+/* Qt includes: */
+#include <QApplication>
+
+/* Windows includes: */
+#include <QApplication>
 #include <windows.h>
 #include <new> /* For bad_alloc. */
 
 #include "UIDnDDropSource_win.h"
+#include "UIDnDDataObject_win.h"
 
-
-
-UIDnDDropSource::UIDnDDropSource(QWidget *pParent)
-    : mRefCount(1),
-      mpParent(pParent),
-      mdwCurEffect(0),
-      muCurAction(Qt::IgnoreAction)
+UIDnDDropSource::UIDnDDropSource(QWidget *pParent, UIDnDDataObject *pDataObject)
+    : m_cRefCount(1)
+    , m_pParent(pParent)
+    , m_pDataObject(pDataObject)
+    , m_dwCurEffect(DROPEFFECT_NONE)
+    , m_uCurAction(Qt::IgnoreAction)
 {
-    LogFlowFunc(("pParent=0x%p\n", mpParent));
+    LogFlowFunc(("pParent=0x%p\n", m_pParent));
 }
 
 UIDnDDropSource::~UIDnDDropSource(void)
 {
-    LogFlowFunc(("mRefCount=%RI32\n", mRefCount));
+    LogFlowFunc(("mRefCount=%RU32\n", m_cRefCount));
 }
 
@@ -51 +56 @@
 STDMETHODIMP_(ULONG) UIDnDDropSource::AddRef(void)
 {
-    return InterlockedIncrement(&mRefCount);
+    LogFlowFunc(("mRefCount=%RU32\n", m_cRefCount + 1));
+    return (ULONG)InterlockedIncrement(&m_cRefCount);
 }
 
 STDMETHODIMP_(ULONG) UIDnDDropSource::Release(void)
 {
-    LONG lCount = InterlockedDecrement(&mRefCount);
-    if (lCount == 0)
+    Assert(m_cRefCount > 0);
+    LogFlowFunc(("mRefCount=%RU32\n", m_cRefCount - 1));
+    LONG lCount = InterlockedDecrement(&m_cRefCount);
+    if (lCount <= 0)
     {
         delete this;
@@ -63 +71 @@
     }
 
-    return lCount;
+    return (ULONG)lCount;
 }
 
@@ -94 +102 @@
 STDMETHODIMP UIDnDDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD dwKeyState)
 {
-#ifndef DEBUG_andy
-    LogFlowFunc(("fEscapePressed=%RTbool, dwKeyState=0x%x, mdwCurEffect=%RI32, muCurAction=%RU32\n",
-                 fEscapePressed, dwKeyState, mdwCurEffect, muCurAction));
-#endif
+    LogFlowFunc(("fEscapePressed=%RTbool, dwKeyState=0x%x, m_dwCurEffect=%RI32, m_uCurAction=%RU32\n",
+                 RT_BOOL(fEscapePressed), dwKeyState, m_dwCurEffect, m_uCurAction));
 
     /* ESC pressed? Bail out. */
     if (fEscapePressed)
     {
-        mdwCurEffect = 0;
-        muCurAction = Qt::IgnoreAction;
+        m_dwCurEffect = DROPEFFECT_NONE;
+        m_uCurAction  = Qt::IgnoreAction;
 
         LogRel2(("DnD: User cancelled dropping data to the host\n"));
@@ -118 +124 @@
     if (fDropContent)
     {
+        if (m_pDataObject)
+            m_pDataObject->Signal();
+
         LogRel2(("DnD: User dropped data to the host\n"));
         return DRAGDROP_S_DROP;
     }
+
+    QApplication::processEvents();
 
     /* No change, just continue. */
@@ -134 +145 @@
 STDMETHODIMP UIDnDDropSource::GiveFeedback(DWORD dwEffect)
 {
-     Qt::DropActions dropActions = Qt::IgnoreAction;
+    Qt::DropActions dropActions = Qt::IgnoreAction;
 
-#ifndef DEBUG_andy
     LogFlowFunc(("dwEffect=0x%x\n", dwEffect));
-#endif
     if (dwEffect)
     {
@@ -147 +156 @@
         if (dwEffect & DROPEFFECT_LINK)
             dropActions |= Qt::LinkAction;
+
+        m_dwCurEffect = dwEffect;
     }
 
-    mdwCurEffect = dwEffect;
-    muCurAction = dropActions;
+    m_uCurAction  = dropActions;
 
     return DRAGDROP_S_USEDEFAULTCURSORS;

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

@@ -22 +22 @@
 #include "COMEnums.h"
 
+class UIDnDDataObject;
+
+/**
+ * Implementation of IDropSource for drag and drop on the host.
+ */
 class UIDnDDropSource : public IDropSource
 {
 public:
 
-    UIDnDDropSource(QWidget *pParent);
+    UIDnDDropSource(QWidget *pParent, UIDnDDataObject *pDataObject);
     virtual ~UIDnDDropSource(void);
 
 public:
 
-    uint32_t GetCurrentAction(void) { return muCurAction; }
+    uint32_t GetCurrentAction(void) const { return m_uCurAction; }
 
 public: /* IUnknown methods. */
@@ -46 +51 @@
 protected:
 
-    LONG             mRefCount;
-    QWidget         *mpParent;
-    DWORD            mdwCurEffect;
-    Qt::DropActions  muCurAction;
+    /** Pointer to parent widget. */
+    QWidget         *m_pParent;
+    UIDnDDataObject *m_pDataObject;
+    /** The current reference count. */
+    LONG             m_cRefCount;
+    /** Current (last) drop effect issued. */
+    DWORD            m_dwCurEffect;
+    /** Current drop action to perform in case of a successful drop. */
+    Qt::DropActions  m_uCurAction;
 };
 

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

@@ -335 +335 @@
 
 # ifdef RT_OS_WINDOWS
-
-    UIDnDDropSource *pDropSource = new UIDnDDropSource(m_pParent);
-    if (!pDropSource)
-        return VERR_NO_MEMORY;
     UIDnDDataObject *pDataObject = new UIDnDDataObject(this, lstFormats);
     if (!pDataObject)
+        return VERR_NO_MEMORY;
+    UIDnDDropSource *pDropSource = new UIDnDDropSource(m_pParent, pDataObject);
+    if (!pDropSource)
         return VERR_NO_MEMORY;
 

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

@@ -109 +109 @@
 
     /* Let the user know. */
-    LogRel(("Drag and drop support for OS X is disabled in this version."));
+    LogRel(("DnD: Drag and drop support for OS X is not available in this version\n"));
 # endif /* VBOX_WITH_DRAG_AND_DROP_PROMISES */
 #else /* !RT_OS_DARWIN */
@@ -120 +120 @@
     {
         LogFlowFunc(("Current drop action is 0x%x, so can't drop yet\n", m_curAction));
-        rc = VERR_WRONG_ORDER;
+        rc = VERR_NOT_FOUND;
     }
 #endif
@@ -172 +172 @@
 
     if (RT_FAILURE(rc))
-        LogRel(("DnD: Retrieving data failed with %Rrc\n", rc));
+        LogRel2(("DnD: Retrieving data failed with %Rrc\n", rc));
 
     return QVariant(QVariant::Invalid);

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

@@ -101 +101 @@
 
 
-#ifdef DEBUG_andy
+#ifdef DEBUG
+# ifdef DEBUG_andy
 /* Macro for debugging drag and drop actions which usually would
  * go to Main's logging group. */
-# define DNDDEBUG(x) LogRel(x)
-#else
-# define DNDDEBUG(x)
+#  define DNDDEBUG(x) LogFlowFunc(x)
+# else
+#  define DNDDEBUG(x)
+# endif
 #endif