Index: /trunk/include/VBox/GuestHost/SharedClipboard-uri.h
===================================================================
--- /trunk/include/VBox/GuestHost/SharedClipboard-uri.h	(revision 80846)
+++ /trunk/include/VBox/GuestHost/SharedClipboard-uri.h	(revision 80847)
@@ -1046,5 +1046,5 @@
     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;
@@ -1135,5 +1135,5 @@
 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 */
Index: /trunk/include/VBox/GuestHost/SharedClipboard.h
===================================================================
--- /trunk/include/VBox/GuestHost/SharedClipboard.h	(revision 80846)
+++ /trunk/include/VBox/GuestHost/SharedClipboard.h	(revision 80847)
@@ -48,14 +48,14 @@
  */
 /** 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
 
@@ -121,15 +121,15 @@
 
 /** 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 \
@@ -140,5 +140,5 @@
     ((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. */
@@ -146,5 +146,5 @@
     (((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)
 
Index: /trunk/include/VBox/GuestHost/clipboard-helper.h
===================================================================
--- /trunk/include/VBox/GuestHost/clipboard-helper.h	(revision 80846)
+++ /trunk/include/VBox/GuestHost/clipboard-helper.h	(revision 80847)
@@ -180,5 +180,5 @@
  * @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);
 
 /**
@@ -189,5 +189,5 @@
  * @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 */
 
@@ -198,5 +198,5 @@
  * @param   uMsg                The message to translate.
  */
-const char *VBoxClipboardHostMsgToStr(uint32_t uMsg);
+const char *VBoxShClHostMsgToStr(uint32_t uMsg);
 
 /**
@@ -206,5 +206,5 @@
  * @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 */
Index: /trunk/include/VBox/HostServices/VBoxClipboardSvc.h
===================================================================
--- /trunk/include/VBox/HostServices/VBoxClipboardSvc.h	(revision 80846)
+++ /trunk/include/VBox/HostServices/VBoxClipboardSvc.h	(revision 80847)
@@ -66,15 +66,15 @@
  */
 /** 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
 
 /*
@@ -82,19 +82,19 @@
  */
 /** 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
 
 /**
@@ -102,60 +102,60 @@
  */
 /** 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
@@ -164,65 +164,65 @@
  *
  *  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
 
 /*
@@ -235,5 +235,5 @@
  * Kept for maintaining compatibility with older Guest Additions.
  */
-typedef struct _VBoxClipboardGetHostMsgOld
+typedef struct _VBoxShClGetHostMsgOld
 {
     VBGLIOCHGCMCALL hdr;
@@ -241,10 +241,10 @@
     /** 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
 
 /**
@@ -252,5 +252,5 @@
  * and the guest. Not available on older (VBox <= 6.0) hosts.
  */
-typedef struct _VBoxClipboardConnect
+typedef struct _VBoxShClConnect
 {
     VBGLIOCHGCMCALL hdr;
@@ -266,9 +266,9 @@
     /** 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;
@@ -276,11 +276,11 @@
     /** 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;
@@ -292,9 +292,9 @@
     /** 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;
@@ -309,9 +309,9 @@
     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;
@@ -321,5 +321,5 @@
         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.  */
@@ -338,12 +338,12 @@
         } 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;
@@ -359,7 +359,7 @@
     /** 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
 
 /**
@@ -368,8 +368,8 @@
  * 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;
@@ -381,7 +381,7 @@
     /** 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. */
@@ -400,5 +400,5 @@
  * Status messag for lists and objects.
  */
-typedef struct _VBoxClipboardStatusMsg
+typedef struct _VBoxShClStatusMsg
 {
     VBGLIOCHGCMCALL hdr;
@@ -412,7 +412,7 @@
     /** 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. */
@@ -432,5 +432,5 @@
  * Generic reply message.
  */
-typedef struct _VBoxClipboardReplyMsg
+typedef struct _VBoxShClReplyMsg
 {
     VBGLIOCHGCMCALL hdr;
@@ -465,10 +465,10 @@
         } 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*/
@@ -476,33 +476,33 @@
     /** 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. */
@@ -512,28 +512,28 @@
     /** 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;
@@ -543,12 +543,12 @@
      *  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;
@@ -568,12 +568,12 @@
     /** 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;
@@ -583,9 +583,9 @@
     /** 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. */
@@ -595,26 +595,26 @@
     /** 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;
@@ -623,9 +623,9 @@
     /** 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. */
@@ -635,27 +635,27 @@
     /** 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;
@@ -665,9 +665,9 @@
      *  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;
@@ -683,9 +683,9 @@
     /** 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;
@@ -695,9 +695,9 @@
     /** 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. */
@@ -709,14 +709,14 @@
     /** 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
 
 /**
@@ -724,8 +724,8 @@
  *
  * 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;
@@ -744,8 +744,8 @@
      *  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
 
 /**
@@ -753,7 +753,7 @@
  *
  * Used by:
- * VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR
- */
-typedef struct _VBoxClipboardErrorMsg
+ * VBOX_SHCL_FN_WRITE_ERROR
+ */
+typedef struct _VBoxShClErrorMsg
 {
     VBGLIOCHGCMCALL hdr;
@@ -763,7 +763,7 @@
     /** 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()
Index: /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp	(revision 80847)
@@ -488,5 +488,5 @@
            LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
 
-           if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_NONE)
+           if (fFormat == VBOX_SHCL_FMT_NONE)
            {
                LogFunc(("WM_RENDERFORMAT: Unsupported format requested\n"));
@@ -571,5 +571,5 @@
                                 * must have the exact string size.
                                 */
-                               if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+                               if (fFormat == VBOX_SHCL_FMT_UNICODETEXT)
                                {
                                    size_t cbActual = 0;
@@ -648,5 +648,5 @@
            const SHCLFORMATS fFormats =  pEvent->u.ReportedFormats.uFormats;
 
-           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. */
            {
                int rc = SharedClipboardWinOpen(hwnd);
@@ -656,7 +656,7 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-                    if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+                    if (fFormats & VBOX_SHCL_FMT_URI_LIST)
                     {
-                        LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST\n"));
+                        LogFunc(("VBOX_SHCL_FMT_URI_LIST\n"));
 
                         PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pCtx->URI, 0); /** @todo FIX !!! */
@@ -705,5 +705,5 @@
            if (RT_SUCCESS(rc))
            {
-               if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+               if (uFormat == VBOX_SHCL_FMT_BITMAP)
                {
                    hClip = GetClipboardData(CF_DIB);
@@ -725,5 +725,5 @@
                    }
                }
-               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+               else if (uFormat == VBOX_SHCL_FMT_UNICODETEXT)
                {
                    hClip = GetClipboardData(CF_UNICODETEXT);
@@ -745,5 +745,5 @@
                    }
                }
-               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+               else if (uFormat == VBOX_SHCL_FMT_HTML)
                {
                    UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
@@ -771,5 +771,5 @@
                }
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+               else if (uFormat == VBOX_SHCL_FMT_URI_LIST)
                {
                    LogFunc(("cTransfersRunning=%RU32\n", SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
@@ -855,5 +855,5 @@
 
                    /* Requested clipboard format is not available, send empty data. */
-                   VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHARED_CLIPBOARD_FMT_NONE, NULL, 0);
+                   VbglR3ClipboardWriteData(pCtx->CmdCtx.uClientID, VBOX_SHCL_FMT_NONE, NULL, 0);
 #ifdef DEBUG_andy
                    AssertFailed();
@@ -1119,5 +1119,5 @@
 }
 
-DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
+DECLCALLBACK(int) VBoxShClInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
 {
     LogFlowFuncEnter();
@@ -1182,5 +1182,5 @@
 }
 
-DECLCALLBACK(int) VBoxClipboardWorker(void *pInstance, bool volatile *pfShutdown)
+DECLCALLBACK(int) VBoxShClWorker(void *pInstance, bool volatile *pfShutdown)
 {
     AssertPtr(pInstance);
@@ -1229,5 +1229,5 @@
                 switch (uMsg)
                 {
-                    case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+                    case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
                     {
                         pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS;
@@ -1236,5 +1236,5 @@
                     }
 
-                    case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+                    case VBOX_SHCL_HOST_MSG_READ_DATA:
                     {
                         pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_READ_DATA;
@@ -1340,5 +1340,5 @@
 }
 
-DECLCALLBACK(int) VBoxClipboardStop(void *pInstance)
+DECLCALLBACK(int) VBoxShClStop(void *pInstance)
 {
     AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
@@ -1356,5 +1356,5 @@
 }
 
-DECLCALLBACK(void) VBoxClipboardDestroy(void *pInstance)
+DECLCALLBACK(void) VBoxShClDestroy(void *pInstance)
 {
     AssertPtrReturnVoid(pInstance);
@@ -1388,8 +1388,8 @@
     "Shared Clipboard",
     /* methods */
-    VBoxClipboardInit,
-    VBoxClipboardWorker,
-    VBoxClipboardStop,
-    VBoxClipboardDestroy
+    VBoxShClInit,
+    VBoxShClWorker,
+    VBoxShClStop,
+    VBoxShClDestroy
 };
 
Index: /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp	(revision 80847)
@@ -374,5 +374,5 @@
                         AssertPtr(pDropFiles);
 
-                        /** @todo Replace / merge the following code with VBoxClipboardWinDropFilesToStringList(). */
+                        /** @todo Replace / merge the following code with VBoxShClWinDropFilesToStringList(). */
 
                         /* Do we need to do Unicode stuff? */
Index: /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp	(revision 80847)
@@ -82,9 +82,9 @@
     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);
@@ -160,5 +160,5 @@
     AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
 
-    VBoxClipboardFormatsMsg Msg;
+    VBoxShClFormatsMsg Msg;
     RT_ZERO(Msg);
 
@@ -166,7 +166,7 @@
     {
         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);
@@ -193,10 +193,10 @@
     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);
@@ -232,8 +232,8 @@
 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);
@@ -272,7 +272,7 @@
 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);
@@ -326,5 +326,5 @@
         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);
@@ -348,5 +348,5 @@
     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);
@@ -370,9 +370,9 @@
     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);
@@ -398,9 +398,9 @@
     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);
@@ -485,11 +485,11 @@
     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);
@@ -523,9 +523,9 @@
     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);
@@ -537,5 +537,5 @@
     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));
@@ -550,11 +550,11 @@
     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);
 
@@ -576,9 +576,9 @@
     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);
@@ -599,11 +599,11 @@
     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);
@@ -628,9 +628,9 @@
     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);
@@ -655,9 +655,9 @@
     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);
@@ -683,11 +683,11 @@
     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);
@@ -717,9 +717,9 @@
     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);
@@ -742,11 +742,11 @@
     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);
 
@@ -767,9 +767,9 @@
     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);
@@ -791,9 +791,9 @@
     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);
@@ -813,9 +813,9 @@
     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);
@@ -848,11 +848,11 @@
     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);
@@ -878,9 +878,9 @@
     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);
@@ -905,9 +905,9 @@
     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);
@@ -935,11 +935,11 @@
     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);
@@ -965,9 +965,9 @@
     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);
@@ -990,11 +990,11 @@
     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);
@@ -1020,9 +1020,9 @@
     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);
@@ -1047,9 +1047,9 @@
     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);
@@ -1074,11 +1074,11 @@
     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);
 
@@ -1099,9 +1099,9 @@
     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);
@@ -1123,9 +1123,9 @@
     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);
@@ -1146,11 +1146,11 @@
     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);
@@ -1181,9 +1181,9 @@
     /* 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);
@@ -1218,9 +1218,9 @@
     /* 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);
@@ -1340,5 +1340,5 @@
     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;
@@ -1346,5 +1346,5 @@
     switch (idMsg)
     {
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS:
+        case VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS:
         {
             SHCLURITRANSFERDIR    enmDir;
@@ -1355,5 +1355,5 @@
                 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)
@@ -1408,5 +1408,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ:
+        case VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ:
         {
             uint32_t fRoots;
@@ -1433,5 +1433,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
+        case VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ:
         {
             uint32_t uIndex;
@@ -1452,5 +1452,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN:
+        case VBOX_SHCL_HOST_MSG_URI_LIST_OPEN:
         {
             SHCLLISTOPENPARMS openParmsList;
@@ -1481,5 +1481,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE:
+        case VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE:
         {
             SHCLLISTHANDLE hList;
@@ -1501,5 +1501,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ:
+        case VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ:
         {
             /** @todo Handle filter + list features. */
@@ -1528,7 +1528,7 @@
 
     #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;
@@ -1542,7 +1542,7 @@
     #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;
@@ -1580,7 +1580,7 @@
 
     #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;
@@ -1588,5 +1588,5 @@
     #endif
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN:
         {
             SHCLOBJOPENCREATEPARMS openParms;
@@ -1615,5 +1615,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE:
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE:
         {
             SHCLOBJHANDLE hObj;
@@ -1635,5 +1635,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ:
+        case VBOX_SHCL_HOST_MSG_URI_OBJ_READ:
         {
             SHCLOBJHANDLE hObj;
@@ -1672,7 +1672,7 @@
 
     #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;
         }
@@ -1702,9 +1702,9 @@
 
 #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);
@@ -1714,5 +1714,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
+        case VBOX_SHCL_HOST_MSG_READ_DATA:
         {
             rc = VbglR3ClipboardReadDataRecv(pCtx, &pEvent->u.ReadData);
@@ -1773,9 +1773,9 @@
     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. */
@@ -1805,9 +1805,9 @@
     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. */
@@ -1837,9 +1837,9 @@
     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. */
@@ -1865,14 +1865,14 @@
 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);
@@ -1898,7 +1898,7 @@
 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);
 
@@ -1909,5 +1909,5 @@
  * 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.
  *
@@ -1920,9 +1920,9 @@
 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);
@@ -1938,5 +1938,5 @@
  * 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.
  *
@@ -1955,9 +1955,9 @@
     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));
@@ -1984,8 +1984,8 @@
 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. */
Index: /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp
===================================================================
--- /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp	(revision 80847)
@@ -307,5 +307,5 @@
                  * 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))
@@ -315,5 +315,5 @@
                         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 */
@@ -413,5 +413,5 @@
          * -lazybird
          */
-        Assert(fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
+        Assert(fFormat & VBOX_SHCL_FMT_UNICODETEXT);
         char *pszUtf8;
         int rc = RTUtf16ToUtf8((PCRTUTF16)pv, &pszUtf8);
@@ -464,5 +464,5 @@
     if (    usFmt == CF_TEXT
         ||  usFmt == g_atomOdin32UnicodeText)
-        fFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+        fFormat = VBOX_SHCL_FMT_UNICODETEXT;
     else /** @todo bitmaps */
         fFormat = 0;
@@ -544,5 +544,5 @@
         uint32_t cb = 0;
 
-        if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
         {
             /* Got any odin32 unicode text? */
@@ -607,5 +607,5 @@
         if (    ulFormat == CF_TEXT
             ||  ulFormat == g_atomOdin32UnicodeText)
-            fFormats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+            fFormats |= VBOX_SHCL_FMT_UNICODETEXT;
         /** @todo else bitmaps and stuff. */
     }
@@ -775,5 +775,5 @@
          * 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;
@@ -782,5 +782,5 @@
          * 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;
@@ -895,6 +895,6 @@
                          * 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",
@@ -905,6 +905,6 @@
                          * 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",
@@ -915,5 +915,5 @@
                          * The host is terminating.
                          */
-                        case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
+                        case VBOX_SHCL_HOST_MSG_QUIT:
                             fQuit = true;
                             break;
Index: /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboard.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboard.cpp	(revision 80847)
@@ -104,5 +104,5 @@
             {
                 /* 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;
@@ -110,5 +110,5 @@
 
                 /* 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);
@@ -117,5 +117,5 @@
 
                 /* 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);
Index: /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp
===================================================================
--- /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardGuestToHost.cpp	(revision 80847)
@@ -67,8 +67,8 @@
         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
@@ -230,5 +230,5 @@
     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));
 
@@ -253,5 +253,5 @@
     AssertRCReturn(rc, rc);
 
-    rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, pvDib, cbDib);
+    rc = vbclClipboardHostPasteData(u32ClientId, VBOX_SHCL_FMT_BITMAP, pvDib, cbDib);
 
     return rc;
@@ -282,7 +282,7 @@
     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;
@@ -324,13 +324,13 @@
             {
                 /* 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);
@@ -343,18 +343,18 @@
             {
                 /* 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);
             }
@@ -362,8 +362,8 @@
             {
                 /* 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;
         }
 
Index: /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp
===================================================================
--- /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboardHostToGuest.cpp	(revision 80847)
@@ -245,9 +245,9 @@
     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))
             {
@@ -259,12 +259,12 @@
             }
 
-            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))
             {
@@ -276,12 +276,12 @@
             }
 
-            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))
             {
@@ -293,5 +293,5 @@
             }
 
-            fFormatsInternal &= ~((uint32_t)VBOX_SHARED_CLIPBOARD_FMT_HTML);
+            fFormatsInternal &= ~((uint32_t)VBOX_SHCL_FMT_HTML);
         }
 
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp	(revision 80847)
@@ -78,6 +78,6 @@
 
 
-VBoxClipboardService::VBoxClipboardService()
-     : BHandler("VBoxClipboardService"),
+VBoxShClService::VBoxShClService()
+     : BHandler("VBoxShClService"),
        fClientId(-1),
        fServiceThreadID(-1),
@@ -87,10 +87,10 @@
 
 
-VBoxClipboardService::~VBoxClipboardService()
-{
-}
-
-
-status_t VBoxClipboardService::Connect()
+VBoxShClService::~VBoxShClService()
+{
+}
+
+
+status_t VBoxShClService::Connect()
 {
     status_t err;
@@ -100,5 +100,5 @@
     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)
         {
@@ -109,8 +109,8 @@
                 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);
@@ -118,10 +118,10 @@
     }
     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;
@@ -138,5 +138,5 @@
 
 
-void VBoxClipboardService::MessageReceived(BMessage *message)
+void VBoxShClService::MessageReceived(BMessage *message)
 {
     uint32_t formats = 0;
@@ -168,7 +168,7 @@
             }
 
-            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)
                 {
@@ -190,7 +190,7 @@
             }
 
-            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)
                 {
@@ -253,5 +253,5 @@
             clip->PrintToStream();
 
-            if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+            if (formats & VBOX_SHCL_FMT_UNICODETEXT)
             {
                 const char *text;
@@ -269,5 +269,5 @@
                         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);
@@ -275,5 +275,5 @@
                 }
             }
-            else if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+            else if (formats & VBOX_SHCL_FMT_BITMAP)
             {
                 BMessage archivedBitmap;
@@ -298,5 +298,5 @@
                                 if (RT_SUCCESS(rc))
                                 {
-                                    rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, (void *)pDib,
+                                    rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHCL_FMT_BITMAP, (void *)pDib,
                                                                   cbDibSize);
                                 }
@@ -335,10 +335,10 @@
 
             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;
             }
 
@@ -359,14 +359,14 @@
 
 
-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. */
@@ -380,5 +380,5 @@
             switch (u32Msg)
             {
-                case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+                case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
                 {
                     /*
@@ -386,5 +386,5 @@
                      * 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);
@@ -393,8 +393,8 @@
                 }
 
-                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);
@@ -403,8 +403,8 @@
                 }
 
-                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;
@@ -412,5 +412,5 @@
 
                 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));
             }
         }
@@ -427,5 +427,5 @@
 
 
-void* VBoxClipboardService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
+void* VBoxShClService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
 {
     uint32_t cb = 1024;
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.h
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.h	(revision 80846)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.h	(revision 80847)
@@ -53,9 +53,9 @@
 #include <Handler.h>
 
-class VBoxClipboardService : public BHandler
+class VBoxShClService : public BHandler
 {
     public:
-        VBoxClipboardService();
-        virtual ~VBoxClipboardService();
+        VBoxShClService();
+        virtual ~VBoxShClService();
 
         virtual status_t    Connect();
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.h
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.h	(revision 80846)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.h	(revision 80847)
@@ -65,5 +65,5 @@
 #include <VBoxGuestInternal.h>
 
-class VBoxClipboardService;
+class VBoxShClService;
 
 class VBoxGuestApplication : public BApplication
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.cpp
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.cpp	(revision 80847)
@@ -269,5 +269,5 @@
         if (RT_SUCCESS(rc))
         {
-            fClipboardService = new VBoxClipboardService();
+            fClipboardService = new VBoxShClService();
             fDisplayService = new VBoxDisplayService();
         }
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h	(revision 80846)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h	(revision 80847)
@@ -92,5 +92,5 @@
         BBitmap               *fIcon;
 
-        VBoxClipboardService *fClipboardService;
+        VBoxShClService *fClipboardService;
         VBoxDisplayService *fDisplayService;
 };
Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxServiceDescriptor.h
===================================================================
--- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxServiceDescriptor.h	(revision 80846)
+++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxServiceDescriptor.h	(revision 80847)
@@ -53,15 +53,15 @@
 #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 */
Index: /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp
===================================================================
--- /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp	(revision 80846)
+++ /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp	(revision 80847)
@@ -229,5 +229,5 @@
             switch (Msg)
             {
-                case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
+                case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
                 {
                     /* The host has announced available clipboard formats.
@@ -235,13 +235,13 @@
                      * 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));
@@ -260,8 +260,8 @@
                 }
 
-                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);
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp	(revision 80846)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp	(revision 80847)
@@ -158,5 +158,5 @@
     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);
@@ -205,5 +205,5 @@
 
     pSource->uEventIDNext++;
-    if (pSource->uEventIDNext == VBOX_SHARED_CLIPBOARD_MAX_EVENTS)
+    if (pSource->uEventIDNext == VBOX_SHCL_MAX_EVENTS)
         pSource->uEventIDNext = 0;
 
@@ -749,5 +749,5 @@
 
 #ifdef LOG_ENABLED
-int VBoxClipboardDbgDumpHtml(const char *pszSrc, size_t cbSrc)
+int VBoxShClDbgDumpHtml(const char *pszSrc, size_t cbSrc)
 {
     size_t cchIgnored = 0;
@@ -777,9 +777,9 @@
 }
 
-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));
@@ -787,9 +787,9 @@
             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)
         {
@@ -822,28 +822,28 @@
  * @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";
@@ -856,34 +856,34 @@
  * @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";
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp	(revision 80846)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp	(revision 80847)
@@ -2521,14 +2521,14 @@
      * 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;
@@ -2567,5 +2567,5 @@
     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))
@@ -2950,5 +2950,5 @@
  * @param   uStatus             The transfer status to translate.
  */
-const char *VBoxClipboardTransferStatusToStr(uint32_t uStatus)
+const char *VBoxShClTransferStatusToStr(uint32_t uStatus)
 {
     switch (uStatus)
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp	(revision 80846)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp	(revision 80847)
@@ -369,5 +369,5 @@
  * 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.
  */
@@ -375,14 +375,14 @@
 {
     /* 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;
 
@@ -393,5 +393,5 @@
          * 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
@@ -407,10 +407,10 @@
 
                     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
@@ -436,5 +436,5 @@
     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. */
@@ -847,17 +847,17 @@
     /** @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)
Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp	(revision 80846)
+++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp	(revision 80847)
@@ -113,18 +113,18 @@
 {
     { "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 }
 
 
@@ -419,5 +419,5 @@
         {
             if (   (clipVBoxFormatForX11Format(format)
-                            == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+                            == VBOX_SHCL_FMT_UNICODETEXT)
                     && enmBestTextTarget < clipRealFormatForX11Format(format))
             {
@@ -472,5 +472,5 @@
         {
             if (   (clipVBoxFormatForX11Format(format)
-                            == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+                            == VBOX_SHCL_FMT_BITMAP)
                     && enmBestBitmapTarget < clipRealFormatForX11Format(format))
             {
@@ -503,5 +503,5 @@
         if (format != NIL_CLIPX11FORMAT)
         {
-            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHCL_FMT_HTML)
                 && enmBestHtmlTarget < clipRealFormatForX11Format(format))
             {
@@ -858,5 +858,5 @@
     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)
     {
@@ -874,5 +874,5 @@
     if (RT_SUCCESS(rc))
     {
-        pCtx->widget = XtVaAppCreateShell(0, "VBoxClipboard",
+        pCtx->widget = XtVaAppCreateShell(0, "VBoxShCl",
                                           applicationShellWidgetClass,
                                           pDisplay, XtNwidth, 1, XtNheight,
@@ -1088,5 +1088,5 @@
  * data returned.
  */
-static int clipReadVBoxClipboard(CLIPBACKEND *pCtx, uint32_t u32Format,
+static int clipReadVBoxShCl(CLIPBACKEND *pCtx, uint32_t u32Format,
                                  void **ppv, uint32_t *pcb)
 {
@@ -1094,5 +1094,5 @@
     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)
@@ -1319,10 +1319,10 @@
     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))
@@ -1338,10 +1338,10 @@
     }
     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))
@@ -1364,10 +1364,10 @@
     }
     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))
@@ -1788,5 +1788,5 @@
         /* 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? */
@@ -1811,5 +1811,5 @@
         }
     }
-    else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    else if (pReq->mFormat == VBOX_SHCL_FMT_BITMAP)
     {
         /* In which format is the clipboard data? */
@@ -1839,5 +1839,5 @@
         }
     }
-    else if(pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+    else if(pReq->mFormat == VBOX_SHCL_FMT_HTML)
     {
         /* In which format is the clipboard data? */
@@ -1961,5 +1961,5 @@
     else
 #endif
-    if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (pReq->mFormat == VBOX_SHCL_FMT_UNICODETEXT)
     {
         /*
@@ -1975,5 +1975,5 @@
             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;
@@ -1986,5 +1986,5 @@
             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
@@ -2115,5 +2115,5 @@
     g_vboxDatacb = cb;
     ClipAnnounceFormatToX11(pCtx,
-                                       VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
+                                       VBOX_SHCL_FMT_UNICODETEXT);
     return VINF_SUCCESS;
 }
@@ -2435,5 +2435,5 @@
     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());
@@ -2442,5 +2442,5 @@
         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;
@@ -2493,5 +2493,5 @@
     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());
@@ -2500,5 +2500,5 @@
         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;
@@ -2578,5 +2578,5 @@
     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));
@@ -2609,5 +2609,5 @@
                            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());
@@ -2625,5 +2625,5 @@
         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");
     }
@@ -2725,5 +2725,5 @@
     clipSetSelectionValues("UTF8_STRING", XA_STRING, NULL,
                            0, 8);
-    ClipRequestDataFromX11(pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+    ClipRequestDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT,
                            pReq);
     clipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp	(revision 80847)
@@ -208,5 +208,5 @@
     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 */
@@ -215,5 +215,5 @@
 
 #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
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp	(revision 80847)
@@ -83,11 +83,11 @@
     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 */);
@@ -124,11 +124,11 @@
                                 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 */);
@@ -202,11 +202,11 @@
     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);
 
@@ -260,11 +260,11 @@
     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);
 
@@ -308,11 +308,11 @@
     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);
@@ -369,11 +369,11 @@
     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);
@@ -429,6 +429,6 @@
     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)
     {
@@ -439,5 +439,5 @@
         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 */
@@ -489,11 +489,11 @@
     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);
@@ -543,11 +543,11 @@
     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);
@@ -602,11 +602,11 @@
     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);
@@ -703,5 +703,5 @@
     int rc;
 
-    if (cParms >= VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN)
+    if (cParms >= VBOX_SHCL_CPARMS_REPLY_MIN)
     {
         uint32_t cbPayload = 0;
@@ -779,5 +779,5 @@
     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);
@@ -805,5 +805,5 @@
     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);
@@ -842,5 +842,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
     {
         uint32_t cbPath   = 0;
@@ -889,5 +889,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
     {
         HGCMSvcSetU32(&paParms[0], pMsgCtx->uContextID);
@@ -922,5 +922,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_CLOSE)
     {
         HGCMSvcSetU32(&paParms[0], pMsgCtx->uContextID);
@@ -950,5 +950,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
     {
         rc = HGCMSvcGetU64(&paParms[1], phList);
@@ -989,5 +989,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
     {
         /** @todo Set pvMetaFmt + cbMetaFmt. */
@@ -1024,5 +1024,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
     {
         rc = HGCMSvcGetU64(&paParms[1], phList);
@@ -1070,5 +1070,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
     {
         /** @todo Calculate chunk checksum. */
@@ -1104,5 +1104,5 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE)
+    if (cParms == VBOX_SHCL_CPARMS_OBJ_WRITE)
     {
         rc = HGCMSvcGetU64(&paParms[1], &pDataChunk->uHandle);
@@ -1142,5 +1142,5 @@
     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 !!! */
@@ -1154,5 +1154,5 @@
 
 /**
- * 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.
@@ -1199,5 +1199,5 @@
                         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));
@@ -1257,5 +1257,5 @@
 
     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
@@ -1289,5 +1289,5 @@
     switch (u32Function)
     {
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
+        case VBOX_SHCL_GUEST_FN_STATUS:
             break;
         default:
@@ -1329,7 +1329,7 @@
     {
 #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;
 
@@ -1409,5 +1409,5 @@
                         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);
                     }
 
@@ -1420,5 +1420,5 @@
             }
 
-            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))
@@ -1429,5 +1429,5 @@
 #endif
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
+        case VBOX_SHCL_GUEST_FN_REPLY:
         {
             rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms);
@@ -1438,10 +1438,10 @@
         }
 
-        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;
@@ -1452,5 +1452,5 @@
                 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;
@@ -1466,5 +1466,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
         {
     #if 0
@@ -1487,5 +1487,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
         {
             SHCLROOTLISTENTRY lstEntry;
@@ -1496,5 +1496,5 @@
                 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;
@@ -1510,5 +1510,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
+        case VBOX_SHCL_GUEST_FN_LIST_OPEN:
         {
             SHCLLISTOPENPARMS listOpenParms;
@@ -1527,7 +1527,7 @@
         }
 
-        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;
 
@@ -1541,7 +1541,7 @@
         }
 
-        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;
 
@@ -1558,5 +1558,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE:
         {
             SHCLLISTHDR hdrList;
@@ -1571,5 +1571,5 @@
                     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;
@@ -1586,7 +1586,7 @@
         }
 
-        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;
 
@@ -1601,5 +1601,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE:
         {
             SHCLLISTENTRY entryList;
@@ -1614,5 +1614,5 @@
                     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;
@@ -1630,15 +1630,15 @@
 
     #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;
@@ -1646,5 +1646,5 @@
     #endif
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
+        case VBOX_SHCL_GUEST_FN_OBJ_WRITE:
         {
             SHCLOBJDATACHUNK dataChunk;
@@ -1655,5 +1655,5 @@
                 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;
@@ -1671,7 +1671,7 @@
 
     #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;
@@ -1704,7 +1704,7 @@
         }
 
-        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;
@@ -1713,7 +1713,7 @@
         }
 
-        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)))
@@ -1790,7 +1790,7 @@
         }
 
-        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;
@@ -1799,7 +1799,7 @@
         }
 
-        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))
@@ -1840,5 +1840,5 @@
         }
 #endif
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
+        case VBOX_SHCL_GUEST_FN_CANCEL:
         {
             LogRel2(("Shared Clipboard: Transfer canceled\n"));
@@ -1846,5 +1846,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR:
+        case VBOX_SHCL_GUEST_FN_ERROR:
         {
             int rcGuest;
@@ -1890,8 +1890,8 @@
     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;
 
@@ -2106,6 +2106,6 @@
     /* 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;
@@ -2113,5 +2113,5 @@
     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);
@@ -2130,5 +2130,5 @@
             {
                 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)
@@ -2259,5 +2259,5 @@
                                     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));
                                 }
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp	(revision 80847)
@@ -42,9 +42,9 @@
 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. */
@@ -52,31 +52,31 @@
     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;
@@ -101,12 +101,12 @@
     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"));
@@ -139,5 +139,5 @@
         && 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;
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp	(revision 80847)
@@ -72,5 +72,5 @@
     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))
     {
@@ -108,5 +108,5 @@
 
 #ifdef LOG_ENABLED
-    VBoxClipboardDbgDumpData(pvDst, cbSrc, u32Format);
+    VBoxShClDbgDumpData(pvDst, cbSrc, u32Format);
 #endif
 
@@ -288,5 +288,5 @@
             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)
             {
@@ -333,9 +333,9 @@
             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;
@@ -572,5 +572,5 @@
         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);
@@ -741,5 +741,5 @@
         LogFunc(("Clipboard opened\n"));
 
-        if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        if (pData->uFormat & VBOX_SHCL_FMT_BITMAP)
         {
             hClip = GetClipboardData(CF_DIB);
@@ -752,5 +752,5 @@
                     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);
 
@@ -763,5 +763,5 @@
             }
         }
-        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        else if (pData->uFormat & VBOX_SHCL_FMT_UNICODETEXT)
         {
             hClip = GetClipboardData(CF_UNICODETEXT);
@@ -774,5 +774,5 @@
                     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);
 
@@ -785,5 +785,5 @@
             }
         }
-        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+        else if (pData->uFormat & VBOX_SHCL_FMT_HTML)
         {
             UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
@@ -797,9 +797,9 @@
                     {
                         /** @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);
@@ -813,5 +813,5 @@
         }
 #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 */
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp	(revision 80847)
@@ -39,5 +39,5 @@
 
 /** 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"));
@@ -46,5 +46,5 @@
 
 /** Terminate the host side of the shared clipboard - called by the hgcm layer. */
-void VBoxClipboardSvcImplDestroy(void)
+void VBoxShClSvcImplDestroy(void)
 {
     LogFlowFunc(("called, returning\n"));
@@ -58,5 +58,5 @@
   * @param   fHeadless          Whether headless.
   */
-int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+int VBoxShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
 {
     RT_NOREF(pClient, fHeadless);
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp	(revision 80847)
@@ -152,5 +152,5 @@
     RT_ZERO(formatData);
 
-    formatData.uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    formatData.uFormats = VBOX_SHCL_FMT_NONE;
 
     return sharedClipboardSvcFormatsReport(pClient, &formatData);
@@ -205,5 +205,5 @@
 
 #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
Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp	(revision 80847)
@@ -40,18 +40,18 @@
  *
  * 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.
@@ -66,7 +66,7 @@
  * 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).
@@ -79,5 +79,5 @@
  * 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
@@ -276,11 +276,11 @@
     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;
@@ -292,5 +292,5 @@
         default:
         {
-            g_uMode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+            g_uMode = VBOX_SHCL_MODE_OFF;
             break;
         }
@@ -373,5 +373,5 @@
 
 /**
- * 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.
  *
@@ -401,5 +401,5 @@
 
 /**
- * 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),
@@ -421,14 +421,14 @@
     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;
@@ -439,7 +439,7 @@
         }
 
-        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;
@@ -473,5 +473,5 @@
 
     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)
@@ -486,5 +486,5 @@
 
 /**
- * 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.
@@ -533,5 +533,5 @@
         {
             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;
@@ -549,6 +549,6 @@
         {
             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;
@@ -573,5 +573,5 @@
     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;
@@ -579,5 +579,5 @@
 
 /**
- * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD.
+ * Implements VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD.
  *
  * @returns VBox status code.
@@ -594,5 +594,5 @@
     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;
@@ -611,5 +611,5 @@
 
             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));
 
@@ -636,5 +636,5 @@
             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. */
@@ -649,5 +649,5 @@
 
 /**
- * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET.
+ * Implements VBOX_SHCL_GUEST_FN_MSG_GET.
  *
  * @returns VBox status code.
@@ -684,15 +684,15 @@
         {
             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);
 
@@ -701,5 +701,5 @@
                 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);
             /*
@@ -797,15 +797,15 @@
             {
                 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);
@@ -862,11 +862,11 @@
     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);
@@ -908,5 +908,5 @@
     }
     else
-        uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
+        uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
 
     int rc = VINF_SUCCESS;
@@ -934,10 +934,10 @@
     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);
@@ -959,6 +959,6 @@
     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;
@@ -993,5 +993,5 @@
     else
     {
-        if (cParms < VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
+        if (cParms < VBOX_SHCL_CPARMS_WRITE_DATA)
         {
             rc = VERR_INVALID_PARAMETER;
@@ -1063,5 +1063,5 @@
     if (RT_SUCCESS(rc))
     {
-        sharedClipboardSvcModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
+        sharedClipboardSvcModeSet(VBOX_SHCL_MODE_OFF);
 
         rc = SharedClipboardSvcImplInit();
@@ -1189,5 +1189,5 @@
 
     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
@@ -1205,5 +1205,5 @@
     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);
@@ -1213,7 +1213,7 @@
         }
 
-        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;
@@ -1227,5 +1227,5 @@
                 rc = VERR_INVALID_PARAMETER;
             }
-            else if (sharedClipboardSvcGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
+            else if (sharedClipboardSvcGetMode() == VBOX_SHCL_MODE_OFF)
             {
                 rc = VERR_ACCESS_DENIED;
@@ -1250,5 +1250,5 @@
         }
 
-        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*/);
@@ -1256,5 +1256,5 @@
         }
 
-        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*/);
@@ -1264,5 +1264,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
+        case VBOX_SHCL_GUEST_FN_MSG_GET:
         {
             rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
@@ -1272,5 +1272,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT:
+        case VBOX_SHCL_GUEST_FN_FORMATS_REPORT:
         {
             uint32_t uFormats = 0;
@@ -1313,6 +1313,6 @@
             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;
@@ -1349,7 +1349,7 @@
         }
 
-        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;
@@ -1364,6 +1364,6 @@
             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;
@@ -1376,5 +1376,5 @@
                 {
 #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,
@@ -1467,5 +1467,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE:
+        case VBOX_SHCL_GUEST_FN_DATA_WRITE:
         {
             rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
@@ -1555,9 +1555,9 @@
 
     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)
@@ -1567,5 +1567,5 @@
             else
             {
-                uint32_t u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+                uint32_t u32Mode = VBOX_SHCL_MODE_OFF;
 
                 rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
@@ -1577,5 +1577,5 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS:
+        case VBOX_SHCL_HOST_FN_SET_HEADLESS:
         {
             if (cParms != 1)
@@ -1670,5 +1670,5 @@
 
     /* 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);
@@ -1755,9 +1755,9 @@
     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);
Index: /trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp	(revision 80847)
@@ -128,10 +128,10 @@
                 {
                     Log(("Unicode flavor detected.\n"));
-                    *pfFormats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+                    *pfFormats |= VBOX_SHCL_FMT_UNICODETEXT;
                 }
                 else if (UTTypeConformsTo(flavorType, kUTTypeBMP))
                 {
                     Log(("BMP flavor detected.\n"));
-                    *pfFormats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
+                    *pfFormats |= VBOX_SHCL_FMT_BITMAP;
                 }
             }
@@ -177,5 +177,5 @@
     {
         /* The guest request unicode */
-        if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
         {
             CFDataRef outData;
@@ -238,5 +238,5 @@
         }
         /* The guest request BITMAP */
-        else if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        else if (fFormat & VBOX_SHCL_FMT_BITMAP)
         {
             CFDataRef outData;
@@ -305,5 +305,5 @@
     int rc = VERR_NOT_SUPPORTED;
     /* Handle the unicode text */
-    if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
     {
         PRTUTF16 pwszSrcText = static_cast <PRTUTF16>(pv);
@@ -372,5 +372,5 @@
     }
     /* Handle the bitmap */
-    else if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    else if (fFormat & VBOX_SHCL_FMT_BITMAP)
     {
         /* Create a full BMP from it */
Index: /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp	(revision 80846)
+++ /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp	(revision 80847)
@@ -63,34 +63,34 @@
     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,
                            1, 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,
                            0, 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,
                            2, parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU64(&parms[0], 99);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
-                           1, 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,
+                           1, 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,
                            1, 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,
                            1, 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);
@@ -105,10 +105,10 @@
     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,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
@@ -120,14 +120,14 @@
     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,
                   2, 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,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -135,16 +135,16 @@
     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,
-                  2, 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,
+                  2, 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,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -155,20 +155,20 @@
     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,
                   2, 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,
-                  2, 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,
+                  2, 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,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -176,22 +176,22 @@
     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,
-                  2, 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,
-                  2, 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,
+                  2, 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,
+                  2, 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,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -213,21 +213,21 @@
     /* 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,
                            1, 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,
                            0, 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,
                            2, 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,
                            1, 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,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
@@ -235,5 +235,5 @@
     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,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
Index: /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp
===================================================================
--- /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp	(revision 80846)
+++ /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp	(revision 80847)
@@ -9257,21 +9257,21 @@
         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));
Index: /trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp
===================================================================
--- /trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp	(revision 80846)
+++ /trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp	(revision 80847)
@@ -3071,5 +3071,5 @@
                             VBOXHGCMSVCPARM parm;
                             HGCMSvcSetU32(&parm, !i_useHostClipboard());
-                            rc = SHAREDCLIPBOARDINST()->hostCall(VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
+                            rc = SHAREDCLIPBOARDINST()->hostCall(VBOX_SHCL_HOST_FN_SET_HEADLESS, 1, &parm);
                             if (RT_FAILURE(rc))
                                 LogRel(("Shared Clipboard: Unable to set initial headless mode, rc=%Rrc\n", rc));
