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

Timestamp:

Sep 9, 2019 8:43:14 AM (5 years ago)

Author:

vboxsync

Message:

Shared Clipboard: Renaming (SHAREDCLIPBOARD -> SHCL and VBOXCLIPBOARD -> SHCL).

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• ClipboardArea.cpp (modified) (10 diffs)
• ClipboardDataObjectImpl-win.cpp (modified) (12 diffs)
• ClipboardStreamImpl-win.cpp (modified) (3 diffs)
• clipboard-common.cpp (modified) (21 diffs)
• clipboard-uri.cpp (modified) (147 diffs)
• clipboard-win.cpp (modified) (16 diffs)
• clipboard-x11.cpp (modified) (7 diffs)

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

@@ -38 +38 @@
     , m_fOpen(0)
     , m_hDir(NIL_RTDIR)
-    , m_uID(NIL_SHAREDCLIPBOARDAREAID)
+    , m_uID(NIL_SHCLAREAID)
 {
     int rc = initInternal();
@@ -46 +46 @@
 
 SharedClipboardArea::SharedClipboardArea(const char *pszPath,
-                                         SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */,
-                                         SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */)
+                                         SHCLAREAID uID /* = NIL_SHCLAREAID */,
+                                         SHCLAREAOPENFLAGS fFlags /* = SHCLAREA_OPEN_FLAGS_NONE */)
     : m_tsCreatedMs(0)
     , m_cRefs(0)
@@ -115 +115 @@
 }
 
-int SharedClipboardArea::AddObject(const char *pszPath, const SHAREDCLIPBOARDAREAOBJ &Obj)
+int SharedClipboardArea::AddObject(const char *pszPath, const SHCLAREAOBJ &Obj)
 {
     AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
@@ -126 +126 @@
 }
 
-int SharedClipboardArea::GetObject(const char *pszPath, PSHAREDCLIPBOARDAREAOBJ pObj)
+int SharedClipboardArea::GetObject(const char *pszPath, PSHCLAREAOBJ pObj)
 {
     SharedClipboardAreaFsObjMap::const_iterator itObj = m_mapObj.find(pszPath);
@@ -166 +166 @@
     if (RT_SUCCESS(rc))
     {
-        this->m_fOpen = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE;
-        this->m_uID   = NIL_SHAREDCLIPBOARDAREAID;
+        this->m_fOpen = SHCLAREA_OPEN_FLAGS_NONE;
+        this->m_uID   = NIL_SHCLAREAID;
     }
 
@@ -185 +185 @@
  */
 /* static */
-int SharedClipboardArea::PathConstruct(const char *pszBase, SHAREDCLIPBOARDAREAID uID, char *pszPath, size_t cbPath)
+int SharedClipboardArea::PathConstruct(const char *pszBase, SHCLAREAID uID, char *pszPath, size_t cbPath)
 {
     LogFlowFunc(("pszBase=%s, uAreaID=%RU32\n", pszBase, uID));
@@ -224 +224 @@
 }
 
-SHAREDCLIPBOARDAREAID SharedClipboardArea::GetID(void) const
+SHCLAREAID SharedClipboardArea::GetID(void) const
 {
     return this->m_uID;
@@ -245 +245 @@
 
 int SharedClipboardArea::OpenEx(const char *pszPath,
-                                SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */,
-                                SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */)
+                                SHCLAREAID uID /* = NIL_SHCLAREAID */,
+                                SHCLAREAOPENFLAGS fFlags /* = SHCLAREA_OPEN_FLAGS_NONE */)
 {
     AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
-    AssertReturn(!(fFlags & ~SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+    AssertReturn(!(fFlags & ~SHCLAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
 
     char szAreaDir[RTPATH_MAX];
@@ -256 +256 @@
     {
         if (   RTDirExists(szAreaDir)
-            && (fFlags & SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST))
+            && (fFlags & SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST))
         {
             rc = VERR_ALREADY_EXISTS;
@@ -282 +282 @@
 }
 
-int SharedClipboardArea::OpenTemp(SHAREDCLIPBOARDAREAID uID,
-                                  SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */)
-{
-    AssertReturn(!(fFlags & ~SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+int SharedClipboardArea::OpenTemp(SHCLAREAID uID,
+                                  SHCLAREAOPENFLAGS fFlags /* = SHCLAREA_OPEN_FLAGS_NONE */)
+{
+    AssertReturn(!(fFlags & ~SHCLAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
 
     /*

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

@@ -41 +41 @@
 //#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 0
 
-VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer,
                                                        LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
     : m_enmStatus(Uninitialized)
@@ -229 +229 @@
  * @param   strDir              Directory path to handle.
  */
-int VBoxClipboardWinDataObject::readDir(PSHAREDCLIPBOARDURITRANSFER pTransfer, const Utf8Str &strDir)
+int VBoxClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir)
 {
     LogFlowFunc(("strDir=%s\n", strDir.c_str()));
 
-    VBOXCLIPBOARDLISTOPENPARMS openParmsList;
+    SHCLLISTOPENPARMS openParmsList;
     int rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
     if (RT_SUCCESS(rc))
@@ -240 +240 @@
         if (RT_SUCCESS(rc))
         {
-            SHAREDCLIPBOARDLISTHANDLE hList;
+            SHCLLISTHANDLE hList;
             rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
             if (RT_SUCCESS(rc))
@@ -246 +246 @@
                 LogFlowFunc(("strDir=%s -> hList=%RU64\n", strDir.c_str(), hList));
 
-                VBOXCLIPBOARDLISTHDR hdrList;
+                SHCLLISTHDR hdrList;
                 rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
                 if (RT_SUCCESS(rc))
@@ -255 +255 @@
                     for (uint64_t o = 0; o < hdrList.cTotalObjects; o++)
                     {
-                        VBOXCLIPBOARDLISTENTRY entryList;
+                        SHCLLISTENTRY entryList;
                         rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
                         if (RT_SUCCESS(rc))
                         {
-                            PSHAREDCLIPBOARDFSOBJINFO pFsObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)entryList.pvInfo;
-                            Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
+                            PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)entryList.pvInfo;
+                            Assert(entryList.cbInfo == sizeof(SHCLFSOBJINFO));
 
                             Utf8Str strPath = strDir + Utf8Str("\\") + Utf8Str(entryList.pszName);
@@ -320 +320 @@
     VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pvUser;
 
-    PSHAREDCLIPBOARDURITRANSFER pTransfer = pThis->m_pTransfer;
+    PSHCLURITRANSFER pTransfer = pThis->m_pTransfer;
     AssertPtr(pTransfer);
 
@@ -333 +333 @@
     if (RT_SUCCESS(rc))
     {
-        PVBOXCLIPBOARDROOTLIST pRootList;
+        PSHCLROOTLIST pRootList;
         rc = SharedClipboardURILTransferRootsAsList(pTransfer, &pRootList);
         if (RT_SUCCESS(rc))
@@ -341 +341 @@
             for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
             {
-                PVBOXCLIPBOARDLISTENTRY pRootEntry = &pRootList->paEntries[i];
+                PSHCLLISTENTRY pRootEntry = &pRootList->paEntries[i];
                 AssertPtr(pRootEntry);
 
-                Assert(pRootEntry->cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO));
-                PSHAREDCLIPBOARDFSOBJINFO pFsObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)pRootEntry->pvInfo;
+                Assert(pRootEntry->cbInfo == sizeof(SHCLFSOBJINFO));
+                PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)pRootEntry->pvInfo;
 
                 LogFlowFunc(("pszRoot=%s, fMode=0x%x\n", pRootEntry->pszName, pFsObjInfo->Attr.fMode));
@@ -405 +405 @@
  * @param   phGlobal            Where to store the allocated HGLOBAL object on success.
  */
-int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer,
                                                                       bool fUnicode, HGLOBAL *phGlobal)
 {
@@ -478 +478 @@
         pFD->dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
 
-        const SHAREDCLIPBOARDFSOBJINFO *pObjInfo = &itRoot->objInfo;
+        const SHCLFSOBJINFO *pObjInfo = &itRoot->objInfo;
 
         if (RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode))
@@ -558 +558 @@
 
         /* The caller can call GetData() several times, so make sure we don't do the same transfer multiple times. */
-        if (SharedClipboardURITransferGetStatus(m_pTransfer) == SHAREDCLIPBOARDURITRANSFERSTATUS_NONE)
+        if (SharedClipboardURITransferGetStatus(m_pTransfer) == SHCLURITRANSFERSTATUS_NONE)
         {
             rc = SharedClipboardURITransferPrepare(m_pTransfer);
@@ -615 +615 @@
             /* Hand-in the provider so that our IStream implementation can continue working with it. */
             hr = VBoxClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer,
-                                                    fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHAREDCLIPBOARDFSOBJINFO */,
+                                                    fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */,
                                                     &m_pStream);
             if (SUCCEEDED(hr))

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

@@ -46 +46 @@
 
 
-VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                                       const Utf8Str &strPath, PSHAREDCLIPBOARDFSOBJINFO pObjInfo)
+VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
+                                                       const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo)
     : m_pParent(pParent)
     , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */
     , m_pURITransfer(pTransfer)
     , m_strPath(strPath)
-    , m_hObj(SHAREDCLIPBOARDOBJHANDLE_INVALID)
+    , m_hObj(SHCLOBJHANDLE_INVALID)
     , m_objInfo(*pObjInfo)
     , m_cbProcessed(0)
@@ -184 +184 @@
     try
     {
-        if (   m_hObj == SHAREDCLIPBOARDOBJHANDLE_INVALID
+        if (   m_hObj == SHCLOBJHANDLE_INVALID
             && m_pURITransfer->ProviderIface.pfnObjOpen)
         {
-            VBOXCLIPBOARDOBJOPENCREATEPARMS openParms;
+            SHCLOBJOPENCREATEPARMS openParms;
             rc = SharedClipboardURIObjectOpenParmsInit(&openParms);
             if (RT_SUCCESS(rc))
             {
-                openParms.fCreate = SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS
-                                  | SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW
-                                  | SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ
-                                  | SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE;
+                openParms.fCreate = SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS
+                                  | SHCL_OBJ_CF_ACT_FAIL_IF_NEW
+                                  | SHCL_OBJ_CF_ACCESS_READ
+                                  | SHCL_OBJ_CF_ACCESS_DENYWRITE;
 
                 rc = RTStrCopy(openParms.pszPath, openParms.cbPath, m_strPath.c_str());
@@ -362 +362 @@
  */
 /* static */
-HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                           const Utf8Str &strPath, PSHAREDCLIPBOARDFSOBJINFO pObjInfo,
+HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
+                                           const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo,
                                            IStream **ppStream)
 {

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

@@ -42 +42 @@
  */
 int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
-                                PSHAREDCLIPBOARDEVENTPAYLOAD *ppPayload)
+                                PSHCLEVENTPAYLOAD *ppPayload)
 {
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     AssertReturn   (cbData, VERR_INVALID_PARAMETER);
 
-    PSHAREDCLIPBOARDEVENTPAYLOAD pPayload =
-        (PSHAREDCLIPBOARDEVENTPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDEVENTPAYLOAD));
+    PSHCLEVENTPAYLOAD pPayload =
+        (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD));
     if (!pPayload)
         return VERR_NO_MEMORY;
@@ -75 +75 @@
  * @param   pPayload            Event payload to free.
  */
-void SharedClipboardPayloadFree(PSHAREDCLIPBOARDEVENTPAYLOAD pPayload)
+void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload)
 {
     if (!pPayload)
@@ -100 +100 @@
  * @param   uID                 Event ID to use.
  */
-int SharedClipboardEventCreate(PSHAREDCLIPBOARDEVENT pEvent, VBOXCLIPBOARDEVENTID uID)
+int SharedClipboardEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
@@ -121 +121 @@
  * @param   pEvent              Event to destroy.
  */
-void SharedClipboardEventDestroy(PSHAREDCLIPBOARDEVENT pEvent)
+void SharedClipboardEventDestroy(PSHCLEVENT pEvent)
 {
     if (!pEvent)
@@ -146 +146 @@
  * @param   uID                 ID to use for event source.
  */
-int SharedClipboardEventSourceCreate(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTSOURCEID uID)
+int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -169 +169 @@
  * @param   pSource             Event source to destroy.
  */
-void SharedClipboardEventSourceDestroy(PSHAREDCLIPBOARDEVENTSOURCE pSource)
+void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource)
 {
     if (!pSource)
@@ -176 +176 @@
     LogFlowFunc(("ID=%RU16\n", pSource->uID));
 
-    PSHAREDCLIPBOARDEVENT pEvIt;
-    PSHAREDCLIPBOARDEVENT pEvItNext;
-    RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHAREDCLIPBOARDEVENT, Node)
+    PSHCLEVENT pEvIt;
+    PSHCLEVENT pEvItNext;
+    RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHCLEVENT, Node)
     {
         SharedClipboardEventDestroy(pEvIt);
@@ -194 +194 @@
  * @param   pSource             Event source to generate event for.
  */
-VBOXCLIPBOARDEVENTID SharedClipboardEventIDGenerate(PSHAREDCLIPBOARDEVENTSOURCE pSource)
+SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource)
 {
     AssertPtrReturn(pSource, 0);
@@ -209 +209 @@
  * @param   uID                 Event ID to get.
  */
-inline PSHAREDCLIPBOARDEVENT sharedClipboardEventGet(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID)
-{
-    PSHAREDCLIPBOARDEVENT pEvIt;
-    RTListForEach(&pSource->lstEvents, pEvIt, SHAREDCLIPBOARDEVENT, Node)
+inline PSHCLEVENT sharedClipboardEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
+{
+    PSHCLEVENT pEvIt;
+    RTListForEach(&pSource->lstEvents, pEvIt, SHCLEVENT, Node)
     {
         if (pEvIt->uID == uID)
@@ -227 +227 @@
  * @param   pSource             Event source to get last registered event from.
  */
-VBOXCLIPBOARDEVENTID SharedClipboardEventGetLast(PSHAREDCLIPBOARDEVENTSOURCE pSource)
+SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource)
 {
     AssertPtrReturn(pSource, 0);
-    PSHAREDCLIPBOARDEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHAREDCLIPBOARDEVENT, Node);
+    PSHCLEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHCLEVENT, Node);
     if (pEvent)
         return pEvent->uID;
@@ -244 +244 @@
  * @param   uID                 Event ID to register.
  */
-int SharedClipboardEventRegister(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID)
+int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -254 +254 @@
     if (sharedClipboardEventGet(pSource, uID) == NULL)
     {
-        PSHAREDCLIPBOARDEVENT pEvent
-            = (PSHAREDCLIPBOARDEVENT)RTMemAllocZ(sizeof(SHAREDCLIPBOARDEVENT));
+        PSHCLEVENT pEvent
+            = (PSHCLEVENT)RTMemAllocZ(sizeof(SHCLEVENT));
         if (pEvent)
         {
@@ -287 +287 @@
  * @param   uID                 Event ID to unregister.
  */
-int SharedClipboardEventUnregister(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID)
+int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -295 +295 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     if (pEvent)
     {
@@ -326 +326 @@
  *                              SharedClipboardPayloadFree().
  */
-int SharedClipboardEventWait(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID, RTMSINTERVAL uTimeoutMs,
-                             PSHAREDCLIPBOARDEVENTPAYLOAD* ppPayload)
+int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
+                             PSHCLEVENTPAYLOAD* ppPayload)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -335 +335 @@
     int rc;
 
-    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     if (pEvent)
     {
@@ -361 +361 @@
  * @param   pPayload            Event payload to associate. Takes ownership. Optional.
  */
-int SharedClipboardEventSignal(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID,
-                               PSHAREDCLIPBOARDEVENTPAYLOAD pPayload)
+int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID,
+                               PSHCLEVENTPAYLOAD pPayload)
 {
     AssertPtrReturn(pSource, VERR_INVALID_POINTER);
@@ -370 +370 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     if (pEvent)
     {
@@ -393 +393 @@
  * @param   uID                 Event ID to detach payload for.
  */
-void SharedClipboardEventPayloadDetach(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID)
+void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
 {
     AssertPtrReturnVoid(pSource);
@@ -399 +399 @@
     LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
 
-    PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID);
+    PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     if (pEvent)
     {
@@ -751 +751 @@
 }
 
-void VBoxClipboardDbgDumpData(const void *pv, size_t cb, VBOXCLIPBOARDFORMAT u32Format)
+void VBoxClipboardDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
 {
     if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)

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

@@ -30 +30 @@
 
 
-static int sharedClipboardURITransferThreadCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
-static int sharedClipboardURITransferThreadDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs);
-static PSHAREDCLIPBOARDURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx);
+static int sharedClipboardURITransferThreadCreate(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
+static int sharedClipboardURITransferThreadDestroy(PSHCLURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs);
+static PSHCLURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHCLURICTX pURI, uint32_t uIdx);
 static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode,
-                                                 SHAREDCLIPBOARDOBJHANDLE handleInitial, uint64_t *pfOpen);
+                                                 SHCLOBJHANDLE handleInitial, uint64_t *pfOpen);
 
 /** @todo Split this file up in different modules. */
@@ -43 +43 @@
  * @returns Allocated URI root list on success, or NULL on failure.
  */
-PVBOXCLIPBOARDROOTLIST SharedClipboardURIRootListAlloc(void)
-{
-    PVBOXCLIPBOARDROOTLIST pRootList = (PVBOXCLIPBOARDROOTLIST)RTMemAllocZ(sizeof(VBOXCLIPBOARDROOTLIST));
+PSHCLROOTLIST SharedClipboardURIRootListAlloc(void)
+{
+    PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST));
 
     return pRootList;
@@ -56 +56 @@
  *                              invalid after returning from this function.
  */
-void SharedClipboardURIRootListFree(PVBOXCLIPBOARDROOTLIST pRootList)
+void SharedClipboardURIRootListFree(PSHCLROOTLIST pRootList)
 {
     if (!pRootList)
@@ -74 +74 @@
  * @param   pRootLstHdr         Root list header to initialize.
  */
-int SharedClipboardURIRootListHdrInit(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
+int SharedClipboardURIRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER);
 
-    RT_BZERO(pRootLstHdr, sizeof(VBOXCLIPBOARDROOTLISTHDR));
+    RT_BZERO(pRootLstHdr, sizeof(SHCLROOTLISTHDR));
 
     return VINF_SUCCESS;
@@ -88 +88 @@
  * @param   pRootLstHdr         Root list header to destroy.
  */
-void SharedClipboardURIRootListHdrDestroy(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
+void SharedClipboardURIRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
 {
     if (!pRootLstHdr)
@@ -103 +103 @@
  * @param   pRootLstHdr         Root list header to duplicate.
  */
-PVBOXCLIPBOARDROOTLISTHDR SharedClipboardURIRootListHdrDup(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
+PSHCLROOTLISTHDR SharedClipboardURIRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, NULL);
@@ -109 +109 @@
     int rc = VINF_SUCCESS;
 
-    PVBOXCLIPBOARDROOTLISTHDR pRootsDup = (PVBOXCLIPBOARDROOTLISTHDR)RTMemAllocZ(sizeof(VBOXCLIPBOARDROOTLISTHDR));
+    PSHCLROOTLISTHDR pRootsDup = (PSHCLROOTLISTHDR)RTMemAllocZ(sizeof(SHCLROOTLISTHDR));
     if (pRootsDup)
     {
@@ -132 +132 @@
  * @param   pListEntry          Clipboard root list entry to copy.
  */
-int SharedClipboardURIRootListEntryCopy(PVBOXCLIPBOARDROOTLISTENTRY pDst, PVBOXCLIPBOARDROOTLISTENTRY pSrc)
+int SharedClipboardURIRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
 {
     return SharedClipboardURIListEntryCopy(pDst, pSrc);
@@ -143 +143 @@
  * @param   pListEntry          Clipboard root list entry to duplicate.
  */
-PVBOXCLIPBOARDROOTLISTENTRY SharedClipboardURIRootListEntryDup(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry)
+PSHCLROOTLISTENTRY SharedClipboardURIRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
 {
     return SharedClipboardURIListEntryDup(pRootListEntry);
@@ -153 +153 @@
  * @param   pListEntry          Clipboard root list entry structure to destroy.
  */
-void SharedClipboardURIRootListEntryDestroy(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry)
+void SharedClipboardURIRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
 {
     return SharedClipboardURIListEntryDestroy(pRootListEntry);
@@ -163 +163 @@
  * @param   pInfo               List handle info structure to destroy.
  */
-void SharedClipboardURIListHandleInfoDestroy(PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo)
+void SharedClipboardURIListHandleInfoDestroy(PSHCLURILISTHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -181 +181 @@
  * @param   ppListHdr           Where to store the allocated URI list header structure on success.
  */
-int SharedClipboardURIListHdrAlloc(PVBOXCLIPBOARDLISTHDR *ppListHdr)
+int SharedClipboardURIListHdrAlloc(PSHCLLISTHDR *ppListHdr)
 {
     int rc;
 
-    PVBOXCLIPBOARDLISTHDR pListHdr = (PVBOXCLIPBOARDLISTHDR)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTHDR));
+    PSHCLLISTHDR pListHdr = (PSHCLLISTHDR)RTMemAllocZ(sizeof(SHCLLISTHDR));
     if (pListHdr)
     {
@@ -203 +203 @@
  * @param   pListEntry          URI list header structure to free.
  */
-void SharedClipboardURIListHdrFree(PVBOXCLIPBOARDLISTHDR pListHdr)
+void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -222 +222 @@
  * @param   pListHdr            URI list header to duplicate.
  */
-PVBOXCLIPBOARDLISTHDR SharedClipboardURIListHdrDup(PVBOXCLIPBOARDLISTHDR pListHdr)
+PSHCLLISTHDR SharedClipboardURIListHdrDup(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturn(pListHdr, NULL);
 
-    PVBOXCLIPBOARDLISTHDR pListHdrDup = (PVBOXCLIPBOARDLISTHDR)RTMemAlloc(sizeof(VBOXCLIPBOARDLISTHDR));
+    PSHCLLISTHDR pListHdrDup = (PSHCLLISTHDR)RTMemAlloc(sizeof(SHCLLISTHDR));
     if (pListHdrDup)
     {
@@ -241 +241 @@
  * @param   pListHdr            Data header struct to initialize.
  */
-int SharedClipboardURIListHdrInit(PVBOXCLIPBOARDLISTHDR pListHdr)
+int SharedClipboardURIListHdrInit(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
@@ -257 +257 @@
  * @param   pListHdr            Data header struct to destroy.
  */
-void SharedClipboardURIListHdrDestroy(PVBOXCLIPBOARDLISTHDR pListHdr)
+void SharedClipboardURIListHdrDestroy(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -266 +266 @@
 
 /**
- * Resets a VBOXCLIPBOARDListHdr structture.
- *
- * @returns VBox status code.
- * @param   pListHdr            VBOXCLIPBOARDListHdr structture to reset.
- */
-void SharedClipboardURIListHdrReset(PVBOXCLIPBOARDLISTHDR pListHdr)
+ * Resets a SHCLListHdr structture.
+ *
+ * @returns VBox status code.
+ * @param   pListHdr            SHCLListHdr structture to reset.
+ */
+void SharedClipboardURIListHdrReset(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturnVoid(pListHdr);
@@ -277 +277 @@
     LogFlowFuncEnter();
 
-    RT_BZERO(pListHdr, sizeof(VBOXCLIPBOARDLISTHDR));
+    RT_BZERO(pListHdr, sizeof(SHCLLISTHDR));
 }
 
@@ -286 +286 @@
  * @param   pListHdr            Clipboard data header to validate.
  */
-bool SharedClipboardURIListHdrIsValid(PVBOXCLIPBOARDLISTHDR pListHdr)
+bool SharedClipboardURIListHdrIsValid(PSHCLLISTHDR pListHdr)
 {
     RT_NOREF(pListHdr);
@@ -292 +292 @@
 }
 
-int SharedClipboardURIListOpenParmsCopy(PVBOXCLIPBOARDLISTOPENPARMS pDst, PVBOXCLIPBOARDLISTOPENPARMS pSrc)
+int SharedClipboardURIListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -330 +330 @@
  * @param   pParms              URI list open parameters structure to duplicate.
  */
-PVBOXCLIPBOARDLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PVBOXCLIPBOARDLISTOPENPARMS pParms)
+PSHCLLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, NULL);
 
-    PVBOXCLIPBOARDLISTOPENPARMS pParmsDup = (PVBOXCLIPBOARDLISTOPENPARMS)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTOPENPARMS));
+    PSHCLLISTOPENPARMS pParmsDup = (PSHCLLISTOPENPARMS)RTMemAllocZ(sizeof(SHCLLISTOPENPARMS));
     if (!pParmsDup)
         return NULL;
@@ -356 +356 @@
  * @param   pParms              URI list open parameters structure to initialize.
  */
-int SharedClipboardURIListOpenParmsInit(PVBOXCLIPBOARDLISTOPENPARMS pParms)
+int SharedClipboardURIListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
 
-    RT_BZERO(pParms, sizeof(VBOXCLIPBOARDLISTOPENPARMS));
+    RT_BZERO(pParms, sizeof(SHCLLISTOPENPARMS));
 
     pParms->cbFilter  = 64; /** @todo Make this dynamic. */
@@ -377 +377 @@
  * @param   pParms              URI list open parameters structure to destroy.
  */
-void SharedClipboardURIListOpenParmsDestroy(PVBOXCLIPBOARDLISTOPENPARMS pParms)
+void SharedClipboardURIListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
 {
     if (!pParms)
@@ -400 +400 @@
  * @param   ppDirData           Where to return the created clipboard list entry structure on success.
  */
-int SharedClipboardURIListEntryAlloc(PVBOXCLIPBOARDLISTENTRY *ppListEntry)
-{
-    PVBOXCLIPBOARDLISTENTRY pListEntry = (PVBOXCLIPBOARDLISTENTRY)RTMemAlloc(sizeof(VBOXCLIPBOARDLISTENTRY));
+int SharedClipboardURIListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
+{
+    PSHCLLISTENTRY pListEntry = (PSHCLLISTENTRY)RTMemAlloc(sizeof(SHCLLISTENTRY));
     if (!pListEntry)
         return VERR_NO_MEMORY;
@@ -418 +418 @@
  * @param   pListEntry         Clipboard list entry structure to free.
  */
-void SharedClipboardURIListEntryFree(PVBOXCLIPBOARDLISTENTRY pListEntry)
+void SharedClipboardURIListEntryFree(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
@@ -433 +433 @@
  * @param   pListEntry          Clipboard list entry to copy.
  */
-int SharedClipboardURIListEntryCopy(PVBOXCLIPBOARDLISTENTRY pDst, PVBOXCLIPBOARDLISTENTRY pSrc)
+int SharedClipboardURIListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -480 +480 @@
  * @param   pListEntry          Clipboard list entry to duplicate.
  */
-PVBOXCLIPBOARDLISTENTRY SharedClipboardURIListEntryDup(PVBOXCLIPBOARDLISTENTRY pListEntry)
+PSHCLLISTENTRY SharedClipboardURIListEntryDup(PSHCLLISTENTRY pListEntry)
 {
     AssertPtrReturn(pListEntry, NULL);
@@ -486 +486 @@
     int rc = VINF_SUCCESS;
 
-    PVBOXCLIPBOARDLISTENTRY pListEntryDup = (PVBOXCLIPBOARDLISTENTRY)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTENTRY));
+    PSHCLLISTENTRY pListEntryDup = (PSHCLLISTENTRY)RTMemAllocZ(sizeof(SHCLLISTENTRY));
     if (pListEntryDup)
         rc = SharedClipboardURIListEntryCopy(pListEntryDup, pListEntry);
@@ -507 +507 @@
  * @param   pListEntry          Clipboard list entry structure to initialize.
  */
-int SharedClipboardURIListEntryInit(PVBOXCLIPBOARDLISTENTRY pListEntry)
-{
-    RT_BZERO(pListEntry, sizeof(VBOXCLIPBOARDLISTENTRY));
-
-    pListEntry->pszName = RTStrAlloc(VBOXCLIPBOARDLISTENTRY_MAX_NAME);
+int SharedClipboardURIListEntryInit(PSHCLLISTENTRY pListEntry)
+{
+    RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY));
+
+    pListEntry->pszName = RTStrAlloc(SHCLLISTENTRY_MAX_NAME);
     if (!pListEntry->pszName)
         return VERR_NO_MEMORY;
 
-    pListEntry->cbName = VBOXCLIPBOARDLISTENTRY_MAX_NAME;
+    pListEntry->cbName = SHCLLISTENTRY_MAX_NAME;
     pListEntry->pvInfo = NULL;
     pListEntry->cbInfo = 0;
@@ -528 +528 @@
  * @param   pListEntry          Clipboard list entry structure to destroy.
  */
-void SharedClipboardURIListEntryDestroy(PVBOXCLIPBOARDLISTENTRY pListEntry)
+void SharedClipboardURIListEntryDestroy(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
@@ -555 +555 @@
  * @param   pListEntry          Clipboard data chunk to validate.
  */
-bool SharedClipboardURIListEntryIsValid(PVBOXCLIPBOARDLISTENTRY pListEntry)
+bool SharedClipboardURIListEntryIsValid(PSHCLLISTENTRY pListEntry)
 {
     RT_NOREF(pListEntry);
@@ -570 +570 @@
  * @param   pObjCtx             URI object context to initialize.
  */
-int SharedClipboardURIObjCtxInit(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx)
+int SharedClipboardURIObjCtxInit(PSHCLCLIENTURIOBJCTX pObjCtx)
 {
     AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
@@ -576 +576 @@
     LogFlowFuncEnter();
 
-    pObjCtx->uHandle  = SHAREDCLIPBOARDOBJHANDLE_INVALID;
+    pObjCtx->uHandle  = SHCLOBJHANDLE_INVALID;
 
     return VINF_SUCCESS;
@@ -586 +586 @@
  * @param   pObjCtx             URI object context to destroy.
  */
-void SharedClipboardURIObjCtxDestroy(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx)
+void SharedClipboardURIObjCtxDestroy(PSHCLCLIENTURIOBJCTX pObjCtx)
 {
     AssertPtrReturnVoid(pObjCtx);
@@ -599 +599 @@
  * @param   pObjCtx             URI object context to check.
  */
-bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx)
+bool SharedClipboardURIObjCtxIsValid(PSHCLCLIENTURIOBJCTX pObjCtx)
 {
     return (   pObjCtx
-            && pObjCtx->uHandle != SHAREDCLIPBOARDOBJHANDLE_INVALID);
+            && pObjCtx->uHandle != SHCLOBJHANDLE_INVALID);
 }
 
@@ -610 +610 @@
  * @param   pInfo               Object handle info structure to destroy.
  */
-void SharedClipboardURIObjectHandleInfoDestroy(PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo)
+void SharedClipboardURIObjectHandleInfoDestroy(PSHCLURIOBJHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -628 +628 @@
  * @param   pParms              URI object open parameters structure to initialize.
  */
-int SharedClipboardURIObjectOpenParmsInit(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms)
+int SharedClipboardURIObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -634 +634 @@
     int rc;
 
-    RT_BZERO(pParms, sizeof(VBOXCLIPBOARDOBJOPENCREATEPARMS));
+    RT_BZERO(pParms, sizeof(SHCLOBJOPENCREATEPARMS));
 
     pParms->cbPath    = RTPATH_MAX; /** @todo Make this dynamic. */
@@ -656 +656 @@
  * @param   pParmsSrc           Which source URI object open parameters to copy.
  */
-int SharedClipboardURIObjectOpenParmsCopy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsDst, PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsSrc)
+int SharedClipboardURIObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
 {
     int rc;
@@ -685 +685 @@
  * @param   pParms              URI object open parameters structure to destroy.
  */
-void SharedClipboardURIObjectOpenParmsDestroy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms)
+void SharedClipboardURIObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
 {
     if (!pParms)
@@ -704 +704 @@
  * @param   hObj                Object handle of the object to get handle info for.
  */
-inline PSHAREDCLIPBOARDURIOBJHANDLEINFO sharedClipboardURIObjectGet(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                                                    SHAREDCLIPBOARDOBJHANDLE hObj)
-{
-    PSHAREDCLIPBOARDURIOBJHANDLEINFO pIt;
-    RTListForEach(&pTransfer->lstObj, pIt, SHAREDCLIPBOARDURIOBJHANDLEINFO, Node)
+inline PSHCLURIOBJHANDLEINFO sharedClipboardURIObjectGet(PSHCLURITRANSFER pTransfer,
+                                                                    SHCLOBJHANDLE hObj)
+{
+    PSHCLURIOBJHANDLEINFO pIt;
+    RTListForEach(&pTransfer->lstObj, pIt, SHCLURIOBJHANDLEINFO, Node)
     {
         if (pIt->hObj == hObj)
@@ -725 +725 @@
  * @param   phObj               Where to store the handle of URI object opened on success.
  */
-int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms,
-                                 PSHAREDCLIPBOARDOBJHANDLE phObj)
+int SharedClipboardURIObjectOpen(PSHCLURITRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
+                                 PSHCLOBJHANDLE phObj)
 {
     AssertPtrReturn(pTransfer,        VERR_INVALID_POINTER);
@@ -736 +736 @@
     LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pOpenCreateParms->pszPath, pOpenCreateParms->fCreate));
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo
-            = (PSHAREDCLIPBOARDURIOBJHANDLEINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDURIOBJHANDLEINFO));
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURIOBJHANDLEINFO pInfo
+            = (PSHCLURIOBJHANDLEINFO)RTMemAlloc(sizeof(SHCLURIOBJHANDLEINFO));
         if (pInfo)
         {
@@ -747 +747 @@
             rc = sharedClipboardConvertFileCreateFlags(fWritable,
                                                        pOpenCreateParms->fCreate, pOpenCreateParms->ObjInfo.Attr.fMode,
-                                                       SHAREDCLIPBOARDOBJHANDLE_INVALID, &fOpen);
+                                                       SHCLOBJHANDLE_INVALID, &fOpen);
             if (RT_SUCCESS(rc))
             {
@@ -765 +765 @@
             {
                 pInfo->hObj    = pTransfer->uObjHandleNext++;
-                pInfo->enmType = SHAREDCLIPBOARDURIOBJTYPE_FILE;
+                pInfo->enmType = SHCLURIOBJTYPE_FILE;
 
                 RTListAppend(&pTransfer->lstObj, &pInfo->Node);
@@ -778 +778 @@
             rc = VERR_NO_MEMORY;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnObjOpen)
@@ -799 +799 @@
  * @param   hObj                Handle of URI object to close.
  */
-int SharedClipboardURIObjectClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj)
+int SharedClipboardURIObjectClose(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -805 +805 @@
     int rc = VINF_SUCCESS;
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                case SHCLURIOBJTYPE_DIRECTORY:
                 {
                     rc = RTDirClose(pInfo->u.Local.hDir);
@@ -820 +820 @@
                 }
 
-                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                case SHCLURIOBJTYPE_FILE:
                 {
                     rc = RTFileClose(pInfo->u.Local.hFile);
@@ -840 +840 @@
             rc = VERR_NOT_FOUND;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnObjClose)
@@ -864 +864 @@
  * @param   pcbRead             How much bytes were read on success. Optional.
  */
-int SharedClipboardURIObjectRead(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                 SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
+int SharedClipboardURIObjectRead(PSHCLURITRANSFER pTransfer,
+                                 SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -875 +875 @@
     int rc = VINF_SUCCESS;
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                case SHCLURIOBJTYPE_FILE:
                 {
                     size_t cbRead;
@@ -902 +902 @@
             rc = VERR_NOT_FOUND;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnObjRead)
@@ -926 +926 @@
  * @param   pcbWritten          How much bytes were writtenon success. Optional.
  */
-int SharedClipboardURIObjectWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                  SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
+int SharedClipboardURIObjectWrite(PSHCLURITRANSFER pTransfer,
+                                  SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
                                   uint32_t fFlags)
 {
@@ -937 +937 @@
     int rc = VINF_SUCCESS;
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                case SHCLURIOBJTYPE_FILE:
                 {
                     rc = RTFileWrite(pInfo->u.Local.hFile, pvBuf, cbBuf, (size_t *)pcbWritten);
@@ -958 +958 @@
             rc = VERR_NOT_FOUND;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnObjWrite)
@@ -978 +978 @@
  * @param   pDataChunk          URI object data chunk to duplicate.
  */
-PVBOXCLIPBOARDOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+PSHCLOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
         return NULL;
 
-    PVBOXCLIPBOARDOBJDATACHUNK pDataChunkDup = (PVBOXCLIPBOARDOBJDATACHUNK)RTMemAllocZ(sizeof(VBOXCLIPBOARDOBJDATACHUNK));
+    PSHCLOBJDATACHUNK pDataChunkDup = (PSHCLOBJDATACHUNK)RTMemAllocZ(sizeof(SHCLOBJDATACHUNK));
     if (!pDataChunkDup)
         return NULL;
@@ -1004 +1004 @@
  * @param   pDataChunk          URI object data chunk to destroy.
  */
-void SharedClipboardURIObjectDataChunkDestroy(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+void SharedClipboardURIObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1028 +1028 @@
  *                              be invalid after calling this function.
  */
-void SharedClipboardURIObjectDataChunkFree(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+void SharedClipboardURIObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1048 +1048 @@
  *                              Must be destroyed by SharedClipboardURITransferDestroy().
  */
-int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
-                                     PSHAREDCLIPBOARDURITRANSFER *ppTransfer)
+int SharedClipboardURITransferCreate(SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
+                                     PSHCLURITRANSFER *ppTransfer)
 {
     AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER);
@@ -1055 +1055 @@
     LogFlowFuncEnter();
 
-    PSHAREDCLIPBOARDURITRANSFER pTransfer = (PSHAREDCLIPBOARDURITRANSFER)RTMemAlloc(sizeof(SHAREDCLIPBOARDURITRANSFER));
+    PSHCLURITRANSFER pTransfer = (PSHCLURITRANSFER)RTMemAlloc(sizeof(SHCLURITRANSFER));
     if (!pTransfer)
         return VERR_NO_MEMORY;
@@ -1062 +1062 @@
 
     pTransfer->State.uID       = 0;
-    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
+    pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_NONE;
     pTransfer->State.enmDir    = enmDir;
     pTransfer->State.enmSource = enmSource;
@@ -1115 +1115 @@
  * @param   pURI                URI clipboard transfer to destroy.
  */
-int SharedClipboardURITransferDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int SharedClipboardURITransferDestroy(PSHCLURITRANSFER pTransfer)
 {
     if (!pTransfer)
@@ -1130 +1130 @@
     SharedClipboardEventSourceDestroy(&pTransfer->Events);
 
-    PSHAREDCLIPBOARDURILISTHANDLEINFO pItList, pItListNext;
-    RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHAREDCLIPBOARDURILISTHANDLEINFO, Node)
+    PSHCLURILISTHANDLEINFO pItList, pItListNext;
+    RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLURILISTHANDLEINFO, Node)
     {
         SharedClipboardURIListHandleInfoDestroy(pItList);
@@ -1140 +1140 @@
     }
 
-    PSHAREDCLIPBOARDURIOBJHANDLEINFO pItObj, pItObjNext;
-    RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHAREDCLIPBOARDURIOBJHANDLEINFO, Node)
+    PSHCLURIOBJHANDLEINFO pItObj, pItObjNext;
+    RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLURIOBJHANDLEINFO, Node)
     {
         SharedClipboardURIObjectHandleInfoDestroy(pItObj);
@@ -1154 +1154 @@
 }
 
-int SharedClipboardURITransferOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int SharedClipboardURITransferOpen(PSHCLURITRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1165 +1165 @@
 }
 
-int SharedClipboardURITransferClose(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int SharedClipboardURITransferClose(PSHCLURITRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1183 +1183 @@
  * @param   hList               List handle of the list to get handle info for.
  */
-inline PSHAREDCLIPBOARDURILISTHANDLEINFO sharedClipboardURITransferListGet(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                                                           SHAREDCLIPBOARDLISTHANDLE hList)
-{
-    PSHAREDCLIPBOARDURILISTHANDLEINFO pIt;
-    RTListForEach(&pTransfer->lstList, pIt, SHAREDCLIPBOARDURILISTHANDLEINFO, Node)
+inline PSHCLURILISTHANDLEINFO sharedClipboardURITransferListGet(PSHCLURITRANSFER pTransfer,
+                                                                           SHCLLISTHANDLE hList)
+{
+    PSHCLURILISTHANDLEINFO pIt;
+    RTListForEach(&pTransfer->lstList, pIt, SHCLURILISTHANDLEINFO, Node)
     {
         if (pIt->hList == hList)
@@ -1199 +1199 @@
  * Creates a new list handle (local only).
  *
- * @returns New List handle on success, or SHAREDCLIPBOARDLISTHANDLE_INVALID on error.
+ * @returns New List handle on success, or SHCLLISTHANDLE_INVALID on error.
  * @param   pTransfer           URI clipboard transfer to create new list handle for.
  */
-inline SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+inline SHCLLISTHANDLE sharedClipboardURITransferListHandleNew(PSHCLURITRANSFER pTransfer)
 {
     return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */
@@ -1215 +1215 @@
  * @param   phList              Where to store the List handle of opened list on success.
  */
-int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
-                                       PSHAREDCLIPBOARDLISTHANDLE phList)
+int SharedClipboardURITransferListOpen(PSHCLURITRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
+                                       PSHCLLISTHANDLE phList)
 {
     AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
@@ -1224 +1224 @@
     int rc;
 
-    SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID;
-
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo
-            = (PSHAREDCLIPBOARDURILISTHANDLEINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDURILISTHANDLEINFO));
+    SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID;
+
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURILISTHANDLEINFO pInfo
+            = (PSHCLURILISTHANDLEINFO)RTMemAlloc(sizeof(SHCLURILISTHANDLEINFO));
         if (pInfo)
         {
@@ -1240 +1240 @@
                 switch (pInfo->enmType)
                 {
-                    case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                    case SHCLURIOBJTYPE_DIRECTORY:
                     {
                         rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath);
@@ -1246 +1246 @@
                     }
 
-                    case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                    case SHCLURIOBJTYPE_FILE:
                     {
                         rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
@@ -1285 +1285 @@
             rc = VERR_NO_MEMORY;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnListOpen)
@@ -1311 +1311 @@
  * @param   hList               Handle of list to close.
  */
-int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList)
+int SharedClipboardURITransferListClose(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
 
-    if (hList == SHAREDCLIPBOARDLISTHANDLE_INVALID)
+    if (hList == SHCLLISTHANDLE_INVALID)
         return VINF_SUCCESS;
 
     int rc = VINF_SUCCESS;
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                case SHCLURIOBJTYPE_DIRECTORY:
                 {
                     if (RTDirIsValid(pInfo->u.Local.hDir))
@@ -1346 +1346 @@
             rc = VERR_NOT_FOUND;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnListClose)
@@ -1367 +1367 @@
  * @param   pszPath             Path of file to add.
  */
-static int sharedClipboardURITransferListHdrAddFile(PVBOXCLIPBOARDLISTHDR pHdr, const char *pszPath)
+static int sharedClipboardURITransferListHdrAddFile(PSHCLLISTHDR pHdr, const char *pszPath)
 {
     uint64_t cbSize = 0;
@@ -1391 +1391 @@
  * @param   cchDstBase          Number of charaters of destination base path.
  */
-static int sharedClipboardURITransferListHdrFromDir(PVBOXCLIPBOARDLISTHDR pHdr,
+static int sharedClipboardURITransferListHdrFromDir(PSHCLLISTHDR pHdr,
                                                     const char *pcszSrcPath, const char *pcszDstPath,
                                                     const char *pcszDstBase)
@@ -1543 +1543 @@
  * @param   pHdr                Where to store the returned list header information.
  */
-int SharedClipboardURITransferListGetHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
-                                            PVBOXCLIPBOARDLISTHDR pHdr)
+int SharedClipboardURITransferListGetHeader(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
+                                            PSHCLLISTHDR pHdr)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1553 +1553 @@
     LogFlowFunc(("hList=%RU64\n", hList));
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
         if (pInfo)
         {
@@ -1563 +1563 @@
                 switch (pInfo->enmType)
                 {
-                    case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                    case SHCLURIOBJTYPE_DIRECTORY:
                     {
                         char *pszPathRel = sharedClipboardPathTranslate(pInfo->pszPathLocalAbs);
@@ -1577 +1577 @@
                     }
 
-                    case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                    case SHCLURIOBJTYPE_FILE:
                     {
                         pHdr->cTotalObjects = 1;
@@ -1601 +1601 @@
             rc = VERR_NOT_FOUND;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnListHdrRead)
@@ -1627 +1627 @@
  * @param   uIdx                Index of object to get.
  */
-PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                                                    SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx)
+PSHCLURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHCLURITRANSFER pTransfer,
+                                                                    SHCLLISTHANDLE hList, uint64_t uIdx)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -1647 +1647 @@
  * @param   pEntry              Where to store the read information.
  */
-int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
-                                       PVBOXCLIPBOARDLISTENTRY pEntry)
+int SharedClipboardURITransferListRead(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
+                                       PSHCLLISTENTRY pEntry)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1657 +1657 @@
     LogFlowFunc(("hList=%RU64\n", hList));
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                case SHCLURIOBJTYPE_DIRECTORY:
                 {
                     LogFlowFunc(("\tDirectory: %s\n", pInfo->pszPathLocalAbs));
@@ -1711 +1711 @@
                                 && !fSkipEntry)
                             {
-                                pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
+                                pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(sizeof(SHCLFSOBJINFO));
                                 if (pEntry->pvInfo)
                                 {
@@ -1717 +1717 @@
                                     if (RT_SUCCESS(rc))
                                     {
-                                        SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
-
-                                        pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
-                                        pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
+                                        SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
+
+                                        pEntry->cbInfo = sizeof(SHCLFSOBJINFO);
+                                        pEntry->fInfo  = VBOX_SHCL_INFO_FLAG_FSOBJINFO;
                                     }
                                 }
@@ -1740 +1740 @@
                 }
 
-                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                case SHCLURIOBJTYPE_FILE:
                 {
                     LogFlowFunc(("\tSingle file: %s\n", pInfo->pszPathLocalAbs));
@@ -1748 +1748 @@
                     if (RT_SUCCESS(rc))
                     {
-                        pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
+                        pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(sizeof(SHCLFSOBJINFO));
                         if (pEntry->pvInfo)
                         {
@@ -1754 +1754 @@
                             if (RT_SUCCESS(rc))
                             {
-                                SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo);
-
-                                pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
-                                pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
+                                SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
+
+                                pEntry->cbInfo = sizeof(SHCLFSOBJINFO);
+                                pEntry->fInfo  = VBOX_SHCL_INFO_FLAG_FSOBJINFO;
                             }
                         }
@@ -1775 +1775 @@
             rc = VERR_NOT_FOUND;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnListEntryRead)
@@ -1787 +1787 @@
 }
 
-int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
-                                        PVBOXCLIPBOARDLISTENTRY pEntry)
+int SharedClipboardURITransferListWrite(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
+                                        PSHCLLISTENTRY pEntry)
 {
     RT_NOREF(pTransfer, hList, pEntry);
@@ -1810 +1810 @@
  * @param   hList               List handle to check.
  */
-bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList)
+bool SharedClipboardURITransferListHandleIsValid(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     bool fIsValid = false;
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
         fIsValid = sharedClipboardURITransferListGet(pTransfer, hList) != NULL;
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         AssertFailed(); /** @todo Implement. */
@@ -1832 +1832 @@
  * @param   pTransfer           URI clipboard transfer to prepare.
  */
-int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int SharedClipboardURITransferPrepare(PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1840 +1840 @@
     int rc = VINF_SUCCESS;
 
-    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_NONE,
+    AssertMsgReturn(pTransfer->State.enmStatus == SHCLURITRANSFERSTATUS_NONE,
                     ("Transfer has wrong state (%RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
 
@@ -1847 +1847 @@
     if (pTransfer->Callbacks.pfnTransferPrepare)
     {
-        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+        SHCLURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
         pTransfer->Callbacks.pfnTransferPrepare(&callbackData);
     }
@@ -1853 +1853 @@
     if (RT_SUCCESS(rc))
     {
-        pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_READY;
+        pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_READY;
 
         /** @todo Add checksum support. */
@@ -1869 +1869 @@
  * @param   pCreationCtx        Provider creation context to use for provider creation.
  */
-int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                           PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx)
+int SharedClipboardURITransferSetInterface(PSHCLURITRANSFER pTransfer,
+                                           PSHCLPROVIDERCREATIONCTX pCreationCtx)
 {
     AssertPtrReturn(pTransfer,    VERR_INVALID_POINTER);
@@ -1906 +1906 @@
  * @param   pTransfer           Transfer to clear URI root list for.
  */
-static void sharedClipboardURIListTransferRootsClear(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+static void sharedClipboardURIListTransferRootsClear(PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -1916 +1916 @@
     }
 
-    PSHAREDCLIPBOARDURILISTROOT pListRoot, pListRootNext;
-    RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHAREDCLIPBOARDURILISTROOT, Node)
+    PSHCLURILISTROOT pListRoot, pListRootNext;
+    RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHCLURILISTROOT, Node)
     {
         RTStrFree(pListRoot->pszPathAbs);
@@ -1939 +1939 @@
  * @param   cbRoots             Size (in bytes) of string list.
  */
-int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
+int SharedClipboardURILTransferSetRoots(PSHCLURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
 {
     AssertPtrReturn(pTransfer,      VERR_INVALID_POINTER);
@@ -1957 +1957 @@
     for (size_t i = 0; i < lstRootEntries.size(); ++i)
     {
-        PSHAREDCLIPBOARDURILISTROOT pListRoot = (PSHAREDCLIPBOARDURILISTROOT)RTMemAlloc(sizeof(SHAREDCLIPBOARDURILISTROOT));
+        PSHCLURILISTROOT pListRoot = (PSHCLURILISTROOT)RTMemAlloc(sizeof(SHCLURILISTROOT));
         AssertPtrBreakStmt(pListRoot, rc = VERR_NO_MEMORY);
 
@@ -2007 +2007 @@
  * @param   pTransfer           URI clipboard transfer to reset.
  */
-void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+void SharedClipboardURITransferReset(PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2022 +2022 @@
  * @param   pTransfer           URI clipboard transfer to return clipboard area for.
  */
-SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+SharedClipboardArea *SharedClipboardURITransferGetArea(PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -2035 +2035 @@
  * @param   pTransfer           URI clipboard transfer to return root entry count for.
  */
-uint32_t SharedClipboardURILTransferRootsCount(PSHAREDCLIPBOARDURITRANSFER pTransfer)
+uint32_t SharedClipboardURILTransferRootsCount(PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2049 +2049 @@
  * @param   uIdx                Index of root list entry to return.
  */
-inline PSHAREDCLIPBOARDURILISTROOT sharedClipboardURILTransferRootsGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uIdx)
+inline PSHCLURILISTROOT sharedClipboardURILTransferRootsGet(PSHCLURITRANSFER pTransfer, uint32_t uIdx)
 {
     if (uIdx >= pTransfer->cRoots)
         return NULL;
 
-    PSHAREDCLIPBOARDURILISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHAREDCLIPBOARDURILISTROOT, Node);
+    PSHCLURILISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHCLURILISTROOT, Node);
     while (uIdx--)
-        pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHAREDCLIPBOARDURILISTROOT, Node);
+        pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHCLURILISTROOT, Node);
 
     return pIt;
@@ -2069 +2069 @@
  * @param   pEntry              Where to store the returned entry on success.
  */
-int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                          uint64_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry)
+int SharedClipboardURILTransferRootsEntry(PSHCLURITRANSFER pTransfer,
+                                          uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2080 +2080 @@
     int rc;
 
-    PSHAREDCLIPBOARDURILISTROOT pRoot = sharedClipboardURILTransferRootsGet(pTransfer, uIndex);
+    PSHCLURILISTROOT pRoot = sharedClipboardURILTransferRootsGet(pTransfer, uIndex);
     AssertPtrReturn(pRoot, VERR_INVALID_PARAMETER);
 
@@ -2101 +2101 @@
             if (RT_SUCCESS(rc))
             {
-                pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
-                pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(pEntry->cbInfo);
+                pEntry->cbInfo = sizeof(SHCLFSOBJINFO);
+                pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(pEntry->cbInfo);
                 if (pEntry->pvInfo)
                 {
@@ -2109 +2109 @@
                     if (RT_SUCCESS(rc))
                     {
-                        SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
-
-                        pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
+                        SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
+
+                        pEntry->fInfo  = VBOX_SHCL_INFO_FLAG_FSOBJINFO;
                     }
                 }
@@ -2133 +2133 @@
  * @param   ppRootList          Where to store the root list on success.
  */
-int SharedClipboardURILTransferRootsAsList(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDROOTLIST *ppRootList)
+int SharedClipboardURILTransferRootsAsList(PSHCLURITRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
 {
     AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
@@ -2142 +2142 @@
     int rc = VINF_SUCCESS;
 
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc();
+    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
+    {
+        PSHCLROOTLIST pRootList = SharedClipboardURIRootListAlloc();
         if (!pRootList)
             return VERR_NO_MEMORY;
@@ -2154 +2154 @@
         if (cRoots)
         {
-            PVBOXCLIPBOARDROOTLISTENTRY paRootListEntries
-                = (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY));
+            PSHCLROOTLISTENTRY paRootListEntries
+                = (PSHCLROOTLISTENTRY)RTMemAllocZ(cRoots * sizeof(SHCLROOTLISTENTRY));
             if (paRootListEntries)
             {
@@ -2182 +2182 @@
         }
     }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
     {
         if (pTransfer->ProviderIface.pfnGetRoots)
@@ -2200 +2200 @@
  * @param   pTransfer           URI clipboard transfer to return source for.
  */
-SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer)
-{
-    AssertPtrReturn(pTransfer, SHAREDCLIPBOARDSOURCE_INVALID);
+SHCLSOURCE SharedClipboardURITransferGetSource(PSHCLURITRANSFER pTransfer)
+{
+    AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
 
     return pTransfer->State.enmSource;
@@ -2213 +2213 @@
  * @param   pTransfer           URI clipboard transfer to return status for.
  */
-SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer)
-{
-    AssertPtrReturn(pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS_NONE);
+SHCLURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHCLURITRANSFER pTransfer)
+{
+    AssertPtrReturn(pTransfer, SHCLURITRANSFERSTATUS_NONE);
 
     return pTransfer->State.enmStatus;
@@ -2228 +2228 @@
  * @param   pvUser              Pointer to user-provided data.
  */
-int SharedClipboardURITransferRun(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
+int SharedClipboardURITransferRun(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
 
-    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_READY,
+    AssertMsgReturn(pTransfer->State.enmStatus == SHCLURITRANSFERSTATUS_READY,
                     ("Wrong status (currently is %RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
 
@@ -2248 +2248 @@
  * @param   pCallbacks          Pointer to callback table to set.
  */
-void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                            PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks)
+void SharedClipboardURITransferSetCallbacks(PSHCLURITRANSFER pTransfer,
+                                            PSHCLURITRANSFERCALLBACKS pCallbacks)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2281 +2281 @@
  * @param   pvUser              Pointer to user-provided data.
  */
-static int sharedClipboardURITransferThreadCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
+static int sharedClipboardURITransferThreadCreate(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
 
 {
@@ -2297 +2297 @@
         if (pTransfer->Thread.fStarted) /* Did the thread indicate that it started correctly? */
         {
-            pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING;
+            pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_RUNNING;
         }
         else
@@ -2314 +2314 @@
  * @param   uTimeoutMs          Timeout (in ms) to wait for thread creation.
  */
-static int sharedClipboardURITransferThreadDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs)
+static int sharedClipboardURITransferThreadDestroy(PSHCLURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2340 +2340 @@
  * @param   pURI                URI clipboard context to initialize.
  */
-int SharedClipboardURICtxInit(PSHAREDCLIPBOARDURICTX pURI)
+int SharedClipboardURICtxInit(PSHCLURICTX pURI)
 {
     AssertPtrReturn(pURI, VERR_INVALID_POINTER);
@@ -2368 +2368 @@
  * @param   pURI                URI clipboard context to destroy.
  */
-void SharedClipboardURICtxDestroy(PSHAREDCLIPBOARDURICTX pURI)
+void SharedClipboardURICtxDestroy(PSHCLURICTX pURI)
 {
     AssertPtrReturnVoid(pURI);
@@ -2376 +2376 @@
     RTCritSectDelete(&pURI->CritSect);
 
-    PSHAREDCLIPBOARDURITRANSFER pTransfer, pTransferNext;
-    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHAREDCLIPBOARDURITRANSFER, Node)
+    PSHCLURITRANSFER pTransfer, pTransferNext;
+    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHCLURITRANSFER, Node)
     {
         SharedClipboardURITransferDestroy(pTransfer);
@@ -2396 +2396 @@
  * @param   pURI                URI clipboard context to reset.
  */
-void SharedClipboardURICtxReset(PSHAREDCLIPBOARDURICTX pURI)
+void SharedClipboardURICtxReset(PSHCLURICTX pURI)
 {
     AssertPtrReturnVoid(pURI);
@@ -2402 +2402 @@
     LogFlowFuncEnter();
 
-    PSHAREDCLIPBOARDURITRANSFER pTransfer;
-    RTListForEach(&pURI->List, pTransfer, SHAREDCLIPBOARDURITRANSFER, Node)
+    PSHCLURITRANSFER pTransfer;
+    RTListForEach(&pURI->List, pTransfer, SHCLURITRANSFER, Node)
         SharedClipboardURITransferReset(pTransfer);
 }
@@ -2414 +2414 @@
  * @param   pTransfer           Pointer to URI clipboard transfer to add.
  */
-int SharedClipboardURICtxTransferAdd(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int SharedClipboardURICtxTransferAdd(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturn(pURI,      VERR_INVALID_POINTER);
@@ -2439 +2439 @@
  * @param   pTransfer           Pointer to URI clipboard transfer to remove.
  */
-int SharedClipboardURICtxTransferRemove(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int SharedClipboardURICtxTransferRemove(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturn(pURI,      VERR_INVALID_POINTER);
@@ -2467 +2467 @@
  * @param   uIdx                Index of the transfer to return.
  */
-static PSHAREDCLIPBOARDURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx)
+static PSHCLURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHCLURICTX pURI, uint32_t uIdx)
 {
     AssertReturn(uIdx == 0, NULL); /* Only one transfer allowed at the moment. */
-    return RTListGetFirst(&pURI->List, SHAREDCLIPBOARDURITRANSFER, Node);
+    return RTListGetFirst(&pURI->List, SHCLURITRANSFER, Node);
 }
 
@@ -2480 +2480 @@
  * @param   uIdx                Index of the transfer to return.
  */
-PSHAREDCLIPBOARDURITRANSFER SharedClipboardURICtxGetTransfer(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx)
+PSHCLURITRANSFER SharedClipboardURICtxGetTransfer(PSHCLURICTX pURI, uint32_t uIdx)
 {
     return sharedClipboardURICtxGetTransferInternal(pURI, uIdx);
@@ -2491 +2491 @@
  * @param   pURI                URI clipboard context to return number for.
  */
-uint32_t SharedClipboardURICtxGetRunningTransfers(PSHAREDCLIPBOARDURICTX pURI)
+uint32_t SharedClipboardURICtxGetRunningTransfers(PSHCLURICTX pURI)
 {
     AssertPtrReturn(pURI, 0);
@@ -2503 +2503 @@
  * @param   pURI                URI clipboard context to return number for.
  */
-uint32_t SharedClipboardURICtxGetTotalTransfers(PSHAREDCLIPBOARDURICTX pURI)
+uint32_t SharedClipboardURICtxGetTotalTransfers(PSHCLURICTX pURI)
 {
     AssertPtrReturn(pURI, 0);
@@ -2515 +2515 @@
  * @param   pURI                URI clipboard context to cleanup transfers for.
  */
-void SharedClipboardURICtxTransfersCleanup(PSHAREDCLIPBOARDURICTX pURI)
+void SharedClipboardURICtxTransfersCleanup(PSHCLURICTX pURI)
 {
     AssertPtrReturnVoid(pURI);
@@ -2522 +2522 @@
 
     /* Remove all transfers which are not in a running state (e.g. only announced). */
-    PSHAREDCLIPBOARDURITRANSFER pTransfer, pTransferNext;
-    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHAREDCLIPBOARDURITRANSFER, Node)
-    {
-        if (SharedClipboardURITransferGetStatus(pTransfer) != SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING)
+    PSHCLURITRANSFER pTransfer, pTransferNext;
+    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHCLURITRANSFER, Node)
+    {
+        if (SharedClipboardURITransferGetStatus(pTransfer) != SHCLURITRANSFERSTATUS_RUNNING)
         {
             SharedClipboardURITransferDestroy(pTransfer);
@@ -2545 +2545 @@
  * @param   pURI                URI clipboard context to determine value for.
  */
-bool SharedClipboardURICtxTransfersMaximumReached(PSHAREDCLIPBOARDURICTX pURI)
+bool SharedClipboardURICtxTransfersMaximumReached(PSHCLURICTX pURI)
 {
     AssertPtrReturn(pURI, true);
@@ -2561 +2561 @@
  * @param   pSrc                The IPRT structure to convert data from.
  */
-void SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO pDst, PCRTFSOBJINFO pSrc)
+void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc)
 {
     pDst->cbObject          = pSrc->cbObject;
@@ -2577 +2577 @@
         default:
         case RTFSOBJATTRADD_NOTHING:
-            pDst->Attr.enmAdditional        = SHAREDCLIPBOARDFSOBJATTRADD_NOTHING;
+            pDst->Attr.enmAdditional        = SHCLFSOBJATTRADD_NOTHING;
             break;
 
         case RTFSOBJATTRADD_UNIX:
-            pDst->Attr.enmAdditional        = SHAREDCLIPBOARDFSOBJATTRADD_UNIX;
+            pDst->Attr.enmAdditional        = SHCLFSOBJATTRADD_UNIX;
             pDst->Attr.u.Unix.uid           = pSrc->Attr.u.Unix.uid;
             pDst->Attr.u.Unix.gid           = pSrc->Attr.u.Unix.gid;
@@ -2593 +2593 @@
 
         case RTFSOBJATTRADD_EASIZE:
-            pDst->Attr.enmAdditional        = SHAREDCLIPBOARDFSOBJATTRADD_EASIZE;
+            pDst->Attr.enmAdditional        = SHCLFSOBJATTRADD_EASIZE;
             pDst->Attr.u.EASize.cb          = pSrc->Attr.u.EASize.cb;
             break;
@@ -2612 +2612 @@
  */
 static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode,
-                                                 SHAREDCLIPBOARDOBJHANDLE handleInitial, uint64_t *pfOpen)
+                                                 SHCLOBJHANDLE handleInitial, uint64_t *pfOpen)
 {
     uint64_t fOpen = 0;
@@ -2640 +2640 @@
          * and it contained random bits from stack. Detect this using the handle field value
          * passed from the guest: old additions set it (incorrectly) to 0, new additions
-         * set it to SHAREDCLIPBOARDOBJHANDLE_INVALID(~0).
+         * set it to SHCLOBJHANDLE_INVALID(~0).
          */
         if (handleInitial == 0)
@@ -2656 +2656 @@
     }
 
-    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_RW))
+    switch ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_RW))
     {
         default:
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE:
+        case SHCL_OBJ_CF_ACCESS_NONE:
         {
 #ifdef RT_OS_WINDOWS
-            if ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR) != SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE)
+            if ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_ATTR) != SHCL_OBJ_CF_ACCESS_ATTR_NONE)
                 fOpen |= RTFILE_O_ATTR_ONLY;
             else
 #endif
                 fOpen |= RTFILE_O_READ;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_NONE\n"));
             break;
         }
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ:
+        case SHCL_OBJ_CF_ACCESS_READ:
         {
             fOpen |= RTFILE_O_READ;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_READ\n"));
             break;
         }
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE:
+        case SHCL_OBJ_CF_ACCESS_WRITE:
         {
             fOpen |= RTFILE_O_WRITE;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_WRITE\n"));
             break;
         }
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE:
+        case SHCL_OBJ_CF_ACCESS_READWRITE:
         {
             fOpen |= RTFILE_O_READWRITE;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_READWRITE\n"));
             break;
         }
     }
 
-    if (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_APPEND)
+    if (fShClFlags & SHCL_OBJ_CF_ACCESS_APPEND)
     {
         fOpen |= RTFILE_O_APPEND;
     }
 
-    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR))
+    switch ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_ATTR))
     {
         default:
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE:
+        case SHCL_OBJ_CF_ACCESS_ATTR_NONE:
         {
             fOpen |= RTFILE_O_ACCESS_ATTR_DEFAULT;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_NONE\n"));
             break;
         }
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ:
+        case SHCL_OBJ_CF_ACCESS_ATTR_READ:
         {
             fOpen |= RTFILE_O_ACCESS_ATTR_READ;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_READ\n"));
             break;
         }
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE:
+        case SHCL_OBJ_CF_ACCESS_ATTR_WRITE:
         {
             fOpen |= RTFILE_O_ACCESS_ATTR_WRITE;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_WRITE\n"));
             break;
         }
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE:
+        case SHCL_OBJ_CF_ACCESS_ATTR_READWRITE:
         {
             fOpen |= RTFILE_O_ACCESS_ATTR_READWRITE;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_READWRITE\n"));
             break;
         }
@@ -2731 +2731 @@
 
     /* Sharing mask */
-    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_DENY))
+    switch ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_DENY))
     {
         default:
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE:
+        case SHCL_OBJ_CF_ACCESS_DENYNONE:
             fOpen |= RTFILE_O_DENY_NONE;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYNONE\n"));
             break;
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD:
+        case SHCL_OBJ_CF_ACCESS_DENYREAD:
             fOpen |= RTFILE_O_DENY_READ;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYREAD\n"));
             break;
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE:
+        case SHCL_OBJ_CF_ACCESS_DENYWRITE:
             fOpen |= RTFILE_O_DENY_WRITE;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYWRITE\n"));
             break;
 
-        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL:
+        case SHCL_OBJ_CF_ACCESS_DENYALL:
             fOpen |= RTFILE_O_DENY_ALL;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYALL\n"));
             break;
     }
 
     /* Open/Create action mask */
-    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS))
-    {
-        case SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS:
-            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+    switch ((fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_EXISTS))
+    {
+        case SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS:
+            if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_OPEN_CREATE;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n"));
             }
-            else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            else if (SHCL_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_OPEN;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS and SHCL_OBJ_CF_ACT_FAIL_IF_NEW\n"));
             }
             else
@@ -2775 +2775 @@
             }
             break;
-        case SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS:
-            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+        case SHCL_OBJ_CF_ACT_FAIL_IF_EXISTS:
+            if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_CREATE;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_FAIL_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n"));
             }
             else
@@ -2787 +2787 @@
             }
             break;
-        case SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS:
-            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+        case SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS:
+            if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_CREATE_REPLACE;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n"));
             }
-            else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            else if (SHCL_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHCL_OBJ_CF_ACT_FAIL_IF_NEW\n"));
             }
             else
@@ -2804 +2804 @@
             }
             break;
-        case SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS:
-            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+        case SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS:
+            if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_CREATE_REPLACE;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n"));
             }
-            else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            else if (SHCL_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW))
             {
                 fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE;
-                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n"));
+                LogFlowFunc(("SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHCL_OBJ_CF_ACT_FAIL_IF_NEW\n"));
             }
             else
@@ -2824 +2824 @@
         {
             rc = VERR_INVALID_PARAMETER;
-            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS - invalid parameter\n"));
+            LogFlowFunc(("SHCL_OBJ_CF_ACT_MASK_IF_EXISTS - invalid parameter\n"));
             break;
         }

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

@@ -154 +154 @@
  *                              Will be set to NULL if the new API is not available.
  */
-int VBoxClipboardWinCheckAndInitNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI)
+int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI)
 {
     RTLDRMOD hUser32 = NIL_RTLDRMOD;
@@ -175 +175 @@
     else
     {
-        RT_BZERO(pAPI, sizeof(VBOXCLIPBOARDWINAPINEW));
+        RT_BZERO(pAPI, sizeof(SHCLWINAPINEW));
         LogFunc(("New Clipboard API not available; rc=%Rrc\n", rc));
     }
@@ -188 +188 @@
  * @param   pAPI                Structure used for checking if the new clipboard API is available or not.
  */
-bool VBoxClipboardWinIsNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI)
+bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI)
 {
     if (!pAPI)
@@ -201 +201 @@
  * @param   pCtx                Windows clipboard context to use to add ourselves.
  */
-int VBoxClipboardWinChainAdd(PVBOXCLIPBOARDWINCTX pCtx)
-{
-    const PVBOXCLIPBOARDWINAPINEW pAPI = &pCtx->newAPI;
+int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx)
+{
+    const PSHCLWINAPINEW pAPI = &pCtx->newAPI;
 
     BOOL fRc;
@@ -234 +234 @@
  * @param   pCtx                Windows clipboard context to use to remove ourselves.
  */
-int VBoxClipboardWinChainRemove(PVBOXCLIPBOARDWINCTX pCtx)
+int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx)
 {
     if (!pCtx->hWnd)
         return VINF_SUCCESS;
 
-    const PVBOXCLIPBOARDWINAPINEW pAPI = &pCtx->newAPI;
+    const PSHCLWINAPINEW pAPI = &pCtx->newAPI;
 
     BOOL fRc;
@@ -283 +283 @@
 
     /** @todo r=andy Why not using SetWindowLongPtr for keeping the context? */
-    PVBOXCLIPBOARDWINCTX pCtx = (PVBOXCLIPBOARDWINCTX)dwData;
+    PSHCLWINCTX pCtx = (PSHCLWINCTX)dwData;
     AssertPtrReturnVoid(pCtx);
 
@@ -298 +298 @@
  * @param   lParam              LPARAM to pass.
  */
-LRESULT VBoxClipboardWinChainPassToNext(PVBOXCLIPBOARDWINCTX pWinCtx,
+LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx,
                                         UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -327 +327 @@
  * @param   uFormat             Windows clipboard format to convert.
  */
-VBOXCLIPBOARDFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat)
+SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat)
 {
     /* Insert the requested clipboard format data into the clipboard. */
-    VBOXCLIPBOARDFORMAT vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    SHCLFORMAT vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_NONE;
 
     switch (uFormat)
@@ -386 +386 @@
  * @param   pFormats            Where to store the retrieved formats.
  */
-int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats)
+int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats)
 {
     AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
     AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
 
-    VBOXCLIPBOARDFORMATS fFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    SHCLFORMATS fFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
 
     /* Query list of available formats and report to host. */
@@ -649 +649 @@
  * @param   lParam              lParam to pass on.
  */
-LRESULT VBoxClipboardWinHandleWMChangeCBChain(PVBOXCLIPBOARDWINCTX pWinCtx,
+LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx,
                                               HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -697 +697 @@
  * @param   pWinCtx             Windows context to use.
  */
-int VBoxClipboardWinHandleWMDestroy(PVBOXCLIPBOARDWINCTX pWinCtx)
+int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx)
 {
     LogFlowFuncEnter();
@@ -723 +723 @@
  * @param   hWnd                Window handle to use.
  */
-int VBoxClipboardWinHandleWMRenderAllFormats(PVBOXCLIPBOARDWINCTX pWinCtx, HWND hWnd)
+int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd)
 {
     RT_NOREF(pWinCtx);
@@ -750 +750 @@
  * @param   pWinCtx             Windows context to use.
  */
-int VBoxClipboardWinHandleWMTimer(PVBOXCLIPBOARDWINCTX pWinCtx)
+int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx)
 {
     int rc = VINF_SUCCESS;
@@ -790 +790 @@
  * @param   fFormats            Clipboard format(s) to announce.
  */
-int VBoxClipboardWinAnnounceFormats(PVBOXCLIPBOARDWINCTX pWinCtx, VBOXCLIPBOARDFORMATS fFormats)
+int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats)
 {
     LogFunc(("fFormats=0x%x\n", fFormats));
@@ -846 +846 @@
  * @param   pTransfer           URI transfer to use.
  */
-int VBoxClipboardWinURITransferCreate(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer)
+int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -912 +912 @@
  * @param   pTransfer           URI transfer to create implementation-specific data for.
  */
-void VBoxClipboardWinURITransferDestroy(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer)
+void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
 {
     RT_NOREF(pWinCtx);

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

@@ -206 +206 @@
 {
     /** Opaque data structure describing the front-end. */
-    VBOXCLIPBOARDCONTEXT *pFrontend;
+    SHCLCONTEXT *pFrontend;
     /** Is an X server actually available? */
     bool fHaveX11;
@@ -926 +926 @@
  * @note  X11 backend code
  */
-CLIPBACKEND *ClipConstructX11(VBOXCLIPBOARDCONTEXT *pFrontend, bool fHeadless)
+CLIPBACKEND *ClipConstructX11(SHCLCONTEXT *pFrontend, bool fHeadless)
 {
     CLIPBACKEND *pCtx = (CLIPBACKEND *)RTMemAllocZ(sizeof(CLIPBACKEND));
@@ -2120 +2120 @@
 
 /* Return the data in the simulated VBox clipboard. */
-int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
+int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
 {
     RT_NOREF2(pCtx, u32Format);
@@ -2241 +2241 @@
 static uint32_t g_fX11Formats = 0;
 
-void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
+void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats)
 {
     RT_NOREF1(pCtx);
@@ -2389 +2389 @@
 static char g_completedBuf[MAX_BUF_SIZE];
 
-void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
+void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
 {
     RT_NOREF1(pCtx);
@@ -2885 +2885 @@
 # include <iprt/test.h>
 
-int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
+int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
 {
     RT_NOREF4(pCtx, u32Format, ppv, pcb);
@@ -2891 +2891 @@
 }
 
-void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
+void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats)
 {
     RT_NOREF2(pCtx, u32Formats);
 }
 
-void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
+void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
 {
     RT_NOREF5(pCtx, rc, pReq, pv, cb);