VirtualBox

Changeset 81223 in vbox


Ignore:
Timestamp:
Oct 11, 2019 12:06:49 PM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard/Transfers: Renaming.

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/GuestHost/SharedClipboard-transfers.h

    r81220 r81223  
    10331033} SHCLTRANSFERCTX, *PSHCLTRANSFERCTX;
    10341034
    1035 int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
    1036 void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
    1037 bool SharedClipboardTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
    1038 
    1039 int SharedClipboardTransferObjectHandleInfoInit(PSHCLOBJHANDLEINFO pInfo);
    1040 void SharedClipboardTransferObjectHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo);
    1041 
    1042 int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
    1043 int SharedClipboardTransferObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
    1044 void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
    1045 
    1046 int SharedClipboardTransferObjectOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj);
    1047 int SharedClipboardTransferObjectClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj);
    1048 int SharedClipboardTransferObjectRead(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
    1049 int SharedClipboardTransferObjectWrite(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
    1050 
    1051 PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
    1052 void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
    1053 void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
    1054 
    1055 int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer);
    1056 int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer);
    1057 
    1058 int SharedClipboardTransferInit(PSHCLTRANSFER pTransfer, uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource);
    1059 int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer);
    1060 int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer);
    1061 
    1062 int SharedClipboardTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
    1063 int SharedClipboardTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
    1064 int SharedClipboardTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTHDR pHdr);
    1065 PSHCLTRANSFEROBJ SharedClipboardTransferListGetObj(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, uint64_t uIdx);
    1066 int SharedClipboardTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
    1067 int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
    1068 bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
    1069 
    1070 int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath);
    1071 int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
    1072 
    1073 PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void);
    1074 void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList);
    1075 
    1076 PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
    1077 int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
    1078 void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
    1079 
    1080 int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
    1081 int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
    1082 void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
    1083 PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
    1084 
    1085 int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo);
    1086 void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo);
    1087 
    1088 int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
    1089 void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
     1035int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
     1036void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
     1037bool ShClTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
     1038
     1039int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo);
     1040void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo);
     1041
     1042int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
     1043int ShClTransferObjOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
     1044void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
     1045
     1046int ShClTransferObjOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj);
     1047int ShClTransferObjClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj);
     1048int ShClTransferObjRead(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
     1049int ShClTransferObjWrite(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
     1050
     1051PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
     1052void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
     1053void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
     1054
     1055int ShClTransferCreate(PSHCLTRANSFER *ppTransfer);
     1056int ShClTransferDestroy(PSHCLTRANSFER pTransfer);
     1057
     1058int ShClTransferInit(PSHCLTRANSFER pTransfer, uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource);
     1059int ShClTransferOpen(PSHCLTRANSFER pTransfer);
     1060int ShClTransferClose(PSHCLTRANSFER pTransfer);
     1061
     1062int ShClTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
     1063int ShClTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
     1064int ShClTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTHDR pHdr);
     1065PSHCLTRANSFEROBJ ShClTransferListGetObj(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, uint64_t uIdx);
     1066int ShClTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
     1067int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
     1068bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
     1069
     1070int ShClPathSanitizeFilename(char *pszPath, size_t cbPath);
     1071int ShClPathSanitize(char *pszPath, size_t cbPath);
     1072
     1073PSHCLROOTLIST ShClTransferRootListAlloc(void);
     1074void ShClTransferRootListFree(PSHCLROOTLIST pRootList);
     1075
     1076PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
     1077int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
     1078void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
     1079
     1080int ShClTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
     1081int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
     1082void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
     1083PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
     1084
     1085int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo);
     1086void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo);
     1087
     1088int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
     1089void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr);
    10901090PSHCLLISTHDR SharedClipboardTransferListHdrDup(PSHCLLISTHDR pListHdr);
    1091 int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr);
    1092 void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
    1093 void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
    1094 void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr);
    1095 bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
    1096 
    1097 int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
    1098 PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
    1099 int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
    1100 void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
    1101 
    1102 int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
    1103 void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry);
    1104 int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
    1105 PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry);
    1106 int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry);
    1107 void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
    1108 bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
    1109 
    1110 int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer, PSHCLPROVIDERCREATIONCTX pCreationCtx);
    1111 int SharedClipboardTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
    1112 void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer);
    1113 SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer);
    1114 
    1115 uint32_t SharedClipboardTransferRootsCount(PSHCLTRANSFER pTransfer);
    1116 int SharedClipboardTransferRootsEntry(PSHCLTRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
    1117 int SharedClipboardTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
    1118 
    1119 SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer);
    1120 SHCLTRANSFERDIR SharedClipboardTransferGetDir(PSHCLTRANSFER pTransfer);
    1121 SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer);
    1122 SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer);
    1123 int SharedClipboardTransferHandleReply(PSHCLTRANSFER pTransfer, PSHCLREPLY pReply);
    1124 int SharedClipboardTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
    1125 int SharedClipboardTransferStart(PSHCLTRANSFER pTransfer);
    1126 void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer, PSHCLTRANSFERCALLBACKS pCallbacks);
    1127 
    1128 int SharedClipboardTransferRead(PSHCLTRANSFER pTransfer);
    1129 int SharedClipboardTransferReadObjects(PSHCLTRANSFER pTransfer);
    1130 
    1131 int SharedClipboardTransferWrite(PSHCLTRANSFER pTransfer);
    1132 int SharedClipboardTransferWriteObjects(PSHCLTRANSFER pTransfer);
    1133 
    1134 int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx);
    1135 void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx);
    1136 void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx);
    1137 PSHCLTRANSFER SharedClipboardTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
    1138 uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx);
    1139 uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx);
    1140 void SharedClipboardTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx);
    1141 bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx);
    1142 int SharedClipboardTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer);
    1143 int SharedClipboardTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer);
    1144 int SharedClipboardTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer);
    1145 
    1146 void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc);
    1147 
    1148 bool SharedClipboardMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax);
    1149 bool SharedClipboardMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax);
    1150 
    1151 const char *VBoxShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus);
     1091int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr);
     1092void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
     1093void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr);
     1094bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
     1095
     1096int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
     1097PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
     1098int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
     1099void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
     1100
     1101int ShClTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
     1102void ShClTransferListEntryFree(PSHCLLISTENTRY pListEntry);
     1103int ShClTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
     1104PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry);
     1105int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry);
     1106void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
     1107bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
     1108
     1109int ShClTransferSetInterface(PSHCLTRANSFER pTransfer, PSHCLPROVIDERCREATIONCTX pCreationCtx);
     1110int ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
     1111void ShClTransferReset(PSHCLTRANSFER pTransfer);
     1112SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer);
     1113
     1114uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer);
     1115int ShClTransferRootsEntry(PSHCLTRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
     1116int ShClTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
     1117
     1118SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer);
     1119SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer);
     1120SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer);
     1121SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer);
     1122int ShClTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
     1123int ShClTransferStart(PSHCLTRANSFER pTransfer);
     1124void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer, PSHCLTRANSFERCALLBACKS pCallbacks);
     1125
     1126int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx);
     1127void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx);
     1128void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx);
     1129PSHCLTRANSFER ShClTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
     1130uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx);
     1131uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx);
     1132void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx);
     1133bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx);
     1134int ShClTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer);
     1135int ShClTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer);
     1136int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer);
     1137
     1138void ShClFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc);
     1139
     1140bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax);
     1141bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax);
     1142
     1143const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus);
    11521144
    11531145#endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_transfers_h */

  • trunk/include/VBox/GuestHost/SharedClipboard.h

    r81044 r81223  
    180180} SHCLEVENTSOURCE, *PSHCLEVENTSOURCE;
    181181
    182 int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
    183                                 PSHCLEVENTPAYLOAD *ppPayload);
    184 void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload);
    185 
    186 int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID);
    187 void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource);
    188 
    189 SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource);
    190 SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource);
    191 int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
    192 int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
    193 int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
    194                              PSHCLEVENTPAYLOAD* ppPayload);
    195 int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, PSHCLEVENTPAYLOAD pPayload);
    196 void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
     182/** @name Shared Clipboard data payload functions.
     183 *  @{
     184 */
     185int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData, PSHCLEVENTPAYLOAD *ppPayload);
     186void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload);
     187/** @} */
     188
     189/** @name Shared Clipboard event source functions.
     190 *  @{
     191 */
     192int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID);
     193void ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource);
     194/** @} */
     195
     196/** @name Shared Clipboard event functions.
     197 *  @{
     198 */
     199SHCLEVENTID ShClEventIDGenerate(PSHCLEVENTSOURCE pSource);
     200SHCLEVENTID ShClEventGetLast(PSHCLEVENTSOURCE pSource);
     201int ShClEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
     202int ShClEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
     203int ShClEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs, PSHCLEVENTPAYLOAD* ppPayload);
     204int ShClEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, PSHCLEVENTPAYLOAD pPayload);
     205void ShClEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID);
     206/** @} */
    197207
    198208/**
    … …  
    225235typedef struct _CLIPREADCBREQ CLIPREADCBREQ;
    226236
    227 /* APIs exported by the X11 backend. */
     237/** @name Shared Clipboard APIs exported by the X11 backend.
     238 *  @{
     239 */
    228240extern CLIPBACKEND *ClipConstructX11(SHCLCONTEXT *pFrontend, bool fHeadless);
    229241extern void ClipDestructX11(CLIPBACKEND *pBackend);
    … …  
    232244extern int ClipAnnounceFormatToX11(CLIPBACKEND *pBackend, SHCLFORMATS vboxFormats);
    233245extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, SHCLFORMATS vboxFormat, CLIPREADCBREQ *pReq);
    234 
    235 /* APIs (as callbacks) exported by the X11/VBox frontend. */
     246/** @} */
     247
     248/** @name Shared Clipboard APIs (as callbacks) exported by the X11/VBox frontend.
     249 *  @{
     250 */
    236251extern DECLCALLBACK(int)  ClipRequestDataForX11Callback(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb);
    237252extern DECLCALLBACK(void) ClipReportX11FormatsCallback(SHCLCONTEXT *pCtx, uint32_t u32Formats);
    238253extern DECLCALLBACK(void) ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb);
     254/** @} */
    239255#endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_h */
    240256

  • trunk/include/VBox/GuestHost/clipboard-helper.h

    r80990 r81223  
    5757 * @param   pcwcDst  The length of the destination string in RTUTF16 units.
    5858 */
    59 int vboxClipboardUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
     59int ShClUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
    6060
    6161/**
    … …  
    7272 * @param   cwcDst   Size of the buffer for the converted text in RTUTF16 units.
    7373 */
    74 int vboxClipboardUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
     74int ShClUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
    7575
    7676/**
    … …  
    8484 * @retval  pcwcDst  The length of the destination string in RTUTF16 units.
    8585 */
    86 int vboxClipboardUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
     86int ShClUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwcSrc, size_t *pcwcDst);
    8787
    8888/**
    … …  
    9898 *                   chars.
    9999 */
    100 int vboxClipboardUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
     100int ShClUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwcSrc, PRTUTF16 pwszDst, size_t cwcDst);
    101101
    102102#pragma pack(1)
    … …  
    157157 *                        data in bytes.
    158158 */
    159 int vboxClipboardDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDst, size_t *pcbDst);
     159int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDst, size_t *pcbDst);
    160160
    161161/**
    … …  
    170170 * @param   pcbDst        Pointer to the size of the destination data in bytes
    171171 */
    172 int vboxClipboardBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDst, size_t *pcbDst);
     172int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDst, size_t *pcbDst);
    173173
    174174#ifdef LOG_ENABLED
    … …  
    180180 * @param   cbSrc               Size (in bytes) of HTML data to dump.
    181181 */
    182 int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc);
     182int ShClDbgDumpHtml(const char *pszSrc, size_t cbSrc);
    183183
    184184/**
    … …  
    189189 * @param   u32Format           Clipboard format to use for dumping.
    190190 */
    191 void VBoxShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format);
     191void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format);
    192192#endif /* LOG_ENABLED */
    193193
    … …  
    198198 * @param   uFn                 The function to translate.
    199199 */
    200 const char *VBoxShClHostFunctionToStr(uint32_t uFn);
     200const char *ShClHostFunctionToStr(uint32_t uFn);
    201201
    202202/**
    … …  
    206206 * @param   uMsg                The message to translate.
    207207 */
    208 const char *VBoxShClHostMsgToStr(uint32_t uMsg);
     208const char *ShClHostMsgToStr(uint32_t uMsg);
    209209
    210210/**
    … …  
    214214 * @param   uMsg                The message to translate.
    215215 */
    216 const char *VBoxShClGuestMsgToStr(uint32_t uMsg);
     216const char *ShClGuestMsgToStr(uint32_t uMsg);
    217217
    218218#endif /* !VBOX_INCLUDED_GuestHost_clipboard_helper_h */

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r81213 r81223  
    115115    }
    116116
    117     int rc2 = SharedClipboardTransferCtxTransferUnregister(pCtx, pTransfer->State.uID);
     117    int rc2 = ShClTransferCtxTransferUnregister(pCtx, pTransfer->State.uID);
    118118    AssertRC(rc2);
    119119
    120     SharedClipboardTransferDestroy(pTransfer);
     120    ShClTransferDestroy(pTransfer);
    121121
    122122    RTMemFree(pTransfer);
    … …  
    145145    AssertPtr(pTransfer);
    146146
    147     const SHCLTRANSFERDIR enmDir = SharedClipboardTransferGetDir(pTransfer);
    148 
    149     LogFlowFunc(("pCtx=%p, idTransfer=%RU16, enmDir=%RU32\n", pCtx, SharedClipboardTransferGetID(pTransfer), enmDir));
     147    const SHCLTRANSFERDIR enmDir = ShClTransferGetDir(pTransfer);
     148
     149    LogFlowFunc(("pCtx=%p, idTransfer=%RU16, enmDir=%RU32\n", pCtx, ShClTransferGetID(pTransfer), enmDir));
    150150
    151151    int rc;
    … …  
    161161        /* The IDataObject *must* be created on the same thread as our (proxy) window, so post a message to it
    162162         * to do the stuff for us. */
    163         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
    164 
    165         rc = SharedClipboardEventRegister(&pTransfer->Events, uEvent);
     163        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pTransfer->Events);
     164
     165        rc = ShClEventRegister(&pTransfer->Events, uEvent);
    166166        if (RT_SUCCESS(rc))
    167167        {
    … …  
    170170
    171171            PSHCLEVENTPAYLOAD pPayload;
    172             rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, 30 * 1000 /* Timeout in ms */, &pPayload);
     172            rc = ShClEventWait(&pTransfer->Events, uEvent, 30 * 1000 /* Timeout in ms */, &pPayload);
    173173            if (RT_SUCCESS(rc))
    174174            {
    … …  
    176176                rc = *(int *)pPayload->pvData;
    177177
    178                 SharedClipboardPayloadFree(pPayload);
    179             }
    180 
    181             SharedClipboardEventUnregister(&pTransfer->Events, uEvent);
     178                ShClPayloadFree(pPayload);
     179            }
     180
     181            ShClEventUnregister(&pTransfer->Events, uEvent);
    182182        }
    183183    }
    … …  
    188188        LogRel(("Shared Clipboard: Starting transfer failed, rc=%Rrc\n", rc));
    189189
    190     LogFlowFunc(("LEAVE: idTransfer=%RU16, rc=%Rrc\n", SharedClipboardTransferGetID(pTransfer), rc));
     190    LogFlowFunc(("LEAVE: idTransfer=%RU16, rc=%Rrc\n", ShClTransferGetID(pTransfer), rc));
    191191    return rc;
    192192}
    … …  
    649649            const SHCLEVENTID uEvent = (SHCLEVENTID)lParam;
    650650
    651             Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
     651            Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
    652652
    653653            int rcTransfer = SharedClipboardWinTransferCreate(pWinCtx, pTransfer);
    654654
    655655            PSHCLEVENTPAYLOAD pPayload = NULL;
    656             int rc = SharedClipboardPayloadAlloc(uEvent, &rcTransfer, sizeof(rcTransfer), &pPayload);
     656            int rc = ShClPayloadAlloc(uEvent, &rcTransfer, sizeof(rcTransfer), &pPayload);
    657657            if (RT_SUCCESS(rc))
    658658            {
    659                 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     659                rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    660660                if (RT_FAILURE(rc))
    661                     SharedClipboardPayloadFree(pPayload);
     661                    ShClPayloadFree(pPayload);
    662662            }
    663663
    … …  
    910910        {
    911911#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    912             rc = SharedClipboardTransferCtxInit(&pCtx->TransferCtx);
     912            rc = ShClTransferCtxInit(&pCtx->TransferCtx);
    913913#endif
    914914            if (RT_SUCCESS(rc))
    … …  
    11781178
    11791179#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1180     SharedClipboardTransferCtxDestroy(&pCtx->TransferCtx);
     1180    ShClTransferCtxDestroy(&pCtx->TransferCtx);
    11811181#endif
    11821182

  • trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp

    r81220 r81223  
    483483    int rc;
    484484
    485     PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
     485    PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
    486486    if (pRootList)
    487487    {
    … …  
    504504                        AssertPtr(pEntry);
    505505
    506                         rc = SharedClipboardTransferRootListEntryInit(pEntry);
     506                        rc = ShClTransferRootListEntryInit(pEntry);
    507507                        if (RT_SUCCESS(rc))
    508508                            rc = vbglR3ClipboardRootListEntryRead(pCtx, i, pEntry);
    … …  
    522522        }
    523523        else
    524             SharedClipboardTransferRootListFree(pRootList);
     524            ShClTransferRootListFree(pRootList);
    525525    }
    526526    else
    … …  
    607607    Msg.u.TransferStatus.enmStatus.SetUInt32((uint32_t)uStatus);
    608608
    609     LogFlowFunc(("%s\n", VBoxShClTransferStatusToStr(uStatus)));
     609    LogFlowFunc(("%s\n", ShClTransferStatusToStr(uStatus)));
    610610
    611611    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    15651565    AssertPtr(pCmdCtx);
    15661566
    1567     int rc = SharedClipboardTransferListHdrInit(pListHdr);
     1567    int rc = ShClTransferListHdrInit(pListHdr);
    15681568    if (RT_SUCCESS(rc))
    15691569    {
    … …  
    15731573        }
    15741574        else
    1575             SharedClipboardTransferListHdrDestroy(pListHdr);
     1575            ShClTransferListHdrDestroy(pListHdr);
    15761576    }
    15771577
    … …  
    16541654{
    16551655    PSHCLTRANSFER pTransfer;
    1656     int rc = SharedClipboardTransferCreate(&pTransfer);
    1657     if (RT_SUCCESS(rc))
    1658     {
    1659         SharedClipboardTransferSetCallbacks(pTransfer, &pCmdCtx->Transfers.Callbacks);
    1660 
    1661         rc = SharedClipboardTransferCtxTransferRegisterByIndex(pTransferCtx, pTransfer, uTransferID);
    1662         if (RT_SUCCESS(rc))
    1663         {
    1664             rc = SharedClipboardTransferInit(pTransfer, uTransferID, enmDir, enmSource);
     1656    int rc = ShClTransferCreate(&pTransfer);
     1657    if (RT_SUCCESS(rc))
     1658    {
     1659        ShClTransferSetCallbacks(pTransfer, &pCmdCtx->Transfers.Callbacks);
     1660
     1661        rc = ShClTransferCtxTransferRegisterByIndex(pTransferCtx, pTransfer, uTransferID);
     1662        if (RT_SUCCESS(rc))
     1663        {
     1664            rc = ShClTransferInit(pTransfer, uTransferID, enmDir, enmSource);
    16651665            if (RT_SUCCESS(rc))
    16661666            {
    … …  
    16851685                    creationCtx.pvUser = pCmdCtx;
    16861686
    1687                     rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
     1687                    rc = ShClTransferSetInterface(pTransfer, &creationCtx);
    16881688                }
    16891689
    16901690                if (RT_SUCCESS(rc))
    1691                     rc = SharedClipboardTransferStart(pTransfer);
     1691                    rc = ShClTransferStart(pTransfer);
    16921692            }
    16931693
    16941694            if (RT_FAILURE(rc))
    1695                 SharedClipboardTransferCtxTransferUnregister(pTransferCtx, uTransferID);
     1695                ShClTransferCtxTransferUnregister(pTransferCtx, uTransferID);
    16961696        }
    16971697    }
    … …  
    17181718    if (RT_FAILURE(rc))
    17191719    {
    1720         SharedClipboardTransferDestroy(pTransfer);
     1720        ShClTransferDestroy(pTransfer);
    17211721        pTransfer = NULL;
    17221722    }
    … …  
    17391739    int rc;
    17401740
    1741     PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx, uTransferID);
     1741    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx, uTransferID);
    17421742    if (pTransfer)
    17431743    {
    1744         rc = SharedClipboardTransferClose(pTransfer);
    1745         if (RT_SUCCESS(rc))
    1746             rc = SharedClipboardTransferCtxTransferUnregister(pTransferCtx, uTransferID);
     1744        rc = ShClTransferClose(pTransfer);
     1745        if (RT_SUCCESS(rc))
     1746            rc = ShClTransferCtxTransferUnregister(pTransferCtx, uTransferID);
    17471747
    17481748        if (RT_SUCCESS(rc))
    … …  
    17741774    AssertPtrReturn(pEvent,       VERR_INVALID_POINTER);
    17751775
    1776     LogFunc(("Handling idMsg=%RU32 (%s), cParms=%RU32\n", idMsg, VBoxShClHostMsgToStr(idMsg), cParms));
     1776    LogFunc(("Handling idMsg=%RU32 (%s), cParms=%RU32\n", idMsg, ShClHostMsgToStr(idMsg), cParms));
    17771777
    17781778    int rc;
    … …  
    17921792
    17931793                LogFlowFunc(("[Transfer %RU16] enmDir=%RU32, status=%s\n",
    1794                              uTransferID, enmDir, VBoxShClTransferStatusToStr(transferReport.uStatus)));
     1794                             uTransferID, enmDir, ShClTransferStatusToStr(transferReport.uStatus)));
    17951795
    17961796                switch (transferReport.uStatus)
    … …  
    18481848
    18491849                    LogRel2(("Shared Clipboard: Received status %s (rc=%Rrc) for transfer ID=%RU16\n",
    1850                              VBoxShClTransferStatusToStr(pEvent->u.TransferStatus.Report.uStatus), pEvent->u.TransferStatus.Report.rc,
     1850                             ShClTransferStatusToStr(pEvent->u.TransferStatus.Report.uStatus), pEvent->u.TransferStatus.Report.rc,
    18511851                             pEvent->u.TransferStatus.uID));
    18521852                }
    … …  
    18641864            if (RT_SUCCESS(rc))
    18651865            {
    1866                 PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    1867                                                                                 VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     1866                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     1867                                                                    VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    18681868                AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    18691869
    … …  
    18711871                RT_ZERO(rootListHdr);
    18721872
    1873                 rootListHdr.cRoots = SharedClipboardTransferRootsCount(pTransfer);
     1873                rootListHdr.cRoots = ShClTransferRootsCount(pTransfer);
    18741874
    18751875                LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cRoots));
    … …  
    18871887            if (RT_SUCCESS(rc))
    18881888            {
    1889                 PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    1890                                                                                 VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     1889                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     1890                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    18911891                AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    18921892
    18931893                SHCLROOTLISTENTRY rootListEntry;
    1894                 rc = SharedClipboardTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
     1894                rc = ShClTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
    18951895                if (RT_SUCCESS(rc))
    18961896                    rc = VbglR3ClipboardRootListEntryReadReply(pCmdCtx, uIndex, &rootListEntry);
    … …  
    19021902        {
    19031903            SHCLLISTOPENPARMS openParmsList;
    1904             rc = SharedClipboardTransferListOpenParmsInit(&openParmsList);
     1904            rc = ShClTransferListOpenParmsInit(&openParmsList);
    19051905            if (RT_SUCCESS(rc))
    19061906            {
    … …  
    19081908                if (RT_SUCCESS(rc))
    19091909                {
    1910                     PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    1911                                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     1910                    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     1911                                                                         VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    19121912                    AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    19131913
    … …  
    19151915
    19161916                    SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID;
    1917                     rc = SharedClipboardTransferListOpen(pTransfer, &openParmsList, &hList);
     1917                    rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList);
    19181918
    19191919                    /* Reply in any case. */
    … …  
    19221922                }
    19231923
    1924                 SharedClipboardTransferListOpenParmsDestroy(&openParmsList);
     1924                ShClTransferListOpenParmsDestroy(&openParmsList);
    19251925            }
    19261926
    … …  
    19341934            if (RT_SUCCESS(rc))
    19351935            {
    1936                 PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    1937                                                                                 VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     1936                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     1937                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    19381938                AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    19391939
    1940                 rc = SharedClipboardTransferListClose(pTransfer, hList);
     1940                rc = ShClTransferListClose(pTransfer, hList);
    19411941
    19421942                /* Reply in any case. */
    … …  
    19571957            if (RT_SUCCESS(rc))
    19581958            {
    1959                 PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    1960                                                                                 VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     1959                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     1960                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    19611961                AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    19621962
    19631963                SHCLLISTHDR hdrList;
    1964                 rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
     1964                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
    19651965                if (RT_SUCCESS(rc))
    19661966                {
    19671967                    rc = VbglR3ClipboardListHdrWrite(pCmdCtx, hList, &hdrList);
    19681968
    1969                     SharedClipboardTransferListHdrDestroy(&hdrList);
     1969                    ShClTransferListHdrDestroy(&hdrList);
    19701970                }
    19711971            }
    … …  
    19791979
    19801980            SHCLLISTENTRY entryList;
    1981             rc = SharedClipboardTransferListEntryInit(&entryList);
     1981            rc = ShClTransferListEntryInit(&entryList);
    19821982            if (RT_SUCCESS(rc))
    19831983            {
    … …  
    19871987                if (RT_SUCCESS(rc))
    19881988                {
    1989                     PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    1990                                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     1989                    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     1990                                                                         VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    19911991                    AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    19921992
    1993                     rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
     1993                    rc = ShClTransferListRead(pTransfer, hList, &entryList);
    19941994                    if (RT_SUCCESS(rc))
    19951995                    {
    … …  
    20052005                }
    20062006
    2007                 SharedClipboardTransferListEntryDestroy(&entryList);
     2007                ShClTransferListEntryDestroy(&entryList);
    20082008            }
    20092009
    … …  
    20142014        {
    20152015            SHCLOBJOPENCREATEPARMS openParms;
    2016             rc = SharedClipboardTransferObjectOpenParmsInit(&openParms);
     2016            rc = ShClTransferObjOpenParmsInit(&openParms);
    20172017            if (RT_SUCCESS(rc))
    20182018            {
    … …  
    20202020                if (RT_SUCCESS(rc))
    20212021                {
    2022                     PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    2023                                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     2022                    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     2023                                                                         VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    20242024                    AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    20252025
    20262026                    SHCLOBJHANDLE hObj;
    2027                     rc = SharedClipboardTransferObjectOpen(pTransfer, &openParms, &hObj);
     2027                    rc = ShClTransferObjOpen(pTransfer, &openParms, &hObj);
    20282028
    20292029                    /* Reply in any case. */
    … …  
    20322032                }
    20332033
    2034                 SharedClipboardTransferObjectOpenParmsDestroy(&openParms);
     2034                ShClTransferObjOpenParmsDestroy(&openParms);
    20352035            }
    20362036
    … …  
    20442044            if (RT_SUCCESS(rc))
    20452045            {
    2046                 PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    2047                                                                                 VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     2046                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     2047                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    20482048                AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    20492049
    2050                 rc = SharedClipboardTransferObjectClose(pTransfer, hObj);
     2050                rc = ShClTransferObjClose(pTransfer, hObj);
    20512051
    20522052                /* Reply in any case. */
    … …  
    20662066            if (RT_SUCCESS(rc))
    20672067            {
    2068                 PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(pTransferCtx,
    2069                                                                                 VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
     2068                PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(pTransferCtx,
     2069                                                                     VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID));
    20702070                AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    20712071
    … …  
    20812081                {
    20822082                    uint32_t cbRead;
    2083                     rc = SharedClipboardTransferObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
     2083                    rc = ShClTransferObjRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
    20842084                    if (RT_SUCCESS(rc))
    20852085                        rc = VbglR3ClipboardObjWriteSend(pCmdCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
    … …  
    21272127
    21282128#ifdef LOG_ENABLED
    2129     LogFunc(("Handling idMsg=%RU32 (%s), protocol v%RU32\n", idMsg, VBoxShClHostMsgToStr(idMsg), pCtx->uProtocolVer));
     2129    LogFunc(("Handling idMsg=%RU32 (%s), protocol v%RU32\n", idMsg, ShClHostMsgToStr(idMsg), pCtx->uProtocolVer));
    21302130#endif
    21312131    switch (idMsg)

  • trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp

    r80847 r81223  
    222222
    223223    size_t cwcActual; /* (includes a schwarzenegger character) */
    224     int rc = vboxClipboardUtf16GetWinSize(pwszData, cbData / sizeof(RTUTF16), &cwcActual);
     224    int rc = ShClUtf16GetWinSize(pwszData, cbData / sizeof(RTUTF16), &cwcActual);
    225225    AssertReturn(RT_SUCCESS(rc), rc);
    226226
    … …  
    228228    AssertReturn(pwszWinTmp, VERR_NO_MEMORY);
    229229
    230     rc = vboxClipboardUtf16LinToWin(pwszData, cbData / sizeof(RTUTF16), pwszWinTmp, cwcActual);
     230    rc = ShClUtf16LinToWin(pwszData, cbData / sizeof(RTUTF16), pwszWinTmp, cwcActual);
    231231    if (RT_SUCCESS(rc))
    232232        rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_UNICODETEXT,
    … …  
    250250    const void   *pvDib;
    251251    size_t        cbDib;
    252     int rc = vboxClipboardBmpGetDib(pvData, cbData, &pvDib, &cbDib);
     252    int rc = ShClBmpGetDib(pvData, cbData, &pvDib, &cbDib);
    253253    AssertRCReturn(rc, rc);
    254254

  • trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp

    r80847 r81223  
    169169
    170170    /* Convert END-OF-LINE */
    171     rc = vboxClipboardUtf16GetLinSize((RTUTF16 *)pData, cbDataSize / 2, &cbActualLen);
     171    rc = ShClUtf16GetLinSize((RTUTF16 *)pData, cbDataSize / 2, &cbActualLen);
    172172    AssertReturn(RT_SUCCESS(rc), rc);
    173173    pDataInternal = (RTUTF16 *)RTMemAlloc(cbActualLen * 2);
    174174    AssertReturn(pDataInternal, VERR_NO_MEMORY);
    175     rc = vboxClipboardUtf16WinToLin((RTUTF16 *)pData, cbDataSize / 2, pDataInternal, cbActualLen);
     175    rc = ShClUtf16WinToLin((RTUTF16 *)pData, cbDataSize / 2, pDataInternal, cbActualLen);
    176176
    177177    /* Do actual paste */
    … …  
    217217    AssertReturn(cbDataSize > 0, VINF_SUCCESS);
    218218
    219     rc = vboxClipboardDibToBmp(pData, cbDataSize, &pBmp, &cbBmpSize);
     219    rc = ShClDibToBmp(pData, cbDataSize, &pBmp, &cbBmpSize);
    220220    AssertReturn(RT_SUCCESS(rc), rc);
    221221

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

    r80990 r81223  
    197197                    void  *pBmp  = NULL;
    198198                    size_t cbBmp = 0;
    199                     rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmp);
     199                    rc = ShClDibToBmp(pv, cb, &pBmp, &cbBmp);
    200200                    if (RT_SUCCESS(rc))
    201201                    {
    … …  
    295295                                size_t cbDibSize;
    296296                                /* Strip out the BM header */
    297                                 rc = vboxClipboardBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
     297                                rc = ShClBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
    298298                                if (RT_SUCCESS(rc))
    299299                                {

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

    r81172 r81223  
    238238
    239239    SHCLLISTOPENPARMS openParmsList;
    240     int rc = SharedClipboardTransferListOpenParmsInit(&openParmsList);
     240    int rc = ShClTransferListOpenParmsInit(&openParmsList);
    241241    if (RT_SUCCESS(rc))
    242242    {
    … …  
    245245        {
    246246            SHCLLISTHANDLE hList;
    247             rc = SharedClipboardTransferListOpen(pTransfer, &openParmsList, &hList);
     247            rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList);
    248248            if (RT_SUCCESS(rc))
    249249            {
    … …  
    251251
    252252                SHCLLISTHDR hdrList;
    253                 rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
     253                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
    254254                if (RT_SUCCESS(rc))
    255255                {
    … …  
    260260                    {
    261261                        SHCLLISTENTRY entryList;
    262                         rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
     262                        rc = ShClTransferListRead(pTransfer, hList, &entryList);
    263263                        if (RT_SUCCESS(rc))
    264264                        {
    … …  
    295295                }
    296296
    297                 SharedClipboardTransferListClose(pTransfer, hList);
     297                ShClTransferListClose(pTransfer, hList);
    298298            }
    299299        }
    300300
    301         SharedClipboardTransferListOpenParmsDestroy(&openParmsList);
     301        ShClTransferListOpenParmsDestroy(&openParmsList);
    302302    }
    303303
    … …  
    334334    LogRel2(("Shared Clipboard: Calculating transfer ...\n"));
    335335
    336     int rc = SharedClipboardTransferOpen(pTransfer);
     336    int rc = ShClTransferOpen(pTransfer);
    337337    if (RT_SUCCESS(rc))
    338338    {
    339339        PSHCLROOTLIST pRootList;
    340         rc = SharedClipboardTransferRootsGet(pTransfer, &pRootList);
     340        rc = ShClTransferRootsGet(pTransfer, &pRootList);
    341341        if (RT_SUCCESS(rc))
    342342        {
    … …  
    378378            }
    379379
    380             SharedClipboardTransferRootListFree(pRootList);
     380            ShClTransferRootListFree(pRootList);
    381381            pRootList = NULL;
    382382
    … …  
    410410        }
    411411
    412         SharedClipboardTransferClose(pTransfer);
     412        ShClTransferClose(pTransfer);
    413413    }
    414414
    … …  
    574574        const bool fUnicode = pFormatEtc->cfFormat == m_cfFileDescriptorW;
    575575
    576         const uint32_t enmTransferStatus = SharedClipboardTransferGetStatus(m_pTransfer);
     576        const uint32_t enmTransferStatus = ShClTransferGetStatus(m_pTransfer);
    577577        RT_NOREF(enmTransferStatus);
    578578
    579579        LogFlowFunc(("FormatIndex_FileDescriptor%s, enmTransferStatus=%s, m_fRunning=%RTbool\n",
    580                      fUnicode ? "W" : "A", VBoxShClTransferStatusToStr(enmTransferStatus), m_fRunning));
     580                     fUnicode ? "W" : "A", ShClTransferStatusToStr(enmTransferStatus), m_fRunning));
    581581
    582582        int rc;
    … …  
    586586        {
    587587            /* Start the transfer asynchronously in a separate thread. */
    588             rc = SharedClipboardTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
     588            rc = ShClTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
    589589            if (RT_SUCCESS(rc))
    590590            {

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

    r80862 r81223  
    2626
    2727
    28 bool SharedClipboardMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
     28bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
    2929{
    3030    /** @todo "text/uri" also an official variant? */
    … …  
    3333}
    3434
    35 bool SharedClipboardMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax)
     35bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax)
    3636{
    3737    bool fNeedsDropDir = false;

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

    r80862 r81223  
    3636 * @param   cbPath              Size (in bytes) of path to sanitize.
    3737 */
    38 int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath)
     38int ShClPathSanitizeFilename(char *pszPath, size_t cbPath)
    3939{
    4040    int rc = VINF_SUCCESS;
    … …  
    7272 * @param   cbPath              Size (in bytes) of the path to sanitize.
    7373 */
    74 int SharedClipboardPathSanitize(char *pszPath, size_t cbPath)
     74int ShClPathSanitize(char *pszPath, size_t cbPath)
    7575{
    7676    RT_NOREF(pszPath, cbPath);

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

    r80858 r81223  
    188188        {
    189189            SHCLOBJOPENCREATEPARMS openParms;
    190             rc = SharedClipboardTransferObjectOpenParmsInit(&openParms);
     190            rc = ShClTransferObjOpenParmsInit(&openParms);
    191191            if (RT_SUCCESS(rc))
    192192            {
    … …  
    202202                }
    203203
    204                 SharedClipboardTransferObjectOpenParmsDestroy(&openParms);
     204                ShClTransferObjOpenParmsDestroy(&openParms);
    205205            }
    206206        }

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

    r81025 r81223  
    4141 * @param   ppPayload           Where to store the allocated event payload on success.
    4242 */
    43 int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
    44                                 PSHCLEVENTPAYLOAD *ppPayload)
     43int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
     44                     PSHCLEVENTPAYLOAD *ppPayload)
    4545{
    4646    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
    … …  
    7575 * @param   pPayload            Event payload to free.
    7676 */
    77 void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload)
     77void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload)
    7878{
    7979    if (!pPayload)
    … …  
    100100 * @param   uID                 Event ID to use.
    101101 */
    102 int SharedClipboardEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
     102int ShClEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID)
    103103{
    104104    AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
    … …  
    121121 * @param   pEvent              Event to destroy.
    122122 */
    123 void SharedClipboardEventDestroy(PSHCLEVENT pEvent)
     123void ShClEventDestroy(PSHCLEVENT pEvent)
    124124{
    125125    if (!pEvent)
    … …  
    134134    }
    135135
    136     SharedClipboardPayloadFree(pEvent->pPayload);
     136    ShClPayloadFree(pEvent->pPayload);
    137137
    138138    pEvent->uID = 0;
    … …  
    146146 * @param   uID                 ID to use for event source.
    147147 */
    148 int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
     148int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
    149149{
    150150    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
    … …  
    169169 * @param   pSource             Event source to destroy.
    170170 */
    171 void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource)
     171void ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource)
    172172{
    173173    if (!pSource)
    … …  
    182182        RTListNodeRemove(&pEvIt->Node);
    183183
    184         SharedClipboardEventDestroy(pEvIt);
     184        ShClEventDestroy(pEvIt);
    185185
    186186        RTMemFree(pEvIt);
    … …  
    198198 * @param   pSource             Event source to generate event for.
    199199 */
    200 SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource)
     200SHCLEVENTID ShClEventIDGenerate(PSHCLEVENTSOURCE pSource)
    201201{
    202202    AssertPtrReturn(pSource, 0);
    … …  
    218218 * @param   uID                 Event ID to get.
    219219 */
    220 inline PSHCLEVENT sharedClipboardEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
     220inline PSHCLEVENT shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
    221221{
    222222    PSHCLEVENT pEvIt;
    … …  
    236236 * @param   pSource             Event source to get last registered event from.
    237237 */
    238 SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource)
     238SHCLEVENTID ShClEventGetLast(PSHCLEVENTSOURCE pSource)
    239239{
    240240    AssertPtrReturn(pSource, 0);
    … …  
    251251 * @param   pEvent              Event to detach payload for.
    252252 */
    253 static void sharedClipboardEventPayloadDetachInternal(PSHCLEVENT pEvent)
     253static void shclEventPayloadDetachInternal(PSHCLEVENT pEvent)
    254254{
    255255    AssertPtrReturnVoid(pEvent);
    … …  
    265265 * @param   uID                 Event ID to register.
    266266 */
    267 int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
     267int ShClEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
    268268{
    269269    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
    … …  
    273273    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
    274274
    275     if (sharedClipboardEventGet(pSource, uID) == NULL)
     275    if (shclEventGet(pSource, uID) == NULL)
    276276    {
    277277        PSHCLEVENT pEvent
    … …  
    279279        if (pEvent)
    280280        {
    281             rc = SharedClipboardEventCreate(pEvent, uID);
     281            rc = ShClEventCreate(pEvent, uID);
    282282            if (RT_SUCCESS(rc))
    283283            {
    … …  
    308308 * @param   uID                 Event ID to unregister.
    309309 */
    310 int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
     310int ShClEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
    311311{
    312312    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
    … …  
    316316    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
    317317
    318     PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     318    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
    319319    if (pEvent)
    320320    {
    … …  
    323323        RTListNodeRemove(&pEvent->Node);
    324324
    325         SharedClipboardEventDestroy(pEvent);
     325        ShClEventDestroy(pEvent);
    326326
    327327        RTMemFree(pEvent);
    … …  
    347347 *                              SharedClipboardPayloadFree(). Optional.
    348348 */
    349 int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
    350                              PSHCLEVENTPAYLOAD* ppPayload)
     349int ShClEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs,
     350                  PSHCLEVENTPAYLOAD* ppPayload)
    351351{
    352352    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
    … …  
    357357    int rc;
    358358
    359     PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     359    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
    360360    if (pEvent)
    361361    {
    … …  
    368368
    369369                /* Make sure to detach payload here, as the caller now owns the data. */
    370                 sharedClipboardEventPayloadDetachInternal(pEvent);
     370                shclEventPayloadDetachInternal(pEvent);
    371371            }
    372372        }
    … …  
    387387 * @param   pPayload            Event payload to associate. Takes ownership. Optional.
    388388 */
    389 int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID,
    390                                PSHCLEVENTPAYLOAD pPayload)
     389int ShClEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID,
     390                    PSHCLEVENTPAYLOAD pPayload)
    391391{
    392392    AssertPtrReturn(pSource, VERR_INVALID_POINTER);
    … …  
    396396    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
    397397
    398     PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     398    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
    399399    if (pEvent)
    400400    {
    … …  
    419419 * @param   uID                 Event ID to detach payload for.
    420420 */
    421 void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
     421void ShClEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
    422422{
    423423    AssertPtrReturnVoid(pSource);
    … …  
    425425    LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID));
    426426
    427     PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID);
     427    PSHCLEVENT pEvent = shclEventGet(pSource, uID);
    428428    if (pEvent)
    429429    {
    430         sharedClipboardEventPayloadDetachInternal(pEvent);
     430        shclEventPayloadDetachInternal(pEvent);
    431431    }
    432432#ifdef DEBUG_andy
    … …  
    438438/** @todo use const where appropriate; delinuxify the code (*Lin* -> *Host*); use AssertLogRel*. */
    439439
    440 int vboxClipboardUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
     440int ShClUtf16GetWinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
    441441{
    442442    size_t cwDest, i;
    … …  
    483483}
    484484
    485 int vboxClipboardUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest,
    486                                size_t cwDest)
     485int ShClUtf16LinToWin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest, size_t cwDest)
    487486{
    488487    size_t i, j;
    … …  
    561560}
    562561
    563 int vboxClipboardUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
     562int ShClUtf16GetLinSize(PRTUTF16 pwszSrc, size_t cwSrc, size_t *pcwDest)
    564563{
    565564    size_t cwDest;
    … …  
    609608}
    610609
    611 int vboxClipboardUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest,
    612                                size_t cwDest)
     610int ShClUtf16WinToLin(PRTUTF16 pwszSrc, size_t cwSrc, PRTUTF16 pu16Dest, size_t cwDest)
    613611{
    614612    size_t cwDestPos;
    … …  
    680678}
    681679
    682 int vboxClipboardDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
     680int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
    683681{
    684682    size_t        cb            = sizeof(BMFILEHEADER) + cbSrc;
    … …  
    728726}
    729727
    730 int vboxClipboardBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
     728int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
    731729{
    732730    AssertPtrReturn(pvSrc,   VERR_INVALID_PARAMETER);
    … …  
    749747
    750748#ifdef LOG_ENABLED
    751 int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
     749int ShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
    752750{
    753751    size_t cchIgnored = 0;
    … …  
    777775}
    778776
    779 void VBoxShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
     777void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
    780778{
    781779    if (u32Format & VBOX_SHCL_FMT_UNICODETEXT)
    … …  
    822820 * @param   uFn                 The function to translate.
    823821 */
    824 const char *VBoxShClHostFunctionToStr(uint32_t uFn)
     822const char *ShClHostFunctionToStr(uint32_t uFn)
    825823{
    826824    switch (uFn)
    … …  
    844842 * @param   uMsg                The message to translate.
    845843 */
    846 const char *VBoxShClHostMsgToStr(uint32_t uMsg)
     844const char *ShClHostMsgToStr(uint32_t uMsg)
    847845{
    848846    switch (uMsg)
    … …  
    878876 * @param   uMsg                The message to translate.
    879877 */
    880 const char *VBoxShClGuestMsgToStr(uint32_t uMsg)
     878const char *ShClGuestMsgToStr(uint32_t uMsg)
    881879{
    882880    switch (uMsg)

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

    r81220 r81223  
    4444 * @returns Allocated transfer root list on success, or NULL on failure.
    4545 */
    46 PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void)
     46PSHCLROOTLIST ShClTransferRootListAlloc(void)
    4747{
    4848    PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST));
    … …  
    5757 *                              invalid after returning from this function.
    5858 */
    59 void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList)
     59void ShClTransferRootListFree(PSHCLROOTLIST pRootList)
    6060{
    6161    if (!pRootList)
    … …  
    6363
    6464    for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
    65         SharedClipboardTransferListEntryDestroy(&pRootList->paEntries[i]);
     65        ShClTransferListEntryInit(&pRootList->paEntries[i]);
    6666
    6767    RTMemFree(pRootList);
    … …  
    7575 * @param   pRootLstHdr         Root list header to initialize.
    7676 */
    77 int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
     77int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
    7878{
    7979    AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER);
    … …  
    8989 * @param   pRootLstHdr         Root list header to destroy.
    9090 */
    91 void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
     91void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
    9292{
    9393    if (!pRootLstHdr)
    … …  
    104104 * @param   pRootLstHdr         Root list header to duplicate.
    105105 */
    106 PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
     106PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
    107107{
    108108    AssertPtrReturn(pRootLstHdr, NULL);
    … …  
    120120    if (RT_FAILURE(rc))
    121121    {
    122         SharedClipboardTransferRootListHdrDestroy(pRootsDup);
     122        ShClTransferRootListHdrDestroy(pRootsDup);
    123123        pRootsDup = NULL;
    124124    }
    … …  
    134134 * @param   pSrc                Source root list entry to copy.
    135135 */
    136 int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
    137 {
    138     return SharedClipboardTransferListEntryCopy(pDst, pSrc);
     136int ShClTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
     137{
     138    return ShClTransferListEntryCopy(pDst, pSrc);
    139139}
    140140
    … …  
    144144 * @param   pRootListEntry      Clipboard root list entry structure to destroy.
    145145 */
    146 int SharedClipboardTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry)
    147 {
    148     return SharedClipboardTransferListEntryInit(pRootListEntry);
     146int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry)
     147{
     148    return ShClTransferListEntryInit(pRootListEntry);
    149149}
    150150
    … …  
    154154 * @param   pRootListEntry      Clipboard root list entry structure to destroy.
    155155 */
    156 void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
    157 {
    158     return SharedClipboardTransferListEntryDestroy(pRootListEntry);
     156void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
     157{
     158    return ShClTransferListEntryDestroy(pRootListEntry);
    159159}
    160160
    … …  
    165165 * @param   pRootListEntry      Clipboard root list entry to duplicate.
    166166 */
    167 PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
    168 {
    169     return SharedClipboardTransferListEntryDup(pRootListEntry);
     167PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
     168{
     169    return ShClTransferListEntryDup(pRootListEntry);
    170170}
    171171
    … …  
    176176 * @param   pInfo               List handle info structure to initialize.
    177177 */
    178 int SharedClipboardTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
     178int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo)
    179179{
    180180    AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
    … …  
    195195 * @param   pInfo               List handle info structure to destroy.
    196196 */
    197 void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
     197void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
    198198{
    199199    if (!pInfo)
    … …  
    213213 * @param   ppListHdr           Where to store the allocated transfer list header structure on success.
    214214 */
    215 int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
     215int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
    216216{
    217217    int rc;
    … …  
    235235 * @param   pListEntry          transfer list header structure to free.
    236236 */
    237 void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr)
     237void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr)
    238238{
    239239    if (!pListHdr)
    … …  
    242242    LogFlowFuncEnter();
    243243
    244     SharedClipboardTransferListHdrDestroy(pListHdr);
     244    ShClTransferListHdrDestroy(pListHdr);
    245245
    246246    RTMemFree(pListHdr);
    … …  
    273273 * @param   pListHdr            Data header struct to initialize.
    274274 */
    275 int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr)
     275int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr)
    276276{
    277277    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    … …  
    279279    LogFlowFuncEnter();
    280280
    281     SharedClipboardTransferListHdrReset(pListHdr);
     281    ShClTransferListHdrReset(pListHdr);
    282282
    283283    return VINF_SUCCESS;
    … …  
    289289 * @param   pListHdr            Data header struct to destroy.
    290290 */
    291 void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
     291void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
    292292{
    293293    if (!pListHdr)
    … …  
    303303 * @param   pListHdr            SHCLListHdr structture to reset.
    304304 */
    305 void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr)
     305void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr)
    306306{
    307307    AssertPtrReturnVoid(pListHdr);
    … …  
    318318 * @param   pListHdr            Clipboard data header to validate.
    319319 */
    320 bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
     320bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
    321321{
    322322    RT_NOREF(pListHdr);
    … …  
    324324}
    325325
    326 int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
     326int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
    327327{
    328328    AssertPtrReturn(pDst, VERR_INVALID_POINTER);
    … …  
    362362 * @param   pParms              transfer list open parameters structure to duplicate.
    363363 */
    364 PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
     364PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
    365365{
    366366    AssertPtrReturn(pParms, NULL);
    … …  
    370370        return NULL;
    371371
    372     int rc = SharedClipboardTransferListOpenParmsCopy(pParmsDup, pParms);
     372    int rc = ShClTransferListOpenParmsCopy(pParmsDup, pParms);
    373373    if (RT_FAILURE(rc))
    374374    {
    375         SharedClipboardTransferListOpenParmsDestroy(pParmsDup);
     375        ShClTransferListOpenParmsDestroy(pParmsDup);
    376376
    377377        RTMemFree(pParmsDup);
    … …  
    388388 * @param   pParms              transfer list open parameters structure to initialize.
    389389 */
    390 int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
     390int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
    391391{
    392392    AssertPtrReturn(pParms, VERR_INVALID_POINTER);
    … …  
    409409 * @param   pParms              transfer list open parameters structure to destroy.
    410410 */
    411 void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
     411void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
    412412{
    413413    if (!pParms)
    … …  
    432432 * @param   ppDirData           Where to return the created clipboard list entry structure on success.
    433433 */
    434 int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
     434int ShClTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
    435435{
    436436    PSHCLLISTENTRY pListEntry = (PSHCLLISTENTRY)RTMemAlloc(sizeof(SHCLLISTENTRY));
    … …  
    438438        return VERR_NO_MEMORY;
    439439
    440     int rc = SharedClipboardTransferListEntryInit(pListEntry);
     440    int rc = ShClTransferListEntryInit(pListEntry);
    441441    if (RT_SUCCESS(rc))
    442442        *ppListEntry = pListEntry;
    … …  
    450450 * @param   pListEntry         Clipboard list entry structure to free.
    451451 */
    452 void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry)
     452void ShClTransferListEntryFree(PSHCLLISTENTRY pListEntry)
    453453{
    454454    if (!pListEntry)
    455455        return;
    456456
    457     SharedClipboardTransferListEntryDestroy(pListEntry);
     457    ShClTransferListEntryDestroy(pListEntry);
    458458    RTMemFree(pListEntry);
    459459}
    … …  
    465465 * @param   pListEntry          Clipboard list entry to copy.
    466466 */
    467 int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
     467int ShClTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
    468468{
    469469    AssertPtrReturn(pDst, VERR_INVALID_POINTER);
    … …  
    512512 * @param   pListEntry          Clipboard list entry to duplicate.
    513513 */
    514 PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry)
     514PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry)
    515515{
    516516    AssertPtrReturn(pListEntry, NULL);
    … …  
    520520    PSHCLLISTENTRY pListEntryDup = (PSHCLLISTENTRY)RTMemAllocZ(sizeof(SHCLLISTENTRY));
    521521    if (pListEntryDup)
    522         rc = SharedClipboardTransferListEntryCopy(pListEntryDup, pListEntry);
     522        rc = ShClTransferListEntryCopy(pListEntryDup, pListEntry);
    523523
    524524    if (RT_FAILURE(rc))
    525525    {
    526         SharedClipboardTransferListEntryDestroy(pListEntryDup);
     526        ShClTransferListEntryDestroy(pListEntryDup);
    527527
    528528        RTMemFree(pListEntryDup);
    … …  
    539539 * @param   pListEntry          Clipboard list entry structure to initialize.
    540540 */
    541 int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry)
     541int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry)
    542542{
    543543    RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY));
    … …  
    566566 * @param   pListEntry          Clipboard list entry structure to destroy.
    567567 */
    568 void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
     568void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
    569569{
    570570    if (!pListEntry)
    … …  
    593593 * @param   pListEntry          Clipboard data chunk to validate.
    594594 */
    595 bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
     595bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
    596596{
    597597    RT_NOREF(pListEntry);
    … …  
    608608 * @param   pObjCtx             transfer object context to initialize.
    609609 */
    610 int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
     610int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
    611611{
    612612    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
    … …  
    624624 * @param   pObjCtx             transfer object context to destroy.
    625625 */
    626 void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
     626void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
    627627{
    628628    AssertPtrReturnVoid(pObjCtx);
    … …  
    649649 * @param   pInfo               Object handle info structure to initialize.
    650650 */
    651 int SharedClipboardTransferObjectHandleInfoInit(PSHCLOBJHANDLEINFO pInfo)
     651int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo)
    652652{
    653653    AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
    … …  
    668668 * @param   pInfo               Object handle info structure to destroy.
    669669 */
    670 void SharedClipboardTransferObjectHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
     670void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
    671671{
    672672    if (!pInfo)
    … …  
    686686 * @param   pParms              transfer object open parameters structure to initialize.
    687687 */
    688 int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
     688int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
    689689{
    690690    AssertPtrReturn(pParms, VERR_INVALID_POINTER);
    … …  
    714714 * @param   pParmsSrc           Which source transfer object open parameters to copy.
    715715 */
    716 int SharedClipboardTransferObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
     716int ShClTransferObjOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
    717717{
    718718    int rc;
    … …  
    743743 * @param   pParms              transfer object open parameters structure to destroy.
    744744 */
    745 void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
     745void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
    746746{
    747747    if (!pParms)
    … …  
    783783 * @param   phObj               Where to store the handle of transfer object opened on success.
    784784 */
    785 int SharedClipboardTransferObjectOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
    786                                       PSHCLOBJHANDLE phObj)
     785int ShClTransferObjOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
     786                        PSHCLOBJHANDLE phObj)
    787787{
    788788    AssertPtrReturn(pTransfer,        VERR_INVALID_POINTER);
    … …  
    800800        if (pInfo)
    801801        {
    802             rc = SharedClipboardTransferObjectHandleInfoInit(pInfo);
     802            rc = ShClTransferObjHandleInfoInit(pInfo);
    803803            if (RT_SUCCESS(rc))
    804804            {
    … …  
    835835            else
    836836            {
    837                 SharedClipboardTransferObjectHandleInfoDestroy(pInfo);
     837                ShClTransferObjHandleInfoDestroy(pInfo);
    838838                RTMemFree(pInfo);
    839839            }
    … …  
    863863 * @param   hObj                Handle of transfer object to close.
    864864 */
    865 int SharedClipboardTransferObjectClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj)
     865int ShClTransferObjClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj)
    866866{
    867867    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    929929 * @param   pcbRead             How much bytes were read on success. Optional.
    930930 */
    931 int SharedClipboardTransferObjectRead(PSHCLTRANSFER pTransfer,
    932                                       SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
     931int ShClTransferObjRead(PSHCLTRANSFER pTransfer,
     932                        SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
    933933{
    934934    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    991991 * @param   pcbWritten          How much bytes were writtenon success. Optional.
    992992 */
    993 int SharedClipboardTransferObjectWrite(PSHCLTRANSFER pTransfer,
    994                                        SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
    995                                        uint32_t fFlags)
     993int ShClTransferObjWrite(PSHCLTRANSFER pTransfer,
     994                         SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
     995                         uint32_t fFlags)
    996996{
    997997    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    10431043 * @param   pDataChunk          transfer object data chunk to duplicate.
    10441044 */
    1045 PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
     1045PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
    10461046{
    10471047    if (!pDataChunk)
    … …  
    10691069 * @param   pDataChunk          transfer object data chunk to destroy.
    10701070 */
    1071 void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
     1071void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
    10721072{
    10731073    if (!pDataChunk)
    … …  
    10931093 *                              be invalid after calling this function.
    10941094 */
    1095 void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
     1095void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
    10961096{
    10971097    if (!pDataChunk)
    10981098        return;
    10991099
    1100     SharedClipboardTransferObjectDataChunkDestroy(pDataChunk);
     1100    ShClTransferObjDataChunkDestroy(pDataChunk);
    11011101
    11021102    RTMemFree(pDataChunk);
    … …  
    11111111 *                              Must be destroyed by SharedClipboardTransferDestroy().
    11121112 */
    1113 int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer)
     1113int ShClTransferCreate(PSHCLTRANSFER *ppTransfer)
    11141114{
    11151115    AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER);
    … …  
    11641164        if (pTransfer)
    11651165        {
    1166             SharedClipboardTransferDestroy(pTransfer);
     1166            ShClTransferDestroy(pTransfer);
    11671167            RTMemFree(pTransfer);
    11681168        }
    … …  
    11791179 * @param   pTransferCtx                Clipboard transfer to destroy.
    11801180 */
    1181 int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer)
     1181int ShClTransferDestroy(PSHCLTRANSFER pTransfer)
    11821182{
    11831183    if (!pTransfer)
    … …  
    11921192    RTStrFree(pTransfer->pszPathRootAbs);
    11931193
    1194     SharedClipboardEventSourceDestroy(&pTransfer->Events);
     1194    ShClEventSourceDestroy(&pTransfer->Events);
    11951195
    11961196    PSHCLLISTHANDLEINFO pItList, pItListNext;
    11971197    RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLLISTHANDLEINFO, Node)
    11981198    {
    1199         SharedClipboardTransferListHandleInfoDestroy(pItList);
     1199        ShClTransferListHandleInfoDestroy(pItList);
    12001200
    12011201        RTListNodeRemove(&pItList->Node);
    … …  
    12071207    RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLOBJHANDLEINFO, Node)
    12081208    {
    1209         SharedClipboardTransferObjectHandleInfoDestroy(pItObj);
     1209        ShClTransferObjHandleInfoDestroy(pItObj);
    12101210
    12111211        RTListNodeRemove(&pItObj->Node);
    … …  
    12271227 * @param   enmSource           Specifies the data source of the transfer.
    12281228 */
    1229 int SharedClipboardTransferInit(PSHCLTRANSFER pTransfer,
    1230                                 uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource)
     1229int ShClTransferInit(PSHCLTRANSFER pTransfer,
     1230                     uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource)
    12311231{
    12321232    pTransfer->State.uID       = uID;
    … …  
    12371237                 pTransfer->State.uID, pTransfer->State.enmDir, pTransfer->State.enmSource));
    12381238
    1239     int rc = SharedClipboardEventSourceCreate(&pTransfer->Events, pTransfer->State.uID);
     1239    int rc = ShClEventSourceCreate(&pTransfer->Events, pTransfer->State.uID);
    12401240    if (RT_SUCCESS(rc))
    12411241    {
    … …  
    12531253}
    12541254
    1255 int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer)
     1255int ShClTransferOpen(PSHCLTRANSFER pTransfer)
    12561256{
    12571257    int rc = VINF_SUCCESS;
    … …  
    12641264}
    12651265
    1266 int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer)
     1266int ShClTransferClose(PSHCLTRANSFER pTransfer)
    12671267{
    12681268    int rc = VINF_SUCCESS;
    … …  
    13131313 * @param   phList              Where to store the List handle of opened list on success.
    13141314 */
    1315 int SharedClipboardTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
    1316                                     PSHCLLISTHANDLE phList)
     1315int ShClTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
     1316                         PSHCLLISTHANDLE phList)
    13171317{
    13181318    AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
    … …  
    13321332        if (pInfo)
    13331333        {
    1334             rc = SharedClipboardTransferListHandleInfoInit(pInfo);
     1334            rc = ShClTransferListHandleInfoInit(pInfo);
    13351335            if (RT_SUCCESS(rc))
    13361336            {
    … …  
    13781378
    13791379                if (RT_FAILURE(rc))
    1380                     SharedClipboardTransferListHandleInfoDestroy(pInfo);
     1380                    ShClTransferListHandleInfoDestroy(pInfo);
    13811381            }
    13821382
    … …  
    14161416 * @param   hList               Handle of list to close.
    14171417 */
    1418 int SharedClipboardTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
     1418int ShClTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
    14191419{
    14201420    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    16511651 * @param   pHdr                Where to store the returned list header information.
    16521652 */
    1653 int SharedClipboardTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
    1654                                          PSHCLLISTHDR pHdr)
     1653int ShClTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
     1654                              PSHCLLISTHDR pHdr)
    16551655{
    16561656    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    16661666        if (pInfo)
    16671667        {
    1668             rc = SharedClipboardTransferListHdrInit(pHdr);
     1668            rc = ShClTransferListHdrInit(pHdr);
    16691669            if (RT_SUCCESS(rc))
    16701670            {
    … …  
    17351735 * @param   uIdx                Index of object to get.
    17361736 */
    1737 PSHCLTRANSFEROBJ SharedClipboardTransferListGetObj(PSHCLTRANSFER pTransfer,
    1738                                                    SHCLLISTHANDLE hList, uint64_t uIdx)
     1737PSHCLTRANSFEROBJ ShClTransferListGetObj(PSHCLTRANSFER pTransfer,
     1738                                        SHCLLISTHANDLE hList, uint64_t uIdx)
    17391739{
    17401740    AssertPtrReturn(pTransfer, NULL);
    … …  
    17551755 * @param   pEntry              Where to store the read information.
    17561756 */
    1757 int SharedClipboardTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
    1758                                     PSHCLLISTENTRY pEntry)
     1757int ShClTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
     1758                         PSHCLLISTENTRY pEntry)
    17591759{
    17601760    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    18251825                                    Assert   (pEntry->cbInfo == sizeof(SHCLFSOBJINFO));
    18261826
    1827                                     SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
     1827                                    ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
    18281828                                }
    18291829                            }
    … …  
    18561856                            if (RT_SUCCESS(rc))
    18571857                            {
    1858                                 SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
     1858                                ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo);
    18591859
    18601860                                pEntry->cbInfo = sizeof(SHCLFSOBJINFO);
    … …  
    18891889}
    18901890
    1891 int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
    1892                                      PSHCLLISTENTRY pEntry)
     1891int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
     1892                          PSHCLLISTENTRY pEntry)
    18931893{
    18941894    RT_NOREF(pTransfer, hList, pEntry);
    … …  
    19121912 * @param   hList               List handle to check.
    19131913 */
    1914 bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
     1914bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
    19151915{
    19161916    bool fIsValid = false;
    … …  
    19351935 * @param   pCreationCtx        Provider creation context to use for provider creation.
    19361936 */
    1937 int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer,
    1938                                         PSHCLPROVIDERCREATIONCTX pCreationCtx)
     1937int ShClTransferSetInterface(PSHCLTRANSFER pTransfer,
     1938                             PSHCLPROVIDERCREATIONCTX pCreationCtx)
    19391939{
    19401940    AssertPtrReturn(pTransfer,    VERR_INVALID_POINTER);
    … …  
    20012001 * @param   pTransfer           Clipboard transfer to reset.
    20022002 */
    2003 void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer)
     2003void ShClTransferReset(PSHCLTRANSFER pTransfer)
    20042004{
    20052005    AssertPtrReturnVoid(pTransfer);
    … …  
    20162016 * @param   pTransfer           Clipboard transfer to return clipboard area for.
    20172017 */
    2018 SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer)
     2018SharedClipboardArea *ShClTransferGetArea(PSHCLTRANSFER pTransfer)
    20192019{
    20202020    AssertPtrReturn(pTransfer, NULL);
    … …  
    20292029 * @param   pTransfer           Clipboard transfer to return root entry count for.
    20302030 */
    2031 uint32_t SharedClipboardTransferRootsCount(PSHCLTRANSFER pTransfer)
     2031uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer)
    20322032{
    20332033    AssertPtrReturn(pTransfer, 0);
    … …  
    20632063 * @param   pEntry              Where to store the returned entry on success.
    20642064 */
    2065 int SharedClipboardTransferRootsEntry(PSHCLTRANSFER pTransfer,
    2066                                       uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
     2065int ShClTransferRootsEntry(PSHCLTRANSFER pTransfer,
     2066                           uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
    20672067{
    20682068    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    20892089        LogFlowFunc(("pcszSrcPath=%s, pszDstPath=%s\n", pcszSrcPath, pszDstPath));
    20902090
    2091         rc = SharedClipboardTransferListEntryInit(pEntry);
     2091        rc = ShClTransferListEntryInit(pEntry);
    20922092        if (RT_SUCCESS(rc))
    20932093        {
    … …  
    21032103                    if (RT_SUCCESS(rc))
    21042104                    {
    2105                         SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
     2105                        ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo);
    21062106
    21072107                        pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO;
    … …  
    21272127 * @param   ppRootList          Where to store the root list on success.
    21282128 */
    2129 int SharedClipboardTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
     2129int ShClTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
    21302130{
    21312131    AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
    … …  
    21382138    if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
    21392139    {
    2140         PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
     2140        PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
    21412141        if (!pRootList)
    21422142            return VERR_NO_MEMORY;
    … …  
    21542154                for (uint64_t i = 0; i < cRoots; ++i)
    21552155                {
    2156                     rc = SharedClipboardTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
     2156                    rc = ShClTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
    21572157                    if (RT_FAILURE(rc))
    21582158                        break;
    … …  
    21982198 * @param   cbRoots             Size (in bytes) of string list.
    21992199 */
    2200 int SharedClipboardTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
     2200int ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
    22012201{
    22022202    AssertPtrReturn(pTransfer,      VERR_INVALID_POINTER);
    … …  
    22672267 * @param   pTransfer           Clipboard transfer to return ID for.
    22682268 */
    2269 SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer)
     2269SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer)
    22702270{
    22712271    AssertPtrReturn(pTransfer, 0);
    … …  
    22802280 * @param   pTransfer           Clipboard transfer to return direction for.
    22812281 */
    2282 SHCLTRANSFERDIR SharedClipboardTransferGetDir(PSHCLTRANSFER pTransfer)
     2282SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer)
    22832283{
    22842284    AssertPtrReturn(pTransfer, SHCLTRANSFERDIR_UNKNOWN);
    … …  
    22932293 * @param   pTransfer           Clipboard transfer to return source for.
    22942294 */
    2295 SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer)
     2295SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer)
    22962296{
    22972297    AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
    … …  
    23062306 * @param   pTransfer           Clipboard transfer to return status for.
    23072307 */
    2308 SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer)
     2308SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer)
    23092309{
    23102310    AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE);
    … …  
    23212321 * @param   pvUser              Pointer to user-provided data. Optional.
    23222322 */
    2323 int SharedClipboardTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
     2323int ShClTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
    23242324{
    23252325    AssertPtrReturn(pTransfer,     VERR_INVALID_POINTER);
    … …  
    23282328
    23292329    AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_STARTED,
    2330                     ("Wrong status (currently is %s)\n", VBoxShClTransferStatusToStr(pTransfer->State.enmStatus)),
     2330                    ("Wrong status (currently is %s)\n", ShClTransferStatusToStr(pTransfer->State.enmStatus)),
    23312331                    VERR_WRONG_ORDER);
    23322332
    … …  
    23432343 * @param   pTransfer           Clipboard transfer to start.
    23442344 */
    2345 int SharedClipboardTransferStart(PSHCLTRANSFER pTransfer)
     2345int ShClTransferStart(PSHCLTRANSFER pTransfer)
    23462346{
    23472347    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    23512351    /* Ready to start? */
    23522352    AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_INITIALIZED,
    2353                     ("Wrong status (currently is %s)\n", VBoxShClTransferStatusToStr(pTransfer->State.enmStatus)),
     2353                    ("Wrong status (currently is %s)\n", ShClTransferStatusToStr(pTransfer->State.enmStatus)),
    23542354                    VERR_WRONG_ORDER);
    23552355
    … …  
    23802380 * @param   pCallbacks          Pointer to callback table to set.
    23812381 */
    2382 void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer,
    2383                                          PSHCLTRANSFERCALLBACKS pCallbacks)
     2382void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer,
     2383                              PSHCLTRANSFERCALLBACKS pCallbacks)
    23842384{
    23852385    AssertPtrReturnVoid(pTransfer);
    … …  
    24792479 * @param   pTransferCtx                Transfer context to initialize.
    24802480 */
    2481 int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
     2481int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
    24822482{
    24832483    AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER);
    … …  
    24962496        RT_ZERO(pTransferCtx->bmTransferIds);
    24972497
    2498         SharedClipboardTransferCtxReset(pTransferCtx);
     2498        ShClTransferCtxReset(pTransferCtx);
    24992499    }
    25002500
    … …  
    25072507 * @param   pTransferCtx                Transfer context to destroy.
    25082508 */
    2509 void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
     2509void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
    25102510{
    25112511    AssertPtrReturnVoid(pTransferCtx);
    … …  
    25182518    RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
    25192519    {
    2520         SharedClipboardTransferDestroy(pTransfer);
     2520        ShClTransferDestroy(pTransfer);
    25212521
    25222522        RTListNodeRemove(&pTransfer->Node);
    … …  
    25352535 * @param   pTransferCtx                Transfer context to reset.
    25362536 */
    2537 void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
     2537void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
    25382538{
    25392539    AssertPtrReturnVoid(pTransferCtx);
    … …  
    25432543    PSHCLTRANSFER pTransfer;
    25442544    RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node)
    2545         SharedClipboardTransferReset(pTransfer);
     2545        ShClTransferReset(pTransfer);
    25462546}
    25472547
    … …  
    25722572 * @param   uID                 ID of the transfer to return.
    25732573 */
    2574 PSHCLTRANSFER SharedClipboardTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
     2574PSHCLTRANSFER ShClTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
    25752575{
    25762576    return sharedClipboardTransferCtxGetTransferInternal(pTransferCtx, uID);
    … …  
    25832583 * @param   pTransferCtx                Transfer context to return number for.
    25842584 */
    2585 uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
     2585uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
    25862586{
    25872587    AssertPtrReturn(pTransferCtx, 0);
    … …  
    25952595 * @param   pTransferCtx                Transfer context to return number for.
    25962596 */
    2597 uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
     2597uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
    25982598{
    25992599    AssertPtrReturn(pTransferCtx, 0);
    … …  
    26112611 * @param   pidTransfer         Where to return the transfer ID on success. Optional.
    26122612 */
    2613 int SharedClipboardTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer)
     2613int ShClTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer)
    26142614{
    26152615    AssertPtrReturn(pTransferCtx,      VERR_INVALID_POINTER);
    … …  
    26642664 * @param   idTransfer          Transfer ID to use for registration.
    26652665 */
    2666 int SharedClipboardTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer)
     2666int ShClTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer)
    26672667{
    26682668    LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pTransferCtx->cTransfers, idTransfer));
    … …  
    26932693 * @param   idTransfer          Transfer ID to unregister.
    26942694 */
    2695 int SharedClipboardTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer)
     2695int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer)
    26962696{
    26972697    int rc = VINF_SUCCESS;
    … …  
    27192719 * @param   pTransferCtx                Transfer context to cleanup transfers for.
    27202720 */
    2721 void SharedClipboardTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx)
     2721void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx)
    27222722{
    27232723    AssertPtrReturnVoid(pTransferCtx);
    … …  
    27332733    RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
    27342734    {
    2735         if (SharedClipboardTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
    2736         {
    2737             SharedClipboardTransferDestroy(pTransfer);
     2735        if (ShClTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
     2736        {
     2737            ShClTransferDestroy(pTransfer);
    27382738            RTListNodeRemove(&pTransfer->Node);
    27392739
    … …  
    27532753 * @param   pTransferCtx                Transfer context to determine value for.
    27542754 */
    2755 bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
     2755bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
    27562756{
    27572757    AssertPtrReturn(pTransferCtx, true);
    … …  
    27692769 * @param   pSrc                The IPRT structure to convert data from.
    27702770 */
    2771 void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc)
     2771void ShClFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc)
    27722772{
    27732773    pDst->cbObject          = pSrc->cbObject;
    … …  
    30553055 * @param   enmStatus           The transfer status to translate.
    30563056 */
    3057 const char *VBoxShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus)
     3057const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus)
    30583058{
    30593059    switch (enmStatus)

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

    r81212 r81223  
    10151015    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    10161016
    1017     Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
     1017    Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
    10181018
    10191019    int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
    … …  
    10361036                if (RT_SUCCESS(rc))
    10371037                {
    1038                     rc = SharedClipboardTransferRootsSet(pTransfer,
    1039                                                          papszList, cbList + 1 /* Include termination */);
     1038                    rc = ShClTransferRootsSet(pTransfer,
     1039                                              papszList, cbList + 1 /* Include termination */);
    10401040                    RTStrFree(papszList);
    10411041                }

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

    r81053 r81223  
    11601160    AssertPtr(pwszSrc);
    11611161    AssertPtr(pszBuf);
    1162     rc = vboxClipboardUtf16GetLinSize(pwszSrc, cwSrc, &cwTmp);
     1162    rc = ShClUtf16GetLinSize(pwszSrc, cwSrc, &cwTmp);
    11631163    if (RT_SUCCESS(rc) && cwTmp == 0)
    11641164        rc = VERR_NO_DATA;
    … …  
    11691169    /* Convert the text. */
    11701170    if (RT_SUCCESS(rc))
    1171         rc = vboxClipboardUtf16WinToLin(pwszSrc, cwSrc, pwszTmp, cwTmp);
     1171        rc = ShClUtf16WinToLin(pwszSrc, cwSrc, pwszTmp, cwTmp);
    11721172    if (RT_SUCCESS(rc))
    11731173        /* Convert the Utf16 string to Utf8. */
    … …  
    13501350        {
    13511351            /* Create a full BMP from it */
    1352             rc = vboxClipboardDibToBmp(pv, cb, (void **)pValReturn,
    1353                                        (size_t *)pcLenReturn);
     1352            rc = ShClDibToBmp(pv, cb, (void **)pValReturn,
     1353                              (size_t *)pcLenReturn);
    13541354        }
    13551355        else
    … …  
    15431543    PRTUTF16 pwszDest = NULL;
    15441544    size_t cwcDest;
    1545     int rc = vboxClipboardUtf16GetWinSize(pwcSrc, cwcSrc + 1, &cwcDest);
     1545    int rc = ShClUtf16GetWinSize(pwcSrc, cwcSrc + 1, &cwcDest);
    15461546    if (RT_SUCCESS(rc))
    15471547    {
    … …  
    15511551    }
    15521552    if (RT_SUCCESS(rc))
    1553         rc = vboxClipboardUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest,
    1554                                         cwcDest);
     1553        rc = ShClUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest,
     1554                               cwcDest);
    15551555    if (RT_SUCCESS(rc))
    15561556    {
    … …  
    18201820                const void *pDib;
    18211821                size_t cbDibSize;
    1822                 rc = vboxClipboardBmpGetDib((const void *)pvSrc, cbSrc,
    1823                                             &pDib, &cbDibSize);
     1822                rc = ShClBmpGetDib((const void *)pvSrc, cbSrc,
     1823                                   &pDib, &cbDibSize);
    18241824                if (RT_SUCCESS(rc))
    18251825                {

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

    r81220 r81223  
    8787    if (pMsgHdr)
    8888    {
    89         SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     89        SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    9090
    9191        HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    9696        if (RT_SUCCESS(rc))
    9797        {
    98             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     98            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    9999            AssertRC(rc2);
    100100
    … …  
    103103            {
    104104                PSHCLEVENTPAYLOAD pPayloadHdr;
    105                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
     105                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
    106106                                              pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
    107107                if (RT_SUCCESS(rc))
    … …  
    112112                    LogFlowFunc(("cRoots=%RU32, fRoots=0x%x\n", pSrcRootListHdr->cRoots, pSrcRootListHdr->fRoots));
    113113
    114                     PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
     114                    PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
    115115                    if (pRootList)
    116116                    {
    … …  
    127127                                                                               VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    128128
    129                                     uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     129                                    uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    130130
    131131                                    HGCMSvcSetU32(&pMsgEntry->paParms[0],
    … …  
    135135                                    HGCMSvcSetU32(&pMsgEntry->paParms[2], i /* uIndex */);
    136136
    137                                     rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     137                                    rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    138138                                    AssertRC(rc2);
    139139
    … …  
    143143
    144144                                    PSHCLEVENTPAYLOAD pPayloadEntry;
    145                                     rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    146                                                                   pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
     145                                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
     146                                                       pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
    147147                                    if (RT_FAILURE(rc))
    148148                                        break;
    … …  
    151151                                    Assert(pPayloadEntry->cbData == sizeof(SHCLROOTLISTENTRY));
    152152
    153                                     rc = SharedClipboardTransferListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
    154 
    155                                     SharedClipboardPayloadFree(pPayloadEntry);
    156 
    157                                     SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
     153                                    rc = ShClTransferListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry);
     154
     155                                    ShClPayloadFree(pPayloadEntry);
     156
     157                                    ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
    158158
    159159                                    if (RT_FAILURE(rc))
    … …  
    173173                        }
    174174                        else
    175                             SharedClipboardTransferRootListFree(pRootList);
    176 
    177                         SharedClipboardPayloadFree(pPayloadHdr);
     175                            ShClTransferRootListFree(pRootList);
     176
     177                        ShClPayloadFree(pPayloadHdr);
    178178                    }
    179179                    else
    … …  
    182182            }
    183183
    184             SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
     184            ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
    185185        }
    186186    }
    … …  
    206206    if (pMsg)
    207207    {
    208         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     208        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    209209
    210210        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
    … …  
    217217            if (RT_SUCCESS(rc))
    218218            {
    219                 int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     219                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    220220                AssertRC(rc2);
    221221
    … …  
    224224                {
    225225                    PSHCLEVENTPAYLOAD pPayload;
    226                     rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     226                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    227227                    if (RT_SUCCESS(rc))
    228228                    {
    … …  
    236236                        *phList = pReply->u.ListOpen.uHandle;
    237237
    238                         SharedClipboardPayloadFree(pPayload);
     238                        ShClPayloadFree(pPayload);
    239239                    }
    240240                }
    241241
    242                 SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
     242                ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
    243243            }
    244244        }
    … …  
    264264    if (pMsg)
    265265    {
    266         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     266        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    267267
    268268        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
    … …  
    275275            if (RT_SUCCESS(rc))
    276276            {
    277                 int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     277                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    278278                AssertRC(rc2);
    279279
    … …  
    282282                {
    283283                    PSHCLEVENTPAYLOAD pPayload;
    284                     rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     284                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    285285                    if (RT_SUCCESS(rc))
    286                         SharedClipboardPayloadFree(pPayload);
    287                 }
    288 
    289                 SharedClipboardEventUnregister(&pCtx->pTransfer->Events, uEvent);
     286                        ShClPayloadFree(pPayload);
     287                }
     288
     289                ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
    290290            }
    291291        }
    … …  
    312312    if (pMsg)
    313313    {
    314         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     314        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    315315
    316316        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    322322        if (RT_SUCCESS(rc))
    323323        {
    324             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     324            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    325325            AssertRC(rc2);
    326326
    … …  
    329329            {
    330330                PSHCLEVENTPAYLOAD pPayload;
    331                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    332                                              pCtx->pTransfer->uTimeoutMs, &pPayload);
     331                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
     332                                   pCtx->pTransfer->uTimeoutMs, &pPayload);
    333333                if (RT_SUCCESS(rc))
    334334                {
    … …  
    337337                    *pListHdr = *(PSHCLLISTHDR)pPayload->pvData;
    338338
    339                     SharedClipboardPayloadFree(pPayload);
     339                    ShClPayloadFree(pPayload);
    340340                }
    341341            }
    … …  
    373373    if (pMsg)
    374374    {
    375         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     375        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    376376
    377377        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    383383        if (RT_SUCCESS(rc))
    384384        {
    385             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     385            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    386386            AssertRC(rc2);
    387387
    … …  
    390390            {
    391391                PSHCLEVENTPAYLOAD pPayload;
    392                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     392                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    393393                if (RT_SUCCESS(rc))
    394394                {
    395395                    Assert(pPayload->cbData == sizeof(SHCLLISTENTRY));
    396396
    397                     rc = SharedClipboardTransferListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData);
    398 
    399                     SharedClipboardPayloadFree(pPayload);
     397                    rc = ShClTransferListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData);
     398
     399                    ShClPayloadFree(pPayload);
    400400                }
    401401            }
    … …  
    433433    if (pMsg)
    434434    {
    435         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     435        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    436436
    437437        LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
    … …  
    449449        if (RT_SUCCESS(rc))
    450450        {
    451             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     451            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    452452            AssertRC(rc2);
    453453
    … …  
    456456            {
    457457                PSHCLEVENTPAYLOAD pPayload;
    458                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     458                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    459459                if (RT_SUCCESS(rc))
    460460                {
    … …  
    468468                    *phObj = pReply->u.ObjOpen.uHandle;
    469469
    470                     SharedClipboardPayloadFree(pPayload);
     470                    ShClPayloadFree(pPayload);
    471471                }
    472472            }
    … …  
    493493    if (pMsg)
    494494    {
    495         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     495        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    496496
    497497        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    502502        if (RT_SUCCESS(rc))
    503503        {
    504             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     504            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    505505            AssertRC(rc2);
    506506
    … …  
    509509            {
    510510                PSHCLEVENTPAYLOAD pPayload;
    511                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     511                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    512512                if (RT_SUCCESS(rc))
    513513                {
    … …  
    521521#endif
    522522
    523                     SharedClipboardPayloadFree(pPayload);
     523                    ShClPayloadFree(pPayload);
    524524                }
    525525            }
    … …  
    547547    if (pMsg)
    548548    {
    549         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     549        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    550550
    551551        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    558558        if (RT_SUCCESS(rc))
    559559        {
    560             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     560            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    561561            AssertRC(rc2);
    562562
    … …  
    565565            {
    566566                PSHCLEVENTPAYLOAD pPayload;
    567                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     567                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    568568                if (RT_SUCCESS(rc))
    569569                {
    … …  
    580580                        *pcbRead = cbRead;
    581581
    582                     SharedClipboardPayloadFree(pPayload);
     582                    ShClPayloadFree(pPayload);
    583583                }
    584584            }
    … …  
    606606    if (pMsg)
    607607    {
    608         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
     608        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
    609609
    610610        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    617617        if (RT_SUCCESS(rc))
    618618        {
    619             int rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
     619            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
    620620            AssertRC(rc2);
    621621
    … …  
    624624            {
    625625                PSHCLEVENTPAYLOAD pPayload;
    626                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     626                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
    627627                if (RT_SUCCESS(rc))
    628628                {
    … …  
    634634                        *pcbWritten = cbRead;
    635635
    636                     SharedClipboardPayloadFree(pPayload);
     636                    ShClPayloadFree(pPayload);
    637637                }
    638638            }
    … …  
    722722    }
    723723
    724     LogFlowFunc(("uMsg=%RU32 (%s), uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, VBoxShClGuestMsgToStr(uMsg), uMode, fAllowed));
     724    LogFlowFunc(("uMsg=%RU32 (%s), uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, ShClGuestMsgToStr(uMsg), uMode, fAllowed));
    725725    return fAllowed;
    726726}
    … …  
    10771077        if (RT_SUCCESS(rc))
    10781078        {
    1079             if (!SharedClipboardTransferListEntryIsValid(pListEntry))
     1079            if (!ShClTransferListEntryIsValid(pListEntry))
    10801080                rc = VERR_INVALID_PARAMETER;
    10811081        }
    … …  
    12361236                            LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent));
    12371237
    1238                             rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1238                            rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    12391239                        }
    12401240                        break;
    … …  
    12901290
    12911291    LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n",
    1292                  pClient->State.uClientID, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
     1292                 pClient->State.uClientID, u32Function, ShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
    12931293
    12941294    /* Check if we've the right mode set. */
    … …  
    13221322        default:
    13231323        {
    1324             if (!SharedClipboardTransferCtxGetTotalTransfers(&pClient->TransferCtx))
     1324            if (!ShClTransferCtxGetTotalTransfers(&pClient->TransferCtx))
    13251325            {
    13261326                LogFunc(("No transfers found\n"));
    … …  
    13381338            const SHCLTRANSFERID uTransferID = VBOX_SHCL_CONTEXTID_GET_TRANSFER(uCID);
    13391339
    1340             pTransfer = SharedClipboardTransferCtxGetTransfer(&pClient->TransferCtx, uTransferID);
     1340            pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, uTransferID);
    13411341            if (!pTransfer)
    13421342            {
    … …  
    13691369            RT_ZERO(rootListHdr);
    13701370
    1371             rootListHdr.cRoots = SharedClipboardTransferRootsCount(pTransfer);
     1371            rootListHdr.cRoots = ShClTransferRootsCount(pTransfer);
    13721372
    13731373            HGCMSvcSetU32(&paParms[0], 0 /* Context ID */);
    … …  
    13851385            if (RT_SUCCESS(rc))
    13861386            {
    1387                 void    *pvData = SharedClipboardTransferRootListHdrDup(&lstHdr);
     1387                void    *pvData = ShClTransferRootListHdrDup(&lstHdr);
    13881388                uint32_t cbData = sizeof(SHCLROOTLISTHDR);
    13891389
    … …  
    13911391
    13921392                PSHCLEVENTPAYLOAD pPayload;
    1393                 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1393                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    13941394                if (RT_SUCCESS(rc))
    13951395                {
    1396                     rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1396                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    13971397                    if (RT_FAILURE(rc))
    1398                         SharedClipboardPayloadFree(pPayload);
     1398                        ShClPayloadFree(pPayload);
    13991399                }
    14001400            }
    … …  
    14131413            {
    14141414                SHCLROOTLISTENTRY rootListEntry;
    1415                 rc = SharedClipboardTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
     1415                rc = ShClTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
    14161416                if (RT_SUCCESS(rc))
    14171417                {
    … …  
    14301430            if (RT_SUCCESS(rc))
    14311431            {
    1432                 void    *pvData = SharedClipboardTransferRootListEntryDup(&lstEntry);
     1432                void    *pvData = ShClTransferRootListEntryDup(&lstEntry);
    14331433                uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
    14341434
    … …  
    14361436
    14371437                PSHCLEVENTPAYLOAD pPayload;
    1438                 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1438                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    14391439                if (RT_SUCCESS(rc))
    14401440                {
    1441                     rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1441                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    14421442                    if (RT_FAILURE(rc))
    1443                         SharedClipboardPayloadFree(pPayload);
     1443                        ShClPayloadFree(pPayload);
    14441444                }
    14451445            }
    … …  
    14541454            {
    14551455                SHCLLISTHANDLE hList;
    1456                 rc = SharedClipboardTransferListOpen(pTransfer, &listOpenParms, &hList);
     1456                rc = ShClTransferListOpen(pTransfer, &listOpenParms, &hList);
    14571457                if (RT_SUCCESS(rc))
    14581458                {
    … …  
    14731473            if (RT_SUCCESS(rc))
    14741474            {
    1475                 rc = SharedClipboardTransferListClose(pTransfer, hList);
     1475                rc = ShClTransferListClose(pTransfer, hList);
    14761476            }
    14771477            break;
    … …  
    14881488            {
    14891489                SHCLLISTHDR hdrList;
    1490                 rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
     1490                rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
    14911491                /*if (RT_SUCCESS(rc))
    14921492                    rc = shclSvcTransferSetListHdr(cParms, paParms, &hdrList);*/
    … …  
    14981498        {
    14991499            SHCLLISTHDR hdrList;
    1500             rc = SharedClipboardTransferListHdrInit(&hdrList);
     1500            rc = ShClTransferListHdrInit(&hdrList);
    15011501            if (RT_SUCCESS(rc))
    15021502            {
    … …  
    15111511
    15121512                    PSHCLEVENTPAYLOAD pPayload;
    1513                     rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1513                    rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    15141514                    if (RT_SUCCESS(rc))
    15151515                    {
    1516                         rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1516                        rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    15171517                        if (RT_FAILURE(rc))
    1518                             SharedClipboardPayloadFree(pPayload);
     1518                            ShClPayloadFree(pPayload);
    15191519                    }
    15201520                }
    … …  
    15331533            {
    15341534                SHCLLISTENTRY entryList;
    1535                 rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
     1535                rc = ShClTransferListRead(pTransfer, hList, &entryList);
    15361536            }
    15371537            break;
    … …  
    15411541        {
    15421542            SHCLLISTENTRY entryList;
    1543             rc = SharedClipboardTransferListEntryInit(&entryList);
     1543            rc = ShClTransferListEntryInit(&entryList);
    15441544            if (RT_SUCCESS(rc))
    15451545            {
    … …  
    15481548                if (RT_SUCCESS(rc))
    15491549                {
    1550                     void    *pvData = SharedClipboardTransferListEntryDup(&entryList);
     1550                    void    *pvData = ShClTransferListEntryDup(&entryList);
    15511551                    uint32_t cbData = sizeof(SHCLLISTENTRY);
    15521552
    … …  
    15541554
    15551555                    PSHCLEVENTPAYLOAD pPayload;
    1556                     rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1556                    rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    15571557                    if (RT_SUCCESS(rc))
    15581558                    {
    1559                         rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1559                        rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    15601560                        if (RT_FAILURE(rc))
    1561                             SharedClipboardPayloadFree(pPayload);
     1561                            ShClPayloadFree(pPayload);
    15621562                    }
    15631563                }
    … …  
    15881588            {
    15891589                SHCLOBJHANDLE hObj;
    1590                 rc = SharedClipboardTransferObjectOpen(pTransfer, &openCreateParms, &hObj);
     1590                rc = ShClTransferObjOpen(pTransfer, &openCreateParms, &hObj);
    15911591                if (RT_SUCCESS(rc))
    15921592                {
    … …  
    16071607            rc = HGCMSvcGetU64(&paParms[1], &hObj); /* Get object handle. */
    16081608            if (RT_SUCCESS(rc))
    1609                 rc = SharedClipboardTransferObjectClose(pTransfer, hObj);
     1609                rc = ShClTransferObjClose(pTransfer, hObj);
    16101610            break;
    16111611        }
    … …  
    16431643            {
    16441644                uint32_t cbRead;
    1645                 rc = SharedClipboardTransferObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, 0 /* fFlags */);
     1645                rc = ShClTransferObjRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, 0 /* fFlags */);
    16461646                if (RT_SUCCESS(rc))
    16471647                {
    … …  
    16601660            if (RT_SUCCESS(rc))
    16611661            {
    1662                 void    *pvData = SharedClipboardTransferObjectDataChunkDup(&dataChunk);
     1662                void    *pvData = ShClTransferObjDataChunkDup(&dataChunk);
    16631663                uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
    16641664
    … …  
    16661666
    16671667                PSHCLEVENTPAYLOAD pPayload;
    1668                 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1668                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    16691669                if (RT_SUCCESS(rc))
    16701670                {
    1671                     rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1671                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
    16721672                    if (RT_FAILURE(rc))
    1673                         SharedClipboardPayloadFree(pPayload);
     1673                        ShClPayloadFree(pPayload);
    16741674                }
    16751675            }
    … …  
    21112111        return VERR_NO_MEMORY;
    21122112
    2113     const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
     2113    const SHCLEVENTID uEvent = ShClEventIDGenerate(&pTransfer->Events);
    21142114
    21152115    HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    2116                                                                                   pTransfer->State.uID, uEvent));
     2116                                                                      pTransfer->State.uID, uEvent));
    21172117    HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir);
    21182118    HGCMSvcSetU32(&pMsgReadData->paParms[2], uStatus);
    … …  
    21232123    if (RT_SUCCESS(rc))
    21242124    {
    2125         rc = SharedClipboardEventRegister(&pTransfer->Events, uEvent);
     2125        rc = ShClEventRegister(&pTransfer->Events, uEvent);
    21262126        if (RT_SUCCESS(rc))
    21272127        {
    … …  
    21302130            {
    21312131                LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n",
    2132                          VBoxShClTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
     2132                         ShClGuestMsgToStr(uStatus), rcTransfer, pTransfer->State.uID));
    21332133
    21342134                if (puEvent)
    … …  
    21362136            }
    21372137            else
    2138                 SharedClipboardEventUnregister(&pTransfer->Events, uEvent);
     2138                ShClEventUnregister(&pTransfer->Events, uEvent);
    21392139        }
    21402140    }
    … …  
    21622162    LogFlowFuncEnter();
    21632163
    2164     SharedClipboardTransferCtxCleanup(&pClient->TransferCtx);
     2164    ShClTransferCtxCleanup(&pClient->TransferCtx);
    21652165
    21662166    int rc;
    21672167
    2168     if (!SharedClipboardTransferCtxTransfersMaximumReached(&pClient->TransferCtx))
     2168    if (!ShClTransferCtxTransfersMaximumReached(&pClient->TransferCtx))
    21692169    {
    21702170        LogRel2(("Shared Clipboard: Starting %s transfer ...\n", enmDir == SHCLTRANSFERDIR_READ ? "read" : "write"));
    21712171
    21722172        PSHCLTRANSFER pTransfer;
    2173         rc = SharedClipboardTransferCreate(&pTransfer);
     2173        rc = ShClTransferCreate(&pTransfer);
    21742174        if (RT_SUCCESS(rc))
    21752175        {
    … …  
    22142214                uint32_t uTransferID = 0;
    22152215
    2216                 rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
     2216                rc = ShClTransferSetInterface(pTransfer, &creationCtx);
    22172217                if (RT_SUCCESS(rc))
    22182218                {
    2219                     rc = SharedClipboardTransferCtxTransferRegister(&pClient->TransferCtx, pTransfer, &uTransferID);
     2219                    rc = ShClTransferCtxTransferRegister(&pClient->TransferCtx, pTransfer, &uTransferID);
    22202220                    if (RT_SUCCESS(rc))
    22212221                    {
    2222                         rc = SharedClipboardTransferInit(pTransfer, uTransferID, enmDir, enmSource);
     2222                        rc = ShClTransferInit(pTransfer, uTransferID, enmDir, enmSource);
    22232223                        if (RT_SUCCESS(rc))
    22242224                        {
    … …  
    22302230
    22312231                            if (RT_SUCCESS(rc))
    2232                                 rc = SharedClipboardTransferStart(pTransfer);
     2232                                rc = ShClTransferStart(pTransfer);
    22332233
    22342234                            if (RT_SUCCESS(rc))
    … …  
    22442244
    22452245                                    PSHCLEVENTPAYLOAD pPayload;
    2246                                     rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload);
     2246                                    rc = ShClEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload);
    22472247                                    if (RT_SUCCESS(rc))
    22482248                                    {
    … …  
    22592259                                        else
    22602260                                            LogRel(("Shared Clipboard: Guest reported status %s (error %Rrc) while starting transfer %RU32\n",
    2261                                                     VBoxShClTransferStatusToStr(pReply->u.TransferStatus.uStatus),
     2261                                                    ShClGuestMsgToStr(pReply->u.TransferStatus.uStatus),
    22622262                                                    pReply->rc, pTransfer->State.uID));
    22632263                                    }
    … …  
    22702270
    22712271                        if (RT_FAILURE(rc))
    2272                             SharedClipboardTransferCtxTransferUnregister(&pClient->TransferCtx, uTransferID);
     2272                            ShClTransferCtxTransferUnregister(&pClient->TransferCtx, uTransferID);
    22732273                    }
    22742274                }
    … …  
    22782278            {
    22792279                ShClSvcImplTransferDestroy(pClient, pTransfer);
    2280                 SharedClipboardTransferDestroy(pTransfer);
     2280                ShClTransferDestroy(pTransfer);
    22812281
    22822282                RTMemFree(pTransfer);
    … …  
    23092309int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    23102310{
    2311     int rc = SharedClipboardTransferClose(pTransfer);
     2311    int rc = ShClTransferClose(pTransfer);
    23122312    if (RT_SUCCESS(rc))
    23132313    {
    … …  
    23202320            LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU32 on guest ...\n", pTransfer->State.uID));
    23212321
    2322             rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL);
    2323             if (RT_SUCCESS(rc))
    2324             {
    2325                 rc = SharedClipboardTransferCtxTransferUnregister(&pClient->TransferCtx, SharedClipboardTransferGetID(pTransfer));
     2322            rc = ShClEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL);
     2323            if (RT_SUCCESS(rc))
     2324            {
     2325                rc = ShClTransferCtxTransferUnregister(&pClient->TransferCtx, ShClTransferGetID(pTransfer));
    23262326
    23272327                LogRel2(("Shared Clipboard: Stopped transfer %RU32 on guest\n", pTransfer->State.uID));

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

    r81212 r81223  
    108108
    109109#ifdef LOG_ENABLED
    110     VBoxShClDbgDumpData(pvDst, cbSrc, u32Format);
     110    ShClDbgDumpData(pvDst, cbSrc, u32Format);
    111111#endif
    112112
    … …  
    183183    {
    184184        PSHCLEVENTPAYLOAD pPayload;
    185         rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
     185        rc = ShClEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
    186186        if (RT_SUCCESS(rc))
    187187        {
    … …  
    190190
    191191            /* Detach the payload, as the caller then will own the data. */
    192             SharedClipboardEventPayloadDetach(&pCtx->pClient->Events, uEvent);
    193         }
    194 
    195         SharedClipboardEventUnregister(&pCtx->pClient->Events, uEvent);
     192            ShClEventPayloadDetach(&pCtx->pClient->Events, uEvent);
     193        }
     194
     195        ShClEventUnregister(&pCtx->pClient->Events, uEvent);
    196196    }
    197197
    … …  
    829829#ifdef VBOX_STRICT
    830830                        LogFlowFunc(("Raw HTML clipboard data from host:"));
    831                         VBoxShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
     831                        ShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
    832832#endif
    833833                        GlobalUnlock(hClip);

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

    r81212 r81223  
    224224    if (pReq)
    225225    {
    226         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     226        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->Events);
    227227
    228228        pReq->pv        = pData->pvData;
    … …  
    234234        if (RT_SUCCESS(rc))
    235235        {
    236             rc = SharedClipboardEventRegister(&pClient->Events, uEvent);
     236            rc = ShClEventRegister(&pClient->Events, uEvent);
    237237            if (RT_SUCCESS(rc))
    238238            {
    239239                PSHCLEVENTPAYLOAD pPayload;
    240                 rc = SharedClipboardEventWait(&pClient->Events, uEvent, 30 * 1000, &pPayload);
     240                rc = ShClEventWait(&pClient->Events, uEvent, 30 * 1000, &pPayload);
    241241                if (RT_SUCCESS(rc))
    242242                {
    … …  
    247247                }
    248248
    249                 SharedClipboardEventUnregister(&pClient->Events, uEvent);
     249                ShClEventUnregister(&pClient->Events, uEvent);
    250250            }
    251251        }
    … …  
    292292
    293293    PSHCLEVENTPAYLOAD pPayload;
    294     int rc2 = SharedClipboardPayloadAlloc(pReq->uEvent, pv, cb, &pPayload);
     294    int rc2 = ShClPayloadAlloc(pReq->uEvent, pv, cb, &pPayload);
    295295    if (RT_SUCCESS(rc2))
    296         rc2 = SharedClipboardEventSignal(&pCtx->pClient->Events, pReq->uEvent, pPayload);
     296        rc2 = ShClEventSignal(&pCtx->pClient->Events, pReq->uEvent, pPayload);
    297297
    298298    AssertRC(rc);
    … …  
    335335    {
    336336        PSHCLEVENTPAYLOAD pPayload;
    337         rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
     337        rc = ShClEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload);
    338338        if (RT_SUCCESS(rc))
    339339        {
    … …  
    342342
    343343            /* Detach the payload, as the caller then will own the data. */
    344             SharedClipboardEventPayloadDetach(&pCtx->pClient->Events, uEvent);
    345         }
    346 
    347         SharedClipboardEventUnregister(&pCtx->pClient->Events, uEvent);
     344            ShClEventPayloadDetach(&pCtx->pClient->Events, uEvent);
     345        }
     346
     347        ShClEventUnregister(&pCtx->pClient->Events, uEvent);
    348348    }
    349349

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

    r81212 r81223  
    473473
    474474    LogFlowFunc(("uMsg=%RU32 (%s), cParms=%RU32, fAppend=%RTbool\n",
    475                  pMsg->uMsg, VBoxShClHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
     475                 pMsg->uMsg, ShClHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
    476476
    477477    if (fAppend)
    … …  
    550550            shclSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
    551551            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
    552                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
     552                         pClient->State.uClientID, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg),
    553553                         pFirstMsg->cParms));
    554554            return VINF_SUCCESS;
    … …  
    611611
    612612            LogFlowFunc(("[Client %RU32] uMsg=%RU32 (%s), cParms=%RU32\n",
    613                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
     613                         pClient->State.uClientID, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg),
    614614                         pFirstMsg->cParms));
    615615
    … …  
    684684        {
    685685            LogFlowFunc(("First message is: %RU32 (%s), cParms=%RU32\n",
    686                          pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
     686                         pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
    687687
    688688            ASSERT_GUEST_MSG_RETURN(pFirstMsg->uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
    689689                                    ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
    690                                      pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
    691                                      idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
     690                                     pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
     691                                     idMsgExpected, ShClHostMsgToStr(idMsgExpected), cParms),
    692692                                    VERR_MISMATCH);
    693693            ASSERT_GUEST_MSG_RETURN(pFirstMsg->cParms == cParms,
    694694                                    ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
    695                                      pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
    696                                      idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
     695                                     pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
     696                                     idMsgExpected, ShClHostMsgToStr(idMsgExpected), cParms),
    697697                                    VERR_WRONG_PARAMETER_COUNT);
    698698
    … …  
    701701                ASSERT_GUEST_MSG_RETURN(pFirstMsg->paParms[i].type == paParms[i].type,
    702702                                        ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->paParms[i].type,
    703                                          paParms[i].type, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg)),
     703                                         paParms[i].type, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg)),
    704704                                        VERR_WRONG_PARAMETER_TYPE);
    705705            /*
    … …  
    797797            {
    798798                LogFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n",
    799                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
     799                         pClient->State.uClientID, pFirstMsg->uMsg, ShClHostMsgToStr(pFirstMsg->uMsg),
    800800                         pFirstMsg->cParms));
    801801
    … …  
    866866    if (pMsgReadData)
    867867    {
    868         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     868        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->Events);
    869869
    870870        HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    876876        if (RT_SUCCESS(rc))
    877877        {
    878             rc = SharedClipboardEventRegister(&pClient->Events, uEvent);
     878            rc = ShClEventRegister(&pClient->Events, uEvent);
    879879            if (RT_SUCCESS(rc))
    880880            {
    … …  
    886886                }
    887887                else
    888                     SharedClipboardEventUnregister(&pClient->Events, uEvent);
     888                    ShClEventUnregister(&pClient->Events, uEvent);
    889889            }
    890890        }
    … …  
    909909        /* Protocol v0 did not have any context ID handling, so we ASSUME that the last event registered
    910910         * is the one we want to handle (as this all was a synchronous protocol anyway). */
    911         uEvent = SharedClipboardEventGetLast(&pClient->Events);
     911        uEvent = ShClEventGetLast(&pClient->Events);
    912912    }
    913913    else
    … …  
    918918    PSHCLEVENTPAYLOAD pPayload = NULL;
    919919    if (pData->cbData)
    920         rc = SharedClipboardPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
     920        rc = ShClPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
    921921
    922922    if (RT_SUCCESS(rc))
    923923    {
    924         rc = SharedClipboardEventSignal(&pClient->Events, uEvent, pPayload);
     924        rc = ShClEventSignal(&pClient->Events, uEvent, pPayload);
    925925        if (RT_FAILURE(rc))
    926             SharedClipboardPayloadFree(pPayload);
     926            ShClPayloadFree(pPayload);
    927927    }
    928928
    … …  
    941941    if (pMsg)
    942942    {
    943         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     943        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->Events);
    944944
    945945        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    11211121
    11221122#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1123     PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
     1123    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
    11241124    if (pTransfer)
    11251125        shclSvcTransferAreaDetach(&pClient->State, pTransfer);
    11261126
    1127     SharedClipboardTransferCtxDestroy(&pClient->TransferCtx);
     1127    ShClTransferCtxDestroy(&pClient->TransferCtx);
    11281128#endif
    11291129
    … …  
    11451145    shclSvcClientStateDestroy(&pClient->State);
    11461146
    1147     SharedClipboardEventSourceDestroy(&pClient->Events);
     1147    ShClEventSourceDestroy(&pClient->Events);
    11481148
    11491149    ClipboardClientMap::iterator itClient = g_mapClients.find(u32ClientID);
    … …  
    11691169
    11701170    /* Create the client's own event source. */
    1171     int rc = SharedClipboardEventSourceCreate(&pClient->Events, 0 /* ID, ignored */);
     1171    int rc = ShClEventSourceCreate(&pClient->Events, 0 /* ID, ignored */);
    11721172    if (RT_SUCCESS(rc))
    11731173    {
    … …  
    11821182        {
    11831183#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1184             rc = SharedClipboardTransferCtxInit(&pClient->TransferCtx);
     1184            rc = ShClTransferCtxInit(&pClient->TransferCtx);
    11851185#endif
    11861186            if (RT_SUCCESS(rc))
    … …  
    12221222
    12231223    LogFunc(("u32ClientID=%RU32 (proto %RU32), fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
    1224              u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, paParms));
     1224             u32ClientID, pClient->State.uProtocolVer, u32Function, ShClGuestMsgToStr(u32Function), cParms, paParms));
    12251225
    12261226#ifdef DEBUG
    … …  
    15681568
    15691569    LogFlowFunc(("u32Function=%RU32 (%s), cParms=%RU32, paParms=%p\n",
    1570                  u32Function, VBoxShClHostFunctionToStr(u32Function), cParms, paParms));
     1570                 u32Function, ShClHostFunctionToStr(u32Function), cParms, paParms));
    15711571
    15721572    switch (u32Function)

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

    r80847 r81223  
    208208                size_t cwSrc = RTUtf16Len(pwszTmp);
    209209                size_t cwDest;
    210                 rc = vboxClipboardUtf16GetWinSize(pwszTmp, cwSrc, &cwDest);
     210                rc = ShClUtf16GetWinSize(pwszTmp, cwSrc, &cwDest);
    211211                if (RT_FAILURE(rc))
    212212                {
    … …  
    222222                if (*pcbActual <= cb)
    223223                {
    224                     rc = vboxClipboardUtf16LinToWin(pwszTmp, RTUtf16Len(pwszTmp), static_cast <PRTUTF16>(pv), cb / 2);
     224                    rc = ShClUtf16LinToWin(pwszTmp, RTUtf16Len(pwszTmp), static_cast <PRTUTF16>(pv), cb / 2);
    225225                    if (RT_FAILURE(rc))
    226226                    {
    … …  
    254254                const void *pDib;
    255255                size_t cbDibSize;
    256                 rc = vboxClipboardBmpGetDib(pTmp, cbTmpSize, &pDib, &cbDibSize);
     256                rc = ShClBmpGetDib(pTmp, cbTmpSize, &pDib, &cbDibSize);
    257257                if (RT_FAILURE(rc))
    258258                {
    … …  
    311311        size_t cwDest = 0;
    312312        /* How long will the converted text be? */
    313         rc = vboxClipboardUtf16GetLinSize(pwszSrcText, cwSrc, &cwDest);
     313        rc = ShClUtf16GetLinSize(pwszSrcText, cwSrc, &cwDest);
    314314        if (RT_FAILURE(rc))
    315315        {
    … …  
    331331        }
    332332        /* Convert the EOL */
    333         rc = vboxClipboardUtf16WinToLin(pwszSrcText, cwSrc, pwszDestText, cwDest);
     333        rc = ShClUtf16WinToLin(pwszSrcText, cwSrc, pwszDestText, cwDest);
    334334        if (RT_FAILURE(rc))
    335335        {
    … …  
    381381        PasteboardItemID itemId = (PasteboardItemID)1;
    382382
    383         rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmpSize);
     383        rc = ShClDibToBmp(pv, cb, &pBmp, &cbBmpSize);
    384384        if (RT_SUCCESS(rc))
    385385        {
Note: See TracChangeset for help on using the changeset viewer.

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