VirtualBox

Ignore:
Timestamp:
Sep 3, 2019 9:49:42 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133077
Message:

Shared Clipboard/URI: Update.

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

Legend:

Unmodified
Added
Removed

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

    r80557 r80562  
    231231int vboxSvcClipboardOldCompleteReadData(PVBOXCLIPBOARDCLIENT pClient, int rc, uint32_t cbActual);
    232232int vboxSvcClipboardOldReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uFormats);
     233void vboxSvcClipboardOldClientStateResetData(PVBOXCLIPBOARDCLIENTSTATE pClientState);
     234void vboxSvcClipboardOldClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState);
    233235
    234236uint32_t vboxSvcClipboardGetMode(void);
    … …  
    246248
    247249# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     250int vboxSvcClipboardURITransferStart(PVBOXCLIPBOARDCLIENT pClient,
     251                                     SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
     252                                     PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
    248253bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
    249254# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    … …  
    258263int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient);
    259264int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats);
     265/** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/
    260266int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual);
    261267int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData);
    … …  
    268274#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    269275int vboxSvcClipboardURITransferOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx);
    270 int vboxSvcClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx);
     276DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx);
     277
     278int vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList);
    271279
    272280int vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    273                                 PVBOXCLIPBOARDLISTHDR pListHdr, PSHAREDCLIPBOARDLISTHANDLE phList);
     281                                PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList);
    274282int vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList);
    275283int vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList,

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

    r80444 r80562  
    216216                                                pCtx->pClient->State.Old.data.pv, pCtx->pClient->State.Old.data.cb);
    217217
    218                 if (pCtx->pClient->State.Old.data.pv)
    219                 {
    220                     RTMemFree(pCtx->pClient->State.Old.data.pv);
    221                     pCtx->pClient->State.Old.data.pv = NULL;
    222                 }
     218                vboxSvcClipboardOldClientStateResetData(&pCtx->pClient->State);
    223219            }
    224220
    225221            if (RT_FAILURE(rc))
    226222            {
    227                 if (pCtx->pClient->State.Old.data.pv)
    228                 {
    229                     RTMemFree(pCtx->pClient->State.Old.data.pv);
    230                     pCtx->pClient->State.Old.data.pv = NULL;
    231                 }
    232 
    233                 pCtx->pClient->State.Old.data.cb        = 0;
    234                 pCtx->pClient->State.Old.data.u32Format = 0;
     223                vboxSvcClipboardOldClientStateReset(&pCtx->pClient->State);
    235224
    236225                /* Something went wrong. */
    … …  
    438427                {
    439428                    VBoxClipboardWinClear();
    440 #if 0
    441                     if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    442                     {
    443                         LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST\n"));
    444 
    445                         PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->pClient->URI,
    446                                                                                                  0 /* uIdx */);
    447                         if (pTransfer)
    448                         {
    449                             rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    450 
    451                             /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
    452                                      (ClipboardDataObjectImpl::GetData()). */
    453                         }
    454                         else
    455                             AssertFailedStmt(rc = VERR_NOT_FOUND);
    456 
    457                         /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
    458                     }
    459                     else
    460                     {
    461 #endif
    462                         rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
    463 
    464                         VBoxClipboardWinClose();
    465 #if 0
    466                     }
    467 #endif
     429
     430                    rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
     431
     432                    VBoxClipboardWinClose();
    468433                }
    469434
    … …  
    806771    RT_NOREF(pCmdCtx);
    807772
     773    int rc;
     774
    808775    PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx;
    809776    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    … …  
    811778    LogFlowFunc(("uFormats=0x%x, hWnd=%p\n", pFormats->uFormats, pCtx->Win.hWnd));
    812779
    813     /*
    814      * The guest announced formats. Forward to the window thread.
    815      */
    816     PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
    817                 0 /* wParam */, pFormats->uFormats /* lParam */);
    818 
    819     return VINF_SUCCESS;
     780    if (!(pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST))
     781    {
     782        /*
     783         * The guest announced formats. Forward to the window thread.
     784         */
     785        PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
     786                    0 /* wParam */, pFormats->uFormats /* lParam */);
     787
     788        rc = VINF_SUCCESS;
     789    }
     790#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     791    else if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
     792    {
     793        PSHAREDCLIPBOARDURITRANSFER pTransfer;
     794        rc = vboxSvcClipboardURITransferStart(pClient,
     795                                              SHAREDCLIPBOARDURITRANSFERDIR_READ, SHAREDCLIPBOARDSOURCE_REMOTE,
     796                                              &pTransfer);
     797        if (RT_SUCCESS(rc))
     798        {
     799            /* Create the IDataObject implementation the host OS needs and assign
     800             * the newly created transfer to this object. */
     801            rc = VBoxClipboardWinURITransferCreate(&pCtx->Win, pTransfer);
     802
     803            /*  Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
     804                      (ClipboardDataObjectImpl::GetData()). */
     805        }
     806    }
     807#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     808    else
     809        rc = VERR_NOT_SUPPORTED;
     810
     811    LogFlowFuncLeaveRC(rc);
     812    return rc;
    820813}
    821814

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

    r80560 r80562  
    10191019    return rc;
    10201020}
     1021
     1022#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     1023int vboxSvcClipboardURITransferStart(PVBOXCLIPBOARDCLIENT pClient,
     1024                                     SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
     1025                                     PSHAREDCLIPBOARDURITRANSFER *ppTransfer)
     1026{
     1027    LogFlowFuncEnter();
     1028
     1029    SharedClipboardURICtxTransfersCleanup(&pClient->URI);
     1030
     1031    int rc;
     1032
     1033    if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI))
     1034    {
     1035        PSHAREDCLIPBOARDURITRANSFER pTransfer;
     1036        rc = SharedClipboardURITransferCreate(enmDir, enmSource, &pTransfer);
     1037        if (RT_SUCCESS(rc))
     1038        {
     1039            SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
     1040            RT_ZERO(creationCtx);
     1041
     1042            if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
     1043            {
     1044                rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
     1045                if (RT_SUCCESS(rc))
     1046                {
     1047                    creationCtx.enmSource = pClient->State.enmSource;
     1048
     1049                    creationCtx.Interface.pfnTransferOpen    = vboxSvcClipboardURITransferOpen;
     1050                    creationCtx.Interface.pfnTransferClose   = vboxSvcClipboardURITransferClose;
     1051                    creationCtx.Interface.pfnListOpen        = vboxSvcClipboardURIListOpen;
     1052                    creationCtx.Interface.pfnListClose       = vboxSvcClipboardURIListClose;
     1053                    creationCtx.Interface.pfnObjOpen         = vboxSvcClipboardURIObjOpen;
     1054                    creationCtx.Interface.pfnObjClose        = vboxSvcClipboardURIObjClose;
     1055
     1056                    creationCtx.Interface.pfnGetRoots        = vboxSvcClipboardURIGetRoots;
     1057                    creationCtx.Interface.pfnListHdrRead     = vboxSvcClipboardURIListHdrRead;
     1058                    creationCtx.Interface.pfnListEntryRead   = vboxSvcClipboardURIListEntryRead;
     1059                    creationCtx.Interface.pfnObjRead         = vboxSvcClipboardURIObjRead;
     1060
     1061                    creationCtx.pvUser = pClient;
     1062                }
     1063            }
     1064            else if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_WRITE)
     1065            {
     1066                AssertFailed(); /** @todo Implement this. */
     1067            }
     1068
     1069            /* Register needed callbacks so that we can wait for the meta data to arrive here. */
     1070            SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
     1071            RT_ZERO(Callbacks);
     1072
     1073            Callbacks.pvUser                = pClient;
     1074
     1075            Callbacks.pfnTransferPrepare    = VBoxSvcClipboardURITransferPrepareCallback;
     1076            Callbacks.pfnTransferComplete   = VBoxSvcClipboardURITransferCompleteCallback;
     1077            Callbacks.pfnTransferCanceled   = VBoxSvcClipboardURITransferCanceledCallback;
     1078            Callbacks.pfnTransferError      = VBoxSvcClipboardURITransferErrorCallback;
     1079
     1080            SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
     1081
     1082            rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
     1083            if (RT_SUCCESS(rc))
     1084            {
     1085                rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer);
     1086                if (RT_SUCCESS(rc))
     1087                    rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1088
     1089                if (RT_FAILURE(rc))
     1090                    VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1091            }
     1092
     1093            if (RT_FAILURE(rc))
     1094            {
     1095                SharedClipboardURITransferDestroy(pTransfer);
     1096                pTransfer = NULL;
     1097            }
     1098            else
     1099            {
     1100                *ppTransfer = pTransfer;
     1101            }
     1102        }
     1103    }
     1104    else
     1105        rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     1106
     1107    LogFlowFuncLeaveRC(rc);
     1108    return rc;
     1109}
     1110#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    10211111
    10221112static int svcInit(void)
    … …  
    16251715
    16261716/**
     1717 * Resets the Shared Clipboard data reading porition of the old client state.
     1718 *
     1719 * Legacy protocol, do not use anymore.
     1720 *
     1721 * @param   pClientState        Client state to reset data reading portion for.
     1722 */
     1723void vboxSvcClipboardOldClientStateResetData(PVBOXCLIPBOARDCLIENTSTATE pClientState)
     1724{
     1725    if (pClientState->Old.data.pv)
     1726    {
     1727        RTMemFree(pClientState->Old.data.pv);
     1728        pClientState->Old.data.pv = NULL;
     1729    }
     1730
     1731    pClientState->Old.data.cb = 0;
     1732    pClientState->Old.data.u32Format = 0;
     1733}
     1734
     1735/**
    16271736 * Resets a Shared Clipboard service's old client state.
    16281737 * Legacy protocol, do not use anymore.
    … …  
    16301739 * @param   pClientState        Client state to reset.
    16311740 */
    1632 static void vboxSvcClipboardOldClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState)
     1741void vboxSvcClipboardOldClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState)
    16331742{
    16341743    LogFlowFuncEnter();
    16351744
    1636     pClientState->Old.fAsync                       = false;
    1637     pClientState->Old.fReadPending                 = false;
    1638 
    1639     pClientState->Old.fHostMsgQuit                 = false;
    1640     pClientState->Old.fHostMsgReadData             = false;
    1641     pClientState->Old.fHostMsgFormats              = false;
     1745    pClientState->Old.fAsync              = false;
     1746    pClientState->Old.fReadPending        = false;
     1747
     1748    pClientState->Old.fHostMsgQuit        = false;
     1749    pClientState->Old.fHostMsgReadData    = false;
     1750    pClientState->Old.fHostMsgFormats     = false;
    16421751
    16431752    pClientState->Old.u32AvailableFormats = 0;
    16441753    pClientState->Old.u32RequestedFormat  = 0;
     1754
     1755    vboxSvcClipboardOldClientStateResetData(pClientState);
    16451756}
    16461757
Note: See TracChangeset for help on using the changeset viewer.

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