Changeset 6290 in vbox

Timestamp:

Jan 9, 2008 10:49:16 AM (17 years ago)

Author:

vboxsync

Message:

Guest Additions: update for the Linux seamless additions

Location:

trunk/src

Files:

• VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibSeamless.cpp (modified) (2 diffs)
• VBox/Additions/x11/xclient/Makefile.kmk (modified) (4 diffs)
• VBox/Additions/x11/xclient/main.cpp (modified) (7 diffs)
• VBox/Additions/x11/xclient/seamless-glue.h (modified) (2 diffs)
• VBox/Additions/x11/xclient/seamless-guest.h (modified) (1 diff)
• VBox/Additions/x11/xclient/seamless-host.cpp (modified) (6 diffs)
• VBox/Additions/x11/xclient/seamless-host.h (modified) (3 diffs)
• VBox/Additions/x11/xclient/seamless-x11.cpp (modified) (13 diffs)
• VBox/Additions/x11/xclient/seamless-x11.h (modified) (10 diffs)
• VBox/Additions/x11/xclient/seamless.h (modified) (10 diffs)
• VBox/Additions/x11/xclient/testcase/tstSeamlessX11.cpp (deleted)
• VBox/Additions/x11/xclient/thread.h (modified) (1 diff)
• testcase/tstRunTestcases.cpp (modified) (1 diff)

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibSeamless.cpp

@@ -54 +54 @@
 #ifdef DEBUG
     if (RT_SUCCESS(rc))
-        LogRel(("Successfully enabled seamless mode on the host.\n"));
+        LogRel(("Successfully set the seamless capability on the host.\n"));
     else
-        LogRel(("Failed to enabled seamless mode on the host, rc = %Rrc.\n", rc));
+        LogRel(("Failed to set the seamless capability on the host, rc = %Rrc.\n", rc));
 #endif
     return rc;
@@ -116 +116 @@
     int rc;
 
+    if (0 == cRects)
+        return VINF_SUCCESS;
     rc = VbglR3GRAlloc((VMMDevRequestHeader **)&req,
                        sizeof(VMMDevVideoSetVisibleRegion) + (cRects - 1) * sizeof(RTRECT),

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

@@ -20 +20 @@
 
 ifneq ($(USERNAME),bird) # crap
-PROGRAMS = vboxadd-xclient
+ PROGRAMS = vboxadd-xclient
 endif
 
@@ -27 +27 @@
 vboxadd-xclient_TEMPLATE = VBOXLNX32GUESTR3EXE
 vboxadd-xclient_SOURCES  = clipboard.cpp main.cpp
+vboxadd-xclient_DEFS    += CLIPBOARD_LINUX
+
 ifdef LINUX_SEAMLESS_GUEST
-vboxadd-xclient_SOURCES += \
-                seamless-host.cpp \
-                seamless-x11.cpp \
-                thread.cpp
+ vboxadd-xclient_SOURCES += \
+                 seamless-host.cpp \
+                 seamless-x11.cpp \
+                 thread.cpp
 endif
 vboxadd-xclient_LIBPATH  = $(PATH_TARGET)/vboxadd-xclient $(VBOX_LIBPATH32_X11)
+# Ugly recursive dependency between the runtime and the guest library.  Sorry.
 vboxadd-xclient_LIBS     = \
                 $(PATH_LIB)/RuntimeLnx32GuestR3.a \
                 $(PATH_LIB)/VBoxGuestR3LibLinux.a \
+                $(PATH_LIB)/RuntimeLnx32GuestR3.a \
                 pthread \
                 rt \
@@ -42 +46 @@
                 Xext \
                 X11
-vboxadd-xclient_DEFS     = _GNU_SOURCE VBOX_HGCM
+vboxadd-xclient_DEFS    += _GNU_SOURCE VBOX_HGCM
+
 ifdef LINUX_SEAMLESS_GUEST
-vboxadd-xclient_DEFS     += LINUX_SEAMLESS
+ vboxadd-xclient_DEFS     += SEAMLESS_LINUX
 endif
 
@@ -55 +60 @@
 
 ifdef LINUX_SEAMLESS_GUEST
-ifdef VBOX_WITH_CPPUNIT_TESTCASES
- PROGRAMS                  += tstSeamlessX11
- tstSeamlessX11_TEMPLATE    = VBOXCPPUNITEXE
- tstSeamlessX11_SOURCES     = \
-         testcase/tstSeamlessX11.cpp \
-         seamless-x11.cpp
- tstSeamlessX11_INST        = $(INST_TESTCASE)
-endif
+ ifdef VBOX_WITH_TESTCASES
+ # Additional testcase designed to be run manually, which initiates and starts the Linux
+ # guest client part of the seamless additions in the host, faking seamless events from
+ # the host and writing information about guest events to standard output.
+  PROGRAMS                  += tstSeamlessX11
+  tstSeamlessX11_TEMPLATE  = VBOXR3EXE
+  tstSeamlessX11_SOURCES   = \
+          testcase/tstSeamlessX11.cpp \
+          seamless-host.cpp \
+          seamless-x11.cpp \
+          thread.cpp
+  tstSeamlessX11_LIBS      = \
+          $(LIB_RUNTIME) \
+          Xext \
+          X11
+  tstSeamlessX11_INST      = $(INST_TESTCASE)
+ endif
 endif
 

trunk/src/VBox/Additions/x11/xclient/main.cpp

@@ -17 +17 @@
  */
 
-#define LOG_GROUP LOG_GROUP_DEV_VMM_BACKDOOR
+// #define LOG_GROUP LOG_GROUP_DEV_VMM_BACKDOOR
 
 #include <VBox/VBoxGuest.h>
@@ -24 +24 @@
 
 #include <iostream>
-
-using std::cout;
-using std::endl;
 
 #include <sys/types.h>
@@ -94 +91 @@
 
 /**
- * Xlib error handler, so that we don't abort when we get a BadAtom error.
- */
-int vboxClipboardXLibErrorHandler(Display *pDisplay, XErrorEvent *pError)
+ * Xlib error handler for certain errors that we can't avoid.
+ */
+int vboxClientXLibErrorHandler(Display *pDisplay, XErrorEvent *pError)
 {
     char errorText[1024];
 
-    LogFlowFunc(("\n"));
     if (pError->error_code == BadAtom)
     {
         /* This can be triggered in debug builds if a guest application passes a bad atom
            in its list of supported clipboard formats.  As such it is harmless. */
-        LogFlowFunc(("ignoring BadAtom error and returning\n"));
+        Log(("VBoxService: ignoring BadAtom error and returning\n"));
         return 0;
     }
+    if (pError->error_code == BadWindow)
+    {
+        /* This can be triggered if a guest application destroys a window before we notice. */
+        Log(("VBoxService: ignoring BadWindow error and returning\n"));
+        return 0;
+    }
+#ifdef CLIPBOARD_LINUX
     vboxClipboardDisconnect();
+#endif
     XGetErrorText(pDisplay, pError->error_code, errorText, sizeof(errorText));
-    if (!gbDaemonise)
-    {
-        cout << "An X Window protocol error occurred: " << errorText << endl
-            << "  Request code: " << int(pError->request_code) << endl
-            << "  Minor code: " << int(pError->minor_code) << endl
-            << "  Serial number of the failed request: " << int(pError->serial) << endl;
-    }
-    Log(("%s: an X Window protocol error occurred: %s.  Request code: %d, minor code: %d, serial number: %d\n",
-         __PRETTY_FUNCTION__, pError->error_code, pError->request_code, pError->minor_code,
-         pError->serial));
-    LogFlowFunc(("exiting\n"));
+    LogRel(("VBoxService: an X Window protocol error occurred: %s.  Request code: %d, minor code: %d, serial number: %d\n",
+         pError->error_code, pError->request_code, pError->minor_code, pError->serial));
     exit(1);
 }
@@ -145 +140 @@
             if (optind < argc)
             {
-                cout << "Unrecognized command line argument: " << argv[argc] << endl;
+                std::cout << "Unrecognized command line argument: " << argv[argc] << std::endl;
                 exit(1);
             }
@@ -156 +151 @@
             break;
         default:
-            cout << "Unrecognized command line option: " << static_cast<char>(cOpt) << endl;
+            std::cout << "Unrecognized command line option: " << static_cast<char>(cOpt)
+                      << std::endl;
         case '?':
             exit(1);
@@ -167 +163 @@
     /* Initialise our runtime before all else. */
     RTR3Init(false);
-    LogFlowFunc(("\n"));
+    rc = VbglR3Init();
+    if (RT_FAILURE(rc))
+    {
+        std::cout << "Failed to connect to the VirtualBox kernel service" << std::endl;
+        return 1;
+    }
+    LogRel(("VBoxService: starting...\n"));
     /* Initialise threading in X11 and in Xt. */
     if (!XInitThreads() || !XtToolkitThreadInitialize())
     {
-        LogRelFunc(("Error initialising threads in X11, returning 1."));
-        cout << "Your guest system appears to be using an old, single-threaded version of the X Window System libraries.  This program cannot continue." << endl;
+        LogRel(("VBoxService: error initialising threads in X11, exiting."));
         return 1;
     }
-    /* Set an X11 error handler, so that we don't die when we get BadAtom errors. */
-    XSetErrorHandler(vboxClipboardXLibErrorHandler);
+    /* Set an X11 error handler, so that we don't die when we get unavoidable errors. */
+    XSetErrorHandler(vboxClientXLibErrorHandler);
+#ifdef CLIPBOARD_LINUX
     /* Connect to the host clipboard. */
-    LogRel(("Starting clipboard Guest Additions...\n"));
+    LogRel(("VBoxService: starting clipboard Guest Additions...\n"));
     rc = vboxClipboardConnect();
-    if (rc != VINF_SUCCESS)
-    {
-        LogRel(("vboxClipboardConnect failed with rc = %d\n", rc));
-        cout << "Failed to connect to the host clipboard." << endl;
-    }
+    if (RT_SUCCESS(rc))
+    {
+        LogRel(("VBoxService: vboxClipboardConnect failed with rc = %Rrc\n", rc));
+    }
+#endif  /* CLIPBOARD_LINUX defined */
 #ifdef SEAMLESS_LINUX
     try
     {
-        LogRel(("Starting seamless Guest Additions...\n"));
+        LogRel(("VBoxService: starting seamless Guest Additions...\n"));
         rc = seamless.init();
-        if (rc != VINF_SUCCESS)
-        {
-            LogRel(("Failed to initialise seamless Additions, rc = %d\n", rc));
-            cout << "Failed to initialise seamless Additions." << endl;
+        if (RT_FAILURE(rc))
+        {
+            LogRel(("VBoxService: failed to initialise seamless Additions, rc = %Rrc\n", rc));
         }
     }
     catch (std::exception e)
     {
-        LogRel(("Failed to initialise seamless Additions - caught exception: %s\n", e.what()));
-        cout << "Failed to initialise seamless Additions\n" << endl;
+        LogRel(("VBoxService: failed to initialise seamless Additions - caught exception: %s\n", e.what()));
         rc = VERR_UNRESOLVED_ERROR;
     }
     catch (...)
     {
-        LogRel(("Failed to initialise seamless Additions - caught unknown exception.\n"));
-        cout << "Failed to initialise seamless Additions\n" << endl;
+        LogRel(("VBoxService: failed to initialise seamless Additions - caught unknown exception.\n"));
         rc = VERR_UNRESOLVED_ERROR;
     }
 #endif /* SEAMLESS_LINUX defined */
+#ifdef CLIPBOARD_LINUX
+    LogRel(("VBoxService: connecting to the shared clipboard service.\n"));
     vboxClipboardMain();
     vboxClipboardDisconnect();
+#else  /* CLIPBOARD_LINUX not defined */
+    LogRel(("VBoxService: sleeping...\n"));
+    pause();
+    LogRel(("VBoxService: exiting...\n"));
+#endif  /* CLIPBOARD_LINUX not defined */
 #ifdef SEAMLESS_LINUX
     try
@@ -218 +224 @@
     catch (std::exception e)
     {
-        LogRel(("Error shutting down seamless Additions - caught exception: %s\n", e.what()));
+        LogRel(("VBoxService: error shutting down seamless Additions - caught exception: %s\n", e.what()));
         rc = VERR_UNRESOLVED_ERROR;
     }
     catch (...)
     {
-        LogRel(("Error shutting down seamless Additions - caught unknown exception.\n"));
+        LogRel(("VBoxService: error shutting down seamless Additions - caught unknown exception.\n"));
         rc = VERR_UNRESOLVED_ERROR;
     }
 #endif /* SEAMLESS_LINUX defined */
-    LogFlowFunc(("returning %Vrc\n", rc));
     return rc;
 }

trunk/src/VBox/Additions/x11/xclient/seamless-glue.h

@@ -20 +20 @@
 # define __Additions_client_seamless_glue_h
 
-#if 0
-
-#include "seamless-host.h"
-#include "seamless-guest.h"
-
-#endif
-
 class VBoxGuestSeamlessObserver
 {
@@ -34 +27 @@
 };
 
-#if 0
-/**
- * Observer to connect the guest and the host parts of the seamless guest client.
- * It starts the host part when the guest reports that it supports seamless mode and
- * stops it when the guest no longer supports seamless.  It also proxies enter and
- * exit seamless mode requests from the host part to the guest and informs the host
- * part when the guest's visible area changes.
- */
-class VBoxGuestSeamlessGlue
-{
-private:
-    VBoxGuestSeamlessHost *mHost;
-    VBoxGuestSeamlessGuestImpl *mGuest;
-
-public:
-    VBoxGuestSeamlessGlue(VBoxGuestSeamlessHost *pHost, VBoxGuestSeamlessGuestImpl *pGuest)
-            : mHost(pHost), mGuest(pGuest) {}
-    ~VBoxGuestSeamlessGlue();
-
-    /** State change notification callback for the guest. */
-    void guestNotify(VBoxGuestSeamlessGuest::meEvent event)
-    {
-        switch(event)
-        {
-            case VBoxGuestSeamlessGuest::CAPABLE:
-                mHost->start();
-                break;
-            case VBoxGuestSeamlessGuest::INCAPABLE:
-                mHost->stop();
-                break;
-            case VBoxGuestSeamlessGuest::UPDATE:
-                mHost->updateRects(mGuest->getRects());
-                break;
-            default:
-                break;
-        }
-    }
-
-    /** State change notification callback for the host. */
-    void hostNotify(VBoxGuestSeamlessHost::meEvent event)
-    {
-        switch(event)
-        {
-            case VBoxGuestSeamlessHost::ENABLE:
-                mGuest->start();
-                break;
-            case VBoxGuestSeamlessHost::DISABLE:
-                mGuest->stop();
-                break;
-            default:
-                break;
-        }
-    }
-};
-#endif /* 0 */
-
 #endif /* __Additions_client_seamless_glue_h not defined */

trunk/src/VBox/Additions/x11/xclient/seamless-guest.h

@@ -73 +73 @@
     /** Get the current list of visible rectangles. */
     std::auto_ptr<std::vector<RTRECT> > getRects(void);
+    /** Process next event in the guest event queue - called by the event thread. */
+    void nextEvent(void);
+    /** Wake up the event thread if it is waiting for an event so that it can exit. */
+    bool interruptEvent(void);
 };
 

trunk/src/VBox/Additions/x11/xclient/seamless-host.cpp

@@ -26 +26 @@
 #include "seamless-host.h"
 
-#ifdef DEBUG
-# include <stdio.h>
-# define DPRINT(a) printf a
-#else
-# define DPRINT(a)
-#endif
-
 /**
  * Start the service.
@@ -43 +36 @@
     if (mRunning)  /* Assertion */
     {
-        LogRelThisFunc(("Service started twice!\n"));
-        DPRINT(("Service started twice!\n"));
+        LogRel(("VBoxService: seamless service started twice!\n"));
         return VERR_INTERNAL_ERROR;
     }
-    if (VbglR3SeamlessSetCap(true))
+    rc = VbglR3CtlFilterMask(VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST, 0);
+    if (RT_FAILURE(rc))
     {
-        DPRINT(("Enabled host seamless.\n"));
+        LogRel(("VBoxService (seamless): failed to set the guest IRQ filter mask, rc=%Rrc\n", rc));
+    }
+    rc = VbglR3SeamlessSetCap(true);
+    if (RT_SUCCESS(rc))
+    {
+        Log(("VBoxService: enabled seamless capability on host.\n"));
         rc = mThread.start();
         if (RT_SUCCESS(rc))
@@ -57 +55 @@
         else
         {
-            DPRINT(("Disabled host seamless again.\n"));
+            LogRel(("VBoxService: failed to start seamless event thread, rc=%Rrc.  Disabled seamless capability on host again.\n", rc));
             VbglR3SeamlessSetCap(false);
         }
@@ -63 +61 @@
     if (RT_FAILURE(rc))
     {
-        DPRINT(("Failed to enable host seamless, rc=%d\n", rc));
+        Log(("VBoxService (seamless): failed to enable seamless capability on host, rc=%Rrc\n", rc));
     }
     return rc;
@@ -73 +71 @@
     if (!mRunning)  /* Assertion */
     {
-        LogRelThisFunc(("Service not running!\n"));
+        LogRel(("VBoxService: tried to stop seamless service which is not running!\n"));
         return;
     }
     mThread.stop(0, 0);
+    VbglR3CtlFilterMask(0, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
     VbglR3SeamlessSetCap(false);
     mRunning = false;
@@ -88 +87 @@
 int VBoxGuestSeamlessHost::nextEvent(void)
 {
-    VMMDevSeamlessMode newMode;
+    VMMDevSeamlessMode newMode = VMMDev_Seamless_Disabled;
 
     int rc = VbglR3SeamlessWaitEvent(&newMode);
-    switch(newMode)
+    if (RT_SUCCESS(rc))
     {
-        case VMMDev_Seamless_Visible_Region:
-        /* A simplified seamless mode, obtained by making the host VM window borderless and
-          making the guest desktop transparent. */
-            mState = ENABLE;
-            mObserver->notify();
-            break;
-        case VMMDev_Seamless_Host_Window:
-        /* One host window represents one guest window.  Not yet implemented. */
-            LogRelFunc(("Warning: VMMDev_Seamless_Host_Window request received.\n"));
-            /* fall through to default */
-        default:
-            LogRelFunc(("Warning: unsupported VMMDev_Seamless request received.\n"));
-            /* fall through to case VMMDev_Seamless_Disabled */
-        case VMMDev_Seamless_Disabled:
-            mState = DISABLE;
-            mObserver->notify();
+        switch(newMode)
+        {
+            case VMMDev_Seamless_Visible_Region:
+            /* A simplified seamless mode, obtained by making the host VM window borderless and
+              making the guest desktop transparent. */
+    #ifdef DEBUG
+                LogRelFunc(("VMMDev_Seamless_Visible_Region request received (VBoxService).\n"));
+    #endif
+                mState = ENABLE;
+                mObserver->notify();
+                break;
+            case VMMDev_Seamless_Host_Window:
+            /* One host window represents one guest window.  Not yet implemented. */
+                LogRelFunc(("Warning: VMMDev_Seamless_Host_Window request received (VBoxService).\n"));
+                /* fall through to default */
+            default:
+                LogRelFunc(("Warning: unsupported VMMDev_Seamless request %d received (VBoxService).\n", newMode));
+                /* fall through to case VMMDev_Seamless_Disabled */
+            case VMMDev_Seamless_Disabled:
+    #ifdef DEBUG
+                LogRelFunc(("VMMDev_Seamless_Disabled set (VBoxService).\n"));
+    #endif
+                mState = DISABLE;
+                mObserver->notify();
+        }
+    }
+    else
+    {
+        LogFunc(("VbglR3SeamlessWaitEvent returned %Rrc (VBoxService)\n", rc));
     }
     return rc;

trunk/src/VBox/Additions/x11/xclient/seamless-host.h

@@ -123 +123 @@
         if (mObserver != 0)  /* Assertion */
         {
-            LogRelThisFunc(("ERROR: attempt to initialise service twice!\n"));
+            LogRel(("VBoxService: ERROR: attempt to initialise seamless host object twice!\n"));
             return VERR_INTERNAL_ERROR;
         }
@@ -149 +149 @@
     VBoxGuestSeamlessHost(void) : mThreadFunction(this),
                                   mThread(&mThreadFunction, 0, RTTHREADTYPE_MAIN_WORKER,
-                                  RTTHREADFLAGS_WAITABLE, "Seamless host event thead")
+                                  RTTHREADFLAGS_WAITABLE, "Host events")
     {
         mObserver = 0;
@@ -160 +160 @@
         if (mRunning)  /* Assertion */
         {
-            LogRelThisFunc(("Service still running!  Stopping...\n"));
+            LogRel(("VBoxService: seamless host object still running!  Stopping...\n"));
             stop();
         }

trunk/src/VBox/Additions/x11/xclient/seamless-x11.cpp

@@ -67 +67 @@
 {
     int rc = VINF_SUCCESS;
-    /** Dummy values for XShapeQueryExtension */
-    int error, event;
+    /** Dummy value for XXGetProperty */
+    unsigned long nItems;
 
     if (0 != mObserver)  /* Assertion */
     {
-        LogRelThisFunc(("ERROR: attempt to initialise service twice!\n"));
+        LogRel(("VBoxService: ERROR: attempt to initialise seamless guest object twice!\n"));
         return VERR_INTERNAL_ERROR;
     }
-    if (!mDisplay.isValid())
-    {
-        LogRelThisFunc(("Failed to acquire a connection to the display.\n"));
+    if (!mDisplay.init())
+    {
+        LogRel(("VBoxService: seamless guest object failed to acquire a connection to the display.\n"));
         return VERR_ACCESS_DENIED;
     }
-    if (!XShapeQueryExtension(mDisplay, &event, &error))
-    {
-        LogFlowFunc(("X11 shape extension not supported, returning.\n"));
-        return VERR_NOT_SUPPORTED;
+    if (0 == XXGetProperty(mDisplay, DefaultRootWindow(mDisplay.get()), XA_WINDOW,
+                           NET_CLIENT_LIST, &nItems).get())
+    {
+        LogRel(("VBoxService: _NET_CLIENT_LIST property not supported by guest window manager.  Seamless mode will not be enabled.\n"));
     }
     mObserver = pObserver;
@@ -100 +100 @@
 {
     int rc = VINF_SUCCESS;
-
-    isEnabled = true;
-    monitorDesktopWindows();
+    /** Dummy values for XShapeQueryExtension */
+    int error, event;
+
+    mSupportsShape = XShapeQueryExtension(mDisplay, &event, &error);
+    mEnabled = true;
+    monitorClientList();
+    rebuildWindowTree();
     return rc;
 }
@@ -110 +114 @@
 void VBoxGuestSeamlessX11::stop(void)
 {
-    isEnabled = false;
+    mEnabled = false;
+    unmonitorClientList();
     freeWindowTree();
 }
 
-void VBoxGuestSeamlessX11::monitorDesktopWindows(void)
-{
-    VBoxGuestX11Pointer<unsigned char> virtualRoots;
+void VBoxGuestSeamlessX11::monitorClientList(void)
+{
+    XSelectInput(mDisplay, DefaultRootWindow(mDisplay.get()), PropertyChangeMask);
+}
+
+void VBoxGuestSeamlessX11::unmonitorClientList(void)
+{
+    XSelectInput(mDisplay, DefaultRootWindow(mDisplay.get()), 0);
+}
+
+void VBoxGuestSeamlessX11::rebuildWindowTree(void)
+{
+    VBoxGuestX11Pointer<unsigned char> clientListRaw;
+    VBoxGuestX11Pointer<Window> clientList;
     unsigned long nItems;
 
-    XSelectInput(mDisplay, DefaultRootWindow(mDisplay.get()), PropertyChangeMask);
-    virtualRoots = XXGetProperty(mDisplay, DefaultRootWindow(mDisplay.get()), XA_CARDINAL,
-                                 VIRTUAL_ROOTS_PROP, &nItems);
-    if ((0 != virtualRoots.get()) && (0 != nItems))
-    {
-        rebuildWindowTree();
-    }
-}
-
-void VBoxGuestSeamlessX11::rebuildWindowTree(void)
-{
-    VBoxGuestX11Pointer<unsigned char> virtualRoots;
-    Window *desktopWindows;
-    unsigned long nItems;
-
     freeWindowTree();
-    virtualRoots = XXGetProperty(mDisplay, DefaultRootWindow(mDisplay.get()), XA_CARDINAL,
-                                 VIRTUAL_ROOTS_PROP, &nItems);
-    desktopWindows = reinterpret_cast<Window *>(virtualRoots.get());
+    clientListRaw = XXGetProperty(mDisplay, DefaultRootWindow(mDisplay.get()), XA_WINDOW,
+                                  NET_CLIENT_LIST, &nItems);
+    clientList = reinterpret_cast<Window *>(clientListRaw.release());
     for (unsigned i = 0; i < nItems; ++i)
     {
-        addDesktopWindow(desktopWindows[i]);
-    }
-    /* This must be done last, so that we do not treat the desktop windows just added as
-       child windows. */
-    addDesktopWindow(DefaultRootWindow(mDisplay.get()));
-}
-
-/**
- * Store information about a desktop window and register for structure events on it.
- * If it is mapped, go through the list of it's children and add information about
- * mapped children to the tree of visible windows, making sure that those windows are
- * not already in our list of desktop windows.
- *
- * @param   hWin     the window concerned - should be a "desktop" window
- */
-void VBoxGuestSeamlessX11::addDesktopWindow(Window hWin)
-{
-    unsigned int cChildren = 0;
-    VBoxGuestX11Pointer<Window> children;
-    XWindowAttributes winAttrib;
-    /** Dummies */
-    Window root, parent, *pChildren;
-
-    if (!XGetWindowAttributes(mDisplay, hWin, &winAttrib))
-    {
-        LogRelFunc(("Failed to get the window attributes for window %d\n", hWin));
-        return;
-    }
-    mDesktopWindows.push_back(VBoxGuestDesktopInfo(hWin, winAttrib.x, winAttrib.y,
-                              (IsUnmapped != winAttrib.map_state)));
-    XSelectInput(mDisplay, hWin,
-                 StructureNotifyMask | SubstructureNotifyMask | PropertyChangeMask);
-    XQueryTree(mDisplay, hWin, &root, &parent, &pChildren, &cChildren);
-    children = pChildren;
-    if (0 == children.get())
-    {
-        LogRelFunc(("Failed to get the tree of active X11 windows.\n"));
-    }
-    else
-    {
-        for (unsigned int i = 0; i < cChildren; ++i)
+        VBoxGuestX11Pointer<unsigned char> windowTypeRaw;
+        VBoxGuestX11Pointer<Atom> windowType;
+        unsigned long ulCount;
+
+        windowTypeRaw = XXGetProperty(mDisplay, clientList.get()[i], XA_ATOM,
+                                      WM_TYPE_PROP, &ulCount);
+        windowType = reinterpret_cast<Atom *>(windowTypeRaw.release());
+        if (   (ulCount != 0)
+            && (*windowType != XInternAtom(mDisplay, WM_TYPE_DESKTOP_PROP, True)))
         {
-            bool found = false;
-
-            for (unsigned int j = 0; j < mDesktopWindows.size() && !found; ++j)
-            {
-                if (children.get()[i] == mDesktopWindows[j].mWin)
-                {
-                    found = true;
-                }
-            }
-            if (!found)
-            {
-                addWindowToList(children.get()[i], hWin);
-            }
+            addClientWindow(clientList.get()[i]);
         }
     }
 }
 
-void VBoxGuestSeamlessX11::addWindowToList(const Window hWin, const Window hParent)
+void VBoxGuestSeamlessX11::addClientWindow(const Window hWin)
 {
     XWindowAttributes winAttrib;
     VBoxGuestX11Pointer<XRectangle> rects;
-    int cRects, iOrdering;
-    unsigned iParent;
-    bool isVisible = false, found = false;
+    int cRects = 0, iOrdering;
+    int x, y;
+    /** Dummy value for XTranslateCoordinates */
+    Window dummyWin;
 
     if (!XGetWindowAttributes(mDisplay, hWin, &winAttrib))
     {
-        LogRelFunc(("Failed to get the window attributes for window %d\n", hWin));
+        LogRelFunc(("VBoxService: Failed to get the window attributes for window %d\n", hWin));
         return;
     }
-    XShapeSelectInput(mDisplay, hWin, ShapeNotify);
-    rects = XShapeGetRectangles(mDisplay, hWin, ShapeClip, &cRects, &iOrdering);
-    if (0 == rects.get())
-    {
-        cRects = 0;
-    }
-    if (IsViewable == winAttrib.map_state)
-    {
-        isVisible = true;
-    }
-    for (iParent = 0; iParent < mDesktopWindows.size() && !found; ++iParent)
-    {
-        if (hParent == mDesktopWindows[iParent].mWin)
+    if (mSupportsShape)
+    {
+        XShapeSelectInput(mDisplay, hWin, ShapeNotify);
+        rects = XShapeGetRectangles(mDisplay, hWin, ShapeClip, &cRects, &iOrdering);
+        if (0 == rects.get())
         {
-            found = true;
+            cRects = 0;
         }
     }
-    if (found)
-    {
-        mGuestWindows.addWindow(hWin, isVisible, winAttrib.x, winAttrib.y,
-                                winAttrib.width, winAttrib.height, cRects, rects, hParent);
-    }
+    XSelectInput(mDisplay, hWin, StructureNotifyMask);
+    XTranslateCoordinates(mDisplay, hWin, DefaultRootWindow(mDisplay.get()), winAttrib.x,
+                          winAttrib.y, &x, &y, &dummyWin);
+    mGuestWindows.addWindow(hWin, winAttrib.map_state != IsUnmapped, x, y,
+                            winAttrib.width, winAttrib.height, cRects, rects);
 }
 
@@ -241 +191 @@
 void VBoxGuestSeamlessX11::freeWindowTree(void)
 {
-    for (unsigned int i = 0; i != mDesktopWindows.size(); ++i)
-    {
-        XSelectInput(mDisplay, mDesktopWindows[i].mWin, 0);
-    }
-    mDesktopWindows.clear();
     /* We use post-increment in the operation to prevent the iterator from being invalidated. */
     for (VBoxGuestWindowList::iterator it = mGuestWindows.begin(); it != mGuestWindows.end();
                  mGuestWindows.removeWindow(it++))
     {
+        XSelectInput(mDisplay, it->first, 0);
         XShapeSelectInput(mDisplay, it->first, 0);
     }
@@ -290 +236 @@
 
 /**
- * Handle a configuration event in the seamless event thread by setting the new position and
- * updating the host's rectangle information.
+ * Handle a configuration event in the seamless event thread by setting the new position.
  *
  * @param event the X11 event structure
@@ -297 +242 @@
 void VBoxGuestSeamlessX11::doConfigureEvent(const XConfigureEvent *event)
 {
-    bool found = false;
-    unsigned i = 0;
-
-    for (i = 0; i < mDesktopWindows.size() && !found; ++i)
-    {
-        if (event->window == mDesktopWindows[i].mWin)
-        {
-            found = true;
-        }
-    }
-    if (found)
-    {
-        mDesktopWindows[i].mx = event->x;
-        mDesktopWindows[i].my = event->y;
-    }
-    else
-    {
-        VBoxGuestWindowList::iterator iter;
-
-        iter = mGuestWindows.find(event->window);
-        if (iter != mGuestWindows.end())
-        {
-            iter->second->mx = event->x;
-            iter->second->my = event->y;
-        }
-    }
-}
-
-/**
- * Handle a map event in the seamless event thread by adding the guest window to the list of
- * visible windows and updating the host's rectangle information.
+    VBoxGuestWindowList::iterator iter;
+
+    iter = mGuestWindows.find(event->window);
+    if (iter != mGuestWindows.end())
+    {
+        iter->second->mX = event->x;
+        iter->second->mY = event->y;
+        iter->second->mWidth = event->width;
+        iter->second->mHeight = event->height;
+    }
+}
+
+/**
+ * Handle a map event in the seamless event thread.
  *
  * @param event the X11 event structure
@@ -334 +262 @@
 {
     VBoxGuestWindowList::iterator iter;
-    bool found = false;
-
-    /* Is one of our desktop windows? */
-    for (unsigned i = 0; i < mDesktopWindows.size() && !found; ++i)
-    {
-        if (event->window == mDesktopWindows[i].mWin)
-        {
-            mDesktopWindows[i].mMapped = true;
-            found = true;
-        }
-    }
-    if (!found)
-    {
-        /* Make sure that the window is not already present in the tree */
-        iter = mGuestWindows.find(event->window);
-        if (iter != mGuestWindows.end())
-        {
-            LogRelFunc(("Warning: MapNotify event received for a window listed as mapped\n"));
-            mGuestWindows.removeWindow(event->window);
-        }
-        addWindowToList(event->window, event->event);
-    }
-}
-
-/**
- * If the list of virtual root windows changes, completely rescan visible windows.
+
+    iter = mGuestWindows.find(event->window);
+    if (iter != mGuestWindows.end())
+    {
+        iter->second->mMapped = true;
+    }
+}
+
+/**
+ * If the list of client windows changes, rebuild the list.
  *
  * @param event the X11 event structure
@@ -365 +277 @@
 void VBoxGuestSeamlessX11::doPropertyEvent(const XPropertyEvent *event)
 {
-    if (XInternAtom(mDisplay, VIRTUAL_ROOTS_PROP, true) == event->atom)
+    if (XInternAtom(mDisplay, NET_CLIENT_LIST, true) == event->atom)
     {
         rebuildWindowTree();
@@ -372 +284 @@
 
 /**
- * Handle a window shape change event in the seamless event thread by changing the set of
- * visible rectangles for the window in the list of visible guest windows and updating the
- * host's rectangle information.
+ * Handle a window shape change event in the seamless event thread.
  *
  * @param event the X11 event structure
@@ -398 +308 @@
 
 /**
- * Handle an unmap event in the seamless event thread by removing the guest window from the
- * list of visible windows and updating the host's rectangle information.
+ * Handle an unmap event in the seamless event thread.
  *
  * @param event the X11 event structure
@@ -406 +315 @@
 {
     VBoxGuestWindowList::iterator iter;
-    bool found = false;
-
-    /* Is this is one of our desktop windows? */
-    for (unsigned i = 0; i < mDesktopWindows.size() && !found; ++i)
-    {
-        if (event->window == mDesktopWindows[i].mWin)
-        {
-            mDesktopWindows[i].mMapped = false;
-            found = true;
-        }
-    }
-    if (!found)
-    {
-        /* Make sure that the window is not already present in the tree */
-        iter = mGuestWindows.find(event->window);
-        if (iter != mGuestWindows.end())
-        {
-            mGuestWindows.removeWindow(event->window);
-        }
-        else
-        {
-            LogRelFunc(("Warning: UnmapNotify event received for a window not listed as mapped\n"));
-        }
+
+    iter = mGuestWindows.find(event->window);
+    if (iter != mGuestWindows.end())
+    {
+        iter->second->mMapped = true;
     }
 }
@@ -447 +338 @@
          it != mGuestWindows.end(); ++it)
     {
-        Window hParent = it->second->mParent;
-        unsigned iParent;
-        bool found = false;
-
-        for (iParent = 0; iParent < mDesktopWindows.size() && !found; ++iParent)
+        if (it->second->mMapped)
         {
-            if (mDesktopWindows[iParent].mWin == hParent)
+            if (it->second->mcRects > 0)
             {
-                found = true;
+                for (int i = 0; i < it->second->mcRects; ++i)
+                {
+                    RTRECT rect;
+                    rect.xLeft   =   it->second->mX
+                                   + it->second->mapRects.get()[i].x;
+                    rect.yBottom =   it->second->mY
+                                   + it->second->mapRects.get()[i].y
+                                   + it->second->mapRects.get()[i].height;
+                    rect.xRight  =   it->second->mX
+                                   + it->second->mapRects.get()[i].x
+                                   + it->second->mapRects.get()[i].width;
+                    rect.yTop    =   it->second->mY
+                                   + it->second->mapRects.get()[i].y;
+                    apRects.get()->push_back(rect);
+                }
+                cRects += it->second->mcRects;
+            }
+            else
+            {
+                RTRECT rect;
+                rect.xLeft   =  it->second->mX;
+                rect.yBottom =  it->second->mY
+                              + it->second->mHeight;
+                rect.xRight  =  it->second->mX
+                              + it->second->mWidth;
+                rect.yTop    =  it->second->mY;
+                apRects.get()->push_back(rect);
+                ++cRects;
             }
         }
-        if (found && mDesktopWindows[iParent - 1].mMapped && it->second->mMapped)
-        {
-            for (int i = 0; i < it->second->mcRects; ++i)
-            {
-                RTRECT rect;
-                rect.xLeft   =   it->second->mx
-                              + it->second->mapRects.get()[i].x
-                              + mDesktopWindows[iParent].mx;
-                rect.yBottom =   it->second->my
-                              + it->second->mapRects.get()[i].y
-                              + it->second->mapRects.get()[i].height
-                              + mDesktopWindows[iParent].my;
-                rect.xRight  =   it->second->mx
-                              + it->second->mapRects.get()[i].x
-                              + it->second->mapRects.get()[i].width
-                              + mDesktopWindows[iParent].mx;
-                rect.yTop    =   it->second->my
-                              + it->second->mapRects.get()[i].y
-                              + mDesktopWindows[iParent].my;
-                apRects.get()->push_back(rect);
-            }
-            cRects += it->second->mcRects;
-        }
     }
     mcRects = cRects;
@@ -493 +384 @@
 bool VBoxGuestSeamlessX11::interruptEvent(void)
 {
-    XClientMessageEvent clientMessage = { ClientMessage };  /* Other members set to zero. */
-    XSendEvent(mDisplay, DefaultRootWindow(mDisplay.get()), false, StructureNotifyMask,
-               reinterpret_cast<XEvent *>(&clientMessage));
-    return true;
-}
+    /* Message contents set to zero. */
+    XClientMessageEvent clientMessage = { ClientMessage, 0, 0, 0, 0, 0, 8 };
+
+    if (0 != XSendEvent(mDisplay, DefaultRootWindow(mDisplay.get()), false, PropertyChangeMask,
+                   reinterpret_cast<XEvent *>(&clientMessage)))
+    {
+        XFlush(mDisplay);
+        return true;
+    }
+    return false;
+}

trunk/src/VBox/Additions/x11/xclient/seamless-x11.h

@@ -29 +29 @@
 
 #define VIRTUAL_ROOTS_PROP "_NET_VIRTUAL_ROOTS"
+#define WM_TYPE_PROP "_NET_WM_WINDOW_TYPE"
+#define WM_TYPE_DESKTOP_PROP "_NET_WM_WINDOW_TYPE_DESKTOP"
+#define NET_CLIENT_LIST "_NET_CLIENT_LIST"
 
 /**
@@ -132 +135 @@
     Display *mDisplay;
 public:
-    VBoxGuestX11Display(char *name = 0)
+    VBoxGuestX11Display(void) {}
+    bool init(char *name = 0)
     {
         mDisplay = XOpenDisplay(name);
+        return (0 != mDisplay);
     }
     operator Display *() { return mDisplay; }
@@ -147 +152 @@
 struct VBoxGuestWinInfo {
 public:
-    /** Is this window currently mapped? */
+    /** Is the window currently mapped? */
     bool mMapped;
     /** Co-ordinates in the guest screen. */
-    int mx, my;
+    int mX, mY;
     /** Window dimensions. */
-    int mwidth, mheight;
+    int mWidth, mHeight;
     /** Number of rectangles used to represent the visible area. */
     int mcRects;
@@ -158 +163 @@
         and will be freed automatically if non-null when the class is destroyed. */
     VBoxGuestX11Pointer<XRectangle> mapRects;
-    /** The index of the virtual root that this window is a child of. */
-    int mParent;
     /** Constructor. */
-    VBoxGuestWinInfo(bool mapped, int x, int y, int w, int h, int cRects,
-                     VBoxGuestX11Pointer<XRectangle> rects, int parent)
+    VBoxGuestWinInfo(bool isMapped, int x, int y, int w, int h, int cRects,
+                     VBoxGuestX11Pointer<XRectangle> rects)
             : mapRects(rects)
     {
-        mMapped = mapped; mx = x; my = y; mwidth = w; mheight = h; mcRects = cRects;
-        mParent = parent;
+        mMapped = isMapped, mX = x; mY = y; mWidth = w; mHeight = h; mcRects = cRects;
     }
 
@@ -214 +216 @@
 
     void addWindow(Window hWin, bool isMapped, int x, int y, int w, int h, int cRects,
-                   VBoxGuestX11Pointer<XRectangle> rects, int parent)
+                   VBoxGuestX11Pointer<XRectangle> rects)
     {
         VBoxGuestWinInfo *pInfo = new VBoxGuestWinInfo(isMapped, x, y, w, h, cRects,
-                                                       rects, parent);
+                                                       rects);
         mWindows.insert(std::pair<Window, VBoxGuestWinInfo *>(hWin, pInfo));
     }
@@ -230 +232 @@
     {
         removeWindow(find(hWin));
-    }
-};
-
-/** Structure containing information about a windows handle and position, for keeping
-    track of desktop windows.  Used internally by VBoxGuestSeamlessX11. */
-struct VBoxGuestDesktopInfo
-{
-    /** The Window handle for this window. */
-    Window mWin;
-    /** Co-ordinates relative to the root window (I hope!). */
-    int mx, my;
-    /** Is this window mapped? */
-    bool mMapped;
-
-    /** Constructor */
-    VBoxGuestDesktopInfo(Window hWin, int x, int y, bool mapped)
-    {
-        mWin = hWin;
-        mx = x;
-        my = y;
-        mMapped = mapped;
     }
 };
@@ -268 +249 @@
     /** Our connection to the X11 display we are running on. */
     VBoxGuestX11Display mDisplay;
-    /** Vector to keep track of which windows are to be treated as desktop windows. */
-    std::vector<VBoxGuestDesktopInfo> mDesktopWindows;
     /** Class to keep track of visible guest windows. */
     VBoxGuestWindowList mGuestWindows;
@@ -276 +255 @@
         the vector of rectangles passed to the host. */
     int mcRects;
+    /** Do we support the X shaped window extension? */
+    bool mSupportsShape;
     /** Is seamles mode currently enabled?  */
-    bool isEnabled;
+    bool mEnabled;
 
     // Private methods
@@ -297 +278 @@
      * @param   hWin     the window concerned - should be a "desktop" window
      */
-    void addDesktopWindow(Window hWin);
-    bool addNonDesktopWindow(Window hWin);
-    void addWindowToList(Window hWin, Window hParent);
-    void monitorDesktopWindows(void);
+    void monitorClientList(void);
+    void unmonitorClientList(void);
     void rebuildWindowTree(void);
+    void addClientWindow(Window hWin);
     void freeWindowTree(void);
     void updateHostSeamlessInfo(void);
@@ -337 +317 @@
     std::auto_ptr<std::vector<RTRECT> > getRects(void);
 
-    /** Process next event in the X11 event queue - called by the event thread. */
+    /** Process next event in the guest event queue - called by the event thread. */
     void nextEvent(void);
-    /** Send ourselves an X11 client event to wake up the event thread - called by
-        the event thread. */
+    /** Wake up the event thread if it is waiting for an event so that it can exit. */
     bool interruptEvent(void);
 
     VBoxGuestSeamlessX11(void)
     {
-        mObserver = 0; mcRects = 0; isEnabled = false;
+        mObserver = 0; mcRects = 0; mEnabled = false; mSupportsShape = false;
     }
 

trunk/src/VBox/Additions/x11/xclient/seamless.h

@@ -29 +29 @@
     /** The guest class "owning" us. */
     VBoxGuestSeamlessGuestImpl *mGuest;
+    /** The guest observer monitoring the guest. */
+    VBoxGuestSeamlessObserver *mObserver;
     /** Should we exit the thread? */
     bool mExit;
@@ -37 +39 @@
 
 public:
-    VBoxGuestSeamlessGuestThread(VBoxGuestSeamlessGuestImpl *pGuest)
-    { mGuest = pGuest; mExit = false; }
+    VBoxGuestSeamlessGuestThread(VBoxGuestSeamlessGuestImpl *pGuest,
+                                 VBoxGuestSeamlessObserver *pObserver)
+    { mGuest = pGuest; mObserver = pObserver; mExit = false; }
     virtual ~VBoxGuestSeamlessGuestThread(void) {}
     /**
@@ -48 +51 @@
     virtual int threadFunction(VBoxGuestThread *pThread)
     {
-        while (!pThread->isStopping)
+        int rc = VINF_SUCCESS;
+
+        rc = mGuest->start();
+        if (RT_SUCCESS(rc))
         {
-            mGuest->nextEvent();
+            while (!pThread->isStopping())
+            {
+                mGuest->nextEvent();
+            }
+            mGuest->stop();
         }
-        return VINF_SUCCESS;
+        return rc;
     }
     /**
@@ -66 +76 @@
 private:
     VBoxGuestSeamlessHost *mHost;
-    VBoxGuestSeamlessGuestImpl *mGuest;
+    VBoxGuestThread *mGuestThread;
 
 public:
     VBoxGuestSeamlessHostObserver(VBoxGuestSeamlessHost *pHost,
-                                  VBoxGuestSeamlessGuestImpl *pGuest)
+                                  VBoxGuestThread *pGuestThread)
     {
         mHost = pHost;
-        mGuest = pGuest;
+        mGuestThread = pGuestThread;
     }
 
-    void notify(void)
+    virtual void notify(void)
     {
         switch (mHost->getState())
         {
-        case VBoxGuestSeamlessGuest::ENABLE:
-             mGuest->start();
+        case VBoxGuestSeamlessHost::ENABLE:
+             mGuestThread->start();
             break;
-        case VBoxGuestSeamlessGuest::DISABLE:
-             mGuest->stop();
+        case VBoxGuestSeamlessHost::DISABLE:
+             mGuestThread->stop(RT_INDEFINITE_WAIT, 0);
             break;
         default:
@@ -108 +118 @@
     }
 
-    void notify(void)
+    virtual void notify(void)
     {
         mHost->updateRects(mGuest->getRects());
@@ -119 +129 @@
     VBoxGuestSeamlessHost mHost;
     VBoxGuestSeamlessGuestImpl mGuest;
+    VBoxGuestSeamlessGuestThread mGuestFunction;
+    VBoxGuestThread mGuestThread;
     VBoxGuestSeamlessHostObserver mHostObs;
     VBoxGuestSeamlessGuestObserver mGuestObs;
-    VBoxGuestSeamlessGuestThread mGuestFunction;
-    VBoxGuestThread mGuestThread;
 
     bool isInitialised;
@@ -132 +142 @@
         if (isInitialised)  /* Assertion */
         {
-            LogRelFunc(("error: called a second time!\n"));
+            LogRelFunc(("error: called a second time! (VBoxService)\n"));
             rc = VERR_INTERNAL_ERROR;
         }
@@ -149 +159 @@
         if (RT_SUCCESS(rc))
         {
-            rc = mGuestThread.start();
+            isInitialised = true;
         }
-        isInitialised = true;
+        if (RT_FAILURE(rc))
+        {
+            LogFunc(("returning %Rrc (VBoxService)\n", rc));
+        }
         return rc;
     }
@@ -159 +172 @@
         if (isInitialised)
         {
-            mGuestThread.stop();
             mHost.stop();
+            mGuestThread.stop(RT_INDEFINITE_WAIT, 0);
             mGuest.uninit();
             isInitialised = false;
@@ -166 +179 @@
     }
 
-    VBoxGuestSeamless() : mHostObs(&mHost, &mGuest), mHostObs(&mHost, &mGuest),
-                          mGuestFunction(&mGuest), mGuestThread(&mGuestFunction)
+    VBoxGuestSeamless() : mGuestFunction(&mGuest, &mGuestObs),
+                          mGuestThread(&mGuestFunction, 0, RTTHREADTYPE_MSG_PUMP,
+                                       RTTHREADFLAGS_WAITABLE, "Guest events"),
+                          mHostObs(&mHost, &mGuestThread), mGuestObs(&mHost, &mGuest)
     {
         isInitialised = false;

trunk/src/VBox/Additions/x11/xclient/thread.h

@@ -30 +30 @@
 {
 public:
-    VBoxGuestThreadFunction(void);
+    // VBoxGuestThreadFunction(void);
     virtual ~VBoxGuestThreadFunction(void) {}
     /**

trunk/src/testcase/tstRunTestcases.cpp

@@ -61 +61 @@
     "testcase/tstSDL",
     "testcase/tstTime-3",
+    "testcase/tstSeamlessX11",
     "./tstRunTestcases",
     "./tstAnimate",