VirtualBox

Changeset 80664 in vbox for trunk/src/VBox/HostServices


Ignore:
Timestamp:
Sep 9, 2019 10:00:04 AM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard: More renaming + unification.

Location:
trunk/src/VBox/HostServices/SharedClipboard
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp

    r80662 r80664  
    5454
    5555/**
    56  * Checks if something is present on the clipboard and calls vboxSvcClipboardReportMsg.
     56 * Checks if something is present on the clipboard and calls sharedClipboardSvcReportMsg.
    5757 *
    5858 * @returns IPRT status code (ignored).
    … …  
    7676        formatData.uFormats = fFormats;
    7777
    78         rc = vboxSvcClipboardFormatsReport(pCtx->pClient, &formatData);
     78        rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
    7979    }
    8080
    … …  
    117117
    118118
    119 int VBoxClipboardSvcImplInit(void)
     119int SharedClipboardSvcImplInit(void)
    120120{
    121121    Log(("vboxClipboardInit\n"));
    … …  
    137137}
    138138
    139 void VBoxClipboardSvcImplDestroy(void)
     139void SharedClipboardSvcImplDestroy(void)
    140140{
    141141    /*
    … …  
    156156}
    157157
    158 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     158int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    159159{
    160160    RT_NOREF(fHeadless);
    … …  
    172172
    173173    /* Initially sync the host clipboard content with the client. */
    174     int rc = VBoxClipboardSvcImplSync(pClient);
    175 
    176     VBoxSvcClipboardUnlock();
    177     return rc;
    178 }
    179 
    180 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     174    int rc = SharedClipboardSvcImplSync(pClient);
     175
     176    VBoxSvcClipboardUnlock();
     177    return rc;
     178}
     179
     180int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    181181{
    182182    /* Sync the host clipboard content with the client. */
    … …  
    190190}
    191191
    192 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     192int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    193193{
    194194    VBoxSvcClipboardLock();
    … …  
    201201}
    202202
    203 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
     203int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
    204204                                       PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
    205205{
    … …  
    225225    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    226226
    227     return vboxSvcClipboardDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
     227    return sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
    228228}
    229229
    … …  
    236236 * @param pcbActual             Where to write the actual size of the written data.
    237237 */
    238 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     238int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    239239                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    240240{
    … …  
    262262 * @param pData                 Data block to write to clipboard.
    263263 */
    264 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient,
     264int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
    265265                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    266266{
    … …  
    277277
    278278#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    279 int VBoxClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
     279int SharedClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    280280{
    281281    RT_NOREF(pClient, pDirData);
    … …  
    283283}
    284284
    285 int VBoxClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
     285int SharedClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    286286{
    287287    RT_NOREF(pClient, pDirData);
    … …  
    289289}
    290290
    291 int VBoxClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
     291int SharedClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    292292{
    293293    RT_NOREF(pClient, pFileHdr);
    … …  
    295295}
    296296
    297 int VBoxClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
     297int SharedClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    298298{
    299299    RT_NOREF(pClient, pFileHdr);
    … …  
    301301}
    302302
    303 int VBoxClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
     303int SharedClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    304304{
    305305    RT_NOREF(pClient, pFileData);
    … …  
    307307}
    308308
    309 int VBoxClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
     309int SharedClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    310310{
    311311    RT_NOREF(pClient, pFileData);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r80662 r80664  
    4646 * Structure for keeping a Shared Clipboard HGCM message context.
    4747 */
    48 typedef struct _VBOXSHCLMSGCTX
     48typedef struct _SHCLMSGCTX
    4949{
    5050    /** Context ID. */
    5151    uint32_t uContextID;
    52 } VBOXSHCLMSGCTX, *PVBOXSHCLMSGCTX;
     52} SHCLMSGCTX, *PSHCLMSGCTX;
    5353
    5454/**
    … …  
    6464    PVBOXHGCMSVCPARM m_paParms;
    6565    /** Message context. */
    66     VBOXSHCLMSGCTX   m_Ctx;
     66    SHCLMSGCTX       m_Ctx;
    6767} SHCLCLIENTMSG, *PSHCLCLIENTMSG;
    6868
    … …  
    178178 * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
    179179 */
    180 int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
    181 int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
    182 int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
    183 
    184 uint32_t vboxSvcClipboardGetMode(void);
    185 int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
    186 
    187 void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient);
    188 PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms);
    189 void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg);
    190 void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
    191 int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
    192 int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
    193 int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    194 
    195 int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient);
     180int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
     181int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     182int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
     183
     184uint32_t sharedClipboardSvcGetMode(void);
     185int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
     186
     187void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient);
     188PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms);
     189void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg);
     190void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
     191int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
     192int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
     193int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     194
     195int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient);
    196196
    197197# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    198 int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient,
     198int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient,
    199199                                     SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
    200200                                     PSHCLURITRANSFER *ppTransfer);
    201 bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
     201bool sharedClipboardSvcURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
    202202# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    203203
    … …  
    205205 * Platform-dependent implementations.
    206206 */
    207 int VBoxClipboardSvcImplInit(void);
    208 void VBoxClipboardSvcImplDestroy(void);
    209 
    210 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
    211 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
    212 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
     207int SharedClipboardSvcImplInit(void);
     208void SharedClipboardSvcImplDestroy(void);
     209
     210int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
     211int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
     212int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
    213213/** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/
    214 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
    215 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     214int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
     215int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
    216216/**
    217217 * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer
    218218 * after a save and restore of the guest.
    219219 */
    220 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient);
     220int SharedClipboardSvcImplSync(PSHCLCLIENT pClient);
    221221
    222222#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    223 int vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx);
    224 DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx);
    225 
    226 int vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
    227 
    228 int vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx,
     223int sharedClipboardSvcURITransferOpen(PSHCLPROVIDERCTX pCtx);
     224DECLCALLBACK(int) sharedClipboardSvcURITransferClose(PSHCLPROVIDERCTX pCtx);
     225
     226int sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
     227
     228int sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx,
    229229                                PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
    230 int vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
    231 int vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     230int sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
     231int sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    232232                                   PSHCLLISTHDR pListHdr);
    233 int vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     233int sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    234234                                    PSHCLLISTHDR pListHdr);
    235 int vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     235int sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    236236                                     PSHCLLISTENTRY pListEntry);
    237 int vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     237int sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    238238                                      PSHCLLISTENTRY pListEntry);
    239239
    240 int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     240int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    241241                               PSHCLOBJHANDLE phObj);
    242 int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
    243 int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     242int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
     243int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    244244                               void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    245 int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     245int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    246246                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    247247
    … …  
    253253DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc);
    254254
    255 int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
    256 int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
     255int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
     256int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
    257257#endif /*VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    258258

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp

    r80662 r80664  
    4848*   Prototypes                                                                                                                   *
    4949*********************************************************************************************************************************/
    50 static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    51                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
    52 static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    53                                            PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
     50static int sharedClipboardSvcURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     51                                            PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
     52static int sharedClipboardSvcURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     53                                             PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
    5454
    5555
    … …  
    5858*********************************************************************************************************************************/
    5959
    60 DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx)
     60DECLCALLBACK(int) sharedClipboardSvcURITransferOpen(PSHCLPROVIDERCTX pCtx)
    6161{
    6262    RT_NOREF(pCtx);
    … …  
    6666}
    6767
    68 DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx)
     68DECLCALLBACK(int) sharedClipboardSvcURITransferClose(PSHCLPROVIDERCTX pCtx)
    6969{
    7070    RT_NOREF(pCtx);
    … …  
    7474}
    7575
    76 DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     76DECLCALLBACK(int) sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    7777{
    7878    LogFlowFuncEnter();
    … …  
    8383    int rc;
    8484
    85     PSHCLCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
     85    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
    8686                                                               VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
    8787    if (pMsgHdr)
    … …  
    9292        HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */);
    9393
    94         rc = vboxSvcClipboardMsgAdd(pClient, pMsgHdr, true /* fAppend */);
     94        rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
    9595        if (RT_SUCCESS(rc))
    9696        {
    … …  
    9898            AssertRC(rc2);
    9999
    100             rc = vboxSvcClipboardClientWakeup(pClient);
     100            rc = sharedClipboardSvcClientWakeup(pClient);
    101101            if (RT_SUCCESS(rc))
    102102            {
    … …  
    123123                                for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
    124124                                {
    125                                     PSHCLCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
     125                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
    126126                                                                                                 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    127127
    … …  
    136136                                    AssertRC(rc2);
    137137
    138                                     rc = vboxSvcClipboardMsgAdd(pClient, pMsgEntry, true /* fAppend */);
     138                                    rc = sharedClipboardSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
    139139                                    if (RT_FAILURE(rc))
    140140                                        break;
    … …  
    190190}
    191191
    192 DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx,
    193                                               PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
     192DECLCALLBACK(int) sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx,
     193                                                PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
    194194{
    195195    LogFlowFuncEnter();
    … …  
    200200    int rc;
    201201
    202     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
    203                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
     202    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
     203                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    204204    if (pMsg)
    205205    {
    … …  
    208208        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    209209
    210         rc = vboxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms);
    211         if (RT_SUCCESS(rc))
    212         {
    213             rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     210        rc = sharedClipboardSvcURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms);
     211        if (RT_SUCCESS(rc))
     212        {
     213            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    214214            if (RT_SUCCESS(rc))
    215215            {
    … …  
    217217                AssertRC(rc2);
    218218
    219                 rc = vboxSvcClipboardClientWakeup(pClient);
     219                rc = sharedClipboardSvcClientWakeup(pClient);
    220220                if (RT_SUCCESS(rc))
    221221                {
    … …  
    248248}
    249249
    250 DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
     250DECLCALLBACK(int) sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    251251{
    252252    LogFlowFuncEnter();
    … …  
    257257    int rc;
    258258
    259     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
     259    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
    260260                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    261261    if (pMsg)
    … …  
    265265        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    266266
    267         rc = vboxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList);
    268         if (RT_SUCCESS(rc))
    269         {
    270             rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     267        rc = sharedClipboardSvcURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList);
     268        if (RT_SUCCESS(rc))
     269        {
     270            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    271271            if (RT_SUCCESS(rc))
    272272            {
    … …  
    274274                AssertRC(rc2);
    275275
    276                 rc = vboxSvcClipboardClientWakeup(pClient);
     276                rc = sharedClipboardSvcClientWakeup(pClient);
    277277                if (RT_SUCCESS(rc))
    278278                {
    … …  
    294294}
    295295
    296 DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx,
    297                                                  SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     296DECLCALLBACK(int) sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx,
     297                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    298298{
    299299    LogFlowFuncEnter();
    … …  
    304304    int rc;
    305305
    306     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
    307                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
     306    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
     307                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
    308308    if (pMsg)
    309309    {
    … …  
    314314        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
    315315
    316         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     316        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    317317        if (RT_SUCCESS(rc))
    318318        {
    … …  
    320320            AssertRC(rc2);
    321321
    322             rc = vboxSvcClipboardClientWakeup(pClient);
     322            rc = sharedClipboardSvcClientWakeup(pClient);
    323323            if (RT_SUCCESS(rc))
    324324            {
    … …  
    344344}
    345345
    346 DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx,
    347                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     346DECLCALLBACK(int) sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx,
     347                                                    SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    348348{
    349349    RT_NOREF(pCtx, hList, pListHdr);
    … …  
    354354}
    355355
    356 DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx,
    357                                                    SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     356DECLCALLBACK(int) sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx,
     357                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    358358{
    359359    LogFlowFuncEnter();
    … …  
    364364    int rc;
    365365
    366     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
    367                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
     366    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
     367                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
    368368    if (pMsg)
    369369    {
    … …  
    374374        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */);
    375375
    376         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     376        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    377377        if (RT_SUCCESS(rc))
    378378        {
    … …  
    380380            AssertRC(rc2);
    381381
    382             rc = vboxSvcClipboardClientWakeup(pClient);
     382            rc = sharedClipboardSvcClientWakeup(pClient);
    383383            if (RT_SUCCESS(rc))
    384384            {
    … …  
    403403}
    404404
    405 DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx,
    406                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     405DECLCALLBACK(int) sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx,
     406                                                      SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    407407{
    408408    RT_NOREF(pCtx, hList, pListEntry);
    … …  
    413413}
    414414
    415 int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    416                                PSHCLOBJHANDLE phObj)
     415int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     416                                 PSHCLOBJHANDLE phObj)
    417417{
    418418    LogFlowFuncEnter();
    … …  
    423423    int rc;
    424424
    425     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
    426                                                             VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     425    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
     426                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
    427427    if (pMsg)
    428428    {
    … …  
    439439        HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate);
    440440
    441         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     441        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    442442        if (RT_SUCCESS(rc))
    443443        {
    … …  
    445445            AssertRC(rc2);
    446446
    447             rc = vboxSvcClipboardClientWakeup(pClient);
     447            rc = sharedClipboardSvcClientWakeup(pClient);
    448448            if (RT_SUCCESS(rc))
    449449            {
    … …  
    473473}
    474474
    475 int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
     475int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    476476{
    477477    LogFlowFuncEnter();
    … …  
    482482    int rc;
    483483
    484     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
     484    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
    485485                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
    486486    if (pMsg)
    … …  
    491491        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
    492492
    493         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     493        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    494494        if (RT_SUCCESS(rc))
    495495        {
    … …  
    497497            AssertRC(rc2);
    498498
    499             rc = vboxSvcClipboardClientWakeup(pClient);
     499            rc = sharedClipboardSvcClientWakeup(pClient);
    500500            if (RT_SUCCESS(rc))
    501501            {
    … …  
    525525}
    526526
    527 int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    528                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
     527int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     528                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    529529{
    530530    LogFlowFuncEnter();
    … …  
    535535    int rc;
    536536
    537     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
     537    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
    538538                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
    539539    if (pMsg)
    … …  
    546546        HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags);
    547547
    548         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     548        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    549549        if (RT_SUCCESS(rc))
    550550        {
    … …  
    552552            AssertRC(rc2);
    553553
    554             rc = vboxSvcClipboardClientWakeup(pClient);
     554            rc = sharedClipboardSvcClientWakeup(pClient);
    555555            if (RT_SUCCESS(rc))
    556556            {
    … …  
    583583}
    584584
    585 int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    586                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
     585int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     586                                  void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    587587{
    588588    LogFlowFuncEnter();
    … …  
    593593    int rc;
    594594
    595     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
     595    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
    596596                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
    597597    if (pMsg)
    … …  
    604604        HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags);
    605605
    606         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     606        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    607607        if (RT_SUCCESS(rc))
    608608        {
    … …  
    610610            AssertRC(rc2);
    611611
    612             rc = vboxSvcClipboardClientWakeup(pClient);
     612            rc = sharedClipboardSvcClientWakeup(pClient);
    613613            if (RT_SUCCESS(rc))
    614614            {
    … …  
    688688 * @param   pReply              Where to store the reply.
    689689 */
    690 static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    691                                        PSHCLREPLY pReply)
     690static int sharedClipboardSvcURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     691                                         PSHCLREPLY pReply)
    692692{
    693693    int rc;
    … …  
    756756 * @param   pRootLstHdr         Where to store the URI root list header on success.
    757757 */
    758 static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    759                                              PSHCLROOTLISTHDR pRootLstHdr)
     758static int sharedClipboardSvcURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     759                                               PSHCLROOTLISTHDR pRootLstHdr)
    760760{
    761761    int rc;
    … …  
    782782 * @param   pListEntry          Where to store the root list entry.
    783783 */
    784 static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    785                                                PSHCLROOTLISTENTRY pListEntry)
     784static int sharedClipboardSvcURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     785                                                 PSHCLROOTLISTENTRY pListEntry)
    786786{
    787787    int rc;
    … …  
    819819 * @param   pOpenParms          Where to store the open parameters of the request.
    820820 */
    821 static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    822                                           PSHCLLISTOPENPARMS pOpenParms)
     821static int sharedClipboardSvcURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     822                                            PSHCLLISTOPENPARMS pOpenParms)
    823823{
    824824    int rc;
    … …  
    866866 * @param   pOpenParms          List open parameters to set.
    867867 */
    868 static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    869                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
     868static int sharedClipboardSvcURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     869                                            PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
    870870{
    871871    int rc;
    … …  
    899899 * @param   hList               Handle of list to close.
    900900 */
    901 static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    902                                            PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
     901static int sharedClipboardSvcURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     902                                             PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
    903903{
    904904    int rc;
    … …  
    927927 * @param   pListHdr            Where to store the list header.
    928928 */
    929 static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    930                                          PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
     929static int sharedClipboardSvcURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     930                                           PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
    931931{
    932932    int rc;
    … …  
    966966 * @param   pListHdr            Pointer to data to set to the HGCM parameters.
    967967 */
    968 static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    969                                          PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
     968static int sharedClipboardSvcURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     969                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
    970970{
    971971    int rc;
    … …  
    10011001 * @param   pListEntry          Where to store the list entry.
    10021002 */
    1003 static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    1004                                            PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
     1003static int sharedClipboardSvcURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     1004                                             PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
    10051005{
    10061006    int rc;
    … …  
    10471047 * @param   pListEntry          Pointer to data to set to the HGCM parameters.
    10481048 */
    1049 static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     1049static int sharedClipboardSvcURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    10501050                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
    10511051{
    … …  
    10791079 * @param   pDataChunk          Where to store the object data chunk data.
    10801080 */
    1081 static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
     1081static int sharedClipboardSvcURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
    10821082{
    10831083    AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
    … …  
    11171117 * @param   pRc                 Where to store the received error code.
    11181118 */
    1119 static int vboxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
     1119static int sharedClipboardSvcURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
    11201120{
    11211121    AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
    … …  
    11441144 * @param   paParms             Array function parameters supplied.
    11451145 */
    1146 static int vboxSvcClipboardURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer,
    1147                                                   uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1146static int sharedClipboardSvcURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer,
     1147                                                    uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    11481148{
    11491149    RT_NOREF(pClient);
    … …  
    11551155    if (pReply)
    11561156    {
    1157         rc = vboxSvcClipboardURIGetReply(cParms, paParms, pReply);
     1157        rc = sharedClipboardSvcURIGetReply(cParms, paParms, pReply);
    11581158        if (RT_SUCCESS(rc))
    11591159        {
    … …  
    12271227 * @param   tsArrival           Timestamp of arrival.
    12281228 */
    1229 int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient,
    1230                                VBOXHGCMCALLHANDLE callHandle,
    1231                                uint32_t u32Function,
    1232                                uint32_t cParms,
    1233                                VBOXHGCMSVCPARM paParms[],
    1234                                uint64_t tsArrival)
     1229int sharedClipboardSvcURIHandler(PSHCLCLIENT pClient,
     1230                                VBOXHGCMCALLHANDLE callHandle,
     1231                                uint32_t u32Function,
     1232                                uint32_t cParms,
     1233                                VBOXHGCMSVCPARM paParms[],
     1234                                uint64_t tsArrival)
    12351235{
    12361236    RT_NOREF(paParms, tsArrival);
    … …  
    12401240
    12411241    /* Check if we've the right mode set. */
    1242     if (!vboxSvcClipboardURIMsgIsAllowed(vboxSvcClipboardGetMode(), u32Function))
     1242    if (!sharedClipboardSvcURIMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function))
    12431243    {
    12441244        LogFunc(("Wrong clipboard mode, denying access\n"));
    … …  
    13251325                if (RT_SUCCESS(rc))
    13261326                {
    1327                     rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
     1327                    rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer);
    13281328                    if (RT_SUCCESS(rc))
    13291329                    {
    … …  
    13331333                        creationCtx.enmSource = pClient->State.enmSource;
    13341334
    1335                         creationCtx.Interface.pfnTransferOpen  = vboxSvcClipboardURITransferOpen;
    1336                         creationCtx.Interface.pfnTransferClose = vboxSvcClipboardURITransferClose;
    1337                         creationCtx.Interface.pfnListOpen      = vboxSvcClipboardURIListOpen;
    1338                         creationCtx.Interface.pfnListClose     = vboxSvcClipboardURIListClose;
    1339                         creationCtx.Interface.pfnObjOpen       = vboxSvcClipboardURIObjOpen;
    1340                         creationCtx.Interface.pfnObjClose      = vboxSvcClipboardURIObjClose;
     1335                        creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcURITransferOpen;
     1336                        creationCtx.Interface.pfnTransferClose = sharedClipboardSvcURITransferClose;
     1337                        creationCtx.Interface.pfnListOpen      = sharedClipboardSvcURIListOpen;
     1338                        creationCtx.Interface.pfnListClose     = sharedClipboardSvcURIListClose;
     1339                        creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcURIObjOpen;
     1340                        creationCtx.Interface.pfnObjClose      = sharedClipboardSvcURIObjClose;
    13411341
    13421342                        if (enmDir == SHCLURITRANSFERDIR_READ)
    13431343                        {
    1344                             creationCtx.Interface.pfnGetRoots        = vboxSvcClipboardURIGetRoots;
    1345                             creationCtx.Interface.pfnListHdrRead     = vboxSvcClipboardURIListHdrRead;
    1346                             creationCtx.Interface.pfnListEntryRead   = vboxSvcClipboardURIListEntryRead;
    1347                             creationCtx.Interface.pfnObjRead         = vboxSvcClipboardURIObjRead;
     1344                            creationCtx.Interface.pfnGetRoots        = sharedClipboardSvcURIGetRoots;
     1345                            creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcURIListHdrRead;
     1346                            creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcURIListEntryRead;
     1347                            creationCtx.Interface.pfnObjRead         = sharedClipboardSvcURIObjRead;
    13481348                        }
    13491349                        else
    … …  
    13741374                    if (RT_SUCCESS(rc))
    13751375                    {
    1376                         rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1376                        rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
    13771377                        if (RT_SUCCESS(rc))
    1378                             rc = VBoxClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
     1378                            rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
    13791379                    }
    13801380
    13811381                    if (RT_FAILURE(rc))
    13821382                    {
    1383                         VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1383                        SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    13841384                        SharedClipboardURITransferDestroy(pTransfer);
    13851385                    }
    … …  
    13981398        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
    13991399        {
    1400             rc = vboxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms);
     1400            rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms);
    14011401            break;
    14021402        }
    … …  
    14101410        {
    14111411            SHCLROOTLISTHDR lstHdr;
    1412             rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr);
     1412            rc = sharedClipboardSvcURIGetRootListHdr(cParms, paParms, &lstHdr);
    14131413            if (RT_SUCCESS(rc))
    14141414            {
    … …  
    14591459        {
    14601460            SHCLROOTLISTENTRY lstEntry;
    1461             rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
     1461            rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry);
    14621462            if (RT_SUCCESS(rc))
    14631463            {
    … …  
    14871487        {
    14881488            SHCLLISTOPENPARMS listOpenParms;
    1489             rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);
     1489            rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms);
    14901490            if (RT_SUCCESS(rc))
    14911491            {
    … …  
    15271527                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    15281528                /*if (RT_SUCCESS(rc))
    1529                     rc = vboxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);*/
     1529                    rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/
    15301530            }
    15311531            break;
    … …  
    15391539            {
    15401540                SHCLLISTHANDLE hList;
    1541                 rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
     1541                rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList);
    15421542                if (RT_SUCCESS(rc))
    15431543                {
    … …  
    15871587            {
    15881588                SHCLLISTHANDLE hList;
    1589                 rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);
     1589                rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList);
    15901590                if (RT_SUCCESS(rc))
    15911591                {
    … …  
    16331633        {
    16341634            SHCLOBJDATACHUNK dataChunk;
    1635             rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk);
     1635            rc = sharedClipboardSvcURIGetObjDataChunk(cParms, paParms, &dataChunk);
    16361636            if (RT_SUCCESS(rc))
    16371637            {
    … …  
    18381838        {
    18391839            int rcGuest;
    1840             rc = vboxSvcClipboardURIGetError(cParms,paParms, &rcGuest);
     1840            rc = sharedClipboardSvcURIGetError(cParms,paParms, &rcGuest);
    18411841            if (RT_SUCCESS(rc))
    18421842                LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest));
    … …  
    18691869 * @param   paParms             Array function parameters  supplied.
    18701870 */
    1871 int vboxSvcClipboardURIHostHandler(uint32_t u32Function,
     1871int sharedClipboardSvcURIHostHandler(uint32_t u32Function,
    18721872                                   uint32_t cParms,
    18731873                                   VBOXHGCMSVCPARM paParms[])
    … …  
    19011901 * @param   pTransfer           URI transfer to register a clipboard area for.
    19021902 */
    1903 int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
     1903int sharedClipboardSvcURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    19041904{
    19051905    RT_NOREF(pClientState);
    … …  
    19501950 * @param   pTransfer           URI transfer to unregister a clipboard area from.
    19511951 */
    1952 int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
     1952int sharedClipboardSvcURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    19531953{
    19541954    RT_NOREF(pClientState);
    … …  
    19981998 * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
    19991999 */
    2000 int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer,
     2000int sharedClipboardSvcURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer,
    20012001                                  SHCLAREAID uID)
    20022002{
    … …  
    20462046 * @param   pTransfer           URI transfer to detach a clipboard area from.
    20472047 */
    2048 int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
     2048int sharedClipboardSvcURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    20492049{
    20502050    RT_NOREF(pClientState);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h

    r80662 r80664  
    2222#endif
    2323
    24 int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
    25 int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     24int sharedClipboardSvcURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
     25int sharedClipboardSvcURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    2626
    27 int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    28 int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    29 int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID);
    30 int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     27int sharedClipboardSvcURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     28int sharedClipboardSvcURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     29int sharedClipboardSvcURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID);
     30int sharedClipboardSvcURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    3131
    3232#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp

    r80662 r80664  
    107107            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
    108108
    109             if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
    110                 && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     109            if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
     110                && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    111111            {
    112112                LogFlowFunc(("Wrong clipboard mode, skipping\n"));
    … …  
    130130}
    131131
    132 bool vboxSvcClipboardURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     132bool sharedClipboardSvcURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    133133{
    134134    RT_NOREF(pClient, cParms, paParms);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp

    r80662 r80664  
    7373
    7474    if (   u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML
    75         && VBoxClipboardWinIsCFHTML((const char *)pvSrc))
     75        && SharedClipboardWinIsCFHTML((const char *)pvSrc))
    7676    {
    7777        /** @todo r=bird: Why the double conversion? */
    7878        char *pszBuf = NULL;
    7979        uint32_t cbBuf = 0;
    80         int rc = VBoxClipboardWinConvertCFHTMLToMIME((const char *)pvSrc, cbSrc, &pszBuf, &cbBuf);
     80        int rc = SharedClipboardWinConvertCFHTMLToMIME((const char *)pvSrc, cbSrc, &pszBuf, &cbBuf);
    8181        if (RT_SUCCESS(rc))
    8282        {
    … …  
    175175    RT_ZERO(dataReq);
    176176
    177     dataReq.uFmt   = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     177    dataReq.uFmt   = SharedClipboardWinClipboardFormatToVBox(cfFormat);
    178178    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    179179
    180180    SHCLEVENTID uEvent = 0;
    181     int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     181    int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    182182    if (RT_SUCCESS(rc))
    183183    {
    … …  
    222222                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    223223                if (RT_SUCCESS(rc))
    224                     vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     224                    sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    225225            }
    226226
    … …  
    231231        {
    232232            LogFunc(("WM_CHANGECBCHAIN\n"));
    233             lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam);
     233            lresultRc = SharedClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam);
    234234            break;
    235235        }
    … …  
    244244                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    245245                if (RT_SUCCESS(rc))
    246                     vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    247             }
    248 
    249             lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam);
     246                    sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     247            }
     248
     249            lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam);
    250250            break;
    251251        }
    … …  
    253253        case WM_TIMER:
    254254        {
    255             int rc = VBoxClipboardWinHandleWMTimer(pWinCtx);
     255            int rc = SharedClipboardWinHandleWMTimer(pWinCtx);
    256256            AssertRC(rc);
    257257
    … …  
    266266            const UINT cfFormat = (UINT)wParam;
    267267
    268             const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     268            const SHCLFORMAT fFormat = SharedClipboardWinClipboardFormatToVBox(cfFormat);
    269269
    270270            LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
    … …  
    275275                /* Unsupported clipboard format is requested. */
    276276                LogFunc(("WM_RENDERFORMAT unsupported format requested or client is not active\n"));
    277                 VBoxClipboardWinClear();
     277                SharedClipboardWinClear();
    278278            }
    279279            else
    … …  
    293293
    294294                if (RT_FAILURE(rc))
    295                     VBoxClipboardWinClear();
     295                    SharedClipboardWinClear();
    296296            }
    297297
    … …  
    303303            LogFunc(("WM_RENDERALLFORMATS\n"));
    304304
    305             int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd);
     305            int rc = SharedClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd);
    306306            AssertRC(rc);
    307307
    … …  
    309309        }
    310310
    311         case VBOX_CLIPBOARD_WM_REPORT_FORMATS:
     311        case SHCL_WIN_WM_REPORT_FORMATS:
    312312        {
    313313            LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n"));
    … …  
    317317            if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
    318318            {
    319                 int rc = VBoxClipboardWinOpen(hWnd);
     319                int rc = SharedClipboardWinOpen(hWnd);
    320320                if (RT_SUCCESS(rc))
    321321                {
    322                     VBoxClipboardWinClear();
    323 
    324                     rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
    325 
    326                     VBoxClipboardWinClose();
     322                    SharedClipboardWinClear();
     323
     324                    rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
     325
     326                    SharedClipboardWinClose();
    327327                }
    328328
    … …  
    337337            LogFunc(("WM_DESTROY\n"));
    338338
    339             int rc = VBoxClipboardWinHandleWMDestroy(pWinCtx);
     339            int rc = SharedClipboardWinHandleWMDestroy(pWinCtx);
    340340            AssertRC(rc);
    341341
    … …  
    416416    char szWndClassName[32];
    417417    RTStrPrintf2(szWndClassName, sizeof(szWndClassName),
    418                  "%s-%RU64", VBOX_CLIPBOARD_WNDCLASS_NAME, RTThreadGetNative(hThreadSelf));
     418                 "%s-%RU64", SHCL_WIN_WNDCLASS_NAME, RTThreadGetNative(hThreadSelf));
    419419    wc.lpszClassName = szWndClassName;
    420420
    … …  
    444444                         SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE);
    445445
    446             rc = VBoxClipboardWinChainAdd(&pCtx->Win);
     446            rc = SharedClipboardWinChainAdd(&pCtx->Win);
    447447            if (RT_SUCCESS(rc))
    448448            {
    449                 if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
     449                if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
    450450                    pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000, NULL);
    451451            }
    … …  
    530530        RT_ZERO(Formats);
    531531
    532         rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats);
     532        rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats);
    533533        if (   RT_SUCCESS(rc)
    534534            && Formats.uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE)
    535535        {
    536             rc = vboxSvcClipboardFormatsReport(pCtx->pClient, &Formats);
     536            rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats);
    537537        }
    538538    }
    … …  
    548548 */
    549549
    550 int VBoxClipboardSvcImplInit(void)
    551 {
    552     /* Initialization is done in VBoxClipboardSvcImplConnect(). */
     550int SharedClipboardSvcImplInit(void)
     551{
     552    /* Initialization is done in SharedClipboardSvcImplConnect(). */
    553553    return VINF_SUCCESS;
    554554}
    555555
    556 void VBoxClipboardSvcImplDestroy(void)
    557 {
    558     /* Destruction is done in VBoxClipboardSvcImplDisconnect(). */
    559 }
    560 
    561 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     556void SharedClipboardSvcImplDestroy(void)
     557{
     558    /* Destruction is done in SharedClipboardSvcImplDisconnect(). */
     559}
     560
     561int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    562562{
    563563    RT_NOREF(fHeadless);
    … …  
    571571    {
    572572        /* Check that new Clipboard API is available. */
    573         rc = VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
     573        rc = SharedClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
    574574        if (RT_SUCCESS(rc))
    575575        {
    … …  
    587587
    588588        /* Sync the host clipboard content with the client. */
    589         rc = VBoxClipboardSvcImplSync(pClient);
     589        rc = SharedClipboardSvcImplSync(pClient);
    590590    }
    591591    else
    … …  
    596596}
    597597
    598 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     598int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    599599{
    600600    /* Sync the host clipboard content with the client. */
    … …  
    602602}
    603603
    604 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     604int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    605605{
    606606    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    641641}
    642642
    643 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    644                                        PSHCLFORMATDATA pFormats)
     643int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     644                                         PSHCLFORMATDATA pFormats)
    645645{
    646646    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    658658    {
    659659        PSHCLURITRANSFER pTransfer;
    660         rc = vboxSvcClipboardURITransferStart(pClient,
    661                                               SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE,
    662                                               &pTransfer);
     660        rc = sharedClipboardSvcURITransferStart(pClient,
     661                                                SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE,
     662                                                &pTransfer);
    663663        if (RT_SUCCESS(rc))
    664664        {
    665665            /* Create the IDataObject implementation the host OS needs and assign
    666666             * the newly created transfer to this object. */
    667             rc = VBoxClipboardWinURITransferCreate(&pCtx->Win, pTransfer);
     667            rc = SharedClipboardWinURITransferCreate(&pCtx->Win, pTransfer);
    668668
    669669            /*  Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
    … …  
    678678         * The guest announced formats. Forward to the window thread.
    679679         */
    680         PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
     680        PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_REPORT_FORMATS,
    681681                    0 /* wParam */, pFormats->uFormats /* lParam */);
    682682
    … …  
    691691}
    692692
    693 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    694                                  PSHCLDATABLOCK pData, uint32_t *pcbActual)
     693int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     694                                   PSHCLDATABLOCK pData, uint32_t *pcbActual)
    695695{
    696696    AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
    … …  
    707707     * The guest wants to read data in the given format.
    708708     */
    709     int rc = VBoxClipboardWinOpen(pWinCtx->hWnd);
     709    int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
    710710    if (RT_SUCCESS(rc))
    711711    {
    … …  
    758758        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
    759759        {
    760             UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML);
     760            UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
    761761            if (format != 0)
    762762            {
    … …  
    789789        }
    790790#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    791         VBoxClipboardWinClose();
     791        SharedClipboardWinClose();
    792792    }
    793793
    … …  
    802802}
    803803
    804 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    805                                   PSHCLDATABLOCK pData)
     804int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     805                                    PSHCLDATABLOCK pData)
    806806{
    807807    LogFlowFuncEnter();
    808808
    809     int rc = vboxSvcClipboardDataReadSignal(pClient, pCmdCtx, pData);
     809    int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
    810810
    811811    LogFlowFuncLeaveRC(rc);
    … …  
    814814
    815815#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    816 int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     816int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    817817{
    818818    RT_NOREF(pClient, pTransfer);
    … …  
    823823}
    824824
    825 int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     825int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    826826{
    827827    LogFlowFuncEnter();
    828828
    829     VBoxClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer);
     829    SharedClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer);
    830830
    831831    return VINF_SUCCESS;

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

    r80662 r80664  
    6969 * after a save and restore of the guest.
    7070 */
    71 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     71int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    7272{
    7373    RT_NOREF(pClient);
    … …  
    8181 * @param   pClient         Structure containing context information about the guest system
    8282 */
    83 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     83int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    8484{
    8585    RT_NOREF(pClient);
    … …  
    9595 * @param pFormats              Clipboard formats the guest is offering.
    9696 */
    97 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     97int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    9898                                       PSHCLFORMATDATA pFormats)
    9999{
    … …  
    110110 * @param pcbActual     Where to store the actual amount of data available.
    111111 */
    112 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     112int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    113113                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    114114{
    … …  
    121121}
    122122
    123 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     123int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    124124                                  PSHCLDATABLOCK pData)
    125125{

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

    r80662 r80664  
    7272    formatData.uFormats = u32Formats;
    7373
    74     int rc2 = vboxSvcClipboardFormatsReport(pCtx->pClient, &formatData);
     74    int rc2 = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
    7575    AssertRC(rc2);
    7676}
    … …  
    8080 * @note  Host glue code
    8181 */
    82 int VBoxClipboardSvcImplInit(void)
     82int SharedClipboardSvcImplInit(void)
    8383{
    8484    LogFlowFuncEnter();
    … …  
    9090 * @note  host glue code
    9191 */
    92 void VBoxClipboardSvcImplDestroy(void)
     92void SharedClipboardSvcImplDestroy(void)
    9393{
    9494    LogFlowFuncEnter();
    … …  
    100100 *        the clipboard and leave ownership to X11.
    101101 */
    102 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     102int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    103103{
    104104    int rc = VINF_SUCCESS;
    … …  
    142142 * @note  Host glue code
    143143 */
    144 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     144int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    145145{
    146146    LogFlowFuncEnter();
    … …  
    154154    formatData.uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
    155155
    156     return vboxSvcClipboardFormatsReport(pClient, &formatData);
     156    return sharedClipboardSvcFormatsReport(pClient, &formatData);
    157157}
    158158
    … …  
    161161 * @note  Host glue code
    162162 */
    163 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     163int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    164164{
    165165    LogFlowFuncEnter();
    … …  
    174174    /* If there is a currently pending request, release it immediately. */
    175175    SHCLDATABLOCK dataBlock = { 0, NULL, 0 };
    176     VBoxClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
     176    SharedClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
    177177
    178178    int rc = ClipStopX11(pCtx->pBackend);
    … …  
    199199 * @param pFormats              Clipboard formats the guest is offering.
    200200 */
    201 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    202                                        PSHCLFORMATDATA pFormats)
     201int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     202                                         PSHCLFORMATDATA pFormats)
    203203{
    204204    RT_NOREF(pCmdCtx);
    … …  
    245245 *
    246246 */
    247 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient,
    248                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
     247int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient,
     248                                   PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
    249249{
    250250    RT_NOREF(pCmdCtx);
    … …  
    299299 * @param  pData                Data block to write to clipboard.
    300300 */
    301 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient,
    302                                   PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
     301int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
     302                                    PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    303303{
    304304    LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n",
    305305                 pClient, pData->pvData, pData->cbData, pData->uFormat));
    306306
    307     int rc = vboxSvcClipboardDataReadSignal(pClient, pCmdCtx, pData);
     307    int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
    308308
    309309    LogFlowFuncLeaveRC(rc);
    … …  
    368368
    369369    SHCLEVENTID uEvent;
    370     int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     370    int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    371371    if (RT_SUCCESS(rc))
    372372    {
    … …  
    390390
    391391#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    392 int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     392int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    393393{
    394394    RT_NOREF(pClient, pTransfer);
    … …  
    396396}
    397397
    398 int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     398int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    399399{
    400400    RT_NOREF(pClient, pTransfer);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

    r80662 r80664  
    224224*   Prototypes                                                                                                                   *
    225225*********************************************************************************************************************************/
    226 static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
    227 static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState);
    228 static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState);
     226static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
     227static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
     228static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
    229229
    230230
    … …  
    260260 * @param   puID                Where to store the created event source ID on success.
    261261 */
    262 int vboxSvcClipboardEventSourceCreateID(PSHCLEVENTSOURCEID puID)
     262int sharedClipboardSvcEventSourceCreateID(PSHCLEVENTSOURCEID puID)
    263263{
    264264    AssertPtrReturn(puID, VERR_INVALID_POINTER);
    … …  
    277277}
    278278
    279 uint32_t vboxSvcClipboardGetMode(void)
     279uint32_t sharedClipboardSvcGetMode(void)
    280280{
    281281    return g_uMode;
    … …  
    286286uint32_t TestClipSvcGetMode(void)
    287287{
    288     return vboxSvcClipboardGetMode();
     288    return sharedClipboardSvcGetMode();
    289289}
    290290#endif
    … …  
    296296}
    297297
    298 static int vboxSvcClipboardModeSet(uint32_t uMode)
     298static int sharedClipboardSvcModeSet(uint32_t uMode)
    299299{
    300300    int rc = VERR_NOT_SUPPORTED;
    … …  
    343343 * @param   pClient             Pointer to the client data structure to reset message queue for.
    344344 */
    345 void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient)
     345void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient)
    346346{
    347347    LogFlowFuncEnter();
    … …  
    361361 * @param   cParms              Number of HGCM parameters to allocate.
    362362 */
    363 PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms)
     363PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms)
    364364{
    365365    PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG));
    … …  
    386386 *                              The pointer will be invalid after calling this function.
    387387 */
    388 void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg)
     388void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg)
    389389{
    390390    if (!pMsg)
    … …  
    407407 * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
    408408 */
    409 void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     409void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
    410410{
    411411    Assert(cDstParms >= 2);
    … …  
    437437 * @param   cDstParms   The number of peek parameters (at least two).
    438438 */
    439 int vboxSvcClipboardMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     439int sharedClipboardSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
    440440{
    441441    AssertPtrReturn(pMsg,           VERR_INVALID_POINTER);
    … …  
    494494 * @param   fAppend             Whether to append or prepend the message to the queue.
    495495 */
    496 int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
     496int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
    497497{
    498498    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
    … …  
    527527 *                      immediately.
    528528 */
    529 int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    530                             bool fWait)
     529int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     530                              bool fWait)
    531531{
    532532    /*
    … …  
    574574        if (pFirstMsg)
    575575        {
    576             vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, paParms, cParms);
     576            sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
    577577            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
    578578                         pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),
    … …  
    616616 * @param   paParms     Array of parameters.
    617617 */
    618 int vboxSvcClipboardMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     618int sharedClipboardSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    619619{
    620620    int rc;
    … …  
    640640                         pFirstMsg->m_cParms));
    641641
    642             rc = vboxSvcClipboardMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
     642            rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
    643643            if (RT_SUCCESS(rc))
    644644            {
    … …  
    648648                {
    649649                    pClient->queueMsg.removeFirst();
    650                     vboxSvcClipboardMsgFree(pFirstMsg);
     650                    sharedClipboardSvcMsgFree(pFirstMsg);
    651651
    652652                    rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
    … …  
    692692 * @param   paParms      Array of parameters.
    693693 */
    694 int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     694int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    695695{
    696696    /*
    … …  
    782782                {
    783783                    pClient->queueMsg.removeFirst();
    784                     vboxSvcClipboardMsgFree(pFirstMsg);
     784                    sharedClipboardSvcMsgFree(pFirstMsg);
    785785                }
    786786
    … …  
    807807 * @param   pClient             Client to wake up.
    808808 */
    809 int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient)
     809int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient)
    810810{
    811811    int rc = VINF_NO_CHANGE;
    … …  
    830830                if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)
    831831                {
    832                     vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     832                    sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
    833833                    fDonePending = true;
    834834                }
    835835                else if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
    836836                {
    837                     rc = vboxSvcClipboardMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     837                    rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
    838838                    if (RT_SUCCESS(rc))
    839839                    {
    … …  
    841841                         * remove the actual message from our queue right now. */
    842842                        pClient->queueMsg.removeFirst();
    843                         vboxSvcClipboardMsgFree(pFirstMsg);
     843                        sharedClipboardSvcMsgFree(pFirstMsg);
    844844
    845845                        fDonePending = true;
    … …  
    879879 * @param   puEvent             Event ID for waiting for new data. Optional.
    880880 */
    881 int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
    882                                     PSHCLEVENTID puEvent)
     881int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
     882                                      PSHCLEVENTID puEvent)
    883883{
    884884    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    888888    int rc;
    889889
    890     PSHCLCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    891                                                                     VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
     890    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     891                                                             VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
    892892    if (pMsgReadData)
    893893    {
    … …  
    898898        HGCMSvcSetU32(&pMsgReadData->m_paParms[2], pClient->State.cbChunkSize);
    899899
    900         rc = vboxSvcClipboardMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     900        rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
    901901        if (RT_SUCCESS(rc))
    902902        {
    … …  
    904904            if (RT_SUCCESS(rc))
    905905            {
    906                 rc = vboxSvcClipboardClientWakeup(pClient);
     906                rc = sharedClipboardSvcClientWakeup(pClient);
    907907                if (RT_SUCCESS(rc))
    908908                {
    … …  
    922922}
    923923
    924 int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    925                                    PSHCLDATABLOCK pData)
     924int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     925                                     PSHCLDATABLOCK pData)
    926926{
    927927    SHCLEVENTID uEvent;
    … …  
    952952}
    953953
    954 int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
     954int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
    955955{
    956956    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    959959    int rc;
    960960
    961     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
     961    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
    962962    if (pMsg)
    963963    {
    … …  
    968968        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
    969969
    970         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     970        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    971971        if (RT_SUCCESS(rc))
    972             rc = vboxSvcClipboardClientWakeup(pClient);
     972            rc = sharedClipboardSvcClientWakeup(pClient);
    973973    }
    974974    else
    … …  
    979979}
    980980
    981 int vboxSvcClipboardGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     981int sharedClipboardSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    982982{
    983983    LogFlowFuncEnter();
    984984
    985     if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
    986         && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     985    if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
     986        && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    987987    {
    988988        return VERR_NOT_SUPPORTED;
    … …  
    10541054        }
    10551055
    1056         rc = VBoxClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
     1056        rc = SharedClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
    10571057    }
    10581058
    … …  
    10611061}
    10621062
    1063 int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
     1063int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
    10641064{
    10651065    if (!pClient) /* If no client connected (anymore), bail out. */
    … …  
    10821082
    10831083#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1084 int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient,
     1084int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient,
    10851085                                     SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
    10861086                                     PSHCLURITRANSFER *ppTransfer)
    … …  
    11031103            if (enmDir == SHCLURITRANSFERDIR_READ)
    11041104            {
    1105                 rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
     1105                rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer);
    11061106                if (RT_SUCCESS(rc))
    11071107                {
    11081108                    creationCtx.enmSource = pClient->State.enmSource;
    11091109
    1110                     creationCtx.Interface.pfnTransferOpen    = vboxSvcClipboardURITransferOpen;
    1111                     creationCtx.Interface.pfnTransferClose   = vboxSvcClipboardURITransferClose;
    1112                     creationCtx.Interface.pfnListOpen        = vboxSvcClipboardURIListOpen;
    1113                     creationCtx.Interface.pfnListClose       = vboxSvcClipboardURIListClose;
    1114                     creationCtx.Interface.pfnObjOpen         = vboxSvcClipboardURIObjOpen;
    1115                     creationCtx.Interface.pfnObjClose        = vboxSvcClipboardURIObjClose;
    1116 
    1117                     creationCtx.Interface.pfnGetRoots        = vboxSvcClipboardURIGetRoots;
    1118                     creationCtx.Interface.pfnListHdrRead     = vboxSvcClipboardURIListHdrRead;
    1119                     creationCtx.Interface.pfnListEntryRead   = vboxSvcClipboardURIListEntryRead;
    1120                     creationCtx.Interface.pfnObjRead         = vboxSvcClipboardURIObjRead;
     1110                    creationCtx.Interface.pfnTransferOpen    = sharedClipboardSvcURITransferOpen;
     1111                    creationCtx.Interface.pfnTransferClose   = sharedClipboardSvcURITransferClose;
     1112                    creationCtx.Interface.pfnListOpen        = sharedClipboardSvcURIListOpen;
     1113                    creationCtx.Interface.pfnListClose       = sharedClipboardSvcURIListClose;
     1114                    creationCtx.Interface.pfnObjOpen         = sharedClipboardSvcURIObjOpen;
     1115                    creationCtx.Interface.pfnObjClose        = sharedClipboardSvcURIObjClose;
     1116
     1117                    creationCtx.Interface.pfnGetRoots        = sharedClipboardSvcURIGetRoots;
     1118                    creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcURIListHdrRead;
     1119                    creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcURIListEntryRead;
     1120                    creationCtx.Interface.pfnObjRead         = sharedClipboardSvcURIObjRead;
    11211121
    11221122                    creationCtx.pvUser = pClient;
    … …  
    11461146                rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer);
    11471147                if (RT_SUCCESS(rc))
    1148                     rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1148                    rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
    11491149
    11501150                if (RT_FAILURE(rc))
    1151                     VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1151                    SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    11521152            }
    11531153
    … …  
    11771177    if (RT_SUCCESS(rc))
    11781178    {
    1179         vboxSvcClipboardModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
    1180 
    1181         rc = VBoxClipboardSvcImplInit();
     1179        sharedClipboardSvcModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
     1180
     1181        rc = SharedClipboardSvcImplInit();
    11821182
    11831183        /* Clean up on failure, because 'svnUnload' will not be called
    … …  
    11971197    LogFlowFuncEnter();
    11981198
    1199     VBoxClipboardSvcImplDestroy();
     1199    SharedClipboardSvcImplDestroy();
    12001200
    12011201    RTCritSectDelete(&g_CritSect);
    … …  
    12161216    PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/);
    12171217    if (pTransfer)
    1218         vboxSvcClipboardURIAreaDetach(&pClient->State, pTransfer);
     1218        sharedClipboardSvcURIAreaDetach(&pClient->State, pTransfer);
    12191219
    12201220    SharedClipboardURICtxDestroy(&pClient->URI);
    12211221#endif
    12221222
    1223     VBoxClipboardSvcImplDisconnect(pClient);
    1224 
    1225     vboxSvcClipboardClientStateReset(&pClient->State);
    1226     vboxSvcClipboardClientStateDestroy(&pClient->State);
     1223    SharedClipboardSvcImplDisconnect(pClient);
     1224
     1225    sharedClipboardSvcClientStateReset(&pClient->State);
     1226    sharedClipboardSvcClientStateDestroy(&pClient->State);
    12271227
    12281228    SharedClipboardEventSourceDestroy(&pClient->Events);
    … …  
    12511251    /* Create the client's own event source. */
    12521252    SHCLEVENTSOURCEID uEventSourceID;
    1253     int rc = vboxSvcClipboardEventSourceCreateID(&uEventSourceID);
     1253    int rc = sharedClipboardSvcEventSourceCreateID(&uEventSourceID);
    12541254    if (RT_SUCCESS(rc))
    12551255        rc = SharedClipboardEventSourceCreate(&pClient->Events, uEventSourceID);
    … …  
    12591259
    12601260        /* Reset the client state. */
    1261         vboxSvcClipboardClientStateReset(&pClient->State);
     1261        sharedClipboardSvcClientStateReset(&pClient->State);
    12621262
    12631263        /* (Re-)initialize the client state. */
    1264         rc = vboxSvcClipboardClientStateInit(&pClient->State, u32ClientID);
     1264        rc = sharedClipboardSvcClientStateInit(&pClient->State, u32ClientID);
    12651265        if (RT_SUCCESS(rc))
    12661266        {
    1267             rc = VBoxClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
     1267            rc = SharedClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
    12681268#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    12691269            if (RT_SUCCESS(rc))
    … …  
    13241324        case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD:
    13251325        {
    1326             rc = vboxSvcClipboardMsgGetOld(pClient, callHandle, cParms, paParms);
     1326            rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms);
    13271327            if (rc == VINF_HGCM_ASYNC_EXECUTE)
    13281328                fDoCallComplete = false;
    … …  
    13441344                rc = VERR_INVALID_PARAMETER;
    13451345            }
    1346             else if (vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
     1346            else if (sharedClipboardSvcGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
    13471347            {
    13481348                rc = VERR_ACCESS_DENIED;
    … …  
    13691369        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
    13701370        {
    1371             rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
     1371            rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
    13721372            break;
    13731373        }
    … …  
    13751375        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
    13761376        {
    1377             rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
     1377            rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
    13781378            if (rc == VINF_HGCM_ASYNC_EXECUTE)
    13791379                fDoCallComplete = false;
    … …  
    13831383        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
    13841384        {
    1385             rc = vboxSvcClipboardMsgGet(pClient, callHandle, cParms, paParms);
     1385            rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
    13861386            if (rc == VINF_HGCM_ASYNC_EXECUTE)
    13871387                fDoCallComplete = false;
    … …  
    14301430            if (RT_SUCCESS(rc))
    14311431            {
    1432                 if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
    1433                     && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     1432                if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
     1433                    && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    14341434                {
    14351435                    rc = VERR_ACCESS_DENIED;
    … …  
    14371437                else
    14381438                {
    1439                     rc = vboxSvcClipboardSetSource(pClient, SHCLSOURCE_REMOTE);
     1439                    rc = sharedClipboardSvcSetSource(pClient, SHCLSOURCE_REMOTE);
    14401440                    if (RT_SUCCESS(rc))
    14411441                    {
    … …  
    14581458                        formatData.uFormats = uFormats;
    14591459
    1460                         rc = VBoxClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
     1460                        rc = SharedClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
    14611461                    }
    14621462                }
    … …  
    14811481            else
    14821482            {
    1483                 if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
    1484                     && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     1483                if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
     1484                    && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    14851485                {
    14861486                    rc = VERR_ACCESS_DENIED;
    … …  
    15061506                            {
    15071507                                /* Attach to the most recent clipboard area. */
    1508                                 rc = vboxSvcClipboardURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */);
     1508                                rc = sharedClipboardSvcURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */);
    15091509                                if (RT_SUCCESS(rc))
    15101510                                {
    … …  
    15161516                                    RT_ZERO(creationCtx.Interface);
    15171517
    1518                                     creationCtx.Interface.pfnListHdrWrite    = vboxSvcClipboardURIListHdrWrite;
    1519                                     creationCtx.Interface.pfnListEntryWrite  = vboxSvcClipboardURIListEntryWrite;
    1520                                     creationCtx.Interface.pfnObjWrite        = vboxSvcClipboardURIObjWrite;
     1518                                    creationCtx.Interface.pfnListHdrWrite    = sharedClipboardSvcURIListHdrWrite;
     1519                                    creationCtx.Interface.pfnListEntryWrite  = sharedClipboardSvcURIListEntryWrite;
     1520                                    creationCtx.Interface.pfnObjWrite        = sharedClipboardSvcURIObjWrite;
    15211521
    15221522                                    creationCtx.pvUser = pClient;
    … …  
    15291529                                if (RT_SUCCESS(rc))
    15301530                                {
    1531                                     rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1531                                    rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
    15321532                                }
    15331533                                else
    15341534                                {
    1535                                     VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1535                                    SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    15361536                                    SharedClipboardURITransferDestroy(pTransfer);
    15371537                                }
    … …  
    15821582                                    formatData.uFormats = g_ExtState.uDelayedFormats;
    15831583
    1584                                     int rc2 = vboxSvcClipboardFormatsReport(pClient, &formatData);
     1584                                    int rc2 = sharedClipboardSvcFormatsReport(pClient, &formatData);
    15851585                                    AssertRC(rc2);
    15861586
    … …  
    16141614                                dataBlock.uFormat = uFormat;
    16151615
    1616                                 rc = VBoxClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
     1616                                rc = SharedClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
    16171617                                if (RT_SUCCESS(rc))
    16181618                                    HGCMSvcSetU32(&paParms[2], cbActual);
    … …  
    16301630        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE:
    16311631        {
    1632             rc = vboxSvcClipboardGetDataWrite(pClient, cParms, paParms);
     1632            rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
    16331633            break;
    16341634        }
    … …  
    16371637        {
    16381638#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1639             rc = vboxSvcClipboardURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
     1639            rc = sharedClipboardSvcURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
    16401640#else
    16411641            rc = VERR_NOT_IMPLEMENTED;
    … …  
    16601660 * @param   uClientID           Client ID (HGCM) to use for this client state.
    16611661 */
    1662 static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
     1662static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
    16631663{
    16641664    LogFlowFuncEnter();
    16651665
    1666     vboxSvcClipboardClientStateReset(pClientState);
     1666    sharedClipboardSvcClientStateReset(pClientState);
    16671667
    16681668    /* Register the client.
    … …  
    16801680 * @param   pClientState        Client state to destroy.
    16811681 */
    1682 static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState)
     1682static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
    16831683{
    16841684    RT_NOREF(pClientState);
    … …  
    16941694 * @param   pClientState    Client state to reset.
    16951695 */
    1696 static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState)
     1696static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
    16971697{
    16981698    LogFlowFuncEnter();
    … …  
    17321732                rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
    17331733                if (RT_SUCCESS(rc))
    1734                     rc = vboxSvcClipboardModeSet(u32Mode);
     1734                    rc = sharedClipboardSvcModeSet(u32Mode);
    17351735            }
    17361736
    … …  
    17601760        {
    17611761#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1762             rc = vboxSvcClipboardURIHostHandler(u32Function, cParms, paParms);
     1762            rc = sharedClipboardSvcURIHostHandler(u32Function, cParms, paParms);
    17631763#else
    17641764            rc = VERR_NOT_IMPLEMENTED;
    … …  
    18091809static SSMFIELD const s_aShClSSMClientMsgCtx[] =
    18101810{
    1811     SSMFIELD_ENTRY(VBOXSHCLMSGCTX, uContextID),
     1811    SSMFIELD_ENTRY(SHCLMSGCTX, uContextID),
    18121812    SSMFIELD_ENTRY_TERM()
    18131813};
    … …  
    18511851        AssertRCReturn(rc, rc);
    18521852
    1853         rc = SSMR3PutStructEx(pSSM, &pMsg->m_Ctx, sizeof(VBOXSHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
     1853        rc = SSMR3PutStructEx(pSSM, &pMsg->m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
    18541854        AssertRCReturn(rc, rc);
    18551855
    … …  
    19411941            AssertRCReturn(rc, rc);
    19421942
    1943             rc = SSMR3GetStructEx(pSSM, &pMsg->m_Ctx, sizeof(VBOXSHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
     1943            rc = SSMR3GetStructEx(pSSM, &pMsg->m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
    19441944            AssertRCReturn(rc, rc);
    19451945
    … …  
    19531953            }
    19541954
    1955             rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     1955            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    19561956            AssertRCReturn(rc, rc);
    19571957        }
    … …  
    19641964
    19651965    /* Actual host data are to be reported to guest (SYNC). */
    1966     VBoxClipboardSvcImplSync(pClient);
     1966    SharedClipboardSvcImplSync(pClient);
    19671967
    19681968#else  /* UNIT_TEST */
    … …  
    20052005                    formatData.uFormats = u32Format;
    20062006
    2007                     rc = vboxSvcClipboardFormatsReport(pClient, &formatData);
     2007                    rc = sharedClipboardSvcFormatsReport(pClient, &formatData);
    20082008                }
    20092009
    … …  
    20202020                dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    20212021
    2022                 rc = vboxSvcClipboardDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
     2022                rc = sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
    20232023                break;
    20242024            }

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

    r80662 r80664  
    123123                  2, parms, 0);
    124124    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    125     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    126                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     125    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     126                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    127127    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    128128    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    … …  
    135135    RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls.");
    136136    RT_ZERO(g_Client.State);
    137     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    138                               VBOX_SHARED_CLIPBOARD_FMT_HTML);
     137    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     138                                   VBOX_SHARED_CLIPBOARD_FMT_HTML);
    139139    HGCMSvcSetU32(&parms[0], 0);
    140140    HGCMSvcSetU32(&parms[1], 0);
    … …  
    158158                  2, parms, 0);
    159159    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    160     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    161                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
     160    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     161                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    162162    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    163163    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    … …  
    176176    RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls.");
    177177    RT_ZERO(g_Client.State);
    178     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    179                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
     178    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     179                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    180180    HGCMSvcSetU32(&parms[0], 0);
    181181    HGCMSvcSetU32(&parms[1], 0);
    … …  
    277277}
    278278
    279 int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; }
    280 void VBoxClipboardSvcImplDestroy() { }
    281 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT)
     279int SharedClipboardSvcImplInit() { return VINF_SUCCESS; }
     280void SharedClipboardSvcImplDestroy() { }
     281int SharedClipboardSvcImplDisconnect(PSHCLCLIENT)
    282282{ return VINF_SUCCESS; }
    283 int VBoxClipboardSvcImplConnect(PSHCLCLIENT, bool)
     283int SharedClipboardSvcImplConnect(PSHCLCLIENT, bool)
    284284{ return VINF_SUCCESS; }
    285 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA)
     285int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA)
    286286{ AssertFailed(); return VINF_SUCCESS; }
    287 int VBoxClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *)
     287int SharedClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *)
    288288{ AssertFailed(); return VERR_WRONG_ORDER; }
    289 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK)
     289int SharedClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK)
    290290{ AssertFailed(); return VINF_SUCCESS; }
    291 int VBoxClipboardSvcImplSync(PSHCLCLIENT)
     291int SharedClipboardSvcImplSync(PSHCLCLIENT)
    292292{ AssertFailed(); return VERR_WRONG_ORDER; }
    293293
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette