VirtualBox

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


Ignore:
Timestamp:
Sep 25, 2019 6:20:09 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133584
Message:

Shared Clipboard/Transfers: Update.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r80967 r80990  
    9494*********************************************************************************************************************************/
    9595#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     96static DECLCALLBACK(int)  vboxClipboardOnTransferInitCallback(PSHCLTRANSFERCALLBACKDATA pData);
    9697static DECLCALLBACK(int)  vboxClipboardOnTransferStartCallback(PSHCLTRANSFERCALLBACKDATA pData);
    9798static DECLCALLBACK(void) vboxClipboardOnTransferCompleteCallback(PSHCLTRANSFERCALLBACKDATA pData, int rc);
    … …  
    127128    RTMemFree(pTransfer);
    128129    pTransfer = NULL;
     130}
     131
     132static DECLCALLBACK(int)  vboxClipboardOnTransferInitCallback(PSHCLTRANSFERCALLBACKDATA pData)
     133{
     134    PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pData->pvUser;
     135    AssertPtr(pCtx);
     136
     137    LogFlowFunc(("pCtx=%p\n", pCtx));
     138
     139    RT_NOREF(pData, pCtx);
     140
     141    return VINF_SUCCESS;
    129142}
    130143
    … …  
    183196    else if (SharedClipboardTransferGetDir(pTransfer) == SHCLTRANSFERDIR_READ)
    184197    {
    185         Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
    186 
    187         rc = SharedClipboardWinTransferCreate(&pCtx->Win, pTransfer);
     198        /* The IDataObject must be created in our window thread, so post a message to it, which
     199         * then in turn takes care of the creation. */
     200        ::PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_URI_TRANSFER_START,
     201                      0 /* wParm */, (LPARAM)pTransfer /* lParm */);
     202
     203        rc = VINF_SUCCESS;
    188204    }
    189205    else
    … …  
    221237    vboxClipboardTransferCallbackCleanup(pData);
    222238}
    223 
    224 static int vboxClipboardTransferOpen(PSHCLPROVIDERCTX pCtx)
    225 {
    226     RT_NOREF(pCtx);
    227 
    228     LogFlowFuncLeave();
    229     return VINF_SUCCESS;
    230 }
    231 
    232 static int vboxClipboardTransferClose(PSHCLPROVIDERCTX pCtx)
    233 {
    234     RT_NOREF(pCtx);
    235 
    236     LogFlowFuncLeave();
    237     return VINF_SUCCESS;
    238 }
    239 
    240 static int vboxClipboardTransferListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms,
    241                                          PSHCLLISTHANDLE phList)
    242 {
    243     RT_NOREF(pCtx, pOpenParms, phList);
    244 
    245     LogFlowFuncEnter();
    246 
    247     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    248     AssertPtr(pThisCtx);
    249 
    250     RT_NOREF(pThisCtx);
    251 
    252     int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
    253 
    254     LogFlowFuncLeaveRC(rc);
    255     return rc;
    256 }
    257 
    258 static int vboxClipboardTransferListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    259 {
    260     RT_NOREF(pCtx, hList);
    261 
    262     LogFlowFuncEnter();
    263 
    264     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    265     AssertPtr(pThisCtx);
    266 
    267     RT_NOREF(pThisCtx);
    268 
    269     int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
    270 
    271     LogFlowFuncLeaveRC(rc);
    272     return rc;
    273 }
    274 
    275 static int vboxClipboardTransferGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    276 {
    277     LogFlowFuncEnter();
    278 
    279     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    280     AssertPtr(pThisCtx);
    281 
    282     int rc = VbglR3ClipboardRootListRead(&pThisCtx->CmdCtx, ppRootList);
    283 
    284     LogFlowFuncLeaveRC(rc);
    285     return rc;
    286 }
    287 
    288 static int vboxClipboardTransferListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    289                                             PSHCLLISTHDR pListHdr)
    290 {
    291     RT_NOREF(hList);
    292 
    293     LogFlowFuncEnter();
    294 
    295     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    296     AssertPtr(pThisCtx);
    297 
    298     RT_NOREF(pThisCtx);
    299 
    300     int rc = SharedClipboardTransferListHdrInit(pListHdr);
    301     if (RT_SUCCESS(rc))
    302     {
    303         if (RT_SUCCESS(rc))
    304         {
    305             //rc = VbglR3ClipboardListHdrReadRecv(pThisCtx->u32ClientID, hList, pListHdr);
    306         }
    307         else
    308             SharedClipboardTransferListHdrDestroy(pListHdr);
    309     }
    310 
    311     LogFlowFuncLeaveRC(rc);
    312     return rc;
    313 }
    314 
    315 /*
    316 static int vboxClipboardTransferListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    317                                              PSHCLLISTHDR pListHdr)
    318 {
    319     LogFlowFuncEnter();
    320 
    321     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    322     AssertPtr(pThisCtx);
    323 
    324     int rc = VbglR3ClipboardListHdrWrite(pThisCtx->u32ClientID, hList, pListHdr);
    325 
    326     LogFlowFuncLeaveRC(rc);
    327     return rc;
    328 }*/
    329 
    330 static int vboxClipboardTransferListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    331                                               PSHCLLISTENTRY pListEntry)
    332 {
    333     RT_NOREF(hList);
    334 
    335     LogFlowFuncEnter();
    336 
    337     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    338     AssertPtr(pThisCtx);
    339 
    340     RT_NOREF(pThisCtx);
    341 
    342     RT_NOREF(pListEntry);
    343     int rc = 0; // VbglR3ClipboardListEntryRead(pThisCtx->u32ClientID, pListEntry);
    344 
    345     LogFlowFuncLeaveRC(rc);
    346     return rc;
    347 }
    348 
    349 /*
    350 static int vboxClipboardTransferListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    351                                                PSHCLLISTENTRY pListEntry)
    352 {
    353     LogFlowFuncEnter();
    354 
    355     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    356     AssertPtr(pThisCtx);
    357 
    358     int rc = VbglR3ClipboardListEntryWrite(pThisCtx->u32ClientID, hList, pListEntry);
    359 
    360     LogFlowFuncLeaveRC(rc);
    361     return rc;
    362 }
    363 */
    364 
    365 static int vboxClipboardTransferObjOpen(PSHCLPROVIDERCTX pCtx,
    366                                         PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj)
    367 {
    368     LogFlowFuncEnter();
    369 
    370     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    371     AssertPtr(pThisCtx);
    372 
    373     int rc = VbglR3ClipboardObjOpenSend(&pThisCtx->CmdCtx, pCreateParms, phObj);
    374 
    375     LogFlowFuncLeaveRC(rc);
    376     return rc;
    377 }
    378 
    379 static int vboxClipboardTransferObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    380 {
    381     LogFlowFuncEnter();
    382 
    383     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    384     AssertPtr(pThisCtx);
    385 
    386     int rc = VbglR3ClipboardObjCloseSend(&pThisCtx->CmdCtx, hObj);
    387 
    388     LogFlowFuncLeaveRC(rc);
    389     return rc;
    390 }
    391 
    392 static int vboxClipboardTransferObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    393                                         void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    394 {
    395     RT_NOREF(fFlags);
    396 
    397     LogFlowFuncEnter();
    398 
    399     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    400     AssertPtr(pThisCtx);
    401 
    402     int rc = VbglR3ClipboardObjRead(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbRead);
    403 
    404     LogFlowFuncLeaveRC(rc);
    405     return rc;
    406 }
    407 
    408 static int vboxClipboardTransferObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    409                                          void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    410 {
    411     RT_NOREF(fFlags);
    412 
    413     LogFlowFuncEnter();
    414 
    415     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    416     AssertPtr(pThisCtx);
    417 
    418     int rc = VbglR3ClipboardObjWrite(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbWritten);
    419 
    420     LogFlowFuncLeaveRC(rc);
    421     return rc;
    422 }
    423239#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    424240
    … …  
    435251        case WM_CLIPBOARDUPDATE:
    436252        {
    437             LogFunc(("WM_CLIPBOARDUPDATE: Waiting ...\n"));
     253            LogFunc(("WM_CLIPBOARDUPDATE\n"));
    438254
    439255            int rc = RTCritSectEnter(&pWinCtx->CritSect);
    … …  
    457273                    {
    458274                        LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", Formats.uFormats));
    459                         rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
     275                        rc = VbglR3ClipboardFormatsReportEx(&pCtx->CmdCtx, &Formats);
    460276                    }
    461277                }
    … …  
    480296       }
    481297
    482        case WM_DRAWCLIPBOARD:
    483        {
    484            LogFlowFunc(("WM_DRAWCLIPBOARD: hwnd %p\n", pWinCtx->hWnd));
    485 
    486            if (GetClipboardOwner() != hwnd)
    487            {
    488                /* Clipboard was updated by another application. */
    489                /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
    490                SHCLFORMATDATA Formats;
    491                int rc = SharedClipboardWinGetFormats(pWinCtx, &Formats);
    492                if (   RT_SUCCESS(rc)
    493                    && Formats.uFormats != VBOX_SHCL_FMT_NONE)
    494                {
    495                    rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
    496                }
    497            }
    498 
    499            lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
    500            break;
    501        }
     298        case WM_DRAWCLIPBOARD:
     299        {
     300            LogFlowFunc(("WM_DRAWCLIPBOARD\n"));
     301
     302            int rc = RTCritSectEnter(&pWinCtx->CritSect);
     303            if (RT_SUCCESS(rc))
     304            {
     305                const HWND hWndClipboardOwner = GetClipboardOwner();
     306
     307                LogFunc(("WM_DRAWCLIPBOARD: hWndClipboardOwnerUs=%p, hWndNewClipboardOwner=%p\n",
     308                         pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
     309
     310                if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
     311                {
     312                    int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     313                    AssertRC(rc2);
     314
     315                    /* Clipboard was updated by another application. */
     316                    /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
     317                    SHCLFORMATDATA Formats;
     318                    rc = SharedClipboardWinGetFormats(pWinCtx, &Formats);
     319                    if (RT_SUCCESS(rc)
     320                        && Formats.uFormats != VBOX_SHCL_FMT_NONE)
     321                    {
     322                        rc = VbglR3ClipboardFormatsReportEx(&pCtx->CmdCtx, &Formats);
     323                    }
     324                }
     325                else
     326                {
     327                    int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     328                    AssertRC(rc2);
     329                }
     330            }
     331
     332            lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
     333            break;
     334        }
    502335
    503336       case WM_TIMER:
    … …  
    819652
    820653#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    821        case SHCL_WIN_WM_URI_TRANSFER_STATUS:
     654       case SHCL_WIN_WM_URI_TRANSFER_START:
    822655       {
    823            LogFunc(("SHCL_WIN_WM_URI_TRANSFER_STATUS\n"));
    824 
     656           LogFunc(("SHCL_WIN_WM_URI_TRANSFER_CREATE\n"));
     657
     658           PSHCLTRANSFER pTransfer = (PSHCLTRANSFER)lParam;
     659           AssertPtr(pTransfer);
     660
     661           Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
     662
     663           int rc2 = SharedClipboardWinTransferCreate(&pCtx->Win, pTransfer);
     664           AssertRC(rc2);
    825665           break;
    826666       }
    827667#endif
    828 
    829 #if 0
    830        /* The host wants to write transfer data. */
    831        case VBOX_CLIPBOARD_WM_URI_START_WRITE:
    832        {
    833            LogFunc(("VBOX_CLIPBOARD_WM_URI_START_WRITE: cTransfersRunning=%RU32\n",
    834                     SharedClipboardTransferCtxGetRunningTransfers(&pCtx->URI)));
    835 
    836            PSHCLTRANSFER pTransfer;
    837            int rc = SharedClipboardTransferCreate(SHCLTRANSFERDIR_READ,
    838                                                   SHCLSOURCE_LOCAL,
    839                                                   &pTransfer);
    840            if (RT_SUCCESS(rc))
    841            {
    842                SHCLTRANSFERCALLBACKS TransferCallbacks;
    843                RT_ZERO(TransferCallbacks);
    844 
    845                TransferCallbacks.pvUser              = &pCtx->URI;
    846                TransferCallbacks.pfnTransferComplete = vboxClipboardTransferCompleteCallback;
    847                TransferCallbacks.pfnTransferError    = vboxClipboardTransferErrorCallback;
    848 
    849                SharedClipboardTransferSetCallbacks(pTransfer, &TransferCallbacks);
    850 
    851                SHCLPROVIDERCREATIONCTX creationCtx;
    852                RT_ZERO(creationCtx);
    853 
    854                creationCtx.enmSource = SHCLSOURCE_REMOTE;
    855 
    856                creationCtx.Interface.pfnRootsGet      = vboxClipboardTransferGetRoots;
    857                creationCtx.Interface.pfnListOpen      = vboxClipboardTransferListOpen;
    858                creationCtx.Interface.pfnListClose     = vboxClipboardTransferListClose;
    859                creationCtx.Interface.pfnListHdrRead   = vboxClipboardTransferListHdrRead;
    860                creationCtx.Interface.pfnListEntryRead = vboxClipboardTransferListEntryRead;
    861                creationCtx.Interface.pfnObjOpen       = vboxClipboardTransferObjOpen;
    862                creationCtx.Interface.pfnObjClose      = vboxClipboardTransferObjClose;
    863                creationCtx.Interface.pfnObjRead       = vboxClipboardTransferObjRead;
    864 
    865                creationCtx.pvUser = pCtx;
    866 
    867                rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
    868                if (RT_SUCCESS(rc))
    869                {
    870                    rc = SharedClipboardTransferCtxTransferAdd(&pCtx->URI, pTransfer);
    871                    if (RT_SUCCESS(rc))
    872                    {
    873                        rc = SharedClipboardTransferPrepare(pTransfer);
    874                        if (RT_SUCCESS(rc))
    875                        {
    876                            rc = SharedClipboardWinTransferCreate(pWinCtx, pTransfer);
    877                        }
    878                    }
    879                }
    880            }
    881 
    882            break;
    883        }
    884 #endif /* 0 */
    885668
    886669       case WM_DESTROY:
    … …  
    1034817        pCtx->CmdCtx.Transfers.Callbacks.pvUser = pCtx; /* Assign context as user-provided callback data. */
    1035818
    1036         pCtx->CmdCtx.Transfers.Callbacks.pfnTransferStart    = vboxClipboardOnTransferStartCallback;
    1037         pCtx->CmdCtx.Transfers.Callbacks.pfnTransferComplete = vboxClipboardOnTransferCompleteCallback;
    1038         pCtx->CmdCtx.Transfers.Callbacks.pfnTransferError    = vboxClipboardOnTransferErrorCallback;
     819        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferInitialize = vboxClipboardOnTransferInitCallback;
     820        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferStart      = vboxClipboardOnTransferStartCallback;
     821        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferComplete   = vboxClipboardOnTransferCompleteCallback;
     822        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferError      = vboxClipboardOnTransferErrorCallback;
    1039823    }
    1040824#endif
    … …  
    1186970                   ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_REPORT_FORMATS,
    1187971                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
     972
     973                   pEvent = NULL; /* Consume pointer. */
    1188974                   break;
    1189975               }
    … …  
    1194980                   ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_READ_DATA,
    1195981                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
     982
     983                   pEvent = NULL; /* Consume pointer. */
    1196984                   break;
    1197985               }
    1198986
    1199 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1200                case VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS:
    1201                {
    1202                    ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_URI_TRANSFER_STATUS,
    1203                                  0 /* wParm */, (LPARAM)pEvent /* lParm */);
    1204                    break;
    1205                }
    1206 #endif
    1207987               case VBGLR3CLIPBOARDEVENTTYPE_QUIT:
    1208988               {
    … …  
    1213993               }
    1214994
     995               case VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS:
     996               {
     997                   /* Nothing to do here. */
     998                   break;
     999               }
     1000
     1001               case VBGLR3CLIPBOARDEVENTTYPE_INVALID:
    12151002               default:
    12161003               {
    12171004                   /* Wait a bit before retrying. */
    12181005                   RTThreadSleep(1000);
     1006
     1007                   rc = VERR_NOT_SUPPORTED;
    12191008                   break;
    12201009               }
    12211010            }
    12221011
    1223             if (RT_FAILURE(rc))
     1012            if (pEvent)
     1013            {
    12241014                VbglR3ClipboardEventFree(pEvent);
     1015                pEvent = NULL;
     1016            }
    12251017        }
    12261018
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