Changeset 78581 in vbox for trunk/src

Timestamp:

May 18, 2019 3:48:41 PM (6 years ago)

Author:

vboxsync

Message:

Shared Clipboard/URI: Update.

Location:

trunk/src/VBox

Files:

• Additions/WINNT/VBoxTray/VBoxClipboard.cpp (modified) (18 diffs)
• Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp (modified) (1 diff)
• Additions/x11/VBoxClient/Makefile.kmk (modified) (2 diffs)
• Additions/x11/VBoxClient/clipboard.cpp (modified) (2 diffs)
• GuestHost/SharedClipboard/ClipboardCache.cpp (modified) (2 diffs)
• GuestHost/SharedClipboard/clipboard-win.cpp (modified) (2 diffs)
• GuestHost/SharedClipboard/clipboard-x11.cpp (modified) (90 diffs)
• HostServices/SharedClipboard/VBoxClipboard.h (modified) (1 diff)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (modified) (1 diff)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (4 diffs)

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

@@ -39 +39 @@
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
 /** !!! HACK ALERT !!! Dynamically resolve functions! */
-#ifdef _WIN32_IE
-#undef _WIN32_IE
-#define _WIN32_IE 0x0501
-#endif
-#include <iprt/win/shlobj.h>
-#include <iprt/win/shlwapi.h>
+# ifdef _WIN32_IE
+#  undef _WIN32_IE
+#  define _WIN32_IE 0x0501
+# endif
+# include <iprt/win/shlobj.h>
+# include <iprt/win/shlwapi.h>
 #endif
 
@@ -73 +73 @@
 
 
-static LRESULT vboxClipboardProcessMsg(PVBOXCLIPBOARDCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+static LRESULT vboxClipboardWinProcessMsg(PVBOXCLIPBOARDCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
     AssertPtr(pCtx);
@@ -83 +83 @@
     switch (msg)
     {
-        case WM_CLIPBOARDUPDATE:
-        {
+       case WM_CLIPBOARDUPDATE:
+       {
            if (GetClipboardOwner() != hwnd)
            {
@@ -98 +98 @@
            else
                LogFlowFunc(("WM_CLIPBOARDUPDATE: No change (VBoxTray is owner)\n"));
-        }
-        break;
-
-        case WM_CHANGECBCHAIN:
-        {
+       }
+       break;
+
+       case WM_CHANGECBCHAIN:
+       {
            if (VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
            {
@@ -132 +132 @@
                }
            }
-        }
-        break;
-
-        case WM_DRAWCLIPBOARD:
-        {
-            LogFlowFunc(("WM_DRAWCLIPBOARD, hwnd %p\n", pWinCtx->hWnd));
-
-            if (GetClipboardOwner() != hwnd)
-            {
+       }
+       break;
+
+       case WM_DRAWCLIPBOARD:
+       {
+           LogFlowFunc(("WM_DRAWCLIPBOARD, hwnd %p\n", pWinCtx->hWnd));
+
+           if (GetClipboardOwner() != hwnd)
+           {
                /* Clipboard was updated by another application. */
                /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
@@ -147 +147 @@
                if (RT_SUCCESS(rc))
                    rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, fFormats);
-            }
-
-            if (pWinCtx->hWndNextInChain)
-            {
+           }
+
+           if (pWinCtx->hWndNextInChain)
+           {
                /* Pass the message to next windows in the clipboard chain. */
                SendMessageTimeout(pWinCtx->hWndNextInChain, msg, wParam, lParam, 0, VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS, NULL);
-            }
-        }
-        break;
-
-        case WM_TIMER:
-        {
-            if (VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
-                break;
-
-            HWND hViewer = GetClipboardViewer();
-
-            /* Re-register ourselves in the clipboard chain if our last ping
-            * timed out or there seems to be no valid chain. */
-            if (!hViewer || pWinCtx->oldAPI.fCBChainPingInProcess)
-            {
-                VBoxClipboardWinRemoveFromCBChain(pWinCtx);
-                VBoxClipboardWinAddToCBChain(pWinCtx);
-            }
-
-            /* Start a new ping by passing a dummy WM_CHANGECBCHAIN to be
-            * processed by ourselves to the chain. */
-            pWinCtx->oldAPI.fCBChainPingInProcess = TRUE;
-
-            hViewer = GetClipboardViewer();
-            if (hViewer)
-                SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain,
-                                    VBoxClipboardWinChainPingProc, (ULONG_PTR)pWinCtx);
-        }
-        break;
-
-        case WM_CLOSE:
-        {
-            /* Do nothing. Ignore the message. */
-        }
-        break;
-
-        case WM_RENDERFORMAT:
-        {
-            LogFunc(("WM_RENDERFORMAT\n"));
-
-            /* Insert the requested clipboard format data into the clipboard. */
-            const UINT cfFormat = (UINT)wParam;
-
-            const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
-
-            LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
-
-            if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_NONE)
-            {
-                LogFunc(("WM_RENDERFORMAT: Unsupported format requested\n"));
-                VBoxClipboardWinClear();
-            }
-            else
-            {
-                const uint32_t cbPrealloc = _4K;
-                uint32_t cb = 0;
-
-                /* Preallocate a buffer, most of small text transfers will fit into it. */
-                HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbPrealloc);
-                LogFlowFunc(("Preallocated handle hMem = %p\n", hMem));
-
-                if (hMem)
-                {
-                    void *pMem = GlobalLock(hMem);
-                    LogFlowFunc(("Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
-
-                    if (pMem)
-                    {
-                        /* Read the host data to the preallocated buffer. */
-                        int rc = VbglR3ClipboardReadData(pCtx->u32ClientID, fFormat, pMem, cbPrealloc, &cb);
-                        LogFlowFunc(("VbglR3ClipboardReadData returned with rc = %Rrc\n",  rc));
-
-                        if (RT_SUCCESS(rc))
-                        {
-                            if (cb == 0)
-                            {
-                                /* 0 bytes returned means the clipboard is empty.
-                                 * Deallocate the memory and set hMem to NULL to get to
-                                 * the clipboard empty code path. */
-                                GlobalUnlock(hMem);
-                                GlobalFree(hMem);
-                                hMem = NULL;
-                            }
-                            else if (cb > cbPrealloc)
-                            {
-                                GlobalUnlock(hMem);
-
-                                /* The preallocated buffer is too small, adjust the size. */
-                                hMem = GlobalReAlloc(hMem, cb, 0);
-                                LogFlowFunc(("Reallocated hMem = %p\n", hMem));
-
-                                if (hMem)
-                                {
-                                    pMem = GlobalLock(hMem);
-                                    LogFlowFunc(("Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
-
-                                    if (pMem)
-                                    {
-                                        /* Read the host data to the preallocated buffer. */
-                                        uint32_t cbNew = 0;
-                                        rc = VbglR3ClipboardReadData(pCtx->u32ClientID, fFormat, pMem, cb, &cbNew);
-                                        LogFlowFunc(("VbglR3ClipboardReadData returned with rc = %Rrc, cb = %d, cbNew = %d\n",
-                                                     rc, cb, cbNew));
-
-                                        if (RT_SUCCESS(rc)
-                                            && cbNew <= cb)
-                                        {
-                                            cb = cbNew;
-                                        }
-                                        else
-                                        {
-                                            GlobalUnlock(hMem);
-                                            GlobalFree(hMem);
-                                            hMem = NULL;
-                                        }
-                                    }
-                                    else
-                                    {
-                                        GlobalFree(hMem);
-                                        hMem = NULL;
-                                    }
-                                }
-                            }
-
-                            if (hMem)
-                            {
-                                /* pMem is the address of the data. cb is the size of returned data. */
-                                /* Verify the size of returned text, the memory block for clipboard
-                                 * must have the exact string size.
-                                 */
-                                if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
-                                {
-                                    size_t cbActual = 0;
-                                    HRESULT hrc = StringCbLengthW((LPWSTR)pMem, cb, &cbActual);
-                                    if (FAILED(hrc))
-                                    {
-                                        /* Discard invalid data. */
-                                        GlobalUnlock(hMem);
-                                        GlobalFree(hMem);
-                                        hMem = NULL;
-                                    }
-                                    else
-                                    {
-                                        /* cbActual is the number of bytes, excluding those used
-                                         * for the terminating null character.
-                                         */
-                                        cb = (uint32_t)(cbActual + 2);
-                                    }
-                                }
-                            }
-
-                            if (hMem)
-                            {
-                                GlobalUnlock(hMem);
-
-                                hMem = GlobalReAlloc(hMem, cb, 0);
-                                LogFlowFunc(("Reallocated hMem = %p\n", hMem));
-
-                                if (hMem)
-                                {
-                                    /* 'hMem' contains the host clipboard data.
-                                     * size is 'cb' and format is 'format'. */
-                                    HANDLE hClip = SetClipboardData(cfFormat, hMem);
-                                    LogFlowFunc(("WM_RENDERFORMAT hClip = %p\n", hClip));
-
-                                    if (hClip)
-                                    {
-                                        /* The hMem ownership has gone to the system. Finish the processing. */
-                                        break;
-                                    }
-
-                                    /* Cleanup follows. */
-                                }
-                            }
-                        }
-                        if (hMem)
-                            GlobalUnlock(hMem);
-                    }
-                    if (hMem)
-                        GlobalFree(hMem);
-                }
-            }
-        }
-        break;
-
-        case WM_RENDERALLFORMATS:
-        {
-            /* Do nothing. The clipboard formats will be unavailable now, because the
-            * windows is to be destroyed and therefore the guest side becomes inactive.
-            */
-            int rc = VBoxClipboardWinOpen(hwnd);
-            if (RT_SUCCESS(rc))
-            {
+           }
+       }
+       break;
+
+       case WM_TIMER:
+       {
+           if (VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
+               break;
+
+           HWND hViewer = GetClipboardViewer();
+
+           /* Re-register ourselves in the clipboard chain if our last ping
+           * timed out or there seems to be no valid chain. */
+           if (!hViewer || pWinCtx->oldAPI.fCBChainPingInProcess)
+           {
+               VBoxClipboardWinRemoveFromCBChain(pWinCtx);
+               VBoxClipboardWinAddToCBChain(pWinCtx);
+           }
+
+           /* Start a new ping by passing a dummy WM_CHANGECBCHAIN to be
+           * processed by ourselves to the chain. */
+           pWinCtx->oldAPI.fCBChainPingInProcess = TRUE;
+
+           hViewer = GetClipboardViewer();
+           if (hViewer)
+               SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain,
+                                   VBoxClipboardWinChainPingProc, (ULONG_PTR)pWinCtx);
+       }
+       break;
+
+       case WM_CLOSE:
+       {
+           /* Do nothing. Ignore the message. */
+       }
+       break;
+
+       case WM_RENDERFORMAT:
+       {
+           LogFunc(("WM_RENDERFORMAT\n"));
+
+           /* Insert the requested clipboard format data into the clipboard. */
+           const UINT cfFormat = (UINT)wParam;
+
+           const VBOXCLIPBOARDFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
+
+           LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
+
+           if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_NONE)
+           {
+               LogFunc(("WM_RENDERFORMAT: Unsupported format requested\n"));
+               VBoxClipboardWinClear();
+           }
+           else
+           {
+               const uint32_t cbPrealloc = _4K;
+               uint32_t cb = 0;
+
+               /* Preallocate a buffer, most of small text transfers will fit into it. */
+               HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbPrealloc);
+               LogFlowFunc(("Preallocated handle hMem = %p\n", hMem));
+
+               if (hMem)
+               {
+                   void *pMem = GlobalLock(hMem);
+                   LogFlowFunc(("Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
+
+                   if (pMem)
+                   {
+                       /* Read the host data to the preallocated buffer. */
+                       int rc = VbglR3ClipboardReadData(pCtx->u32ClientID, fFormat, pMem, cbPrealloc, &cb);
+                       LogFlowFunc(("VbglR3ClipboardReadData returned with rc = %Rrc\n",  rc));
+
+                       if (RT_SUCCESS(rc))
+                       {
+                           if (cb == 0)
+                           {
+                               /* 0 bytes returned means the clipboard is empty.
+                                * Deallocate the memory and set hMem to NULL to get to
+                                * the clipboard empty code path. */
+                               GlobalUnlock(hMem);
+                               GlobalFree(hMem);
+                               hMem = NULL;
+                           }
+                           else if (cb > cbPrealloc)
+                           {
+                               GlobalUnlock(hMem);
+
+                               /* The preallocated buffer is too small, adjust the size. */
+                               hMem = GlobalReAlloc(hMem, cb, 0);
+                               LogFlowFunc(("Reallocated hMem = %p\n", hMem));
+
+                               if (hMem)
+                               {
+                                   pMem = GlobalLock(hMem);
+                                   LogFlowFunc(("Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
+
+                                   if (pMem)
+                                   {
+                                       /* Read the host data to the preallocated buffer. */
+                                       uint32_t cbNew = 0;
+                                       rc = VbglR3ClipboardReadData(pCtx->u32ClientID, fFormat, pMem, cb, &cbNew);
+                                       LogFlowFunc(("VbglR3ClipboardReadData returned with rc = %Rrc, cb = %d, cbNew = %d\n",
+                                                    rc, cb, cbNew));
+
+                                       if (RT_SUCCESS(rc)
+                                           && cbNew <= cb)
+                                       {
+                                           cb = cbNew;
+                                       }
+                                       else
+                                       {
+                                           GlobalUnlock(hMem);
+                                           GlobalFree(hMem);
+                                           hMem = NULL;
+                                       }
+                                   }
+                                   else
+                                   {
+                                       GlobalFree(hMem);
+                                       hMem = NULL;
+                                   }
+                               }
+                           }
+
+                           if (hMem)
+                           {
+                               /* pMem is the address of the data. cb is the size of returned data. */
+                               /* Verify the size of returned text, the memory block for clipboard
+                                * must have the exact string size.
+                                */
+                               if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+                               {
+                                   size_t cbActual = 0;
+                                   HRESULT hrc = StringCbLengthW((LPWSTR)pMem, cb, &cbActual);
+                                   if (FAILED(hrc))
+                                   {
+                                       /* Discard invalid data. */
+                                       GlobalUnlock(hMem);
+                                       GlobalFree(hMem);
+                                       hMem = NULL;
+                                   }
+                                   else
+                                   {
+                                       /* cbActual is the number of bytes, excluding those used
+                                        * for the terminating null character.
+                                        */
+                                       cb = (uint32_t)(cbActual + 2);
+                                   }
+                               }
+                           }
+
+                           if (hMem)
+                           {
+                               GlobalUnlock(hMem);
+
+                               hMem = GlobalReAlloc(hMem, cb, 0);
+                               LogFlowFunc(("Reallocated hMem = %p\n", hMem));
+
+                               if (hMem)
+                               {
+                                   /* 'hMem' contains the host clipboard data.
+                                    * size is 'cb' and format is 'format'. */
+                                   HANDLE hClip = SetClipboardData(cfFormat, hMem);
+                                   LogFlowFunc(("WM_RENDERFORMAT hClip = %p\n", hClip));
+
+                                   if (hClip)
+                                   {
+                                       /* The hMem ownership has gone to the system. Finish the processing. */
+                                       break;
+                                   }
+
+                                   /* Cleanup follows. */
+                               }
+                           }
+                       }
+                       if (hMem)
+                           GlobalUnlock(hMem);
+                   }
+                   if (hMem)
+                       GlobalFree(hMem);
+               }
+           }
+       }
+       break;
+
+       case WM_RENDERALLFORMATS:
+       {
+           /* Do nothing. The clipboard formats will be unavailable now, because the
+           * windows is to be destroyed and therefore the guest side becomes inactive.
+           */
+           int rc = VBoxClipboardWinOpen(hwnd);
+           if (RT_SUCCESS(rc))
+           {
                VBoxClipboardWinClear();
                VBoxClipboardWinClose();
-            }
-        }
-        break;
-
-        case VBOX_CLIPBOARD_WM_SET_FORMATS:
-        {
+           }
+       }
+       break;
+
+       case VBOX_CLIPBOARD_WM_SET_FORMATS:
+       {
            /* Announce available formats. Do not insert data, they will be inserted in WM_RENDER*. */
            VBOXCLIPBOARDFORMATS fFormats = (uint32_t)lParam;
@@ -389 +389 @@
                else if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
                {
-                   LogFunc(("VBOX_WM_SHCLPB_SET_FORMATS: VBOX_CLIPBOARD_WIN_REGFMT_URI_LIST\n"));
-                   if (pWinCtx->URI.pDataObj == NULL) /* Only allow one transfer at a time. */
+                   LogFunc(("VBOX_WM_SHCLPB_SET_FORMATS: VBOX_CLIPBOARD_WIN_REGFMT_URI_LIST cTransfers=%RU32\n",
+                            pWinCtx->URI.cTransfers));
+                   if (pWinCtx->URI.cTransfers == 0) /* Only allow one transfer at a time for now. */
                    {
-                       pWinCtx->URI.pDataObj = new VBoxClipboardWinDataObject(/* No additional formats needed right now */);
-                       if (pWinCtx->URI.pDataObj)
+                       pWinCtx->URI.Transfer.pDataObj = new VBoxClipboardWinDataObject(/* No additional formats needed right now */);
+                       if (pWinCtx->URI.Transfer.pDataObj)
                        {
-                           rc = pWinCtx->URI.pDataObj->Init(pCtx->u32ClientID);
+                           rc = pWinCtx->URI.Transfer.pDataObj->Init(pCtx->u32ClientID);
                            if (RT_SUCCESS(rc))
                            {
@@ -405 +406 @@
                                 *        OleSetClipboard() will fail. Needs fixing. */
 
-                               HRESULT hr = OleSetClipboard(pWinCtx->URI.pDataObj);
-                               if (FAILED(hr))
+                               HRESULT hr = OleSetClipboard(pWinCtx->URI.Transfer.pDataObj);
+                               if (SUCCEEDED(hr))
+                               {
+                                   pWinCtx->URI.cTransfers++;
+                               }
+                               else
                                    LogRel(("Clipboard: Failed with %Rhrc when setting data object to clipboard\n", hr));
                            }
@@ -423 +428 @@
                LogFunc(("VBOX_WM_SHCLPB_SET_FORMATS: cfFormat=%u, lastErr=%ld\n", cfFormat, GetLastError()));
            }
-        }
-        break;
-
-        case VBOX_CLIPBOARD_WM_READ_DATA:
-        {
-            /* Send data in the specified format to the host. */
-            uint32_t u32Formats = (uint32_t)lParam;
-            HANDLE hClip = NULL;
-
-            LogFlowFunc(("VBOX_WM_SHCLPB_READ_DATA: u32Formats=0x%x\n", u32Formats));
-
-            int rc = VBoxClipboardWinOpen(hwnd);
-            if (RT_SUCCESS(rc))
-            {
-               if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+       }
+       break;
+
+       case VBOX_CLIPBOARD_WM_READ_DATA:
+       {
+           /* Send data in the specified format to the host. */
+           VBOXCLIPBOARDFORMAT uFormat = (uint32_t)lParam;
+           HANDLE hClip = NULL;
+
+           LogFlowFunc(("VBOX_WM_SHCLPB_READ_DATA: uFormat=0x%x\n", uFormat));
+
+           int rc = VBoxClipboardWinOpen(hwnd);
+           if (RT_SUCCESS(rc))
+           {
+               if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
                {
                    hClip = GetClipboardData(CF_DIB);
@@ -455 +460 @@
                    }
                }
-               else if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
                {
                    hClip = GetClipboardData(CF_UNICODETEXT);
@@ -473 +478 @@
                    }
                }
-               else if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
                {
                    UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML);
@@ -497 +502 @@
                }
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-               else if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
                {
                    /* The data data in CF_HDROP format, as the files are locally present and don't need to be
@@ -507 +512 @@
                        if (hDrop)
                        {
-        /*                    vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST,
-                                                             );*/
+                           char *pszList;
+                           size_t cbList;
+                           rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &pszList, &cbList);
+                           if (RT_SUCCESS(rc))
+                           {
+                               rc = VbglR3ClipboardWriteData(pCtx->u32ClientID, uFormat, pszList, (uint32_t)cbList);
+                               RTMemFree(pszList);
+                           }
+
                            GlobalUnlock(hClip);
                        }
@@ -518 +530 @@
                }
 #endif
+               if (hClip == NULL)
+               {
+                   LogFunc(("VBOX_WM_SHCLPB_READ_DATA: hClip=NULL, lastError=%ld\n", GetLastError()));
+
+                   /* Requested clipboard format is not available, send empty data. */
+                   VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_NONE, NULL, 0);
+               }
+
                VBoxClipboardWinClose();
-            }
-
-            if (hClip == NULL)
-            {
-               /* Requested clipboard format is not available, send empty data. */
-               VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_NONE, NULL, 0);
-            }
-        }
-        break;
-
-        case WM_DESTROY:
-        {
-            VBoxClipboardWinRemoveFromCBChain(pWinCtx);
-            if (pWinCtx->oldAPI.timerRefresh)
+           }
+       }
+       break;
+
+       case WM_DESTROY:
+       {
+           VBoxClipboardWinRemoveFromCBChain(pWinCtx);
+           if (pWinCtx->oldAPI.timerRefresh)
                KillTimer(pWinCtx->hWnd, 0);
-            /*
-            * don't need to call PostQuitMessage cause
-            * the VBoxTray already finished a message loop
-            */
-        }
-        break;
-
-        default:
-        {
-            lresultRc = DefWindowProc(hwnd, msg, wParam, lParam);
-        }
-        break;
+           /*
+           * don't need to call PostQuitMessage cause
+           * the VBoxTray already finished a message loop
+           */
+       }
+       break;
+
+       default:
+       {
+           lresultRc = DefWindowProc(hwnd, msg, wParam, lParam);
+       }
+       break;
     }
 
@@ -554 +568 @@
 }
 
-static LRESULT CALLBACK vboxClipboardWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
+static LRESULT CALLBACK vboxClipboardWinWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
 static int vboxClipboardCreateWindow(PVBOXCLIPBOARDCONTEXT pCtx)
@@ -573 +587 @@
     {
         wc.style         = CS_NOCLOSE;
-        wc.lpfnWndProc   = vboxClipboardWndProc;
+        wc.lpfnWndProc   = vboxClipboardWinWndProc;
         wc.hInstance     = pCtx->pEnv->hInstance;
         wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
@@ -626 +640 @@
 }
 
-static LRESULT CALLBACK vboxClipboardWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+static LRESULT CALLBACK vboxClipboardWinWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
     PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /** @todo r=andy Make pCtx available through SetWindowLongPtr() / GWL_USERDATA. */
@@ -632 +646 @@
 
     /* Forward with proper context. */
-    return vboxClipboardProcessMsg(pCtx, hWnd, uMsg, wParam, lParam);
+    return vboxClipboardWinProcessMsg(pCtx, hWnd, uMsg, wParam, lParam);
 }
 

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

@@ -499 +499 @@
         /*
          * Send the (meta) data; in case of URIs it's the (non-recursive) file/directory
-         * URI list the host needs to know upfront to set up the drag'n drop operation.
+         * URI list the host needs to know upfront to set up the Shared Clipboard operation.
          */
         RTCString strRootDest = lstURI.GetRootEntries();

trunk/src/VBox/Additions/x11/VBoxClient/Makefile.kmk

@@ -103 +103 @@
         clipboard.cpp
  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-  ifdef VBOX_WITH_LIBFUSE
+ VBoxClient_SOURCES += \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIObject.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp
+  ifdef VBOX_WITH_LIBFUSE_DISABLED
    VBoxClient_SOURCES += \
         clipboard-fuse.cpp
@@ -170 +174 @@
 
 include $(FILE_KBUILD_SUB_FOOTER)
-

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

@@ -181 +181 @@
  * @returns VBox status code
  */
-int vboxClipboardConnect(void)
+int VBoxClipboardSvcImplConnect(void)
 {
     int rc = VINF_SUCCESS;
@@ -294 +294 @@
     if (RT_FAILURE(rc))
         VBClFatalError(("Failed to connect to the VirtualBox kernel service, rc=%Rrc\n", rc));
-    rc = vboxClipboardConnect();
+    rc = VBoxClipboardSvcImplConnect();
     /* Not RT_SUCCESS: VINF_PERMISSION_DENIED is host service not present. */
     if (rc == VINF_SUCCESS)

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardCache.cpp

@@ -75 +75 @@
 uint16_t SharedClipboardCache::AddRef(void)
 {
-    return ASMAtomicIncU16(&m_cRefs);
+    return ASMAtomicIncU32(&m_cRefs);
 }
 
@@ -86 +86 @@
 {
     Assert(m_cRefs);
-    return ASMAtomicDecU16(&m_cRefs);
+    return ASMAtomicDecU32(&m_cRefs);
 }
 

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

@@ -594 +594 @@
 /**
  * Converts a DROPFILES (HDROP) structure to a string list, separated by \r\n.
+ * Does not do any locking on the input data.
  *
  * @returns VBox status code.
  * @param   pDropFiles          Pointer to DROPFILES structure to convert.
- * @param   ppvData             Where to return the converted (allocated) data on success.
+ * @param   ppszData            Where to return the converted (allocated) data on success.
+ *                              Must be free'd by the caller with RTMemFree().
  * @param   pcbData             Size (in bytes) of the allocated data returned.
  */
-int VBoxClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, void **ppvData, size_t *pcbData)
+int VBoxClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **ppszbData, size_t *pcbData)
 {
     AssertPtrReturn(pDropFiles, VERR_INVALID_POINTER);
-    AssertPtrReturn(ppvData,    VERR_INVALID_POINTER);
+    AssertPtrReturn(ppszbData,  VERR_INVALID_POINTER);
     AssertPtrReturn(pcbData,    VERR_INVALID_POINTER);
 
@@ -725 +727 @@
                 memcpy(pvData, strRoot.c_str(), cbRoot);
 
-                *ppvData = pvData;
-                *pcbData = cbRoot;
+                *ppszbData = (char *)pvData;
+                *pcbData   = cbRoot;
             }
             else

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

@@ -75 +75 @@
 *   Structures and Typedefs                                                                                                      *
 *********************************************************************************************************************************/
-/** The different clipboard formats which we support. */
-enum CLIPFORMAT
-{
-    INVALID = 0,
-    TARGETS,
-    TEXT,  /* Treat this as Utf8, but it may really be ascii */
-    UTF8,
-    BMP,
-    HTML
-};
-
-typedef unsigned CLIPX11FORMAT;
+/** The different X11 clipboard format targets. */
+typedef enum _CLIPX11FORMATTARGET
+{
+    CLIPX11FORMATTARGET_INVALID = 0,
+    CLIPX11FORMATTARGET_TARGETS,
+    CLIPX11FORMATTARGET_TEXT,  /* Treat this as Utf8, but it may really be ascii */
+    CLIPX11FORMATTARGET_UTF8,
+    CLIPX11FORMATTARGET_BMP,
+    CLIPX11FORMATTARGET_HTML,
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    CLIPX11FORMATTARGET_URI_LIST
+#endif
+} CLIPX11FORMATTARGET;
+
+/** Index into the format array. */
+typedef unsigned CLIPX11FORMATIDX;
 
 
@@ -101 +105 @@
 /** The table mapping X11 names to data formats and to the corresponding
  * VBox clipboard formats (currently only Unicode) */
-static struct _CLIPFORMATTABLE
-{
-    /** The X11 atom name of the format (several names can match one format)
-     */
+static struct _CLIPX11FORMATTABLE
+{
+    /** The X11 atom name of the format (several names can match one format) */
     const char *pcszAtom;
-    /** The format corresponding to the name */
-    CLIPFORMAT  enmFormat;
+    /** The format target corresponding to the atom name */
+    CLIPX11FORMATTARGET enmTarget;
     /** The corresponding VBox clipboard format */
-    uint32_t    u32VBoxFormat;
+    VBOXCLIPBOARDFORMAT vboxFormat;
 } g_aFormats[] =
 {
-    { "INVALID", INVALID, 0 },
-    { "UTF8_STRING", UTF8, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
-    { "text/plain;charset=UTF-8", UTF8,
-      VBOX_SHARED_CLIPBOARD_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 },
-    { "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 }
-
-
+    { "INVALID", CLIPX11FORMATTARGET_INVALID, 0 },
+    { "UTF8_STRING", CLIPX11FORMATTARGET_UTF8, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "text/plain;charset=UTF-8", CLIPX11FORMATTARGET_UTF8, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "text/plain;charset=utf-8", CLIPX11FORMATTARGET_UTF8, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "STRING", CLIPX11FORMATTARGET_TEXT, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "TEXT", CLIPX11FORMATTARGET_TEXT, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "text/plain", CLIPX11FORMATTARGET_TEXT, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT },
+    { "text/html", CLIPX11FORMATTARGET_HTML, VBOX_SHARED_CLIPBOARD_FMT_HTML },
+    { "text/html;charset=utf-8", CLIPX11FORMATTARGET_HTML, VBOX_SHARED_CLIPBOARD_FMT_HTML },
+    { "image/bmp", CLIPX11FORMATTARGET_BMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP },
+    { "image/x-bmp", CLIPX11FORMATTARGET_BMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP },
+    { "image/x-MS-bmp", CLIPX11FORMATTARGET_BMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP },
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    { "text/uri-list", CLIPX11FORMATTARGET_URI_LIST, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST },
+    { "x-special/gnome-copied-files", CLIPX11FORMATTARGET_URI_LIST, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST }
+#endif
     /** @todo Inkscape exports image/png but not bmp... */
 };
@@ -134 +136 @@
 enum
 {
-    NIL_CLIPX11FORMAT = 0,
-    MAX_CLIP_X11_FORMATS = RT_ELEMENTS(g_aFormats)
+    CLIPX11FORMATIDX_NIL = 0,
+    CLIPX11FORMATIDX_MAX = RT_ELEMENTS(g_aFormats)
 };
 
 
-/** Return the atom corresponding to a supported X11 format.
+/** Returnx the atom name corresponding to a supported X11 format index.
  * @param widget a valid Xt widget
  */
-static Atom clipAtomForX11Format(CLIPBACKEND *pCtx, CLIPX11FORMAT format)
-{
-    return clipGetAtom(pCtx, g_aFormats[format].pcszAtom);
-}
-
-/** Return the CLIPFORMAT corresponding to a supported X11 format. */
-static CLIPFORMAT clipRealFormatForX11Format(CLIPX11FORMAT format)
-{
-    return g_aFormats[format].enmFormat;
-}
-
-/** Return the atom corresponding to a supported X11 format. */
-static uint32_t clipVBoxFormatForX11Format(CLIPX11FORMAT format)
-{
-    return g_aFormats[format].u32VBoxFormat;
-}
-
-/** Lookup the X11 format matching a given X11 atom.
- * @returns the format on success, NIL_CLIPX11FORMAT on failure
+static Atom clipGetAtomFromFmtIdx(CLIPBACKEND *pCtx, CLIPX11FORMATIDX formatIdx)
+{
+    return clipGetAtom(pCtx, g_aFormats[formatIdx].pcszAtom);
+}
+
+/** Returns the format target corresponding to a supported X11 format index. */
+static CLIPX11FORMATTARGET clipGetTargetFmtFromFmtIdx(CLIPX11FORMATIDX formatIdx)
+{
+    return g_aFormats[formatIdx].enmTarget;
+}
+
+/** Returns the VBox format corresponding to a supported X11 format index. */
+static VBOXCLIPBOARDFORMAT clipGetVBoxFmtFromFmtIdx(CLIPX11FORMATIDX formatIdx)
+{
+    return g_aFormats[formatIdx].vboxFormat;
+}
+
+/**
+ * Looks up the X11 format index matching a given X11 atom.
+ *
+ * @returns the format on success, CLIPX11FORMATIDX_NIL on failure.
  * @param   widget a valid Xt widget
  */
-static CLIPX11FORMAT clipFindX11FormatByAtom(CLIPBACKEND *pCtx, Atom atomFormat)
+static CLIPX11FORMATIDX clipGetFmtIdxFromAtom(CLIPBACKEND *pCtx, Atom atomFormat)
 {
     for (unsigned i = 0; i < RT_ELEMENTS(g_aFormats); ++i)
-        if (clipAtomForX11Format(pCtx, i) == atomFormat)
+        if (clipGetAtomFromFmtIdx(pCtx, i) == atomFormat)
             return i;
-    return NIL_CLIPX11FORMAT;
+    return CLIPX11FORMATIDX_NIL;
 }
 
@@ -176 +180 @@
  * @param   widget a valid Xt widget
  */
-static CLIPX11FORMAT clipFindX11FormatByAtomText(const char *pcsz)
+static CLIPX11FORMATIDX clipGetFmtIdxFromAtomText(const char *pcsz)
 {
     for (unsigned i = 0; i < RT_ELEMENTS(g_aFormats); ++i)
         if (!strcmp(g_aFormats[i].pcszAtom, pcsz))
             return i;
-    return NIL_CLIPX11FORMAT;
-}
-#endif
-
-/**
- * Enumerates supported X11 clipboard formats corresponding to a given VBox
- * format.
+    return CLIPX11FORMATIDX_NIL;
+}
+#endif
+
+/**
+ * Enumerates supported X11 clipboard formats corresponding to a given VBox format.
+ *
  * @returns the next matching X11 format in the list, or NIL_CLIPX11FORMAT if
  *          there are no more
- * @param lastFormat  The value returned from the last call of this function.
- *                    Use NIL_CLIPX11FORMAT to start the enumeration.
- */
-static CLIPX11FORMAT clipEnumX11Formats(uint32_t u32VBoxFormats,
-                                        CLIPX11FORMAT lastFormat)
-{
-    for (unsigned i = lastFormat + 1; i < RT_ELEMENTS(g_aFormats); ++i)
-        if (u32VBoxFormats & clipVBoxFormatForX11Format(i))
+ * @param lastFmtIdx  The format index returned from the last call of this function.
+ *                    Use CLIPX11FORMATIDX_NIL to start the enumeration.
+ */
+static CLIPX11FORMATIDX clipEnumFmtIdxForVBoxFmt(VBOXCLIPBOARDFORMAT vboxFormat,
+                                                 CLIPX11FORMATIDX lastFmtIdx)
+{
+    for (unsigned i = lastFmtIdx + 1; i < RT_ELEMENTS(g_aFormats); ++i)
+        if (vboxFormat & clipGetVBoxFmtFromFmtIdx(i))
             return i;
-    return NIL_CLIPX11FORMAT;
+    return CLIPX11FORMATIDX_NIL;
 }
 
@@ -222 +226 @@
     /** The best text format X11 has to offer, as an index into the formats
      * table */
-    CLIPX11FORMAT X11TextFormat;
+    CLIPX11FORMATIDX X11TextFmtIdx;
     /** The best bitmap format X11 has to offer, as an index into the formats
      * table */
-    CLIPX11FORMAT X11BitmapFormat;
+    CLIPX11FORMATIDX X11BitmapFmtIdx;
     /** The best HTML format X11 has to offer, as an index into the formats
      * table */
-    CLIPX11FORMAT X11HTMLFormat;
+    CLIPX11FORMATIDX X11HTMLFmtIdx;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    /** The best URI list format X11 has to offer, as an index into the formats
+     * table */
+    CLIPX11FORMATIDX X11URListFmtIdx;
+#endif
     /** What formats does VBox have on offer? */
-    uint32_t vboxFormats;
+    VBOXCLIPBOARDFORMATS vboxFormats;
     /** Cache of the last unicode data that we received */
     void *pvUnicodeCache;
@@ -358 +367 @@
                     (XtPointer)client_data);
     ssize_t cbWritten = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
-    NOREF(cbWritten);
+    RT_NOREF(cbWritten);
 #else
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     testQueueToEventThread(proc, client_data);
 #endif
@@ -370 +379 @@
 static void clipReportFormatsToVBox(CLIPBACKEND *pCtx)
 {
-    uint32_t u32VBoxFormats = clipVBoxFormatForX11Format(pCtx->X11TextFormat);
-    u32VBoxFormats |= clipVBoxFormatForX11Format(pCtx->X11BitmapFormat);
-    u32VBoxFormats |= clipVBoxFormatForX11Format(pCtx->X11HTMLFormat);
-    LogRelFlowFunc(("clipReportFormatsToVBox format: %d\n", u32VBoxFormats));
-    LogRelFlowFunc(("clipReportFormatsToVBox txt: %d, bitm: %d, html:%d, u32VBoxFormats: %d\n",
-                    pCtx->X11TextFormat, pCtx->X11BitmapFormat, pCtx->X11HTMLFormat,
-                    u32VBoxFormats ));
-    ClipReportX11Formats(pCtx->pFrontend, u32VBoxFormats);
+    VBOXCLIPBOARDFORMATS vboxFormats = clipGetVBoxFmtFromFmtIdx(pCtx->X11TextFmtIdx);
+    vboxFormats |= clipGetVBoxFmtFromFmtIdx(pCtx->X11BitmapFmtIdx);
+    vboxFormats |= clipGetVBoxFmtFromFmtIdx(pCtx->X11HTMLFmtIdx);
+
+    LogRelFlowFunc(("clipReportFormatsToVBox formats: 0x%x\n", vboxFormats));
+    LogRelFlowFunc(("clipReportFormatsToVBox txt: %d, bitm: %d, html:%d, vboxFormat: %d\n",
+                    pCtx->X11TextFmtIdx, pCtx->X11BitmapFmtIdx, pCtx->X11HTMLFmtIdx,
+                    vboxFormats));
+
+    ClipReportX11Formats(pCtx->pFrontend, vboxFormats);
 }
 
@@ -385 +396 @@
 static void clipResetX11Formats(CLIPBACKEND *pCtx)
 {
-    pCtx->X11TextFormat = INVALID;
-    pCtx->X11BitmapFormat = INVALID;
-    pCtx->X11HTMLFormat = INVALID;
+    pCtx->X11TextFmtIdx   = CLIPX11FORMATIDX_NIL;
+    pCtx->X11BitmapFmtIdx = CLIPX11FORMATIDX_NIL;
+    pCtx->X11HTMLFmtIdx   = CLIPX11FORMATIDX_NIL;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    pCtx->X11URListFmtIdx = CLIPX11FORMATIDX_NIL;
+#endif
 }
 
@@ -397 +411 @@
 }
 
-/**
- * Go through an array of X11 clipboard targets to see if they contain a text
+#ifdef TESTCASE
+static bool clipTestTextFormatConversion(CLIPBACKEND *pCtx)
+{
+    bool success = true;
+    CLIPX11FORMAT targets[2];
+    CLIPX11FORMAT x11Format;
+    targets[0] = clipGetFmtIdxFromAtomText("text/plain");
+    targets[1] = clipGetFmtIdxFromAtomText("image/bmp");
+    x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2);
+    if (clipGetTargetFmtFromFmtIdx(x11Format) != TEXT)
+        success = false;
+    targets[0] = clipGetFmtIdxFromAtomText("UTF8_STRING");
+    targets[1] = clipGetFmtIdxFromAtomText("text/plain");
+    x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2);
+    if (clipGetTargetFmtFromFmtIdx(x11Format) != UTF8)
+        success = false;
+    return success;
+}
+#endif
+
+/**
+ * Go through an array of X11 clipboard targets to see if they contain a bitmap
  * format we can support, and if so choose the ones we prefer (e.g. we like
- * Utf8 better than plain text).
+ * BMP better than PNG because we don't have to convert).
+ *
  * @param  pCtx      the clipboard backend context structure
  * @param  pTargets  the list of targets
  * @param  cTargets  the size of the list in @a pTargets
  */
-static CLIPX11FORMAT clipGetTextFormatFromTargets(CLIPBACKEND *pCtx,
-                                                  CLIPX11FORMAT *pTargets,
-                                                  size_t cTargets)
-{
-    CLIPX11FORMAT bestTextFormat = NIL_CLIPX11FORMAT;
-    CLIPFORMAT enmBestTextTarget = INVALID;
-    AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
-    AssertReturn(VALID_PTR(pTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
+static CLIPX11FORMATIDX clipGetBestFmtIdxFromTargets(CLIPBACKEND *pCtx,
+                                                     VBOXCLIPBOARDFORMAT vboxFormat,
+                                                     CLIPX11FORMATIDX   *paTargets, size_t cTargets)
+{
+    AssertPtrReturn(pCtx, CLIPX11FORMATIDX_NIL);
+    AssertReturn(VALID_PTR(paTargets) || cTargets == 0, CLIPX11FORMATIDX_NIL);
+
+    CLIPX11FORMATIDX    bestFmtIdx    = CLIPX11FORMATIDX_NIL;
+    CLIPX11FORMATTARGET enmBestTarget = CLIPX11FORMATTARGET_INVALID;
+
     for (unsigned i = 0; i < cTargets; ++i)
     {
-        CLIPX11FORMAT format = pTargets[i];
-        if (format != NIL_CLIPX11FORMAT)
-        {
-            if (   (clipVBoxFormatForX11Format(format)
-                            == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
-                    && enmBestTextTarget < clipRealFormatForX11Format(format))
+        CLIPX11FORMATIDX format = paTargets[i];
+        if (format != CLIPX11FORMATIDX_NIL)
+        {
+            if (   (clipGetVBoxFmtFromFmtIdx(format) == vboxFormat)
+                && enmBestTarget < clipGetTargetFmtFromFmtIdx(format))
             {
-                enmBestTextTarget = clipRealFormatForX11Format(format);
-                bestTextFormat = format;
+                enmBestTarget = clipGetTargetFmtFromFmtIdx(format);
+                bestFmtIdx = format;
             }
         }
     }
-    return bestTextFormat;
-}
-
-#ifdef TESTCASE
-static bool clipTestTextFormatConversion(CLIPBACKEND *pCtx)
-{
-    bool success = true;
-    CLIPX11FORMAT targets[2];
-    CLIPX11FORMAT x11Format;
-    targets[0] = clipFindX11FormatByAtomText("text/plain");
-    targets[1] = clipFindX11FormatByAtomText("image/bmp");
-    x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2);
-    if (clipRealFormatForX11Format(x11Format) != TEXT)
-        success = false;
-    targets[0] = clipFindX11FormatByAtomText("UTF8_STRING");
-    targets[1] = clipFindX11FormatByAtomText("text/plain");
-    x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2);
-    if (clipRealFormatForX11Format(x11Format) != UTF8)
-        success = false;
-    return success;
-}
-#endif
-
-/**
- * Go through an array of X11 clipboard targets to see if they contain a bitmap
- * format we can support, and if so choose the ones we prefer (e.g. we like
- * BMP better than PNG because we don't have to convert).
+    return bestFmtIdx;
+}
+
+/**
+ * Go through an array of X11 clipboard targets to see if we can support any
+ * of them and if relevant to choose the ones we prefer (e.g. we like Utf8
+ * better than plain text).
+ *
  * @param  pCtx      the clipboard backend context structure
  * @param  pTargets  the list of targets
  * @param  cTargets  the size of the list in @a pTargets
  */
-static CLIPX11FORMAT clipGetBitmapFormatFromTargets(CLIPBACKEND *pCtx,
-                                                    CLIPX11FORMAT *pTargets,
-                                                    size_t cTargets)
-{
-    CLIPX11FORMAT bestBitmapFormat = NIL_CLIPX11FORMAT;
-    CLIPFORMAT enmBestBitmapTarget = INVALID;
-    AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
-    AssertReturn(VALID_PTR(pTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
-    for (unsigned i = 0; i < cTargets; ++i)
-    {
-        CLIPX11FORMAT format = pTargets[i];
-        if (format != NIL_CLIPX11FORMAT)
-        {
-            if (   (clipVBoxFormatForX11Format(format)
-                            == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
-                    && enmBestBitmapTarget < clipRealFormatForX11Format(format))
-            {
-                enmBestBitmapTarget = clipRealFormatForX11Format(format);
-                bestBitmapFormat = format;
-            }
-        }
-    }
-    return bestBitmapFormat;
-}
-
-/**
- * Go through an array of X11 clipboard targets to see if they contain a HTML
- * format we can support, and if so choose the ones we prefer
- * @param  pCtx      the clipboard backend context structure
- * @param  pTargets  the list of targets
- * @param  cTargets  the size of the list in @a pTargets
- */
-static CLIPX11FORMAT clipGetHtmlFormatFromTargets(CLIPBACKEND *pCtx,
-                                                  CLIPX11FORMAT *pTargets,
-                                                  size_t cTargets)
-{
-    CLIPX11FORMAT bestHTMLFormat = NIL_CLIPX11FORMAT;
-    CLIPFORMAT enmBestHtmlTarget = INVALID;
-    AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
-    AssertReturn(VALID_PTR(pTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
-    for (unsigned i = 0; i < cTargets; ++i)
-    {
-        CLIPX11FORMAT format = pTargets[i];
-        if (format != NIL_CLIPX11FORMAT)
-        {
-            if (   (clipVBoxFormatForX11Format(format) == VBOX_SHARED_CLIPBOARD_FMT_HTML)
-                && enmBestHtmlTarget < clipRealFormatForX11Format(format))
-            {
-                enmBestHtmlTarget = clipRealFormatForX11Format(format);
-                bestHTMLFormat = format;
-            }
-        }
-    }
-    return bestHTMLFormat;
-}
-
-
-/**
- * Go through an array of X11 clipboard targets to see if we can support any
- * of them and if relevant to choose the ones we prefer (e.g. we like Utf8
- * better than plain text).
- * @param  pCtx      the clipboard backend context structure
- * @param  pTargets  the list of targets
- * @param  cTargets  the size of the list in @a pTargets
- */
 static void clipGetFormatsFromTargets(CLIPBACKEND *pCtx,
-                                      CLIPX11FORMAT *pTargets, size_t cTargets)
+                                      CLIPX11FORMATIDX *paTargets, size_t cTargets)
 {
     AssertPtrReturnVoid(pCtx);
-    AssertPtrReturnVoid(pTargets);
-    CLIPX11FORMAT bestTextFormat;
-    CLIPX11FORMAT bestBitmapFormat;
-    CLIPX11FORMAT bestHtmlFormat;
-    bestTextFormat = clipGetTextFormatFromTargets(pCtx, pTargets, cTargets);
-    if (pCtx->X11TextFormat != bestTextFormat)
-    {
-        pCtx->X11TextFormat = bestTextFormat;
-    }
-    pCtx->X11BitmapFormat = INVALID;  /* not yet supported */
-    bestBitmapFormat = clipGetBitmapFormatFromTargets(pCtx, pTargets, cTargets);
-    if (pCtx->X11BitmapFormat != bestBitmapFormat)
-    {
-        pCtx->X11BitmapFormat = bestBitmapFormat;
-    }
-    bestHtmlFormat = clipGetHtmlFormatFromTargets(pCtx, pTargets, cTargets);
-    if(pCtx->X11HTMLFormat != bestHtmlFormat)
-    {
-        pCtx->X11HTMLFormat = bestHtmlFormat;
-    }
+    AssertPtrReturnVoid(paTargets);
+
+    CLIPX11FORMATIDX bestFmtIdx = clipGetBestFmtIdxFromTargets(pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
+                                                               paTargets, cTargets);
+    if (pCtx->X11TextFmtIdx != bestFmtIdx)
+        pCtx->X11TextFmtIdx = bestFmtIdx;
+
+    pCtx->X11BitmapFmtIdx = CLIPX11FORMATIDX_NIL;  /* not yet supported */
+    bestFmtIdx = clipGetBestFmtIdxFromTargets(pCtx, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, paTargets, cTargets);
+    if (pCtx->X11BitmapFmtIdx != bestFmtIdx)
+        pCtx->X11BitmapFmtIdx = bestFmtIdx;
+
+    bestFmtIdx = clipGetBestFmtIdxFromTargets(pCtx, VBOX_SHARED_CLIPBOARD_FMT_HTML, paTargets, cTargets);
+    if(pCtx->X11HTMLFmtIdx != bestFmtIdx)
+        pCtx->X11HTMLFmtIdx = bestFmtIdx;
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    bestFmtIdx = clipGetBestFmtIdxFromTargets(pCtx, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST, paTargets, cTargets);
+    if(pCtx->X11URListFmtIdx != bestFmtIdx)
+        pCtx->X11URListFmtIdx = bestFmtIdx;
+#endif
 }
 
@@ -554 +507 @@
  * Update the context's information about targets currently supported by X11,
  * based on an array of X11 atoms.
+ *
  * @param  pCtx      the context to be updated
  * @param  pTargets  the array of atoms describing the targets supported
  * @param  cTargets  the size of the array @a pTargets
  */
-static void clipUpdateX11Targets(CLIPBACKEND *pCtx, CLIPX11FORMAT *pTargets,
-                                 size_t cTargets)
-{
-    LogRel2 (("%s: called\n", __FUNCTION__));
+static void clipUpdateX11Targets(CLIPBACKEND *pCtx, CLIPX11FORMATIDX *paTargetFmtIdx, size_t cTargets)
+{
+    LogRel2(("Shared clipboard: clipUpdateX11Targets called\n"));
+
 #ifndef VBOX_AFTER_5_2
     pCtx->fBusy = false;
@@ -572 +526 @@
     }
 #endif
-    if (pTargets == NULL) {
+
+    if (paTargetFmtIdx == NULL)
+    {
         /* No data available */
         clipReportEmptyX11CB(pCtx);
         return;
     }
-    clipGetFormatsFromTargets(pCtx, pTargets, cTargets);
+
+    clipGetFormatsFromTargets(pCtx, paTargetFmtIdx, cTargets);
     clipReportFormatsToVBox(pCtx);
 }
@@ -588 +545 @@
  *        unit test.  So keep it simple, be paranoid and log everything.
  */
-static void clipConvertX11Targets(Widget widget, XtPointer pClientData,
+static void clipConvertX11Targets(Widget widget, XtPointer pSvcCtxData,
                                   Atom * /* selection */, Atom *atomType,
                                   XtPointer pValue, long unsigned int *pcLen,
                                   int *piFormat)
 {
-    RT_NOREF1(piFormat);
-    CLIPBACKEND *pCtx = reinterpret_cast<CLIPBACKEND *>(pClientData);
+    RT_NOREF(piFormat);
+
+    CLIPBACKEND *pCtx = reinterpret_cast<CLIPBACKEND *>(pSvcCtxData);
     Atom *pAtoms = (Atom *)pValue;
     unsigned i, j;
-    LogRel2(("%s: pValue=%p, *pcLen=%u, *atomType=%d%s\n", __FUNCTION__,
+
+    LogRel2(("Shared clipboard: pValue=%p, *pcLen=%u, *atomType=%d%s\n",
              pValue, *pcLen, *atomType,
              *atomType == XT_CONVERT_FAIL ? " (XT_CONVERT_FAIL)" : ""));
-    CLIPX11FORMAT *pFormats = NULL;
+
+    CLIPX11FORMATIDX *paFmtIdx = NULL;
+
     if (*pcLen && pValue && (*atomType != XT_CONVERT_FAIL /* time out */))
-        pFormats = (CLIPX11FORMAT *)RTMemAllocZ(*pcLen * sizeof(CLIPX11FORMAT));
+        paFmtIdx = (CLIPX11FORMATIDX *)RTMemAllocZ(*pcLen * sizeof(CLIPX11FORMATIDX));
+
 #if defined(DEBUG) && !defined(TESTCASE)
     if (pValue)
     {
         for (i = 0; i < *pcLen; ++i)
+        {
             if (pAtoms[i])
             {
                 char *pszName = XGetAtomName(XtDisplay(widget), pAtoms[i]);
-                LogRel2(("%s: found target %s\n", __FUNCTION__,
-                         pszName));
+                LogRel(("Shared clipboard: Found target %s\n", pszName));
                 XFree(pszName);
             }
             else
-                LogRel2(("%s: found empty target.\n", __FUNCTION__));
-    }
-#endif
-    if (pFormats)
+                LogRel(("Shared clipboard: Found empty target\n"));
+        }
+    }
+#endif
+
+    if (paFmtIdx)
     {
         for (i = 0; i < *pcLen; ++i)
@@ -624 +588 @@
             for (j = 0; j < RT_ELEMENTS(g_aFormats); ++j)
             {
-                Atom target = XInternAtom(XtDisplay(widget),
-                                          g_aFormats[j].pcszAtom, False);
+                Atom target = XInternAtom(XtDisplay(widget), g_aFormats[j].pcszAtom, False);
                 if (*(pAtoms + i) == target)
-                    pFormats[i] = j;
+                    paFmtIdx[i] = j;
             }
 #if defined(DEBUG) && !defined(TESTCASE)
-            LogRel2(("%s: reporting format %d (%s)\n", __FUNCTION__,
-                     pFormats[i], g_aFormats[pFormats[i]].pcszAtom));
+            LogRel(("Shared clipboard: Reporting format %d (%s)\n",
+                    paFmtIdx[i], g_aFormats[paFmtIdx[i]].pcszAtom));
 #endif
         }
     }
     else
-        LogRel2(("%s: reporting empty targets (none reported or allocation failure).\n",
-                 __FUNCTION__));
-    clipUpdateX11Targets(pCtx, pFormats, *pcLen);
-    RTMemFree(pFormats);
+        LogRel2(("Shared clipboard: Reporting empty targets (none reported or allocation failure)\n"));
+
+    clipUpdateX11Targets(pCtx, paFmtIdx, *pcLen);
+
+    RTMemFree(paFmtIdx);
     XtFree(reinterpret_cast<char *>(pValue));
 }
@@ -652 +616 @@
 static void clipQueryX11CBFormats(CLIPBACKEND *pCtx)
 {
-    LogRel2 (("%s: requesting the targets that the X11 clipboard offers\n",
-           __PRETTY_FUNCTION__));
+    LogRel2 (("Shared clipboard: Requesting the targets that the X11 clipboard offers\n"));
+
 #ifndef VBOX_AFTER_5_2
     if (pCtx->fBusy)
@@ -718 +682 @@
 static DECLCALLBACK(int) clipEventThread(RTTHREAD hThreadSelf, void *pvUser)
 {
-    RT_NOREF1(hThreadSelf);
+    RT_NOREF(hThreadSelf);
+
     LogRel(("Shared clipboard: Starting shared clipboard thread\n"));
 
@@ -725 +690 @@
     if (pCtx->fGrabClipboardOnStart)
         clipQueryX11CBFormats(pCtx);
+
     while (XtAppGetExitFlag(pCtx->appContext) == FALSE)
     {
@@ -730 +696 @@
         XtAppProcessEvent(pCtx->appContext, XtIMAll);
     }
+
     LogRel(("Shared clipboard: Shared clipboard thread terminated successfully\n"));
     return VINF_SUCCESS;
@@ -764 +731 @@
 static void clipStopEventThreadWorker(void *pUserData, void *)
 {
-
     CLIPBACKEND *pCtx = (CLIPBACKEND *)pUserData;
 
@@ -829 +795 @@
 #endif
 
-/** This is the callback which is scheduled when data is available on the
- * wakeup pipe.  It simply reads all data from the pipe. */
+/**
+ * This is the callback which is scheduled when data is available on the
+ * wakeup pipe.  It simply reads all data from the pipe.
+ */
 static void clipDrainWakeupPipe(XtPointer pUserData, int *, XtInputId *)
 {
@@ -836 +804 @@
     char acBuf[WAKE_UP_STRING_LEN];
 
-    LogRel2(("clipDrainWakeupPipe: called\n"));
+    LogRel2(("Shared clipboard: clipDrainWakeupPipe called\n"));
+
     while (read(pCtx->wakeupPipeRead, acBuf, sizeof(acBuf)) > 0) {}
 }
 
-/** X11 specific initialisation for the shared clipboard.
+/**
+ * X11 specific initialisation for the shared clipboard.
+ *
  * @note  X11 backend code.
  */
@@ -861 +832 @@
     if (NULL == pDisplay)
     {
-        LogRel(("Shared clipboard: Failed to connect to the X11 clipboard - the window system may not be running.\n"));
+        LogRel(("Shared clipboard: Failed to connect to the X11 clipboard - the window system may not be running\n"));
         rc = VERR_NOT_SUPPORTED;
     }
@@ -869 +840 @@
         rc = clipLoadXFixes(pDisplay, pCtx);
         if (RT_FAILURE(rc))
-           LogRel(("Shared clipboard: Failed to load the XFIXES extension.\n"));
+           LogRel(("Shared clipboard: Failed to load the XFIXES extension\n"));
     }
 #endif
@@ -880 +851 @@
         if (NULL == pCtx->widget)
         {
-            LogRel(("Shared clipboard: Failed to construct the X11 window for the shared clipboard manager.\n"));
+            LogRel(("Shared clipboard: Failed to construct the X11 window for the shared clipboard manager\n"));
             rc = VERR_NO_MEMORY;
         }
@@ -911 +882 @@
             rc = RTErrConvertFromErrno(errno);
         if (RT_FAILURE(rc))
-            LogRel(("Shared clipboard: Failed to setup the termination mechanism.\n"));
+            LogRel(("Shared clipboard: Failed to setup the termination mechanism\n"));
     }
     else
@@ -923 +894 @@
 
 /**
- * Construct the X11 backend of the shared clipboard.
+ * Constructs the X11 backend of the shared clipboard.
+ *
  * @note  X11 backend code
  */
@@ -937 +909 @@
          * This is important for VBoxHeadless.
          */
-        LogRelFunc(("X11 DISPLAY variable not set -- disabling shared clipboard\n"));
+        LogRel(("Shared clipboard: X11 DISPLAY variable not set -- disabling Shared Clipboard\n"));
         pCtx->fHaveX11 = false;
         return pCtx;
@@ -945 +917 @@
 
     LogRel(("Shared clipboard: Initializing X11 clipboard backend\n"));
+
     if (pCtx)
         pCtx->pFrontend = pFrontend;
@@ -951 +924 @@
 
 /**
- * Destruct the shared clipboard X11 backend.
+ * Destructs the shared clipboard X11 backend.
+ *
  * @note  X11 backend code
  */
@@ -965 +939 @@
 
 /**
- * Announce to the X11 backend that we are ready to start.
+ * Announces to the X11 backend that we are ready to start.
+ *
  * @param  grab  whether we should try to grab the shared clipboard at once
  */
@@ -971 +946 @@
 {
     int rc = VINF_SUCCESS;
-    LogRelFlowFunc(("\n"));
+
+    LogRel2(("Shared clipboard: Starting\n"));
+
     /*
      * Immediately return if we are not connected to the X server.
@@ -991 +968 @@
         if (RT_FAILURE(rc))
         {
-            LogRel(("Shared clipboard: Failed to start the shared clipboard thread.\n"));
+            LogRel(("Shared clipboard: Failed to start the shared clipboard thread, rc=%Rrc\n", rc));
             clipUninit(pCtx);
         }
@@ -1000 +977 @@
 
 /**
- * Shut down the shared clipboard X11 backend.
- * @note  X11 backend code
+ * Shuts down the shared clipboard X11 backend.
+ *
+ * @note  X11 backend code.
  * @note  Any requests from this object to get clipboard data from VBox
  *        *must* have completed or aborted before we are called, as
@@ -1017 +995 @@
         return VINF_SUCCESS;
 
-    LogRelFunc(("stopping the shared clipboard X11 backend\n"));
+    LogRel(("Shared clipboard: Stopping X11 backend\n"));
+
     /* Write to the "stop" pipe */
     clipQueueToEventThread(pCtx, clipStopEventThreadWorker, (XtPointer) pCtx);
@@ -1035 +1014 @@
         AssertRC(rcThread);
     else
-        LogRelFunc(("rc=%Rrc\n", rc));
+        LogRel(("Shared clipboard: Stopping X11 backend failed with rc=%Rrc\n", rc));
+
     clipUninit(pCtx);
-    LogRelFlowFunc(("returning %Rrc.\n", rc));
+
     RT_NOREF_PV(rcThread);
     return rc;
@@ -1045 +1025 @@
  * Satisfy a request from X11 for clipboard targets supported by VBox.
  *
- * @returns iprt status code
- * @param  atomTypeReturn The type of the data we are returning
+ * @returns IPRT status code.
+ * @param  atomTypeReturn The type of the data we are returning.
  * @param  pValReturn     A pointer to the data we are returning.  This
  *                        should be set to memory allocated by XtMalloc,
  *                        which will be freed later by the Xt toolkit.
- * @param  pcLenReturn    The length of the data we are returning
+ * @param  pcLenReturn    The length of the data we are returning.
  * @param  piFormatReturn The format (8bit, 16bit, 32bit) of the data we are
- *                        returning
+ *                        returning.
+ *
  * @note  X11 backend code, called by the XtOwnSelection callback.
  */
@@ -1060 +1041 @@
                                 int *piFormatReturn)
 {
-    Atom *atomTargets = (Atom *)XtMalloc(  (MAX_CLIP_X11_FORMATS + 3)
-                                         * sizeof(Atom));
+    Atom *atomTargets = (Atom *)XtMalloc((CLIPX11FORMATIDX_MAX + 3) * sizeof(Atom));
     unsigned cTargets = 0;
+
     LogRelFlowFunc (("called\n"));
-    CLIPX11FORMAT format = NIL_CLIPX11FORMAT;
+
+    CLIPX11FORMATIDX fmtIdx = CLIPX11FORMATIDX_NIL;
+
     do
     {
-        format = clipEnumX11Formats(pCtx->vboxFormats, format);
-        if (format != NIL_CLIPX11FORMAT)
-        {
-            atomTargets[cTargets] = clipAtomForX11Format(pCtx, format);
+        fmtIdx = clipEnumFmtIdxForVBoxFmt(pCtx->vboxFormats, fmtIdx);
+        if (fmtIdx != CLIPX11FORMATIDX_NIL)
+        {
+            atomTargets[cTargets] = clipGetAtomFromFmtIdx(pCtx, fmtIdx);
             ++cTargets;
         }
-    } while (format != NIL_CLIPX11FORMAT);
+    } while (fmtIdx != CLIPX11FORMATIDX_NIL);
+
     /* We always offer these */
-    atomTargets[cTargets] = clipGetAtom(pCtx, "TARGETS");
+    atomTargets[cTargets]     = clipGetAtom(pCtx, "TARGETS");
     atomTargets[cTargets + 1] = clipGetAtom(pCtx, "MULTIPLE");
     atomTargets[cTargets + 2] = clipGetAtom(pCtx, "TIMESTAMP");
+
     *atomTypeReturn = XA_ATOM;
     *pValReturn = (XtPointer)atomTargets;
     *pcLenReturn = cTargets + 3;
     *piFormatReturn = 32;
+
     return VINF_SUCCESS;
 }
 
-/** This is a wrapper around ClipRequestDataForX11 that will cache the
+/**
+ * This is a wrapper around ClipRequestDataForX11 that will cache the
  * data returned.
  */
-static int clipReadVBoxClipboard(CLIPBACKEND *pCtx, uint32_t u32Format,
+static int clipReadVBoxClipboard(CLIPBACKEND *pCtx, VBOXCLIPBOARDFORMAT vboxFormat,
                                  void **ppv, uint32_t *pcb)
 {
     int rc = VINF_SUCCESS;
-    LogRelFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx,
-                 u32Format, ppv, pcb));
-    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    LogRelFlowFunc(("pCtx=%p, vboxFormat=%02X, ppv=%p, pcb=%p\n", pCtx,
+                 vboxFormat, ppv, pcb));
+    if (vboxFormat == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
     {
         if (pCtx->pvUnicodeCache == NULL)
-            rc = ClipRequestDataForX11(pCtx->pFrontend, u32Format,
+            rc = ClipRequestDataForX11(pCtx->pFrontend, vboxFormat,
                                               &pCtx->pvUnicodeCache,
                                               &pCtx->cbUnicodeCache);
@@ -1109 +1096 @@
     }
     else
-        rc = ClipRequestDataForX11(pCtx->pFrontend, u32Format,
+        rc = ClipRequestDataForX11(pCtx->pFrontend, vboxFormat,
                                           ppv, pcb);
     LogRelFlowFunc(("returning %Rrc\n", rc));
@@ -1118 +1105 @@
 
 /**
- * Calculate a buffer size large enough to hold the source Windows format
- * text converted into Unix Utf8, including the null terminator
- * @returns iprt status code
- * @param  pwsz       the source text in UCS-2 with Windows EOLs
+ * Calculates a buffer size large enough to hold the source Windows format
+ * text converted into Unix Utf8, including the null terminator.
+ *
+ * @returns IPRT status code.
+ * @param  pwsz       the source text in UCS-2 with Windows EOLs.
  * @param  cwc        the size in USC-2 elements of the source text, with or
- *                    without the terminator
- * @param  pcbActual  where to store the buffer size needed
+ *                    without the terminator.
+ * @param  pcbActual  where to store the buffer size needed.
  */
 static int clipWinTxtBufSizeForUtf8(PRTUTF16 pwsz, size_t cwc,
@@ -1137 +1125 @@
 
 /**
- * Convert text from Windows format (UCS-2 with CRLF line endings) to standard
+ * Converts text from Windows format (UCS-2 with CRLF line endings) to standard
  * Utf-8.
  *
- * @returns iprt status code
- *
- * @param  pwszSrc    the text to be converted
- * @param  cbSrc      the length of @a pwszSrc in bytes
- * @param  pszBuf     where to write the converted string
- * @param  cbBuf      the size of the buffer pointed to by @a pszBuf
+ * @returns IPRT status code.
+ * @param  pwszSrc    the text to be converted.
+ * @param  cbSrc      the length of @a pwszSrc in bytes.
+ * @param  pszBuf     where to write the converted string.
+ * @param  cbBuf      the size of the buffer pointed to by @a pszBuf.
  * @param  pcbActual  where to store the size of the converted string.
  *                    optional.
@@ -1179 +1166 @@
     LogRelFlowFunc(("returning %Rrc\n", rc));
     if (RT_SUCCESS(rc))
-        LogRelFlowFunc (("converted string is %.*s. Returning.\n", cbDest,
+        LogRelFlowFunc (("converted string is %.*s. Returning\n", cbDest,
                       pszBuf));
     return rc;
@@ -1185 +1172 @@
 
 /**
- * Satisfy a request from X11 to convert the clipboard text to Utf-8.  We
+ * Satisfies a request from X11 to convert the clipboard text to Utf-8.  We
  * return null-terminated text, but can cope with non-null-terminated input.
  *
- * @returns iprt status code
+ * @returns IPRT status code.
  * @param  pDisplay        an X11 display structure, needed for conversions
- *                         performed by Xlib
- * @param  pv              the text to be converted (UCS-2 with Windows EOLs)
- * @param  cb              the length of the text in @cb in bytes
+ *                         performed by Xlib.
+ * @param  pv              the text to be converted (UCS-2 with Windows EOLs).
+ * @param  cb              the length of the text in @cb in bytes.
  * @param  atomTypeReturn  where to store the atom for the type of the data
- *                         we are returning
+ *                         we are returning.
  * @param  pValReturn      where to store the pointer to the data we are
  *                         returning.  This should be to memory allocated by
@@ -1200 +1187 @@
  *                         later.
  * @param  pcLenReturn     where to store the length of the data we are
- *                         returning
+ *                         returning.
  * @param  piFormatReturn  where to store the bit width (8, 16, 32) of the
- *                         data we are returning
+ *                         data we are returning.
  */
 static int clipWinTxtToUtf8ForX11CB(Display *pDisplay, PRTUTF16 pwszSrc,
@@ -1211 +1198 @@
                                     int *piFormatReturn)
 {
-    RT_NOREF2(pDisplay, pcLenReturn);
+    RT_NOREF(pDisplay, pcLenReturn);
 
     /* This may slightly overestimate the space needed. */
@@ -1235 +1222 @@
 
 /**
- * Satisfy a request from X11 to convert the clipboard HTML fragment to Utf-8.  We
+ * Satisfies a request from X11 to convert the clipboard HTML fragment to Utf-8.  We
  * return null-terminated text, but can cope with non-null-terminated input.
  *
- * @returns iprt status code
+ * @returns IPRT status code.
  * @param  pDisplay        an X11 display structure, needed for conversions
- *                         performed by Xlib
- * @param  pv              the text to be converted (UTF8 with Windows EOLs)
- * @param  cb              the length of the text in @cb in bytes
+ *                         performed by Xlib.
+ * @param  pv              the text to be converted (UTF8 with Windows EOLs).
+ * @param  cb              the length of the text in @cb in bytes.
  * @param  atomTypeReturn  where to store the atom for the type of the data
- *                         we are returning
+ *                         we are returning.
  * @param  pValReturn      where to store the pointer to the data we are
  *                         returning.  This should be to memory allocated by
@@ -1250 +1237 @@
  *                         later.
  * @param  pcLenReturn     where to store the length of the data we are
- *                         returning
+ *                         returning.
  * @param  piFormatReturn  where to store the bit width (8, 16, 32) of the
- *                         data we are returning
+ *                         data we are returning.
  */
 static int clipWinHTMLToUtf8ForX11CB(Display *pDisplay, const char *pszSrc,
@@ -1261 +1248 @@
                                     int *piFormatReturn)
 {
-    RT_NOREF2(pDisplay, pValReturn);
+    RT_NOREF(pDisplay, pValReturn);
 
     /* This may slightly overestimate the space needed. */
@@ -1280 +1267 @@
 }
 
-
 /**
  * Does this atom correspond to one of the two selection types we support?
+ *
  * @param  widget   a valid Xt widget
  * @param  selType  the atom in question
@@ -1293 +1280 @@
 
 /**
- * Remove a trailing nul character from a string by adjusting the string
+ * Removes a trailing nul character from a string by adjusting the string
  * length.  Some X11 applications don't like zero-terminated text...
+ *
  * @param  pText   the text in question
  * @param  pcText  the length of the text, adjusted on return
@@ -1300 +1288 @@
  */
 static void clipTrimTrailingNul(XtPointer pText, unsigned long *pcText,
-                                CLIPFORMAT format)
+                                CLIPX11FORMATTARGET format)
 {
     AssertPtrReturnVoid(pText);
     AssertPtrReturnVoid(pcText);
-    AssertReturnVoid((format == UTF8) || (format == TEXT) || (format == HTML));
+    AssertReturnVoid(   (format == CLIPX11FORMATTARGET_UTF8)
+                     || (format == CLIPX11FORMATTARGET_TEXT)
+                     || (format == CLIPX11FORMATTARGET_HTML));
     if (((char *)pText)[*pcText - 1] == '\0')
        --(*pcText);
@@ -1316 +1306 @@
 {
     int rc = VINF_SUCCESS;
-    CLIPX11FORMAT x11Format = clipFindX11FormatByAtom(pCtx, *atomTarget);
-    CLIPFORMAT format = clipRealFormatForX11Format(x11Format);
-    if (   ((format == UTF8) || (format == TEXT))
+
+    CLIPX11FORMATIDX    fmtIdx = clipGetFmtIdxFromAtom(pCtx, *atomTarget);
+    CLIPX11FORMATTARGET fmtTgt = clipGetTargetFmtFromFmtIdx(fmtIdx);
+
+    if (   ((fmtTgt == CLIPX11FORMATTARGET_UTF8) || (fmtTgt == CLIPX11FORMATTARGET_TEXT))
         && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT))
     {
         void *pv = NULL;
         uint32_t cb = 0;
-        rc = clipReadVBoxClipboard(pCtx,
-                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
-                                   &pv, &cb);
+        rc = clipReadVBoxClipboard(pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
             rc = VERR_NO_DATA;
-        if (RT_SUCCESS(rc) && ((format == UTF8) || (format == TEXT)))
+
+        if (RT_SUCCESS(rc) && (   (fmtTgt == CLIPX11FORMATTARGET_UTF8)
+                               || (fmtTgt == CLIPX11FORMATTARGET_TEXT)))
+        {
             rc = clipWinTxtToUtf8ForX11CB(XtDisplay(pCtx->widget),
                                           (PRTUTF16)pv, cb, atomTarget,
                                           atomTypeReturn, pValReturn,
                                           pcLenReturn, piFormatReturn);
+        }
+
         if (RT_SUCCESS(rc))
-            clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, format);
+            clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, fmtTgt);
+
         RTMemFree(pv);
     }
-    else if (   (format == BMP)
+    else if (   (fmtTgt == CLIPX11FORMATTARGET_BMP)
              && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP))
     {
         void *pv = NULL;
         uint32_t cb = 0;
-        rc = clipReadVBoxClipboard(pCtx,
-                                   VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
-                                   &pv, &cb);
+        rc = clipReadVBoxClipboard(pCtx, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
             rc = VERR_NO_DATA;
-        if (RT_SUCCESS(rc) && (format == BMP))
-        {
-            /* Create a full BMP from it */
+
+        if (RT_SUCCESS(rc) && (fmtTgt == CLIPX11FORMATTARGET_BMP))
+        {
+            /* Create a full BMP from it. */
             rc = vboxClipboardDibToBmp(pv, cb, (void **)pValReturn,
                                        (size_t *)pcLenReturn);
@@ -1361 +1356 @@
             *piFormatReturn = 8;
         }
+
         RTMemFree(pv);
     }
-    else if ( (format == HTML)
-            && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_HTML))
+    else if (   (fmtTgt == CLIPX11FORMATTARGET_HTML)
+             && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_HTML))
     {
         void *pv = NULL;
         uint32_t cb = 0;
-        rc = clipReadVBoxClipboard(pCtx,
-                                   VBOX_SHARED_CLIPBOARD_FMT_HTML,
-                                   &pv, &cb);
+        rc = clipReadVBoxClipboard(pCtx, VBOX_SHARED_CLIPBOARD_FMT_HTML, &pv, &cb);
         if (RT_SUCCESS(rc) && (cb == 0))
             rc = VERR_NO_DATA;
+
         if (RT_SUCCESS(rc))
         {
@@ -1384 +1379 @@
             */
             rc = clipWinHTMLToUtf8ForX11CB(XtDisplay(pCtx->widget),
-                (const char*)pv, cb, atomTarget,
-                atomTypeReturn, pValReturn,
-                pcLenReturn, piFormatReturn);
-
-
+                                           (const char*)pv, cb, atomTarget,
+                                           atomTypeReturn, pValReturn,
+                                           pcLenReturn, piFormatReturn);
             if (RT_SUCCESS(rc))
-                clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, format);
+                clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, fmtTgt);
+
             RTMemFree(pv);
         }
     }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    else if (   (fmtTgt == CLIPX11FORMATTARGET_URI_LIST)
+             && (pCtx->vboxFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST))
+    {
+        /** Nothing to do here yet. */
+    }
+#endif
     else
         rc = VERR_NOT_SUPPORTED;
@@ -1400 +1401 @@
 
 /**
- * Return VBox's clipboard data for an X11 client.
- * @note  X11 backend code, callback for XtOwnSelection
+ * Returns VBox's clipboard data for an X11 client.
+ *
+ * @note  X11 backend code, callback for XtOwnSelection.
  */
 static Boolean clipXtConvertSelectionProc(Widget widget, Atom *atomSelection,
@@ -1434 +1436 @@
     CLIPBACKEND *pCtx;
     /** Formats supported by VBox */
-    uint32_t formats;
+    VBOXCLIPBOARDFORMATS vboxFormats;
 } CLIPNEWVBOXFORMATS;
 
@@ -1448 +1450 @@
 
 /**
- * Take possession of the X11 clipboard (and middle-button selection).
- */
-static void clipGrabX11CB(CLIPBACKEND *pCtx, uint32_t u32Formats)
+ * Takes possession of the X11 clipboard (and middle-button selection).
+ */
+static void clipGrabX11CB(CLIPBACKEND *pCtx, VBOXCLIPBOARDFORMATS vboxFormats)
 {
     if (XtOwnSelection(pCtx->widget, clipGetAtom(pCtx, "CLIPBOARD"),
                        CurrentTime, clipXtConvertSelectionProc, NULL, 0))
     {
-        pCtx->vboxFormats = u32Formats;
+        pCtx->vboxFormats = vboxFormats;
+
         /* Grab the middle-button paste selection too. */
         XtOwnSelection(pCtx->widget, clipGetAtom(pCtx, "PRIMARY"),
@@ -1475 +1478 @@
  * Worker function for ClipAnnounceFormatToX11 which runs on the
  * event thread.
+ *
  * @param pUserData  Pointer to a CLIPNEWVBOXFORMATS structure containing
  *                   information about the VBox formats available and the
  *                   clipboard context data.  Must be freed by the worker.
  */
-static void clipNewVBoxFormatsWorker(void *pUserData,
-                                     void * /* interval */)
+static void clipNewVBoxFormatsWorker(void *pUserData, void * /* interval */)
 {
     CLIPNEWVBOXFORMATS *pFormats = (CLIPNEWVBOXFORMATS *)pUserData;
+
     CLIPBACKEND *pCtx = pFormats->pCtx;
-    uint32_t u32Formats = pFormats->formats;
+    VBOXCLIPBOARDFORMAT vboxFormat = pFormats->vboxFormats;
+
     RTMemFree(pFormats);
-    LogRelFlowFunc (("u32Formats=%d\n", u32Formats));
+
+    LogRelFlowFunc (("vboxFormat=%RU32\n", vboxFormat));
+
     clipInvalidateVBoxCBCache(pCtx);
-    clipGrabX11CB(pCtx, u32Formats);
+    clipGrabX11CB(pCtx, vboxFormat);
     clipResetX11Formats(pCtx);
+
     LogRelFlowFunc(("returning\n"));
 }
@@ -1496 +1504 @@
  * VBox is taking possession of the shared clipboard.
  *
- * @param u32Formats Clipboard formats that VBox is offering
+ * @param vboxFormats Clipboard formats that VBox is offering
  * @note  X11 backend code
  */
-void ClipAnnounceFormatToX11(CLIPBACKEND *pCtx,
-                                        uint32_t u32Formats)
+int ClipAnnounceFormatToX11(CLIPBACKEND *pCtx, VBOXCLIPBOARDFORMATS vboxFormats)
 {
     /*
@@ -1506 +1513 @@
      */
     if (!pCtx->fHaveX11)
-        return;
+        return VINF_SUCCESS;
+
+    int rc;
+
     /* This must be freed by the worker callback */
     CLIPNEWVBOXFORMATS *pFormats =
         (CLIPNEWVBOXFORMATS *) RTMemAlloc(sizeof(CLIPNEWVBOXFORMATS));
+
     if (pFormats != NULL)  /* if it is we will soon have other problems */
     {
         pFormats->pCtx = pCtx;
-        pFormats->formats = u32Formats;
+        pFormats->vboxFormats = vboxFormats;
         clipQueueToEventThread(pCtx, clipNewVBoxFormatsWorker,
                                (XtPointer) pFormats);
-    }
-}
-
-/**
- * Massage generic Utf16 with CR end-of-lines into the format Windows expects
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+/**
+ * Massages generic Utf16 with CR end-of-lines into the format Windows expects
  * and return the result in a RTMemAlloc allocated buffer.
- * @returns  IPRT status code
- * @param  pwcSrc     The source Utf16
+ *
+ * @returns IPRT status code.
+ * @param  pwcSrc     The source Utf16.
  * @param  cwcSrc     The number of 16bit elements in @a pwcSrc, not counting
- *                    the terminating zero
- * @param  ppwszDest  Where to store the buffer address
+ *                    the terminating zero.
+ * @param  ppwszDest  Where to store the buffer address.
  * @param  pcbDest    On success, where to store the number of bytes written.
- *                    Undefined otherwise.  Optional
+ *                    Undefined otherwise.  Optional.
  */
 static int clipUtf16ToWinTxt(RTUTF16 *pwcSrc, size_t cwcSrc,
@@ -1567 +1584 @@
 
 /**
- * Convert Utf-8 text with CR end-of-lines into Utf-16 as Windows expects it
+ * Converts Utf-8 text with CR end-of-lines into Utf-16 as Windows expects it
  * and return the result in a RTMemAlloc allocated buffer.
- * @returns  IPRT status code
- * @param  pcSrc      The source Utf-8
+ *
+ * @returns  IPRT status code.
+ * @param  pcSrc      The source Utf-8.
  * @param  cbSrc      The size of the source in bytes, not counting the
- *                    terminating zero
- * @param  ppwszDest  Where to store the buffer address
+ *                    terminating zero.
+ * @param  ppwszDest  Where to store the buffer address.
  * @param  pcbDest    On success, where to store the number of bytes written.
- *                    Undefined otherwise.  Optional
+ *                    Undefined otherwise.  Optional.
  */
 static int clipUtf8ToWinTxt(const char *pcSrc, unsigned cbSrc,
@@ -1600 +1618 @@
 
 /**
- * Convert Latin-1 text with CR end-of-lines into Utf-16 as Windows expects
+ * Converts Latin-1 text with CR end-of-lines into Utf-16 as Windows expects
  * it and return the result in a RTMemAlloc allocated buffer.
- * @returns  IPRT status code
- * @param  pcSrc      The source text
+ *
+ * @returns IPRT status code.
+ * @param  pcSrc      The source text.
  * @param  cbSrc      The size of the source in bytes, not counting the
- *                    terminating zero
- * @param  ppwszDest  Where to store the buffer address
+ *                    terminating zero.
+ * @param  ppwszDest  Where to store the buffer address.
  * @param  pcbDest    On success, where to store the number of bytes written.
- *                    Undefined otherwise.  Optional
+ *                    Undefined otherwise.  Optional.
  */
 static int clipLatin1ToWinTxt(char *pcSrc, unsigned cbSrc,
@@ -1662 +1681 @@
 
 /**
-* Convert Utf16 text into UTF8 as Windows expects
-* it and return the result in a RTMemAlloc allocated buffer.
-* @returns  IPRT status code
-* @param  pcSrc      The source text
-* @param  cbSrc      The size of the source in bytes, not counting the
-*                    terminating zero
-* @param  ppwszDest  Where to store the buffer address
-* @param  pcbDest    On success, where to store the number of bytes written.
-*                    Undefined otherwise.  Optional
-*/
+ * Converts Utf16 text into UTF8 as Windows expects
+ * it and return the result in a RTMemAlloc allocated buffer.
+ *
+ * @returns  IPRT status code.
+ * @param  pcSrc      The source text.
+ * @param  cbSrc      The size of the source in bytes, not counting the
+ *                    terminating zero.
+ * @param  ppwszDest  Where to store the buffer address.
+ * @param  pcbDest    On success, where to store the number of bytes written.
+ *                    Undefined otherwise.  Optional.
+ */
 int  clipUTF16ToWinHTML(RTUTF16 *pwcBuf, size_t cb, char **ppszOut, uint32_t *pcOut)
 {
@@ -1732 +1752 @@
 }
 
-
-
 /** A structure containing information about where to store a request
  * for the X11 clipboard contents. */
 struct _CLIPREADX11CBREQ
 {
+    /** @todo r=andy Why all those different CLIPX11FORMAT members? Shouldn't be one enough? */
+
     /** The format VBox would like the data in */
-    uint32_t mFormat;
+    VBOXCLIPBOARDFORMAT mFormat;
     /** The text format we requested from X11 if we requested text */
-    CLIPX11FORMAT mTextFormat;
+    CLIPX11FORMATIDX mTextFmtIdx;
     /** The bitmap format we requested from X11 if we requested bitmap */
-    CLIPX11FORMAT mBitmapFormat;
+    CLIPX11FORMATIDX mBitmapFmtIdx;
     /** The HTML format we requested from X11 if we requested HTML */
-    CLIPX11FORMAT mHtmlFormat;
+    CLIPX11FORMATIDX mHtmlFmtIdx;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    /** The URI list format we requested from X11 if we requested URI list */
+    CLIPX11FORMATIDX mURIListFmtIdx;
+#endif
     /** The clipboard context this request is associated with */
     CLIPBACKEND *mCtx;
@@ -1755 +1779 @@
 
 /**
- * Convert the data obtained from the X11 clipboard to the required format,
+ * Converts the data obtained from the X11 clipboard to the required format,
  * place it in the buffer supplied and signal that data has arrived.
  * Convert the text obtained UTF-16LE with Windows EOLs.
  * Convert full BMP data to DIB format.
+ *
  * @note  X11 backend code, callback for XtGetSelectionValue, for use when
  *        the X11 clipboard contains a format we understand.
  */
-static void clipConvertX11CB(void *pClientData, void *pvSrc, unsigned cbSrc)
-{
-    CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *) pClientData;
+static void clipConvertX11CB(void *pSvcCtxData, void *pvSrc, unsigned cbSrc)
+{
+    CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *) pSvcCtxData;
     LogRelFlowFunc(("pReq->mFormat=%02X, pReq->mTextFormat=%u, "
                 "pReq->mBitmapFormat=%u, pReq->mHtmlFormat=%u, pReq->mCtx=%p\n",
-                 pReq->mFormat, pReq->mTextFormat, pReq->mBitmapFormat,
-                 pReq->mHtmlFormat, pReq->mCtx));
+                 pReq->mFormat, pReq->mTextFmtIdx, pReq->mBitmapFmtIdx,
+                 pReq->mHtmlFmtIdx, pReq->mCtx));
     AssertPtr(pReq->mCtx);
     Assert(pReq->mFormat != 0);  /* sanity */
@@ -1789 +1814 @@
     {
         /* In which format is the clipboard data? */
-        switch (clipRealFormatForX11Format(pReq->mTextFormat))
-        {
-            case UTF8:
-            case TEXT:
+        switch (clipGetTargetFmtFromFmtIdx(pReq->mTextFmtIdx))
+        {
+            case CLIPX11FORMATTARGET_UTF8:
+            case CLIPX11FORMATTARGET_TEXT:
             {
                 /* If we are given broken Utf-8, we treat it as Latin1.  Is
@@ -1812 +1837 @@
     {
         /* In which format is the clipboard data? */
-        switch (clipRealFormatForX11Format(pReq->mBitmapFormat))
-        {
-            case BMP:
+        switch (clipGetTargetFmtFromFmtIdx(pReq->mBitmapFmtIdx))
+        {
+            case CLIPX11FORMATTARGET_BMP:
             {
                 const void *pDib;
@@ -1840 +1865 @@
     {
         /* In which format is the clipboard data? */
-        switch (clipRealFormatForX11Format(pReq->mHtmlFormat))
-        {
-            case HTML:
+        switch (clipGetTargetFmtFromFmtIdx(pReq->mHtmlFmtIdx))
+        {
+            case CLIPX11FORMATTARGET_HTML:
             {
                 /* The common VBox HTML encoding will be - Utf8
@@ -1889 +1914 @@
         }
     }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+    {
+        // @todo
+    }
+#endif
     else
         rc = VERR_NOT_IMPLEMENTED;
@@ -1900 +1931 @@
 #ifndef TESTCASE
 /**
- * Convert the data obtained from the X11 clipboard to the required format,
+ * Converts the data obtained from the X11 clipboard to the required format,
  * place it in the buffer supplied and signal that data has arrived.
  * Convert the text obtained UTF-16LE with Windows EOLs.
  * Convert full BMP data to DIB format.
+ *
  * @note  X11 backend code, callback for XtGetSelectionValue, for use when
  *        the X11 clipboard contains a format we understand.
  */
-static void cbConvertX11CB(Widget widget, XtPointer pClientData,
+static void cbConvertX11CB(Widget widget, XtPointer pSvcCtxData,
                            Atom * /* selection */, Atom *atomType,
                            XtPointer pvSrc, long unsigned int *pcLen,
                            int *piFormat)
 {
-    RT_NOREF1(widget);
+    RT_NOREF(widget);
     if (*atomType == XT_CONVERT_FAIL) /* Xt timeout */
-        clipConvertX11CB(pClientData, NULL, 0);
+        clipConvertX11CB(pSvcCtxData, NULL, 0);
     else
-        clipConvertX11CB(pClientData, pvSrc, (*pcLen) * (*piFormat) / 8);
+        clipConvertX11CB(pSvcCtxData, pvSrc, (*pcLen) * (*piFormat) / 8);
 
     XtFree((char *)pvSrc);
@@ -1923 +1955 @@
 
 #ifdef TESTCASE
-static void testRequestData(CLIPBACKEND* pCtx, CLIPX11FORMAT target,
+static void testRequestData(CLIPBACKEND* pCtx, CLIPX11FORMATTARGET target,
                             void *closure);
 #endif
 
-static void getSelectionValue(CLIPBACKEND *pCtx, CLIPX11FORMAT format,
+static void getSelectionValue(CLIPBACKEND *pCtx, CLIPX11FORMATIDX format,
                               CLIPREADX11CBREQ *pReq)
 {
 #ifndef TESTCASE
     XtGetSelectionValue(pCtx->widget, clipGetAtom(pCtx, "CLIPBOARD"),
-                        clipAtomForX11Format(pCtx, format),
+                        clipGetAtomFromFmtIdx(pCtx, format),
                         cbConvertX11CB,
                         reinterpret_cast<XtPointer>(pReq),
@@ -1943 +1975 @@
 /** Worker function for ClipRequestDataFromX11 which runs on the event
  * thread. */
-static void vboxClipboardReadX11Worker(void *pUserData,
-                                       void * /* interval */)
+static void vboxClipboardReadX11Worker(void *pUserData, void * /* interval */)
 {
     CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pUserData;
@@ -1955 +1986 @@
     pCtx->fBusy = true;
     if (fBusy)
+    {
         /* If the clipboard is busy just fend off the request. */
         rc = VERR_TRY_AGAIN;
+    }
     else
 #endif
@@ -1964 +1997 @@
          * VBox wants to read data in the given format.
          */
-        pReq->mTextFormat = pCtx->X11TextFormat;
-        if (pReq->mTextFormat == INVALID)
+        pReq->mTextFmtIdx = pCtx->X11TextFmtIdx;
+        if (pReq->mTextFmtIdx == CLIPX11FORMATIDX_NIL)
+        {
             /* VBox thinks we have data and we don't */
             rc = VERR_NO_DATA;
+        }
+        else
+        {
+            /* Send out a request for the data to the current clipboard owner */
+            getSelectionValue(pCtx, pCtx->X11TextFmtIdx, pReq);
+        }
+    }
+    else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    {
+        pReq->mBitmapFmtIdx = pCtx->X11BitmapFmtIdx;
+        if (pReq->mBitmapFmtIdx == CLIPX11FORMATIDX_NIL)
+        {
+            /* VBox thinks we have data and we don't */
+            rc = VERR_NO_DATA;
+        }
+        else
+        {
+            /* Send out a request for the data to the current clipboard
+             * owner */
+            getSelectionValue(pCtx, pCtx->X11BitmapFmtIdx, pReq);
+        }
+    }
+    else if(pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
+    {
+        /* Send out a request for the data to the current clipboard owner */
+        pReq->mHtmlFmtIdx = pCtx->X11HTMLFmtIdx;
+        if(pReq->mHtmlFmtIdx == CLIPX11FORMATIDX_NIL)
+        {
+             /* VBox thinks we have data and we don't */
+            rc = VERR_NO_DATA;
+        }
         else
             /* Send out a request for the data to the current clipboard
              * owner */
-            getSelectionValue(pCtx, pCtx->X11TextFormat, pReq);
-    }
-    else if (pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
-    {
-        pReq->mBitmapFormat = pCtx->X11BitmapFormat;
-        if (pReq->mBitmapFormat == INVALID)
-            /* VBox thinks we have data and we don't */
-            rc = VERR_NO_DATA;
-        else
-            /* Send out a request for the data to the current clipboard
-             * owner */
-            getSelectionValue(pCtx, pCtx->X11BitmapFormat, pReq);
-    }
-    else if(pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
-    {
-        /* Send out a request for the data to the current clipboard
-             * owner */
-        pReq->mHtmlFormat = pCtx->X11HTMLFormat;
-        if(pReq->mHtmlFormat == INVALID)
+            getSelectionValue(pCtx, pCtx->X11HTMLFmtIdx, pReq);
+    }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    else if(pReq->mFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+    {
+        /* Send out a request for the data to the current clipboard owner */
+        pReq->mURIListFmtIdx = pCtx->X11URListFmtIdx;
+        if(pReq->mURIListFmtIdx == CLIPX11FORMATIDX_NIL)
+        {
                     /* VBox thinks we have data and we don't */
             rc = VERR_NO_DATA;
+        }
         else
-            /* Send out a request for the data to the current clipboard
-             * owner */
-            getSelectionValue(pCtx, pCtx->X11HTMLFormat, pReq);
-    }
+        {
+            /* Send out a request for the data to the current clipboard owner */
+            getSelectionValue(pCtx, pCtx->X11HTMLFmtIdx, pReq);
+        }
+    }
+#endif
     else
     {
@@ -2004 +2062 @@
 #endif
     }
+
     if (RT_FAILURE(rc))
     {
@@ -2012 +2071 @@
         RTMemFree(pReq);
     }
+
     LogRelFlowFunc(("status %Rrc\n", rc));
 }
@@ -2018 +2078 @@
  * Called when VBox wants to read the X11 clipboard.
  *
- * @returns iprt status code
- * @param  pCtx      Context data for the clipboard backend
- * @param  u32Format The format that the VBox would like to receive the data
- *                   in
- * @param  pv        Where to write the data to
- * @param  cb        The size of the buffer to write the data to
- * @param  pcbActual Where to write the actual size of the written data
- * @note   We allocate a request structure which must be freed by the worker
- */
-int ClipRequestDataFromX11(CLIPBACKEND *pCtx, uint32_t u32Format,
+ * @returns IPRT status code.
+ * @param  pCtx      Context data for the clipboard backend.
+ * @param  vboxFormat The format that the VBox would like to receive the data in.
+ * @param  pv        Where to write the data to.
+ * @param  cb        The size of the buffer to write the data to.
+ * @param  pcbActual Where to write the actual size of the written data.
+ *
+ * @note   We allocate a request structure which must be freed by the worker.
+ */
+int ClipRequestDataFromX11(CLIPBACKEND *pCtx, VBOXCLIPBOARDFORMAT vboxFormat,
                            CLIPREADCBREQ *pReq)
 {
@@ -2042 +2102 @@
     else
     {
-        pX11Req->mFormat = u32Format;
+        pX11Req->mFormat = vboxFormat;
         pX11Req->mCtx = pCtx;
         pX11Req->mReq = pReq;
@@ -2116 +2176 @@
 
 /* Return the data in the simulated VBox clipboard. */
-int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
-{
-    RT_NOREF2(pCtx, u32Format);
+int ClipRequestDataForX11(VBOXCLIPBOARDCONTEXT *pCtx, VBOXCLIPBOARDFORMAT vboxFormat, void **ppv, uint32_t *pcb)
+{
+    RT_NOREF(pCtx, vboxFormat);
     *pcb = g_vboxDatacb;
     if (g_vboxDatapv != NULL)
@@ -2131 +2191 @@
 
 Display *XtDisplay(Widget w)
-{ NOREF(w); return (Display *) 0xffff; }
-
-void XtAppSetExitFlag(XtAppContext app_context) { NOREF(app_context); }
-
-void XtDestroyWidget(Widget w) { NOREF(w); }
+{ RT_NOREF(w); return (Display *) 0xffff; }
+
+void XtAppSetExitFlag(XtAppContext app_context) { RT_NOREF(app_context); }
+
+void XtDestroyWidget(Widget w) { RT_NOREF(w); }
 
 XtAppContext XtCreateApplicationContext(void) { return (XtAppContext)0xffff; }
 
-void XtDestroyApplicationContext(XtAppContext app_context) { NOREF(app_context); }
+void XtDestroyApplicationContext(XtAppContext app_context) { RT_NOREF(app_context); }
 
 void XtToolkitInitialize(void) {}
@@ -2163 +2223 @@
 }
 
-void XtSetMappedWhenManaged(Widget widget, _XtBoolean mapped_when_managed) { RT_NOREF2(widget, mapped_when_managed); }
-
-void XtRealizeWidget(Widget widget) { NOREF(widget); }
+void XtSetMappedWhenManaged(Widget widget, _XtBoolean mapped_when_managed) { RT_NOREF(widget, mapped_when_managed); }
+
+void XtRealizeWidget(Widget widget) { RT_NOREF(widget); }
 
 XtInputId XtAppAddInput(XtAppContext app_context, int source, XtPointer condition, XtInputCallbackProc proc, XtPointer closure)
@@ -2212 +2272 @@
 void testRequestData(CLIPBACKEND *pCtx, CLIPX11FORMAT target, void *closure)
 {
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     unsigned long count = 0;
     int format = 0;
@@ -2239 +2299 @@
 void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
 {
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     g_fX11Formats = u32Formats;
 }
@@ -2268 +2328 @@
                        XtSelectionDoneProc done)
 {
-    RT_NOREF2(widget, time);
+    RT_NOREF(widget, time);
     if (selection != XInternAtom(NULL, "CLIPBOARD", 0))
         return True;  /* We don't really care about this. */
@@ -2319 +2379 @@
 {
     Atom clipAtom = XInternAtom(NULL, "CLIPBOARD", 0);
-    g_selTargets[0] = clipFindX11FormatByAtomText(pcszTarget);
+    g_selTargets[0] = clipGetFmtIdxFromAtomText(pcszTarget);
     g_cTargets = 1;
     g_selType = type;
@@ -2345 +2405 @@
 char *XGetAtomName(Display *display, Atom atom)
 {
-    RT_NOREF1(display);
+    RT_NOREF(display);
     AssertReturn((unsigned)atom < RT_ELEMENTS(g_aFormats) + 1, NULL);
     const char *pcszName = NULL;
@@ -2387 +2447 @@
 void ClipCompleteDataRequestFromX11(VBOXCLIPBOARDCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
 {
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     if (cb <= MAX_BUF_SIZE)
     {
@@ -2540 +2600 @@
 static void testStringFromVBox(RTTEST hTest, CLIPBACKEND *pCtx, const char *pcszTarget, Atom typeExp,  const char *valueExp)
 {
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     bool retval = false;
     Atom type;
@@ -2581 +2641 @@
 static void testStringFromVBoxFailed(RTTEST hTest, CLIPBACKEND *pCtx, const char *pcszTarget)
 {
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     Atom type;
     XtPointer value = NULL;
@@ -2596 +2656 @@
 static void testNoSelectionOwnership(CLIPBACKEND *pCtx, const char *pcszTestCtx)
 {
-    RT_NOREF1(pCtx);
+    RT_NOREF(pCtx);
     RTTESTI_CHECK_MSG(!g_ownsSel, ("context: %s\n", pcszTestCtx));
 }
@@ -2622 +2682 @@
         clipSendTargetUpdate(pCtx);
         if (clipQueryFormats() == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
-            RTTestFailed(hTest, "Failed to report targets after bad host request.\n");
+            RTTestFailed(hTest, "Failed to report targets after bad host request\n");
     }
 }
@@ -2889 +2949 @@
 void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
 {
-    RT_NOREF2(pCtx, u32Formats);
+    RT_NOREF(pCtx, u32Formats);
 }
 

trunk/src/VBox/HostServices/SharedClipboard/VBoxClipboard.h

@@ -49 +49 @@
     struct {
         VBOXHGCMCALLHANDLE callHandle;
-        VBOXHGCMSVCPARM *paParms;
+        VBOXHGCMSVCPARM   *paParms;
     } async;
 
     struct {
         VBOXHGCMCALLHANDLE callHandle;
-        VBOXHGCMSVCPARM *paParms;
+        VBOXHGCMSVCPARM   *paParms;
     } asyncRead;
 

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

@@ -507 +507 @@
 }
 
-void ClipAnnounceFormatToX11(CLIPBACKEND *pBackend, uint32_t u32Formats)
-{
-    pBackend->formats = u32Formats;
-}
-
-extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, uint32_t u32Format,
+void ClipAnnounceFormatToX11(CLIPBACKEND *pBackend, VBOXCLIPBOARDFORMATS vboxFormats)
+{
+    pBackend->formats = vboxFormats;
+}
+
+extern int ClipRequestDataFromX11(CLIPBACKEND *pBackend, VBOXCLIPBOARDFORMAT vboxFormat,
                                   CLIPREADCBREQ *pReq)
 {
-    pBackend->readData.format = u32Format;
+    pBackend->readData.format = vboxFormat;
     pBackend->readData.pReq = pReq;
     return pBackend->readData.rc;

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

@@ -513 +513 @@
                 uint32_t u32Formats;
 
-                rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Formats);
+                rc = VBoxHGCMParmUInt32Get(&paParms[0], &u32Formats);
 
                 if (RT_SUCCESS (rc))
@@ -562 +562 @@
                 uint32_t cb;
 
-                rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Format);
+                rc = VBoxHGCMParmUInt32Get(&paParms[0], &u32Format);
 
                 if (RT_SUCCESS (rc))
                 {
-                    rc = VBoxHGCMParmPtrGet (&paParms[1], &pv, &cb);
+                    rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb);
 
                     if (RT_SUCCESS (rc))
@@ -629 +629 @@
                         else if (RT_SUCCESS (rc))
                         {
-                            VBoxHGCMParmUInt32Set (&paParms[2], cbActual);
+                            VBoxHGCMParmUInt32Set(&paParms[2], cbActual);
                         }
                     }
@@ -657 +657 @@
                 uint32_t u32Format;
 
-                rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Format);
+                rc = VBoxHGCMParmUInt32Get(&paParms[0], &u32Format);
 
                 if (RT_SUCCESS (rc))
                 {
-                    rc = VBoxHGCMParmPtrGet (&paParms[1], &pv, &cb);
+                    rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb);
 
                     if (RT_SUCCESS (rc))