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