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

Timestamp:

Oct 11, 2019 12:06:49 PM (6 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

133910

Message:

Shared Clipboard/Transfers: Renaming.

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• ClipboardDataObjectImpl-win.cpp (modified) (10 diffs)
• ClipboardMIME.cpp (modified) (2 diffs)
• ClipboardPath.cpp (modified) (2 diffs)
• ClipboardStreamImpl-win.cpp (modified) (2 diffs)
• clipboard-common.cpp (modified) (36 diffs)
• clipboard-transfers.cpp (modified) (109 diffs)
• clipboard-win.cpp (modified) (2 diffs)
• clipboard-x11.cpp (modified) (6 diffs)

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

@@ -238 +238 @@
 
     SHCLLISTOPENPARMS openParmsList;
-    int rc = SharedClipboardTransferListOpenParmsInit(&openParmsList);
+    int rc = ShClTransferListOpenParmsInit(&openParmsList);
     if (RT_SUCCESS(rc))
     {
@@ -245 +245 @@
         {
             SHCLLISTHANDLE hList;
-            rc = SharedClipboardTransferListOpen(pTransfer, &openParmsList, &hList);
+            rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList);
             if (RT_SUCCESS(rc))
             {
@@ -251 +251 @@
 
                 SHCLLISTHDR hdrList;
-                rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
+                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
                 if (RT_SUCCESS(rc))
                 {
@@ -260 +260 @@
                     {
                         SHCLLISTENTRY entryList;
-                        rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
+                        rc = ShClTransferListRead(pTransfer, hList, &entryList);
                         if (RT_SUCCESS(rc))
                         {
@@ -295 +295 @@
                 }
 
-                SharedClipboardTransferListClose(pTransfer, hList);
+                ShClTransferListClose(pTransfer, hList);
             }
         }
 
-        SharedClipboardTransferListOpenParmsDestroy(&openParmsList);
+        ShClTransferListOpenParmsDestroy(&openParmsList);
     }
 
@@ -334 +334 @@
     LogRel2(("Shared Clipboard: Calculating transfer ...\n"));
 
-    int rc = SharedClipboardTransferOpen(pTransfer);
+    int rc = ShClTransferOpen(pTransfer);
     if (RT_SUCCESS(rc))
     {
         PSHCLROOTLIST pRootList;
-        rc = SharedClipboardTransferRootsGet(pTransfer, &pRootList);
+        rc = ShClTransferRootsGet(pTransfer, &pRootList);
         if (RT_SUCCESS(rc))
         {
@@ -378 +378 @@
             }
 
-            SharedClipboardTransferRootListFree(pRootList);
+            ShClTransferRootListFree(pRootList);
             pRootList = NULL;
 
@@ -410 +410 @@
         }
 
-        SharedClipboardTransferClose(pTransfer);
+        ShClTransferClose(pTransfer);
     }
 
@@ -574 +574 @@
         const bool fUnicode = pFormatEtc->cfFormat == m_cfFileDescriptorW;
 
-        const uint32_t enmTransferStatus = SharedClipboardTransferGetStatus(m_pTransfer);
+        const uint32_t enmTransferStatus = ShClTransferGetStatus(m_pTransfer);
         RT_NOREF(enmTransferStatus);
 
         LogFlowFunc(("FormatIndex_FileDescriptor%s, enmTransferStatus=%s, m_fRunning=%RTbool\n",
-                     fUnicode ? "W" : "A", VBoxShClTransferStatusToStr(enmTransferStatus), m_fRunning));
+                     fUnicode ? "W" : "A", ShClTransferStatusToStr(enmTransferStatus), m_fRunning));
 
         int rc;
@@ -586 +586 @@
         {
             /* Start the transfer asynchronously in a separate thread. */
-            rc = SharedClipboardTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
+            rc = ShClTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
             if (RT_SUCCESS(rc))
             {

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp

@@ -26 +26 @@
 
 
-bool SharedClipboardMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
+bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
 {
     /** @todo "text/uri" also an official variant? */
@@ -33 +33 @@
 }
 
-bool SharedClipboardMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax)
+bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax)
 {
     bool fNeedsDropDir = false;

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp

@@ -36 +36 @@
  * @param   cbPath              Size (in bytes) of path to sanitize.
  */
-int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath)
+int ShClPathSanitizeFilename(char *pszPath, size_t cbPath)
 {
     int rc = VINF_SUCCESS;
@@ -72 +72 @@
  * @param   cbPath              Size (in bytes) of the path to sanitize.
  */
-int SharedClipboardPathSanitize(char *pszPath, size_t cbPath)
+int ShClPathSanitize(char *pszPath, size_t cbPath)
 {
     RT_NOREF(pszPath, cbPath);

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

@@ -188 +188 @@
         {
             SHCLOBJOPENCREATEPARMS openParms;
-            rc = SharedClipboardTransferObjectOpenParmsInit(&openParms);
+            rc = ShClTransferObjOpenParmsInit(&openParms);
             if (RT_SUCCESS(rc))
             {
@@ -202 +202 @@
                 }
 
-                SharedClipboardTransferObjectOpenParmsDestroy(&openParms);
+                ShClTransferObjOpenParmsDestroy(&openParms);
             }
         }

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

@@ -41 +41 @@
  * @param   ppPayload           Where to store the allocated event payload on success.
  */
-int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
-                                PSHCLEVENTPAYLOAD *ppPayload)
+int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
+                     PSHCLEVENTPAYLOAD *ppPayload)
 {
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
@@ -75 +75 @@
  * @param   pPayload            Event payload to free.
  */
-void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload)
+void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload)
 {
     if (!pPayload)
@@ -100 +100 @@
  * @param   uID                 Event ID to use.
  */
-int SharedClipboardEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
+int ShClEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
@@ -121 +121 @@
  * @param   pEvent              Event to destroy.
  */
-void SharedClipboardEventDestroy(PSHCLEVENT pEvent)
+void ShClEventDestroy(PSHCLEVENT pEvent)
 {
     if (!pEvent)
@@ -134 +134 @@
     }
 
-    SharedClipboardPayloadFree(pEvent->pPayload);
+    ShClPayloadFree(pEvent->pPayload);
 
     pEvent->uID = 0;
@@ -146 +146 @@
  * @param   uID                 ID to use for event source.
  */
-int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
+int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -169 +169 @@
  * @param   pSource             Event source to destroy.
  */
-void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource)
+void ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource)
 {
     if (!pSource)
@@ -182 +182 @@
         RTListNodeRemove(&pEvIt->Node);
 
-        SharedClipboardEventDestroy(pEvIt);
+        ShClEventDestroy(pEvIt);
 
         RTMemFree(pEvIt);
@@ -198 +198 @@
  * @param   pSource             Event source to generate event for.
  */
-SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource)
+SHCLEVENTID ShClEventIDGenerate(PSHCLEVENTSOURCE pSource)
 {
     AssertPtrReturn(pSource, 0);
@@ -218 +218 @@
  * @param   uID                 Event ID to get.
  */
-inline PSHCLEVENT sharedClipboardEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+inline PSHCLEVENT shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     PSHCLEVENT pEvIt;
@@ -236 +236 @@
  * @param   pSource             Event source to get last registered event from.
  */
-SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource)
+SHCLEVENTID ShClEventGetLast(PSHCLEVENTSOURCE pSource)
 {
     AssertPtrReturn(pSource, 0);
@@ -251 +251 @@
  * @param   pEvent              Event to detach payload for.
  */
-static void sharedClipboardEventPayloadDetachInternal(PSHCLEVENT pEvent)
+static void shclEventPayloadDetachInternal(PSHCLEVENT pEvent)
 {
     AssertPtrReturnVoid(pEvent);
@@ -265 +265 @@
  * @param   uID                 Event ID to register.
  */
-int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+int ShClEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -273 +273 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    if (sharedClipboardEventGet(pSource, uID) == NULL)
+    if (shclEventGet(pSource, uID) == NULL)
     {
         PSHCLEVENT pEvent
@@ -279 +279 @@
         if (pEvent)
         {
-            rc = SharedClipboardEventCreate(pEvent, uID);
+            rc = ShClEventCreate(pEvent, uID);
             if (RT_SUCCESS(rc))
             {
@@ -308 +308 @@
  * @param   uID                 Event ID to unregister.
  */
-int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+int ShClEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -316 +316 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
@@ -323 +323 @@
         RTListNodeRemove(&pEvent->Node);
 
-        SharedClipboardEventDestroy(pEvent);
+        ShClEventDestroy(pEvent);
 
         RTMemFree(pEvent);
@@ -347 +347 @@
  *                              SharedClipboardPayloadFree(). Optional.
  */
-int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
-                             PSHCLEVENTPAYLOAD* ppPayload)
+int ShClEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
+                  PSHCLEVENTPAYLOAD* ppPayload)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -357 +357 @@
     int rc;
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
@@ -368 +368 @@
 
                 /* Make sure to detach payload here, as the caller now owns the data. */
-                sharedClipboardEventPayloadDetachInternal(pEvent);
+                shclEventPayloadDetachInternal(pEvent);
             }
         }
@@ -387 +387 @@
  * @param   pPayload            Event payload to associate. Takes ownership. Optional.
  */
-int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID,
-                               PSHCLEVENTPAYLOAD pPayload)
+int ShClEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID,
+                    PSHCLEVENTPAYLOAD pPayload)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -396 +396 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
@@ -419 +419 @@
  * @param   uID                 Event ID to detach payload for.
  */
-void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+void ShClEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturnVoid(pSource);
@@ -425 +425 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
-        sharedClipboardEventPayloadDetachInternal(pEvent);
+        shclEventPayloadDetachInternal(pEvent);
     }
 #ifdef DEBUG_andy
@@ -438 +438 @@
 /** @todo use const where appropriate; delinuxify the code (*Lin* -> *Host*); use AssertLogRel*. */
 
-int vboxClipboardUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
+int ShClUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
 {
     size_t cwDest, i;
@@ -483 +483 @@
 }
 
-int vboxClipboardUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest,
-                               size_t cwDest)
+int ShClUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest, size_t cwDest)
 {
     size_t i, j;
@@ -561 +560 @@
 }
 
-int vboxClipboardUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
+int ShClUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
 {
     size_t cwDest;
@@ -609 +608 @@
 }
 
-int vboxClipboardUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest,
-                               size_t cwDest)
+int ShClUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest, size_t cwDest)
 {
     size_t cwDestPos;
@@ -680 +678 @@
 }
 
-int vboxClipboardDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
+int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
 {
     size_t        cb            = sizeof(BMFILEHEADER) + cbSrc;
@@ -728 +726 @@
 }
 
-int vboxClipboardBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
+int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
 {
     AssertPtrReturn(pvSrc,   VERR_INVALID_PARAMETER);
@@ -749 +747 @@
 
 #ifdef LOG_ENABLED
-int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
+int ShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
 {
     size_t cchIgnored = 0;
@@ -777 +775 @@
 }
 
-void VBoxShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
+void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
 {
     if (u32Format & VBOX_SHCL_FMT_UNICODETEXT)
@@ -822 +820 @@
  * @param   uFn                 The function to translate.
  */
-const char *VBoxShClHostFunctionToStr(uint32_t uFn)
+const char *ShClHostFunctionToStr(uint32_t uFn)
 {
     switch (uFn)
@@ -844 +842 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxShClHostMsgToStr(uint32_t uMsg)
+const char *ShClHostMsgToStr(uint32_t uMsg)
 {
     switch (uMsg)
@@ -878 +876 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxShClGuestMsgToStr(uint32_t uMsg)
+const char *ShClGuestMsgToStr(uint32_t uMsg)
 {
     switch (uMsg)

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

@@ -44 +44 @@
  * @returns Allocated transfer root list on success, or NULL on failure.
  */
-PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void)
+PSHCLROOTLIST ShClTransferRootListAlloc(void)
 {
     PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST));
@@ -57 +57 @@
  *                              invalid after returning from this function.
  */
-void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList)
+void ShClTransferRootListFree(PSHCLROOTLIST pRootList)
 {
     if (!pRootList)
@@ -63 +63 @@
 
     for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
-        SharedClipboardTransferListEntryDestroy(&pRootList->paEntries[i]);
+        ShClTransferListEntryInit(&pRootList->paEntries[i]);
 
     RTMemFree(pRootList);
@@ -75 +75 @@
  * @param   pRootLstHdr         Root list header to initialize.
  */
-int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
+int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER);
@@ -89 +89 @@
  * @param   pRootLstHdr         Root list header to destroy.
  */
-void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
+void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
 {
     if (!pRootLstHdr)
@@ -104 +104 @@
  * @param   pRootLstHdr         Root list header to duplicate.
  */
-PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
+PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, NULL);
@@ -120 +120 @@
     if (RT_FAILURE(rc))
     {
-        SharedClipboardTransferRootListHdrDestroy(pRootsDup);
+        ShClTransferRootListHdrDestroy(pRootsDup);
         pRootsDup = NULL;
     }
@@ -134 +134 @@
  * @param   pSrc                Source root list entry to copy.
  */
-int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
-{
-    return SharedClipboardTransferListEntryCopy(pDst, pSrc);
+int ShClTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
+{
+    return ShClTransferListEntryCopy(pDst, pSrc);
 }
 
@@ -144 +144 @@
  * @param   pRootListEntry      Clipboard root list entry structure to destroy.
  */
-int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardTransferListEntryInit(pRootListEntry);
+int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return ShClTransferListEntryInit(pRootListEntry);
 }
 
@@ -154 +154 @@
  * @param   pRootListEntry      Clipboard root list entry structure to destroy.
  */
-void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardTransferListEntryDestroy(pRootListEntry);
+void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return ShClTransferListEntryDestroy(pRootListEntry);
 }
 
@@ -165 +165 @@
  * @param   pRootListEntry      Clipboard root list entry to duplicate.
  */
-PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardTransferListEntryDup(pRootListEntry);
+PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return ShClTransferListEntryDup(pRootListEntry);
 }
 
@@ -176 +176 @@
  * @param   pInfo               List handle info structure to initialize.
  */
-int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
+int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
 {
     AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
@@ -195 +195 @@
  * @param   pInfo               List handle info structure to destroy.
  */
-void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
+void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -213 +213 @@
  * @param   ppListHdr           Where to store the allocated transfer list header structure on success.
  */
-int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
+int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
 {
     int rc;
@@ -235 +235 @@
  * @param   pListEntry          transfer list header structure to free.
  */
-void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr)
+void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -242 +242 @@
     LogFlowFuncEnter();
 
-    SharedClipboardTransferListHdrDestroy(pListHdr);
+    ShClTransferListHdrDestroy(pListHdr);
 
     RTMemFree(pListHdr);
@@ -273 +273 @@
  * @param   pListHdr            Data header struct to initialize.
  */
-int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr)
+int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
@@ -279 +279 @@
     LogFlowFuncEnter();
 
-    SharedClipboardTransferListHdrReset(pListHdr);
+    ShClTransferListHdrReset(pListHdr);
 
     return VINF_SUCCESS;
@@ -289 +289 @@
  * @param   pListHdr            Data header struct to destroy.
  */
-void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
+void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -303 +303 @@
  * @param   pListHdr            SHCLListHdr structture to reset.
  */
-void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr)
+void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturnVoid(pListHdr);
@@ -318 +318 @@
  * @param   pListHdr            Clipboard data header to validate.
  */
-bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
+bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
 {
     RT_NOREF(pListHdr);
@@ -324 +324 @@
 }
 
-int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
+int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -362 +362 @@
  * @param   pParms              transfer list open parameters structure to duplicate.
  */
-PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
+PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, NULL);
@@ -370 +370 @@
         return NULL;
 
-    int rc = SharedClipboardTransferListOpenParmsCopy(pParmsDup, pParms);
+    int rc = ShClTransferListOpenParmsCopy(pParmsDup, pParms);
     if (RT_FAILURE(rc))
     {
-        SharedClipboardTransferListOpenParmsDestroy(pParmsDup);
+        ShClTransferListOpenParmsDestroy(pParmsDup);
 
         RTMemFree(pParmsDup);
@@ -388 +388 @@
  * @param   pParms              transfer list open parameters structure to initialize.
  */
-int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
+int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -409 +409 @@
  * @param   pParms              transfer list open parameters structure to destroy.
  */
-void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
+void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
 {
     if (!pParms)
@@ -432 +432 @@
  * @param   ppDirData           Where to return the created clipboard list entry structure on success.
  */
-int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
+int ShClTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
 {
     PSHCLLISTENTRY pListEntry = (PSHCLLISTENTRY)RTMemAlloc(sizeof(SHCLLISTENTRY));
@@ -438 +438 @@
         return VERR_NO_MEMORY;
 
-    int rc = SharedClipboardTransferListEntryInit(pListEntry);
+    int rc = ShClTransferListEntryInit(pListEntry);
     if (RT_SUCCESS(rc))
         *ppListEntry = pListEntry;
@@ -450 +450 @@
  * @param   pListEntry         Clipboard list entry structure to free.
  */
-void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry)
+void ShClTransferListEntryFree(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
         return;
 
-    SharedClipboardTransferListEntryDestroy(pListEntry);
+    ShClTransferListEntryDestroy(pListEntry);
     RTMemFree(pListEntry);
 }
@@ -465 +465 @@
  * @param   pListEntry          Clipboard list entry to copy.
  */
-int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
+int ShClTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -512 +512 @@
  * @param   pListEntry          Clipboard list entry to duplicate.
  */
-PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry)
+PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry)
 {
     AssertPtrReturn(pListEntry, NULL);
@@ -520 +520 @@
     PSHCLLISTENTRY pListEntryDup = (PSHCLLISTENTRY)RTMemAllocZ(sizeof(SHCLLISTENTRY));
     if (pListEntryDup)
-        rc = SharedClipboardTransferListEntryCopy(pListEntryDup, pListEntry);
+        rc = ShClTransferListEntryCopy(pListEntryDup, pListEntry);
 
     if (RT_FAILURE(rc))
     {
-        SharedClipboardTransferListEntryDestroy(pListEntryDup);
+        ShClTransferListEntryDestroy(pListEntryDup);
 
         RTMemFree(pListEntryDup);
@@ -539 +539 @@
  * @param   pListEntry          Clipboard list entry structure to initialize.
  */
-int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry)
+int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry)
 {
     RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY));
@@ -566 +566 @@
  * @param   pListEntry          Clipboard list entry structure to destroy.
  */
-void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
+void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
@@ -593 +593 @@
  * @param   pListEntry          Clipboard data chunk to validate.
  */
-bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
+bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
 {
     RT_NOREF(pListEntry);
@@ -608 +608 @@
  * @param   pObjCtx             transfer object context to initialize.
  */
-int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
+int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
@@ -624 +624 @@
  * @param   pObjCtx             transfer object context to destroy.
  */
-void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
+void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     AssertPtrReturnVoid(pObjCtx);
@@ -649 +649 @@
  * @param   pInfo               Object handle info structure to initialize.
  */
-int SharedClipboardTransferObjectHandleInfoInit(PSHCLOBJHANDLEINFO pInfo)
+int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo)
 {
     AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
@@ -668 +668 @@
  * @param   pInfo               Object handle info structure to destroy.
  */
-void SharedClipboardTransferObjectHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
+void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -686 +686 @@
  * @param   pParms              transfer object open parameters structure to initialize.
  */
-int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
+int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -714 +714 @@
  * @param   pParmsSrc           Which source transfer object open parameters to copy.
  */
-int SharedClipboardTransferObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
+int ShClTransferObjOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
 {
     int rc;
@@ -743 +743 @@
  * @param   pParms              transfer object open parameters structure to destroy.
  */
-void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
+void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
 {
     if (!pParms)
@@ -783 +783 @@
  * @param   phObj               Where to store the handle of transfer object opened on success.
  */
-int SharedClipboardTransferObjectOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
-                                      PSHCLOBJHANDLE phObj)
+int ShClTransferObjOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
+                        PSHCLOBJHANDLE phObj)
 {
     AssertPtrReturn(pTransfer,        VERR_INVALID_POINTER);
@@ -800 +800 @@
         if (pInfo)
         {
-            rc = SharedClipboardTransferObjectHandleInfoInit(pInfo);
+            rc = ShClTransferObjHandleInfoInit(pInfo);
             if (RT_SUCCESS(rc))
             {
@@ -835 +835 @@
             else
             {
-                SharedClipboardTransferObjectHandleInfoDestroy(pInfo);
+                ShClTransferObjHandleInfoDestroy(pInfo);
                 RTMemFree(pInfo);
             }
@@ -863 +863 @@
  * @param   hObj                Handle of transfer object to close.
  */
-int SharedClipboardTransferObjectClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj)
+int ShClTransferObjClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -929 +929 @@
  * @param   pcbRead             How much bytes were read on success. Optional.
  */
-int SharedClipboardTransferObjectRead(PSHCLTRANSFER pTransfer,
-                                      SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
+int ShClTransferObjRead(PSHCLTRANSFER pTransfer,
+                        SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -991 +991 @@
  * @param   pcbWritten          How much bytes were writtenon success. Optional.
  */
-int SharedClipboardTransferObjectWrite(PSHCLTRANSFER pTransfer,
-                                       SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
-                                       uint32_t fFlags)
+int ShClTransferObjWrite(PSHCLTRANSFER pTransfer,
+                         SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
+                         uint32_t fFlags)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1043 +1043 @@
  * @param   pDataChunk          transfer object data chunk to duplicate.
  */
-PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
+PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1069 +1069 @@
  * @param   pDataChunk          transfer object data chunk to destroy.
  */
-void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
+void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1093 +1093 @@
  *                              be invalid after calling this function.
  */
-void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
+void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
         return;
 
-    SharedClipboardTransferObjectDataChunkDestroy(pDataChunk);
+    ShClTransferObjDataChunkDestroy(pDataChunk);
 
     RTMemFree(pDataChunk);
@@ -1111 +1111 @@
  *                              Must be destroyed by SharedClipboardTransferDestroy().
  */
-int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer)
+int ShClTransferCreate(PSHCLTRANSFER *ppTransfer)
 {
     AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER);
@@ -1164 +1164 @@
         if (pTransfer)
         {
-            SharedClipboardTransferDestroy(pTransfer);
+            ShClTransferDestroy(pTransfer);
             RTMemFree(pTransfer);
         }
@@ -1179 +1179 @@
  * @param   pTransferCtx                Clipboard transfer to destroy.
  */
-int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer)
+int ShClTransferDestroy(PSHCLTRANSFER pTransfer)
 {
     if (!pTransfer)
@@ -1192 +1192 @@
     RTStrFree(pTransfer->pszPathRootAbs);
 
-    SharedClipboardEventSourceDestroy(&pTransfer->Events);
+    ShClEventSourceDestroy(&pTransfer->Events);
 
     PSHCLLISTHANDLEINFO pItList, pItListNext;
     RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLLISTHANDLEINFO, Node)
     {
-        SharedClipboardTransferListHandleInfoDestroy(pItList);
+        ShClTransferListHandleInfoDestroy(pItList);
 
         RTListNodeRemove(&pItList->Node);
@@ -1207 +1207 @@
     RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLOBJHANDLEINFO, Node)
     {
-        SharedClipboardTransferObjectHandleInfoDestroy(pItObj);
+        ShClTransferObjHandleInfoDestroy(pItObj);
 
         RTListNodeRemove(&pItObj->Node);
@@ -1227 +1227 @@
  * @param   enmSource           Specifies the data source of the transfer.
  */
-int SharedClipboardTransferInit(PSHCLTRANSFER pTransfer,
-                                uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource)
+int ShClTransferInit(PSHCLTRANSFER pTransfer,
+                     uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource)
 {
     pTransfer->State.uID       = uID;
@@ -1237 +1237 @@
                  pTransfer->State.uID, pTransfer->State.enmDir, pTransfer->State.enmSource));
 
-    int rc = SharedClipboardEventSourceCreate(&pTransfer->Events, pTransfer->State.uID);
+    int rc = ShClEventSourceCreate(&pTransfer->Events, pTransfer->State.uID);
     if (RT_SUCCESS(rc))
     {
@@ -1253 +1253 @@
 }
 
-int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer)
+int ShClTransferOpen(PSHCLTRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1264 +1264 @@
 }
 
-int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer)
+int ShClTransferClose(PSHCLTRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1313 +1313 @@
  * @param   phList              Where to store the List handle of opened list on success.
  */
-int SharedClipboardTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
-                                    PSHCLLISTHANDLE phList)
+int ShClTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
+                         PSHCLLISTHANDLE phList)
 {
     AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
@@ -1332 +1332 @@
         if (pInfo)
         {
-            rc = SharedClipboardTransferListHandleInfoInit(pInfo);
+            rc = ShClTransferListHandleInfoInit(pInfo);
             if (RT_SUCCESS(rc))
             {
@@ -1378 +1378 @@
 
                 if (RT_FAILURE(rc))
-                    SharedClipboardTransferListHandleInfoDestroy(pInfo);
+                    ShClTransferListHandleInfoDestroy(pInfo);
             }
 
@@ -1416 +1416 @@
  * @param   hList               Handle of list to close.
  */
-int SharedClipboardTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
+int ShClTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1651 +1651 @@
  * @param   pHdr                Where to store the returned list header information.
  */
-int SharedClipboardTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                         PSHCLLISTHDR pHdr)
+int ShClTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                              PSHCLLISTHDR pHdr)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1666 +1666 @@
         if (pInfo)
         {
-            rc = SharedClipboardTransferListHdrInit(pHdr);
+            rc = ShClTransferListHdrInit(pHdr);
             if (RT_SUCCESS(rc))
             {
@@ -1735 +1735 @@
  * @param   uIdx                Index of object to get.
  */
-PSHCLTRANSFEROBJ SharedClipboardTransferListGetObj(PSHCLTRANSFER pTransfer,
-                                                   SHCLLISTHANDLE hList, uint64_t uIdx)
+PSHCLTRANSFEROBJ ShClTransferListGetObj(PSHCLTRANSFER pTransfer,
+                                        SHCLLISTHANDLE hList, uint64_t uIdx)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -1755 +1755 @@
  * @param   pEntry              Where to store the read information.
  */
-int SharedClipboardTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                    PSHCLLISTENTRY pEntry)
+int ShClTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                         PSHCLLISTENTRY pEntry)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1825 +1825 @@
                                     Assert   (pEntry->cbInfo == sizeof(SHCLFSOBJINFO));
 
-                                    SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
+                                    ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
                                 }
                             }
@@ -1856 +1856 @@
                             if (RT_SUCCESS(rc))
                             {
-                                SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
+                                ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
 
                                 pEntry->cbInfo = sizeof(SHCLFSOBJINFO);
@@ -1889 +1889 @@
 }
 
-int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                     PSHCLLISTENTRY pEntry)
+int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                          PSHCLLISTENTRY pEntry)
 {
     RT_NOREF(pTransfer, hList, pEntry);
@@ -1912 +1912 @@
  * @param   hList               List handle to check.
  */
-bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
+bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     bool fIsValid = false;
@@ -1935 +1935 @@
  * @param   pCreationCtx        Provider creation context to use for provider creation.
  */
-int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer,
-                                        PSHCLPROVIDERCREATIONCTX pCreationCtx)
+int ShClTransferSetInterface(PSHCLTRANSFER pTransfer,
+                             PSHCLPROVIDERCREATIONCTX pCreationCtx)
 {
     AssertPtrReturn(pTransfer,    VERR_INVALID_POINTER);
@@ -2001 +2001 @@
  * @param   pTransfer           Clipboard transfer to reset.
  */
-void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer)
+void ShClTransferReset(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2016 +2016 @@
  * @param   pTransfer           Clipboard transfer to return clipboard area for.
  */
-SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer)
+SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -2029 +2029 @@
  * @param   pTransfer           Clipboard transfer to return root entry count for.
  */
-uint32_t SharedClipboardTransferRootsCount(PSHCLTRANSFER pTransfer)
+uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2063 +2063 @@
  * @param   pEntry              Where to store the returned entry on success.
  */
-int SharedClipboardTransferRootsEntry(PSHCLTRANSFER pTransfer,
-                                      uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
+int ShClTransferRootsEntry(PSHCLTRANSFER pTransfer,
+                           uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2089 +2089 @@
         LogFlowFunc(("pcszSrcPath=%s, pszDstPath=%s\n", pcszSrcPath, pszDstPath));
 
-        rc = SharedClipboardTransferListEntryInit(pEntry);
+        rc = ShClTransferListEntryInit(pEntry);
         if (RT_SUCCESS(rc))
         {
@@ -2103 +2103 @@
                     if (RT_SUCCESS(rc))
                     {
-                        SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
+                        ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
 
                         pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO;
@@ -2127 +2127 @@
  * @param   ppRootList          Where to store the root list on success.
  */
-int SharedClipboardTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
+int ShClTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
 {
     AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
@@ -2138 +2138 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
+        PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
         if (!pRootList)
             return VERR_NO_MEMORY;
@@ -2154 +2154 @@
                 for (uint64_t i = 0; i < cRoots; ++i)
                 {
-                    rc = SharedClipboardTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
+                    rc = ShClTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
                     if (RT_FAILURE(rc))
                         break;
@@ -2198 +2198 @@
  * @param   cbRoots             Size (in bytes) of string list.
  */
-int SharedClipboardTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
+int ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
 {
     AssertPtrReturn(pTransfer,      VERR_INVALID_POINTER);
@@ -2267 +2267 @@
  * @param   pTransfer           Clipboard transfer to return ID for.
  */
-SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer)
+SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2280 +2280 @@
  * @param   pTransfer           Clipboard transfer to return direction for.
  */
-SHCLTRANSFERDIR SharedClipboardTransferGetDir(PSHCLTRANSFER pTransfer)
+SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLTRANSFERDIR_UNKNOWN);
@@ -2293 +2293 @@
  * @param   pTransfer           Clipboard transfer to return source for.
  */
-SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer)
+SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
@@ -2306 +2306 @@
  * @param   pTransfer           Clipboard transfer to return status for.
  */
-SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer)
+SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE);
@@ -2321 +2321 @@
  * @param   pvUser              Pointer to user-provided data. Optional.
  */
-int SharedClipboardTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
+int ShClTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
 {
     AssertPtrReturn(pTransfer,     VERR_INVALID_POINTER);
@@ -2328 +2328 @@
 
     AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_STARTED,
-                    ("Wrong status (currently is %s)\n", VBoxShClTransferStatusToStr(pTransfer->State.enmStatus)),
+                    ("Wrong status (currently is %s)\n", ShClTransferStatusToStr(pTransfer->State.enmStatus)),
                     VERR_WRONG_ORDER);
 
@@ -2343 +2343 @@
  * @param   pTransfer           Clipboard transfer to start.
  */
-int SharedClipboardTransferStart(PSHCLTRANSFER pTransfer)
+int ShClTransferStart(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2351 +2351 @@
     /* Ready to start? */
     AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_INITIALIZED,
-                    ("Wrong status (currently is %s)\n", VBoxShClTransferStatusToStr(pTransfer->State.enmStatus)),
+                    ("Wrong status (currently is %s)\n", ShClTransferStatusToStr(pTransfer->State.enmStatus)),
                     VERR_WRONG_ORDER);
 
@@ -2380 +2380 @@
  * @param   pCallbacks          Pointer to callback table to set.
  */
-void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer,
-                                         PSHCLTRANSFERCALLBACKS pCallbacks)
+void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer,
+                              PSHCLTRANSFERCALLBACKS pCallbacks)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2479 +2479 @@
  * @param   pTransferCtx                Transfer context to initialize.
  */
-int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
+int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER);
@@ -2496 +2496 @@
         RT_ZERO(pTransferCtx->bmTransferIds);
 
-        SharedClipboardTransferCtxReset(pTransferCtx);
+        ShClTransferCtxReset(pTransferCtx);
     }
 
@@ -2507 +2507 @@
  * @param   pTransferCtx                Transfer context to destroy.
  */
-void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
+void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturnVoid(pTransferCtx);
@@ -2518 +2518 @@
     RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
     {
-        SharedClipboardTransferDestroy(pTransfer);
+        ShClTransferDestroy(pTransfer);
 
         RTListNodeRemove(&pTransfer->Node);
@@ -2535 +2535 @@
  * @param   pTransferCtx                Transfer context to reset.
  */
-void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
+void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturnVoid(pTransferCtx);
@@ -2543 +2543 @@
     PSHCLTRANSFER pTransfer;
     RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node)
-        SharedClipboardTransferReset(pTransfer);
+        ShClTransferReset(pTransfer);
 }
 
@@ -2572 +2572 @@
  * @param   uID                 ID of the transfer to return.
  */
-PSHCLTRANSFER SharedClipboardTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
+PSHCLTRANSFER ShClTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
 {
     return sharedClipboardTransferCtxGetTransferInternal(pTransferCtx, uID);
@@ -2583 +2583 @@
  * @param   pTransferCtx                Transfer context to return number for.
  */
-uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
+uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, 0);
@@ -2595 +2595 @@
  * @param   pTransferCtx                Transfer context to return number for.
  */
-uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
+uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, 0);
@@ -2611 +2611 @@
  * @param   pidTransfer         Where to return the transfer ID on success. Optional.
  */
-int SharedClipboardTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer)
+int ShClTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer)
 {
     AssertPtrReturn(pTransferCtx,      VERR_INVALID_POINTER);
@@ -2664 +2664 @@
  * @param   idTransfer          Transfer ID to use for registration.
  */
-int SharedClipboardTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer)
+int ShClTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer)
 {
     LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pTransferCtx->cTransfers, idTransfer));
@@ -2693 +2693 @@
  * @param   idTransfer          Transfer ID to unregister.
  */
-int SharedClipboardTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer)
+int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -2719 +2719 @@
  * @param   pTransferCtx                Transfer context to cleanup transfers for.
  */
-void SharedClipboardTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx)
+void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturnVoid(pTransferCtx);
@@ -2733 +2733 @@
     RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
     {
-        if (SharedClipboardTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
-        {
-            SharedClipboardTransferDestroy(pTransfer);
+        if (ShClTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
+        {
+            ShClTransferDestroy(pTransfer);
             RTListNodeRemove(&pTransfer->Node);
 
@@ -2753 +2753 @@
  * @param   pTransferCtx                Transfer context to determine value for.
  */
-bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
+bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, true);
@@ -2769 +2769 @@
  * @param   pSrc                The IPRT structure to convert data from.
  */
-void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc)
+void ShClFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc)
 {
     pDst->cbObject          = pSrc->cbObject;
@@ -3055 +3055 @@
  * @param   enmStatus           The transfer status to translate.
  */
-const char *VBoxShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus)
+const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus)
 {
     switch (enmStatus)

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

@@ -1015 +1015 @@
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
 
-    Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
+    Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
 
     int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
@@ -1036 +1036 @@
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardTransferRootsSet(pTransfer,
-                                                         papszList, cbList + 1 /* Include termination */);
+                    rc = ShClTransferRootsSet(pTransfer,
+                                              papszList, cbList + 1 /* Include termination */);
                     RTStrFree(papszList);
                 }

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

@@ -1160 +1160 @@
     AssertPtr(pwszSrc);
     AssertPtr(pszBuf);
-    rc = vboxClipboardUtf16GetLinSize(pwszSrc, cwSrc, &cwTmp);
+    rc = ShClUtf16GetLinSize(pwszSrc, cwSrc, &cwTmp);
     if (RT_SUCCESS(rc) && cwTmp == 0)
         rc = VERR_NO_DATA;
@@ -1169 +1169 @@
     /* Convert the text. */
     if (RT_SUCCESS(rc))
-        rc = vboxClipboardUtf16WinToLin(pwszSrc, cwSrc, pwszTmp, cwTmp);
+        rc = ShClUtf16WinToLin(pwszSrc, cwSrc, pwszTmp, cwTmp);
     if (RT_SUCCESS(rc))
         /* Convert the Utf16 string to Utf8. */
@@ -1350 +1350 @@
         {
             /* Create a full BMP from it */
-            rc = vboxClipboardDibToBmp(pv, cb, (void **)pValReturn,
-                                       (size_t *)pcLenReturn);
+            rc = ShClDibToBmp(pv, cb, (void **)pValReturn,
+                              (size_t *)pcLenReturn);
         }
         else
@@ -1543 +1543 @@
     PRTUTF16 pwszDest = NULL;
     size_t cwcDest;
-    int rc = vboxClipboardUtf16GetWinSize(pwcSrc, cwcSrc + 1, &cwcDest);
+    int rc = ShClUtf16GetWinSize(pwcSrc, cwcSrc + 1, &cwcDest);
     if (RT_SUCCESS(rc))
     {
@@ -1551 +1551 @@
     }
     if (RT_SUCCESS(rc))
-        rc = vboxClipboardUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest,
-                                        cwcDest);
+        rc = ShClUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest,
+                               cwcDest);
     if (RT_SUCCESS(rc))
     {
@@ -1820 +1820 @@
                 const void *pDib;
                 size_t cbDibSize;
-                rc = vboxClipboardBmpGetDib((const void *)pvSrc, cbSrc,
-                                            &pDib, &cbDibSize);
+                rc = ShClBmpGetDib((const void *)pvSrc, cbSrc,
+                                   &pDib, &cbDibSize);
                 if (RT_SUCCESS(rc))
                 {