Index: /trunk/include/VBox/GuestHost/SharedClipboard-transfers.h
===================================================================
--- /trunk/include/VBox/GuestHost/SharedClipboard-transfers.h	(revision 81222)
+++ /trunk/include/VBox/GuestHost/SharedClipboard-transfers.h	(revision 81223)
@@ -1033,121 +1033,113 @@
 } SHCLTRANSFERCTX, *PSHCLTRANSFERCTX;
 
-int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
-void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
-bool SharedClipboardTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
-
-int SharedClipboardTransferObjectHandleInfoInit(PSHCLOBJHANDLEINFO pInfo);
-void SharedClipboardTransferObjectHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo);
-
-int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
-int SharedClipboardTransferObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
-void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
-
-int SharedClipboardTransferObjectOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj);
-int SharedClipboardTransferObjectClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj);
-int SharedClipboardTransferObjectRead(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
-int SharedClipboardTransferObjectWrite(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
-
-PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
-void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
-void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
-
-int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer);
-int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer);
-
-int SharedClipboardTransferInit(PSHCLTRANSFER pTransfer, uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource);
-int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer);
-int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer);
-
-int SharedClipboardTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
-int SharedClipboardTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
-int SharedClipboardTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTHDR pHdr);
-PSHCLTRANSFEROBJ SharedClipboardTransferListGetObj(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, uint64_t uIdx);
-int SharedClipboardTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
-int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
-bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
-
-int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath);
-int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
-
-PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void);
-void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList);
-
-PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
-int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
-void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
-
-int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
-int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
-void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
-PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
-
-int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo);
-void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo);
-
-int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
-void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
+int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
+void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
+bool ShClTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
+
+int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo);
+void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo);
+
+int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
+int ShClTransferObjOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
+void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
+
+int ShClTransferObjOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj);
+int ShClTransferObjClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj);
+int ShClTransferObjRead(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
+int ShClTransferObjWrite(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
+
+PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
+void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
+void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
+
+int ShClTransferCreate(PSHCLTRANSFER *ppTransfer);
+int ShClTransferDestroy(PSHCLTRANSFER pTransfer);
+
+int ShClTransferInit(PSHCLTRANSFER pTransfer, uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource);
+int ShClTransferOpen(PSHCLTRANSFER pTransfer);
+int ShClTransferClose(PSHCLTRANSFER pTransfer);
+
+int ShClTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
+int ShClTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
+int ShClTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTHDR pHdr);
+PSHCLTRANSFEROBJ ShClTransferListGetObj(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, uint64_t uIdx);
+int ShClTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
+int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
+bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
+
+int ShClPathSanitizeFilename(char *pszPath, size_t cbPath);
+int ShClPathSanitize(char *pszPath, size_t cbPath);
+
+PSHCLROOTLIST ShClTransferRootListAlloc(void);
+void ShClTransferRootListFree(PSHCLROOTLIST pRootList);
+
+PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
+int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
+void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
+
+int ShClTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
+int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
+void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
+PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
+
+int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo);
+void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo);
+
+int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
+void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr);
 PSHCLLISTHDR SharedClipboardTransferListHdrDup(PSHCLLISTHDR pListHdr);
-int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr);
-void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
-void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
-void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr);
-bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
-
-int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
-PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
-int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
-void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
-
-int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
-void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry);
-int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
-PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry);
-int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry);
-void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
-bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
-
-int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer, PSHCLPROVIDERCREATIONCTX pCreationCtx);
-int SharedClipboardTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
-void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer);
-SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer);
-
-uint32_t SharedClipboardTransferRootsCount(PSHCLTRANSFER pTransfer);
-int SharedClipboardTransferRootsEntry(PSHCLTRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
-int SharedClipboardTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
-
-SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer);
-SHCLTRANSFERDIR SharedClipboardTransferGetDir(PSHCLTRANSFER pTransfer);
-SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer);
-SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer);
-int SharedClipboardTransferHandleReply(PSHCLTRANSFER pTransfer, PSHCLREPLY pReply);
-int SharedClipboardTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
-int SharedClipboardTransferStart(PSHCLTRANSFER pTransfer);
-void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer, PSHCLTRANSFERCALLBACKS pCallbacks);
-
-int SharedClipboardTransferRead(PSHCLTRANSFER pTransfer);
-int SharedClipboardTransferReadObjects(PSHCLTRANSFER pTransfer);
-
-int SharedClipboardTransferWrite(PSHCLTRANSFER pTransfer);
-int SharedClipboardTransferWriteObjects(PSHCLTRANSFER pTransfer);
-
-int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx);
-void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx);
-void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx);
-PSHCLTRANSFER SharedClipboardTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
-uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx);
-uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx);
-void SharedClipboardTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx);
-bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx);
-int SharedClipboardTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer);
-int SharedClipboardTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer);
-int SharedClipboardTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer);
-
-void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc);
-
-bool SharedClipboardMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax);
-bool SharedClipboardMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax);
-
-const char *VBoxShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus);
+int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr);
+void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
+void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr);
+bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
+
+int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
+PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
+int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
+void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
+
+int ShClTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
+void ShClTransferListEntryFree(PSHCLLISTENTRY pListEntry);
+int ShClTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
+PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry);
+int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry);
+void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
+bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
+
+int ShClTransferSetInterface(PSHCLTRANSFER pTransfer, PSHCLPROVIDERCREATIONCTX pCreationCtx);
+int ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
+void ShClTransferReset(PSHCLTRANSFER pTransfer);
+SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer);
+
+uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer);
+int ShClTransferRootsEntry(PSHCLTRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
+int ShClTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
+
+SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer);
+SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer);
+SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer);
+SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer);
+int ShClTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
+int ShClTransferStart(PSHCLTRANSFER pTransfer);
+void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer, PSHCLTRANSFERCALLBACKS pCallbacks);
+
+int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx);
+void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx);
+void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx);
+PSHCLTRANSFER ShClTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
+uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx);
+uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx);
+void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx);
+bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx);
+int ShClTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer);
+int ShClTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer);
+int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer);
+
+void ShClFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc);
+
+bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax);
+bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax);
+
+const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus);
 
 #endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_transfers_h */
Index: /trunk/include/VBox/GuestHost/SharedClipboard.h
===================================================================
--- /trunk/include/VBox/GuestHost/SharedClipboard.h	(revision 81222)
+++ /trunk/include/VBox/GuestHost/SharedClipboard.h	(revision 81223)
@@ -180,19 +180,29 @@
 } SHCLEVENTSOURCE, *PSHCLEVENTSOURCE;
 
-int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
-                                PSHCLEVENTPAYLOAD *ppPayload);
-void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload);
-
-int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID);
-void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource);
-
-SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource);
-SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource);
-int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
-int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
-int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
-                             PSHCLEVENTPAYLOAD* ppPayload);
-int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, PSHCLEVENTPAYLOAD pPayload);
-void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
+/** @name Shared Clipboard data payload functions.
+ *  @{
+ */
+int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData, PSHCLEVENTPAYLOAD *ppPayload);
+void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload);
+/** @} */
+
+/** @name Shared Clipboard event source functions.
+ *  @{
+ */
+int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID);
+void ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource);
+/** @} */
+
+/** @name Shared Clipboard event functions.
+ *  @{
+ */
+SHCLEVENTID ShClEventIDGenerate(PSHCLEVENTSOURCE pSource);
+SHCLEVENTID ShClEventGetLast(PSHCLEVENTSOURCE pSource);
+int ShClEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
+int ShClEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
+int ShClEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs, PSHCLEVENTPAYLOAD* ppPayload);
+int ShClEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, PSHCLEVENTPAYLOAD pPayload);
+void ShClEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
+/** @} */
 
 /**
@@ -225,5 +235,7 @@
 typedef struct _CLIPREADCBREQ CLIPREADCBREQ;
 
-/* APIs exported by the X11 backend. */
+/** @name Shared Clipboard APIs exported by the X11 backend.
+ *  @{
+ */
 extern CLIPBACKEND *ClipConstructX11(SHCLCONTEXT *pFrontend, bool fHeadless);
 extern void ClipDestructX11(CLIPBACKEND *pBackend);
@@ -232,9 +244,13 @@
 extern int ClipAnnounceFormatToX11(CLIPBACKEND *pBackend, SHCLFORMATS vboxFormats);
 extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, SHCLFORMATS vboxFormat, CLIPREADCBREQ *pReq);
-
-/* APIs (as callbacks) exported by the X11/VBox frontend. */
+/** @} */
+
+/** @name Shared Clipboard APIs (as callbacks) exported by the X11/VBox frontend.
+ *  @{
+ */
 extern DECLCALLBACK(int)  ClipRequestDataForX11Callback(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb);
 extern DECLCALLBACK(void) ClipReportX11FormatsCallback(SHCLCONTEXT *pCtx, uint32_t u32Formats);
 extern DECLCALLBACK(void) ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb);
+/** @} */
 #endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_h */
 
Index: /trunk/include/VBox/GuestHost/clipboard-helper.h
===================================================================
--- /trunk/include/VBox/GuestHost/clipboard-helper.h	(revision 81222)
+++ /trunk/include/VBox/GuestHost/clipboard-helper.h	(revision 81223)
@@ -57,5 +57,5 @@
  * @param   pcwcDst  The length of the destination string in RTUTF16 units.
  */
-int vboxClipboardUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
+int ShClUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
 
 /**
@@ -72,5 +72,5 @@
  * @param   cwcDst   Size of the buffer for the converted text in RTUTF16 units.
  */
-int vboxClipboardUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
+int ShClUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
 
 /**
@@ -84,5 +84,5 @@
  * @retval  pcwcDst  The length of the destination string in RTUTF16 units.
  */
-int vboxClipboardUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
+int ShClUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
 
 /**
@@ -98,5 +98,5 @@
  *                   chars.
  */
-int vboxClipboardUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
+int ShClUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
 
 #pragma pack(1)
@@ -157,5 +157,5 @@
  *                        data in bytes.
  */
-int vboxClipboardDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDst, size_t *pcbDst);
+int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDst, size_t *pcbDst);
 
 /**
@@ -170,5 +170,5 @@
  * @param   pcbDst        Pointer to the size of the destination data in bytes
  */
-int vboxClipboardBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDst, size_t *pcbDst);
+int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDst, size_t *pcbDst);
 
 #ifdef LOG_ENABLED
@@ -180,5 +180,5 @@
  * @param   cbSrc               Size (in bytes) of HTML data to dump.
  */
-int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc);
+int ShClDbgDumpHtml(const char *pszSrc, size_t cbSrc);
 
 /**
@@ -189,5 +189,5 @@
  * @param   u32Format           Clipboard format to use for dumping.
  */
-void VBoxShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format);
+void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format);
 #endif /* LOG_ENABLED */
 
@@ -198,5 +198,5 @@
  * @param   uFn                 The function to translate.
  */
-const char *VBoxShClHostFunctionToStr(uint32_t uFn);
+const char *ShClHostFunctionToStr(uint32_t uFn);
 
 /**
@@ -206,5 +206,5 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxShClHostMsgToStr(uint32_t uMsg);
+const char *ShClHostMsgToStr(uint32_t uMsg);
 
 /**
@@ -214,5 +214,5 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxShClGuestMsgToStr(uint32_t uMsg);
+const char *ShClGuestMsgToStr(uint32_t uMsg);
 
 #endif /* !VBOX_INCLUDED_GuestHost_clipboard_helper_h */
Index: /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp	(revision 81222)
+++ /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp	(revision 81223)
@@ -115,8 +115,8 @@
     }
 
-    int rc2 = SharedClipboardTransferCtxTransferUnregister(pCtx, pTransfer->State.uID);
+    int rc2 = ShClTransferCtxTransferUnregister(pCtx, pTransfer->State.uID);
     AssertRC(rc2);
 
-    SharedClipboardTransferDestroy(pTransfer);
+    ShClTransferDestroy(pTransfer);
 
     RTMemFree(pTransfer);
@@ -145,7 +145,7 @@
     AssertPtr(pTransfer);
 
-    const SHCLTRANSFERDIR enmDir = SharedClipboardTransferGetDir(pTransfer);
-
-    LogFlowFunc(("pCtx=%p, idTransfer=%RU16, enmDir=%RU32\n", pCtx, SharedClipboardTransferGetID(pTransfer), enmDir));
+    const SHCLTRANSFERDIR enmDir = ShClTransferGetDir(pTransfer);
+
+    LogFlowFunc(("pCtx=%p, idTransfer=%RU16, enmDir=%RU32\n", pCtx, ShClTransferGetID(pTransfer), enmDir));
 
     int rc;
@@ -161,7 +161,7 @@
         /* The IDataObject *must* be created on the same thread as our (proxy) window, so post a message to it
          * to do the stuff for us. */
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
-
-        rc = SharedClipboardEventRegister(&pTransfer->Events, uEvent);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pTransfer->Events);
+
+        rc = ShClEventRegister(&pTransfer->Events, uEvent);
         if (RT_SUCCESS(rc))
         {
@@ -170,5 +170,5 @@
 
             PSHCLEVENTPAYLOAD pPayload;
-            rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, 30 * 1000 /* Timeout in ms */, &pPayload);
+            rc = ShClEventWait(&pTransfer->Events, uEvent, 30 * 1000 /* Timeout in ms */, &pPayload);
             if (RT_SUCCESS(rc))
             {
@@ -176,8 +176,8 @@
                 rc = *(int *)pPayload->pvData;
 
-                SharedClipboardPayloadFree(pPayload);
-            }
-
-            SharedClipboardEventUnregister(&pTransfer->Events, uEvent);
+                ShClPayloadFree(pPayload);
+            }
+
+            ShClEventUnregister(&pTransfer->Events, uEvent);
         }
     }
@@ -188,5 +188,5 @@
         LogRel(("Shared Clipboard: Starting transfer failed, rc=%Rrc\n", rc));
 
-    LogFlowFunc(("LEAVE: idTransfer=%RU16, rc=%Rrc\n", SharedClipboardTransferGetID(pTransfer), rc));
+    LogFlowFunc(("LEAVE: idTransfer=%RU16, rc=%Rrc\n", ShClTransferGetID(pTransfer), rc));
     return rc;
 }
@@ -649,15 +649,15 @@
             const SHCLEVENTID uEvent = (SHCLEVENTID)lParam;
 
-            Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
+            Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
 
             int rcTransfer = SharedClipboardWinTransferCreate(pWinCtx, pTransfer);
 
             PSHCLEVENTPAYLOAD pPayload = NULL;
-            int rc = SharedClipboardPayloadAlloc(uEvent, &rcTransfer, sizeof(rcTransfer), &pPayload);
+            int rc = ShClPayloadAlloc(uEvent, &rcTransfer, sizeof(rcTransfer), &pPayload);
             if (RT_SUCCESS(rc))
             {
-                rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                 if (RT_FAILURE(rc))
-                    SharedClipboardPayloadFree(pPayload);
+                    ShClPayloadFree(pPayload);
             }
 
@@ -910,5 +910,5 @@
         {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-            rc = SharedClipboardTransferCtxInit(&pCtx->TransferCtx);
+            rc = ShClTransferCtxInit(&pCtx->TransferCtx);
 #endif
             if (RT_SUCCESS(rc))
@@ -1178,5 +1178,5 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-    SharedClipboardTransferCtxDestroy(&pCtx->TransferCtx);
+    ShClTransferCtxDestroy(&pCtx->TransferCtx);
 #endif
 
Index: /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp	(revision 81222)
+++ /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp	(revision 81223)
@@ -483,5 +483,5 @@
     int rc;
 
-    PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
+    PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
     if (pRootList)
     {
@@ -504,5 +504,5 @@
                         AssertPtr(pEntry);
 
-                        rc = SharedClipboardTransferRootListEntryInit(pEntry);
+                        rc = ShClTransferRootListEntryInit(pEntry);
                         if (RT_SUCCESS(rc))
                             rc = vbglR3ClipboardRootListEntryRead(pCtx, i, pEntry);
@@ -522,5 +522,5 @@
         }
         else
-            SharedClipboardTransferRootListFree(pRootList);
+            ShClTransferRootListFree(pRootList);
     }
     else
@@ -607,5 +607,5 @@
     Msg.u.TransferStatus.enmStatus.SetUInt32((uint32_t)uStatus);
 
-    LogFlowFunc(("%s\n", VBoxShClTransferStatusToStr(uStatus)));
+    LogFlowFunc(("%s\n", ShClTransferStatusToStr(uStatus)));
 
     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
@@ -1565,5 +1565,5 @@
     AssertPtr(pCmdCtx);
 
-    int rc = SharedClipboardTransferListHdrInit(pListHdr);
+    int rc = ShClTransferListHdrInit(pListHdr);
     if (RT_SUCCESS(rc))
     {
@@ -1573,5 +1573,5 @@
         }
         else
-            SharedClipboardTransferListHdrDestroy(pListHdr);
+            ShClTransferListHdrDestroy(pListHdr);
     }
 
@@ -1654,13 +1654,13 @@
 {
     PSHCLTRANSFER pTransfer;
-    int rc = SharedClipboardTransferCreate(&pTransfer);
-    if (RT_SUCCESS(rc))
-    {
-        SharedClipboardTransferSetCallbacks(pTransfer, &pCmdCtx->Transfers.Callbacks);
-
-        rc = SharedClipboardTransferCtxTransferRegisterByIndex(pTransferCtx, pTransfer, uTransferID);
-        if (RT_SUCCESS(rc))
-        {
-            rc = SharedClipboardTransferInit(pTransfer, uTransferID, enmDir, enmSource);
+    int rc = ShClTransferCreate(&pTransfer);
+    if (RT_SUCCESS(rc))
+    {
+        ShClTransferSetCallbacks(pTransfer, &pCmdCtx->Transfers.Callbacks);
+
+        rc = ShClTransferCtxTransferRegisterByIndex(pTransferCtx, pTransfer, uTransferID);
+        if (RT_SUCCESS(rc))
+        {
+            rc = ShClTransferInit(pTransfer, uTransferID, enmDir, enmSource);
             if (RT_SUCCESS(rc))
             {
@@ -1685,13 +1685,13 @@
                     creationCtx.pvUser = pCmdCtx;
 
-                    rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
+                    rc = ShClTransferSetInterface(pTransfer, &creationCtx);
                 }
 
                 if (RT_SUCCESS(rc))
-                    rc = SharedClipboardTransferStart(pTransfer);
+                    rc = ShClTransferStart(pTransfer);
             }
 
             if (RT_FAILURE(rc))
-                SharedClipboardTransferCtxTransferUnregister(pTransferCtx, uTransferID);
+                ShClTransferCtxTransferUnregister(pTransferCtx, uTransferID);
         }
     }
@@ -1718,5 +1718,5 @@
     if (RT_FAILURE(rc))
     {
-        SharedClipboardTransferDestroy(pTransfer);
+        ShClTransferDestroy(pTransfer);
         pTransfer = NULL;
     }
@@ -1739,10 +1739,10 @@
     int rc;
 
-    PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx, uTransferID);
+    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx, uTransferID);
     if (pTransfer)
     {
-        rc = SharedClipboardTransferClose(pTransfer);
-        if (RT_SUCCESS(rc))
-            rc = SharedClipboardTransferCtxTransferUnregister(pTransferCtx, uTransferID);
+        rc = ShClTransferClose(pTransfer);
+        if (RT_SUCCESS(rc))
+            rc = ShClTransferCtxTransferUnregister(pTransferCtx, uTransferID);
 
         if (RT_SUCCESS(rc))
@@ -1774,5 +1774,5 @@
     AssertPtrReturn(pEvent,       VERR_INVALID_POINTER);
 
-    LogFunc(("Handling idMsg=%RU32 (%s), cParms=%RU32\n", idMsg, VBoxShClHostMsgToStr(idMsg), cParms));
+    LogFunc(("Handling idMsg=%RU32 (%s), cParms=%RU32\n", idMsg, ShClHostMsgToStr(idMsg), cParms));
 
     int rc;
@@ -1792,5 +1792,5 @@
 
                 LogFlowFunc(("[Transfer %RU16] enmDir=%RU32, status=%s\n",
-                             uTransferID, enmDir, VBoxShClTransferStatusToStr(transferReport.uStatus)));
+                             uTransferID, enmDir, ShClTransferStatusToStr(transferReport.uStatus)));
 
                 switch (transferReport.uStatus)
@@ -1848,5 +1848,5 @@
 
                     LogRel2(("Shared Clipboard: Received status %s (rc=%Rrc) for transfer ID=%RU16\n",
-                             VBoxShClTransferStatusToStr(pEvent->u.TransferStatus.Report.uStatus), pEvent->u.TransferStatus.Report.rc,
+                             ShClTransferStatusToStr(pEvent->u.TransferStatus.Report.uStatus), pEvent->u.TransferStatus.Report.rc,
                              pEvent->u.TransferStatus.uID));
                 }
@@ -1864,6 +1864,6 @@
             if (RT_SUCCESS(rc))
             {
-                PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                    VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                 AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
@@ -1871,5 +1871,5 @@
                 RT_ZERO(rootListHdr);
 
-                rootListHdr.cRoots = SharedClipboardTransferRootsCount(pTransfer);
+                rootListHdr.cRoots = ShClTransferRootsCount(pTransfer);
 
                 LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cRoots));
@@ -1887,10 +1887,10 @@
             if (RT_SUCCESS(rc))
             {
-                PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                 AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
                 SHCLROOTLISTENTRY rootListEntry;
-                rc = SharedClipboardTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
+                rc = ShClTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
                 if (RT_SUCCESS(rc))
                     rc = VbglR3ClipboardRootListEntryReadReply(pCmdCtx, uIndex, &rootListEntry);
@@ -1902,5 +1902,5 @@
         {
             SHCLLISTOPENPARMS openParmsList;
-            rc = SharedClipboardTransferListOpenParmsInit(&openParmsList);
+            rc = ShClTransferListOpenParmsInit(&openParmsList);
             if (RT_SUCCESS(rc))
             {
@@ -1908,6 +1908,6 @@
                 if (RT_SUCCESS(rc))
                 {
-                    PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                    VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                         VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                     AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
@@ -1915,5 +1915,5 @@
 
                     SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID;
-                    rc = SharedClipboardTransferListOpen(pTransfer, &openParmsList, &hList);
+                    rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList);
 
                     /* Reply in any case. */
@@ -1922,5 +1922,5 @@
                 }
 
-                SharedClipboardTransferListOpenParmsDestroy(&openParmsList);
+                ShClTransferListOpenParmsDestroy(&openParmsList);
             }
 
@@ -1934,9 +1934,9 @@
             if (RT_SUCCESS(rc))
             {
-                PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                 AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
-                rc = SharedClipboardTransferListClose(pTransfer, hList);
+                rc = ShClTransferListClose(pTransfer, hList);
 
                 /* Reply in any case. */
@@ -1957,15 +1957,15 @@
             if (RT_SUCCESS(rc))
             {
-                PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                 AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
                 SHCLLISTHDR hdrList;
-                rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
+                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
                 if (RT_SUCCESS(rc))
                 {
                     rc = VbglR3ClipboardListHdrWrite(pCmdCtx, hList, &hdrList);
 
-                    SharedClipboardTransferListHdrDestroy(&hdrList);
+                    ShClTransferListHdrDestroy(&hdrList);
                 }
             }
@@ -1979,5 +1979,5 @@
 
             SHCLLISTENTRY entryList;
-            rc = SharedClipboardTransferListEntryInit(&entryList);
+            rc = ShClTransferListEntryInit(&entryList);
             if (RT_SUCCESS(rc))
             {
@@ -1987,9 +1987,9 @@
                 if (RT_SUCCESS(rc))
                 {
-                    PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                    VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                         VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                     AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
-                    rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
+                    rc = ShClTransferListRead(pTransfer, hList, &entryList);
                     if (RT_SUCCESS(rc))
                     {
@@ -2005,5 +2005,5 @@
                 }
 
-                SharedClipboardTransferListEntryDestroy(&entryList);
+                ShClTransferListEntryDestroy(&entryList);
             }
 
@@ -2014,5 +2014,5 @@
         {
             SHCLOBJOPENCREATEPARMS openParms;
-            rc = SharedClipboardTransferObjectOpenParmsInit(&openParms);
+            rc = ShClTransferObjOpenParmsInit(&openParms);
             if (RT_SUCCESS(rc))
             {
@@ -2020,10 +2020,10 @@
                 if (RT_SUCCESS(rc))
                 {
-                    PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                    VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                         VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                     AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
                     SHCLOBJHANDLE hObj;
-                    rc = SharedClipboardTransferObjectOpen(pTransfer, &openParms, &hObj);
+                    rc = ShClTransferObjOpen(pTransfer, &openParms, &hObj);
 
                     /* Reply in any case. */
@@ -2032,5 +2032,5 @@
                 }
 
-                SharedClipboardTransferObjectOpenParmsDestroy(&openParms);
+                ShClTransferObjOpenParmsDestroy(&openParms);
             }
 
@@ -2044,9 +2044,9 @@
             if (RT_SUCCESS(rc))
             {
-                PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                 AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
-                rc = SharedClipboardTransferObjectClose(pTransfer, hObj);
+                rc = ShClTransferObjClose(pTransfer, hObj);
 
                 /* Reply in any case. */
@@ -2066,6 +2066,6 @@
             if (RT_SUCCESS(rc))
             {
-                PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
-                                                                                VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
+                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
+                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
                 AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
 
@@ -2081,5 +2081,5 @@
                 {
                     uint32_t cbRead;
-                    rc = SharedClipboardTransferObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
+                    rc = ShClTransferObjRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
                     if (RT_SUCCESS(rc))
                         rc = VbglR3ClipboardObjWriteSend(pCmdCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
@@ -2127,5 +2127,5 @@
 
 #ifdef LOG_ENABLED
-    LogFunc(("Handling idMsg=%RU32 (%s), protocol v%RU32\n", idMsg, VBoxShClHostMsgToStr(idMsg), pCtx->uProtocolVer));
+    LogFunc(("Handling idMsg=%RU32 (%s), protocol v%RU32\n", idMsg, ShClHostMsgToStr(idMsg), pCtx->uProtocolVer));
 #endif
     switch (idMsg)
Index: /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp
===================================================================
--- /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp	(revision 81222)
+++ /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp	(revision 81223)
@@ -222,5 +222,5 @@
 
     size_t cwcActual; /* (includes a schwarzenegger character) */
-    int rc = vboxClipboardUtf16GetWinSize(pwszData, cbData / sizeof(RTUTF16), &cwcActual);
+    int rc = ShClUtf16GetWinSize(pwszData, cbData / sizeof(RTUTF16), &cwcActual);
     AssertReturn(RT_SUCCESS(rc), rc);
 
@@ -228,5 +228,5 @@
     AssertReturn(pwszWinTmp, VERR_NO_MEMORY);
 
-    rc = vboxClipboardUtf16LinToWin(pwszData, cbData / sizeof(RTUTF16), pwszWinTmp, cwcActual);
+    rc = ShClUtf16LinToWin(pwszData, cbData / sizeof(RTUTF16), pwszWinTmp, cwcActual);
     if (RT_SUCCESS(rc))
         rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_UNICODETEXT,
@@ -250,5 +250,5 @@
     const void   *pvDib;
     size_t        cbDib;
-    int rc = vboxClipboardBmpGetDib(pvData, cbData, &pvDib, &cbDib);
+    int rc = ShClBmpGetDib(pvData, cbData, &pvDib, &cbDib);
     AssertRCReturn(rc, rc);
 
Index: /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp
===================================================================
--- /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp	(revision 81222)
+++ /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp	(revision 81223)
@@ -169,9 +169,9 @@
 
     /* Convert END-OF-LINE */
-    rc = vboxClipboardUtf16GetLinSize((RTUTF16 *)pData, cbDataSize / 2, &cbActualLen);
+    rc = ShClUtf16GetLinSize((RTUTF16 *)pData, cbDataSize / 2, &cbActualLen);
     AssertReturn(RT_SUCCESS(rc), rc);
     pDataInternal = (RTUTF16 *)RTMemAlloc(cbActualLen * 2);
     AssertReturn(pDataInternal, VERR_NO_MEMORY);
-    rc = vboxClipboardUtf16WinToLin((RTUTF16 *)pData, cbDataSize / 2, pDataInternal, cbActualLen);
+    rc = ShClUtf16WinToLin((RTUTF16 *)pData, cbDataSize / 2, pDataInternal, cbActualLen);
 
     /* Do actual paste */
@@ -217,5 +217,5 @@
     AssertReturn(cbDataSize > 0, VINF_SUCCESS);
 
-    rc = vboxClipboardDibToBmp(pData, cbDataSize, &pBmp, &cbBmpSize);
+    rc = ShClDibToBmp(pData, cbDataSize, &pBmp, &cbBmpSize);
     AssertReturn(RT_SUCCESS(rc), rc);
 
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp	(revision 81222)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp	(revision 81223)
@@ -197,5 +197,5 @@
                     void  *pBmp  = NULL;
                     size_t cbBmp = 0;
-                    rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmp);
+                    rc = ShClDibToBmp(pv, cb, &pBmp, &cbBmp);
                     if (RT_SUCCESS(rc))
                     {
@@ -295,5 +295,5 @@
                                 size_t cbDibSize;
                                 /* Strip out the BM header */
-                                rc = vboxClipboardBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
+                                rc = ShClBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
                                 if (RT_SUCCESS(rc))
                                 {
Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp	(revision 81223)
@@ -238,5 +238,5 @@
 
     SHCLLISTOPENPARMS openParmsList;
-    int rc = SharedClipboardTransferListOpenParmsInit(&openParmsList);
+    int rc = ShClTransferListOpenParmsInit(&openParmsList);
     if (RT_SUCCESS(rc))
     {
@@ -245,5 +245,5 @@
         {
             SHCLLISTHANDLE hList;
-            rc = SharedClipboardTransferListOpen(pTransfer, &openParmsList, &hList);
+            rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList);
             if (RT_SUCCESS(rc))
             {
@@ -251,5 +251,5 @@
 
                 SHCLLISTHDR hdrList;
-                rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
+                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
                 if (RT_SUCCESS(rc))
                 {
@@ -260,5 +260,5 @@
                     {
                         SHCLLISTENTRY entryList;
-                        rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
+                        rc = ShClTransferListRead(pTransfer, hList, &entryList);
                         if (RT_SUCCESS(rc))
                         {
@@ -295,9 +295,9 @@
                 }
 
-                SharedClipboardTransferListClose(pTransfer, hList);
+                ShClTransferListClose(pTransfer, hList);
             }
         }
 
-        SharedClipboardTransferListOpenParmsDestroy(&openParmsList);
+        ShClTransferListOpenParmsDestroy(&openParmsList);
     }
 
@@ -334,9 +334,9 @@
     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,5 +378,5 @@
             }
 
-            SharedClipboardTransferRootListFree(pRootList);
+            ShClTransferRootListFree(pRootList);
             pRootList = NULL;
 
@@ -410,5 +410,5 @@
         }
 
-        SharedClipboardTransferClose(pTransfer);
+        ShClTransferClose(pTransfer);
     }
 
@@ -574,9 +574,9 @@
         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,5 +586,5 @@
         {
             /* 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))
             {
Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp	(revision 81223)
@@ -26,5 +26,5 @@
 
 
-bool SharedClipboardMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
+bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
 {
     /** @todo "text/uri" also an official variant? */
@@ -33,5 +33,5 @@
 }
 
-bool SharedClipboardMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax)
+bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax)
 {
     bool fNeedsDropDir = false;
Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp	(revision 81223)
@@ -36,5 +36,5 @@
  * @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,5 +72,5 @@
  * @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);
Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp	(revision 81223)
@@ -188,5 +188,5 @@
         {
             SHCLOBJOPENCREATEPARMS openParms;
-            rc = SharedClipboardTransferObjectOpenParmsInit(&openParms);
+            rc = ShClTransferObjOpenParmsInit(&openParms);
             if (RT_SUCCESS(rc))
             {
@@ -202,5 +202,5 @@
                 }
 
-                SharedClipboardTransferObjectOpenParmsDestroy(&openParms);
+                ShClTransferObjOpenParmsDestroy(&openParms);
             }
         }
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp	(revision 81223)
@@ -41,6 +41,6 @@
  * @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,5 +75,5 @@
  * @param   pPayload            Event payload to free.
  */
-void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload)
+void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload)
 {
     if (!pPayload)
@@ -100,5 +100,5 @@
  * @param   uID                 Event ID to use.
  */
-int SharedClipboardEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
+int ShClEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
@@ -121,5 +121,5 @@
  * @param   pEvent              Event to destroy.
  */
-void SharedClipboardEventDestroy(PSHCLEVENT pEvent)
+void ShClEventDestroy(PSHCLEVENT pEvent)
 {
     if (!pEvent)
@@ -134,5 +134,5 @@
     }
 
-    SharedClipboardPayloadFree(pEvent->pPayload);
+    ShClPayloadFree(pEvent->pPayload);
 
     pEvent->uID = 0;
@@ -146,5 +146,5 @@
  * @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,5 +169,5 @@
  * @param   pSource             Event source to destroy.
  */
-void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource)
+void ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource)
 {
     if (!pSource)
@@ -182,5 +182,5 @@
         RTListNodeRemove(&pEvIt->Node);
 
-        SharedClipboardEventDestroy(pEvIt);
+        ShClEventDestroy(pEvIt);
 
         RTMemFree(pEvIt);
@@ -198,5 +198,5 @@
  * @param   pSource             Event source to generate event for.
  */
-SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource)
+SHCLEVENTID ShClEventIDGenerate(PSHCLEVENTSOURCE pSource)
 {
     AssertPtrReturn(pSource, 0);
@@ -218,5 +218,5 @@
  * @param   uID                 Event ID to get.
  */
-inline PSHCLEVENT sharedClipboardEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+inline PSHCLEVENT shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     PSHCLEVENT pEvIt;
@@ -236,5 +236,5 @@
  * @param   pSource             Event source to get last registered event from.
  */
-SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource)
+SHCLEVENTID ShClEventGetLast(PSHCLEVENTSOURCE pSource)
 {
     AssertPtrReturn(pSource, 0);
@@ -251,5 +251,5 @@
  * @param   pEvent              Event to detach payload for.
  */
-static void sharedClipboardEventPayloadDetachInternal(PSHCLEVENT pEvent)
+static void shclEventPayloadDetachInternal(PSHCLEVENT pEvent)
 {
     AssertPtrReturnVoid(pEvent);
@@ -265,5 +265,5 @@
  * @param   uID                 Event ID to register.
  */
-int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+int ShClEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -273,5 +273,5 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    if (sharedClipboardEventGet(pSource, uID) == NULL)
+    if (shclEventGet(pSource, uID) == NULL)
     {
         PSHCLEVENT pEvent
@@ -279,5 +279,5 @@
         if (pEvent)
         {
-            rc = SharedClipboardEventCreate(pEvent, uID);
+            rc = ShClEventCreate(pEvent, uID);
             if (RT_SUCCESS(rc))
             {
@@ -308,5 +308,5 @@
  * @param   uID                 Event ID to unregister.
  */
-int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+int ShClEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -316,5 +316,5 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
@@ -323,5 +323,5 @@
         RTListNodeRemove(&pEvent->Node);
 
-        SharedClipboardEventDestroy(pEvent);
+        ShClEventDestroy(pEvent);
 
         RTMemFree(pEvent);
@@ -347,6 +347,6 @@
  *                              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,5 +357,5 @@
     int rc;
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
@@ -368,5 +368,5 @@
 
                 /* Make sure to detach payload here, as the caller now owns the data. */
-                sharedClipboardEventPayloadDetachInternal(pEvent);
+                shclEventPayloadDetachInternal(pEvent);
             }
         }
@@ -387,6 +387,6 @@
  * @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,5 +396,5 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
     if (pEvent)
     {
@@ -419,5 +419,5 @@
  * @param   uID                 Event ID to detach payload for.
  */
-void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+void ShClEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturnVoid(pSource);
@@ -425,8 +425,8 @@
     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,5 +438,5 @@
 /** @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,6 +483,5 @@
 }
 
-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,5 +560,5 @@
 }
 
-int vboxClipboardUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
+int ShClUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
 {
     size_t cwDest;
@@ -609,6 +608,5 @@
 }
 
-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,5 +678,5 @@
 }
 
-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,5 +726,5 @@
 }
 
-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,5 +747,5 @@
 
 #ifdef LOG_ENABLED
-int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
+int ShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
 {
     size_t cchIgnored = 0;
@@ -777,5 +775,5 @@
 }
 
-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,5 +820,5 @@
  * @param   uFn                 The function to translate.
  */
-const char *VBoxShClHostFunctionToStr(uint32_t uFn)
+const char *ShClHostFunctionToStr(uint32_t uFn)
 {
     switch (uFn)
@@ -844,5 +842,5 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxShClHostMsgToStr(uint32_t uMsg)
+const char *ShClHostMsgToStr(uint32_t uMsg)
 {
     switch (uMsg)
@@ -878,5 +876,5 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxShClGuestMsgToStr(uint32_t uMsg)
+const char *ShClGuestMsgToStr(uint32_t uMsg)
 {
     switch (uMsg)
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp	(revision 81223)
@@ -44,5 +44,5 @@
  * @returns Allocated transfer root list on success, or NULL on failure.
  */
-PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void)
+PSHCLROOTLIST ShClTransferRootListAlloc(void)
 {
     PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST));
@@ -57,5 +57,5 @@
  *                              invalid after returning from this function.
  */
-void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList)
+void ShClTransferRootListFree(PSHCLROOTLIST pRootList)
 {
     if (!pRootList)
@@ -63,5 +63,5 @@
 
     for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
-        SharedClipboardTransferListEntryDestroy(&pRootList->paEntries[i]);
+        ShClTransferListEntryInit(&pRootList->paEntries[i]);
 
     RTMemFree(pRootList);
@@ -75,5 +75,5 @@
  * @param   pRootLstHdr         Root list header to initialize.
  */
-int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
+int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER);
@@ -89,5 +89,5 @@
  * @param   pRootLstHdr         Root list header to destroy.
  */
-void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
+void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
 {
     if (!pRootLstHdr)
@@ -104,5 +104,5 @@
  * @param   pRootLstHdr         Root list header to duplicate.
  */
-PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
+PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, NULL);
@@ -120,5 +120,5 @@
     if (RT_FAILURE(rc))
     {
-        SharedClipboardTransferRootListHdrDestroy(pRootsDup);
+        ShClTransferRootListHdrDestroy(pRootsDup);
         pRootsDup = NULL;
     }
@@ -134,7 +134,7 @@
  * @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,7 +144,7 @@
  * @param   pRootListEntry      Clipboard root list entry structure to destroy.
  */
-int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardTransferListEntryInit(pRootListEntry);
+int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return ShClTransferListEntryInit(pRootListEntry);
 }
 
@@ -154,7 +154,7 @@
  * @param   pRootListEntry      Clipboard root list entry structure to destroy.
  */
-void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardTransferListEntryDestroy(pRootListEntry);
+void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return ShClTransferListEntryDestroy(pRootListEntry);
 }
 
@@ -165,7 +165,7 @@
  * @param   pRootListEntry      Clipboard root list entry to duplicate.
  */
-PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardTransferListEntryDup(pRootListEntry);
+PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return ShClTransferListEntryDup(pRootListEntry);
 }
 
@@ -176,5 +176,5 @@
  * @param   pInfo               List handle info structure to initialize.
  */
-int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
+int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
 {
     AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
@@ -195,5 +195,5 @@
  * @param   pInfo               List handle info structure to destroy.
  */
-void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
+void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -213,5 +213,5 @@
  * @param   ppListHdr           Where to store the allocated transfer list header structure on success.
  */
-int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
+int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
 {
     int rc;
@@ -235,5 +235,5 @@
  * @param   pListEntry          transfer list header structure to free.
  */
-void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr)
+void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -242,5 +242,5 @@
     LogFlowFuncEnter();
 
-    SharedClipboardTransferListHdrDestroy(pListHdr);
+    ShClTransferListHdrDestroy(pListHdr);
 
     RTMemFree(pListHdr);
@@ -273,5 +273,5 @@
  * @param   pListHdr            Data header struct to initialize.
  */
-int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr)
+int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
@@ -279,5 +279,5 @@
     LogFlowFuncEnter();
 
-    SharedClipboardTransferListHdrReset(pListHdr);
+    ShClTransferListHdrReset(pListHdr);
 
     return VINF_SUCCESS;
@@ -289,5 +289,5 @@
  * @param   pListHdr            Data header struct to destroy.
  */
-void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
+void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -303,5 +303,5 @@
  * @param   pListHdr            SHCLListHdr structture to reset.
  */
-void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr)
+void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturnVoid(pListHdr);
@@ -318,5 +318,5 @@
  * @param   pListHdr            Clipboard data header to validate.
  */
-bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
+bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
 {
     RT_NOREF(pListHdr);
@@ -324,5 +324,5 @@
 }
 
-int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
+int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -362,5 +362,5 @@
  * @param   pParms              transfer list open parameters structure to duplicate.
  */
-PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
+PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, NULL);
@@ -370,8 +370,8 @@
         return NULL;
 
-    int rc = SharedClipboardTransferListOpenParmsCopy(pParmsDup, pParms);
+    int rc = ShClTransferListOpenParmsCopy(pParmsDup, pParms);
     if (RT_FAILURE(rc))
     {
-        SharedClipboardTransferListOpenParmsDestroy(pParmsDup);
+        ShClTransferListOpenParmsDestroy(pParmsDup);
 
         RTMemFree(pParmsDup);
@@ -388,5 +388,5 @@
  * @param   pParms              transfer list open parameters structure to initialize.
  */
-int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
+int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -409,5 +409,5 @@
  * @param   pParms              transfer list open parameters structure to destroy.
  */
-void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
+void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
 {
     if (!pParms)
@@ -432,5 +432,5 @@
  * @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,5 +438,5 @@
         return VERR_NO_MEMORY;
 
-    int rc = SharedClipboardTransferListEntryInit(pListEntry);
+    int rc = ShClTransferListEntryInit(pListEntry);
     if (RT_SUCCESS(rc))
         *ppListEntry = pListEntry;
@@ -450,10 +450,10 @@
  * @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,5 +465,5 @@
  * @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,5 +512,5 @@
  * @param   pListEntry          Clipboard list entry to duplicate.
  */
-PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry)
+PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry)
 {
     AssertPtrReturn(pListEntry, NULL);
@@ -520,9 +520,9 @@
     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,5 +539,5 @@
  * @param   pListEntry          Clipboard list entry structure to initialize.
  */
-int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry)
+int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry)
 {
     RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY));
@@ -566,5 +566,5 @@
  * @param   pListEntry          Clipboard list entry structure to destroy.
  */
-void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
+void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
@@ -593,5 +593,5 @@
  * @param   pListEntry          Clipboard data chunk to validate.
  */
-bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
+bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
 {
     RT_NOREF(pListEntry);
@@ -608,5 +608,5 @@
  * @param   pObjCtx             transfer object context to initialize.
  */
-int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
+int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
@@ -624,5 +624,5 @@
  * @param   pObjCtx             transfer object context to destroy.
  */
-void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
+void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     AssertPtrReturnVoid(pObjCtx);
@@ -649,5 +649,5 @@
  * @param   pInfo               Object handle info structure to initialize.
  */
-int SharedClipboardTransferObjectHandleInfoInit(PSHCLOBJHANDLEINFO pInfo)
+int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo)
 {
     AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
@@ -668,5 +668,5 @@
  * @param   pInfo               Object handle info structure to destroy.
  */
-void SharedClipboardTransferObjectHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
+void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -686,5 +686,5 @@
  * @param   pParms              transfer object open parameters structure to initialize.
  */
-int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
+int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -714,5 +714,5 @@
  * @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,5 +743,5 @@
  * @param   pParms              transfer object open parameters structure to destroy.
  */
-void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
+void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
 {
     if (!pParms)
@@ -783,6 +783,6 @@
  * @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,5 +800,5 @@
         if (pInfo)
         {
-            rc = SharedClipboardTransferObjectHandleInfoInit(pInfo);
+            rc = ShClTransferObjHandleInfoInit(pInfo);
             if (RT_SUCCESS(rc))
             {
@@ -835,5 +835,5 @@
             else
             {
-                SharedClipboardTransferObjectHandleInfoDestroy(pInfo);
+                ShClTransferObjHandleInfoDestroy(pInfo);
                 RTMemFree(pInfo);
             }
@@ -863,5 +863,5 @@
  * @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,6 +929,6 @@
  * @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,7 +991,7 @@
  * @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,5 +1043,5 @@
  * @param   pDataChunk          transfer object data chunk to duplicate.
  */
-PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
+PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1069,5 +1069,5 @@
  * @param   pDataChunk          transfer object data chunk to destroy.
  */
-void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
+void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1093,10 +1093,10 @@
  *                              be invalid after calling this function.
  */
-void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
+void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
         return;
 
-    SharedClipboardTransferObjectDataChunkDestroy(pDataChunk);
+    ShClTransferObjDataChunkDestroy(pDataChunk);
 
     RTMemFree(pDataChunk);
@@ -1111,5 +1111,5 @@
  *                              Must be destroyed by SharedClipboardTransferDestroy().
  */
-int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer)
+int ShClTransferCreate(PSHCLTRANSFER *ppTransfer)
 {
     AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER);
@@ -1164,5 +1164,5 @@
         if (pTransfer)
         {
-            SharedClipboardTransferDestroy(pTransfer);
+            ShClTransferDestroy(pTransfer);
             RTMemFree(pTransfer);
         }
@@ -1179,5 +1179,5 @@
  * @param   pTransferCtx                Clipboard transfer to destroy.
  */
-int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer)
+int ShClTransferDestroy(PSHCLTRANSFER pTransfer)
 {
     if (!pTransfer)
@@ -1192,10 +1192,10 @@
     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,5 +1207,5 @@
     RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLOBJHANDLEINFO, Node)
     {
-        SharedClipboardTransferObjectHandleInfoDestroy(pItObj);
+        ShClTransferObjHandleInfoDestroy(pItObj);
 
         RTListNodeRemove(&pItObj->Node);
@@ -1227,6 +1227,6 @@
  * @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,5 +1237,5 @@
                  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,5 +1253,5 @@
 }
 
-int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer)
+int ShClTransferOpen(PSHCLTRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1264,5 +1264,5 @@
 }
 
-int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer)
+int ShClTransferClose(PSHCLTRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1313,6 +1313,6 @@
  * @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,5 +1332,5 @@
         if (pInfo)
         {
-            rc = SharedClipboardTransferListHandleInfoInit(pInfo);
+            rc = ShClTransferListHandleInfoInit(pInfo);
             if (RT_SUCCESS(rc))
             {
@@ -1378,5 +1378,5 @@
 
                 if (RT_FAILURE(rc))
-                    SharedClipboardTransferListHandleInfoDestroy(pInfo);
+                    ShClTransferListHandleInfoDestroy(pInfo);
             }
 
@@ -1416,5 +1416,5 @@
  * @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,6 +1651,6 @@
  * @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,5 +1666,5 @@
         if (pInfo)
         {
-            rc = SharedClipboardTransferListHdrInit(pHdr);
+            rc = ShClTransferListHdrInit(pHdr);
             if (RT_SUCCESS(rc))
             {
@@ -1735,6 +1735,6 @@
  * @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,6 +1755,6 @@
  * @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,5 +1825,5 @@
                                     Assert   (pEntry->cbInfo == sizeof(SHCLFSOBJINFO));
 
-                                    SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
+                                    ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
                                 }
                             }
@@ -1856,5 +1856,5 @@
                             if (RT_SUCCESS(rc))
                             {
-                                SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
+                                ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
 
                                 pEntry->cbInfo = sizeof(SHCLFSOBJINFO);
@@ -1889,6 +1889,6 @@
 }
 
-int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                     PSHCLLISTENTRY pEntry)
+int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                          PSHCLLISTENTRY pEntry)
 {
     RT_NOREF(pTransfer, hList, pEntry);
@@ -1912,5 +1912,5 @@
  * @param   hList               List handle to check.
  */
-bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
+bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     bool fIsValid = false;
@@ -1935,6 +1935,6 @@
  * @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,5 +2001,5 @@
  * @param   pTransfer           Clipboard transfer to reset.
  */
-void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer)
+void ShClTransferReset(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2016,5 +2016,5 @@
  * @param   pTransfer           Clipboard transfer to return clipboard area for.
  */
-SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer)
+SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -2029,5 +2029,5 @@
  * @param   pTransfer           Clipboard transfer to return root entry count for.
  */
-uint32_t SharedClipboardTransferRootsCount(PSHCLTRANSFER pTransfer)
+uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2063,6 +2063,6 @@
  * @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,5 +2089,5 @@
         LogFlowFunc(("pcszSrcPath=%s, pszDstPath=%s\n", pcszSrcPath, pszDstPath));
 
-        rc = SharedClipboardTransferListEntryInit(pEntry);
+        rc = ShClTransferListEntryInit(pEntry);
         if (RT_SUCCESS(rc))
         {
@@ -2103,5 +2103,5 @@
                     if (RT_SUCCESS(rc))
                     {
-                        SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
+                        ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
 
                         pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO;
@@ -2127,5 +2127,5 @@
  * @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,5 +2138,5 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
+        PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
         if (!pRootList)
             return VERR_NO_MEMORY;
@@ -2154,5 +2154,5 @@
                 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,5 +2198,5 @@
  * @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,5 +2267,5 @@
  * @param   pTransfer           Clipboard transfer to return ID for.
  */
-SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer)
+SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2280,5 +2280,5 @@
  * @param   pTransfer           Clipboard transfer to return direction for.
  */
-SHCLTRANSFERDIR SharedClipboardTransferGetDir(PSHCLTRANSFER pTransfer)
+SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLTRANSFERDIR_UNKNOWN);
@@ -2293,5 +2293,5 @@
  * @param   pTransfer           Clipboard transfer to return source for.
  */
-SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer)
+SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
@@ -2306,5 +2306,5 @@
  * @param   pTransfer           Clipboard transfer to return status for.
  */
-SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer)
+SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE);
@@ -2321,5 +2321,5 @@
  * @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,5 +2328,5 @@
 
     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,5 +2343,5 @@
  * @param   pTransfer           Clipboard transfer to start.
  */
-int SharedClipboardTransferStart(PSHCLTRANSFER pTransfer)
+int ShClTransferStart(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2351,5 +2351,5 @@
     /* 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,6 +2380,6 @@
  * @param   pCallbacks          Pointer to callback table to set.
  */
-void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer,
-                                         PSHCLTRANSFERCALLBACKS pCallbacks)
+void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer,
+                              PSHCLTRANSFERCALLBACKS pCallbacks)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2479,5 +2479,5 @@
  * @param   pTransferCtx                Transfer context to initialize.
  */
-int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
+int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER);
@@ -2496,5 +2496,5 @@
         RT_ZERO(pTransferCtx->bmTransferIds);
 
-        SharedClipboardTransferCtxReset(pTransferCtx);
+        ShClTransferCtxReset(pTransferCtx);
     }
 
@@ -2507,5 +2507,5 @@
  * @param   pTransferCtx                Transfer context to destroy.
  */
-void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
+void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturnVoid(pTransferCtx);
@@ -2518,5 +2518,5 @@
     RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
     {
-        SharedClipboardTransferDestroy(pTransfer);
+        ShClTransferDestroy(pTransfer);
 
         RTListNodeRemove(&pTransfer->Node);
@@ -2535,5 +2535,5 @@
  * @param   pTransferCtx                Transfer context to reset.
  */
-void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
+void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturnVoid(pTransferCtx);
@@ -2543,5 +2543,5 @@
     PSHCLTRANSFER pTransfer;
     RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node)
-        SharedClipboardTransferReset(pTransfer);
+        ShClTransferReset(pTransfer);
 }
 
@@ -2572,5 +2572,5 @@
  * @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,5 +2583,5 @@
  * @param   pTransferCtx                Transfer context to return number for.
  */
-uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
+uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, 0);
@@ -2595,5 +2595,5 @@
  * @param   pTransferCtx                Transfer context to return number for.
  */
-uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
+uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, 0);
@@ -2611,5 +2611,5 @@
  * @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,5 +2664,5 @@
  * @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,5 +2693,5 @@
  * @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,5 +2719,5 @@
  * @param   pTransferCtx                Transfer context to cleanup transfers for.
  */
-void SharedClipboardTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx)
+void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturnVoid(pTransferCtx);
@@ -2733,7 +2733,7 @@
     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,5 +2753,5 @@
  * @param   pTransferCtx                Transfer context to determine value for.
  */
-bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
+bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
 {
     AssertPtrReturn(pTransferCtx, true);
@@ -2769,5 +2769,5 @@
  * @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,5 +3055,5 @@
  * @param   enmStatus           The transfer status to translate.
  */
-const char *VBoxShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus)
+const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus)
 {
     switch (enmStatus)
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp	(revision 81223)
@@ -1015,5 +1015,5 @@
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
 
-    Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
+    Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
 
     int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
@@ -1036,6 +1036,6 @@
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardTransferRootsSet(pTransfer,
-                                                         papszList, cbList + 1 /* Include termination */);
+                    rc = ShClTransferRootsSet(pTransfer,
+                                              papszList, cbList + 1 /* Include termination */);
                     RTStrFree(papszList);
                 }
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp	(revision 81222)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp	(revision 81223)
@@ -1160,5 +1160,5 @@
     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,5 +1169,5 @@
     /* 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,6 +1350,6 @@
         {
             /* 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,5 +1543,5 @@
     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,6 +1551,6 @@
     }
     if (RT_SUCCESS(rc))
-        rc = vboxClipboardUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest,
-                                        cwcDest);
+        rc = ShClUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest,
+                               cwcDest);
     if (RT_SUCCESS(rc))
     {
@@ -1820,6 +1820,6 @@
                 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))
                 {
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp	(revision 81222)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp	(revision 81223)
@@ -87,5 +87,5 @@
     if (pMsgHdr)
     {
-        SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -96,5 +96,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -103,5 +103,5 @@
             {
                 PSHCLEVENTPAYLOAD pPayloadHdr;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
                                               pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
                 if (RT_SUCCESS(rc))
@@ -112,5 +112,5 @@
                     LogFlowFunc(("cRoots=%RU32, fRoots=0x%x\n", pSrcRootListHdr->cRoots, pSrcRootListHdr->fRoots));
 
-                    PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
+                    PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
                     if (pRootList)
                     {
@@ -127,5 +127,5 @@
                                                                                VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
 
-                                    uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+                                    uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
                                     HGCMSvcSetU32(&pMsgEntry->paParms[0],
@@ -135,5 +135,5 @@
                                     HGCMSvcSetU32(&pMsgEntry->paParms[2], i /* uIndex */);
 
-                                    rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+                                    rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
                                     AssertRC(rc2);
 
@@ -143,6 +143,6 @@
 
                                     PSHCLEVENTPAYLOAD pPayloadEntry;
-                                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
-                                                                  pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
+                                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
+                                                       pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
                                     if (RT_FAILURE(rc))
                                         break;
@@ -151,9 +151,9 @@
                                     Assert(pPayloadEntry->cbData == sizeof(SHCLROOTLISTENTRY));
 
-                                    rc = SharedClipboardTransferListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
-
-                                    SharedClipboardPayloadFree(pPayloadEntry);
-
-                                    SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
+                                    rc = ShClTransferListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
+
+                                    ShClPayloadFree(pPayloadEntry);
+
+                                    ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
 
                                     if (RT_FAILURE(rc))
@@ -173,7 +173,7 @@
                         }
                         else
-                            SharedClipboardTransferRootListFree(pRootList);
-
-                        SharedClipboardPayloadFree(pPayloadHdr);
+                            ShClTransferRootListFree(pRootList);
+
+                        ShClPayloadFree(pPayloadHdr);
                     }
                     else
@@ -182,5 +182,5 @@
             }
 
-            SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
+            ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
         }
     }
@@ -206,5 +206,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
@@ -217,5 +217,5 @@
             if (RT_SUCCESS(rc))
             {
-                int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
                 AssertRC(rc2);
 
@@ -224,5 +224,5 @@
                 {
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                     if (RT_SUCCESS(rc))
                     {
@@ -236,9 +236,9 @@
                         *phList = pReply->u.ListOpen.uHandle;
 
-                        SharedClipboardPayloadFree(pPayload);
+                        ShClPayloadFree(pPayload);
                     }
                 }
 
-                SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
+                ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
             }
         }
@@ -264,5 +264,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
@@ -275,5 +275,5 @@
             if (RT_SUCCESS(rc))
             {
-                int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
                 AssertRC(rc2);
 
@@ -282,10 +282,10 @@
                 {
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                     if (RT_SUCCESS(rc))
-                        SharedClipboardPayloadFree(pPayload);
-                }
-
-                SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
+                        ShClPayloadFree(pPayload);
+                }
+
+                ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
             }
         }
@@ -312,5 +312,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -322,5 +322,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -329,6 +329,6 @@
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
-                                             pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
+                                   pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -337,5 +337,5 @@
                     *pListHdr = *(PSHCLLISTHDR)pPayload->pvData;
 
-                    SharedClipboardPayloadFree(pPayload);
+                    ShClPayloadFree(pPayload);
                 }
             }
@@ -373,5 +373,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -383,5 +383,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -390,12 +390,12 @@
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     Assert(pPayload->cbData == sizeof(SHCLLISTENTRY));
 
-                    rc = SharedClipboardTransferListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData);
-
-                    SharedClipboardPayloadFree(pPayload);
+                    rc = ShClTransferListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData);
+
+                    ShClPayloadFree(pPayload);
                 }
             }
@@ -433,5 +433,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
@@ -449,5 +449,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -456,5 +456,5 @@
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -468,5 +468,5 @@
                     *phObj = pReply->u.ObjOpen.uHandle;
 
-                    SharedClipboardPayloadFree(pPayload);
+                    ShClPayloadFree(pPayload);
                 }
             }
@@ -493,5 +493,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -502,5 +502,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -509,5 +509,5 @@
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -521,5 +521,5 @@
 #endif
 
-                    SharedClipboardPayloadFree(pPayload);
+                    ShClPayloadFree(pPayload);
                 }
             }
@@ -547,5 +547,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -558,5 +558,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -565,5 +565,5 @@
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -580,5 +580,5 @@
                         *pcbRead = cbRead;
 
-                    SharedClipboardPayloadFree(pPayload);
+                    ShClPayloadFree(pPayload);
                 }
             }
@@ -606,5 +606,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -617,5 +617,5 @@
         if (RT_SUCCESS(rc))
         {
-            int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
             AssertRC(rc2);
 
@@ -624,5 +624,5 @@
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -634,5 +634,5 @@
                         *pcbWritten = cbRead;
 
-                    SharedClipboardPayloadFree(pPayload);
+                    ShClPayloadFree(pPayload);
                 }
             }
@@ -722,5 +722,5 @@
     }
 
-    LogFlowFunc(("uMsg=%RU32 (%s), uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, VBoxShClGuestMsgToStr(uMsg), uMode, fAllowed));
+    LogFlowFunc(("uMsg=%RU32 (%s), uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, ShClGuestMsgToStr(uMsg), uMode, fAllowed));
     return fAllowed;
 }
@@ -1077,5 +1077,5 @@
         if (RT_SUCCESS(rc))
         {
-            if (!SharedClipboardTransferListEntryIsValid(pListEntry))
+            if (!ShClTransferListEntryIsValid(pListEntry))
                 rc = VERR_INVALID_PARAMETER;
         }
@@ -1236,5 +1236,5 @@
                             LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent));
 
-                            rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                            rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                         }
                         break;
@@ -1290,5 +1290,5 @@
 
     LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n",
-                 pClient->State.uClientID, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
+                 pClient->State.uClientID, u32Function, ShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
 
     /* Check if we've the right mode set. */
@@ -1322,5 +1322,5 @@
         default:
         {
-            if (!SharedClipboardTransferCtxGetTotalTransfers(&pClient->TransferCtx))
+            if (!ShClTransferCtxGetTotalTransfers(&pClient->TransferCtx))
             {
                 LogFunc(("No transfers found\n"));
@@ -1338,5 +1338,5 @@
             const SHCLTRANSFERID uTransferID = VBOX_SHCL_CONTEXTID_GET_TRANSFER(uCID);
 
-            pTransfer = SharedClipboardTransferCtxGetTransfer(&pClient->TransferCtx, uTransferID);
+            pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, uTransferID);
             if (!pTransfer)
             {
@@ -1369,5 +1369,5 @@
             RT_ZERO(rootListHdr);
 
-            rootListHdr.cRoots = SharedClipboardTransferRootsCount(pTransfer);
+            rootListHdr.cRoots = ShClTransferRootsCount(pTransfer);
 
             HGCMSvcSetU32(&paParms[0], 0 /* Context ID */);
@@ -1385,5 +1385,5 @@
             if (RT_SUCCESS(rc))
             {
-                void    *pvData = SharedClipboardTransferRootListHdrDup(&lstHdr);
+                void    *pvData = ShClTransferRootListHdrDup(&lstHdr);
                 uint32_t cbData = sizeof(SHCLROOTLISTHDR);
 
@@ -1391,10 +1391,10 @@
 
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                     if (RT_FAILURE(rc))
-                        SharedClipboardPayloadFree(pPayload);
+                        ShClPayloadFree(pPayload);
                 }
             }
@@ -1413,5 +1413,5 @@
             {
                 SHCLROOTLISTENTRY rootListEntry;
-                rc = SharedClipboardTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
+                rc = ShClTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
                 if (RT_SUCCESS(rc))
                 {
@@ -1430,5 +1430,5 @@
             if (RT_SUCCESS(rc))
             {
-                void    *pvData = SharedClipboardTransferRootListEntryDup(&lstEntry);
+                void    *pvData = ShClTransferRootListEntryDup(&lstEntry);
                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
 
@@ -1436,10 +1436,10 @@
 
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                     if (RT_FAILURE(rc))
-                        SharedClipboardPayloadFree(pPayload);
+                        ShClPayloadFree(pPayload);
                 }
             }
@@ -1454,5 +1454,5 @@
             {
                 SHCLLISTHANDLE hList;
-                rc = SharedClipboardTransferListOpen(pTransfer, &listOpenParms, &hList);
+                rc = ShClTransferListOpen(pTransfer, &listOpenParms, &hList);
                 if (RT_SUCCESS(rc))
                 {
@@ -1473,5 +1473,5 @@
             if (RT_SUCCESS(rc))
             {
-                rc = SharedClipboardTransferListClose(pTransfer, hList);
+                rc = ShClTransferListClose(pTransfer, hList);
             }
             break;
@@ -1488,5 +1488,5 @@
             {
                 SHCLLISTHDR hdrList;
-                rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
+                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
                 /*if (RT_SUCCESS(rc))
                     rc = shclSvcTransferSetListHdr(cParms, paParms, &hdrList);*/
@@ -1498,5 +1498,5 @@
         {
             SHCLLISTHDR hdrList;
-            rc = SharedClipboardTransferListHdrInit(&hdrList);
+            rc = ShClTransferListHdrInit(&hdrList);
             if (RT_SUCCESS(rc))
             {
@@ -1511,10 +1511,10 @@
 
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                    rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                     if (RT_SUCCESS(rc))
                     {
-                        rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                        rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                         if (RT_FAILURE(rc))
-                            SharedClipboardPayloadFree(pPayload);
+                            ShClPayloadFree(pPayload);
                     }
                 }
@@ -1533,5 +1533,5 @@
             {
                 SHCLLISTENTRY entryList;
-                rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
+                rc = ShClTransferListRead(pTransfer, hList, &entryList);
             }
             break;
@@ -1541,5 +1541,5 @@
         {
             SHCLLISTENTRY entryList;
-            rc = SharedClipboardTransferListEntryInit(&entryList);
+            rc = ShClTransferListEntryInit(&entryList);
             if (RT_SUCCESS(rc))
             {
@@ -1548,5 +1548,5 @@
                 if (RT_SUCCESS(rc))
                 {
-                    void    *pvData = SharedClipboardTransferListEntryDup(&entryList);
+                    void    *pvData = ShClTransferListEntryDup(&entryList);
                     uint32_t cbData = sizeof(SHCLLISTENTRY);
 
@@ -1554,10 +1554,10 @@
 
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                    rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                     if (RT_SUCCESS(rc))
                     {
-                        rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                        rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                         if (RT_FAILURE(rc))
-                            SharedClipboardPayloadFree(pPayload);
+                            ShClPayloadFree(pPayload);
                     }
                 }
@@ -1588,5 +1588,5 @@
             {
                 SHCLOBJHANDLE hObj;
-                rc = SharedClipboardTransferObjectOpen(pTransfer, &openCreateParms, &hObj);
+                rc = ShClTransferObjOpen(pTransfer, &openCreateParms, &hObj);
                 if (RT_SUCCESS(rc))
                 {
@@ -1607,5 +1607,5 @@
             rc = HGCMSvcGetU64(&paParms[1], &hObj); /* Get object handle. */
             if (RT_SUCCESS(rc))
-                rc = SharedClipboardTransferObjectClose(pTransfer, hObj);
+                rc = ShClTransferObjClose(pTransfer, hObj);
             break;
         }
@@ -1643,5 +1643,5 @@
             {
                 uint32_t cbRead;
-                rc = SharedClipboardTransferObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, 0 /* fFlags */);
+                rc = ShClTransferObjRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, 0 /* fFlags */);
                 if (RT_SUCCESS(rc))
                 {
@@ -1660,5 +1660,5 @@
             if (RT_SUCCESS(rc))
             {
-                void    *pvData = SharedClipboardTransferObjectDataChunkDup(&dataChunk);
+                void    *pvData = ShClTransferObjDataChunkDup(&dataChunk);
                 uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
 
@@ -1666,10 +1666,10 @@
 
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
+                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
                     if (RT_FAILURE(rc))
-                        SharedClipboardPayloadFree(pPayload);
+                        ShClPayloadFree(pPayload);
                 }
             }
@@ -2111,8 +2111,8 @@
         return VERR_NO_MEMORY;
 
-    const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
+    const SHCLEVENTID uEvent = ShClEventIDGenerate(&pTransfer->Events);
 
     HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                                  pTransfer->State.uID, uEvent));
+                                                                      pTransfer->State.uID, uEvent));
     HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir);
     HGCMSvcSetU32(&pMsgReadData->paParms[2], uStatus);
@@ -2123,5 +2123,5 @@
     if (RT_SUCCESS(rc))
     {
-        rc = SharedClipboardEventRegister(&pTransfer->Events, uEvent);
+        rc = ShClEventRegister(&pTransfer->Events, uEvent);
         if (RT_SUCCESS(rc))
         {
@@ -2130,5 +2130,5 @@
             {
                 LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n",
-                         VBoxShClTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
+                         ShClGuestMsgToStr(uStatus), rcTransfer, pTransfer->State.uID));
 
                 if (puEvent)
@@ -2136,5 +2136,5 @@
             }
             else
-                SharedClipboardEventUnregister(&pTransfer->Events, uEvent);
+                ShClEventUnregister(&pTransfer->Events, uEvent);
         }
     }
@@ -2162,14 +2162,14 @@
     LogFlowFuncEnter();
 
-    SharedClipboardTransferCtxCleanup(&pClient->TransferCtx);
+    ShClTransferCtxCleanup(&pClient->TransferCtx);
 
     int rc;
 
-    if (!SharedClipboardTransferCtxTransfersMaximumReached(&pClient->TransferCtx))
+    if (!ShClTransferCtxTransfersMaximumReached(&pClient->TransferCtx))
     {
         LogRel2(("Shared Clipboard: Starting %s transfer ...\n", enmDir == SHCLTRANSFERDIR_READ ? "read" : "write"));
 
         PSHCLTRANSFER pTransfer;
-        rc = SharedClipboardTransferCreate(&pTransfer);
+        rc = ShClTransferCreate(&pTransfer);
         if (RT_SUCCESS(rc))
         {
@@ -2214,11 +2214,11 @@
                 uint32_t uTransferID = 0;
 
-                rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
+                rc = ShClTransferSetInterface(pTransfer, &creationCtx);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardTransferCtxTransferRegister(&pClient->TransferCtx, pTransfer, &uTransferID);
+                    rc = ShClTransferCtxTransferRegister(&pClient->TransferCtx, pTransfer, &uTransferID);
                     if (RT_SUCCESS(rc))
                     {
-                        rc = SharedClipboardTransferInit(pTransfer, uTransferID, enmDir, enmSource);
+                        rc = ShClTransferInit(pTransfer, uTransferID, enmDir, enmSource);
                         if (RT_SUCCESS(rc))
                         {
@@ -2230,5 +2230,5 @@
 
                             if (RT_SUCCESS(rc))
-                                rc = SharedClipboardTransferStart(pTransfer);
+                                rc = ShClTransferStart(pTransfer);
 
                             if (RT_SUCCESS(rc))
@@ -2244,5 +2244,5 @@
 
                                     PSHCLEVENTPAYLOAD pPayload;
-                                    rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload);
+                                    rc = ShClEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload);
                                     if (RT_SUCCESS(rc))
                                     {
@@ -2259,5 +2259,5 @@
                                         else
                                             LogRel(("Shared Clipboard: Guest reported status %s (error %Rrc) while starting transfer %RU32\n",
-                                                    VBoxShClTransferStatusToStr(pReply->u.TransferStatus.uStatus),
+                                                    ShClGuestMsgToStr(pReply->u.TransferStatus.uStatus),
                                                     pReply->rc, pTransfer->State.uID));
                                     }
@@ -2270,5 +2270,5 @@
 
                         if (RT_FAILURE(rc))
-                            SharedClipboardTransferCtxTransferUnregister(&pClient->TransferCtx, uTransferID);
+                            ShClTransferCtxTransferUnregister(&pClient->TransferCtx, uTransferID);
                     }
                 }
@@ -2278,5 +2278,5 @@
             {
                 ShClSvcImplTransferDestroy(pClient, pTransfer);
-                SharedClipboardTransferDestroy(pTransfer);
+                ShClTransferDestroy(pTransfer);
 
                 RTMemFree(pTransfer);
@@ -2309,5 +2309,5 @@
 int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
-    int rc = SharedClipboardTransferClose(pTransfer);
+    int rc = ShClTransferClose(pTransfer);
     if (RT_SUCCESS(rc))
     {
@@ -2320,8 +2320,8 @@
             LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU32 on guest ...\n", pTransfer->State.uID));
 
-            rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL);
-            if (RT_SUCCESS(rc))
-            {
-                rc = SharedClipboardTransferCtxTransferUnregister(&pClient->TransferCtx, SharedClipboardTransferGetID(pTransfer));
+            rc = ShClEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL);
+            if (RT_SUCCESS(rc))
+            {
+                rc = ShClTransferCtxTransferUnregister(&pClient->TransferCtx, ShClTransferGetID(pTransfer));
 
                 LogRel2(("Shared Clipboard: Stopped transfer %RU32 on guest\n", pTransfer->State.uID));
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp	(revision 81222)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp	(revision 81223)
@@ -108,5 +108,5 @@
 
 #ifdef LOG_ENABLED
-    VBoxShClDbgDumpData(pvDst, cbSrc, u32Format);
+    ShClDbgDumpData(pvDst, cbSrc, u32Format);
 #endif
 
@@ -183,5 +183,5 @@
     {
         PSHCLEVENTPAYLOAD pPayload;
-        rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
+        rc = ShClEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
         if (RT_SUCCESS(rc))
         {
@@ -190,8 +190,8 @@
 
             /* Detach the payload, as the caller then will own the data. */
-            SharedClipboardEventPayloadDetach(&pCtx->pClient->Events, uEvent);
-        }
-
-        SharedClipboardEventUnregister(&pCtx->pClient->Events, uEvent);
+            ShClEventPayloadDetach(&pCtx->pClient->Events, uEvent);
+        }
+
+        ShClEventUnregister(&pCtx->pClient->Events, uEvent);
     }
 
@@ -829,5 +829,5 @@
 #ifdef VBOX_STRICT
                         LogFlowFunc(("Raw HTML clipboard data from host:"));
-                        VBoxShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
+                        ShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
 #endif
                         GlobalUnlock(hClip);
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp	(revision 81222)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp	(revision 81223)
@@ -224,5 +224,5 @@
     if (pReq)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->Events);
 
         pReq->pv        = pData->pvData;
@@ -234,9 +234,9 @@
         if (RT_SUCCESS(rc))
         {
-            rc = SharedClipboardEventRegister(&pClient->Events, uEvent);
+            rc = ShClEventRegister(&pClient->Events, uEvent);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = SharedClipboardEventWait(&pClient->Events, uEvent, 30 * 1000, &pPayload);
+                rc = ShClEventWait(&pClient->Events, uEvent, 30 * 1000, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -247,5 +247,5 @@
                 }
 
-                SharedClipboardEventUnregister(&pClient->Events, uEvent);
+                ShClEventUnregister(&pClient->Events, uEvent);
             }
         }
@@ -292,7 +292,7 @@
 
     PSHCLEVENTPAYLOAD pPayload;
-    int rc2 = SharedClipboardPayloadAlloc(pReq->uEvent, pv, cb, &pPayload);
+    int rc2 = ShClPayloadAlloc(pReq->uEvent, pv, cb, &pPayload);
     if (RT_SUCCESS(rc2))
-        rc2 = SharedClipboardEventSignal(&pCtx->pClient->Events, pReq->uEvent, pPayload);
+        rc2 = ShClEventSignal(&pCtx->pClient->Events, pReq->uEvent, pPayload);
 
     AssertRC(rc);
@@ -335,5 +335,5 @@
     {
         PSHCLEVENTPAYLOAD pPayload;
-        rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
+        rc = ShClEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
         if (RT_SUCCESS(rc))
         {
@@ -342,8 +342,8 @@
 
             /* Detach the payload, as the caller then will own the data. */
-            SharedClipboardEventPayloadDetach(&pCtx->pClient->Events, uEvent);
-        }
-
-        SharedClipboardEventUnregister(&pCtx->pClient->Events, uEvent);
+            ShClEventPayloadDetach(&pCtx->pClient->Events, uEvent);
+        }
+
+        ShClEventUnregister(&pCtx->pClient->Events, uEvent);
     }
 
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp	(revision 81222)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp	(revision 81223)
@@ -473,5 +473,5 @@
 
     LogFlowFunc(("uMsg=%RU32 (%s), cParms=%RU32, fAppend=%RTbool\n",
-                 pMsg->uMsg, VBoxShClHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
+                 pMsg->uMsg, ShClHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
 
     if (fAppend)
@@ -550,5 +550,5 @@
             shclSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
             LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
-                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
             return VINF_SUCCESS;
@@ -611,5 +611,5 @@
 
             LogFlowFunc(("[Client %RU32] uMsg=%RU32 (%s), cParms=%RU32\n",
-                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
 
@@ -684,15 +684,15 @@
         {
             LogFlowFunc(("First message is: %RU32 (%s), cParms=%RU32\n",
-                         pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
+                         pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
 
             ASSERT_GUEST_MSG_RETURN(pFirstMsg->uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
                                     ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                     pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
-                                     idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
+                                     pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
+                                     idMsgExpected, ShClHostMsgToStr(idMsgExpected), cParms),
                                     VERR_MISMATCH);
             ASSERT_GUEST_MSG_RETURN(pFirstMsg->cParms == cParms,
                                     ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                     pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
-                                     idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
+                                     pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
+                                     idMsgExpected, ShClHostMsgToStr(idMsgExpected), cParms),
                                     VERR_WRONG_PARAMETER_COUNT);
 
@@ -701,5 +701,5 @@
                 ASSERT_GUEST_MSG_RETURN(pFirstMsg->paParms[i].type == paParms[i].type,
                                         ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->paParms[i].type,
-                                         paParms[i].type, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg)),
+                                         paParms[i].type, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg)),
                                         VERR_WRONG_PARAMETER_TYPE);
             /*
@@ -797,5 +797,5 @@
             {
                 LogFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n",
-                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
 
@@ -866,5 +866,5 @@
     if (pMsgReadData)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->Events);
 
         HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -876,5 +876,5 @@
         if (RT_SUCCESS(rc))
         {
-            rc = SharedClipboardEventRegister(&pClient->Events, uEvent);
+            rc = ShClEventRegister(&pClient->Events, uEvent);
             if (RT_SUCCESS(rc))
             {
@@ -886,5 +886,5 @@
                 }
                 else
-                    SharedClipboardEventUnregister(&pClient->Events, uEvent);
+                    ShClEventUnregister(&pClient->Events, uEvent);
             }
         }
@@ -909,5 +909,5 @@
         /* Protocol v0 did not have any context ID handling, so we ASSUME that the last event registered
          * is the one we want to handle (as this all was a synchronous protocol anyway). */
-        uEvent = SharedClipboardEventGetLast(&pClient->Events);
+        uEvent = ShClEventGetLast(&pClient->Events);
     }
     else
@@ -918,11 +918,11 @@
     PSHCLEVENTPAYLOAD pPayload = NULL;
     if (pData->cbData)
-        rc = SharedClipboardPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
+        rc = ShClPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
 
     if (RT_SUCCESS(rc))
     {
-        rc = SharedClipboardEventSignal(&pClient->Events, uEvent, pPayload);
+        rc = ShClEventSignal(&pClient->Events, uEvent, pPayload);
         if (RT_FAILURE(rc))
-            SharedClipboardPayloadFree(pPayload);
+            ShClPayloadFree(pPayload);
     }
 
@@ -941,5 +941,5 @@
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
+        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->Events);
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
@@ -1121,9 +1121,9 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-    PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
+    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
     if (pTransfer)
         shclSvcTransferAreaDetach(&pClient->State, pTransfer);
 
-    SharedClipboardTransferCtxDestroy(&pClient->TransferCtx);
+    ShClTransferCtxDestroy(&pClient->TransferCtx);
 #endif
 
@@ -1145,5 +1145,5 @@
     shclSvcClientStateDestroy(&pClient->State);
 
-    SharedClipboardEventSourceDestroy(&pClient->Events);
+    ShClEventSourceDestroy(&pClient->Events);
 
     ClipboardClientMap::iterator itClient = g_mapClients.find(u32ClientID);
@@ -1169,5 +1169,5 @@
 
     /* Create the client's own event source. */
-    int rc = SharedClipboardEventSourceCreate(&pClient->Events, 0 /* ID, ignored */);
+    int rc = ShClEventSourceCreate(&pClient->Events, 0 /* ID, ignored */);
     if (RT_SUCCESS(rc))
     {
@@ -1182,5 +1182,5 @@
         {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-            rc = SharedClipboardTransferCtxInit(&pClient->TransferCtx);
+            rc = ShClTransferCtxInit(&pClient->TransferCtx);
 #endif
             if (RT_SUCCESS(rc))
@@ -1222,5 +1222,5 @@
 
     LogFunc(("u32ClientID=%RU32 (proto %RU32), fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
-             u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, paParms));
+             u32ClientID, pClient->State.uProtocolVer, u32Function, ShClGuestMsgToStr(u32Function), cParms, paParms));
 
 #ifdef DEBUG
@@ -1568,5 +1568,5 @@
 
     LogFlowFunc(("u32Function=%RU32 (%s), cParms=%RU32, paParms=%p\n",
-                 u32Function, VBoxShClHostFunctionToStr(u32Function), cParms, paParms));
+                 u32Function, ShClHostFunctionToStr(u32Function), cParms, paParms));
 
     switch (u32Function)
Index: /trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp	(revision 81222)
+++ /trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp	(revision 81223)
@@ -208,5 +208,5 @@
                 size_t cwSrc = RTUtf16Len(pwszTmp);
                 size_t cwDest;
-                rc = vboxClipboardUtf16GetWinSize(pwszTmp, cwSrc, &cwDest);
+                rc = ShClUtf16GetWinSize(pwszTmp, cwSrc, &cwDest);
                 if (RT_FAILURE(rc))
                 {
@@ -222,5 +222,5 @@
                 if (*pcbActual <= cb)
                 {
-                    rc = vboxClipboardUtf16LinToWin(pwszTmp, RTUtf16Len(pwszTmp), static_cast <PRTUTF16>(pv), cb / 2);
+                    rc = ShClUtf16LinToWin(pwszTmp, RTUtf16Len(pwszTmp), static_cast <PRTUTF16>(pv), cb / 2);
                     if (RT_FAILURE(rc))
                     {
@@ -254,5 +254,5 @@
                 const void *pDib;
                 size_t cbDibSize;
-                rc = vboxClipboardBmpGetDib(pTmp, cbTmpSize, &pDib, &cbDibSize);
+                rc = ShClBmpGetDib(pTmp, cbTmpSize, &pDib, &cbDibSize);
                 if (RT_FAILURE(rc))
                 {
@@ -311,5 +311,5 @@
         size_t cwDest = 0;
         /* How long will the converted text be? */
-        rc = vboxClipboardUtf16GetLinSize(pwszSrcText, cwSrc, &cwDest);
+        rc = ShClUtf16GetLinSize(pwszSrcText, cwSrc, &cwDest);
         if (RT_FAILURE(rc))
         {
@@ -331,5 +331,5 @@
         }
         /* Convert the EOL */
-        rc = vboxClipboardUtf16WinToLin(pwszSrcText, cwSrc, pwszDestText, cwDest);
+        rc = ShClUtf16WinToLin(pwszSrcText, cwSrc, pwszDestText, cwDest);
         if (RT_FAILURE(rc))
         {
@@ -381,5 +381,5 @@
         PasteboardItemID itemId = (PasteboardItemID)1;
 
-        rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmpSize);
+        rc = ShClDibToBmp(pv, cb, &pBmp, &cbBmpSize);
         if (RT_SUCCESS(rc))
         {