VirtualBox

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


Ignore:
Timestamp:
Sep 9, 2019 8:43:14 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133193
Message:

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

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

Legend:

Unmodified
Added
Removed

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

    r80623 r80662  
    3535*********************************************************************************************************************************/
    3636/** Global clipboard context information */
    37 struct _VBOXCLIPBOARDCONTEXT
     37struct _SHCLCONTEXT
    3838{
    3939    /** We have a separate thread to poll for new clipboard content */
    … …  
    4242    /** The reference to the current pasteboard */
    4343    PasteboardRef           pasteboard;
    44     PVBOXCLIPBOARDCLIENT    pClient;
     44    PSHCLCLIENT    pClient;
    4545};
    4646
    … …  
    5050*********************************************************************************************************************************/
    5151/** Only one client is supported. There seems to be no need for more clients. */
    52 static VBOXCLIPBOARDCONTEXT g_ctx;
     52static SHCLCONTEXT g_ctx;
    5353
    5454
    … …  
    5959 * @param   pCtx    The context.
    6060 */
    61 static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx)
     61static int vboxClipboardChanged(SHCLCONTEXT *pCtx)
    6262{
    6363    if (pCtx->pClient == NULL)
    … …  
    7171        && fChanged)
    7272    {
    73         SHAREDCLIPBOARDFORMATDATA formatData;
     73        SHCLFORMATDATA formatData;
    7474        RT_ZERO(formatData);
    7575
    … …  
    9090 * @returns VINF_SUCCESS (not used).
    9191 * @param   ThreadSelf  Our thread handle.
    92  * @param   pvUser      Pointer to the VBOXCLIPBOARDCONTEXT structure.
     92 * @param   pvUser      Pointer to the SHCLCONTEXT structure.
    9393 *
    9494 */
    … …  
    9898
    9999    AssertPtrReturn(pvUser, VERR_INVALID_PARAMETER);
    100     VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)pvUser;
     100    SHCLCONTEXT *pCtx = (SHCLCONTEXT *)pvUser;
    101101
    102102    while (!pCtx->fTerminate)
    … …  
    156156}
    157157
    158 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
     158int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    159159{
    160160    RT_NOREF(fHeadless);
    … …  
    178178}
    179179
    180 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
     180int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
    181181{
    182182    /* Sync the host clipboard content with the client. */
    … …  
    190190}
    191191
    192 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
     192int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    193193{
    194194    VBoxSvcClipboardLock();
    … …  
    201201}
    202202
    203 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient,
    204                                        PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats)
     203int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
     204                                       PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
    205205{
    206206    RT_NOREF(pCmdCtx);
    … …  
    219219#endif
    220220
    221     SHAREDCLIPBOARDDATAREQ dataReq;
     221    SHCLDATAREQ dataReq;
    222222    RT_ZERO(dataReq);
    223223
    … …  
    236236 * @param pcbActual             Where to write the actual size of the written data.
    237237 */
    238 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    239                                  PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
     238int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     239                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    240240{
    241241    RT_NOREF(pCmdCtx);
    … …  
    262262 * @param pData                 Data block to write to clipboard.
    263263 */
    264 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient,
    265                                   PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData)
     264int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient,
     265                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    266266{
    267267    RT_NOREF(pCmdCtx);
    … …  
    277277
    278278#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    279 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
     279int VBoxClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    280280{
    281281    RT_NOREF(pClient, pDirData);
    … …  
    283283}
    284284
    285 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData)
     285int VBoxClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    286286{
    287287    RT_NOREF(pClient, pDirData);
    … …  
    289289}
    290290
    291 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
     291int VBoxClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    292292{
    293293    RT_NOREF(pClient, pFileHdr);
    … …  
    295295}
    296296
    297 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr)
     297int VBoxClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    298298{
    299299    RT_NOREF(pClient, pFileHdr);
    … …  
    301301}
    302302
    303 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
     303int VBoxClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    304304{
    305305    RT_NOREF(pClient, pFileData);
    … …  
    307307}
    308308
    309 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData)
     309int VBoxClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    310310{
    311311    RT_NOREF(pClient, pFileData);

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

    r80638 r80662  
    4040
    4141#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    42 struct VBOXCLIPBOARDCLIENTSTATE;
     42struct SHCLCLIENTSTATE;
    4343#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    4444
    … …  
    5555 * Structure for keeping a single HGCM message.
    5656 */
    57 typedef struct _VBOXCLIPBOARDCLIENTMSG
     57typedef struct _SHCLCLIENTMSG
    5858{
    5959    /** Stored message type. */
    … …  
    6565    /** Message context. */
    6666    VBOXSHCLMSGCTX   m_Ctx;
    67 } VBOXCLIPBOARDCLIENTMSG, *PVBOXCLIPBOARDCLIENTMSG;
    68 
    69 typedef struct VBOXCLIPBOARDCLIENTURISTATE
     67} SHCLCLIENTMSG, *PSHCLCLIENTMSG;
     68
     69typedef struct SHCLCLIENTURISTATE
    7070{
    7171    /** Directory of the transfer to start. */
    72     SHAREDCLIPBOARDURITRANSFERDIR enmTransferDir;
    73 } VBOXCLIPBOARDCLIENTURISTATE, *PVBOXCLIPBOARDCLIENTURISTATE;
     72    SHCLURITRANSFERDIR enmTransferDir;
     73} SHCLCLIENTURISTATE, *PSHCLCLIENTURISTATE;
    7474
    7575/**
    … …  
    7777 * This structure needs to be serializable by SSM (must be a POD type).
    7878 */
    79 typedef struct VBOXCLIPBOARDCLIENTSTATE
    80 {
    81     struct VBOXCLIPBOARDCLIENTSTATE *pNext;
    82     struct VBOXCLIPBOARDCLIENTSTATE *pPrev;
    83 
    84     VBOXCLIPBOARDCONTEXT            *pCtx;
     79typedef struct SHCLCLIENTSTATE
     80{
     81    struct SHCLCLIENTSTATE *pNext;
     82    struct SHCLCLIENTSTATE *pPrev;
     83
     84    SHCLCONTEXT            *pCtx;
    8585
    8686    /** The client's HGCM ID. */
    … …  
    9090    /** Maximum chunk size to use for data transfers. Set to _64K by default. */
    9191    uint32_t                         cbChunkSize;
    92     SHAREDCLIPBOARDSOURCE            enmSource;
     92    SHCLSOURCE            enmSource;
    9393    /** The client's URI state. */
    94     VBOXCLIPBOARDCLIENTURISTATE      URI;
    95 } VBOXCLIPBOARDCLIENTSTATE, *PVBOXCLIPBOARDCLIENTSTATE;
    96 
    97 typedef struct _VBOXCLIPBOARDCLIENTCMDCTX
     94    SHCLCLIENTURISTATE      URI;
     95} SHCLCLIENTSTATE, *PSHCLCLIENTSTATE;
     96
     97typedef struct _SHCLCLIENTCMDCTX
    9898{
    9999    uint32_t                          uContextID;
    100 } VBOXCLIPBOARDCLIENTCMDCTX, *PVBOXCLIPBOARDCLIENTCMDCTX;
    101 
    102 typedef struct _VBOXCLIPBOARDCLIENT
     100} SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX;
     101
     102typedef struct _SHCLCLIENT
    103103{
    104104    /** The client's HGCM client ID. */
    105105    uint32_t                          uClientID;
    106106    /** General client state data. */
    107     VBOXCLIPBOARDCLIENTSTATE          State;
     107    SHCLCLIENTSTATE          State;
    108108    /** The client's message queue (FIFO). */
    109     RTCList<VBOXCLIPBOARDCLIENTMSG *> queueMsg;
     109    RTCList<SHCLCLIENTMSG *> queueMsg;
    110110    /** The client's own event source. */
    111     SHAREDCLIPBOARDEVENTSOURCE        Events;
     111    SHCLEVENTSOURCE        Events;
    112112#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    113113    /** URI context data. */
    114     SHAREDCLIPBOARDURICTX             URI;
     114    SHCLURICTX             URI;
    115115#endif
    116116    /** Structure for keeping the client's pending (deferred return) state.
    … …  
    130130        PVBOXHGCMSVCPARM   paParms;
    131131    } Pending;
    132 } VBOXCLIPBOARDCLIENT, *PVBOXCLIPBOARDCLIENT;
     132} SHCLCLIENT, *PSHCLCLIENT;
    133133
    134134/**
    … …  
    136136 * Currently empty.
    137137 */
    138 typedef struct _VBOXCLIPBOARDEVENTSOURCEMAPENTRY
    139 {
    140 } VBOXCLIPBOARDEVENTSOURCEMAPENTRY;
     138typedef struct _SHCLEVENTSOURCEMAPENTRY
     139{
     140} SHCLEVENTSOURCEMAPENTRY;
    141141
    142142/** Map holding information about connected HGCM clients. Key is the (unique) HGCM client ID.
    143  *  The value is a weak pointer to PVBOXCLIPBOARDCLIENT, which is owned by HGCM. */
    144 typedef std::map<uint32_t, PVBOXCLIPBOARDCLIENT> ClipboardClientMap;
     143 *  The value is a weak pointer to PSHCLCLIENT, which is owned by HGCM. */
     144typedef std::map<uint32_t, PSHCLCLIENT> ClipboardClientMap;
    145145
    146146/** Map holding information about event sources. Key is the (unique) event source ID. */
    147 typedef std::map<VBOXCLIPBOARDEVENTSOURCEID, VBOXCLIPBOARDEVENTSOURCEMAPENTRY> ClipboardEventSourceMap;
     147typedef std::map<SHCLEVENTSOURCEID, SHCLEVENTSOURCEMAPENTRY> ClipboardEventSourceMap;
    148148
    149149/** Simple queue (list) which holds deferred (waiting) clients. */
    … …  
    156156 * to communicate with the Shared Clipboard host service.
    157157 */
    158 typedef struct _VBOXCLIPBOARDEXTSTATE
     158typedef struct _SHCLEXTSTATE
    159159{
    160160    /** Pointer to the actual service extension handle. */
    … …  
    173173     *  is reading clipboard data from the extension. */
    174174    uint32_t       uDelayedFormats;
    175 } VBOXCLIPBOARDEXTSTATE, *PVBOXCLIPBOARDEXTSTATE;
     175} SHCLEXTSTATE, *PSHCLEXTSTATE;
    176176
    177177/*
    178178 * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
    179179 */
    180 int vboxSvcClipboardDataReadRequest(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDDATAREQ pDataReq, PVBOXCLIPBOARDEVENTID puEvent);
    181 int vboxSvcClipboardDataReadSignal(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData);
    182 int vboxSvcClipboardFormatsReport(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDFORMATDATA pFormats);
     180int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
     181int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     182int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
    183183
    184184uint32_t vboxSvcClipboardGetMode(void);
    185 int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENT pClient, SHAREDCLIPBOARDSOURCE enmSource);
    186 
    187 void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENT pClient);
    188 PVBOXCLIPBOARDCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms);
    189 void vboxSvcClipboardMsgFree(PVBOXCLIPBOARDCLIENTMSG pMsg);
    190 void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
    191 int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend);
    192 int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
    193 int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    194 
    195 int vboxSvcClipboardClientWakeup(PVBOXCLIPBOARDCLIENT pClient);
     185int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
     186
     187void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient);
     188PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms);
     189void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg);
     190void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
     191int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
     192int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
     193int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     194
     195int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient);
    196196
    197197# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    198 int vboxSvcClipboardURITransferStart(PVBOXCLIPBOARDCLIENT pClient,
    199                                      SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
    200                                      PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
     198int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient,
     199                                     SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
     200                                     PSHCLURITRANSFER *ppTransfer);
    201201bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
    202202# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    … …  
    208208void VBoxClipboardSvcImplDestroy(void);
    209209
    210 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless);
    211 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient);
    212 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats);
     210int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
     211int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
     212int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
    213213/** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/
    214 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual);
    215 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData);
     214int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
     215int VBoxClipboardSvcImplWriteData(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(PVBOXCLIPBOARDCLIENT pClient);
     220int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient);
    221221
    222222#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    223 int vboxSvcClipboardURITransferOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx);
    224 DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx);
    225 
    226 int vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList);
    227 
    228 int vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    229                                 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList);
    230 int vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList);
    231 int vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    232                                    PVBOXCLIPBOARDLISTHDR pListHdr);
    233 int vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    234                                     PVBOXCLIPBOARDLISTHDR pListHdr);
    235 int vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    236                                      PVBOXCLIPBOARDLISTENTRY pListEntry);
    237 int vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,
    238                                       PVBOXCLIPBOARDLISTENTRY pListEntry);
    239 
    240 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
    241                                PSHAREDCLIPBOARDOBJHANDLE phObj);
    242 int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj);
    243 int vboxSvcClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
     223int vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx);
     224DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx);
     225
     226int vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
     227
     228int vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx,
     229                                PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
     230int vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
     231int vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     232                                   PSHCLLISTHDR pListHdr);
     233int vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     234                                    PSHCLLISTHDR pListHdr);
     235int vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     236                                     PSHCLLISTENTRY pListEntry);
     237int vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     238                                      PSHCLLISTENTRY pListEntry);
     239
     240int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     241                               PSHCLOBJHANDLE phObj);
     242int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
     243int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    244244                               void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    245 int vboxSvcClipboardURIObjWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
     245int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    246246                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    247247
    248 DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    249 DECLCALLBACK(void) VBoxSvcClipboardURIDataHeaderCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    250 DECLCALLBACK(void) VBoxSvcClipboardURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    251 DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    252 DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    253 DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    254 
    255 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    256 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     248DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHCLURITRANSFERCALLBACKDATA pData);
     249DECLCALLBACK(void) VBoxSvcClipboardURIDataHeaderCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData);
     250DECLCALLBACK(void) VBoxSvcClipboardURIDataCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData);
     251DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc);
     252DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHCLURITRANSFERCALLBACKDATA pData);
     253DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc);
     254
     255int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
     256int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
    257257#endif /*VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    258258

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

    r80557 r80662  
    4040*   Externals                                                                                                                    *
    4141*********************************************************************************************************************************/
    42 extern VBOXCLIPBOARDEXTSTATE g_ExtState;
     42extern SHCLEXTSTATE g_ExtState;
    4343extern PVBOXHGCMSVCHELPERS g_pHelpers;
    4444extern ClipboardClientQueue g_listClientsDeferred;
    … …  
    4949*********************************************************************************************************************************/
    5050static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    51                                           PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);
     51                                          PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
    5252static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    53                                            PVBOXSHCLMSGCTX pMsgCtx, SHAREDCLIPBOARDLISTHANDLE hList);
     53                                           PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
    5454
    5555
    … …  
    5858*********************************************************************************************************************************/
    5959
    60 DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx)
     60DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx)
    6161{
    6262    RT_NOREF(pCtx);
    … …  
    6666}
    6767
    68 DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx)
     68DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx)
    6969{
    7070    RT_NOREF(pCtx);
    … …  
    7474}
    7575
    76 DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList)
     76DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    7777{
    7878    LogFlowFuncEnter();
    7979
    80     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     80    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    8181    AssertPtr(pClient);
    8282
    8383    int rc;
    8484
    85     PVBOXCLIPBOARDCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
     85    PSHCLCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
    8686                                                               VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
    8787    if (pMsgHdr)
    8888    {
    89         VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     89        SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    9090
    9191        HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    101101            if (RT_SUCCESS(rc))
    102102            {
    103                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayloadHdr;
     103                PSHCLEVENTPAYLOAD pPayloadHdr;
    104104                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    105105                                              pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
    106106                if (RT_SUCCESS(rc))
    107107                {
    108                     PVBOXCLIPBOARDROOTLISTHDR pSrcRootListHdr = (PVBOXCLIPBOARDROOTLISTHDR)pPayloadHdr->pvData;
    109                     Assert(pPayloadHdr->cbData == sizeof(VBOXCLIPBOARDROOTLISTHDR));
     108                    PSHCLROOTLISTHDR pSrcRootListHdr = (PSHCLROOTLISTHDR)pPayloadHdr->pvData;
     109                    Assert(pPayloadHdr->cbData == sizeof(SHCLROOTLISTHDR));
    110110
    111111                    LogFlowFunc(("cRoots=%RU32, fRoots=0x%x\n", pSrcRootListHdr->cRoots, pSrcRootListHdr->fRoots));
    112112
    113                     PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc();
     113                    PSHCLROOTLIST pRootList = SharedClipboardURIRootListAlloc();
    114114                    if (pRootList)
    115115                    {
    … …  
    117117                        {
    118118                            pRootList->paEntries =
    119                                 (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(pSrcRootListHdr->cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY));
     119                                (PSHCLROOTLISTENTRY)RTMemAllocZ(pSrcRootListHdr->cRoots * sizeof(SHCLROOTLISTENTRY));
    120120
    121121                            if (pRootList->paEntries)
    … …  
    123123                                for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
    124124                                {
    125                                     PVBOXCLIPBOARDCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
     125                                    PSHCLCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
    126126                                                                                                 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    127127
    … …  
    140140                                        break;
    141141
    142                                     PSHAREDCLIPBOARDEVENTPAYLOAD pPayloadEntry;
     142                                    PSHCLEVENTPAYLOAD pPayloadEntry;
    143143                                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    144144                                                                  pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
    … …  
    146146                                        break;
    147147
    148                                     PVBOXCLIPBOARDROOTLISTENTRY pSrcRootListEntry = (PVBOXCLIPBOARDROOTLISTENTRY)pPayloadEntry->pvData;
    149                                     Assert(pPayloadEntry->cbData == sizeof(VBOXCLIPBOARDROOTLISTENTRY));
     148                                    PSHCLROOTLISTENTRY pSrcRootListEntry = (PSHCLROOTLISTENTRY)pPayloadEntry->pvData;
     149                                    Assert(pPayloadEntry->cbData == sizeof(SHCLROOTLISTENTRY));
    150150
    151151                                    rc = SharedClipboardURIListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
    … …  
    190190}
    191191
    192 DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    193                                               PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList)
     192DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx,
     193                                              PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
    194194{
    195195    LogFlowFuncEnter();
    196196
    197     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     197    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    198198    AssertPtr(pClient);
    199199
    200200    int rc;
    201201
    202     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
     202    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
    203203                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    204204    if (pMsg)
    205205    {
    206         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     206        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    207207
    208208        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    … …  
    220220                if (RT_SUCCESS(rc))
    221221                {
    222                     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     222                    PSHCLEVENTPAYLOAD pPayload;
    223223                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    224224                    if (RT_SUCCESS(rc))
    225225                    {
    226                         Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
    227 
    228                         PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     226                        Assert(pPayload->cbData == sizeof(SHCLREPLY));
     227
     228                        PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
    229229                        AssertPtr(pReply);
    230230
    231                         Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN);
     231                        Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN);
    232232
    233233                        *phList = pReply->u.ListOpen.uHandle;
    … …  
    248248}
    249249
    250 DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList)
     250DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    251251{
    252252    LogFlowFuncEnter();
    253253
    254     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     254    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    255255    AssertPtr(pClient);
    256256
    257257    int rc;
    258258
    259     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
     259    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
    260260                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    261261    if (pMsg)
    262262    {
    263         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     263        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    264264
    265265        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    … …  
    277277                if (RT_SUCCESS(rc))
    278278                {
    279                     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     279                    PSHCLEVENTPAYLOAD pPayload;
    280280                    rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    281281                    if (RT_SUCCESS(rc))
    … …  
    294294}
    295295
    296 DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    297                                                  SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     296DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx,
     297                                                 SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    298298{
    299299    LogFlowFuncEnter();
    300300
    301     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     301    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    302302    AssertPtr(pClient);
    303303
    304304    int rc;
    305305
    306     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
     306    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
    307307                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
    308308    if (pMsg)
    309309    {
    310         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     310        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    311311
    312312        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    323323            if (RT_SUCCESS(rc))
    324324            {
    325                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     325                PSHCLEVENTPAYLOAD pPayload;
    326326                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    327327                                                         pCtx->pTransfer->uTimeoutMs, &pPayload);
    328328                if (RT_SUCCESS(rc))
    329329                {
    330                     Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR));
    331 
    332                     *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData;
     330                    Assert(pPayload->cbData == sizeof(SHCLLISTHDR));
     331
     332                    *pListHdr = *(PSHCLLISTHDR)pPayload->pvData;
    333333
    334334                    SharedClipboardPayloadFree(pPayload);
    … …  
    344344}
    345345
    346 DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    347                                                   SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     346DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx,
     347                                                  SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    348348{
    349349    RT_NOREF(pCtx, hList, pListHdr);
    … …  
    354354}
    355355
    356 DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    357                                                    SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     356DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx,
     357                                                   SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    358358{
    359359    LogFlowFuncEnter();
    360360
    361     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     361    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    362362    AssertPtr(pClient);
    363363
    364364    int rc;
    365365
    366     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
     366    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
    367367                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
    368368    if (pMsg)
    369369    {
    370         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     370        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    371371
    372372        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    383383            if (RT_SUCCESS(rc))
    384384            {
    385                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     385                PSHCLEVENTPAYLOAD pPayload;
    386386                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    387387                if (RT_SUCCESS(rc))
    388388                {
    389                     Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY));
    390 
    391                     rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData);
     389                    Assert(pPayload->cbData == sizeof(SHCLLISTENTRY));
     390
     391                    rc = SharedClipboardURIListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData);
    392392
    393393                    SharedClipboardPayloadFree(pPayload);
    … …  
    403403}
    404404
    405 DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    406                                                     SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     405DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx,
     406                                                    SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    407407{
    408408    RT_NOREF(pCtx, hList, pListEntry);
    … …  
    413413}
    414414
    415 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms,
    416                                PSHAREDCLIPBOARDOBJHANDLE phObj)
     415int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     416                               PSHCLOBJHANDLE phObj)
    417417{
    418418    LogFlowFuncEnter();
    419419
    420     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     420    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    421421    AssertPtr(pClient);
    422422
    423423    int rc;
    424424
    425     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
     425    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
    426426                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
    427427    if (pMsg)
    428428    {
    429         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     429        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    430430
    431431        LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
    … …  
    448448            if (RT_SUCCESS(rc))
    449449            {
    450                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     450                PSHCLEVENTPAYLOAD pPayload;
    451451                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    452452                if (RT_SUCCESS(rc))
    453453                {
    454                     Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
    455 
    456                     PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     454                    Assert(pPayload->cbData == sizeof(SHCLREPLY));
     455
     456                    PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
    457457                    AssertPtr(pReply);
    458458
    459                     Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN);
     459                    Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN);
    460460
    461461                    *phObj = pReply->u.ObjOpen.uHandle;
    … …  
    473473}
    474474
    475 int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj)
     475int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    476476{
    477477    LogFlowFuncEnter();
    478478
    479     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     479    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    480480    AssertPtr(pClient);
    481481
    482482    int rc;
    483483
    484     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
     484    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
    485485                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
    486486    if (pMsg)
    487487    {
    488         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     488        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    489489
    490490        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    500500            if (RT_SUCCESS(rc))
    501501            {
    502                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     502                PSHCLEVENTPAYLOAD pPayload;
    503503                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    504504                if (RT_SUCCESS(rc))
    505505                {
    506                     Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
     506                    Assert(pPayload->cbData == sizeof(SHCLREPLY));
    507507
    508508#ifdef VBOX_STRICT
    509                     PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     509                    PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
    510510                    AssertPtr(pReply);
    511511
    512                     Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE);
     512                    Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE);
    513513#endif
    514514
    … …  
    525525}
    526526
    527 int vboxSvcClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
     527int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    528528                               void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    529529{
    530530    LogFlowFuncEnter();
    531531
    532     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     532    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    533533    AssertPtr(pClient);
    534534
    535535    int rc;
    536536
    537     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
     537    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
    538538                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
    539539    if (pMsg)
    540540    {
    541         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     541        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    542542
    543543        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    555555            if (RT_SUCCESS(rc))
    556556            {
    557                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     557                PSHCLEVENTPAYLOAD pPayload;
    558558                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    559559                if (RT_SUCCESS(rc))
    560560                {
    561                     Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDOBJDATACHUNK));
    562 
    563                     PVBOXCLIPBOARDOBJDATACHUNK pDataChunk = (PVBOXCLIPBOARDOBJDATACHUNK)pPayload->pvData;
     561                    Assert(pPayload->cbData == sizeof(SHCLOBJDATACHUNK));
     562
     563                    PSHCLOBJDATACHUNK pDataChunk = (PSHCLOBJDATACHUNK)pPayload->pvData;
    564564                    AssertPtr(pDataChunk);
    565565
    … …  
    583583}
    584584
    585 int vboxSvcClipboardURIObjWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
     585int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    586586                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    587587{
    588588    LogFlowFuncEnter();
    589589
    590     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     590    PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    591591    AssertPtr(pClient);
    592592
    593593    int rc;
    594594
    595     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
     595    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
    596596                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
    597597    if (pMsg)
    598598    {
    599         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     599        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    600600
    601601        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    … …  
    613613            if (RT_SUCCESS(rc))
    614614            {
    615                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     615                PSHCLEVENTPAYLOAD pPayload;
    616616                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    617617                if (RT_SUCCESS(rc))
    … …  
    641641*********************************************************************************************************************************/
    642642
    643 DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     643DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHCLURITRANSFERCALLBACKDATA pData)
    644644{
    645645    RT_NOREF(pData);
    … …  
    648648}
    649649
    650 DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     650DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc)
    651651{
    652652    RT_NOREF(pData, rc);
    … …  
    657657}
    658658
    659 DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     659DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHCLURITRANSFERCALLBACKDATA pData)
    660660{
    661661    LogFlowFuncEnter();
    … …  
    666666}
    667667
    668 DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     668DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc)
    669669{
    670670    LogFlowFuncEnter();
    … …  
    689689 */
    690690static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    691                                        PVBOXCLIPBOARDREPLY pReply)
     691                                       PSHCLREPLY pReply)
    692692{
    693693    int rc;
    … …  
    714714            switch (pReply->uType)
    715715            {
    716                 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN:
     716                case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN:
    717717                {
    718718                    if (cParms >= 6)
    … …  
    721721                }
    722722
    723                 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN:
     723                case VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN:
    724724                {
    725725                    if (cParms >= 6)
    … …  
    728728                }
    729729
    730                 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE:
     730                case VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE:
    731731                {
    732732                    if (cParms >= 6)
    … …  
    757757 */
    758758static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    759                                              PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr)
     759                                             PSHCLROOTLISTHDR pRootLstHdr)
    760760{
    761761    int rc;
    … …  
    783783 */
    784784static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    785                                                PVBOXCLIPBOARDROOTLISTENTRY pListEntry)
     785                                               PSHCLROOTLISTENTRY pListEntry)
    786786{
    787787    int rc;
    … …  
    820820 */
    821821static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    822                                           PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     822                                          PSHCLLISTOPENPARMS pOpenParms)
    823823{
    824824    int rc;
    … …  
    867867 */
    868868static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    869                                           PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)
     869                                          PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
    870870{
    871871    int rc;
    … …  
    900900 */
    901901static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    902                                            PVBOXSHCLMSGCTX pMsgCtx, SHAREDCLIPBOARDLISTHANDLE hList)
     902                                           PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
    903903{
    904904    int rc;
    … …  
    928928 */
    929929static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    930                                          PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
     930                                         PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
    931931{
    932932    int rc;
    … …  
    967967 */
    968968static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    969                                          PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTHDR pListHdr)
     969                                         PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
    970970{
    971971    int rc;
    … …  
    10021002 */
    10031003static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    1004                                            PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     1004                                           PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
    10051005{
    10061006    int rc;
    … …  
    10481048 */
    10491049static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    1050                                            PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTENTRY pListEntry)
     1050                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
    10511051{
    10521052    int rc;
    … …  
    10791079 * @param   pDataChunk          Where to store the object data chunk data.
    10801080 */
    1081 static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
     1081static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
    10821082{
    10831083    AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
    … …  
    11441144 * @param   paParms             Array function parameters supplied.
    11451145 */
    1146 static int vboxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     1146static int vboxSvcClipboardURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer,
    11471147                                                  uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    11481148{
    … …  
    11511151    int rc;
    11521152
    1153     uint32_t            cbReply = sizeof(VBOXCLIPBOARDREPLY);
    1154     PVBOXCLIPBOARDREPLY pReply  = (PVBOXCLIPBOARDREPLY)RTMemAlloc(cbReply);
     1153    uint32_t            cbReply = sizeof(SHCLREPLY);
     1154    PSHCLREPLY pReply  = (PSHCLREPLY)RTMemAlloc(cbReply);
    11551155    if (pReply)
    11561156    {
    … …  
    11581158        if (RT_SUCCESS(rc))
    11591159        {
    1160             PSHAREDCLIPBOARDEVENTPAYLOAD pPayload
    1161                 = (PSHAREDCLIPBOARDEVENTPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDEVENTPAYLOAD));
     1160            PSHCLEVENTPAYLOAD pPayload
     1161                = (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD));
    11621162            if (pPayload)
    11631163            {
    … …  
    11671167                switch (pReply->uType)
    11681168                {
    1169                     case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN:
     1169                    case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN:
    11701170                        RT_FALL_THROUGH();
    1171                     case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_CLOSE:
     1171                    case VBOX_SHCL_REPLYMSGTYPE_LIST_CLOSE:
    11721172                        RT_FALL_THROUGH();
    1173                     case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN:
     1173                    case VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN:
    11741174                        RT_FALL_THROUGH();
    1175                     case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE:
     1175                    case VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE:
    11761176                    {
    11771177                        uint32_t uCID;
    … …  
    11791179                        if (RT_SUCCESS(rc))
    11801180                        {
    1181                             const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1181                            const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    11821182
    11831183                            LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent));
    … …  
    12271227 * @param   tsArrival           Timestamp of arrival.
    12281228 */
    1229 int vboxSvcClipboardURIHandler(PVBOXCLIPBOARDCLIENT pClient,
     1229int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient,
    12301230                               VBOXHGCMCALLHANDLE callHandle,
    12311231                               uint32_t u32Function,
    … …  
    12621262     * Pre-check: For certain messages we need to make sure that a (right) transfer is present.
    12631263     */
    1264     PSHAREDCLIPBOARDURITRANSFER pTransfer = NULL;
     1264    PSHCLURITRANSFER pTransfer = NULL;
    12651265    switch (u32Function)
    12661266    {
    … …  
    13011301                break;
    13021302
    1303             SHAREDCLIPBOARDURITRANSFERSTATUS uStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE;
     1303            SHCLURITRANSFERSTATUS uStatus = SHCLURITRANSFERSTATUS_NONE;
    13041304            rc = HGCMSvcGetU32(&paParms[1], &uStatus);
    13051305            if (RT_FAILURE(rc))
    … …  
    13161316            }
    13171317
    1318             if (uStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING)
    1319             {
    1320                 const SHAREDCLIPBOARDURITRANSFERDIR enmDir = SHAREDCLIPBOARDURITRANSFERDIR_READ;
    1321 
    1322                 PSHAREDCLIPBOARDURITRANSFER pTransfer;
     1318            if (uStatus == SHCLURITRANSFERSTATUS_RUNNING)
     1319            {
     1320                const SHCLURITRANSFERDIR enmDir = SHCLURITRANSFERDIR_READ;
     1321
     1322                PSHCLURITRANSFER pTransfer;
    13231323                rc = SharedClipboardURITransferCreate(enmDir,
    1324                                                       SHAREDCLIPBOARDSOURCE_REMOTE, &pTransfer);
     1324                                                      SHCLSOURCE_REMOTE, &pTransfer);
    13251325                if (RT_SUCCESS(rc))
    13261326                {
    … …  
    13281328                    if (RT_SUCCESS(rc))
    13291329                    {
    1330                         SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
     1330                        SHCLPROVIDERCREATIONCTX creationCtx;
    13311331                        RT_ZERO(creationCtx);
    13321332
    … …  
    13401340                        creationCtx.Interface.pfnObjClose      = vboxSvcClipboardURIObjClose;
    13411341
    1342                         if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
     1342                        if (enmDir == SHCLURITRANSFERDIR_READ)
    13431343                        {
    13441344                            creationCtx.Interface.pfnGetRoots        = vboxSvcClipboardURIGetRoots;
    … …  
    13551355
    13561356                        /* Register needed callbacks so that we can wait for the meta data to arrive here. */
    1357                         SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
     1357                        SHCLURITRANSFERCALLBACKS Callbacks;
    13581358                        RT_ZERO(Callbacks);
    13591359
    … …  
    14091409        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE:
    14101410        {
    1411             VBOXCLIPBOARDROOTLISTHDR lstHdr;
     1411            SHCLROOTLISTHDR lstHdr;
    14121412            rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr);
    14131413            if (RT_SUCCESS(rc))
    14141414            {
    14151415                void    *pvData = SharedClipboardURIRootListHdrDup(&lstHdr);
    1416                 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTHDR);
     1416                uint32_t cbData = sizeof(SHCLROOTLISTHDR);
    14171417
    14181418                uint32_t uCID;
    … …  
    14201420                if (RT_SUCCESS(rc))
    14211421                {
    1422                     const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1423 
    1424                     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1422                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1423
     1424                    PSHCLEVENTPAYLOAD pPayload;
    14251425                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    14261426                    if (RT_SUCCESS(rc))
    … …  
    14381438        {
    14391439    #if 0
    1440             VBOXCLIPBOARDROOTLISTENTRY lstEntry;
     1440            SHCLROOTLISTENTRY lstEntry;
    14411441            rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
    14421442            if (RT_SUCCESS(rc))
    14431443            {
    14441444                void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
    1445                 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY);
    1446 
    1447                 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
    1448                 rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
     1445                uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
     1446
     1447                PSHCLURITRANSFERPAYLOAD pPayload;
     1448                rc = SharedClipboardURITransferPayloadAlloc(SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    14491449                                                            pvData, cbData, &pPayload);
    14501450                if (RT_SUCCESS(rc))
    1451                     rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
     1451                    rc = SharedClipboardURITransferEventSignal(pTransfer, SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    14521452                                                               pPayload);
    14531453            }
    … …  
    14581458        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
    14591459        {
    1460             VBOXCLIPBOARDROOTLISTENTRY lstEntry;
     1460            SHCLROOTLISTENTRY lstEntry;
    14611461            rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
    14621462            if (RT_SUCCESS(rc))
    14631463            {
    14641464                void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
    1465                 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY);
     1465                uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
    14661466
    14671467                uint32_t uCID;
    … …  
    14691469                if (RT_SUCCESS(rc))
    14701470                {
    1471                     const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1472 
    1473                     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1471                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1472
     1473                    PSHCLEVENTPAYLOAD pPayload;
    14741474                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    14751475                    if (RT_SUCCESS(rc))
    … …  
    14861486        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
    14871487        {
    1488             VBOXCLIPBOARDLISTOPENPARMS listOpenParms;
     1488            SHCLLISTOPENPARMS listOpenParms;
    14891489            rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);
    14901490            if (RT_SUCCESS(rc))
    14911491            {
    1492                 SHAREDCLIPBOARDLISTHANDLE hList;
     1492                SHCLLISTHANDLE hList;
    14931493                rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList);
    14941494                if (RT_SUCCESS(rc))
    … …  
    15061506                break;
    15071507
    1508             SHAREDCLIPBOARDLISTHANDLE hList;
     1508            SHCLLISTHANDLE hList;
    15091509            rc = HGCMSvcGetU64(&paParms[1], &hList);
    15101510            if (RT_SUCCESS(rc))
    … …  
    15201520                break;
    15211521
    1522             SHAREDCLIPBOARDLISTHANDLE hList;
     1522            SHCLLISTHANDLE hList;
    15231523            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    15241524            if (RT_SUCCESS(rc))
    15251525            {
    1526                 VBOXCLIPBOARDLISTHDR hdrList;
     1526                SHCLLISTHDR hdrList;
    15271527                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    15281528                /*if (RT_SUCCESS(rc))
    … …  
    15341534        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
    15351535        {
    1536             VBOXCLIPBOARDLISTHDR hdrList;
     1536            SHCLLISTHDR hdrList;
    15371537            rc = SharedClipboardURIListHdrInit(&hdrList);
    15381538            if (RT_SUCCESS(rc))
    15391539            {
    1540                 SHAREDCLIPBOARDLISTHANDLE hList;
     1540                SHCLLISTHANDLE hList;
    15411541                rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
    15421542                if (RT_SUCCESS(rc))
    15431543                {
    15441544                    void    *pvData = SharedClipboardURIListHdrDup(&hdrList);
    1545                     uint32_t cbData = sizeof(VBOXCLIPBOARDLISTHDR);
     1545                    uint32_t cbData = sizeof(SHCLLISTHDR);
    15461546
    15471547                    uint32_t uCID;
    … …  
    15491549                    if (RT_SUCCESS(rc))
    15501550                    {
    1551                         const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1552 
    1553                         PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1551                        const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1552
     1553                        PSHCLEVENTPAYLOAD pPayload;
    15541554                        rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    15551555                        if (RT_SUCCESS(rc))
    … …  
    15701570                break;
    15711571
    1572             SHAREDCLIPBOARDLISTHANDLE hList;
     1572            SHCLLISTHANDLE hList;
    15731573            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    15741574            if (RT_SUCCESS(rc))
    15751575            {
    1576                 VBOXCLIPBOARDLISTENTRY entryList;
     1576                SHCLLISTENTRY entryList;
    15771577                rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
    15781578            }
    … …  
    15821582        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
    15831583        {
    1584             VBOXCLIPBOARDLISTENTRY entryList;
     1584            SHCLLISTENTRY entryList;
    15851585            rc = SharedClipboardURIListEntryInit(&entryList);
    15861586            if (RT_SUCCESS(rc))
    15871587            {
    1588                 SHAREDCLIPBOARDLISTHANDLE hList;
     1588                SHCLLISTHANDLE hList;
    15891589                rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);
    15901590                if (RT_SUCCESS(rc))
    15911591                {
    15921592                    void    *pvData = SharedClipboardURIListEntryDup(&entryList);
    1593                     uint32_t cbData = sizeof(VBOXCLIPBOARDLISTENTRY);
     1593                    uint32_t cbData = sizeof(SHCLLISTENTRY);
    15941594
    15951595                    uint32_t uCID;
    … …  
    15971597                    if (RT_SUCCESS(rc))
    15981598                    {
    1599                         const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1600 
    1601                         PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1599                        const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1600
     1601                        PSHCLEVENTPAYLOAD pPayload;
    16021602                        rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    16031603                        if (RT_SUCCESS(rc))
    … …  
    16321632        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
    16331633        {
    1634             VBOXCLIPBOARDOBJDATACHUNK dataChunk;
     1634            SHCLOBJDATACHUNK dataChunk;
    16351635            rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk);
    16361636            if (RT_SUCCESS(rc))
    16371637            {
    16381638                void    *pvData = SharedClipboardURIObjectDataChunkDup(&dataChunk);
    1639                 uint32_t cbData = sizeof(VBOXCLIPBOARDOBJDATACHUNK);
     1639                uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
    16401640
    16411641                uint32_t uCID;
    … …  
    16431643                if (RT_SUCCESS(rc))
    16441644                {
    1645                     const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1646 
    1647                     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     1645                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1646
     1647                    PSHCLEVENTPAYLOAD pPayload;
    16481648                    rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    16491649                    if (RT_SUCCESS(rc))
    … …  
    16641664            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR\n"));
    16651665
    1666             VBOXCLIPBOARDDIRDATA dirData;
     1666            SHCLDIRDATA dirData;
    16671667            rc = VBoxSvcClipboardURIGetDir(cParms, paParms, &dirData);
    16681668            if (RT_SUCCESS(rc))
    … …  
    16801680                    if (RT_SUCCESS(rc))
    16811681                    {
    1682                         SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_DIR, SHAREDCLIPBOARDAREAOBJSTATE_COMPLETE };
     1682                        SHCLAREAOBJ Obj = { SHCLAREAOBJTYPE_DIR, SHCLAREAOBJSTATE_COMPLETE };
    16831683                        int rc2 = pArea->AddObject(pszDir, Obj);
    16841684                        AssertRC(rc2);
    … …  
    16971697            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n"));
    16981698
    1699             VBOXCLIPBOARDFILEHDR fileHdr;
     1699            SHCLFILEHDR fileHdr;
    17001700            rc = VBoxSvcClipboardURISetFileHdr(cParms, paParms, &fileHdr);
    17011701            break;
    … …  
    17221722                break;
    17231723
    1724             VBOXCLIPBOARDFILEHDR fileHdr;
     1724            SHCLFILEHDR fileHdr;
    17251725            rc = VBoxSvcClipboardURIGetFileHdr(cParms, paParms, &fileHdr);
    17261726            if (RT_SUCCESS(rc))
    … …  
    17381738                    if (RT_SUCCESS(rc))
    17391739                    {
    1740                         PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
     1740                        PSHCLCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
    17411741                        AssertPtrBreakStmt(pObjCtx, VERR_INVALID_POINTER);
    17421742
    … …  
    17671767                            }
    17681768
    1769                             SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_FILE, SHAREDCLIPBOARDAREAOBJSTATE_NONE };
     1769                            SHCLAREAOBJ Obj = { SHCLAREAOBJTYPE_FILE, SHCLAREAOBJSTATE_NONE };
    17701770                            int rc2 = pArea->AddObject(pszPathAbs, Obj);
    17711771                            AssertRC(rc2);
    … …  
    17831783            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n"));
    17841784
    1785             VBOXCLIPBOARDFILEDATA fileData;
     1785            SHCLFILEDATA fileData;
    17861786            rc = VBoxSvcClipboardURISetFileData(cParms, paParms, &fileData);
    17871787            break;
    … …  
    17981798            }
    17991799
    1800             VBOXCLIPBOARDFILEDATA fileData;
     1800            SHCLFILEDATA fileData;
    18011801            rc = VBoxSvcClipboardURIGetFileData(cParms, paParms, &fileData);
    18021802            if (RT_SUCCESS(rc))
    18031803            {
    1804                 PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
     1804                PSHCLCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
    18051805                AssertPtrBreakStmt(pObjCtx, VERR_INVALID_POINTER);
    18061806
    … …  
    19011901 * @param   pTransfer           URI transfer to register a clipboard area for.
    19021902 */
    1903 int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1903int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    19041904{
    19051905    RT_NOREF(pClientState);
    … …  
    19181918    if (g_ExtState.pfnExtension)
    19191919    {
    1920         VBOXCLIPBOARDEXTAREAPARMS parms;
     1920        SHCLEXTAREAPARMS parms;
    19211921        RT_ZERO(parms);
    19221922
    1923         parms.uID = NIL_SHAREDCLIPBOARDAREAID;
     1923        parms.uID = NIL_SHCLAREAID;
    19241924
    19251925        /* As the meta data is now complete, register a new clipboard on the host side. */
    … …  
    19271927        if (RT_SUCCESS(rc))
    19281928        {
    1929             /* Note: Do *not* specify SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the
     1929            /* Note: Do *not* specify SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the
    19301930             *       clipboard area creation already. */
    19311931            rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */,
    1932                                             SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
     1932                                            SHCLAREA_OPEN_FLAGS_NONE);
    19331933        }
    19341934
    … …  
    19501950 * @param   pTransfer           URI transfer to unregister a clipboard area from.
    19511951 */
    1952 int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     1952int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    19531953{
    19541954    RT_NOREF(pClientState);
    … …  
    19631963    if (g_ExtState.pfnExtension)
    19641964    {
    1965         VBOXCLIPBOARDEXTAREAPARMS parms;
     1965        SHCLEXTAREAPARMS parms;
    19661966        RT_ZERO(parms);
    19671967
    … …  
    19981998 * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
    19991999 */
    2000 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer,
    2001                                   SHAREDCLIPBOARDAREAID uID)
     2000int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer,
     2001                                  SHCLAREAID uID)
    20022002{
    20032003    RT_NOREF(pClientState);
    … …  
    20162016    if (g_ExtState.pfnExtension)
    20172017    {
    2018         VBOXCLIPBOARDEXTAREAPARMS parms;
     2018        SHCLEXTAREAPARMS parms;
    20192019        RT_ZERO(parms);
    20202020
    … …  
    20462046 * @param   pTransfer           URI transfer to detach a clipboard area from.
    20472047 */
    2048 int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     2048int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    20492049{
    20502050    RT_NOREF(pClientState);
    … …  
    20612061    if (g_ExtState.pfnExtension)
    20622062    {
    2063         VBOXCLIPBOARDEXTAREAPARMS parms;
     2063        SHCLEXTAREAPARMS parms;
    20642064        RT_ZERO(parms);
    20652065        parms.uID = uAreaID;

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

    r79497 r80662  
    2222#endif
    2323
    24 int vboxSvcClipboardURIHandler(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
     24int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
    2525int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    2626
    27 int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    28 int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    29 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDAREAID uID);
    30 int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     27int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     28int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     29int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID);
     30int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    3131
    3232#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */

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

    r80444 r80662  
    9393
    9494#if 0
    95 int vboxSvcClipboardURIReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uParm)
     95int vboxSvcClipboardURIReportMsg(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t uParm)
    9696{
    9797    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    115115
    116116            pClient->State.URI.fTransferStart = true;
    117             pClient->State.URI.enmTransferDir = (SHAREDCLIPBOARDURITRANSFERDIR)uParm;
     117            pClient->State.URI.enmTransferDir = (SHCLURITRANSFERDIR)uParm;
    118118            break;
    119119
    … …  
    130130}
    131131
    132 bool vboxSvcClipboardURIReturnMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     132bool vboxSvcClipboardURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    133133{
    134134    RT_NOREF(pClient, cParms, paParms);

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

    r80623 r80662  
    5353*   Internal Functions                                                                                                           *
    5454*********************************************************************************************************************************/
    55 static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx);
    56 
    57 struct _VBOXCLIPBOARDCONTEXT
     55static int vboxClipboardSvcWinSyncInternal(PSHCLCONTEXT pCtx);
     56
     57struct _SHCLCONTEXT
    5858{
    5959    /** Handle for window message handling thread. */
    6060    RTTHREAD                 hThread;
    6161    /** Structure for keeping and communicating with service client. */
    62     PVBOXCLIPBOARDCLIENT     pClient;
     62    PSHCLCLIENT     pClient;
    6363    /** Windows-specific context data. */
    64     VBOXCLIPBOARDWINCTX      Win;
     64    SHCLWINCTX      Win;
    6565};
    6666
    … …  
    114114}
    115115
    116 static int vboxClipboardSvcWinDataSet(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat, void *pvData, uint32_t cbData)
     116static int vboxClipboardSvcWinDataSet(PSHCLCONTEXT pCtx, UINT cfFormat, void *pvData, uint32_t cbData)
    117117{
    118118    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
    … …  
    167167}
    168168
    169 static int vboxClipboardSvcWinDataRead(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat,
     169static int vboxClipboardSvcWinDataRead(PSHCLCONTEXT pCtx, UINT cfFormat,
    170170                                       void **ppvData, uint32_t *pcbData)
    171171{
    172172    LogFlowFunc(("cfFormat=%u\n", cfFormat));
    173173
    174     SHAREDCLIPBOARDDATAREQ dataReq;
     174    SHCLDATAREQ dataReq;
    175175    RT_ZERO(dataReq);
    176176
    … …  
    178178    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    179179
    180     VBOXCLIPBOARDEVENTID uEvent = 0;
     180    SHCLEVENTID uEvent = 0;
    181181    int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    182182    if (RT_SUCCESS(rc))
    183183    {
    184         PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     184        PSHCLEVENTPAYLOAD pPayload;
    185185        rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
    186186        if (RT_SUCCESS(rc))
    … …  
    200200}
    201201
    202 static LRESULT CALLBACK vboxClipboardSvcWinWndProcMain(PVBOXCLIPBOARDCONTEXT pCtx,
     202static LRESULT CALLBACK vboxClipboardSvcWinWndProcMain(PSHCLCONTEXT pCtx,
    203203                                                       HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    204204{
    … …  
    207207    LRESULT lresultRc = 0;
    208208
    209     const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win;
     209    const PSHCLWINCTX pWinCtx = &pCtx->Win;
    210210
    211211    switch (uMsg)
    … …  
    222222                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    223223                if (RT_SUCCESS(rc))
    224                     vboxSvcClipboardSetSource(pCtx->pClient, SHAREDCLIPBOARDSOURCE_LOCAL);
     224                    vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    225225            }
    226226
    … …  
    244244                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    245245                if (RT_SUCCESS(rc))
    246                     vboxSvcClipboardSetSource(pCtx->pClient, SHAREDCLIPBOARDSOURCE_LOCAL);
     246                    vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    247247            }
    248248
    … …  
    266266            const UINT cfFormat = (UINT)wParam;
    267267
    268             const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     268            const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
    269269
    270270            LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
    … …  
    314314
    315315            /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT. */
    316             VBOXCLIPBOARDFORMATS fFormats = (uint32_t)lParam;
     316            SHCLFORMATS fFormats = (uint32_t)lParam;
    317317            if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
    318318            {
    … …  
    361361    AssertPtrReturn(pUserData, 0);
    362362
    363     PVBOXCLIPBOARDCONTEXT pCtx = reinterpret_cast<PVBOXCLIPBOARDCONTEXT>(pUserData);
     363    PSHCLCONTEXT pCtx = reinterpret_cast<PSHCLCONTEXT>(pUserData);
    364364    if (pCtx)
    365365        return vboxClipboardSvcWinWndProcMain(pCtx, hWnd, uMsg, wParam, lParam);
    … …  
    398398    bool fThreadSignalled = false;
    399399
    400     const PVBOXCLIPBOARDCONTEXT pCtx    = (PVBOXCLIPBOARDCONTEXT)pvUser;
     400    const PSHCLCONTEXT pCtx    = (PSHCLCONTEXT)pvUser;
    401401    AssertPtr(pCtx);
    402     const PVBOXCLIPBOARDWINCTX  pWinCtx = &pCtx->Win;
     402    const PSHCLWINCTX  pWinCtx = &pCtx->Win;
    403403
    404404    HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
    … …  
    517517 * @param   pCtx                Clipboard context to synchronize.
    518518 */
    519 static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx)
     519static int vboxClipboardSvcWinSyncInternal(PSHCLCONTEXT pCtx)
    520520{
    521521    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    … …  
    527527    if (pCtx->pClient)
    528528    {
    529         SHAREDCLIPBOARDFORMATDATA Formats;
     529        SHCLFORMATDATA Formats;
    530530        RT_ZERO(Formats);
    531531
    … …  
    559559}
    560560
    561 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
     561int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    562562{
    563563    RT_NOREF(fHeadless);
    … …  
    567567    int rc;
    568568
    569     PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT));
     569    PSHCLCONTEXT pCtx = (PSHCLCONTEXT)RTMemAllocZ(sizeof(SHCLCONTEXT));
    570570    if (pCtx)
    571571    {
    … …  
    596596}
    597597
    598 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
     598int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
    599599{
    600600    /* Sync the host clipboard content with the client. */
    … …  
    602602}
    603603
    604 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
     604int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    605605{
    606606    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    610610    int rc = VINF_SUCCESS;
    611611
    612     PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
     612    PSHCLCONTEXT pCtx = pClient->State.pCtx;
    613613    if (pCtx)
    614614    {
    … …  
    641641}
    642642
    643 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    644                                        PSHAREDCLIPBOARDFORMATDATA pFormats)
     643int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     644                                       PSHCLFORMATDATA pFormats)
    645645{
    646646    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    649649    int rc;
    650650
    651     PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
     651    PSHCLCONTEXT pCtx = pClient->State.pCtx;
    652652    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    653653
    … …  
    657657    if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    658658    {
    659         PSHAREDCLIPBOARDURITRANSFER pTransfer;
     659        PSHCLURITRANSFER pTransfer;
    660660        rc = vboxSvcClipboardURITransferStart(pClient,
    661                                               SHAREDCLIPBOARDURITRANSFERDIR_READ, SHAREDCLIPBOARDSOURCE_REMOTE,
     661                                              SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE,
    662662                                              &pTransfer);
    663663        if (RT_SUCCESS(rc))
    … …  
    691691}
    692692
    693 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    694                                  PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
     693int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     694                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    695695{
    696696    AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
    … …  
    702702    HANDLE hClip = NULL;
    703703
    704     const PVBOXCLIPBOARDWINCTX pWinCtx = &pClient->State.pCtx->Win;
     704    const PSHCLWINCTX pWinCtx = &pClient->State.pCtx->Win;
    705705
    706706    /*
    … …  
    802802}
    803803
    804 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    805                                   PSHAREDCLIPBOARDDATABLOCK pData)
     804int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     805                                  PSHCLDATABLOCK pData)
    806806{
    807807    LogFlowFuncEnter();
    … …  
    814814
    815815#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    816 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     816int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    817817{
    818818    RT_NOREF(pClient, pTransfer);
    … …  
    823823}
    824824
    825 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     825int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    826826{
    827827    LogFlowFuncEnter();

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

    r80623 r80662  
    5858  * @param   fHeadless          Whether headless.
    5959  */
    60 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
     60int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    6161{
    6262    RT_NOREF(pClient, fHeadless);
    … …  
    6969 * after a save and restore of the guest.
    7070 */
    71 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
     71int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
    7272{
    7373    RT_NOREF(pClient);
    … …  
    8181 * @param   pClient         Structure containing context information about the guest system
    8282 */
    83 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
     83int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    8484{
    8585    RT_NOREF(pClient);
    … …  
    9595 * @param pFormats              Clipboard formats the guest is offering.
    9696 */
    97 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    98                                        PSHAREDCLIPBOARDFORMATDATA pFormats)
     97int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     98                                       PSHCLFORMATDATA pFormats)
    9999{
    100100    RT_NOREF(pClient, pCmdCtx, pFormats);
    … …  
    110110 * @param pcbActual     Where to store the actual amount of data available.
    111111 */
    112 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    113                                  PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
     112int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     113                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    114114{
    115115    RT_NOREF(pClient, pCmdCtx, pData);
    … …  
    121121}
    122122
    123 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    124                                   PSHAREDCLIPBOARDDATABLOCK pData)
     123int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     124                                  PSHCLDATABLOCK pData)
    125125{
    126126    RT_NOREF(pClient, pCmdCtx, pData);

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

    r80623 r80662  
    4242 * Global context information used by the host glue for the X11 clipboard backend.
    4343 */
    44 struct _VBOXCLIPBOARDCONTEXT
     44struct _SHCLCONTEXT
    4545{
    4646    /** This mutex is grabbed during any critical operations on the clipboard
    … …  
    5050    CLIPBACKEND         *pBackend;
    5151    /** Pointer to the VBox host client data structure. */
    52     PVBOXCLIPBOARDCLIENT pClient;
     52    PSHCLCLIENT pClient;
    5353    /** We set this when we start shutting down as a hint not to post any new
    5454     * requests. */
    … …  
    6363 * @note  Host glue code
    6464 */
    65 void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
     65void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats)
    6666{
    6767    LogFlowFunc(("pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
    6868
    69     SHAREDCLIPBOARDFORMATDATA formatData;
     69    SHCLFORMATDATA formatData;
    7070    RT_ZERO(formatData);
    7171
    … …  
    100100 *        the clipboard and leave ownership to X11.
    101101 */
    102 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless)
     102int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    103103{
    104104    int rc = VINF_SUCCESS;
    105105
    106     PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT));
     106    PSHCLCONTEXT pCtx = (PSHCLCONTEXT)RTMemAllocZ(sizeof(SHCLCONTEXT));
    107107    if (pCtx)
    108108    {
    … …  
    142142 * @note  Host glue code
    143143 */
    144 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient)
     144int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
    145145{
    146146    LogFlowFuncEnter();
    … …  
    149149     * there is data in the host clipboard it will automatically be sent to
    150150     * the guest when the clipboard starts up. */
    151     SHAREDCLIPBOARDFORMATDATA formatData;
     151    SHCLFORMATDATA formatData;
    152152    RT_ZERO(formatData);
    153153
    … …  
    161161 * @note  Host glue code
    162162 */
    163 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient)
     163int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    164164{
    165165    LogFlowFuncEnter();
    166166
    167     PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
     167    PSHCLCONTEXT pCtx = pClient->State.pCtx;
    168168
    169169    /* Drop the reference to the client, in case it is still there.  This
    … …  
    173173
    174174    /* If there is a currently pending request, release it immediately. */
    175     SHAREDCLIPBOARDDATABLOCK dataBlock = { 0, NULL, 0 };
     175    SHCLDATABLOCK dataBlock = { 0, NULL, 0 };
    176176    VBoxClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
    177177
    … …  
    199199 * @param pFormats              Clipboard formats the guest is offering.
    200200 */
    201 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    202                                        PSHAREDCLIPBOARDFORMATDATA pFormats)
     201int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     202                                       PSHCLFORMATDATA pFormats)
    203203{
    204204    RT_NOREF(pCmdCtx);
    … …  
    224224    uint32_t            *pcbActual;
    225225    /** The request's event ID. */
    226     VBOXCLIPBOARDEVENTID uEvent;
     226    SHCLEVENTID uEvent;
    227227};
    228228
    … …  
    245245 *
    246246 */
    247 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient,
    248                                  PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual)
     247int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient,
     248                                 PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
    249249{
    250250    RT_NOREF(pCmdCtx);
    … …  
    258258    if (pReq)
    259259    {
    260         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     260        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
    261261
    262262        pReq->pv        = pData->pvData;
    … …  
    271271            if (RT_SUCCESS(rc))
    272272            {
    273                 PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     273                PSHCLEVENTPAYLOAD pPayload;
    274274                rc = SharedClipboardEventWait(&pClient->Events, uEvent, 30 * 1000, &pPayload);
    275275                if (RT_SUCCESS(rc))
    … …  
    299299 * @param  pData                Data block to write to clipboard.
    300300 */
    301 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient,
    302                                   PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData)
     301int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient,
     302                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    303303{
    304304    LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n",
    … …  
    323323 * @todo   Change this to deal with the buffer issues rather than offloading them onto the caller.
    324324 */
    325 void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc,
     325void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc,
    326326                                        CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
    327327{
    328328    AssertMsgRC(rc, ("Clipboard data completion from X11 failed with %Rrc\n", rc));
    329329
    330     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     330    PSHCLEVENTPAYLOAD pPayload;
    331331    int rc2 = SharedClipboardPayloadAlloc(pReq->uEvent, pv, cb, &pPayload);
    332332    if (RT_SUCCESS(rc2))
    … …  
    349349 * @note   Host glue code.
    350350 */
    351 int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
     351int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
    352352{
    353353    LogFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p\n", pCtx, u32Format, ppv));
    … …  
    361361
    362362    /* Request data from the guest. */
    363     SHAREDCLIPBOARDDATAREQ dataReq;
     363    SHCLDATAREQ dataReq;
    364364    RT_ZERO(dataReq);
    365365
    … …  
    367367    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    368368
    369     VBOXCLIPBOARDEVENTID uEvent;
     369    SHCLEVENTID uEvent;
    370370    int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    371371    if (RT_SUCCESS(rc))
    372372    {
    373         PSHAREDCLIPBOARDEVENTPAYLOAD pPayload;
     373        PSHCLEVENTPAYLOAD pPayload;
    374374        rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
    375375        if (RT_SUCCESS(rc))
    … …  
    390390
    391391#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    392 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     392int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    393393{
    394394    RT_NOREF(pClient, pTransfer);
    … …  
    396396}
    397397
    398 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     398int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    399399{
    400400    RT_NOREF(pClient, pTransfer);

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

    r80640 r80662  
    224224*   Prototypes                                                                                                                   *
    225225*********************************************************************************************************************************/
    226 static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTSTATE pClientState, uint32_t uClientID);
    227 static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTSTATE pClientState);
    228 static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState);
     226static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
     227static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState);
     228static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState);
    229229
    230230
    … …  
    241241
    242242/** Holds the service extension state. */
    243 VBOXCLIPBOARDEXTSTATE g_ExtState = { 0 };
     243SHCLEXTSTATE g_ExtState = { 0 };
    244244
    245245/** Global map of all connected clients. */
    … …  
    260260 * @param   puID                Where to store the created event source ID on success.
    261261 */
    262 int vboxSvcClipboardEventSourceCreateID(PVBOXCLIPBOARDEVENTSOURCEID puID)
     262int vboxSvcClipboardEventSourceCreateID(PSHCLEVENTSOURCEID puID)
    263263{
    264264    AssertPtrReturn(puID, VERR_INVALID_POINTER);
    … …  
    266266    for (uint32_t i = 0; i < 32; i++) /* Don't try too hard. */
    267267    {
    268         VBOXCLIPBOARDEVENTSOURCEID uID = RTRandU32() % VBOX_SHARED_CLIPBOARD_MAX_EVENT_SOURCES;
     268        SHCLEVENTSOURCEID uID = RTRandU32() % VBOX_SHARED_CLIPBOARD_MAX_EVENT_SOURCES;
    269269        if (g_mapEventSources.find(uID) == g_mapEventSources.end())
    270270        {
    … …  
    343343 * @param   pClient             Pointer to the client data structure to reset message queue for.
    344344 */
    345 void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENT pClient)
     345void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient)
    346346{
    347347    LogFlowFuncEnter();
    … …  
    361361 * @param   cParms              Number of HGCM parameters to allocate.
    362362 */
    363 PVBOXCLIPBOARDCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms)
    364 {
    365     PVBOXCLIPBOARDCLIENTMSG pMsg = (PVBOXCLIPBOARDCLIENTMSG)RTMemAlloc(sizeof(VBOXCLIPBOARDCLIENTMSG));
     363PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms)
     364{
     365    PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG));
    366366    if (pMsg)
    367367    {
    … …  
    386386 *                              The pointer will be invalid after calling this function.
    387387 */
    388 void vboxSvcClipboardMsgFree(PVBOXCLIPBOARDCLIENTMSG pMsg)
     388void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg)
    389389{
    390390    if (!pMsg)
    … …  
    407407 * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
    408408 */
    409 void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     409void vboxSvcClipboardMsgSetPeekReturn(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(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     439int vboxSvcClipboardMsgSetGetHostMsgOldReturn(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(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend)
     496int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
    497497{
    498498    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
    … …  
    527527 *                      immediately.
    528528 */
    529 int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     529int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    530530                            bool fWait)
    531531{
    … …  
    571571    if (!pClient->queueMsg.isEmpty())
    572572    {
    573         PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
     573        PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    574574        if (pFirstMsg)
    575575        {
    … …  
    616616 * @param   paParms     Array of parameters.
    617617 */
    618 int vboxSvcClipboardMsgGetOld(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     618int vboxSvcClipboardMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    619619{
    620620    int rc;
    … …  
    633633        if (!pClient->queueMsg.isEmpty())
    634634        {
    635             PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
     635            PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    636636            AssertPtr(pFirstMsg);
    637637
    … …  
    692692 * @param   paParms      Array of parameters.
    693693 */
    694 int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     694int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    695695{
    696696    /*
    … …  
    706706    if (!pClient->queueMsg.isEmpty())
    707707    {
    708         PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
     708        PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    709709        if (pFirstMsg)
    710710        {
    … …  
    807807 * @param   pClient             Client to wake up.
    808808 */
    809 int vboxSvcClipboardClientWakeup(PVBOXCLIPBOARDCLIENT pClient)
     809int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient)
    810810{
    811811    int rc = VINF_NO_CHANGE;
    … …  
    819819        if (!pClient->queueMsg.isEmpty())
    820820        {
    821             PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first();
     821            PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first();
    822822            if (pFirstMsg)
    823823            {
    … …  
    879879 * @param   puEvent             Event ID for waiting for new data. Optional.
    880880 */
    881 int vboxSvcClipboardDataReadRequest(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDDATAREQ pDataReq,
    882                                     PVBOXCLIPBOARDEVENTID puEvent)
     881int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
     882                                    PSHCLEVENTID puEvent)
    883883{
    884884    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    888888    int rc;
    889889
    890     PVBOXCLIPBOARDCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     890    PSHCLCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    891891                                                                    VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
    892892    if (pMsgReadData)
    893893    {
    894         const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     894        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
    895895
    896896        HGCMSvcSetU32(&pMsgReadData->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent));
    … …  
    922922}
    923923
    924 int vboxSvcClipboardDataReadSignal(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx,
    925                                    PSHAREDCLIPBOARDDATABLOCK pData)
    926 {
    927     VBOXCLIPBOARDEVENTID uEvent;
     924int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     925                                   PSHCLDATABLOCK pData)
     926{
     927    SHCLEVENTID uEvent;
    928928    if (pClient->State.uProtocolVer == 0)
    929929    {
    … …  
    937937    int rc = VINF_SUCCESS;
    938938
    939     PSHAREDCLIPBOARDEVENTPAYLOAD pPayload = NULL;
     939    PSHCLEVENTPAYLOAD pPayload = NULL;
    940940    if (pData->cbData)
    941941        rc = SharedClipboardPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
    … …  
    952952}
    953953
    954 int vboxSvcClipboardFormatsReport(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDFORMATDATA pFormats)
     954int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
    955955{
    956956    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    959959    int rc;
    960960
    961     PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
     961    PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
    962962    if (pMsg)
    963963    {
    964         VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     964        SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
    965965
    966966        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent));
    … …  
    979979}
    980980
    981 int vboxSvcClipboardGetDataWrite(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     981int vboxSvcClipboardGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    982982{
    983983    LogFlowFuncEnter();
    … …  
    991991    int rc;
    992992
    993     SHAREDCLIPBOARDDATABLOCK dataBlock;
     993    SHCLDATABLOCK dataBlock;
    994994    RT_ZERO(dataBlock);
    995995
    996     VBOXCLIPBOARDCLIENTCMDCTX cmdCtx;
     996    SHCLCLIENTCMDCTX cmdCtx;
    997997    RT_ZERO(cmdCtx);
    998998
    … …  
    10441044        if (g_ExtState.pfnExtension)
    10451045        {
    1046             VBOXCLIPBOARDEXTPARMS parms;
     1046            SHCLEXTPARMS parms;
    10471047            RT_ZERO(parms);
    10481048
    … …  
    10611061}
    10621062
    1063 int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENT pClient, SHAREDCLIPBOARDSOURCE enmSource)
     1063int vboxSvcClipboardSetSource(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(PVBOXCLIPBOARDCLIENT pClient,
    1085                                      SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
    1086                                      PSHAREDCLIPBOARDURITRANSFER *ppTransfer)
     1084int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient,
     1085                                     SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
     1086                                     PSHCLURITRANSFER *ppTransfer)
    10871087{
    10881088    LogFlowFuncEnter();
    … …  
    10941094    if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI))
    10951095    {
    1096         PSHAREDCLIPBOARDURITRANSFER pTransfer;
     1096        PSHCLURITRANSFER pTransfer;
    10971097        rc = SharedClipboardURITransferCreate(enmDir, enmSource, &pTransfer);
    10981098        if (RT_SUCCESS(rc))
    10991099        {
    1100             SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
     1100            SHCLPROVIDERCREATIONCTX creationCtx;
    11011101            RT_ZERO(creationCtx);
    11021102
    1103             if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
     1103            if (enmDir == SHCLURITRANSFERDIR_READ)
    11041104            {
    11051105                rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
    … …  
    11231123                }
    11241124            }
    1125             else if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_WRITE)
     1125            else if (enmDir == SHCLURITRANSFERDIR_WRITE)
    11261126            {
    11271127                AssertFailed(); /** @todo Implement this. */
    … …  
    11291129
    11301130            /* Register needed callbacks so that we can wait for the meta data to arrive here. */
    1131             SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
     1131            SHCLURITRANSFERCALLBACKS Callbacks;
    11321132            RT_ZERO(Callbacks);
    11331133
    … …  
    12101210    LogFunc(("u32ClientID=%RU32\n", u32ClientID));
    12111211
    1212     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1212    PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient;
    12131213    AssertPtr(pClient);
    12141214
    12151215#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1216     PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/);
     1216    PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/);
    12171217    if (pTransfer)
    12181218        vboxSvcClipboardURIAreaDetach(&pClient->State, pTransfer);
    … …  
    12431243    RT_NOREF(fRequestor, fRestoring);
    12441244
    1245     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1245    PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient;
    12461246    AssertPtr(pvClient);
    12471247
    … …  
    12501250
    12511251    /* Create the client's own event source. */
    1252     VBOXCLIPBOARDEVENTSOURCEID uEventSourceID;
     1252    SHCLEVENTSOURCEID uEventSourceID;
    12531253    int rc = vboxSvcClipboardEventSourceCreateID(&uEventSourceID);
    12541254    if (RT_SUCCESS(rc))
    … …  
    13021302    int rc = VINF_SUCCESS;
    13031303
    1304     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1304    PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient;
    13051305    AssertPtr(pClient);
    13061306
    … …  
    14371437                else
    14381438                {
    1439                     rc = vboxSvcClipboardSetSource(pClient, SHAREDCLIPBOARDSOURCE_REMOTE);
     1439                    rc = vboxSvcClipboardSetSource(pClient, SHCLSOURCE_REMOTE);
    14401440                    if (RT_SUCCESS(rc))
    14411441                    {
    14421442                        if (g_ExtState.pfnExtension)
    14431443                        {
    1444                             VBOXCLIPBOARDEXTPARMS parms;
     1444                            SHCLEXTPARMS parms;
    14451445                            RT_ZERO(parms);
    14461446
    … …  
    14501450                        }
    14511451
    1452                         VBOXCLIPBOARDCLIENTCMDCTX cmdCtx;
     1452                        SHCLCLIENTCMDCTX cmdCtx;
    14531453                        RT_ZERO(cmdCtx);
    14541454
    1455                         SHAREDCLIPBOARDFORMATDATA formatData;
     1455                        SHCLFORMATDATA formatData;
    14561456                        RT_ZERO(formatData);
    14571457
    … …  
    14991499                            SharedClipboardURICtxTransfersCleanup(&pClient->URI);
    15001500
    1501                             PSHAREDCLIPBOARDURITRANSFER pTransfer;
    1502                             rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
     1501                            PSHCLURITRANSFER pTransfer;
     1502                            rc = SharedClipboardURITransferCreate(SHCLURITRANSFERDIR_WRITE,
    15031503                                                                  pClient->State.enmSource,
    15041504                                                                  &pTransfer);
    … …  
    15091509                                if (RT_SUCCESS(rc))
    15101510                                {
    1511                                     SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
     1511                                    SHCLPROVIDERCREATIONCTX creationCtx;
    15121512                                    RT_ZERO(creationCtx);
    15131513
    … …  
    15571557                            if (g_ExtState.pfnExtension)
    15581558                            {
    1559                                 VBOXCLIPBOARDEXTPARMS parms;
     1559                                SHCLEXTPARMS parms;
    15601560                                RT_ZERO(parms);
    15611561
    … …  
    15771577                                if (g_ExtState.fDelayedAnnouncement)
    15781578                                {
    1579                                     SHAREDCLIPBOARDFORMATDATA formatData;
     1579                                    SHCLFORMATDATA formatData;
    15801580                                    RT_ZERO(formatData);
    15811581
    … …  
    16001600                             *       so data which has been read above might get overridden by the host clipboard eventually. */
    16011601
    1602                             VBOXCLIPBOARDCLIENTCMDCTX cmdCtx;
     1602                            SHCLCLIENTCMDCTX cmdCtx;
    16031603                            RT_ZERO(cmdCtx);
    16041604
    … …  
    16071607                            if (RT_SUCCESS(rc))
    16081608                            {
    1609                                 SHAREDCLIPBOARDDATABLOCK dataBlock;
     1609                                SHCLDATABLOCK dataBlock;
    16101610                                RT_ZERO(dataBlock);
    16111611
    … …  
    16601660 * @param   uClientID           Client ID (HGCM) to use for this client state.
    16611661 */
    1662 static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTSTATE pClientState, uint32_t uClientID)
     1662static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
    16631663{
    16641664    LogFlowFuncEnter();
    … …  
    16801680 * @param   pClientState        Client state to destroy.
    16811681 */
    1682 static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTSTATE pClientState)
     1682static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState)
    16831683{
    16841684    RT_NOREF(pClientState);
    … …  
    16941694 * @param   pClientState    Client state to reset.
    16951695 */
    1696 static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState)
     1696static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState)
    16971697{
    16981698    LogFlowFuncEnter();
    16991699
    17001700#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1701     pClientState->URI.enmTransferDir = SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN;
     1701    pClientState->URI.enmTransferDir = SHCLURITRANSFERDIR_UNKNOWN;
    17021702#else
    17031703    RT_NOREF(pClientState);
    … …  
    17741774#ifndef UNIT_TEST
    17751775/**
    1776  * SSM descriptor table for the VBOXCLIPBOARDCLIENTSTATE structure.
     1776 * SSM descriptor table for the SHCLCLIENTSTATE structure.
    17771777 */
    17781778static SSMFIELD const s_aShClSSMClientState[] =
    17791779{
    1780     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, uProtocolVer),
    1781     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, cbChunkSize),
    1782     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, enmSource),
     1780    SSMFIELD_ENTRY(SHCLCLIENTSTATE, uProtocolVer),
     1781    SSMFIELD_ENTRY(SHCLCLIENTSTATE, cbChunkSize),
     1782    SSMFIELD_ENTRY(SHCLCLIENTSTATE, enmSource),
    17831783    SSMFIELD_ENTRY_TERM()
    17841784};
    17851785
    17861786/**
    1787  * SSM descriptor table for the VBOXCLIPBOARDCLIENTURISTATE structure.
     1787 * SSM descriptor table for the SHCLCLIENTURISTATE structure.
    17881788 */
    17891789static SSMFIELD const s_aShClSSMClientURIState[] =
    17901790{
    1791     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTURISTATE, enmTransferDir),
     1791    SSMFIELD_ENTRY(SHCLCLIENTURISTATE, enmTransferDir),
    17921792    SSMFIELD_ENTRY_TERM()
    17931793};
    17941794
    17951795/**
    1796  * SSM descriptor table for the header of the VBOXCLIPBOARDCLIENTMSG structure.
     1796 * SSM descriptor table for the header of the SHCLCLIENTMSG structure.
    17971797 * The actual message parameters will be serialized separately.
    17981798 */
    17991799static SSMFIELD const s_aShClSSMClientMsgHdr[] =
    18001800{
    1801     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTMSG, m_uMsg),
    1802     SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTMSG, m_cParms),
     1801    SSMFIELD_ENTRY(SHCLCLIENTMSG, m_uMsg),
     1802    SSMFIELD_ENTRY(SHCLCLIENTMSG, m_cParms),
    18031803    SSMFIELD_ENTRY_TERM()
    18041804};
    … …  
    18271827    LogFunc(("u32ClientID=%RU32\n", u32ClientID));
    18281828
    1829     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1829    PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient;
    18301830    AssertPtr(pClient);
    18311831
    … …  
    18451845    for (size_t i = 0; i < pClient->queueMsg.size(); i++)
    18461846    {
    1847         PVBOXCLIPBOARDCLIENTMSG pMsg = pClient->queueMsg.at(i);
     1847        PSHCLCLIENTMSG pMsg = pClient->queueMsg.at(i);
    18481848        AssertPtr(pMsg);
    18491849
    1850         rc = SSMR3PutStructEx(pSSM, pMsg, sizeof(VBOXCLIPBOARDCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL);
     1850        rc = SSMR3PutStructEx(pSSM, pMsg, sizeof(SHCLCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL);
    18511851        AssertRCReturn(rc, rc);
    18521852
    … …  
    19091909    LogFunc(("u32ClientID=%RU32\n", u32ClientID));
    19101910
    1911     PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient;
     1911    PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient;
    19121912    AssertPtr(pClient);
    19131913
    … …  
    19351935        for (uint64_t i = 0; i < cMsg; i++)
    19361936        {
    1937             PVBOXCLIPBOARDCLIENTMSG pMsg = (PVBOXCLIPBOARDCLIENTMSG)RTMemAlloc(sizeof(VBOXCLIPBOARDCLIENTMSG));
     1937            PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG));
    19381938            AssertPtrReturn(pMsg, VERR_NO_MEMORY);
    19391939
    1940             rc = SSMR3GetStructEx(pSSM, pMsg, sizeof(VBOXCLIPBOARDCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL);
     1940            rc = SSMR3GetStructEx(pSSM, pMsg, sizeof(SHCLCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL);
    19411941            AssertRCReturn(rc, rc);
    19421942
    … …  
    19841984    if (itClient != g_mapClients.end())
    19851985    {
    1986         PVBOXCLIPBOARDCLIENT pClient = itClient->second;
     1986        PSHCLCLIENT pClient = itClient->second;
    19871987        AssertPtr(pClient);
    19881988
    … …  
    20002000                else
    20012001                {
    2002                     SHAREDCLIPBOARDFORMATDATA formatData;
     2002                    SHCLFORMATDATA formatData;
    20032003                    RT_ZERO(formatData);
    20042004
    … …  
    20142014            case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
    20152015            {
    2016                 SHAREDCLIPBOARDDATAREQ dataReq;
     2016                SHCLDATAREQ dataReq;
    20172017                RT_ZERO(dataReq);
    20182018
    … …  
    20402040    LogFlowFunc(("pfnExtension=%p\n", pfnExtension));
    20412041
    2042     VBOXCLIPBOARDEXTPARMS parms;
     2042    SHCLEXTPARMS parms;
    20432043    RT_ZERO(parms);
    20442044
    … …  
    20892089            g_pHelpers = pTable->pHelpers;
    20902090
    2091             pTable->cbClient = sizeof(VBOXCLIPBOARDCLIENT);
     2091            pTable->cbClient = sizeof(SHCLCLIENT);
    20922092
    20932093            pTable->pfnUnload     = svcUnload;

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

    r80626 r80662  
    2626extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable);
    2727
    28 static VBOXCLIPBOARDCLIENT g_Client;
     28static SHCLCLIENT g_Client;
    2929static VBOXHGCMSVCHELPERS g_Helpers = { NULL };
    3030
    … …  
    279279int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; }
    280280void VBoxClipboardSvcImplDestroy() { }
    281 int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT)
     281int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT)
    282282{ return VINF_SUCCESS; }
    283 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT, bool)
     283int VBoxClipboardSvcImplConnect(PSHCLCLIENT, bool)
    284284{ return VINF_SUCCESS; }
    285 int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX, PSHAREDCLIPBOARDFORMATDATA)
     285int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA)
    286286{ AssertFailed(); return VINF_SUCCESS; }
    287 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX, PSHAREDCLIPBOARDDATABLOCK, unsigned int *)
     287int VBoxClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *)
    288288{ AssertFailed(); return VERR_WRONG_ORDER; }
    289 int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX, PSHAREDCLIPBOARDDATABLOCK)
     289int VBoxClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK)
    290290{ AssertFailed(); return VINF_SUCCESS; }
    291 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT)
     291int VBoxClipboardSvcImplSync(PSHCLCLIENT)
    292292{ AssertFailed(); return VERR_WRONG_ORDER; }
    293293
Note: See TracChangeset for help on using the changeset viewer.

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