VirtualBox

Ignore:
Timestamp:
Jun 21, 2019 10:11:59 AM (6 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: Update.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r79174 r79267  
    3131#endif
    3232
     33#include <map>
     34
    3335#include <iprt/assert.h>
    3436#include <iprt/critsect.h>
    … …  
    4042
    4143#include <VBox/HostServices/VBoxClipboardSvc.h>
    42 
    43 #ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
    44 #include <map> /* Needed for host provider. */
    45 #endif
    4644
    4745/** Clipboard area ID. A valid area is >= 1.
    … …  
    384382};
    385383
     384int SharedClipboardURIDataHdrAlloc(PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     385void SharedClipboardURIDataHdrFree(PVBOXCLIPBOARDDATAHDR pDataHdr);
     386PVBOXCLIPBOARDDATAHDR SharedClipboardURIDataHdrDup(PVBOXCLIPBOARDDATAHDR pDataHdr);
    386387uint32_t SharedClipboardURIDataHdrGetMetaDataSize(PVBOXCLIPBOARDDATAHDR pDataHdr);
    387388int SharedClipboardURIDataHdrInit(PVBOXCLIPBOARDDATAHDR pDataHdr);
    388389void SharedClipboardURIDataHdrDestroy(PVBOXCLIPBOARDDATAHDR pDataHdr);
     390void SharedClipboardURIDataHdrFree(PVBOXCLIPBOARDDATAHDR pDataHdr);
    389391void SharedClipboardURIDataHdrReset(PVBOXCLIPBOARDDATAHDR pDataHdr);
    390392bool SharedClipboardURIDataHdrIsValid(PVBOXCLIPBOARDDATAHDR pDataHdr);
    391393
     394int SharedClipboardURIDataChunkAlloc(PVBOXCLIPBOARDDATACHUNK *ppDataChunk);
     395void SharedClipboardURIDataChunkFree(PVBOXCLIPBOARDDATACHUNK pDataChunk);
     396PVBOXCLIPBOARDDATACHUNK SharedClipboardURIDataChunkDup(PVBOXCLIPBOARDDATACHUNK pDataChunk);
     397int SharedClipboardURIDataChunkInit(PVBOXCLIPBOARDDATACHUNK pDataChunk);
     398void SharedClipboardURIDataChunkDestroy(PVBOXCLIPBOARDDATACHUNK pDataChunk);
    392399bool SharedClipboardURIDataChunkIsValid(PVBOXCLIPBOARDDATACHUNK pDataChunk);
    393400
     401int SharedClipboardURIDirDataAlloc(PVBOXCLIPBOARDDIRDATA *ppDirData);
     402void SharedClipboardURIDirDataFree(PVBOXCLIPBOARDDIRDATA pDirData);
     403int SharedClipboardURIDirDataInit(PVBOXCLIPBOARDDIRDATA pDirData);
    394404void SharedClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData);
     405PVBOXCLIPBOARDDIRDATA SharedClipboardURIDirDataDup(PVBOXCLIPBOARDDIRDATA pDirData);
    395406bool SharedClipboardURIDirDataIsValid(PVBOXCLIPBOARDDIRDATA pDirData);
    396407
     408int SharedClipboardURIFileHdrInit(PVBOXCLIPBOARDFILEHDR pFileHdr);
    397409void SharedClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr);
     410PVBOXCLIPBOARDFILEHDR SharedClipboardURIFileHdrDup(PVBOXCLIPBOARDFILEHDR pFileHdr);
    398411bool SharedClipboardURIFileHdrIsValid(PVBOXCLIPBOARDFILEHDR pFileHdr, PVBOXCLIPBOARDDATAHDR pDataHdr);
    399412
    400413void SharedClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData);
     414PVBOXCLIPBOARDFILEDATA SharedClipboardURIFileDataDup(PVBOXCLIPBOARDFILEDATA pFileData);
    401415bool SharedClipboardURIFileDataIsValid(PVBOXCLIPBOARDFILEDATA pFileData, PVBOXCLIPBOARDDATAHDR pDataHdr);
    402416
    403 /**
    404  * Structure for maintaining a meta data format.
    405  */
    406 typedef struct _SHAREDCLIPBOARDMETADATAFMT
     417/** Specifies a meta data format. */
     418typedef uint32_t SHAREDCLIPBOARDMETADATAFMT;
     419
     420/**
     421 * Enumeration of meta data formats.
     422 */
     423typedef enum _SHAREDCLIPBOARDMETADATAFMTENUM
     424{
     425    /** Unknown meta data format; do not use. */
     426    SHAREDCLIPBOARDMETADATAFMT_UNKNOWN  = 0,
     427    /** Meta data is an URI list.
     428     *  UTF-8 format with Unix path separators. Each URI entry is separated by "\r\n". */
     429    SHAREDCLIPBOARDMETADATAFMT_URI_LIST = 1
     430} SHAREDCLIPBOARDMETADATAFMTENUM;
     431
     432/**
     433 * Structure for maintaining meta data format data.
     434 */
     435typedef struct _SHAREDCLIPBOARDMETADATAFMTDATA
    407436{
    408437    /** Meta data format version. */
    … …  
    412441    /** Size of meta data format data (in bytes). */
    413442    uint32_t cbFmt;
    414 } SHAREDCLIPBOARDMETADATAFMT, *PSHAREDCLIPBOARDMETADATAFMT;
     443} SHAREDCLIPBOARDMETADATAFMTDATA, *PSHAREDCLIPBOARDMETADATAFMTDATA;
    415444
    416445/**
    417446 * Structure for keeping Shared Clipboard meta data.
    418  *
    419  * For URI transfers this represents a string list with the file object root entries in it.
     447 * The actual format of the meta data depends on the format set in enmFmt.
    420448 */
    421449typedef struct _SHAREDCLIPBOARDMETADATA
    422450{
     451    /** Format of the data. */
     452    SHAREDCLIPBOARDMETADATAFMT  enmFmt;
    423453    /** Actual meta data block. */
    424     void    *pvMeta;
     454    void                       *pvMeta;
    425455    /** Total size (in bytes) of the allocated meta data block .*/
    426     uint32_t cbMeta;
     456    uint32_t                    cbMeta;
    427457    /** How many bytes are being used in the meta data block. */
    428     uint32_t cbUsed;
     458    uint32_t                    cbUsed;
    429459} SHAREDCLIPBOARDMETADATA, *PSHAREDCLIPBOARDMETADATA;
    430460
    431 int SharedClipboardMetaDataInit(PSHAREDCLIPBOARDMETADATA pMeta);
     461int SharedClipboardMetaDataInit(PSHAREDCLIPBOARDMETADATA pMeta, SHAREDCLIPBOARDMETADATAFMT enmFmt);
    432462void SharedClipboardMetaDataDestroy(PSHAREDCLIPBOARDMETADATA pMeta);
    433463int SharedClipboardMetaDataAdd(PSHAREDCLIPBOARDMETADATA pMeta, const void *pvDataAdd, uint32_t cbDataAdd);
     464int SharedClipboardMetaDataConvertToFormat(const void *pvData, size_t cbData, SHAREDCLIPBOARDMETADATAFMT enmFmt,
     465                                           void **ppvData, uint32_t *pcbData);
    434466int SharedClipboardMetaDataResize(PSHAREDCLIPBOARDMETADATA pMeta, uint32_t cbNewSize);
    435467size_t SharedClipboardMetaDataGetFree(PSHAREDCLIPBOARDMETADATA pMeta);
    … …  
    462494    /** The transfer's direction. */
    463495    SHAREDCLIPBOARDURITRANSFERDIR enmDir;
    464     /** The transfer's cached data header. */
    465     VBOXCLIPBOARDDATAHDR          Header;
    466     /** The transfer's cached meta data. */
    467     SHAREDCLIPBOARDMETADATA       Meta;
     496    /** The transfer's cached data header.
     497     *  Can be NULL if no header has been received yet. */
     498    PVBOXCLIPBOARDDATAHDR         pHeader;
     499    /** The transfer's cached meta data.
     500     *  Can be NULL if no meta data has been received yet. */
     501    PSHAREDCLIPBOARDMETADATA      pMeta;
    468502} SHAREDCLIPBOARDURITRANSFERSTATE, *PSHAREDCLIPBOARDURITRANSFERSTATE;
    469503
    … …  
    494528} SHAREDCLIPBOARDPROVIDERCALLBACKDATA, *PSHAREDCLIPBOARDPROVIDERCALLBACKDATA;
    495529
    496 typedef DECLCALLBACK(int) FNSSHAREDCLIPBOARDPROVIDERREADDATAHDR(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData);
    497 /** Pointer to a FNSSHAREDCLIPBOARDPROVIDERREADDATAHDR function. */
    498 typedef FNSSHAREDCLIPBOARDPROVIDERREADDATAHDR *PFNSSHAREDCLIPBOARDPROVIDERREADDATAHDR;
     530/** Callback functopn for the Shared Clipboard provider. */
     531typedef DECLCALLBACK(int) FNSSHAREDCLIPBOARDPROVIDERCALLBACK(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData);
     532/** Pointer to a FNSSHAREDCLIPBOARDPROVIDERCALLBACK function. */
     533typedef FNSSHAREDCLIPBOARDPROVIDERCALLBACK *PFNSSHAREDCLIPBOARDPROVIDERCALLBACK;
    499534
    500535/**
    … …  
    505540{
    506541    /** 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;
     542    void                                    *pvUser;
     543    /** Function pointer, called when reading the (meta) data header. */
     544    PFNSSHAREDCLIPBOARDPROVIDERCALLBACK      pfnReadDataHdr;
     545    /** Function pointer, called when reading a (meta) data chunk. */
     546    PFNSSHAREDCLIPBOARDPROVIDERCALLBACK      pfnReadDataChunk;
    510547} SHAREDCLIPBOARDPROVIDERCALLBACKS, *PSHAREDCLIPBOARDPROVIDERCALLBACKS;
    511548
    … …  
    528565        struct
    529566        {
     567            SharedClipboardArea *pArea;
    530568        } HostService;
    531569    } u;
    … …  
    587625public: /* Interface to be implemented. */
    588626
    589     virtual int ReadDataHdr(PVBOXCLIPBOARDDATAHDR pDataHdr);
     627    virtual int ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr);
    590628    virtual int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
    591629
    592     virtual int ReadDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t *pcbRead,
    593                               uint32_t fFlags = 0);
    594     virtual int WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t *pcbWritten,
    595                                uint32_t fFlags = 0);
    596 
    597     virtual int ReadDirectory(PVBOXCLIPBOARDDIRDATA pDirData);
     630    virtual int ReadDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags = 0,
     631                              uint32_t *pcbRead = NULL);
     632    virtual int WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags = 0,
     633                               uint32_t *pcbWritten = NULL);
     634
     635    virtual int ReadDirectory(PVBOXCLIPBOARDDIRDATA *ppDirData);
    598636    virtual int WriteDirectory(const PVBOXCLIPBOARDDIRDATA pDirData);
    599637
    600     virtual int ReadFileHdr(PVBOXCLIPBOARDFILEHDR pFileHdr);
     638    virtual int ReadFileHdr(PVBOXCLIPBOARDFILEHDR *ppFileHdr);
    601639    virtual int WriteFileHdr(const PVBOXCLIPBOARDFILEHDR pFileHdr);
    602640
    603     virtual int ReadFileData(PVBOXCLIPBOARDFILEDATA pFileData, uint32_t *pcbRead);
    604     virtual int WriteFileData(const PVBOXCLIPBOARDFILEDATA pFileData, uint32_t *pcbWritten);
     641    virtual int ReadFileData(void *pvData, uint32_t cbData, uint32_t fFlags = 0, uint32_t *pcbRead = NULL);
     642    virtual int WriteFileData(void *pvData, uint32_t cbData, uint32_t fFlags = 0, uint32_t *pcbWritten = NULL);
    605643
    606644    virtual void Reset(void);
    … …  
    618656
    619657protected:
    620 
    621     /** Number of references to this instance. */
    622     volatile uint32_t                m_cRefs;
    623     /** The provider's callback table. */
    624     SHAREDCLIPBOARDPROVIDERCALLBACKS m_Callbacks;
    625 };
    626 
    627 /**
    628  * Shared Clipboard provider implementation for VbglR3 (guest side).
    629  */
    630 class SharedClipboardProviderVbglR3 : protected SharedClipboardProvider
    631 {
    632     friend class SharedClipboardProvider;
    633 
    634 public:
    635 
    636     virtual ~SharedClipboardProviderVbglR3(void);
    637 
    638 public:
    639 
    640     int ReadDataHdr(PVBOXCLIPBOARDDATAHDR pDataHdr);
    641     int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
    642 
    643     int ReadDataChunkk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t *pcbRead,
    644                        uint32_t fFlags = 0);
    645     int WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t *pcbWritten,
    646                        uint32_t fFlags = 0);
    647 
    648     int ReadDirectory(PVBOXCLIPBOARDDIRDATA pDirData);
    649     int WriteDirectory(const PVBOXCLIPBOARDDIRDATA pDirData);
    650 
    651     int ReadFileHdr(PVBOXCLIPBOARDFILEHDR pFileHdr);
    652     int WriteFileHdr(const PVBOXCLIPBOARDFILEHDR pFileHdr);
    653 
    654     int ReadFileData(PVBOXCLIPBOARDFILEDATA pFileData, uint32_t *pcbRead);
    655     int WriteFileData(const PVBOXCLIPBOARDFILEDATA pFileData, uint32_t *pcbWritten);
    656 
    657     void Reset(void);
    658 
    659 protected:
    660 
    661     SharedClipboardProviderVbglR3(uint32_t uClientID);
    662 
    663     /** HGCM client ID to use. */
    664     uint32_t m_uClientID;
    665 };
    666 
    667 #ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
    668 /**
    669  * Shared Clipboard provider implementation for host service (host side).
    670  */
    671 class SharedClipboardProviderHostService : protected SharedClipboardProvider
    672 {
    673     friend class SharedClipboardProvider;
    674 
    675 public:
    676 
    677     virtual ~SharedClipboardProviderHostService(void);
    678 
    679 public:
    680 
    681     int ReadDataHdr(PVBOXCLIPBOARDDATAHDR pDataHdr);
    682     int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
    683 
    684     int ReaaDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvMeta, uint32_t cbMeta, uint32_t *pcbRead, uint32_t fFlags = 0);
    685     int WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvMeta, uint32_t cbMeta, uint32_t *pcbWritten,
    686                        uint32_t fFlags = 0);
    687 
    688     int ReadDirectory(PVBOXCLIPBOARDDIRDATA pDirData);
    689     int WriteDirectory(const PVBOXCLIPBOARDDIRDATA pDirData);
    690 
    691     int ReadFileHdr(PVBOXCLIPBOARDFILEHDR pFileHdr);
    692     int WriteFileHdr(const PVBOXCLIPBOARDFILEHDR pFileHdr);
    693 
    694     int ReadFileData(PVBOXCLIPBOARDFILEDATA pFileData, uint32_t *pcbRead);
    695     int WriteFileData(const PVBOXCLIPBOARDFILEDATA pFileData, uint32_t *pcbWritten);
    696 
    697     void Reset(void);
    698 
    699 public:
    700 
    701     int OnRead(PSHAREDCLIPBOARDPROVIDERREADPARMS pParms);
    702     int OnWrite(PSHAREDCLIPBOARDPROVIDERWRITEPARMS pParms);
    703 
    704 protected:
    705 
    706     SharedClipboardProviderHostService(void);
    707658
    708659    /**
    … …  
    714665        virtual ~Event();
    715666
     667        void *DataAdopt(void);
    716668        uint32_t DataSize(void);
    717669        void *DataRaw(void);
     670        void Reset(void);
    718671        int SetData(const void *pvData, uint32_t cbData);
    719672        int Wait(RTMSINTERVAL uTimeoutMs);
    … …  
    734687    int eventRegister(uint32_t uMsg);
    735688    int eventUnregister(uint32_t uMsg);
     689    int eventUnregisterAll(void);
    736690    int eventSignal(uint32_t uMsg);
    737     SharedClipboardProviderHostService::Event *eventGet(uint32_t uMsg);
    738 
    739 protected:
    740 
     691    int eventWait(uint32_t uMsg, PFNSSHAREDCLIPBOARDPROVIDERCALLBACK pfnCallback, RTMSINTERVAL uTimeoutMs,
     692                  void **ppvData, uint32_t *pcbData = NULL);
     693    SharedClipboardProvider::Event *eventGet(uint32_t uMsg);
     694
     695protected:
     696
     697    /** Number of references to this instance. */
     698    volatile uint32_t                m_cRefs;
     699    /** The provider's callback table. */
     700    SHAREDCLIPBOARDPROVIDERCALLBACKS m_Callbacks;
    741701    /** Default timeout (in ms) for waiting for events. */
    742     RTMSINTERVAL                    m_uTimeoutMs;
     702    RTMSINTERVAL                     m_uTimeoutMs;
    743703    /** Map of (internal) events to provide asynchronous reads / writes. */
    744     EventMap                        m_mapEvents;
     704    EventMap                         m_mapEvents;
     705};
     706
     707/**
     708 * Shared Clipboard provider implementation for VbglR3 (guest side).
     709 */
     710class SharedClipboardProviderVbglR3 : protected SharedClipboardProvider
     711{
     712    friend class SharedClipboardProvider;
     713
     714public:
     715
     716    virtual ~SharedClipboardProviderVbglR3(void);
     717
     718public:
     719
     720    int ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     721    int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
     722
     723    int ReadDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags = 0,
     724                      uint32_t *pcbRead = NULL);
     725    int WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags = 0,
     726                       uint32_t *pcbWritten = NULL);
     727
     728    int ReadDirectory(PVBOXCLIPBOARDDIRDATA *ppDirData);
     729    int WriteDirectory(const PVBOXCLIPBOARDDIRDATA pDirData);
     730
     731    int ReadFileHdr(PVBOXCLIPBOARDFILEHDR *ppFileHdr);
     732    int WriteFileHdr(const PVBOXCLIPBOARDFILEHDR pFileHdr);
     733
     734    int ReadFileData(void *pvData, uint32_t cbData, uint32_t fFlags = 0, uint32_t *pcbRead = NULL);
     735    int WriteFileData(void *pvData, uint32_t cbData, uint32_t fFlags = 0, uint32_t *pcbWritten = NULL);
     736
     737    void Reset(void);
     738
     739protected:
     740
     741    SharedClipboardProviderVbglR3(uint32_t uClientID);
     742
     743    /** HGCM client ID to use. */
     744    uint32_t m_uClientID;
     745};
     746
     747#ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
     748/**
     749 * Shared Clipboard provider implementation for host service (host side).
     750 */
     751class SharedClipboardProviderHostService : protected SharedClipboardProvider
     752{
     753    friend class SharedClipboardProvider;
     754
     755public:
     756
     757    virtual ~SharedClipboardProviderHostService();
     758
     759public:
     760
     761    int ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     762    int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
     763
     764    int ReadDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags = 0,
     765                      uint32_t *pcbRead = NULL);
     766    int WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags = 0,
     767                       uint32_t *pcbWritten = NULL);
     768
     769    int ReadDirectory(PVBOXCLIPBOARDDIRDATA *ppDirData);
     770    int WriteDirectory(const PVBOXCLIPBOARDDIRDATA pDirData);
     771
     772    int ReadFileHdr(PVBOXCLIPBOARDFILEHDR *ppFileHdr);
     773    int WriteFileHdr(const PVBOXCLIPBOARDFILEHDR pFileHdr);
     774
     775    int ReadFileData(void *pvData, uint32_t cbData, uint32_t fFlags = 0, uint32_t *pcbRead = NULL);
     776    int WriteFileData(void *pvData, uint32_t cbData, uint32_t fFlags = 0, uint32_t *pcbWritten = NULL);
     777
     778    void Reset(void);
     779
     780public:
     781
     782    int OnWrite(PSHAREDCLIPBOARDPROVIDERWRITEPARMS pParms);
     783
     784protected:
     785
     786    SharedClipboardProviderHostService(SharedClipboardArea *pArea);
     787
     788protected:
     789
     790    /** Pointer to associated clipboard area. */
     791    SharedClipboardArea            *m_pArea;
    745792};
    746793#endif /* VBOX_WITH_SHARED_CLIPBOARD_HOST */
    … …  
    835882    SharedClipboardArea                *pArea;
    836883    /** The URI list for this transfer. */
    837     SharedClipboardURIList              URIList;
     884    SharedClipboardURIList             *pURIList;
    838885    /** Context of current object being handled. */
    839886    SHAREDCLIPBOARDCLIENTURIOBJCTX      ObjCtx;
    … …  
    869916
    870917int SharedClipboardURIObjCtxInit(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
    871 void SharedClipboardURIObjCtxUninit(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
     918void SharedClipboardURIObjCtxDestroy(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
    872919SharedClipboardURIObject *SharedClipboardURIObjCtxGetObj(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
    873920bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
    874921
    875 int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCtx,
    876                                      PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
     922int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, PSHAREDCLIPBOARDURITRANSFER *ppTransfer);
    877923int SharedClipboardURITransferDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     924int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     925int SharedClipboardURITransferProviderCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     926                                             PSHAREDCLIPBOARDPROVIDERCREATIONCTX pProviderCtx);
    878927void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    879928SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     929PSHAREDCLIPBOARDCLIENTURIOBJCTX SharedClipboardURITransferGetCurrentObjCtx(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    880930const SharedClipboardURIObject *SharedClipboardURITransferGetCurrentObject(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    881931SharedClipboardProvider *SharedClipboardURITransferGetProvider(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    … …  
    886936
    887937int SharedClipboardURITransferMetaDataAdd(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
    888 int SharedClipboardURITransferMetaDataComplete(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     938bool SharedClipboardURITransferMetaDataIsComplete(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    889939int SharedClipboardURITransferMetaGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
    890940int SharedClipboardURITransferMetaDataRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t *pcbRead);
    … …  
    892942
    893943int SharedClipboardURITransferRead(PSHAREDCLIPBOARDURITRANSFER pTransfer);
     944int SharedClipboardURITransferReadObjects(PSHAREDCLIPBOARDURITRANSFER pTransfer);
    894945
    895946int SharedClipboardURITransferWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer);
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