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