openbox/screen.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    screen.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "debug.h"
  21 #include "openbox.h"
  22 #include "dock.h"
  23 #include "grab.h"
  24 #include "startupnotify.h"
  25 #include "moveresize.h"
  26 #include "config.h"
  27 #include "screen.h"
  28 #include "client.h"
  29 #include "session.h"
  30 #include "frame.h"
  31 #include "event.h"
  32 #include "focus.h"
  33 #include "popup.h"
  34 #include "render/render.h"
  35 #include "gettext.h"
  36 #include "obt/display.h"
  37 #include "obt/prop.h"
  38 #include "obt/mainloop.h"
  39
  40 #include <X11/Xlib.h>
  41 #ifdef HAVE_UNISTD_H
  42 #  include <sys/types.h>
  43 #  include <unistd.h>
  44 #endif
  45 #include <assert.h>
  46
  47 /*! The event mask to grab on the root window */
  48 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
  49                         EnterWindowMask | LeaveWindowMask | \
  50                         SubstructureRedirectMask | FocusChangeMask | \
  51                         ButtonPressMask | ButtonReleaseMask)
  52
  53 static gboolean screen_validate_layout(ObDesktopLayout *l);
  54 static gboolean replace_wm(void);
  55 static void     screen_tell_ksplash(void);
  56 static void     screen_fallback_focus(void);
  57
  58 guint           screen_num_desktops;
  59 guint           screen_num_monitors;
  60 guint           screen_desktop;
  61 guint           screen_last_desktop;
  62 gboolean        screen_showing_desktop;
  63 ObDesktopLayout screen_desktop_layout;
  64 gchar         **screen_desktop_names;
  65 Window          screen_support_win;
  66 Time            screen_desktop_user_time = CurrentTime;
  67
  68 static Size     screen_physical_size;
  69 static guint    screen_old_desktop;
  70 static gboolean screen_desktop_timeout = TRUE;
  71 /*! An array of desktops, holding an array of areas per monitor */
  72 static Rect  *monitor_area = NULL;
  73 /*! An array of desktops, holding an array of struts */
  74 static GSList *struts_top = NULL;
  75 static GSList *struts_left = NULL;
  76 static GSList *struts_right = NULL;
  77 static GSList *struts_bottom = NULL;
  78
  79 static ObPagerPopup *desktop_popup;
  80
  81 /*! The number of microseconds that you need to be on a desktop before it will
  82   replace the remembered "last desktop" */
  83 #define REMEMBER_LAST_DESKTOP_TIME 750000
  84
  85 static gboolean replace_wm(void)
  86 {
  87     gchar *wm_sn;
  88     Atom wm_sn_atom;
  89     Window current_wm_sn_owner;
  90     Time timestamp;
  91
  92     wm_sn = g_strdup_printf("WM_S%d", ob_screen);
  93     wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
  94     g_free(wm_sn);
  95
  96     current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
  97     if (current_wm_sn_owner == screen_support_win)
  98         current_wm_sn_owner = None;
  99     if (current_wm_sn_owner) {
 100         if (!ob_replace_wm) {
 101             g_message(_("A window manager is already running on screen %d"),
 102                       ob_screen);
 103             return FALSE;
 104         }
 105         obt_display_ignore_errors(TRUE);
 106
 107         /* We want to find out when the current selection owner dies */
 108         XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
 109         XSync(obt_display, FALSE);
 110
 111         obt_display_ignore_errors(FALSE);
 112         if (obt_display_error_occured)
 113             current_wm_sn_owner = None;
 114     }
 115
 116     timestamp = event_get_server_time();
 117
 118     XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
 119                        timestamp);
 120
 121     if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
 122         g_message(_("Could not acquire window manager selection on screen %d"),
 123                   ob_screen);
 124         return FALSE;
 125     }
 126
 127     /* Wait for old window manager to go away */
 128     if (current_wm_sn_owner) {
 129       XEvent event;
 130       gulong wait = 0;
 131       const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
 132
 133       while (wait < timeout) {
 134           if (XCheckWindowEvent(obt_display, current_wm_sn_owner,
 135                                 StructureNotifyMask, &event) &&
 136               event.type == DestroyNotify)
 137               break;
 138           g_usleep(G_USEC_PER_SEC / 10);
 139           wait += G_USEC_PER_SEC / 10;
 140       }
 141
 142       if (wait >= timeout) {
 143           g_message(_("The WM on screen %d is not exiting"), ob_screen);
 144           return FALSE;
 145       }
 146     }
 147
 148     /* Send client message indicating that we are now the WM */
 149     obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
 150                      timestamp, wm_sn_atom, screen_support_win, 0, 0,
 151                      SubstructureNotifyMask);
 152
 153     return TRUE;
 154 }
 155
 156 gboolean screen_annex(void)
 157 {
 158     XSetWindowAttributes attrib;
 159     pid_t pid;
 160     gint i, num_support;
 161     gulong *supported;
 162
 163     /* create the netwm support window */
 164     attrib.override_redirect = TRUE;
 165     attrib.event_mask = PropertyChangeMask;
 166     screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
 167                                        -100, -100, 1, 1, 0,
 168                                        CopyFromParent, InputOutput,
 169                                        CopyFromParent,
 170                                        CWEventMask | CWOverrideRedirect,
 171                                        &attrib);
 172     XMapWindow(obt_display, screen_support_win);
 173     XLowerWindow(obt_display, screen_support_win);
 174
 175     if (!replace_wm()) {
 176         XDestroyWindow(obt_display, screen_support_win);
 177         return FALSE;
 178     }
 179
 180     obt_display_ignore_errors(TRUE);
 181     XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
 182     obt_display_ignore_errors(FALSE);
 183     if (obt_display_error_occured) {
 184         g_message(_("A window manager is already running on screen %d"),
 185                   ob_screen);
 186
 187         XDestroyWindow(obt_display, screen_support_win);
 188         return FALSE;
 189     }
 190
 191     screen_set_root_cursor();
 192
 193     /* set the OPENBOX_PID hint */
 194     pid = getpid();
 195     OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
 196
 197     /* set supporting window */
 198     OBT_PROP_SET32(obt_root(ob_screen),
 199                    NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
 200
 201     /* set properties on the supporting window */
 202     OBT_PROP_SETS(screen_support_win, NET_WM_NAME, utf8, "Openbox");
 203     OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK,
 204                    WINDOW, screen_support_win);
 205
 206     /* set the _NET_SUPPORTED_ATOMS hint */
 207
 208     /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
 209     num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
 210     i = 0;
 211     supported = g_new(gulong, num_support);
 212     supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
 213     supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
 214     supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
 215     supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
 216     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
 217     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
 218     supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
 219     supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
 220     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
 221     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
 222     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
 223     supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
 224     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
 225     supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
 226     supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
 227     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
 228     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
 229     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
 230     supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
 231     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
 232     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
 233     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
 234     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
 235     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
 236     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
 237     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
 238     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
 239     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
 240     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
 241     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
 242     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
 243     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
 244     supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
 245     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
 246     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
 247     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
 248     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
 249     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
 250     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
 251     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
 252     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
 253     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
 254     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
 255     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
 256     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
 257     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
 258     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
 259     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
 260     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
 261     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
 262     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
 263     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
 264     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
 265     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
 266     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
 267     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
 268     supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
 269     supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
 270     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
 271 /*
 272     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
 273 */
 274     supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
 275     supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
 276     supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
 277     supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
 278 #ifdef SYNC
 279     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
 280     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
 281 #endif
 282     supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
 283     supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
 284
 285     supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
 286     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
 287     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
 288
 289     supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
 290     supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
 291     supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
 292     supported[i++] = OBT_PROP_ATOM(OB_THEME);
 293     supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
 294     supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
 295     g_assert(i == num_support);
 296
 297     OBT_PROP_SETA32(obt_root(ob_screen),
 298                     NET_SUPPORTED, ATOM, supported, num_support);
 299     g_free(supported);
 300
 301     screen_tell_ksplash();
 302
 303     return TRUE;
 304 }
 305
 306 static void screen_tell_ksplash(void)
 307 {
 308     XEvent e;
 309     char **argv;
 310
 311     argv = g_new(gchar*, 6);
 312     argv[0] = g_strdup("dcop");
 313     argv[1] = g_strdup("ksplash");
 314     argv[2] = g_strdup("ksplash");
 315     argv[3] = g_strdup("upAndRunning(QString)");
 316     argv[4] = g_strdup("wm started");
 317     argv[5] = NULL;
 318
 319     /* tell ksplash through the dcop server command line interface */
 320     g_spawn_async(NULL, argv, NULL,
 321                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
 322                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
 323                   NULL, NULL, NULL, NULL);
 324     g_strfreev(argv);
 325
 326     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
 327        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
 328        something. oh well. */
 329     e.xclient.type = ClientMessage;
 330     e.xclient.display = obt_display;
 331     e.xclient.window = obt_root(ob_screen);
 332     e.xclient.message_type =
 333         XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
 334     e.xclient.format = 8;
 335     strcpy(e.xclient.data.b, "wm started");
 336     XSendEvent(obt_display, obt_root(ob_screen),
 337                False, SubstructureNotifyMask, &e);
 338 }
 339
 340 void screen_startup(gboolean reconfig)
 341 {
 342     gchar **names = NULL;
 343     guint32 d;
 344     gboolean namesexist = FALSE;
 345
 346     desktop_popup = pager_popup_new();
 347     pager_popup_height(desktop_popup, POPUP_HEIGHT);
 348
 349     if (reconfig) {
 350         /* update the pager popup's width */
 351         pager_popup_text_width_to_strings(desktop_popup,
 352                                           screen_desktop_names,
 353                                           screen_num_desktops);
 354         return;
 355     }
 356
 357     /* get the initial size */
 358     screen_resize();
 359
 360     /* have names already been set for the desktops? */
 361     if (OBT_PROP_GETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, utf8, &names)) {
 362         g_strfreev(names);
 363         namesexist = TRUE;
 364     }
 365
 366     /* if names don't exist and we have session names, set those.
 367        do this stuff BEFORE setting the number of desktops, because that
 368        will create default names for them
 369     */
 370     if (!namesexist && session_desktop_names != NULL) {
 371         guint i, numnames;
 372         GSList *it;
 373
 374         /* get the desktop names */
 375         numnames = g_slist_length(session_desktop_names);
 376         names = g_new(gchar*, numnames + 1);
 377         names[numnames] = NULL;
 378         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
 379             names[i] = g_strdup(it->data);
 380
 381         /* set the root window property */
 382         OBT_PROP_SETSS(obt_root(ob_screen),
 383                        NET_DESKTOP_NAMES, utf8, (const gchar**)names);
 384
 385         g_strfreev(names);
 386     }
 387
 388     /* set the number of desktops, if it's not already set.
 389
 390        this will also set the default names from the config file up for
 391        desktops that don't have names yet */
 392     screen_num_desktops = 0;
 393     if (OBT_PROP_GET32(obt_root(ob_screen),
 394                        NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
 395     {
 396         if (d != config_desktops_num) {
 397             /* TRANSLATORS: If you need to specify a different order of the
 398                arguments, you can use %1$d for the first one and %2$d for the
 399                second one. For example,
 400                "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
 401             g_warning(_("Openbox is configured for %d desktops, but the current session has %d.  Overriding the Openbox configuration."),
 402                       config_desktops_num, d);
 403         }
 404         screen_set_num_desktops(d);
 405     }
 406     /* restore from session if possible */
 407     else if (session_num_desktops)
 408         screen_set_num_desktops(session_num_desktops);
 409     else
 410         screen_set_num_desktops(config_desktops_num);
 411
 412     screen_desktop = screen_num_desktops;  /* something invalid */
 413     /* start on the current desktop when a wm was already running */
 414     if (OBT_PROP_GET32(obt_root(ob_screen),
 415                        NET_CURRENT_DESKTOP, CARDINAL, &d) &&
 416         d < screen_num_desktops)
 417     {
 418         screen_set_desktop(d, FALSE);
 419     } else if (session_desktop >= 0)
 420         screen_set_desktop(MIN((guint)session_desktop,
 421                                screen_num_desktops), FALSE);
 422     else
 423         screen_set_desktop(MIN(config_screen_firstdesk,
 424                                screen_num_desktops) - 1, FALSE);
 425     screen_last_desktop = screen_desktop;
 426
 427     /* don't start in showing-desktop mode */
 428     screen_showing_desktop = FALSE;
 429     OBT_PROP_SET32(obt_root(ob_screen),
 430                    NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
 431
 432     if (session_desktop_layout_present &&
 433         screen_validate_layout(&session_desktop_layout))
 434     {
 435         screen_desktop_layout = session_desktop_layout;
 436     }
 437     else
 438         screen_update_layout();
 439 }
 440
 441 void screen_shutdown(gboolean reconfig)
 442 {
 443     pager_popup_free(desktop_popup);
 444
 445     if (reconfig)
 446         return;
 447
 448     XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
 449
 450     /* we're not running here no more! */
 451     OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
 452     /* not without us */
 453     OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
 454     /* don't keep this mode */
 455     OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
 456
 457     XDestroyWindow(obt_display, screen_support_win);
 458
 459     g_strfreev(screen_desktop_names);
 460     screen_desktop_names = NULL;
 461 }
 462
 463 void screen_resize(void)
 464 {
 465     static gint oldw = 0, oldh = 0;
 466     gint w, h;
 467     GList *it;
 468     gulong geometry[2];
 469
 470     w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 471     h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 472
 473     if (w == oldw && h == oldh) return;
 474
 475     oldw = w; oldh = h;
 476
 477     /* Set the _NET_DESKTOP_GEOMETRY hint */
 478     screen_physical_size.width = geometry[0] = w;
 479     screen_physical_size.height = geometry[1] = h;
 480     OBT_PROP_SETA32(obt_root(ob_screen),
 481                     NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
 482
 483     if (ob_state() == OB_STATE_STARTING)
 484         return;
 485
 486     screen_update_areas();
 487     dock_configure();
 488
 489     for (it = client_list; it; it = g_list_next(it))
 490         client_move_onscreen(it->data, FALSE);
 491 }
 492
 493 void screen_set_num_desktops(guint num)
 494 {
 495     guint old;
 496     gulong *viewport;
 497     GList *it, *stacking_copy;
 498
 499     g_assert(num > 0);
 500
 501     if (screen_num_desktops == num) return;
 502
 503     old = screen_num_desktops;
 504     screen_num_desktops = num;
 505     OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
 506
 507     /* set the viewport hint */
 508     viewport = g_new0(gulong, num * 2);
 509     OBT_PROP_SETA32(obt_root(ob_screen),
 510                     NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
 511     g_free(viewport);
 512
 513     /* the number of rows/columns will differ */
 514     screen_update_layout();
 515
 516     /* move windows on desktops that will no longer exist!
 517        make a copy of the list cuz we're changing it */
 518     stacking_copy = g_list_copy(stacking_list);
 519     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 520         if (WINDOW_IS_CLIENT(it->data)) {
 521             ObClient *c = it->data;
 522             if (c->desktop != DESKTOP_ALL && c->desktop >= num)
 523                 client_set_desktop(c, num - 1, FALSE, TRUE);
 524             /* raise all the windows that are on the current desktop which
 525                is being merged */
 526             else if (screen_desktop == num - 1 &&
 527                      (c->desktop == DESKTOP_ALL ||
 528                       c->desktop == screen_desktop))
 529                 stacking_raise(CLIENT_AS_WINDOW(c));
 530         }
 531     }
 532     g_list_free(stacking_copy);
 533
 534     /* change our struts/area to match (after moving windows) */
 535     screen_update_areas();
 536
 537     /* may be some unnamed desktops that we need to fill in with names
 538        (after updating the areas so the popup can resize) */
 539     screen_update_desktop_names();
 540
 541     /* change our desktop if we're on one that no longer exists! */
 542     if (screen_desktop >= screen_num_desktops)
 543         screen_set_desktop(num - 1, TRUE);
 544 }
 545
 546 static void screen_fallback_focus(void)
 547 {
 548     ObClient *c;
 549     gboolean allow_omni;
 550
 551     /* only allow omnipresent windows to get focus on desktop change if
 552        an omnipresent window is already focused (it'll keep focus probably, but
 553        maybe not depending on mouse-focus options) */
 554     allow_omni = focus_client && (client_normal(focus_client) &&
 555                                   focus_client->desktop == DESKTOP_ALL);
 556
 557     /* the client moved there already so don't move focus. prevent flicker
 558        on sendtodesktop + follow */
 559     if (focus_client && focus_client->desktop == screen_desktop)
 560         return;
 561
 562     /* have to try focus here because when you leave an empty desktop
 563        there is no focus out to watch for. also, we have different rules
 564        here. we always allow it to look under the mouse pointer if
 565        config_focus_last is FALSE
 566
 567        do this before hiding the windows so if helper windows are coming
 568        with us, they don't get hidden
 569     */
 570     if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
 571                             !allow_omni)))
 572     {
 573         /* only do the flicker reducing stuff ahead of time if we are going
 574            to call xsetinputfocus on the window ourselves. otherwise there is
 575            no guarantee the window will actually take focus.. */
 576         if (c->can_focus) {
 577             /* reduce flicker by hiliting now rather than waiting for the
 578                server FocusIn event */
 579             frame_adjust_focus(c->frame, TRUE);
 580             /* do this here so that if you switch desktops to a window with
 581                helper windows then the helper windows won't flash */
 582             client_bring_helper_windows(c);
 583         }
 584     }
 585 }
 586
 587 static gboolean last_desktop_func(gpointer data)
 588 {
 589     screen_desktop_timeout = TRUE;
 590     return FALSE;
 591 }
 592
 593 void screen_set_desktop(guint num, gboolean dofocus)
 594 {
 595     GList *it;
 596     guint previous;
 597     gulong ignore_start;
 598
 599     g_assert(num < screen_num_desktops);
 600
 601     previous = screen_desktop;
 602     screen_desktop = num;
 603
 604     if (previous == num) return;
 605
 606     OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
 607
 608     /* This whole thing decides when/how to save the screen_last_desktop so
 609        that it can be restored later if you want */
 610     if (screen_desktop_timeout) {
 611         /* If screen_desktop_timeout is true, then we've been on this desktop
 612            long enough and we can save it as the last desktop. */
 613
 614         if (screen_last_desktop == previous)
 615             /* this is the startup state only */
 616             screen_old_desktop = screen_desktop;
 617         else {
 618             /* save the "last desktop" as the "old desktop" */
 619             screen_old_desktop = screen_last_desktop;
 620             /* save the desktop we're coming from as the "last desktop" */
 621             screen_last_desktop = previous;
 622         }
 623     }
 624     else {
 625         /* If screen_desktop_timeout is false, then we just got to this desktop
 626            and we are moving away again. */
 627
 628         if (screen_desktop == screen_last_desktop) {
 629             /* If we are moving to the "last desktop" .. */
 630             if (previous == screen_old_desktop) {
 631                 /* .. from the "old desktop", change the last desktop to
 632                    be where we are coming from */
 633                 screen_last_desktop = screen_old_desktop;
 634             }
 635             else if (screen_last_desktop == screen_old_desktop) {
 636                 /* .. and also to the "old desktop", change the "last
 637                    desktop" to be where we are coming from */
 638                 screen_last_desktop = previous;
 639             }
 640             else {
 641                 /* .. from some other desktop, then set the "last desktop" to
 642                    be the saved "old desktop", i.e. where we were before the
 643                    "last desktop" */
 644                 screen_last_desktop = screen_old_desktop;
 645             }
 646         }
 647         else {
 648             /* If we are moving to any desktop besides the "last desktop"..
 649                (this is the normal case) */
 650             if (screen_desktop == screen_old_desktop) {
 651                 /* If moving to the "old desktop", which is not the
 652                    "last desktop", don't save anything */
 653             }
 654             else if (previous == screen_old_desktop) {
 655                 /* If moving from the "old desktop", and not to the
 656                    "last desktop", don't save anything */
 657             }
 658             else if (screen_last_desktop == screen_old_desktop) {
 659                 /* If the "last desktop" is the same as "old desktop" and
 660                    you're not moving to the "last desktop" then save where
 661                    we're coming from as the "last desktop" */
 662                 screen_last_desktop = previous;
 663             }
 664             else {
 665                 /* If the "last desktop" is different from the "old desktop"
 666                    and you're not moving to the "last desktop", then don't save
 667                    anything */
 668             }
 669         }
 670     }
 671     screen_desktop_timeout = FALSE;
 672     obt_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
 673     obt_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
 674                               last_desktop_func, NULL, NULL, NULL);
 675
 676     ob_debug("Moving to desktop %d", num+1);
 677
 678     if (ob_state() == OB_STATE_RUNNING)
 679         screen_show_desktop_popup(screen_desktop);
 680
 681     /* ignore enter events caused by the move */
 682     ignore_start = event_start_ignore_all_enters();
 683
 684     if (moveresize_client)
 685         client_set_desktop(moveresize_client, num, TRUE, FALSE);
 686
 687     /* show windows before hiding the rest to lessen the enter/leave events */
 688
 689     /* show windows from top to bottom */
 690     for (it = stacking_list; it; it = g_list_next(it)) {
 691         if (WINDOW_IS_CLIENT(it->data)) {
 692             ObClient *c = it->data;
 693             client_show(c);
 694         }
 695     }
 696
 697     if (dofocus) screen_fallback_focus();
 698
 699     /* hide windows from bottom to top */
 700     for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
 701         if (WINDOW_IS_CLIENT(it->data)) {
 702             ObClient *c = it->data;
 703             client_hide(c);
 704         }
 705     }
 706
 707     event_end_ignore_all_enters(ignore_start);
 708
 709     if (event_curtime != CurrentTime)
 710         screen_desktop_user_time = event_curtime;
 711 }
 712
 713 void screen_add_desktop(gboolean current)
 714 {
 715     gulong ignore_start;
 716
 717     /* ignore enter events caused by this */
 718     ignore_start = event_start_ignore_all_enters();
 719
 720     screen_set_num_desktops(screen_num_desktops+1);
 721
 722     /* move all the clients over */
 723     if (current) {
 724         GList *it;
 725
 726         for (it = client_list; it; it = g_list_next(it)) {
 727             ObClient *c = it->data;
 728             if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
 729                 /* don't move direct children, they'll be moved with their
 730                    parent - which will have to be on the same desktop */
 731                 !client_direct_parent(c))
 732             {
 733                 ob_debug("moving window %s", c->title);
 734                 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
 735             }
 736         }
 737     }
 738
 739     event_end_ignore_all_enters(ignore_start);
 740 }
 741
 742 void screen_remove_desktop(gboolean current)
 743 {
 744     guint rmdesktop, movedesktop;
 745     GList *it, *stacking_copy;
 746     gulong ignore_start;
 747
 748     if (screen_num_desktops <= 1) return;
 749
 750     /* ignore enter events caused by this */
 751     ignore_start = event_start_ignore_all_enters();
 752
 753     /* what desktop are we removing and moving to? */
 754     if (current)
 755         rmdesktop = screen_desktop;
 756     else
 757         rmdesktop = screen_num_desktops - 1;
 758     if (rmdesktop < screen_num_desktops - 1)
 759         movedesktop = rmdesktop + 1;
 760     else
 761         movedesktop = rmdesktop;
 762
 763     /* make a copy of the list cuz we're changing it */
 764     stacking_copy = g_list_copy(stacking_list);
 765     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 766         if (WINDOW_IS_CLIENT(it->data)) {
 767             ObClient *c = it->data;
 768             guint d = c->desktop;
 769             if (d != DESKTOP_ALL && d >= movedesktop &&
 770                 /* don't move direct children, they'll be moved with their
 771                    parent - which will have to be on the same desktop */
 772                 !client_direct_parent(c))
 773             {
 774                 ob_debug("moving window %s", c->title);
 775                 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
 776             }
 777             /* raise all the windows that are on the current desktop which
 778                is being merged */
 779             if ((screen_desktop == rmdesktop - 1 ||
 780                  screen_desktop == rmdesktop) &&
 781                 (d == DESKTOP_ALL || d == screen_desktop))
 782             {
 783                 stacking_raise(CLIENT_AS_WINDOW(c));
 784                 ob_debug("raising window %s", c->title);
 785             }
 786         }
 787     }
 788     g_list_free(stacking_copy);
 789
 790     /* fallback focus like we're changing desktops */
 791     if (screen_desktop < screen_num_desktops - 1) {
 792         screen_fallback_focus();
 793         ob_debug("fake desktop change");
 794     }
 795
 796     screen_set_num_desktops(screen_num_desktops-1);
 797
 798     event_end_ignore_all_enters(ignore_start);
 799 }
 800
 801 static void get_row_col(guint d, guint *r, guint *c)
 802 {
 803     switch (screen_desktop_layout.orientation) {
 804     case OB_ORIENTATION_HORZ:
 805         switch (screen_desktop_layout.start_corner) {
 806         case OB_CORNER_TOPLEFT:
 807             *r = d / screen_desktop_layout.columns;
 808             *c = d % screen_desktop_layout.columns;
 809             break;
 810         case OB_CORNER_BOTTOMLEFT:
 811             *r = screen_desktop_layout.rows - 1 -
 812                 d / screen_desktop_layout.columns;
 813             *c = d % screen_desktop_layout.columns;
 814             break;
 815         case OB_CORNER_TOPRIGHT:
 816             *r = d / screen_desktop_layout.columns;
 817             *c = screen_desktop_layout.columns - 1 -
 818                 d % screen_desktop_layout.columns;
 819             break;
 820         case OB_CORNER_BOTTOMRIGHT:
 821             *r = screen_desktop_layout.rows - 1 -
 822                 d / screen_desktop_layout.columns;
 823             *c = screen_desktop_layout.columns - 1 -
 824                 d % screen_desktop_layout.columns;
 825             break;
 826         }
 827         break;
 828     case OB_ORIENTATION_VERT:
 829         switch (screen_desktop_layout.start_corner) {
 830         case OB_CORNER_TOPLEFT:
 831             *r = d % screen_desktop_layout.rows;
 832             *c = d / screen_desktop_layout.rows;
 833             break;
 834         case OB_CORNER_BOTTOMLEFT:
 835             *r = screen_desktop_layout.rows - 1 -
 836                 d % screen_desktop_layout.rows;
 837             *c = d / screen_desktop_layout.rows;
 838             break;
 839         case OB_CORNER_TOPRIGHT:
 840             *r = d % screen_desktop_layout.rows;
 841             *c = screen_desktop_layout.columns - 1 -
 842                 d / screen_desktop_layout.rows;
 843             break;
 844         case OB_CORNER_BOTTOMRIGHT:
 845             *r = screen_desktop_layout.rows - 1 -
 846                 d % screen_desktop_layout.rows;
 847             *c = screen_desktop_layout.columns - 1 -
 848                 d / screen_desktop_layout.rows;
 849             break;
 850         }
 851         break;
 852     }
 853 }
 854
 855 static guint translate_row_col(guint r, guint c)
 856 {
 857     switch (screen_desktop_layout.orientation) {
 858     case OB_ORIENTATION_HORZ:
 859         switch (screen_desktop_layout.start_corner) {
 860         case OB_CORNER_TOPLEFT:
 861             return r % screen_desktop_layout.rows *
 862                 screen_desktop_layout.columns +
 863                 c % screen_desktop_layout.columns;
 864         case OB_CORNER_BOTTOMLEFT:
 865             return (screen_desktop_layout.rows - 1 -
 866                     r % screen_desktop_layout.rows) *
 867                 screen_desktop_layout.columns +
 868                 c % screen_desktop_layout.columns;
 869         case OB_CORNER_TOPRIGHT:
 870             return r % screen_desktop_layout.rows *
 871                 screen_desktop_layout.columns +
 872                 (screen_desktop_layout.columns - 1 -
 873                  c % screen_desktop_layout.columns);
 874         case OB_CORNER_BOTTOMRIGHT:
 875             return (screen_desktop_layout.rows - 1 -
 876                     r % screen_desktop_layout.rows) *
 877                 screen_desktop_layout.columns +
 878                 (screen_desktop_layout.columns - 1 -
 879                  c % screen_desktop_layout.columns);
 880         }
 881     case OB_ORIENTATION_VERT:
 882         switch (screen_desktop_layout.start_corner) {
 883         case OB_CORNER_TOPLEFT:
 884             return c % screen_desktop_layout.columns *
 885                 screen_desktop_layout.rows +
 886                 r % screen_desktop_layout.rows;
 887         case OB_CORNER_BOTTOMLEFT:
 888             return c % screen_desktop_layout.columns *
 889                 screen_desktop_layout.rows +
 890                 (screen_desktop_layout.rows - 1 -
 891                  r % screen_desktop_layout.rows);
 892         case OB_CORNER_TOPRIGHT:
 893             return (screen_desktop_layout.columns - 1 -
 894                     c % screen_desktop_layout.columns) *
 895                 screen_desktop_layout.rows +
 896                 r % screen_desktop_layout.rows;
 897         case OB_CORNER_BOTTOMRIGHT:
 898             return (screen_desktop_layout.columns - 1 -
 899                     c % screen_desktop_layout.columns) *
 900                 screen_desktop_layout.rows +
 901                 (screen_desktop_layout.rows - 1 -
 902                  r % screen_desktop_layout.rows);
 903         }
 904     }
 905     g_assert_not_reached();
 906     return 0;
 907 }
 908
 909 static gboolean hide_desktop_popup_func(gpointer data)
 910 {
 911     pager_popup_hide(desktop_popup);
 912     return FALSE; /* don't repeat */
 913 }
 914
 915 void screen_show_desktop_popup(guint d)
 916 {
 917     Rect *a;
 918
 919     /* 0 means don't show the popup */
 920     if (!config_desktop_popup_time) return;
 921
 922     a = screen_physical_area_active();
 923     pager_popup_position(desktop_popup, CenterGravity,
 924                          a->x + a->width / 2, a->y + a->height / 2);
 925     pager_popup_icon_size_multiplier(desktop_popup,
 926                                      (screen_desktop_layout.columns /
 927                                       screen_desktop_layout.rows) / 2,
 928                                      (screen_desktop_layout.rows/
 929                                       screen_desktop_layout.columns) / 2);
 930     pager_popup_max_width(desktop_popup,
 931                           MAX(a->width/3, POPUP_WIDTH));
 932     pager_popup_show(desktop_popup, screen_desktop_names[d], d);
 933
 934     obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 935     obt_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
 936                               hide_desktop_popup_func, NULL, NULL, NULL);
 937     g_free(a);
 938 }
 939
 940 void screen_hide_desktop_popup(void)
 941 {
 942     obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 943     pager_popup_hide(desktop_popup);
 944 }
 945
 946 guint screen_find_desktop(guint from, ObDirection dir,
 947                           gboolean wrap, gboolean linear)
 948 {
 949     guint r, c;
 950     guint d;
 951
 952     d = from;
 953     get_row_col(d, &r, &c);
 954     if (linear) {
 955         switch (dir) {
 956         case OB_DIRECTION_EAST:
 957             if (d < screen_num_desktops - 1)
 958                 ++d;
 959             else if (wrap)
 960                 d = 0;
 961             else
 962                 return from;
 963             break;
 964         case OB_DIRECTION_WEST:
 965             if (d > 0)
 966                 --d;
 967             else if (wrap)
 968                 d = screen_num_desktops - 1;
 969             else
 970                 return from;
 971             break;
 972         default:
 973             g_assert_not_reached();
 974             return from;
 975         }
 976     } else {
 977         switch (dir) {
 978         case OB_DIRECTION_EAST:
 979             ++c;
 980             if (c >= screen_desktop_layout.columns) {
 981                 if (wrap)
 982                     c = 0;
 983                 else
 984                     return from;
 985             }
 986             d = translate_row_col(r, c);
 987             if (d >= screen_num_desktops) {
 988                 if (wrap)
 989                     ++c;
 990                 else
 991                     return from;
 992             }
 993             break;
 994         case OB_DIRECTION_WEST:
 995             --c;
 996             if (c >= screen_desktop_layout.columns) {
 997                 if (wrap)
 998                     c = screen_desktop_layout.columns - 1;
 999                 else
1000                     return from;
1001             }
1002             d = translate_row_col(r, c);
1003             if (d >= screen_num_desktops) {
1004                 if (wrap)
1005                     --c;
1006                 else
1007                     return from;
1008             }
1009             break;
1010         case OB_DIRECTION_SOUTH:
1011             ++r;
1012             if (r >= screen_desktop_layout.rows) {
1013                 if (wrap)
1014                     r = 0;
1015                 else
1016                     return from;
1017             }
1018             d = translate_row_col(r, c);
1019             if (d >= screen_num_desktops) {
1020                 if (wrap)
1021                     ++r;
1022                 else
1023                     return from;
1024             }
1025             break;
1026         case OB_DIRECTION_NORTH:
1027             --r;
1028             if (r >= screen_desktop_layout.rows) {
1029                 if (wrap)
1030                     r = screen_desktop_layout.rows - 1;
1031                 else
1032                     return from;
1033             }
1034             d = translate_row_col(r, c);
1035             if (d >= screen_num_desktops) {
1036                 if (wrap)
1037                     --r;
1038                 else
1039                     return from;
1040             }
1041             break;
1042         default:
1043             g_assert_not_reached();
1044             return from;
1045         }
1046
1047         d = translate_row_col(r, c);
1048     }
1049     return d;
1050 }
1051
1052 static gboolean screen_validate_layout(ObDesktopLayout *l)
1053 {
1054     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1055         return FALSE;
1056
1057     /* fill in a zero rows/columns */
1058     if (l->columns == 0) {
1059         l->columns = screen_num_desktops / l->rows;
1060         if (l->rows * l->columns < screen_num_desktops)
1061             l->columns++;
1062         if (l->rows * l->columns >= screen_num_desktops + l->columns)
1063             l->rows--;
1064     } else if (l->rows == 0) {
1065         l->rows = screen_num_desktops / l->columns;
1066         if (l->columns * l->rows < screen_num_desktops)
1067             l->rows++;
1068         if (l->columns * l->rows >= screen_num_desktops + l->rows)
1069             l->columns--;
1070     }
1071
1072     /* bounds checking */
1073     if (l->orientation == OB_ORIENTATION_HORZ) {
1074         l->columns = MIN(screen_num_desktops, l->columns);
1075         l->rows = MIN(l->rows,
1076                       (screen_num_desktops + l->columns - 1) / l->columns);
1077         l->columns = screen_num_desktops / l->rows +
1078             !!(screen_num_desktops % l->rows);
1079     } else {
1080         l->rows = MIN(screen_num_desktops, l->rows);
1081         l->columns = MIN(l->columns,
1082                          (screen_num_desktops + l->rows - 1) / l->rows);
1083         l->rows = screen_num_desktops / l->columns +
1084             !!(screen_num_desktops % l->columns);
1085     }
1086     return TRUE;
1087 }
1088
1089 void screen_update_layout(void)
1090
1091 {
1092     ObDesktopLayout l;
1093     guint32 *data;
1094     guint num;
1095
1096     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1097     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1098     screen_desktop_layout.rows = 1;
1099     screen_desktop_layout.columns = screen_num_desktops;
1100
1101     if (OBT_PROP_GETA32(obt_root(ob_screen),
1102                         NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1103         if (num == 3 || num == 4) {
1104
1105             if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1106                 l.orientation = OB_ORIENTATION_VERT;
1107             else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1108                 l.orientation = OB_ORIENTATION_HORZ;
1109             else
1110                 return;
1111
1112             if (num < 4)
1113                 l.start_corner = OB_CORNER_TOPLEFT;
1114             else {
1115                 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1116                     l.start_corner = OB_CORNER_TOPLEFT;
1117                 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1118                     l.start_corner = OB_CORNER_TOPRIGHT;
1119                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1120                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
1121                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1122                     l.start_corner = OB_CORNER_BOTTOMLEFT;
1123                 else
1124                     return;
1125             }
1126
1127             l.columns = data[1];
1128             l.rows = data[2];
1129
1130             if (screen_validate_layout(&l))
1131                 screen_desktop_layout = l;
1132
1133             g_free(data);
1134         }
1135     }
1136 }
1137
1138 void screen_update_desktop_names(void)
1139 {
1140     guint i;
1141
1142     /* empty the array */
1143     g_strfreev(screen_desktop_names);
1144     screen_desktop_names = NULL;
1145
1146     if (OBT_PROP_GETSS(obt_root(ob_screen),
1147                        NET_DESKTOP_NAMES, utf8, &screen_desktop_names))
1148         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1149     else
1150         i = 0;
1151     if (i < screen_num_desktops) {
1152         GSList *it;
1153
1154         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1155                                        screen_num_desktops + 1);
1156         screen_desktop_names[screen_num_desktops] = NULL;
1157
1158         it = g_slist_nth(config_desktops_names, i);
1159
1160         for (; i < screen_num_desktops; ++i) {
1161             if (it && ((char*)it->data)[0]) /* not empty */
1162                 /* use the names from the config file when possible */
1163                 screen_desktop_names[i] = g_strdup(it->data);
1164             else
1165                 /* make up a nice name if it's not though */
1166                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1167                                                           i + 1);
1168             if (it) it = g_slist_next(it);
1169         }
1170
1171         /* if we changed any names, then set the root property so we can
1172            all agree on the names */
1173         OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1174                        utf8, (const gchar**)screen_desktop_names);
1175     }
1176
1177     /* resize the pager for these names */
1178     pager_popup_text_width_to_strings(desktop_popup,
1179                                       screen_desktop_names,
1180                                       screen_num_desktops);
1181 }
1182
1183 void screen_show_desktop(gboolean show, ObClient *show_only)
1184 {
1185     GList *it;
1186
1187     if (show == screen_showing_desktop) return; /* no change */
1188
1189     screen_showing_desktop = show;
1190
1191     if (show) {
1192         /* hide windows bottom to top */
1193         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1194             if (WINDOW_IS_CLIENT(it->data)) {
1195                 ObClient *client = it->data;
1196                 client_showhide(client);
1197             }
1198         }
1199     }
1200     else {
1201         /* restore windows top to bottom */
1202         for (it = stacking_list; it; it = g_list_next(it)) {
1203             if (WINDOW_IS_CLIENT(it->data)) {
1204                 ObClient *client = it->data;
1205                 if (client_should_show(client)) {
1206                     if (!show_only || client == show_only)
1207                         client_show(client);
1208                     else
1209                         client_iconify(client, TRUE, FALSE, TRUE);
1210                 }
1211             }
1212         }
1213     }
1214
1215     if (show) {
1216         /* focus the desktop */
1217         for (it = focus_order; it; it = g_list_next(it)) {
1218             ObClient *c = it->data;
1219             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1220                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1221                 client_focus(it->data))
1222                 break;
1223         }
1224     }
1225     else if (!show_only) {
1226         ObClient *c;
1227
1228         if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1229             /* only do the flicker reducing stuff ahead of time if we are going
1230                to call xsetinputfocus on the window ourselves. otherwise there
1231                is no guarantee the window will actually take focus.. */
1232             if (c->can_focus) {
1233                 /* reduce flicker by hiliting now rather than waiting for the
1234                    server FocusIn event */
1235                 frame_adjust_focus(c->frame, TRUE);
1236             }
1237         }
1238     }
1239
1240     show = !!show; /* make it boolean */
1241     OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1242 }
1243
1244 void screen_install_colormap(ObClient *client, gboolean install)
1245 {
1246     if (client == NULL || client->colormap == None) {
1247         if (install)
1248             XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1249         else
1250             XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1251     } else {
1252         obt_display_ignore_errors(TRUE);
1253         if (install)
1254             XInstallColormap(obt_display, client->colormap);
1255         else
1256             XUninstallColormap(obt_display, client->colormap);
1257         obt_display_ignore_errors(FALSE);
1258     }
1259 }
1260
1261 #define STRUT_LEFT_ON_MONITOR(s, i) \
1262     (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
1263                       monitor_area[i].y, monitor_area[i].height))
1264 #define STRUT_RIGHT_ON_MONITOR(s, i) \
1265     (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
1266                       monitor_area[i].y, monitor_area[i].height))
1267 #define STRUT_TOP_ON_MONITOR(s, i) \
1268     (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
1269                       monitor_area[i].x, monitor_area[i].width))
1270 #define STRUT_BOTTOM_ON_MONITOR(s, i) \
1271     (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
1272                       monitor_area[i].x, monitor_area[i].width))
1273
1274 typedef struct {
1275     guint desktop;
1276     StrutPartial *strut;
1277 } ObScreenStrut;
1278
1279 #define RESET_STRUT_LIST(sl) \
1280     (g_slist_free(sl), sl = NULL)
1281
1282 #define ADD_STRUT_TO_LIST(sl, d, s) \
1283 { \
1284     ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1285     ss->desktop = d; \
1286     ss->strut = s;  \
1287     sl = g_slist_prepend(sl, ss); \
1288 }
1289
1290 #define VALIDATE_STRUTS(sl, side, max) \
1291 { \
1292     GSList *it; \
1293     for (it = sl; it; it = g_slist_next(it)) { \
1294       ObScreenStrut *ss = it->data; \
1295       ss->strut->side = MIN(max, ss->strut->side); \
1296     } \
1297 }
1298
1299 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1300 {
1301     guint i;
1302     gint l, r, t, b;
1303
1304     if (ob_debug_xinerama) {
1305         gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1306         gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1307         *nxin = 2;
1308         *xin_areas = g_new(Rect, *nxin + 1);
1309         RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1310         RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1311     }
1312 #ifdef XINERAMA
1313     else if (obt_display_extension_xinerama) {
1314         guint i;
1315         gint n;
1316         XineramaScreenInfo *info = XineramaQueryScreens(obt_display, &n);
1317         *nxin = n;
1318         *xin_areas = g_new(Rect, *nxin + 1);
1319         for (i = 0; i < *nxin; ++i)
1320             RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1321                      info[i].width, info[i].height);
1322         XFree(info);
1323     }
1324 #endif
1325     else {
1326         *nxin = 1;
1327         *xin_areas = g_new(Rect, *nxin + 1);
1328         RECT_SET((*xin_areas)[0], 0, 0,
1329                  WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1330                  HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1331     }
1332
1333     /* returns one extra with the total area in it */
1334     l = (*xin_areas)[0].x;
1335     t = (*xin_areas)[0].y;
1336     r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1337     b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1338     for (i = 1; i < *nxin; ++i) {
1339         l = MIN(l, (*xin_areas)[i].x);
1340         t = MIN(l, (*xin_areas)[i].y);
1341         r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1342         b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1343     }
1344     RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1345 }
1346
1347 void screen_update_areas(void)
1348 {
1349     guint i, j;
1350     gulong *dims;
1351     GList *it;
1352     GSList *sit;
1353
1354     g_free(monitor_area);
1355     get_xinerama_screens(&monitor_area, &screen_num_monitors);
1356
1357     /* set up the user-specified margins */
1358     config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1359     config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1360     config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1361     config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1362     config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1363     config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1364     config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1365     config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1366
1367     dims = g_new(gulong, 4 * screen_num_desktops * screen_num_monitors);
1368
1369     RESET_STRUT_LIST(struts_left);
1370     RESET_STRUT_LIST(struts_top);
1371     RESET_STRUT_LIST(struts_right);
1372     RESET_STRUT_LIST(struts_bottom);
1373
1374     /* collect the struts */
1375     for (it = client_list; it; it = g_list_next(it)) {
1376         ObClient *c = it->data;
1377         if (c->strut.left)
1378             ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1379         if (c->strut.top)
1380             ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1381         if (c->strut.right)
1382             ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1383         if (c->strut.bottom)
1384             ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1385     }
1386     if (dock_strut.left)
1387         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1388     if (dock_strut.top)
1389         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1390     if (dock_strut.right)
1391         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1392     if (dock_strut.bottom)
1393         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1394
1395     if (config_margins.left)
1396         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1397     if (config_margins.top)
1398         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1399     if (config_margins.right)
1400         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1401     if (config_margins.bottom)
1402         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1403
1404     VALIDATE_STRUTS(struts_left, left,
1405                     monitor_area[screen_num_monitors].width / 2);
1406     VALIDATE_STRUTS(struts_right, right,
1407                     monitor_area[screen_num_monitors].width / 2);
1408     VALIDATE_STRUTS(struts_top, top,
1409                     monitor_area[screen_num_monitors].height / 2);
1410     VALIDATE_STRUTS(struts_bottom, bottom,
1411                     monitor_area[screen_num_monitors].height / 2);
1412
1413     /* set up the work areas to be full screen */
1414     for (i = 0; i < screen_num_monitors; ++i)
1415         for (j = 0; j < screen_num_desktops; ++j) {
1416             dims[(i * screen_num_desktops + j) * 4+0] = monitor_area[i].x;
1417             dims[(i * screen_num_desktops + j) * 4+1] = monitor_area[i].y;
1418             dims[(i * screen_num_desktops + j) * 4+2] = monitor_area[i].width;
1419             dims[(i * screen_num_desktops + j) * 4+3] = monitor_area[i].height;
1420         }
1421
1422     /* calculate the work areas from the struts */
1423     for (i = 0; i < screen_num_monitors; ++i)
1424         for (j = 0; j < screen_num_desktops; ++j) {
1425             gint l = 0, r = 0, t = 0, b = 0;
1426
1427             /* only add the strut to the area if it touches the monitor */
1428
1429             for (sit = struts_left; sit; sit = g_slist_next(sit)) {
1430                 ObScreenStrut *s = sit->data;
1431                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1432                     STRUT_LEFT_ON_MONITOR(s->strut, i))
1433                     l = MAX(l, s->strut->left);
1434             }
1435             for (sit = struts_top; sit; sit = g_slist_next(sit)) {
1436                 ObScreenStrut *s = sit->data;
1437                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1438                     STRUT_TOP_ON_MONITOR(s->strut, i))
1439                     t = MAX(t, s->strut->top);
1440             }
1441             for (sit = struts_right; sit; sit = g_slist_next(sit)) {
1442                 ObScreenStrut *s = sit->data;
1443                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1444                     STRUT_RIGHT_ON_MONITOR(s->strut, i))
1445                     r = MAX(r, s->strut->right);
1446             }
1447             for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
1448                 ObScreenStrut *s = sit->data;
1449                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1450                     STRUT_BOTTOM_ON_MONITOR(s->strut, i))
1451                     b = MAX(b, s->strut->bottom);
1452             }
1453
1454             /* based on these margins, set the work area for the
1455                monitor/desktop */
1456             dims[(i * screen_num_desktops + j) * 4 + 0] += l;
1457             dims[(i * screen_num_desktops + j) * 4 + 1] += t;
1458             dims[(i * screen_num_desktops + j) * 4 + 2] -= l + r;
1459             dims[(i * screen_num_desktops + j) * 4 + 3] -= t + b;
1460         }
1461
1462     /* all the work areas are not used here, only the ones for the first
1463        monitor are */
1464     OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1465                     dims, 4 * screen_num_desktops);
1466
1467     /* the area has changed, adjust all the windows if they need it */
1468     for (it = client_list; it; it = g_list_next(it))
1469         client_reconfigure(it->data, FALSE);
1470
1471     g_free(dims);
1472 }
1473
1474 #if 0
1475 Rect* screen_area_all_monitors(guint desktop)
1476 {
1477     guint i;
1478     Rect *a;
1479
1480     a = screen_area_monitor(desktop, 0);
1481
1482     /* combine all the monitors together */
1483     for (i = 1; i < screen_num_monitors; ++i) {
1484         Rect *m = screen_area_monitor(desktop, i);
1485         gint l, r, t, b;
1486
1487         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1488         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1489         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1490         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1491
1492         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1493
1494         g_free(m);
1495     }
1496
1497     return a;
1498 }
1499 #endif
1500
1501 #define STRUT_LEFT_IN_SEARCH(s, search) \
1502     (RANGES_INTERSECT(search->y, search->height, \
1503                       s->left_start, s->left_end - s->left_start + 1))
1504 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1505     (RANGES_INTERSECT(search->y, search->height, \
1506                       s->right_start, s->right_end - s->right_start + 1))
1507 #define STRUT_TOP_IN_SEARCH(s, search) \
1508     (RANGES_INTERSECT(search->x, search->width, \
1509                       s->top_start, s->top_end - s->top_start + 1))
1510 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1511     (RANGES_INTERSECT(search->x, search->width, \
1512                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1513
1514 #define STRUT_LEFT_IGNORE(s, us, search) \
1515     (head == SCREEN_AREA_ALL_MONITORS && us && \
1516      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1517 #define STRUT_RIGHT_IGNORE(s, us, search) \
1518     (head == SCREEN_AREA_ALL_MONITORS && us && \
1519      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1520 #define STRUT_TOP_IGNORE(s, us, search) \
1521     (head == SCREEN_AREA_ALL_MONITORS && us && \
1522      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1523 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1524     (head == SCREEN_AREA_ALL_MONITORS && us && \
1525      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1526
1527 Rect* screen_area(guint desktop, guint head, Rect *search)
1528 {
1529     Rect *a;
1530     GSList *it;
1531     gint l, r, t, b, al, ar, at, ab;
1532     guint i, d;
1533     gboolean us = search != NULL; /* user provided search */
1534
1535     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1536     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1537              head == SCREEN_AREA_ALL_MONITORS);
1538     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1539
1540     /* find any struts for this monitor
1541        which will be affecting the search area.
1542     */
1543
1544     /* search everything if search is null */
1545     if (!search) {
1546         if (head < screen_num_monitors) search = &monitor_area[head];
1547         else search = &monitor_area[screen_num_monitors];
1548     }
1549     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1550
1551     /* al is "all left" meaning the furthest left you can get, l is our
1552        "working left" meaning our current strut edge which we're calculating
1553     */
1554
1555     /* only include monitors which the search area lines up with */
1556     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1557         al = l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1558         at = t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1559         ar = r = RECT_LEFT(monitor_area[screen_num_monitors]);
1560         ab = b = RECT_TOP(monitor_area[screen_num_monitors]);
1561         for (i = 0; i < screen_num_monitors; ++i) {
1562             /* add the monitor if applicable */
1563             if (RANGES_INTERSECT(search->x, search->width,
1564                                  monitor_area[i].x, monitor_area[i].width))
1565             {
1566                 at = t = MIN(t, RECT_TOP(monitor_area[i]));
1567                 ab = b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1568             }
1569             if (RANGES_INTERSECT(search->y, search->height,
1570                                  monitor_area[i].y, monitor_area[i].height))
1571             {
1572                 al = l = MIN(l, RECT_LEFT(monitor_area[i]));
1573                 ar = r = MAX(r, RECT_RIGHT(monitor_area[i]));
1574             }
1575         }
1576     } else {
1577         al = l = RECT_LEFT(monitor_area[screen_num_monitors]);
1578         at = t = RECT_TOP(monitor_area[screen_num_monitors]);
1579         ar = r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1580         ab = b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1581     }
1582
1583     for (d = 0; d < screen_num_desktops; ++d) {
1584         if (d != desktop && desktop != DESKTOP_ALL) continue;
1585
1586         for (i = 0; i < screen_num_monitors; ++i) {
1587             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1588
1589             for (it = struts_left; it; it = g_slist_next(it)) {
1590                 ObScreenStrut *s = it->data;
1591                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1592                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1593                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1594                     l = MAX(l, al + s->strut->left);
1595             }
1596             for (it = struts_top; it; it = g_slist_next(it)) {
1597                 ObScreenStrut *s = it->data;
1598                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1599                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1600                     !STRUT_TOP_IGNORE(s->strut, us, search))
1601                     t = MAX(t, at + s->strut->top);
1602             }
1603             for (it = struts_right; it; it = g_slist_next(it)) {
1604                 ObScreenStrut *s = it->data;
1605                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1606                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1607                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1608                     r = MIN(r, ar - s->strut->right);
1609             }
1610             for (it = struts_bottom; it; it = g_slist_next(it)) {
1611                 ObScreenStrut *s = it->data;
1612                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1613                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1614                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1615                     b = MIN(b, ab - s->strut->bottom);
1616             }
1617
1618             /* limit to this monitor */
1619             if (head == i) {
1620                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1621                 t = MAX(t, RECT_TOP(monitor_area[i]));
1622                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1623                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1624             }
1625         }
1626     }
1627
1628     a = g_new(Rect, 1);
1629     a->x = l;
1630     a->y = t;
1631     a->width = r - l + 1;
1632     a->height = b - t + 1;
1633     return a;
1634 }
1635
1636 guint screen_find_monitor(Rect *search)
1637 {
1638     guint i;
1639     guint most = screen_num_monitors;
1640     guint mostv = 0;
1641
1642     for (i = 0; i < screen_num_monitors; ++i) {
1643         Rect *area = screen_physical_area_monitor(i);
1644         if (RECT_INTERSECTS_RECT(*area, *search)) {
1645             Rect r;
1646             guint v;
1647
1648             RECT_SET_INTERSECTION(r, *area, *search);
1649             v = r.width * r.height;
1650
1651             if (v > mostv) {
1652                 mostv = v;
1653                 most = i;
1654             }
1655         }
1656         g_free(area);
1657     }
1658     return most;
1659 }
1660
1661 Rect* screen_physical_area_all_monitors(void)
1662 {
1663     return screen_physical_area_monitor(screen_num_monitors);
1664 }
1665
1666 Rect* screen_physical_area_monitor(guint head)
1667 {
1668     Rect *a;
1669     g_assert(head <= screen_num_monitors);
1670
1671     a = g_new(Rect, 1);
1672     *a = monitor_area[head];
1673     return a;
1674 }
1675
1676 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1677 {
1678     g_assert(head <= screen_num_monitors);
1679     g_assert(search);
1680     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1681 }
1682
1683 Rect* screen_physical_area_active(void)
1684 {
1685     Rect *a;
1686     gint x, y;
1687
1688     if (moveresize_client)
1689         a = screen_physical_area_monitor(client_monitor(focus_client));
1690     else if (focus_client)
1691         a = screen_physical_area_monitor(client_monitor(focus_client));
1692     else {
1693         Rect mon;
1694         if (screen_pointer_pos(&x, &y))
1695             RECT_SET(mon, x, y, 1, 1);
1696         else
1697             RECT_SET(mon, 0, 0, 1, 1);
1698         a = screen_physical_area_monitor(screen_find_monitor(&mon));
1699     }
1700     return a;
1701 }
1702
1703 void screen_set_root_cursor(void)
1704 {
1705     if (sn_app_starting())
1706         XDefineCursor(obt_display, obt_root(ob_screen),
1707                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1708     else
1709         XDefineCursor(obt_display, obt_root(ob_screen),
1710                       ob_cursor(OB_CURSOR_POINTER));
1711 }
1712
1713 gboolean screen_pointer_pos(gint *x, gint *y)
1714 {
1715     Window w;
1716     gint i;
1717     guint u;
1718     gboolean ret;
1719
1720     ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1721                           &w, &w, x, y, &i, &i, &u);
1722     if (!ret) {
1723         for (i = 0; i < ScreenCount(obt_display); ++i)
1724             if (i != ob_screen)
1725                 if (XQueryPointer(obt_display, obt_root(i),
1726                                   &w, &w, x, y, &i, &i, &u))
1727                     break;
1728     }
1729     return ret;
1730 }