VirtualBox

Changeset 79347 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Jun 26, 2019 9:15:29 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131579
Message:

Shared Clipboard/URI: Update.

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk

    • Property svn:mergeinfo

      •  

        old new  
        99/branches/VBox-5.1:112367,115992,116543,116550,116568,116573
        1010/branches/VBox-5.2:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124260,124263,124271,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812
        11 /branches/VBox-6.0:130474-130475,130477,130479
         11/branches/VBox-6.0:130474-130475,130477,130479,131352
        1212/branches/aeichner/vbox-chromium-cleanup:129816,129818-129851,129853-129861,129871-129872,129876,129880,129882,130013-130015,130036,130094-130095
        1313/branches/andy/draganddrop:90781-91268

  • trunk/src/VBox/Additions/WINNT/VBoxTray/Makefile.kmk

    r79270 r79347  
    6161        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp \
    6262        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \
    63         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp \
    64         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-VbglR3.cpp \
    6563        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp \
    6664        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp \

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

    r79299 r79347  
    8282*********************************************************************************************************************************/
    8383#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    84 static DECLCALLBACK(void) vboxClipboardOnURITransferComplete(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    85 static DECLCALLBACK(void) vboxClipboardOnURITransferError(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
     84static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
     85static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
    8686#endif
    8787
     88
     89#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     90static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     91{
     92    RT_NOREF(rc);
     93
     94    LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
     95
     96    LogRel2(("Shared Clipboard: Transfer to destination complete\n"));
     97
     98    PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
     99    AssertPtr(pCtx);
     100
     101    PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
     102    AssertPtr(pTransfer);
     103
     104    if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
     105    {
     106        delete pTransfer->pvUser;
     107        pTransfer->pvUser = NULL;
     108    }
     109
     110    int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
     111    AssertRC(rc2);
     112}
     113
     114static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     115{
     116    RT_NOREF(rc);
     117
     118    LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
     119
     120    LogRel(("Shared Clipboard: Transfer to destination failed with %Rrc\n", rc));
     121
     122    PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
     123    AssertPtr(pCtx);
     124
     125    PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
     126    AssertPtr(pTransfer);
     127
     128    if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
     129    {
     130        delete pTransfer->pvUser;
     131        pTransfer->pvUser = NULL;
     132    }
     133
     134    int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
     135    AssertRC(rc2);
     136}
     137
     138static int vboxClipboardURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     139{
     140    LogFlowFuncEnter();
     141
     142    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     143    AssertPtr(pThisCtx);
     144
     145    LogFlowFunc(("c=%RU32\n", pThisCtx->u32ClientID));
     146
     147    VBOXCLIPBOARDDATAHDR dataHdr;
     148    SharedClipboardURIDataHdrInit(&dataHdr);
     149
     150    int rc = VbglR3ClipboardReadDataHdr(pThisCtx->u32ClientID, &dataHdr);
     151    if (RT_SUCCESS(rc))
     152    {
     153        *ppDataHdr = SharedClipboardURIDataHdrDup(&dataHdr);
     154    }
     155
     156    LogFlowFuncLeaveRC(rc);
     157    return rc;
     158}
     159
     160static int vboxClipboardURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr)
     161{
     162    LogFlowFuncEnter();
     163
     164    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     165    AssertPtr(pThisCtx);
     166
     167    int rc = VbglR3ClipboardWriteDataHdr(pThisCtx->u32ClientID, pDataHdr);
     168
     169    LogFlowFuncLeaveRC(rc);
     170    return rc;
     171}
     172
     173static int vboxClipboardURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     174                                         void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead)
     175{
     176    RT_NOREF(fFlags);
     177
     178    LogFlowFuncEnter();
     179
     180    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     181    AssertPtr(pThisCtx);
     182
     183    int rc = VINF_SUCCESS;
     184
     185    uint32_t cbReadTotal = 0;
     186    uint32_t cbToRead = RT_MIN(pDataHdr->cbMeta, cbChunk);
     187
     188    while (cbToRead)
     189    {
     190        uint32_t cbRead;
     191        rc = VbglR3ClipboardReadMetaData(pThisCtx->u32ClientID, pDataHdr, (uint8_t *)pvChunk + cbReadTotal, cbToRead, &cbRead);
     192        if (RT_FAILURE(rc))
     193            break;
     194
     195        cbReadTotal += cbRead;
     196        Assert(cbToRead >= cbRead);
     197        cbToRead    -= cbRead;
     198    }
     199
     200    if (RT_SUCCESS(rc))
     201    {
     202        if (pcbRead)
     203            *pcbRead = cbReadTotal;
     204    }
     205
     206    LogFlowFuncLeaveRC(rc);
     207    return rc;
     208}
     209
     210static int vboxClipboardURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     211                                          const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten)
     212{
     213    RT_NOREF(fFlags);
     214
     215    LogFlowFuncEnter();
     216
     217    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     218    AssertPtr(pThisCtx);
     219
     220    int rc = VINF_SUCCESS;
     221
     222    uint32_t cbWrittenTotal = 0;
     223    uint32_t cbToWrite      = RT_MIN(pDataHdr->cbMeta, cbChunk);
     224
     225    while (cbToWrite)
     226    {
     227        uint32_t cbWritten;
     228        rc = VbglR3ClipboardWriteMetaData(pThisCtx->u32ClientID, pDataHdr, (uint8_t *)pvChunk + cbWrittenTotal, cbToWrite,
     229                                          &cbWritten);
     230        if (RT_FAILURE(rc))
     231            break;
     232
     233        cbWrittenTotal += cbWritten;
     234        Assert(cbToWrite >= cbWritten);
     235        cbToWrite      -= cbWritten;
     236    }
     237
     238    if (RT_SUCCESS(rc))
     239    {
     240        if (pcbWritten)
     241            *pcbWritten = cbWrittenTotal;
     242    }
     243
     244    LogFlowFunc(("cbWrittenTotal=%RU32, rc=%Rrc\n", cbWrittenTotal, rc));
     245    return rc;
     246}
     247
     248static int vboxClipboardURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData)
     249{
     250    LogFlowFuncEnter();
     251
     252    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     253    AssertPtr(pThisCtx);
     254
     255    VBOXCLIPBOARDDIRDATA dirData;
     256    SharedClipboardURIDirDataInit(&dirData);
     257
     258    int rc = VbglR3ClipboardReadDir(pThisCtx->u32ClientID, dirData.pszPath, dirData.cbPath, &dirData.cbPath, &dirData.fMode);
     259    if (RT_SUCCESS(rc))
     260    {
     261        *ppDirData = SharedClipboardURIDirDataDup(&dirData);
     262    }
     263
     264    LogFlowFuncLeaveRC(rc);
     265    return rc;
     266}
     267
     268static int vboxClipboardURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData)
     269{
     270    LogFlowFuncEnter();
     271
     272    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     273    AssertPtr(pThisCtx);
     274
     275    int rc = VbglR3ClipboardWriteDir(pThisCtx->u32ClientID, pDirData->pszPath, pDirData->cbPath, pDirData->fMode);
     276
     277    LogFlowFuncLeaveRC(rc);
     278    return rc;
     279}
     280
     281static int vboxClipboardURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr)
     282{
     283    LogFlowFuncEnter();
     284
     285    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     286    AssertPtr(pThisCtx);
     287
     288    VBOXCLIPBOARDFILEHDR fileHdr;
     289    SharedClipboardURIFileHdrInit(&fileHdr);
     290
     291    int rc = VbglR3ClipboardReadFileHdr(pThisCtx->u32ClientID, fileHdr.pszFilePath, fileHdr.cbFilePath,
     292                                        &fileHdr.fFlags, &fileHdr.fMode, &fileHdr.cbSize);
     293    if (RT_SUCCESS(rc))
     294    {
     295        *ppFileHdr = SharedClipboardURIFileHdrDup(&fileHdr);
     296    }
     297
     298    LogFlowFuncLeaveRC(rc);
     299    return rc;
     300}
     301
     302static int vboxClipboardURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr)
     303{
     304    LogFlowFuncEnter();
     305
     306    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     307    AssertPtr(pThisCtx);
     308
     309    int rc = VbglR3ClipboardWriteFileHdr(pThisCtx->u32ClientID, pFileHdr->pszFilePath, pFileHdr->cbFilePath,
     310                                         pFileHdr->fFlags, pFileHdr->fMode, pFileHdr->cbSize);
     311    LogFlowFuncLeaveRC(rc);
     312    return rc;
     313}
     314
     315static int vboxClipboardURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     316                                        uint32_t *pcbRead)
     317{
     318    RT_NOREF(fFlags);
     319
     320    AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
     321
     322    LogFlowFuncEnter();
     323
     324    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     325    AssertPtr(pThisCtx);
     326
     327    int rc = VbglR3ClipboardReadFileData(pThisCtx->u32ClientID, pvData, cbData, pcbRead);
     328
     329    LogFlowFuncLeaveRC(rc);
     330    return rc;
     331}
     332
     333static int vboxClipboardURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     334                                         uint32_t *pcbWritten)
     335{
     336    RT_NOREF(fFlags);
     337
     338    AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER);
     339
     340    LogFlowFuncEnter();
     341
     342    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     343    AssertPtr(pThisCtx);
     344
     345    int rc = VbglR3ClipboardWriteFileData(pThisCtx->u32ClientID, pvData, cbData, pcbWritten);
     346
     347    LogFlowFuncLeaveRC(rc);
     348    return rc;
     349}
     350#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    88351
    89352static LRESULT vboxClipboardWinProcessMsg(PVBOXCLIPBOARDCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    … …  
    99362       case WM_CLIPBOARDUPDATE:
    100363       {
    101             const HWND hWndClipboardOwner = GetClipboardOwner();
    102             if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
    103             {
    104                 LogFunc(("WM_CLIPBOARDUPDATE: hWndOldClipboardOwner=%p, hWndNewClipboardOwner=%p\n",
    105                          pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
    106 
    107                 /* Clipboard was updated by another application.
     364           const HWND hWndClipboardOwner = GetClipboardOwner();
     365           if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
     366           {
     367               LogFunc(("WM_CLIPBOARDUPDATE: hWndOldClipboardOwner=%p, hWndNewClipboardOwner=%p\n",
     368                        pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
     369
     370               /* Clipboard was updated by another application.
    108371                * Report available formats to the host. */
    109372               VBOXCLIPBOARDFORMATS fFormats;
    … …  
    114377                   rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, fFormats);
    115378               }
    116             }
     379           }
    117380       }
    118381       break;
    … …  
    340603
    341604                            TransferCallbacks.pvUser              = &pCtx->URI;
    342                             TransferCallbacks.pfnTransferComplete = vboxClipboardOnURITransferComplete;
    343                             TransferCallbacks.pfnTransferError    = vboxClipboardOnURITransferError;
     605                            TransferCallbacks.pfnTransferComplete = vboxClipboardURITransferCompleteCallback;
     606                            TransferCallbacks.pfnTransferError    = vboxClipboardURITransferErrorCallback;
    344607
    345608                            SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks);
    … …  
    347610                            SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    348611                            RT_ZERO(creationCtx);
    349                             creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
    350                             creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
     612                            creationCtx.enmSource = SHAREDCLIPBOARDSOURCE_REMOTE;
     613
     614                            RT_ZERO(creationCtx.Interface);
     615                            creationCtx.Interface.pfnReadDataHdr    = vboxClipboardURIReadDataHdr;
     616                            creationCtx.Interface.pfnReadDataChunk  = vboxClipboardURIReadDataChunk;
     617                            creationCtx.Interface.pfnReadDirectory  = vboxClipboardURIReadDir;
     618                            creationCtx.Interface.pfnReadFileHdr    = vboxClipboardURIReadFileHdr;
     619                            creationCtx.Interface.pfnReadFileData   = vboxClipboardURIReadFileData;
     620
     621                            creationCtx.pvUser = pCtx;
     622
    351623                            creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    352624
    … …  
    356628                                rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
    357629                                if (RT_SUCCESS(rc))
    358                                     rc = VBoxClipboardWinURIAnnounce(pWinCtx, &pCtx->URI, pTransfer);
     630                                    rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    359631                            }
    360632
    361                             /* Note: VBoxClipboardWinURIAnnounce() takes care of closing the clipboard. */
     633                            /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
    362634
    363635                            LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST: rc=%Rrc\n", rc));
    … …  
    453725               {
    454726                   LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST cTransfers=%RU32\n",
    455                             SharedClipboardURICtxGetActiveTransfers(&pCtx->URI)));
     727                            SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
    456728
    457729                    PSHAREDCLIPBOARDURITRANSFER pTransfer;
    … …  
    463735
    464736                        TransferCallbacks.pvUser              = &pCtx->URI;
    465                         TransferCallbacks.pfnTransferComplete = vboxClipboardOnURITransferComplete;
    466                         TransferCallbacks.pfnTransferError    = vboxClipboardOnURITransferError;
     737                        TransferCallbacks.pfnTransferComplete = vboxClipboardURITransferCompleteCallback;
     738                        TransferCallbacks.pfnTransferError    = vboxClipboardURITransferErrorCallback;
    467739
    468740                        SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks);
    … …  
    470742                        SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    471743                        RT_ZERO(creationCtx);
    472                         creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
    473                         creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_WRITE;
     744                        creationCtx.enmSource          = SHAREDCLIPBOARDSOURCE_LOCAL;
    474745                        creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    475746
    … …  
    610881    return rc;
    611882}
    612 
    613 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    614 static DECLCALLBACK(void) vboxClipboardOnURITransferComplete(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
    615 {
    616     RT_NOREF(rc);
    617 
    618     LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
    619 
    620     LogRel2(("Shared Clipboard: Transfer to destination complete\n"));
    621 
    622     PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
    623     AssertPtr(pCtx);
    624 
    625     PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
    626     AssertPtr(pTransfer);
    627 
    628     if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
    629     {
    630         delete pTransfer->pvUser;
    631         pTransfer->pvUser = NULL;
    632     }
    633 
    634     int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
    635     AssertRC(rc2);
    636 }
    637 
    638 static DECLCALLBACK(void) vboxClipboardOnURITransferError(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
    639 {
    640     RT_NOREF(rc);
    641 
    642     LogFlowFunc(("pData=%p, rc=%Rrc\n", pData, rc));
    643 
    644     LogRel(("Shared Clipboard: Transfer to destination failed with %Rrc\n", rc));
    645 
    646     PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser;
    647     AssertPtr(pCtx);
    648 
    649     PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer;
    650     AssertPtr(pTransfer);
    651 
    652     if (pTransfer->pvUser) /* SharedClipboardWinURITransferCtx */
    653     {
    654         delete pTransfer->pvUser;
    655         pTransfer->pvUser = NULL;
    656     }
    657 
    658     int rc2 = SharedClipboardURICtxTransferRemove(pCtx, pTransfer);
    659     AssertRC(rc2);
    660 }
    661 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    662883
    663884static void vboxClipboardDestroy(PVBOXCLIPBOARDCONTEXT pCtx)
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