Changeset 85694 in vbox for trunk/src/VBox/Additions/WINNT/VBoxTray

Timestamp:

Aug 11, 2020 4:30:25 PM (4 years ago)

Author:

vboxsync

Message:

DnD/VBoxTray: Renaming, removed unused functions.

Location:

trunk/src/VBox/Additions/WINNT/VBoxTray

Files:

• VBoxDnD.cpp (modified) (58 diffs)
• VBoxDnD.h (modified) (11 diffs)
• VBoxDnDDataObject.cpp (modified) (23 diffs)
• VBoxDnDDropSource.cpp (modified) (6 diffs)
• VBoxDnDDropTarget.cpp (modified) (26 diffs)
• VBoxDnDEnumFormat.cpp (modified) (8 diffs)

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

@@ -91 +91 @@
 
 VBoxDnDWnd::VBoxDnDWnd(void)
-    : hThread(NIL_RTTHREAD),
-      mEventSem(NIL_RTSEMEVENT),
-      hWnd(NULL),
-      dndLstActionsAllowed(VBOX_DND_ACTION_IGNORE),
-      mfMouseButtonDown(false),
+    : m_hThread(NIL_RTTHREAD),
+      m_EvtSem(NIL_RTSEMEVENT),
+      m_hWnd(NULL),
+      m_lstActionsAllowed(VBOX_DND_ACTION_IGNORE),
+      m_fMouseButtonDown(false),
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
-      pDropTarget(NULL),
+      m_pDropTarget(NULL),
 #endif
-      mMode(Unknown),
-      mState(Uninitialized)
-{
-    RT_ZERO(startupInfo);
+      m_enmMode(Unknown),
+      m_enmState(Uninitialized)
+{
+    RT_ZERO(m_startupInfo);
 
     LogFlowFunc(("Supported formats:\n"));
@@ -109 +109 @@
     {
         LogFlowFunc(("\t%s\n", arrEntries[i].c_str()));
-        this->lstFmtSup.append(arrEntries[i]);
+        this->m_lstFmtSup.append(arrEntries[i]);
     }
 }
@@ -129 +129 @@
 
     /* Save the context. */
-    this->pCtx = a_pCtx;
-
-    int rc = RTSemEventCreate(&mEventSem);
+    this->m_pCtx = a_pCtx;
+
+    int rc = RTSemEventCreate(&m_EvtSem);
     if (RT_SUCCESS(rc))
-        rc = RTCritSectInit(&mCritSect);
+        rc = RTCritSectInit(&m_CritSect);
 
     if (RT_SUCCESS(rc))
     {
         /* Message pump thread for our proxy window. */
-        rc = RTThreadCreate(&hThread, VBoxDnDWnd::Thread, this,
+        rc = RTThreadCreate(&m_hThread, VBoxDnDWnd::Thread, this,
                             0, RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
                             "dndwnd"); /** @todo Include ID if there's more than one proxy window. */
         if (RT_SUCCESS(rc))
         {
-            int rc2 = RTThreadUserWait(hThread, 30 * 1000 /* Timeout in ms */);
+            int rc2 = RTThreadUserWait(m_hThread, 30 * 1000 /* Timeout in ms */);
             AssertRC(rc2);
 
@@ -164 +164 @@
 void VBoxDnDWnd::Destroy(void)
 {
-    if (hThread != NIL_RTTHREAD)
+    if (m_hThread != NIL_RTTHREAD)
     {
         int rcThread = VERR_WRONG_ORDER;
-        int rc = RTThreadWait(hThread, 60 * 1000 /* Timeout in ms */, &rcThread);
+        int rc = RTThreadWait(m_hThread, 60 * 1000 /* Timeout in ms */, &rcThread);
         LogFlowFunc(("Waiting for thread resulted in %Rrc (thread exited with %Rrc)\n",
                      rc, rcThread));
@@ -175 +175 @@
     Reset();
 
-    RTCritSectDelete(&mCritSect);
-    if (mEventSem != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy(mEventSem);
-        mEventSem = NIL_RTSEMEVENT;
-    }
-
-    if (pCtx->wndClass != 0)
-    {
-        UnregisterClass(VBOX_DND_WND_CLASS, pCtx->pEnv->hInstance);
-        pCtx->wndClass = 0;
+    RTCritSectDelete(&m_CritSect);
+    if (m_EvtSem != NIL_RTSEMEVENT)
+    {
+        RTSemEventDestroy(m_EvtSem);
+        m_EvtSem = NIL_RTSEMEVENT;
+    }
+
+    if (m_pCtx->wndClass != 0)
+    {
+        UnregisterClass(VBOX_DND_WND_CLASS, m_pCtx->pEnv->hInstance);
+        m_pCtx->wndClass = 0;
     }
 
@@ -199 +199 @@
  *                                  is using the thread.
  */
-/*static*/ DECLCALLBACK(int) VBoxDnDWnd::Thread(RTTHREAD hThread, void *pvUser)
+/*static*/ DECLCALLBACK(int) VBoxDnDWnd::Thread(RTTHREAD m_hThread, void *pvUser)
 {
     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
@@ -208 +208 @@
     AssertPtr(pThis);
 
-    PVBOXDNDCONTEXT pCtx = pThis->pCtx;
-    AssertPtr(pCtx);
-    AssertPtr(pCtx->pEnv);
+    PVBOXDNDCONTEXT m_pCtx = pThis->m_pCtx;
+    AssertPtr(m_pCtx);
+    AssertPtr(m_pCtx->pEnv);
 
     int rc = VINF_SUCCESS;
 
-    AssertPtr(pCtx->pEnv);
-    HINSTANCE hInstance = pCtx->pEnv->hInstance;
+    AssertPtr(m_pCtx->pEnv);
+    HINSTANCE hInstance = m_pCtx->pEnv->hInstance;
     Assert(hInstance != 0);
 
@@ -250 +250 @@
         dwStyle |= WS_VISIBLE; /* Make the window visible. */
 #endif
-        pThis->hWnd = CreateWindowEx(dwExStyle,
+        pThis->m_hWnd = CreateWindowEx(dwExStyle,
                                      VBOX_DND_WND_CLASS, VBOX_DND_WND_CLASS,
                                      dwStyle,
@@ -259 +259 @@
 #endif
                                      hInstance, pThis /* lParm */);
-        if (!pThis->hWnd)
+        if (!pThis->m_hWnd)
         {
             DWORD dwErr = GetLastError();
@@ -268 +268 @@
         {
 #ifndef VBOX_DND_DEBUG_WND
-            SetWindowPos(pThis->hWnd, HWND_TOPMOST, -200, -200, 0, 0,
+            SetWindowPos(pThis->m_hWnd, HWND_TOPMOST, -200, -200, 0, 0,
                            SWP_NOACTIVATE | SWP_HIDEWINDOW
                          | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE);
-            LogFlowFunc(("Proxy window created, hWnd=0x%x\n", pThis->hWnd));
+            LogFlowFunc(("Proxy window created, hWnd=0x%x\n", pThis->m_hWnd));
 #else
-            LogFlowFunc(("Debug proxy window created, hWnd=0x%x\n", pThis->hWnd));
+            LogFlowFunc(("Debug proxy window created, hWnd=0x%x\n", pThis->m_hWnd));
 
             /*
@@ -282 +282 @@
             me.cbSize    = sizeof(TRACKMOUSEEVENT);
             me.dwFlags   = TME_HOVER | TME_LEAVE | TME_NONCLIENT;
-            me.hwndTrack = pThis->hWnd;
+            me.hwndTrack = pThis->m_hWnd;
             BOOL fRc = TrackMouseEvent(&me);
             Assert(fRc);
@@ -303 +303 @@
 
     if (RT_SUCCESS(rc))
-        pCtx->fStarted = true; /* Set started indicator on success. */
-
-    int rc2 = RTThreadUserSignal(hThread);
+        m_pCtx->fStarted = true; /* Set started indicator on success. */
+
+    int rc2 = RTThreadUserSignal(m_hThread);
     bool fSignalled = RT_SUCCESS(rc2);
 
@@ -322 +322 @@
             Assert(fRet >= 0);
 
-            if (ASMAtomicReadBool(&pCtx->fShutdown))
+            if (ASMAtomicReadBool(&m_pCtx->fShutdown))
                 fShutdown = true;
 
@@ -344 +344 @@
     if (!fSignalled)
     {
-        rc2 = RTThreadUserSignal(hThread);
+        rc2 = RTThreadUserSignal(m_hThread);
         AssertRC(rc2);
     }
@@ -425 +425 @@
         {
             LogFlowThisFunc(("WM_LBUTTONDOWN\n"));
-            mfMouseButtonDown = true;
+            m_fMouseButtonDown = true;
             return 0;
         }
@@ -432 +432 @@
         {
             LogFlowThisFunc(("WM_LBUTTONUP\n"));
-            mfMouseButtonDown = false;
+            m_fMouseButtonDown = false;
 
             /* As the mouse button was released, Hide the proxy window again.
@@ -454 +454 @@
         {
             LogFlowThisFunc(("WM_MOUSEMOVE: mfMouseButtonDown=%RTbool, mMode=%ld, mState=%ld\n",
-                             mfMouseButtonDown, mMode, mState));
+                             m_fMouseButtonDown, m_enmMode, m_enmState));
 #ifdef DEBUG_andy
             POINT p;
@@ -461 +461 @@
 #endif
             int rc = VINF_SUCCESS;
-            if (mMode == HG) /* Host to guest. */
+            if (m_enmMode == HG) /* Host to guest. */
             {
                 /* Dragging not started yet? Kick it off ... */
-                if (   mfMouseButtonDown
-                    && (mState != Dragging))
+                if (   m_fMouseButtonDown
+                    && (m_enmState != Dragging))
                 {
-                    mState = Dragging;
+                    m_enmState = Dragging;
 #if 0
                     /* Delay hiding the proxy window a bit when debugging, to see
@@ -476 +476 @@
 
                     LogFlowThisFunc(("Starting drag and drop: dndLstActionsAllowed=0x%x, dwOKEffects=0x%x ...\n",
-                                     dndLstActionsAllowed, startupInfo.dwOKEffects));
-
-                    AssertPtr(startupInfo.pDataObject);
-                    AssertPtr(startupInfo.pDropSource);
+                                     m_lstActionsAllowed, m_startupInfo.dwOKEffects));
+
+                    AssertPtr(m_startupInfo.pDataObject);
+                    AssertPtr(m_startupInfo.pDropSource);
                     DWORD dwEffect;
-                    HRESULT hr = DoDragDrop(startupInfo.pDataObject, startupInfo.pDropSource,
-                                            startupInfo.dwOKEffects, &dwEffect);
+                    HRESULT hr = DoDragDrop(m_startupInfo.pDataObject, m_startupInfo.pDropSource,
+                                            m_startupInfo.dwOKEffects, &dwEffect);
                     LogFlowThisFunc(("hr=%Rhrc, dwEffect=%RI32\n", hr, dwEffect));
                     switch (hr)
                     {
                         case DRAGDROP_S_DROP:
-                            mState = Dropped;
+                            m_enmState = Dropped;
                             break;
 
                         case DRAGDROP_S_CANCEL:
-                            mState = Canceled;
+                            m_enmState = Canceled;
                             break;
 
                         default:
                             LogFlowThisFunc(("Drag and drop failed with %Rhrc\n", hr));
-                            mState = Canceled;
+                            m_enmState = Canceled;
                             rc = VERR_GENERAL_FAILURE; /** @todo Find a better status code. */
                             break;
                     }
 
-                    int rc2 = RTCritSectEnter(&mCritSect);
+                    int rc2 = RTCritSectEnter(&m_CritSect);
                     if (RT_SUCCESS(rc2))
                     {
-                        startupInfo.pDropSource->Release();
-                        startupInfo.pDataObject->Release();
-
-                        RT_ZERO(startupInfo);
-
-                        rc2 = RTCritSectLeave(&mCritSect);
+                        m_startupInfo.pDropSource->Release();
+                        m_startupInfo.pDataObject->Release();
+
+                        RT_ZERO(m_startupInfo);
+
+                        rc2 = RTCritSectLeave(&m_CritSect);
                         if (RT_SUCCESS(rc))
                             rc = rc2;
                     }
 
-                    mMode = Unknown;
+                    m_enmMode = Unknown;
                 }
             }
-            else if (mMode == GH) /* Guest to host. */
+            else if (m_enmMode == GH) /* Guest to host. */
             {
                 /* Starting here VBoxDnDDropTarget should
@@ -527 +527 @@
 
             LogFlowThisFunc(("WM_MOUSEMOVE: mMode=%ld, mState=%ld, rc=%Rrc\n",
-                             mMode, mState, rc));
+                             m_enmMode, m_enmState, rc));
             return 0;
         }
@@ -674 +674 @@
 int VBoxDnDWnd::RegisterAsDropTarget(void)
 {
-    if (pDropTarget) /* Already registered as drop target? */
+    if (m_pDropTarget) /* Already registered as drop target? */
         return VINF_SUCCESS;
 
@@ -680 +680 @@
     try
     {
-        pDropTarget = new VBoxDnDDropTarget(this /* pParent */);
-        HRESULT hr = CoLockObjectExternal(pDropTarget, TRUE /* fLock */,
+        m_pDropTarget = new VBoxDnDDropTarget(this /* pParent */);
+        HRESULT hr = CoLockObjectExternal(m_pDropTarget, TRUE /* fLock */,
                                           FALSE /* fLastUnlockReleases */);
         if (SUCCEEDED(hr))
-            hr = RegisterDragDrop(hWnd, pDropTarget);
+            hr = RegisterDragDrop(m_hWnd, m_pDropTarget);
 
         if (FAILED(hr))
@@ -715 +715 @@
     LogFlowFuncEnter();
 
-    if (!pDropTarget) /* No drop target? Bail out. */
+    if (!m_pDropTarget) /* No drop target? Bail out. */
         return VINF_SUCCESS;
 
-    HRESULT hr = RevokeDragDrop(hWnd);
+    HRESULT hr = RevokeDragDrop(m_hWnd);
     if (SUCCEEDED(hr))
-        hr = CoLockObjectExternal(pDropTarget, FALSE /* fLock */,
+        hr = CoLockObjectExternal(m_pDropTarget, FALSE /* fLock */,
                                   TRUE /* fLastUnlockReleases */);
     if (SUCCEEDED(hr))
     {
-        ULONG cRefs = pDropTarget->Release();
+        ULONG cRefs = m_pDropTarget->Release();
         Assert(cRefs == 0); NOREF(cRefs);
-        pDropTarget = NULL;
+        m_pDropTarget = NULL;
     }
 
@@ -745 +745 @@
 {
     LogFlowFuncEnter();
-    int rc = VbglR3DnDConnect(&mDnDCtx);
+    int rc = VbglR3DnDConnect(&m_cmdCtx);
     if (RT_FAILURE(rc))
     {
@@ -752 +752 @@
     }
 
-    LogFlowThisFunc(("Client ID=%RU32, rc=%Rrc\n", mDnDCtx.uClientID, rc));
+    LogFlowThisFunc(("Client ID=%RU32, rc=%Rrc\n", m_cmdCtx.uClientID, rc));
     return rc;
 }
@@ -761 +761 @@
 void VBoxDnDWnd::OnDestroy(void)
 {
-    DestroyWindow(hWnd);
-
-    VbglR3DnDDisconnect(&mDnDCtx);
+    DestroyWindow(m_hWnd);
+
+    VbglR3DnDDisconnect(&m_cmdCtx);
     LogFlowThisFuncLeave();
 }
@@ -774 +774 @@
 int VBoxDnDWnd::Abort(void)
 {
-    LogFlowThisFunc(("mMode=%ld, mState=%RU32\n", mMode, mState));
+    LogFlowThisFunc(("mMode=%ld, mState=%RU32\n", m_enmMode, m_enmState));
     LogRel(("DnD: Drag and drop operation aborted\n"));
 
-    int rc = RTCritSectEnter(&mCritSect);
+    int rc = RTCritSectEnter(&m_CritSect);
     if (RT_SUCCESS(rc))
     {
-        if (startupInfo.pDataObject)
-            startupInfo.pDataObject->Abort();
-
-        RTCritSectLeave(&mCritSect);
+        if (m_startupInfo.pDataObject)
+            m_startupInfo.pDataObject->Abort();
+
+        RTCritSectLeave(&m_CritSect);
     }
 
@@ -805 +805 @@
 int VBoxDnDWnd::OnHgEnter(const RTCList<RTCString> &a_lstFormats, VBOXDNDACTIONLIST a_fDndLstActionsAllowed)
 {
-    if (mMode == GH) /* Wrong mode? Bail out. */
+    if (m_enmMode == GH) /* Wrong mode? Bail out. */
         return VERR_WRONG_ORDER;
 
@@ -826 +826 @@
     {
         /* Save all allowed actions. */
-        this->dndLstActionsAllowed = a_fDndLstActionsAllowed;
+        this->m_lstActionsAllowed = a_fDndLstActionsAllowed;
 
         /*
          * Check if reported formats from host are compatible with this client.
          */
-        size_t cFormatsSup    = this->lstFmtSup.size();
+        size_t cFormatsSup    = this->m_lstFmtSup.size();
         ULONG  cFormatsActive = 0;
 
@@ -844 +844 @@
         {
             bool fSupported = false;
-            for (size_t a = 0; a < this->lstFmtSup.size(); a++)
+            for (size_t a = 0; a < this->m_lstFmtSup.size(); a++)
             {
                 const char *pszFormat = a_lstFormats.at(i).c_str();
-                LogFlowThisFunc(("\t\"%s\" <=> \"%s\"\n", this->lstFmtSup.at(a).c_str(), pszFormat));
-
-                fSupported = RTStrICmp(this->lstFmtSup.at(a).c_str(), pszFormat) == 0;
+                LogFlowThisFunc(("\t\"%s\" <=> \"%s\"\n", this->m_lstFmtSup.at(a).c_str(), pszFormat));
+
+                fSupported = RTStrICmp(this->m_lstFmtSup.at(a).c_str(), pszFormat) == 0;
                 if (fSupported)
                 {
-                    this->lstFmtActive.append(a_lstFormats.at(i));
+                    this->m_lstFmtActive.append(a_lstFormats.at(i));
 
                     /** @todo Put this into a \#define / struct. */
@@ -900 +900 @@
             LogRel2(("DnD: %RU32 supported formats found:\n", cFormatsActive));
             for (size_t i = 0; i < cFormatsActive; i++)
-                LogRel2(("DnD: \t%s\n", this->lstFmtActive.at(i).c_str()));
+                LogRel2(("DnD: \t%s\n", this->m_lstFmtActive.at(i).c_str()));
         }
         else
@@ -910 +910 @@
 
         /* Translate our drop actions into allowed Windows drop effects. */
-        startupInfo.dwOKEffects = DROPEFFECT_NONE;
+        m_startupInfo.dwOKEffects = DROPEFFECT_NONE;
         if (a_fDndLstActionsAllowed)
         {
             if (a_fDndLstActionsAllowed & VBOX_DND_ACTION_COPY)
-                startupInfo.dwOKEffects |= DROPEFFECT_COPY;
+                m_startupInfo.dwOKEffects |= DROPEFFECT_COPY;
             if (a_fDndLstActionsAllowed & VBOX_DND_ACTION_MOVE)
-                startupInfo.dwOKEffects |= DROPEFFECT_MOVE;
+                m_startupInfo.dwOKEffects |= DROPEFFECT_MOVE;
             if (a_fDndLstActionsAllowed & VBOX_DND_ACTION_LINK)
-                startupInfo.dwOKEffects |= DROPEFFECT_LINK;
-        }
-
-        LogRel2(("DnD: Supported drop actions: 0x%x\n", startupInfo.dwOKEffects));
-
-        startupInfo.pDropSource = new VBoxDnDDropSource(this);
-        startupInfo.pDataObject = new VBoxDnDDataObject(pFormatEtc, pStgMeds, cFormatsActive);
+                m_startupInfo.dwOKEffects |= DROPEFFECT_LINK;
+        }
+
+        LogRel2(("DnD: Supported drop actions: 0x%x\n", m_startupInfo.dwOKEffects));
+
+        m_startupInfo.pDropSource = new VBoxDnDDropSource(this);
+        m_startupInfo.pDataObject = new VBoxDnDDataObject(pFormatEtc, pStgMeds, cFormatsActive);
 
         if (pFormatEtc)
@@ -961 +961 @@
 
     uint32_t uActionNotify = VBOX_DND_ACTION_IGNORE;
-    if (mMode == HG)
+    if (m_enmMode == HG)
     {
         LogFlowThisFunc(("u32xPos=%RU32, u32yPos=%RU32, dndAction=0x%x\n",
@@ -969 +969 @@
 
         if (RT_SUCCESS(rc))
-            rc = RTCritSectEnter(&mCritSect);
+            rc = RTCritSectEnter(&m_CritSect);
         if (RT_SUCCESS(rc))
         {
-            if (   (Dragging == mState)
-                && startupInfo.pDropSource)
-                uActionNotify = startupInfo.pDropSource->GetCurrentAction();
-
-            RTCritSectLeave(&mCritSect);
+            if (   (Dragging == m_enmState)
+                && m_startupInfo.pDropSource)
+                uActionNotify = m_startupInfo.pDropSource->GetCurrentAction();
+
+            RTCritSectLeave(&m_CritSect);
         }
     }
@@ -984 +984 @@
     if (RT_SUCCESS(rc))
     {
-        rc = VbglR3DnDHGSendAckOp(&mDnDCtx, uActionNotify);
+        rc = VbglR3DnDHGSendAckOp(&m_cmdCtx, uActionNotify);
         if (RT_FAILURE(rc))
             LogFlowThisFunc(("Acknowledging operation failed with rc=%Rrc\n", rc));
@@ -1001 +1001 @@
 int VBoxDnDWnd::OnHgLeave(void)
 {
-    if (mMode == GH) /* Wrong mode? Bail out. */
+    if (m_enmMode == GH) /* Wrong mode? Bail out. */
         return VERR_WRONG_ORDER;
 
@@ -1018 +1018 @@
 int VBoxDnDWnd::OnHgDrop(void)
 {
-    if (mMode == GH)
+    if (m_enmMode == GH)
         return VERR_WRONG_ORDER;
 
-    LogFlowThisFunc(("mMode=%ld, mState=%RU32\n", mMode, mState));
+    LogFlowThisFunc(("mMode=%ld, mState=%RU32\n", m_enmMode, m_enmState));
 
     int rc = VINF_SUCCESS;
-    if (mState == Dragging)
-    {
-        if (lstFmtActive.size() >= 1)
+    if (m_enmState == Dragging)
+    {
+        if (m_lstFmtActive.size() >= 1)
         {
             /** @todo What to do when multiple formats are available? */
-            mFormatRequested = lstFmtActive.at(0);
-
-            rc = RTCritSectEnter(&mCritSect);
+            m_strFmtReq = m_lstFmtActive.at(0);
+
+            rc = RTCritSectEnter(&m_CritSect);
             if (RT_SUCCESS(rc))
             {
-                if (startupInfo.pDataObject)
-                    startupInfo.pDataObject->SetStatus(VBoxDnDDataObject::Dropping);
+                if (m_startupInfo.pDataObject)
+                    m_startupInfo.pDataObject->SetStatus(VBoxDnDDataObject::Status_Dropping);
                 else
                     rc = VERR_NOT_FOUND;
 
-                RTCritSectLeave(&mCritSect);
+                RTCritSectLeave(&m_CritSect);
             }
 
             if (RT_SUCCESS(rc))
             {
-                LogRel(("DnD: Requesting data as '%s' ...\n", mFormatRequested.c_str()));
-                rc = VbglR3DnDHGSendReqData(&mDnDCtx, mFormatRequested.c_str());
+                LogRel(("DnD: Requesting data as '%s' ...\n", m_strFmtReq.c_str()));
+                rc = VbglR3DnDHGSendReqData(&m_cmdCtx, m_strFmtReq.c_str());
                 if (RT_FAILURE(rc))
                     LogFlowThisFunc(("Requesting data failed with rc=%Rrc\n", rc));
@@ -1068 +1068 @@
 int VBoxDnDWnd::OnHgDataReceive(PVBGLR3GUESTDNDMETADATA pMeta)
 {
-    LogFlowThisFunc(("mState=%ld, enmMetaType=%RU32\n", mState, pMeta->enmType));
-
-    int rc = RTCritSectEnter(&mCritSect);
+    LogFlowThisFunc(("mState=%ld, enmMetaType=%RU32\n", m_enmState, pMeta->enmType));
+
+    int rc = RTCritSectEnter(&m_CritSect);
     if (RT_SUCCESS(rc))
     {
-        mState = Dropped;
-
-        if (startupInfo.pDataObject)
+        m_enmState = Dropped;
+
+        if (m_startupInfo.pDataObject)
         {
             switch (pMeta->enmType)
@@ -1084 +1084 @@
                     AssertBreakStmt(pMeta->u.Raw.cbMeta, rc = VERR_INVALID_PARAMETER);
 
-                    rc = startupInfo.pDataObject->Signal(mFormatRequested, pMeta->u.Raw.pvMeta, pMeta->u.Raw.cbMeta);
+                    rc = m_startupInfo.pDataObject->Signal(m_strFmtReq, pMeta->u.Raw.pvMeta, pMeta->u.Raw.cbMeta);
                     break;
                 }
@@ -1100 +1100 @@
                     if (RT_SUCCESS(rc))
                     {
-                        rc = startupInfo.pDataObject->Signal(mFormatRequested, pszBuf, cbBuf);
+                        rc = m_startupInfo.pDataObject->Signal(m_strFmtReq, pszBuf, cbBuf);
                         RTStrFree(pszBuf);
                     }
@@ -1118 +1118 @@
             rc = rc2;
 
-        RTCritSectLeave(&mCritSect);
+        RTCritSectLeave(&m_CritSect);
     }
 
@@ -1160 +1160 @@
 int VBoxDnDWnd::OnGhIsDnDPending(void)
 {
-    LogFlowThisFunc(("mMode=%ld, mState=%ld\n", mMode, mState));
-
-    if (mMode == Unknown)
+    LogFlowThisFunc(("mMode=%ld, mState=%ld\n", m_enmMode, m_enmState));
+
+    if (m_enmMode == Unknown)
         setMode(GH);
 
-    if (mMode != GH)
+    if (m_enmMode != GH)
         return VERR_WRONG_ORDER;
 
-    if (mState == Uninitialized)
+    if (m_enmState == Uninitialized)
     {
         /* Nothing to do here yet. */
-        mState = Initialized;
+        m_enmState = Initialized;
     }
 
     int rc;
-    if (mState == Initialized)
+    if (m_enmState == Initialized)
     {
         /* Check if the VM session has changed and reconnect to the HGCM service if necessary. */
@@ -1195 +1195 @@
                  * own drop target (for the host).
                  */
-                mState = Dragging;
+                m_enmState = Dragging;
             }
         }
@@ -1213 +1213 @@
 
     if (   RT_SUCCESS(rc)
-        && mState == Dragging)
+        && m_enmState == Dragging)
     {
         /** @todo Put this block into a function! */
         POINT p;
         GetCursorPos(&p);
-        ClientToScreen(hWnd, &p);
+        ClientToScreen(m_hWnd, &p);
 #ifdef DEBUG_andy
         LogFlowThisFunc(("Client to screen curX=%ld, curY=%ld\n", p.x, p.y));
@@ -1243 +1243 @@
         VBOXDNDACTION dndActionDefault = VBOX_DND_ACTION_IGNORE;
 
-        AssertPtr(pDropTarget);
-        RTCString strFormats = pDropTarget->Formats();
+        AssertPtr(m_pDropTarget);
+        RTCString strFormats = m_pDropTarget->Formats();
         if (!strFormats.isEmpty())
         {
@@ -1250 +1250 @@
 
             LogFlowFunc(("Acknowledging pDropTarget=0x%p, dndActionDefault=0x%x, dndLstActionsAllowed=0x%x, strFormats=%s\n",
-                         pDropTarget, dndActionDefault, dndLstActionsAllowed, strFormats.c_str()));
+                         m_pDropTarget, dndActionDefault, m_lstActionsAllowed, strFormats.c_str()));
         }
         else
@@ -1259 +1259 @@
 
         /** @todo Support more than one action at a time. */
-        dndLstActionsAllowed = dndActionDefault;
-
-        int rc2 = VbglR3DnDGHSendAckPending(&mDnDCtx,
-                                            dndActionDefault, dndLstActionsAllowed,
+        m_lstActionsAllowed = dndActionDefault;
+
+        int rc2 = VbglR3DnDGHSendAckPending(&m_cmdCtx,
+                                            dndActionDefault, m_lstActionsAllowed,
                                             strFormats.c_str(), (uint32_t)strFormats.length() + 1 /* Include termination */);
         if (RT_FAILURE(rc2))
@@ -1316 +1316 @@
 
     LogFlowThisFunc(("mMode=%ld, mState=%ld, pDropTarget=0x%p, strFormat=%s, dndActionDefault=0x%x\n",
-                     mMode, mState, pDropTarget, strFormat.c_str(), dndActionDefault));
+                     m_enmMode, m_enmState, m_pDropTarget, strFormat.c_str(), dndActionDefault));
     int rc;
-    if (mMode == GH)
-    {
-        if (mState == Dragging)
-        {
-            AssertPtr(pDropTarget);
-            rc = pDropTarget->WaitForDrop(5 * 1000 /* 5s timeout */);
+    if (m_enmMode == GH)
+    {
+        if (m_enmState == Dragging)
+        {
+            AssertPtr(m_pDropTarget);
+            rc = m_pDropTarget->WaitForDrop(5 * 1000 /* 5s timeout */);
 
             Reset();
         }
-        else if (mState == Dropped)
+        else if (m_enmState == Dropped)
         {
             rc = VINF_SUCCESS;
@@ -1337 +1337 @@
         {
             /** @todo Respect uDefAction. */
-            void *pvData    = pDropTarget->DataMutableRaw();
-            uint32_t cbData = (uint32_t)pDropTarget->DataSize();
-            Assert(cbData == pDropTarget->DataSize());
+            void *pvData    = m_pDropTarget->DataMutableRaw();
+            uint32_t cbData = (uint32_t)m_pDropTarget->DataSize();
+            Assert(cbData == m_pDropTarget->DataSize());
 
             if (   pvData
                 && cbData)
             {
-                rc = VbglR3DnDGHSendData(&mDnDCtx, strFormat.c_str(), pvData, cbData);
+                rc = VbglR3DnDGHSendData(&m_cmdCtx, strFormat.c_str(), pvData, cbData);
                 LogFlowFunc(("Sent pvData=0x%p, cbData=%RU32, rc=%Rrc\n", pvData, cbData, rc));
             }
@@ -1361 +1361 @@
          * not wait for the data it expects from the guest.
          */
-        int rc2 = VbglR3DnDGHSendError(&mDnDCtx, rc);
+        int rc2 = VbglR3DnDGHSendError(&m_cmdCtx, rc);
         AssertRC(rc2);
     }
@@ -1373 +1373 @@
 {
     LogFlowFunc(("Posting message %u\n"));
-    BOOL fRc = ::PostMessage(hWnd, uMsg, wParam, lParam);
+    BOOL fRc = ::PostMessage(m_hWnd, uMsg, wParam, lParam);
     Assert(fRc); NOREF(fRc);
 }
@@ -1389 +1389 @@
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
 
-    BOOL fRc = ::PostMessage(hWnd, WM_VBOXTRAY_DND_MESSAGE,
+    BOOL fRc = ::PostMessage(m_hWnd, WM_VBOXTRAY_DND_MESSAGE,
                              0 /* wParm */, (LPARAM)pEvent /* lParm */);
     if (!fRc)
@@ -1424 +1424 @@
     int rc = VbglR3GetSessionId(&uSessionID);
     if (   RT_SUCCESS(rc)
-        && uSessionID != mDnDCtx.uSessionID)
+        && uSessionID != m_cmdCtx.uSessionID)
     {
         LogFlowThisFunc(("VM session has changed to %RU64\n", uSessionID));
 
-        rc = VbglR3DnDDisconnect(&mDnDCtx);
+        rc = VbglR3DnDDisconnect(&m_cmdCtx);
         AssertRC(rc);
 
-        rc = VbglR3DnDConnect(&mDnDCtx);
+        rc = VbglR3DnDConnect(&m_cmdCtx);
         AssertRC(rc);
     }
@@ -1449 +1449 @@
     LogFlowFunc(("\n"));
 #endif
-    ShowWindow(hWnd, SW_HIDE);
+    ShowWindow(m_hWnd, SW_HIDE);
 
     return VINF_SUCCESS;
@@ -1496 +1496 @@
     if (RT_SUCCESS(rc))
     {
-        LONG lStyle = GetWindowLong(hWnd, GWL_STYLE);
-        SetWindowLong(hWnd, GWL_STYLE,
+        LONG lStyle = GetWindowLong(m_hWnd, GWL_STYLE);
+        SetWindowLong(m_hWnd, GWL_STYLE,
                       lStyle & ~(WS_CAPTION | WS_THICKFRAME));
-        LONG lExStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
-        SetWindowLong(hWnd, GWL_EXSTYLE,
+        LONG lExStyle = GetWindowLong(m_hWnd, GWL_EXSTYLE);
+        SetWindowLong(m_hWnd, GWL_EXSTYLE,
                       lExStyle & ~(  WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE
                                    | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
 
-        fRc = SetWindowPos(hWnd, HWND_TOPMOST,
+        fRc = SetWindowPos(m_hWnd, HWND_TOPMOST,
                            r.left,
                            r.top,
@@ -1614 +1614 @@
 {
     LogFlowThisFunc(("Resetting, old mMode=%ld, mState=%ld\n",
-                     mMode, mState));
+                     m_enmMode, m_enmState));
 
     /*
@@ -1622 +1622 @@
      */
 
-    this->lstFmtActive.clear();
-    this->dndLstActionsAllowed = VBOX_DND_ACTION_IGNORE;
+    this->m_lstFmtActive.clear();
+    this->m_lstActionsAllowed = VBOX_DND_ACTION_IGNORE;
 
     int rc2 = setMode(Unknown);
@@ -1640 +1640 @@
 {
     LogFlowThisFunc(("Old mode=%ld, new mode=%ld\n",
-                     mMode, enmMode));
-
-    mMode = enmMode;
-    mState = Initialized;
+                     m_enmMode, enmMode));
+
+    m_enmMode = enmMode;
+    m_enmState = Initialized;
 
     return VINF_SUCCESS;

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

@@ -38 +38 @@
     enum Status
     {
-        Uninitialized = 0,
-        Initialized,
-        Dropping,
-        Dropped,
-        Aborted
+        Status_Uninitialized = 0,
+        Status_Initialized,
+        Status_Dropping,
+        Status_Dropped,
+        Status_Aborted,
+        Status_32Bit_Hack = 0x7fffffff
     };
 
@@ -79 +80 @@
 
     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);
 
     /** Current drag and drop status. */
-    Status      mStatus;
+    Status      m_enmStatus;
     /** Internal reference count of this object. */
-    LONG        mRefCount;
+    LONG        m_cRefs;
     /** Number of native formats registered. This can be a different number than supplied with m_lstFormats. */
-    ULONG       mcFormats;
+    ULONG       m_cFormats;
     /** Array of registered FORMATETC structs. Matches m_cFormats. */
-    LPFORMATETC mpFormatEtc;
+    LPFORMATETC m_paFormatEtc;
     /** Array of registered STGMEDIUM structs. Matches m_cFormats. */
-    LPSTGMEDIUM mpStgMedium;
+    LPSTGMEDIUM m_paStgMedium;
     /** Event semaphore used for waiting on status changes. */
-    RTSEMEVENT  mEventDropped;
+    RTSEMEVENT  m_EvtDropped;
     /** Format of currently retrieved data. */
-    RTCString   mstrFormat;
+    RTCString   m_strFormat;
     /** The retrieved data as a raw buffer. */
-    void       *mpvData;
+    void       *m_pvData;
     /** Raw buffer size (in bytes). */
-    size_t      mcbData;
+    size_t      m_cbData;
 };
 
@@ -115 +115 @@
 public:
 
-    VBOXDNDACTION GetCurrentAction(void) { return mDnDActionCurrent; }
+    VBOXDNDACTION GetCurrentAction(void) { return m_enmActionCurrent; }
 
 public: /* IUnknown methods. */
@@ -131 +131 @@
 
     /** Reference count of this object. */
-    LONG                  mRefCount;
+    LONG                  m_cRefs;
     /** Pointer to parent proxy window. */
-    VBoxDnDWnd           *mpWndParent;
+    VBoxDnDWnd           *m_pWndParent;
     /** Current drag effect. */
-    DWORD                 mdwCurEffect;
+    DWORD                 m_dwCurEffect;
     /** Current action to perform on the host. */
-    VBOXDNDACTION         mDnDActionCurrent;
+    VBOXDNDACTION         m_enmActionCurrent;
 };
 
@@ -172 +172 @@
 
     /** Returns the data as mutable raw. Use with caution! */
-    void *DataMutableRaw(void) const { return mpvData; }
+    void *DataMutableRaw(void) const { return m_pvData; }
 
     /** Returns the data size (in bytes). */
-    size_t DataSize(void) const { return mcbData; }
+    size_t DataSize(void) const { return m_cbData; }
 
     RTCString Formats(void) const;
@@ -183 +183 @@
 
     /** Reference count of this object. */
-    LONG                  mRefCount;
+    LONG                  m_cRefs;
     /** Pointer to parent proxy window. */
-    VBoxDnDWnd           *mpWndParent;
+    VBoxDnDWnd           *m_pWndParent;
     /** Current drop effect. */
-    DWORD                 mdwCurEffect;
+    DWORD                 m_dwCurEffect;
     /** Copy of the data object's current FORMATETC struct.
      *  Note: We don't keep the pointer of the DVTARGETDEVICE here! */
-    FORMATETC             mFormatEtc;
-    /** Stringified data object's formats string.  */
-    RTCString             mstrFormats;
+    FORMATETC             m_FormatEtc;
+    /** Stringified data object's format currently in use.  */
+    RTCString             m_strFormat;
     /** Pointer to actual format data. */
-    void                 *mpvData;
+    void                 *m_pvData;
     /** Size (in bytes) of format data. */
-    size_t                mcbData;
+    size_t                m_cbData;
     /** Event for waiting on the "drop" event. */
-    RTSEMEVENT            hEventDrop;
+    RTSEMEVENT            m_EvtDrop;
     /** Result of the drop event. */
-    int                   mDroppedRc;
+    int                   m_rcDropped;
 };
 
@@ -232 +232 @@
 
     /** Reference count of this object. */
-    LONG        m_lRefCount;
+    LONG        m_cRefs;
     /** Current index for format iteration. */
-    ULONG       m_nIndex;
+    ULONG       m_uIdxCur;
     /** Number of format this object contains. */
-    ULONG       m_nNumFormats;
-    /** Array of FORMATETC formats this object contains. Matches m_nNumFormats. */
-    LPFORMATETC m_pFormatEtc;
+    ULONG       m_cFormats;
+    /** Array of FORMATETC formats this object contains. Matches m_cFormats. */
+    LPFORMATETC m_paFormatEtc;
 };
 
@@ -343 +343 @@
 
     /** The window's thread for the native message pump and OLE context. */
-    static DECLCALLBACK(int) Thread(RTTHREAD hThread, void *pvUser);
+    static DECLCALLBACK(int) Thread(RTTHREAD m_hThread, void *pvUser);
 
 public:
@@ -366 +366 @@
 
     /* Host -> Guest */
-    int OnHgEnter(const RTCList<RTCString> &formats, VBOXDNDACTIONLIST dndLstActionsAllowed);
+    int OnHgEnter(const RTCList<RTCString> &formats, VBOXDNDACTIONLIST m_lstActionsAllowed);
     int OnHgMove(uint32_t u32xPos, uint32_t u32yPos, VBOXDNDACTION dndAction);
     int OnHgDrop(void);
@@ -396 +396 @@
 
     /** Pointer to DnD context. */
-    PVBOXDNDCONTEXT            pCtx;
+    PVBOXDNDCONTEXT            m_pCtx;
     /** The proxy window's main thread for processing
      *  window messages. */
-    RTTHREAD                   hThread;
+    RTTHREAD                   m_hThread;
     /** Critical section to serialize access. */
-    RTCRITSECT                 mCritSect;
+    RTCRITSECT                 m_CritSect;
     /** Event semaphore to wait for new DnD events. */
-    RTSEMEVENT                 mEventSem;
+    RTSEMEVENT                 m_EvtSem;
 #ifdef RT_OS_WINDOWS
     /** The window's handle. */
-    HWND                       hWnd;
+    HWND                       m_hWnd;
     /** List of allowed MIME types this
      *  client can handle. Make this a per-instance
      *  property so that we can selectively allow/forbid
      *  certain types later on runtime. */
-    RTCList<RTCString>         lstFmtSup;
+    RTCList<RTCString>         m_lstFmtSup;
     /** List of formats for the current
      *  drag'n drop operation. */
-    RTCList<RTCString>         lstFmtActive;
+    RTCList<RTCString>         m_lstFmtActive;
     /** List of all current drag'n drop actions allowed. */
-    VBOXDNDACTIONLIST          dndLstActionsAllowed;
+    VBOXDNDACTIONLIST          m_lstActionsAllowed;
     /** The startup information required
      *  for the actual DoDragDrop() call. */
-    VBOXDNDSTARTUPINFO         startupInfo;
+    VBOXDNDSTARTUPINFO         m_startupInfo;
     /** Is the left mouse button being pressed
      *  currently while being in this window? */
-    bool                       mfMouseButtonDown;
+    bool                       m_fMouseButtonDown;
 # ifdef VBOX_WITH_DRAG_AND_DROP_GH
     /** Pointer to IDropTarget implementation for
      *  guest -> host support. */
-    VBoxDnDDropTarget         *pDropTarget;
+    VBoxDnDDropTarget         *m_pDropTarget;
 # endif /* VBOX_WITH_DRAG_AND_DROP_GH */
 #else /* !RT_OS_WINDOWS */
@@ -433 +433 @@
 
     /** The window's own DnD context. */
-    VBGLR3GUESTDNDCMDCTX       mDnDCtx;
+    VBGLR3GUESTDNDCMDCTX       m_cmdCtx;
     /** The current operation mode. */
-    Mode                       mMode;
+    Mode                       m_enmMode;
     /** The current state. */
-    State                      mState;
+    State                      m_enmState;
     /** Format being requested. */
-    RTCString                  mFormatRequested;
+    RTCString                  m_strFmtReq;
 };
 

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

@@ -42 +42 @@
 
 VBoxDnDDataObject::VBoxDnDDataObject(LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
-    : mStatus(Uninitialized),
-      mRefCount(1),
-      mcFormats(0),
-      mpvData(NULL),
-      mcbData(0)
+    : m_enmStatus(Status_Uninitialized),
+      m_cRefs(1),
+      m_cFormats(0),
+      m_pvData(NULL),
+      m_cbData(0)
 {
     HRESULT hr;
@@ -55 +55 @@
     try
     {
-        mpFormatEtc = new FORMATETC[cAllFormats];
-        RT_BZERO(mpFormatEtc, sizeof(FORMATETC) * cAllFormats);
-        mpStgMedium = new STGMEDIUM[cAllFormats];
-        RT_BZERO(mpStgMedium, sizeof(STGMEDIUM) * cAllFormats);
+        m_paFormatEtc = new FORMATETC[cAllFormats];
+        RT_BZERO(m_paFormatEtc, sizeof(FORMATETC) * cAllFormats);
+        m_paStgMedium = new STGMEDIUM[cAllFormats];
+        RT_BZERO(m_paStgMedium, sizeof(STGMEDIUM) * cAllFormats);
 
         /*
@@ -73 +73 @@
                 LogFlowFunc(("Format %RU32: cfFormat=%RI16, tyMed=%RU32, dwAspect=%RU32\n",
                              i, pFormatEtc[i].cfFormat, pFormatEtc[i].tymed, pFormatEtc[i].dwAspect));
-                mpFormatEtc[i] = pFormatEtc[i];
-                mpStgMedium[i] = pStgMed[i];
+                m_paFormatEtc[i] = pFormatEtc[i];
+                m_paStgMedium[i] = pStgMed[i];
             }
         }
@@ -87 +87 @@
     if (SUCCEEDED(hr))
     {
-        int rc2 = RTSemEventCreate(&mEventDropped);
+        int rc2 = RTSemEventCreate(&m_EvtDropped);
         AssertRC(rc2);
 
@@ -115 +115 @@
                        RegisterClipboardFormat(CFSTR_SHELLIDLISTOFFSET));
 #endif
-        mcFormats = cFormats;
-        mStatus   = Initialized;
+        m_cFormats = cFormats;
+        m_enmStatus   = Status_Initialized;
     }
 
@@ -124 +124 @@
 VBoxDnDDataObject::~VBoxDnDDataObject(void)
 {
-    if (mpFormatEtc)
-        delete[] mpFormatEtc;
-
-    if (mpStgMedium)
-        delete[] mpStgMedium;
-
-    if (mpvData)
-        RTMemFree(mpvData);
-
-    LogFlowFunc(("mRefCount=%RI32\n", mRefCount));
+    if (m_paFormatEtc)
+        delete[] m_paFormatEtc;
+
+    if (m_paStgMedium)
+        delete[] m_paStgMedium;
+
+    if (m_pvData)
+        RTMemFree(m_pvData);
+
+    LogFlowFunc(("mRefCount=%RI32\n", m_cRefs));
 }
 
@@ -142 +142 @@
 STDMETHODIMP_(ULONG) VBoxDnDDataObject::AddRef(void)
 {
-    return InterlockedIncrement(&mRefCount);
+    return InterlockedIncrement(&m_cRefs);
 }
 
 STDMETHODIMP_(ULONG) VBoxDnDDataObject::Release(void)
 {
-    LONG lCount = InterlockedDecrement(&mRefCount);
+    LONG lCount = InterlockedDecrement(&m_cRefs);
     if (lCount == 0)
     {
@@ -181 +181 @@
     if (!LookupFormatEtc(pFormatEtc, &lIndex)) /* Format supported? */
         return DV_E_FORMATETC;
-    if (lIndex >= mcFormats) /* Paranoia. */
+    if (lIndex >= m_cFormats) /* Paranoia. */
         return DV_E_FORMATETC;
 
-    LPFORMATETC pThisFormat = &mpFormatEtc[lIndex];
+    LPFORMATETC pThisFormat = &m_paFormatEtc[lIndex];
     AssertPtr(pThisFormat);
 
-    LPSTGMEDIUM pThisMedium = &mpStgMedium[lIndex];
+    LPSTGMEDIUM pThisMedium = &m_paStgMedium[lIndex];
     AssertPtr(pThisMedium);
 
@@ -194 +194 @@
     HRESULT hr = DV_E_FORMATETC; /* Play safe. */
 
-    LogFlowFunc(("mStatus=%ld\n", mStatus));
-    if (mStatus == Dropping)
+    LogFlowFunc(("mStatus=%ld\n", m_enmStatus));
+    if (m_enmStatus == Status_Dropping)
     {
         LogRel2(("DnD: Waiting for drop event ...\n"));
-        int rc2 = RTSemEventWait(mEventDropped, RT_INDEFINITE_WAIT);
-        LogFlowFunc(("rc2=%Rrc, mStatus=%ld\n", rc2, mStatus)); RT_NOREF(rc2);
-    }
-
-    if (mStatus == Dropped)
+        int rc2 = RTSemEventWait(m_EvtDropped, RT_INDEFINITE_WAIT);
+        LogFlowFunc(("rc2=%Rrc, mStatus=%ld\n", rc2, m_enmStatus)); RT_NOREF(rc2);
+    }
+
+    if (m_enmStatus == Status_Dropped)
     {
         LogRel2(("DnD: Drop event received\n"));
@@ -209 +209 @@
                  pThisFormat->tymed, pThisFormat->dwAspect));
         LogRel3(("DnD: Got strFormat=%s, pvData=%p, cbData=%RU32\n",
-                  mstrFormat.c_str(), mpvData, mcbData));
+                  m_strFormat.c_str(), m_pvData, m_cbData));
 
         /*
@@ -220 +220 @@
          * URI list handling.
          */
-        if (DnDMIMEHasFileURLs(mstrFormat.c_str(), RTSTR_MAX))
+        if (DnDMIMEHasFileURLs(m_strFormat.c_str(), RTSTR_MAX))
         {
             char **papszFiles;
             size_t cFiles;
-            int rc = RTStrSplit((const char *)mpvData, mcbData, DND_PATH_SEPARATOR, &papszFiles, &cFiles);
+            int rc = RTStrSplit((const char *)m_pvData, m_cbData, DND_PATH_SEPARATOR, &papszFiles, &cFiles);
             if (   RT_SUCCESS(rc)
                 && cFiles)
@@ -263 +263 @@
                     && (pFormatEtc->cfFormat == CF_TEXT))
                 {
-                    pMedium->hGlobal = GlobalAlloc(GHND, mcbData + 1);
+                    pMedium->hGlobal = GlobalAlloc(GHND, m_cbData + 1);
                     if (pMedium->hGlobal)
                     {
                         char *pcDst  = (char *)GlobalLock(pMedium->hGlobal);
-                        memcpy(pcDst, mpvData, mcbData);
-                        pcDst[mcbData] = '\0';
+                        memcpy(pcDst, m_pvData, m_cbData);
+                        pcDst[m_cbData] = '\0';
                         GlobalUnlock(pMedium->hGlobal);
 
@@ -356 +356 @@
          * Plain text handling.
          */
-        else if (   mstrFormat.equalsIgnoreCase("text/plain")
-                 || mstrFormat.equalsIgnoreCase("text/html")
-                 || mstrFormat.equalsIgnoreCase("text/plain;charset=utf-8")
-                 || mstrFormat.equalsIgnoreCase("text/plain;charset=utf-16")
-                 || mstrFormat.equalsIgnoreCase("text/richtext")
-                 || mstrFormat.equalsIgnoreCase("UTF8_STRING")
-                 || mstrFormat.equalsIgnoreCase("TEXT")
-                 || mstrFormat.equalsIgnoreCase("STRING"))
+        else if (   m_strFormat.equalsIgnoreCase("text/plain")
+                 || m_strFormat.equalsIgnoreCase("text/html")
+                 || m_strFormat.equalsIgnoreCase("text/plain;charset=utf-8")
+                 || m_strFormat.equalsIgnoreCase("text/plain;charset=utf-16")
+                 || m_strFormat.equalsIgnoreCase("text/richtext")
+                 || m_strFormat.equalsIgnoreCase("UTF8_STRING")
+                 || m_strFormat.equalsIgnoreCase("TEXT")
+                 || m_strFormat.equalsIgnoreCase("STRING"))
         {
-            pMedium->hGlobal = GlobalAlloc(GHND, mcbData + 1);
+            pMedium->hGlobal = GlobalAlloc(GHND, m_cbData + 1);
             if (pMedium->hGlobal)
             {
                 char *pcDst  = (char *)GlobalLock(pMedium->hGlobal);
-                memcpy(pcDst, mpvData, mcbData);
-                pcDst[mcbData] = '\0';
+                memcpy(pcDst, m_pvData, m_cbData);
+                pcDst[m_cbData] = '\0';
                 GlobalUnlock(pMedium->hGlobal);
 
@@ -377 +377 @@
         }
         else
-            LogRel(("DnD: Error: Format '%s' not implemented\n", mstrFormat.c_str()));
+            LogRel(("DnD: Error: Format '%s' not implemented\n", m_strFormat.c_str()));
     }
 
@@ -401 +401 @@
 
     if (hr == DV_E_FORMATETC)
-        LogRel(("DnD: Error handling format '%s' (%RU32 bytes)\n", mstrFormat.c_str(), mcbData));
+        LogRel(("DnD: Error handling format '%s' (%RU32 bytes)\n", m_strFormat.c_str(), m_cbData));
 
     LogFlowFunc(("hr=%Rhrc\n", hr));
@@ -438 +438 @@
 STDMETHODIMP VBoxDnDDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
 {
-    LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, mcFormats, mpFormatEtc));
+    LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_paFormatEtc));
 
     HRESULT hr;
     if (dwDirection == DATADIR_GET)
-        hr = VBoxDnDEnumFormatEtc::CreateEnumFormatEtc(mcFormats, mpFormatEtc, ppEnumFormatEtc);
+        hr = VBoxDnDEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_paFormatEtc, ppEnumFormatEtc);
     else
         hr = E_NOTIMPL;
@@ -480 +480 @@
 {
     LogFlowFunc(("Aborting ...\n"));
-    mStatus = Aborted;
-    return RTSemEventSignal(mEventDropped);
+    m_enmStatus = Status_Aborted;
+    return RTSemEventSignal(m_EvtDropped);
 }
 
@@ -585 +585 @@
     /* 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_paFormatEtc[i].tymed)
+            && pFormatEtc->cfFormat == m_paFormatEtc[i].cfFormat
+            && pFormatEtc->dwAspect == m_paFormatEtc[i].dwAspect)
         {
             LogRel3(("DnD: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
-                      pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mpFormatEtc[i].cfFormat),
+                      pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxDnDDataObject::ClipboardFormatToString(m_paFormatEtc[i].cfFormat),
                       pFormatEtc->dwAspect, i));
             if (puIndex)
@@ -605 +605 @@
 
     return false;
-}
-
-/* static */
-HGLOBAL VBoxDnDDataObject::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;
 }
 
@@ -660 +641 @@
 {
     LogFlowFunc(("Setting status to %ld\n", status));
-    mStatus = status;
+    m_enmStatus = status;
 }
 
@@ -678 +659 @@
     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;
         }
@@ -693 +674 @@
     if (RT_SUCCESS(rc))
     {
-        mStatus    = Dropped;
-        mstrFormat = strFormat;
+        m_enmStatus    = Status_Dropped;
+        m_strFormat = strFormat;
     }
     else
     {
-        mStatus = Aborted;
+        m_enmStatus = Status_Aborted;
     }
 
@@ -704 +685 @@
     LogRel2(("DnD: Signalling drop event\n"));
 
-    int rc2 = RTSemEventSignal(mEventDropped);
+    int rc2 = RTSemEventSignal(m_EvtDropped);
     if (RT_SUCCESS(rc))
         rc = rc2;
 
-    LogFunc(("mStatus=%RU32, rc=%Rrc\n", mStatus, rc));
+    LogFunc(("mStatus=%RU32, rc=%Rrc\n", m_enmStatus, rc));
     return rc;
 }

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

@@ -34 +34 @@
 
 VBoxDnDDropSource::VBoxDnDDropSource(VBoxDnDWnd *pParent)
-    : mRefCount(1),
-      mpWndParent(pParent),
-      mdwCurEffect(0),
-      mDnDActionCurrent(VBOX_DND_ACTION_IGNORE)
+    : m_cRefs(1),
+      m_pWndParent(pParent),
+      m_dwCurEffect(0),
+      m_enmActionCurrent(VBOX_DND_ACTION_IGNORE)
 {
     LogFlowFuncEnter();
@@ -44 +44 @@
 VBoxDnDDropSource::~VBoxDnDDropSource(void)
 {
-    LogFlowFunc(("mRefCount=%RI32\n", mRefCount));
+    LogFlowFunc(("mRefCount=%RI32\n", m_cRefs));
 }
 
@@ -53 +53 @@
 STDMETHODIMP_(ULONG) VBoxDnDDropSource::AddRef(void)
 {
-    return InterlockedIncrement(&mRefCount);
+    return InterlockedIncrement(&m_cRefs);
 }
 
 STDMETHODIMP_(ULONG) VBoxDnDDropSource::Release(void)
 {
-    LONG lCount = InterlockedDecrement(&mRefCount);
+    LONG lCount = InterlockedDecrement(&m_cRefs);
     if (lCount == 0)
     {
@@ -98 +98 @@
 #if 1
     LogFlowFunc(("fEscapePressed=%RTbool, dwKeyState=0x%x, mdwCurEffect=%RI32, mDnDActionCurrent=%RU32\n",
-                 fEscapePressed, dwKeyState, mdwCurEffect, mDnDActionCurrent));
+                 fEscapePressed, dwKeyState, m_dwCurEffect, m_enmActionCurrent));
 #endif
 
@@ -104 +104 @@
     if (fEscapePressed)
     {
-        mdwCurEffect = 0;
-        mDnDActionCurrent = VBOX_DND_ACTION_IGNORE;
+        m_dwCurEffect = 0;
+        m_enmActionCurrent = VBOX_DND_ACTION_IGNORE;
 
         LogFlowFunc(("Canceled\n"));
@@ -145 +145 @@
     }
 
-    mdwCurEffect = dwEffect;
-    mDnDActionCurrent = uAction;
+    m_dwCurEffect = dwEffect;
+    m_enmActionCurrent = uAction;
 
     return DRAGDROP_S_USEDEFAULTCURSORS;

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

@@ -36 +36 @@
 
 VBoxDnDDropTarget::VBoxDnDDropTarget(VBoxDnDWnd *pParent)
-    : mRefCount(1),
-      mpWndParent(pParent),
-      mdwCurEffect(0),
-      mpvData(NULL),
-      mcbData(0),
-      hEventDrop(NIL_RTSEMEVENT)
-{
-    int rc = RTSemEventCreate(&hEventDrop);
+    : m_cRefs(1),
+      m_pWndParent(pParent),
+      m_dwCurEffect(0),
+      m_pvData(NULL),
+      m_cbData(0),
+      m_EvtDrop(NIL_RTSEMEVENT)
+{
+    int rc = RTSemEventCreate(&m_EvtDrop);
     LogFlowFunc(("rc=%Rrc\n", rc)); NOREF(rc);
 }
@@ -51 +51 @@
     reset();
 
-    int rc2 = RTSemEventDestroy(hEventDrop);
+    int rc2 = RTSemEventDestroy(m_EvtDrop);
     AssertRC(rc2);
 
-    LogFlowFunc(("rc=%Rrc, mRefCount=%RI32\n", rc2, mRefCount));
+    LogFlowFunc(("rc=%Rrc, mRefCount=%RI32\n", rc2, m_cRefs));
 }
 
@@ -63 +63 @@
 STDMETHODIMP_(ULONG) VBoxDnDDropTarget::AddRef(void)
 {
-    return InterlockedIncrement(&mRefCount);
+    return InterlockedIncrement(&m_cRefs);
 }
 
 STDMETHODIMP_(ULONG) VBoxDnDDropTarget::Release(void)
 {
-    LONG lCount = InterlockedDecrement(&mRefCount);
+    LONG lCount = InterlockedDecrement(&m_cRefs);
     if (lCount == 0)
     {
@@ -158 +158 @@
     if (hr == S_OK)
     {
-        mstrFormats = "text/uri-list";
+        m_strFormat = "text/uri-list";
     }
     else
@@ -170 +170 @@
         if (hr == S_OK)
         {
-            mstrFormats = "text/plain;charset=utf-8";
+            m_strFormat = "text/plain;charset=utf-8";
         }
         else
@@ -180 +180 @@
             if (hr == S_OK)
             {
-                mstrFormats = "text/plain;charset=utf-8";
+                m_strFormat = "text/plain;charset=utf-8";
             }
             else
@@ -202 +202 @@
          * use this for comparrison and stuff. */
         /** @todo The DVTARGETDEVICE member only is a shallow copy for now! */
-        memcpy(&mFormatEtc, &fmtEtc, sizeof(FORMATETC));
+        memcpy(&m_FormatEtc, &fmtEtc, sizeof(FORMATETC));
 
         /* Which drop effect we're going to use? */
@@ -229 +229 @@
 
     LogFlowFunc(("Returning mstrFormats=%s, cfFormat=%RI16, pdwEffect=%ld, hr=%Rhrc\n",
-                 mstrFormats.c_str(), fmtEtc.cfFormat, *pdwEffect, hr));
+                 m_strFormat.c_str(), fmtEtc.cfFormat, *pdwEffect, hr));
     return hr;
 }
@@ -240 +240 @@
 #ifdef DEBUG_andy
     LogFlowFunc(("cfFormat=%RI16, grfKeyState=0x%x, x=%ld, y=%ld\n",
-                 mFormatEtc.cfFormat, grfKeyState, pt.x, pt.y));
+                 m_FormatEtc.cfFormat, grfKeyState, pt.x, pt.y));
 #endif
 
-    if (mFormatEtc.cfFormat)
+    if (m_FormatEtc.cfFormat)
     {
         /* Note: pt is not used since we don't need to differentiate within our
@@ -263 +263 @@
 {
 #ifdef DEBUG_andy
-    LogFlowFunc(("cfFormat=%RI16\n", mFormatEtc.cfFormat));
+    LogFlowFunc(("cfFormat=%RI16\n", m_FormatEtc.cfFormat));
 #endif
 
-    if (mpWndParent)
-        mpWndParent->Hide();
+    if (m_pWndParent)
+        m_pWndParent->Hide();
 
     return S_OK;
@@ -279 +279 @@
 
     LogFlowFunc(("mFormatEtc.cfFormat=%RI16 (%s), pDataObject=0x%p, grfKeyState=0x%x, x=%ld, y=%ld\n",
-                 mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat),
+                 m_FormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(m_FormatEtc.cfFormat),
                  pDataObject, grfKeyState, pt.x, pt.y));
 
     HRESULT hr = S_OK;
 
-    if (mFormatEtc.cfFormat) /* Did we get a supported format yet? */
+    if (m_FormatEtc.cfFormat) /* Did we get a supported format yet? */
     {
         /* Make sure the data object's data format is still valid. */
-        hr = pDataObject->QueryGetData(&mFormatEtc);
+        hr = pDataObject->QueryGetData(&m_FormatEtc);
         AssertMsg(SUCCEEDED(hr),
                   ("Data format changed to invalid between DragEnter() and Drop(), cfFormat=%RI16 (%s), hr=%Rhrc\n",
-                  mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat), hr));
+                  m_FormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(m_FormatEtc.cfFormat), hr));
     }
 
@@ -298 +298 @@
     {
         STGMEDIUM stgMed;
-        hr = pDataObject->GetData(&mFormatEtc, &stgMed);
+        hr = pDataObject->GetData(&m_FormatEtc, &stgMed);
         if (SUCCEEDED(hr))
         {
@@ -307 +307 @@
             PVOID pvData = NULL; /** @todo Put this in an own union? */
 
-            switch (mFormatEtc.tymed)
+            switch (m_FormatEtc.tymed)
             {
                 case TYMED_HGLOBAL:
@@ -322 +322 @@
                 default:
                     AssertMsgFailed(("Storage medium type %RI32 supported\n",
-                                     mFormatEtc.tymed));
+                                     m_FormatEtc.tymed));
                     rc = VERR_NOT_SUPPORTED;
                     hr = DV_E_TYMED; /* Set special hr for OLE. */
@@ -334 +334 @@
                  *               based on the storage medium type.
                  */
-                switch (mFormatEtc.cfFormat)
+                switch (m_FormatEtc.cfFormat)
                 {
                     case CF_TEXT:
@@ -344 +344 @@
 
                         LogRel(("DnD: Got %zu bytes of %s\n", cbSize,
-                                                                mFormatEtc.cfFormat == CF_TEXT
+                                                                m_FormatEtc.cfFormat == CF_TEXT
                                                               ? "ANSI text" : "Unicode text"));
                         if (cbSize)
@@ -350 +350 @@
                             char *pszText = NULL;
 
-                            rc = mFormatEtc.cfFormat == CF_TEXT
+                            rc = m_FormatEtc.cfFormat == CF_TEXT
                                /* ANSI codepage -> UTF-8 */
                                ? RTStrCurrentCPToUtf8(&pszText, (char *)pvData)
@@ -362 +362 @@
                                 size_t cbText = strlen(pszText) + 1; /* Include termination. */
 
-                                mpvData = RTMemDup((void *)pszText, cbText);
-                                mcbData = cbText;
+                                m_pvData = RTMemDup((void *)pszText, cbText);
+                                m_cbData = cbText;
 
                                 RTStrFree(pszText);
@@ -499 +499 @@
                                          cFiles, cchFiles, cbFiles, pszFiles));
 
-                            mpvData = pszFiles;
-                            mcbData = cbFiles;
+                            m_pvData = pszFiles;
+                            m_cbData = cbFiles;
                         }
                         else
@@ -516 +516 @@
                         /* Note: Should not happen due to the checks done in DragEnter(). */
                         AssertMsgFailed(("Format of type %RI16 (%s) not supported\n",
-                                         mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat)));
+                                         m_FormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(m_FormatEtc.cfFormat)));
                         hr = DV_E_CLIPFORMAT; /* Set special hr for OLE. */
                         break;
@@ -524 +524 @@
                  * Third stage: Unlock + release access to the storage medium again.
                  */
-                switch (mFormatEtc.tymed)
+                switch (m_FormatEtc.tymed)
                 {
                     case TYMED_HGLOBAL:
@@ -540 +540 @@
 
             /* Signal waiters. */
-            mDroppedRc = rc;
-            RTSemEventSignal(hEventDrop);
+            m_rcDropped = rc;
+            RTSemEventSignal(m_EvtDrop);
         }
     }
@@ -554 +554 @@
         *pdwEffect = DROPEFFECT_NONE;
 
-    if (mpWndParent)
-        mpWndParent->Hide();
+    if (m_pWndParent)
+        m_pWndParent->Hide();
 
     LogFlowFunc(("Returning with hr=%Rhrc (%Rrc), mFormatEtc.cfFormat=%RI16 (%s), *pdwEffect=%RI32\n",
-                 hr, rc, mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat),
+                 hr, rc, m_FormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(m_FormatEtc.cfFormat),
                  *pdwEffect));
 
@@ -607 +607 @@
     LogFlowFuncEnter();
 
-    if (mpvData)
-    {
-        RTMemFree(mpvData);
-        mpvData = NULL;
-    }
-
-    mcbData = 0;
-
-    RT_ZERO(mFormatEtc);
-    mstrFormats = "";
+    if (m_pvData)
+    {
+        RTMemFree(m_pvData);
+        m_pvData = NULL;
+    }
+
+    m_cbData = 0;
+
+    RT_ZERO(m_FormatEtc);
+    m_strFormat = "";
 }
 
@@ -626 +626 @@
 RTCString VBoxDnDDropTarget::Formats(void) const
 {
-    return mstrFormats;
+    return m_strFormat;
 }
 
@@ -639 +639 @@
     LogFlowFunc(("msTimeout=%RU32\n", msTimeout));
 
-    int rc = RTSemEventWait(hEventDrop, msTimeout);
+    int rc = RTSemEventWait(m_EvtDrop, msTimeout);
     if (RT_SUCCESS(rc))
-        rc = mDroppedRc;
+        rc = m_rcDropped;
 
     LogFlowFuncLeaveRC(rc);

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

@@ -32 +32 @@
 
 VBoxDnDEnumFormatEtc::VBoxDnDEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats)
-    : m_lRefCount(1),
-      m_nIndex(0)
+    : m_cRefs(1),
+      m_uIdxCur(0)
 {
     HRESULT hr;
@@ -40 +40 @@
     {
         LogFlowFunc(("pFormatEtc=%p, cFormats=%RU32\n", pFormatEtc, cFormats));
-        m_pFormatEtc  = new FORMATETC[cFormats];
+        m_paFormatEtc  = new FORMATETC[cFormats];
 
         for (ULONG i = 0; i < cFormats; i++)
@@ -47 +47 @@
                          i, pFormatEtc[i].cfFormat, VBoxDnDDataObject::ClipboardFormatToString(pFormatEtc[i].cfFormat),
                          pFormatEtc[i].tymed, pFormatEtc[i].dwAspect));
-            VBoxDnDEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]);
+            VBoxDnDEnumFormatEtc::CopyFormat(&m_paFormatEtc[i], &pFormatEtc[i]);
         }
 
-        m_nNumFormats = cFormats;
+        m_cFormats = cFormats;
         hr = S_OK;
     }
@@ -63 +63 @@
 VBoxDnDEnumFormatEtc::~VBoxDnDEnumFormatEtc(void)
 {
-    if (m_pFormatEtc)
+    if (m_paFormatEtc)
     {
-        for (ULONG i = 0; i < m_nNumFormats; i++)
+        for (ULONG i = 0; i < m_cFormats; i++)
         {
-            if(m_pFormatEtc[i].ptd)
-                CoTaskMemFree(m_pFormatEtc[i].ptd);
+            if(m_paFormatEtc[i].ptd)
+                CoTaskMemFree(m_paFormatEtc[i].ptd);
         }
 
-        delete[] m_pFormatEtc;
-        m_pFormatEtc = NULL;
+        delete[] m_paFormatEtc;
+        m_paFormatEtc = NULL;
     }
 
-    LogFlowFunc(("m_lRefCount=%RI32\n", m_lRefCount));
+    LogFlowFunc(("m_lRefCount=%RI32\n", m_cRefs));
 }
 
@@ -84 +84 @@
 STDMETHODIMP_(ULONG) VBoxDnDEnumFormatEtc::AddRef(void)
 {
-    return InterlockedIncrement(&m_lRefCount);
+    return InterlockedIncrement(&m_cRefs);
 }
 
 STDMETHODIMP_(ULONG) VBoxDnDEnumFormatEtc::Release(void)
 {
-    LONG lCount = InterlockedDecrement(&m_lRefCount);
+    LONG lCount = InterlockedDecrement(&m_cRefs);
     if (lCount == 0)
     {
@@ -120 +120 @@
         return E_INVALIDARG;
 
-    while (   m_nIndex < m_nNumFormats
+    while (   m_uIdxCur < m_cFormats
            && ulCopied < cFormats)
     {
         VBoxDnDEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied],
-                                         &m_pFormatEtc[m_nIndex]);
+                                         &m_paFormatEtc[m_uIdxCur]);
         ulCopied++;
-        m_nIndex++;
+        m_uIdxCur++;
     }
 
@@ -137 +137 @@
 STDMETHODIMP VBoxDnDEnumFormatEtc::Skip(ULONG cFormats)
 {
-    m_nIndex += cFormats;
-    return (m_nIndex <= m_nNumFormats) ? S_OK : S_FALSE;
+    m_uIdxCur += cFormats;
+    return (m_uIdxCur <= m_cFormats) ? S_OK : S_FALSE;
 }
 
 STDMETHODIMP VBoxDnDEnumFormatEtc::Reset(void)
 {
-    m_nIndex = 0;
+    m_uIdxCur = 0;
     return S_OK;
 }
@@ -150 +150 @@
 {
     HRESULT hResult =
-        CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);
+        CreateEnumFormatEtc(m_cFormats, m_paFormatEtc, ppEnumFormatEtc);
 
     if (hResult == S_OK)
-        ((VBoxDnDEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex;
+        ((VBoxDnDEnumFormatEtc *) *ppEnumFormatEtc)->m_uIdxCur = m_uIdxCur;
 
     return hResult;