add the --replace command line option, and support for the WM_Sn selection

[chaz/openbox] / openbox / screen.c

diff --git a/openbox/screen.c b/openbox/screen.c
index 75cc3c4c3cbe02887fa79c4db6e90f9edc9f4bae..3e3b9632d50ede9169864fb03a6a251b0c5aa0ef 100644 (file)
--- a/openbox/screen.c
+++ b/openbox/screen.c
@@ -30,53 +30,148 @@
                        SubstructureNotifyMask | SubstructureRedirectMask | \
                        ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
 
                        SubstructureNotifyMask | SubstructureRedirectMask | \
                        ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
 

-guint    screen_num_desktops    = 0;
-guint    screen_num_monitors    = 0;
-guint    screen_desktop         = 0;
+guint    screen_num_desktops;
+guint    screen_num_monitors;
+guint    screen_desktop;

 Size     screen_physical_size;
 gboolean screen_showing_desktop;
 DesktopLayout screen_desktop_layout;
 Size     screen_physical_size;
 gboolean screen_showing_desktop;
 DesktopLayout screen_desktop_layout;

-char   **screen_desktop_names = NULL;
+char   **screen_desktop_names;
+Window   screen_support_win;

 
 

-static Rect  **area = NULL; /* array of desktop holding array of
-                               xinerama areas */
-static Rect  *monitor_area = NULL;
-static Window support_window = None;
+static Rect  **area; /* array of desktop holding array of xinerama areas */
+static Rect  *monitor_area;

 
 #ifdef USE_LIBSN
 static SnMonitorContext *sn_context;
 static int sn_busy_cnt;
 
 #ifdef USE_LIBSN
 static SnMonitorContext *sn_context;
 static int sn_busy_cnt;

-static Timer *sn_timer = NULL;
+static ObTimer *sn_timer;

 
 static void sn_event_func(SnMonitorEvent *event, void *data);
 #endif
 
 static void set_root_cursor();
 
 
 static void sn_event_func(SnMonitorEvent *event, void *data);
 #endif
 
 static void set_root_cursor();
 

-static gboolean running;
-static int another_running(Display *d, XErrorEvent *e)
+static gboolean replace_wm()

 {
 {

-    (void)d;(void)e;
-    g_message("A window manager is already running on screen %d",
-             ob_screen);
-    running = TRUE;
-    return -1;
+    char *wm_sn;
+    Atom wm_sn_atom;
+    Window current_wm_sn_owner;
+    Time timestamp;
+
+    wm_sn = g_strdup_printf("WM_S%d", ob_screen);
+    wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
+
+    current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
+    if (current_wm_sn_owner) {
+        if (!ob_replace_wm) {
+            g_message("A window manager is already running on screen %d",
+                      ob_screen);
+            return FALSE;
+        }
+        xerror_set_ignore(TRUE);
+        xerror_occured = FALSE;
+
+        /* We want to find out when the current selection owner dies */
+        XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
+        XSync(ob_display, FALSE);
+
+        xerror_set_ignore(FALSE);
+        if (xerror_occured)
+            current_wm_sn_owner = None;
+    }
+
+    {
+        /* Generate a timestamp */
+        XEvent event;
+
+        XSelectInput(ob_display, screen_support_win, PropertyChangeMask);
+
+        XChangeProperty(ob_display, screen_support_win,
+                        prop_atoms.wm_class, prop_atoms.string,
+                        8, PropModeAppend, NULL, 0);
+        XWindowEvent(ob_display, screen_support_win,
+                     PropertyChangeMask, &event);
+
+        XSelectInput(ob_display, screen_support_win, NoEventMask);
+
+        timestamp = event.xproperty.time;
+    }
+
+    XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
+                       timestamp);
+
+    if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
+        g_message("Could not acquire window manager selection on screen %d",
+                  ob_screen);
+        return FALSE;
+    }
+
+    /* Wait for old window manager to go away */
+    if (current_wm_sn_owner) {
+      XEvent event;
+      gulong wait = 0;
+      const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
+
+      while (wait < timeout) {
+          if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
+                                StructureNotifyMask, &event) &&
+              event.type == DestroyNotify)
+              break;
+          g_usleep(G_USEC_PER_SEC / 10);
+          wait += G_USEC_PER_SEC / 10;
+      }
+
+      if (wait >= timeout) {
+          g_message("Timeout expired while waiting for the current WM to die "
+                    "on screen %d", ob_screen);
+          return FALSE;
+      }
+    }
+
+    /* Send client message indicating that we are now the WM */
+    prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
+                 timestamp, wm_sn_atom, 0, 0, SubstructureNotifyMask);
+
+
+    return TRUE;

 }
 
 gboolean screen_annex()
 {
 }
 
 gboolean screen_annex()
 {

-    XErrorHandler old;
+    XSetWindowAttributes attrib;

     pid_t pid;
     pid_t pid;

-    int i, num_support;
+    gint i, num_support;

     guint32 *supported;
 
     guint32 *supported;
 

-    running = FALSE;
-    old = XSetErrorHandler(another_running);
-    XSelectInput(ob_display, ob_root, ROOT_EVENTMASK);
-    XSync(ob_display, FALSE);
-    XSetErrorHandler(old);
-    if (running)
+    /* create the netwm support window */
+    attrib.override_redirect = TRUE;
+    screen_support_win = XCreateWindow(ob_display,
+                                       RootWindow(ob_display, ob_screen),
+                                       -100, -100, 1, 1, 0,
+                                       CopyFromParent, InputOutput,
+                                       CopyFromParent,
+                                       CWOverrideRedirect, &attrib);
+    XMapRaised(ob_display, screen_support_win);
+
+    if (!replace_wm()) {
+        XDestroyWindow(ob_display, screen_support_win);
+        return FALSE;
+    }
+
+    xerror_set_ignore(TRUE);
+    xerror_occured = FALSE;
+    XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
+                 ROOT_EVENTMASK);
+    xerror_set_ignore(FALSE);
+    if (xerror_occured) {
+        g_message("A window manager is already running on screen %d",
+                  ob_screen);
+
+        XDestroyWindow(ob_display, screen_support_win);

        return FALSE;
        return FALSE;

+    }
+

 
     g_message("Managing screen %d", ob_screen);
 
 
     g_message("Managing screen %d", ob_screen);
 


@@ -84,17 +179,17 @@ gboolean screen_annex()
 
     /* set the OPENBOX_PID hint */
     pid = getpid();
 
     /* set the OPENBOX_PID hint */
     pid = getpid();

-    PROP_SET32(ob_root, openbox_pid, cardinal, pid);
-
-    /* create the netwm support window */
-    support_window = XCreateSimpleWindow(ob_display, ob_root, 0,0,1,1,0,0,0);
+    PROP_SET32(RootWindow(ob_display, ob_screen),
+               openbox_pid, cardinal, pid);

 
     /* set supporting window */
 
     /* set supporting window */

-    PROP_SET32(ob_root, net_supporting_wm_check, window, support_window);
+    PROP_SET32(RootWindow(ob_display, ob_screen),
+               net_supporting_wm_check, window, screen_support_win);

 
     /* set properties on the supporting window */
 
     /* set properties on the supporting window */

-    PROP_SETS(support_window, net_wm_name, "Openbox");
-    PROP_SET32(support_window, net_supporting_wm_check, window,support_window);
+    PROP_SETS(screen_support_win, net_wm_name, "Openbox");
+    PROP_SET32(screen_support_win, net_supporting_wm_check,
+               window, screen_support_win);

 
     /* set the _NET_SUPPORTED_ATOMS hint */
     num_support = 61;
 
     /* set the _NET_SUPPORTED_ATOMS hint */
     num_support = 61;


@@ -166,7 +261,8 @@ gboolean screen_annex()
   supported[] = prop_atoms.net_wm_action_stick;
 */
 
   supported[] = prop_atoms.net_wm_action_stick;
 */
 

-    PROP_SETA32(ob_root, net_supported, atom, supported, num_support);
+    PROP_SETA32(RootWindow(ob_display, ob_screen),
+                net_supported, atom, supported, num_support);

     g_free(supported);
 
     return TRUE;
     g_free(supported);
 
     return TRUE;


@@ -186,7 +282,8 @@ void screen_startup()
     for (i = 0, it = config_desktops_names; it; ++i, it = it->next)
         screen_desktop_names[i] = it->data; /* dont strdup */
     screen_desktop_names[i] = NULL;
     for (i = 0, it = config_desktops_names; it; ++i, it = it->next)
         screen_desktop_names[i] = it->data; /* dont strdup */
     screen_desktop_names[i] = NULL;

-    PROP_SETSS(ob_root, net_desktop_names, screen_desktop_names);
+    PROP_SETSS(RootWindow(ob_display, ob_screen),
+               net_desktop_names, screen_desktop_names);

     g_free(screen_desktop_names); /* dont free the individual strings */
     screen_desktop_names = NULL;
 
     g_free(screen_desktop_names); /* dont free the individual strings */
     screen_desktop_names = NULL;
 


@@ -199,7 +296,8 @@ void screen_startup()
 
     /* don't start in showing-desktop mode */
     screen_showing_desktop = FALSE;
 
     /* don't start in showing-desktop mode */
     screen_showing_desktop = FALSE;

-    PROP_SET32(ob_root, net_showing_desktop, cardinal, screen_showing_desktop);
+    PROP_SET32(RootWindow(ob_display, ob_screen),
+               net_showing_desktop, cardinal, screen_showing_desktop);

 
     screen_update_layout();
 
 
     screen_update_layout();
 


@@ -214,13 +312,16 @@ void screen_shutdown()
 {
     Rect **r;
 
 {
     Rect **r;
 

-    XSelectInput(ob_display, ob_root, NoEventMask);
+    XSelectInput(ob_display, RootWindow(ob_display, ob_screen), NoEventMask);

 
 

-    PROP_ERASE(ob_root, openbox_pid); /* we're not running here no more! */
-    PROP_ERASE(ob_root, net_supported); /* not without us */
-    PROP_ERASE(ob_root, net_showing_desktop); /* don't keep this mode */
+    /* we're not running here no more! */
+    PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
+    /* not without us */
+    PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
+    /* don't keep this mode */
+    PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);

 
 

-    XDestroyWindow(ob_display, support_window);
+    XDestroyWindow(ob_display, screen_support_win);

 
     g_strfreev(screen_desktop_names);
     for (r = area; *r; ++r)
 
     g_strfreev(screen_desktop_names);
     for (r = area; *r; ++r)


@@ -245,9 +346,10 @@ void screen_resize()
     /* Set the _NET_DESKTOP_GEOMETRY hint */
     screen_physical_size.width = geometry[0] = w;
     screen_physical_size.height = geometry[1] = h;
     /* Set the _NET_DESKTOP_GEOMETRY hint */
     screen_physical_size.width = geometry[0] = w;
     screen_physical_size.height = geometry[1] = h;

-    PROP_SETA32(ob_root, net_desktop_geometry, cardinal, geometry, 2);
+    PROP_SETA32(RootWindow(ob_display, ob_screen),
+                net_desktop_geometry, cardinal, geometry, 2);

 
 

-    if (ob_state == State_Starting)
+    if (ob_state() == OB_STATE_STARTING)

        return;
 
     dock_configure();
        return;
 
     dock_configure();


@@ -267,11 +369,13 @@ void screen_set_num_desktops(guint num)
 
     old = screen_num_desktops;
     screen_num_desktops = num;
 
     old = screen_num_desktops;
     screen_num_desktops = num;

-    PROP_SET32(ob_root, net_number_of_desktops, cardinal, num);
+    PROP_SET32(RootWindow(ob_display, ob_screen),
+               net_number_of_desktops, cardinal, num);

 
     /* set the viewport hint */
     viewport = g_new0(guint32, num * 2);
 
     /* set the viewport hint */
     viewport = g_new0(guint32, num * 2);

-    PROP_SETA32(ob_root, net_desktop_viewport, cardinal, viewport, num * 2);
+    PROP_SETA32(RootWindow(ob_display, ob_screen),
+                net_desktop_viewport, cardinal, viewport, num * 2);

     g_free(viewport);
 
     /* the number of rows/columns will differ */
     g_free(viewport);
 
     /* the number of rows/columns will differ */


@@ -292,7 +396,7 @@ void screen_set_num_desktops(guint num)
 
     /* move windows on desktops that will no longer exist! */
     for (it = client_list; it != NULL; it = it->next) {
 
     /* move windows on desktops that will no longer exist! */
     for (it = client_list; it != NULL; it = it->next) {

-        Client *c = it->data;
+        ObClient *c = it->data;

         if (c->desktop >= num && c->desktop != DESKTOP_ALL)
             client_set_desktop(c, num - 1, FALSE);
     }
         if (c->desktop >= num && c->desktop != DESKTOP_ALL)
             client_set_desktop(c, num - 1, FALSE);
     }


@@ -317,7 +421,8 @@ void screen_set_desktop(guint num)
 
     old = screen_desktop;
     screen_desktop = num;
 
     old = screen_desktop;
     screen_desktop = num;

-    PROP_SET32(ob_root, net_current_desktop, cardinal, num);
+    PROP_SET32(RootWindow(ob_display, ob_screen),
+               net_current_desktop, cardinal, num);

 
     if (old == num) return;
 
 
     if (old == num) return;
 


@@ -328,7 +433,7 @@ void screen_set_desktop(guint num)
     /* show windows from top to bottom */
     for (it = stacking_list; it != NULL; it = it->next) {
         if (WINDOW_IS_CLIENT(it->data)) {
     /* show windows from top to bottom */
     for (it = stacking_list; it != NULL; it = it->next) {
         if (WINDOW_IS_CLIENT(it->data)) {

-            Client *c = it->data;
+            ObClient *c = it->data;

             if (!c->frame->visible && client_should_show(c))
                 frame_show(c->frame);
         }
             if (!c->frame->visible && client_should_show(c))
                 frame_show(c->frame);
         }


@@ -337,7 +442,7 @@ void screen_set_desktop(guint num)
     /* hide windows from bottom to top */
     for (it = g_list_last(stacking_list); it != NULL; it = it->prev) {
         if (WINDOW_IS_CLIENT(it->data)) {
     /* hide windows from bottom to top */
     for (it = g_list_last(stacking_list); it != NULL; it = it->prev) {
         if (WINDOW_IS_CLIENT(it->data)) {

-            Client *c = it->data;
+            ObClient *c = it->data;

             if (c->frame->visible && !client_should_show(c))
                 frame_hide(c->frame);
         }
             if (c->frame->visible && !client_should_show(c))
                 frame_hide(c->frame);
         }


@@ -346,42 +451,56 @@ void screen_set_desktop(guint num)
     /* focus the last focused window on the desktop, and ignore enter events
        from the switch so it doesnt mess with the focus */
     while (XCheckTypedEvent(ob_display, EnterNotify, &e));
     /* focus the last focused window on the desktop, and ignore enter events
        from the switch so it doesnt mess with the focus */
     while (XCheckTypedEvent(ob_display, EnterNotify, &e));

+#ifdef DEBUG_FOCUS

     g_message("switch fallback");
     g_message("switch fallback");

-    focus_fallback(Fallback_Desktop);
+#endif
+    focus_fallback(OB_FOCUS_FALLBACK_DESKTOP);
+#ifdef DEBUG_FOCUS

     g_message("/switch fallback");
     g_message("/switch fallback");

+#endif

 
     dispatch_ob(Event_Ob_Desktop, num, old);
 }
 
 void screen_update_layout()
 {
 
     dispatch_ob(Event_Ob_Desktop, num, old);
 }
 
 void screen_update_layout()
 {

-    guint32 *data = NULL;
+    ObOrientation orient;
+    ObCorner corner;
+    guint rows;
+    guint cols;
+    guint32 *data;

     guint num;
     guint num;

+    gboolean valid = FALSE;

 
 

-    /* defaults */
-    screen_desktop_layout.orientation = prop_atoms.net_wm_orientation_horz;
-    screen_desktop_layout.start_corner = prop_atoms.net_wm_topleft;
-    screen_desktop_layout.rows = 1;
-    screen_desktop_layout.columns = screen_num_desktops;
-
-    if (PROP_GETA32(ob_root, net_desktop_layout, cardinal, &data, &num)) {
+    if (PROP_GETA32(RootWindow(ob_display, ob_screen),
+                    net_desktop_layout, cardinal, &data, &num)) {

         if (num == 3 || num == 4) {
         if (num == 3 || num == 4) {

+

             if (data[0] == prop_atoms.net_wm_orientation_vert)
             if (data[0] == prop_atoms.net_wm_orientation_vert)

-                screen_desktop_layout.orientation = data[0];
-            if (num == 3)
-                screen_desktop_layout.start_corner =
-                    prop_atoms.net_wm_topright;
+                orient = OB_ORIENTATION_VERT;
+            else if (data[0] == prop_atoms.net_wm_orientation_horz)
+                orient = OB_ORIENTATION_HORZ;
+            else
+                goto screen_update_layout_bail;
+
+            if (num < 4)
+                corner = OB_CORNER_TOPLEFT;

             else {
                 if (data[3] == prop_atoms.net_wm_topright)
             else {
                 if (data[3] == prop_atoms.net_wm_topright)

-                    screen_desktop_layout.start_corner = data[3];
+                    corner = OB_CORNER_TOPRIGHT;

                 else if (data[3] == prop_atoms.net_wm_bottomright)
                 else if (data[3] == prop_atoms.net_wm_bottomright)

-                    screen_desktop_layout.start_corner = data[3];
+                    corner = OB_CORNER_BOTTOMRIGHT;

                 else if (data[3] == prop_atoms.net_wm_bottomleft)
                 else if (data[3] == prop_atoms.net_wm_bottomleft)

-                    screen_desktop_layout.start_corner = data[3];
+                    corner = OB_CORNER_BOTTOMLEFT;
+                else
+                    goto screen_update_layout_bail;

             }
 
             /* fill in a zero rows/columns */
             }
 
             /* fill in a zero rows/columns */

-            if (!(data[1] == 0 && data[2] == 0)) { /* both 0's is bad data.. */
+            if ((data[1] == 0 && data[2] == 0) || /* both 0's is bad data.. */
+                (data[1] != 0 && data[2] != 0)) { /* no 0's is bad data.. */
+                goto screen_update_layout_bail;
+            } else {

                 if (data[1] == 0) {
                     data[1] = (screen_num_desktops +
                                screen_num_desktops % data[2]) / data[2];
                 if (data[1] == 0) {
                     data[1] = (screen_num_desktops +
                                screen_num_desktops % data[2]) / data[2];


@@ -389,38 +508,39 @@ void screen_update_layout()
                     data[2] = (screen_num_desktops +
                                screen_num_desktops % data[1]) / data[1];
                 }
                     data[2] = (screen_num_desktops +
                                screen_num_desktops % data[1]) / data[1];
                 }

-                screen_desktop_layout.columns = data[1];
-                screen_desktop_layout.rows = data[2];
+                cols = data[1];
+                rows = data[2];

             }
 
             /* bounds checking */
             }
 
             /* bounds checking */

-            if (screen_desktop_layout.orientation ==
-                prop_atoms.net_wm_orientation_horz) {
-                if (screen_desktop_layout.rows > screen_num_desktops)
-                    screen_desktop_layout.rows = screen_num_desktops;
-                if (screen_desktop_layout.columns >
-                    ((screen_num_desktops + screen_num_desktops %
-                      screen_desktop_layout.rows) /
-                     screen_desktop_layout.rows))
-                    screen_desktop_layout.columns =
-                        (screen_num_desktops + screen_num_desktops %
-                         screen_desktop_layout.rows) /
-                        screen_desktop_layout.rows;
+            if (orient == OB_ORIENTATION_HORZ) {
+                rows = MIN(rows, screen_num_desktops);
+                cols = MIN(cols, ((screen_num_desktops +
+                                     (screen_num_desktops % rows)) / rows));

             } else {
             } else {

-                if (screen_desktop_layout.columns > screen_num_desktops)
-                    screen_desktop_layout.columns = screen_num_desktops;
-                if (screen_desktop_layout.rows >
-                    ((screen_num_desktops + screen_num_desktops %
-                      screen_desktop_layout.columns) /
-                     screen_desktop_layout.columns))
-                    screen_desktop_layout.rows =
-                        (screen_num_desktops + screen_num_desktops %
-                         screen_desktop_layout.columns) /
-                        screen_desktop_layout.columns;
+                cols = MIN(cols, screen_num_desktops);
+                rows = MIN(rows, ((screen_num_desktops +
+                                     (screen_num_desktops % cols)) / cols));

             }
             }

+
+            valid = TRUE;

         }
         }

-       g_free(data);
+    screen_update_layout_bail:
+        g_free(data);
+    }
+
+    if (!valid) {
+        /* defaults */
+        orient = OB_ORIENTATION_HORZ;
+        corner = OB_CORNER_TOPLEFT;
+        rows = 1;
+        cols = screen_num_desktops;

     }
     }

+
+    screen_desktop_layout.orientation = orient;
+    screen_desktop_layout.start_corner = corner;
+    screen_desktop_layout.rows = rows;
+    screen_desktop_layout.columns = cols;

 }
 
 void screen_update_desktop_names()
 }
 
 void screen_update_desktop_names()


@@ -431,7 +551,8 @@ void screen_update_desktop_names()
     g_strfreev(screen_desktop_names);
     screen_desktop_names = NULL;
 
     g_strfreev(screen_desktop_names);
     screen_desktop_names = NULL;
 

-    if (PROP_GETSS(ob_root, net_desktop_names, utf8, &screen_desktop_names))
+    if (PROP_GETSS(RootWindow(ob_display, ob_screen),
+                   net_desktop_names, utf8, &screen_desktop_names))

         for (i = 0; screen_desktop_names[i] && i <= screen_num_desktops; ++i);
     else
         i = 0;
         for (i = 0; screen_desktop_names[i] && i <= screen_num_desktops; ++i);
     else
         i = 0;


@@ -456,7 +577,7 @@ void screen_show_desktop(gboolean show)
        /* bottom to top */
        for (it = g_list_last(stacking_list); it != NULL; it = it->prev) {
             if (WINDOW_IS_CLIENT(it->data)) {
        /* bottom to top */
        for (it = g_list_last(stacking_list); it != NULL; it = it->prev) {
             if (WINDOW_IS_CLIENT(it->data)) {

-                Client *client = it->data;
+                ObClient *client = it->data;

                 if (client->frame->visible && !client_should_show(client))
                     frame_hide(client->frame);
             }
                 if (client->frame->visible && !client_should_show(client))
                     frame_hide(client->frame);
             }


@@ -465,7 +586,7 @@ void screen_show_desktop(gboolean show)
         /* top to bottom */
        for (it = stacking_list; it != NULL; it = it->next) {
             if (WINDOW_IS_CLIENT(it->data)) {
         /* top to bottom */
        for (it = stacking_list; it != NULL; it = it->next) {
             if (WINDOW_IS_CLIENT(it->data)) {

-                Client *client = it->data;
+                ObClient *client = it->data;

                 if (!client->frame->visible && client_should_show(client))
                     frame_show(client->frame);
             }
                 if (!client->frame->visible && client_should_show(client))
                     frame_show(client->frame);
             }


@@ -475,20 +596,21 @@ void screen_show_desktop(gboolean show)
     if (show) {
         /* focus desktop */
         for (it = focus_order[screen_desktop]; it; it = it->next)
     if (show) {
         /* focus desktop */
         for (it = focus_order[screen_desktop]; it; it = it->next)

-            if (((Client*)it->data)->type == Type_Desktop &&
+            if (((ObClient*)it->data)->type == OB_CLIENT_TYPE_DESKTOP &&

                 client_focus(it->data))
                 break;
     } else {
                 client_focus(it->data))
                 break;
     } else {

-        focus_fallback(Fallback_NoFocus);
+        focus_fallback(OB_FOCUS_FALLBACK_NOFOCUS);

     }
 
     show = !!show; /* make it boolean */
     }
 
     show = !!show; /* make it boolean */

-    PROP_SET32(ob_root, net_showing_desktop, cardinal, show);
+    PROP_SET32(RootWindow(ob_display, ob_screen),
+               net_showing_desktop, cardinal, show);

 
     dispatch_ob(Event_Ob_ShowDesktop, show, 0);
 }
 
 
     dispatch_ob(Event_Ob_ShowDesktop, show, 0);
 }
 

-void screen_install_colormap(Client *client, gboolean install)
+void screen_install_colormap(ObClient *client, gboolean install)

 {
     XWindowAttributes wa;
 
 {
     XWindowAttributes wa;
 


@@ -559,7 +681,7 @@ void screen_update_areas()
         /* apply struts */
         STRUT_SET(s, 0, 0, 0, 0);
         for (it = client_list; it; it = it->next)
         /* apply struts */
         STRUT_SET(s, 0, 0, 0, 0);
         for (it = client_list; it; it = it->next)

-            STRUT_ADD(s, ((Client*)it->data)->strut);
+            STRUT_ADD(s, ((ObClient*)it->data)->strut);

         STRUT_ADD(s, dock_strut);
 
         if (s.left) {
         STRUT_ADD(s, dock_strut);
 
         if (s.left) {


@@ -648,7 +770,7 @@ void screen_update_areas()
                 XXX if gunna test this shit, then gotta worry about when
                 the client moves between xinerama heads..
 
                 XXX if gunna test this shit, then gotta worry about when
                 the client moves between xinerama heads..
 

-                if (RECT_CONTAINS_RECT(((Client*)it->data)->frame->area,
+                if (RECT_CONTAINS_RECT(((ObClient*)it->data)->frame->area,

                                        area[i][x])) {
 
                 }            
                                        area[i][x])) {
 
                 }            


@@ -661,7 +783,7 @@ void screen_update_areas()
         /* the area has changed, adjust all the maximized 
            windows */
         for (it = client_list; it; it = it->next) {
         /* the area has changed, adjust all the maximized 
            windows */
         for (it = client_list; it; it = it->next) {

-            Client *c = it->data; 
+            ObClient *c = it->data; 

             if (i < screen_num_desktops) {
                 if (c->desktop == i)
                     client_reconfigure(c);
             if (i < screen_num_desktops) {
                 if (c->desktop == i)
                     client_reconfigure(c);


@@ -676,7 +798,7 @@ void screen_update_areas()
             dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
         }
     }
             dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
         }
     }

-    PROP_SETA32(ob_root, net_workarea, cardinal,
+    PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,

                dims, 4 * screen_num_desktops);
 
     g_free(dims);
                dims, 4 * screen_num_desktops);
 
     g_free(dims);


@@ -715,10 +837,12 @@ static void set_root_cursor()
 {
 #ifdef USE_LIBSN
         if (sn_busy_cnt)
 {
 #ifdef USE_LIBSN
         if (sn_busy_cnt)

-            XDefineCursor(ob_display, ob_root, ob_cursors.busy);
+            XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
+                          ob_cursor(OB_CURSOR_BUSY));

         else
 #endif
         else
 #endif

-            XDefineCursor(ob_display, ob_root, ob_cursors.ptr);
+            XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
+                          ob_cursor(OB_CURSOR_POINTER));

 }
 
 #ifdef USE_LIBSN
 }
 
 #ifdef USE_LIBSN


@@ -775,3 +899,13 @@ static void sn_event_func(SnMonitorEvent *ev, void *data)
         set_root_cursor();
 }
 #endif
         set_root_cursor();
 }
 #endif

+
+gboolean screen_pointer_pos(int *x, int *y)
+{
+    Window w;
+    int i;
+    guint u;
+
+    return !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
+                           &w, &w, x, y, &i, &i, &u);
+}