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     supported[i++] = OBT_PROP_ATOM(OB_ROLE);
 296     supported[i++] = OBT_PROP_ATOM(OB_NAME);
 297     supported[i++] = OBT_PROP_ATOM(OB_CLASS);
 298     g_assert(i == num_support);
 299
 300     OBT_PROP_SETA32(obt_root(ob_screen),
 301                     NET_SUPPORTED, ATOM, supported, num_support);
 302     g_free(supported);
 303
 304     screen_tell_ksplash();
 305
 306     return TRUE;
 307 }
 308
 309 static void screen_tell_ksplash(void)
 310 {
 311     XEvent e;
 312     char **argv;
 313
 314     argv = g_new(gchar*, 6);
 315     argv[0] = g_strdup("dcop");
 316     argv[1] = g_strdup("ksplash");
 317     argv[2] = g_strdup("ksplash");
 318     argv[3] = g_strdup("upAndRunning(QString)");
 319     argv[4] = g_strdup("wm started");
 320     argv[5] = NULL;
 321
 322     /* tell ksplash through the dcop server command line interface */
 323     g_spawn_async(NULL, argv, NULL,
 324                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
 325                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
 326                   NULL, NULL, NULL, NULL);
 327     g_strfreev(argv);
 328
 329     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
 330        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
 331        something. oh well. */
 332     e.xclient.type = ClientMessage;
 333     e.xclient.display = obt_display;
 334     e.xclient.window = obt_root(ob_screen);
 335     e.xclient.message_type =
 336         XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
 337     e.xclient.format = 8;
 338     strcpy(e.xclient.data.b, "wm started");
 339     XSendEvent(obt_display, obt_root(ob_screen),
 340                False, SubstructureNotifyMask, &e);
 341 }
 342
 343 void screen_startup(gboolean reconfig)
 344 {
 345     gchar **names = NULL;
 346     guint32 d;
 347     gboolean namesexist = FALSE;
 348
 349     desktop_popup = pager_popup_new();
 350     pager_popup_height(desktop_popup, POPUP_HEIGHT);
 351
 352     if (reconfig) {
 353         /* update the pager popup's width */
 354         pager_popup_text_width_to_strings(desktop_popup,
 355                                           screen_desktop_names,
 356                                           screen_num_desktops);
 357         return;
 358     }
 359
 360     /* get the initial size */
 361     screen_resize();
 362
 363     /* have names already been set for the desktops? */
 364     if (OBT_PROP_GETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, utf8, &names)) {
 365         g_strfreev(names);
 366         namesexist = TRUE;
 367     }
 368
 369     /* if names don't exist and we have session names, set those.
 370        do this stuff BEFORE setting the number of desktops, because that
 371        will create default names for them
 372     */
 373     if (!namesexist && session_desktop_names != NULL) {
 374         guint i, numnames;
 375         GSList *it;
 376
 377         /* get the desktop names */
 378         numnames = g_slist_length(session_desktop_names);
 379         names = g_new(gchar*, numnames + 1);
 380         names[numnames] = NULL;
 381         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
 382             names[i] = g_strdup(it->data);
 383
 384         /* set the root window property */
 385         OBT_PROP_SETSS(obt_root(ob_screen),
 386                        NET_DESKTOP_NAMES, utf8, (const gchar**)names);
 387
 388         g_strfreev(names);
 389     }
 390
 391     /* set the number of desktops, if it's not already set.
 392
 393        this will also set the default names from the config file up for
 394        desktops that don't have names yet */
 395     screen_num_desktops = 0;
 396     if (OBT_PROP_GET32(obt_root(ob_screen),
 397                        NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
 398     {
 399         if (d != config_desktops_num) {
 400             /* TRANSLATORS: If you need to specify a different order of the
 401                arguments, you can use %1$d for the first one and %2$d for the
 402                second one. For example,
 403                "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
 404             g_warning(ngettext("Openbox is configured for %d desktop, but the current session has %d.  Overriding the Openbox configuration.", "Openbox is configured for %d desktops, but the current session has %d.  Overriding the Openbox configuration.", config_desktops_num),
 405                       config_desktops_num, d);
 406         }
 407         screen_set_num_desktops(d);
 408     }
 409     /* restore from session if possible */
 410     else if (session_num_desktops)
 411         screen_set_num_desktops(session_num_desktops);
 412     else
 413         screen_set_num_desktops(config_desktops_num);
 414
 415     screen_desktop = screen_num_desktops;  /* something invalid */
 416     /* start on the current desktop when a wm was already running */
 417     if (OBT_PROP_GET32(obt_root(ob_screen),
 418                        NET_CURRENT_DESKTOP, CARDINAL, &d) &&
 419         d < screen_num_desktops)
 420     {
 421         screen_set_desktop(d, FALSE);
 422     } else if (session_desktop >= 0)
 423         screen_set_desktop(MIN((guint)session_desktop,
 424                                screen_num_desktops), FALSE);
 425     else
 426         screen_set_desktop(MIN(config_screen_firstdesk,
 427                                screen_num_desktops) - 1, FALSE);
 428     screen_last_desktop = screen_desktop;
 429
 430     /* don't start in showing-desktop mode */
 431     screen_showing_desktop = FALSE;
 432     OBT_PROP_SET32(obt_root(ob_screen),
 433                    NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
 434
 435     if (session_desktop_layout_present &&
 436         screen_validate_layout(&session_desktop_layout))
 437     {
 438         screen_desktop_layout = session_desktop_layout;
 439     }
 440     else
 441         screen_update_layout();
 442 }
 443
 444 void screen_shutdown(gboolean reconfig)
 445 {
 446     pager_popup_free(desktop_popup);
 447
 448     if (reconfig)
 449         return;
 450
 451     XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
 452
 453     /* we're not running here no more! */
 454     OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
 455     /* not without us */
 456     OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
 457     /* don't keep this mode */
 458     OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
 459
 460     XDestroyWindow(obt_display, screen_support_win);
 461
 462     g_strfreev(screen_desktop_names);
 463     screen_desktop_names = NULL;
 464 }
 465
 466 void screen_resize(void)
 467 {
 468     static gint oldw = 0, oldh = 0;
 469     gint w, h;
 470     GList *it;
 471     gulong geometry[2];
 472
 473     w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 474     h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 475
 476     if (w == oldw && h == oldh) return;
 477
 478     oldw = w; oldh = h;
 479
 480     /* Set the _NET_DESKTOP_GEOMETRY hint */
 481     screen_physical_size.width = geometry[0] = w;
 482     screen_physical_size.height = geometry[1] = h;
 483     OBT_PROP_SETA32(obt_root(ob_screen),
 484                     NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
 485
 486     if (ob_state() != OB_STATE_RUNNING)
 487         return;
 488
 489     screen_update_areas();
 490     dock_configure();
 491
 492     for (it = client_list; it; it = g_list_next(it))
 493         client_move_onscreen(it->data, FALSE);
 494 }
 495
 496 void screen_set_num_desktops(guint num)
 497 {
 498     gulong *viewport;
 499     GList *it, *stacking_copy;
 500
 501     g_assert(num > 0);
 502
 503     if (screen_num_desktops == num) return;
 504
 505     screen_num_desktops = num;
 506     OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
 507
 508     /* set the viewport hint */
 509     viewport = g_new0(gulong, num * 2);
 510     OBT_PROP_SETA32(obt_root(ob_screen),
 511                     NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
 512     g_free(viewport);
 513
 514     /* the number of rows/columns will differ */
 515     screen_update_layout();
 516
 517     /* move windows on desktops that will no longer exist!
 518        make a copy of the list cuz we're changing it */
 519     stacking_copy = g_list_copy(stacking_list);
 520     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 521         if (WINDOW_IS_CLIENT(it->data)) {
 522             ObClient *c = it->data;
 523             if (c->desktop != DESKTOP_ALL && c->desktop >= num)
 524                 client_set_desktop(c, num - 1, FALSE, TRUE);
 525             /* raise all the windows that are on the current desktop which
 526                is being merged */
 527             else if (screen_desktop == num - 1 &&
 528                      (c->desktop == DESKTOP_ALL ||
 529                       c->desktop == screen_desktop))
 530                 stacking_raise(CLIENT_AS_WINDOW(c));
 531         }
 532     }
 533     g_list_free(stacking_copy);
 534
 535     /* change our struts/area to match (after moving windows) */
 536     screen_update_areas();
 537
 538     /* may be some unnamed desktops that we need to fill in with names
 539        (after updating the areas so the popup can resize) */
 540     screen_update_desktop_names();
 541
 542     /* change our desktop if we're on one that no longer exists! */
 543     if (screen_desktop >= screen_num_desktops)
 544         screen_set_desktop(num - 1, TRUE);
 545 }
 546
 547 static void screen_fallback_focus(void)
 548 {
 549     ObClient *c;
 550     gboolean allow_omni;
 551
 552     /* only allow omnipresent windows to get focus on desktop change if
 553        an omnipresent window is already focused (it'll keep focus probably, but
 554        maybe not depending on mouse-focus options) */
 555     allow_omni = focus_client && (client_normal(focus_client) &&
 556                                   focus_client->desktop == DESKTOP_ALL);
 557
 558     /* the client moved there already so don't move focus. prevent flicker
 559        on sendtodesktop + follow */
 560     if (focus_client && focus_client->desktop == screen_desktop)
 561         return;
 562
 563     /* have to try focus here because when you leave an empty desktop
 564        there is no focus out to watch for. also, we have different rules
 565        here. we always allow it to look under the mouse pointer if
 566        config_focus_last is FALSE
 567
 568        do this before hiding the windows so if helper windows are coming
 569        with us, they don't get hidden
 570     */
 571     if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
 572                             !allow_omni)))
 573     {
 574         /* only do the flicker reducing stuff ahead of time if we are going
 575            to call xsetinputfocus on the window ourselves. otherwise there is
 576            no guarantee the window will actually take focus.. */
 577         if (c->can_focus) {
 578             /* reduce flicker by hiliting now rather than waiting for the
 579                server FocusIn event */
 580             frame_adjust_focus(c->frame, TRUE);
 581             /* do this here so that if you switch desktops to a window with
 582                helper windows then the helper windows won't flash */
 583             client_bring_helper_windows(c);
 584         }
 585     }
 586 }
 587
 588 static gboolean last_desktop_func(gpointer data)
 589 {
 590     screen_desktop_timeout = TRUE;
 591     return FALSE;
 592 }
 593
 594 void screen_set_desktop(guint num, gboolean dofocus)
 595 {
 596     GList *it;
 597     guint previous;
 598     gulong ignore_start;
 599
 600     g_assert(num < screen_num_desktops);
 601
 602     previous = screen_desktop;
 603     screen_desktop = num;
 604
 605     if (previous == num) return;
 606
 607     OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
 608
 609     /* This whole thing decides when/how to save the screen_last_desktop so
 610        that it can be restored later if you want */
 611     if (screen_desktop_timeout) {
 612         /* If screen_desktop_timeout is true, then we've been on this desktop
 613            long enough and we can save it as the last desktop. */
 614
 615         if (screen_last_desktop == previous)
 616             /* this is the startup state only */
 617             screen_old_desktop = screen_desktop;
 618         else {
 619             /* save the "last desktop" as the "old desktop" */
 620             screen_old_desktop = screen_last_desktop;
 621             /* save the desktop we're coming from as the "last desktop" */
 622             screen_last_desktop = previous;
 623         }
 624     }
 625     else {
 626         /* If screen_desktop_timeout is false, then we just got to this desktop
 627            and we are moving away again. */
 628
 629         if (screen_desktop == screen_last_desktop) {
 630             /* If we are moving to the "last desktop" .. */
 631             if (previous == screen_old_desktop) {
 632                 /* .. from the "old desktop", change the last desktop to
 633                    be where we are coming from */
 634                 screen_last_desktop = screen_old_desktop;
 635             }
 636             else if (screen_last_desktop == screen_old_desktop) {
 637                 /* .. and also to the "old desktop", change the "last
 638                    desktop" to be where we are coming from */
 639                 screen_last_desktop = previous;
 640             }
 641             else {
 642                 /* .. from some other desktop, then set the "last desktop" to
 643                    be the saved "old desktop", i.e. where we were before the
 644                    "last desktop" */
 645                 screen_last_desktop = screen_old_desktop;
 646             }
 647         }
 648         else {
 649             /* If we are moving to any desktop besides the "last desktop"..
 650                (this is the normal case) */
 651             if (screen_desktop == screen_old_desktop) {
 652                 /* If moving to the "old desktop", which is not the
 653                    "last desktop", don't save anything */
 654             }
 655             else if (previous == screen_old_desktop) {
 656                 /* If moving from the "old desktop", and not to the
 657                    "last desktop", don't save anything */
 658             }
 659             else if (screen_last_desktop == screen_old_desktop) {
 660                 /* If the "last desktop" is the same as "old desktop" and
 661                    you're not moving to the "last desktop" then save where
 662                    we're coming from as the "last desktop" */
 663                 screen_last_desktop = previous;
 664             }
 665             else {
 666                 /* If the "last desktop" is different from the "old desktop"
 667                    and you're not moving to the "last desktop", then don't save
 668                    anything */
 669             }
 670         }
 671     }
 672     screen_desktop_timeout = FALSE;
 673     obt_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
 674     obt_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
 675                               last_desktop_func, NULL, NULL, NULL);
 676
 677     ob_debug("Moving to desktop %d", num+1);
 678
 679     if (ob_state() == OB_STATE_RUNNING)
 680         screen_show_desktop_popup(screen_desktop);
 681
 682     /* ignore enter events caused by the move */
 683     ignore_start = event_start_ignore_all_enters();
 684
 685     if (moveresize_client)
 686         client_set_desktop(moveresize_client, num, TRUE, FALSE);
 687
 688     /* show windows before hiding the rest to lessen the enter/leave events */
 689
 690     /* show windows from top to bottom */
 691     for (it = stacking_list; it; it = g_list_next(it)) {
 692         if (WINDOW_IS_CLIENT(it->data)) {
 693             ObClient *c = it->data;
 694             client_show(c);
 695         }
 696     }
 697
 698     if (dofocus) screen_fallback_focus();
 699
 700     /* hide windows from bottom to top */
 701     for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
 702         if (WINDOW_IS_CLIENT(it->data)) {
 703             ObClient *c = it->data;
 704             client_hide(c);
 705             if (c == focus_client) {
 706                 /* c was focused and we didn't do fallback clearly so make sure
 707                    openbox doesnt still consider the window focused.
 708                    this happens when using NextWindow with allDesktops, since
 709                    it doesnt want to move focus on desktop change, but the
 710                    focus is not going to stay with the current window, which
 711                    has now disappeared */
 712                 focus_set_client(NULL);
 713             }
 714         }
 715     }
 716
 717     event_end_ignore_all_enters(ignore_start);
 718
 719     if (event_curtime != CurrentTime)
 720         screen_desktop_user_time = event_curtime;
 721 }
 722
 723 void screen_add_desktop(gboolean current)
 724 {
 725     gulong ignore_start;
 726
 727     /* ignore enter events caused by this */
 728     ignore_start = event_start_ignore_all_enters();
 729
 730     screen_set_num_desktops(screen_num_desktops+1);
 731
 732     /* move all the clients over */
 733     if (current) {
 734         GList *it;
 735
 736         for (it = client_list; it; it = g_list_next(it)) {
 737             ObClient *c = it->data;
 738             if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
 739                 /* don't move direct children, they'll be moved with their
 740                    parent - which will have to be on the same desktop */
 741                 !client_direct_parent(c))
 742             {
 743                 ob_debug("moving window %s", c->title);
 744                 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
 745             }
 746         }
 747     }
 748
 749     event_end_ignore_all_enters(ignore_start);
 750 }
 751
 752 void screen_remove_desktop(gboolean current)
 753 {
 754     guint rmdesktop, movedesktop;
 755     GList *it, *stacking_copy;
 756     gulong ignore_start;
 757
 758     if (screen_num_desktops <= 1) return;
 759
 760     /* ignore enter events caused by this */
 761     ignore_start = event_start_ignore_all_enters();
 762
 763     /* what desktop are we removing and moving to? */
 764     if (current)
 765         rmdesktop = screen_desktop;
 766     else
 767         rmdesktop = screen_num_desktops - 1;
 768     if (rmdesktop < screen_num_desktops - 1)
 769         movedesktop = rmdesktop + 1;
 770     else
 771         movedesktop = rmdesktop;
 772
 773     /* make a copy of the list cuz we're changing it */
 774     stacking_copy = g_list_copy(stacking_list);
 775     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 776         if (WINDOW_IS_CLIENT(it->data)) {
 777             ObClient *c = it->data;
 778             guint d = c->desktop;
 779             if (d != DESKTOP_ALL && d >= movedesktop &&
 780                 /* don't move direct children, they'll be moved with their
 781                    parent - which will have to be on the same desktop */
 782                 !client_direct_parent(c))
 783             {
 784                 ob_debug("moving window %s", c->title);
 785                 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
 786             }
 787             /* raise all the windows that are on the current desktop which
 788                is being merged */
 789             if ((screen_desktop == rmdesktop - 1 ||
 790                  screen_desktop == rmdesktop) &&
 791                 (d == DESKTOP_ALL || d == screen_desktop))
 792             {
 793                 stacking_raise(CLIENT_AS_WINDOW(c));
 794                 ob_debug("raising window %s", c->title);
 795             }
 796         }
 797     }
 798     g_list_free(stacking_copy);
 799
 800     /* fallback focus like we're changing desktops */
 801     if (screen_desktop < screen_num_desktops - 1) {
 802         screen_fallback_focus();
 803         ob_debug("fake desktop change");
 804     }
 805
 806     screen_set_num_desktops(screen_num_desktops-1);
 807
 808     event_end_ignore_all_enters(ignore_start);
 809 }
 810
 811 static void get_row_col(guint d, guint *r, guint *c)
 812 {
 813     switch (screen_desktop_layout.orientation) {
 814     case OB_ORIENTATION_HORZ:
 815         switch (screen_desktop_layout.start_corner) {
 816         case OB_CORNER_TOPLEFT:
 817             *r = d / screen_desktop_layout.columns;
 818             *c = d % screen_desktop_layout.columns;
 819             break;
 820         case OB_CORNER_BOTTOMLEFT:
 821             *r = screen_desktop_layout.rows - 1 -
 822                 d / screen_desktop_layout.columns;
 823             *c = d % screen_desktop_layout.columns;
 824             break;
 825         case OB_CORNER_TOPRIGHT:
 826             *r = d / screen_desktop_layout.columns;
 827             *c = screen_desktop_layout.columns - 1 -
 828                 d % screen_desktop_layout.columns;
 829             break;
 830         case OB_CORNER_BOTTOMRIGHT:
 831             *r = screen_desktop_layout.rows - 1 -
 832                 d / screen_desktop_layout.columns;
 833             *c = screen_desktop_layout.columns - 1 -
 834                 d % screen_desktop_layout.columns;
 835             break;
 836         }
 837         break;
 838     case OB_ORIENTATION_VERT:
 839         switch (screen_desktop_layout.start_corner) {
 840         case OB_CORNER_TOPLEFT:
 841             *r = d % screen_desktop_layout.rows;
 842             *c = d / screen_desktop_layout.rows;
 843             break;
 844         case OB_CORNER_BOTTOMLEFT:
 845             *r = screen_desktop_layout.rows - 1 -
 846                 d % screen_desktop_layout.rows;
 847             *c = d / screen_desktop_layout.rows;
 848             break;
 849         case OB_CORNER_TOPRIGHT:
 850             *r = d % screen_desktop_layout.rows;
 851             *c = screen_desktop_layout.columns - 1 -
 852                 d / screen_desktop_layout.rows;
 853             break;
 854         case OB_CORNER_BOTTOMRIGHT:
 855             *r = screen_desktop_layout.rows - 1 -
 856                 d % screen_desktop_layout.rows;
 857             *c = screen_desktop_layout.columns - 1 -
 858                 d / screen_desktop_layout.rows;
 859             break;
 860         }
 861         break;
 862     }
 863 }
 864
 865 static guint translate_row_col(guint r, guint c)
 866 {
 867     switch (screen_desktop_layout.orientation) {
 868     case OB_ORIENTATION_HORZ:
 869         switch (screen_desktop_layout.start_corner) {
 870         case OB_CORNER_TOPLEFT:
 871             return r % screen_desktop_layout.rows *
 872                 screen_desktop_layout.columns +
 873                 c % screen_desktop_layout.columns;
 874         case OB_CORNER_BOTTOMLEFT:
 875             return (screen_desktop_layout.rows - 1 -
 876                     r % screen_desktop_layout.rows) *
 877                 screen_desktop_layout.columns +
 878                 c % screen_desktop_layout.columns;
 879         case OB_CORNER_TOPRIGHT:
 880             return r % screen_desktop_layout.rows *
 881                 screen_desktop_layout.columns +
 882                 (screen_desktop_layout.columns - 1 -
 883                  c % screen_desktop_layout.columns);
 884         case OB_CORNER_BOTTOMRIGHT:
 885             return (screen_desktop_layout.rows - 1 -
 886                     r % screen_desktop_layout.rows) *
 887                 screen_desktop_layout.columns +
 888                 (screen_desktop_layout.columns - 1 -
 889                  c % screen_desktop_layout.columns);
 890         }
 891     case OB_ORIENTATION_VERT:
 892         switch (screen_desktop_layout.start_corner) {
 893         case OB_CORNER_TOPLEFT:
 894             return c % screen_desktop_layout.columns *
 895                 screen_desktop_layout.rows +
 896                 r % screen_desktop_layout.rows;
 897         case OB_CORNER_BOTTOMLEFT:
 898             return c % screen_desktop_layout.columns *
 899                 screen_desktop_layout.rows +
 900                 (screen_desktop_layout.rows - 1 -
 901                  r % screen_desktop_layout.rows);
 902         case OB_CORNER_TOPRIGHT:
 903             return (screen_desktop_layout.columns - 1 -
 904                     c % screen_desktop_layout.columns) *
 905                 screen_desktop_layout.rows +
 906                 r % screen_desktop_layout.rows;
 907         case OB_CORNER_BOTTOMRIGHT:
 908             return (screen_desktop_layout.columns - 1 -
 909                     c % screen_desktop_layout.columns) *
 910                 screen_desktop_layout.rows +
 911                 (screen_desktop_layout.rows - 1 -
 912                  r % screen_desktop_layout.rows);
 913         }
 914     }
 915     g_assert_not_reached();
 916     return 0;
 917 }
 918
 919 static gboolean hide_desktop_popup_func(gpointer data)
 920 {
 921     pager_popup_hide(desktop_popup);
 922     return FALSE; /* don't repeat */
 923 }
 924
 925 void screen_show_desktop_popup(guint d)
 926 {
 927     Rect *a;
 928
 929     /* 0 means don't show the popup */
 930     if (!config_desktop_popup_time) return;
 931
 932     a = screen_physical_area_primary(FALSE);
 933     pager_popup_position(desktop_popup, CenterGravity,
 934                          a->x + a->width / 2, a->y + a->height / 2);
 935     pager_popup_icon_size_multiplier(desktop_popup,
 936                                      (screen_desktop_layout.columns /
 937                                       screen_desktop_layout.rows) / 2,
 938                                      (screen_desktop_layout.rows/
 939                                       screen_desktop_layout.columns) / 2);
 940     pager_popup_max_width(desktop_popup,
 941                           MAX(a->width/3, POPUP_WIDTH));
 942     pager_popup_show(desktop_popup, screen_desktop_names[d], d);
 943
 944     obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 945     obt_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
 946                               hide_desktop_popup_func, desktop_popup,
 947                               g_direct_equal, NULL);
 948     g_free(a);
 949 }
 950
 951 void screen_hide_desktop_popup(void)
 952 {
 953     obt_main_loop_timeout_remove_data(ob_main_loop, hide_desktop_popup_func,
 954                                       desktop_popup, FALSE);
 955     pager_popup_hide(desktop_popup);
 956 }
 957
 958 guint screen_find_desktop(guint from, ObDirection dir,
 959                           gboolean wrap, gboolean linear)
 960 {
 961     guint r, c;
 962     guint d;
 963
 964     d = from;
 965     get_row_col(d, &r, &c);
 966     if (linear) {
 967         switch (dir) {
 968         case OB_DIRECTION_EAST:
 969             if (d < screen_num_desktops - 1)
 970                 ++d;
 971             else if (wrap)
 972                 d = 0;
 973             else
 974                 return from;
 975             break;
 976         case OB_DIRECTION_WEST:
 977             if (d > 0)
 978                 --d;
 979             else if (wrap)
 980                 d = screen_num_desktops - 1;
 981             else
 982                 return from;
 983             break;
 984         default:
 985             g_assert_not_reached();
 986             return from;
 987         }
 988     } else {
 989         switch (dir) {
 990         case OB_DIRECTION_EAST:
 991             ++c;
 992             if (c >= screen_desktop_layout.columns) {
 993                 if (wrap)
 994                     c = 0;
 995                 else
 996                     return from;
 997             }
 998             d = translate_row_col(r, c);
 999             if (d >= screen_num_desktops) {
1000                 if (wrap)
1001                     ++c;
1002                 else
1003                     return from;
1004             }
1005             break;
1006         case OB_DIRECTION_WEST:
1007             --c;
1008             if (c >= screen_desktop_layout.columns) {
1009                 if (wrap)
1010                     c = screen_desktop_layout.columns - 1;
1011                 else
1012                     return from;
1013             }
1014             d = translate_row_col(r, c);
1015             if (d >= screen_num_desktops) {
1016                 if (wrap)
1017                     --c;
1018                 else
1019                     return from;
1020             }
1021             break;
1022         case OB_DIRECTION_SOUTH:
1023             ++r;
1024             if (r >= screen_desktop_layout.rows) {
1025                 if (wrap)
1026                     r = 0;
1027                 else
1028                     return from;
1029             }
1030             d = translate_row_col(r, c);
1031             if (d >= screen_num_desktops) {
1032                 if (wrap)
1033                     ++r;
1034                 else
1035                     return from;
1036             }
1037             break;
1038         case OB_DIRECTION_NORTH:
1039             --r;
1040             if (r >= screen_desktop_layout.rows) {
1041                 if (wrap)
1042                     r = screen_desktop_layout.rows - 1;
1043                 else
1044                     return from;
1045             }
1046             d = translate_row_col(r, c);
1047             if (d >= screen_num_desktops) {
1048                 if (wrap)
1049                     --r;
1050                 else
1051                     return from;
1052             }
1053             break;
1054         default:
1055             g_assert_not_reached();
1056             return from;
1057         }
1058
1059         d = translate_row_col(r, c);
1060     }
1061     return d;
1062 }
1063
1064 static gboolean screen_validate_layout(ObDesktopLayout *l)
1065 {
1066     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1067         return FALSE;
1068
1069     /* fill in a zero rows/columns */
1070     if (l->columns == 0) {
1071         l->columns = screen_num_desktops / l->rows;
1072         if (l->rows * l->columns < screen_num_desktops)
1073             l->columns++;
1074         if (l->rows * l->columns >= screen_num_desktops + l->columns)
1075             l->rows--;
1076     } else if (l->rows == 0) {
1077         l->rows = screen_num_desktops / l->columns;
1078         if (l->columns * l->rows < screen_num_desktops)
1079             l->rows++;
1080         if (l->columns * l->rows >= screen_num_desktops + l->rows)
1081             l->columns--;
1082     }
1083
1084     /* bounds checking */
1085     if (l->orientation == OB_ORIENTATION_HORZ) {
1086         l->columns = MIN(screen_num_desktops, l->columns);
1087         l->rows = MIN(l->rows,
1088                       (screen_num_desktops + l->columns - 1) / l->columns);
1089         l->columns = screen_num_desktops / l->rows +
1090             !!(screen_num_desktops % l->rows);
1091     } else {
1092         l->rows = MIN(screen_num_desktops, l->rows);
1093         l->columns = MIN(l->columns,
1094                          (screen_num_desktops + l->rows - 1) / l->rows);
1095         l->rows = screen_num_desktops / l->columns +
1096             !!(screen_num_desktops % l->columns);
1097     }
1098     return TRUE;
1099 }
1100
1101 void screen_update_layout(void)
1102
1103 {
1104     ObDesktopLayout l;
1105     guint32 *data;
1106     guint num;
1107
1108     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1109     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1110     screen_desktop_layout.rows = 1;
1111     screen_desktop_layout.columns = screen_num_desktops;
1112
1113     if (OBT_PROP_GETA32(obt_root(ob_screen),
1114                         NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1115         if (num == 3 || num == 4) {
1116
1117             if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1118                 l.orientation = OB_ORIENTATION_VERT;
1119             else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1120                 l.orientation = OB_ORIENTATION_HORZ;
1121             else
1122                 return;
1123
1124             if (num < 4)
1125                 l.start_corner = OB_CORNER_TOPLEFT;
1126             else {
1127                 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1128                     l.start_corner = OB_CORNER_TOPLEFT;
1129                 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1130                     l.start_corner = OB_CORNER_TOPRIGHT;
1131                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1132                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
1133                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1134                     l.start_corner = OB_CORNER_BOTTOMLEFT;
1135                 else
1136                     return;
1137             }
1138
1139             l.columns = data[1];
1140             l.rows = data[2];
1141
1142             if (screen_validate_layout(&l))
1143                 screen_desktop_layout = l;
1144
1145             g_free(data);
1146         }
1147     }
1148 }
1149
1150 void screen_update_desktop_names(void)
1151 {
1152     guint i;
1153
1154     /* empty the array */
1155     g_strfreev(screen_desktop_names);
1156     screen_desktop_names = NULL;
1157
1158     if (OBT_PROP_GETSS(obt_root(ob_screen),
1159                        NET_DESKTOP_NAMES, utf8, &screen_desktop_names))
1160         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1161     else
1162         i = 0;
1163     if (i < screen_num_desktops) {
1164         GSList *it;
1165
1166         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1167                                        screen_num_desktops + 1);
1168         screen_desktop_names[screen_num_desktops] = NULL;
1169
1170         it = g_slist_nth(config_desktops_names, i);
1171
1172         for (; i < screen_num_desktops; ++i) {
1173             if (it && ((char*)it->data)[0]) /* not empty */
1174                 /* use the names from the config file when possible */
1175                 screen_desktop_names[i] = g_strdup(it->data);
1176             else
1177                 /* make up a nice name if it's not though */
1178                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1179                                                           i + 1);
1180             if (it) it = g_slist_next(it);
1181         }
1182
1183         /* if we changed any names, then set the root property so we can
1184            all agree on the names */
1185         OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1186                        utf8, (const gchar**)screen_desktop_names);
1187     }
1188
1189     /* resize the pager for these names */
1190     pager_popup_text_width_to_strings(desktop_popup,
1191                                       screen_desktop_names,
1192                                       screen_num_desktops);
1193 }
1194
1195 void screen_show_desktop(gboolean show, ObClient *show_only)
1196 {
1197     GList *it;
1198
1199     if (show == screen_showing_desktop) return; /* no change */
1200
1201     screen_showing_desktop = show;
1202
1203     if (show) {
1204         /* hide windows bottom to top */
1205         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1206             if (WINDOW_IS_CLIENT(it->data)) {
1207                 ObClient *client = it->data;
1208                 client_showhide(client);
1209             }
1210         }
1211     }
1212     else {
1213         /* restore windows top to bottom */
1214         for (it = stacking_list; it; it = g_list_next(it)) {
1215             if (WINDOW_IS_CLIENT(it->data)) {
1216                 ObClient *client = it->data;
1217                 if (client_should_show(client)) {
1218                     if (!show_only || client == show_only)
1219                         client_show(client);
1220                     else
1221                         client_iconify(client, TRUE, FALSE, TRUE);
1222                 }
1223             }
1224         }
1225     }
1226
1227     if (show) {
1228         /* focus the desktop */
1229         for (it = focus_order; it; it = g_list_next(it)) {
1230             ObClient *c = it->data;
1231             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1232                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1233                 client_focus(it->data))
1234                 break;
1235         }
1236     }
1237     else if (!show_only) {
1238         ObClient *c;
1239
1240         if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1241             /* only do the flicker reducing stuff ahead of time if we are going
1242                to call xsetinputfocus on the window ourselves. otherwise there
1243                is no guarantee the window will actually take focus.. */
1244             if (c->can_focus) {
1245                 /* reduce flicker by hiliting now rather than waiting for the
1246                    server FocusIn event */
1247                 frame_adjust_focus(c->frame, TRUE);
1248             }
1249         }
1250     }
1251
1252     show = !!show; /* make it boolean */
1253     OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1254 }
1255
1256 void screen_install_colormap(ObClient *client, gboolean install)
1257 {
1258     if (client == NULL || client->colormap == None) {
1259         if (install)
1260             XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1261         else
1262             XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1263     } else {
1264         obt_display_ignore_errors(TRUE);
1265         if (install)
1266             XInstallColormap(obt_display, client->colormap);
1267         else
1268             XUninstallColormap(obt_display, client->colormap);
1269         obt_display_ignore_errors(FALSE);
1270     }
1271 }
1272
1273 typedef struct {
1274     guint desktop;
1275     StrutPartial *strut;
1276 } ObScreenStrut;
1277
1278 #define RESET_STRUT_LIST(sl) \
1279     (g_slist_free(sl), sl = NULL)
1280
1281 #define ADD_STRUT_TO_LIST(sl, d, s) \
1282 { \
1283     ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1284     ss->desktop = d; \
1285     ss->strut = s;  \
1286     sl = g_slist_prepend(sl, ss); \
1287 }
1288
1289 #define VALIDATE_STRUTS(sl, side, max) \
1290 { \
1291     GSList *it; \
1292     for (it = sl; it; it = g_slist_next(it)) { \
1293       ObScreenStrut *ss = it->data; \
1294       ss->strut->side = MIN(max, ss->strut->side); \
1295     } \
1296 }
1297
1298 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1299 {
1300     guint i;
1301     gint n, l, r, t, b;
1302 #ifdef XINERAMA
1303     XineramaScreenInfo *info;
1304 #endif
1305
1306     if (ob_debug_xinerama) {
1307         gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1308         gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1309         *nxin = 2;
1310         *xin_areas = g_new(Rect, *nxin + 1);
1311         RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1312         RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1313     }
1314 #ifdef XINERAMA
1315     else if (obt_display_extension_xinerama &&
1316              (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 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);
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 area to be full screen across all monitors */
1414     for (j = 0; j < screen_num_desktops; ++j) {
1415         dims[j*4 + 0] =
1416             monitor_area[screen_num_monitors].x;
1417         dims[j*4 + 1] =
1418             monitor_area[screen_num_monitors].y;
1419         dims[j*4 + 2] =
1420             monitor_area[screen_num_monitors].width;
1421         dims[j*4 + 3] =
1422             monitor_area[screen_num_monitors].height;
1423     }
1424
1425     /* calculate the work area from the struts */
1426     for (j = 0; j < screen_num_desktops; ++j) {
1427         gint l = 0, r = 0, t = 0, b = 0;
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                 l = MAX(l, s->strut->left);
1433         }
1434         for (sit = struts_top; sit; sit = g_slist_next(sit)) {
1435             ObScreenStrut *s = sit->data;
1436             if (s->desktop == j || s->desktop == DESKTOP_ALL)
1437                 t = MAX(t, s->strut->top);
1438         }
1439         for (sit = struts_right; sit; sit = g_slist_next(sit)) {
1440             ObScreenStrut *s = sit->data;
1441             if (s->desktop == j || s->desktop == DESKTOP_ALL)
1442                 r = MAX(r, s->strut->right);
1443         }
1444         for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
1445             ObScreenStrut *s = sit->data;
1446             if (s->desktop == j || s->desktop == DESKTOP_ALL)
1447                 b = MAX(b, s->strut->bottom);
1448         }
1449
1450         /* based on these margins, set the work area for the desktop */
1451         dims[j*4 + 0] += l;
1452         dims[j*4 + 1] += t;
1453         dims[j*4 + 2] -= l + r;
1454         dims[j*4 + 3] -= t + b;
1455     }
1456
1457     /* set the legacy workarea hint to the union of all the monitors */
1458     OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1459                     dims, 4 * screen_num_desktops);
1460
1461     /* the area has changed, adjust all the windows if they need it */
1462     for (it = client_list; it; it = g_list_next(it))
1463         client_reconfigure(it->data, FALSE);
1464
1465     g_free(dims);
1466 }
1467
1468 #if 0
1469 Rect* screen_area_all_monitors(guint desktop)
1470 {
1471     guint i;
1472     Rect *a;
1473
1474     a = screen_area_monitor(desktop, 0);
1475
1476     /* combine all the monitors together */
1477     for (i = 1; i < screen_num_monitors; ++i) {
1478         Rect *m = screen_area_monitor(desktop, i);
1479         gint l, r, t, b;
1480
1481         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1482         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1483         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1484         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1485
1486         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1487
1488         g_free(m);
1489     }
1490
1491     return a;
1492 }
1493 #endif
1494
1495 #define STRUT_LEFT_IN_SEARCH(s, search) \
1496     (RANGES_INTERSECT(search->y, search->height, \
1497                       s->left_start, s->left_end - s->left_start + 1))
1498 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1499     (RANGES_INTERSECT(search->y, search->height, \
1500                       s->right_start, s->right_end - s->right_start + 1))
1501 #define STRUT_TOP_IN_SEARCH(s, search) \
1502     (RANGES_INTERSECT(search->x, search->width, \
1503                       s->top_start, s->top_end - s->top_start + 1))
1504 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1505     (RANGES_INTERSECT(search->x, search->width, \
1506                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1507
1508 #define STRUT_LEFT_IGNORE(s, us, search) \
1509     (head == SCREEN_AREA_ALL_MONITORS && us && \
1510      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1511 #define STRUT_RIGHT_IGNORE(s, us, search) \
1512     (head == SCREEN_AREA_ALL_MONITORS && us && \
1513      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1514 #define STRUT_TOP_IGNORE(s, us, search) \
1515     (head == SCREEN_AREA_ALL_MONITORS && us && \
1516      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1517 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1518     (head == SCREEN_AREA_ALL_MONITORS && us && \
1519      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1520
1521 Rect* screen_area(guint desktop, guint head, Rect *search)
1522 {
1523     Rect *a;
1524     GSList *it;
1525     gint l, r, t, b;
1526     guint i, d;
1527     gboolean us = search != NULL; /* user provided search */
1528
1529     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1530     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1531              head == SCREEN_AREA_ALL_MONITORS);
1532     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1533
1534     /* find any struts for this monitor
1535        which will be affecting the search area.
1536     */
1537
1538     /* search everything if search is null */
1539     if (!search) {
1540         if (head < screen_num_monitors) search = &monitor_area[head];
1541         else search = &monitor_area[screen_num_monitors];
1542     }
1543     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1544
1545     /* al is "all left" meaning the furthest left you can get, l is our
1546        "working left" meaning our current strut edge which we're calculating
1547     */
1548
1549     /* only include monitors which the search area lines up with */
1550     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1551         l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1552         t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1553         r = RECT_LEFT(monitor_area[screen_num_monitors]);
1554         b = RECT_TOP(monitor_area[screen_num_monitors]);
1555         for (i = 0; i < screen_num_monitors; ++i) {
1556             /* add the monitor if applicable */
1557             if (RANGES_INTERSECT(search->x, search->width,
1558                                  monitor_area[i].x, monitor_area[i].width))
1559             {
1560                 t = MIN(t, RECT_TOP(monitor_area[i]));
1561                 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1562             }
1563             if (RANGES_INTERSECT(search->y, search->height,
1564                                  monitor_area[i].y, monitor_area[i].height))
1565             {
1566                 l = MIN(l, RECT_LEFT(monitor_area[i]));
1567                 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1568             }
1569         }
1570     } else {
1571         l = RECT_LEFT(monitor_area[screen_num_monitors]);
1572         t = RECT_TOP(monitor_area[screen_num_monitors]);
1573         r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1574         b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1575     }
1576
1577     for (d = 0; d < screen_num_desktops; ++d) {
1578         if (d != desktop && desktop != DESKTOP_ALL) continue;
1579
1580         for (i = 0; i < screen_num_monitors; ++i) {
1581             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1582
1583             for (it = struts_left; it; it = g_slist_next(it)) {
1584                 ObScreenStrut *s = it->data;
1585                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1586                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1587                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1588                     l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1589                                + s->strut->left);
1590             }
1591             for (it = struts_top; it; it = g_slist_next(it)) {
1592                 ObScreenStrut *s = it->data;
1593                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1594                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1595                     !STRUT_TOP_IGNORE(s->strut, us, search))
1596                     t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1597                                + s->strut->top);
1598             }
1599             for (it = struts_right; it; it = g_slist_next(it)) {
1600                 ObScreenStrut *s = it->data;
1601                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1602                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1603                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1604                     r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1605                                - s->strut->right);
1606             }
1607             for (it = struts_bottom; it; it = g_slist_next(it)) {
1608                 ObScreenStrut *s = it->data;
1609                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1610                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1611                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1612                     b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1613                                - s->strut->bottom);
1614             }
1615
1616             /* limit to this monitor */
1617             if (head == i) {
1618                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1619                 t = MAX(t, RECT_TOP(monitor_area[i]));
1620                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1621                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1622             }
1623         }
1624     }
1625
1626     a = g_new(Rect, 1);
1627     a->x = l;
1628     a->y = t;
1629     a->width = r - l + 1;
1630     a->height = b - t + 1;
1631     return a;
1632 }
1633
1634 guint screen_find_monitor(Rect *search)
1635 {
1636     guint i;
1637     guint most = screen_num_monitors;
1638     guint mostv = 0;
1639
1640     for (i = 0; i < screen_num_monitors; ++i) {
1641         Rect *area = screen_physical_area_monitor(i);
1642         if (RECT_INTERSECTS_RECT(*area, *search)) {
1643             Rect r;
1644             guint v;
1645
1646             RECT_SET_INTERSECTION(r, *area, *search);
1647             v = r.width * r.height;
1648
1649             if (v > mostv) {
1650                 mostv = v;
1651                 most = i;
1652             }
1653         }
1654         g_free(area);
1655     }
1656     return most;
1657 }
1658
1659 Rect* screen_physical_area_all_monitors(void)
1660 {
1661     return screen_physical_area_monitor(screen_num_monitors);
1662 }
1663
1664 Rect* screen_physical_area_monitor(guint head)
1665 {
1666     Rect *a;
1667     g_assert(head <= screen_num_monitors);
1668
1669     a = g_new(Rect, 1);
1670     *a = monitor_area[head];
1671     return a;
1672 }
1673
1674 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1675 {
1676     g_assert(head <= screen_num_monitors);
1677     g_assert(search);
1678     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1679 }
1680
1681 guint screen_monitor_active(void)
1682 {
1683     if (moveresize_client)
1684         return client_monitor(moveresize_client);
1685     else if (focus_client)
1686         return client_monitor(focus_client);
1687     else
1688         return screen_monitor_pointer();
1689 }
1690
1691 Rect* screen_physical_area_active(void)
1692 {
1693     return screen_physical_area_monitor(screen_monitor_active());
1694 }
1695
1696 guint screen_monitor_primary(gboolean fixed)
1697 {
1698     if (config_primary_monitor_index > 0) {
1699         if (config_primary_monitor_index-1 < screen_num_monitors)
1700             return config_primary_monitor_index - 1;
1701         else
1702             return 0;
1703     }
1704     else if (fixed)
1705         return 0;
1706     else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1707         return screen_monitor_active();
1708     else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1709         return screen_monitor_pointer();
1710 }
1711
1712 Rect *screen_physical_area_primary(gboolean fixed)
1713 {
1714     return screen_physical_area_monitor(screen_monitor_primary(fixed));
1715 }
1716
1717 void screen_set_root_cursor(void)
1718 {
1719     if (sn_app_starting())
1720         XDefineCursor(obt_display, obt_root(ob_screen),
1721                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1722     else
1723         XDefineCursor(obt_display, obt_root(ob_screen),
1724                       ob_cursor(OB_CURSOR_POINTER));
1725 }
1726
1727 guint screen_find_monitor_point(guint x, guint y)
1728 {
1729     Rect mon;
1730     RECT_SET(mon, x, y, 1, 1);
1731     return screen_find_monitor(&mon);
1732 }
1733
1734 guint screen_monitor_pointer()
1735 {
1736     gint x, y;
1737     if (!screen_pointer_pos(&x, &y))
1738         x = y = 0;
1739     return screen_find_monitor_point(x, y);
1740 }
1741
1742 gboolean screen_pointer_pos(gint *x, gint *y)
1743 {
1744     Window w;
1745     gint i;
1746     guint u;
1747     gboolean ret;
1748
1749     ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1750                           &w, &w, x, y, &i, &i, &u);
1751     if (!ret) {
1752         for (i = 0; i < ScreenCount(obt_display); ++i)
1753             if (i != ob_screen)
1754                 if (XQueryPointer(obt_display, obt_root(i),
1755                                   &w, &w, x, y, &i, &i, &u))
1756                     break;
1757     }
1758     return ret;
1759 }