VirtualBox

Changeset 80374 in vbox


Ignore:
Timestamp:
Aug 21, 2019 3:04:54 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132839
Message:

Shared Clipboard/URI: Update.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r80318 r80374  
    6161#define VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS   5000
    6262
    63 /** Sets announced clipboard formats from the host. */
    64 #define VBOX_CLIPBOARD_WM_SET_FORMATS       WM_USER
    65 /** Reads data from the clipboard and sends it to the host. */
     63/** Reports clipboard formats. */
     64#define VBOX_CLIPBOARD_WM_REPORT_FORMATS    WM_USER
     65/** Reads data from the clipboard and sends it to the destination. */
    6666#define VBOX_CLIPBOARD_WM_READ_DATA         WM_USER + 1
    6767#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST

  • trunk/include/VBox/VBoxGuestLib.h

    r80359 r80374  
    653653
    654654VBGLR3DECL(int)     VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus);
     655
     656VBGLR3DECL(int)     VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList);
    655657
    656658VBGLR3DECL(int)     VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots);

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

    r80359 r80374  
    220220}
    221221
    222 static int vboxClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDLISTHDR pListHdr,
     222static int vboxClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms,
    223223                                    PSHAREDCLIPBOARDLISTHANDLE phList)
    224224{
    225     RT_NOREF(pCtx, pListHdr, phList);
     225    RT_NOREF(pCtx, pOpenParms, phList);
    226226
    227227    LogFlowFuncEnter();
    … …  
    233233
    234234    int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
     235
     236    LogFlowFuncLeaveRC(rc);
     237    return rc;
     238}
     239
     240static int vboxClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList)
     241{
     242    RT_NOREF(pCtx, hList);
     243
     244    LogFlowFuncEnter();
     245
     246    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     247    AssertPtr(pThisCtx);
     248
     249    RT_NOREF(pThisCtx);
     250
     251    int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
     252
     253    LogFlowFuncLeaveRC(rc);
     254    return rc;
     255}
     256
     257static int vboxClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList)
     258{
     259    LogFlowFuncEnter();
     260
     261    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
     262    AssertPtr(pThisCtx);
     263
     264    int rc = VbglR3ClipboardRootListRead(&pThisCtx->CmdCtx, ppRootList);
    235265
    236266    LogFlowFuncLeaveRC(rc);
    … …  
    403433               }
    404434           }
     435
     436           break;
    405437       }
    406            break;
    407438
    408439       case WM_CHANGECBCHAIN:
    … …  
    410441           LogFunc(("WM_CHANGECBCHAIN\n"));
    411442           lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hwnd, msg, wParam, lParam);
     443           break;
    412444       }
    413            break;
    414445
    415446       case WM_DRAWCLIPBOARD:
    … …  
    428459
    429460           lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
     461           break;
    430462       }
    431            break;
    432463
    433464       case WM_TIMER:
    … …  
    435466           int rc = VBoxClipboardWinHandleWMTimer(pWinCtx);
    436467           AssertRC(rc);
     468
     469           break;
    437470       }
    438            break;
    439471
    440472       case WM_CLOSE:
    441473       {
    442474           /* Do nothing. Ignore the message. */
     475           break;
    443476       }
    444            break;
    445477
    446478       case WM_RENDERFORMAT:
    … …  
    590622               }
    591623           }
     624
     625           break;
    592626       }
    593            break;
    594627
    595628       case WM_RENDERALLFORMATS:
    … …  
    599632           int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hwnd);
    600633           AssertRC(rc);
     634
     635           break;
    601636       }
    602            break;
    603 
    604        case VBOX_CLIPBOARD_WM_SET_FORMATS:
     637
     638       case VBOX_CLIPBOARD_WM_REPORT_FORMATS:
    605639       {
    606            LogFunc(("VBOX_CLIPBOARD_WM_SET_FORMATS\n"));
     640           LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n"));
    607641
    608642           /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT. */
    … …  
    615649                   VBoxClipboardWinClear();
    616650
    617 #if 0
    618                    if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    619                    {
    620                        LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST\n"));
    621 
    622                        PSHAREDCLIPBOARDURITRANSFER pTransfer;
    623                        rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ,
    624                                                              SHAREDCLIPBOARDSOURCE_REMOTE,
    625                                                              &pTransfer);
    626                        if (RT_SUCCESS(rc))
    627                        {
    628                            SHAREDCLIPBOARDURITRANSFERCALLBACKS TransferCallbacks;
    629                            RT_ZERO(TransferCallbacks);
    630 
    631                            TransferCallbacks.pvUser              = &pCtx->URI;
    632                            TransferCallbacks.pfnTransferComplete = vboxClipboardURITransferCompleteCallback;
    633                            TransferCallbacks.pfnTransferError    = vboxClipboardURITransferErrorCallback;
    634 
    635                            SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks);
    636 
    637                            SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    638                            RT_ZERO(creationCtx);
    639                            creationCtx.enmSource = SHAREDCLIPBOARDSOURCE_REMOTE;
    640 
    641                            RT_ZERO(creationCtx.Interface);
    642                            creationCtx.Interface.pfnTransferOpen  = vboxClipboardURITransferOpen;
    643                            creationCtx.Interface.pfnTransferClose = vboxClipboardURITransferClose;
    644                            creationCtx.Interface.pfnListHdrRead   = vboxClipboardURIListHdrRead;
    645                            creationCtx.Interface.pfnListEntryRead = vboxClipboardURIListEntryRead;
    646                            creationCtx.Interface.pfnObjOpen       = vboxClipboardURIObjOpen;
    647                            creationCtx.Interface.pfnObjClose      = vboxClipboardURIObjClose;
    648                            creationCtx.Interface.pfnObjRead       = vboxClipboardURIObjRead;
    649 
    650                            creationCtx.pvUser = pCtx;
    651 
    652                            rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
    653                            if (RT_SUCCESS(rc))
    654                            {
    655                                rc = SharedClipboardURICtxTransferAdd(&pCtx->URI, pTransfer);
    656                                if (RT_SUCCESS(rc))
    657                                    rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    658                            }
    659 
    660                            /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
    661 
    662                            LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST: rc=%Rrc\n", rc));
    663                        }
    664                    }
    665                    else
    666                    {
     651#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     652                    if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
     653                    {
     654                        LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST\n"));
     655
     656                        PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->URI,
     657                                                                                                 0 /* uIdx */);
     658                        if (pTransfer)
     659                        {
     660                            rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
     661
     662                            /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
     663                                     (ClipboardDataObjectImpl::GetData()). */
     664                        }
     665                        else
     666                            AssertFailedStmt(rc = VERR_NOT_FOUND);
     667
     668                        /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
     669                    }
     670                    else
     671                    {
    667672#endif
    668                        rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
    669 
    670                        VBoxClipboardWinClose();
    671 #if 0
    672                    }
     673                        rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
     674
     675                        VBoxClipboardWinClose();
     676#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     677                    }
    673678#endif
    674679               }
    675680           }
     681
    676682           LogFunc(("VBOX_CLIPBOARD_WM_SET_FORMATS: fFormats=0x%x, lastErr=%ld\n", fFormats, GetLastError()));
     683           break;
    677684       }
    678            break;
    679685
    680686       case VBOX_CLIPBOARD_WM_READ_DATA:
    … …  
    843849       }
    844850
     851#if 1
    845852       /* The host wants to write URI data. */
    846853       case VBOX_CLIPBOARD_WM_URI_START_WRITE:
    … …  
    866873               SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    867874               RT_ZERO(creationCtx);
     875
    868876               creationCtx.enmSource = SHAREDCLIPBOARDSOURCE_REMOTE;
    869877
    870                RT_ZERO(creationCtx.Interface);
     878               creationCtx.Interface.pfnGetRoots      = vboxClipboardURIGetRoots;
     879               creationCtx.Interface.pfnListOpen      = vboxClipboardURIListOpen;
     880               creationCtx.Interface.pfnListClose     = vboxClipboardURIListClose;
    871881               creationCtx.Interface.pfnListHdrRead   = vboxClipboardURIListHdrRead;
    872882               creationCtx.Interface.pfnListEntryRead = vboxClipboardURIListEntryRead;
    … …  
    883893                   if (RT_SUCCESS(rc))
    884894                   {
     895                       rc = SharedClipboardURITransferPrepare(pTransfer);
    885896                       if (RT_SUCCESS(rc))
    886897                       {
    887                            rc = SharedClipboardURITransferPrepare(pTransfer);
    888                            if (RT_SUCCESS(rc))
    889                            {
    890                                rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    891                            }
     898                           rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
    892899                       }
    893900                   }
    … …  
    897904           break;
    898905       }
     906#endif
    899907#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    900908
    … …  
    910918            * the VBoxTray already finished a message loop.
    911919            */
     920
     921           break;
    912922       }
    913            break;
    914923
    915924       default:
    … …  
    917926           LogFunc(("WM_ %p\n", msg));
    918927           lresultRc = DefWindowProc(hwnd, msg, wParam, lParam);
     928           break;
    919929       }
    920            break;
    921930    }
    922931
    … …  
    11231132                    * Forward the information to the window, so it can later
    11241133                    * respond to WM_RENDERFORMAT message. */
    1125                    ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_SET_FORMATS, 0, u32Formats);
     1134                   ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS, 0, u32Formats);
    11261135                   break;
    11271136               }

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

    r80359 r80374  
    320320}
    321321
     322static int vbglR3ClipboardRootListHdrRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRootListHdr)
     323{
     324    AssertPtrReturn(pCtx,         VERR_INVALID_POINTER);
     325    AssertPtrReturn(pRootListHdr, VERR_INVALID_POINTER);
     326
     327    VBoxClipboardRootListHdrMsg Msg;
     328    RT_ZERO(Msg);
     329
     330    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     331                       VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
     332
     333    Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
     334    Msg.ReqParms.fRoots.SetUInt32(pRootListHdr->fRoots);
     335
     336    Msg.cRoots.SetUInt32(0);
     337    Msg.enmCompression.SetUInt32(0);  /** @todo Not implemented yet. */
     338    Msg.enmChecksumType.SetUInt32(0); /** @todo Not implemented yet. */
     339
     340    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     341    if (RT_SUCCESS(rc))
     342    {
     343        rc = Msg.ReqParms.fRoots.GetUInt32(&pRootListHdr->fRoots); AssertRC(rc);
     344        if (RT_SUCCESS(rc))
     345            rc = Msg.cRoots.GetUInt32(&pRootListHdr->cRoots); AssertRC(rc);
     346    }
     347
     348    LogFlowFuncLeaveRC(rc);
     349    return rc;
     350}
     351
     352static int vbglR3ClipboardRootListEntryRead(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry)
     353{
     354    AssertPtrReturn(pCtx,           VERR_INVALID_POINTER);
     355    AssertPtrReturn(pRootListEntry, VERR_INVALID_POINTER);
     356
     357    VBoxClipboardRootListEntryMsg Msg;
     358    RT_ZERO(Msg);
     359
     360    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
     361                       VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY);
     362
     363    Msg.Parms.uContext.SetUInt32(pCtx->uContextID);
     364    Msg.Parms.fInfo.SetUInt32(pRootListEntry->fInfo);
     365    Msg.Parms.uIndex.SetUInt32(uIndex);
     366
     367    Msg.szName.SetPtr(pRootListEntry->pszName, pRootListEntry->cbName);
     368    Msg.cbInfo.SetUInt32(pRootListEntry->cbInfo);
     369    Msg.pvInfo.SetPtr(pRootListEntry->pvInfo, pRootListEntry->cbInfo);
     370
     371    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     372    if (RT_SUCCESS(rc))
     373    {
     374        rc = Msg.Parms.fInfo.GetUInt32(&pRootListEntry->fInfo); AssertRC(rc);
     375        if (RT_SUCCESS(rc))
     376        {
     377            uint32_t cbInfo;
     378            rc = Msg.cbInfo.GetUInt32(&cbInfo); AssertRC(rc);
     379            if (pRootListEntry->cbInfo != cbInfo)
     380                rc = VERR_INVALID_PARAMETER;
     381        }
     382    }
     383
     384    LogFlowFuncLeaveRC(rc);
     385    return rc;
     386}
     387
     388VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList)
     389{
     390    AssertPtrReturn(pCtx,       VERR_INVALID_POINTER);
     391    AssertPtrReturn(ppRootList, VERR_INVALID_POINTER);
     392
     393    int rc;
     394
     395    PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc();
     396    if (pRootList)
     397    {
     398        VBOXCLIPBOARDROOTLISTHDR srcRootListHdr;
     399        rc = vbglR3ClipboardRootListHdrRead(pCtx, &srcRootListHdr);
     400        if (RT_SUCCESS(rc))
     401        {
     402            pRootList->Hdr.cRoots = srcRootListHdr.cRoots;
     403            pRootList->Hdr.fRoots = 0; /** @todo Implement this. */
     404
     405            if (srcRootListHdr.cRoots)
     406            {
     407                pRootList->paEntries =
     408                    (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(srcRootListHdr.cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY));
     409                if (pRootList->paEntries)
     410                {
     411                    for (uint32_t i = 0; i < srcRootListHdr.cRoots; i++)
     412                    {
     413                        rc = vbglR3ClipboardRootListEntryRead(pCtx, i, &pRootList->paEntries[i]);
     414                        if (RT_FAILURE(rc))
     415                            break;
     416                    }
     417                }
     418                else
     419                    rc = VERR_NO_MEMORY;
     420            }
     421        }
     422
     423        if (RT_SUCCESS(rc))
     424        {
     425            *ppRootList = pRootList;
     426        }
     427        else
     428            SharedClipboardURIRootListFree(pRootList);
     429    }
     430    else
     431        rc = VERR_NO_MEMORY;
     432
     433    LogFlowFuncLeaveRC(rc);
     434    return rc;
     435}
     436
    322437VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots)
    323438{

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

    r80359 r80374  
    10961096    if (RT_FAILURE(rc))
    10971097    {
    1098         RTMemFree(pTransfer);
     1098        if (pTransfer)
     1099        {
     1100            SharedClipboardURITransferDestroy(pTransfer);
     1101            RTMemFree(pTransfer);
     1102        }
    10991103    }
    11001104
    … …  
    18881892    pTransfer->ProviderIface         = pCreationCtx->Interface;
    18891893
     1894#ifdef DEBUG
     1895# define LOG_IFACE_PTR(a_Name) \
     1896    LogFlowFunc(( #a_Name "=%p\n", pTransfer->ProviderIface.a_Name));
     1897
     1898    LOG_IFACE_PTR(pfnTransferOpen);
     1899    LOG_IFACE_PTR(pfnTransferClose);
     1900    LOG_IFACE_PTR(pfnGetRoots);
     1901    LOG_IFACE_PTR(pfnListOpen);
     1902    LOG_IFACE_PTR(pfnListClose);
     1903
     1904# undef LOG_IFACE_PTR
     1905#endif
     1906
    18901907    pTransfer->ProviderCtx.pTransfer = pTransfer;
    18911908    pTransfer->ProviderCtx.pvUser    = pCreationCtx->pvUser;
    … …  
    20962113    AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
    20972114    AssertPtrReturn(ppRootList, VERR_INVALID_POINTER);
     2115
     2116    LogFlowFuncEnter();
    20982117
    20992118    int rc = VINF_SUCCESS;

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

    r80361 r80374  
    13261326                SharedClipboardURICtxTransfersCleanup(&pClientData->URI);
    13271327
    1328                 SHAREDCLIPBOARDURITRANSFERDIR enmDir = SHAREDCLIPBOARDURITRANSFERDIR_READ;
     1328                const SHAREDCLIPBOARDURITRANSFERDIR enmDir = SHAREDCLIPBOARDURITRANSFERDIR_READ;
    13291329
    13301330                PSHAREDCLIPBOARDURITRANSFER pTransfer;
    … …  
    13411341                        creationCtx.enmSource = pClientData->State.enmSource;
    13421342
    1343                         RT_ZERO(creationCtx.Interface);
    13441343                        creationCtx.Interface.pfnTransferOpen  = vboxSvcClipboardURITransferOpen;
    13451344                        creationCtx.Interface.pfnTransferClose = vboxSvcClipboardURITransferClose;

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

    r80283 r80374  
    102102        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START:
    103103        {
     104            Assert(pClientData->State.URI.fTransferStart == false);
     105
    104106            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
    105107

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

    r79630 r80374  
    166166                /* Clipboard was updated by another application, retrieve formats and report back. */
    167167                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    168                 AssertRC(rc);
    169 
    170                 vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL);
     168                if (RT_SUCCESS(rc))
     169                    vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL);
    171170            }
    172171        } break;
    … …  
    295294        } break;
    296295
    297         case VBOX_CLIPBOARD_WM_SET_FORMATS:
    298         {
    299             LogFunc(("VBOX_CLIPBOARD_WM_SET_FORMATS\n"));
     296        case VBOX_CLIPBOARD_WM_REPORT_FORMATS:
     297        {
     298            LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n"));
    300299
    301300            if (   pCtx->pClientData == NULL
    … …  
    305304                 * because host clipboard has more priority.
    306305                 */
    307                 LogFunc(("VBOX_CLIPBOARD_WM_SET_FORMATS ignored; pClientData=%p\n", pCtx->pClientData));
     306                LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS ignored; pClientData=%p\n", pCtx->pClientData));
    308307                break;
    309308            }
    … …  
    351350                    LogFunc(("Failed with rc=%Rrc\n", rc));
    352351            }
    353             LogFunc(("VBOX_CLIPBOARD_WM_SET_FORMATS: fFormats=0x%x, lastErr=%ld\n", fFormats, GetLastError()));
     352            LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS: fFormats=0x%x, lastErr=%ld\n", fFormats, GetLastError()));
    354353        } break;
    355354
    … …  
    689688     * The guest announced formats. Forward to the window thread.
    690689     */
    691     PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_SET_FORMATS,
     690    PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
    692691                0 /* wParam */, u32Formats /* lParam */);
    693692

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

    r80359 r80374  
    11831183                            if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
    11841184                            {
    1185                                 /* Tell the guest that we want to start a (reading) transfer. */
     1185                                /* Tell the guest that we want to start a reading transfer
     1186                                 * (from guest to the host). */
    11861187                                rc = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START,
    11871188                                                               0 /* u32Formats == 0 means reading data */);
    … …  
    12931294                    else
    12941295                    {
    1295 #endif
     1296#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    12961297                        void    *pv;
    12971298                        uint32_t cb;
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