VirtualBox

Changeset 79174 in vbox for trunk/include


Ignore:
Timestamp:
Jun 17, 2019 10:30:49 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131345
Message:

Shared Clipboard/URI: Update.

Location:
trunk/include/VBox
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified trunk/include/VBox/GuestHost/SharedClipboard-uri.h

    r79120 r79174  
    3131#endif
    3232
    33 #ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
    34 #include <map> /* Needed for host provider. */
    35 #endif
    36 
    3733#include <iprt/assert.h>
    3834#include <iprt/critsect.h>
     
    4541#include <VBox/HostServices/VBoxClipboardSvc.h>
    4642
     43#ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
     44#include <map> /* Needed for host provider. */
     45#endif
     46
    4747/** Clipboard area ID. A valid area is >= 1.
    4848 *  If 0 is specified, the last (most recent) area is meant.
     
    5656typedef uint32_t SHAREDCLIPBOARDAREAOPENFLAGS;
    5757
    58 /** No open flags specified. */
     58/** No clipboard area open flags specified. */
    5959#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE               0
    6060/** The clipboard area must not exist yet. */
    6161#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST     RT_BIT(0)
     62/** Mask of all valid clipboard area open flags.  */
     63#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK         0x1
    6264
    6365/**
     
    382384};
    383385
     386uint32_t SharedClipboardURIDataHdrGetMetaDataSize(PVBOXCLIPBOARDDATAHDR pDataHdr);
    384387int SharedClipboardURIDataHdrInit(PVBOXCLIPBOARDDATAHDR pDataHdr);
    385388void SharedClipboardURIDataHdrDestroy(PVBOXCLIPBOARDDATAHDR pDataHdr);
     389void SharedClipboardURIDataHdrReset(PVBOXCLIPBOARDDATAHDR pDataHdr);
    386390bool SharedClipboardURIDataHdrIsValid(PVBOXCLIPBOARDDATAHDR pDataHdr);
     391
    387392bool SharedClipboardURIDataChunkIsValid(PVBOXCLIPBOARDDATACHUNK pDataChunk);
     393
    388394void SharedClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData);
    389395bool SharedClipboardURIDirDataIsValid(PVBOXCLIPBOARDDIRDATA pDirData);
     396
    390397void SharedClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr);
    391398bool SharedClipboardURIFileHdrIsValid(PVBOXCLIPBOARDFILEHDR pFileHdr, PVBOXCLIPBOARDDATAHDR pDataHdr);
     399
    392400void SharedClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData);
    393401bool SharedClipboardURIFileDataIsValid(PVBOXCLIPBOARDFILEDATA pFileData, PVBOXCLIPBOARDDATAHDR pDataHdr);
     402
     403/**
     404 * Structure for maintaining a meta data format.
     405 */
     406typedef struct _SHAREDCLIPBOARDMETADATAFMT
     407{
     408    /** Meta data format version. */
     409    uint32_t uVer;
     410    /** Actual meta data format data. */
     411    void    *pvFmt;
     412    /** Size of meta data format data (in bytes). */
     413    uint32_t cbFmt;
     414} SHAREDCLIPBOARDMETADATAFMT, *PSHAREDCLIPBOARDMETADATAFMT;
    394415
    395416/**
     
    419440
    420441/**
    421  * Structure for maintaining an URI transfer cache.
    422  */
    423 typedef struct _SHAREDCLIPBOARDURITRANSFERCACHE
    424 {
     442 * Enumeration specifying an URI transfer direction.
     443 */
     444typedef enum _SHAREDCLIPBOARDURITRANSFERDIR
     445{
     446    /** Unknown transfer directory. */
     447    SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN = 0,
     448    /** Read transfer (from source). */
     449    SHAREDCLIPBOARDURITRANSFERDIR_READ,
     450    /** Write transfer (to target). */
     451    SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
     452    /** The usual 32-bit hack. */
     453    SHAREDCLIPBOARDURITRANSFERDIR__32BIT_HACK = 0x7fffffff
     454} SHAREDCLIPBOARDURITRANSFERDIR;
     455
     456/**
     457 * Structure for maintaining an URI transfer state.
     458 * Everything in here will be part of a saved state (later).
     459 */
     460typedef struct _SHAREDCLIPBOARDURITRANSFERSTATE
     461{
     462    /** The transfer's direction. */
     463    SHAREDCLIPBOARDURITRANSFERDIR enmDir;
    425464    /** The transfer's cached data header. */
    426     VBOXCLIPBOARDDATAHDR        Header;
     465    VBOXCLIPBOARDDATAHDR          Header;
    427466    /** The transfer's cached meta data. */
    428     SHAREDCLIPBOARDMETADATA     Meta;
    429 } SHAREDCLIPBOARDURITRANSFERCACHE, *PSHAREDCLIPBOARDURITRANSFERCACHE;
     467    SHAREDCLIPBOARDMETADATA       Meta;
     468} SHAREDCLIPBOARDURITRANSFERSTATE, *PSHAREDCLIPBOARDURITRANSFERSTATE;
    430469
    431470/**
     
    442481} SHAREDCLIPBOARDPROVIDERSOURCE;
    443482
     483class SharedClipboardProvider;
     484
     485/**
     486 * Structure for storing clipboard provider callback data.
     487 */
     488typedef struct _SHAREDCLIPBOARDPROVIDERCALLBACKDATA
     489{
     490    /** Pointer to related clipboard provider ("this"). */
     491    SharedClipboardProvider    *pProvider;
     492    /** Saved user pointer. */
     493    void                       *pvUser;
     494} SHAREDCLIPBOARDPROVIDERCALLBACKDATA, *PSHAREDCLIPBOARDPROVIDERCALLBACKDATA;
     495
     496typedef DECLCALLBACK(int) FNSSHAREDCLIPBOARDPROVIDERREADDATAHDR(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData);
     497/** Pointer to a FNSSHAREDCLIPBOARDPROVIDERREADDATAHDR function. */
     498typedef FNSSHAREDCLIPBOARDPROVIDERREADDATAHDR *PFNSSHAREDCLIPBOARDPROVIDERREADDATAHDR;
     499
     500/**
     501 * Structure acting as a function callback table for clipboard providers.
     502 * All callbacks are optional and therefore can be NULL.
     503 */
     504typedef struct _SHAREDCLIPBOARDPROVIDERCALLBACKS
     505{
     506    /** Saved user pointer. Will be passed to the callback (if needed). */
     507    void                                   *pvUser;
     508    /** Function pointer, called when the transfer has been started. */
     509    PFNSSHAREDCLIPBOARDPROVIDERREADDATAHDR  pfnReadDataHdr;
     510} SHAREDCLIPBOARDPROVIDERCALLBACKS, *PSHAREDCLIPBOARDPROVIDERCALLBACKS;
     511
    444512/**
    445513 * Structure for the Shared Clipboard provider creation context.
     
    447515typedef struct _SHAREDCLIPBOARDPROVIDERCREATIONCTX
    448516{
    449     SHAREDCLIPBOARDPROVIDERSOURCE enmSource;
     517    /** Specifies what the source of the provider is. */
     518    SHAREDCLIPBOARDPROVIDERSOURCE     enmSource;
     519    /** Optional callback table; can be NULL if not needed. */
     520    PSHAREDCLIPBOARDPROVIDERCALLBACKS pCallbacks;
    450521    union
    451522    {
     
    454525            /** HGCM client ID to use. */
    455526            uint32_t uClientID;
    456         } VBGLR3;
     527        } VbglR3;
     528        struct
     529        {
     530        } HostService;
    457531    } u;
    458532} SHAREDCLIPBOARDPROVIDERCREATIONCTX, *PSHAREDCLIPBOARDPROVIDERCREATIONCTX;
     
    467541        struct
    468542        {
    469 
    470543        } HostService;
    471544    } u;
     
    508581    uint32_t Release(void);
    509582
     583public:
     584
     585    void SetCallbacks(PSHAREDCLIPBOARDPROVIDERCALLBACKS pCallbacks);
     586
    510587public: /* Interface to be implemented. */
    511588
     
    543620
    544621    /** Number of references to this instance. */
    545     volatile uint32_t      m_cRefs;
     622    volatile uint32_t                m_cRefs;
     623    /** The provider's callback table. */
     624    SHAREDCLIPBOARDPROVIDERCALLBACKS m_Callbacks;
    546625};
    547626
     
    644723        /** The event's own event semaphore. */
    645724        RTSEMEVENT  mEvent;
     725        /** User-provided data buffer associated to this event. Optional. */
    646726        void       *mpvData;
     727        /** Size (in bytes) of user-provided data buffer associated to this event. */
    647728        uint32_t    mcbData;
    648729    };
     
    658739protected:
    659740
     741    /** Default timeout (in ms) for waiting for events. */
    660742    RTMSINTERVAL                    m_uTimeoutMs;
    661     SHAREDCLIPBOARDURITRANSFERCACHE m_Cache;
     743    /** Map of (internal) events to provide asynchronous reads / writes. */
    662744    EventMap                        m_mapEvents;
    663 
    664745};
    665746#endif /* VBOX_WITH_SHARED_CLIPBOARD_HOST */
     
    728809
    729810/**
    730  * Enumeration specifying an URI transfer direction.
    731  */
    732 typedef enum _SHAREDCLIPBOARDURITRANSFERDIR
    733 {
    734     /** Unknown transfer directory. */
    735     SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN = 0,
    736     /** Read transfer (from source). */
    737     SHAREDCLIPBOARDURITRANSFERDIR_READ,
    738     /** Write transfer (to target). */
    739     SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
    740     /** The usual 32-bit hack. */
    741     SHAREDCLIPBOARDURITRANSFERDIR__32BIT_HACK = 0x7fffffff
    742 } SHAREDCLIPBOARDURITRANSFERDIR;
    743 
    744 /**
    745811 * Structure for handling a single URI object context.
    746812 */
     
    762828    /** Critical section for serializing access. */
    763829    RTCRITSECT                          CritSect;
    764     /** The transfer's direction. */
    765     SHAREDCLIPBOARDURITRANSFERDIR       enmDir;
    766     /** The transfer's cache. */
    767     SHAREDCLIPBOARDURITRANSFERCACHE     Cache;
     830    /** The transfer's state (for SSM, later). */
     831    SHAREDCLIPBOARDURITRANSFERSTATE     State;
    768832    /** The transfer's own (local) area, if any (can be NULL if not needed).
    769833     *  The area itself has a clipboard area ID assigned.
     
    797861    RTLISTANCHOR                List;
    798862    /** Number of concurrent transfers.
    799      *  At the moment we only support only one transfer at a time. */
     863     *  At the moment we only support only one transfer per client at a time. */
    800864    uint32_t                    cTransfers;
    801865    /** Maximum Number of concurrent transfers.
    802      *  At the moment we only support one transfer at a time (per client). */
     866     *  At the moment we only support only one transfer per client at a time. */
    803867    uint32_t                    cMaxTransfers;
    804868} SHAREDCLIPBOARDURICTX, *PSHAREDCLIPBOARDURICTX;
     
    822886
    823887int SharedClipboardURITransferMetaDataAdd(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
     888int SharedClipboardURITransferMetaDataComplete(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    824889int SharedClipboardURITransferMetaGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
    825890int SharedClipboardURITransferMetaDataRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t *pcbRead);
  • TabularUnified trunk/include/VBox/GuestHost/SharedClipboard-win.h

    r79036 r79174  
    9898    /** Window handle which is next to us in the clipboard chain. */
    9999    HWND                        hWndNextInChain;
     100    /** Window handle of the clipboard owner *if* we are the owner. */
     101    HWND                        hWndClipboardOwnerUs;
    100102    /** Structure for maintaining the new clipboard API. */
    101103    VBOXCLIPBOARDWINAPINEW      newAPI;
     
    107109int VBoxClipboardWinClose(void);
    108110int VBoxClipboardWinClear(void);
     111
    109112int VBoxClipboardWinCheckAndInitNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI);
    110113bool VBoxClipboardWinIsNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI);
    111 int VBoxClipboardWinAddToCBChain(PVBOXCLIPBOARDWINCTX pCtx);
    112 int VBoxClipboardWinRemoveFromCBChain(PVBOXCLIPBOARDWINCTX pCtx);
     114
     115int VBoxClipboardWinChainAdd(PVBOXCLIPBOARDWINCTX pCtx);
     116int VBoxClipboardWinChainRemove(PVBOXCLIPBOARDWINCTX pCtx);
    113117VOID CALLBACK VBoxClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult);
     118LRESULT VBoxClipboardWinChainPassToNext(PVBOXCLIPBOARDWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam);
    114119
    115120VBOXCLIPBOARDFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat);
     
    125130int VBoxClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput);
    126131
    127 int VBoxClipboardWinHandleWMSetFormats(const PVBOXCLIPBOARDWINCTX pCtx, VBOXCLIPBOARDFORMATS fFormats);
     132void VBoxClipboardWinDump(const void *pv, size_t cb, VBOXCLIPBOARDFORMAT u32Format);
     133int VBoxClipboardWinOHandleMSetFormats(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURICTX pURICtx,
     134                                       PSHAREDCLIPBOARDPROVIDERCREATIONCTX pProviderCtx);
     135
     136LRESULT VBoxClipboardWinHandleWMChangeCBChain(PVBOXCLIPBOARDWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
     137int VBoxClipboardWinHandleWMDestroy(PVBOXCLIPBOARDWINCTX pWinCtx);
     138int VBoxClipboardWinHandleWMRenderAllFormats(PVBOXCLIPBOARDWINCTX pWinCtx, HWND hWnd);
     139int VBoxClipboardWinHandleWMTimer(PVBOXCLIPBOARDWINCTX pWinCtx);
     140
     141int VBoxClipboardWinAnnounceFormats(PVBOXCLIPBOARDWINCTX pWinCtx, VBOXCLIPBOARDFORMATS fFormats);
    128142#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    129 int VBoxClipboardWinURIHandleWMSetFormats(const PVBOXCLIPBOARDWINCTX pCtx, PSHAREDCLIPBOARDURICTX pURICtx,
    130                                           PSHAREDCLIPBOARDPROVIDERCREATIONCTX pProviderCtx, VBOXCLIPBOARDFORMATS fFormats);
     143int VBoxClipboardWinURIReadMain(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURICTX pURICtx,
     144                                PSHAREDCLIPBOARDPROVIDERCREATIONCTX pProviderCtx, VBOXCLIPBOARDFORMATS fFormats);
    131145#endif
    132146
  • TabularUnified trunk/include/VBox/GuestHost/SharedClipboard.h

    r79107 r79174  
    3838typedef VBOXCLIPBOARDFORMAT *PVBOXCLIPBOARDFORMAT;
    3939
    40 /** Bit map of Shared Clipboard format. */
     40/** Bit map of Shared Clipboard formats. */
    4141typedef uint32_t VBOXCLIPBOARDFORMATS;
    42 /** Pointer to a bit map of Shared Clipboard format. */
     42/** Pointer to a bit map of Shared Clipboard formats. */
    4343typedef VBOXCLIPBOARDFORMATS *PVBOXCLIPBOARDFORMATS;
    4444
  • TabularUnified trunk/include/VBox/GuestHost/clipboard-helper.h

    r76585 r79174  
    170170int vboxClipboardBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDst, size_t *pcbDst);
    171171
     172#ifdef VBOX_STRICT
     173/**
     174 * Dumps HTML data to the debug log.
     175 *
     176 * @returns VBox status code.
     177 * @param   pszSrc              HTML data to dump.
     178 * @param   cb                  Size (in bytes) of HTML data to dump.
     179 */
     180int vboxClipboardDbgDumpHtml(const char *pszSrc, size_t cbSrc);
     181#endif
    172182
    173183#endif /* !VBOX_INCLUDED_GuestHost_clipboard_helper_h */
  • TabularUnified trunk/include/VBox/HostServices/VBoxClipboardSvc.h

    r79120 r79174  
    127127#define VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG 2
    128128
    129 typedef struct _VBoxClipboardWriteFormatsMsg
     129typedef struct _VBoxClipboardReportFormatsMsg
    130130{
    131131    VBGLIOCHGCMCALL hdr;
     
    133133    /* VBOX_SHARED_CLIPBOARD_FMT_* */
    134134    HGCMFunctionParameter formats; /* OUT uint32_t */
    135 } VBoxClipboardWriteFormatsMsg;
    136 
    137 #define VBOX_SHARED_CLIPBOARD_CPARMS_FORMATS 1
     135} VBoxClipboardReportFormatsMsg;
     136
     137#define VBOX_SHARED_CLIPBOARD_CPARMS_REPORT_FORMATS 1
    138138
    139139typedef struct _VBoxClipboardReadDataMsg
     
    369369     *  This size also is part of cbTotal already. */
    370370    uint32_t                    cbMeta;
    371     /** Meta format buffer. */
     371    /** Meta data format.
     372     *  Is SHAREDCLIPBOARDMETADATAFMT. */
    372373    void                       *pvMetaFmt;
    373     /** Size (in bytes) of meta format buffer. */
     374    /** Size (in bytes) of meta format buffer.
     375     *  Is sizeof(SHAREDCLIPBOARDMETADATAFMT). */
    374376    uint32_t                    cbMetaFmt;
    375377    /** Number of objects (files/directories) to transfer. */
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