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_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_source_time() != CurrentTime)
 735         screen_desktop_user_time = event_source_time();
 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     const 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
 970 void screen_hide_desktop_popup(void)
 971 {
 972     obt_main_loop_timeout_remove_data(ob_main_loop, hide_desktop_popup_func,
 973                                       desktop_popup, FALSE);
 974     pager_popup_hide(desktop_popup);
 975     desktop_popup_perm = FALSE;
 976 }
 977
 978 guint screen_find_desktop(guint from, ObDirection dir,
 979                           gboolean wrap, gboolean linear)
 980 {
 981     guint r, c;
 982     guint d;
 983
 984     d = from;
 985     get_row_col(d, &r, &c);
 986     if (linear) {
 987         switch (dir) {
 988         case OB_DIRECTION_EAST:
 989             if (d < screen_num_desktops - 1)
 990                 ++d;
 991             else if (wrap)
 992                 d = 0;
 993             else
 994                 return from;
 995             break;
 996         case OB_DIRECTION_WEST:
 997             if (d > 0)
 998                 --d;
 999             else if (wrap)
1000                 d = screen_num_desktops - 1;
1001             else
1002                 return from;
1003             break;
1004         default:
1005             g_assert_not_reached();
1006             return from;
1007         }
1008     } else {
1009         switch (dir) {
1010         case OB_DIRECTION_EAST:
1011             ++c;
1012             if (c >= screen_desktop_layout.columns) {
1013                 if (wrap)
1014                     c = 0;
1015                 else
1016                     return from;
1017             }
1018             d = translate_row_col(r, c);
1019             if (d >= screen_num_desktops) {
1020                 if (wrap)
1021                     ++c;
1022                 else
1023                     return from;
1024             }
1025             break;
1026         case OB_DIRECTION_WEST:
1027             --c;
1028             if (c >= screen_desktop_layout.columns) {
1029                 if (wrap)
1030                     c = screen_desktop_layout.columns - 1;
1031                 else
1032                     return from;
1033             }
1034             d = translate_row_col(r, c);
1035             if (d >= screen_num_desktops) {
1036                 if (wrap)
1037                     --c;
1038                 else
1039                     return from;
1040             }
1041             break;
1042         case OB_DIRECTION_SOUTH:
1043             ++r;
1044             if (r >= screen_desktop_layout.rows) {
1045                 if (wrap)
1046                     r = 0;
1047                 else
1048                     return from;
1049             }
1050             d = translate_row_col(r, c);
1051             if (d >= screen_num_desktops) {
1052                 if (wrap)
1053                     ++r;
1054                 else
1055                     return from;
1056             }
1057             break;
1058         case OB_DIRECTION_NORTH:
1059             --r;
1060             if (r >= screen_desktop_layout.rows) {
1061                 if (wrap)
1062                     r = screen_desktop_layout.rows - 1;
1063                 else
1064                     return from;
1065             }
1066             d = translate_row_col(r, c);
1067             if (d >= screen_num_desktops) {
1068                 if (wrap)
1069                     --r;
1070                 else
1071                     return from;
1072             }
1073             break;
1074         default:
1075             g_assert_not_reached();
1076             return from;
1077         }
1078
1079         d = translate_row_col(r, c);
1080     }
1081     return d;
1082 }
1083
1084 static gboolean screen_validate_layout(ObDesktopLayout *l)
1085 {
1086     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1087         return FALSE;
1088
1089     /* fill in a zero rows/columns */
1090     if (l->columns == 0) {
1091         l->columns = screen_num_desktops / l->rows;
1092         if (l->rows * l->columns < screen_num_desktops)
1093             l->columns++;
1094         if (l->rows * l->columns >= screen_num_desktops + l->columns)
1095             l->rows--;
1096     } else if (l->rows == 0) {
1097         l->rows = screen_num_desktops / l->columns;
1098         if (l->columns * l->rows < screen_num_desktops)
1099             l->rows++;
1100         if (l->columns * l->rows >= screen_num_desktops + l->rows)
1101             l->columns--;
1102     }
1103
1104     /* bounds checking */
1105     if (l->orientation == OB_ORIENTATION_HORZ) {
1106         l->columns = MIN(screen_num_desktops, l->columns);
1107         l->rows = MIN(l->rows,
1108                       (screen_num_desktops + l->columns - 1) / l->columns);
1109         l->columns = screen_num_desktops / l->rows +
1110             !!(screen_num_desktops % l->rows);
1111     } else {
1112         l->rows = MIN(screen_num_desktops, l->rows);
1113         l->columns = MIN(l->columns,
1114                          (screen_num_desktops + l->rows - 1) / l->rows);
1115         l->rows = screen_num_desktops / l->columns +
1116             !!(screen_num_desktops % l->columns);
1117     }
1118     return TRUE;
1119 }
1120
1121 void screen_update_layout(void)
1122
1123 {
1124     ObDesktopLayout l;
1125     guint32 *data;
1126     guint num;
1127
1128     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1129     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1130     screen_desktop_layout.rows = 1;
1131     screen_desktop_layout.columns = screen_num_desktops;
1132
1133     if (OBT_PROP_GETA32(obt_root(ob_screen),
1134                         NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1135         if (num == 3 || num == 4) {
1136
1137             if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1138                 l.orientation = OB_ORIENTATION_VERT;
1139             else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1140                 l.orientation = OB_ORIENTATION_HORZ;
1141             else
1142                 return;
1143
1144             if (num < 4)
1145                 l.start_corner = OB_CORNER_TOPLEFT;
1146             else {
1147                 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1148                     l.start_corner = OB_CORNER_TOPLEFT;
1149                 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1150                     l.start_corner = OB_CORNER_TOPRIGHT;
1151                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1152                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
1153                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1154                     l.start_corner = OB_CORNER_BOTTOMLEFT;
1155                 else
1156                     return;
1157             }
1158
1159             l.columns = data[1];
1160             l.rows = data[2];
1161
1162             if (screen_validate_layout(&l))
1163                 screen_desktop_layout = l;
1164
1165             g_free(data);
1166         }
1167     }
1168 }
1169
1170 void screen_update_desktop_names(void)
1171 {
1172     guint i;
1173
1174     /* empty the array */
1175     g_strfreev(screen_desktop_names);
1176     screen_desktop_names = NULL;
1177
1178     if (OBT_PROP_GETSS(obt_root(ob_screen),
1179                        NET_DESKTOP_NAMES, utf8, &screen_desktop_names))
1180         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1181     else
1182         i = 0;
1183     if (i < screen_num_desktops) {
1184         GSList *it;
1185
1186         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1187                                        screen_num_desktops + 1);
1188         screen_desktop_names[screen_num_desktops] = NULL;
1189
1190         it = g_slist_nth(config_desktops_names, i);
1191
1192         for (; i < screen_num_desktops; ++i) {
1193             if (it && ((char*)it->data)[0]) /* not empty */
1194                 /* use the names from the config file when possible */
1195                 screen_desktop_names[i] = g_strdup(it->data);
1196             else
1197                 /* make up a nice name if it's not though */
1198                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1199                                                           i + 1);
1200             if (it) it = g_slist_next(it);
1201         }
1202
1203         /* if we changed any names, then set the root property so we can
1204            all agree on the names */
1205         OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1206                        utf8, (const gchar**)screen_desktop_names);
1207     }
1208
1209     /* resize the pager for these names */
1210     pager_popup_text_width_to_strings(desktop_popup,
1211                                       screen_desktop_names,
1212                                       screen_num_desktops);
1213 }
1214
1215 void screen_show_desktop(gboolean show, ObClient *show_only)
1216 {
1217     GList *it;
1218
1219     if (show == screen_showing_desktop) return; /* no change */
1220
1221     screen_showing_desktop = show;
1222
1223     if (show) {
1224         /* hide windows bottom to top */
1225         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1226             if (WINDOW_IS_CLIENT(it->data)) {
1227                 ObClient *client = it->data;
1228                 client_showhide(client);
1229             }
1230         }
1231     }
1232     else {
1233         /* restore windows top to bottom */
1234         for (it = stacking_list; it; it = g_list_next(it)) {
1235             if (WINDOW_IS_CLIENT(it->data)) {
1236                 ObClient *client = it->data;
1237                 if (client_should_show(client)) {
1238                     if (!show_only || client == show_only)
1239                         client_show(client);
1240                     else
1241                         client_iconify(client, TRUE, FALSE, TRUE);
1242                 }
1243             }
1244         }
1245     }
1246
1247     if (show) {
1248         /* focus the desktop */
1249         for (it = focus_order; it; it = g_list_next(it)) {
1250             ObClient *c = it->data;
1251             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1252                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1253                 client_focus(it->data))
1254                 break;
1255         }
1256     }
1257     else if (!show_only) {
1258         ObClient *c;
1259
1260         if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1261             /* only do the flicker reducing stuff ahead of time if we are going
1262                to call xsetinputfocus on the window ourselves. otherwise there
1263                is no guarantee the window will actually take focus.. */
1264             if (c->can_focus) {
1265                 /* reduce flicker by hiliting now rather than waiting for the
1266                    server FocusIn event */
1267                 frame_adjust_focus(c->frame, TRUE);
1268             }
1269         }
1270     }
1271
1272     show = !!show; /* make it boolean */
1273     OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1274 }
1275
1276 void screen_install_colormap(ObClient *client, gboolean install)
1277 {
1278     if (client == NULL || client->colormap == None) {
1279         if (install)
1280             XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1281         else
1282             XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1283     } else {
1284         obt_display_ignore_errors(TRUE);
1285         if (install)
1286             XInstallColormap(obt_display, client->colormap);
1287         else
1288             XUninstallColormap(obt_display, client->colormap);
1289         obt_display_ignore_errors(FALSE);
1290     }
1291 }
1292
1293 typedef struct {
1294     guint desktop;
1295     StrutPartial *strut;
1296 } ObScreenStrut;
1297
1298 #define RESET_STRUT_LIST(sl) \
1299     while (sl) { \
1300         g_slice_free(ObScreenStrut, (sl)->data); \
1301         sl = g_slist_delete_link(sl, sl); \
1302     }
1303
1304 #define ADD_STRUT_TO_LIST(sl, d, s) \
1305 { \
1306     ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1307     ss->desktop = d; \
1308     ss->strut = s;  \
1309     sl = g_slist_prepend(sl, ss); \
1310 }
1311
1312 #define VALIDATE_STRUTS(sl, side, max) \
1313 { \
1314     GSList *it; \
1315     for (it = sl; it; it = g_slist_next(it)) { \
1316       ObScreenStrut *ss = it->data; \
1317       ss->strut->side = MIN(max, ss->strut->side); \
1318     } \
1319 }
1320
1321 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1322 {
1323     guint i;
1324     gint n, l, r, t, b;
1325 #ifdef XINERAMA
1326     XineramaScreenInfo *info;
1327 #endif
1328
1329     if (ob_debug_xinerama) {
1330         gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1331         gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1332         *nxin = 2;
1333         *xin_areas = g_new(Rect, *nxin + 1);
1334         RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1335         RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1336     }
1337 #ifdef XINERAMA
1338     else if (obt_display_extension_xinerama &&
1339              (info = XineramaQueryScreens(obt_display, &n))) {
1340         *nxin = n;
1341         *xin_areas = g_new(Rect, *nxin + 1);
1342         for (i = 0; i < *nxin; ++i)
1343             RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1344                      info[i].width, info[i].height);
1345         XFree(info);
1346     }
1347 #endif
1348     else {
1349         *nxin = 1;
1350         *xin_areas = g_new(Rect, *nxin + 1);
1351         RECT_SET((*xin_areas)[0], 0, 0,
1352                  WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1353                  HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1354     }
1355
1356     /* returns one extra with the total area in it */
1357     l = (*xin_areas)[0].x;
1358     t = (*xin_areas)[0].y;
1359     r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1360     b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1361     for (i = 1; i < *nxin; ++i) {
1362         l = MIN(l, (*xin_areas)[i].x);
1363         t = MIN(l, (*xin_areas)[i].y);
1364         r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1365         b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1366     }
1367     RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1368 }
1369
1370 void screen_update_areas(void)
1371 {
1372     guint i;
1373     gulong *dims;
1374     GList *it;
1375
1376     g_free(monitor_area);
1377     get_xinerama_screens(&monitor_area, &screen_num_monitors);
1378
1379     /* set up the user-specified margins */
1380     config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1381     config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1382     config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1383     config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1384     config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1385     config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1386     config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1387     config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1388
1389     RESET_STRUT_LIST(struts_left);
1390     RESET_STRUT_LIST(struts_top);
1391     RESET_STRUT_LIST(struts_right);
1392     RESET_STRUT_LIST(struts_bottom);
1393
1394     /* collect the struts */
1395     for (it = client_list; it; it = g_list_next(it)) {
1396         ObClient *c = it->data;
1397         if (c->strut.left)
1398             ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1399         if (c->strut.top)
1400             ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1401         if (c->strut.right)
1402             ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1403         if (c->strut.bottom)
1404             ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1405     }
1406     if (dock_strut.left)
1407         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1408     if (dock_strut.top)
1409         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1410     if (dock_strut.right)
1411         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1412     if (dock_strut.bottom)
1413         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1414
1415     if (config_margins.left)
1416         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1417     if (config_margins.top)
1418         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1419     if (config_margins.right)
1420         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1421     if (config_margins.bottom)
1422         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1423
1424     VALIDATE_STRUTS(struts_left, left,
1425                     monitor_area[screen_num_monitors].width / 2);
1426     VALIDATE_STRUTS(struts_right, right,
1427                     monitor_area[screen_num_monitors].width / 2);
1428     VALIDATE_STRUTS(struts_top, top,
1429                     monitor_area[screen_num_monitors].height / 2);
1430     VALIDATE_STRUTS(struts_bottom, bottom,
1431                     monitor_area[screen_num_monitors].height / 2);
1432
1433     dims = g_new(gulong, 4 * screen_num_desktops);
1434     for (i = 0; i < screen_num_desktops; ++i) {
1435         Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1436         dims[i*4+0] = area->x;
1437         dims[i*4+1] = area->y;
1438         dims[i*4+2] = area->width;
1439         dims[i*4+3] = area->height;
1440         g_slice_free(Rect, area);
1441     }
1442
1443     /* set the legacy workarea hint to the union of all the monitors */
1444     OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1445                     dims, 4 * screen_num_desktops);
1446
1447     /* the area has changed, adjust all the windows if they need it */
1448     for (it = client_list; it; it = g_list_next(it))
1449         client_reconfigure(it->data, FALSE);
1450
1451     g_free(dims);
1452 }
1453
1454 #if 0
1455 Rect* screen_area_all_monitors(guint desktop)
1456 {
1457     guint i;
1458     Rect *a;
1459
1460     a = screen_area_monitor(desktop, 0);
1461
1462     /* combine all the monitors together */
1463     for (i = 1; i < screen_num_monitors; ++i) {
1464         Rect *m = screen_area_monitor(desktop, i);
1465         gint l, r, t, b;
1466
1467         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1468         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1469         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1470         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1471
1472         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1473
1474         g_free(m);
1475     }
1476
1477     return a;
1478 }
1479 #endif
1480
1481 #define STRUT_LEFT_IN_SEARCH(s, search) \
1482     (RANGES_INTERSECT(search->y, search->height, \
1483                       s->left_start, s->left_end - s->left_start + 1))
1484 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1485     (RANGES_INTERSECT(search->y, search->height, \
1486                       s->right_start, s->right_end - s->right_start + 1))
1487 #define STRUT_TOP_IN_SEARCH(s, search) \
1488     (RANGES_INTERSECT(search->x, search->width, \
1489                       s->top_start, s->top_end - s->top_start + 1))
1490 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1491     (RANGES_INTERSECT(search->x, search->width, \
1492                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1493
1494 #define STRUT_LEFT_IGNORE(s, us, search) \
1495     (head == SCREEN_AREA_ALL_MONITORS && us && \
1496      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1497 #define STRUT_RIGHT_IGNORE(s, us, search) \
1498     (head == SCREEN_AREA_ALL_MONITORS && us && \
1499      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1500 #define STRUT_TOP_IGNORE(s, us, search) \
1501     (head == SCREEN_AREA_ALL_MONITORS && us && \
1502      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1503 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1504     (head == SCREEN_AREA_ALL_MONITORS && us && \
1505      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1506
1507 Rect* screen_area(guint desktop, guint head, Rect *search)
1508 {
1509     Rect *a;
1510     GSList *it;
1511     gint l, r, t, b;
1512     guint i, d;
1513     gboolean us = search != NULL; /* user provided search */
1514
1515     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1516     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1517              head == SCREEN_AREA_ALL_MONITORS);
1518     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1519
1520     /* find any struts for this monitor
1521        which will be affecting the search area.
1522     */
1523
1524     /* search everything if search is null */
1525     if (!search) {
1526         if (head < screen_num_monitors) search = &monitor_area[head];
1527         else search = &monitor_area[screen_num_monitors];
1528     }
1529     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1530
1531     /* al is "all left" meaning the furthest left you can get, l is our
1532        "working left" meaning our current strut edge which we're calculating
1533     */
1534
1535     /* only include monitors which the search area lines up with */
1536     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1537         l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1538         t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1539         r = RECT_LEFT(monitor_area[screen_num_monitors]);
1540         b = RECT_TOP(monitor_area[screen_num_monitors]);
1541         for (i = 0; i < screen_num_monitors; ++i) {
1542             /* add the monitor if applicable */
1543             if (RANGES_INTERSECT(search->x, search->width,
1544                                  monitor_area[i].x, monitor_area[i].width))
1545             {
1546                 t = MIN(t, RECT_TOP(monitor_area[i]));
1547                 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1548             }
1549             if (RANGES_INTERSECT(search->y, search->height,
1550                                  monitor_area[i].y, monitor_area[i].height))
1551             {
1552                 l = MIN(l, RECT_LEFT(monitor_area[i]));
1553                 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1554             }
1555         }
1556     } else {
1557         l = RECT_LEFT(monitor_area[screen_num_monitors]);
1558         t = RECT_TOP(monitor_area[screen_num_monitors]);
1559         r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1560         b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1561     }
1562
1563     for (d = 0; d < screen_num_desktops; ++d) {
1564         if (d != desktop && desktop != DESKTOP_ALL) continue;
1565
1566         for (i = 0; i < screen_num_monitors; ++i) {
1567             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1568
1569             for (it = struts_left; it; it = g_slist_next(it)) {
1570                 ObScreenStrut *s = it->data;
1571                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1572                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1573                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1574                     l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1575                                + s->strut->left);
1576             }
1577             for (it = struts_top; it; it = g_slist_next(it)) {
1578                 ObScreenStrut *s = it->data;
1579                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1580                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1581                     !STRUT_TOP_IGNORE(s->strut, us, search))
1582                     t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1583                                + s->strut->top);
1584             }
1585             for (it = struts_right; it; it = g_slist_next(it)) {
1586                 ObScreenStrut *s = it->data;
1587                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1588                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1589                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1590                     r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1591                                - s->strut->right);
1592             }
1593             for (it = struts_bottom; it; it = g_slist_next(it)) {
1594                 ObScreenStrut *s = it->data;
1595                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1596                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1597                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1598                     b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1599                                - s->strut->bottom);
1600             }
1601
1602             /* limit to this monitor */
1603             if (head == i) {
1604                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1605                 t = MAX(t, RECT_TOP(monitor_area[i]));
1606                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1607                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1608             }
1609         }
1610     }
1611
1612     a = g_slice_new(Rect);
1613     a->x = l;
1614     a->y = t;
1615     a->width = r - l + 1;
1616     a->height = b - t + 1;
1617     return a;
1618 }
1619
1620 guint screen_find_monitor(const Rect *search)
1621 {
1622     guint i;
1623     guint most = screen_num_monitors;
1624     guint mostv = 0;
1625
1626     for (i = 0; i < screen_num_monitors; ++i) {
1627         const Rect *area = screen_physical_area_monitor(i);
1628         if (RECT_INTERSECTS_RECT(*area, *search)) {
1629             Rect r;
1630             guint v;
1631
1632             RECT_SET_INTERSECTION(r, *area, *search);
1633             v = r.width * r.height;
1634
1635             if (v > mostv) {
1636                 mostv = v;
1637                 most = i;
1638             }
1639         }
1640     }
1641     return most;
1642 }
1643
1644 const Rect* screen_physical_area_all_monitors(void)
1645 {
1646     return screen_physical_area_monitor(screen_num_monitors);
1647 }
1648
1649 const Rect* screen_physical_area_monitor(guint head)
1650 {
1651     g_assert(head <= screen_num_monitors);
1652
1653     return &monitor_area[head];
1654 }
1655
1656 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1657 {
1658     g_assert(head <= screen_num_monitors);
1659     g_assert(search);
1660     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1661 }
1662
1663 guint screen_monitor_active(void)
1664 {
1665     if (moveresize_client)
1666         return client_monitor(moveresize_client);
1667     else if (focus_client)
1668         return client_monitor(focus_client);
1669     else
1670         return screen_monitor_pointer();
1671 }
1672
1673 const Rect* screen_physical_area_active(void)
1674 {
1675     return screen_physical_area_monitor(screen_monitor_active());
1676 }
1677
1678 guint screen_monitor_primary(gboolean fixed)
1679 {
1680     if (config_primary_monitor_index > 0) {
1681         if (config_primary_monitor_index-1 < screen_num_monitors)
1682             return config_primary_monitor_index - 1;
1683         else
1684             return 0;
1685     }
1686     else if (fixed)
1687         return 0;
1688     else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1689         return screen_monitor_active();
1690     else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1691         return screen_monitor_pointer();
1692 }
1693
1694 const Rect* screen_physical_area_primary(gboolean fixed)
1695 {
1696     return screen_physical_area_monitor(screen_monitor_primary(fixed));
1697 }
1698
1699 void screen_set_root_cursor(void)
1700 {
1701     if (sn_app_starting())
1702         XDefineCursor(obt_display, obt_root(ob_screen),
1703                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1704     else
1705         XDefineCursor(obt_display, obt_root(ob_screen),
1706                       ob_cursor(OB_CURSOR_POINTER));
1707 }
1708
1709 guint screen_find_monitor_point(guint x, guint y)
1710 {
1711     Rect mon;
1712     RECT_SET(mon, x, y, 1, 1);
1713     return screen_find_monitor(&mon);
1714 }
1715
1716 guint screen_monitor_pointer()
1717 {
1718     gint x, y;
1719     if (!screen_pointer_pos(&x, &y))
1720         x = y = 0;
1721     return screen_find_monitor_point(x, y);
1722 }
1723
1724 gboolean screen_pointer_pos(gint *x, gint *y)
1725 {
1726     Window w;
1727     gint i;
1728     guint u;
1729     gboolean ret;
1730
1731     ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1732                           &w, &w, x, y, &i, &i, &u);
1733     if (!ret) {
1734         for (i = 0; i < ScreenCount(obt_display); ++i)
1735             if (i != ob_screen)
1736                 if (XQueryPointer(obt_display, obt_root(i),
1737                                   &w, &w, x, y, &i, &i, &u))
1738                     break;
1739     }
1740     return ret;
1741 }