Changeset 49891 in vbox for trunk/src/VBox/Main

Timestamp:

Dec 12, 2013 8:09:20 PM (11 years ago)

Author:

vboxsync

Message:

Merged private draganddrop branch into trunk.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/VBox (modified) (1 prop)
• src/VBox/Main/src-client/GuestDnDImpl.cpp (modified) (30 diffs)

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2011-2012 Oracle Corporation
+ * Copyright (C) 2011-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -29 +29 @@
 # include <VBox/HostServices/DragAndDropSvc.h>
 
+# ifdef LOG_GROUP
+ # undef LOG_GROUP
+# endif
+# define LOG_GROUP LOG_GROUP_GUEST_DND
+# include <VBox/log.h>
+
 # include <iprt/stream.h>
 # include <iprt/semaphore.h>
@@ -48 +54 @@
  *    of it to the Main IGuest interface (see UIDnDHandler.cpp).
  * 2. Main: Public interface for doing Drag and Drop. Also manage the IProgress
- *    interfaces for blocking the caller by showing a progress dialog. (see
- *    this file)
+ *    interfaces for blocking the caller by showing a progress dialog (see
+ *    this file).
  * 3. HGCM service: Handle all messages from the host to the guest at once and
- *    encapsulate the internal communication details. (see dndmanager.cpp and
- *    friends)
+ *    encapsulate the internal communication details (see dndmanager.cpp and
+ *    friends).
  * 4. Guest additions: Split into the platform neutral part (see
  *    VBoxGuestR3LibDragAndDrop.cpp) and the guest OS specific parts.
  *    Receive/send message from/to the HGCM service and does all guest specific
- *    operations. Currently only X11 is supported. (see draganddrop.cpp within
- *    VBoxClient)
- *
- * Host  -> Guest:
+ *    operations. Currently only X11 is supported (see draganddrop.cpp within
+ *    VBoxClient).
+ *
+ * Host -> Guest:
  * 1. There are DnD Enter, Move, Leave events which are send exactly like this
  *    to the guest. The info includes the pos, mimetypes and allowed actions.
@@ -86 +92 @@
  * Dropping of a directory, means recursively transferring _all_ the content.
  *
- * Directories and files are placed into a public visible user directory on the
- * guest (~/Documents/VirtualBox Dropped Files). We can't delete them after the
+ * Directories and files are placed into the user's temporary directory on the
+ * guest (e.g. /tmp/VirtualBox Dropped Files). We can't delete them after the
  * DnD operation, because we didn't know what the DnD target does with it. E.g.
  * it could just be opened in place. This could lead ofc to filling up the disk
@@ -111 +117 @@
  * Cancel is supported in both directions and cleans up all previous steps
  * (thats is: deleting already transfered dirs/files).
- *
- * There are a lot of DO (debug output) calls in the code. This could be
- * disabled, but should be removed (or replaced by Log calls) when this is
- * nearly finished.
- *
- * For Windows guests there could be different communication become necessary.
- * So the current interface isn't set in stone and should be made public only,
- * after someone had deeply looked into the Win guest support. See
- * http://www.catch22.net/tuts/dragdrop for a start.
- *
- * How to test:
- * First set VBOX_WITH_DRAG_AND_DROP=1 in LocalConfig.kmk. The best is if the
- * host match the guest OS arch. Just build the tree and point a shared folder
- * within the guest to the additions subfolder in bin. Start the guest and
- * execute ./VBoxClient --dragandrop --nodaemon within this shared folder. You
- * should now be able of dragging text or files to the guest. I used a 64bit
- * Linux for both the host and the guest. If the archs don't match, you need to
- * first setup a build environment in the guest ofc.
  *
  * In general I propose the following changes in the VBox HGCM infrastructure
@@ -152 +140 @@
  * Todo:
  * - Dragging out of the guest (partly done)
- *   - ESC doesn't really work
+ *   - ESC doesn't really work (on Windows guests it's already implemented)
  *   - transfer of URIs (that is the files and patching of the data)
  *   - testing in a multi monitor setup
@@ -230 +218 @@
 
     void adjustCoords(ULONG uScreenId, ULONG *puX, ULONG *puY) const;
-    void hostCall(const char* psczFunction, uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const;
+    void hostCall(uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const;
 
     /* Static helper */
@@ -254 +242 @@
 /* What mime-types are supported by VirtualBox.
  * Note: If you add something here, make sure you test it with all guest OS's!
+ ** @todo Make this MIME list configurable / extendable (by extra data?). Currently
+ *        this is done hardcoded on every guest platform (POSIX/Windows).
  */
 /* static */
@@ -296 +286 @@
 int DnDGuestResponse::waitForGuestResponse()
 {
-    return RTSemEventWait(m_EventSem, 300);
+    int vrc = RTSemEventWait(m_EventSem, 300);
+#ifdef DEBUG_andy
+    LogFlowFunc(("rc=%Rrc\n", vrc));
+#endif
+    return vrc;
 }
 
@@ -340 +334 @@
 int DnDGuestResponse::setProgress(unsigned uPercentage, uint32_t uState, int rcOp /* = VINF_SUCCESS */)
 {
+    LogFlowFunc(("uPercentage=%RU32, uState=%ld, rcOp=%Rrc\n", uPercentage, uState, rcOp));
+
     int vrc = VINF_SUCCESS;
-    HRESULT rc;
     if (!m_progress.isNull())
     {
         BOOL fCompleted;
-        rc = m_progress->COMGETTER(Completed)(&fCompleted);
+        HRESULT rc = m_progress->COMGETTER(Completed)(&fCompleted);
         if (!fCompleted)
         {
             if (uState == DragAndDropSvc::DND_PROGRESS_ERROR)
+            {
                 rc = m_progress->notifyComplete(E_FAIL,
                                                 COM_IIDOF(IGuest),
                                                 m_parent->getComponentName(),
                                                 m_parent->tr("Guest error (%Rrc)"), rcOp);
+            }
             else if (uState == DragAndDropSvc::DND_PROGRESS_CANCELLED)
-                rc = m_progress->notifyComplete(S_OK);
-            else
+            {
+                rc = m_progress->Cancel();
+                vrc = VERR_CANCELLED;
+            }
+            else /* uState == DragAndDropSvc::DND_PROGRESS_RUNNING */
             {
                 rc = m_progress->SetCurrentOperationProgress(uPercentage);
+#ifndef DEBUG_andy
+                Assert(SUCCEEDED(rc));
+#endif
                 if (   uState      == DragAndDropSvc::DND_PROGRESS_COMPLETE
                     || uPercentage >= 100)
                     rc = m_progress->notifyComplete(S_OK);
             }
+#ifndef DEBUG_andy
+            Assert(SUCCEEDED(rc));
+#endif
         }
-        BOOL fCanceled = FALSE;
-        rc = m_progress->COMGETTER(Canceled)(&fCanceled);
-        if (fCanceled)
-            vrc = VERR_CANCELLED;
-    }
+    }
+
     return vrc;
 }
@@ -391 +394 @@
 }
 
-void GuestDnDPrivate::hostCall(const char* psczFunction, uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const
-{
-    VMMDev *vmmDev = 0;
+void GuestDnDPrivate::hostCall(uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const
+{
+    VMMDev *vmmDev = NULL;
     {
         /* Make sure mParent is valid, so set the read lock while using.
@@ -409 +412 @@
                           p->tr("VMM device is not available (is the VM running?)"));
 
-    LogFlowFunc(("hgcmHostCall msg=%s; numParms=%u\n", psczFunction, u32Function));
+    LogFlowFunc(("hgcmHostCall msg=%RU32, numParms=%RU32\n", u32Function, cParms));
     int vrc = vmmDev->hgcmHostCall("VBoxDragAndDropSvc",
                                    u32Function,
@@ -576 +579 @@
         paParms[i++].setUInt32(strFormats.length() + 1);
 
-        d->hostCall("HOST_DND_HG_EVT_ENTER",
-                    DragAndDropSvc::HOST_DND_HG_EVT_ENTER,
+        d->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_ENTER,
                     i,
                     paParms);
@@ -588 +590 @@
         /* Copy the response info */
         *pResultAction = d->toMainAction(pDnD->defAction());
+        LogFlowFunc(("*pResultAction=%ld\n", *pResultAction));
     }
     catch (HRESULT rc2)
@@ -636 +639 @@
         paParms[i++].setUInt32(strFormats.length() + 1);
 
-        d->hostCall("HOST_DND_HG_EVT_MOVE",
-                    DragAndDropSvc::HOST_DND_HG_EVT_MOVE,
+        d->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_MOVE,
                     i,
                     paParms);
@@ -648 +650 @@
         /* Copy the response info */
         *pResultAction = d->toMainAction(pDnD->defAction());
+        LogFlowFunc(("*pResultAction=%ld\n", *pResultAction));
     }
     catch (HRESULT rc2)
@@ -666 +669 @@
     try
     {
-        d->hostCall("HOST_DND_HG_EVT_LEAVE",
-                    DragAndDropSvc::HOST_DND_HG_EVT_LEAVE,
+        d->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_LEAVE,
                     0,
                     NULL);
@@ -722 +724 @@
         paParms[i++].setUInt32(strFormats.length() + 1);
 
-        d->hostCall("HOST_DND_HG_EVT_DROPPED",
-                    DragAndDropSvc::HOST_DND_HG_EVT_DROPPED,
+        d->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_DROPPED,
                     i,
                     paParms);
@@ -735 +736 @@
         *pResultAction = d->toMainAction(pDnD->defAction());
         Bstr(pDnD->format()).cloneTo(pstrFormat);
+
+        LogFlowFunc(("*pResultAction=%ld\n", *pResultAction));
     }
     catch (HRESULT rc2)
@@ -768 +771 @@
         pDnD->resetProgress(p);
 
-        d->hostCall("HOST_DND_HG_SND_DATA",
-                    DragAndDropSvc::HOST_DND_HG_SND_DATA,
+        d->hostCall(DragAndDropSvc::HOST_DND_HG_SND_DATA,
                     i,
                     paParms);
@@ -801 +803 @@
         paParms[i++].setUInt32(uScreenId);
 
-        d->hostCall("HOST_DND_GH_REQ_PENDING",
-                    DragAndDropSvc::HOST_DND_GH_REQ_PENDING,
+        d->hostCall(DragAndDropSvc::HOST_DND_GH_REQ_PENDING,
                     i,
                     paParms);
@@ -855 +856 @@
         pDnD->resetProgress(p);
 
-        d->hostCall("HOST_DND_GH_EVT_DROPPED",
-                    DragAndDropSvc::HOST_DND_GH_EVT_DROPPED,
+        d->hostCall(DragAndDropSvc::HOST_DND_GH_EVT_DROPPED,
                     i,
                     paParms);
@@ -902 +902 @@
 DECLCALLBACK(int) GuestDnD::notifyGuestDragAndDropEvent(void *pvExtension, uint32_t u32Function, void *pvParms, uint32_t cbParms)
 {
+    LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
+                 pvExtension, u32Function, pvParms, cbParms));
+
     ComObjPtr<Guest> pGuest = reinterpret_cast<Guest*>(pvExtension);
     if (!pGuest->m_pGuestDnD)
@@ -909 +912 @@
     const ComObjPtr<Guest> &p = d->p;
 
-    DnDGuestResponse *pDnD = d->response();
-    if (pDnD == NULL)
+    DnDGuestResponse *pResp = d->response();
+    if (pResp == NULL)
         return VERR_INVALID_PARAMETER;
 
@@ -922 +925 @@
             AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGACKOPDATA) == cbParms, VERR_INVALID_PARAMETER);
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-            pDnD->setDefAction(pCBData->uAction);
-            rc = pDnD->notifyAboutGuestResponse();
+            pResp->setDefAction(pCBData->uAction);
+            rc = pResp->notifyAboutGuestResponse();
             break;
         }
@@ -932 +935 @@
             AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGREQDATADATA) == cbParms, VERR_INVALID_PARAMETER);
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_REQ_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-            pDnD->setFormat(pCBData->pszFormat);
-            rc = pDnD->notifyAboutGuestResponse();
+            pResp->setFormat(pCBData->pszFormat);
+            rc = pResp->notifyAboutGuestResponse();
             break;
         }
@@ -942 +945 @@
             AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGEVTPROGRESSDATA) == cbParms, VERR_INVALID_PARAMETER);
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_EVT_PROGRESS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-            rc = pDnD->setProgress(pCBData->uPercentage, pCBData->uState);
+            rc = pResp->setProgress(pCBData->uPercentage, pCBData->uState, pCBData->rc);
             break;
         }
@@ -952 +955 @@
             AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA) == cbParms, VERR_INVALID_PARAMETER);
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_ACK_PENDING == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-            pDnD->setFormat(pCBData->pszFormat);
-            pDnD->setDefAction(pCBData->uDefAction);
-            pDnD->setAllActions(pCBData->uAllActions);
-            rc = pDnD->notifyAboutGuestResponse();
+            pResp->setFormat(pCBData->pszFormat);
+            pResp->setDefAction(pCBData->uDefAction);
+            pResp->setAllActions(pCBData->uAllActions);
+            rc = pResp->notifyAboutGuestResponse();
             break;
         }
@@ -965 +968 @@
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
             uint32_t cbCurSize = 0;
-            pDnD->addData(pCBData->pvData, pCBData->cbData, &cbCurSize);
-            rc = pDnD->setProgress(100.0 / pCBData->cbAllSize * cbCurSize, (pCBData->cbAllSize == cbCurSize ? DragAndDropSvc::DND_PROGRESS_COMPLETE : DragAndDropSvc::DND_PROGRESS_RUNNING));
+            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));
             /* Todo: for now we instantly confirm the cancel. Check if the
              * guest should first clean up stuff itself and than really confirm
              * the cancel request by an extra message. */
             if (rc == VERR_CANCELLED)
-                pDnD->setProgress(100, DragAndDropSvc::DND_PROGRESS_CANCELLED);
+                pResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_CANCELLED);
             break;
         }
@@ -981 +984 @@
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
             /* Cleanup */
-            pDnD->resetData();
-            rc = pDnD->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc);
+            pResp->resetData();
+            rc = pResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc);
             break;
         }
 #endif /* VBOX_WITH_DRAG_AND_DROP_GH */
-        default: AssertMsgFailedReturn(("Function %u not recognized!\n", u32Function), VERR_INVALID_PARAMETER); break;
-    }
-
+        default:
+            AssertMsgFailedReturn(("Function %RU32 not supported\n", u32Function), VERR_NOT_SUPPORTED);
+            break;
+    }
+
+    LogFlowFunc(("Returning rc=%Rrc\n", rc));
     return rc;
 }