Changeset 103631 in vbox for trunk/src/VBox/GuestHost/SharedClipboard

Timestamp:

Mar 1, 2024 11:00:38 AM (11 months ago)

Author:

vboxsync

Message:

Shared Clipboard: More cleanups (renaming Windows parts to match the other platforms). bugref:9437

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• ClipboardDataObjectImpl-win.cpp (modified) (42 diffs)
• ClipboardEnumFormatEtcImpl-win.cpp (modified) (15 diffs)
• ClipboardStreamImpl-win.cpp (modified) (19 diffs)
• clipboard-win.cpp (modified) (51 diffs)

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp

@@ -62 +62 @@
 //#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 1
 
-SharedClipboardWinDataObject::SharedClipboardWinDataObject(void)
+ShClWinDataObject::ShClWinDataObject(void)
     : m_pCtx(NULL)
     , m_enmStatus(Uninitialized)
@@ -80 +80 @@
 }
 
-SharedClipboardWinDataObject::~SharedClipboardWinDataObject(void)
+ShClWinDataObject::~ShClWinDataObject(void)
 {
     Destroy();
@@ -102 +102 @@
  * @param   cFormats            Number of formats in \a pFormatEtc and \a pStgMed. Optional.
  */
-int SharedClipboardWinDataObject::Init(PSHCLCONTEXT pCtx, SharedClipboardWinDataObject::PCALLBACKS pCallbacks,
-                                       LPFORMATETC pFormatEtc /* = NULL */, LPSTGMEDIUM pStgMed /* = NULL */,
-                                       ULONG cFormats /* = 0 */)
+int ShClWinDataObject::Init(PSHCLCONTEXT pCtx, ShClWinDataObject::PCALLBACKS pCallbacks,
+                            LPFORMATETC pFormatEtc /* = NULL */, LPSTGMEDIUM pStgMed /* = NULL */,
+                            ULONG cFormats /* = 0 */)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
@@ -117 +117 @@
      * Set up callback context + table.
      */
-    memcpy(&m_Callbacks, pCallbacks, sizeof(SharedClipboardWinDataObject::CALLBACKS));
+    memcpy(&m_Callbacks, pCallbacks, sizeof(ShClWinDataObject::CALLBACKS));
     m_CallbackCtx.pvUser = pCtx;
     m_CallbackCtx.pThis  = this;
@@ -199 +199 @@
  * Uninitialized a data object instance, internal version.
  */
-void SharedClipboardWinDataObject::uninitInternal(void)
+void ShClWinDataObject::uninitInternal(void)
 {
     LogFlowFuncEnter();
@@ -230 +230 @@
  * Uninitialized a data object instance.
  */
-void SharedClipboardWinDataObject::Uninit(void)
+void ShClWinDataObject::Uninit(void)
 {
     LogFlowFuncEnter();
@@ -240 +240 @@
  * Destroys a data object instance.
  */
-void SharedClipboardWinDataObject::Destroy(void)
+void ShClWinDataObject::Destroy(void)
 {
     LogFlowFuncEnter();
@@ -295 +295 @@
  ********************************************************************************************************************************/
 
-STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::AddRef(void)
+STDMETHODIMP_(ULONG) ShClWinDataObject::AddRef(void)
 {
     ULONG ulCount = InterlockedIncrement(&m_lRefCount);
@@ -302 +302 @@
 }
 
-STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::Release(void)
+STDMETHODIMP_(ULONG) ShClWinDataObject::Release(void)
 {
     ULONG ulCount = InterlockedDecrement(&m_lRefCount);
@@ -315 +315 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject)
+STDMETHODIMP ShClWinDataObject::QueryInterface(REFIID iid, void **ppvObject)
 {
     AssertPtrReturn(ppvObject, E_INVALIDARG);
@@ -340 +340 @@
  * @param   phGlobal            Where to store the allocated HGLOBAL object.
  */
-int SharedClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal)
+int ShClWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal)
 {
     AssertPtrReturn(phGlobal, VERR_INVALID_POINTER);
@@ -363 +363 @@
 }
 
-inline int SharedClipboardWinDataObject::lock(void)
+inline int ShClWinDataObject::lock(void)
 {
     int rc = RTCritSectEnter(&m_CritSect);
@@ -371 +371 @@
 }
 
-inline int SharedClipboardWinDataObject::unlock(void)
+inline int ShClWinDataObject::unlock(void)
 {
     int rc = RTCritSectLeave(&m_CritSect);
@@ -387 +387 @@
  * @param   strDir              Directory path to handle.
  */
-int SharedClipboardWinDataObject::readDir(PSHCLTRANSFER pTransfer, const Utf8Str &strDir)
+int ShClWinDataObject::readDir(PSHCLTRANSFER pTransfer, const Utf8Str &strDir)
 {
     LogFlowFunc(("strDir=%s\n", strDir.c_str()));
@@ -482 +482 @@
  * @returns VBox status code.
  * @param   pTransfer           Pointer to transfer.
- * @param   pvUser              Pointer to user-provided data. Of type SharedClipboardWinDataObject.
+ * @param   pvUser              Pointer to user-provided data. Of type ShClWinDataObject.
  */
 /* static */
-DECLCALLBACK(int) SharedClipboardWinDataObject::readThread(PSHCLTRANSFER pTransfer, void *pvUser)
+DECLCALLBACK(int) ShClWinDataObject::readThread(PSHCLTRANSFER pTransfer, void *pvUser)
 {
     LogFlowFuncEnter();
 
-    SharedClipboardWinDataObject *pThis = (SharedClipboardWinDataObject *)pvUser;
+    ShClWinDataObject *pThis = (ShClWinDataObject *)pvUser;
 
     LogRel2(("Shared Clipboard: Calculating transfer ...\n"));
@@ -639 +639 @@
  * @param   phGlobal            Where to store the allocated HGLOBAL object on success.
  */
-int SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLTRANSFER pTransfer,
+int ShClWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLTRANSFER pTransfer,
                                                                         bool fUnicode, HGLOBAL *phGlobal)
 {
@@ -764 +764 @@
  * @thread  Windows event thread.
  */
-STDMETHODIMP SharedClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
+STDMETHODIMP ShClWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
 {
     AssertPtrReturn(pFormatEtc, DV_E_FORMATETC);
@@ -861 +861 @@
                     if (RT_SUCCESS(rc))
                     {
-                        rc = ShClTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this /* pvUser */);
+                        rc = ShClTransferRun(m_pTransfer, &ShClWinDataObject::readThread, this /* pvUser */);
                         if (RT_SUCCESS(rc))
                         {
@@ -932 +932 @@
 
                 /* Hand-in the provider so that our IStream implementation can continue working with it. */
-                hr = SharedClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer,
+                hr = ShClWinStreamImpl::Create(this /* pParent */, m_pTransfer,
                                                           fsObjEntry.pszPath /* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */,
                                                           &m_pStream);
@@ -978 +978 @@
  * @param   pMedium
  */
-STDMETHODIMP SharedClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
+STDMETHODIMP ShClWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
 {
     RT_NOREF(pFormatEtc, pMedium);
@@ -992 +992 @@
  * @param   pFormatEtc
  */
-STDMETHODIMP SharedClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc)
+STDMETHODIMP ShClWinDataObject::QueryGetData(LPFORMATETC pFormatEtc)
 {
     LogFlowFunc(("\n"));
@@ -998 +998 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut)
+STDMETHODIMP ShClWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut)
 {
     RT_NOREF(pFormatEtc);
@@ -1008 +1008 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease)
+STDMETHODIMP ShClWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease)
 {
     if (   pFormatEtc == NULL
@@ -1055 +1055 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
+STDMETHODIMP ShClWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
 {
     LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_pFormatEtc));
@@ -1061 +1061 @@
     HRESULT hr;
     if (dwDirection == DATADIR_GET)
-        hr = SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc);
+        hr = ShClWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc);
     else
         hr = E_NOTIMPL;
@@ -1069 +1069 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection)
+STDMETHODIMP ShClWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 {
     RT_NOREF(pFormatEtc, fAdvise, pAdvSink, pdwConnection);
@@ -1075 +1075 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::DUnadvise(DWORD dwConnection)
+STDMETHODIMP ShClWinDataObject::DUnadvise(DWORD dwConnection)
 {
     RT_NOREF(dwConnection);
@@ -1081 +1081 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise)
+STDMETHODIMP ShClWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise)
 {
     RT_NOREF(ppEnumAdvise);
@@ -1092 +1092 @@
  */
 
-STDMETHODIMP SharedClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects)
+STDMETHODIMP ShClWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects)
 {
      RT_NOREF(hResult, pbcReserved, dwEffects);
@@ -1098 +1098 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync)
+STDMETHODIMP ShClWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync)
 {
      RT_NOREF(pfIsOpAsync);
@@ -1104 +1104 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp)
+STDMETHODIMP ShClWinDataObject::InOperation(BOOL *pfInAsyncOp)
 {
      RT_NOREF(pfInAsyncOp);
@@ -1110 +1110 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync)
+STDMETHODIMP ShClWinDataObject::SetAsyncMode(BOOL fDoOpAsync)
 {
      RT_NOREF(fDoOpAsync);
@@ -1116 +1116 @@
 }
 
-STDMETHODIMP SharedClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved)
+STDMETHODIMP ShClWinDataObject::StartOperation(IBindCtx *pbcReserved)
 {
      RT_NOREF(pbcReserved);
@@ -1134 +1134 @@
  *                              When set to NULL, the transfer will be released from the object.
  */
-int SharedClipboardWinDataObject::setTransferLocked(PSHCLTRANSFER pTransfer)
+int ShClWinDataObject::setTransferLocked(PSHCLTRANSFER pTransfer)
 {
     AssertReturn(RTCritSectIsOwned(&m_CritSect), VERR_WRONG_ORDER);
@@ -1150 +1150 @@
             m_pTransfer = pTransfer;
 
-            SharedClipboardWinTransferCtx *pWinURITransferCtx = (SharedClipboardWinTransferCtx *)pTransfer->pvUser;
+            ShClWinTransferCtx *pWinURITransferCtx = (ShClWinTransferCtx *)pTransfer->pvUser;
             AssertPtr(pWinURITransferCtx);
 
@@ -1164 +1164 @@
         if (m_pTransfer)
         {
-            SharedClipboardWinTransferCtx *pWinURITransferCtx = (SharedClipboardWinTransferCtx *)m_pTransfer->pvUser;
+            ShClWinTransferCtx *pWinURITransferCtx = (ShClWinTransferCtx *)m_pTransfer->pvUser;
             AssertPtr(pWinURITransferCtx);
 
@@ -1188 +1188 @@
  *                              When set to NULL, the transfer will be released from the object.
  */
-int SharedClipboardWinDataObject::SetTransfer(PSHCLTRANSFER pTransfer)
+int ShClWinDataObject::SetTransfer(PSHCLTRANSFER pTransfer)
 {
     lock();
@@ -1206 +1206 @@
  * @param   rcSts               Result code. Optional.
  *
- * @note    Called by the main clipboard thread + SharedClipboardWinStreamImpl.
- */
-int SharedClipboardWinDataObject::SetStatus(Status enmStatus, int rcSts /* = VINF_SUCCESS */)
+ * @note    Called by the main clipboard thread + ShClWinStreamImpl.
+ */
+int ShClWinDataObject::SetStatus(Status enmStatus, int rcSts /* = VINF_SUCCESS */)
 {
     lock();
@@ -1219 +1219 @@
 
 /* static */
-void SharedClipboardWinDataObject::logFormat(CLIPFORMAT fmt)
+void ShClWinDataObject::logFormat(CLIPFORMAT fmt)
 {
     char szFormat[128];
@@ -1230 +1230 @@
 }
 
-bool SharedClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex)
+bool ShClWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex)
 {
     AssertReturn(pFormatEtc, false);
@@ -1258 +1258 @@
 }
 
-void SharedClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat,
+void ShClWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat,
                                                   TYMED tyMed, LONG lIndex, DWORD dwAspect,
                                                   DVTARGETDEVICE *pTargetDevice)
@@ -1285 +1285 @@
  * @note    Caller must have taken the critical section.
  */
-int SharedClipboardWinDataObject::setStatusLocked(Status enmStatus, int rc /* = VINF_SUCCESS */)
+int ShClWinDataObject::setStatusLocked(Status enmStatus, int rc /* = VINF_SUCCESS */)
 {
     AssertReturn(enmStatus == Error || RT_SUCCESS(rc), VERR_INVALID_PARAMETER);

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp

@@ -56 +56 @@
 
 
-SharedClipboardWinEnumFormatEtc::SharedClipboardWinEnumFormatEtc(void)
+ShClWinEnumFormatEtc::ShClWinEnumFormatEtc(void)
     : m_lRefCount(1),
       m_nIndex(0)
@@ -66 +66 @@
 }
 
-SharedClipboardWinEnumFormatEtc::~SharedClipboardWinEnumFormatEtc(void)
+ShClWinEnumFormatEtc::~ShClWinEnumFormatEtc(void)
 {
     Destroy();
@@ -85 +85 @@
  * @param   cFormats            Number of formats in \a pFormatEtc.
  */
-int SharedClipboardWinEnumFormatEtc::Init(LPFORMATETC pFormatEtc, ULONG cFormats)
+int ShClWinEnumFormatEtc::Init(LPFORMATETC pFormatEtc, ULONG cFormats)
 {
     LogFlowFunc(("pFormatEtc=%p, cFormats=%RU32\n", pFormatEtc, cFormats));
@@ -96 +96 @@
                      i, pFormatEtc[i].cfFormat, pFormatEtc[i].tymed, pFormatEtc[i].dwAspect));
 
-        SharedClipboardWinDataObject::logFormat(pFormatEtc[i].cfFormat);
-
-        SharedClipboardWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]);
+        ShClWinDataObject::logFormat(pFormatEtc[i].cfFormat);
+
+        ShClWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]);
     }
 
@@ -109 +109 @@
  * Destroys an IEnumFORMATETC instance.
  */
-void SharedClipboardWinEnumFormatEtc::Destroy(void)
+void ShClWinEnumFormatEtc::Destroy(void)
 {
     if (m_pFormatEtc)
@@ -130 +130 @@
  */
 
-STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::AddRef(void)
+STDMETHODIMP_(ULONG) ShClWinEnumFormatEtc::AddRef(void)
 {
     return InterlockedIncrement(&m_lRefCount);
 }
 
-STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::Release(void)
+STDMETHODIMP_(ULONG) ShClWinEnumFormatEtc::Release(void)
 {
     LONG lCount = InterlockedDecrement(&m_lRefCount);
@@ -148 +148 @@
 }
 
-STDMETHODIMP SharedClipboardWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject)
+STDMETHODIMP ShClWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject)
 {
     if (   iid == IID_IEnumFORMATETC
@@ -162 +162 @@
 }
 
-STDMETHODIMP SharedClipboardWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched)
+STDMETHODIMP ShClWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched)
 {
     ULONG ulCopied  = 0;
@@ -172 +172 @@
            && ulCopied < cFormats)
     {
-        SharedClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]);
+        ShClWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]);
         ulCopied++;
         m_nIndex++;
@@ -183 +183 @@
 }
 
-STDMETHODIMP SharedClipboardWinEnumFormatEtc::Skip(ULONG cFormats)
+STDMETHODIMP ShClWinEnumFormatEtc::Skip(ULONG cFormats)
 {
     m_nIndex += cFormats;
@@ -189 +189 @@
 }
 
-STDMETHODIMP SharedClipboardWinEnumFormatEtc::Reset(void)
+STDMETHODIMP ShClWinEnumFormatEtc::Reset(void)
 {
     m_nIndex = 0;
@@ -195 +195 @@
 }
 
-STDMETHODIMP SharedClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc)
+STDMETHODIMP ShClWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc)
 {
     HRESULT hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);
     if (hResult == S_OK)
-        ((SharedClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex;
+        ((ShClWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex;
 
     return hResult;
@@ -205 +205 @@
 
 /* static */
-void SharedClipboardWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource)
+void ShClWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource)
 {
     AssertPtrReturnVoid(pDest);
@@ -220 +220 @@
 
 /* static */
-HRESULT SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc)
+HRESULT ShClWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc)
 {
     AssertReturn(nNumFormats, E_INVALIDARG);
@@ -228 +228 @@
     HRESULT hr;
 
-    SharedClipboardWinEnumFormatEtc *pEnumFormatEtc = new SharedClipboardWinEnumFormatEtc();
+    ShClWinEnumFormatEtc *pEnumFormatEtc = new ShClWinEnumFormatEtc();
     if (pEnumFormatEtc)
     {

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp

@@ -60 +60 @@
 
 
-SharedClipboardWinStreamImpl::SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLTRANSFER pTransfer,
-                                                           const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo)
+ShClWinStreamImpl::ShClWinStreamImpl(ShClWinDataObject *pParent, PSHCLTRANSFER pTransfer,
+                                     const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo)
     : m_pParent(pParent)
     , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */
@@ -81 +81 @@
 }
 
-SharedClipboardWinStreamImpl::~SharedClipboardWinStreamImpl(void)
+ShClWinStreamImpl::~ShClWinStreamImpl(void)
 {
     LogFlowThisFuncEnter();
@@ -95 +95 @@
  */
 
-STDMETHODIMP SharedClipboardWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject)
+STDMETHODIMP ShClWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject)
 {
     AssertPtrReturn(ppvObject, E_INVALIDARG);
@@ -124 +124 @@
 }
 
-STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::AddRef(void)
+STDMETHODIMP_(ULONG) ShClWinStreamImpl::AddRef(void)
 {
     LONG lCount = InterlockedIncrement(&m_lRefCount);
@@ -131 +131 @@
 }
 
-STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::Release(void)
+STDMETHODIMP_(ULONG) ShClWinStreamImpl::Release(void)
 {
     LONG lCount = InterlockedDecrement(&m_lRefCount);
@@ -148 +148 @@
  */
 
-STDMETHODIMP SharedClipboardWinStreamImpl::Clone(IStream** ppStream)
+STDMETHODIMP ShClWinStreamImpl::Clone(IStream** ppStream)
 {
     RT_NOREF(ppStream);
@@ -156 +156 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::Commit(DWORD dwFrags)
+STDMETHODIMP ShClWinStreamImpl::Commit(DWORD dwFrags)
 {
     RT_NOREF(dwFrags);
@@ -164 +164 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead,
+STDMETHODIMP ShClWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead,
                                                   ULARGE_INTEGER *nBytesWritten)
 {
@@ -173 +173 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags)
+STDMETHODIMP ShClWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags)
 {
     RT_NOREF(nStart, nBytes, dwFlags);
@@ -182 +182 @@
 
 /* Note: Windows seems to assume EOF if nBytesRead < nBytesToRead. */
-STDMETHODIMP SharedClipboardWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
+STDMETHODIMP ShClWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
 {
     LogFlowThisFunc(("Enter: m_cbProcessed=%RU64\n", m_cbProcessed));
@@ -249 +249 @@
 
             if (m_pParent)
-                m_pParent->SetStatus(SharedClipboardWinDataObject::Completed);
+                m_pParent->SetStatus(ShClWinDataObject::Completed);
         }
     }
@@ -256 +256 @@
     {
         if (m_pParent)
-            m_pParent->SetStatus(SharedClipboardWinDataObject::Error, rc /* Propagate rc */);
+            m_pParent->SetStatus(ShClWinDataObject::Error, rc /* Propagate rc */);
     }
 
@@ -271 +271 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::Revert(void)
-{
-    LogFlowThisFuncEnter();
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP SharedClipboardWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos)
+STDMETHODIMP ShClWinStreamImpl::Revert(void)
+{
+    LogFlowThisFuncEnter();
+    return E_NOTIMPL;
+}
+
+STDMETHODIMP ShClWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos)
 {
     RT_NOREF(nMove, dwOrigin, nNewPos);
@@ -286 +286 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize)
+STDMETHODIMP ShClWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize)
 {
     RT_NOREF(nNewSize);
@@ -294 +294 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags)
+STDMETHODIMP ShClWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags)
 {
     HRESULT hr = S_OK;
@@ -355 +355 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags)
+STDMETHODIMP ShClWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags)
 {
     RT_NOREF(nStart, nBytes, dwFlags);
@@ -363 +363 @@
 }
 
-STDMETHODIMP SharedClipboardWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
+STDMETHODIMP ShClWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
 {
     RT_NOREF(pvBuffer, nBytesToRead, nBytesRead);
@@ -386 +386 @@
  */
 /* static */
-HRESULT SharedClipboardWinStreamImpl::Create(SharedClipboardWinDataObject *pParent, PSHCLTRANSFER pTransfer,
+HRESULT ShClWinStreamImpl::Create(ShClWinDataObject *pParent, PSHCLTRANSFER pTransfer,
                                              const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo,
                                              IStream **ppStream)
@@ -392 +392 @@
     AssertPtrReturn(pTransfer, E_POINTER);
 
-    SharedClipboardWinStreamImpl *pStream = new SharedClipboardWinStreamImpl(pParent, pTransfer, strPath, pObjInfo);
+    ShClWinStreamImpl *pStream = new ShClWinStreamImpl(pParent, pTransfer, strPath, pObjInfo);
     if (pStream)
     {

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp

@@ -54 +54 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-int SharedClipboardWinTransferDropFilesToStringList(DROPFILES *pDropFiles, char **ppszList, uint32_t *pcbList);
+int ShClWinTransferDropFilesToStringList(DROPFILES *pDropFiles, char **ppszList, uint32_t *pcbList);
 #endif
 
@@ -64 +64 @@
  * @param   hWnd                Handle of window to open clipboard for.
  */
-int SharedClipboardWinOpen(HWND hWnd)
+int ShClWinOpen(HWND hWnd)
 {
     /* "OpenClipboard fails if another window has the clipboard open."
@@ -112 +112 @@
  * @returns VBox status code.
  */
-int SharedClipboardWinClose(void)
+int ShClWinClose(void)
 {
     int rc;
@@ -142 +142 @@
  * @returns VBox status code.
  */
-int SharedClipboardWinClear(void)
+int ShClWinClear(void)
 {
     LogFlowFuncEnter();
@@ -164 +164 @@
  * @param   pWinCtx             Shared Clipboard Windows context to initialize.
  */
-int SharedClipboardWinCtxInit(PSHCLWINCTX pWinCtx)
+int ShClWinCtxInit(PSHCLWINCTX pWinCtx)
 {
     int rc = RTCritSectInit(&pWinCtx->CritSect);
@@ -170 +170 @@
     {
         /* Check that new Clipboard API is available. */
-        SharedClipboardWinCheckAndInitNewAPI(&pWinCtx->newAPI);
+        ShClWinCheckAndInitNewAPI(&pWinCtx->newAPI);
         /* Do *not* check the rc, as the call might return VERR_SYMBOL_NOT_FOUND is the new API isn't available. */
 
@@ -191 +191 @@
  * @param   pWinCtx             Shared Clipboard Windows context to destroy.
  */
-void SharedClipboardWinCtxDestroy(PSHCLWINCTX pWinCtx)
+void ShClWinCtxDestroy(PSHCLWINCTX pWinCtx)
 {
     if (!pWinCtx)
@@ -213 +213 @@
  *                              Will be set to NULL if the new API is not available.
  */
-int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI)
+int ShClWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI)
 {
     RTLDRMOD hUser32 = NIL_RTLDRMOD;
@@ -248 +248 @@
  * @param   pAPI                Structure used for checking if the new clipboard API is available or not.
  */
-bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI)
+bool ShClWinIsNewAPI(PSHCLWINAPINEW pAPI)
 {
     if (!pAPI)
@@ -261 +261 @@
  * @param   pCtx                Windows clipboard context to use to add ourselves.
  */
-int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx)
+int ShClWinChainAdd(PSHCLWINCTX pCtx)
 {
     const PSHCLWINAPINEW pAPI = &pCtx->newAPI;
 
     BOOL fRc;
-    if (SharedClipboardWinIsNewAPI(pAPI))
+    if (ShClWinIsNewAPI(pAPI))
         fRc = pAPI->pfnAddClipboardFormatListener(pCtx->hWnd);
     else
@@ -293 +293 @@
  * @param   pCtx                Windows clipboard context to use to remove ourselves.
  */
-int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx)
+int ShClWinChainRemove(PSHCLWINCTX pCtx)
 {
     if (!pCtx->hWnd)
@@ -301 +301 @@
 
     BOOL fRc;
-    if (SharedClipboardWinIsNewAPI(pAPI))
+    if (ShClWinIsNewAPI(pAPI))
     {
         fRc = pAPI->pfnRemoveClipboardFormatListener(pCtx->hWnd);
@@ -335 +335 @@
  * @param   lResult             Additional data to pass. Not used currently.
  */
-VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult) RT_NOTHROW_DEF
+VOID CALLBACK ShClWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult) RT_NOTHROW_DEF
 {
     RT_NOREF(hWnd);
@@ -357 +357 @@
  * @param   lParam              LPARAM to pass.
  */
-LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx,
+LRESULT ShClWinChainPassToNext(PSHCLWINCTX pWinCtx,
                                           UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -386 +386 @@
  * @param   uFormat             Windows clipboard format to convert.
  */
-SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat)
+SHCLFORMAT ShClWinClipboardFormatToVBox(UINT uFormat)
 {
     /* Insert the requested clipboard format data into the clipboard. */
@@ -445 +445 @@
  * @param   pfFormats           Where to store the retrieved formats.
  */
-int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATS pfFormats)
+int ShClWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATS pfFormats)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
@@ -453 +453 @@
 
     /* Query list of available formats and report to host. */
-    int rc = SharedClipboardWinOpen(pCtx->hWnd);
+    int rc = ShClWinOpen(pCtx->hWnd);
     if (RT_SUCCESS(rc))
     {
         UINT uCurFormat = 0; /* Must be set to zero for EnumClipboardFormats(). */
         while ((uCurFormat = EnumClipboardFormats(uCurFormat)) != 0)
-            fFormats |= SharedClipboardWinClipboardFormatToVBox(uCurFormat);
-
-        int rc2 = SharedClipboardWinClose();
+            fFormats |= ShClWinClipboardFormatToVBox(uCurFormat);
+
+        int rc2 = ShClWinClose();
         AssertRC(rc2);
         LogFlowFunc(("fFormats=%#x\n", fFormats));
@@ -479 +479 @@
  * @param   puValue     Where to return extracted value of CF_HTML field.
  */
-int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue)
+int ShClWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue)
 {
     AssertPtrReturn(pszSrc, VERR_INVALID_POINTER);
@@ -503 +503 @@
  * @param   pszSource   Source string to check.
  */
-bool SharedClipboardWinIsCFHTML(const char *pszSource)
+bool ShClWinIsCFHTML(const char *pszSource)
 {
     return    RTStrStr(pszSource, "Version:") != NULL
@@ -520 +520 @@
  * @param   pcbOutput   Where to the return length of the result (bytes/chars).
  */
-int SharedClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput)
+int ShClWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput)
 {
     Assert(pszSource);
@@ -528 +528 @@
 
     uint32_t offStart;
-    int rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart);
+    int rc = ShClWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart);
     if (RT_SUCCESS(rc))
     {
         uint32_t offEnd;
-        rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd);
+        rc = ShClWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd);
         if (RT_SUCCESS(rc))
         {
@@ -612 +612 @@
  * @note    Everything inside of fragment can be UTF8. Windows allows it. Everything in header should be Latin1.
  */
-int SharedClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput)
+int ShClWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput)
 {
     Assert(ppszOutput);
@@ -709 +709 @@
  * @param   lParam              lParam to pass on.
  */
-LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx,
+LRESULT ShClWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx,
                                               HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -716 +716 @@
     LogFlowFuncEnter();
 
-    if (SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
+    if (ShClWinIsNewAPI(&pWinCtx->newAPI))
     {
         lresultRc = DefWindowProc(hWnd, msg, wParam, lParam);
@@ -757 +757 @@
  * @param   pWinCtx             Windows context to use.
  */
-int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx)
+int ShClWinHandleWMDestroy(PSHCLWINCTX pWinCtx)
 {
     LogFlowFuncEnter();
@@ -764 +764 @@
 
     /* MS recommends to remove from Clipboard chain in this callback. */
-    SharedClipboardWinChainRemove(pWinCtx);
+    ShClWinChainRemove(pWinCtx);
 
     if (pWinCtx->oldAPI.timerRefresh)
@@ -783 +783 @@
  * @param   hWnd                Window handle to use.
  */
-int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd)
+int ShClWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd)
 {
     RT_NOREF(pWinCtx);
@@ -792 +792 @@
      * windows is to be destroyed and therefore the guest side becomes inactive.
      */
-    int rc = SharedClipboardWinOpen(hWnd);
+    int rc = ShClWinOpen(hWnd);
     if (RT_SUCCESS(rc))
     {
-        SharedClipboardWinClear();
-        SharedClipboardWinClose();
+        ShClWinClear();
+        ShClWinClose();
     }
 
@@ -810 +810 @@
  * @param   pWinCtx             Windows context to use.
  */
-int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx)
+int ShClWinHandleWMTimer(PSHCLWINCTX pWinCtx)
 {
     int rc = VINF_SUCCESS;
 
-    if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */
+    if (!ShClWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */
     {
         LogFlowFuncEnter();
@@ -824 +824 @@
         if (!hViewer || pWinCtx->oldAPI.fCBChainPingInProcess)
         {
-            SharedClipboardWinChainRemove(pWinCtx);
-            SharedClipboardWinChainAdd(pWinCtx);
+            ShClWinChainRemove(pWinCtx);
+            ShClWinChainAdd(pWinCtx);
        }
 
@@ -835 +835 @@
        if (hViewer)
            SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain,
-                               SharedClipboardWinChainPingProc, (ULONG_PTR)pWinCtx);
+                               ShClWinChainPingProc, (ULONG_PTR)pWinCtx);
     }
 
@@ -853 +853 @@
  * @param   fFormats            Clipboard format(s) to announce.
  */
-static int sharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats)
+static int shClWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats)
 {
     LogFunc(("fFormats=0x%x\n", fFormats));
@@ -960 +960 @@
  * @param   hWnd        The window handle to use as owner.
  */
-int SharedClipboardWinClearAndAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats, HWND hWnd)
-{
-    int rc = SharedClipboardWinOpen(hWnd);
+int ShClWinClearAndAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats, HWND hWnd)
+{
+    int rc = ShClWinOpen(hWnd);
     if (RT_SUCCESS(rc))
     {
-        SharedClipboardWinClear();
-
-        rc = sharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
+        ShClWinClear();
+
+        rc = shClWinAnnounceFormats(pWinCtx, fFormats);
         Assert(pWinCtx->hWndClipboardOwnerUs == hWnd || pWinCtx->hWndClipboardOwnerUs == NULL);
 
-        SharedClipboardWinClose();
+        ShClWinClose();
     }
     return rc;
@@ -985 +985 @@
  * @note    ASSUMES that the clipboard has already been opened.
  */
-int SharedClipboardWinDataWrite(UINT cfFormat, void *pvData, uint32_t cbData)
+int ShClWinDataWrite(UINT cfFormat, void *pvData, uint32_t cbData)
 {
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
@@ -1053 +1053 @@
  * @param   pCallbacks          Callbacks table to use.
  */
-int SharedClipboardWinTransferCreateAndSetDataObject(PSHCLWINCTX pWinCtx,
-                                                     PSHCLCONTEXT pCtx, SharedClipboardWinDataObject::PCALLBACKS pCallbacks)
+int ShClWinTransferCreateAndSetDataObject(PSHCLWINCTX pWinCtx,
+                                                     PSHCLCONTEXT pCtx, ShClWinDataObject::PCALLBACKS pCallbacks)
 {
     AssertPtrReturn(pWinCtx, VERR_INVALID_POINTER);
@@ -1072 +1072 @@
          * The data object will be deleted automatically once its refcount reaches 0.
          */
-        SharedClipboardWinDataObject *pObj = new SharedClipboardWinDataObject();
+        ShClWinDataObject *pObj = new ShClWinDataObject();
         if (pObj)
         {
@@ -1087 +1087 @@
         if (RT_SUCCESS(rc))
         {
-            SharedClipboardWinClose();
+            ShClWinClose();
             /* Note: Clipboard must be closed first before calling OleSetClipboard(). */
 
-            /** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(),
+            /** @todo There is a potential race between ShClWinClose() and OleSetClipboard(),
              *        where another application could own the clipboard (open), and thus the call to
              *        OleSetClipboard() will fail. Needs (better) fixing. */
@@ -1139 +1139 @@
  * @param   pTransfer           Shared Clipboard transfer to create implementation-specific data for.
  */
-int SharedClipboardWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
+int ShClWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pWinCtx);
@@ -1146 +1146 @@
                     && pTransfer->cbUser == 0, ("Already initialized Windows-specific data\n"), VERR_WRONG_ORDER);
 
-    pTransfer->pvUser = new SharedClipboardWinTransferCtx();  /** @todo Can this throw? */
+    pTransfer->pvUser = new ShClWinTransferCtx();  /** @todo Can this throw? */
     AssertPtrReturn(pTransfer->pvUser, VERR_INVALID_POINTER);
-    pTransfer->cbUser = sizeof(SharedClipboardWinTransferCtx);
+    pTransfer->cbUser = sizeof(ShClWinTransferCtx);
 
     return VINF_SUCCESS;
@@ -1160 +1160 @@
  * @param   pTransfer           Shared Clipboard transfer to destroy implementation-specific data for.
  */
-void SharedClipboardWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
+void ShClWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pWinCtx);
@@ -1171 +1171 @@
     if (pTransfer->pvUser)
     {
-        Assert(pTransfer->cbUser == sizeof(SharedClipboardWinTransferCtx));
-        SharedClipboardWinTransferCtx *pWinURITransferCtx = (SharedClipboardWinTransferCtx *)pTransfer->pvUser;
+        Assert(pTransfer->cbUser == sizeof(ShClWinTransferCtx));
+        ShClWinTransferCtx *pWinURITransferCtx = (ShClWinTransferCtx *)pTransfer->pvUser;
         AssertPtr(pWinURITransferCtx);
 
@@ -1199 +1199 @@
  * @param   pObj                Data object to initialize transfer for.
  */
-static int sharedClipboardWinTransferInitializeInternal(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer,
-                                                        SharedClipboardWinDataObject *pObj)
+static int shClWinTransferInitializeInternal(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer,
+                                             ShClWinDataObject *pObj)
 {
     RT_NOREF(pWinCtx);
@@ -1215 +1215 @@
  * @param   pTransfer           Transfer to initialize for the data object.
  */
-int SharedClipboardWinTransferInitialize(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
+int ShClWinTransferInitialize(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     int rc = RTCritSectEnter(&pWinCtx->CritSect);
     if (RT_SUCCESS(rc))
     {
-        SharedClipboardWinDataObject *pObj = pWinCtx->pDataObjInFlight;
+        ShClWinDataObject *pObj = pWinCtx->pDataObjInFlight;
         if (pObj)
         {
-            rc = sharedClipboardWinTransferInitializeInternal(pWinCtx, pTransfer, pObj);
+            rc = shClWinTransferInitializeInternal(pWinCtx, pTransfer, pObj);
         }
         else /* No current in-flight data object. */
@@ -1242 +1242 @@
  * @param   pObj                Data object to start transfer for.
  */
-static int sharedClipboardWinTransferStartInternal(PSHCLWINCTX pWinCtx, SharedClipboardWinDataObject *pObj)
+static int shClWinTransferStartInternal(PSHCLWINCTX pWinCtx, ShClWinDataObject *pObj)
 {
     RT_NOREF(pWinCtx);
 
-    return pObj->SetStatus(SharedClipboardWinDataObject::Running);
+    return pObj->SetStatus(ShClWinDataObject::Running);
 }
 
@@ -1259 +1259 @@
  * @param   pTransfer           Transfer to initialize for the data object.
  */
-int SharedClipboardWinTransferStart(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
+int ShClWinTransferStart(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pTransfer);
@@ -1266 +1266 @@
     if (RT_SUCCESS(rc))
     {
-        SharedClipboardWinDataObject *pObj = pWinCtx->pDataObjInFlight;
+        ShClWinDataObject *pObj = pWinCtx->pDataObjInFlight;
         if (pObj)
         {
-            rc = sharedClipboardWinTransferStartInternal(pWinCtx, pObj);
+            rc = shClWinTransferStartInternal(pWinCtx, pObj);
             if (RT_SUCCESS(rc))
                 pWinCtx->pDataObjInFlight = NULL; /* Hand off to Windows on success. */
@@ -1291 +1291 @@
  * @param   pTransfer           Transfer to get roots for.
  */
-int SharedClipboardWinTransferGetRootsFromClipboard(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
+int ShClWinTransferGetRootsFromClipboard(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pWinCtx,   VERR_INVALID_POINTER);
@@ -1298 +1298 @@
     Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
 
-    int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
+    int rc = ShClWinOpen(pWinCtx->hWnd);
     if (RT_SUCCESS(rc))
     {
@@ -1311 +1311 @@
                 char    *pszList = NULL;
                 uint32_t cbList;
-                rc = SharedClipboardWinTransferDropFilesToStringList((DROPFILES *)hDrop, &pszList, &cbList);
+                rc = ShClWinTransferDropFilesToStringList((DROPFILES *)hDrop, &pszList, &cbList);
 
                 GlobalUnlock(hClip);
@@ -1328 +1328 @@
                     GetLastError()));
 
-        SharedClipboardWinClose();
+        ShClWinClose();
     }
 
@@ -1346 +1346 @@
  *                              Includes zero terminator.
  */
-int SharedClipboardWinTransferDropFilesToStringList(DROPFILES *pDropFiles, char **ppszList, uint32_t *pcbList)
+int ShClWinTransferDropFilesToStringList(DROPFILES *pDropFiles, char **ppszList, uint32_t *pcbList)
 {
     AssertPtrReturn(pDropFiles, VERR_INVALID_POINTER);