Index: /trunk/include/VBox/GuestHost/SharedClipboard-uri.h =================================================================== --- /trunk/include/VBox/GuestHost/SharedClipboard-uri.h (revision 80661) +++ /trunk/include/VBox/GuestHost/SharedClipboard-uri.h (revision 80662) @@ -48,18 +48,18 @@ /** A Shared Clipboard list handle. */ -typedef uint64_t SHAREDCLIPBOARDLISTHANDLE; +typedef uint64_t SHCLLISTHANDLE; /** Pointer to a Shared Clipboard list handle. */ -typedef SHAREDCLIPBOARDLISTHANDLE *PSHAREDCLIPBOARDLISTHANDLE; +typedef SHCLLISTHANDLE *PSHCLLISTHANDLE; /** Specifies an invalid Shared Clipboard list handle. */ -#define SHAREDCLIPBOARDLISTHANDLE_INVALID ((SHAREDCLIPBOARDLISTHANDLE)~0LL) +#define SHCLLISTHANDLE_INVALID ((SHCLLISTHANDLE)~0LL) /** A Shared Clipboard object handle. */ -typedef uint64_t SHAREDCLIPBOARDOBJHANDLE; +typedef uint64_t SHCLOBJHANDLE; /** Pointer to a Shared Clipboard object handle. */ -typedef SHAREDCLIPBOARDOBJHANDLE *PSHAREDCLIPBOARDOBJHANDLE; +typedef SHCLOBJHANDLE *PSHCLOBJHANDLE; /** Specifies an invalid Shared Clipboard object handle. */ -#define SHAREDCLIPBOARDOBJHANDLE_INVALID ((SHAREDCLIPBOARDOBJHANDLE)~0LL) +#define SHCLOBJHANDLE_INVALID ((SHCLOBJHANDLE)~0LL) /** @} */ @@ -70,11 +70,11 @@ /** No flags. Initialization value. */ -#define SHAREDCLIPBOARD_OBJ_CF_NONE (0x00000000) +#define SHCL_OBJ_CF_NONE (0x00000000) /** Lookup only the object, do not return a handle. All other flags are ignored. */ -#define SHAREDCLIPBOARD_OBJ_CF_LOOKUP (0x00000001) +#define SHCL_OBJ_CF_LOOKUP (0x00000001) /** Create/open a directory. */ -#define SHAREDCLIPBOARD_OBJ_CF_DIRECTORY (0x00000004) +#define SHCL_OBJ_CF_DIRECTORY (0x00000004) /** Open/create action to do if object exists @@ -87,55 +87,55 @@ * FILE_EXISTS with NIL handle. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS (0x000000F0) -#define SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW (0x00000F00) +#define SHCL_OBJ_CF_ACT_MASK_IF_EXISTS (0x000000F0) +#define SHCL_OBJ_CF_ACT_MASK_IF_NEW (0x00000F00) /** What to do if object exists. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS (0x00000000) -#define SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS (0x00000010) -#define SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS (0x00000020) -#define SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS (0x00000030) +#define SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS (0x00000000) +#define SHCL_OBJ_CF_ACT_FAIL_IF_EXISTS (0x00000010) +#define SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS (0x00000020) +#define SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS (0x00000030) /** What to do if object does not exist. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW (0x00000000) -#define SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW (0x00000100) +#define SHCL_OBJ_CF_ACT_CREATE_IF_NEW (0x00000000) +#define SHCL_OBJ_CF_ACT_FAIL_IF_NEW (0x00000100) /** Read/write requested access for the object. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_RW (0x00003000) +#define SHCL_OBJ_CF_ACCESS_MASK_RW (0x00003000) /** No access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE (0x00000000) +#define SHCL_OBJ_CF_ACCESS_NONE (0x00000000) /** Read access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ (0x00001000) +#define SHCL_OBJ_CF_ACCESS_READ (0x00001000) /** Write access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE (0x00002000) +#define SHCL_OBJ_CF_ACCESS_WRITE (0x00002000) /** Read/Write access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE (SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ | SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE) +#define SHCL_OBJ_CF_ACCESS_READWRITE (SHCL_OBJ_CF_ACCESS_READ | SHCL_OBJ_CF_ACCESS_WRITE) /** Requested share access for the object. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_DENY (0x0000C000) +#define SHCL_OBJ_CF_ACCESS_MASK_DENY (0x0000C000) /** Allow any access. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE (0x00000000) +#define SHCL_OBJ_CF_ACCESS_DENYNONE (0x00000000) /** Do not allow read. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD (0x00004000) +#define SHCL_OBJ_CF_ACCESS_DENYREAD (0x00004000) /** Do not allow write. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE (0x00008000) +#define SHCL_OBJ_CF_ACCESS_DENYWRITE (0x00008000) /** Do not allow access. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL (SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD | SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE) +#define SHCL_OBJ_CF_ACCESS_DENYALL (SHCL_OBJ_CF_ACCESS_DENYREAD | SHCL_OBJ_CF_ACCESS_DENYWRITE) /** Requested access to attributes of the object. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR (0x00030000) +#define SHCL_OBJ_CF_ACCESS_MASK_ATTR (0x00030000) /** No access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE (0x00000000) +#define SHCL_OBJ_CF_ACCESS_ATTR_NONE (0x00000000) /** Read access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ (0x00010000) +#define SHCL_OBJ_CF_ACCESS_ATTR_READ (0x00010000) /** Write access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE (0x00020000) +#define SHCL_OBJ_CF_ACCESS_ATTR_WRITE (0x00020000) /** Read/Write access requested. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE (SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ | SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE) - -/** The file is opened in append mode. Ignored if SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE is not set. */ -#define SHAREDCLIPBOARD_OBJ_CF_ACCESS_APPEND (0x00040000) +#define SHCL_OBJ_CF_ACCESS_ATTR_READWRITE (SHCL_OBJ_CF_ACCESS_ATTR_READ | SHCL_OBJ_CF_ACCESS_ATTR_WRITE) + +/** The file is opened in append mode. Ignored if SHCL_OBJ_CF_ACCESS_WRITE is not set. */ +#define SHCL_OBJ_CF_ACCESS_APPEND (0x00040000) /** @} */ @@ -146,44 +146,44 @@ * trying to open the object. */ -typedef enum _SHAREDCLIPBOARDCREATERESULT -{ - SHAREDCLIPBOARD_CREATERESULT_NONE, +typedef enum _SHCLCREATERESULT +{ + SHCL_CREATERESULT_NONE, /** Specified path does not exist. */ - SHAREDCLIPBOARD_CREATERESULT_PATH_NOT_FOUND, + SHCL_CREATERESULT_PATH_NOT_FOUND, /** Path to file exists, but the last component does not. */ - SHAREDCLIPBOARD_CREATERESULT_FILE_NOT_FOUND, + SHCL_CREATERESULT_FILE_NOT_FOUND, /** File already exists and either has been opened or not. */ - SHAREDCLIPBOARD_CREATERESULT_FILE_EXISTS, + SHCL_CREATERESULT_FILE_EXISTS, /** New file was created. */ - SHAREDCLIPBOARD_CREATERESULT_FILE_CREATED, + SHCL_CREATERESULT_FILE_CREATED, /** Existing file was replaced or overwritten. */ - SHAREDCLIPBOARD_CREATERESULT_FILE_REPLACED, + SHCL_CREATERESULT_FILE_REPLACED, /** Blow the type up to 32-bit. */ - SHAREDCLIPBOARD_CREATERESULT_32BIT_HACK = 0x7fffffff -} SHAREDCLIPBOARDCREATERESULT; -AssertCompile(SHAREDCLIPBOARD_CREATERESULT_NONE == 0); -AssertCompileSize(SHAREDCLIPBOARDCREATERESULT, 4); - -/** - * The available additional information in a SHAREDCLIPBOARDFSOBJATTR object. - */ -typedef enum _SHAREDCLIPBOARDFSOBJATTRADD + SHCL_CREATERESULT_32BIT_HACK = 0x7fffffff +} SHCLCREATERESULT; +AssertCompile(SHCL_CREATERESULT_NONE == 0); +AssertCompileSize(SHCLCREATERESULT, 4); + +/** + * The available additional information in a SHCLFSOBJATTR object. + */ +typedef enum _SHCLFSOBJATTRADD { /** No additional information is available / requested. */ - SHAREDCLIPBOARDFSOBJATTRADD_NOTHING = 1, - /** The additional unix attributes (SHAREDCLIPBOARDFSOBJATTR::u::Unix) are + SHCLFSOBJATTRADD_NOTHING = 1, + /** The additional unix attributes (SHCLFSOBJATTR::u::Unix) are * available / requested. */ - SHAREDCLIPBOARDFSOBJATTRADD_UNIX, - /** The additional extended attribute size (SHAREDCLIPBOARDFSOBJATTR::u::EASize) is + SHCLFSOBJATTRADD_UNIX, + /** The additional extended attribute size (SHCLFSOBJATTR::u::EASize) is * available / requested. */ - SHAREDCLIPBOARDFSOBJATTRADD_EASIZE, + SHCLFSOBJATTRADD_EASIZE, /** The last valid item (inclusive). - * The valid range is SHAREDCLIPBOARDFSOBJATTRADD_NOTHING thru - * SHAREDCLIPBOARDFSOBJATTRADD_LAST. */ - SHAREDCLIPBOARDFSOBJATTRADD_LAST = SHAREDCLIPBOARDFSOBJATTRADD_EASIZE, + * The valid range is SHCLFSOBJATTRADD_NOTHING thru + * SHCLFSOBJATTRADD_LAST. */ + SHCLFSOBJATTRADD_LAST = SHCLFSOBJATTRADD_EASIZE, /** The usual 32-bit hack. */ - SHAREDCLIPBOARDFSOBJATTRADD_32BIT_SIZE_HACK = 0x7fffffff -} SHAREDCLIPBOARDFSOBJATTRADD; + SHCLFSOBJATTRADD_32BIT_SIZE_HACK = 0x7fffffff +} SHCLFSOBJATTRADD; @@ -200,5 +200,5 @@ */ #pragma pack(1) -typedef struct _SHAREDCLIPBOARDFSOBJATTR +typedef struct _SHCLFSOBJATTR { /** Mode flags (st_mode). RTFS_UNIX_*, RTFS_TYPE_*, and RTFS_DOS_*. @@ -206,8 +206,8 @@ * Fortuntately, these are depending on windows, dos and unix * standard values, so this shouldn't be much of a pain. */ - RTFMODE fMode; + RTFMODE fMode; /** The additional attributes available. */ - SHAREDCLIPBOARDFSOBJATTRADD enmAdditional; + SHCLFSOBJATTRADD enmAdditional; /** @@ -217,10 +217,10 @@ * data as it is provided by the underlying OS. */ - union SHAREDCLIPBOARDFSOBJATTRUNION + union SHCLFSOBJATTRUNION { /** Additional Unix Attributes - * These are available when SHAREDCLIPBOARDFSOBJATTRADD is set in fUnix. + * These are available when SHCLFSOBJATTRADD is set in fUnix. */ - struct SHAREDCLIPBOARDFSOBJATTRUNIX + struct SHCLFSOBJATTRUNIX { /** The user owning the filesystem object (st_uid). @@ -265,5 +265,5 @@ * Extended attribute size. */ - struct SHAREDCLIPBOARDFSOBJATTREASIZE + struct SHCLFSOBJATTREASIZE { /** Size of EAs. */ @@ -271,11 +271,11 @@ } EASize; } u; -} SHAREDCLIPBOARDFSOBJATTR; +} SHCLFSOBJATTR; #pragma pack() -AssertCompileSize(SHAREDCLIPBOARDFSOBJATTR, 44); +AssertCompileSize(SHCLFSOBJATTR, 44); /** Pointer to a shared folder filesystem object attributes structure. */ -typedef SHAREDCLIPBOARDFSOBJATTR *PSHAREDCLIPBOARDFSOBJATTR; +typedef SHCLFSOBJATTR *PSHCLFSOBJATTR; /** Pointer to a const shared folder filesystem object attributes structure. */ -typedef const SHAREDCLIPBOARDFSOBJATTR *PCSHAREDCLIPBOARDFSOBJATTR; +typedef const SHCLFSOBJATTR *PCSHCLFSOBJATTR; /** @@ -283,5 +283,5 @@ */ #pragma pack(1) -typedef struct _SHAREDCLIPBOARDFSOBJINFO +typedef struct _SHCLFSOBJINFO { /** Logical size (st_size). @@ -315,14 +315,14 @@ /** Attributes. */ - SHAREDCLIPBOARDFSOBJATTR Attr; - -} SHAREDCLIPBOARDFSOBJINFO; + SHCLFSOBJATTR Attr; + +} SHCLFSOBJINFO; #pragma pack() -AssertCompileSize(SHAREDCLIPBOARDFSOBJINFO, 92); +AssertCompileSize(SHCLFSOBJINFO, 92); /** Pointer to a shared folder filesystem object information structure. */ -typedef SHAREDCLIPBOARDFSOBJINFO *PSHAREDCLIPBOARDFSOBJINFO; +typedef SHCLFSOBJINFO *PSHCLFSOBJINFO; /** Pointer to a const shared folder filesystem object information * structure. */ -typedef const SHAREDCLIPBOARDFSOBJINFO *PCSHAREDCLIPBOARDFSOBJINFO; +typedef const SHCLFSOBJINFO *PCSHCLFSOBJINFO; #pragma pack(1) @@ -330,5 +330,5 @@ * Structure for keeping object open/create parameters. */ -typedef struct _VBOXCLIPBOARDOBJOPENCREATEPARMS +typedef struct _SHCLOBJOPENCREATEPARMS { /** Path to object to open / create. */ @@ -336,5 +336,5 @@ /** Size (in bytes) of path to to object. */ uint32_t cbPath; - /** SHAREDCLIPBOARD_OBJ_CF_* */ + /** SHCL_OBJ_CF_* */ uint32_t fCreate; /** @@ -342,6 +342,6 @@ * returned actual attributes of opened/created object. */ - SHAREDCLIPBOARDFSOBJINFO ObjInfo; -} VBOXCLIPBOARDOBJOPENCREATEPARMS, *PVBOXCLIPBOARDOBJOPENCREATEPARMS; + SHCLFSOBJINFO ObjInfo; +} SHCLOBJOPENCREATEPARMS, *PSHCLOBJOPENCREATEPARMS; #pragma pack() @@ -349,7 +349,7 @@ * Structure for keeping a reply message. */ -typedef struct _VBOXCLIPBOARDREPLY -{ - /** Message type of type VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_XXX. */ +typedef struct _SHCLREPLY +{ + /** Message type of type VBOX_SHCL_REPLYMSGTYPE_XXX. */ uint32_t uType; /** IPRT result of overall operation. Note: int vs. uint32! */ @@ -359,13 +359,13 @@ struct { - SHAREDCLIPBOARDLISTHANDLE uHandle; + SHCLLISTHANDLE uHandle; } ListOpen; struct { - SHAREDCLIPBOARDOBJHANDLE uHandle; + SHCLOBJHANDLE uHandle; } ObjOpen; struct { - SHAREDCLIPBOARDOBJHANDLE uHandle; + SHCLOBJHANDLE uHandle; } ObjClose; } u; @@ -374,18 +374,18 @@ /** Payload size (in bytes). */ uint32_t cbPayload; -} VBOXCLIPBOARDREPLY, *PVBOXCLIPBOARDREPLY; - -struct _VBOXCLIPBOARDLISTENTRY; -typedef _VBOXCLIPBOARDLISTENTRY VBOXCLIPBOARDLISTENTRY; +} SHCLREPLY, *PSHCLREPLY; + +struct _SHCLLISTENTRY; +typedef _SHCLLISTENTRY SHCLLISTENTRY; /** Defines a single root list entry. Currently the same as a regular list entry. */ -typedef VBOXCLIPBOARDLISTENTRY VBOXCLIPBOARDROOTLISTENTRY; +typedef SHCLLISTENTRY SHCLROOTLISTENTRY; /** Defines a pointer to a single root list entry. Currently the same as a regular list entry pointer. */ -typedef VBOXCLIPBOARDROOTLISTENTRY *PVBOXCLIPBOARDROOTLISTENTRY; +typedef SHCLROOTLISTENTRY *PSHCLROOTLISTENTRY; /** * Structure for keeping Shared Clipboard root list headers. */ -typedef struct _VBOXCLIPBOARDROOTLISTHDR +typedef struct _SHCLROOTLISTHDR { /** Roots listing flags; unused at the moment. */ @@ -393,23 +393,23 @@ /** Number of root list entries. */ uint32_t cRoots; -} VBOXCLIPBOARDROOTLISTHDR, *PVBOXCLIPBOARDROOTLISTHDR; +} SHCLROOTLISTHDR, *PSHCLROOTLISTHDR; /** * Structure for maintaining a Shared Clipboard root list. */ -typedef struct _VBOXCLIPBOARDROOTLIST +typedef struct _SHCLROOTLIST { /** Root list header. */ - VBOXCLIPBOARDROOTLISTHDR Hdr; + SHCLROOTLISTHDR Hdr; /** Root list entries. */ - VBOXCLIPBOARDROOTLISTENTRY *paEntries; -} VBOXCLIPBOARDROOTLIST, *PVBOXCLIPBOARDROOTLIST; + SHCLROOTLISTENTRY *paEntries; +} SHCLROOTLIST, *PSHCLROOTLIST; /** * Structure for maintaining Shared Clipboard list open paramters. */ -typedef struct _VBOXCLIPBOARDLISTOPENPARMS -{ - /** Listing flags (see VBOX_SHAREDCLIPBOARD_LIST_FLAG_XXX). */ +typedef struct _SHCLLISTOPENPARMS +{ + /** Listing flags (see VBOX_SHCL_LIST_FLAG_XXX). */ uint32_t fList; /** Size (in bytes) of the filter string. */ @@ -421,10 +421,10 @@ /** Listing path (absolute). If empty or NULL the listing's root path will be opened. */ char *pszPath; -} VBOXCLIPBOARDLISTOPENPARMS, *PVBOXCLIPBOARDLISTOPENPARMS; +} SHCLLISTOPENPARMS, *PSHCLLISTOPENPARMS; /** * Structure for keeping a Shared Clipboard list header. */ -typedef struct _VBOXCLIPBOARDLISTHDR +typedef struct _SHCLLISTHDR { /** Feature flag(s). Not being used atm. */ @@ -434,10 +434,10 @@ /** Total size (in bytes) returned. */ uint64_t cbTotalSize; -} VBOXCLIPBOARDLISTHDR, *PVBOXCLIPBOARDLISTHDR; +} SHCLLISTHDR, *PSHCLLISTHDR; /** * Structure for a Shared Clipboard list entry. */ -typedef struct _VBOXCLIPBOARDLISTENTRY +typedef struct _SHCLLISTENTRY { /** Entry name. */ @@ -451,24 +451,24 @@ /** Data of the actual list entry. */ void *pvInfo; -} VBOXCLIPBOARDLISTENTRY, *PVBOXCLIPBOARDLISTENTRY; +} SHCLLISTENTRY, *PSHCLLISTENTRY; /** Maximum length (in UTF-8 characters) of a list entry name. */ -#define VBOXCLIPBOARDLISTENTRY_MAX_NAME RTPATH_MAX /** @todo Improve this to be more dynamic. */ +#define SHCLLISTENTRY_MAX_NAME RTPATH_MAX /** @todo Improve this to be more dynamic. */ /** * Structure for maintaining a Shared Clipboard list. */ -typedef struct _VBOXCLIPBOARDLIST +typedef struct _SHCLLIST { /** List header. */ - VBOXCLIPBOARDLISTHDR Hdr; + SHCLLISTHDR Hdr; /** List entries. */ - VBOXCLIPBOARDROOTLISTENTRY *paEntries; -} VBOXCLIPBOARDLIST, *PVBOXCLIPBOARDLIST; + SHCLROOTLISTENTRY *paEntries; +} SHCLLIST, *PSHCLLIST; /** * Structure for keeping a Shared Clipboard object data chunk. */ -typedef struct _VBOXCLIPBOARDOBJDATACHUNK +typedef struct _SHCLOBJDATACHUNK { /** Handle of object this data chunk is related to. */ @@ -478,48 +478,48 @@ /** Size (in bytes) of data chunk. */ uint32_t cbData; -} VBOXCLIPBOARDOBJDATACHUNK, *PVBOXCLIPBOARDOBJDATACHUNK; +} SHCLOBJDATACHUNK, *PSHCLOBJDATACHUNK; /** * Enumeration for specifying a clipboard area object type. */ -typedef enum _SHAREDCLIPBOARDAREAOBJTYPE +typedef enum _SHCLAREAOBJTYPE { /** Unknown object type; do not use. */ - SHAREDCLIPBOARDAREAOBJTYPE_UNKNOWN = 0, + SHCLAREAOBJTYPE_UNKNOWN = 0, /** Object is a directory. */ - SHAREDCLIPBOARDAREAOBJTYPE_DIR, + SHCLAREAOBJTYPE_DIR, /** Object is a file. */ - SHAREDCLIPBOARDAREAOBJTYPE_FILE, + SHCLAREAOBJTYPE_FILE, /** Object is a symbolic link. */ - SHAREDCLIPBOARDAREAOBJTYPE_SYMLINK, + SHCLAREAOBJTYPE_SYMLINK, /** The usual 32-bit hack. */ - SHAREDCLIPBOARDAREAOBJTYPE_32Bit_Hack = 0x7fffffff -} SHAREDCLIPBOARDAREAOBJTYPE; + SHCLAREAOBJTYPE_32Bit_Hack = 0x7fffffff +} SHCLAREAOBJTYPE; /** Clipboard area ID. A valid area is >= 1. * If 0 is specified, the last (most recent) area is meant. * Set to UINT32_MAX if not initialized. */ -typedef uint32_t SHAREDCLIPBOARDAREAID; +typedef uint32_t SHCLAREAID; /** Defines a non-initialized (nil) clipboard area. */ -#define NIL_SHAREDCLIPBOARDAREAID UINT32_MAX +#define NIL_SHCLAREAID UINT32_MAX /** SharedClipboardArea open flags. */ -typedef uint32_t SHAREDCLIPBOARDAREAOPENFLAGS; +typedef uint32_t SHCLAREAOPENFLAGS; /** No clipboard area open flags specified. */ -#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE 0 +#define SHCLAREA_OPEN_FLAGS_NONE 0 /** The clipboard area must not exist yet. */ -#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST RT_BIT(0) +#define SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST RT_BIT(0) /** Mask of all valid clipboard area open flags. */ -#define SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK 0x1 +#define SHCLAREA_OPEN_FLAGS_VALID_MASK 0x1 /** Defines a clipboard area object state. */ -typedef uint32_t SHAREDCLIPBOARDAREAOBJSTATE; +typedef uint32_t SHCLAREAOBJSTATE; /** No object state set. */ -#define SHAREDCLIPBOARDAREAOBJSTATE_NONE 0 +#define SHCLAREAOBJSTATE_NONE 0 /** The object is considered as being complete (e.g. serialized). */ -#define SHAREDCLIPBOARDAREAOBJSTATE_COMPLETE RT_BIT(0) +#define SHCLAREAOBJSTATE_COMPLETE RT_BIT(0) /** @@ -529,9 +529,9 @@ * is too heavy for this purpose. */ -typedef struct _SHAREDCLIPBOARDAREAOBJ -{ - SHAREDCLIPBOARDAREAOBJTYPE enmType; - SHAREDCLIPBOARDAREAOBJSTATE fState; -} SHAREDCLIPBOARDAREAOBJ, *PSHAREDCLIPBOARDAREAOBJ; +typedef struct _SHCLAREAOBJ +{ + SHCLAREAOBJTYPE enmType; + SHCLAREAOBJSTATE fState; +} SHCLAREAOBJ, *PSHCLAREAOBJ; /** @@ -548,6 +548,6 @@ SharedClipboardArea(void); - SharedClipboardArea(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID, - SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE); + SharedClipboardArea(const char *pszPath, SHCLAREAID uID = NIL_SHCLAREAID, + SHCLAREAOPENFLAGS fFlags = SHCLAREA_OPEN_FLAGS_NONE); virtual ~SharedClipboardArea(void); @@ -560,14 +560,14 @@ int Unlock(void); - int AddObject(const char *pszPath, const SHAREDCLIPBOARDAREAOBJ &Obj); - int GetObject(const char *pszPath, PSHAREDCLIPBOARDAREAOBJ pObj); + int AddObject(const char *pszPath, const SHCLAREAOBJ &Obj); + int GetObject(const char *pszPath, PSHCLAREAOBJ pObj); int Close(void); bool IsOpen(void) const; - int OpenEx(const char *pszPath, SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID, - SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE); - int OpenTemp(SHAREDCLIPBOARDAREAID uID = NIL_SHAREDCLIPBOARDAREAID, - SHAREDCLIPBOARDAREAOPENFLAGS fFlags = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE); - SHAREDCLIPBOARDAREAID GetID(void) const; + int OpenEx(const char *pszPath, SHCLAREAID uID = NIL_SHCLAREAID, + SHCLAREAOPENFLAGS fFlags = SHCLAREA_OPEN_FLAGS_NONE); + int OpenTemp(SHCLAREAID uID = NIL_SHCLAREAID, + SHCLAREAOPENFLAGS fFlags = SHCLAREA_OPEN_FLAGS_NONE); + SHCLAREAID GetID(void) const; const char *GetDirAbs(void) const; uint32_t GetRefCount(void); @@ -578,5 +578,5 @@ public: - static int PathConstruct(const char *pszBase, SHAREDCLIPBOARDAREAID uID, char *pszPath, size_t cbPath); + static int PathConstruct(const char *pszBase, SHCLAREAID uID, char *pszPath, size_t cbPath); protected: @@ -588,5 +588,5 @@ protected: - typedef std::map SharedClipboardAreaFsObjMap; + typedef std::map SharedClipboardAreaFsObjMap; /** Creation timestamp (in ms). */ @@ -605,5 +605,5 @@ SharedClipboardAreaFsObjMap m_mapObj; /** Associated clipboard area ID. */ - SHAREDCLIPBOARDAREAID m_uID; + SHCLAREAID m_uID; }; @@ -611,110 +611,110 @@ int SharedClipboardPathSanitize(char *pszPath, size_t cbPath); -PVBOXCLIPBOARDROOTLIST SharedClipboardURIRootListAlloc(void); -void SharedClipboardURIRootListFree(PVBOXCLIPBOARDROOTLIST pRootList); - -PVBOXCLIPBOARDROOTLISTHDR SharedClipboardURIRootListHdrDup(PVBOXCLIPBOARDROOTLISTHDR pRoots); -int SharedClipboardURIRootListHdrInit(PVBOXCLIPBOARDROOTLISTHDR pRoots); -void SharedClipboardURIRootListHdrDestroy(PVBOXCLIPBOARDROOTLISTHDR pRoots); - -int SharedClipboardURIRootListEntryCopy(PVBOXCLIPBOARDROOTLISTENTRY pDst, PVBOXCLIPBOARDROOTLISTENTRY pSrc); -PVBOXCLIPBOARDROOTLISTENTRY SharedClipboardURIRootListEntryDup(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry); -void SharedClipboardURIRootListEntryDestroy(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry); - -int SharedClipboardURIListHdrAlloc(PVBOXCLIPBOARDLISTHDR *ppListHdr); -void SharedClipboardURIListHdrFree(PVBOXCLIPBOARDLISTHDR pListHdr); -PVBOXCLIPBOARDLISTHDR SharedClipboardURIListHdrDup(PVBOXCLIPBOARDLISTHDR pListHdr); -int SharedClipboardURIListHdrInit(PVBOXCLIPBOARDLISTHDR pListHdr); -void SharedClipboardURIListHdrDestroy(PVBOXCLIPBOARDLISTHDR pListHdr); -void SharedClipboardURIListHdrFree(PVBOXCLIPBOARDLISTHDR pListHdr); -void SharedClipboardURIListHdrReset(PVBOXCLIPBOARDLISTHDR pListHdr); -bool SharedClipboardURIListHdrIsValid(PVBOXCLIPBOARDLISTHDR pListHdr); - -int SharedClipboardURIListOpenParmsCopy(PVBOXCLIPBOARDLISTOPENPARMS pDst, PVBOXCLIPBOARDLISTOPENPARMS pSrc); -PVBOXCLIPBOARDLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PVBOXCLIPBOARDLISTOPENPARMS pParms); -int SharedClipboardURIListOpenParmsInit(PVBOXCLIPBOARDLISTOPENPARMS pParms); -void SharedClipboardURIListOpenParmsDestroy(PVBOXCLIPBOARDLISTOPENPARMS pParms); - -int SharedClipboardURIListEntryAlloc(PVBOXCLIPBOARDLISTENTRY *ppListEntry); -void SharedClipboardURIListEntryFree(PVBOXCLIPBOARDLISTENTRY pListEntry); -int SharedClipboardURIListEntryCopy(PVBOXCLIPBOARDLISTENTRY pDst, PVBOXCLIPBOARDLISTENTRY pSrc); -PVBOXCLIPBOARDLISTENTRY SharedClipboardURIListEntryDup(PVBOXCLIPBOARDLISTENTRY pListEntry); -int SharedClipboardURIListEntryInit(PVBOXCLIPBOARDLISTENTRY pListEntry); -void SharedClipboardURIListEntryDestroy(PVBOXCLIPBOARDLISTENTRY pListEntry); -bool SharedClipboardURIListEntryIsValid(PVBOXCLIPBOARDLISTENTRY pListEntry); +PSHCLROOTLIST SharedClipboardURIRootListAlloc(void); +void SharedClipboardURIRootListFree(PSHCLROOTLIST pRootList); + +PSHCLROOTLISTHDR SharedClipboardURIRootListHdrDup(PSHCLROOTLISTHDR pRoots); +int SharedClipboardURIRootListHdrInit(PSHCLROOTLISTHDR pRoots); +void SharedClipboardURIRootListHdrDestroy(PSHCLROOTLISTHDR pRoots); + +int SharedClipboardURIRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc); +PSHCLROOTLISTENTRY SharedClipboardURIRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry); +void SharedClipboardURIRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry); + +int SharedClipboardURIListHdrAlloc(PSHCLLISTHDR *ppListHdr); +void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr); +PSHCLLISTHDR SharedClipboardURIListHdrDup(PSHCLLISTHDR pListHdr); +int SharedClipboardURIListHdrInit(PSHCLLISTHDR pListHdr); +void SharedClipboardURIListHdrDestroy(PSHCLLISTHDR pListHdr); +void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr); +void SharedClipboardURIListHdrReset(PSHCLLISTHDR pListHdr); +bool SharedClipboardURIListHdrIsValid(PSHCLLISTHDR pListHdr); + +int SharedClipboardURIListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc); +PSHCLLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PSHCLLISTOPENPARMS pParms); +int SharedClipboardURIListOpenParmsInit(PSHCLLISTOPENPARMS pParms); +void SharedClipboardURIListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms); + +int SharedClipboardURIListEntryAlloc(PSHCLLISTENTRY *ppListEntry); +void SharedClipboardURIListEntryFree(PSHCLLISTENTRY pListEntry); +int SharedClipboardURIListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc); +PSHCLLISTENTRY SharedClipboardURIListEntryDup(PSHCLLISTENTRY pListEntry); +int SharedClipboardURIListEntryInit(PSHCLLISTENTRY pListEntry); +void SharedClipboardURIListEntryDestroy(PSHCLLISTENTRY pListEntry); +bool SharedClipboardURIListEntryIsValid(PSHCLLISTENTRY pListEntry); /** * Enumeration specifying an URI transfer direction. */ -typedef enum _SHAREDCLIPBOARDURITRANSFERDIR +typedef enum _SHCLURITRANSFERDIR { /** Unknown transfer directory. */ - SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN = 0, + SHCLURITRANSFERDIR_UNKNOWN = 0, /** Read transfer (from source). */ - SHAREDCLIPBOARDURITRANSFERDIR_READ, + SHCLURITRANSFERDIR_READ, /** Write transfer (to target). */ - SHAREDCLIPBOARDURITRANSFERDIR_WRITE, + SHCLURITRANSFERDIR_WRITE, /** The usual 32-bit hack. */ - SHAREDCLIPBOARDURITRANSFERDIR_32BIT_HACK = 0x7fffffff -} SHAREDCLIPBOARDURITRANSFERDIR; - -struct _SHAREDCLIPBOARDURITRANSFER; -typedef struct _SHAREDCLIPBOARDURITRANSFER SHAREDCLIPBOARDURITRANSFER; + SHCLURITRANSFERDIR_32BIT_HACK = 0x7fffffff +} SHCLURITRANSFERDIR; + +struct _SHCLURITRANSFER; +typedef struct _SHCLURITRANSFER SHCLURITRANSFER; /** * Structure for handling a single URI object context. */ -typedef struct _SHAREDCLIPBOARDCLIENTURIOBJCTX -{ - SHAREDCLIPBOARDURITRANSFER *pTransfer; - SHAREDCLIPBOARDOBJHANDLE uHandle; -} SHAREDCLIPBOARDCLIENTURIOBJCTX, *PSHAREDCLIPBOARDCLIENTURIOBJCTX; - -typedef struct _SHAREDCLIPBOARDURITRANSFEROBJSTATE +typedef struct _SHCLCLIENTURIOBJCTX +{ + SHCLURITRANSFER *pTransfer; + SHCLOBJHANDLE uHandle; +} SHCLCLIENTURIOBJCTX, *PSHCLCLIENTURIOBJCTX; + +typedef struct _SHCLURITRANSFEROBJSTATE { uint64_t cbProcessed; -} SHAREDCLIPBOARDURITRANSFEROBJSTATE, *PSHAREDCLIPBOARDURITRANSFEROBJSTATE; - -typedef struct _SHAREDCLIPBOARDURITRANSFEROBJ -{ - SHAREDCLIPBOARDOBJHANDLE uHandle; +} SHCLURITRANSFEROBJSTATE, *PSHCLURITRANSFEROBJSTATE; + +typedef struct _SHCLURITRANSFEROBJ +{ + SHCLOBJHANDLE uHandle; char *pszPathAbs; - SHAREDCLIPBOARDFSOBJINFO objInfo; - SHAREDCLIPBOARDSOURCE enmSource; - SHAREDCLIPBOARDURITRANSFEROBJSTATE State; -} SHAREDCLIPBOARDURITRANSFEROBJ, *PSHAREDCLIPBOARDURITRANSFEROBJ; + SHCLFSOBJINFO objInfo; + SHCLSOURCE enmSource; + SHCLURITRANSFEROBJSTATE State; +} SHCLURITRANSFEROBJ, *PSHCLURITRANSFEROBJ; /** No status set. */ -#define SHAREDCLIPBOARDURITRANSFERSTATUS_NONE 0 +#define SHCLURITRANSFERSTATUS_NONE 0 /** The transfer has been announced but is not running yet. */ -#define SHAREDCLIPBOARDURITRANSFERSTATUS_READY 1 +#define SHCLURITRANSFERSTATUS_READY 1 /** The transfer is active and running. */ -#define SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING 2 +#define SHCLURITRANSFERSTATUS_RUNNING 2 /** The transfer has been completed. */ -#define SHAREDCLIPBOARDURITRANSFERSTATUS_COMPLETED 3 +#define SHCLURITRANSFERSTATUS_COMPLETED 3 /** The transfer has been canceled. */ -#define SHAREDCLIPBOARDURITRANSFERSTATUS_CANCELED 4 +#define SHCLURITRANSFERSTATUS_CANCELED 4 /** The transfer ran into an unrecoverable error. */ -#define SHAREDCLIPBOARDURITRANSFERSTATUS_ERROR 5 +#define SHCLURITRANSFERSTATUS_ERROR 5 /** Defines a transfer status. */ -typedef uint32_t SHAREDCLIPBOARDURITRANSFERSTATUS; +typedef uint32_t SHCLURITRANSFERSTATUS; /** * Enumeration for specifying a Shared Clipboard object type. */ -typedef enum _SHAREDCLIPBOARDURIOBJTYPE +typedef enum _SHCLURIOBJTYPE { /** Invalid object type. */ - SHAREDCLIPBOARDURIOBJTYPE_INVALID = 0, + SHCLURIOBJTYPE_INVALID = 0, /** Object is a directory. */ - SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY, + SHCLURIOBJTYPE_DIRECTORY, /** Object is a file. */ - SHAREDCLIPBOARDURIOBJTYPE_FILE, + SHCLURIOBJTYPE_FILE, /** Object is a symbolic link. */ - SHAREDCLIPBOARDURIOBJTYPE_SYMLINK, + SHCLURIOBJTYPE_SYMLINK, /** The usual 32-bit hack. */ - SHAREDCLIPBOARDURIOBJTYPE_32BIT_SIZE_HACK = 0x7fffffff -} SHAREDCLIPBOARDURIOBJTYPE; + SHCLURIOBJTYPE_32BIT_SIZE_HACK = 0x7fffffff +} SHCLURIOBJTYPE; /** @@ -722,12 +722,12 @@ * This is using to map own (local) handles to the underlying file system. */ -typedef struct _SHAREDCLIPBOARDURILISTHANDLEINFO +typedef struct _SHCLURILISTHANDLEINFO { /** The list node. */ RTLISTNODE Node; /** The list's handle. */ - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; /** Type of list handle. */ - SHAREDCLIPBOARDURIOBJTYPE enmType; + SHCLURIOBJTYPE enmType; /** Absolute local path of the list object. */ char *pszPathLocalAbs; @@ -744,5 +744,5 @@ } Local; } u; -} SHAREDCLIPBOARDURILISTHANDLEINFO, *PSHAREDCLIPBOARDURILISTHANDLEINFO; +} SHCLURILISTHANDLEINFO, *PSHCLURILISTHANDLEINFO; /** @@ -750,12 +750,12 @@ * This is using to map own (local) handles to the underlying file system. */ -typedef struct _SHAREDCLIPBOARDURIOBJHANDLEINFO +typedef struct _SHCLURIOBJHANDLEINFO { /** The list node. */ RTLISTNODE Node; /** The object's handle. */ - SHAREDCLIPBOARDOBJHANDLE hObj; + SHCLOBJHANDLE hObj; /** Type of object handle. */ - SHAREDCLIPBOARDURIOBJTYPE enmType; + SHCLURIOBJTYPE enmType; /** Absolute local path of the object. */ char *pszPathLocalAbs; @@ -772,10 +772,10 @@ } Local; } u; -} SHAREDCLIPBOARDURIOBJHANDLEINFO, *PSHAREDCLIPBOARDURIOBJHANDLEINFO; +} SHCLURIOBJHANDLEINFO, *PSHCLURIOBJHANDLEINFO; /** * Structure for keeping a single root list entry. */ -typedef struct _SHAREDCLIPBOARDURILISTROOT +typedef struct _SHCLURILISTROOT { /** The list node. */ @@ -783,5 +783,5 @@ /** Absolute path of entry. */ char *pszPathAbs; -} SHAREDCLIPBOARDURILISTROOT, *PSHAREDCLIPBOARDURILISTROOT; +} SHCLURILISTROOT, *PSHCLURILISTROOT; /** @@ -789,18 +789,18 @@ * Everything in here will be part of a saved state (later). */ -typedef struct _SHAREDCLIPBOARDURITRANSFERSTATE +typedef struct _SHCLURITRANSFERSTATE { /** The transfer's (local) ID. */ uint16_t uID; /** The transfer's current status. */ - SHAREDCLIPBOARDURITRANSFERSTATUS enmStatus; + SHCLURITRANSFERSTATUS enmStatus; /** The transfer's direction. */ - SHAREDCLIPBOARDURITRANSFERDIR enmDir; + SHCLURITRANSFERDIR enmDir; /** The transfer's source. */ - SHAREDCLIPBOARDSOURCE enmSource; -} SHAREDCLIPBOARDURITRANSFERSTATE, *PSHAREDCLIPBOARDURITRANSFERSTATE; - -struct _SHAREDCLIPBOARDURITRANSFER; -typedef struct _SHAREDCLIPBOARDURITRANSFER *PSHAREDCLIPBOARDURITRANSFER; + SHCLSOURCE enmSource; +} SHCLURITRANSFERSTATE, *PSHCLURITRANSFERSTATE; + +struct _SHCLURITRANSFER; +typedef struct _SHCLURITRANSFER *PSHCLURITRANSFER; /** @@ -808,110 +808,110 @@ * This is handed in to the provider implementation callbacks. */ - typedef struct _SHAREDCLIPBOARDPROVIDERCTX + typedef struct _SHCLPROVIDERCTX { /** Pointer to the related URI transfer. */ - PSHAREDCLIPBOARDURITRANSFER pTransfer; + PSHCLURITRANSFER pTransfer; /** User-defined data pointer. Can be NULL if not needed. */ void *pvUser; -} SHAREDCLIPBOARDPROVIDERCTX, *PSHAREDCLIPBOARDPROVIDERCTX; +} SHCLPROVIDERCTX, *PSHCLPROVIDERCTX; /** Defines an URI clipboard provider function declaration with additional parameters. */ -#define SHAREDCLIPBOARDPROVIDERFUNCDECL(a_Name, ...) \ - typedef DECLCALLBACK(int) RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name)(PSHAREDCLIPBOARDPROVIDERCTX, __VA_ARGS__); \ - typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name); +#define SHCLPROVIDERFUNCDECL(a_Name, ...) \ + typedef DECLCALLBACK(int) RT_CONCAT(FNSHCLPROVIDER, a_Name)(PSHCLPROVIDERCTX, __VA_ARGS__); \ + typedef RT_CONCAT(FNSHCLPROVIDER, a_Name) RT_CONCAT(*PFNSHCLPROVIDER, a_Name); /** Defines an URI clipboard provider function declaration with additional parameters. */ -#define SHAREDCLIPBOARDPROVIDERFUNCDECLRET(a_Ret, a_Name, ...) \ - typedef DECLCALLBACK(a_Ret) RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name)(PSHAREDCLIPBOARDPROVIDERCTX, __VA_ARGS__); \ - typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name); +#define SHCLPROVIDERFUNCDECLRET(a_Ret, a_Name, ...) \ + typedef DECLCALLBACK(a_Ret) RT_CONCAT(FNSHCLPROVIDER, a_Name)(PSHCLPROVIDERCTX, __VA_ARGS__); \ + typedef RT_CONCAT(FNSHCLPROVIDER, a_Name) RT_CONCAT(*PFNSHCLPROVIDER, a_Name); /** Defines an URI clipboard provider function declaration (no additional parameters). */ -#define SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(a_Name) \ - typedef DECLCALLBACK(int) RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name)(PSHAREDCLIPBOARDPROVIDERCTX); \ - typedef RT_CONCAT(FNSHAREDCLIPBOARDPROVIDER, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDPROVIDER, a_Name); +#define SHCLPROVIDERFUNCDECLVOID(a_Name) \ + typedef DECLCALLBACK(int) RT_CONCAT(FNSHCLPROVIDER, a_Name)(PSHCLPROVIDERCTX); \ + typedef RT_CONCAT(FNSHCLPROVIDER, a_Name) RT_CONCAT(*PFNSHCLPROVIDER, a_Name); /** Declares a URI clipboard provider function member. */ -#define SHAREDCLIPBOARDPROVIDERFUNCMEMBER(a_Name, a_Member) \ - RT_CONCAT(PFNSHAREDCLIPBOARDPROVIDER, a_Name) a_Member; - -SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFEROPEN) -SHAREDCLIPBOARDPROVIDERFUNCDECLVOID(TRANSFERCLOSE) -SHAREDCLIPBOARDPROVIDERFUNCDECL(GETROOTS, PVBOXCLIPBOARDROOTLIST *ppRootList) -SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTOPEN, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList) -SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTCLOSE, SHAREDCLIPBOARDLISTHANDLE hList) -SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRREAD, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr) -SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTHDRWRITE, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr) -SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYREAD, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry) -SHAREDCLIPBOARDPROVIDERFUNCDECL(LISTENTRYWRITE, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pEntry) -SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJOPEN, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj) -SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJCLOSE, SHAREDCLIPBOARDOBJHANDLE hObj) -SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJREAD, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead) -SHAREDCLIPBOARDPROVIDERFUNCDECL(OBJWRITE, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten) +#define SHCLPROVIDERFUNCMEMBER(a_Name, a_Member) \ + RT_CONCAT(PFNSHCLPROVIDER, a_Name) a_Member; + +SHCLPROVIDERFUNCDECLVOID(TRANSFEROPEN) +SHCLPROVIDERFUNCDECLVOID(TRANSFERCLOSE) +SHCLPROVIDERFUNCDECL(GETROOTS, PSHCLROOTLIST *ppRootList) +SHCLPROVIDERFUNCDECL(LISTOPEN, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList) +SHCLPROVIDERFUNCDECL(LISTCLOSE, SHCLLISTHANDLE hList) +SHCLPROVIDERFUNCDECL(LISTHDRREAD, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) +SHCLPROVIDERFUNCDECL(LISTHDRWRITE, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) +SHCLPROVIDERFUNCDECL(LISTENTRYREAD, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry) +SHCLPROVIDERFUNCDECL(LISTENTRYWRITE, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry) +SHCLPROVIDERFUNCDECL(OBJOPEN, PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj) +SHCLPROVIDERFUNCDECL(OBJCLOSE, SHCLOBJHANDLE hObj) +SHCLPROVIDERFUNCDECL(OBJREAD, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead) +SHCLPROVIDERFUNCDECL(OBJWRITE, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten) /** * Shared Clipboard URI provider interface table. */ -typedef struct _SHAREDCLIPBOARDPROVIDERINTERFACE -{ - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFEROPEN, pfnTransferOpen) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(TRANSFERCLOSE, pfnTransferClose) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(GETROOTS, pfnGetRoots) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTOPEN, pfnListOpen) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTCLOSE, pfnListClose) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRREAD, pfnListHdrRead) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTHDRWRITE, pfnListHdrWrite) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTENTRYREAD, pfnListEntryRead) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(LISTENTRYWRITE, pfnListEntryWrite) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJOPEN, pfnObjOpen) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJCLOSE, pfnObjClose) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJREAD, pfnObjRead) - SHAREDCLIPBOARDPROVIDERFUNCMEMBER(OBJWRITE, pfnObjWrite) -} SHAREDCLIPBOARDPROVIDERINTERFACE, *PSHAREDCLIPBOARDPROVIDERINTERFACE; +typedef struct _SHCLPROVIDERINTERFACE +{ + SHCLPROVIDERFUNCMEMBER(TRANSFEROPEN, pfnTransferOpen) + SHCLPROVIDERFUNCMEMBER(TRANSFERCLOSE, pfnTransferClose) + SHCLPROVIDERFUNCMEMBER(GETROOTS, pfnGetRoots) + SHCLPROVIDERFUNCMEMBER(LISTOPEN, pfnListOpen) + SHCLPROVIDERFUNCMEMBER(LISTCLOSE, pfnListClose) + SHCLPROVIDERFUNCMEMBER(LISTHDRREAD, pfnListHdrRead) + SHCLPROVIDERFUNCMEMBER(LISTHDRWRITE, pfnListHdrWrite) + SHCLPROVIDERFUNCMEMBER(LISTENTRYREAD, pfnListEntryRead) + SHCLPROVIDERFUNCMEMBER(LISTENTRYWRITE, pfnListEntryWrite) + SHCLPROVIDERFUNCMEMBER(OBJOPEN, pfnObjOpen) + SHCLPROVIDERFUNCMEMBER(OBJCLOSE, pfnObjClose) + SHCLPROVIDERFUNCMEMBER(OBJREAD, pfnObjRead) + SHCLPROVIDERFUNCMEMBER(OBJWRITE, pfnObjWrite) +} SHCLPROVIDERINTERFACE, *PSHCLPROVIDERINTERFACE; /** * Structure for the Shared Clipboard provider creation context. */ -typedef struct _SHAREDCLIPBOARDPROVIDERCREATIONCTX +typedef struct _SHCLPROVIDERCREATIONCTX { /** Specifies what the source of the provider is. */ - SHAREDCLIPBOARDSOURCE enmSource; + SHCLSOURCE enmSource; /** The provider interface table. */ - SHAREDCLIPBOARDPROVIDERINTERFACE Interface; + SHCLPROVIDERINTERFACE Interface; /** Provider callback data. */ void *pvUser; -} SHAREDCLIPBOARDPROVIDERCREATIONCTX, *PSHAREDCLIPBOARDPROVIDERCREATIONCTX; - -struct _SHAREDCLIPBOARDURITRANSFER; -typedef _SHAREDCLIPBOARDURITRANSFER *PSHAREDCLIPBOARDURITRANSFER; +} SHCLPROVIDERCREATIONCTX, *PSHCLPROVIDERCREATIONCTX; + +struct _SHCLURITRANSFER; +typedef _SHCLURITRANSFER *PSHCLURITRANSFER; /** * Structure for storing URI transfer callback data. */ -typedef struct _SHAREDCLIPBOARDURITRANSFERCALLBACKDATA +typedef struct _SHCLURITRANSFERCALLBACKDATA { /** Pointer to related URI transfer. */ - PSHAREDCLIPBOARDURITRANSFER pTransfer; + PSHCLURITRANSFER pTransfer; /** Saved user pointer. */ void *pvUser; -} SHAREDCLIPBOARDURITRANSFERCALLBACKDATA, *PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA; - -#define SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(a_Name) \ - typedef DECLCALLBACK(void) RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name)(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData); \ - typedef RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDCALLBACK, a_Name); - -#define SHAREDCLIPBOARDTRANSFERCALLBACKDECL(a_Name, ...) \ - typedef DECLCALLBACK(void) RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name)(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, __VA_ARGS__); \ - typedef RT_CONCAT(FNSHAREDCLIPBOARDCALLBACK, a_Name) RT_CONCAT(*PFNSHAREDCLIPBOARDCALLBACK, a_Name); - -#define SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(a_Name, a_Member) \ - RT_CONCAT(PFNSHAREDCLIPBOARDCALLBACK, a_Name) a_Member; - -SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(TRANSFERPREPARE) -SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(TRANSFERSTARTED) -SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(LISTHEADERCOMPLETE) -SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(LISTENTRYCOMPLETE) -SHAREDCLIPBOARDTRANSFERCALLBACKDECL (TRANSFERCOMPLETE, int rc) -SHAREDCLIPBOARDTRANSFERCALLBACKDECLVOID(TRANSFERCANCELED) -SHAREDCLIPBOARDTRANSFERCALLBACKDECL (TRANSFERERROR, int rc) +} SHCLURITRANSFERCALLBACKDATA, *PSHCLURITRANSFERCALLBACKDATA; + +#define SHCLTRANSFERCALLBACKDECLVOID(a_Name) \ + typedef DECLCALLBACK(void) RT_CONCAT(FNSHCLCALLBACK, a_Name)(PSHCLURITRANSFERCALLBACKDATA pData); \ + typedef RT_CONCAT(FNSHCLCALLBACK, a_Name) RT_CONCAT(*PFNSHCLCALLBACK, a_Name); + +#define SHCLTRANSFERCALLBACKDECL(a_Name, ...) \ + typedef DECLCALLBACK(void) RT_CONCAT(FNSHCLCALLBACK, a_Name)(PSHCLURITRANSFERCALLBACKDATA pData, __VA_ARGS__); \ + typedef RT_CONCAT(FNSHCLCALLBACK, a_Name) RT_CONCAT(*PFNSHCLCALLBACK, a_Name); + +#define SHCLTRANSFERCALLBACKMEMBER(a_Name, a_Member) \ + RT_CONCAT(PFNSHCLCALLBACK, a_Name) a_Member; + +SHCLTRANSFERCALLBACKDECLVOID(TRANSFERPREPARE) +SHCLTRANSFERCALLBACKDECLVOID(TRANSFERSTARTED) +SHCLTRANSFERCALLBACKDECLVOID(LISTHEADERCOMPLETE) +SHCLTRANSFERCALLBACKDECLVOID(LISTENTRYCOMPLETE) +SHCLTRANSFERCALLBACKDECL (TRANSFERCOMPLETE, int rc) +SHCLTRANSFERCALLBACKDECLVOID(TRANSFERCANCELED) +SHCLTRANSFERCALLBACKDECL (TRANSFERERROR, int rc) /** @@ -919,28 +919,28 @@ * All callbacks are optional and therefore can be NULL. */ -typedef struct _SHAREDCLIPBOARDURITRANSFERCALLBACKS +typedef struct _SHCLURITRANSFERCALLBACKS { /** Saved user pointer. */ void *pvUser; /** Function pointer, called when the transfer is going to be prepared. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERPREPARE, pfnTransferPrepare) + SHCLTRANSFERCALLBACKMEMBER(TRANSFERPREPARE, pfnTransferPrepare) /** Function pointer, called when the transfer has been started. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERSTARTED, pfnTransferStarted) + SHCLTRANSFERCALLBACKMEMBER(TRANSFERSTARTED, pfnTransferStarted) /** Function pointer, called when reading / writing the list header is complete. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(LISTHEADERCOMPLETE, pfnListHeaderComplete) + SHCLTRANSFERCALLBACKMEMBER(LISTHEADERCOMPLETE, pfnListHeaderComplete) /** Function pointer, called when reading / writing a list entry is complete. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(LISTENTRYCOMPLETE, pfnListEntryComplete) + SHCLTRANSFERCALLBACKMEMBER(LISTENTRYCOMPLETE, pfnListEntryComplete) /** Function pointer, called when the transfer is complete. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCOMPLETE, pfnTransferComplete) + SHCLTRANSFERCALLBACKMEMBER(TRANSFERCOMPLETE, pfnTransferComplete) /** Function pointer, called when the transfer has been canceled. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERCANCELED, pfnTransferCanceled) + SHCLTRANSFERCALLBACKMEMBER(TRANSFERCANCELED, pfnTransferCanceled) /** Function pointer, called when transfer resulted in an unrecoverable error. */ - SHAREDCLIPBOARDTRANSFERCALLBACKMEMBER(TRANSFERERROR, pfnTransferError) -} SHAREDCLIPBOARDURITRANSFERCALLBACKS, *PSHAREDCLIPBOARDURITRANSFERCALLBACKS; + SHCLTRANSFERCALLBACKMEMBER(TRANSFERERROR, pfnTransferError) +} SHCLURITRANSFERCALLBACKS, *PSHCLURITRANSFERCALLBACKS; /** * Structure for thread-related members for a single URI transfer. */ -typedef struct _SHAREDCLIPBOARDURITRANSFERTHREAD +typedef struct _SHCLURITRANSFERTHREAD { /** Thread handle for the reading / writing thread. @@ -953,5 +953,5 @@ /** Thread cancelled flag / indicator. */ volatile bool fCancelled; -} SHAREDCLIPBOARDURITRANSFERTHREAD, *PSHAREDCLIPBOARDURITRANSFERTHREAD; +} SHCLURITRANSFERTHREAD, *PSHCLURITRANSFERTHREAD; /** @@ -960,5 +960,5 @@ ** @todo Not yet thread safe. */ -typedef struct _SHAREDCLIPBOARDURITRANSFER +typedef struct _SHCLURITRANSFER { /** The node member for using this struct in a RTList. */ @@ -967,5 +967,5 @@ RTCRITSECT CritSect; /** The transfer's state (for SSM, later). */ - SHAREDCLIPBOARDURITRANSFERSTATE State; + SHCLURITRANSFERSTATE State; /** Timeout (in ms) for waiting of events. Default is 30s. */ RTMSINTERVAL uTimeoutMs; @@ -975,7 +975,7 @@ uint32_t cbMaxChunkSize; /** The transfer's own event source. */ - SHAREDCLIPBOARDEVENTSOURCE Events; + SHCLEVENTSOURCE Events; /** Next upcoming list handle. */ - SHAREDCLIPBOARDLISTHANDLE uListHandleNext; + SHCLLISTHANDLE uListHandleNext; /** List of all list handles elated to this transfer. */ RTLISTANCHOR lstList; @@ -985,5 +985,5 @@ RTLISTANCHOR lstRoots; /** Next upcoming object handle. */ - SHAREDCLIPBOARDOBJHANDLE uObjHandleNext; + SHCLOBJHANDLE uObjHandleNext; /** Map of all objects handles related to this transfer. */ RTLISTANCHOR lstObj; @@ -992,9 +992,9 @@ * On the host this area ID gets shared (maintained / locked) across all VMs via VBoxSVC. */ SharedClipboardArea *pArea; - SHAREDCLIPBOARDPROVIDERCTX ProviderCtx; + SHCLPROVIDERCTX ProviderCtx; /** The transfer's provider interface. */ - SHAREDCLIPBOARDPROVIDERINTERFACE ProviderIface; + SHCLPROVIDERINTERFACE ProviderIface; /** The transfer's (optional) callback table. */ - SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks; + SHCLURITRANSFERCALLBACKS Callbacks; /** Opaque pointer to implementation-specific parameters. */ void *pvUser; @@ -1002,11 +1002,11 @@ size_t cbUser; /** Contains thread-related attributes. */ - SHAREDCLIPBOARDURITRANSFERTHREAD Thread; -} SHAREDCLIPBOARDURITRANSFER, *PSHAREDCLIPBOARDURITRANSFER; + SHCLURITRANSFERTHREAD Thread; +} SHCLURITRANSFER, *PSHCLURITRANSFER; /** * Structure for keeping URI clipboard information around. */ -typedef struct _SHAREDCLIPBOARDURICTX +typedef struct _SHCLURICTX { /** Critical section for serializing access. */ @@ -1022,80 +1022,80 @@ /** Number of total transfers (in list). */ uint32_t cTransfers; -} SHAREDCLIPBOARDURICTX, *PSHAREDCLIPBOARDURICTX; - -int SharedClipboardURIObjCtxInit(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx); -void SharedClipboardURIObjCtxDestroy(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx); -bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx); - -int SharedClipboardURIObjectOpenParmsInit(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms); -int SharedClipboardURIObjectOpenParmsCopy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsDst, PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsSrc); -void SharedClipboardURIObjectOpenParmsDestroy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms); - -int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms, - PSHAREDCLIPBOARDOBJHANDLE phObj); -int SharedClipboardURIObjectClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj); -int SharedClipboardURIObjectRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags); -int SharedClipboardURIObjectWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags); - -PVBOXCLIPBOARDOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk); -void SharedClipboardURIObjectDataChunkDestroy(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk); -void SharedClipboardURIObjectDataChunkFree(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk); - -int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource, - PSHAREDCLIPBOARDURITRANSFER *ppTransfer); -int SharedClipboardURITransferDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer); - -int SharedClipboardURITransferOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURITransferClose(PSHAREDCLIPBOARDURITRANSFER pTransfer); - -int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, - PSHAREDCLIPBOARDLISTHANDLE phList); -int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList); -int SharedClipboardURITransferListGetHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pHdr); -PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx); -int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pEntry); -int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pEntry); -bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList); - -int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer, - PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx); -int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots); -void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer); -SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer); - -uint32_t SharedClipboardURILTransferRootsCount(PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry); -int SharedClipboardURILTransferRootsAsList(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDROOTLIST *ppRootList); - -SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer); -SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURITransferHandleReply(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDREPLY pReply); -int SharedClipboardURITransferRun(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser); -void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer, - PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks); - -int SharedClipboardURITransferRead(PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURITransferReadObjects(PSHAREDCLIPBOARDURITRANSFER pTransfer); - -int SharedClipboardURITransferWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURITransferWriteObjects(PSHAREDCLIPBOARDURITRANSFER pTransfer); - -int SharedClipboardURICtxInit(PSHAREDCLIPBOARDURICTX pURI); -void SharedClipboardURICtxDestroy(PSHAREDCLIPBOARDURICTX pURI); -void SharedClipboardURICtxReset(PSHAREDCLIPBOARDURICTX pURI); -PSHAREDCLIPBOARDURITRANSFER SharedClipboardURICtxGetTransfer(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx); -uint32_t SharedClipboardURICtxGetRunningTransfers(PSHAREDCLIPBOARDURICTX pURI); -uint32_t SharedClipboardURICtxGetTotalTransfers(PSHAREDCLIPBOARDURICTX pURI); -void SharedClipboardURICtxTransfersCleanup(PSHAREDCLIPBOARDURICTX pURI); -bool SharedClipboardURICtxTransfersMaximumReached(PSHAREDCLIPBOARDURICTX pURI); -int SharedClipboardURICtxTransferAdd(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer); -int SharedClipboardURICtxTransferRemove(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer); - -void SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO pDst, PCRTFSOBJINFO pSrc); +} SHCLURICTX, *PSHCLURICTX; + +int SharedClipboardURIObjCtxInit(PSHCLCLIENTURIOBJCTX pObjCtx); +void SharedClipboardURIObjCtxDestroy(PSHCLCLIENTURIOBJCTX pObjCtx); +bool SharedClipboardURIObjCtxIsValid(PSHCLCLIENTURIOBJCTX pObjCtx); + +int SharedClipboardURIObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms); +int SharedClipboardURIObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc); +void SharedClipboardURIObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms); + +int SharedClipboardURIObjectOpen(PSHCLURITRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, + PSHCLOBJHANDLE phObj); +int SharedClipboardURIObjectClose(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj); +int SharedClipboardURIObjectRead(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags); +int SharedClipboardURIObjectWrite(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags); + +PSHCLOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk); +void SharedClipboardURIObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk); +void SharedClipboardURIObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk); + +int SharedClipboardURITransferCreate(SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, + PSHCLURITRANSFER *ppTransfer); +int SharedClipboardURITransferDestroy(PSHCLURITRANSFER pTransfer); + +int SharedClipboardURITransferOpen(PSHCLURITRANSFER pTransfer); +int SharedClipboardURITransferClose(PSHCLURITRANSFER pTransfer); + +int SharedClipboardURITransferListOpen(PSHCLURITRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, + PSHCLLISTHANDLE phList); +int SharedClipboardURITransferListClose(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList); +int SharedClipboardURITransferListGetHeader(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTHDR pHdr); +PSHCLURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHCLURITRANSFER pTransfer, + SHCLLISTHANDLE hList, uint64_t uIdx); +int SharedClipboardURITransferListRead(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pEntry); +int SharedClipboardURITransferListWrite(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pEntry); +bool SharedClipboardURITransferListHandleIsValid(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList); + +int SharedClipboardURITransferPrepare(PSHCLURITRANSFER pTransfer); +int SharedClipboardURITransferSetInterface(PSHCLURITRANSFER pTransfer, + PSHCLPROVIDERCREATIONCTX pCreationCtx); +int SharedClipboardURILTransferSetRoots(PSHCLURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots); +void SharedClipboardURITransferReset(PSHCLURITRANSFER pTransfer); +SharedClipboardArea *SharedClipboardURITransferGetArea(PSHCLURITRANSFER pTransfer); + +uint32_t SharedClipboardURILTransferRootsCount(PSHCLURITRANSFER pTransfer); +int SharedClipboardURILTransferRootsEntry(PSHCLURITRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry); +int SharedClipboardURILTransferRootsAsList(PSHCLURITRANSFER pTransfer, PSHCLROOTLIST *ppRootList); + +SHCLSOURCE SharedClipboardURITransferGetSource(PSHCLURITRANSFER pTransfer); +SHCLURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHCLURITRANSFER pTransfer); +int SharedClipboardURITransferHandleReply(PSHCLURITRANSFER pTransfer, PSHCLREPLY pReply); +int SharedClipboardURITransferRun(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser); +void SharedClipboardURITransferSetCallbacks(PSHCLURITRANSFER pTransfer, + PSHCLURITRANSFERCALLBACKS pCallbacks); + +int SharedClipboardURITransferRead(PSHCLURITRANSFER pTransfer); +int SharedClipboardURITransferReadObjects(PSHCLURITRANSFER pTransfer); + +int SharedClipboardURITransferWrite(PSHCLURITRANSFER pTransfer); +int SharedClipboardURITransferWriteObjects(PSHCLURITRANSFER pTransfer); + +int SharedClipboardURICtxInit(PSHCLURICTX pURI); +void SharedClipboardURICtxDestroy(PSHCLURICTX pURI); +void SharedClipboardURICtxReset(PSHCLURICTX pURI); +PSHCLURITRANSFER SharedClipboardURICtxGetTransfer(PSHCLURICTX pURI, uint32_t uIdx); +uint32_t SharedClipboardURICtxGetRunningTransfers(PSHCLURICTX pURI); +uint32_t SharedClipboardURICtxGetTotalTransfers(PSHCLURICTX pURI); +void SharedClipboardURICtxTransfersCleanup(PSHCLURICTX pURI); +bool SharedClipboardURICtxTransfersMaximumReached(PSHCLURICTX pURI); +int SharedClipboardURICtxTransferAdd(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer); +int SharedClipboardURICtxTransferRemove(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer); + +void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc); bool SharedClipboardMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax); Index: /trunk/include/VBox/GuestHost/SharedClipboard-win.h =================================================================== --- /trunk/include/VBox/GuestHost/SharedClipboard-win.h (revision 80661) +++ /trunk/include/VBox/GuestHost/SharedClipboard-win.h (revision 80662) @@ -83,14 +83,14 @@ * If the new API is not available, those function pointer are NULL. */ -typedef struct _VBOXCLIPBOARDWINAPINEW +typedef struct _SHCLWINAPINEW { PFNADDCLIPBOARDFORMATLISTENER pfnAddClipboardFormatListener; PFNREMOVECLIPBOARDFORMATLISTENER pfnRemoveClipboardFormatListener; -} VBOXCLIPBOARDWINAPINEW, *PVBOXCLIPBOARDWINAPINEW; +} SHCLWINAPINEW, *PSHCLWINAPINEW; /** * Structure for keeping variables which are needed to drive the old clipboard API. */ -typedef struct _VBOXCLIPBOARDWINAPIOLD +typedef struct _SHCLWINAPIOLD { /** Timer ID for the refresh timer. */ @@ -98,10 +98,10 @@ /** Whether "pinging" the clipboard chain currently is in progress or not. */ bool fCBChainPingInProcess; -} VBOXCLIPBOARDWINAPIOLD, *PVBOXCLIPBOARDWINAPIOLD; +} SHCLWINAPIOLD, *PSHCLWINAPIOLD; /** * Structure for maintaining a Shared Clipboard context on Windows platforms. */ -typedef struct _VBOXCLIPBOARDWINCTX +typedef struct _SHCLWINCTX { /** Window handle of our (invisible) clipbaord window. */ @@ -112,8 +112,8 @@ HWND hWndClipboardOwnerUs; /** Structure for maintaining the new clipboard API. */ - VBOXCLIPBOARDWINAPINEW newAPI; + SHCLWINAPINEW newAPI; /** Structure for maintaining the old clipboard API. */ - VBOXCLIPBOARDWINAPIOLD oldAPI; -} VBOXCLIPBOARDWINCTX, *PVBOXCLIPBOARDWINCTX; + SHCLWINAPIOLD oldAPI; +} SHCLWINCTX, *PSHCLWINCTX; int VBoxClipboardWinOpen(HWND hWnd); @@ -121,14 +121,14 @@ int VBoxClipboardWinClear(void); -int VBoxClipboardWinCheckAndInitNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI); -bool VBoxClipboardWinIsNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI); - -int VBoxClipboardWinChainAdd(PVBOXCLIPBOARDWINCTX pCtx); -int VBoxClipboardWinChainRemove(PVBOXCLIPBOARDWINCTX pCtx); +int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI); +bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI); + +int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx); +int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx); VOID CALLBACK VBoxClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult); -LRESULT VBoxClipboardWinChainPassToNext(PVBOXCLIPBOARDWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam); - -VBOXCLIPBOARDFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat); -int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats); +LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam); + +SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat); +int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST @@ -141,13 +141,13 @@ int VBoxClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput); -LRESULT VBoxClipboardWinHandleWMChangeCBChain(PVBOXCLIPBOARDWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); -int VBoxClipboardWinHandleWMDestroy(PVBOXCLIPBOARDWINCTX pWinCtx); -int VBoxClipboardWinHandleWMRenderAllFormats(PVBOXCLIPBOARDWINCTX pWinCtx, HWND hWnd); -int VBoxClipboardWinHandleWMTimer(PVBOXCLIPBOARDWINCTX pWinCtx); - -int VBoxClipboardWinAnnounceFormats(PVBOXCLIPBOARDWINCTX pWinCtx, VBOXCLIPBOARDFORMATS fFormats); +LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); +int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx); +int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd); +int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx); + +int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardWinURITransferCreate(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer); -void VBoxClipboardWinURITransferDestroy(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer); +int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer); +void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer); #endif @@ -170,5 +170,5 @@ public: - VBoxClipboardWinDataObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, + VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer, LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0); virtual ~VBoxClipboardWinDataObject(void); @@ -218,8 +218,8 @@ static int Thread(RTTHREAD hThread, void *pvUser); - int readDir(PSHAREDCLIPBOARDURITRANSFER pTransfer, const Utf8Str &strPath); + int readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strPath); int copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal); - int createFileGroupDescriptorFromTransfer(PSHAREDCLIPBOARDURITRANSFER pTransfer, + int createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer, bool fUnicode, HGLOBAL *phGlobal); @@ -237,5 +237,5 @@ Utf8Str strPath; /** Related (cached) object information. */ - SHAREDCLIPBOARDFSOBJINFO objInfo; + SHCLFSOBJINFO objInfo; }; @@ -248,5 +248,5 @@ LPFORMATETC m_pFormatEtc; LPSTGMEDIUM m_pStgMedium; - PSHAREDCLIPBOARDURITRANSFER m_pTransfer; + PSHCLURITRANSFER m_pTransfer; IStream *m_pStream; ULONG m_uObjIdx; @@ -303,6 +303,6 @@ public: - VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer, - const Utf8Str &strPath, PSHAREDCLIPBOARDFSOBJINFO pObjInfo); + VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo); virtual ~VBoxClipboardWinStreamImpl(void); @@ -329,6 +329,6 @@ public: /* Own methods. */ - static HRESULT Create(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer, const Utf8Str &strPath, - PSHAREDCLIPBOARDFSOBJINFO pObjInfo, IStream **ppStream); + static HRESULT Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, const Utf8Str &strPath, + PSHCLFSOBJINFO pObjInfo, IStream **ppStream); private: @@ -338,11 +338,11 @@ LONG m_lRefCount; /** Pointer to the associated URI transfer. */ - PSHAREDCLIPBOARDURITRANSFER m_pURITransfer; + PSHCLURITRANSFER m_pURITransfer; /** The object handle to use. */ - SHAREDCLIPBOARDOBJHANDLE m_hObj; + SHCLOBJHANDLE m_hObj; /** Object path. */ Utf8Str m_strPath; /** (Cached) object information. */ - SHAREDCLIPBOARDFSOBJINFO m_objInfo; + SHCLFSOBJINFO m_objInfo; /** Number of bytes already processed. */ uint64_t m_cbProcessed; @@ -353,5 +353,5 @@ /** * Class for Windows-specifics for maintaining a single URI transfer. - * Set as pvUser / cbUser in SHAREDCLIPBOARDURICTX. + * Set as pvUser / cbUser in SHCLURICTX. */ class SharedClipboardWinURITransferCtx Index: /trunk/include/VBox/GuestHost/SharedClipboard.h =================================================================== --- /trunk/include/VBox/GuestHost/SharedClipboard.h (revision 80661) +++ /trunk/include/VBox/GuestHost/SharedClipboard.h (revision 80662) @@ -35,12 +35,12 @@ /** A single Shared Clipboard format. */ -typedef uint32_t VBOXCLIPBOARDFORMAT; +typedef uint32_t SHCLFORMAT; /** Pointer to a single Shared Clipboard format. */ -typedef VBOXCLIPBOARDFORMAT *PVBOXCLIPBOARDFORMAT; +typedef SHCLFORMAT *PSHCLFORMAT; /** Bit map of Shared Clipboard formats. */ -typedef uint32_t VBOXCLIPBOARDFORMATS; +typedef uint32_t SHCLFORMATS; /** Pointer to a bit map of Shared Clipboard formats. */ -typedef VBOXCLIPBOARDFORMATS *PVBOXCLIPBOARDFORMATS; +typedef SHCLFORMATS *PSHCLFORMATS; /** @@ -63,42 +63,42 @@ * Structure for keeping a generic Shared Clipboard data block. */ -typedef struct _SHAREDCLIPBOARDDATABLOCK +typedef struct _SHCLDATABLOCK { /** Clipboard format this data block represents. */ - VBOXCLIPBOARDFORMAT uFormat; + SHCLFORMAT uFormat; /** Pointer to actual data block. */ void *pvData; /** Size (in bytes) of actual data block. */ uint32_t cbData; -} SHAREDCLIPBOARDDATABLOCK, *PSHAREDCLIPBOARDDATABLOCK; +} SHCLDATABLOCK, *PSHCLDATABLOCK; /** * Structure for keeping a Shared Clipboard data read request. */ -typedef struct _SHAREDCLIPBOARDDATAREQ +typedef struct _SHCLDATAREQ { /** In which format the data needs to be sent. */ - VBOXCLIPBOARDFORMAT uFmt; + SHCLFORMAT uFmt; /** Read flags; currently unused. */ uint32_t fFlags; /** Maximum data (in byte) can be sent. */ uint32_t cbSize; -} SHAREDCLIPBOARDDATAREQ, *PSHAREDCLIPBOARDDATAREQ; +} SHCLDATAREQ, *PSHCLDATAREQ; /** * Structure for keeping Shared Clipboard formats specifications. */ -typedef struct _SHAREDCLIPBOARDFORMATDATA +typedef struct _SHCLFORMATDATA { /** Available format(s) as bit map. */ - VBOXCLIPBOARDFORMATS uFormats; + SHCLFORMATS uFormats; /** Formats flags. Currently unused. */ uint32_t fFlags; -} SHAREDCLIPBOARDFORMATDATA, *PSHAREDCLIPBOARDFORMATDATA; +} SHCLFORMATDATA, *PSHCLFORMATDATA; /** * Structure for an (optional) Shared Clipboard event payload. */ -typedef struct _SHAREDCLIPBOARDEVENTPAYLOAD +typedef struct _SHCLEVENTPAYLOAD { /** Payload ID; currently unused. */ @@ -108,15 +108,15 @@ /** Size (in bytes) of actual payload data. */ uint32_t cbData; -} SHAREDCLIPBOARDEVENTPAYLOAD, *PSHAREDCLIPBOARDEVENTPAYLOAD; +} SHCLEVENTPAYLOAD, *PSHCLEVENTPAYLOAD; /** Defines an event source ID. */ -typedef uint16_t VBOXCLIPBOARDEVENTSOURCEID; +typedef uint16_t SHCLEVENTSOURCEID; /** Defines a pointer to a event source ID. */ -typedef VBOXCLIPBOARDEVENTSOURCEID *PVBOXCLIPBOARDEVENTSOURCEID; +typedef SHCLEVENTSOURCEID *PSHCLEVENTSOURCEID; /** Defines an event ID. */ -typedef uint16_t VBOXCLIPBOARDEVENTID; +typedef uint16_t SHCLEVENTID; /** Defines a pointer to a event source ID. */ -typedef VBOXCLIPBOARDEVENTID *PVBOXCLIPBOARDEVENTID; +typedef SHCLEVENTID *PSHCLEVENTID; /** Maximum number of concurrent Shared Clipboard transfers a VM can have. @@ -131,15 +131,15 @@ * Structure for maintaining a Shared Clipboard event. */ -typedef struct _SHAREDCLIPBOARDEVENT +typedef struct _SHCLEVENT { /** List node. */ RTLISTNODE Node; /** The event's ID, for self-reference. */ - VBOXCLIPBOARDEVENTID uID; + SHCLEVENTID uID; /** Event semaphore for signalling the event. */ RTSEMEVENT hEventSem; /** Payload to this event. Optional and can be NULL. */ - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; -} SHAREDCLIPBOARDEVENT, *PSHAREDCLIPBOARDEVENT; + PSHCLEVENTPAYLOAD pPayload; +} SHCLEVENT, *PSHCLEVENT; /** @@ -149,49 +149,49 @@ * it can be used in different contexts. */ -typedef struct _SHAREDCLIPBOARDEVENTSOURCE +typedef struct _SHCLEVENTSOURCE { /** The event source' ID. */ - VBOXCLIPBOARDEVENTSOURCEID uID; + SHCLEVENTSOURCEID uID; /** Next upcoming event ID. */ - VBOXCLIPBOARDEVENTID uEventIDNext; - /** List of events (PSHAREDCLIPBOARDEVENT). */ + SHCLEVENTID uEventIDNext; + /** List of events (PSHCLEVENT). */ RTLISTANCHOR lstEvents; -} SHAREDCLIPBOARDEVENTSOURCE, *PSHAREDCLIPBOARDEVENTSOURCE; +} SHCLEVENTSOURCE, *PSHCLEVENTSOURCE; int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData, - PSHAREDCLIPBOARDEVENTPAYLOAD *ppPayload); -void SharedClipboardPayloadFree(PSHAREDCLIPBOARDEVENTPAYLOAD pPayload); - -int SharedClipboardEventSourceCreate(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTSOURCEID uID); -void SharedClipboardEventSourceDestroy(PSHAREDCLIPBOARDEVENTSOURCE pSource); - -VBOXCLIPBOARDEVENTID SharedClipboardEventIDGenerate(PSHAREDCLIPBOARDEVENTSOURCE pSource); -VBOXCLIPBOARDEVENTID SharedClipboardEventGetLast(PSHAREDCLIPBOARDEVENTSOURCE pSource); -int SharedClipboardEventRegister(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID); -int SharedClipboardEventUnregister(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID); -int SharedClipboardEventWait(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID, RTMSINTERVAL uTimeoutMs, - PSHAREDCLIPBOARDEVENTPAYLOAD* ppPayload); -int SharedClipboardEventSignal(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID, PSHAREDCLIPBOARDEVENTPAYLOAD pPayload); -void SharedClipboardEventPayloadDetach(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID); + PSHCLEVENTPAYLOAD *ppPayload); +void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload); + +int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID); +void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource); + +SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource); +SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource); +int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID); +int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID); +int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs, + PSHCLEVENTPAYLOAD* ppPayload); +int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, PSHCLEVENTPAYLOAD pPayload); +void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID); /** * Enumeration to specify the Shared Clipboard URI source type. */ -typedef enum SHAREDCLIPBOARDSOURCE +typedef enum SHCLSOURCE { /** Invalid source type. */ - SHAREDCLIPBOARDSOURCE_INVALID = 0, + SHCLSOURCE_INVALID = 0, /** Source is local. */ - SHAREDCLIPBOARDSOURCE_LOCAL, + SHCLSOURCE_LOCAL, /** Source is remote. */ - SHAREDCLIPBOARDSOURCE_REMOTE, + SHCLSOURCE_REMOTE, /** The usual 32-bit hack. */ - SHAREDCLIPBOARDSOURCE_32Bit_Hack = 0x7fffffff -} SHAREDCLIPBOARDSOURCE; + SHCLSOURCE_32Bit_Hack = 0x7fffffff +} SHCLSOURCE; /** Opaque data structure for the X11/VBox frontend/glue code. */ -struct _VBOXCLIPBOARDCONTEXT; -typedef struct _VBOXCLIPBOARDCONTEXT VBOXCLIPBOARDCONTEXT; -typedef struct _VBOXCLIPBOARDCONTEXT *PVBOXCLIPBOARDCONTEXT; +struct _SHCLCONTEXT; +typedef struct _SHCLCONTEXT SHCLCONTEXT; +typedef struct _SHCLCONTEXT *PSHCLCONTEXT; /** Opaque data structure for the X11/VBox backend code. */ @@ -205,15 +205,15 @@ /* APIs exported by the X11 backend */ -extern CLIPBACKEND *ClipConstructX11(VBOXCLIPBOARDCONTEXT *pFrontend, bool fHeadless); +extern CLIPBACKEND *ClipConstructX11(SHCLCONTEXT *pFrontend, bool fHeadless); extern void ClipDestructX11(CLIPBACKEND *pBackend); extern int ClipStartX11(CLIPBACKEND *pBackend, bool grab); extern int ClipStopX11(CLIPBACKEND *pBackend); -extern int ClipAnnounceFormatToX11(CLIPBACKEND *pBackend, VBOXCLIPBOARDFORMATS vboxFormats); -extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, VBOXCLIPBOARDFORMATS vboxFormat, CLIPREADCBREQ *pReq); +extern int ClipAnnounceFormatToX11(CLIPBACKEND *pBackend, SHCLFORMATS vboxFormats); +extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, SHCLFORMATS vboxFormat, CLIPREADCBREQ *pReq); /* APIs exported by the X11/VBox frontend */ -extern int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb); -extern void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats); -extern void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb); +extern int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb); +extern void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats); +extern void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb); #endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_h */ Index: /trunk/include/VBox/GuestHost/clipboard-helper.h =================================================================== --- /trunk/include/VBox/GuestHost/clipboard-helper.h (revision 80661) +++ /trunk/include/VBox/GuestHost/clipboard-helper.h (revision 80662) @@ -189,5 +189,5 @@ * @param u32Format Clipboard format to use for dumping. */ -void VBoxClipboardDbgDumpData(const void *pv, size_t cb, VBOXCLIPBOARDFORMAT u32Format); +void VBoxClipboardDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format); #endif /* LOG_ENABLED */ Index: /trunk/include/VBox/HostServices/VBoxClipboardExt.h =================================================================== --- /trunk/include/VBox/HostServices/VBoxClipboardExt.h (revision 80661) +++ /trunk/include/VBox/HostServices/VBoxClipboardExt.h (revision 80662) @@ -40,14 +40,14 @@ #define VBOX_CLIPBOARD_EXT_FN_DATA_WRITE (3) /** Registers a new clipboard area. - * Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */ + * Uses the SHCLEXTAREAPARMS struct. */ #define VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER (4) /** Unregisters an existing clipboard area. - * Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */ + * Uses the SHCLEXTAREAPARMS struct. */ #define VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER (5) /** Attaches to an existing clipboard area. - * Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */ + * Uses the SHCLEXTAREAPARMS struct. */ #define VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH (6) /** Detaches from an existing clipboard area. - * Uses the VBOXCLIPBOARDEXTAREAPARMS struct. */ + * Uses the SHCLEXTAREAPARMS struct. */ #define VBOX_CLIPBOARD_EXT_FN_AREA_DETACH (7) @@ -55,5 +55,5 @@ typedef VRDPCLIPBOARDEXTCALLBACK *PFNVRDPCLIPBOARDEXTCALLBACK; -typedef struct _VBOXCLIPBOARDEXTPARMS +typedef struct _SHCLEXTPARMS { uint32_t uFormat; @@ -64,22 +64,22 @@ } u; uint32_t cbData; -} VBOXCLIPBOARDEXTPARMS; +} SHCLEXTPARMS; #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -typedef uint32_t VBOXCLIPBOARDEXTAREAREGISTETRFLAGS; +typedef uint32_t SHCLEXTAREAREGISTETRFLAGS; /** No clipboard register area flags specified. */ -#define VBOXCLIPBOARDEXTAREA_REGISTER_FLAGS_NONE 0 +#define SHCLEXTAREA_REGISTER_FLAGS_NONE 0 -typedef uint32_t VBOXCLIPBOARDEXTAREAATTACHFLAGS; +typedef uint32_t SHCLEXTAREAATTACHFLAGS; /** No clipboard attach area flags specified. */ -#define VBOXCLIPBOARDEXTAREA_ATTACH_FLAGS_NONE 0 +#define SHCLEXTAREA_ATTACH_FLAGS_NONE 0 /** * Structure for keeping clipboard area callback parameters. */ -typedef struct _VBOXCLIPBOARDEXTAREAPARMS +typedef struct _SHCLEXTAREAPARMS { /** The clipboard area's ID the callback is for. */ - SHAREDCLIPBOARDAREAID uID; + SHCLAREAID uID; union { @@ -89,13 +89,13 @@ uint32_t cbData; /** Area register flags; not used yet and must be set to 0. */ - VBOXCLIPBOARDEXTAREAREGISTETRFLAGS fFlags; + SHCLEXTAREAREGISTETRFLAGS fFlags; } fn_register; struct { /** Area attach flags; not used yet and must be set to 0. */ - VBOXCLIPBOARDEXTAREAATTACHFLAGS fFlags; + SHCLEXTAREAATTACHFLAGS fFlags; } fn_attach; } u; -} VBOXCLIPBOARDEXTAREAPARMS, *PVBOXCLIPBOARDEXTAREAPARMS; +} SHCLEXTAREAPARMS, *PSHCLEXTAREAPARMS; #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ Index: /trunk/include/VBox/HostServices/VBoxClipboardSvc.h =================================================================== --- /trunk/include/VBox/HostServices/VBoxClipboardSvc.h (revision 80661) +++ /trunk/include/VBox/HostServices/VBoxClipboardSvc.h (revision 80662) @@ -389,14 +389,14 @@ /** @todo might be necessary for future. */ -#define VBOX_SHAREDCLIPBOARD_LIST_FLAG_NONE 0 -#define VBOX_SHAREDCLIPBOARD_LIST_FLAG_RETURN_ONE RT_BIT(0) -#define VBOX_SHAREDCLIPBOARD_LIST_FLAG_RESTART RT_BIT(1) - -#define VBOX_SHAREDCLIPBOARD_LISTHDR_FLAG_NONE 0 +#define VBOX_SHCL_LIST_FLAG_NONE 0 +#define VBOX_SHCL_LIST_FLAG_RETURN_ONE RT_BIT(0) +#define VBOX_SHCL_LIST_FLAG_RESTART RT_BIT(1) + +#define VBOX_SHCL_LISTHDR_FLAG_NONE 0 /** No additional information provided. */ -#define VBOX_SHAREDCLIPBOARD_INFO_FLAG_NONE 0 -/** Get object information of type SHAREDCLIPBOARDFSOBJINFO. */ -#define VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO RT_BIT(0) +#define VBOX_SHCL_INFO_FLAG_NONE 0 +/** Get object information of type SHCLFSOBJINFO. */ +#define VBOX_SHCL_INFO_FLAG_FSOBJINFO RT_BIT(0) /** @@ -409,5 +409,5 @@ /** uint32_t, in: Context ID. */ HGCMFunctionParameter uContext; - /** uint32_t, in: Transfer status of type SHAREDCLIPBOARDURITRANSFERSTATUS. */ + /** uint32_t, in: Transfer status of type SHCLURITRANSFERSTATUS. */ HGCMFunctionParameter uStatus; /** uint32_t, in: Size of payload of this status, based on the status type. */ @@ -419,9 +419,9 @@ #define VBOX_SHARED_CLIPBOARD_CPARMS_STATUS 4 -#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_INVALID 0 -#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN 1 -#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_CLOSE 2 -#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN 3 -#define VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE 4 +#define VBOX_SHCL_REPLYMSGTYPE_INVALID 0 +#define VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN 1 +#define VBOX_SHCL_REPLYMSGTYPE_LIST_CLOSE 2 +#define VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN 3 +#define VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE 4 /** @@ -434,5 +434,5 @@ /** uint32_t, out: Context ID. */ HGCMFunctionParameter uContext; - /** uint32_t, out: Message type of type VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_XXX. */ + /** uint32_t, out: Message type of type VBOX_SHCL_REPLYMSGTYPE_XXX. */ HGCMFunctionParameter enmType; /** uint32_t, out: IPRT result of overall operation. */ @@ -499,5 +499,5 @@ /** uint32_t, in: Context ID. */ HGCMFunctionParameter uContext; - /** uint32_t, in: VBOX_SHAREDCLIPBOARD_INFO_FLAG_XXX. */ + /** uint32_t, in: VBOX_SHCL_INFO_FLAG_XXX. */ HGCMFunctionParameter fInfo; /** uint32_t, in: Index of root list entry to get (zero-based). */ @@ -531,6 +531,6 @@ /** uint32_t, out: Bytes to be used for information/How many bytes were used. */ HGCMFunctionParameter cbInfo; - /** pointer, in/out: Information to be set/get (SHAREDCLIPBOARDFSOBJINFO only currently). - * Do not forget to set the SHAREDCLIPBOARDFSOBJINFO::Attr::enmAdditional for Get operation as well. */ + /** pointer, in/out: Information to be set/get (SHCLFSOBJINFO only currently). + * Do not forget to set the SHCLFSOBJINFO::Attr::enmAdditional for Get operation as well. */ HGCMFunctionParameter pvInfo; } VBoxClipboardRootListEntryMsg; @@ -547,5 +547,5 @@ /** uint32_t, in: Context ID. */ HGCMFunctionParameter uContext; - /** uint32_t, in: Listing flags (see VBOX_SHAREDCLIPBOARD_LIST_FLAG_XXX). */ + /** uint32_t, in: Listing flags (see VBOX_SHCL_LIST_FLAG_XXX). */ HGCMFunctionParameter fList; /** uint32_t, in: Size (in bytes) of the filter string. */ @@ -584,5 +584,5 @@ /** uint64_t, in: List handle. */ HGCMFunctionParameter uHandle; - /** uint32_t, in: Flags of type VBOX_SHAREDCLIPBOARD_LISTHDR_FLAG_XXX. */ + /** uint32_t, in: Flags of type VBOX_SHCL_LISTHDR_FLAG_XXX. */ HGCMFunctionParameter fFlags; } VBoxClipboardListHdrReqParms; @@ -608,5 +608,5 @@ VBoxClipboardListHdrReqParms ReqParms; - /** uint32_t, in/out: Feature flags (see VBOX_SHAREDCLIPBOARD_FEATURE_FLAG_XXX). */ + /** uint32_t, in/out: Feature flags (see VBOX_SHCL_FEATURE_FLAG_XXX). */ HGCMFunctionParameter fFeatures; /** uint64_t, in/out: Number of total objects to transfer. */ @@ -624,5 +624,5 @@ /** uint64_t, in: List handle. */ HGCMFunctionParameter uHandle; - /** uint32_t, in: VBOX_SHAREDCLIPBOARD_INFO_FLAG_XXX. */ + /** uint32_t, in: VBOX_SHCL_INFO_FLAG_XXX. */ HGCMFunctionParameter fInfo; } VBoxClipboardListEntryReqParms; @@ -653,6 +653,6 @@ /** uint32_t, out: Bytes to be used for information/How many bytes were used. */ HGCMFunctionParameter cbInfo; - /** pointer, in/out: Information to be set/get (SHAREDCLIPBOARDFSOBJINFO only currently). - * Do not forget to set the SHAREDCLIPBOARDFSOBJINFO::Attr::enmAdditional for Get operation as well. */ + /** pointer, in/out: Information to be set/get (SHCLFSOBJINFO only currently). + * Do not forget to set the SHCLFSOBJINFO::Attr::enmAdditional for Get operation as well. */ HGCMFunctionParameter pvInfo; } VBoxClipboardListEntryMsg; @@ -672,5 +672,5 @@ /** pointer, in/out: Absoulte path of object to open/create. */ HGCMFunctionParameter szPath; - /** uint32_t in/out: Open / Create flags of type SHAREDCLIPBOARD_OBJ_CF_. */ + /** uint32_t in/out: Open / Create flags of type SHCL_OBJ_CF_. */ HGCMFunctionParameter fCreate; } VBoxClipboardObjOpenMsg; @@ -684,5 +684,5 @@ /** uint32_t, in/out: Context ID. */ HGCMFunctionParameter uContext; - /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to close. */ + /** uint64_t, in: SHCLOBJHANDLE of object to close. */ HGCMFunctionParameter uHandle; } VBoxClipboardObjCloseMsg; @@ -694,5 +694,5 @@ /** uint32_t, in: Context ID. */ HGCMFunctionParameter uContext; - /** uint64_t, in: SHAREDCLIPBOARDOBJHANDLE of object to write to. */ + /** uint64_t, in: SHCLOBJHANDLE of object to write to. */ HGCMFunctionParameter uHandle; /** uint32_t, in: How many bytes to read. */ @@ -724,5 +724,5 @@ /** uint32_t, in/out: Context ID. */ HGCMFunctionParameter uContext; - /** uint64_t, in/out: SHAREDCLIPBOARDOBJHANDLE of object to write to. */ + /** uint64_t, in/out: SHCLOBJHANDLE of object to write to. */ HGCMFunctionParameter uHandle; /** uint32_t, in/out: Size (in bytes) of current data chunk. */ @@ -760,5 +760,5 @@ #pragma pack() -typedef struct _VBOXCLIPBOARDFILEDATA +typedef struct _SHCLFILEDATA { /** Current file data chunk. */ @@ -770,10 +770,10 @@ /** Size (in bytes) of current data chunk. */ uint32_t cbChecksum; -} VBOXCLIPBOARDFILEDATA, *PVBOXCLIPBOARDFILEDATA; - -typedef struct _VBOXCLIPBOARDERRORDATA +} SHCLFILEDATA, *PSHCLFILEDATA; + +typedef struct _SHCLERRORDATA { int32_t rc; -} VBOXCLIPBOARDERRORDATA, *PVBOXCLIPBOARDERRORDATA; +} SHCLERRORDATA, *PSHCLERRORDATA; bool VBoxSvcClipboardGetHeadless(void); Index: /trunk/include/VBox/VBoxGuestLib.h =================================================================== --- /trunk/include/VBox/VBoxGuestLib.h (revision 80661) +++ /trunk/include/VBox/VBoxGuestLib.h (revision 80662) @@ -639,7 +639,7 @@ { /** Reports available formats from the host. */ - SHAREDCLIPBOARDFORMATDATA ReportFormats; + SHCLFORMATDATA ReportFormats; /** Requests data to be read from the guest. */ - SHAREDCLIPBOARDDATAREQ ReadData; + SHCLDATAREQ ReadData; } u; } VBGLR3CLIPBOARDEVENT, *PVBGLR3CLIPBOARDEVENT; @@ -651,6 +651,6 @@ VBGLR3DECL(int) VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb); VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb); -VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATABLOCK pData); -VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats); +VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATABLOCK pData); +VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats); VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats); @@ -664,38 +664,38 @@ # ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST VBGLR3DECL(int) VbglR3ClipboardTransferEvent(PVBGLR3SHCLCMDCTX pCtx, uint32_t uMsg, uint32_t cParms, - PSHAREDCLIPBOARDURITRANSFER pTransfer); -VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDURITRANSFERSTATUS uStatus); - -VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList); + PSHCLURITRANSFER pTransfer); +VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, PSHCLURITRANSFER pTransfer, + SHCLURITRANSFERSTATUS uStatus); + +VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLIST *ppRootList); VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReq(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pfRoots); -VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST pRootList); -VBGLR3DECL(int) VbglR3ClipboardRootsWrite(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRoots); - -VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList); -VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms); -VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList); - -VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList); -VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList); - -VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr); -VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry); - -VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms); -VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj); -VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, - PSHAREDCLIPBOARDOBJHANDLE phObj); - -VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj); -VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj); -VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj); - -VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj, uint32_t pcbToRead, +VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLIST pRootList); +VBGLR3DECL(int) VbglR3ClipboardRootsWrite(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLISTHDR pRoots); + +VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList); +VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTOPENPARMS pOpenParms); +VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLLISTHANDLE hList); + +VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList); +VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHANDLE phList); + +VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr); +VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry); + +VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms); +VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLOBJHANDLE hObj); +VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, + PSHCLOBJHANDLE phObj); + +VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj); +VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLOBJHANDLE hObj); +VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj); + +VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj, uint32_t pcbToRead, uint32_t *pfFlags); -VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, +VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead); -VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, +VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten); # endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ Index: /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (revision 80661) +++ /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (revision 80662) @@ -52,5 +52,5 @@ *********************************************************************************************************************************/ -typedef struct _VBOXCLIPBOARDCONTEXT +typedef struct _SHCLCONTEXT { /** Pointer to the VBoxClient service environment. */ @@ -59,23 +59,23 @@ VBGLR3SHCLCMDCTX CmdCtx; /** Windows-specific context data. */ - VBOXCLIPBOARDWINCTX Win; + SHCLWINCTX Win; #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST /** URI transfer data. */ - SHAREDCLIPBOARDURICTX URI; + SHCLURICTX URI; #endif -} VBOXCLIPBOARDCONTEXT, *PVBOXCLIPBOARDCONTEXT; +} SHCLCONTEXT, *PSHCLCONTEXT; #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -typedef struct _VBOXCLIPBOARDURIREADTHREADCTX -{ - PVBOXCLIPBOARDCONTEXT pClipboardCtx; - PSHAREDCLIPBOARDURITRANSFER pTransfer; -} VBOXCLIPBOARDURIREADTHREADCTX, *PVBOXCLIPBOARDURIREADTHREADCTX; - -typedef struct _VBOXCLIPBOARDURIWRITETHREADCTX -{ - PVBOXCLIPBOARDCONTEXT pClipboardCtx; - PSHAREDCLIPBOARDURITRANSFER pTransfer; -} VBOXCLIPBOARDURIWRITETHREADCTX, *PVBOXCLIPBOARDURIWRITETHREADCTX; +typedef struct _SHCLURIREADTHREADCTX +{ + PSHCLCONTEXT pClipboardCtx; + PSHCLURITRANSFER pTransfer; +} SHCLURIREADTHREADCTX, *PSHCLURIREADTHREADCTX; + +typedef struct _SHCLURIWRITETHREADCTX +{ + PSHCLCONTEXT pClipboardCtx; + PSHCLURITRANSFER pTransfer; +} SHCLURIWRITETHREADCTX, *PSHCLURIWRITETHREADCTX; #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ @@ -85,5 +85,5 @@ *********************************************************************************************************************************/ /** Static clipboard context (since it is the single instance). Directly used in the windows proc. */ -static VBOXCLIPBOARDCONTEXT g_Ctx = { NULL }; +static SHCLCONTEXT g_Ctx = { NULL }; /** Static window class name. */ static char s_szClipWndClassName[] = VBOX_CLIPBOARD_WNDCLASS_NAME; @@ -94,6 +94,6 @@ *********************************************************************************************************************************/ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc); -static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc); +static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc); +static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc); #endif @@ -106,8 +106,8 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDURIWRITETHREADCTX pCtx = (PVBOXCLIPBOARDURIWRITETHREADCTX)pvUser; + PSHCLURIWRITETHREADCTX pCtx = (PSHCLURIWRITETHREADCTX)pvUser; AssertPtr(pCtx); - PSHAREDCLIPBOARDURITRANSFER pTransfer = pCtx->pTransfer; + PSHCLURITRANSFER pTransfer = pCtx->pTransfer; AssertPtr(pTransfer); @@ -120,5 +120,5 @@ if (RT_SUCCESS(rc)) { - rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING); + rc = VbglR3ClipboardTransferSendStatus(&cmdCtx, pTransfer, SHCLURITRANSFERSTATUS_RUNNING); if (RT_SUCCESS(rc)) { @@ -158,5 +158,5 @@ } -static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc) +static DECLCALLBACK(void) vboxClipboardURITransferCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc) { RT_NOREF(rc); @@ -166,8 +166,8 @@ LogRel2(("Shared Clipboard: Transfer to destination complete\n")); - PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser; + PSHCLURICTX pCtx = (PSHCLURICTX)pData->pvUser; AssertPtr(pCtx); - PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer; + PSHCLURITRANSFER pTransfer = pData->pTransfer; AssertPtr(pTransfer); @@ -182,5 +182,5 @@ } -static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc) +static DECLCALLBACK(void) vboxClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc) { RT_NOREF(rc); @@ -190,8 +190,8 @@ LogRel(("Shared Clipboard: Transfer to destination failed with %Rrc\n", rc)); - PSHAREDCLIPBOARDURICTX pCtx = (PSHAREDCLIPBOARDURICTX)pData->pvUser; + PSHCLURICTX pCtx = (PSHCLURICTX)pData->pvUser; AssertPtr(pCtx); - PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer; + PSHCLURITRANSFER pTransfer = pData->pTransfer; AssertPtr(pTransfer); @@ -206,5 +206,5 @@ } -static int vboxClipboardURITransferOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx) +static int vboxClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx) { RT_NOREF(pCtx); @@ -214,5 +214,5 @@ } -static int vboxClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx) +static int vboxClipboardURITransferClose(PSHCLPROVIDERCTX pCtx) { RT_NOREF(pCtx); @@ -222,6 +222,6 @@ } -static int vboxClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, - PSHAREDCLIPBOARDLISTHANDLE phList) +static int vboxClipboardURIListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, + PSHCLLISTHANDLE phList) { RT_NOREF(pCtx, pOpenParms, phList); @@ -229,5 +229,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -240,5 +240,5 @@ } -static int vboxClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList) +static int vboxClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList) { RT_NOREF(pCtx, hList); @@ -246,5 +246,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -257,9 +257,9 @@ } -static int vboxClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList) +static int vboxClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -270,6 +270,6 @@ } -static int vboxClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pListHdr) +static int vboxClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTHDR pListHdr) { RT_NOREF(hList); @@ -277,5 +277,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -298,10 +298,10 @@ /* -static int vboxClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pListHdr) +static int vboxClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTHDR pListHdr) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -312,6 +312,6 @@ }*/ -static int vboxClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pListEntry) +static int vboxClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pListEntry) { RT_NOREF(hList); @@ -319,5 +319,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -332,10 +332,10 @@ /* -static int vboxClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pListEntry) +static int vboxClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pListEntry) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -347,10 +347,10 @@ */ -static int vboxClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj) +static int vboxClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, + PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -361,9 +361,9 @@ } -static int vboxClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj) +static int vboxClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -374,5 +374,5 @@ } -static int vboxClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +static int vboxClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead) { @@ -381,5 +381,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -390,5 +390,5 @@ } -static int vboxClipboardURIObjWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +static int vboxClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten) { @@ -397,5 +397,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; + PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser; AssertPtr(pThisCtx); @@ -407,9 +407,9 @@ #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ -static LRESULT vboxClipboardWinProcessMsg(PVBOXCLIPBOARDCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +static LRESULT vboxClipboardWinProcessMsg(PSHCLCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { AssertPtr(pCtx); - const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; + const PSHCLWINCTX pWinCtx = &pCtx->Win; LRESULT lresultRc = 0; @@ -427,5 +427,5 @@ /* Clipboard was updated by another application. * Report available formats to the host. */ - SHAREDCLIPBOARDFORMATDATA Formats; + SHCLFORMATDATA Formats; int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats); if (RT_SUCCESS(rc)) @@ -454,5 +454,5 @@ /* Clipboard was updated by another application. */ /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */ - SHAREDCLIPBOARDFORMATDATA Formats; + SHCLFORMATDATA Formats; int rc = VBoxClipboardWinGetFormats(pWinCtx, &Formats); if (RT_SUCCESS(rc)) @@ -485,5 +485,5 @@ const UINT cfFormat = (UINT)wParam; - const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat); + const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat); LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat)); @@ -647,5 +647,5 @@ Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS); - const VBOXCLIPBOARDFORMATS fFormats = pEvent->u.ReportFormats.uFormats; + const SHCLFORMATS fFormats = pEvent->u.ReportFormats.uFormats; if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */ @@ -661,5 +661,5 @@ LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST\n")); - PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->URI, + PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->URI, 0 /* uIdx */); if (pTransfer) @@ -698,5 +698,5 @@ Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_READ_DATA); - const VBOXCLIPBOARDFORMAT uFormat = (uint32_t)pEvent->u.ReadData.uFmt; + const SHCLFORMAT uFormat = (uint32_t)pEvent->u.ReadData.uFmt; HANDLE hClip = NULL; @@ -715,5 +715,5 @@ if (lp != NULL) { - SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) }; + SHCLDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) }; rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock); @@ -735,5 +735,5 @@ if (uniString != NULL) { - SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, uniString, ((uint32_t)lstrlenW(uniString) + 1) * 2 }; + SHCLDATABLOCK dataBlock = { uFormat, uniString, ((uint32_t)lstrlenW(uniString) + 1) * 2 }; rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock); @@ -759,5 +759,5 @@ if (lp != NULL) { - SHAREDCLIPBOARDDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) }; + SHCLDATABLOCK dataBlock = { uFormat, lp, (uint32_t)GlobalSize(hClip) }; rc = VbglR3ClipboardWriteDataEx(&pEvent->cmdCtx, &dataBlock); @@ -780,7 +780,7 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDURITRANSFER pTransfer; - rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE, - SHAREDCLIPBOARDSOURCE_LOCAL, + PSHCLURITRANSFER pTransfer; + rc = SharedClipboardURITransferCreate(SHCLURITRANSFERDIR_WRITE, + SHCLSOURCE_LOCAL, &pTransfer); if (RT_SUCCESS(rc)) @@ -809,6 +809,6 @@ if (RT_SUCCESS(rc)) { - PVBOXCLIPBOARDURIWRITETHREADCTX pThreadCtx - = (PVBOXCLIPBOARDURIWRITETHREADCTX)RTMemAllocZ(sizeof(VBOXCLIPBOARDURIWRITETHREADCTX)); + PSHCLURIWRITETHREADCTX pThreadCtx + = (PSHCLURIWRITETHREADCTX)RTMemAllocZ(sizeof(SHCLURIWRITETHREADCTX)); if (pThreadCtx) { @@ -874,7 +874,7 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDURITRANSFER pTransfer; - rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE, - SHAREDCLIPBOARDSOURCE_LOCAL, + PSHCLURITRANSFER pTransfer; + rc = SharedClipboardURITransferCreate(SHCLURITRANSFERDIR_WRITE, + SHCLSOURCE_LOCAL, &pTransfer); if (RT_SUCCESS(rc)) @@ -903,6 +903,6 @@ if (RT_SUCCESS(rc)) { - PVBOXCLIPBOARDURIWRITETHREADCTX pThreadCtx - = (PVBOXCLIPBOARDURIWRITETHREADCTX)RTMemAllocZ(sizeof(VBOXCLIPBOARDURIWRITETHREADCTX)); + PSHCLURIWRITETHREADCTX pThreadCtx + = (PSHCLURIWRITETHREADCTX)RTMemAllocZ(sizeof(SHCLURIWRITETHREADCTX)); if (pThreadCtx) { @@ -949,11 +949,11 @@ SharedClipboardURICtxGetRunningTransfers(&pCtx->URI))); - PSHAREDCLIPBOARDURITRANSFER pTransfer; - int rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ, - SHAREDCLIPBOARDSOURCE_LOCAL, + PSHCLURITRANSFER pTransfer; + int rc = SharedClipboardURITransferCreate(SHCLURITRANSFERDIR_READ, + SHCLSOURCE_LOCAL, &pTransfer); if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDURITRANSFERCALLBACKS TransferCallbacks; + SHCLURITRANSFERCALLBACKS TransferCallbacks; RT_ZERO(TransferCallbacks); @@ -964,8 +964,8 @@ SharedClipboardURITransferSetCallbacks(pTransfer, &TransferCallbacks); - SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx; + SHCLPROVIDERCREATIONCTX creationCtx; RT_ZERO(creationCtx); - creationCtx.enmSource = SHAREDCLIPBOARDSOURCE_REMOTE; + creationCtx.enmSource = SHCLSOURCE_REMOTE; creationCtx.Interface.pfnGetRoots = vboxClipboardURIGetRoots; @@ -1029,5 +1029,5 @@ static LRESULT CALLBACK vboxClipboardWinWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); -static int vboxClipboardCreateWindow(PVBOXCLIPBOARDCONTEXT pCtx) +static int vboxClipboardCreateWindow(PSHCLCONTEXT pCtx) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -1058,5 +1058,5 @@ if (RT_SUCCESS(rc)) { - const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; + const PSHCLWINCTX pWinCtx = &pCtx->Win; /* Create the window. */ @@ -1084,9 +1084,9 @@ } -static void vboxClipboardDestroy(PVBOXCLIPBOARDCONTEXT pCtx) +static void vboxClipboardDestroy(PSHCLCONTEXT pCtx) { AssertPtrReturnVoid(pCtx); - const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; + const PSHCLWINCTX pWinCtx = &pCtx->Win; if (pWinCtx->hWnd) @@ -1101,5 +1101,5 @@ static LRESULT CALLBACK vboxClipboardWinWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { - PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /** @todo r=andy Make pCtx available through SetWindowLongPtr() / GWL_USERDATA. */ + PSHCLCONTEXT pCtx = &g_Ctx; /** @todo r=andy Make pCtx available through SetWindowLongPtr() / GWL_USERDATA. */ AssertPtr(pCtx); @@ -1112,5 +1112,5 @@ LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */ + PSHCLCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */ AssertPtr(pCtx); @@ -1182,8 +1182,8 @@ RTThreadUserSignal(RTThreadSelf()); - const PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance; + const PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pInstance; AssertPtr(pCtx); - const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; + const PSHCLWINCTX pWinCtx = &pCtx->Win; int rc; @@ -1324,5 +1324,5 @@ LogFunc(("Stopping pInstance=%p\n", pInstance)); - PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance; + PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pInstance; AssertPtr(pCtx); @@ -1338,5 +1338,5 @@ AssertPtrReturnVoid(pInstance); - PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance; + PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pInstance; AssertPtr(pCtx); Index: /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp =================================================================== --- /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp (revision 80661) +++ /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp (revision 80662) @@ -155,5 +155,5 @@ -VBGLR3DECL(int) VbglR3ClipboardFormatsWriteRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats) +VBGLR3DECL(int) VbglR3ClipboardFormatsWriteRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -188,5 +188,5 @@ -VBGLR3DECL(int) VbglR3ClipboardReadDataRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATAREQ pDataReq) +VBGLR3DECL(int) VbglR3ClipboardReadDataRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATAREQ pDataReq) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -366,5 +366,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST VBGLR3DECL(int) VbglR3ClipboardTransferSendStatus(PVBGLR3SHCLCMDCTX pCtx, - PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS uStatus) + PSHCLURITRANSFER pTransfer, SHCLURITRANSFERSTATUS uStatus) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -388,5 +388,5 @@ } -static int vbglR3ClipboardRootListHdrRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRootListHdr) +static int vbglR3ClipboardRootListHdrRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLISTHDR pRootListHdr) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -416,5 +416,5 @@ } -static int vbglR3ClipboardRootListEntryRead(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry) +static int vbglR3ClipboardRootListEntryRead(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PSHCLROOTLISTENTRY pRootListEntry) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -452,5 +452,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList) +VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLIST *ppRootList) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -459,8 +459,8 @@ int rc; - PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc(); + PSHCLROOTLIST pRootList = SharedClipboardURIRootListAlloc(); if (pRootList) { - VBOXCLIPBOARDROOTLISTHDR srcRootListHdr; + SHCLROOTLISTHDR srcRootListHdr; rc = vbglR3ClipboardRootListHdrRead(pCtx, &srcRootListHdr); if (RT_SUCCESS(rc)) @@ -472,5 +472,5 @@ { pRootList->paEntries = - (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(srcRootListHdr.cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY)); + (PSHCLROOTLISTENTRY)RTMemAllocZ(srcRootListHdr.cRoots * sizeof(SHCLROOTLISTENTRY)); if (pRootList->paEntries) { @@ -527,5 +527,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDROOTLISTHDR pRootListHdr) +VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLISTHDR pRootListHdr) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -579,5 +579,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry) +VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PSHCLROOTLISTENTRY pEntry) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -604,6 +604,6 @@ } -VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, - PSHAREDCLIPBOARDLISTHANDLE phList) +VBGLR3DECL(int) VbglR3ClipboardListOpenSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, + PSHCLLISTHANDLE phList) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -634,5 +634,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms) +VBGLR3DECL(int) VbglR3ClipboardListOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTOPENPARMS pOpenParms) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -669,5 +669,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList) +VBGLR3DECL(int) VbglR3ClipboardListOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLLISTHANDLE hList) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -680,5 +680,5 @@ Msg.uContext.SetUInt32(pCtx->uContextID); - Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN); + Msg.enmType.SetUInt32(VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN); Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */ Msg.cbPayload.SetUInt32(0); @@ -693,5 +693,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList) +VBGLR3DECL(int) VbglR3ClipboardListCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHANDLE phList) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -719,5 +719,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDLISTHANDLE hList) +VBGLR3DECL(int) VbglR3ClipboardListCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLLISTHANDLE hList) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -730,5 +730,5 @@ Msg.uContext.SetUInt32(pCtx->uContextID); - Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_CLOSE); + Msg.enmType.SetUInt32(VBOX_SHCL_REPLYMSGTYPE_LIST_CLOSE); Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */ Msg.cbPayload.SetUInt32(0); @@ -743,5 +743,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList) +VBGLR3DECL(int) VbglR3ClipboardListCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -763,6 +763,6 @@ -VBGLR3DECL(int) VbglR3ClipboardListHdrRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, uint32_t fFlags, - PVBOXCLIPBOARDLISTHDR pListHdr) +VBGLR3DECL(int) VbglR3ClipboardListHdrRead(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, uint32_t fFlags, + PSHCLLISTHDR pListHdr) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -798,5 +798,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecvReq(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfFlags) +VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecvReq(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHANDLE phList, uint32_t *pfFlags) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -828,6 +828,6 @@ } -VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pListHdr) +VBGLR3DECL(int) VbglR3ClipboardListHdrWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTHDR pListHdr) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -855,6 +855,6 @@ } -VBGLR3DECL(int) VbglR3ClipboardListEntryRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pListEntry) +VBGLR3DECL(int) VbglR3ClipboardListEntryRead(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pListEntry) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -885,5 +885,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardListEntryReadRecvReq(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDLISTHANDLE phList, uint32_t *pfInfo) +VBGLR3DECL(int) VbglR3ClipboardListEntryReadRecvReq(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHANDLE phList, uint32_t *pfInfo) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -915,6 +915,6 @@ } -VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pListEntry) +VBGLR3DECL(int) VbglR3ClipboardListEntryWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pListEntry) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -941,5 +941,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms) +VBGLR3DECL(int) VbglR3ClipboardObjOpenRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -972,5 +972,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj) +VBGLR3DECL(int) VbglR3ClipboardObjOpenReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLOBJHANDLE hObj) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -983,5 +983,5 @@ Msg.uContext.SetUInt32(pCtx->uContextID); - Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN); + Msg.enmType.SetUInt32(VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN); Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */ Msg.cbPayload.SetUInt32(0); @@ -996,6 +996,6 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, - PSHAREDCLIPBOARDOBJHANDLE phObj) +VBGLR3DECL(int) VbglR3ClipboardObjOpenSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, + PSHCLOBJHANDLE phObj) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -1025,5 +1025,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj) +VBGLR3DECL(int) VbglR3ClipboardObjCloseRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -1051,5 +1051,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHAREDCLIPBOARDOBJHANDLE hObj) +VBGLR3DECL(int) VbglR3ClipboardObjCloseReply(PVBGLR3SHCLCMDCTX pCtx, int rcReply, SHCLOBJHANDLE hObj) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -1062,5 +1062,5 @@ Msg.uContext.SetUInt32(pCtx->uContextID); - Msg.enmType.SetUInt32(VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE); + Msg.enmType.SetUInt32(VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE); Msg.rc.SetUInt32((uint32_t)rcReply); /** int vs. uint32_t */ Msg.cbPayload.SetUInt32(0); @@ -1075,5 +1075,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj) +VBGLR3DECL(int) VbglR3ClipboardObjCloseSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -1094,5 +1094,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj, uint32_t *pcbToRead, +VBGLR3DECL(int) VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj, uint32_t *pcbToRead, uint32_t *pfFlags) { @@ -1129,5 +1129,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t *pcbRead) { @@ -1166,5 +1166,5 @@ } -VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t *pcbWritten) { @@ -1201,5 +1201,5 @@ VBGLR3DECL(int) VbglR3ClipboardTransferEvent(PVBGLR3SHCLCMDCTX pCtx, uint32_t uMsg, uint32_t cParms, - PSHAREDCLIPBOARDURITRANSFER pTransfer) + PSHCLURITRANSFER pTransfer) { RT_NOREF(cParms); @@ -1220,5 +1220,5 @@ if (RT_SUCCESS(rc)) { - VBOXCLIPBOARDROOTLISTHDR rootListHdr; + SHCLROOTLISTHDR rootListHdr; RT_ZERO(rootListHdr); @@ -1239,5 +1239,5 @@ if (RT_SUCCESS(rc)) { - VBOXCLIPBOARDROOTLISTENTRY rootListEntry; + SHCLROOTLISTENTRY rootListEntry; rc = SharedClipboardURILTransferRootsEntry(pTransfer, uIndex, &rootListEntry); if (RT_SUCCESS(rc)) @@ -1249,5 +1249,5 @@ case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN: { - VBOXCLIPBOARDLISTOPENPARMS openParmsList; + SHCLLISTOPENPARMS openParmsList; rc = SharedClipboardURIListOpenParmsInit(&openParmsList); if (RT_SUCCESS(rc)) @@ -1258,5 +1258,5 @@ LogFlowFunc(("pszPath=%s\n", openParmsList.pszPath)); - SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID; + SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID; rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList); @@ -1274,5 +1274,5 @@ case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE: { - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = VbglR3ClipboardListCloseRecv(pCtx, &hList); if (RT_SUCCESS(rc)) @@ -1292,10 +1292,10 @@ /** @todo Handle filter + list features. */ - SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID; + SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID; uint32_t fFlags = 0; rc = VbglR3ClipboardListHdrReadRecvReq(pCtx, &hList, &fFlags); if (RT_SUCCESS(rc)) { - VBOXCLIPBOARDLISTHDR hdrList; + SHCLLISTHDR hdrList; rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList); if (RT_SUCCESS(rc)) @@ -1315,5 +1315,5 @@ LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE\n")); - VBOXCLIPBOARDLISTHDR hdrList; + SHCLLISTHDR hdrList; rc = SharedClipboardURIListHdrInit(&hdrList); if (RT_SUCCESS(rc)) @@ -1329,9 +1329,9 @@ LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ\n")); - VBOXCLIPBOARDLISTENTRY entryList; + SHCLLISTENTRY entryList; rc = SharedClipboardURIListEntryInit(&entryList); if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; uint32_t fInfo; rc = VbglR3ClipboardListEntryReadRecvReq(pCtx, &hList, &fInfo); @@ -1341,6 +1341,6 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDFSOBJINFO pObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)entryList.pvInfo; - Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO)); + PSHCLFSOBJINFO pObjInfo = (PSHCLFSOBJINFO)entryList.pvInfo; + Assert(entryList.cbInfo == sizeof(SHCLFSOBJINFO)); RT_NOREF(pObjInfo); @@ -1369,5 +1369,5 @@ case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN: { - VBOXCLIPBOARDOBJOPENCREATEPARMS openParms; + SHCLOBJOPENCREATEPARMS openParms; rc = SharedClipboardURIObjectOpenParmsInit(&openParms); if (RT_SUCCESS(rc)) @@ -1376,5 +1376,5 @@ if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDOBJHANDLE hObj; + SHCLOBJHANDLE hObj; rc = SharedClipboardURIObjectOpen(pTransfer, &openParms, &hObj); @@ -1392,5 +1392,5 @@ case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE: { - SHAREDCLIPBOARDOBJHANDLE hObj; + SHCLOBJHANDLE hObj; rc = VbglR3ClipboardObjCloseRecv(pCtx, &hObj); if (RT_SUCCESS(rc)) @@ -1408,5 +1408,5 @@ case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ: { - SHAREDCLIPBOARDOBJHANDLE hObj; + SHCLOBJHANDLE hObj; uint32_t cbBuf; uint32_t fFlags; @@ -1549,5 +1549,5 @@ #if 0 -VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecv(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList) +VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecv(HGCMCLIENTID idClient, PSHCLLISTHANDLE phList) { AssertPtrReturn(phList, VERR_INVALID_POINTER); @@ -1581,5 +1581,5 @@ */ VBGLR3DECL(int) VbglR3ClipboardListHdrSend(HGCMCLIENTID idClient, - VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr) + SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) { AssertPtrReturn(pListHdr, VERR_INVALID_POINTER); @@ -1613,5 +1613,5 @@ */ VBGLR3DECL(int) VbglR3ClipboardSendListEntryWrite(HGCMCLIENTID idClient, - VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry) + SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) { AssertPtrReturn(pListEntry, VERR_INVALID_POINTER); @@ -1643,5 +1643,5 @@ * @param pFormats The formats to send (report). */ -VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats) +VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats) { VBoxClipboardFormatsMsg Msg; @@ -1725,5 +1725,5 @@ * @param pData Clipboard data to send. */ -VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDDATABLOCK pData) +VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATABLOCK pData) { int rc; Index: /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp =================================================================== --- /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp (revision 80661) +++ /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp (revision 80662) @@ -44,5 +44,5 @@ * Global clipboard context information. */ -struct _VBOXCLIPBOARDCONTEXT +struct _SHCLCONTEXT { /** Client ID for the clipboard subsystem */ @@ -54,5 +54,5 @@ /** Only one client is supported. There seems to be no need for more clients. */ -static VBOXCLIPBOARDCONTEXT g_ctx; +static SHCLCONTEXT g_ctx; @@ -86,5 +86,5 @@ * returned */ -int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) +int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) { RT_NOREF1(pCtx); @@ -148,5 +148,5 @@ * @param u32Formats The formats to report. */ -void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats) +void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats) { RT_NOREF1(pCtx); @@ -166,5 +166,5 @@ * @param cb the size of the data in @a pv */ -void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) +void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) { RT_NOREF1(pCtx); Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp (revision 80662) @@ -38,5 +38,5 @@ , m_fOpen(0) , m_hDir(NIL_RTDIR) - , m_uID(NIL_SHAREDCLIPBOARDAREAID) + , m_uID(NIL_SHCLAREAID) { int rc = initInternal(); @@ -46,6 +46,6 @@ SharedClipboardArea::SharedClipboardArea(const char *pszPath, - SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */, - SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */) + SHCLAREAID uID /* = NIL_SHCLAREAID */, + SHCLAREAOPENFLAGS fFlags /* = SHCLAREA_OPEN_FLAGS_NONE */) : m_tsCreatedMs(0) , m_cRefs(0) @@ -115,5 +115,5 @@ } -int SharedClipboardArea::AddObject(const char *pszPath, const SHAREDCLIPBOARDAREAOBJ &Obj) +int SharedClipboardArea::AddObject(const char *pszPath, const SHCLAREAOBJ &Obj) { AssertPtrReturn(pszPath, VERR_INVALID_POINTER); @@ -126,5 +126,5 @@ } -int SharedClipboardArea::GetObject(const char *pszPath, PSHAREDCLIPBOARDAREAOBJ pObj) +int SharedClipboardArea::GetObject(const char *pszPath, PSHCLAREAOBJ pObj) { SharedClipboardAreaFsObjMap::const_iterator itObj = m_mapObj.find(pszPath); @@ -166,6 +166,6 @@ if (RT_SUCCESS(rc)) { - this->m_fOpen = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE; - this->m_uID = NIL_SHAREDCLIPBOARDAREAID; + this->m_fOpen = SHCLAREA_OPEN_FLAGS_NONE; + this->m_uID = NIL_SHCLAREAID; } @@ -185,5 +185,5 @@ */ /* static */ -int SharedClipboardArea::PathConstruct(const char *pszBase, SHAREDCLIPBOARDAREAID uID, char *pszPath, size_t cbPath) +int SharedClipboardArea::PathConstruct(const char *pszBase, SHCLAREAID uID, char *pszPath, size_t cbPath) { LogFlowFunc(("pszBase=%s, uAreaID=%RU32\n", pszBase, uID)); @@ -224,5 +224,5 @@ } -SHAREDCLIPBOARDAREAID SharedClipboardArea::GetID(void) const +SHCLAREAID SharedClipboardArea::GetID(void) const { return this->m_uID; @@ -245,9 +245,9 @@ int SharedClipboardArea::OpenEx(const char *pszPath, - SHAREDCLIPBOARDAREAID uID /* = NIL_SHAREDCLIPBOARDAREAID */, - SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */) + SHCLAREAID uID /* = NIL_SHCLAREAID */, + SHCLAREAOPENFLAGS fFlags /* = SHCLAREA_OPEN_FLAGS_NONE */) { AssertPtrReturn(pszPath, VERR_INVALID_POINTER); - AssertReturn(!(fFlags & ~SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS); + AssertReturn(!(fFlags & ~SHCLAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS); char szAreaDir[RTPATH_MAX]; @@ -256,5 +256,5 @@ { if ( RTDirExists(szAreaDir) - && (fFlags & SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST)) + && (fFlags & SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST)) { rc = VERR_ALREADY_EXISTS; @@ -282,8 +282,8 @@ } -int SharedClipboardArea::OpenTemp(SHAREDCLIPBOARDAREAID uID, - SHAREDCLIPBOARDAREAOPENFLAGS fFlags /* = SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE */) -{ - AssertReturn(!(fFlags & ~SHAREDCLIPBOARDAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS); +int SharedClipboardArea::OpenTemp(SHCLAREAID uID, + SHCLAREAOPENFLAGS fFlags /* = SHCLAREA_OPEN_FLAGS_NONE */) +{ + AssertReturn(!(fFlags & ~SHCLAREA_OPEN_FLAGS_VALID_MASK), VERR_INVALID_FLAGS); /* Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (revision 80662) @@ -41,5 +41,5 @@ //#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 0 -VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, +VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer, LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats) : m_enmStatus(Uninitialized) @@ -229,9 +229,9 @@ * @param strDir Directory path to handle. */ -int VBoxClipboardWinDataObject::readDir(PSHAREDCLIPBOARDURITRANSFER pTransfer, const Utf8Str &strDir) +int VBoxClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir) { LogFlowFunc(("strDir=%s\n", strDir.c_str())); - VBOXCLIPBOARDLISTOPENPARMS openParmsList; + SHCLLISTOPENPARMS openParmsList; int rc = SharedClipboardURIListOpenParmsInit(&openParmsList); if (RT_SUCCESS(rc)) @@ -240,5 +240,5 @@ if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList); if (RT_SUCCESS(rc)) @@ -246,5 +246,5 @@ LogFlowFunc(("strDir=%s -> hList=%RU64\n", strDir.c_str(), hList)); - VBOXCLIPBOARDLISTHDR hdrList; + SHCLLISTHDR hdrList; rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList); if (RT_SUCCESS(rc)) @@ -255,10 +255,10 @@ for (uint64_t o = 0; o < hdrList.cTotalObjects; o++) { - VBOXCLIPBOARDLISTENTRY entryList; + SHCLLISTENTRY entryList; rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList); if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDFSOBJINFO pFsObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)entryList.pvInfo; - Assert(entryList.cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO)); + PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)entryList.pvInfo; + Assert(entryList.cbInfo == sizeof(SHCLFSOBJINFO)); Utf8Str strPath = strDir + Utf8Str("\\") + Utf8Str(entryList.pszName); @@ -320,5 +320,5 @@ VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pvUser; - PSHAREDCLIPBOARDURITRANSFER pTransfer = pThis->m_pTransfer; + PSHCLURITRANSFER pTransfer = pThis->m_pTransfer; AssertPtr(pTransfer); @@ -333,5 +333,5 @@ if (RT_SUCCESS(rc)) { - PVBOXCLIPBOARDROOTLIST pRootList; + PSHCLROOTLIST pRootList; rc = SharedClipboardURILTransferRootsAsList(pTransfer, &pRootList); if (RT_SUCCESS(rc)) @@ -341,9 +341,9 @@ for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++) { - PVBOXCLIPBOARDLISTENTRY pRootEntry = &pRootList->paEntries[i]; + PSHCLLISTENTRY pRootEntry = &pRootList->paEntries[i]; AssertPtr(pRootEntry); - Assert(pRootEntry->cbInfo == sizeof(SHAREDCLIPBOARDFSOBJINFO)); - PSHAREDCLIPBOARDFSOBJINFO pFsObjInfo = (PSHAREDCLIPBOARDFSOBJINFO)pRootEntry->pvInfo; + Assert(pRootEntry->cbInfo == sizeof(SHCLFSOBJINFO)); + PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)pRootEntry->pvInfo; LogFlowFunc(("pszRoot=%s, fMode=0x%x\n", pRootEntry->pszName, pFsObjInfo->Attr.fMode)); @@ -405,5 +405,5 @@ * @param phGlobal Where to store the allocated HGLOBAL object on success. */ -int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHAREDCLIPBOARDURITRANSFER pTransfer, +int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer, bool fUnicode, HGLOBAL *phGlobal) { @@ -478,5 +478,5 @@ pFD->dwFileAttributes = FILE_ATTRIBUTE_NORMAL; - const SHAREDCLIPBOARDFSOBJINFO *pObjInfo = &itRoot->objInfo; + const SHCLFSOBJINFO *pObjInfo = &itRoot->objInfo; if (RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode)) @@ -558,5 +558,5 @@ /* The caller can call GetData() several times, so make sure we don't do the same transfer multiple times. */ - if (SharedClipboardURITransferGetStatus(m_pTransfer) == SHAREDCLIPBOARDURITRANSFERSTATUS_NONE) + if (SharedClipboardURITransferGetStatus(m_pTransfer) == SHCLURITRANSFERSTATUS_NONE) { rc = SharedClipboardURITransferPrepare(m_pTransfer); @@ -615,5 +615,5 @@ /* Hand-in the provider so that our IStream implementation can continue working with it. */ hr = VBoxClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer, - fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHAREDCLIPBOARDFSOBJINFO */, + fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */, &m_pStream); if (SUCCEEDED(hr)) Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp (revision 80662) @@ -46,11 +46,11 @@ -VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer, - const Utf8Str &strPath, PSHAREDCLIPBOARDFSOBJINFO pObjInfo) +VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo) : m_pParent(pParent) , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */ , m_pURITransfer(pTransfer) , m_strPath(strPath) - , m_hObj(SHAREDCLIPBOARDOBJHANDLE_INVALID) + , m_hObj(SHCLOBJHANDLE_INVALID) , m_objInfo(*pObjInfo) , m_cbProcessed(0) @@ -184,15 +184,15 @@ try { - if ( m_hObj == SHAREDCLIPBOARDOBJHANDLE_INVALID + if ( m_hObj == SHCLOBJHANDLE_INVALID && m_pURITransfer->ProviderIface.pfnObjOpen) { - VBOXCLIPBOARDOBJOPENCREATEPARMS openParms; + SHCLOBJOPENCREATEPARMS openParms; rc = SharedClipboardURIObjectOpenParmsInit(&openParms); if (RT_SUCCESS(rc)) { - openParms.fCreate = SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS - | SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW - | SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ - | SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE; + openParms.fCreate = SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS + | SHCL_OBJ_CF_ACT_FAIL_IF_NEW + | SHCL_OBJ_CF_ACCESS_READ + | SHCL_OBJ_CF_ACCESS_DENYWRITE; rc = RTStrCopy(openParms.pszPath, openParms.cbPath, m_strPath.c_str()); @@ -362,6 +362,6 @@ */ /* static */ -HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHAREDCLIPBOARDURITRANSFER pTransfer, - const Utf8Str &strPath, PSHAREDCLIPBOARDFSOBJINFO pObjInfo, +HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo, IStream **ppStream) { Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp (revision 80662) @@ -42,11 +42,11 @@ */ int SharedClipboardPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData, - PSHAREDCLIPBOARDEVENTPAYLOAD *ppPayload) + PSHCLEVENTPAYLOAD *ppPayload) { AssertPtrReturn(pvData, VERR_INVALID_POINTER); AssertReturn (cbData, VERR_INVALID_PARAMETER); - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload = - (PSHAREDCLIPBOARDEVENTPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDEVENTPAYLOAD)); + PSHCLEVENTPAYLOAD pPayload = + (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD)); if (!pPayload) return VERR_NO_MEMORY; @@ -75,5 +75,5 @@ * @param pPayload Event payload to free. */ -void SharedClipboardPayloadFree(PSHAREDCLIPBOARDEVENTPAYLOAD pPayload) +void SharedClipboardPayloadFree(PSHCLEVENTPAYLOAD pPayload) { if (!pPayload) @@ -100,5 +100,5 @@ * @param uID Event ID to use. */ -int SharedClipboardEventCreate(PSHAREDCLIPBOARDEVENT pEvent, VBOXCLIPBOARDEVENTID uID) +int SharedClipboardEventCreate(PSHCLEVENT pEvent, SHCLEVENTID uID) { AssertPtrReturn(pEvent, VERR_INVALID_POINTER); @@ -121,5 +121,5 @@ * @param pEvent Event to destroy. */ -void SharedClipboardEventDestroy(PSHAREDCLIPBOARDEVENT pEvent) +void SharedClipboardEventDestroy(PSHCLEVENT pEvent) { if (!pEvent) @@ -146,5 +146,5 @@ * @param uID ID to use for event source. */ -int SharedClipboardEventSourceCreate(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTSOURCEID uID) +int SharedClipboardEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID) { AssertPtrReturn(pSource, VERR_INVALID_POINTER); @@ -169,5 +169,5 @@ * @param pSource Event source to destroy. */ -void SharedClipboardEventSourceDestroy(PSHAREDCLIPBOARDEVENTSOURCE pSource) +void SharedClipboardEventSourceDestroy(PSHCLEVENTSOURCE pSource) { if (!pSource) @@ -176,7 +176,7 @@ LogFlowFunc(("ID=%RU16\n", pSource->uID)); - PSHAREDCLIPBOARDEVENT pEvIt; - PSHAREDCLIPBOARDEVENT pEvItNext; - RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHAREDCLIPBOARDEVENT, Node) + PSHCLEVENT pEvIt; + PSHCLEVENT pEvItNext; + RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHCLEVENT, Node) { SharedClipboardEventDestroy(pEvIt); @@ -194,5 +194,5 @@ * @param pSource Event source to generate event for. */ -VBOXCLIPBOARDEVENTID SharedClipboardEventIDGenerate(PSHAREDCLIPBOARDEVENTSOURCE pSource) +SHCLEVENTID SharedClipboardEventIDGenerate(PSHCLEVENTSOURCE pSource) { AssertPtrReturn(pSource, 0); @@ -209,8 +209,8 @@ * @param uID Event ID to get. */ -inline PSHAREDCLIPBOARDEVENT sharedClipboardEventGet(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID) -{ - PSHAREDCLIPBOARDEVENT pEvIt; - RTListForEach(&pSource->lstEvents, pEvIt, SHAREDCLIPBOARDEVENT, Node) +inline PSHCLEVENT sharedClipboardEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID) +{ + PSHCLEVENT pEvIt; + RTListForEach(&pSource->lstEvents, pEvIt, SHCLEVENT, Node) { if (pEvIt->uID == uID) @@ -227,8 +227,8 @@ * @param pSource Event source to get last registered event from. */ -VBOXCLIPBOARDEVENTID SharedClipboardEventGetLast(PSHAREDCLIPBOARDEVENTSOURCE pSource) +SHCLEVENTID SharedClipboardEventGetLast(PSHCLEVENTSOURCE pSource) { AssertPtrReturn(pSource, 0); - PSHAREDCLIPBOARDEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHAREDCLIPBOARDEVENT, Node); + PSHCLEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHCLEVENT, Node); if (pEvent) return pEvent->uID; @@ -244,5 +244,5 @@ * @param uID Event ID to register. */ -int SharedClipboardEventRegister(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID) +int SharedClipboardEventRegister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID) { AssertPtrReturn(pSource, VERR_INVALID_POINTER); @@ -254,6 +254,6 @@ if (sharedClipboardEventGet(pSource, uID) == NULL) { - PSHAREDCLIPBOARDEVENT pEvent - = (PSHAREDCLIPBOARDEVENT)RTMemAllocZ(sizeof(SHAREDCLIPBOARDEVENT)); + PSHCLEVENT pEvent + = (PSHCLEVENT)RTMemAllocZ(sizeof(SHCLEVENT)); if (pEvent) { @@ -287,5 +287,5 @@ * @param uID Event ID to unregister. */ -int SharedClipboardEventUnregister(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID) +int SharedClipboardEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID) { AssertPtrReturn(pSource, VERR_INVALID_POINTER); @@ -295,5 +295,5 @@ LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID)); - PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID); + PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID); if (pEvent) { @@ -326,6 +326,6 @@ * SharedClipboardPayloadFree(). */ -int SharedClipboardEventWait(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID, RTMSINTERVAL uTimeoutMs, - PSHAREDCLIPBOARDEVENTPAYLOAD* ppPayload) +int SharedClipboardEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs, + PSHCLEVENTPAYLOAD* ppPayload) { AssertPtrReturn(pSource, VERR_INVALID_POINTER); @@ -335,5 +335,5 @@ int rc; - PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID); + PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID); if (pEvent) { @@ -361,6 +361,6 @@ * @param pPayload Event payload to associate. Takes ownership. Optional. */ -int SharedClipboardEventSignal(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID, - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload) +int SharedClipboardEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, + PSHCLEVENTPAYLOAD pPayload) { AssertPtrReturn(pSource, VERR_INVALID_POINTER); @@ -370,5 +370,5 @@ LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID)); - PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID); + PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID); if (pEvent) { @@ -393,5 +393,5 @@ * @param uID Event ID to detach payload for. */ -void SharedClipboardEventPayloadDetach(PSHAREDCLIPBOARDEVENTSOURCE pSource, VBOXCLIPBOARDEVENTID uID) +void SharedClipboardEventPayloadDetach(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID) { AssertPtrReturnVoid(pSource); @@ -399,5 +399,5 @@ LogFlowFunc(("uSource=%RU16, uEvent=%RU16\n", pSource->uID, uID)); - PSHAREDCLIPBOARDEVENT pEvent = sharedClipboardEventGet(pSource, uID); + PSHCLEVENT pEvent = sharedClipboardEventGet(pSource, uID); if (pEvent) { @@ -751,5 +751,5 @@ } -void VBoxClipboardDbgDumpData(const void *pv, size_t cb, VBOXCLIPBOARDFORMAT u32Format) +void VBoxClipboardDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format) { if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT) Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp (revision 80662) @@ -30,9 +30,9 @@ -static int sharedClipboardURITransferThreadCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser); -static int sharedClipboardURITransferThreadDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs); -static PSHAREDCLIPBOARDURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx); +static int sharedClipboardURITransferThreadCreate(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser); +static int sharedClipboardURITransferThreadDestroy(PSHCLURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs); +static PSHCLURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHCLURICTX pURI, uint32_t uIdx); static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode, - SHAREDCLIPBOARDOBJHANDLE handleInitial, uint64_t *pfOpen); + SHCLOBJHANDLE handleInitial, uint64_t *pfOpen); /** @todo Split this file up in different modules. */ @@ -43,7 +43,7 @@ * @returns Allocated URI root list on success, or NULL on failure. */ -PVBOXCLIPBOARDROOTLIST SharedClipboardURIRootListAlloc(void) -{ - PVBOXCLIPBOARDROOTLIST pRootList = (PVBOXCLIPBOARDROOTLIST)RTMemAllocZ(sizeof(VBOXCLIPBOARDROOTLIST)); +PSHCLROOTLIST SharedClipboardURIRootListAlloc(void) +{ + PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST)); return pRootList; @@ -56,5 +56,5 @@ * invalid after returning from this function. */ -void SharedClipboardURIRootListFree(PVBOXCLIPBOARDROOTLIST pRootList) +void SharedClipboardURIRootListFree(PSHCLROOTLIST pRootList) { if (!pRootList) @@ -74,9 +74,9 @@ * @param pRootLstHdr Root list header to initialize. */ -int SharedClipboardURIRootListHdrInit(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr) +int SharedClipboardURIRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr) { AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER); - RT_BZERO(pRootLstHdr, sizeof(VBOXCLIPBOARDROOTLISTHDR)); + RT_BZERO(pRootLstHdr, sizeof(SHCLROOTLISTHDR)); return VINF_SUCCESS; @@ -88,5 +88,5 @@ * @param pRootLstHdr Root list header to destroy. */ -void SharedClipboardURIRootListHdrDestroy(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr) +void SharedClipboardURIRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr) { if (!pRootLstHdr) @@ -103,5 +103,5 @@ * @param pRootLstHdr Root list header to duplicate. */ -PVBOXCLIPBOARDROOTLISTHDR SharedClipboardURIRootListHdrDup(PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr) +PSHCLROOTLISTHDR SharedClipboardURIRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr) { AssertPtrReturn(pRootLstHdr, NULL); @@ -109,5 +109,5 @@ int rc = VINF_SUCCESS; - PVBOXCLIPBOARDROOTLISTHDR pRootsDup = (PVBOXCLIPBOARDROOTLISTHDR)RTMemAllocZ(sizeof(VBOXCLIPBOARDROOTLISTHDR)); + PSHCLROOTLISTHDR pRootsDup = (PSHCLROOTLISTHDR)RTMemAllocZ(sizeof(SHCLROOTLISTHDR)); if (pRootsDup) { @@ -132,5 +132,5 @@ * @param pListEntry Clipboard root list entry to copy. */ -int SharedClipboardURIRootListEntryCopy(PVBOXCLIPBOARDROOTLISTENTRY pDst, PVBOXCLIPBOARDROOTLISTENTRY pSrc) +int SharedClipboardURIRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc) { return SharedClipboardURIListEntryCopy(pDst, pSrc); @@ -143,5 +143,5 @@ * @param pListEntry Clipboard root list entry to duplicate. */ -PVBOXCLIPBOARDROOTLISTENTRY SharedClipboardURIRootListEntryDup(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry) +PSHCLROOTLISTENTRY SharedClipboardURIRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry) { return SharedClipboardURIListEntryDup(pRootListEntry); @@ -153,5 +153,5 @@ * @param pListEntry Clipboard root list entry structure to destroy. */ -void SharedClipboardURIRootListEntryDestroy(PVBOXCLIPBOARDROOTLISTENTRY pRootListEntry) +void SharedClipboardURIRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry) { return SharedClipboardURIListEntryDestroy(pRootListEntry); @@ -163,5 +163,5 @@ * @param pInfo List handle info structure to destroy. */ -void SharedClipboardURIListHandleInfoDestroy(PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo) +void SharedClipboardURIListHandleInfoDestroy(PSHCLURILISTHANDLEINFO pInfo) { if (!pInfo) @@ -181,9 +181,9 @@ * @param ppListHdr Where to store the allocated URI list header structure on success. */ -int SharedClipboardURIListHdrAlloc(PVBOXCLIPBOARDLISTHDR *ppListHdr) +int SharedClipboardURIListHdrAlloc(PSHCLLISTHDR *ppListHdr) { int rc; - PVBOXCLIPBOARDLISTHDR pListHdr = (PVBOXCLIPBOARDLISTHDR)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTHDR)); + PSHCLLISTHDR pListHdr = (PSHCLLISTHDR)RTMemAllocZ(sizeof(SHCLLISTHDR)); if (pListHdr) { @@ -203,5 +203,5 @@ * @param pListEntry URI list header structure to free. */ -void SharedClipboardURIListHdrFree(PVBOXCLIPBOARDLISTHDR pListHdr) +void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr) { if (!pListHdr) @@ -222,9 +222,9 @@ * @param pListHdr URI list header to duplicate. */ -PVBOXCLIPBOARDLISTHDR SharedClipboardURIListHdrDup(PVBOXCLIPBOARDLISTHDR pListHdr) +PSHCLLISTHDR SharedClipboardURIListHdrDup(PSHCLLISTHDR pListHdr) { AssertPtrReturn(pListHdr, NULL); - PVBOXCLIPBOARDLISTHDR pListHdrDup = (PVBOXCLIPBOARDLISTHDR)RTMemAlloc(sizeof(VBOXCLIPBOARDLISTHDR)); + PSHCLLISTHDR pListHdrDup = (PSHCLLISTHDR)RTMemAlloc(sizeof(SHCLLISTHDR)); if (pListHdrDup) { @@ -241,5 +241,5 @@ * @param pListHdr Data header struct to initialize. */ -int SharedClipboardURIListHdrInit(PVBOXCLIPBOARDLISTHDR pListHdr) +int SharedClipboardURIListHdrInit(PSHCLLISTHDR pListHdr) { AssertPtrReturn(pListHdr, VERR_INVALID_POINTER); @@ -257,5 +257,5 @@ * @param pListHdr Data header struct to destroy. */ -void SharedClipboardURIListHdrDestroy(PVBOXCLIPBOARDLISTHDR pListHdr) +void SharedClipboardURIListHdrDestroy(PSHCLLISTHDR pListHdr) { if (!pListHdr) @@ -266,10 +266,10 @@ /** - * Resets a VBOXCLIPBOARDListHdr structture. - * - * @returns VBox status code. - * @param pListHdr VBOXCLIPBOARDListHdr structture to reset. - */ -void SharedClipboardURIListHdrReset(PVBOXCLIPBOARDLISTHDR pListHdr) + * Resets a SHCLListHdr structture. + * + * @returns VBox status code. + * @param pListHdr SHCLListHdr structture to reset. + */ +void SharedClipboardURIListHdrReset(PSHCLLISTHDR pListHdr) { AssertPtrReturnVoid(pListHdr); @@ -277,5 +277,5 @@ LogFlowFuncEnter(); - RT_BZERO(pListHdr, sizeof(VBOXCLIPBOARDLISTHDR)); + RT_BZERO(pListHdr, sizeof(SHCLLISTHDR)); } @@ -286,5 +286,5 @@ * @param pListHdr Clipboard data header to validate. */ -bool SharedClipboardURIListHdrIsValid(PVBOXCLIPBOARDLISTHDR pListHdr) +bool SharedClipboardURIListHdrIsValid(PSHCLLISTHDR pListHdr) { RT_NOREF(pListHdr); @@ -292,5 +292,5 @@ } -int SharedClipboardURIListOpenParmsCopy(PVBOXCLIPBOARDLISTOPENPARMS pDst, PVBOXCLIPBOARDLISTOPENPARMS pSrc) +int SharedClipboardURIListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc) { AssertPtrReturn(pDst, VERR_INVALID_POINTER); @@ -330,9 +330,9 @@ * @param pParms URI list open parameters structure to duplicate. */ -PVBOXCLIPBOARDLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PVBOXCLIPBOARDLISTOPENPARMS pParms) +PSHCLLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PSHCLLISTOPENPARMS pParms) { AssertPtrReturn(pParms, NULL); - PVBOXCLIPBOARDLISTOPENPARMS pParmsDup = (PVBOXCLIPBOARDLISTOPENPARMS)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTOPENPARMS)); + PSHCLLISTOPENPARMS pParmsDup = (PSHCLLISTOPENPARMS)RTMemAllocZ(sizeof(SHCLLISTOPENPARMS)); if (!pParmsDup) return NULL; @@ -356,9 +356,9 @@ * @param pParms URI list open parameters structure to initialize. */ -int SharedClipboardURIListOpenParmsInit(PVBOXCLIPBOARDLISTOPENPARMS pParms) +int SharedClipboardURIListOpenParmsInit(PSHCLLISTOPENPARMS pParms) { AssertPtrReturn(pParms, VERR_INVALID_POINTER); - RT_BZERO(pParms, sizeof(VBOXCLIPBOARDLISTOPENPARMS)); + RT_BZERO(pParms, sizeof(SHCLLISTOPENPARMS)); pParms->cbFilter = 64; /** @todo Make this dynamic. */ @@ -377,5 +377,5 @@ * @param pParms URI list open parameters structure to destroy. */ -void SharedClipboardURIListOpenParmsDestroy(PVBOXCLIPBOARDLISTOPENPARMS pParms) +void SharedClipboardURIListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms) { if (!pParms) @@ -400,7 +400,7 @@ * @param ppDirData Where to return the created clipboard list entry structure on success. */ -int SharedClipboardURIListEntryAlloc(PVBOXCLIPBOARDLISTENTRY *ppListEntry) -{ - PVBOXCLIPBOARDLISTENTRY pListEntry = (PVBOXCLIPBOARDLISTENTRY)RTMemAlloc(sizeof(VBOXCLIPBOARDLISTENTRY)); +int SharedClipboardURIListEntryAlloc(PSHCLLISTENTRY *ppListEntry) +{ + PSHCLLISTENTRY pListEntry = (PSHCLLISTENTRY)RTMemAlloc(sizeof(SHCLLISTENTRY)); if (!pListEntry) return VERR_NO_MEMORY; @@ -418,5 +418,5 @@ * @param pListEntry Clipboard list entry structure to free. */ -void SharedClipboardURIListEntryFree(PVBOXCLIPBOARDLISTENTRY pListEntry) +void SharedClipboardURIListEntryFree(PSHCLLISTENTRY pListEntry) { if (!pListEntry) @@ -433,5 +433,5 @@ * @param pListEntry Clipboard list entry to copy. */ -int SharedClipboardURIListEntryCopy(PVBOXCLIPBOARDLISTENTRY pDst, PVBOXCLIPBOARDLISTENTRY pSrc) +int SharedClipboardURIListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc) { AssertPtrReturn(pDst, VERR_INVALID_POINTER); @@ -480,5 +480,5 @@ * @param pListEntry Clipboard list entry to duplicate. */ -PVBOXCLIPBOARDLISTENTRY SharedClipboardURIListEntryDup(PVBOXCLIPBOARDLISTENTRY pListEntry) +PSHCLLISTENTRY SharedClipboardURIListEntryDup(PSHCLLISTENTRY pListEntry) { AssertPtrReturn(pListEntry, NULL); @@ -486,5 +486,5 @@ int rc = VINF_SUCCESS; - PVBOXCLIPBOARDLISTENTRY pListEntryDup = (PVBOXCLIPBOARDLISTENTRY)RTMemAllocZ(sizeof(VBOXCLIPBOARDLISTENTRY)); + PSHCLLISTENTRY pListEntryDup = (PSHCLLISTENTRY)RTMemAllocZ(sizeof(SHCLLISTENTRY)); if (pListEntryDup) rc = SharedClipboardURIListEntryCopy(pListEntryDup, pListEntry); @@ -507,13 +507,13 @@ * @param pListEntry Clipboard list entry structure to initialize. */ -int SharedClipboardURIListEntryInit(PVBOXCLIPBOARDLISTENTRY pListEntry) -{ - RT_BZERO(pListEntry, sizeof(VBOXCLIPBOARDLISTENTRY)); - - pListEntry->pszName = RTStrAlloc(VBOXCLIPBOARDLISTENTRY_MAX_NAME); +int SharedClipboardURIListEntryInit(PSHCLLISTENTRY pListEntry) +{ + RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY)); + + pListEntry->pszName = RTStrAlloc(SHCLLISTENTRY_MAX_NAME); if (!pListEntry->pszName) return VERR_NO_MEMORY; - pListEntry->cbName = VBOXCLIPBOARDLISTENTRY_MAX_NAME; + pListEntry->cbName = SHCLLISTENTRY_MAX_NAME; pListEntry->pvInfo = NULL; pListEntry->cbInfo = 0; @@ -528,5 +528,5 @@ * @param pListEntry Clipboard list entry structure to destroy. */ -void SharedClipboardURIListEntryDestroy(PVBOXCLIPBOARDLISTENTRY pListEntry) +void SharedClipboardURIListEntryDestroy(PSHCLLISTENTRY pListEntry) { if (!pListEntry) @@ -555,5 +555,5 @@ * @param pListEntry Clipboard data chunk to validate. */ -bool SharedClipboardURIListEntryIsValid(PVBOXCLIPBOARDLISTENTRY pListEntry) +bool SharedClipboardURIListEntryIsValid(PSHCLLISTENTRY pListEntry) { RT_NOREF(pListEntry); @@ -570,5 +570,5 @@ * @param pObjCtx URI object context to initialize. */ -int SharedClipboardURIObjCtxInit(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx) +int SharedClipboardURIObjCtxInit(PSHCLCLIENTURIOBJCTX pObjCtx) { AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER); @@ -576,5 +576,5 @@ LogFlowFuncEnter(); - pObjCtx->uHandle = SHAREDCLIPBOARDOBJHANDLE_INVALID; + pObjCtx->uHandle = SHCLOBJHANDLE_INVALID; return VINF_SUCCESS; @@ -586,5 +586,5 @@ * @param pObjCtx URI object context to destroy. */ -void SharedClipboardURIObjCtxDestroy(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx) +void SharedClipboardURIObjCtxDestroy(PSHCLCLIENTURIOBJCTX pObjCtx) { AssertPtrReturnVoid(pObjCtx); @@ -599,8 +599,8 @@ * @param pObjCtx URI object context to check. */ -bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx) +bool SharedClipboardURIObjCtxIsValid(PSHCLCLIENTURIOBJCTX pObjCtx) { return ( pObjCtx - && pObjCtx->uHandle != SHAREDCLIPBOARDOBJHANDLE_INVALID); + && pObjCtx->uHandle != SHCLOBJHANDLE_INVALID); } @@ -610,5 +610,5 @@ * @param pInfo Object handle info structure to destroy. */ -void SharedClipboardURIObjectHandleInfoDestroy(PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo) +void SharedClipboardURIObjectHandleInfoDestroy(PSHCLURIOBJHANDLEINFO pInfo) { if (!pInfo) @@ -628,5 +628,5 @@ * @param pParms URI object open parameters structure to initialize. */ -int SharedClipboardURIObjectOpenParmsInit(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms) +int SharedClipboardURIObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms) { AssertPtrReturn(pParms, VERR_INVALID_POINTER); @@ -634,5 +634,5 @@ int rc; - RT_BZERO(pParms, sizeof(VBOXCLIPBOARDOBJOPENCREATEPARMS)); + RT_BZERO(pParms, sizeof(SHCLOBJOPENCREATEPARMS)); pParms->cbPath = RTPATH_MAX; /** @todo Make this dynamic. */ @@ -656,5 +656,5 @@ * @param pParmsSrc Which source URI object open parameters to copy. */ -int SharedClipboardURIObjectOpenParmsCopy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsDst, PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsSrc) +int SharedClipboardURIObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc) { int rc; @@ -685,5 +685,5 @@ * @param pParms URI object open parameters structure to destroy. */ -void SharedClipboardURIObjectOpenParmsDestroy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms) +void SharedClipboardURIObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms) { if (!pParms) @@ -704,9 +704,9 @@ * @param hObj Object handle of the object to get handle info for. */ -inline PSHAREDCLIPBOARDURIOBJHANDLEINFO sharedClipboardURIObjectGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDOBJHANDLE hObj) -{ - PSHAREDCLIPBOARDURIOBJHANDLEINFO pIt; - RTListForEach(&pTransfer->lstObj, pIt, SHAREDCLIPBOARDURIOBJHANDLEINFO, Node) +inline PSHCLURIOBJHANDLEINFO sharedClipboardURIObjectGet(PSHCLURITRANSFER pTransfer, + SHCLOBJHANDLE hObj) +{ + PSHCLURIOBJHANDLEINFO pIt; + RTListForEach(&pTransfer->lstObj, pIt, SHCLURIOBJHANDLEINFO, Node) { if (pIt->hObj == hObj) @@ -725,6 +725,6 @@ * @param phObj Where to store the handle of URI object opened on success. */ -int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms, - PSHAREDCLIPBOARDOBJHANDLE phObj) +int SharedClipboardURIObjectOpen(PSHCLURITRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, + PSHCLOBJHANDLE phObj) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -736,8 +736,8 @@ LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pOpenCreateParms->pszPath, pOpenCreateParms->fCreate)); - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo - = (PSHAREDCLIPBOARDURIOBJHANDLEINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDURIOBJHANDLEINFO)); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURIOBJHANDLEINFO pInfo + = (PSHCLURIOBJHANDLEINFO)RTMemAlloc(sizeof(SHCLURIOBJHANDLEINFO)); if (pInfo) { @@ -747,5 +747,5 @@ rc = sharedClipboardConvertFileCreateFlags(fWritable, pOpenCreateParms->fCreate, pOpenCreateParms->ObjInfo.Attr.fMode, - SHAREDCLIPBOARDOBJHANDLE_INVALID, &fOpen); + SHCLOBJHANDLE_INVALID, &fOpen); if (RT_SUCCESS(rc)) { @@ -765,5 +765,5 @@ { pInfo->hObj = pTransfer->uObjHandleNext++; - pInfo->enmType = SHAREDCLIPBOARDURIOBJTYPE_FILE; + pInfo->enmType = SHCLURIOBJTYPE_FILE; RTListAppend(&pTransfer->lstObj, &pInfo->Node); @@ -778,5 +778,5 @@ rc = VERR_NO_MEMORY; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnObjOpen) @@ -799,5 +799,5 @@ * @param hObj Handle of URI object to close. */ -int SharedClipboardURIObjectClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj) +int SharedClipboardURIObjectClose(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -805,12 +805,12 @@ int rc = VINF_SUCCESS; - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj); if (pInfo) { switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY: + case SHCLURIOBJTYPE_DIRECTORY: { rc = RTDirClose(pInfo->u.Local.hDir); @@ -820,5 +820,5 @@ } - case SHAREDCLIPBOARDURIOBJTYPE_FILE: + case SHCLURIOBJTYPE_FILE: { rc = RTFileClose(pInfo->u.Local.hFile); @@ -840,5 +840,5 @@ rc = VERR_NOT_FOUND; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnObjClose) @@ -864,6 +864,6 @@ * @param pcbRead How much bytes were read on success. Optional. */ -int SharedClipboardURIObjectRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags) +int SharedClipboardURIObjectRead(PSHCLURITRANSFER pTransfer, + SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -875,12 +875,12 @@ int rc = VINF_SUCCESS; - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj); if (pInfo) { switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_FILE: + case SHCLURIOBJTYPE_FILE: { size_t cbRead; @@ -902,5 +902,5 @@ rc = VERR_NOT_FOUND; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnObjRead) @@ -926,6 +926,6 @@ * @param pcbWritten How much bytes were writtenon success. Optional. */ -int SharedClipboardURIObjectWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, +int SharedClipboardURIObjectWrite(PSHCLURITRANSFER pTransfer, + SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags) { @@ -937,12 +937,12 @@ int rc = VINF_SUCCESS; - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj); if (pInfo) { switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_FILE: + case SHCLURIOBJTYPE_FILE: { rc = RTFileWrite(pInfo->u.Local.hFile, pvBuf, cbBuf, (size_t *)pcbWritten); @@ -958,5 +958,5 @@ rc = VERR_NOT_FOUND; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnObjWrite) @@ -978,10 +978,10 @@ * @param pDataChunk URI object data chunk to duplicate. */ -PVBOXCLIPBOARDOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk) +PSHCLOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk) { if (!pDataChunk) return NULL; - PVBOXCLIPBOARDOBJDATACHUNK pDataChunkDup = (PVBOXCLIPBOARDOBJDATACHUNK)RTMemAllocZ(sizeof(VBOXCLIPBOARDOBJDATACHUNK)); + PSHCLOBJDATACHUNK pDataChunkDup = (PSHCLOBJDATACHUNK)RTMemAllocZ(sizeof(SHCLOBJDATACHUNK)); if (!pDataChunkDup) return NULL; @@ -1004,5 +1004,5 @@ * @param pDataChunk URI object data chunk to destroy. */ -void SharedClipboardURIObjectDataChunkDestroy(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk) +void SharedClipboardURIObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk) { if (!pDataChunk) @@ -1028,5 +1028,5 @@ * be invalid after calling this function. */ -void SharedClipboardURIObjectDataChunkFree(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk) +void SharedClipboardURIObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk) { if (!pDataChunk) @@ -1048,6 +1048,6 @@ * Must be destroyed by SharedClipboardURITransferDestroy(). */ -int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource, - PSHAREDCLIPBOARDURITRANSFER *ppTransfer) +int SharedClipboardURITransferCreate(SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, + PSHCLURITRANSFER *ppTransfer) { AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER); @@ -1055,5 +1055,5 @@ LogFlowFuncEnter(); - PSHAREDCLIPBOARDURITRANSFER pTransfer = (PSHAREDCLIPBOARDURITRANSFER)RTMemAlloc(sizeof(SHAREDCLIPBOARDURITRANSFER)); + PSHCLURITRANSFER pTransfer = (PSHCLURITRANSFER)RTMemAlloc(sizeof(SHCLURITRANSFER)); if (!pTransfer) return VERR_NO_MEMORY; @@ -1062,5 +1062,5 @@ pTransfer->State.uID = 0; - pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE; + pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_NONE; pTransfer->State.enmDir = enmDir; pTransfer->State.enmSource = enmSource; @@ -1115,5 +1115,5 @@ * @param pURI URI clipboard transfer to destroy. */ -int SharedClipboardURITransferDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer) +int SharedClipboardURITransferDestroy(PSHCLURITRANSFER pTransfer) { if (!pTransfer) @@ -1130,6 +1130,6 @@ SharedClipboardEventSourceDestroy(&pTransfer->Events); - PSHAREDCLIPBOARDURILISTHANDLEINFO pItList, pItListNext; - RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHAREDCLIPBOARDURILISTHANDLEINFO, Node) + PSHCLURILISTHANDLEINFO pItList, pItListNext; + RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLURILISTHANDLEINFO, Node) { SharedClipboardURIListHandleInfoDestroy(pItList); @@ -1140,6 +1140,6 @@ } - PSHAREDCLIPBOARDURIOBJHANDLEINFO pItObj, pItObjNext; - RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHAREDCLIPBOARDURIOBJHANDLEINFO, Node) + PSHCLURIOBJHANDLEINFO pItObj, pItObjNext; + RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLURIOBJHANDLEINFO, Node) { SharedClipboardURIObjectHandleInfoDestroy(pItObj); @@ -1154,5 +1154,5 @@ } -int SharedClipboardURITransferOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer) +int SharedClipboardURITransferOpen(PSHCLURITRANSFER pTransfer) { int rc = VINF_SUCCESS; @@ -1165,5 +1165,5 @@ } -int SharedClipboardURITransferClose(PSHAREDCLIPBOARDURITRANSFER pTransfer) +int SharedClipboardURITransferClose(PSHCLURITRANSFER pTransfer) { int rc = VINF_SUCCESS; @@ -1183,9 +1183,9 @@ * @param hList List handle of the list to get handle info for. */ -inline PSHAREDCLIPBOARDURILISTHANDLEINFO sharedClipboardURITransferListGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDLISTHANDLE hList) -{ - PSHAREDCLIPBOARDURILISTHANDLEINFO pIt; - RTListForEach(&pTransfer->lstList, pIt, SHAREDCLIPBOARDURILISTHANDLEINFO, Node) +inline PSHCLURILISTHANDLEINFO sharedClipboardURITransferListGet(PSHCLURITRANSFER pTransfer, + SHCLLISTHANDLE hList) +{ + PSHCLURILISTHANDLEINFO pIt; + RTListForEach(&pTransfer->lstList, pIt, SHCLURILISTHANDLEINFO, Node) { if (pIt->hList == hList) @@ -1199,8 +1199,8 @@ * Creates a new list handle (local only). * - * @returns New List handle on success, or SHAREDCLIPBOARDLISTHANDLE_INVALID on error. + * @returns New List handle on success, or SHCLLISTHANDLE_INVALID on error. * @param pTransfer URI clipboard transfer to create new list handle for. */ -inline SHAREDCLIPBOARDLISTHANDLE sharedClipboardURITransferListHandleNew(PSHAREDCLIPBOARDURITRANSFER pTransfer) +inline SHCLLISTHANDLE sharedClipboardURITransferListHandleNew(PSHCLURITRANSFER pTransfer) { return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */ @@ -1215,6 +1215,6 @@ * @param phList Where to store the List handle of opened list on success. */ -int SharedClipboardURITransferListOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, - PSHAREDCLIPBOARDLISTHANDLE phList) +int SharedClipboardURITransferListOpen(PSHCLURITRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, + PSHCLLISTHANDLE phList) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -1224,10 +1224,10 @@ int rc; - SHAREDCLIPBOARDLISTHANDLE hList = SHAREDCLIPBOARDLISTHANDLE_INVALID; - - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo - = (PSHAREDCLIPBOARDURILISTHANDLEINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDURILISTHANDLEINFO)); + SHCLLISTHANDLE hList = SHCLLISTHANDLE_INVALID; + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURILISTHANDLEINFO pInfo + = (PSHCLURILISTHANDLEINFO)RTMemAlloc(sizeof(SHCLURILISTHANDLEINFO)); if (pInfo) { @@ -1240,5 +1240,5 @@ switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY: + case SHCLURIOBJTYPE_DIRECTORY: { rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath); @@ -1246,5 +1246,5 @@ } - case SHAREDCLIPBOARDURIOBJTYPE_FILE: + case SHCLURIOBJTYPE_FILE: { rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath, @@ -1285,5 +1285,5 @@ rc = VERR_NO_MEMORY; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnListOpen) @@ -1311,21 +1311,21 @@ * @param hList Handle of list to close. */ -int SharedClipboardURITransferListClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList) +int SharedClipboardURITransferListClose(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); - if (hList == SHAREDCLIPBOARDLISTHANDLE_INVALID) + if (hList == SHCLLISTHANDLE_INVALID) return VINF_SUCCESS; int rc = VINF_SUCCESS; - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList); if (pInfo) { switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY: + case SHCLURIOBJTYPE_DIRECTORY: { if (RTDirIsValid(pInfo->u.Local.hDir)) @@ -1346,5 +1346,5 @@ rc = VERR_NOT_FOUND; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnListClose) @@ -1367,5 +1367,5 @@ * @param pszPath Path of file to add. */ -static int sharedClipboardURITransferListHdrAddFile(PVBOXCLIPBOARDLISTHDR pHdr, const char *pszPath) +static int sharedClipboardURITransferListHdrAddFile(PSHCLLISTHDR pHdr, const char *pszPath) { uint64_t cbSize = 0; @@ -1391,5 +1391,5 @@ * @param cchDstBase Number of charaters of destination base path. */ -static int sharedClipboardURITransferListHdrFromDir(PVBOXCLIPBOARDLISTHDR pHdr, +static int sharedClipboardURITransferListHdrFromDir(PSHCLLISTHDR pHdr, const char *pcszSrcPath, const char *pcszDstPath, const char *pcszDstBase) @@ -1543,6 +1543,6 @@ * @param pHdr Where to store the returned list header information. */ -int SharedClipboardURITransferListGetHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pHdr) +int SharedClipboardURITransferListGetHeader(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTHDR pHdr) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -1553,7 +1553,7 @@ LogFlowFunc(("hList=%RU64\n", hList)); - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList); if (pInfo) { @@ -1563,5 +1563,5 @@ switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY: + case SHCLURIOBJTYPE_DIRECTORY: { char *pszPathRel = sharedClipboardPathTranslate(pInfo->pszPathLocalAbs); @@ -1577,5 +1577,5 @@ } - case SHAREDCLIPBOARDURIOBJTYPE_FILE: + case SHCLURIOBJTYPE_FILE: { pHdr->cTotalObjects = 1; @@ -1601,5 +1601,5 @@ rc = VERR_NOT_FOUND; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnListHdrRead) @@ -1627,6 +1627,6 @@ * @param uIdx Index of object to get. */ -PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx) +PSHCLURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHCLURITRANSFER pTransfer, + SHCLLISTHANDLE hList, uint64_t uIdx) { AssertPtrReturn(pTransfer, NULL); @@ -1647,6 +1647,6 @@ * @param pEntry Where to store the read information. */ -int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pEntry) +int SharedClipboardURITransferListRead(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pEntry) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -1657,12 +1657,12 @@ LogFlowFunc(("hList=%RU64\n", hList)); - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList); if (pInfo) { switch (pInfo->enmType) { - case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY: + case SHCLURIOBJTYPE_DIRECTORY: { LogFlowFunc(("\tDirectory: %s\n", pInfo->pszPathLocalAbs)); @@ -1711,5 +1711,5 @@ && !fSkipEntry) { - pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO)); + pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(sizeof(SHCLFSOBJINFO)); if (pEntry->pvInfo) { @@ -1717,8 +1717,8 @@ if (RT_SUCCESS(rc)) { - SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info); - - pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO); - pEntry->fInfo = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO; + SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info); + + pEntry->cbInfo = sizeof(SHCLFSOBJINFO); + pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO; } } @@ -1740,5 +1740,5 @@ } - case SHAREDCLIPBOARDURIOBJTYPE_FILE: + case SHCLURIOBJTYPE_FILE: { LogFlowFunc(("\tSingle file: %s\n", pInfo->pszPathLocalAbs)); @@ -1748,5 +1748,5 @@ if (RT_SUCCESS(rc)) { - pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO)); + pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(sizeof(SHCLFSOBJINFO)); if (pEntry->pvInfo) { @@ -1754,8 +1754,8 @@ if (RT_SUCCESS(rc)) { - SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo); - - pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO); - pEntry->fInfo = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO; + SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo); + + pEntry->cbInfo = sizeof(SHCLFSOBJINFO); + pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO; } } @@ -1775,5 +1775,5 @@ rc = VERR_NOT_FOUND; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnListEntryRead) @@ -1787,6 +1787,6 @@ } -int SharedClipboardURITransferListWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pEntry) +int SharedClipboardURITransferListWrite(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pEntry) { RT_NOREF(pTransfer, hList, pEntry); @@ -1810,13 +1810,13 @@ * @param hList List handle to check. */ -bool SharedClipboardURITransferListHandleIsValid(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList) +bool SharedClipboardURITransferListHandleIsValid(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList) { bool fIsValid = false; - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) { fIsValid = sharedClipboardURITransferListGet(pTransfer, hList) != NULL; } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { AssertFailed(); /** @todo Implement. */ @@ -1832,5 +1832,5 @@ * @param pTransfer URI clipboard transfer to prepare. */ -int SharedClipboardURITransferPrepare(PSHAREDCLIPBOARDURITRANSFER pTransfer) +int SharedClipboardURITransferPrepare(PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -1840,5 +1840,5 @@ int rc = VINF_SUCCESS; - AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_NONE, + AssertMsgReturn(pTransfer->State.enmStatus == SHCLURITRANSFERSTATUS_NONE, ("Transfer has wrong state (%RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER); @@ -1847,5 +1847,5 @@ if (pTransfer->Callbacks.pfnTransferPrepare) { - SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser }; + SHCLURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser }; pTransfer->Callbacks.pfnTransferPrepare(&callbackData); } @@ -1853,5 +1853,5 @@ if (RT_SUCCESS(rc)) { - pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_READY; + pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_READY; /** @todo Add checksum support. */ @@ -1869,6 +1869,6 @@ * @param pCreationCtx Provider creation context to use for provider creation. */ -int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer, - PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx) +int SharedClipboardURITransferSetInterface(PSHCLURITRANSFER pTransfer, + PSHCLPROVIDERCREATIONCTX pCreationCtx) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -1906,5 +1906,5 @@ * @param pTransfer Transfer to clear URI root list for. */ -static void sharedClipboardURIListTransferRootsClear(PSHAREDCLIPBOARDURITRANSFER pTransfer) +static void sharedClipboardURIListTransferRootsClear(PSHCLURITRANSFER pTransfer) { AssertPtrReturnVoid(pTransfer); @@ -1916,6 +1916,6 @@ } - PSHAREDCLIPBOARDURILISTROOT pListRoot, pListRootNext; - RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHAREDCLIPBOARDURILISTROOT, Node) + PSHCLURILISTROOT pListRoot, pListRootNext; + RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHCLURILISTROOT, Node) { RTStrFree(pListRoot->pszPathAbs); @@ -1939,5 +1939,5 @@ * @param cbRoots Size (in bytes) of string list. */ -int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots) +int SharedClipboardURILTransferSetRoots(PSHCLURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -1957,5 +1957,5 @@ for (size_t i = 0; i < lstRootEntries.size(); ++i) { - PSHAREDCLIPBOARDURILISTROOT pListRoot = (PSHAREDCLIPBOARDURILISTROOT)RTMemAlloc(sizeof(SHAREDCLIPBOARDURILISTROOT)); + PSHCLURILISTROOT pListRoot = (PSHCLURILISTROOT)RTMemAlloc(sizeof(SHCLURILISTROOT)); AssertPtrBreakStmt(pListRoot, rc = VERR_NO_MEMORY); @@ -2007,5 +2007,5 @@ * @param pTransfer URI clipboard transfer to reset. */ -void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer) +void SharedClipboardURITransferReset(PSHCLURITRANSFER pTransfer) { AssertPtrReturnVoid(pTransfer); @@ -2022,5 +2022,5 @@ * @param pTransfer URI clipboard transfer to return clipboard area for. */ -SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer) +SharedClipboardArea *SharedClipboardURITransferGetArea(PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pTransfer, NULL); @@ -2035,5 +2035,5 @@ * @param pTransfer URI clipboard transfer to return root entry count for. */ -uint32_t SharedClipboardURILTransferRootsCount(PSHAREDCLIPBOARDURITRANSFER pTransfer) +uint32_t SharedClipboardURILTransferRootsCount(PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pTransfer, 0); @@ -2049,12 +2049,12 @@ * @param uIdx Index of root list entry to return. */ -inline PSHAREDCLIPBOARDURILISTROOT sharedClipboardURILTransferRootsGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uIdx) +inline PSHCLURILISTROOT sharedClipboardURILTransferRootsGet(PSHCLURITRANSFER pTransfer, uint32_t uIdx) { if (uIdx >= pTransfer->cRoots) return NULL; - PSHAREDCLIPBOARDURILISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHAREDCLIPBOARDURILISTROOT, Node); + PSHCLURILISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHCLURILISTROOT, Node); while (uIdx--) - pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHAREDCLIPBOARDURILISTROOT, Node); + pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHCLURILISTROOT, Node); return pIt; @@ -2069,6 +2069,6 @@ * @param pEntry Where to store the returned entry on success. */ -int SharedClipboardURILTransferRootsEntry(PSHAREDCLIPBOARDURITRANSFER pTransfer, - uint64_t uIndex, PVBOXCLIPBOARDROOTLISTENTRY pEntry) +int SharedClipboardURILTransferRootsEntry(PSHCLURITRANSFER pTransfer, + uint64_t uIndex, PSHCLROOTLISTENTRY pEntry) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -2080,5 +2080,5 @@ int rc; - PSHAREDCLIPBOARDURILISTROOT pRoot = sharedClipboardURILTransferRootsGet(pTransfer, uIndex); + PSHCLURILISTROOT pRoot = sharedClipboardURILTransferRootsGet(pTransfer, uIndex); AssertPtrReturn(pRoot, VERR_INVALID_PARAMETER); @@ -2101,6 +2101,6 @@ if (RT_SUCCESS(rc)) { - pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO); - pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(pEntry->cbInfo); + pEntry->cbInfo = sizeof(SHCLFSOBJINFO); + pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(pEntry->cbInfo); if (pEntry->pvInfo) { @@ -2109,7 +2109,7 @@ if (RT_SUCCESS(rc)) { - SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &fsObjInfo); - - pEntry->fInfo = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO; + SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo); + + pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO; } } @@ -2133,5 +2133,5 @@ * @param ppRootList Where to store the root list on success. */ -int SharedClipboardURILTransferRootsAsList(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDROOTLIST *ppRootList) +int SharedClipboardURILTransferRootsAsList(PSHCLURITRANSFER pTransfer, PSHCLROOTLIST *ppRootList) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -2142,7 +2142,7 @@ int rc = VINF_SUCCESS; - if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL) - { - PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc(); + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLROOTLIST pRootList = SharedClipboardURIRootListAlloc(); if (!pRootList) return VERR_NO_MEMORY; @@ -2154,6 +2154,6 @@ if (cRoots) { - PVBOXCLIPBOARDROOTLISTENTRY paRootListEntries - = (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY)); + PSHCLROOTLISTENTRY paRootListEntries + = (PSHCLROOTLISTENTRY)RTMemAllocZ(cRoots * sizeof(SHCLROOTLISTENTRY)); if (paRootListEntries) { @@ -2182,5 +2182,5 @@ } } - else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE) + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) { if (pTransfer->ProviderIface.pfnGetRoots) @@ -2200,7 +2200,7 @@ * @param pTransfer URI clipboard transfer to return source for. */ -SHAREDCLIPBOARDSOURCE SharedClipboardURITransferGetSource(PSHAREDCLIPBOARDURITRANSFER pTransfer) -{ - AssertPtrReturn(pTransfer, SHAREDCLIPBOARDSOURCE_INVALID); +SHCLSOURCE SharedClipboardURITransferGetSource(PSHCLURITRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID); return pTransfer->State.enmSource; @@ -2213,7 +2213,7 @@ * @param pTransfer URI clipboard transfer to return status for. */ -SHAREDCLIPBOARDURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHAREDCLIPBOARDURITRANSFER pTransfer) -{ - AssertPtrReturn(pTransfer, SHAREDCLIPBOARDURITRANSFERSTATUS_NONE); +SHCLURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHCLURITRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, SHCLURITRANSFERSTATUS_NONE); return pTransfer->State.enmStatus; @@ -2228,9 +2228,9 @@ * @param pvUser Pointer to user-provided data. */ -int SharedClipboardURITransferRun(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser) +int SharedClipboardURITransferRun(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); - AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_READY, + AssertMsgReturn(pTransfer->State.enmStatus == SHCLURITRANSFERSTATUS_READY, ("Wrong status (currently is %RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER); @@ -2248,6 +2248,6 @@ * @param pCallbacks Pointer to callback table to set. */ -void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer, - PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks) +void SharedClipboardURITransferSetCallbacks(PSHCLURITRANSFER pTransfer, + PSHCLURITRANSFERCALLBACKS pCallbacks) { AssertPtrReturnVoid(pTransfer); @@ -2281,5 +2281,5 @@ * @param pvUser Pointer to user-provided data. */ -static int sharedClipboardURITransferThreadCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser) +static int sharedClipboardURITransferThreadCreate(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser) { @@ -2297,5 +2297,5 @@ if (pTransfer->Thread.fStarted) /* Did the thread indicate that it started correctly? */ { - pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING; + pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_RUNNING; } else @@ -2314,5 +2314,5 @@ * @param uTimeoutMs Timeout (in ms) to wait for thread creation. */ -static int sharedClipboardURITransferThreadDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs) +static int sharedClipboardURITransferThreadDestroy(PSHCLURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -2340,5 +2340,5 @@ * @param pURI URI clipboard context to initialize. */ -int SharedClipboardURICtxInit(PSHAREDCLIPBOARDURICTX pURI) +int SharedClipboardURICtxInit(PSHCLURICTX pURI) { AssertPtrReturn(pURI, VERR_INVALID_POINTER); @@ -2368,5 +2368,5 @@ * @param pURI URI clipboard context to destroy. */ -void SharedClipboardURICtxDestroy(PSHAREDCLIPBOARDURICTX pURI) +void SharedClipboardURICtxDestroy(PSHCLURICTX pURI) { AssertPtrReturnVoid(pURI); @@ -2376,6 +2376,6 @@ RTCritSectDelete(&pURI->CritSect); - PSHAREDCLIPBOARDURITRANSFER pTransfer, pTransferNext; - RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHAREDCLIPBOARDURITRANSFER, Node) + PSHCLURITRANSFER pTransfer, pTransferNext; + RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHCLURITRANSFER, Node) { SharedClipboardURITransferDestroy(pTransfer); @@ -2396,5 +2396,5 @@ * @param pURI URI clipboard context to reset. */ -void SharedClipboardURICtxReset(PSHAREDCLIPBOARDURICTX pURI) +void SharedClipboardURICtxReset(PSHCLURICTX pURI) { AssertPtrReturnVoid(pURI); @@ -2402,6 +2402,6 @@ LogFlowFuncEnter(); - PSHAREDCLIPBOARDURITRANSFER pTransfer; - RTListForEach(&pURI->List, pTransfer, SHAREDCLIPBOARDURITRANSFER, Node) + PSHCLURITRANSFER pTransfer; + RTListForEach(&pURI->List, pTransfer, SHCLURITRANSFER, Node) SharedClipboardURITransferReset(pTransfer); } @@ -2414,5 +2414,5 @@ * @param pTransfer Pointer to URI clipboard transfer to add. */ -int SharedClipboardURICtxTransferAdd(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int SharedClipboardURICtxTransferAdd(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pURI, VERR_INVALID_POINTER); @@ -2439,5 +2439,5 @@ * @param pTransfer Pointer to URI clipboard transfer to remove. */ -int SharedClipboardURICtxTransferRemove(PSHAREDCLIPBOARDURICTX pURI, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int SharedClipboardURICtxTransferRemove(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pURI, VERR_INVALID_POINTER); @@ -2467,8 +2467,8 @@ * @param uIdx Index of the transfer to return. */ -static PSHAREDCLIPBOARDURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx) +static PSHCLURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHCLURICTX pURI, uint32_t uIdx) { AssertReturn(uIdx == 0, NULL); /* Only one transfer allowed at the moment. */ - return RTListGetFirst(&pURI->List, SHAREDCLIPBOARDURITRANSFER, Node); + return RTListGetFirst(&pURI->List, SHCLURITRANSFER, Node); } @@ -2480,5 +2480,5 @@ * @param uIdx Index of the transfer to return. */ -PSHAREDCLIPBOARDURITRANSFER SharedClipboardURICtxGetTransfer(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx) +PSHCLURITRANSFER SharedClipboardURICtxGetTransfer(PSHCLURICTX pURI, uint32_t uIdx) { return sharedClipboardURICtxGetTransferInternal(pURI, uIdx); @@ -2491,5 +2491,5 @@ * @param pURI URI clipboard context to return number for. */ -uint32_t SharedClipboardURICtxGetRunningTransfers(PSHAREDCLIPBOARDURICTX pURI) +uint32_t SharedClipboardURICtxGetRunningTransfers(PSHCLURICTX pURI) { AssertPtrReturn(pURI, 0); @@ -2503,5 +2503,5 @@ * @param pURI URI clipboard context to return number for. */ -uint32_t SharedClipboardURICtxGetTotalTransfers(PSHAREDCLIPBOARDURICTX pURI) +uint32_t SharedClipboardURICtxGetTotalTransfers(PSHCLURICTX pURI) { AssertPtrReturn(pURI, 0); @@ -2515,5 +2515,5 @@ * @param pURI URI clipboard context to cleanup transfers for. */ -void SharedClipboardURICtxTransfersCleanup(PSHAREDCLIPBOARDURICTX pURI) +void SharedClipboardURICtxTransfersCleanup(PSHCLURICTX pURI) { AssertPtrReturnVoid(pURI); @@ -2522,8 +2522,8 @@ /* Remove all transfers which are not in a running state (e.g. only announced). */ - PSHAREDCLIPBOARDURITRANSFER pTransfer, pTransferNext; - RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHAREDCLIPBOARDURITRANSFER, Node) - { - if (SharedClipboardURITransferGetStatus(pTransfer) != SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING) + PSHCLURITRANSFER pTransfer, pTransferNext; + RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHCLURITRANSFER, Node) + { + if (SharedClipboardURITransferGetStatus(pTransfer) != SHCLURITRANSFERSTATUS_RUNNING) { SharedClipboardURITransferDestroy(pTransfer); @@ -2545,5 +2545,5 @@ * @param pURI URI clipboard context to determine value for. */ -bool SharedClipboardURICtxTransfersMaximumReached(PSHAREDCLIPBOARDURICTX pURI) +bool SharedClipboardURICtxTransfersMaximumReached(PSHCLURICTX pURI) { AssertPtrReturn(pURI, true); @@ -2561,5 +2561,5 @@ * @param pSrc The IPRT structure to convert data from. */ -void SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO pDst, PCRTFSOBJINFO pSrc) +void SharedClipboardFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc) { pDst->cbObject = pSrc->cbObject; @@ -2577,9 +2577,9 @@ default: case RTFSOBJATTRADD_NOTHING: - pDst->Attr.enmAdditional = SHAREDCLIPBOARDFSOBJATTRADD_NOTHING; + pDst->Attr.enmAdditional = SHCLFSOBJATTRADD_NOTHING; break; case RTFSOBJATTRADD_UNIX: - pDst->Attr.enmAdditional = SHAREDCLIPBOARDFSOBJATTRADD_UNIX; + pDst->Attr.enmAdditional = SHCLFSOBJATTRADD_UNIX; pDst->Attr.u.Unix.uid = pSrc->Attr.u.Unix.uid; pDst->Attr.u.Unix.gid = pSrc->Attr.u.Unix.gid; @@ -2593,5 +2593,5 @@ case RTFSOBJATTRADD_EASIZE: - pDst->Attr.enmAdditional = SHAREDCLIPBOARDFSOBJATTRADD_EASIZE; + pDst->Attr.enmAdditional = SHCLFSOBJATTRADD_EASIZE; pDst->Attr.u.EASize.cb = pSrc->Attr.u.EASize.cb; break; @@ -2612,5 +2612,5 @@ */ static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode, - SHAREDCLIPBOARDOBJHANDLE handleInitial, uint64_t *pfOpen) + SHCLOBJHANDLE handleInitial, uint64_t *pfOpen) { uint64_t fOpen = 0; @@ -2640,5 +2640,5 @@ * and it contained random bits from stack. Detect this using the handle field value * passed from the guest: old additions set it (incorrectly) to 0, new additions - * set it to SHAREDCLIPBOARDOBJHANDLE_INVALID(~0). + * set it to SHCLOBJHANDLE_INVALID(~0). */ if (handleInitial == 0) @@ -2656,74 +2656,74 @@ } - switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_RW)) + switch ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_RW)) { default: - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE: + case SHCL_OBJ_CF_ACCESS_NONE: { #ifdef RT_OS_WINDOWS - if ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR) != SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE) + if ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_ATTR) != SHCL_OBJ_CF_ACCESS_ATTR_NONE) fOpen |= RTFILE_O_ATTR_ONLY; else #endif fOpen |= RTFILE_O_READ; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_NONE\n")); break; } - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ: + case SHCL_OBJ_CF_ACCESS_READ: { fOpen |= RTFILE_O_READ; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_READ\n")); break; } - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE: + case SHCL_OBJ_CF_ACCESS_WRITE: { fOpen |= RTFILE_O_WRITE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_WRITE\n")); break; } - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE: + case SHCL_OBJ_CF_ACCESS_READWRITE: { fOpen |= RTFILE_O_READWRITE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_READWRITE\n")); break; } } - if (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_APPEND) + if (fShClFlags & SHCL_OBJ_CF_ACCESS_APPEND) { fOpen |= RTFILE_O_APPEND; } - switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR)) + switch ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_ATTR)) { default: - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE: + case SHCL_OBJ_CF_ACCESS_ATTR_NONE: { fOpen |= RTFILE_O_ACCESS_ATTR_DEFAULT; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_NONE\n")); break; } - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ: + case SHCL_OBJ_CF_ACCESS_ATTR_READ: { fOpen |= RTFILE_O_ACCESS_ATTR_READ; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_READ\n")); break; } - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE: + case SHCL_OBJ_CF_ACCESS_ATTR_WRITE: { fOpen |= RTFILE_O_ACCESS_ATTR_WRITE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_WRITE\n")); break; } - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE: + case SHCL_OBJ_CF_ACCESS_ATTR_READWRITE: { fOpen |= RTFILE_O_ACCESS_ATTR_READWRITE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_READWRITE\n")); break; } @@ -2731,41 +2731,41 @@ /* Sharing mask */ - switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_DENY)) + switch ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_DENY)) { default: - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE: + case SHCL_OBJ_CF_ACCESS_DENYNONE: fOpen |= RTFILE_O_DENY_NONE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYNONE\n")); break; - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD: + case SHCL_OBJ_CF_ACCESS_DENYREAD: fOpen |= RTFILE_O_DENY_READ; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYREAD\n")); break; - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE: + case SHCL_OBJ_CF_ACCESS_DENYWRITE: fOpen |= RTFILE_O_DENY_WRITE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYWRITE\n")); break; - case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL: + case SHCL_OBJ_CF_ACCESS_DENYALL: fOpen |= RTFILE_O_DENY_ALL; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYALL\n")); break; } /* Open/Create action mask */ - switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS)) - { - case SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS: - if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + switch ((fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_EXISTS)) + { + case SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS: + if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_OPEN_CREATE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n")); } - else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + else if (SHCL_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_OPEN; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_OPEN_IF_EXISTS and SHCL_OBJ_CF_ACT_FAIL_IF_NEW\n")); } else @@ -2775,9 +2775,9 @@ } break; - case SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS: - if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + case SHCL_OBJ_CF_ACT_FAIL_IF_EXISTS: + if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_CREATE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_FAIL_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n")); } else @@ -2787,14 +2787,14 @@ } break; - case SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS: - if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + case SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS: + if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_CREATE_REPLACE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n")); } - else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + else if (SHCL_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHCL_OBJ_CF_ACT_FAIL_IF_NEW\n")); } else @@ -2804,14 +2804,14 @@ } break; - case SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS: - if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + case SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS: + if (SHCL_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_CREATE_REPLACE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHCL_OBJ_CF_ACT_CREATE_IF_NEW\n")); } - else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW)) + else if (SHCL_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHCL_OBJ_CF_ACT_MASK_IF_NEW)) { fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHCL_OBJ_CF_ACT_FAIL_IF_NEW\n")); } else @@ -2824,5 +2824,5 @@ { rc = VERR_INVALID_PARAMETER; - LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS - invalid parameter\n")); + LogFlowFunc(("SHCL_OBJ_CF_ACT_MASK_IF_EXISTS - invalid parameter\n")); break; } Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp (revision 80662) @@ -154,5 +154,5 @@ * Will be set to NULL if the new API is not available. */ -int VBoxClipboardWinCheckAndInitNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI) +int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI) { RTLDRMOD hUser32 = NIL_RTLDRMOD; @@ -175,5 +175,5 @@ else { - RT_BZERO(pAPI, sizeof(VBOXCLIPBOARDWINAPINEW)); + RT_BZERO(pAPI, sizeof(SHCLWINAPINEW)); LogFunc(("New Clipboard API not available; rc=%Rrc\n", rc)); } @@ -188,5 +188,5 @@ * @param pAPI Structure used for checking if the new clipboard API is available or not. */ -bool VBoxClipboardWinIsNewAPI(PVBOXCLIPBOARDWINAPINEW pAPI) +bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI) { if (!pAPI) @@ -201,7 +201,7 @@ * @param pCtx Windows clipboard context to use to add ourselves. */ -int VBoxClipboardWinChainAdd(PVBOXCLIPBOARDWINCTX pCtx) -{ - const PVBOXCLIPBOARDWINAPINEW pAPI = &pCtx->newAPI; +int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx) +{ + const PSHCLWINAPINEW pAPI = &pCtx->newAPI; BOOL fRc; @@ -234,10 +234,10 @@ * @param pCtx Windows clipboard context to use to remove ourselves. */ -int VBoxClipboardWinChainRemove(PVBOXCLIPBOARDWINCTX pCtx) +int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx) { if (!pCtx->hWnd) return VINF_SUCCESS; - const PVBOXCLIPBOARDWINAPINEW pAPI = &pCtx->newAPI; + const PSHCLWINAPINEW pAPI = &pCtx->newAPI; BOOL fRc; @@ -283,5 +283,5 @@ /** @todo r=andy Why not using SetWindowLongPtr for keeping the context? */ - PVBOXCLIPBOARDWINCTX pCtx = (PVBOXCLIPBOARDWINCTX)dwData; + PSHCLWINCTX pCtx = (PSHCLWINCTX)dwData; AssertPtrReturnVoid(pCtx); @@ -298,5 +298,5 @@ * @param lParam LPARAM to pass. */ -LRESULT VBoxClipboardWinChainPassToNext(PVBOXCLIPBOARDWINCTX pWinCtx, +LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam) { @@ -327,8 +327,8 @@ * @param uFormat Windows clipboard format to convert. */ -VBOXCLIPBOARDFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat) +SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat) { /* Insert the requested clipboard format data into the clipboard. */ - VBOXCLIPBOARDFORMAT vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_NONE; + SHCLFORMAT vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_NONE; switch (uFormat) @@ -386,10 +386,10 @@ * @param pFormats Where to store the retrieved formats. */ -int VBoxClipboardWinGetFormats(PVBOXCLIPBOARDWINCTX pCtx, PSHAREDCLIPBOARDFORMATDATA pFormats) +int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); AssertPtrReturn(pFormats, VERR_INVALID_POINTER); - VBOXCLIPBOARDFORMATS fFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE; + SHCLFORMATS fFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE; /* Query list of available formats and report to host. */ @@ -649,5 +649,5 @@ * @param lParam lParam to pass on. */ -LRESULT VBoxClipboardWinHandleWMChangeCBChain(PVBOXCLIPBOARDWINCTX pWinCtx, +LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { @@ -697,5 +697,5 @@ * @param pWinCtx Windows context to use. */ -int VBoxClipboardWinHandleWMDestroy(PVBOXCLIPBOARDWINCTX pWinCtx) +int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx) { LogFlowFuncEnter(); @@ -723,5 +723,5 @@ * @param hWnd Window handle to use. */ -int VBoxClipboardWinHandleWMRenderAllFormats(PVBOXCLIPBOARDWINCTX pWinCtx, HWND hWnd) +int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd) { RT_NOREF(pWinCtx); @@ -750,5 +750,5 @@ * @param pWinCtx Windows context to use. */ -int VBoxClipboardWinHandleWMTimer(PVBOXCLIPBOARDWINCTX pWinCtx) +int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx) { int rc = VINF_SUCCESS; @@ -790,5 +790,5 @@ * @param fFormats Clipboard format(s) to announce. */ -int VBoxClipboardWinAnnounceFormats(PVBOXCLIPBOARDWINCTX pWinCtx, VBOXCLIPBOARDFORMATS fFormats) +int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats) { LogFunc(("fFormats=0x%x\n", fFormats)); @@ -846,5 +846,5 @@ * @param pTransfer URI transfer to use. */ -int VBoxClipboardWinURITransferCreate(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -912,5 +912,5 @@ * @param pTransfer URI transfer to create implementation-specific data for. */ -void VBoxClipboardWinURITransferDestroy(PVBOXCLIPBOARDWINCTX pWinCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer) +void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer) { RT_NOREF(pWinCtx); Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp (revision 80661) +++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp (revision 80662) @@ -206,5 +206,5 @@ { /** Opaque data structure describing the front-end. */ - VBOXCLIPBOARDCONTEXT *pFrontend; + SHCLCONTEXT *pFrontend; /** Is an X server actually available? */ bool fHaveX11; @@ -926,5 +926,5 @@ * @note X11 backend code */ -CLIPBACKEND *ClipConstructX11(VBOXCLIPBOARDCONTEXT *pFrontend, bool fHeadless) +CLIPBACKEND *ClipConstructX11(SHCLCONTEXT *pFrontend, bool fHeadless) { CLIPBACKEND *pCtx = (CLIPBACKEND *)RTMemAllocZ(sizeof(CLIPBACKEND)); @@ -2120,5 +2120,5 @@ /* Return the data in the simulated VBox clipboard. */ -int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) +int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) { RT_NOREF2(pCtx, u32Format); @@ -2241,5 +2241,5 @@ static uint32_t g_fX11Formats = 0; -void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats) +void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats) { RT_NOREF1(pCtx); @@ -2389,5 +2389,5 @@ static char g_completedBuf[MAX_BUF_SIZE]; -void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) +void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) { RT_NOREF1(pCtx); @@ -2885,5 +2885,5 @@ # include -int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) +int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) { RT_NOREF4(pCtx, u32Format, ppv, pcb); @@ -2891,10 +2891,10 @@ } -void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats) +void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats) { RT_NOREF2(pCtx, u32Formats); } -void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) +void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) { RT_NOREF5(pCtx, rc, pReq, pv, cb); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp (revision 80662) @@ -35,5 +35,5 @@ *********************************************************************************************************************************/ /** Global clipboard context information */ -struct _VBOXCLIPBOARDCONTEXT +struct _SHCLCONTEXT { /** We have a separate thread to poll for new clipboard content */ @@ -42,5 +42,5 @@ /** The reference to the current pasteboard */ PasteboardRef pasteboard; - PVBOXCLIPBOARDCLIENT pClient; + PSHCLCLIENT pClient; }; @@ -50,5 +50,5 @@ *********************************************************************************************************************************/ /** Only one client is supported. There seems to be no need for more clients. */ -static VBOXCLIPBOARDCONTEXT g_ctx; +static SHCLCONTEXT g_ctx; @@ -59,5 +59,5 @@ * @param pCtx The context. */ -static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx) +static int vboxClipboardChanged(SHCLCONTEXT *pCtx) { if (pCtx->pClient == NULL) @@ -71,5 +71,5 @@ && fChanged) { - SHAREDCLIPBOARDFORMATDATA formatData; + SHCLFORMATDATA formatData; RT_ZERO(formatData); @@ -90,5 +90,5 @@ * @returns VINF_SUCCESS (not used). * @param ThreadSelf Our thread handle. - * @param pvUser Pointer to the VBOXCLIPBOARDCONTEXT structure. + * @param pvUser Pointer to the SHCLCONTEXT structure. * */ @@ -98,5 +98,5 @@ AssertPtrReturn(pvUser, VERR_INVALID_PARAMETER); - VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)pvUser; + SHCLCONTEXT *pCtx = (SHCLCONTEXT *)pvUser; while (!pCtx->fTerminate) @@ -156,5 +156,5 @@ } -int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless) +int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { RT_NOREF(fHeadless); @@ -178,5 +178,5 @@ } -int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) { /* Sync the host clipboard content with the client. */ @@ -190,5 +190,5 @@ } -int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { VBoxSvcClipboardLock(); @@ -201,6 +201,6 @@ } -int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, - PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats) +int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, + PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats) { RT_NOREF(pCmdCtx); @@ -219,5 +219,5 @@ #endif - SHAREDCLIPBOARDDATAREQ dataReq; + SHCLDATAREQ dataReq; RT_ZERO(dataReq); @@ -236,6 +236,6 @@ * @param pcbActual Where to write the actual size of the written data. */ -int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual) +int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData, uint32_t *pcbActual) { RT_NOREF(pCmdCtx); @@ -262,6 +262,6 @@ * @param pData Data block to write to clipboard. */ -int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, - PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData) +int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, + PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData) { RT_NOREF(pCmdCtx); @@ -277,5 +277,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData) +int VBoxClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData) { RT_NOREF(pClient, pDirData); @@ -283,5 +283,5 @@ } -int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDDIRDATA pDirData) +int VBoxClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData) { RT_NOREF(pClient, pDirData); @@ -289,5 +289,5 @@ } -int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr) +int VBoxClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr) { RT_NOREF(pClient, pFileHdr); @@ -295,5 +295,5 @@ } -int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEHDR pFileHdr) +int VBoxClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr) { RT_NOREF(pClient, pFileHdr); @@ -301,5 +301,5 @@ } -int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData) +int VBoxClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData) { RT_NOREF(pClient, pFileData); @@ -307,5 +307,5 @@ } -int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDFILEDATA pFileData) +int VBoxClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData) { RT_NOREF(pClient, pFileData); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h (revision 80662) @@ -40,5 +40,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -struct VBOXCLIPBOARDCLIENTSTATE; +struct SHCLCLIENTSTATE; #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ @@ -55,5 +55,5 @@ * Structure for keeping a single HGCM message. */ -typedef struct _VBOXCLIPBOARDCLIENTMSG +typedef struct _SHCLCLIENTMSG { /** Stored message type. */ @@ -65,11 +65,11 @@ /** Message context. */ VBOXSHCLMSGCTX m_Ctx; -} VBOXCLIPBOARDCLIENTMSG, *PVBOXCLIPBOARDCLIENTMSG; - -typedef struct VBOXCLIPBOARDCLIENTURISTATE +} SHCLCLIENTMSG, *PSHCLCLIENTMSG; + +typedef struct SHCLCLIENTURISTATE { /** Directory of the transfer to start. */ - SHAREDCLIPBOARDURITRANSFERDIR enmTransferDir; -} VBOXCLIPBOARDCLIENTURISTATE, *PVBOXCLIPBOARDCLIENTURISTATE; + SHCLURITRANSFERDIR enmTransferDir; +} SHCLCLIENTURISTATE, *PSHCLCLIENTURISTATE; /** @@ -77,10 +77,10 @@ * This structure needs to be serializable by SSM (must be a POD type). */ -typedef struct VBOXCLIPBOARDCLIENTSTATE -{ - struct VBOXCLIPBOARDCLIENTSTATE *pNext; - struct VBOXCLIPBOARDCLIENTSTATE *pPrev; - - VBOXCLIPBOARDCONTEXT *pCtx; +typedef struct SHCLCLIENTSTATE +{ + struct SHCLCLIENTSTATE *pNext; + struct SHCLCLIENTSTATE *pPrev; + + SHCLCONTEXT *pCtx; /** The client's HGCM ID. */ @@ -90,27 +90,27 @@ /** Maximum chunk size to use for data transfers. Set to _64K by default. */ uint32_t cbChunkSize; - SHAREDCLIPBOARDSOURCE enmSource; + SHCLSOURCE enmSource; /** The client's URI state. */ - VBOXCLIPBOARDCLIENTURISTATE URI; -} VBOXCLIPBOARDCLIENTSTATE, *PVBOXCLIPBOARDCLIENTSTATE; - -typedef struct _VBOXCLIPBOARDCLIENTCMDCTX + SHCLCLIENTURISTATE URI; +} SHCLCLIENTSTATE, *PSHCLCLIENTSTATE; + +typedef struct _SHCLCLIENTCMDCTX { uint32_t uContextID; -} VBOXCLIPBOARDCLIENTCMDCTX, *PVBOXCLIPBOARDCLIENTCMDCTX; - -typedef struct _VBOXCLIPBOARDCLIENT +} SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX; + +typedef struct _SHCLCLIENT { /** The client's HGCM client ID. */ uint32_t uClientID; /** General client state data. */ - VBOXCLIPBOARDCLIENTSTATE State; + SHCLCLIENTSTATE State; /** The client's message queue (FIFO). */ - RTCList queueMsg; + RTCList queueMsg; /** The client's own event source. */ - SHAREDCLIPBOARDEVENTSOURCE Events; + SHCLEVENTSOURCE Events; #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST /** URI context data. */ - SHAREDCLIPBOARDURICTX URI; + SHCLURICTX URI; #endif /** Structure for keeping the client's pending (deferred return) state. @@ -130,5 +130,5 @@ PVBOXHGCMSVCPARM paParms; } Pending; -} VBOXCLIPBOARDCLIENT, *PVBOXCLIPBOARDCLIENT; +} SHCLCLIENT, *PSHCLCLIENT; /** @@ -136,14 +136,14 @@ * Currently empty. */ -typedef struct _VBOXCLIPBOARDEVENTSOURCEMAPENTRY -{ -} VBOXCLIPBOARDEVENTSOURCEMAPENTRY; +typedef struct _SHCLEVENTSOURCEMAPENTRY +{ +} SHCLEVENTSOURCEMAPENTRY; /** Map holding information about connected HGCM clients. Key is the (unique) HGCM client ID. - * The value is a weak pointer to PVBOXCLIPBOARDCLIENT, which is owned by HGCM. */ -typedef std::map ClipboardClientMap; + * The value is a weak pointer to PSHCLCLIENT, which is owned by HGCM. */ +typedef std::map ClipboardClientMap; /** Map holding information about event sources. Key is the (unique) event source ID. */ -typedef std::map ClipboardEventSourceMap; +typedef std::map ClipboardEventSourceMap; /** Simple queue (list) which holds deferred (waiting) clients. */ @@ -156,5 +156,5 @@ * to communicate with the Shared Clipboard host service. */ -typedef struct _VBOXCLIPBOARDEXTSTATE +typedef struct _SHCLEXTSTATE { /** Pointer to the actual service extension handle. */ @@ -173,30 +173,30 @@ * is reading clipboard data from the extension. */ uint32_t uDelayedFormats; -} VBOXCLIPBOARDEXTSTATE, *PVBOXCLIPBOARDEXTSTATE; +} SHCLEXTSTATE, *PSHCLEXTSTATE; /* * The service functions. Locking is between the service thread and the platform-dependent (window) thread. */ -int vboxSvcClipboardDataReadRequest(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDDATAREQ pDataReq, PVBOXCLIPBOARDEVENTID puEvent); -int vboxSvcClipboardDataReadSignal(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData); -int vboxSvcClipboardFormatsReport(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDFORMATDATA pFormats); +int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent); +int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData); +int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats); uint32_t vboxSvcClipboardGetMode(void); -int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENT pClient, SHAREDCLIPBOARDSOURCE enmSource); - -void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENT pClient); -PVBOXCLIPBOARDCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms); -void vboxSvcClipboardMsgFree(PVBOXCLIPBOARDCLIENTMSG pMsg); -void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms); -int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend); -int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait); -int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); - -int vboxSvcClipboardClientWakeup(PVBOXCLIPBOARDCLIENT pClient); +int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource); + +void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient); +PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms); +void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg); +void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms); +int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend); +int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait); +int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); + +int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient); # ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int vboxSvcClipboardURITransferStart(PVBOXCLIPBOARDCLIENT pClient, - SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource, - PSHAREDCLIPBOARDURITRANSFER *ppTransfer); +int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient, + SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, + PSHCLURITRANSFER *ppTransfer); bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg); # endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ @@ -208,51 +208,51 @@ void VBoxClipboardSvcImplDestroy(void); -int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless); -int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient); -int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDFORMATDATA pFormats); +int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless); +int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient); +int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats); /** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/ -int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual); -int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData); +int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual); +int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData); /** * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer * after a save and restore of the guest. */ -int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient); +int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int vboxSvcClipboardURITransferOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx); -DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx); - -int vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList); - -int vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList); -int vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList); -int vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pListHdr); -int vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTHDR pListHdr); -int vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pListEntry); -int vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList, - PVBOXCLIPBOARDLISTENTRY pListEntry); - -int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, - PSHAREDCLIPBOARDOBJHANDLE phObj); -int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj); -int vboxSvcClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +int vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx); +DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx); + +int vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList); + +int vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx, + PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList); +int vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList); +int vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTHDR pListHdr); +int vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTHDR pListHdr); +int vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pListEntry); +int vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pListEntry); + +int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, + PSHCLOBJHANDLE phObj); +int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj); +int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead); -int vboxSvcClipboardURIObjWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten); -DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData); -DECLCALLBACK(void) VBoxSvcClipboardURIDataHeaderCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData); -DECLCALLBACK(void) VBoxSvcClipboardURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData); -DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc); -DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData); -DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc); - -int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer); -int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer); +DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHCLURITRANSFERCALLBACKDATA pData); +DECLCALLBACK(void) VBoxSvcClipboardURIDataHeaderCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData); +DECLCALLBACK(void) VBoxSvcClipboardURIDataCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData); +DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc); +DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHCLURITRANSFERCALLBACKDATA pData); +DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc); + +int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer); +int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer); #endif /*VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (revision 80662) @@ -40,5 +40,5 @@ * Externals * *********************************************************************************************************************************/ -extern VBOXCLIPBOARDEXTSTATE g_ExtState; +extern SHCLEXTSTATE g_ExtState; extern PVBOXHGCMSVCHELPERS g_pHelpers; extern ClipboardClientQueue g_listClientsDeferred; @@ -49,7 +49,7 @@ *********************************************************************************************************************************/ static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms); + PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms); static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, SHAREDCLIPBOARDLISTHANDLE hList); + PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList); @@ -58,5 +58,5 @@ *********************************************************************************************************************************/ -DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx) +DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx) { RT_NOREF(pCtx); @@ -66,5 +66,5 @@ } -DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx) +DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx) { RT_NOREF(pCtx); @@ -74,18 +74,18 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList) +DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ, + PSHCLCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ); if (pMsgHdr) { - VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); @@ -101,15 +101,15 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayloadHdr; + PSHCLEVENTPAYLOAD pPayloadHdr; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayloadHdr); if (RT_SUCCESS(rc)) { - PVBOXCLIPBOARDROOTLISTHDR pSrcRootListHdr = (PVBOXCLIPBOARDROOTLISTHDR)pPayloadHdr->pvData; - Assert(pPayloadHdr->cbData == sizeof(VBOXCLIPBOARDROOTLISTHDR)); + PSHCLROOTLISTHDR pSrcRootListHdr = (PSHCLROOTLISTHDR)pPayloadHdr->pvData; + Assert(pPayloadHdr->cbData == sizeof(SHCLROOTLISTHDR)); LogFlowFunc(("cRoots=%RU32, fRoots=0x%x\n", pSrcRootListHdr->cRoots, pSrcRootListHdr->fRoots)); - PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc(); + PSHCLROOTLIST pRootList = SharedClipboardURIRootListAlloc(); if (pRootList) { @@ -117,5 +117,5 @@ { pRootList->paEntries = - (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(pSrcRootListHdr->cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY)); + (PSHCLROOTLISTENTRY)RTMemAllocZ(pSrcRootListHdr->cRoots * sizeof(SHCLROOTLISTENTRY)); if (pRootList->paEntries) @@ -123,5 +123,5 @@ for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++) { - PVBOXCLIPBOARDCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ, + PSHCLCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ); @@ -140,5 +140,5 @@ break; - PSHAREDCLIPBOARDEVENTPAYLOAD pPayloadEntry; + PSHCLEVENTPAYLOAD pPayloadEntry; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayloadEntry); @@ -146,6 +146,6 @@ break; - PVBOXCLIPBOARDROOTLISTENTRY pSrcRootListEntry = (PVBOXCLIPBOARDROOTLISTENTRY)pPayloadEntry->pvData; - Assert(pPayloadEntry->cbData == sizeof(VBOXCLIPBOARDROOTLISTENTRY)); + PSHCLROOTLISTENTRY pSrcRootListEntry = (PSHCLROOTLISTENTRY)pPayloadEntry->pvData; + Assert(pPayloadEntry->cbData == sizeof(SHCLROOTLISTENTRY)); rc = SharedClipboardURIListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry); @@ -190,19 +190,19 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList) +DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx, + PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent); @@ -220,14 +220,14 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) { - Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY)); - - PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData; + Assert(pPayload->cbData == sizeof(SHCLREPLY)); + + PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData; AssertPtr(pReply); - Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN); + Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN); *phList = pReply->u.ListOpen.uHandle; @@ -248,18 +248,18 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDLISTHANDLE hList) +DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent); @@ -277,5 +277,5 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) @@ -294,19 +294,19 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr) +DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); @@ -323,12 +323,12 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) { - Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR)); - - *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData; + Assert(pPayload->cbData == sizeof(SHCLLISTHDR)); + + *pListHdr = *(PSHCLLISTHDR)pPayload->pvData; SharedClipboardPayloadFree(pPayload); @@ -344,6 +344,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr) +DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) { RT_NOREF(pCtx, hList, pListHdr); @@ -354,19 +354,19 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry) +DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); @@ -383,11 +383,11 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) { - Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY)); - - rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData); + Assert(pPayload->cbData == sizeof(SHCLLISTENTRY)); + + rc = SharedClipboardURIListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData); SharedClipboardPayloadFree(pPayload); @@ -403,6 +403,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, - SHAREDCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry) +DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) { RT_NOREF(pCtx, hList, pListEntry); @@ -413,19 +413,19 @@ } -int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, - PSHAREDCLIPBOARDOBJHANDLE phObj) +int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, + PSHCLOBJHANDLE phObj) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate)); @@ -448,14 +448,14 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) { - Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY)); - - PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData; + Assert(pPayload->cbData == sizeof(SHCLREPLY)); + + PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData; AssertPtr(pReply); - Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN); + Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN); *phObj = pReply->u.ObjOpen.uHandle; @@ -473,18 +473,18 @@ } -int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj) +int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); @@ -500,15 +500,15 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) { - Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY)); + Assert(pPayload->cbData == sizeof(SHCLREPLY)); #ifdef VBOX_STRICT - PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData; + PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData; AssertPtr(pReply); - Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE); + Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE); #endif @@ -525,19 +525,19 @@ } -int vboxSvcClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); @@ -555,11 +555,11 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) { - Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDOBJDATACHUNK)); - - PVBOXCLIPBOARDOBJDATACHUNK pDataChunk = (PVBOXCLIPBOARDOBJDATACHUNK)pPayload->pvData; + Assert(pPayload->cbData == sizeof(SHCLOBJDATACHUNK)); + + PSHCLOBJDATACHUNK pDataChunk = (PSHCLOBJDATACHUNK)pPayload->pvData; AssertPtr(pDataChunk); @@ -583,19 +583,19 @@ } -int vboxSvcClipboardURIObjWrite(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, +int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser; + PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser; AssertPtr(pClient); int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE, + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE); if (pMsg) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); @@ -613,5 +613,5 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); if (RT_SUCCESS(rc)) @@ -641,5 +641,5 @@ *********************************************************************************************************************************/ -DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData) +DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHCLURITRANSFERCALLBACKDATA pData) { RT_NOREF(pData); @@ -648,5 +648,5 @@ } -DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc) +DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc) { RT_NOREF(pData, rc); @@ -657,5 +657,5 @@ } -DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData) +DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHCLURITRANSFERCALLBACKDATA pData) { LogFlowFuncEnter(); @@ -666,5 +666,5 @@ } -DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc) +DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc) { LogFlowFuncEnter(); @@ -689,5 +689,5 @@ */ static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXCLIPBOARDREPLY pReply) + PSHCLREPLY pReply) { int rc; @@ -714,5 +714,5 @@ switch (pReply->uType) { - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN: + case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN: { if (cParms >= 6) @@ -721,5 +721,5 @@ } - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN: + case VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN: { if (cParms >= 6) @@ -728,5 +728,5 @@ } - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE: + case VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE: { if (cParms >= 6) @@ -757,5 +757,5 @@ */ static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr) + PSHCLROOTLISTHDR pRootLstHdr) { int rc; @@ -783,5 +783,5 @@ */ static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXCLIPBOARDROOTLISTENTRY pListEntry) + PSHCLROOTLISTENTRY pListEntry) { int rc; @@ -820,5 +820,5 @@ */ static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXCLIPBOARDLISTOPENPARMS pOpenParms) + PSHCLLISTOPENPARMS pOpenParms) { int rc; @@ -867,5 +867,5 @@ */ static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTOPENPARMS pOpenParms) + PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms) { int rc; @@ -900,5 +900,5 @@ */ static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, SHAREDCLIPBOARDLISTHANDLE hList) + PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList) { int rc; @@ -928,5 +928,5 @@ */ static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr) + PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr) { int rc; @@ -967,5 +967,5 @@ */ static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTHDR pListHdr) + PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr) { int rc; @@ -1002,5 +1002,5 @@ */ static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry) + PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry) { int rc; @@ -1048,5 +1048,5 @@ */ static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PVBOXCLIPBOARDLISTENTRY pListEntry) + PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry) { int rc; @@ -1079,5 +1079,5 @@ * @param pDataChunk Where to store the object data chunk data. */ -static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDOBJDATACHUNK pDataChunk) +static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk) { AssertPtrReturn(paParms, VERR_INVALID_PARAMETER); @@ -1144,5 +1144,5 @@ * @param paParms Array function parameters supplied. */ -static int vboxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer, +static int vboxSvcClipboardURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { @@ -1151,6 +1151,6 @@ int rc; - uint32_t cbReply = sizeof(VBOXCLIPBOARDREPLY); - PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)RTMemAlloc(cbReply); + uint32_t cbReply = sizeof(SHCLREPLY); + PSHCLREPLY pReply = (PSHCLREPLY)RTMemAlloc(cbReply); if (pReply) { @@ -1158,6 +1158,6 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload - = (PSHAREDCLIPBOARDEVENTPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDEVENTPAYLOAD)); + PSHCLEVENTPAYLOAD pPayload + = (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD)); if (pPayload) { @@ -1167,11 +1167,11 @@ switch (pReply->uType) { - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN: + case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN: RT_FALL_THROUGH(); - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_CLOSE: + case VBOX_SHCL_REPLYMSGTYPE_LIST_CLOSE: RT_FALL_THROUGH(); - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN: + case VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN: RT_FALL_THROUGH(); - case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE: + case VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE: { uint32_t uCID; @@ -1179,5 +1179,5 @@ if (RT_SUCCESS(rc)) { - const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); + const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent)); @@ -1227,5 +1227,5 @@ * @param tsArrival Timestamp of arrival. */ -int vboxSvcClipboardURIHandler(PVBOXCLIPBOARDCLIENT pClient, +int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, @@ -1262,5 +1262,5 @@ * Pre-check: For certain messages we need to make sure that a (right) transfer is present. */ - PSHAREDCLIPBOARDURITRANSFER pTransfer = NULL; + PSHCLURITRANSFER pTransfer = NULL; switch (u32Function) { @@ -1301,5 +1301,5 @@ break; - SHAREDCLIPBOARDURITRANSFERSTATUS uStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_NONE; + SHCLURITRANSFERSTATUS uStatus = SHCLURITRANSFERSTATUS_NONE; rc = HGCMSvcGetU32(&paParms[1], &uStatus); if (RT_FAILURE(rc)) @@ -1316,11 +1316,11 @@ } - if (uStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING) - { - const SHAREDCLIPBOARDURITRANSFERDIR enmDir = SHAREDCLIPBOARDURITRANSFERDIR_READ; - - PSHAREDCLIPBOARDURITRANSFER pTransfer; + if (uStatus == SHCLURITRANSFERSTATUS_RUNNING) + { + const SHCLURITRANSFERDIR enmDir = SHCLURITRANSFERDIR_READ; + + PSHCLURITRANSFER pTransfer; rc = SharedClipboardURITransferCreate(enmDir, - SHAREDCLIPBOARDSOURCE_REMOTE, &pTransfer); + SHCLSOURCE_REMOTE, &pTransfer); if (RT_SUCCESS(rc)) { @@ -1328,5 +1328,5 @@ if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx; + SHCLPROVIDERCREATIONCTX creationCtx; RT_ZERO(creationCtx); @@ -1340,5 +1340,5 @@ creationCtx.Interface.pfnObjClose = vboxSvcClipboardURIObjClose; - if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ) + if (enmDir == SHCLURITRANSFERDIR_READ) { creationCtx.Interface.pfnGetRoots = vboxSvcClipboardURIGetRoots; @@ -1355,5 +1355,5 @@ /* Register needed callbacks so that we can wait for the meta data to arrive here. */ - SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks; + SHCLURITRANSFERCALLBACKS Callbacks; RT_ZERO(Callbacks); @@ -1409,10 +1409,10 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE: { - VBOXCLIPBOARDROOTLISTHDR lstHdr; + SHCLROOTLISTHDR lstHdr; rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr); if (RT_SUCCESS(rc)) { void *pvData = SharedClipboardURIRootListHdrDup(&lstHdr); - uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTHDR); + uint32_t cbData = sizeof(SHCLROOTLISTHDR); uint32_t uCID; @@ -1420,7 +1420,7 @@ if (RT_SUCCESS(rc)) { - const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); - - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); + + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); if (RT_SUCCESS(rc)) @@ -1438,16 +1438,16 @@ { #if 0 - VBOXCLIPBOARDROOTLISTENTRY lstEntry; + SHCLROOTLISTENTRY lstEntry; rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); if (RT_SUCCESS(rc)) { void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); - uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY); - - PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; - rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, + uint32_t cbData = sizeof(SHCLROOTLISTENTRY); + + PSHCLURITRANSFERPAYLOAD pPayload; + rc = SharedClipboardURITransferPayloadAlloc(SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, pvData, cbData, &pPayload); if (RT_SUCCESS(rc)) - rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, + rc = SharedClipboardURITransferEventSignal(pTransfer, SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, pPayload); } @@ -1458,10 +1458,10 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE: { - VBOXCLIPBOARDROOTLISTENTRY lstEntry; + SHCLROOTLISTENTRY lstEntry; rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); if (RT_SUCCESS(rc)) { void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); - uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY); + uint32_t cbData = sizeof(SHCLROOTLISTENTRY); uint32_t uCID; @@ -1469,7 +1469,7 @@ if (RT_SUCCESS(rc)) { - const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); - - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); + + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); if (RT_SUCCESS(rc)) @@ -1486,9 +1486,9 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN: { - VBOXCLIPBOARDLISTOPENPARMS listOpenParms; + SHCLLISTOPENPARMS listOpenParms; rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms); if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList); if (RT_SUCCESS(rc)) @@ -1506,5 +1506,5 @@ break; - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = HGCMSvcGetU64(&paParms[1], &hList); if (RT_SUCCESS(rc)) @@ -1520,9 +1520,9 @@ break; - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */ if (RT_SUCCESS(rc)) { - VBOXCLIPBOARDLISTHDR hdrList; + SHCLLISTHDR hdrList; rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList); /*if (RT_SUCCESS(rc)) @@ -1534,14 +1534,14 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE: { - VBOXCLIPBOARDLISTHDR hdrList; + SHCLLISTHDR hdrList; rc = SharedClipboardURIListHdrInit(&hdrList); if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList); if (RT_SUCCESS(rc)) { void *pvData = SharedClipboardURIListHdrDup(&hdrList); - uint32_t cbData = sizeof(VBOXCLIPBOARDLISTHDR); + uint32_t cbData = sizeof(SHCLLISTHDR); uint32_t uCID; @@ -1549,7 +1549,7 @@ if (RT_SUCCESS(rc)) { - const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); - - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); + + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); if (RT_SUCCESS(rc)) @@ -1570,9 +1570,9 @@ break; - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */ if (RT_SUCCESS(rc)) { - VBOXCLIPBOARDLISTENTRY entryList; + SHCLLISTENTRY entryList; rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList); } @@ -1582,14 +1582,14 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE: { - VBOXCLIPBOARDLISTENTRY entryList; + SHCLLISTENTRY entryList; rc = SharedClipboardURIListEntryInit(&entryList); if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDLISTHANDLE hList; + SHCLLISTHANDLE hList; rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList); if (RT_SUCCESS(rc)) { void *pvData = SharedClipboardURIListEntryDup(&entryList); - uint32_t cbData = sizeof(VBOXCLIPBOARDLISTENTRY); + uint32_t cbData = sizeof(SHCLLISTENTRY); uint32_t uCID; @@ -1597,7 +1597,7 @@ if (RT_SUCCESS(rc)) { - const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); - - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); + + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); if (RT_SUCCESS(rc)) @@ -1632,10 +1632,10 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE: { - VBOXCLIPBOARDOBJDATACHUNK dataChunk; + SHCLOBJDATACHUNK dataChunk; rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk); if (RT_SUCCESS(rc)) { void *pvData = SharedClipboardURIObjectDataChunkDup(&dataChunk); - uint32_t cbData = sizeof(VBOXCLIPBOARDOBJDATACHUNK); + uint32_t cbData = sizeof(SHCLOBJDATACHUNK); uint32_t uCID; @@ -1643,7 +1643,7 @@ if (RT_SUCCESS(rc)) { - const VBOXCLIPBOARDEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); - - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); + + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); if (RT_SUCCESS(rc)) @@ -1664,5 +1664,5 @@ LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR\n")); - VBOXCLIPBOARDDIRDATA dirData; + SHCLDIRDATA dirData; rc = VBoxSvcClipboardURIGetDir(cParms, paParms, &dirData); if (RT_SUCCESS(rc)) @@ -1680,5 +1680,5 @@ if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_DIR, SHAREDCLIPBOARDAREAOBJSTATE_COMPLETE }; + SHCLAREAOBJ Obj = { SHCLAREAOBJTYPE_DIR, SHCLAREAOBJSTATE_COMPLETE }; int rc2 = pArea->AddObject(pszDir, Obj); AssertRC(rc2); @@ -1697,5 +1697,5 @@ LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n")); - VBOXCLIPBOARDFILEHDR fileHdr; + SHCLFILEHDR fileHdr; rc = VBoxSvcClipboardURISetFileHdr(cParms, paParms, &fileHdr); break; @@ -1722,5 +1722,5 @@ break; - VBOXCLIPBOARDFILEHDR fileHdr; + SHCLFILEHDR fileHdr; rc = VBoxSvcClipboardURIGetFileHdr(cParms, paParms, &fileHdr); if (RT_SUCCESS(rc)) @@ -1738,5 +1738,5 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer); + PSHCLCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer); AssertPtrBreakStmt(pObjCtx, VERR_INVALID_POINTER); @@ -1767,5 +1767,5 @@ } - SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_FILE, SHAREDCLIPBOARDAREAOBJSTATE_NONE }; + SHCLAREAOBJ Obj = { SHCLAREAOBJTYPE_FILE, SHCLAREAOBJSTATE_NONE }; int rc2 = pArea->AddObject(pszPathAbs, Obj); AssertRC(rc2); @@ -1783,5 +1783,5 @@ LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n")); - VBOXCLIPBOARDFILEDATA fileData; + SHCLFILEDATA fileData; rc = VBoxSvcClipboardURISetFileData(cParms, paParms, &fileData); break; @@ -1798,9 +1798,9 @@ } - VBOXCLIPBOARDFILEDATA fileData; + SHCLFILEDATA fileData; rc = VBoxSvcClipboardURIGetFileData(cParms, paParms, &fileData); if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer); + PSHCLCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer); AssertPtrBreakStmt(pObjCtx, VERR_INVALID_POINTER); @@ -1901,5 +1901,5 @@ * @param pTransfer URI transfer to register a clipboard area for. */ -int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClientState); @@ -1918,8 +1918,8 @@ if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTAREAPARMS parms; + SHCLEXTAREAPARMS parms; RT_ZERO(parms); - parms.uID = NIL_SHAREDCLIPBOARDAREAID; + parms.uID = NIL_SHCLAREAID; /* As the meta data is now complete, register a new clipboard on the host side. */ @@ -1927,8 +1927,8 @@ if (RT_SUCCESS(rc)) { - /* Note: Do *not* specify SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the + /* Note: Do *not* specify SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the * clipboard area creation already. */ rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */, - SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE); + SHCLAREA_OPEN_FLAGS_NONE); } @@ -1950,5 +1950,5 @@ * @param pTransfer URI transfer to unregister a clipboard area from. */ -int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClientState); @@ -1963,5 +1963,5 @@ if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTAREAPARMS parms; + SHCLEXTAREAPARMS parms; RT_ZERO(parms); @@ -1998,6 +1998,6 @@ * @param uID ID of clipboard area to to attach to. Specify 0 to attach to the most recent one. */ -int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer, - SHAREDCLIPBOARDAREAID uID) +int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, + SHCLAREAID uID) { RT_NOREF(pClientState); @@ -2016,5 +2016,5 @@ if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTAREAPARMS parms; + SHCLEXTAREAPARMS parms; RT_ZERO(parms); @@ -2046,5 +2046,5 @@ * @param pTransfer URI transfer to detach a clipboard area from. */ -int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClientState); @@ -2061,5 +2061,5 @@ if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTAREAPARMS parms; + SHCLEXTAREAPARMS parms; RT_ZERO(parms); parms.uID = uAreaID; Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h (revision 80662) @@ -22,11 +22,11 @@ #endif -int vboxSvcClipboardURIHandler(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival); +int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival); int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); -int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer); -int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer); -int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDAREAID uID); -int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer); +int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); +int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); +int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID); +int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); #endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */ Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp (revision 80662) @@ -93,5 +93,5 @@ #if 0 -int vboxSvcClipboardURIReportMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t uMsg, uint32_t uParm) +int vboxSvcClipboardURIReportMsg(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t uParm) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -115,5 +115,5 @@ pClient->State.URI.fTransferStart = true; - pClient->State.URI.enmTransferDir = (SHAREDCLIPBOARDURITRANSFERDIR)uParm; + pClient->State.URI.enmTransferDir = (SHCLURITRANSFERDIR)uParm; break; @@ -130,5 +130,5 @@ } -bool vboxSvcClipboardURIReturnMsg(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +bool vboxSvcClipboardURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { RT_NOREF(pClient, cParms, paParms); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (revision 80662) @@ -53,14 +53,14 @@ * Internal Functions * *********************************************************************************************************************************/ -static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx); - -struct _VBOXCLIPBOARDCONTEXT +static int vboxClipboardSvcWinSyncInternal(PSHCLCONTEXT pCtx); + +struct _SHCLCONTEXT { /** Handle for window message handling thread. */ RTTHREAD hThread; /** Structure for keeping and communicating with service client. */ - PVBOXCLIPBOARDCLIENT pClient; + PSHCLCLIENT pClient; /** Windows-specific context data. */ - VBOXCLIPBOARDWINCTX Win; + SHCLWINCTX Win; }; @@ -114,5 +114,5 @@ } -static int vboxClipboardSvcWinDataSet(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat, void *pvData, uint32_t cbData) +static int vboxClipboardSvcWinDataSet(PSHCLCONTEXT pCtx, UINT cfFormat, void *pvData, uint32_t cbData) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -167,10 +167,10 @@ } -static int vboxClipboardSvcWinDataRead(PVBOXCLIPBOARDCONTEXT pCtx, UINT cfFormat, +static int vboxClipboardSvcWinDataRead(PSHCLCONTEXT pCtx, UINT cfFormat, void **ppvData, uint32_t *pcbData) { LogFlowFunc(("cfFormat=%u\n", cfFormat)); - SHAREDCLIPBOARDDATAREQ dataReq; + SHCLDATAREQ dataReq; RT_ZERO(dataReq); @@ -178,9 +178,9 @@ dataReq.cbSize = _64K; /** @todo Make this more dynamic. */ - VBOXCLIPBOARDEVENTID uEvent = 0; + SHCLEVENTID uEvent = 0; int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent); if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload); if (RT_SUCCESS(rc)) @@ -200,5 +200,5 @@ } -static LRESULT CALLBACK vboxClipboardSvcWinWndProcMain(PVBOXCLIPBOARDCONTEXT pCtx, +static LRESULT CALLBACK vboxClipboardSvcWinWndProcMain(PSHCLCONTEXT pCtx, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { @@ -207,5 +207,5 @@ LRESULT lresultRc = 0; - const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; + const PSHCLWINCTX pWinCtx = &pCtx->Win; switch (uMsg) @@ -222,5 +222,5 @@ int rc = vboxClipboardSvcWinSyncInternal(pCtx); if (RT_SUCCESS(rc)) - vboxSvcClipboardSetSource(pCtx->pClient, SHAREDCLIPBOARDSOURCE_LOCAL); + vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); } @@ -244,5 +244,5 @@ int rc = vboxClipboardSvcWinSyncInternal(pCtx); if (RT_SUCCESS(rc)) - vboxSvcClipboardSetSource(pCtx->pClient, SHAREDCLIPBOARDSOURCE_LOCAL); + vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); } @@ -266,5 +266,5 @@ const UINT cfFormat = (UINT)wParam; - const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat); + const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat); LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat)); @@ -314,5 +314,5 @@ /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT. */ - VBOXCLIPBOARDFORMATS fFormats = (uint32_t)lParam; + SHCLFORMATS fFormats = (uint32_t)lParam; if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */ { @@ -361,5 +361,5 @@ AssertPtrReturn(pUserData, 0); - PVBOXCLIPBOARDCONTEXT pCtx = reinterpret_cast(pUserData); + PSHCLCONTEXT pCtx = reinterpret_cast(pUserData); if (pCtx) return vboxClipboardSvcWinWndProcMain(pCtx, hWnd, uMsg, wParam, lParam); @@ -398,7 +398,7 @@ bool fThreadSignalled = false; - const PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pvUser; + const PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pvUser; AssertPtr(pCtx); - const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; + const PSHCLWINCTX pWinCtx = &pCtx->Win; HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL); @@ -517,5 +517,5 @@ * @param pCtx Clipboard context to synchronize. */ -static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx) +static int vboxClipboardSvcWinSyncInternal(PSHCLCONTEXT pCtx) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -527,5 +527,5 @@ if (pCtx->pClient) { - SHAREDCLIPBOARDFORMATDATA Formats; + SHCLFORMATDATA Formats; RT_ZERO(Formats); @@ -559,5 +559,5 @@ } -int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless) +int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { RT_NOREF(fHeadless); @@ -567,5 +567,5 @@ int rc; - PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT)); + PSHCLCONTEXT pCtx = (PSHCLCONTEXT)RTMemAllocZ(sizeof(SHCLCONTEXT)); if (pCtx) { @@ -596,5 +596,5 @@ } -int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) { /* Sync the host clipboard content with the client. */ @@ -602,5 +602,5 @@ } -int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -610,5 +610,5 @@ int rc = VINF_SUCCESS; - PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx; + PSHCLCONTEXT pCtx = pClient->State.pCtx; if (pCtx) { @@ -641,6 +641,6 @@ } -int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDFORMATDATA pFormats) +int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLFORMATDATA pFormats) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -649,5 +649,5 @@ int rc; - PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx; + PSHCLCONTEXT pCtx = pClient->State.pCtx; AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -657,7 +657,7 @@ if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) { - PSHAREDCLIPBOARDURITRANSFER pTransfer; + PSHCLURITRANSFER pTransfer; rc = vboxSvcClipboardURITransferStart(pClient, - SHAREDCLIPBOARDURITRANSFERDIR_READ, SHAREDCLIPBOARDSOURCE_REMOTE, + SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE, &pTransfer); if (RT_SUCCESS(rc)) @@ -691,6 +691,6 @@ } -int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual) +int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData, uint32_t *pcbActual) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -702,5 +702,5 @@ HANDLE hClip = NULL; - const PVBOXCLIPBOARDWINCTX pWinCtx = &pClient->State.pCtx->Win; + const PSHCLWINCTX pWinCtx = &pClient->State.pCtx->Win; /* @@ -802,6 +802,6 @@ } -int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDDATABLOCK pData) +int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData) { LogFlowFuncEnter(); @@ -814,5 +814,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClient, pTransfer); @@ -823,5 +823,5 @@ } -int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { LogFlowFuncEnter(); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp (revision 80662) @@ -58,5 +58,5 @@ * @param fHeadless Whether headless. */ -int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless) +int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { RT_NOREF(pClient, fHeadless); @@ -69,5 +69,5 @@ * after a save and restore of the guest. */ -int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) { RT_NOREF(pClient); @@ -81,5 +81,5 @@ * @param pClient Structure containing context information about the guest system */ -int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { RT_NOREF(pClient); @@ -95,6 +95,6 @@ * @param pFormats Clipboard formats the guest is offering. */ -int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDFORMATDATA pFormats) +int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLFORMATDATA pFormats) { RT_NOREF(pClient, pCmdCtx, pFormats); @@ -110,6 +110,6 @@ * @param pcbActual Where to store the actual amount of data available. */ -int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual) +int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData, uint32_t *pcbActual) { RT_NOREF(pClient, pCmdCtx, pData); @@ -121,6 +121,6 @@ } -int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDDATABLOCK pData) +int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData) { RT_NOREF(pClient, pCmdCtx, pData); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (revision 80662) @@ -42,5 +42,5 @@ * Global context information used by the host glue for the X11 clipboard backend. */ -struct _VBOXCLIPBOARDCONTEXT +struct _SHCLCONTEXT { /** This mutex is grabbed during any critical operations on the clipboard @@ -50,5 +50,5 @@ CLIPBACKEND *pBackend; /** Pointer to the VBox host client data structure. */ - PVBOXCLIPBOARDCLIENT pClient; + PSHCLCLIENT pClient; /** We set this when we start shutting down as a hint not to post any new * requests. */ @@ -63,9 +63,9 @@ * @note Host glue code */ -void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats) +void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats) { LogFlowFunc(("pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats)); - SHAREDCLIPBOARDFORMATDATA formatData; + SHCLFORMATDATA formatData; RT_ZERO(formatData); @@ -100,9 +100,9 @@ * the clipboard and leave ownership to X11. */ -int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT pClient, bool fHeadless) +int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { int rc = VINF_SUCCESS; - PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT)); + PSHCLCONTEXT pCtx = (PSHCLCONTEXT)RTMemAllocZ(sizeof(SHCLCONTEXT)); if (pCtx) { @@ -142,5 +142,5 @@ * @note Host glue code */ -int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) { LogFlowFuncEnter(); @@ -149,5 +149,5 @@ * there is data in the host clipboard it will automatically be sent to * the guest when the clipboard starts up. */ - SHAREDCLIPBOARDFORMATDATA formatData; + SHCLFORMATDATA formatData; RT_ZERO(formatData); @@ -161,9 +161,9 @@ * @note Host glue code */ -int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT pClient) +int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { LogFlowFuncEnter(); - PVBOXCLIPBOARDCONTEXT pCtx = pClient->State.pCtx; + PSHCLCONTEXT pCtx = pClient->State.pCtx; /* Drop the reference to the client, in case it is still there. This @@ -173,5 +173,5 @@ /* If there is a currently pending request, release it immediately. */ - SHAREDCLIPBOARDDATABLOCK dataBlock = { 0, NULL, 0 }; + SHCLDATABLOCK dataBlock = { 0, NULL, 0 }; VBoxClipboardSvcImplWriteData(pClient, NULL, &dataBlock); @@ -199,6 +199,6 @@ * @param pFormats Clipboard formats the guest is offering. */ -int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDFORMATDATA pFormats) +int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLFORMATDATA pFormats) { RT_NOREF(pCmdCtx); @@ -224,5 +224,5 @@ uint32_t *pcbActual; /** The request's event ID. */ - VBOXCLIPBOARDEVENTID uEvent; + SHCLEVENTID uEvent; }; @@ -245,6 +245,6 @@ * */ -int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT pClient, - PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData, uint32_t *pcbActual) +int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, + PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual) { RT_NOREF(pCmdCtx); @@ -258,5 +258,5 @@ if (pReq) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); pReq->pv = pData->pvData; @@ -271,5 +271,5 @@ if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pClient->Events, uEvent, 30 * 1000, &pPayload); if (RT_SUCCESS(rc)) @@ -299,6 +299,6 @@ * @param pData Data block to write to clipboard. */ -int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT pClient, - PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, PSHAREDCLIPBOARDDATABLOCK pData) +int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, + PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData) { LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n", @@ -323,10 +323,10 @@ * @todo Change this to deal with the buffer issues rather than offloading them onto the caller. */ -void ClipRequestFromX11CompleteCallback(VBOXCLIPBOARDCONTEXT *pCtx, int rc, +void ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb) { AssertMsgRC(rc, ("Clipboard data completion from X11 failed with %Rrc\n", rc)); - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; int rc2 = SharedClipboardPayloadAlloc(pReq->uEvent, pv, cb, &pPayload); if (RT_SUCCESS(rc2)) @@ -349,5 +349,5 @@ * @note Host glue code. */ -int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) +int ClipRequestDataForX11(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb) { LogFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p\n", pCtx, u32Format, ppv)); @@ -361,5 +361,5 @@ /* Request data from the guest. */ - SHAREDCLIPBOARDDATAREQ dataReq; + SHCLDATAREQ dataReq; RT_ZERO(dataReq); @@ -367,9 +367,9 @@ dataReq.cbSize = _64K; /** @todo Make this more dynamic. */ - VBOXCLIPBOARDEVENTID uEvent; + SHCLEVENTID uEvent; int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent); if (RT_SUCCESS(rc)) { - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload; + PSHCLEVENTPAYLOAD pPayload; rc = SharedClipboardEventWait(&pCtx->pClient->Events, uEvent, 30 * 1000, &pPayload); if (RT_SUCCESS(rc)) @@ -390,5 +390,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClient, pTransfer); @@ -396,5 +396,5 @@ } -int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer) +int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClient, pTransfer); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (revision 80662) @@ -224,7 +224,7 @@ * Prototypes * *********************************************************************************************************************************/ -static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTSTATE pClientState, uint32_t uClientID); -static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTSTATE pClientState); -static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState); +static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID); +static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState); +static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState); @@ -241,5 +241,5 @@ /** Holds the service extension state. */ -VBOXCLIPBOARDEXTSTATE g_ExtState = { 0 }; +SHCLEXTSTATE g_ExtState = { 0 }; /** Global map of all connected clients. */ @@ -260,5 +260,5 @@ * @param puID Where to store the created event source ID on success. */ -int vboxSvcClipboardEventSourceCreateID(PVBOXCLIPBOARDEVENTSOURCEID puID) +int vboxSvcClipboardEventSourceCreateID(PSHCLEVENTSOURCEID puID) { AssertPtrReturn(puID, VERR_INVALID_POINTER); @@ -266,5 +266,5 @@ for (uint32_t i = 0; i < 32; i++) /* Don't try too hard. */ { - VBOXCLIPBOARDEVENTSOURCEID uID = RTRandU32() % VBOX_SHARED_CLIPBOARD_MAX_EVENT_SOURCES; + SHCLEVENTSOURCEID uID = RTRandU32() % VBOX_SHARED_CLIPBOARD_MAX_EVENT_SOURCES; if (g_mapEventSources.find(uID) == g_mapEventSources.end()) { @@ -343,5 +343,5 @@ * @param pClient Pointer to the client data structure to reset message queue for. */ -void vboxSvcClipboardMsgQueueReset(PVBOXCLIPBOARDCLIENT pClient) +void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient) { LogFlowFuncEnter(); @@ -361,7 +361,7 @@ * @param cParms Number of HGCM parameters to allocate. */ -PVBOXCLIPBOARDCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms) -{ - PVBOXCLIPBOARDCLIENTMSG pMsg = (PVBOXCLIPBOARDCLIENTMSG)RTMemAlloc(sizeof(VBOXCLIPBOARDCLIENTMSG)); +PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms) +{ + PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG)); if (pMsg) { @@ -386,5 +386,5 @@ * The pointer will be invalid after calling this function. */ -void vboxSvcClipboardMsgFree(PVBOXCLIPBOARDCLIENTMSG pMsg) +void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg) { if (!pMsg) @@ -407,5 +407,5 @@ * @remarks ASSUMES the parameters has been cleared by clientMsgPeek. */ -void vboxSvcClipboardMsgSetPeekReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) +void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) { Assert(cDstParms >= 2); @@ -437,5 +437,5 @@ * @param cDstParms The number of peek parameters (at least two). */ -int vboxSvcClipboardMsgSetGetHostMsgOldReturn(PVBOXCLIPBOARDCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) +int vboxSvcClipboardMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) { AssertPtrReturn(pMsg, VERR_INVALID_POINTER); @@ -494,5 +494,5 @@ * @param fAppend Whether to append or prepend the message to the queue. */ -int vboxSvcClipboardMsgAdd(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTMSG pMsg, bool fAppend) +int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend) { AssertPtrReturn(pMsg, VERR_INVALID_POINTER); @@ -527,5 +527,5 @@ * immediately. */ -int vboxSvcClipboardMsgPeek(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], +int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait) { @@ -571,5 +571,5 @@ if (!pClient->queueMsg.isEmpty()) { - PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first(); + PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first(); if (pFirstMsg) { @@ -616,5 +616,5 @@ * @param paParms Array of parameters. */ -int vboxSvcClipboardMsgGetOld(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +int vboxSvcClipboardMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { int rc; @@ -633,5 +633,5 @@ if (!pClient->queueMsg.isEmpty()) { - PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first(); + PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first(); AssertPtr(pFirstMsg); @@ -692,5 +692,5 @@ * @param paParms Array of parameters. */ -int vboxSvcClipboardMsgGet(PVBOXCLIPBOARDCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { /* @@ -706,5 +706,5 @@ if (!pClient->queueMsg.isEmpty()) { - PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first(); + PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first(); if (pFirstMsg) { @@ -807,5 +807,5 @@ * @param pClient Client to wake up. */ -int vboxSvcClipboardClientWakeup(PVBOXCLIPBOARDCLIENT pClient) +int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient) { int rc = VINF_NO_CHANGE; @@ -819,5 +819,5 @@ if (!pClient->queueMsg.isEmpty()) { - PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->queueMsg.first(); + PSHCLCLIENTMSG pFirstMsg = pClient->queueMsg.first(); if (pFirstMsg) { @@ -879,6 +879,6 @@ * @param puEvent Event ID for waiting for new data. Optional. */ -int vboxSvcClipboardDataReadRequest(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDDATAREQ pDataReq, - PVBOXCLIPBOARDEVENTID puEvent) +int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, + PSHCLEVENTID puEvent) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -888,9 +888,9 @@ int rc; - PVBOXCLIPBOARDCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, + PSHCLCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA); if (pMsgReadData) { - const VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); + const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); HGCMSvcSetU32(&pMsgReadData->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent)); @@ -922,8 +922,8 @@ } -int vboxSvcClipboardDataReadSignal(PVBOXCLIPBOARDCLIENT pClient, PVBOXCLIPBOARDCLIENTCMDCTX pCmdCtx, - PSHAREDCLIPBOARDDATABLOCK pData) -{ - VBOXCLIPBOARDEVENTID uEvent; +int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData) +{ + SHCLEVENTID uEvent; if (pClient->State.uProtocolVer == 0) { @@ -937,5 +937,5 @@ int rc = VINF_SUCCESS; - PSHAREDCLIPBOARDEVENTPAYLOAD pPayload = NULL; + PSHCLEVENTPAYLOAD pPayload = NULL; if (pData->cbData) rc = SharedClipboardPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload); @@ -952,5 +952,5 @@ } -int vboxSvcClipboardFormatsReport(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDFORMATDATA pFormats) +int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -959,8 +959,8 @@ int rc; - PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3); + PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3); if (pMsg) { - VBOXCLIPBOARDEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); + SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent)); @@ -979,5 +979,5 @@ } -int vboxSvcClipboardGetDataWrite(PVBOXCLIPBOARDCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +int vboxSvcClipboardGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { LogFlowFuncEnter(); @@ -991,8 +991,8 @@ int rc; - SHAREDCLIPBOARDDATABLOCK dataBlock; + SHCLDATABLOCK dataBlock; RT_ZERO(dataBlock); - VBOXCLIPBOARDCLIENTCMDCTX cmdCtx; + SHCLCLIENTCMDCTX cmdCtx; RT_ZERO(cmdCtx); @@ -1044,5 +1044,5 @@ if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTPARMS parms; + SHCLEXTPARMS parms; RT_ZERO(parms); @@ -1061,5 +1061,5 @@ } -int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENT pClient, SHAREDCLIPBOARDSOURCE enmSource) +int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource) { if (!pClient) /* If no client connected (anymore), bail out. */ @@ -1082,7 +1082,7 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int vboxSvcClipboardURITransferStart(PVBOXCLIPBOARDCLIENT pClient, - SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource, - PSHAREDCLIPBOARDURITRANSFER *ppTransfer) +int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient, + SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, + PSHCLURITRANSFER *ppTransfer) { LogFlowFuncEnter(); @@ -1094,12 +1094,12 @@ if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI)) { - PSHAREDCLIPBOARDURITRANSFER pTransfer; + PSHCLURITRANSFER pTransfer; rc = SharedClipboardURITransferCreate(enmDir, enmSource, &pTransfer); if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx; + SHCLPROVIDERCREATIONCTX creationCtx; RT_ZERO(creationCtx); - if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ) + if (enmDir == SHCLURITRANSFERDIR_READ) { rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer); @@ -1123,5 +1123,5 @@ } } - else if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_WRITE) + else if (enmDir == SHCLURITRANSFERDIR_WRITE) { AssertFailed(); /** @todo Implement this. */ @@ -1129,5 +1129,5 @@ /* Register needed callbacks so that we can wait for the meta data to arrive here. */ - SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks; + SHCLURITRANSFERCALLBACKS Callbacks; RT_ZERO(Callbacks); @@ -1210,9 +1210,9 @@ LogFunc(("u32ClientID=%RU32\n", u32ClientID)); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient; + PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient; AssertPtr(pClient); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST - PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/); + PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/); if (pTransfer) vboxSvcClipboardURIAreaDetach(&pClient->State, pTransfer); @@ -1243,5 +1243,5 @@ RT_NOREF(fRequestor, fRestoring); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient; + PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient; AssertPtr(pvClient); @@ -1250,5 +1250,5 @@ /* Create the client's own event source. */ - VBOXCLIPBOARDEVENTSOURCEID uEventSourceID; + SHCLEVENTSOURCEID uEventSourceID; int rc = vboxSvcClipboardEventSourceCreateID(&uEventSourceID); if (RT_SUCCESS(rc)) @@ -1302,5 +1302,5 @@ int rc = VINF_SUCCESS; - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient; + PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient; AssertPtr(pClient); @@ -1437,10 +1437,10 @@ else { - rc = vboxSvcClipboardSetSource(pClient, SHAREDCLIPBOARDSOURCE_REMOTE); + rc = vboxSvcClipboardSetSource(pClient, SHCLSOURCE_REMOTE); if (RT_SUCCESS(rc)) { if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTPARMS parms; + SHCLEXTPARMS parms; RT_ZERO(parms); @@ -1450,8 +1450,8 @@ } - VBOXCLIPBOARDCLIENTCMDCTX cmdCtx; + SHCLCLIENTCMDCTX cmdCtx; RT_ZERO(cmdCtx); - SHAREDCLIPBOARDFORMATDATA formatData; + SHCLFORMATDATA formatData; RT_ZERO(formatData); @@ -1499,6 +1499,6 @@ SharedClipboardURICtxTransfersCleanup(&pClient->URI); - PSHAREDCLIPBOARDURITRANSFER pTransfer; - rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE, + PSHCLURITRANSFER pTransfer; + rc = SharedClipboardURITransferCreate(SHCLURITRANSFERDIR_WRITE, pClient->State.enmSource, &pTransfer); @@ -1509,5 +1509,5 @@ if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx; + SHCLPROVIDERCREATIONCTX creationCtx; RT_ZERO(creationCtx); @@ -1557,5 +1557,5 @@ if (g_ExtState.pfnExtension) { - VBOXCLIPBOARDEXTPARMS parms; + SHCLEXTPARMS parms; RT_ZERO(parms); @@ -1577,5 +1577,5 @@ if (g_ExtState.fDelayedAnnouncement) { - SHAREDCLIPBOARDFORMATDATA formatData; + SHCLFORMATDATA formatData; RT_ZERO(formatData); @@ -1600,5 +1600,5 @@ * so data which has been read above might get overridden by the host clipboard eventually. */ - VBOXCLIPBOARDCLIENTCMDCTX cmdCtx; + SHCLCLIENTCMDCTX cmdCtx; RT_ZERO(cmdCtx); @@ -1607,5 +1607,5 @@ if (RT_SUCCESS(rc)) { - SHAREDCLIPBOARDDATABLOCK dataBlock; + SHCLDATABLOCK dataBlock; RT_ZERO(dataBlock); @@ -1660,5 +1660,5 @@ * @param uClientID Client ID (HGCM) to use for this client state. */ -static int vboxSvcClipboardClientStateInit(PVBOXCLIPBOARDCLIENTSTATE pClientState, uint32_t uClientID) +static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID) { LogFlowFuncEnter(); @@ -1680,5 +1680,5 @@ * @param pClientState Client state to destroy. */ -static int vboxSvcClipboardClientStateDestroy(PVBOXCLIPBOARDCLIENTSTATE pClientState) +static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState) { RT_NOREF(pClientState); @@ -1694,10 +1694,10 @@ * @param pClientState Client state to reset. */ -static void vboxSvcClipboardClientStateReset(PVBOXCLIPBOARDCLIENTSTATE pClientState) +static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState) { LogFlowFuncEnter(); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST - pClientState->URI.enmTransferDir = SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN; + pClientState->URI.enmTransferDir = SHCLURITRANSFERDIR_UNKNOWN; #else RT_NOREF(pClientState); @@ -1774,31 +1774,31 @@ #ifndef UNIT_TEST /** - * SSM descriptor table for the VBOXCLIPBOARDCLIENTSTATE structure. + * SSM descriptor table for the SHCLCLIENTSTATE structure. */ static SSMFIELD const s_aShClSSMClientState[] = { - SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, uProtocolVer), - SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, cbChunkSize), - SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, enmSource), + SSMFIELD_ENTRY(SHCLCLIENTSTATE, uProtocolVer), + SSMFIELD_ENTRY(SHCLCLIENTSTATE, cbChunkSize), + SSMFIELD_ENTRY(SHCLCLIENTSTATE, enmSource), SSMFIELD_ENTRY_TERM() }; /** - * SSM descriptor table for the VBOXCLIPBOARDCLIENTURISTATE structure. + * SSM descriptor table for the SHCLCLIENTURISTATE structure. */ static SSMFIELD const s_aShClSSMClientURIState[] = { - SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTURISTATE, enmTransferDir), + SSMFIELD_ENTRY(SHCLCLIENTURISTATE, enmTransferDir), SSMFIELD_ENTRY_TERM() }; /** - * SSM descriptor table for the header of the VBOXCLIPBOARDCLIENTMSG structure. + * SSM descriptor table for the header of the SHCLCLIENTMSG structure. * The actual message parameters will be serialized separately. */ static SSMFIELD const s_aShClSSMClientMsgHdr[] = { - SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTMSG, m_uMsg), - SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTMSG, m_cParms), + SSMFIELD_ENTRY(SHCLCLIENTMSG, m_uMsg), + SSMFIELD_ENTRY(SHCLCLIENTMSG, m_cParms), SSMFIELD_ENTRY_TERM() }; @@ -1827,5 +1827,5 @@ LogFunc(("u32ClientID=%RU32\n", u32ClientID)); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient; + PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient; AssertPtr(pClient); @@ -1845,8 +1845,8 @@ for (size_t i = 0; i < pClient->queueMsg.size(); i++) { - PVBOXCLIPBOARDCLIENTMSG pMsg = pClient->queueMsg.at(i); + PSHCLCLIENTMSG pMsg = pClient->queueMsg.at(i); AssertPtr(pMsg); - rc = SSMR3PutStructEx(pSSM, pMsg, sizeof(VBOXCLIPBOARDCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL); + rc = SSMR3PutStructEx(pSSM, pMsg, sizeof(SHCLCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL); AssertRCReturn(rc, rc); @@ -1909,5 +1909,5 @@ LogFunc(("u32ClientID=%RU32\n", u32ClientID)); - PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pvClient; + PSHCLCLIENT pClient = (PSHCLCLIENT)pvClient; AssertPtr(pClient); @@ -1935,8 +1935,8 @@ for (uint64_t i = 0; i < cMsg; i++) { - PVBOXCLIPBOARDCLIENTMSG pMsg = (PVBOXCLIPBOARDCLIENTMSG)RTMemAlloc(sizeof(VBOXCLIPBOARDCLIENTMSG)); + PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG)); AssertPtrReturn(pMsg, VERR_NO_MEMORY); - rc = SSMR3GetStructEx(pSSM, pMsg, sizeof(VBOXCLIPBOARDCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL); + rc = SSMR3GetStructEx(pSSM, pMsg, sizeof(SHCLCLIENTMSG), 0 /*fFlags*/, &s_aShClSSMClientMsgHdr[0], NULL); AssertRCReturn(rc, rc); @@ -1984,5 +1984,5 @@ if (itClient != g_mapClients.end()) { - PVBOXCLIPBOARDCLIENT pClient = itClient->second; + PSHCLCLIENT pClient = itClient->second; AssertPtr(pClient); @@ -2000,5 +2000,5 @@ else { - SHAREDCLIPBOARDFORMATDATA formatData; + SHCLFORMATDATA formatData; RT_ZERO(formatData); @@ -2014,5 +2014,5 @@ case VBOX_CLIPBOARD_EXT_FN_DATA_READ: { - SHAREDCLIPBOARDDATAREQ dataReq; + SHCLDATAREQ dataReq; RT_ZERO(dataReq); @@ -2040,5 +2040,5 @@ LogFlowFunc(("pfnExtension=%p\n", pfnExtension)); - VBOXCLIPBOARDEXTPARMS parms; + SHCLEXTPARMS parms; RT_ZERO(parms); @@ -2089,5 +2089,5 @@ g_pHelpers = pTable->pHelpers; - pTable->cbClient = sizeof(VBOXCLIPBOARDCLIENT); + pTable->cbClient = sizeof(SHCLCLIENT); pTable->pfnUnload = svcUnload; Index: /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp (revision 80661) +++ /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp (revision 80662) @@ -26,5 +26,5 @@ extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable); -static VBOXCLIPBOARDCLIENT g_Client; +static SHCLCLIENT g_Client; static VBOXHGCMSVCHELPERS g_Helpers = { NULL }; @@ -279,15 +279,15 @@ int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; } void VBoxClipboardSvcImplDestroy() { } -int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENT) +int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT) { return VINF_SUCCESS; } -int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENT, bool) +int VBoxClipboardSvcImplConnect(PSHCLCLIENT, bool) { return VINF_SUCCESS; } -int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX, PSHAREDCLIPBOARDFORMATDATA) +int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA) { AssertFailed(); return VINF_SUCCESS; } -int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX, PSHAREDCLIPBOARDDATABLOCK, unsigned int *) +int VBoxClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *) { AssertFailed(); return VERR_WRONG_ORDER; } -int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENT, PVBOXCLIPBOARDCLIENTCMDCTX, PSHAREDCLIPBOARDDATABLOCK) +int VBoxClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK) { AssertFailed(); return VINF_SUCCESS; } -int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENT) +int VBoxClipboardSvcImplSync(PSHCLCLIENT) { AssertFailed(); return VERR_WRONG_ORDER; } Index: /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp (revision 80661) +++ /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp (revision 80662) @@ -8421,5 +8421,5 @@ LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE\n")); - VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms; + SHCLEXTPARMS *pParms = (SHCLEXTPARMS *)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); @@ -8437,5 +8437,5 @@ LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_DATA_READ\n")); - VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms; + SHCLEXTPARMS *pParms = (SHCLEXTPARMS *)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); @@ -8456,5 +8456,5 @@ LogFlowFunc(("VBOX_CLIPBOARD_EXT_FN_DATA_WRITE\n")); - VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms; + SHCLEXTPARMS *pParms = (SHCLEXTPARMS *)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); @@ -8475,5 +8475,5 @@ if (SUCCEEDED(hrc)) { - PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms; + PSHCLEXTAREAPARMS pParms = (PSHCLEXTAREAPARMS)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); @@ -8487,5 +8487,5 @@ case VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER: { - PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms; + PSHCLEXTAREAPARMS pParms = (PSHCLEXTAREAPARMS)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); @@ -8497,5 +8497,5 @@ case VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH: { - PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms; + PSHCLEXTAREAPARMS pParms = (PSHCLEXTAREAPARMS)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); @@ -8507,5 +8507,5 @@ case VBOX_CLIPBOARD_EXT_FN_AREA_DETACH: { - PVBOXCLIPBOARDEXTAREAPARMS pParms = (PVBOXCLIPBOARDEXTAREAPARMS)pvParms; + PSHCLEXTAREAPARMS pParms = (PSHCLEXTAREAPARMS)pvParms; AssertPtrBreakStmt(pParms, rc = VERR_INVALID_POINTER); Index: /trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp (revision 80661) +++ /trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp (revision 80662) @@ -230,8 +230,8 @@ { SharedClipboardAreaData() - : uID(NIL_SHAREDCLIPBOARDAREAID) { } + : uID(NIL_SHCLAREAID) { } /** The area's (unique) ID. - * Set to NIL_SHAREDCLIPBOARDAREAID if not initialized yet. */ + * Set to NIL_SHCLAREAID if not initialized yet. */ ULONG uID; /** The actual Shared Clipboard area assigned to this ID. */ @@ -248,5 +248,5 @@ { SharedClipboardData() - : uMostRecentClipboardAreaID(NIL_SHAREDCLIPBOARDAREAID) + : uMostRecentClipboardAreaID(NIL_SHCLAREAID) , uMaxClipboardAreas(32) /** @todo Make this configurable. */ { @@ -271,5 +271,5 @@ ULONG GenerateAreaID(void) { - ULONG uID = NIL_SHAREDCLIPBOARDAREAID; + ULONG uID = NIL_SHCLAREAID; int rc = RTCritSectEnter(&CritSect); @@ -289,5 +289,5 @@ RTCRITSECT CritSect; /** The most recent (last created) clipboard area ID. - * NIL_SHAREDCLIPBOARDAREAID if not initialized yet. */ + * NIL_SHCLAREAID if not initialized yet. */ ULONG uMostRecentClipboardAreaID; /** Maximum of concurrent clipboard areas. @@ -3424,5 +3424,5 @@ if (pAreaData) { - vrc = pAreaData->Area.OpenTemp(uAreaID, SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST); + vrc = pAreaData->Area.OpenTemp(uAreaID, SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST); if (RT_SUCCESS(vrc)) { @@ -3635,5 +3635,5 @@ /** * Returns the ID of the most recent (last created) clipboard area, - * or NIL_SHAREDCLIPBOARDAREAID if no clipboard area has been created yet. + * or NIL_SHCLAREAID if no clipboard area has been created yet. * * @returns Most recent clipboard area ID.