Changeset 22181 in vbox for trunk/src/VBox/GuestHost/SharedClipboard

Timestamp:

Aug 11, 2009 4:41:38 PM (16 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

50961

Message:

GuestHost/SharedClipboard: use the XFIXES notification extension in the X11 shared clipboard instead of polling

File:

• trunk/src/VBox/GuestHost/SharedClipboard/x11-clipboard.cpp (modified) (29 diffs)

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

@@ -21 +21 @@
  */
 
-/* Note: to automatically run regression tests on the shared clipboard, set
- * the make variable VBOX_RUN_X11_CLIPBOARD_TEST=1 while building.  If you
- * often make changes to the clipboard code, setting this variable in
- * LocalConfig.kmk will cause the tests to be run every time the code is
+/* Note: to automatically run regression tests on the shared clipboard,
+ * execute the tstClipboardX11 testcase.  If you often make changes to the
+ * clipboard code, adding the line
+ *   OTHERS += $(PATH_tstClipboardX11)/tstClipboardX11.run
+ * to LocalConfig.kmk will cause the tests to be run every time the code is
  * changed. */
 
@@ -31 +32 @@
 #include <errno.h>
 
+#include <dlfcn.h>
+#include <fcntl.h>
 #include <unistd.h>
 
@@ -44 +47 @@
 #include <X11/StringDefs.h>
 
+#include <iprt/types.h>
 #include <iprt/env.h>
 #include <iprt/mem.h>
@@ -164 +168 @@
     Widget widget;
 
-    /** Does VBox currently own the clipboard?  If so, we don't need to poll
-     * X11 for supported formats. */
+    /** Does VBox currently own the clipboard? */
     bool fOwnsClipboard;
+    /** Should we try to grab the clipboard on startup? */
+    bool fGrabClipboardOnStart;
 
     /** The best text format X11 has to offer, as an index into the formats
@@ -191 +196 @@
     /** The reader end of the pipe */
     int wakeupPipeRead;
+    /** A pointer to the XFixesSelectSelectionInput function */
+    void (*fixesSelectInput)(Display *, Window, Atom, unsigned long);
+    /** The first XFixes event number */
+    int fixesEventBase;
 };
 
@@ -280 +289 @@
 }
 
-static void clipQueueToEventThread(XtAppContext app_context,
+static void clipQueueToEventThread(CLIPBACKEND *pCtx,
                                    XtTimerCallbackProc proc,
                                    XtPointer client_data);
+
+/** String written to the wakeup pipe. */
+#define WAKE_UP_STRING      "WakeUp!"
+/** Length of the string written. */
+#define WAKE_UP_STRING_LEN  ( sizeof(WAKE_UP_STRING) - 1 )
+
 #ifndef TESTCASE
-void clipQueueToEventThread(XtAppContext app_context,
+/** Schedule a function call to run on the Xt event thread by passing it to
+ * the application context as a 0ms timeout and waking up the event loop by
+ * writing to the wakeup pipe which it monitors. */
+void clipQueueToEventThread(CLIPBACKEND *pCtx,
                             XtTimerCallbackProc proc,
                             XtPointer client_data)
 {
-    XtAppAddTimeOut(app_context, 0, proc, client_data);
+    LogRel2(("clipQueueToEventThread: proc=%p, client_data=%p\n",
+             proc, client_data));
+    XtAppAddTimeOut(pCtx->appContext, 0, proc, client_data);
+    write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
 }
 #endif
@@ -302 +323 @@
 
 /**
- * Forget which formats were previously in the X11 clipboard.  Should be
- * called when we grab the clipboard, so that when we lose it again the poller
- * will notify us when new formats become available. */
+ * Forget which formats were previously in the X11 clipboard.  Called when we
+ * grab the clipboard. */
 static void clipResetX11Formats(CLIPBACKEND *pCtx)
 {
@@ -425 +445 @@
     bool changed = false;
 
-    LogRel3 (("%s: called\n", __PRETTY_FUNCTION__));
+    LogRel2 (("%s: called\n", __PRETTY_FUNCTION__));
     if (pCtx->fOwnsClipboard)
         /* VBox raced us and we lost.  So we don't want to report anything. */
         return;
     clipGetFormatsFromTargets(pCtx, pTargets, cTargets, &changed);
-    if (changed)
-        clipReportFormatsToVBox(pCtx);
+    clipReportFormatsToVBox(pCtx);
 }
 
@@ -460 +479 @@
  * Notify the VBox clipboard about available data formats, based on the
  * "targets" information obtained from the X11 clipboard.
- * @note  callback for XtGetSelectionValue, called on a polling loop
+ * @note  callback for XtGetSelectionValue
  */
 static void clipConvertX11Targets(Widget, XtPointer pClientData,
@@ -472 +491 @@
                                                     : (Atom *)pValue;
     size_t cTargets = pTargets ? *pcLen : 0;
+    LogRel2(("clipConvertX11Targets: pValue=%p, *pcLen=%u, *atomType=%d, XT_CONVERT_FAIL=%d\n",
+             pValue, *pcLen, *atomType, XT_CONVERT_FAIL));
     clipUpdateX11Targets(pCtx, pTargets, cTargets);
     XtFree(reinterpret_cast<char *>(pValue));
 }
 
-enum { TIMER_FREQ = 200 /* ms */ };
-
-static void clipPollX11CBFormats(XtPointer pUserData,
-                                 XtIntervalId * /* hTimerId */);
-static void clipSchedulePoller(CLIPBACKEND *pCtx,
-                               XtTimerCallbackProc proc);
-
-#ifndef TESTCASE
-void clipSchedulePoller(CLIPBACKEND *pCtx,
-                        XtTimerCallbackProc proc)
-{
-    XtAppAddTimeOut(pCtx->appContext, TIMER_FREQ, proc, pCtx);
-}
-#endif
-
-/**
- * This timer callback is called every 200ms to check the contents of the X11
- * clipboard.
- * @note  X11 backend code, callback for XtAppAddTimeOut, recursively
- *        re-armed.
- * @todo  Use the XFIXES extension to check for new clipboard data when
- *        available.
- */
-void clipPollX11CBFormats(XtPointer pUserData, XtIntervalId * /* hTimerId */)
-{
-    CLIPBACKEND *pCtx = (CLIPBACKEND *)pUserData;
-    LogRel3 (("%s: called\n", __PRETTY_FUNCTION__));
+/**
+ * Callback to notify us when the contents of the X11 clipboard change.
+ */
+void clipQueryX11CBFormats(CLIPBACKEND *pCtx)
+{
+    LogRel2 (("%s: called\n", __PRETTY_FUNCTION__));
     /* Get the current clipboard contents if we don't own it ourselves */
     if (!pCtx->fOwnsClipboard)
     {
-        LogRel3 (("%s: requesting the targets that the X11 clipboard offers\n",
+        LogRel2 (("%s: requesting the targets that the X11 clipboard offers\n",
                __PRETTY_FUNCTION__));
         XtGetSelectionValue(pCtx->widget,
@@ -514 +514 @@
                             CurrentTime);
     }
-    /* Re-arm our timer */
-    clipSchedulePoller(pCtx, clipPollX11CBFormats);
 }
 
 #ifndef TESTCASE
+/**
+ * Wait until an event arrives and handle it if it is an XFIXES selection
+ * event, which Xt doesn't know about.
+ */
+void clipPeekEventAndDoXFixesHandling(CLIPBACKEND *pCtx)
+{
+    XEvent event = { 0 };
+
+    if (XtAppPeekEvent(pCtx->appContext, &event))
+        if (event.type == pCtx->fixesEventBase)
+            clipQueryX11CBFormats(pCtx);
+}
+
 /**
  * The main loop of our clipboard reader.
@@ -528 +539 @@
 
     CLIPBACKEND *pCtx = (CLIPBACKEND *)pvUser;
+
+    if (pCtx->fGrabClipboardOnStart)
+        clipQueryX11CBFormats(pCtx);
     while (XtAppGetExitFlag(pCtx->appContext) == FALSE)
+    {
+        clipPeekEventAndDoXFixesHandling(pCtx);
         XtAppProcessEvent(pCtx->appContext, XtIMAll);
+    }
     LogRel(("Shared clipboard: shared clipboard thread terminated successfully\n"));
     return VINF_SUCCESS;
@@ -562 +579 @@
 /** Worker function for stopping the clipboard which runs on the event
  * thread. */
-static void clipStopEventThreadWorker(XtPointer pUserData, int * /* source */,
-                                      XtInputId * /* id */)
+static void clipStopEventThreadWorker(XtPointer pUserData, XtIntervalId *)
 {
     
@@ -575 +591 @@
      * the VBox part *must* have returned before we do this. */
     XtAppSetExitFlag(pCtx->appContext);
+}
+
+#ifndef TESTCASE
+/** Setup the XFixes library and load the XFixesSelectSelectionInput symbol */
+static int clipLoadXFixes(Display *pDisplay, CLIPBACKEND *pCtx)
+{
+    int dummy1 = 0, dummy2 = 0, rc = VINF_SUCCESS;
+    void *hFixesLib;
+
+    hFixesLib = dlopen("libXfixes.so.1", RTLD_LAZY);
+    if (!hFixesLib)
+        hFixesLib = dlopen("libXfixes.so.2", RTLD_LAZY);
+    if (!hFixesLib)
+        hFixesLib = dlopen("libXfixes.so.3", RTLD_LAZY);
+    if (hFixesLib)
+        pCtx->fixesSelectInput =
+            (void (*)(Display *, Window, Atom, long unsigned int))
+                (uintptr_t)dlsym(hFixesLib, "XFixesSelectSelectionInput");
+    /* For us, a NULL function pointer is a failure */
+    if (!hFixesLib || !pCtx->fixesSelectInput)
+        rc = VERR_NOT_SUPPORTED;
+    if (   RT_SUCCESS(rc)
+        && !XQueryExtension(pDisplay, "XFIXES", &dummy1,
+                            &pCtx->fixesEventBase, &dummy2))
+        rc = VERR_NOT_SUPPORTED;
+    if (RT_SUCCESS(rc) && pCtx->fixesEventBase < 0)
+        rc = VERR_NOT_SUPPORTED;
+    return rc;
+}
+#endif
+
+/** 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 *)
+{
+    CLIPBACKEND *pCtx = (CLIPBACKEND *)pUserData;
+    char acBuf[WAKE_UP_STRING_LEN];
+
+    LogRel2(("clipDrainWakeupPipe: called\n"));
+    while (read(pCtx->wakeupPipeRead, acBuf, sizeof(acBuf)) > 0) {}
 }
 
@@ -601 +657 @@
         rc = VERR_NOT_SUPPORTED;
     }
+#ifndef TESTCASE
+    if (RT_SUCCESS(rc))
+        rc = clipLoadXFixes(pDisplay, pCtx);
+#endif
     if (RT_SUCCESS(rc))
     {
@@ -617 +677 @@
     if (RT_SUCCESS(rc))
     {
+        EventMask mask = 0;
+
         XtSetMappedWhenManaged(pCtx->widget, false);
         XtRealizeWidget(pCtx->widget);
-        /* Set up a timer to poll the X11 clipboard */
-        clipSchedulePoller(pCtx, clipPollX11CBFormats);
+#ifndef TESTCASE
+        /* Enable clipboard update notification */
+        pCtx->fixesSelectInput(pDisplay, XtWindow(pCtx->widget),
+                               clipGetAtom(pCtx->widget, "CLIPBOARD"),
+                               7 /* All XFixes*Selection*NotifyMask flags */);
+#endif
     }
     /* Create the pipes */
@@ -630 +696 @@
         if (!XtAppAddInput(pCtx->appContext, pCtx->wakeupPipeRead,
                            (XtPointer) XtInputReadMask,
-                           clipStopEventThreadWorker, (XtPointer) pCtx))
+                           clipDrainWakeupPipe, (XtPointer) pCtx))
             rc = VERR_NO_MEMORY;  /* What failure means is not doc'ed. */
+        if (   RT_SUCCESS(rc)
+            && (fcntl(pCtx->wakeupPipeRead, F_SETFL, O_NONBLOCK) != 0))
+            rc = RTErrConvertFromErrno(errno);
     }
     else
@@ -691 +760 @@
 /**
  * Announce to the X11 backend that we are ready to start.
- */
-int ClipStartX11(CLIPBACKEND *pCtx)
+ * @param  grab  whether we should try to grab the shared clipboard at once
+ */
+int ClipStartX11(CLIPBACKEND *pCtx, bool grab)
 {
     int rc = VINF_SUCCESS;
@@ -703 +773 @@
 
     rc = clipInit(pCtx);
+    if (RT_SUCCESS(rc))
+    {
+        pCtx->fOwnsClipboard = false;
+        clipResetX11Formats(pCtx);
+        pCtx->fGrabClipboardOnStart = grab;
+    }
 #ifndef TESTCASE
     if (RT_SUCCESS(rc))
@@ -712 +788 @@
     }
 #endif
-    if (RT_SUCCESS(rc))
-    {
-        pCtx->fOwnsClipboard = false;
-        clipResetX11Formats(pCtx);
-    }
     return rc;
 }
-
-/** String written to the wakeup pipe. */
-#define WAKE_UP_STRING      "WakeUp!"
-/** Length of the string written. */
-#define WAKE_UP_STRING_LEN  ( sizeof(WAKE_UP_STRING) - 1 )
 
 /**
@@ -745 +811 @@
     LogRelFunc(("stopping the shared clipboard X11 backend\n"));
     /* Write to the "stop" pipe */
-    rc = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
+    clipQueueToEventThread(pCtx, clipStopEventThreadWorker, (XtPointer) pCtx);
+#ifndef TESTCASE
     do
     {
@@ -752 +819 @@
         Assert(RT_SUCCESS(rc) || ((VERR_TIMEOUT == rc) && (count != 5)));
     } while ((VERR_TIMEOUT == rc) && (count < 300));
+#else
+    rc = VINF_SUCCESS;
+    rcThread = VINF_SUCCESS;
+#endif
     if (RT_SUCCESS(rc))
         AssertRC(rcThread);
@@ -1090 +1161 @@
         rc = clipCreateX11Targets(pCtx, atomTypeReturn, pValReturn,
                                   pcLenReturn, piFormatReturn);
-    else
         rc = clipConvertVBoxCBForX11(pCtx, atomTarget, atomTypeReturn,
                                      pValReturn, pcLenReturn, piFormatReturn);
@@ -1103 +1173 @@
 {
     LogRelFlowFunc (("\n"));
-    /* The formats should be set to the right values as soon as we start
-     * polling */
+    /* The formats should be set to the right values as soon as X11 clipboard
+     * data becomes available. */
     clipReportEmptyX11CB(pCtx);
     pCtx->fOwnsClipboard = false;
@@ -1203 +1273 @@
         pFormats->pCtx = pCtx;
         pFormats->formats = u32Formats;
-        clipQueueToEventThread(pCtx->appContext, clipNewVBoxFormatsWorker,
+        clipQueueToEventThread(pCtx, clipNewVBoxFormatsWorker,
                                (XtPointer) pFormats);
     }
@@ -1497 +1567 @@
     RTMemFree(pvDest);
     RTMemFree(pReq);
-    if (RT_SUCCESS(rc))
-        /* The other end may want to cache the data, so pretend we have new
-         * data, as we have no way of telling when new data really does
-         * arrive. */
-        clipReportFormatsToVBox(pCtx);
-    // else
-    //     clipReportEmptyX11CB(pCtx);
     LogRelFlowFunc(("rc=%Rrc\n", rc));
 }
@@ -1586 +1649 @@
         pX11Req->mReq = pReq;
         /* We use this to schedule a worker function on the event thread. */
-        clipQueueToEventThread(pCtx->appContext, vboxClipboardReadX11Worker,
+        clipQueueToEventThread(pCtx, vboxClipboardReadX11Worker,
                                (XtPointer) pX11Req);
     }
@@ -1607 +1670 @@
 #define TEST_WIDGET (Widget)0xffff
 
-/* Our X11 clipboard target poller */
-static XtTimerCallbackProc g_pfnPoller = NULL;
-/* User data for the poller function. */
-static XtPointer g_pPollerData = NULL;
-
-/* For the testcase, we install the poller function in a global variable
- * which is called when the testcase updates the X11 targets. */
-void clipSchedulePoller(CLIPBACKEND *pCtx,
-                        XtTimerCallbackProc proc)
-{
-    g_pfnPoller = proc;
-    g_pPollerData = (XtPointer)pCtx;
-}
-
 /* For the purpose of the test case, we just execute the procedure to be
  * scheduled, as we are running single threaded. */
-void clipQueueToEventThread(XtAppContext app_context,
+void clipQueueToEventThread(CLIPBACKEND *pCtx,
                             XtTimerCallbackProc proc,
                             XtPointer client_data)
@@ -2570 +2619 @@
     if (!testStringFromVBoxFailed(pCtx, "UTF8_STRING"))
         ++cErrs;
+    rc = ClipStopX11(pCtx);
+    AssertRCReturn(rc, 1);
+    ClipDestructX11(pCtx);
 
     if (cErrs > 0)