VirtualBox

Ignore:
Timestamp:
Sep 17, 2019 1:03:39 PM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: More renaming (URI -> transfer).

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r80847 r80858  
    11/* $Id$ */
    22/** @file
    3  * Shared Clipboard - Shared URI functions between host and guest.
     3 * Shared Clipboard - Shared transfer functions between host and guest.
    44 */
    55
    … …  
    4949
    5050/** No status set. */
    51 #define SHCLURITRANSFERSTATUS_NONE           0
     51#define SHCLTRANSFERSTATUS_NONE           0
    5252/** The transfer has been announced but is not running yet. */
    53 #define SHCLURITRANSFERSTATUS_READY          1
     53#define SHCLTRANSFERSTATUS_READY          1
    5454/** The transfer is active and running. */
    55 #define SHCLURITRANSFERSTATUS_STARTED        2
     55#define SHCLTRANSFERSTATUS_STARTED        2
    5656/** The transfer has been stopped. */
    57 #define SHCLURITRANSFERSTATUS_STOPPED        3
     57#define SHCLTRANSFERSTATUS_STOPPED        3
    5858/** The transfer has been canceled. */
    59 #define SHCLURITRANSFERSTATUS_CANCELED       4
     59#define SHCLTRANSFERSTATUS_CANCELED       4
    6060/** The transfer has been killed. */
    61 #define SHCLURITRANSFERSTATUS_KILLED         5
     61#define SHCLTRANSFERSTATUS_KILLED         5
    6262/** The transfer ran into an unrecoverable error. */
    63 #define SHCLURITRANSFERSTATUS_ERROR          6
     63#define SHCLTRANSFERSTATUS_ERROR          6
    6464
    6565/** Defines a transfer status. */
    66 typedef uint32_t SHCLURITRANSFERSTATUS;
     66typedef uint32_t SHCLTRANSFERSTATUS;
    6767
    6868/** @} */
    … …  
    384384        struct
    385385        {
    386             SHCLURITRANSFERSTATUS uStatus;
     386            SHCLTRANSFERSTATUS uStatus;
    387387        } TransferStatus;
    388388        struct
    … …  
    634634    SharedClipboardAreaFsObjMap  m_mapObj;
    635635    /** Associated clipboard area ID. */
    636     SHCLAREAID        m_uID;
     636    SHCLAREAID                   m_uID;
    637637};
    638638
    … …  
    640640int SharedClipboardPathSanitize(char *pszPath, size_t cbPath);
    641641
    642 PSHCLROOTLIST SharedClipboardURIRootListAlloc(void);
    643 void SharedClipboardURIRootListFree(PSHCLROOTLIST pRootList);
    644 
    645 PSHCLROOTLISTHDR SharedClipboardURIRootListHdrDup(PSHCLROOTLISTHDR pRoots);
    646 int SharedClipboardURIRootListHdrInit(PSHCLROOTLISTHDR pRoots);
    647 void SharedClipboardURIRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
    648 
    649 int SharedClipboardURIRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
    650 PSHCLROOTLISTENTRY SharedClipboardURIRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
    651 void SharedClipboardURIRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
    652 
    653 int SharedClipboardURIListHdrAlloc(PSHCLLISTHDR *ppListHdr);
    654 void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr);
    655 PSHCLLISTHDR SharedClipboardURIListHdrDup(PSHCLLISTHDR pListHdr);
    656 int SharedClipboardURIListHdrInit(PSHCLLISTHDR pListHdr);
    657 void SharedClipboardURIListHdrDestroy(PSHCLLISTHDR pListHdr);
    658 void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr);
    659 void SharedClipboardURIListHdrReset(PSHCLLISTHDR pListHdr);
    660 bool SharedClipboardURIListHdrIsValid(PSHCLLISTHDR pListHdr);
    661 
    662 int SharedClipboardURIListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
    663 PSHCLLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
    664 int SharedClipboardURIListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
    665 void SharedClipboardURIListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
    666 
    667 int SharedClipboardURIListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
    668 void SharedClipboardURIListEntryFree(PSHCLLISTENTRY pListEntry);
    669 int SharedClipboardURIListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
    670 PSHCLLISTENTRY SharedClipboardURIListEntryDup(PSHCLLISTENTRY pListEntry);
    671 int SharedClipboardURIListEntryInit(PSHCLLISTENTRY pListEntry);
    672 void SharedClipboardURIListEntryDestroy(PSHCLLISTENTRY pListEntry);
    673 bool SharedClipboardURIListEntryIsValid(PSHCLLISTENTRY pListEntry);
    674 
    675 /**
    676  * Enumeration specifying an URI transfer direction.
    677  */
    678 typedef enum _SHCLURITRANSFERDIR
     642PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void);
     643void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList);
     644
     645PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
     646int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
     647void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
     648
     649int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
     650PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
     651void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
     652
     653int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
     654void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
     655PSHCLLISTHDR SharedClipboardTransferListHdrDup(PSHCLLISTHDR pListHdr);
     656int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr);
     657void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
     658void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr);
     659void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr);
     660bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
     661
     662int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
     663PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
     664int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
     665void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
     666
     667int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
     668void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry);
     669int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
     670PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry);
     671int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry);
     672void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
     673bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
     674
     675/**
     676 * Enumeration specifying an Shared Clipboard transfer direction.
     677 */
     678typedef enum _SHCLTRANSFERDIR
    679679{
    680680    /** Unknown transfer directory. */
    681     SHCLURITRANSFERDIR_UNKNOWN = 0,
     681    SHCLTRANSFERDIR_UNKNOWN = 0,
    682682    /** Read transfer (from source). */
    683     SHCLURITRANSFERDIR_READ,
     683    SHCLTRANSFERDIR_READ,
    684684    /** Write transfer (to target). */
    685     SHCLURITRANSFERDIR_WRITE,
     685    SHCLTRANSFERDIR_WRITE,
    686686    /** The usual 32-bit hack. */
    687     SHCLURITRANSFERDIR_32BIT_HACK = 0x7fffffff
    688 } SHCLURITRANSFERDIR, *PSHCLURITRANSFERDIR;
    689 
    690 struct _SHCLURITRANSFER;
    691 typedef struct _SHCLURITRANSFER SHCLURITRANSFER;
    692 
    693 /**
    694  * Structure for handling a single URI object context.
    695  */
    696 typedef struct _SHCLCLIENTURIOBJCTX
    697 {
    698     SHCLURITRANSFER *pTransfer;
    699     SHCLOBJHANDLE    uHandle;
    700 } SHCLCLIENTURIOBJCTX, *PSHCLCLIENTURIOBJCTX;
    701 
    702 typedef struct _SHCLURITRANSFEROBJSTATE
     687    SHCLTRANSFERDIR_32BIT_HACK = 0x7fffffff
     688} SHCLTRANSFERDIR, *PSHCLTRANSFERDIR;
     689
     690struct _SHCLTRANSFER;
     691typedef struct _SHCLTRANSFER SHCLTRANSFER;
     692
     693/**
     694 * Structure for handling a single transfer object context.
     695 */
     696typedef struct _SHCLCLIENTTRANSFEROBJCTX
     697{
     698    SHCLTRANSFER *pTransfer;
     699    SHCLOBJHANDLE uHandle;
     700} SHCLCLIENTTRANSFEROBJCTX, *PSHCLCLIENTTRANSFEROBJCTX;
     701
     702typedef struct _SHCLTRANSFEROBJSTATE
    703703{
    704704    /** How many bytes were processed (read / write) so far. */
    705705    uint64_t cbProcessed;
    706 } SHCLURITRANSFEROBJSTATE, *PSHCLURITRANSFEROBJSTATE;
    707 
    708 typedef struct _SHCLURITRANSFEROBJ
    709 {
    710     SHCLOBJHANDLE           uHandle;
    711     char                   *pszPathAbs;
    712     SHCLFSOBJINFO           objInfo;
    713     SHCLSOURCE              enmSource;
    714     SHCLURITRANSFEROBJSTATE State;
    715 } SHCLURITRANSFEROBJ, *PSHCLURITRANSFEROBJ;
     706} SHCLTRANSFEROBJSTATE, *PSHCLTRANSFEROBJSTATE;
     707
     708typedef struct _SHCLTRANSFEROBJ
     709{
     710    SHCLOBJHANDLE        uHandle;
     711    char                *pszPathAbs;
     712    SHCLFSOBJINFO        objInfo;
     713    SHCLSOURCE           enmSource;
     714    SHCLTRANSFEROBJSTATE State;
     715} SHCLTRANSFEROBJ, *PSHCLTRANSFEROBJ;
    716716
    717717/** Defines a transfer ID. */
    718 typedef uint16_t SHCLURITRANSFERID;
     718typedef uint16_t SHCLTRANSFERID;
    719719
    720720/**
    721721 * Enumeration for specifying a Shared Clipboard object type.
    722722 */
    723 typedef enum _SHCLURIOBJTYPE
     723typedef enum _SHCLOBJTYPE
    724724{
    725725    /** Invalid object type. */
    726     SHCLURIOBJTYPE_INVALID = 0,
     726    SHCLOBJTYPE_INVALID = 0,
    727727    /** Object is a directory. */
    728     SHCLURIOBJTYPE_DIRECTORY,
     728    SHCLOBJTYPE_DIRECTORY,
    729729    /** Object is a file. */
    730     SHCLURIOBJTYPE_FILE,
     730    SHCLOBJTYPE_FILE,
    731731    /** Object is a symbolic link. */
    732     SHCLURIOBJTYPE_SYMLINK,
     732    SHCLOBJTYPE_SYMLINK,
    733733    /** The usual 32-bit hack. */
    734     SHCLURIOBJTYPE_32BIT_SIZE_HACK = 0x7fffffff
    735 } SHCLURIOBJTYPE;
    736 
    737 /**
    738  * Structure for keeping URI list handle information.
     734    SHCLOBJTYPE_32BIT_SIZE_HACK = 0x7fffffff
     735} SHCLOBJTYPE;
     736
     737/**
     738 * Structure for keeping transfer list handle information.
    739739 * This is using to map own (local) handles to the underlying file system.
    740740 */
    741 typedef struct _SHCLURILISTHANDLEINFO
     741typedef struct _SHCLLISTHANDLEINFO
    742742{
    743743    /** The list node. */
    … …  
    746746    SHCLLISTHANDLE  hList;
    747747    /** Type of list handle. */
    748     SHCLURIOBJTYPE  enmType;
     748    SHCLOBJTYPE     enmType;
    749749    /** Absolute local path of the list object. */
    750750    char           *pszPathLocalAbs;
    … …  
    761761        } Local;
    762762    } u;
    763 } SHCLURILISTHANDLEINFO, *PSHCLURILISTHANDLEINFO;
    764 
    765 /**
    766  * Structure for keeping URI object handle information.
     763} SHCLLISTHANDLEINFO, *PSHCLLISTHANDLEINFO;
     764
     765/**
     766 * Structure for keeping transfer object handle information.
    767767 * This is using to map own (local) handles to the underlying file system.
    768768 */
    769 typedef struct _SHCLURIOBJHANDLEINFO
     769typedef struct _SHCLOBJHANDLEINFO
    770770{
    771771    /** The list node. */
    … …  
    774774    SHCLOBJHANDLE  hObj;
    775775    /** Type of object handle. */
    776     SHCLURIOBJTYPE enmType;
     776    SHCLOBJTYPE    enmType;
    777777    /** Absolute local path of the object. */
    778778    char          *pszPathLocalAbs;
    … …  
    789789        } Local;
    790790    } u;
    791 } SHCLURIOBJHANDLEINFO, *PSHCLURIOBJHANDLEINFO;
     791} SHCLOBJHANDLEINFO, *PSHCLOBJHANDLEINFO;
    792792
    793793/**
    794794 * Structure for keeping a single root list entry.
    795795 */
    796 typedef struct _SHCLURILISTROOT
     796typedef struct _SHCLLISTROOT
    797797{
    798798    /** The list node. */
    … …  
    800800    /** Absolute path of entry. */
    801801    char               *pszPathAbs;
    802 } SHCLURILISTROOT, *PSHCLURILISTROOT;
    803 
    804 /**
    805  * Structure for maintaining an URI transfer state.
     802} SHCLLISTROOT, *PSHCLLISTROOT;
     803
     804/**
     805 * Structure for maintaining an Shared Clipboard transfer state.
    806806 * Everything in here will be part of a saved state (later).
    807807 */
    808 typedef struct _SHCLURITRANSFERSTATE
     808typedef struct _SHCLTRANSFERSTATE
    809809{
    810810    /** The transfer's (local) ID. */
    811     SHCLURITRANSFERID     uID;
     811    SHCLTRANSFERID     uID;
    812812    /** The transfer's current status. */
    813     SHCLURITRANSFERSTATUS enmStatus;
     813    SHCLTRANSFERSTATUS enmStatus;
    814814    /** The transfer's direction. */
    815     SHCLURITRANSFERDIR    enmDir;
     815    SHCLTRANSFERDIR    enmDir;
    816816    /** The transfer's source. */
    817     SHCLSOURCE            enmSource;
    818 } SHCLURITRANSFERSTATE, *PSHCLURITRANSFERSTATE;
    819 
    820 struct _SHCLURITRANSFER;
    821 typedef struct _SHCLURITRANSFER *PSHCLURITRANSFER;
    822 
    823 /**
    824  * Structure maintaining URI clipboard provider context data.
     817    SHCLSOURCE         enmSource;
     818} SHCLTRANSFERSTATE, *PSHCLTRANSFERSTATE;
     819
     820struct _SHCLTRANSFER;
     821typedef struct _SHCLTRANSFER *PSHCLTRANSFER;
     822
     823/**
     824 * Structure maintaining clipboard transfer provider context data.
    825825 * This is handed in to the provider implementation callbacks.
    826826 */
    827827    typedef struct _SHCLPROVIDERCTX
    828828{
    829     /** Pointer to the related URI transfer. */
    830     PSHCLURITRANSFER pTransfer;
     829    /** Pointer to the related Shared Clipboard transfer. */
     830    PSHCLTRANSFER pTransfer;
    831831    /** User-defined data pointer. Can be NULL if not needed. */
    832     void                       *pvUser;
     832    void         *pvUser;
    833833} SHCLPROVIDERCTX, *PSHCLPROVIDERCTX;
    834834
    835 /** Defines an URI clipboard provider function declaration with additional parameters. */
     835/** Defines an clipboard transfer provider function declaration with additional parameters. */
    836836#define SHCLPROVIDERFUNCDECL(a_Name, ...) \
    837837    typedef DECLCALLBACK(int) RT_CONCAT(FNSHCLPROVIDER, a_Name)(PSHCLPROVIDERCTX, __VA_ARGS__); \
    838838    typedef RT_CONCAT(FNSHCLPROVIDER, a_Name) RT_CONCAT(*PFNSHCLPROVIDER, a_Name);
    839839
    840 /** Defines an URI clipboard provider function declaration with additional parameters. */
     840/** Defines an clipboard transfer provider function declaration with additional parameters. */
    841841#define SHCLPROVIDERFUNCDECLRET(a_Ret, a_Name, ...) \
    842842    typedef DECLCALLBACK(a_Ret) RT_CONCAT(FNSHCLPROVIDER, a_Name)(PSHCLPROVIDERCTX, __VA_ARGS__); \
    843843    typedef RT_CONCAT(FNSHCLPROVIDER, a_Name) RT_CONCAT(*PFNSHCLPROVIDER, a_Name);
    844844
    845 /** Defines an URI clipboard provider function declaration (no additional parameters). */
     845/** Defines an clipboard transfer provider function declaration (no additional parameters). */
    846846#define SHCLPROVIDERFUNCDECLVOID(a_Name) \
    847847    typedef DECLCALLBACK(int) RT_CONCAT(FNSHCLPROVIDER, a_Name)(PSHCLPROVIDERCTX); \
    848848    typedef RT_CONCAT(FNSHCLPROVIDER, a_Name) RT_CONCAT(*PFNSHCLPROVIDER, a_Name);
    849849
    850 /** Declares a URI clipboard provider function member. */
     850/** Declares a clipboard transfer provider function member. */
    851851#define SHCLPROVIDERFUNCMEMBER(a_Name, a_Member) \
    852852    RT_CONCAT(PFNSHCLPROVIDER, a_Name) a_Member;
    … …  
    867867
    868868/**
    869  * Shared Clipboard URI provider interface table.
     869 * Shared Clipboard transfer provider interface table.
    870870 */
    871871typedef struct _SHCLPROVIDERINTERFACE
    … …  
    899899} SHCLPROVIDERCREATIONCTX, *PSHCLPROVIDERCREATIONCTX;
    900900
    901 struct _SHCLURITRANSFER;
    902 typedef _SHCLURITRANSFER *PSHCLURITRANSFER;
    903 
    904 /**
    905  * Structure for storing URI transfer callback data.
    906  */
    907 typedef struct _SHCLURITRANSFERCALLBACKDATA
    908 {
    909     /** Pointer to related URI transfer. */
    910     PSHCLURITRANSFER pTransfer;
     901struct _SHCLTRANSFER;
     902typedef _SHCLTRANSFER *PSHCLTRANSFER;
     903
     904/**
     905 * Structure for storing Shared Clipboard transfer callback data.
     906 */
     907typedef struct _SHCLTRANSFERCALLBACKDATA
     908{
     909    /** Pointer to related Shared Clipboard transfer. */
     910    PSHCLTRANSFER pTransfer;
    911911    /** Saved user pointer. */
    912     void            *pvUser;
    913 } SHCLURITRANSFERCALLBACKDATA, *PSHCLURITRANSFERCALLBACKDATA;
     912    void         *pvUser;
     913} SHCLTRANSFERCALLBACKDATA, *PSHCLTRANSFERCALLBACKDATA;
    914914
    915915#define SHCLTRANSFERCALLBACKDECLVOID(a_Name) \
    916     typedef DECLCALLBACK(void) RT_CONCAT(FNSHCLCALLBACK, a_Name)(PSHCLURITRANSFERCALLBACKDATA pData); \
     916    typedef DECLCALLBACK(void) RT_CONCAT(FNSHCLCALLBACK, a_Name)(PSHCLTRANSFERCALLBACKDATA pData); \
    917917    typedef RT_CONCAT(FNSHCLCALLBACK, a_Name) RT_CONCAT(*PFNSHCLCALLBACK, a_Name);
    918918
    919919#define SHCLTRANSFERCALLBACKDECL(a_Name, ...) \
    920     typedef DECLCALLBACK(void) RT_CONCAT(FNSHCLCALLBACK, a_Name)(PSHCLURITRANSFERCALLBACKDATA pData, __VA_ARGS__); \
     920    typedef DECLCALLBACK(void) RT_CONCAT(FNSHCLCALLBACK, a_Name)(PSHCLTRANSFERCALLBACKDATA pData, __VA_ARGS__); \
    921921    typedef RT_CONCAT(FNSHCLCALLBACK, a_Name) RT_CONCAT(*PFNSHCLCALLBACK, a_Name);
    922922
    … …  
    933933
    934934/**
    935  * Structure acting as a function callback table for URI transfers.
     935 * Structure acting as a function callback table for Shared Clipboard transfers.
    936936 * All callbacks are optional and therefore can be NULL.
    937937 */
    938 typedef struct _SHCLURITRANSFERCALLBACKS
     938typedef struct _SHCLTRANSFERCALLBACKS
    939939{
    940940    /** Saved user pointer. */
    941     void                                  *pvUser;
     941    void *pvUser;
    942942    /** Function pointer, called when the transfer is going to be prepared. */
    943943    SHCLTRANSFERCALLBACKMEMBER(TRANSFERPREPARE, pfnTransferPrepare)
    … …  
    954954    /** Function pointer, called when transfer resulted in an unrecoverable error. */
    955955    SHCLTRANSFERCALLBACKMEMBER(TRANSFERERROR, pfnTransferError)
    956 } SHCLURITRANSFERCALLBACKS, *PSHCLURITRANSFERCALLBACKS;
    957 
    958 /**
    959  * Structure for thread-related members for a single URI transfer.
    960  */
    961 typedef struct _SHCLURITRANSFERTHREAD
     956} SHCLTRANSFERCALLBACKS, *PSHCLTRANSFERCALLBACKS;
     957
     958/**
     959 * Structure for thread-related members for a single Shared Clipboard transfer.
     960 */
     961typedef struct _SHCLTRANSFERTHREAD
    962962{
    963963    /** Thread handle for the reading / writing thread.
    … …  
    970970    /** Thread cancelled flag / indicator. */
    971971    volatile bool               fCancelled;
    972 } SHCLURITRANSFERTHREAD, *PSHCLURITRANSFERTHREAD;
    973 
    974 /**
    975  * Structure for maintaining a single URI transfer.
     972} SHCLTRANSFERTHREAD, *PSHCLTRANSFERTHREAD;
     973
     974/**
     975 * Structure for maintaining a single Shared Clipboard transfer.
    976976 *
    977977 ** @todo Not yet thread safe.
    978978 */
    979 typedef struct _SHCLURITRANSFER
     979typedef struct _SHCLTRANSFER
    980980{
    981981    /** The node member for using this struct in a RTList. */
    … …  
    984984    RTCRITSECT               CritSect;
    985985    /** The transfer's state (for SSM, later). */
    986     SHCLURITRANSFERSTATE     State;
     986    SHCLTRANSFERSTATE        State;
    987987    /** Timeout (in ms) for waiting of events. Default is 30s. */
    988988    RTMSINTERVAL             uTimeoutMs;
    … …  
    10141014    SHCLPROVIDERINTERFACE    ProviderIface;
    10151015    /** The transfer's (optional) callback table. */
    1016     SHCLURITRANSFERCALLBACKS Callbacks;
     1016    SHCLTRANSFERCALLBACKS    Callbacks;
    10171017    /** Opaque pointer to implementation-specific parameters. */
    10181018    void                    *pvUser;
    … …  
    10201020    size_t                   cbUser;
    10211021    /** Contains thread-related attributes. */
    1022     SHCLURITRANSFERTHREAD    Thread;
    1023 } SHCLURITRANSFER, *PSHCLURITRANSFER;
    1024 
    1025 /**
    1026  * Structure for keeping an URI transfer status report.
    1027  */
    1028 typedef struct _SHCLURITRANSFERREPORT
     1022    SHCLTRANSFERTHREAD       Thread;
     1023} SHCLTRANSFER, *PSHCLTRANSFER;
     1024
     1025/**
     1026 * Structure for keeping an Shared Clipboard transfer status report.
     1027 */
     1028typedef struct _SHCLTRANSFERREPORT
    10291029{
    10301030    /** Actual status to report. */
    1031     SHCLURITRANSFERSTATUS uStatus;
     1031    SHCLTRANSFERSTATUS uStatus;
    10321032    /** Result code (rc) to report; might be unused / invalid, based on enmStatus. */
    10331033    int                   rc;
    10341034    /** Reporting flags. Currently unused and must be 0. */
    10351035    uint32_t              fFlags;
    1036 } SHCLURITRANSFERREPORT, *PSHCLURITRANSFERREPORT;
    1037 
    1038 /**
    1039  * Structure for keeping URI clipboard information around.
    1040  */
    1041 typedef struct _SHCLURICTX
     1036} SHCLTRANSFERREPORT, *PSHCLTRANSFERREPORT;
     1037
     1038/**
     1039 * Structure for keeping Shared Clipboard transfer context around.
     1040 */
     1041typedef struct _SHCLTRANSFERCTX
    10421042{
    10431043    /** Critical section for serializing access. */
    … …  
    10531053    /** Number of total transfers (in list). */
    10541054    uint16_t                    cTransfers;
    1055 } SHCLURICTX, *PSHCLURICTX;
    1056 
    1057 int SharedClipboardURIObjCtxInit(PSHCLCLIENTURIOBJCTX pObjCtx);
    1058 void SharedClipboardURIObjCtxDestroy(PSHCLCLIENTURIOBJCTX pObjCtx);
    1059 bool SharedClipboardURIObjCtxIsValid(PSHCLCLIENTURIOBJCTX pObjCtx);
    1060 
    1061 int SharedClipboardURIObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
    1062 int SharedClipboardURIObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
    1063 void SharedClipboardURIObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
    1064 
    1065 int SharedClipboardURIObjectOpen(PSHCLURITRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
    1066                                  PSHCLOBJHANDLE phObj);
    1067 int SharedClipboardURIObjectClose(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj);
    1068 int SharedClipboardURIObjectRead(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
    1069 int SharedClipboardURIObjectWrite(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
    1070 
    1071 PSHCLOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
    1072 void SharedClipboardURIObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
    1073 void SharedClipboardURIObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
    1074 
    1075 int SharedClipboardURITransferCreate(PSHCLURITRANSFER *ppTransfer);
    1076 int SharedClipboardURITransferDestroy(PSHCLURITRANSFER pTransfer);
    1077 
    1078 int SharedClipboardURITransferInit(PSHCLURITRANSFER pTransfer, uint32_t uID, SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource);
    1079 int SharedClipboardURITransferOpen(PSHCLURITRANSFER pTransfer);
    1080 int SharedClipboardURITransferClose(PSHCLURITRANSFER pTransfer);
    1081 
    1082 int SharedClipboardURITransferListOpen(PSHCLURITRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
     1055} SHCLTRANSFERCTX, *PSHCLTRANSFERCTX;
     1056
     1057int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
     1058void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
     1059bool SharedClipboardTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
     1060
     1061int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
     1062int SharedClipboardTransferObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
     1063void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
     1064
     1065int SharedClipboardTransferObjectOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj);
     1066int SharedClipboardTransferObjectClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj);
     1067int SharedClipboardTransferObjectRead(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
     1068int SharedClipboardTransferObjectWrite(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
     1069
     1070PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
     1071void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
     1072void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
     1073
     1074int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer);
     1075int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer);
     1076
     1077int SharedClipboardTransferInit(PSHCLTRANSFER pTransfer, uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource);
     1078int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer);
     1079int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer);
     1080
     1081int SharedClipboardTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
    10831082                                       PSHCLLISTHANDLE phList);
    1084 int SharedClipboardURITransferListClose(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList);
    1085 int SharedClipboardURITransferListGetHeader(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
     1083int SharedClipboardTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
     1084int SharedClipboardTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
    10861085                                            PSHCLLISTHDR pHdr);
    1087 PSHCLURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHCLURITRANSFER pTransfer,
     1086PSHCLTRANSFEROBJ SharedClipboardTransferListGetObj(PSHCLTRANSFER pTransfer,
    10881087                                                                    SHCLLISTHANDLE hList, uint64_t uIdx);
    1089 int SharedClipboardURITransferListRead(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
     1088int SharedClipboardTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
    10901089                                       PSHCLLISTENTRY pEntry);
    1091 int SharedClipboardURITransferListWrite(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
     1090int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
    10921091                                        PSHCLLISTENTRY pEntry);
    1093 bool SharedClipboardURITransferListHandleIsValid(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList);
    1094 
    1095 int SharedClipboardURITransferPrepare(PSHCLURITRANSFER pTransfer);
    1096 int SharedClipboardURITransferSetInterface(PSHCLURITRANSFER pTransfer,
     1092bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
     1093
     1094int SharedClipboardTransferPrepare(PSHCLTRANSFER pTransfer);
     1095int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer,
    10971096                                           PSHCLPROVIDERCREATIONCTX pCreationCtx);
    1098 int SharedClipboardURILTransferSetRoots(PSHCLURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
    1099 void SharedClipboardURITransferReset(PSHCLURITRANSFER pTransfer);
    1100 SharedClipboardArea *SharedClipboardURITransferGetArea(PSHCLURITRANSFER pTransfer);
    1101 
    1102 uint32_t SharedClipboardURILTransferRootsCount(PSHCLURITRANSFER pTransfer);
    1103 int SharedClipboardURILTransferRootsEntry(PSHCLURITRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
    1104 int SharedClipboardURILTransferRootsAsList(PSHCLURITRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
    1105 
    1106 SHCLURITRANSFERID SharedClipboardURITransferGetID(PSHCLURITRANSFER pTransfer);
    1107 SHCLSOURCE SharedClipboardURITransferGetSource(PSHCLURITRANSFER pTransfer);
    1108 SHCLURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHCLURITRANSFER pTransfer);
    1109 int SharedClipboardURITransferHandleReply(PSHCLURITRANSFER pTransfer, PSHCLREPLY pReply);
    1110 int SharedClipboardURITransferRun(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
    1111 void SharedClipboardURITransferSetCallbacks(PSHCLURITRANSFER pTransfer,
    1112                                             PSHCLURITRANSFERCALLBACKS pCallbacks);
    1113 
    1114 int SharedClipboardURITransferRead(PSHCLURITRANSFER pTransfer);
    1115 int SharedClipboardURITransferReadObjects(PSHCLURITRANSFER pTransfer);
    1116 
    1117 int SharedClipboardURITransferWrite(PSHCLURITRANSFER pTransfer);
    1118 int SharedClipboardURITransferWriteObjects(PSHCLURITRANSFER pTransfer);
    1119 
    1120 int SharedClipboardURICtxInit(PSHCLURICTX pURI);
    1121 void SharedClipboardURICtxDestroy(PSHCLURICTX pURI);
    1122 void SharedClipboardURICtxReset(PSHCLURICTX pURI);
    1123 PSHCLURITRANSFER SharedClipboardURICtxGetTransfer(PSHCLURICTX pURI, uint32_t uIdx);
    1124 uint32_t SharedClipboardURICtxGetRunningTransfers(PSHCLURICTX pURI);
    1125 uint32_t SharedClipboardURICtxGetTotalTransfers(PSHCLURICTX pURI);
    1126 void SharedClipboardURICtxTransfersCleanup(PSHCLURICTX pURI);
    1127 bool SharedClipboardURICtxTransfersMaximumReached(PSHCLURICTX pURI);
    1128 int SharedClipboardURICtxTransferRegister(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer, uint32_t *pidTransfer);
    1129 int SharedClipboardURICtxTransferRegisterByIndex(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer, uint32_t idTransfer);
    1130 int SharedClipboardURICtxTransferUnregister(PSHCLURICTX pURI, uint32_t idTransfer);
     1097int SharedClipboardTransferLTransferSetRoots(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
     1098void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer);
     1099SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer);
     1100
     1101uint32_t SharedClipboardTransferLTransferRootsCount(PSHCLTRANSFER pTransfer);
     1102int SharedClipboardTransferLTransferRootsEntry(PSHCLTRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
     1103int SharedClipboardTransferLTransferRootsAsList(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
     1104
     1105SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer);
     1106SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer);
     1107SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer);
     1108int SharedClipboardTransferHandleReply(PSHCLTRANSFER pTransfer, PSHCLREPLY pReply);
     1109int SharedClipboardTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
     1110void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer, PSHCLTRANSFERCALLBACKS pCallbacks);
     1111
     1112int SharedClipboardTransferRead(PSHCLTRANSFER pTransfer);
     1113int SharedClipboardTransferReadObjects(PSHCLTRANSFER pTransfer);
     1114
     1115int SharedClipboardTransferWrite(PSHCLTRANSFER pTransfer);
     1116int SharedClipboardTransferWriteObjects(PSHCLTRANSFER pTransfer);
     1117
     1118int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx);
     1119void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx);
     1120void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx);
     1121PSHCLTRANSFER SharedClipboardTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
     1122uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx);
     1123uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx);
     1124void SharedClipboardTransferCtxTransfersCleanup(PSHCLTRANSFERCTX pTransferCtx);
     1125bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx);
     1126int SharedClipboardTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer);
     1127int SharedClipboardTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer);
     1128int SharedClipboardTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer);
    11311129
    11321130void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc);
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