Changeset 80847 – Oracle VirtualBox

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

-              r80845
+              r80847
     RTLISTANCHOR                List;
     /** Transfer ID allocation bitmap; clear bits are free, set bits are busy. */
     uint64_t                    bmTransferIds[VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS / sizeof(uint64_t) / 8];
+    uint64_t                    bmTransferIds[VBOX_SHCL_MAX_TRANSFERS / sizeof(uint64_t) / 8];
     /** Number of running (concurrent) transfers. */
     uint16_t                    cRunning;
 …
 bool SharedClipboardMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax);
 const char *VBoxClipboardTransferStatusToStr(uint32_t uStatus);
+const char *VBoxShClTransferStatusToStr(uint32_t uStatus);
 #endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_uri_h */

trunk/include/VBox/GuestHost/SharedClipboard.h

-              r80846
+              r80847
  */
 /** No format set. */
 #define VBOX_SHARED_CLIPBOARD_FMT_NONE          0
+#define VBOX_SHCL_FMT_NONE          0
 /** Shared Clipboard format is an Unicode text. */
 #define VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT   RT_BIT(0)
+#define VBOX_SHCL_FMT_UNICODETEXT   RT_BIT(0)
 /** Shared Clipboard format is bitmap (BMP / DIB). */
 #define VBOX_SHARED_CLIPBOARD_FMT_BITMAP        RT_BIT(1)
+#define VBOX_SHCL_FMT_BITMAP        RT_BIT(1)
 /** Shared Clipboard format is HTML. */
 #define VBOX_SHARED_CLIPBOARD_FMT_HTML          RT_BIT(2)
+#define VBOX_SHCL_FMT_HTML          RT_BIT(2)
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
 /** Shared Clipboard format is an URI list. */
 #define VBOX_SHARED_CLIPBOARD_FMT_URI_LIST      RT_BIT(3)
+#define VBOX_SHCL_FMT_URI_LIST      RT_BIT(3)
 #endif
 …
 /** Maximum number of concurrent Shared Clipboard client sessions a VM can have. */
 #define VBOX_SHARED_CLIPBOARD_MAX_SESSIONS                   32
+#define VBOX_SHCL_MAX_SESSIONS                   32
 /** Maximum number of concurrent Shared Clipboard transfers a single
  *  client can have. */
 #define VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS                  _2K
+#define VBOX_SHCL_MAX_TRANSFERS                  _2K
 /** Maximum number of events a single Shared Clipboard transfer can have. */
 #define VBOX_SHARED_CLIPBOARD_MAX_EVENTS                     _64K
+#define VBOX_SHCL_MAX_EVENTS                     _64K
 /**
  * Creates a context ID out of a client ID, a transfer ID and a count.
  */
 #define VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(uSessionID, uTransferID, uEventID) \
+#define VBOX_SHCL_CONTEXTID_MAKE(uSessionID, uTransferID, uEventID) \
     (  (uint32_t)((uSessionID)  &   0x1f) << 27 \
      | (uint32_t)((uTransferID) &  0x7ff) << 16 \
 …
     ((uint32_t)((uSessionID) & 0x1f) << 27)
 /** Gets the session ID out of a context ID. */
 #define VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_SESSION(uContextID) \
+#define VBOX_SHCL_CONTEXTID_GET_SESSION(uContextID) \
     (((uContextID) >> 27) & 0x1f)
 /** Gets the transfer ID out of a context ID. */
 …
     (((uContextID) >> 16) & 0x7ff)
 /** Gets the transfer event out of a context ID. */
 #define VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uContextID) \
+#define VBOX_SHCL_CONTEXTID_GET_EVENT(uContextID) \
     ((uContextID) & 0xffff)

trunk/include/VBox/GuestHost/clipboard-helper.h

-              r80662
+              r80847
  * @param   cbSrc               Size (in bytes) of HTML data to dump.
  */
 int VBoxClipboardDbgDumpHtml(const char *pszSrc, size_t cbSrc);
+int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc);
 /**
 …
  * @param   u32Format           Clipboard format to use for dumping.
  */
 void VBoxClipboardDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format);
+void VBoxShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format);
 #endif /* LOG_ENABLED */
 …
  * @param   uMsg                The message to translate.
  */
 const char *VBoxClipboardHostMsgToStr(uint32_t uMsg);
+const char *VBoxShClHostMsgToStr(uint32_t uMsg);
 /**
 …
  * @param   uMsg                The message to translate.
  */
 const char *VBoxClipboardGuestMsgToStr(uint32_t uMsg);
+const char *VBoxShClGuestMsgToStr(uint32_t uMsg);
 #endif /* !VBOX_INCLUDED_GuestHost_clipboard_helper_h */

trunk/include/VBox/HostServices/VBoxClipboardSvc.h

-              r80845
+              r80847
  */
 /** Older saved states (VBox < 6.1). Includes protocol v0 state. */
 #define VBOX_SHARED_CLIPBOARD_SSM_VER_0          UINT32_C(0x80000002)
+#define VBOX_SHCL_SSM_VER_0          UINT32_C(0x80000002)
 /** Protocol v1 is being used. */
 #define VBOX_SHARED_CLIPBOARD_SSM_VER_1          UINT32_C(0x80000003)
+#define VBOX_SHCL_SSM_VER_1          UINT32_C(0x80000003)
 /*
  * The mode of operations.
  */
 #define VBOX_SHARED_CLIPBOARD_MODE_OFF           0
 #define VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST 1
 #define VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST 2
 #define VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL 3
+#define VBOX_SHCL_MODE_OFF           0
+#define VBOX_SHCL_MODE_HOST_TO_GUEST 1
+#define VBOX_SHCL_MODE_GUEST_TO_HOST 2
+#define VBOX_SHCL_MODE_BIDIRECTIONAL 3
 /*
 …
  */
 /** Sets the current Shared Clipboard operation mode. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE           1
+#define VBOX_SHCL_HOST_FN_SET_MODE           1
 /** Run headless on the host, i.e. do not touch the host clipboard. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS       2
+#define VBOX_SHCL_HOST_FN_SET_HEADLESS       2
 /** Reports cancellation of the current operation to the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL             3
+#define VBOX_SHCL_HOST_FN_CANCEL             3
 /** Reports an error to the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR              4
+#define VBOX_SHCL_HOST_FN_ERROR              4
 /** Reports that a new clipboard area has been registered. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_REGISTER      5
+#define VBOX_SHCL_HOST_FN_AREA_REGISTER      5
 /** Reports that a clipboard area has been unregistered. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_UNREGISTER    6
+#define VBOX_SHCL_HOST_FN_AREA_UNREGISTER    6
 /** Reports that a client (host / guest) has attached to a clipboard area. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_ATTACH        7
+#define VBOX_SHCL_HOST_FN_AREA_ATTACH        7
 /** Reports that a client (host / guest) has detached from a clipboard area. */
 #define VBOX_SHARED_CLIPBOARD_HOST_FN_AREA_DETACH        8
+#define VBOX_SHCL_HOST_FN_AREA_DETACH        8
 /**
 …
  */
 /** Asks the client to quit / terminate. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT                         1
+#define VBOX_SHCL_HOST_MSG_QUIT                         1
 /** Reads (simple) data from the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA                    2
+#define VBOX_SHCL_HOST_MSG_READ_DATA                    2
 /** Reports available clipboard format from host to the guest.
  *  Formerly known as VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT               3
+ *  Formerly known as VBOX_SHCL_HOST_MSG_REPORT_FORMATS. */
+#define VBOX_SHCL_HOST_MSG_FORMATS_REPORT               3
 /** Sends a transfer status to the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS          50
+#define VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS          50
 /** Reads the root list header from the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ       51
+#define VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ       51
 /** Writes the root list header to the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_WRITE      52
+#define VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_WRITE      52
 /** Reads a root list entry from the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ     53
+#define VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ     53
 /** Writes a root list entry to the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE    54
+#define VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE    54
 /** Open an URI list on the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN                55
+#define VBOX_SHCL_HOST_MSG_URI_LIST_OPEN                55
 /** Closes a formerly opened URI list on the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE               56
+#define VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE               56
 /** Reads a list header from the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ            57
+#define VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ            57
 /** Writes a list header to the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE           58
+#define VBOX_SHCL_HOST_MSG_URI_LIST_HDR_WRITE           58
 /** Reads a list entry from the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ          59
+#define VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ          59
 /** Writes a list entry to the guest. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE         60
+#define VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_WRITE         60
 /** Open an URI object on the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN                 61
+#define VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN                 61
 /** Closes a formerly opened URI object on the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE                62
+#define VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE                62
 /** Reads from an object on the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ                 63
+#define VBOX_SHCL_HOST_MSG_URI_OBJ_READ                 63
 /** Writes to an object on the guest side. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE                64
+#define VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE                64
 /** Indicates that the host has canceled a transfer. */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL                   65
+#define VBOX_SHCL_HOST_MSG_URI_CANCEL                   65
 /** Indicates that the an unrecoverable error on the host occurred . */
 #define VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR                    66
+#define VBOX_SHCL_HOST_MSG_URI_ERROR                    66
 /*
  * The service functions which are called by guest.
  */
 /** Calls the host and waits (blocking) for an host event VBOX_SHARED_CLIPBOARD_HOST_MSG_*.
+/** Calls the host and waits (blocking) for an host event VBOX_SHCL_HOST_MSG_*.
  *  Note: This is the old message which still is being used for the non-URI Shared Clipboard transfers,
  *        to not break compatibility with older Guest Additions / VBox versions. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD       1
+#define VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD       1
 /** Sends a list of available formats to the host.
  *  Formely known as VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT         2
+ *  Formely known as VBOX_SHCL_GUEST_FN_REPORT_FORMATS. */
+#define VBOX_SHCL_GUEST_FN_FORMATS_REPORT         2
 /** Reads data in specified format from the host. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ              3
+#define VBOX_SHCL_GUEST_FN_DATA_READ              3
 /** Writes data in requested format to the host. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE             4
+#define VBOX_SHCL_GUEST_FN_DATA_WRITE             4
 /** Does the actual protocol handshake. If this message is not
 …
+ *
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT                5
+#define VBOX_SHCL_GUEST_FN_CONNECT                5
 /** Peeks at the next message, returning immediately.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT        6
+#define VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT        6
 /** Peeks at the next message, waiting for one to arrive.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT          7
+#define VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT          7
 /** Gets the next message, returning immediately.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET                8
+#define VBOX_SHCL_GUEST_FN_MSG_GET                8
 /** Sends a transfer status to the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS                 9
+#define VBOX_SHCL_GUEST_FN_STATUS                 9
 /** Replies to a function from the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY                  10
+#define VBOX_SHCL_GUEST_FN_REPLY                  10
 /** Reports the available root entries of a transfer.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ     11
+#define VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ     11
 /** Reports the available root entries of a transfer.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE    12
+#define VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE    12
 /** Reports the available root entries of a transfer.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ   13
+#define VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ   13
 /** Reports the available root entries of a transfer.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE  14
+#define VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE  14
 /** Opens / gets a list handle from the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN              15
+#define VBOX_SHCL_GUEST_FN_LIST_OPEN              15
 /** Closes a list handle from the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE             16
+#define VBOX_SHCL_GUEST_FN_LIST_CLOSE             16
 /** Reads a list header from the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ          17
+#define VBOX_SHCL_GUEST_FN_LIST_HDR_READ          17
 /** Writes a list header to the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE         18
+#define VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE         18
 /** New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ        19
+#define VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ        19
 /** New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE       20
+#define VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE       20
 /** New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN               21
+#define VBOX_SHCL_GUEST_FN_OBJ_OPEN               21
 /** New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE              22
+#define VBOX_SHCL_GUEST_FN_OBJ_CLOSE              22
 /** New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ               23
+#define VBOX_SHCL_GUEST_FN_OBJ_READ               23
 /** New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE              24
+#define VBOX_SHCL_GUEST_FN_OBJ_WRITE              24
 /** Reports cancellation of the current operation to the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL                 25
+#define VBOX_SHCL_GUEST_FN_CANCEL                 25
 /** Reports an error to the host.
  *  New since protocol v1. */
 #define VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR                  26
+#define VBOX_SHCL_GUEST_FN_ERROR                  26
 /** The maximum default chunk size for a single data transfer. */
 #define VBOX_SHARED_CLIPBOARD_MAX_CHUNK_SIZE                  _64K
+#define VBOX_SHCL_MAX_CHUNK_SIZE                  _64K
 /*
 …
  * Kept for maintaining compatibility with older Guest Additions.
  */
 typedef struct _VBoxClipboardGetHostMsgOld
+typedef struct _VBoxShClGetHostMsgOld
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, out: Host message type. */
     HGCMFunctionParameter msg;
     /** uint32_t, out: VBOX_SHARED_CLIPBOARD_FMT_*, depends on the 'msg'.
+    /** uint32_t, out: VBOX_SHCL_FMT_*, depends on the 'msg'.
      *  r=andy This actual can have *different* meanings, depending on the host message type. */
     HGCMFunctionParameter formats; /* OUT uint32_t */
 } VBoxClipboardGetHostMsgOld;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD 2
+} VBoxShClGetHostMsgOld;
+#define VBOX_SHCL_CPARMS_GET_HOST_MSG_OLD 2
 /**
 …
  * and the guest. Not available on older (VBox <= 6.0) hosts.
  */
 typedef struct _VBoxClipboardConnect
+typedef struct _VBoxShClConnect
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, in/out: Checksum type used for data transfer. Currently unused. */
     HGCMFunctionParameter enmChecksumType;
 } VBoxClipboardConnect;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT 5
 typedef struct _VBoxClipboardFormatsMsg
+} VBoxShClConnect;
+#define VBOX_SHCL_CPARMS_CONNECT 5
+typedef struct _VBoxShClFormatsMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, in: Context ID. */
     HGCMFunctionParameter uContext;
     /** uint32_t, out:  VBOX_SHARED_CLIPBOARD_FMT_*. */
+    /** uint32_t, out:  VBOX_SHCL_FMT_*. */
     HGCMFunctionParameter uFormats;
     /** uint32_t, in: Format flags. */
     HGCMFunctionParameter fFlags;
 } VBoxClipboardFormatsMsg;
 typedef struct _VBoxClipboardReadDataReqMsg
+} VBoxShClFormatsMsg;
+typedef struct _VBoxShClReadDataReqMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, out: Maximum size (in bytes) to read. */
     HGCMFunctionParameter cbSize;
 } VBoxClipboardReadDataReqMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_REQ 2
 typedef struct _VBoxClipboardReadDataMsg
+} VBoxShClReadDataReqMsg;
+#define VBOX_SHCL_CPARMS_READ_DATA_REQ 2
+typedef struct _VBoxShClReadDataMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     HGCMFunctionParameter size;   /* OUT uint32_t */
 } VBoxClipboardReadDataMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA 3
 typedef struct _VBoxClipboardWriteDataMsg
+} VBoxShClReadDataMsg;
+#define VBOX_SHCL_CPARMS_READ_DATA 3
+typedef struct _VBoxShClWriteDataMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
         struct
+        {
             /** Returned format as requested in the VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message. */
+            /** Returned format as requested in the VBOX_SHCL_HOST_MSG_READ_DATA message. */
             HGCMFunctionParameter format; /* IN uint32_t */
             /** Data.  */
 …
         } v1;
     } u;
 } VBoxClipboardWriteDataMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA 4
+} VBoxShClWriteDataMsg;
+#define VBOX_SHCL_CPARMS_WRITE_DATA 4
 /**
  * Reports a transfer status.
  */
 typedef struct _VBoxClipboardTransferStatusMsg
+typedef struct _VBoxShClTransferStatusMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, out: Reporting flags. Currently unused and must be 0. */
     HGCMFunctionParameter fFlags;
 } VBoxClipboardTransferStatusMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_STATUS 5
+} VBoxShClTransferStatusMsg;
+#define VBOX_SHCL_CPARMS_TRANSFER_STATUS 5
 /**
 …
  * flag.
+ *
  * Used by: VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG
+ *
  */
 typedef struct _VBoxClipboardGetHostMsg
+ * Used by: VBOX_SHCL_GUEST_FN_GET_HOST_MSG
+ *
+ */
+typedef struct _VBoxShClGetHostMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, in: Whether or not to block (wait) for a  new message to arrive. */
     HGCMFunctionParameter fBlock;
 } VBoxClipboardPeekMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG 3
+} VBoxShClPeekMsg;
+#define VBOX_SHCL_CPARMS_GET_HOST_MSG 3
 /** @todo might be necessary for future. */
 …
  * Status messag for lists and objects.
  */
 typedef struct _VBoxClipboardStatusMsg
+typedef struct _VBoxShClStatusMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** pointer, in: Optional payload of this status, based on the status type. */
     HGCMFunctionParameter pvPayload;
 } VBoxClipboardStatusMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_STATUS 4
+} VBoxShClStatusMsg;
+#define VBOX_SHCL_CPARMS_STATUS 4
 /** Invalid message type, do not use. */
 …
  * Generic reply message.
  */
 typedef struct _VBoxClipboardReplyMsg
+typedef struct _VBoxShClReplyMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
         } ObjClose;
     } u;
 } VBoxClipboardReplyMsg;
+} VBoxShClReplyMsg;
 /** Minimum parameters (HGCM function parameters minus the union) a reply message must have. */
 #define VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN 5
 typedef struct _VBoxClipboardRootListParms
+#define VBOX_SHCL_CPARMS_REPLY_MIN 5
+typedef struct _VBoxShClRootListParms
+{
     /** uint32_t, in: Context ID. s*/
 …
     /** uint32_t, in: Roots listing flags; unused at the moment. */
     HGCMFunctionParameter fRoots;
 } VBoxClipboardRootListParms;
+} VBoxShClRootListParms;
 /**
  * Requests to read the root list.
  */
 typedef struct _VBoxClipboardRootListReadReqMsg
+{
     VBGLIOCHGCMCALL hdr;
     VBoxClipboardRootListParms ReqParms;
 } VBoxClipboardRootListReadReqMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ 2
+typedef struct _VBoxShClRootListReadReqMsg
+{
+    VBGLIOCHGCMCALL hdr;
+    VBoxShClRootListParms ReqParms;
+} VBoxShClRootListReadReqMsg;
+#define VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ 2
 /**
  * Reads / Writes a root list header.
  */
 typedef struct _VBoxClipboardRootListHdrMsg
+{
     VBGLIOCHGCMCALL hdr;
     VBoxClipboardRootListParms ReqParms;
+typedef struct _VBoxShClRootListHdrMsg
+{
+    VBGLIOCHGCMCALL hdr;
+    VBoxShClRootListParms ReqParms;
     /** uint64_t, in/out: Number of total root list entries. */
     HGCMFunctionParameter      cRoots;
 } VBoxClipboardRootListHdrMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR 2
 typedef struct _VBoxClipboardRootListEntryParms
+} VBoxShClRootListHdrMsg;
+#define VBOX_SHCL_CPARMS_ROOT_LIST_HDR 2
+typedef struct _VBoxShClRootListEntryParms
+{
     /** uint32_t, in: Context ID. */
 …
     /** uint32_t, in: Index of root list entry to get (zero-based). */
     HGCMFunctionParameter uIndex;
 } VBoxClipboardRootListEntryParms;
+} VBoxShClRootListEntryParms;
 /**
  * Request to read a list root entry.
  */
 typedef struct _VBoxClipboardRootListEntryReadReqMsg
+typedef struct _VBoxShClRootListEntryReadReqMsg
+{
     VBGLIOCHGCMCALL hdr;
     /** in: Request parameters. */
     VBoxClipboardRootListEntryParms Parms;
 } VBoxClipboardRootListEntryReadReqMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ 3
+    VBoxShClRootListEntryParms Parms;
+} VBoxShClRootListEntryReadReqMsg;
+#define VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ 3
 /**
  * Reads / Writes a root list entry.
  */
 typedef struct _VBoxClipboardRootListEntryMsg
+typedef struct _VBoxShClRootListEntryMsg
+{
     VBGLIOCHGCMCALL hdr;
     /** in/out: Request parameters. */
     VBoxClipboardRootListEntryParms Parms;
+    VBoxShClRootListEntryParms Parms;
     /** pointer, in/out: Entry name. */
     HGCMFunctionParameter           szName;
 …
      *  Do not forget to set the SHCLFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
     HGCMFunctionParameter           pvInfo;
 } VBoxClipboardRootListEntryMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY 6
+} VBoxShClRootListEntryMsg;
+#define VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY 6
 /**
  * Opens a list.
  */
 typedef struct _VBoxClipboardListOpenMsg
+typedef struct _VBoxShClListOpenMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint64_t, out: List handle. */
     HGCMFunctionParameter uHandle;
 } VBoxClipboardListOpenMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN 7
+} VBoxShClListOpenMsg;
+#define VBOX_SHCL_CPARMS_LIST_OPEN 7
 /**
  * Closes a list.
  */
 typedef struct _VBoxClipboardListCloseMsg
+typedef struct _VBoxShClListCloseMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint64_t, in: List handle. */
     HGCMFunctionParameter uHandle;
 } VBoxClipboardListCloseMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE 2
 typedef struct _VBoxClipboardListHdrReqParms
+} VBoxShClListCloseMsg;
+#define VBOX_SHCL_CPARMS_LIST_CLOSE 2
+typedef struct _VBoxShClListHdrReqParms
+{
     /** uint32_t, in: Context ID. */
 …
     /** uint32_t, in: Flags of type VBOX_SHCL_LISTHDR_FLAG_XXX. */
     HGCMFunctionParameter fFlags;
 } VBoxClipboardListHdrReqParms;
+} VBoxShClListHdrReqParms;
 /**
  * Request to read a list header.
  */
 typedef struct _VBoxClipboardListHdrReadReqMsg
+{
     VBGLIOCHGCMCALL hdr;
     VBoxClipboardListHdrReqParms ReqParms;
 } VBoxClipboardListHdrReadReqMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ 3
+typedef struct _VBoxShClListHdrReadReqMsg
+{
+    VBGLIOCHGCMCALL hdr;
+    VBoxShClListHdrReqParms ReqParms;
+} VBoxShClListHdrReadReqMsg;
+#define VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ 3
 /**
  * Reads / Writes a list header.
  */
 typedef struct _VBoxClipboardListHdrMsg
+{
     VBGLIOCHGCMCALL hdr;
     VBoxClipboardListHdrReqParms ReqParms;
+typedef struct _VBoxShClListHdrMsg
+{
+    VBGLIOCHGCMCALL hdr;
+    VBoxShClListHdrReqParms ReqParms;
     /** uint32_t, in/out: Feature flags (see VBOX_SHCL_FEATURE_FLAG_XXX). */
     HGCMFunctionParameter        fFeatures;
 …
     /** uint64_t, in/out:  Number of total bytes to transfer. */
     HGCMFunctionParameter        cbTotalSize;
 } VBoxClipboardListHdrMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR 6
 typedef struct _VBoxClipboardListEntryReqParms
+} VBoxShClListHdrMsg;
+#define VBOX_SHCL_CPARMS_LIST_HDR 6
+typedef struct _VBoxShClListEntryReqParms
+{
     /** uint32_t, in: Context ID. */
 …
     /** uint32_t, in: VBOX_SHCL_INFO_FLAG_XXX. */
     HGCMFunctionParameter fInfo;
 } VBoxClipboardListEntryReqParms;
+} VBoxShClListEntryReqParms;
 /**
  * Request to read a list entry.
  */
 typedef struct _VBoxClipboardListEntryReadReqMsg
+{
     VBGLIOCHGCMCALL hdr;
     VBoxClipboardListEntryReqParms ReqParms;
 } VBoxClipboardListEntryReadReqMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ 3
+typedef struct _VBoxShClListEntryReadReqMsg
+{
+    VBGLIOCHGCMCALL hdr;
+    VBoxShClListEntryReqParms ReqParms;
+} VBoxShClListEntryReadReqMsg;
+#define VBOX_SHCL_CPARMS_LIST_ENTRY_READ 3
 /**
  * Reads / Writes a list entry.
  */
 typedef struct _VBoxClipboardListEntryMsg
+typedef struct _VBoxShClListEntryMsg
+{
     VBGLIOCHGCMCALL hdr;
     /** in/out: Request parameters. */
     VBoxClipboardListEntryReqParms ReqParms;
+    VBoxShClListEntryReqParms ReqParms;
     /** pointer, in/out: Entry name. */
     HGCMFunctionParameter          szName;
 …
      *  Do not forget to set the SHCLFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
     HGCMFunctionParameter          pvInfo;
 } VBoxClipboardListEntryMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY 6
 typedef struct _VBoxClipboardObjOpenMsg
+} VBoxShClListEntryMsg;
+#define VBOX_SHCL_CPARMS_LIST_ENTRY 6
+typedef struct _VBoxShClObjOpenMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t in/out: Open / Create flags of type SHCL_OBJ_CF_. */
     HGCMFunctionParameter fCreate;
 } VBoxClipboardObjOpenMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN 5
 typedef struct _VBoxClipboardObjCloseMsg
+} VBoxShClObjOpenMsg;
+#define VBOX_SHCL_CPARMS_OBJ_OPEN 5
+typedef struct _VBoxShClObjCloseMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint64_t, in: SHCLOBJHANDLE of object to close. */
     HGCMFunctionParameter uHandle;
 } VBoxClipboardObjCloseMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE 2
 typedef struct _VBoxClipboardObjReadReqParms
+} VBoxShClObjCloseMsg;
+#define VBOX_SHCL_CPARMS_OBJ_CLOSE 2
+typedef struct _VBoxShClObjReadReqParms
+{
     /** uint32_t, in: Context ID. */
 …
     /** uint32_t, in: Read flags. Currently unused and must be 0. */
     HGCMFunctionParameter fRead;
 } VBoxClipboardObjReadReqParms;
 typedef struct _VBoxClipboardObjReadReqMsg
+{
     VBGLIOCHGCMCALL hdr;
     VBoxClipboardObjReadReqParms ReqParms;
 } VBoxClipboardObjReadReqMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ 4
+} VBoxShClObjReadReqParms;
+typedef struct _VBoxShClObjReadReqMsg
+{
+    VBGLIOCHGCMCALL hdr;
+    VBoxShClObjReadReqParms ReqParms;
+} VBoxShClObjReadReqMsg;
+#define VBOX_SHCL_CPARMS_OBJ_READ_REQ 4
 /**
 …
+ *
  * Used by:
  * VBOX_SHARED_CLIPBOARD_FN_OBJ_READ
  * VBOX_SHARED_CLIPBOARD_FN_OBJ_WRITE
  */
 typedef struct _VBoxClipboardObjReadWriteMsg
+ * VBOX_SHCL_FN_OBJ_READ
+ * VBOX_SHCL_FN_OBJ_WRITE
+ */
+typedef struct _VBoxShClObjReadWriteMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
      *  type in the data header. Optional. */
     HGCMFunctionParameter pvChecksum;
 } VBoxClipboardObjReadWriteMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ  6
 #define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE 6
+} VBoxShClObjReadWriteMsg;
+#define VBOX_SHCL_CPARMS_OBJ_READ  6
+#define VBOX_SHCL_CPARMS_OBJ_WRITE 6
 /**
 …
+ *
  * Used by:
  * VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR
  */
 typedef struct _VBoxClipboardErrorMsg
+ * VBOX_SHCL_FN_WRITE_ERROR
+ */
+typedef struct _VBoxShClErrorMsg
+{
     VBGLIOCHGCMCALL hdr;
 …
     /** uint32_t, in: The error code (IPRT-style). */
     HGCMFunctionParameter rc;
 } VBoxClipboardWriteErrorMsg;
 #define VBOX_SHARED_CLIPBOARD_CPARMS_ERROR 2
+} VBoxShClWriteErrorMsg;
+#define VBOX_SHCL_CPARMS_ERROR 2
 #pragma pack()

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

r80845	r80847
488	488	LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
489	489
490		if (fFormat == VBOX_SH~~ARED_CLIPBOARD~~_FMT_NONE)
	490	if (fFormat == VBOX_SHCL_FMT_NONE)
491	491	{
492	492	LogFunc(("WM_RENDERFORMAT: Unsupported format requested\n"));
…	…
571	571	* must have the exact string size.
572	572	*/
573		if (fFormat == VBOX_SH~~ARED_CLIPBOARD~~_FMT_UNICODETEXT)
	573	if (fFormat == VBOX_SHCL_FMT_UNICODETEXT)
574	574	{
575	575	size_t cbActual = 0;
…	…
648	648	const SHCLFORMATS fFormats = pEvent->u.ReportedFormats.uFormats;
649	649
650		if (fFormats != VBOX_SH~~ARED_CLIPBOARD~~_FMT_NONE) /* Could arrive with some older GA versions. */
	650	if (fFormats != VBOX_SHCL_FMT_NONE) /* Could arrive with some older GA versions. */
651	651	{
652	652	int rc = SharedClipboardWinOpen(hwnd);
…	…
656	656
657	657	#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
658		if (fFormats & VBOX_SH~~ARED_CLIPBOARD~~_FMT_URI_LIST)
	658	if (fFormats & VBOX_SHCL_FMT_URI_LIST)
659	659	{
660		LogFunc(("VBOX_SH~~ARED_CLIPBOARD~~_FMT_URI_LIST\n"));
	660	LogFunc(("VBOX_SHCL_FMT_URI_LIST\n"));
661	661
662	662	PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->URI, 0); /** @todo FIX !!! */
…	…
705	705	if (RT_SUCCESS(rc))
706	706	{
707		if (uFormat == VBOX_SH~~ARED_CLIPBOARD~~_FMT_BITMAP)
	707	if (uFormat == VBOX_SHCL_FMT_BITMAP)
708	708	{
709	709	hClip = GetClipboardData(CF_DIB);
…	…
725	725	}
726	726	}
727		else if (uFormat == VBOX_SH~~ARED_CLIPBOARD~~_FMT_UNICODETEXT)
	727	else if (uFormat == VBOX_SHCL_FMT_UNICODETEXT)
728	728	{
729	729	hClip = GetClipboardData(CF_UNICODETEXT);
…	…
745	745	}
746	746	}
747		else if (uFormat == VBOX_SH~~ARED_CLIPBOARD~~_FMT_HTML)
	747	else if (uFormat == VBOX_SHCL_FMT_HTML)
748	748	{
749	749	UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
…	…
771	771	}
772	772	#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
773		else if (uFormat == VBOX_SH~~ARED_CLIPBOARD~~_FMT_URI_LIST)
	773	else if (uFormat == VBOX_SHCL_FMT_URI_LIST)
774	774	{
775	775	LogFunc(("cTransfersRunning=%RU32\n", SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
…	…
855	855
856	856	/* Requested clipboard format is not available, send empty data. */
857		VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SH~~ARED_CLIPBOARD~~_FMT_NONE, NULL, 0);
	857	VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHCL_FMT_NONE, NULL, 0);
858	858	#ifdef DEBUG_andy
859	859	AssertFailed();
…	…
1119	1119	}
1120	1120
1121		DECLCALLBACK(int) VBox~~Clipboard~~Init(const PVBOXSERVICEENV pEnv, void **ppInstance)
	1121	DECLCALLBACK(int) VBoxShClInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
1122	1122	{
1123	1123	LogFlowFuncEnter();
…	…
1182	1182	}
1183	1183
1184		DECLCALLBACK(int) VBox~~Clipboard~~Worker(void pInstance, bool volatile pfShutdown)
	1184	DECLCALLBACK(int) VBoxShClWorker(void pInstance, bool volatile pfShutdown)
1185	1185	{
1186	1186	AssertPtr(pInstance);
…	…
1229	1229	switch (uMsg)
1230	1230	{
1231		case VBOX_SH~~ARED_CLIPBOARD~~_HOST_MSG_FORMATS_REPORT:
	1231	case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
1232	1232	{
1233	1233	pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS;
…	…
1236	1236	}
1237	1237
1238		case VBOX_SH~~ARED_CLIPBOARD~~_HOST_MSG_READ_DATA:
	1238	case VBOX_SHCL_HOST_MSG_READ_DATA:
1239	1239	{
1240	1240	pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_READ_DATA;
…	…
1340	1340	}
1341	1341
1342		DECLCALLBACK(int) VBox~~Clipboard~~Stop(void *pInstance)
	1342	DECLCALLBACK(int) VBoxShClStop(void *pInstance)
1343	1343	{
1344	1344	AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
…	…
1356	1356	}
1357	1357
1358		DECLCALLBACK(void) VBox~~Clipboard~~Destroy(void *pInstance)
	1358	DECLCALLBACK(void) VBoxShClDestroy(void *pInstance)
1359	1359	{
1360	1360	AssertPtrReturnVoid(pInstance);
…	…
1388	1388	"Shared Clipboard",
1389	1389	/* methods */
1390		VBox~~Clipboard~~Init,
1391		VBox~~Clipboard~~Worker,
1392		VBox~~Clipboard~~Stop,
1393		VBox~~Clipboard~~Destroy
	1390	VBoxShClInit,
	1391	VBoxShClWorker,
	1392	VBoxShClStop,
	1393	VBoxShClDestroy
1394	1394	};
1395	1395

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp

r78516	r80847
374	374	AssertPtr(pDropFiles);
375	375
376		/** @todo Replace / merge the following code with VBox~~Clipboard~~WinDropFilesToStringList(). */
	376	/** @todo Replace / merge the following code with VBoxShClWinDropFilesToStringList(). */
377	377
378	378	/* Do we need to do Unicode stuff? */

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

-              r80845
+              r80847
     if (RT_SUCCESS(rc))
+    {
         VBoxClipboardConnect Msg;
+        VBoxShClConnect Msg;
         RT_ZERO(Msg);
         VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                            VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT, VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT);
+                           VBOX_SHCL_GUEST_FN_CONNECT, VBOX_SHCL_CPARMS_CONNECT);
         VbglHGCMParmUInt32Set(&Msg.uProtocolVer, 0);
 …
     AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
     VBoxClipboardFormatsMsg Msg;
+    VBoxShClFormatsMsg Msg;
     RT_ZERO(Msg);
 …
+    {
         VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                            VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, 3);
         Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT);
+                           VBOX_SHCL_GUEST_FN_MSG_GET, 3);
+        Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
         Msg.uFormats.SetUInt32(0);
         Msg.fFlags.SetUInt32(0);
 …
     AssertPtrReturn(pDataReq, VERR_INVALID_POINTER);
     VBoxClipboardReadDataReqMsg Msg;
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
+    VBoxShClReadDataReqMsg Msg;
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_READ_DATA);
+    Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_READ_DATA);
     Msg.uFormat.SetUInt32(0);
     Msg.cbSize.SetUInt32(0);
 …
 VBGLR3DECL(int) VbglR3ClipboardGetHostMsgOld(HGCMCLIENTID idClient, uint32_t *pidMsg, uint32_t *pfFormats)
+{
     VBoxClipboardGetHostMsgOld Msg;
+    VBoxShClGetHostMsgOld Msg;
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD, VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD);
+                       VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD, VBOX_SHCL_CPARMS_GET_HOST_MSG_OLD);
     VbglHGCMParmUInt32Set(&Msg.msg, 0);
 …
 VBGLR3DECL(int) VbglR3ClipboardReadData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb)
+{
     VBoxClipboardReadDataMsg Msg;
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
+    VBoxShClReadDataMsg Msg;
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHCL_GUEST_FN_DATA_READ, VBOX_SHCL_CPARMS_READ_DATA);
     VbglHGCMParmUInt32Set(&Msg.format, fFormat);
     VbglHGCMParmPtrSet(&Msg.ptr, pv, cb);
 …
         HGCMFunctionParameter cParameters;
     } Msg;
     VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT, 2);
+    VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->uClientID, VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT, 2);
     VbglHGCMParmUInt64Set(&Msg.idMsg, pidRestoreCheck ? *pidRestoreCheck : 0);
     VbglHGCMParmUInt32Set(&Msg.cParameters, 0);
 …
     if (rc == VERR_INTERRUPTED)
+    {
         VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL, 0);
+        VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->uClientID, VBOX_SHCL_GUEST_FN_CANCEL, 0);
         int rc2 = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg.Hdr));
         AssertRC(rc2);
 …
     AssertPtrReturn(pRootListHdr, VERR_INVALID_POINTER);
     VBoxClipboardRootListHdrMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
+    VBoxShClRootListHdrMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ, VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pRootListEntry, VERR_INVALID_POINTER);
     VBoxClipboardRootListEntryMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY);
+    VBoxShClRootListEntryMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY);
     Msg.Parms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pEnmDir, VERR_INVALID_POINTER);
     VBoxClipboardTransferStatusMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_STATUS);
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS);
+    VBoxShClTransferStatusMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_TRANSFER_STATUS);
+    Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS);
     Msg.enmDir.SetUInt32(0);
     Msg.enmStatus.SetUInt32(0);
 …
     RT_NOREF(pTransfer);
     VBoxClipboardReplyMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN + 1);
+    VBoxShClReplyMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_REPLY, VBOX_SHCL_CPARMS_REPLY_MIN + 1);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     Msg.u.TransferStatus.enmStatus.SetUInt32((uint32_t)uStatus);
     LogFlowFunc(("%s\n", VBoxClipboardTransferStatusToStr(uStatus)));
+    LogFlowFunc(("%s\n", VBoxShClTransferStatusToStr(uStatus)));
     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
 …
     AssertPtrReturn(pfRoots, VERR_INVALID_POINTER);
     VBoxClipboardRootListReadReqMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
     Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ);
+    VBoxShClRootListReadReqMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
+    Msg.ReqParms.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ);
     Msg.ReqParms.fRoots.SetUInt32(0);
 …
     AssertPtrReturn(pRootListHdr, VERR_INVALID_POINTER);
     VBoxClipboardRootListHdrMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR);
+    VBoxShClRootListHdrMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE, VBOX_SHCL_CPARMS_ROOT_LIST_HDR);
     Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pfInfo,  VERR_INVALID_POINTER);
     VBoxClipboardRootListEntryReadReqMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
     Msg.Parms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
+    VBoxShClRootListEntryReadReqMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
+    Msg.Parms.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
     Msg.Parms.fInfo.SetUInt32(0);
     Msg.Parms.uIndex.SetUInt32(0);
 …
     AssertPtrReturn(pEntry, VERR_INVALID_POINTER);
     VBoxClipboardRootListEntryMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY);
+    VBoxShClRootListEntryMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY);
     Msg.Parms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(phList,     VERR_INVALID_POINTER);
     VBoxClipboardListOpenMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
+    VBoxShClListOpenMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_LIST_OPEN, VBOX_SHCL_CPARMS_LIST_OPEN);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER);
     VBoxClipboardListOpenMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN);
+    VBoxShClListOpenMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_LIST_OPEN);
+    Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_LIST_OPEN);
     Msg.fList.SetUInt32(0);
     Msg.cbPath.SetUInt32(pOpenParms->cbPath);
 …
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     VBoxClipboardReplyMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN + 1);
+    VBoxShClReplyMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_REPLY, VBOX_SHCL_CPARMS_REPLY_MIN + 1);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(phList, VERR_INVALID_POINTER);
     VBoxClipboardListCloseMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
+    VBoxShClListCloseMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_LIST_CLOSE);
+    Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE);
     Msg.uHandle.SetUInt64(0);
 …
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     VBoxClipboardReplyMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN + 1);
+    VBoxShClReplyMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_REPLY, VBOX_SHCL_CPARMS_REPLY_MIN + 1);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     VBoxClipboardListCloseMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
+    VBoxShClListCloseMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE, VBOX_SHCL_CPARMS_LIST_CLOSE);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     VBoxClipboardListHdrMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
+    VBoxShClListHdrMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_LIST_HDR_READ, VBOX_SHCL_CPARMS_LIST_HDR);
     Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     VBoxClipboardListHdrReadReqMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
     Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ);
+    VBoxShClListHdrReadReqMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
+    Msg.ReqParms.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ);
     Msg.ReqParms.uHandle.SetUInt64(0);
     Msg.ReqParms.fFlags.SetUInt32(0);
 …
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     VBoxClipboardListHdrMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
+    VBoxShClListHdrMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE, VBOX_SHCL_CPARMS_LIST_HDR);
     Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
     VBoxClipboardListEntryMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY);
+    VBoxShClListEntryMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ, VBOX_SHCL_CPARMS_LIST_ENTRY);
     Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pfInfo, VERR_INVALID_POINTER);
     VBoxClipboardListEntryReadReqMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
     Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
+    VBoxShClListEntryReadReqMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
+    Msg.ReqParms.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ);
     Msg.ReqParms.uHandle.SetUInt64(0);
     Msg.ReqParms.fInfo.SetUInt32(0);
 …
     AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
     VBoxClipboardListEntryMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY);
+    VBoxShClListEntryMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHCL_CPARMS_LIST_ENTRY);
     Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pCreateParms, VERR_INVALID_POINTER);
     VBoxClipboardObjOpenMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
+    VBoxShClObjOpenMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_OBJ_OPEN);
+    Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN);
     Msg.uHandle.SetUInt64(0);
     Msg.cbPath.SetUInt32(pCreateParms->cbPath);
 …
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     VBoxClipboardReplyMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN + 1);
+    VBoxShClReplyMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_REPLY, VBOX_SHCL_CPARMS_REPLY_MIN + 1);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(phObj,        VERR_INVALID_POINTER);
     VBoxClipboardObjOpenMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
+    VBoxShClObjOpenMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_OBJ_OPEN, VBOX_SHCL_CPARMS_OBJ_OPEN);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(phObj, VERR_INVALID_POINTER);
     VBoxClipboardObjCloseMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE);
+    VBoxShClObjCloseMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_OBJ_CLOSE);
+    Msg.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE);
     Msg.uHandle.SetUInt64(0);
 …
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     VBoxClipboardReplyMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY, VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN + 1);
+    VBoxShClReplyMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_REPLY, VBOX_SHCL_CPARMS_REPLY_MIN + 1);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     VBoxClipboardObjCloseMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
+    VBoxShClObjCloseMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_OBJ_CLOSE, VBOX_SHCL_CPARMS_OBJ_CLOSE);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pfFlags,   VERR_INVALID_POINTER);
     VBoxClipboardObjReadReqMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
     Msg.ReqParms.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ);
+    VBoxShClObjReadReqMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_OBJ_READ_REQ);
+    Msg.ReqParms.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_URI_OBJ_READ);
     Msg.ReqParms.uHandle.SetUInt64(0);
     Msg.ReqParms.cbToRead.SetUInt32(0);
 …
     /* pcbRead is optional. */
     VBoxClipboardObjReadWriteMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ);
+    VBoxShClObjReadWriteMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_OBJ_READ, VBOX_SHCL_CPARMS_OBJ_READ);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     /* pcbWritten is optional. */
     VBoxClipboardObjReadWriteMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
+    VBoxShClObjReadWriteMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHCL_GUEST_FN_OBJ_WRITE, VBOX_SHCL_CPARMS_OBJ_WRITE);
     Msg.uContext.SetUInt32(pCtx->uContextID);
 …
     AssertPtrReturn(pEvent,       VERR_INVALID_POINTER);
     LogFunc(("Handling idMsg=%RU32 (%s), cParms=%RU32\n", idMsg, VBoxClipboardHostMsgToStr(idMsg), cParms));
+    LogFunc(("Handling idMsg=%RU32 (%s), cParms=%RU32\n", idMsg, VBoxShClHostMsgToStr(idMsg), cParms));
     int rc;
 …
     switch (idMsg)
+    {
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS:
+        case VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS:
+        {
             SHCLURITRANSFERDIR    enmDir;
 …
                 const SHCLURITRANSFERID uTransferID = VBO_SHARED_CLIPBOARD_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID);
                 LogFlowFunc(("[Transfer %RU16] %s\n", uTransferID, VBoxClipboardTransferStatusToStr(transferReport.uStatus)));
+                LogFlowFunc(("[Transfer %RU16] %s\n", uTransferID, VBoxShClTransferStatusToStr(transferReport.uStatus)));
                 switch (transferReport.uStatus)
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ:
+        case VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ:
+        {
             uint32_t fRoots;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
+        case VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
+        {
             uint32_t uIndex;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN:
+        case VBOX_SHCL_HOST_MSG_URI_LIST_OPEN:
+        {
             SHCLLISTOPENPARMS openParmsList;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE:
+        case VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE:
+        {
             SHCLLISTHANDLE hList;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ:
+        case VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ:
+        {
             /** @todo Handle filter + list features. */
 …
     #if 0
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE\n"));
+        case VBOX_SHCL_HOST_MSG_URI_LIST_HDR_WRITE:
+        {
+            LogFlowFunc(("VBOX_SHCL_HOST_MSG_URI_LIST_HDR_WRITE\n"));
             SHCLLISTHDR hdrList;
 …
     #endif
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ\n"));
+        case VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ:
+        {
+            LogFlowFunc(("VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ\n"));
             SHCLLISTENTRY entryList;
 …
     #if 0
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE\n"));
+        case VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_WRITE:
+        {
+            LogFlowFunc(("VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_WRITE\n"));
             pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_WRITE;
             break;
 …
     #endif
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN:
+        {
             SHCLOBJOPENCREATEPARMS openParms;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE:
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE:
+        {
             SHCLOBJHANDLE hObj;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ:
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_READ:
+        {
             SHCLOBJHANDLE hObj;
 …
     #if 0
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE\n"));
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE:
+        {
+            LogFlowFunc(("VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE\n"));
             break;
+        }
 …
 #ifdef LOG_ENABLED
     LogFunc(("Handling idMsg=%RU32 (%s), protocol v%RU32\n", idMsg, VBoxClipboardHostMsgToStr(idMsg), pCtx->uProtocolVer));
+    LogFunc(("Handling idMsg=%RU32 (%s), protocol v%RU32\n", idMsg, VBoxShClHostMsgToStr(idMsg), pCtx->uProtocolVer));
 #endif
     switch (idMsg)
+    {
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+        case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
+        {
             rc = VbglR3ClipboardFormatsReportRecv(pCtx, &pEvent->u.ReportedFormats);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+        case VBOX_SHCL_HOST_MSG_READ_DATA:
+        {
             rc = VbglR3ClipboardReadDataRecv(pCtx, &pEvent->u.ReadData);
 …
     AssertPtrReturn(phList, VERR_INVALID_POINTER);
     VBoxClipboardListHdrReadMsg Msg;
+    VBoxShClListHdrReadMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ);
+                       VBOX_SHCL_GUEST_FN_LIST_HDR_READ, VBOX_SHCL_CPARMS_LIST_HDR_READ);
     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
 …
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     VBoxClipboardListHdrMsg Msg;
+    VBoxShClListHdrMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR);
+                       VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE, VBOX_SHCL_CPARMS_LIST_HDR);
     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
 …
     AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
     VBoxClipboardListEntryWriteMsg Msg;
+    VBoxShClListEntryWriteMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_WRITE);
+                       VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHCL_CPARMS_LIST_ENTRY_WRITE);
     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
 …
 VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats)
+{
     VBoxClipboardFormatsMsg Msg;
+    VBoxShClFormatsMsg Msg;
     if (pCtx->uProtocolVer == 0)
+    {
         VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT, 1);
+        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHCL_GUEST_FN_FORMATS_REPORT, 1);
         VbglHGCMParmUInt32Set(&Msg.uFormats, pFormats->uFormats);
+    }
     else
+    {
         VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT, 3);
+        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHCL_GUEST_FN_FORMATS_REPORT, 3);
         Msg.uContext.SetUInt32(pCtx->uContextID);
 …
 VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats)
+{
     VBoxClipboardFormatsMsg Msg;
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT, 1);
+    VBoxShClFormatsMsg Msg;
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHCL_GUEST_FN_FORMATS_REPORT, 1);
     VbglHGCMParmUInt32Set(&Msg.uFormats, fFormats);
 …
  * Sends guest clipboard data to the host. Legacy function kept for compatibility, do not use anymore.
+ *
  * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
+ * This is usually called in reply to a VBOX_SHCL_HOST_MSG_READ_DATA message
  * from the host.
+ *
 …
 VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
+{
     VBoxClipboardWriteDataMsg Msg;
+    VBoxShClWriteDataMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE, 2);
+                       VBOX_SHCL_GUEST_FN_DATA_WRITE, 2);
     VbglHGCMParmUInt32Set(&Msg.u.v0.format, fFormat);
 …
  * Sends guest clipboard data to the host.
+ *
  * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
+ * This is usually called in reply to a VBOX_SHCL_HOST_MSG_READ_DATA message
  * from the host.
+ *
 …
     else
+    {
         VBoxClipboardWriteDataMsg Msg;
+        VBoxShClWriteDataMsg Msg;
         RT_ZERO(Msg);
         VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
                            VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA);
+                           VBOX_SHCL_GUEST_FN_DATA_WRITE, VBOX_SHCL_CPARMS_WRITE_DATA);
         LogFlowFunc(("CID=%RU32\n", pCtx->uContextID));
 …
 VBGLR3DECL(int) VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr)
+{
     VBoxClipboardWriteErrorMsg Msg;
     RT_ZERO(Msg);
     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR, VBOX_SHARED_CLIPBOARD_CPARMS_ERROR);
+    VBoxShClWriteErrorMsg Msg;
+    RT_ZERO(Msg);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHCL_GUEST_FN_ERROR, VBOX_SHCL_CPARMS_ERROR);
     /** @todo Context ID not used yet. */

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp

-              r80623
+              r80847
                  * Do the format advertising.
                  */
                 if (fFormats & (VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT/* | VBOX_SHARED_CLIPBOARD_FMT_HTML ?? */))
+                if (fFormats & (VBOX_SHCL_FMT_UNICODETEXT/* | VBOX_SHCL_FMT_HTML ?? */))
+                {
                     if (!WinSetClipbrdData(g_habWorker, 0, CF_TEXT, CFI_POINTER))
 …
                         VGSvcError("WinSetClipbrdData(,,g_atomOdin32UnicodeText,) failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
+                }
                 if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+                if (fFormats & VBOX_SHCL_FMT_BITMAP)
+                {
                     /** @todo bitmaps */
 …
          * -lazybird
          */
         Assert(fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
+        Assert(fFormat & VBOX_SHCL_FMT_UNICODETEXT);
         char *pszUtf8;
         int rc = RTUtf16ToUtf8((PCRTUTF16)pv, &pszUtf8);
 …
     if (    usFmt == CF_TEXT
         ||  usFmt == g_atomOdin32UnicodeText)
         fFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+        fFormat = VBOX_SHCL_FMT_UNICODETEXT;
     else /** @todo bitmaps */
         fFormat = 0;
 …
         uint32_t cb = 0;
         if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
+        {
             /* Got any odin32 unicode text? */
 …
         if (    ulFormat == CF_TEXT
             ||  ulFormat == g_atomOdin32UnicodeText)
             fFormats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+            fFormats |= VBOX_SHCL_FMT_UNICODETEXT;
         /** @todo else bitmaps and stuff. */
+    }
 …
          * Listener message - the host has new formats to offer.
          */
         case WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+        case WM_USER + VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
             vgsvcClipboardOs2AdvertiseHostFormats(LONGFROMMP(mp1));
             break;
 …
          * Listener message - the host wish to read our clipboard data.
          */
         case WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+        case WM_USER + VBOX_SHCL_HOST_MSG_READ_DATA:
             vgsvcClipboardOs2SendDataToHost(LONGFROMMP(mp1));
             break;
 …
                          * respond do WM_RENDERFORMAT message.
                          */
                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
                             if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT,
+                        case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
+                            if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHCL_HOST_MSG_FORMATS_REPORT,
                                             MPFROMLONG(fFormats), 0))
                                 VGSvcError("WinPostMsg(%lx, FORMATS,,) failed, lasterr=%#lx\n",
 …
                          * The host needs data in the specified format.
                          */
                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
                             if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
+                        case VBOX_SHCL_HOST_MSG_READ_DATA:
+                            if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHCL_HOST_MSG_READ_DATA,
                                             MPFROMLONG(fFormats), 0))
                                 VGSvcError("WinPostMsg(%lx, READ_DATA,,) failed, lasterr=%#lx\n",
 …
                          * The host is terminating.
                          */
                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
+                        case VBOX_SHCL_HOST_MSG_QUIT:
                             fQuit = true;
                             break;

trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboard.cpp

-              r80627
+              r80847
+            {
                 /* The host is terminating */
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
+                case VBOX_SHCL_HOST_MSG_QUIT:
                     VBoxClientVerbose(2, "host requested quit\n");
                     fQuit = true;
 …
                 /* The host needs data in the specified format */
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+                case VBOX_SHCL_HOST_MSG_READ_DATA:
                     VBoxClientVerbose(2, "host requested guest's clipboard read\n");
                     rc = vbclClipboardForwardToHost(g_u32ClientId, g_PasteboardRef, fFormats);
 …
                 /* The host has announced available clipboard formats */
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+                case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
                     VBoxClientVerbose(2, "host requested guest's clipboard write\n");
                     rc = vbclClipboardForwardToGuest(g_u32ClientId, g_PasteboardRef, fFormats);

trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp

-              r78188
+              r80847
         if (rc == noErr)
+        {
             VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeUTF16PlainText, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
             VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeUTF8PlainText,  VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
             VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeBMP,            VBOX_SHARED_CLIPBOARD_FMT_BITMAP     );
             VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeHTML,           VBOX_SHARED_CLIPBOARD_FMT_HTML       );
+            VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeUTF16PlainText, VBOX_SHCL_FMT_UNICODETEXT);
+            VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeUTF8PlainText,  VBOX_SHCL_FMT_UNICODETEXT);
+            VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeBMP,            VBOX_SHCL_FMT_BITMAP     );
+            VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeHTML,           VBOX_SHCL_FMT_HTML       );
 #ifdef CLIPBOARD_DUMP_CONTENT_FORMATS
 …
     rc = vboxClipboardUtf16LinToWin(pwszData, cbData / sizeof(RTUTF16), pwszWinTmp, cwcActual);
     if (RT_SUCCESS(rc))
         rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+        rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_UNICODETEXT,
                                         pwszWinTmp, cwcActual * sizeof(RTUTF16));
 …
     AssertRCReturn(rc, rc);
     rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, pvDib, cbDib);
+    rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_BITMAP, pvDib, cbDib);
     return rc;
 …
     while (fFormatsLeft)
+    {
         if (fFormatsLeft & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        {
             VBoxClientVerbose(3, "requested VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT: %d\n", fFormats);
+        if (fFormatsLeft & VBOX_SHCL_FMT_UNICODETEXT)
+        {
+            VBoxClientVerbose(3, "requested VBOX_SHCL_FMT_UNICODETEXT: %d\n", fFormats);
             RTUTF16 *pUtf16Str = NULL;
 …
+            {
                 /* No data found or error occurred: send empty buffer */
                 rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, NULL, 0);
+            }
             fFormatsLeft &= ~(uint32_t)VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+        }
         else if (fFormatsLeft & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        {
             VBoxClientVerbose(3, "requested VBOX_SHARED_CLIPBOARD_FMT_BITMAP: %d\n", fFormats);
+                rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_UNICODETEXT, NULL, 0);
+            }
+            fFormatsLeft &= ~(uint32_t)VBOX_SHCL_FMT_UNICODETEXT;
+        }
+        else if (fFormatsLeft & VBOX_SHCL_FMT_BITMAP)
+        {
+            VBoxClientVerbose(3, "requested VBOX_SHCL_FMT_BITMAP: %d\n", fFormats);
             rc = vbclClipboardReadGuestData(pPasteboard, kUTTypeBMP, &pvData, &cbData, &cbAlloc);
 …
+            {
                 /* No data found or error occurred: send empty buffer */
                 rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, NULL, 0);
+            }
             fFormatsLeft &= ~(uint32_t)VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
+        }
         else if (fFormatsLeft & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+        {
             VBoxClientVerbose(3, "requested VBOX_SHARED_CLIPBOARD_FMT_HTML: %d\n", fFormats);
+                rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_BITMAP, NULL, 0);
+            }
+            fFormatsLeft &= ~(uint32_t)VBOX_SHCL_FMT_BITMAP;
+        }
+        else if (fFormatsLeft & VBOX_SHCL_FMT_HTML)
+        {
+            VBoxClientVerbose(3, "requested VBOX_SHCL_FMT_HTML: %d\n", fFormats);
             rc = vbclClipboardReadGuestData(pPasteboard, kUTTypeHTML, &pvData, &cbData, &cbAlloc);
             if (RT_SUCCESS(rc))
+            {
                 rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_HTML, pvData, cbData);
+                rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_HTML, pvData, cbData);
                 vbclClipboardReleaseGuestData(&pvData, cbAlloc);
+            }
 …
+            {
                 /* No data found or error occurred: send empty buffer */
                 rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_HTML, NULL, 0);
+            }
             fFormatsLeft &= ~(uint32_t)VBOX_SHARED_CLIPBOARD_FMT_HTML;
+                rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_HTML, NULL, 0);
+            }
+            fFormatsLeft &= ~(uint32_t)VBOX_SHCL_FMT_HTML;
+        }

trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp

-              r78188
+              r80847
     while (fFormatsInternal)
+    {
         if (fFormatsInternal & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        {
             VBoxClientVerbose(3, "found VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT: %d\n", fFormatsInternal);
             rc = vbclClipboardReadHostData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &pData, &cbDataSize, &cbMemSize);
+        if (fFormatsInternal & VBOX_SHCL_FMT_UNICODETEXT)
+        {
+            VBoxClientVerbose(3, "found VBOX_SHCL_FMT_UNICODETEXT: %d\n", fFormatsInternal);
+            rc = vbclClipboardReadHostData(u32ClientId, VBOX_SHCL_FMT_UNICODETEXT, &pData, &cbDataSize, &cbMemSize);
             if (RT_SUCCESS(rc))
+            {
 …
+            }
             fFormatsInternal &= ~((uint32_t)VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
+        }
         else if (fFormatsInternal & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        {
             VBoxClientVerbose(3, "found VBOX_SHARED_CLIPBOARD_FMT_BITMAP: %d\n", fFormatsInternal);
             rc = vbclClipboardReadHostData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &pData, &cbDataSize, &cbMemSize);
+            fFormatsInternal &= ~((uint32_t)VBOX_SHCL_FMT_UNICODETEXT);
+        }
+        else if (fFormatsInternal & VBOX_SHCL_FMT_BITMAP)
+        {
+            VBoxClientVerbose(3, "found VBOX_SHCL_FMT_BITMAP: %d\n", fFormatsInternal);
+            rc = vbclClipboardReadHostData(u32ClientId, VBOX_SHCL_FMT_BITMAP, &pData, &cbDataSize, &cbMemSize);
             if (RT_SUCCESS(rc))
+            {
 …
+            }
             fFormatsInternal &= ~((uint32_t)VBOX_SHARED_CLIPBOARD_FMT_BITMAP);
+        }
         else if (fFormatsInternal & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+        {
             VBoxClientVerbose(3, "found VBOX_SHARED_CLIPBOARD_FMT_HTML: %d\n", fFormatsInternal);
             rc = vbclClipboardReadHostData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_HTML, &pData, &cbDataSize, &cbMemSize);
+            fFormatsInternal &= ~((uint32_t)VBOX_SHCL_FMT_BITMAP);
+        }
+        else if (fFormatsInternal & VBOX_SHCL_FMT_HTML)
+        {
+            VBoxClientVerbose(3, "found VBOX_SHCL_FMT_HTML: %d\n", fFormatsInternal);
+            rc = vbclClipboardReadHostData(u32ClientId, VBOX_SHCL_FMT_HTML, &pData, &cbDataSize, &cbMemSize);
             if (RT_SUCCESS(rc))
+            {
 …
+            }
             fFormatsInternal &= ~((uint32_t)VBOX_SHARED_CLIPBOARD_FMT_HTML);
+            fFormatsInternal &= ~((uint32_t)VBOX_SHCL_FMT_HTML);
+        }

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

-              r80664
+              r80847
 VBoxClipboardService::VBoxClipboardService()
      : BHandler("VBoxClipboardService"),
+VBoxShClService::VBoxShClService()
+     : BHandler("VBoxShClService"),
        fClientId(-1),
        fServiceThreadID(-1),
 …
 VBoxClipboardService::~VBoxClipboardService()
+{
+}
 status_t VBoxClipboardService::Connect()
+VBoxShClService::~VBoxShClService()
+{
+}
+status_t VBoxShClService::Connect()
+{
     status_t err;
 …
     if (RT_SUCCESS(rc))
+    {
         err = fServiceThreadID = spawn_thread(_ServiceThreadNub, "VBoxClipboardService", B_NORMAL_PRIORITY, this);
+        err = fServiceThreadID = spawn_thread(_ServiceThreadNub, "VBoxShClService", B_NORMAL_PRIORITY, this);
         if (err >= B_OK)
+        {
 …
                 return B_OK;
             else
                 LogRel(("VBoxClipboardService: Error watching the system clipboard: %ld\n", err));
+                LogRel(("VBoxShClService: Error watching the system clipboard: %ld\n", err));
+        }
         else
             LogRel(("VBoxClipboardService: Error starting service thread: %ld\n", err));
+            LogRel(("VBoxShClService: Error starting service thread: %ld\n", err));
         //rc = RTErrConvertFromErrno(err);
 …
+    }
     else
         LogRel(("VBoxClipboardService: Error starting service thread: %d\n", rc));
+        LogRel(("VBoxShClService: Error starting service thread: %d\n", rc));
     return B_ERROR;
+}
 status_t VBoxClipboardService::Disconnect()
+status_t VBoxShClService::Disconnect()
+{
     status_t status;
 …
 void VBoxClipboardService::MessageReceived(BMessage *message)
+void VBoxShClService::MessageReceived(BMessage *message)
+{
     uint32_t formats = 0;
 …
+            }
             if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+            {
                 pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &cb);
+            if (formats & VBOX_SHCL_FMT_UNICODETEXT)
+            {
+                pv = _VBoxReadHostClipboard(VBOX_SHCL_FMT_UNICODETEXT, &cb);
                 if (pv)
+                {
 …
+            }
             if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+            {
                 pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &cb);
+            if (formats & VBOX_SHCL_FMT_BITMAP)
+            {
+                pv = _VBoxReadHostClipboard(VBOX_SHCL_FMT_BITMAP, &cb);
                 if (pv)
+                {
 …
             clip->PrintToStream();
             if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+            if (formats & VBOX_SHCL_FMT_UNICODETEXT)
+            {
                 const char *text;
 …
                         uint32_t cb = (RTUtf16Len(pwsz) + 1) * sizeof(RTUTF16);
                         rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, pwsz, cb);
+                        rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHCL_FMT_UNICODETEXT, pwsz, cb);
                         //printf("VbglR3ClipboardWriteData: %d\n", rc);
                         RTUtf16Free(pwsz);
 …
+                }
+            }
             else if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+            else if (formats & VBOX_SHCL_FMT_BITMAP)
+            {
                 BMessage archivedBitmap;
 …
                                 if (RT_SUCCESS(rc))
+                                {
                                     rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, (void *)pDib,
+                                    rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHCL_FMT_BITMAP, (void *)pDib,
                                                                   cbDibSize);
+                                }
 …
             if (clip->FindData("text/plain", B_MIME_TYPE, &data, &dataLen) == B_OK)
                 formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+                formats |= VBOX_SHCL_FMT_UNICODETEXT;
             if (   clip->HasMessage("image/bitmap")
                 || clip->HasMessage("image/x-be-bitmap"))
+            {
                 formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
+                formats |= VBOX_SHCL_FMT_BITMAP;
+            }
 …
 status_t VBoxClipboardService::_ServiceThreadNub(void *_this)
+{
     VBoxClipboardService *service = (VBoxClipboardService *)_this;
+status_t VBoxShClService::_ServiceThreadNub(void *_this)
+{
+    VBoxShClService *service = (VBoxShClService *)_this;
     return service->_ServiceThread();
+}
 status_t VBoxClipboardService::_ServiceThread()
+{
     printf("VBoxClipboardService::%s()\n", __FUNCTION__);
+status_t VBoxShClService::_ServiceThread()
+{
+    printf("VBoxShClService::%s()\n", __FUNCTION__);
     /* The thread waits for incoming messages from the host. */
 …
             switch (u32Msg)
+            {
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+                case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
+                {
                     /*
 …
                      * the information to the handler.
                      */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS u32Formats=%x\n", u32Formats));
+                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_REPORT_FORMATS u32Formats=%x\n", u32Formats));
                     BMessage msg(VBOX_GUEST_CLIPBOARD_HOST_MSG_FORMATS);
                     msg.AddInt32("Formats", (uint32)u32Formats);
 …
+                }
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+                case VBOX_SHCL_HOST_MSG_READ_DATA:
+                {
                     /* The host needs data in the specified format. */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA u32Formats=%x\n", u32Formats));
+                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_READ_DATA u32Formats=%x\n", u32Formats));
                     BMessage msg(VBOX_GUEST_CLIPBOARD_HOST_MSG_READ_DATA);
                     msg.AddInt32("Formats", (uint32)u32Formats);
 …
+                }
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
+                case VBOX_SHCL_HOST_MSG_QUIT:
+                {
                     /* The host is terminating. */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
+                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_QUIT\n"));
                     fExiting = true;
                     return VERR_INTERRUPTED;
 …
                 default:
                     Log(("VBoxClipboardService::%s: Unsupported message from host! Message = %u\n", __FUNCTION__, u32Msg));
+                    Log(("VBoxShClService::%s: Unsupported message from host! Message = %u\n", __FUNCTION__, u32Msg));
+            }
+        }
 …
 void* VBoxClipboardService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
+void* VBoxShClService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
+{
     uint32_t cb = 1024;

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.h

-              r76563
+              r80847
 #include <Handler.h>
 class VBoxClipboardService : public BHandler
+class VBoxShClService : public BHandler
+{
     public:
         VBoxClipboardService();
         virtual ~VBoxClipboardService();
+        VBoxShClService();
+        virtual ~VBoxShClService();
         virtual status_t    Connect();

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.h

r76563	r80847
65	65	#include <VBoxGuestInternal.h>
66	66
67		class VBox~~Clipboard~~Service;
	67	class VBoxShClService;
68	68
69	69	class VBoxGuestApplication : public BApplication

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.cpp

r76553	r80847
269	269	if (RT_SUCCESS(rc))
270	270	{
271		fClipboardService = new VBox~~Clipboard~~Service();
	271	fClipboardService = new VBoxShClService();
272	272	fDisplayService = new VBoxDisplayService();
273	273	}

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h

r76563	r80847
92	92	BBitmap *fIcon;
93	93
94		VBox~~Clipboard~~Service *fClipboardService;
	94	VBoxShClService *fClipboardService;
95	95	VBoxDisplayService *fDisplayService;
96	96	};

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxServiceDescriptor.h

-              r76563
+              r80847
 #include <Handler.h>
 class VBoxClipboardService : public BHandler
+class VBoxShClService : public BHandler
+{
     public:
         VBoxClipboardService();
         virtual ~VBoxClipboardService();
+        VBoxShClService();
+        virtual ~VBoxShClService();
 };
 /* The shared clipboard service prototypes. */
 int VBoxClipboardInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
 unsigned __stdcall VBoxClipboardThread(void *pInstance);
 void VBoxClipboardDestroy(const VBOXSERVICEENV *pEnv, void *pInstance);
+int VBoxShClInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
+unsigned __stdcall VBoxShClThread(void *pInstance);
+void VBoxShClDestroy(const VBOXSERVICEENV *pEnv, void *pInstance);
 #endif /* !GA_INCLUDED_SRC_haiku_VBoxTray_VBoxServiceDescriptor_h */

trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp

-              r80664
+              r80847
             switch (Msg)
+            {
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+                case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
+                {
                     /* The host has announced available clipboard formats.
 …
                      * future requests from guest applications.
                      */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_WRITE fFormats=%x\n", fFormats));
+                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_FORMATS_WRITE fFormats=%x\n", fFormats));
                     ClipAnnounceFormatToX11(g_ctx.pBackend, fFormats);
                     break;
+                }
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+                case VBOX_SHCL_HOST_MSG_READ_DATA:
+                {
                     /* The host needs data in the specified format. */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA fFormats=%x\n", fFormats));
+                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_READ_DATA fFormats=%x\n", fFormats));
                     CLIPREADCBREQ *pReq;
                     pReq = (CLIPREADCBREQ *)RTMemAllocZ(sizeof(*pReq));
 …
+                }
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
+                case VBOX_SHCL_HOST_MSG_QUIT:
+                {
                     /* The host is terminating. */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
+                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_QUIT\n"));
                     if (RT_SUCCESS(ClipStopX11(g_ctx.pBackend)))
                         ClipDestructX11(g_ctx.pBackend);

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp

-              r80845
+              r80847
     pSource->uID          = uID;
     /* Choose a random event ID starting point. */
     pSource->uEventIDNext = RTRandU32() % VBOX_SHARED_CLIPBOARD_MAX_EVENTS;
+    pSource->uEventIDNext = RTRandU32() % VBOX_SHCL_MAX_EVENTS;
     LogFlowFuncLeaveRC(rc);
 …
     pSource->uEventIDNext++;
     if (pSource->uEventIDNext == VBOX_SHARED_CLIPBOARD_MAX_EVENTS)
+    if (pSource->uEventIDNext == VBOX_SHCL_MAX_EVENTS)
         pSource->uEventIDNext = 0;
 …
 #ifdef LOG_ENABLED
 int VBoxClipboardDbgDumpHtml(const char *pszSrc, size_t cbSrc)
+int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
+{
     size_t cchIgnored = 0;
 …
+}
 void VBoxClipboardDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
+{
     if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    {
         LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT:\n"));
+void VBoxShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT u32Format)
+{
+    if (u32Format & VBOX_SHCL_FMT_UNICODETEXT)
+    {
+        LogFunc(("VBOX_SHCL_FMT_UNICODETEXT:\n"));
         if (pv && cb)
             LogFunc(("%ls\n", pv));
 …
             LogFunc(("%p %zu\n", pv, cb));
+    }
     else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
         LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
     else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+    {
         LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_HTML:\n"));
+    else if (u32Format & VBOX_SHCL_FMT_BITMAP)
+        LogFunc(("VBOX_SHCL_FMT_BITMAP\n"));
+    else if (u32Format & VBOX_SHCL_FMT_HTML)
+    {
+        LogFunc(("VBOX_SHCL_FMT_HTML:\n"));
         if (pv && cb)
+        {
 …
  * @param   uMsg                The message to translate.
  */
 const char *VBoxClipboardHostMsgToStr(uint32_t uMsg)
+const char *VBoxShClHostMsgToStr(uint32_t uMsg)
+{
     switch (uMsg)
+    {
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_CANCEL);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ERROR);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_QUIT);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_OPEN);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_CANCEL);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ERROR);
+    }
     return "Unknown";
 …
  * @param   uMsg                The message to translate.
  */
 const char *VBoxClipboardGuestMsgToStr(uint32_t uMsg)
+const char *VBoxShClGuestMsgToStr(uint32_t uMsg)
+{
     switch (uMsg)
+    {
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL);
         RT_CASE_RET_STR(VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_FORMATS_REPORT);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_CONNECT);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_GET);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_STATUS);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPLY);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_OPEN);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_CLOSE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_OPEN);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_CLOSE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_CANCEL);
+        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ERROR);
+    }
     return "Unknown";

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

-              r80845
+              r80847
      * max-1 IDs.
      */
     uint32_t idTransfer = RTRandU32Ex(1, VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS - 2);
+    uint32_t idTransfer = RTRandU32Ex(1, VBOX_SHCL_MAX_TRANSFERS - 2);
     if (!ASMBitTestAndSet(&pURI->bmTransferIds[0], idTransfer))
     { /* likely */ }
     else if (pURI->cTransfers < VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS - 2 /* First and last are not used */)
+    else if (pURI->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
+    {
         /* Forward search. */
         int iHit = ASMBitNextClear(&pURI->bmTransferIds[0], VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS, idTransfer);
+        int iHit = ASMBitNextClear(&pURI->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS, idTransfer);
         if (iHit < 0)
             iHit = ASMBitFirstClear(&pURI->bmTransferIds[0], VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS);
+            iHit = ASMBitFirstClear(&pURI->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS);
         AssertLogRelMsgReturn(iHit >= 0, ("Transfer count: %RU16\n", pURI->cTransfers), VERR_SHCLPB_MAX_TRANSFERS_REACHED);
         idTransfer = iHit;
 …
     LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pURI->cTransfers, idTransfer));
     if (pURI->cTransfers < VBOX_SHARED_CLIPBOARD_MAX_TRANSFERS - 2 /* First and last are not used */)
+    if (pURI->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
+    {
         if (!ASMBitTestAndSet(&pURI->bmTransferIds[0], idTransfer))
 …
  * @param   uStatus             The transfer status to translate.
  */
 const char *VBoxClipboardTransferStatusToStr(uint32_t uStatus)
+const char *VBoxShClTransferStatusToStr(uint32_t uStatus)
+{
     switch (uStatus)

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp

-              r80845
+              r80847
  * Converts a (registered or standard) Windows clipboard format to a VBox clipboard format.
+ *
  * @returns Converted VBox clipboard format, or VBOX_SHARED_CLIPBOARD_FMT_NONE if not found.
+ * @returns Converted VBox clipboard format, or VBOX_SHCL_FMT_NONE if not found.
  * @param   uFormat             Windows clipboard format to convert.
  */
 …
+{
     /* Insert the requested clipboard format data into the clipboard. */
     SHCLFORMAT vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    SHCLFORMAT vboxFormat = VBOX_SHCL_FMT_NONE;
     switch (uFormat)
+    {
         case CF_UNICODETEXT:
             vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+            vboxFormat = VBOX_SHCL_FMT_UNICODETEXT;
             break;
         case CF_DIB:
             vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
+            vboxFormat = VBOX_SHCL_FMT_BITMAP;
             break;
 …
          * This does *not* invoke any IDataObject / IStream implementations! */
         case CF_HDROP:
             vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_URI_LIST;
+            vboxFormat = VBOX_SHCL_FMT_URI_LIST;
             break;
 #endif
 …
                     if (RTStrCmp(szFormatName, SHCL_WIN_REGFMT_HTML) == 0)
                         vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_HTML;
+                        vboxFormat = VBOX_SHCL_FMT_HTML;
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
                     /* These types invoke our IDataObject / IStream implementations. */
                     else if (   (RTStrCmp(szFormatName, CFSTR_FILEDESCRIPTORA) == 0)
                              || (RTStrCmp(szFormatName, CFSTR_FILECONTENTS)    == 0))
                         vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_URI_LIST;
+                        vboxFormat = VBOX_SHCL_FMT_URI_LIST;
                     /** @todo Do we need to handle CFSTR_FILEDESCRIPTORW here as well? */
 #endif
 …
     AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
     SHCLFORMATS fFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    SHCLFORMATS fFormats = VBOX_SHCL_FMT_NONE;
     /* Query list of available formats and report to host. */
 …
     /** @todo Implement more flexible clipboard precedence for supported formats. */
     if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (fFormats & VBOX_SHCL_FMT_UNICODETEXT)
+    {
         LogFunc(("CF_UNICODETEXT\n"));
         hClip = SetClipboardData(CF_UNICODETEXT, NULL);
+    }
     else if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    else if (fFormats & VBOX_SHCL_FMT_BITMAP)
+    {
         LogFunc(("CF_DIB\n"));
         hClip = SetClipboardData(CF_DIB, NULL);
+    }
     else if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+    {
         LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_HTML\n"));
+    else if (fFormats & VBOX_SHCL_FMT_HTML)
+    {
+        LogFunc(("VBOX_SHCL_FMT_HTML\n"));
         cfFormat = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
         if (cfFormat != 0)

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp

-              r80662
+              r80847
+{
     { "INVALID", INVALID, 0 },
     { "UTF8_STRING", UTF8, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "UTF8_STRING", UTF8, VBOX_SHCL_FMT_UNICODETEXT },
     { "text/plain;charset=UTF-8", UTF8,
       VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+      VBOX_SHCL_FMT_UNICODETEXT },
     { "text/plain;charset=utf-8", UTF8,
       VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
     { "STRING", TEXT, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
     { "TEXT", TEXT, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
     { "text/plain", TEXT, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
     { "text/html", HTML, VBOX_SHARED_CLIPBOARD_FMT_HTML },
+      VBOX_SHCL_FMT_UNICODETEXT },
+    { "STRING", TEXT, VBOX_SHCL_FMT_UNICODETEXT },
+    { "TEXT", TEXT, VBOX_SHCL_FMT_UNICODETEXT },
+    { "text/plain", TEXT, VBOX_SHCL_FMT_UNICODETEXT },
+    { "text/html", HTML, VBOX_SHCL_FMT_HTML },
     { "text/html;charset=utf-8", HTML,
       VBOX_SHARED_CLIPBOARD_FMT_HTML },
     { "image/bmp", BMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP },
     { "image/x-bmp", BMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP },
     { "image/x-MS-bmp", BMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP }
+      VBOX_SHCL_FMT_HTML },
+    { "image/bmp", BMP, VBOX_SHCL_FMT_BITMAP },
+    { "image/x-bmp", BMP, VBOX_SHCL_FMT_BITMAP },
+    { "image/x-MS-bmp", BMP, VBOX_SHCL_FMT_BITMAP }
 …
+        {
             if (   (clipVBoxFormatForX11Format(format)
                             == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+                            == VBOX_SHCL_FMT_UNICODETEXT)
                     && enmBestTextTarget < clipRealFormatForX11Format(format))
+            {
 …
+        {
             if (   (clipVBoxFormatForX11Format(format)
                             == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+                            == VBOX_SHCL_FMT_BITMAP)
                     && enmBestBitmapTarget < clipRealFormatForX11Format(format))
+            {
 …
         if (format != NIL_CLIPX11FORMAT)
+        {
             if (   (clipVBoxFormatForX11Format(format) == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHCL_FMT_HTML)
                 && enmBestHtmlTarget < clipRealFormatForX11Format(format))
+            {
 …
     XtToolkitInitialize();
     pCtx->appContext = XtCreateApplicationContext();
     pDisplay = XtOpenDisplay(pCtx->appContext, 0, 0, "VBoxClipboard", 0, 0, &cArgc, &pcArgv);
+    pDisplay = XtOpenDisplay(pCtx->appContext, 0, 0, "VBoxShCl", 0, 0, &cArgc, &pcArgv);
     if (NULL == pDisplay)
+    {
 …
     if (RT_SUCCESS(rc))
+    {
         pCtx->widget = XtVaAppCreateShell(0, "VBoxClipboard",
+        pCtx->widget = XtVaAppCreateShell(0, "VBoxShCl",
                                           applicationShellWidgetClass,
                                           pDisplay, XtNwidth, 1, XtNheight,
 …
  * data returned.
  */
 static int clipReadVBoxClipboard(CLIPBACKEND *pCtx, uint32_t u32Format,
+static int clipReadVBoxShCl(CLIPBACKEND *pCtx, uint32_t u32Format,
                                  void **ppv, uint32_t *pcb)
+{
 …
     LogRelFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx,
                  u32Format, ppv, pcb));
     if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (u32Format == VBOX_SHCL_FMT_UNICODETEXT)
+    {
         if (pCtx->pvUnicodeCache == NULL)
 …
     CLIPFORMAT format = clipRealFormatForX11Format(x11Format);
     if (   ((format == UTF8) || (format == TEXT))
         && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT))
+        && (pCtx->vboxFormats & VBOX_SHCL_FMT_UNICODETEXT))
+    {
         void *pv = NULL;
         uint32_t cb = 0;
         rc = clipReadVBoxClipboard(pCtx,
                                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+        rc = clipReadVBoxShCl(pCtx,
+                                   VBOX_SHCL_FMT_UNICODETEXT,
                                    &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
 …
+    }
     else if (   (format == BMP)
              && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP))
+             && (pCtx->vboxFormats & VBOX_SHCL_FMT_BITMAP))
+    {
         void *pv = NULL;
         uint32_t cb = 0;
         rc = clipReadVBoxClipboard(pCtx,
                                    VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
+        rc = clipReadVBoxShCl(pCtx,
+                                   VBOX_SHCL_FMT_BITMAP,
                                    &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
 …
+    }
     else if ( (format == HTML)
             && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_HTML))
+            && (pCtx->vboxFormats & VBOX_SHCL_FMT_HTML))
+    {
         void *pv = NULL;
         uint32_t cb = 0;
         rc = clipReadVBoxClipboard(pCtx,
                                    VBOX_SHARED_CLIPBOARD_FMT_HTML,
+        rc = clipReadVBoxShCl(pCtx,
+                                   VBOX_SHCL_FMT_HTML,
                                    &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
 …
         /* The clipboard selection may have changed before we could get it. */
         rc = VERR_NO_DATA;
     else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    else if (pReq->mFormat == VBOX_SHCL_FMT_UNICODETEXT)
+    {
         /* In which format is the clipboard data? */
 …
+        }
+    }
     else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    else if (pReq->mFormat == VBOX_SHCL_FMT_BITMAP)
+    {
         /* In which format is the clipboard data? */
 …
+        }
+    }
     else if(pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+    else if(pReq->mFormat == VBOX_SHCL_FMT_HTML)
+    {
         /* In which format is the clipboard data? */
 …
     else
 #endif
     if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (pReq->mFormat == VBOX_SHCL_FMT_UNICODETEXT)
+    {
         /*
 …
             getSelectionValue(pCtx, pCtx->X11TextFormat, pReq);
+    }
     else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    else if (pReq->mFormat == VBOX_SHCL_FMT_BITMAP)
+    {
         pReq->mBitmapFormat = pCtx->X11BitmapFormat;
 …
             getSelectionValue(pCtx, pCtx->X11BitmapFormat, pReq);
+    }
     else if(pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+    else if(pReq->mFormat == VBOX_SHCL_FMT_HTML)
+    {
         /* Send out a request for the data to the current clipboard
 …
     g_vboxDatacb = cb;
     ClipAnnounceFormatToX11(pCtx,
                                        VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
+                                       VBOX_SHCL_FMT_UNICODETEXT);
     return VINF_SUCCESS;
+}
 …
     bool retval = true;
     clipSendTargetUpdate(pCtx);
     if (clipQueryFormats() != VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (clipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
         RTTestFailed(hTest, "Wrong targets reported: %02X\n",
                      clipQueryFormats());
 …
         char *pc;
         CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL;
         ClipRequestDataFromX11(pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+        ClipRequestDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT,
                                pReq);
         int rc = VINF_SUCCESS;
 …
     bool retval = false;
     clipSendTargetUpdate(pCtx);
     if (clipQueryFormats() != VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (clipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
         RTTestFailed(hTest, "Wrong targets reported: %02X\n",
                      clipQueryFormats());
 …
         char *pc;
         CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL;
         ClipRequestDataFromX11(pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+        ClipRequestDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT,
                                pReq);
         int rc = VINF_SUCCESS;
 …
     CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq;
     int rc = ClipRequestDataFromX11(pCtx,
                                     VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                    VBOX_SHCL_FMT_UNICODETEXT,
                                     pReq);
     RTTESTI_CHECK_MSG(rc == VERR_NO_DATA, ("context: %s\n", pcszTestCtx));
 …
                            sizeof("hello world"), 8);
     clipSendTargetUpdate(pCtx);
     if (clipQueryFormats() != VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (clipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
         RTTestFailed(hTest, "Wrong targets reported: %02X\n",
                      clipQueryFormats());
 …
         clipSetSelectionValues("", XA_STRING, "", sizeof(""), 8);
         clipSendTargetUpdate(pCtx);
         if (clipQueryFormats() == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        if (clipQueryFormats() == VBOX_SHCL_FMT_UNICODETEXT)
             RTTestFailed(hTest, "Failed to report targets after bad host request.\n");
+    }
 …
     clipSetSelectionValues("UTF8_STRING", XA_STRING, NULL,
 , 8);
     ClipRequestDataFromX11(pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+    ClipRequestDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT,
                            pReq);
     clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp

-              r80664
+              r80847
     LogFlowFunc(("uFormats=%02X\n", pFormats->uFormats));
     if (pFormats->uFormats == VBOX_SHARED_CLIPBOARD_FMT_NONE)
+    if (pFormats->uFormats == VBOX_SHCL_FMT_NONE)
+    {
         /* This is just an automatism, not a genuine announcement */
 …
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) /* No URI support yet. */
+    if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST) /* No URI support yet. */
         return VINF_SUCCESS;
 #endif

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

-              r80845
+              r80847
     int rc;
     PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
                                                         VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
+    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ,
+                                                        VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     if (pMsgHdr)
+    {
         SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                                    pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */);
 …
                                 for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
+                                {
                                     PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
                                                                                           VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
+                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
+                                                                                          VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
                                     uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
                                     HGCMSvcSetU32(&pMsgEntry->paParms[0],
                                                   VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uClientID,
+                                                  VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uClientID,
                                                                                        pCtx->pTransfer->State.uID, uEvent));
                                     HGCMSvcSetU32(&pMsgEntry->paParms[1], 0 /* fRoots */);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_OPEN,
+                                                     VBOX_SHCL_CPARMS_LIST_OPEN);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
+        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
                                                                       uEvent);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE,
+                                                     VBOX_SHCL_CPARMS_LIST_CLOSE);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
+        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
                                                                     uEvent);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ,
+                                                     VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ,
+                                                     VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN,
+                                                     VBOX_SHCL_CPARMS_OBJ_OPEN);
     if (pMsg)
+    {
 …
         const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], 0); /* uHandle */
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE,
+                                                     VBOX_SHCL_CPARMS_OBJ_CLOSE);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_READ,
+                                                     VBOX_SHCL_CPARMS_OBJ_READ_REQ);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
                                                      VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE,
+                                                     VBOX_SHCL_CPARMS_OBJ_WRITE);
     if (pMsg)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
 …
     int rc;
     if (cParms >= VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN)
+    if (cParms >= VBOX_SHCL_CPARMS_REPLY_MIN)
+    {
         uint32_t cbPayload = 0;
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_HDR)
+    {
         rc = HGCMSvcGetU32(&paParms[1], &pRootLstHdr->fRoots);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY)
+    {
         rc = HGCMSvcGetU32(&paParms[1], &pListEntry->fInfo);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
+    {
         uint32_t cbPath   = 0;
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
+    {
         HGCMSvcSetU32(&paParms[0], pMsgCtx->uContextID);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_CLOSE)
+    {
         HGCMSvcSetU32(&paParms[0], pMsgCtx->uContextID);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
+    {
         rc = HGCMSvcGetU64(&paParms[1], phList);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
+    {
         /** @todo Set pvMetaFmt + cbMetaFmt. */
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
+    {
         rc = HGCMSvcGetU64(&paParms[1], phList);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
+    {
         /** @todo Calculate chunk checksum. */
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE)
+    if (cParms == VBOX_SHCL_CPARMS_OBJ_WRITE)
+    {
         rc = HGCMSvcGetU64(&paParms[1], &pDataChunk->uHandle);
 …
     int rc;
     if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ERROR)
+    if (cParms == VBOX_SHCL_CPARMS_ERROR)
+    {
         rc = HGCMSvcGetU32(&paParms[1], (uint32_t *)pRc); /** @todo int vs. uint32_t !!! */
 …
 /**
  * Handles a guest reply (VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY) message.
+ * Handles a guest reply (VBOX_SHCL_GUEST_FN_REPLY) message.
+ *
  * @returns VBox status code.
 …
                         if (RT_SUCCESS(rc))
+                        {
                             const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                            const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
                             LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent));
 …
     LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n",
                  pClient->State.uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
+                 pClient->State.uClientID, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
 #if 0
 …
     switch (u32Function)
+    {
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
+        case VBOX_SHCL_GUEST_FN_STATUS:
             break;
         default:
 …
+    {
 #if 0
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
+        {
             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_STATUS)
+        case VBOX_SHCL_GUEST_FN_STATUS:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_STATUS)
                 break;
 …
                         rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
                         if (RT_SUCCESS(rc))
                             rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
+                            rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
+                    }
 …
+            }
             LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
+            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
             if (RT_FAILURE(rc))
 …
 #endif
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
+        case VBOX_SHCL_GUEST_FN_REPLY:
+        {
             rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ:
+        {
             break;
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
+        {
+            break;
+        }
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE:
+        {
             SHCLROOTLISTHDR lstHdr;
 …
                 uint32_t cbData = sizeof(SHCLROOTLISTHDR);
                 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
                 PSHCLEVENTPAYLOAD pPayload;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
+        {
     #if 0
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
+        {
             SHCLROOTLISTENTRY lstEntry;
 …
                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
                 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
                 PSHCLEVENTPAYLOAD pPayload;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
+        case VBOX_SHCL_GUEST_FN_LIST_OPEN:
+        {
             SHCLLISTOPENPARMS listOpenParms;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
+        {
             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
+        case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_LIST_CLOSE)
                 break;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
+        {
             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_LIST_HDR)
                 break;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE:
+        {
             SHCLLISTHDR hdrList;
 …
                     uint32_t cbData = sizeof(SHCLLISTHDR);
                     const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                    const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
                     PSHCLEVENTPAYLOAD pPayload;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
+        {
             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_LIST_ENTRY)
                 break;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE:
+        {
             SHCLLISTENTRY entryList;
 …
                     uint32_t cbData = sizeof(SHCLLISTENTRY);
                     const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                    const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
                     PSHCLEVENTPAYLOAD pPayload;
 …
     #if 0
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
+        {
             break;
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE:
+        {
             break;
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ:
+        case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
+        {
+            break;
+        }
+        case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
+        {
+            break;
+        }
+        case VBOX_SHCL_GUEST_FN_OBJ_READ:
+        {
             break;
 …
     #endif
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
+        case VBOX_SHCL_GUEST_FN_OBJ_WRITE:
+        {
             SHCLOBJDATACHUNK dataChunk;
 …
                 uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
                 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
                 PSHCLEVENTPAYLOAD pPayload;
 …
     #if 0
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR\n"));
+        case VBOX_SHCL_GUEST_FN_WRITE_DIR:
+        {
+            LogFlowFunc(("VBOX_SHCL_GUEST_FN_WRITE_DIR\n"));
             SHCLDIRDATA dirData;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n"));
+        case VBOX_SHCL_GUEST_FN_READ_FILE_HDR:
+        {
+            LogFlowFunc(("VBOX_SHCL_GUEST_FN_READ_FILE_HDR\n"));
             SHCLFILEHDR fileHdr;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR\n"));
+        case VBOX_SHCL_GUEST_FN_WRITE_FILE_HDR:
+        {
+            LogFlowFunc(("VBOX_SHCL_GUEST_FN_WRITE_FILE_HDR\n"));
             if (!SharedClipboardURIObjCtxIsValid(SharedClipboardURITransferGetCurrentObjCtx(pTransfer)))
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_DATA:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n"));
+        case VBOX_SHCL_GUEST_FN_READ_FILE_DATA:
+        {
+            LogFlowFunc(("VBOX_SHCL_FN_READ_FILE_DATA\n"));
             SHCLFILEDATA fileData;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA:
+        {
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n"));
+        case VBOX_SHCL_GUEST_FN_WRITE_FILE_DATA:
+        {
+            LogFlowFunc(("VBOX_SHCL_FN_WRITE_FILE_DATA\n"));
             if (!SharedClipboardURIObjCtxIsValid(&pTransfer->State.ObjCtx))
 …
+        }
 #endif
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
+        case VBOX_SHCL_GUEST_FN_CANCEL:
+        {
             LogRel2(("Shared Clipboard: Transfer canceled\n"));
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR:
+        case VBOX_SHCL_GUEST_FN_ERROR:
+        {
             int rcGuest;
 …
     switch (u32Function)
+    {
         case VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL: /** @todo Implement this. */
             break;
         case VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR: /** @todo Implement this. */
+        case VBOX_SHCL_HOST_FN_CANCEL: /** @todo Implement this. */
+            break;
+        case VBOX_SHCL_HOST_FN_ERROR: /** @todo Implement this. */
             break;
 …
     /* puEvent is optional. */
     PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS,
                                                              VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_STATUS);
+    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS,
+                                                             VBOX_SHCL_CPARMS_TRANSFER_STATUS);
     if (!pMsgReadData)
         return VERR_NO_MEMORY;
 …
     const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
     HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+    HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                                   pTransfer->State.uID, uEvent));
     HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir);
 …
+            {
                 LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n",
                          VBoxClipboardTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
+                         VBoxShClTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
                 if (puEvent)
 …
                                     else
                                         LogRel(("Shared Clipboard: Guest reported status %s (error %Rrc) while starting transfer %RU32\n",
                                                 VBoxClipboardTransferStatusToStr(pReply->u.TransferStatus.uStatus),
+                                                VBoxShClTransferStatusToStr(pReply->u.TransferStatus.uStatus),
                                                 pReply->rc, pTransfer->State.uID));
+                                }

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

-              r80664
+              r80847
 bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg)
+{
     const bool fHostToGuest =    uMode == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
                               || uMode == VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
+    const bool fHostToGuest =    uMode == VBOX_SHCL_MODE_HOST_TO_GUEST
+                              || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
     const bool fGuestToHost =    uMode == VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
                               || uMode == VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
+    const bool fGuestToHost =    uMode == VBOX_SHCL_MODE_GUEST_TO_HOST
+                              || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
     bool fAllowed = false; /* If in doubt, don't allow. */
 …
     switch (uMsg)
+    {
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
+        case VBOX_SHCL_GUEST_FN_LIST_OPEN:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
+        case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
+        case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE:
+        case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ:
+        case VBOX_SHCL_GUEST_FN_OBJ_READ:
             fAllowed = fHostToGuest;
             break;
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
+        case VBOX_SHCL_GUEST_FN_MSG_GET:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
+        case VBOX_SHCL_GUEST_FN_STATUS:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
+        case VBOX_SHCL_GUEST_FN_CANCEL:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR:
+        case VBOX_SHCL_GUEST_FN_ERROR:
             fAllowed = fHostToGuest || fGuestToHost;
             break;
 …
     switch (uMsg)
+    {
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START:
+        case VBOX_SHCL_HOST_MSG_URI_TRANSFER_START:
+        {
             Assert(pClient->State.URI.fTransferStart == false);
             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
+            LogFlowFunc(("VBOX_SHCL_HOST_MSG_URI_TRANSFER_START\n"));
             if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
                 && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+            if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
+                && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+            {
                 LogFlowFunc(("Wrong clipboard mode, skipping\n"));
 …
         && cParms >= 2)
+    {
         HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
+        HGCMSvcSetU32(&paParms[0], VBOX_SHCL_HOST_MSG_URI_TRANSFER_START);
         HGCMSvcSetU32(&paParms[1], pClient->State.URI.enmTransferDir);
         pClient->State.URI.fTransferStart = false;

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

-              r80845
+              r80847
     LogFlowFunc(("cbSrc = %d, cbDst = %d\n", cbSrc, cbDst));
     if (   u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML
+    if (   u32Format == VBOX_SHCL_FMT_HTML
         && SharedClipboardWinIsCFHTML((const char *)pvSrc))
+    {
 …
 #ifdef LOG_ENABLED
     VBoxClipboardDbgDumpData(pvDst, cbSrc, u32Format);
+    VBoxShClDbgDumpData(pvDst, cbSrc, u32Format);
 #endif
 …
             LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
             if (   fFormat       == VBOX_SHARED_CLIPBOARD_FMT_NONE
+            if (   fFormat       == VBOX_SHCL_FMT_NONE
                 || pCtx->pClient == NULL)
+            {
 …
             LogFunc(("SHCL_WIN_WM_REPORT_FORMATS: fFormats=0x%x\n", fFormats));
             if (fFormats == VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
+            if (fFormats == VBOX_SHCL_FMT_NONE) /* Could arrive with some older GA versions. */
                 break;
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
             if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+            if (fFormats & VBOX_SHCL_FMT_URI_LIST)
+            {
                 PSHCLURITRANSFER pTransfer;
 …
         rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats);
         if (   RT_SUCCESS(rc)
             && Formats.uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE)
+            && Formats.uFormats != VBOX_SHCL_FMT_NONE)
+        {
             rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats);
 …
         LogFunc(("Clipboard opened\n"));
         if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        if (pData->uFormat & VBOX_SHCL_FMT_BITMAP)
+        {
             hClip = GetClipboardData(CF_DIB);
 …
                     LogFunc(("CF_DIB\n"));
                     vboxClipboardSvcWinGetData(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, lp, GlobalSize(hClip),
+                    vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_BITMAP, lp, GlobalSize(hClip),
                                                pData->pvData, pData->cbData, pcbActual);
 …
+            }
+        }
         else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        else if (pData->uFormat & VBOX_SHCL_FMT_UNICODETEXT)
+        {
             hClip = GetClipboardData(CF_UNICODETEXT);
 …
                     LogFunc(("CF_UNICODETEXT\n"));
                     vboxClipboardSvcWinGetData(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, uniString, (lstrlenW(uniString) + 1) * 2,
+                    vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_UNICODETEXT, uniString, (lstrlenW(uniString) + 1) * 2,
                                                pData->pvData, pData->cbData, pcbActual);
 …
+            }
+        }
         else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+        else if (pData->uFormat & VBOX_SHCL_FMT_HTML)
+        {
             UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
 …
+                    {
                         /** @todo r=andy Add data overflow handling. */
                         vboxClipboardSvcWinGetData(VBOX_SHARED_CLIPBOARD_FMT_HTML, lp, GlobalSize(hClip),
+                        vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_HTML, lp, GlobalSize(hClip),
                                                    pData->pvData, pData->cbData, pcbActual);
 #ifdef VBOX_STRICT
                         LogFlowFunc(("Raw HTML clipboard data from host:"));
                         VBoxClipboardDbgDumpHtml((char *)pData->pvData, pData->cbData);
+                        VBoxShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
 #endif
                         GlobalUnlock(hClip);
 …
+        }
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
         else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+        else if (pData->uFormat & VBOX_SHCL_FMT_URI_LIST)
+        {
             AssertFailed(); /** @todo */

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

-              r80664
+              r80847
 /** Initialise the host side of the shared clipboard - called by the hgcm layer. */
 int VBoxClipboardSvcImplInit(void)
+int VBoxShClSvcImplInit(void)
+{
     LogFlowFunc(("called, returning VINF_SUCCESS\n"));
 …
 /** Terminate the host side of the shared clipboard - called by the hgcm layer. */
 void VBoxClipboardSvcImplDestroy(void)
+void VBoxShClSvcImplDestroy(void)
+{
     LogFlowFunc(("called, returning\n"));
 …
   * @param   fHeadless          Whether headless.
   */
 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+int VBoxShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+{
     RT_NOREF(pClient, fHeadless);

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

-              r80664
+              r80847
     RT_ZERO(formatData);
     formatData.uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    formatData.uFormats = VBOX_SHCL_FMT_NONE;
     return sharedClipboardSvcFormatsReport(pClient, &formatData);
 …
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) /* No URI support yet. */
+    if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST) /* No URI support yet. */
         return VINF_SUCCESS;
 #endif

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

-              r80845
+              r80847
+ *
  * There are currently four messages defined.  The first is
  * VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG, which waits for a message from the
+ * VBOX_SHCL_FN_GET_HOST_MSG, which waits for a message from the
  * host. If a host message is sent while the guest is not waiting, it will be
  * queued until the guest requests it. The host code only supports a single
  * simultaneous VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG call from one guest.
+ *
  * The second guest message is VBOX_SHARED_CLIPBOARD_FN_FORMATS, which tells
+ * simultaneous VBOX_SHCL_FN_GET_HOST_MSG call from one guest.
+ *
+ * The second guest message is VBOX_SHCL_FN_FORMATS, which tells
  * the host that the guest has new clipboard data available.  The third is
  * VBOX_SHARED_CLIPBOARD_FN_READ_DATA, which asks the host to send its
+ * VBOX_SHCL_FN_READ_DATA, which asks the host to send its
  * clipboard data and waits until it arrives.  The host supports at most one
  * simultaneous VBOX_SHARED_CLIPBOARD_FN_READ_DATA call from a guest - if a
+ * simultaneous VBOX_SHCL_FN_READ_DATA call from a guest - if a
  * second call is made before the first has returned, the first will be
  * aborted.
+ *
  * The last guest message is VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA, which is
+ * The last guest message is VBOX_SHCL_FN_WRITE_DATA, which is
  * used to send the contents of the guest clipboard to the host.  This call
  * should be used after the host has requested data from the guest.
 …
  * Since VBox 6.1 a newer protocol (v1) has been established to also support
  * file transfers. This protocol uses a (per-client) message queue instead
  * (see VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD vs. VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG).
+ *
  * To distinguish the old (legacy) or new(er) protocol, the VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT
+ * (see VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD vs. VBOX_SHCL_GUEST_FN_GET_HOST_MSG).
+ *
+ * To distinguish the old (legacy) or new(er) protocol, the VBOX_SHCL_GUEST_FN_CONNECT
  * message has been introduced. If an older guest does not send this message,
  * an appropriate translation will be done to serve older Guest Additions (< 6.1).
 …
  * the host request.
+ *
  * Also see the protocol changelog at VBoxClipboardSvc.h.
+ * Also see the protocol changelog at VBoxShClSvc.h.
+ *
  * @section sec_uri_intro               Transferring files
 …
     switch (uMode)
+    {
         case VBOX_SHARED_CLIPBOARD_MODE_OFF:
+        case VBOX_SHCL_MODE_OFF:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST:
+        case VBOX_SHCL_MODE_HOST_TO_GUEST:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST:
+        case VBOX_SHCL_MODE_GUEST_TO_HOST:
             RT_FALL_THROUGH();
         case VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL:
+        case VBOX_SHCL_MODE_BIDIRECTIONAL:
+        {
             g_uMode = uMode;
 …
         default:
+        {
             g_uMode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+            g_uMode = VBOX_SHCL_MODE_OFF;
             break;
+        }
 …
 /**
  * Sets the VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT
+ * Sets the VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT
  * return parameters.
+ *
 …
 /**
  * Sets the VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD return parameters.
+ * Sets the VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD return parameters.
+ *
  * This function does the necessary translation between the legacy protocol (v0) and the new protocols (>= v1),
 …
     switch (pMsg->uMsg)
+    {
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
+        {
             HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
+        case VBOX_SHCL_HOST_MSG_QUIT:
+        {
+            HGCMSvcSetU32(&paDstParms[0], VBOX_SHCL_HOST_MSG_QUIT);
             HGCMSvcSetU32(&paDstParms[1], 0 /* Not used */);
             break;
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+        {
             HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
+        case VBOX_SHCL_HOST_MSG_READ_DATA:
+        {
+            HGCMSvcSetU32(&paDstParms[0], VBOX_SHCL_HOST_MSG_READ_DATA);
             AssertBreakStmt(pMsg->cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */
             uint32_t uFmt;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+        {
             HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT);
+        case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
+        {
+            HGCMSvcSetU32(&paDstParms[0], VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
             AssertBreakStmt(pMsg->cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */
             uint32_t uFmts;
 …
     LogFlowFunc(("uMsg=%RU32 (%s), cParms=%RU32, fAppend=%RTbool\n",
                  pMsg->uMsg, VBoxClipboardHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
+                 pMsg->uMsg, VBoxShClHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
     if (fAppend)
 …
 /**
  * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT.
+ * Implements VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT.
+ *
  * @returns VBox status code.
 …
+        {
             paParms[0].u.uint64 = idRestore;
             LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n",
+            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n",
                          pClient->State.uClientID, idRestoreCheck, idRestore));
             return VERR_VM_RESTORED;
 …
+        {
             sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
             LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg),
+            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
+                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
             return VINF_SUCCESS;
 …
     pClient->Pending.cParms  = cParms;
     pClient->Pending.paParms = paParms;
     pClient->Pending.uType   = VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT;
+    pClient->Pending.uType   = VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT;
     LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient->State.uClientID));
     return VINF_HGCM_ASYNC_EXECUTE;
 …
 /**
  * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD.
+ * Implements VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD.
+ *
  * @returns VBox status code.
 …
     int rc;
     if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD)
+    if (cParms != VBOX_SHCL_CPARMS_GET_HOST_MSG_OLD)
+    {
         rc = VERR_INVALID_PARAMETER;
 …
             LogFlowFunc(("[Client %RU32] uMsg=%RU32 (%s), cParms=%RU32\n",
                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
 …
             pClient->Pending.cParms  = cParms;
             pClient->Pending.paParms = paParms;
             pClient->Pending.uType   = VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD;
+            pClient->Pending.uType   = VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD;
             rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
 …
 /**
  * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET.
+ * Implements VBOX_SHCL_GUEST_FN_MSG_GET.
+ *
  * @returns VBox status code.
 …
+        {
             LogFlowFunc(("First message is: %RU32 (%s), cParms=%RU32\n",
                          pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
+                         pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
             ASSERT_GUEST_MSG_RETURN(pFirstMsg->uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
                                     ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
                                      pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
                                      idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms),
+                                     pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
+                                     idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
                                     VERR_MISMATCH);
             ASSERT_GUEST_MSG_RETURN(pFirstMsg->cParms == cParms,
                                     ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
                                      pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
                                      idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms),
+                                     pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
+                                     idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
                                     VERR_WRONG_PARAMETER_COUNT);
 …
                 ASSERT_GUEST_MSG_RETURN(pFirstMsg->paParms[i].type == paParms[i].type,
                                         ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->paParms[i].type,
                                          paParms[i].type, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg)),
+                                         paParms[i].type, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg)),
                                         VERR_WRONG_PARAMETER_TYPE);
             /*
 …
+            {
                 LogFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n",
                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
                 bool fDonePending = false;
                 if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)
+                if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT)
+                {
                     sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
                     fDonePending = true;
+                }
                 else if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
+                else if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
+                {
                     rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
 …
     int rc;
     PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                                                              VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
+    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_READ_DATA,
+                                                             VBOX_SHCL_CPARMS_READ_DATA);
     if (pMsgReadData)
+    {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
         HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                                       pClient->Events.uID, uEvent));
         HGCMSvcSetU32(&pMsgReadData->paParms[1], pDataReq->uFmt);
 …
+    }
     else
         uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
+        uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
     int rc = VINF_SUCCESS;
 …
     int rc;
     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 3);
     if (pMsg)
+    {
         SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pClient->Events.uID, uEvent));
         HGCMSvcSetU32(&pMsg->paParms[1], pFormats->uFormats);
 …
     LogFlowFuncEnter();
     if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
         && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+    if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
+        && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+    {
         return VERR_NOT_SUPPORTED;
 …
     else
+    {
         if (cParms < VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
+        if (cParms < VBOX_SHCL_CPARMS_WRITE_DATA)
+        {
             rc = VERR_INVALID_PARAMETER;
 …
     if (RT_SUCCESS(rc))
+    {
         sharedClipboardSvcModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
+        sharedClipboardSvcModeSet(VBOX_SHCL_MODE_OFF);
         rc = SharedClipboardSvcImplInit();
 …
     LogFunc(("u32ClientID=%RU32 (proto %RU32), fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
              u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, paParms));
+             u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, paParms));
 #ifdef DEBUG
 …
     switch (u32Function)
+    {
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD:
+        case VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD:
+        {
             rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT:
+        {
             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT)
+        case VBOX_SHCL_GUEST_FN_CONNECT:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_CONNECT)
+            {
                 rc = VERR_INVALID_PARAMETER;
 …
                 rc = VERR_INVALID_PARAMETER;
+            }
             else if (sharedClipboardSvcGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
+            else if (sharedClipboardSvcGetMode() == VBOX_SHCL_MODE_OFF)
+            {
                 rc = VERR_ACCESS_DENIED;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
+        {
             rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
+        {
             rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
+        case VBOX_SHCL_GUEST_FN_MSG_GET:
+        {
             rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT:
+        case VBOX_SHCL_GUEST_FN_FORMATS_REPORT:
+        {
             uint32_t uFormats = 0;
 …
             if (RT_SUCCESS(rc))
+            {
                 if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
                     && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
+                    && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+                {
                     rc = VERR_ACCESS_DENIED;
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ:
+        {
             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA)
+        case VBOX_SHCL_GUEST_FN_DATA_READ:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_READ_DATA)
+            {
                 rc = VERR_INVALID_PARAMETER;
 …
             else
+            {
                 if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
                     && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
+                    && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+                {
                     rc = VERR_ACCESS_DENIED;
 …
+                {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
                     if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+                    if (uFormat == VBOX_SHCL_FMT_URI_LIST)
+                    {
                         rc = sharedClipboardSvcURITransferStart(pClient, SHCLURITRANSFERDIR_WRITE, SHCLSOURCE_LOCAL,
 …
+        }
         case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE:
+        case VBOX_SHCL_GUEST_FN_DATA_WRITE:
+        {
             rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
 …
     LogFlowFunc(("u32Function=%RU32 (%s), cParms=%RU32, paParms=%p\n",
                  u32Function, VBoxClipboardHostMsgToStr(u32Function), cParms, paParms));
+                 u32Function, VBoxShClHostMsgToStr(u32Function), cParms, paParms));
     switch (u32Function)
+    {
         case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE:
+        case VBOX_SHCL_HOST_FN_SET_MODE:
+        {
             if (cParms != 1)
 …
             else
+            {
                 uint32_t u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+                uint32_t u32Mode = VBOX_SHCL_MODE_OFF;
                 rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
 …
+        }
         case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS:
+        case VBOX_SHCL_HOST_FN_SET_HEADLESS:
+        {
             if (cParms != 1)
 …
     /* Write Shared Clipboard saved state version. */
     SSMR3PutU32(pSSM, VBOX_SHARED_CLIPBOARD_SSM_VER_1);
+    SSMR3PutU32(pSSM, VBOX_SHCL_SSM_VER_1);
     int rc = SSMR3PutStructEx(pSSM, &pClient->State, sizeof(pClient->State), 0 /*fFlags*/, &s_aShClSSMClientState[0], NULL);
 …
     int rc = SSMR3GetU32(pSSM, &lenOrVer);
     AssertRCReturn(rc, rc);
     if (lenOrVer == VBOX_SHARED_CLIPBOARD_SSM_VER_0)
+    if (lenOrVer == VBOX_SHCL_SSM_VER_0)
+    {
         return svcLoadStateV0(u32ClientID, pvClient, pSSM, uVersion);
+    }
     else if (lenOrVer == VBOX_SHARED_CLIPBOARD_SSM_VER_1)
+    else if (lenOrVer == VBOX_SHCL_SSM_VER_1)
+    {
         rc = SSMR3GetStructEx(pSSM, &pClient->State, sizeof(pClient->State), 0 /*fFlags*/, &s_aShClSSMClientState[0], NULL);

trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp

r78160	r80847
128	128	{
129	129	Log(("Unicode flavor detected.\n"));
130		*pfFormats \|= VBOX_SH~~ARED_CLIPBOARD~~_FMT_UNICODETEXT;
	130	*pfFormats \|= VBOX_SHCL_FMT_UNICODETEXT;
131	131	}
132	132	else if (UTTypeConformsTo(flavorType, kUTTypeBMP))
133	133	{
134	134	Log(("BMP flavor detected.\n"));
135		*pfFormats \|= VBOX_SH~~ARED_CLIPBOARD~~_FMT_BITMAP;
	135	*pfFormats \|= VBOX_SHCL_FMT_BITMAP;
136	136	}
137	137	}
…	…
177	177	{
178	178	/* The guest request unicode */
179		if (fFormat & VBOX_SH~~ARED_CLIPBOARD~~_FMT_UNICODETEXT)
	179	if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
180	180	{
181	181	CFDataRef outData;
…	…
238	238	}
239	239	/* The guest request BITMAP */
240		else if (fFormat & VBOX_SH~~ARED_CLIPBOARD~~_FMT_BITMAP)
	240	else if (fFormat & VBOX_SHCL_FMT_BITMAP)
241	241	{
242	242	CFDataRef outData;
…	…
305	305	int rc = VERR_NOT_SUPPORTED;
306	306	/* Handle the unicode text */
307		if (fFormat & VBOX_SH~~ARED_CLIPBOARD~~_FMT_UNICODETEXT)
	307	if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
308	308	{
309	309	PRTUTF16 pwszSrcText = static_cast <PRTUTF16>(pv);
…	…
372	372	}
373	373	/* Handle the bitmap */
374		else if (fFormat & VBOX_SH~~ARED_CLIPBOARD~~_FMT_BITMAP)
	374	else if (fFormat & VBOX_SHCL_FMT_BITMAP)
375	375	{
376	376	/* Create a full BMP from it */

trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

-              r80664
+              r80847
     RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
     /* Reset global variable which doesn't reset itself. */
     HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_OFF);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    HGCMSvcSetU32(&parms[0], VBOX_SHCL_MODE_OFF);
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC_OK(rc);
     u32Mode = TestClipSvcGetMode();
     RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_OFF,
+    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHCL_MODE_OFF,
                       ("u32Mode=%u\n", (unsigned) u32Mode));
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU64(&parms[0], 99);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
+, parms);
+    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
+    HGCMSvcSetU32(&parms[0], VBOX_SHCL_MODE_HOST_TO_GUEST);
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC_OK(rc);
     u32Mode = TestClipSvcGetMode();
     RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST,
+    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHCL_MODE_HOST_TO_GUEST,
                       ("u32Mode=%u\n", (unsigned) u32Mode));
     HGCMSvcSetU32(&parms[0], 99);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_NOT_SUPPORTED);
     u32Mode = TestClipSvcGetMode();
     RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_OFF,
+    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHCL_MODE_OFF,
                       ("u32Mode=%u\n", (unsigned) u32Mode));
     table.pfnUnload(NULL);
 …
     int rc;
     RTTestISub("Setting up VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG test");
+    RTTestISub("Setting up VBOX_SHCL_FN_GET_HOST_MSG test");
     rc = setupTable(&table);
     RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
     /* Unless we are bidirectional the host message requests will be dropped. */
     HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    HGCMSvcSetU32(&parms[0], VBOX_SHCL_MODE_BIDIRECTIONAL);
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
 , parms);
     RTTESTI_CHECK_RC_OK(rc);
 …
     call.rc = VERR_TRY_AGAIN;
     table.pfnConnect(NULL, 1 /* clientId */, &g_Client, 0, 0);
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
     sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     RTTESTI_CHECK_RC_OK(call.rc);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
 …
     RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls.");
     RT_ZERO(g_Client.State);
     sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                                    VBOX_SHARED_CLIPBOARD_FMT_HTML);
     HGCMSvcSetU32(&parms[0], 0);
     HGCMSvcSetU32(&parms[1], 0);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
     RTTESTI_CHECK_RC_OK(call.rc);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_HTML);
+    HGCMSvcSetU32(&parms[0], 0);
+    HGCMSvcSetU32(&parms[1], 0);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
 …
     HGCMSvcSetU32(&parms[1], 0);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
     sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
     RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     RTTESTI_CHECK_RC_OK(call.rc);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
     RTTESTI_CHECK_RC_OK(call.rc);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_UNICODETEXT | VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
 …
     RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls.");
     RT_ZERO(g_Client.State);
     sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                                    VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
     HGCMSvcSetU32(&parms[0], 0);
     HGCMSvcSetU32(&parms[1], 0);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     RTTESTI_CHECK_RC_OK(call.rc);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
     RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
     RTTESTI_CHECK_RC_OK(call.rc);
     call.rc = VERR_TRY_AGAIN;
     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_UNICODETEXT | VBOX_SHCL_FMT_HTML);
+    HGCMSvcSetU32(&parms[0], 0);
+    HGCMSvcSetU32(&parms[1], 0);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
 , parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
 …
     /* Reset global variable which doesn't reset itself. */
     HGCMSvcSetU32(&parms[0], false);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
 , parms);
     RTTESTI_CHECK_RC_OK(rc);
     fHeadless = VBoxSvcClipboardGetHeadless();
     RTTESTI_CHECK_MSG(fHeadless == false, ("fHeadless=%RTbool\n", fHeadless));
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU64(&parms[0], 99);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
 , parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU32(&parms[0], true);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
 , parms);
     RTTESTI_CHECK_RC_OK(rc);
 …
     RTTESTI_CHECK_MSG(fHeadless == true, ("fHeadless=%RTbool\n", fHeadless));
     HGCMSvcSetU32(&parms[0], 99);
     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
 , parms);
     RTTESTI_CHECK_RC_OK(rc);

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

-              r80737
+              r80847
         case ClipboardMode_Disabled:
             LogRel(("Shared Clipboard: Mode: Off\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+            parm.u.uint32 = VBOX_SHCL_MODE_OFF;
             break;
         case ClipboardMode_GuestToHost:
             LogRel(("Shared Clipboard: Mode: Guest to Host\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
+            parm.u.uint32 = VBOX_SHCL_MODE_GUEST_TO_HOST;
             break;
         case ClipboardMode_HostToGuest:
             LogRel(("Shared Clipboard: Mode: Host to Guest\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
+            parm.u.uint32 = VBOX_SHCL_MODE_HOST_TO_GUEST;
             break;
         case ClipboardMode_Bidirectional:
             LogRel(("Shared Clipboard: Mode: Bidirectional\n"));
             parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
+            parm.u.uint32 = VBOX_SHCL_MODE_BIDIRECTIONAL;
             break;
+    }
     int vrc = pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
+    int vrc = pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHCL_HOST_FN_SET_MODE, 1, &parm);
     if (RT_FAILURE(vrc))
         LogRel(("Shared Clipboard: Error changing mode: %Rrc\n", vrc));

trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

r80729	r80847
3071	3071	VBOXHGCMSVCPARM parm;
3072	3072	HGCMSvcSetU32(&parm, !i_useHostClipboard());
3073		rc = SHAREDCLIPBOARDINST()->hostCall(VBOX_SH~~ARED_CLIPBOARD~~_HOST_FN_SET_HEADLESS, 1, &parm);
	3073	rc = SHAREDCLIPBOARDINST()->hostCall(VBOX_SHCL_HOST_FN_SET_HEADLESS, 1, &parm);
3074	3074	if (RT_FAILURE(rc))
3075	3075	LogRel(("Shared Clipboard: Unable to set initial headless mode, rc=%Rrc\n", rc));

Changeset 80847 in vbox

Legend:

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

trunk/include/VBox/GuestHost/SharedClipboard.h

trunk/include/VBox/GuestHost/clipboard-helper.h

trunk/include/VBox/HostServices/VBoxClipboardSvc.h

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

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp

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

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp

trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboard.cpp

trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp

trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.h

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.h

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.cpp

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxServiceDescriptor.h

trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp

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

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp

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

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

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

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

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

trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp

trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

Download in other formats: