Changeset 74439 in vbox

Timestamp:

Sep 24, 2018 12:30:47 PM (6 years ago)

Author:

vboxsync

Message:

DnD: Added typedefs for DNDACTION and DNDACTIONLIST to emphasize usage, did some renaming to clean things up.

Location:

trunk

Files:

• include/VBox/GuestHost/DragAndDropDefs.h (added)
• include/VBox/HostServices/DragAndDropSvc.h (modified) (1 diff)
• include/VBox/VBoxGuestLib.h (modified) (6 diffs)
• src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.cpp (modified) (13 diffs)
• src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.h (modified) (1 diff)
• src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibDragAndDrop.cpp (modified) (8 diffs)
• src/VBox/Additions/x11/VBoxClient/draganddrop.cpp (modified) (21 diffs)
• src/VBox/HostServices/DragAndDrop/service.cpp (modified) (1 diff)
• src/VBox/Main/include/GuestDnDPrivate.h (modified) (5 diffs)
• src/VBox/Main/src-client/GuestDnDPrivate.cpp (modified) (8 diffs)
• src/VBox/Main/src-client/GuestDnDSourceImpl.cpp (modified) (4 diffs)
• src/VBox/Main/src-client/GuestDnDTargetImpl.cpp (modified) (10 diffs)

trunk/include/VBox/HostServices/DragAndDropSvc.h

@@ -67 +67 @@
 #include <VBox/VMMDevCoreTypes.h>
 #include <VBox/VBoxGuestCoreTypes.h>
-
-/*
- * The mode of operations.
- */
-#define VBOX_DRAG_AND_DROP_MODE_OFF           0
-#define VBOX_DRAG_AND_DROP_MODE_HOST_TO_GUEST 1
-#define VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST 2
-#define VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL 3
-
-#define VBOX_DND_ACTION_IGNORE     UINT32_C(0)
-#define VBOX_DND_ACTION_COPY       RT_BIT_32(0)
-#define VBOX_DND_ACTION_MOVE       RT_BIT_32(1)
-#define VBOX_DND_ACTION_LINK       RT_BIT_32(2)
-
-/** A single DnD action. */
-typedef uint32_t VBOXDNDACTION;
-/** A list of (OR'ed) DnD actions. */
-typedef uint32_t VBOXDNDACTIONLIST;
-
-#define hasDnDCopyAction(a)   ((a) & VBOX_DND_ACTION_COPY)
-#define hasDnDMoveAction(a)   ((a) & VBOX_DND_ACTION_MOVE)
-#define hasDnDLinkAction(a)   ((a) & VBOX_DND_ACTION_LINK)
-
-#define isDnDIgnoreAction(a)  ((a) == VBOX_DND_ACTION_IGNORE)
-#define isDnDCopyAction(a)    ((a) == VBOX_DND_ACTION_COPY)
-#define isDnDMoveAction(a)    ((a) == VBOX_DND_ACTION_MOVE)
-#define isDnDLinkAction(a)    ((a) == VBOX_DND_ACTION_LINK)
-
-/** @def VBOX_DND_FORMATS_DEFAULT
- * Default drag'n drop formats.
- * Note: If you add new entries here, make sure you test those
- *       with all supported guest OSes!
- */
-#define VBOX_DND_FORMATS_DEFAULT                                                                \
-    "text/uri-list",                                                                            \
-    /* Text. */                                                                                 \
-    "text/html",                                                                                \
-    "text/plain;charset=utf-8",                                                                 \
-    "text/plain;charset=utf-16",                                                                \
-    "text/plain",                                                                               \
-    "text/richtext",                                                                            \
-    "UTF8_STRING",                                                                              \
-    "TEXT",                                                                                     \
-    "STRING",                                                                                   \
-    /* OpenOffice formats. */                                                                   \
-    /* See: https://wiki.openoffice.org/wiki/Documentation/DevGuide/OfficeDev/Common_Application_Features#OpenOffice.org_Clipboard_Data_Formats */ \
-    "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"", \
-    "application/x-openoffice;windows_formatname=\"Bitmap\""
 
 namespace DragAndDropSvc {

trunk/include/VBox/VBoxGuestLib.h

@@ -34 +34 @@
 #include <VBox/VMMDev.h>
 #include <VBox/VBoxGuestCoreTypes.h>
+# ifdef VBOX_WITH_DRAG_AND_DROP
+#  include <VBox/GuestHost/DragAndDropDefs.h>
+# endif
 
 /** @defgroup grp_vboxguest_lib     VirtualBox Guest Additions Library
@@ -920 +923 @@
             /** Size (in bytes) of pszFormats (\0 included). */
             uint32_t cbFormats;
-            /** Allowed DnD actions. */
-            uint32_t uAllActions;
+            /** List of allowed DnD actions. */
+            VBOXDNDACTIONLIST dndLstActionsAllowed;
         } HG_Enter;
         struct
@@ -929 +932 @@
             /** Absolute Y position of guest screen. */
             uint32_t uYpos;
-            /** Proposed DnD action. */
-            uint32_t uDefAction;
+            /** Default DnD action. */
+            VBOXDNDACTION dndActionDefault;
         } HG_Move;
         struct
@@ -942 +945 @@
             /** Absolute Y position of guest screen. */
             uint32_t uYpos;
-            /** Proposed DnD action. */
-            uint32_t uDefAction;
+            /** Default DnD action. */
+            VBOXDNDACTION dndActionDefault;
         } HG_Drop;
         struct
@@ -968 +971 @@
             uint32_t cbFormat;
             /** Requested DnD action. */
-            uint32_t uAction;
+            VBOXDNDACTION dndActionRequested;
         } GH_Drop;
 # endif
@@ -982 +985 @@
 VBGLR3DECL(void)    VbglR3DnDEventFree(PVBGLR3DNDEVENT pEvent);
 
-VBGLR3DECL(int)     VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uAction);
+VBGLR3DECL(int)     VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndAction);
 VBGLR3DECL(int)     VbglR3DnDHGSendReqData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pcszFormat);
 VBGLR3DECL(int)     VbglR3DnDHGSendProgress(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uStatus, uint8_t uPercent, int rcErr);
 #  ifdef VBOX_WITH_DRAG_AND_DROP_GH
-VBGLR3DECL(int)     VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uDefAction, uint32_t uAllActions, const char* pcszFormats, uint32_t cbFormats);
+VBGLR3DECL(int)     VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndActionDefault, VBOXDNDACTIONLIST dndLstActionsAllowed, const char* pcszFormats, uint32_t cbFormats);
 VBGLR3DECL(int)     VbglR3DnDGHSendData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pszFormat, void *pvData, uint32_t cbData);
 VBGLR3DECL(int)     VbglR3DnDGHSendError(PVBGLR3GUESTDNDCMDCTX pCtx, int rcOp);

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

@@ -94 +94 @@
       mEventSem(NIL_RTSEMEVENT),
       hWnd(NULL),
-      uAllActions(VBOX_DND_ACTION_IGNORE),
+      dndLstActionsAllowed(VBOX_DND_ACTION_IGNORE),
       mfMouseButtonDown(false),
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
@@ -477 +477 @@
                     hide();
 
-                    LogFlowThisFunc(("Starting drag and drop: uAllActions=0x%x, dwOKEffects=0x%x ...\n",
-                                     uAllActions, startupInfo.dwOKEffects));
+                    LogFlowThisFunc(("Starting drag and drop: dndLstActionsAllowed=0x%x, dwOKEffects=0x%x ...\n",
+                                     dndLstActionsAllowed, startupInfo.dwOKEffects));
 
                     AssertPtr(startupInfo.pDataObject);
@@ -561 +561 @@
                         RTCList<RTCString> lstFormats =
                             RTCString(pVbglR3Event->u.HG_Enter.pszFormats, pVbglR3Event->u.HG_Enter.cbFormats - 1).split("\r\n");
-                        rc = OnHgEnter(lstFormats, pVbglR3Event->u.HG_Enter.uAllActions);
+                        rc = OnHgEnter(lstFormats, pVbglR3Event->u.HG_Enter.dndLstActionsAllowed);
                         if (RT_FAILURE(rc))
                             break;
@@ -580 +580 @@
                 {
                     rc = OnHgMove(pVbglR3Event->u.HG_Move.uXpos, pVbglR3Event->u.HG_Move.uYpos,
-                                  pVbglR3Event->u.HG_Move.uDefAction);
+                                  pVbglR3Event->u.HG_Move.dndActionDefault);
                     break;
                 }
@@ -628 +628 @@
                 case VBGLR3DNDEVENTTYPE_GH_DROP:
                 {
-                    rc = OnGhDrop(pVbglR3Event->u.GH_Drop.pszFormat, pVbglR3Event->u.GH_Drop.uAction);
+                    rc = OnGhDrop(pVbglR3Event->u.GH_Drop.pszFormat, pVbglR3Event->u.GH_Drop.dndActionRequested);
                     break;
                 }
@@ -769 +769 @@
  * @return  IPRT status code.
  * @param   lstFormats              Supported formats offered by the host.
- * @param   uAllActions             Supported actions offered by the host.
- */
-int VBoxDnDWnd::OnHgEnter(const RTCList<RTCString> &lstFormats, uint32_t uAllActions)
+ * @param   dndLstActionsAllowed    Supported actions offered by the host.
+ */
+int VBoxDnDWnd::OnHgEnter(const RTCList<RTCString> &lstFormats, VBOXDNDACTIONLIST dndLstActionsAllowed)
 {
     if (mMode == GH) /* Wrong mode? Bail out. */
@@ -777 +777 @@
 
 #ifdef DEBUG
-    LogFlowThisFunc(("uActions=0x%x, lstFormats=%zu: ", uAllActions, lstFormats.size()));
+    LogFlowThisFunc(("dndActionList=0x%x, lstFormats=%zu: ", dndLstActionsAllowed, lstFormats.size()));
     for (size_t i = 0; i < lstFormats.size(); i++)
         LogFlow(("'%s' ", lstFormats.at(i).c_str()));
@@ -791 +791 @@
     {
         /* Save all allowed actions. */
-        this->uAllActions = uAllActions;
+        this->dndLstActionsAllowed = dndLstActionsAllowed;
 
         /*
@@ -876 +876 @@
         /* Translate our drop actions into allowed Windows drop effects. */
         startupInfo.dwOKEffects = DROPEFFECT_NONE;
-        if (uAllActions)
-        {
-            if (uAllActions & VBOX_DND_ACTION_COPY)
+        if (dndLstActionsAllowed)
+        {
+            if (dndLstActionsAllowed & VBOX_DND_ACTION_COPY)
                 startupInfo.dwOKEffects |= DROPEFFECT_COPY;
-            if (uAllActions & VBOX_DND_ACTION_MOVE)
+            if (dndLstActionsAllowed & VBOX_DND_ACTION_MOVE)
                 startupInfo.dwOKEffects |= DROPEFFECT_MOVE;
-            if (uAllActions & VBOX_DND_ACTION_LINK)
+            if (dndLstActionsAllowed & VBOX_DND_ACTION_LINK)
                 startupInfo.dwOKEffects |= DROPEFFECT_LINK;
         }
@@ -1196 +1196 @@
     if (RT_SUCCESS(rc))
     {
-        uint32_t uDefAction = VBOX_DND_ACTION_IGNORE;
+        uint32_t dndActionDefault = VBOX_DND_ACTION_IGNORE;
 
         AssertPtr(pDropTarget);
@@ -1202 +1202 @@
         if (!strFormats.isEmpty())
         {
-            uDefAction = VBOX_DND_ACTION_COPY;
-
-            LogFlowFunc(("Acknowledging pDropTarget=0x%p, uDefAction=0x%x, uAllActions=0x%x, strFormats=%s\n",
-                         pDropTarget, uDefAction, uAllActions, strFormats.c_str()));
+            dndActionDefault = VBOX_DND_ACTION_COPY;
+
+            LogFlowFunc(("Acknowledging pDropTarget=0x%p, dndActionDefault=0x%x, dndLstActionsAllowed=0x%x, strFormats=%s\n",
+                         pDropTarget, dndActionDefault, dndLstActionsAllowed, strFormats.c_str()));
         }
         else
@@ -1214 +1214 @@
 
         /** @todo Support more than one action at a time. */
-        uAllActions = uDefAction;
+        dndLstActionsAllowed = dndActionDefault;
 
         int rc2 = VbglR3DnDGHSendAckPending(&mDnDCtx,
-                                            uDefAction, uAllActions,
+                                            dndActionDefault, dndLstActionsAllowed,
                                             strFormats.c_str(), (uint32_t)strFormats.length() + 1 /* Include termination */);
         if (RT_FAILURE(rc2))
@@ -1550 +1550 @@
 
     this->lstFmtActive.clear();
-    this->uAllActions = VBOX_DND_ACTION_IGNORE;
+    this->dndLstActionsAllowed = VBOX_DND_ACTION_IGNORE;
 
     int rc2 = setMode(Unknown);

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

@@ -380 +380 @@
      *  drag'n drop operation. */
     RTCList<RTCString>         lstFmtActive;
-    /** Flags of all current drag'n drop
-     *  actions allowed. */
-    uint32_t                   uAllActions;
+    /** List of all current drag'n drop actions allowed. */
+    VBOXDNDACTIONLIST          dndLstActionsAllowed;
     /** The startup information required
      *  for the actual DoDragDrop() call. */

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibDragAndDrop.cpp

@@ -1212 +1212 @@
                                            NULL /* puYPos */,
                                            NULL /* uDefAction */,
-                                           &pEvent->u.HG_Enter.uAllActions,
+                                           &pEvent->u.HG_Enter.dndLstActionsAllowed,
                                            &pEvent->u.HG_Enter.pszFormats,
                                            &pEvent->u.HG_Enter.cbFormats);
@@ -1226 +1226 @@
                                            &pEvent->u.HG_Move.uXpos,
                                            &pEvent->u.HG_Move.uYpos,
-                                           &pEvent->u.HG_Move.uDefAction,
+                                           &pEvent->u.HG_Move.dndActionDefault,
                                            NULL /* puAllActions */,
                                            NULL /* pszFormats */,
@@ -1241 +1241 @@
                                            &pEvent->u.HG_Drop.uXpos,
                                            &pEvent->u.HG_Drop.uYpos,
-                                           &pEvent->u.HG_Drop.uDefAction,
+                                           &pEvent->u.HG_Drop.dndActionDefault,
                                            NULL /* puAllActions */,
                                            NULL /* pszFormats */,
@@ -1295 +1295 @@
                                             &pEvent->u.GH_Drop.pszFormat,
                                             &pEvent->u.GH_Drop.cbFormat,
-                                            &pEvent->u.GH_Drop.uAction);
+                                            &pEvent->u.GH_Drop.dndActionRequested);
                 if (RT_SUCCESS(rc))
                     pEvent->enmType = VBGLR3DNDEVENTTYPE_GH_DROP;
@@ -1369 +1369 @@
 }
 
-VBGLR3DECL(int) VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uAction)
+VBGLR3DECL(int) VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndAction)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
@@ -1379 +1379 @@
     /** @todo Context ID not used yet. */
     Msg.u.v3.uContext.SetUInt32(0);
-    Msg.u.v3.uAction.SetUInt32(uAction);
+    Msg.u.v3.uAction.SetUInt32(dndAction);
 
     return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
@@ -1448 +1448 @@
  *
  * @returns IPRT status code.
- * @param   pCtx                DnD context to use.
- * @param   uDefAction          Default action for the operation to report.
- * @param   uAllActions         All available actions for the operation to report.
- * @param   pcszFormats         Available formats for the operation to report.
- * @param   cbFormats           Size (in bytes) of formats to report.
+ * @param   pCtx                 DnD context to use.
+ * @param   dndActionDefault     Default action for the operation to report.
+ * @param   dndLstActionsAllowed All available actions for the operation to report.
+ * @param   pcszFormats          Available formats for the operation to report.
+ * @param   cbFormats            Size (in bytes) of formats to report.
  */
 VBGLR3DECL(int) VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx,
-                                          uint32_t uDefAction, uint32_t uAllActions, const char* pcszFormats, uint32_t cbFormats)
+                                          VBOXDNDACTION dndActionDefault, VBOXDNDACTIONLIST dndLstActionsAllowed,
+                                          const char* pcszFormats, uint32_t cbFormats)
 {
     AssertPtrReturn(pCtx,        VERR_INVALID_POINTER);
@@ -1470 +1471 @@
     /** @todo Context ID not used yet. */
     Msg.u.v3.uContext.SetUInt32(0);
-    Msg.u.v3.uDefAction.SetUInt32(uDefAction);
-    Msg.u.v3.uAllActions.SetUInt32(uAllActions);
+    Msg.u.v3.uDefAction.SetUInt32(dndActionDefault);
+    Msg.u.v3.uAllActions.SetUInt32(dndLstActionsAllowed);
     Msg.u.v3.pvFormats.SetPtr((void*)pcszFormats, cbFormats);
     Msg.u.v3.cbFormats.SetUInt32(cbFormats);

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

@@ -440 +440 @@
     void destroy();
 
-    int sendFinished(Window hWndSource, uint32_t uAction);
+    int sendFinished(Window hWndSource, VBOXDNDACTION dndAction);
 
 public:
@@ -504 +504 @@
 
     /* Host -> Guest handling. */
-    int hgEnter(const RTCList<RTCString> &formats, uint32_t actions);
+    int hgEnter(const RTCList<RTCString> &formats, VBOXDNDACTIONLIST dndListActionsAllowed);
     int hgLeave(void);
-    int hgMove(uint32_t uPosX, uint32_t uPosY, uint32_t uDefaultAction);
-    int hgDrop(uint32_t uPosX, uint32_t uPosY, uint32_t uDefaultAction);
+    int hgMove(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault);
+    int hgDrop(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault);
     int hgDataReceive(PVBGLR3GUESTDNDMETADATA pMetaData);
 
@@ -537 +537 @@
     int             toAtomList(const RTCList<RTCString> &lstFormats, VBoxDnDAtomList &lstAtoms) const;
     int             toAtomList(const void *pvData, uint32_t cbData, VBoxDnDAtomList &lstAtoms) const;
-    static Atom     toAtomAction(uint32_t uAction);
-    static int      toAtomActions(uint32_t uActions, VBoxDnDAtomList &lstAtoms);
+    static Atom     toAtomAction(VBOXDNDACTION dndAction);
+    static int      toAtomActions(VBOXDNDACTIONLIST dndActionList, VBoxDnDAtomList &lstAtoms);
     static uint32_t toHGCMAction(Atom atom);
     static uint32_t toHGCMActions(const VBoxDnDAtomList &actionsList);
@@ -950 +950 @@
                 LogFlowThisFunc(("\tReported dead area: x=%RU16, y=%RU16, cx=%RU16, cy=%RU16\n", x, y, cx, cy));
 #endif
-
-                uint32_t uAction = VBOX_DND_ACTION_IGNORE; /* Default is ignoring. */
+                VBOXDNDACTION dndAction = VBOX_DND_ACTION_IGNORE; /* Default is ignoring. */
                 /** @todo Compare this with the allowed actions. */
                 if (fAcceptDrop)
-                    uAction = toHGCMAction(static_cast<Atom>(e.xclient.data.l[XdndStatusAction]));
-
-                rc = VbglR3DnDHGSendAckOp(&m_dndCtx, uAction);
+                    dndAction = toHGCMAction(static_cast<Atom>(e.xclient.data.l[XdndStatusAction]));
+
+                rc = VbglR3DnDHGSendAckOp(&m_dndCtx, dndAction);
             }
             else if (e.xclient.message_type == xAtom(XA_XdndFinished))
@@ -1594 +1593 @@
  * @returns IPRT status code.
  * @param   lstFormats              List of supported formats from the host.
- * @param   uActions                (ORed) List of supported actions from the host.
- */
-int DragInstance::hgEnter(const RTCList<RTCString> &lstFormats, uint32_t uActions)
+ * @param   dndListActionsAllowed   (ORed) List of supported actions from the host.
+ */
+int DragInstance::hgEnter(const RTCList<RTCString> &lstFormats, uint32_t dndListActionsAllowed)
 {
     LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
@@ -1606 +1605 @@
 
 #ifdef DEBUG
-    LogFlowThisFunc(("uActions=0x%x, lstFormats=%zu: ", uActions, lstFormats.size()));
+    LogFlowThisFunc(("dndListActionsAllowed=0x%x, lstFormats=%zu: ", dndListActionsAllowed, lstFormats.size()));
     for (size_t i = 0; i < lstFormats.size(); ++i)
         LogFlow(("'%s' ", lstFormats.at(i).c_str()));
@@ -1630 +1629 @@
         /* Announce the possible actions. */
         VBoxDnDAtomList lstActions;
-        rc = toAtomActions(uActions, lstActions);
+        rc = toAtomActions(dndListActionsAllowed, lstActions);
         if (RT_FAILURE(rc))
             break;
@@ -1667 +1666 @@
  * @param   uPosX                   Relative X position within the guest's display area.
  * @param   uPosY                   Relative Y position within the guest's display area.
- * @param   uDefaultAction          Default action the host wants to perform on the guest
+ * @param   dndActionDefault        Default action the host wants to perform on the guest
  *                                  as soon as the operation successfully finishes.
  */
-int DragInstance::hgMove(uint32_t uPosX, uint32_t uPosY, uint32_t uDefaultAction)
+int DragInstance::hgMove(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault)
 {
     LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
-    LogFlowThisFunc(("uPosX=%RU32, uPosY=%RU32, uAction=%RU32\n", uPosX, uPosY, uDefaultAction));
+    LogFlowThisFunc(("uPosX=%RU32, uPosY=%RU32, dndActionDefault=%RU32\n", uPosX, uPosY, dndActionDefault));
 
     if (   m_enmMode  != HG
@@ -1820 +1819 @@
          * Send a XdndPosition event with the proposed action to the guest.
          */
-        Atom pa = toAtomAction(uDefaultAction);
+        Atom pa = toAtomAction(dndActionDefault);
         LogFlowThisFunc(("strAction=%s\n", xAtomToString(pa).c_str()));
 
@@ -1863 +1862 @@
  * @param   uPosX                   Relative X position within the guest's display area.
  * @param   uPosY                   Relative Y position within the guest's display area.
- * @param   uDefaultAction          Default action the host wants to perform on the guest
+ * @param   dndActionDefault        Default action the host wants to perform on the guest
  *                                  as soon as the operation successfully finishes.
  */
-int DragInstance::hgDrop(uint32_t uPosX, uint32_t uPosY, uint32_t uDefaultAction)
-{
-    RT_NOREF3(uPosX, uPosY, uDefaultAction);
+int DragInstance::hgDrop(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault)
+{
+    RT_NOREF3(uPosX, uPosY, dndActionDefault);
     LogFlowThisFunc(("wndCur=%RU32, wndProxy=%RU32, mode=%RU32, state=%RU32\n", m_wndCur, m_wndProxy.hWnd, m_enmMode, m_enmState));
-    LogFlowThisFunc(("uPosX=%RU32, uPosY=%RU32, uAction=%RU32\n", uPosX, uPosY, uDefaultAction));
+    LogFlowThisFunc(("uPosX=%RU32, uPosY=%RU32, dndActionDefault=%RU32\n", uPosX, uPosY, dndActionDefault));
 
     if (   m_enmMode  != HG
@@ -1995 +1994 @@
 
     RTCString strFormats = "\r\n"; /** @todo If empty, IOCTL fails with VERR_ACCESS_DENIED. */
-    uint32_t uDefAction  = VBOX_DND_ACTION_IGNORE;
-    uint32_t uAllActions = VBOX_DND_ACTION_IGNORE;
+    VBOXDNDACTION     dndActionDefault = VBOX_DND_ACTION_IGNORE;
+    VBOXDNDACTIONLIST dndActionList    = VBOX_DND_ACTION_IGNORE;
 
     /* Currently in wrong mode? Bail out. */
@@ -2097 +2096 @@
         {
             strFormats   = strFormatsCur;
-            uDefAction   = VBOX_DND_ACTION_COPY; /** @todo Handle default action! */
-            uAllActions  = VBOX_DND_ACTION_COPY; /** @todo Ditto. */
-            uAllActions |= toHGCMActions(m_lstActions);
+            dndActionDefault = VBOX_DND_ACTION_COPY; /** @todo Handle default action! */
+            dndActionList    = VBOX_DND_ACTION_COPY; /** @todo Ditto. */
+            dndActionList   |= toHGCMActions(m_lstActions);
         }
 
@@ -2105 +2104 @@
     }
 
-    rc2 = VbglR3DnDGHSendAckPending(&m_dndCtx, uDefAction, uAllActions,
+    rc2 = VbglR3DnDGHSendAckPending(&m_dndCtx, dndActionDefault, dndActionList,
                                     strFormats.c_str(), strFormats.length() + 1 /* Include termination */);
-    LogFlowThisFunc(("uClientID=%RU32, uDefAction=0x%x, allActions=0x%x, strFormats=%s, rc=%Rrc\n",
-                     m_dndCtx.uClientID, uDefAction, uAllActions, strFormats.c_str(), rc2));
+    LogFlowThisFunc(("uClientID=%RU32, uDefAction=0x%x, uLstActions=0x%x, strFormats=%s, rc=%Rrc\n",
+                     m_dndCtx.uClientID, dndActionDefault, dndActionList, strFormats.c_str(), rc2));
     if (RT_FAILURE(rc2))
     {
@@ -2822 +2821 @@
  *
  * @returns Converted Atom-based drag'n drop action.
- * @param   uAction                 HGCM drag'n drop actions to convert.
+ * @param   dndAction               HGCM drag'n drop actions to convert.
  */
 /* static */
-Atom DragInstance::toAtomAction(uint32_t uAction)
+Atom DragInstance::toAtomAction(VBOXDNDACTION dndAction)
 {
     /* Ignore is None. */
-    return (isDnDCopyAction(uAction) ? xAtom(XA_XdndActionCopy) :
-            isDnDMoveAction(uAction) ? xAtom(XA_XdndActionMove) :
-            isDnDLinkAction(uAction) ? xAtom(XA_XdndActionLink) :
+    return (isDnDCopyAction(dndAction) ? xAtom(XA_XdndActionCopy) :
+            isDnDMoveAction(dndAction) ? xAtom(XA_XdndActionMove) :
+            isDnDLinkAction(dndAction) ? xAtom(XA_XdndActionLink) :
             None);
 }
@@ -2838 +2837 @@
  *
  * @returns IPRT status code.
- * @param   uActions                HGCM drag'n drop actions to convert.
+ * @param   dndActionList           HGCM drag'n drop actions to convert.
  * @param   lstAtoms                Reference to VBoxDnDAtomList to store actions in.
  */
 /* static */
-int DragInstance::toAtomActions(uint32_t uActions, VBoxDnDAtomList &lstAtoms)
-{
-    if (hasDnDCopyAction(uActions))
+int DragInstance::toAtomActions(VBOXDNDACTIONLIST dndActionList, VBoxDnDAtomList &lstAtoms)
+{
+    if (hasDnDCopyAction(dndActionList))
         lstAtoms.append(xAtom(XA_XdndActionCopy));
-    if (hasDnDMoveAction(uActions))
+    if (hasDnDMoveAction(dndActionList))
         lstAtoms.append(xAtom(XA_XdndActionMove));
-    if (hasDnDLinkAction(uActions))
+    if (hasDnDLinkAction(dndActionList))
         lstAtoms.append(xAtom(XA_XdndActionLink));
 
@@ -2929 +2928 @@
 }
 
-int VBoxDnDProxyWnd::sendFinished(Window hWndSource, uint32_t uAction)
+int VBoxDnDProxyWnd::sendFinished(Window hWndSource, VBOXDNDACTION dndAction)
 {
     /* Was the drop accepted by the host? That is, anything than ignoring. */
-    bool fDropAccepted = uAction > VBOX_DND_ACTION_IGNORE;
-
-    LogFlowFunc(("uAction=%RU32\n", uAction));
+    bool fDropAccepted = dndAction > VBOX_DND_ACTION_IGNORE;
+
+    LogFlowFunc(("dndAction=%RU32\n", dndAction));
 
     /* Confirm the result of the transfer to the target window. */
@@ -2944 +2943 @@
     m.message_type = xAtom(XA_XdndFinished);
     m.format       = 32;
-    m.data.l[XdndFinishedWindow] = hWnd;                                                       /* Target window. */
-    m.data.l[XdndFinishedFlags]  = fDropAccepted ? RT_BIT(0) : 0;                              /* Was the drop accepted? */
-    m.data.l[XdndFinishedAction] = fDropAccepted ? DragInstance::toAtomAction(uAction) : None; /* Action used on accept. */
+    m.data.l[XdndFinishedWindow] = hWnd;                                                         /* Target window. */
+    m.data.l[XdndFinishedFlags]  = fDropAccepted ? RT_BIT(0) : 0;                                /* Was the drop accepted? */
+    m.data.l[XdndFinishedAction] = fDropAccepted ? DragInstance::toAtomAction(dndAction) : None; /* Action used on accept. */
 
     int xRc = XSendEvent(pDisp, hWndSource, True, NoEventMask, reinterpret_cast<XEvent*>(&m));
@@ -3111 +3110 @@
                             RTCList<RTCString> lstFormats =
                                 RTCString(pVbglR3Event->u.HG_Enter.pszFormats, pVbglR3Event->u.HG_Enter.cbFormats - 1).split("\r\n");
-                            rc = m_pCurDnD->hgEnter(lstFormats, pVbglR3Event->u.HG_Enter.uAllActions);
+                            rc = m_pCurDnD->hgEnter(lstFormats, pVbglR3Event->u.HG_Enter.dndLstActionsAllowed);
                             if (RT_FAILURE(rc))
                                 break;
@@ -3131 +3130 @@
                     {
                         rc = m_pCurDnD->hgMove(pVbglR3Event->u.HG_Move.uXpos, pVbglR3Event->u.HG_Move.uYpos,
-                                               pVbglR3Event->u.HG_Move.uDefAction);
+                                               pVbglR3Event->u.HG_Move.dndActionDefault);
                         break;
                     }
@@ -3144 +3143 @@
                     {
                         rc = m_pCurDnD->hgDrop(pVbglR3Event->u.HG_Drop.uXpos, pVbglR3Event->u.HG_Drop.uYpos,
-                                               pVbglR3Event->u.HG_Drop.uDefAction);
+                                               pVbglR3Event->u.HG_Drop.dndActionDefault);
                         break;
                     }
@@ -3184 +3183 @@
                     case VBGLR3DNDEVENTTYPE_GH_DROP:
                     {
-                        rc = m_pCurDnD->ghDropped(pVbglR3Event->u.GH_Drop.pszFormat, pVbglR3Event->u.GH_Drop.uAction);
+                        rc = m_pCurDnD->ghDropped(pVbglR3Event->u.GH_Drop.pszFormat, pVbglR3Event->u.GH_Drop.dndActionRequested);
                         break;
                     }

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

@@ -35 +35 @@
 
 #include <VBox/GuestHost/DragAndDrop.h>
+#include <VBox/GuestHost/DragAndDropDefs.h>
 #include <VBox/HostServices/Service.h>
 #include <VBox/HostServices/DragAndDropSvc.h>

trunk/src/VBox/Main/include/GuestDnDPrivate.h

@@ -26 +26 @@
 #include <VBox/hgcmsvc.h> /* For PVBOXHGCMSVCPARM. */
 #include <VBox/GuestHost/DragAndDrop.h>
+#include <VBox/GuestHost/DragAndDropDefs.h>
 #include <VBox/HostServices/DragAndDropSvc.h>
 
@@ -797 +798 @@
      *  Needed to tell the guest if data has to be
      *  deleted e.g. when moving instead of copying. */
-    uint32_t                            mAction;
+    VBOXDNDACTION                       mAction;
     /** Drag'n drop received from the guest.
      *  This can be arbitrary data or an URI list. */
@@ -986 +987 @@
     int waitForGuestResponse(RTMSINTERVAL msTimeout = 500) const;
 
-    void setAllActions(uint32_t a) { m_allActions = a; }
-    uint32_t allActions(void) const { return m_allActions; }
-
-    void setDefAction(uint32_t a) { m_defAction = a; }
-    uint32_t defAction(void) const { return m_defAction; }
+    void setActionsAllowed(VBOXDNDACTIONLIST a) { m_dndLstActionsAllowed = a; }
+    VBOXDNDACTIONLIST getActionsAllowed(void) const { return m_dndLstActionsAllowed; }
+
+    void setActionDefault(VBOXDNDACTION a) { m_dndActionDefault = a; }
+    VBOXDNDACTION getActionDefault(void) const { return m_dndActionDefault; }
 
     void setFormats(const GuestDnDMIMEList &lstFormats) { m_lstFormats = lstFormats; }
@@ -1018 +1019 @@
     /** Default action to perform in case of a
      *  successful drop. */
-    uint32_t              m_defAction;
-    /** Actions supported by the guest in case of
-     *  a successful drop. */
-    uint32_t              m_allActions;
+    VBOXDNDACTION         m_dndActionDefault;
+    /** Actions supported by the guest in case of a successful drop. */
+    VBOXDNDACTIONLIST     m_dndLstActionsAllowed;
     /** Format(s) requested/supported from the guest. */
     GuestDnDMIMEList      m_lstFormats;
@@ -1094 +1094 @@
     static GuestDnDMIMEList         toFilteredFormatList(const GuestDnDMIMEList &lstFormatsSupported, const GuestDnDMIMEList &lstFormatsWanted);
     static GuestDnDMIMEList         toFilteredFormatList(const GuestDnDMIMEList &lstFormatsSupported, const com::Utf8Str &strFormatsWanted);
-    static DnDAction_T              toMainAction(uint32_t uAction);
-    static std::vector<DnDAction_T> toMainActions(uint32_t uActions);
-    static uint32_t                 toHGCMAction(DnDAction_T enmAction);
-    static void                     toHGCMActions(DnDAction_T enmDefAction, uint32_t *puDefAction, const std::vector<DnDAction_T> vecAllowedActions, uint32_t *puAllowedActions);
+    static DnDAction_T              toMainAction(VBOXDNDACTION dndAction);
+    static std::vector<DnDAction_T> toMainActions(VBOXDNDACTIONLIST dndActionList);
+    static VBOXDNDACTION            toHGCMAction(DnDAction_T enmAction);
+    static void                     toHGCMActions(DnDAction_T enmDefAction, VBOXDNDACTION *pDefAction, const std::vector<DnDAction_T> vecAllowedActions, VBOXDNDACTIONLIST *pLstAllowedActions);
     /** @}  */
 

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

@@ -188 +188 @@
 GuestDnDResponse::GuestDnDResponse(const ComObjPtr<Guest>& pGuest)
     : m_EventSem(NIL_RTSEMEVENT)
-    , m_defAction(0)
-    , m_allActions(0)
+    , m_dndActionDefault(0)
+    , m_dndLstActionsAllowed(0)
     , m_pParent(pGuest)
 {
@@ -214 +214 @@
     LogFlowThisFuncEnter();
 
-    m_defAction  = 0;
-    m_allActions = 0;
+    m_dndActionDefault     = 0;
+    m_dndLstActionsAllowed = 0;
 
     m_lstFormats.clear();
@@ -384 +384 @@
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
 
-            setDefAction(pCBData->uAction);
+            setActionDefault(pCBData->uAction);
             rc = notifyAboutGuestResponse();
             break;
@@ -453 +453 @@
             {
                 setFormats   (GuestDnD::toFormatList(pCBData->pszFormat));
-                setDefAction (pCBData->uDefAction);
-                setAllActions(pCBData->uAllActions);
+                setActionDefault (pCBData->uDefAction);
+                setActionsAllowed(pCBData->uAllActions);
 
                 rc = VINF_SUCCESS;
@@ -671 +671 @@
 
 /* static */
-uint32_t GuestDnD::toHGCMAction(DnDAction_T enmAction)
-{
-    uint32_t uAction = VBOX_DND_ACTION_IGNORE;
+VBOXDNDACTION GuestDnD::toHGCMAction(DnDAction_T enmAction)
+{
+    VBOXDNDACTION dndAction = VBOX_DND_ACTION_IGNORE;
     switch (enmAction)
     {
         case DnDAction_Copy:
-            uAction = VBOX_DND_ACTION_COPY;
+            dndAction = VBOX_DND_ACTION_COPY;
             break;
         case DnDAction_Move:
-            uAction = VBOX_DND_ACTION_MOVE;
+            dndAction = VBOX_DND_ACTION_MOVE;
             break;
         case DnDAction_Link:
@@ -693 +693 @@
     }
 
-    return uAction;
+    return dndAction;
 }
 
 /* static */
-void GuestDnD::toHGCMActions(DnDAction_T                    enmDefAction,
-                             uint32_t                      *puDefAction,
-                             const std::vector<DnDAction_T> vecAllowedActions,
-                             uint32_t                      *puAllowedActions)
-{
-    uint32_t uAllowedActions = VBOX_DND_ACTION_IGNORE;
-    uint32_t uDefAction      = toHGCMAction(enmDefAction);
-
-    if (!vecAllowedActions.empty())
+void GuestDnD::toHGCMActions(DnDAction_T                    enmDnDActionDefault,
+                             VBOXDNDACTION                 *pDnDActionDefault,
+                             const std::vector<DnDAction_T> vecDnDActionsAllowed,
+                             VBOXDNDACTIONLIST             *pDnDLstActionsAllowed)
+{
+    VBOXDNDACTIONLIST dndLstActionsAllowed = VBOX_DND_ACTION_IGNORE;
+    VBOXDNDACTION     dndActionDefault     = toHGCMAction(enmDnDActionDefault);
+
+    if (!vecDnDActionsAllowed.empty())
     {
         /* First convert the allowed actions to a bit array. */
-        for (size_t i = 0; i < vecAllowedActions.size(); i++)
-            uAllowedActions |= toHGCMAction(vecAllowedActions[i]);
+        for (size_t i = 0; i < vecDnDActionsAllowed.size(); i++)
+            dndLstActionsAllowed |= toHGCMAction(vecDnDActionsAllowed[i]);
 
         /*
@@ -715 +715 @@
          * set allowed actions, preferring copy, move (in that order).
          */
-        if (isDnDIgnoreAction(uDefAction))
-        {
-            if (hasDnDCopyAction(uAllowedActions))
-                uDefAction = VBOX_DND_ACTION_COPY;
-            else if (hasDnDMoveAction(uAllowedActions))
-                uDefAction = VBOX_DND_ACTION_MOVE;
-        }
-    }
-
-    if (puDefAction)
-        *puDefAction      = uDefAction;
-    if (puAllowedActions)
-        *puAllowedActions = uAllowedActions;
+        if (isDnDIgnoreAction(dndActionDefault))
+        {
+            if (hasDnDCopyAction(dndLstActionsAllowed))
+                dndActionDefault = VBOX_DND_ACTION_COPY;
+            else if (hasDnDMoveAction(dndLstActionsAllowed))
+                dndActionDefault = VBOX_DND_ACTION_MOVE;
+        }
+    }
+
+    if (pDnDActionDefault)
+        *pDnDActionDefault     = dndActionDefault;
+    if (pDnDLstActionsAllowed)
+        *pDnDLstActionsAllowed = dndLstActionsAllowed;
 }
 
 /* static */
-DnDAction_T GuestDnD::toMainAction(uint32_t uAction)
+DnDAction_T GuestDnD::toMainAction(VBOXDNDACTION dndAction)
 {
     /* For now it doesn't seems useful to allow a
      * link action between host & guest. Maybe later! */
-    return isDnDCopyAction(uAction) ? DnDAction_Copy
-         : isDnDMoveAction(uAction) ? DnDAction_Move
-         :                            DnDAction_Ignore;
+    return isDnDCopyAction(dndAction) ? DnDAction_Copy
+         : isDnDMoveAction(dndAction) ? DnDAction_Move
+         :                              DnDAction_Ignore;
 }
 
 /* static */
-std::vector<DnDAction_T> GuestDnD::toMainActions(uint32_t uActions)
+std::vector<DnDAction_T> GuestDnD::toMainActions(VBOXDNDACTIONLIST dndActionList)
 {
     std::vector<DnDAction_T> vecActions;
@@ -748 +748 @@
      * link action between host & guest. Maybe later! */
     RTCList<DnDAction_T> lstActions;
-    if (hasDnDCopyAction(uActions))
+    if (hasDnDCopyAction(dndActionList))
         lstActions.append(DnDAction_Copy);
-    if (hasDnDMoveAction(uActions))
+    if (hasDnDMoveAction(dndActionList))
         lstActions.append(DnDAction_Move);
 

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

@@ -279 +279 @@
 
         if (   fFetchResult
-            && isDnDIgnoreAction(pResp->defAction()))
+            && isDnDIgnoreAction(pResp->getActionDefault()))
             fFetchResult = false;
 
@@ -299 +299 @@
 
                 aFormats            = lstFiltered;
-                aAllowedActions     = GuestDnD::toMainActions(pResp->allActions());
+                aAllowedActions     = GuestDnD::toMainActions(pResp->getActionsAllowed());
                 if (aDefaultAction)
-                    *aDefaultAction = GuestDnD::toMainAction(pResp->defAction());
+                    *aDefaultAction = GuestDnD::toMainAction(pResp->getActionDefault());
 
                 /* Apply the (filtered) formats list. */
@@ -310 +310 @@
         }
 
-        LogFlowFunc(("fFetchResult=%RTbool, allActions=0x%x\n", fFetchResult, pResp->allActions()));
+        LogFlowFunc(("fFetchResult=%RTbool, lstActionsAllowed=0x%x\n", fFetchResult, pResp->getActionsAllowed()));
     }
 
@@ -337 +337 @@
         return setError(E_INVALIDARG, tr("Specified format '%s' is not supported"), aFormat.c_str());
 
-    uint32_t uAction = GuestDnD::toHGCMAction(aAction);
-    if (isDnDIgnoreAction(uAction)) /* If there is no usable action, ignore this request. */
+    VBOXDNDACTION dndAction = GuestDnD::toHGCMAction(aAction);
+    if (isDnDIgnoreAction(dndAction)) /* If there is no usable action, ignore this request. */
         return S_OK;
 

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

@@ -274 +274 @@
     DnDAction_T resAction = DnDAction_Ignore;
 
-    /* Check & convert the drag & drop actions */
-    uint32_t uDefAction      = 0;
-    uint32_t uAllowedActions = 0;
-    GuestDnD::toHGCMActions(aDefaultAction, &uDefAction,
-                            aAllowedActions, &uAllowedActions);
+    /* Check & convert the drag & drop actions. */
+    VBOXDNDACTION     dndActionDefault     = 0;
+    VBOXDNDACTIONLIST dndActionListAllowed = 0;
+    GuestDnD::toHGCMActions(aDefaultAction, &dndActionDefault,
+                            aAllowedActions, &dndActionListAllowed);
+
     /* If there is no usable action, ignore this request. */
-    if (isDnDIgnoreAction(uDefAction))
+    if (isDnDIgnoreAction(dndActionDefault))
         return S_OK;
 
@@ -316 +317 @@
         Msg.setNextUInt32(aX);
         Msg.setNextUInt32(aY);
-        Msg.setNextUInt32(uDefAction);
-        Msg.setNextUInt32(uAllowedActions);
+        Msg.setNextUInt32(dndActionDefault);
+        Msg.setNextUInt32(dndActionListAllowed);
         Msg.setNextPointer((void *)strFormats.c_str(), cbFormats);
         Msg.setNextUInt32(cbFormats);
@@ -326 +327 @@
             GuestDnDResponse *pResp = GuestDnDInst()->response();
             if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
-                resAction = GuestDnD::toMainAction(pResp->defAction());
+                resAction = GuestDnD::toMainAction(pResp->getActionDefault());
         }
     }
@@ -363 +364 @@
 
     /* Check & convert the drag & drop actions. */
-    uint32_t uDefAction      = 0;
-    uint32_t uAllowedActions = 0;
-    GuestDnD::toHGCMActions(aDefaultAction, &uDefAction,
-                            aAllowedActions, &uAllowedActions);
+    VBOXDNDACTION     dndActionDefault     = 0;
+    VBOXDNDACTIONLIST dndActionListAllowed = 0;
+    GuestDnD::toHGCMActions(aDefaultAction, &dndActionDefault,
+                            aAllowedActions, &dndActionListAllowed);
+
     /* If there is no usable action, ignore this request. */
-    if (isDnDIgnoreAction(uDefAction))
+    if (isDnDIgnoreAction(dndActionDefault))
         return S_OK;
 
@@ -393 +395 @@
         Msg.setNextUInt32(aX);
         Msg.setNextUInt32(aY);
-        Msg.setNextUInt32(uDefAction);
-        Msg.setNextUInt32(uAllowedActions);
+        Msg.setNextUInt32(dndActionDefault);
+        Msg.setNextUInt32(dndActionListAllowed);
         Msg.setNextPointer((void *)strFormats.c_str(), cbFormats);
         Msg.setNextUInt32(cbFormats);
@@ -403 +405 @@
             GuestDnDResponse *pResp = GuestDnDInst()->response();
             if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
-                resAction = GuestDnD::toMainAction(pResp->defAction());
+                resAction = GuestDnD::toMainAction(pResp->getActionDefault());
         }
     }
@@ -480 +482 @@
 
     /* Check & convert the drag & drop actions to HGCM codes. */
-    uint32_t uDefAction      = VBOX_DND_ACTION_IGNORE;
-    uint32_t uAllowedActions = 0;
-    GuestDnD::toHGCMActions(aDefaultAction,  &uDefAction,
-                            aAllowedActions, &uAllowedActions);
+    VBOXDNDACTION     dndActionDefault     = VBOX_DND_ACTION_IGNORE;
+    VBOXDNDACTIONLIST dndActionListAllowed = 0;
+    GuestDnD::toHGCMActions(aDefaultAction,  &dndActionDefault,
+                            aAllowedActions, &dndActionListAllowed);
+
     /* If there is no usable action, ignore this request. */
-    if (isDnDIgnoreAction(uDefAction))
+    if (isDnDIgnoreAction(dndActionDefault))
     {
         aFormat = "";
@@ -514 +517 @@
         Msg.setNextUInt32(aX);
         Msg.setNextUInt32(aY);
-        Msg.setNextUInt32(uDefAction);
-        Msg.setNextUInt32(uAllowedActions);
+        Msg.setNextUInt32(dndActionDefault);
+        Msg.setNextUInt32(dndActionListAllowed);
         Msg.setNextPointer((void*)strFormats.c_str(), cbFormats);
         Msg.setNextUInt32(cbFormats);
@@ -528 +531 @@
             if (RT_SUCCESS(vrc))
             {
-                resAction = GuestDnD::toMainAction(pResp->defAction());
+                resAction = GuestDnD::toMainAction(pResp->getActionDefault());
 
                 GuestDnDMIMEList lstFormats = pResp->formats();
@@ -534 +537 @@
                 {
                     aFormat = lstFormats.at(0);
-                    LogFlowFunc(("resFormat=%s, resAction=%RU32\n", aFormat.c_str(), pResp->defAction()));
+                    LogFlowFunc(("resFormat=%s, resAction=%RU32\n", aFormat.c_str(), pResp->getActionDefault()));
                 }
                 else