Changeset 100394 in vbox
- Timestamp:
- Jul 5, 2023 4:21:48 PM (20 months ago)
- svn:sync-xref-src-repo-rev:
- 158134
- Location:
- trunk
- Files:
-
- 5 edited
-
include/VBox/GuestHost/SharedClipboard-win.h (modified) (8 diffs)
-
src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (modified) (4 diffs)
-
src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (modified) (3 diffs)
-
src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp (modified) (2 diffs)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (modified) (6 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/VBox/GuestHost/SharedClipboard-win.h
r100367 r100394 171 171 int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATS pfFormats); 172 172 173 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS174 int SharedClipboardWinTransferGetRoots(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer);175 int SharedClipboardWinTransferDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList);176 int SharedClipboardWinTransferGetRootsFromClipboard(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer);177 int SharedClipboardWinTransferCreateAndSetDataObject(PSHCLWINCTX pWinCtx, PSHCLCONTEXT pCtx, PSHCLCALLBACKS pCallbacks);178 #endif179 180 173 int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue); 181 174 bool SharedClipboardWinIsCFHTML(const char *pszSource); … … 189 182 190 183 int SharedClipboardWinClearAndAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats, HWND hWnd); 184 191 185 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS 192 int SharedClipboardWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer);193 void SharedClipboardWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer);194 #endif195 196 # ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS197 186 class SharedClipboardTransferList; 198 187 # ifndef FILEGROUPDESCRIPTOR … … 200 189 # endif 201 190 191 /** 192 * Generic Windows class implementing IDataObject for Shared Clipboard data transfers. 193 */ 202 194 class SharedClipboardWinDataObject : public IDataObject //, public IDataObjectAsyncCapability 203 195 { 204 196 public: 197 198 /** 199 * Structure for keeping a data object callback context. 200 */ 201 struct CALLBACKCTX 202 { 203 /** Pointer to the data object of this callback. */ 204 SharedClipboardWinDataObject *pThis; 205 /** User-supplied pointer to more context data. */ 206 void *pvUser; 207 }; 208 /** Pointer to a Shared Clipboard Windows data object callback table. */ 209 typedef CALLBACKCTX *PCALLBACKCTX; 210 211 /** 212 * @name Shared Clipboard Windows data object callback table. 213 */ 214 struct CALLBACKS 215 { 216 /** 217 * Called by the data object if a transfer needs to be started. 218 * 219 * @returns VBox status code. 220 * @param pCbCtx Pointer to callback context. 221 */ 222 DECLCALLBACKMEMBER(int, pfnTransferStart, (PCALLBACKCTX pCbCtx)); 223 }; 224 /** Pointer to a Shared Clipboard Windows data object callback table. */ 225 typedef CALLBACKS *PCALLBACKS; 205 226 206 227 enum Status … … 228 249 public: 229 250 230 int Init(PSHCLCONTEXT pCtx, LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0);251 int Init(PSHCLCONTEXT pCtx, SharedClipboardWinDataObject::PCALLBACKS pCallbacks, LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0); 231 252 void Destroy(void); 232 253 … … 303 324 /** Shared Clipboard context to use. */ 304 325 PSHCLCONTEXT m_pCtx; 305 /** Callbacks table to use. */306 SHCLCALLBACKS m_Callbacks;307 326 /** The object's current status. */ 308 327 Status m_enmStatus; 328 /** Data object callback table to use. */ 329 CALLBACKS m_Callbacks; 330 /** Data object callback table context to use. */ 331 CALLBACKCTX m_CallbackCtx; 309 332 /** The object's current reference count. */ 310 333 LONG m_lRefCount; … … 340 363 }; 341 364 365 /** 366 * Generic Windows class implementing IEnumFORMATETC for Shared Clipboard data transfers. 367 */ 342 368 class SharedClipboardWinEnumFormatEtc : public IEnumFORMATETC 343 369 { … … 379 405 380 406 /** 381 * Own IStream implementation to implement file-based clipboard operations 382 * through HGCM. Needed on Windows hosts and guests. 407 * Generic Windows class implementing IStream for Shared Clipboard data transfers. 383 408 */ 384 409 class SharedClipboardWinStreamImpl : public IStream … … 454 479 SharedClipboardWinDataObject *pDataObj; 455 480 }; 481 482 int SharedClipboardWinTransferGetRoots(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer); 483 int SharedClipboardWinTransferDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList); 484 int SharedClipboardWinTransferGetRootsFromClipboard(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer); 485 486 int SharedClipboardWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer); 487 void SharedClipboardWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer); 488 489 int SharedClipboardWinTransferCreateAndSetDataObject(PSHCLWINCTX pWinCtx, PSHCLCONTEXT pCtx, SharedClipboardWinDataObject::PCALLBACKS pCallbacks); 456 490 # endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */ 457 491 #endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_win_h */ -
trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp
r100367 r100394 93 93 *********************************************************************************************************************************/ 94 94 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS 95 static DECLCALLBACK(void) vbtrShClTransferInitializedCallback(PSHCLTXPROVIDERCTX pC tx);96 static DECLCALLBACK(void) vbtrShClTransferStartedCallback(PSHCLTXPROVIDERCTX pC tx);97 static DECLCALLBACK(void) vbtrShClTransferErrorCallback(PSHCLTXPROVIDERCTX pC tx, int rc);95 static DECLCALLBACK(void) vbtrShClTransferInitializedCallback(PSHCLTXPROVIDERCTX pCbCtx); 96 static DECLCALLBACK(void) vbtrShClTransferStartedCallback(PSHCLTXPROVIDERCTX pCbCtx); 97 static DECLCALLBACK(void) vbtrShClTransferErrorCallback(PSHCLTXPROVIDERCTX pCbCtx, int rc); 98 98 #endif 99 99 100 100 101 /** 102 * Worker for a reading clipboard from the host. 103 */ 104 static DECLCALLBACK(int) vbtrReadDataWorker(PSHCLCONTEXT pCtx, SHCLFORMAT uFmt, void **ppv, uint32_t *pcb, void *pvUser) 105 { 106 RT_NOREF(pvUser); 107 108 LogFlowFuncEnter(); 109 110 int rc = VERR_NO_DATA; /* Play safe. */ 111 112 uint32_t cbRead = 0; 113 114 uint32_t cbData = _4K; /** @todo Make this dynamic. */ 115 void *pvData = RTMemAlloc(cbData); 116 if (pvData) 117 { 118 rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmt, pvData, cbData, &cbRead); 119 } 120 else 121 rc = VERR_NO_MEMORY; 122 123 /* 124 * A return value of VINF_BUFFER_OVERFLOW tells us to try again with a 125 * larger buffer. The size of the buffer needed is placed in *pcb. 126 * So we start all over again. 127 */ 128 if (rc == VINF_BUFFER_OVERFLOW) 129 { 130 /* cbRead contains the size required. */ 131 132 cbData = cbRead; 133 pvData = RTMemRealloc(pvData, cbRead); 134 if (pvData) 135 { 136 rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmt, pvData, cbData, &cbRead); 137 if (rc == VINF_BUFFER_OVERFLOW) 138 rc = VERR_BUFFER_OVERFLOW; 139 } 140 else 141 rc = VERR_NO_MEMORY; 142 } 143 144 if (!cbRead) 145 rc = VERR_NO_DATA; 146 147 if (RT_SUCCESS(rc)) 148 { 149 if (ppv) 150 *ppv = pvData; 151 if (pcb) 152 *pcb = cbRead; /* Actual bytes read. */ 153 } 154 else 155 { 156 /* 157 * Catch other errors. This also catches the case in which the buffer was 158 * too small a second time, possibly because the clipboard contents 159 * changed half-way through the operation. Since we can't say whether or 160 * not this is actually an error, we just return size 0. 161 */ 162 RTMemFree(pvData); 163 } 164 165 LogFlowFuncLeaveRC(rc); 166 return rc; 167 } 168 101 169 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS 170 171 /** 172 * @copydoc SharedClipboardWinDataObject::CALLBACKS::pfnTransferStart 173 * 174 * @thread Clipboard main thread. 175 */ 176 static DECLCALLBACK(int) vbtrShClDataObjectTransferStartCallback(SharedClipboardWinDataObject::PCALLBACKCTX pCbCtx) 177 { 178 LogFlowFuncEnter(); 179 180 PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pCbCtx->pvUser; 181 AssertPtr(pCtx); 182 183 int rc = VbglR3ClipboardTransferRequest(&pCtx->CmdCtx); 184 185 LogFlowFuncLeaveRC(rc); 186 return rc; 187 } 188 189 /** 190 * @copydoc SHCLTRANSFERCALLBACKS::pfnOnInitialized 191 * 192 * Called by ShClTransferInit via VbglR3. 193 * This lets the current in-flight data object know that it can start the actual transfer as needed. 194 * 195 * @thread Clipboard main thread. 196 */ 197 static DECLCALLBACK(void) vbtrShClTransferInitializedCallback(PSHCLTXPROVIDERCTX pCbCtx) 198 { 199 LogFlowFuncEnter(); 200 201 int rc = VINF_SUCCESS; 202 203 PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pCbCtx->pvUser; 204 AssertPtr(pCtx); 205 206 switch(ShClTransferGetDir(pCbCtx->pTransfer)) 207 { 208 case SHCLTRANSFERDIR_FROM_REMOTE: 209 { 210 AssertPtrBreak(pCtx->Win.pDataObjInFlight); 211 rc = pCtx->Win.pDataObjInFlight->SetStatus(SharedClipboardWinDataObject::Running); 212 break; 213 } 214 215 default: 216 break; 217 } 218 219 LogFlowFuncLeaveRC(rc); 220 } 102 221 103 222 /** … … 132 251 * Worker for a reading clipboard from the host. 133 252 * 134 * @thread Main clipboardthread.253 * @thread Clipboard main thread. 135 254 */ 136 255 static DECLCALLBACK(int) vbtrShClRequestDataFromSourceCallbackWorker(PSHCLCONTEXT pCtx, … … 139 258 RT_NOREF(pvUser); 140 259 141 LogFlowFuncEnter(); 142 143 int rc = VERR_NO_DATA; /* Play safe. */ 144 145 uint32_t cbRead = 0; 146 147 uint32_t cbData = _4K; /** @todo Make this dynamic. */ 148 void *pvData = RTMemAlloc(cbData); 149 if (pvData) 150 { 151 rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmt, pvData, cbData, &cbRead); 152 } 153 else 154 rc = VERR_NO_MEMORY; 155 156 /* 157 * A return value of VINF_BUFFER_OVERFLOW tells us to try again with a 158 * larger buffer. The size of the buffer needed is placed in *pcb. 159 * So we start all over again. 160 */ 161 if (rc == VINF_BUFFER_OVERFLOW) 162 { 163 /* cbRead contains the size required. */ 164 165 cbData = cbRead; 166 pvData = RTMemRealloc(pvData, cbRead); 167 if (pvData) 168 { 169 rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmt, pvData, cbData, &cbRead); 170 if (rc == VINF_BUFFER_OVERFLOW) 171 rc = VERR_BUFFER_OVERFLOW; 172 } 173 else 174 rc = VERR_NO_MEMORY; 175 } 176 177 if (!cbRead) 178 rc = VERR_NO_DATA; 179 180 if (RT_SUCCESS(rc)) 181 { 182 if (ppv) 183 *ppv = pvData; 184 if (pcb) 185 *pcb = cbRead; /* Actual bytes read. */ 186 } 187 else 188 { 189 /* 190 * Catch other errors. This also catches the case in which the buffer was 191 * too small a second time, possibly because the clipboard contents 192 * changed half-way through the operation. Since we can't say whether or 193 * not this is actually an error, we just return size 0. 194 */ 195 RTMemFree(pvData); 196 } 260 LogFlowFunc(("pCtx=%p, uFmt=%#x\n", pCtx, uFmt)); 261 262 int rc = vbtrReadDataWorker(pCtx, uFmt, ppv, pcb, pvUser); 263 264 if (RT_FAILURE(rc)) 265 LogRel(("Shared Clipboard: Requesting data in format %#x from host failed with %Rrc\n", uFmt, rc)); 197 266 198 267 LogFlowFuncLeaveRC(rc); … … 634 703 { 635 704 /* 636 * Creating and starting the actual transfer will be done in vbglR3ClipboardTransferStart() as soon 637 * as the host announces the start of the transfer via a VBOX_SHCL_HOST_MSG_TRANSFER_STATUS message. 638 * Transfers always are controlled and initiated on the host side! 639 * 640 * What we need to do here, however, is, that we create our IDataObject implementation and push it to the 641 * Windows clibpoard. That way Windows will recognize that there is a data transfer "in flight". 705 * Create our IDataObject implementation and push it to the Windows clibpoard. 706 * That way Windows will recognize that there is a data transfer available. 642 707 */ 643 S HCLCALLBACKS Callbacks;708 SharedClipboardWinDataObject::CALLBACKS Callbacks; 644 709 RT_ZERO(Callbacks); 645 Callbacks.pfn OnRequestDataFromSource = vbtrShClRequestDataFromSourceCallback;710 Callbacks.pfnTransferStart = vbtrShClDataObjectTransferStartCallback; 646 711 647 712 rc = SharedClipboardWinTransferCreateAndSetDataObject(pWinCtx, pCtx, &Callbacks); -
trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp
r100367 r100394 79 79 * 80 80 * @returns VBox status code. 81 * @param pFormatEtc FormatETC to use. 82 * @param pStgMed Storage medium to use. 83 * @param cFormats Number of formats in \a pFormatEtc and \a pStgMed. 84 */ 85 int SharedClipboardWinDataObject::Init(PSHCLCONTEXT pCtx, 81 * @param pCtx Opaque Shared Clipboard context to use. 82 * @param pCallbacks Callbacks table to use. 83 * @param pFormatEtc FormatETC to use. Optional. 84 * @param pStgMed Storage medium to use. Optional. 85 * @param cFormats Number of formats in \a pFormatEtc and \a pStgMed. Optional. 86 */ 87 int SharedClipboardWinDataObject::Init(PSHCLCONTEXT pCtx, SharedClipboardWinDataObject::PCALLBACKS pCallbacks, 86 88 LPFORMATETC pFormatEtc /* = NULL */, LPSTGMEDIUM pStgMed /* = NULL */, 87 89 ULONG cFormats /* = 0 */) 88 90 { 89 91 AssertPtrReturn(pCtx, VERR_INVALID_POINTER); 92 AssertPtrReturn(pCallbacks, VERR_INVALID_POINTER); 90 93 AssertReturn(cFormats == 0 || (RT_VALID_PTR(pFormatEtc) && RT_VALID_PTR(pStgMed)), VERR_INVALID_POINTER); 91 94 … … 94 97 m_pCtx = pCtx; /* Save opaque context. */ 95 98 99 /* 100 * Set up callback context + table. 101 */ 102 memcpy(&m_Callbacks, pCallbacks, sizeof(SharedClipboardWinDataObject::CALLBACKS)); 103 m_CallbackCtx.pvUser = pCtx; 104 m_CallbackCtx.pThis = this; 105 106 /* 107 * Set up / register handled formats. 108 */ 96 109 ULONG cFixedFormats = 3; /* CFSTR_FILEDESCRIPTORA + CFSTR_FILECONTENTS + CFSTR_PERFORMEDDROPEFFECT */ 97 110 #ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT … … 690 703 /* Leave lock while requesting + waiting. */ 691 704 rc2 = RTCritSectLeave(&m_CritSect); 692 AssertRCReturn(rc2, E_UNEXPECTED); 693 694 /* Request the transfer from the source. 695 * This will generate a transfer status message which we're waiting for here. */ 696 #if 0 // CLEAN 697 AssertPtr(m_Callbacks.pfnOnRequestDataFromSource); 698 rc = m_Callbacks.pfnOnRequestDataFromSource(m_pCtx, 699 VBOX_SHCL_FMT_URI_LIST, NULL /* ppv */, NULL /* pv */, 700 this /* pvUser */); 701 AssertRCBreak(rc); 702 #else 703 rc = ShClTransferStart(m_pTransfer); 704 AssertRCBreak(rc); 705 #endif 705 AssertRCBreak(rc2); 706 707 /* Start the transfer. */ 708 AssertPtrBreak(m_Callbacks.pfnTransferStart); 709 rc = m_Callbacks.pfnTransferStart(&m_CallbackCtx); 710 AssertRCBreak(rc2); 706 711 707 712 LogRel2(("Shared Clipboard: Waiting for IDataObject started status ...\n")); 708 713 709 714 rc = RTSemEventWait(m_EventStatusChanged, SHCL_TIMEOUT_DEFAULT_MS); 715 AssertRCBreak(rc2); 710 716 711 717 /* Re-acquire lock. */ 712 718 rc2 = RTCritSectEnter(&m_CritSect); 713 AssertRC Return(rc2, E_UNEXPECTED);719 AssertRCBreak(rc2); 714 720 715 721 if (RT_SUCCESS(rc)) -
trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp
r100367 r100394 1050 1050 * @param pCallbacks Callbacks table to use. 1051 1051 */ 1052 int SharedClipboardWinTransferCreateAndSetDataObject(PSHCLWINCTX pWinCtx, PSHCLCONTEXT pCtx, PSHCLCALLBACKS pCallbacks) 1052 int SharedClipboardWinTransferCreateAndSetDataObject(PSHCLWINCTX pWinCtx, 1053 PSHCLCONTEXT pCtx, SharedClipboardWinDataObject::PCALLBACKS pCallbacks) 1053 1054 { 1054 1055 AssertPtrReturn(pWinCtx, VERR_INVALID_POINTER); … … 1066 1067 if (pObj) 1067 1068 { 1068 rc = pObj->Init(pCtx );1069 rc = pObj->Init(pCtx, pCallbacks); 1069 1070 if (RT_SUCCESS(rc)) 1070 1071 { -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
r100381 r100394 252 252 PSHCLTXPROVIDERIFACE pIface = &pClient->Transfers.Provider.Interface; 253 253 254 pClient->Transfers.Provider.enmSource = pClient->State.enmSource; 255 pClient->Transfers.Provider.pvUser = pClient; 256 257 int rc = VINF_SUCCESS; 258 254 259 switch (ShClTransferGetDir(pTransfer)) 255 260 { 256 case SHCLTRANSFERDIR_FROM_REMOTE: /* G uest -> Host.*/261 case SHCLTRANSFERDIR_FROM_REMOTE: /* G->H */ 257 262 { 258 263 pIface->pfnRootListRead = shClSvcTransferIfaceGHRootListRead; … … 269 274 } 270 275 271 case SHCLTRANSFERDIR_TO_REMOTE: /* H ost -> Guest.*/276 case SHCLTRANSFERDIR_TO_REMOTE: /* H->G */ 272 277 { 273 278 pIface->pfnRootListRead = shClSvcWinTransferIfaceHGRootListRead; … … 276 281 277 282 default: 278 AssertFailed(); 279 } 280 281 int rc = ShClTransferSetProvider(pTransfer, &pClient->Transfers.Provider); RT_NOREF(rc); 283 AssertFailedStmt(rc = VERR_NOT_SUPPORTED); 284 break; 285 } 286 287 if (RT_SUCCESS(rc)) 288 rc = ShClTransferSetProvider(pTransfer, &pClient->Transfers.Provider); RT_NOREF(rc); 282 289 283 290 LogFlowFuncLeaveRC(rc); … … 287 294 * @copydoc SHCLTRANSFERCALLBACKS::pfnOnInitialized 288 295 * 289 * Called on transfer intialization to notify the "in-flight" IDataObject about a data transfer. 296 * For G->H: Called on transfer intialization to notify the "in-flight" IDataObject about a data transfer. 297 * For H->G: Called on transfer intialization to populate the transfer's root list. 290 298 * 291 299 * @thread Service main thread. … … 299 307 AssertPtr(pTransfer); 300 308 301 const SHCLTRANSFERDIR enmDir = ShClTransferGetDir(pTransfer);302 303 309 int rc = VINF_SUCCESS; 304 310 305 LogFlowFunc(("pCtx=%p, idTransfer=%RU32, enmDir=%RU32\n", pCtx, ShClTransferGetID(pTransfer), enmDir)); 306 307 /* The host wants to transfer data from the guest. */ 308 if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE) 309 { 310 rc = RTCritSectEnter(&pCtx->Win.CritSect); 311 if (RT_SUCCESS(rc)) 312 { 313 SharedClipboardWinDataObject *pObj = pCtx->Win.pDataObjInFlight; 314 AssertPtrReturnVoid(pObj); 315 rc = pObj->SetTransfer(pTransfer); 316 317 pCtx->Win.pDataObjInFlight = NULL; /* Hand off to Windows. */ 318 319 int rc2 = RTCritSectLeave(&pCtx->Win.CritSect); 320 AssertRC(rc2); 321 } 322 } 323 324 if (RT_FAILURE(rc)) 325 LogRel(("Shared Clipboard: Starting transfer failed, rc=%Rrc\n", rc)); 326 327 LogFlowFunc(("LEAVE: idTransfer=%RU32, rc=%Rrc\n", ShClTransferGetID(pTransfer), rc)); 311 switch (ShClTransferGetDir(pTransfer)) 312 { 313 case SHCLTRANSFERDIR_FROM_REMOTE: /* G->H */ 314 { 315 rc = RTCritSectEnter(&pCtx->Win.CritSect); 316 if (RT_SUCCESS(rc)) 317 { 318 SharedClipboardWinDataObject *pObj = pCtx->Win.pDataObjInFlight; 319 AssertPtrReturnVoid(pObj); 320 rc = pObj->SetTransfer(pTransfer); 321 322 pCtx->Win.pDataObjInFlight = NULL; /* Hand off to Windows. */ 323 324 int rc2 = RTCritSectLeave(&pCtx->Win.CritSect); 325 AssertRC(rc2); 326 } 327 328 break; 329 } 330 331 case SHCLTRANSFERDIR_TO_REMOTE: /* H->G */ 332 { 333 rc = ShClTransferRootListRead(pTransfer); /* Calls shClSvcWinTransferIfaceHGRootListRead(). */ 334 break; 335 } 336 337 default: 338 AssertFailedStmt(rc = VERR_NOT_SUPPORTED); 339 break; 340 } 341 342 LogFlowFuncLeaveRC(rc); 328 343 } 329 344 … … 803 818 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS 804 819 /* 805 * Init transfer callbacks. 820 * Set callbacks. 821 * Those will be registered within ShClSvcTransferInit() when a new transfer gets initialized. 806 822 */ 807 823 RT_ZERO(pClient->Transfers.Callbacks); 824 825 pClient->Transfers.Callbacks.pvUser = pCtx; /* Assign context as user-provided callback data. */ 826 pClient->Transfers.Callbacks.cbUser = sizeof(SHCLCONTEXT); 827 828 pClient->Transfers.Callbacks.pfnOnCreated = shClSvcWinTransferOnCreatedCallback; 808 829 pClient->Transfers.Callbacks.pfnOnInitialized = shClSvcWinTransferOnInitializedCallback; 809 830 pClient->Transfers.Callbacks.pfnOnStarted = shClSvcWinTransferOnStartedCallback; 810 831 pClient->Transfers.Callbacks.pfnOnDestroy = shClSvcWinTransferOnDestroyCallback; 811 812 pClient->Transfers.Callbacks.pvUser = pCtx; /* Assign context as user-provided callback data. */813 pClient->Transfers.Callbacks.cbUser = sizeof(SHCLCONTEXT);814 832 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */ 815 833 }
Note:
See TracChangeset
for help on using the changeset viewer.
