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 "xerror.h"
  24 #include "prop.h"
  25 #include "grab.h"
  26 #include "startupnotify.h"
  27 #include "moveresize.h"
  28 #include "config.h"
  29 #include "screen.h"
  30 #include "client.h"
  31 #include "session.h"
  32 #include "frame.h"
  33 #include "event.h"
  34 #include "focus.h"
  35 #include "popup.h"
  36 #include "extensions.h"
  37 #include "render/render.h"
  38 #include "gettext.h"
  39
  40 #include <X11/Xlib.h>
  41 #ifdef HAVE_UNISTD_H
  42 #  include <sys/types.h>
  43 #  include <unistd.h>
  44 #endif
  45 #include <assert.h>
  46
  47 /*! The event mask to grab on the root window */
  48 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
  49                         EnterWindowMask | LeaveWindowMask | \
  50                         SubstructureRedirectMask | FocusChangeMask | \
  51                         ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
  52
  53 static gboolean screen_validate_layout(ObDesktopLayout *l);
  54 static gboolean replace_wm();
  55 static void     screen_tell_ksplash();
  56
  57 guint    screen_num_desktops;
  58 guint    screen_num_monitors;
  59 guint    screen_desktop;
  60 guint    screen_last_desktop;
  61 Size     screen_physical_size;
  62 gboolean screen_showing_desktop;
  63 ObDesktopLayout screen_desktop_layout;
  64 gchar  **screen_desktop_names;
  65 Window   screen_support_win;
  66 Time     screen_desktop_user_time = CurrentTime;
  67
  68 static Rect  **area; /* array of desktop holding array of xinerama areas */
  69 static Rect  *monitor_area;
  70
  71 static ObPagerPopup *desktop_cycle_popup;
  72
  73 static gboolean replace_wm()
  74 {
  75     gchar *wm_sn;
  76     Atom wm_sn_atom;
  77     Window current_wm_sn_owner;
  78     Time timestamp;
  79
  80     wm_sn = g_strdup_printf("WM_S%d", ob_screen);
  81     wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
  82     g_free(wm_sn);
  83
  84     current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
  85     if (current_wm_sn_owner == screen_support_win)
  86         current_wm_sn_owner = None;
  87     if (current_wm_sn_owner) {
  88         if (!ob_replace_wm) {
  89             g_message(_("A window manager is already running on screen %d"),
  90                       ob_screen);
  91             return FALSE;
  92         }
  93         xerror_set_ignore(TRUE);
  94         xerror_occured = FALSE;
  95
  96         /* We want to find out when the current selection owner dies */
  97         XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
  98         XSync(ob_display, FALSE);
  99
 100         xerror_set_ignore(FALSE);
 101         if (xerror_occured)
 102             current_wm_sn_owner = None;
 103     }
 104
 105     {
 106         /* Generate a timestamp */
 107         XEvent event;
 108
 109         XSelectInput(ob_display, screen_support_win, PropertyChangeMask);
 110
 111         XChangeProperty(ob_display, screen_support_win,
 112                         prop_atoms.wm_class, prop_atoms.string,
 113                         8, PropModeAppend, NULL, 0);
 114         XWindowEvent(ob_display, screen_support_win,
 115                      PropertyChangeMask, &event);
 116
 117         XSelectInput(ob_display, screen_support_win, NoEventMask);
 118
 119         timestamp = event.xproperty.time;
 120     }
 121
 122     XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
 123                        timestamp);
 124
 125     if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
 126         g_message(_("Could not acquire window manager selection on screen %d"),
 127                   ob_screen);
 128         return FALSE;
 129     }
 130
 131     /* Wait for old window manager to go away */
 132     if (current_wm_sn_owner) {
 133       XEvent event;
 134       gulong wait = 0;
 135       const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
 136
 137       while (wait < timeout) {
 138           if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
 139                                 StructureNotifyMask, &event) &&
 140               event.type == DestroyNotify)
 141               break;
 142           g_usleep(G_USEC_PER_SEC / 10);
 143           wait += G_USEC_PER_SEC / 10;
 144       }
 145
 146       if (wait >= timeout) {
 147           g_message(_("The WM on screen %d is not exiting"), ob_screen);
 148           return FALSE;
 149       }
 150     }
 151
 152     /* Send client message indicating that we are now the WM */
 153     prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
 154                  timestamp, wm_sn_atom, screen_support_win, 0,
 155                  SubstructureNotifyMask);
 156
 157     return TRUE;
 158 }
 159
 160 gboolean screen_annex()
 161 {
 162     XSetWindowAttributes attrib;
 163     pid_t pid;
 164     gint i, num_support;
 165     Atom *prop_atoms_start, *wm_supported_pos;
 166     gulong *supported;
 167
 168     /* create the netwm support window */
 169     attrib.override_redirect = TRUE;
 170     screen_support_win = XCreateWindow(ob_display,
 171                                        RootWindow(ob_display, ob_screen),
 172                                        -100, -100, 1, 1, 0,
 173                                        CopyFromParent, InputOutput,
 174                                        CopyFromParent,
 175                                        CWOverrideRedirect, &attrib);
 176     XMapWindow(ob_display, screen_support_win);
 177     XLowerWindow(ob_display, screen_support_win);
 178
 179     if (!replace_wm()) {
 180         XDestroyWindow(ob_display, screen_support_win);
 181         return FALSE;
 182     }
 183
 184     xerror_set_ignore(TRUE);
 185     xerror_occured = FALSE;
 186     XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
 187                  ROOT_EVENTMASK);
 188     xerror_set_ignore(FALSE);
 189     if (xerror_occured) {
 190         g_message(_("A window manager is already running on screen %d"),
 191                   ob_screen);
 192
 193         XDestroyWindow(ob_display, screen_support_win);
 194         return FALSE;
 195     }
 196
 197     screen_set_root_cursor();
 198
 199     /* set the OPENBOX_PID hint */
 200     pid = getpid();
 201     PROP_SET32(RootWindow(ob_display, ob_screen),
 202                openbox_pid, cardinal, pid);
 203
 204     /* set supporting window */
 205     PROP_SET32(RootWindow(ob_display, ob_screen),
 206                net_supporting_wm_check, window, screen_support_win);
 207
 208     /* set properties on the supporting window */
 209     PROP_SETS(screen_support_win, net_wm_name, "Openbox");
 210     PROP_SET32(screen_support_win, net_supporting_wm_check,
 211                window, screen_support_win);
 212
 213     /* set the _NET_SUPPORTED_ATOMS hint */
 214
 215     /* this is all the atoms after net_supported in the prop_atoms struct */
 216     prop_atoms_start = (Atom*)&prop_atoms;
 217     wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
 218     num_support = sizeof(prop_atoms) / sizeof(Atom) -
 219         (wm_supported_pos - prop_atoms_start) - 1;
 220     i = 0;
 221     supported = g_new(gulong, num_support);
 222     supported[i++] = prop_atoms.net_supporting_wm_check;
 223     supported[i++] = prop_atoms.net_wm_full_placement;
 224     supported[i++] = prop_atoms.net_current_desktop;
 225     supported[i++] = prop_atoms.net_number_of_desktops;
 226     supported[i++] = prop_atoms.net_desktop_geometry;
 227     supported[i++] = prop_atoms.net_desktop_viewport;
 228     supported[i++] = prop_atoms.net_active_window;
 229     supported[i++] = prop_atoms.net_workarea;
 230     supported[i++] = prop_atoms.net_client_list;
 231     supported[i++] = prop_atoms.net_client_list_stacking;
 232     supported[i++] = prop_atoms.net_desktop_names;
 233     supported[i++] = prop_atoms.net_close_window;
 234     supported[i++] = prop_atoms.net_desktop_layout;
 235     supported[i++] = prop_atoms.net_showing_desktop;
 236     supported[i++] = prop_atoms.net_wm_name;
 237     supported[i++] = prop_atoms.net_wm_visible_name;
 238     supported[i++] = prop_atoms.net_wm_icon_name;
 239     supported[i++] = prop_atoms.net_wm_visible_icon_name;
 240     supported[i++] = prop_atoms.net_wm_desktop;
 241     supported[i++] = prop_atoms.net_wm_strut;
 242     supported[i++] = prop_atoms.net_wm_strut_partial;
 243     supported[i++] = prop_atoms.net_wm_icon;
 244     supported[i++] = prop_atoms.net_wm_icon_geometry;
 245     supported[i++] = prop_atoms.net_wm_window_type;
 246     supported[i++] = prop_atoms.net_wm_window_type_desktop;
 247     supported[i++] = prop_atoms.net_wm_window_type_dock;
 248     supported[i++] = prop_atoms.net_wm_window_type_toolbar;
 249     supported[i++] = prop_atoms.net_wm_window_type_menu;
 250     supported[i++] = prop_atoms.net_wm_window_type_utility;
 251     supported[i++] = prop_atoms.net_wm_window_type_splash;
 252     supported[i++] = prop_atoms.net_wm_window_type_dialog;
 253     supported[i++] = prop_atoms.net_wm_window_type_normal;
 254     supported[i++] = prop_atoms.net_wm_allowed_actions;
 255     supported[i++] = prop_atoms.net_wm_action_move;
 256     supported[i++] = prop_atoms.net_wm_action_resize;
 257     supported[i++] = prop_atoms.net_wm_action_minimize;
 258     supported[i++] = prop_atoms.net_wm_action_shade;
 259     supported[i++] = prop_atoms.net_wm_action_maximize_horz;
 260     supported[i++] = prop_atoms.net_wm_action_maximize_vert;
 261     supported[i++] = prop_atoms.net_wm_action_fullscreen;
 262     supported[i++] = prop_atoms.net_wm_action_change_desktop;
 263     supported[i++] = prop_atoms.net_wm_action_close;
 264     supported[i++] = prop_atoms.net_wm_action_above;
 265     supported[i++] = prop_atoms.net_wm_action_below;
 266     supported[i++] = prop_atoms.net_wm_state;
 267     supported[i++] = prop_atoms.net_wm_state_modal;
 268     supported[i++] = prop_atoms.net_wm_state_maximized_vert;
 269     supported[i++] = prop_atoms.net_wm_state_maximized_horz;
 270     supported[i++] = prop_atoms.net_wm_state_shaded;
 271     supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
 272     supported[i++] = prop_atoms.net_wm_state_skip_pager;
 273     supported[i++] = prop_atoms.net_wm_state_hidden;
 274     supported[i++] = prop_atoms.net_wm_state_fullscreen;
 275     supported[i++] = prop_atoms.net_wm_state_above;
 276     supported[i++] = prop_atoms.net_wm_state_below;
 277     supported[i++] = prop_atoms.net_wm_state_demands_attention;
 278     supported[i++] = prop_atoms.net_moveresize_window;
 279     supported[i++] = prop_atoms.net_wm_moveresize;
 280     supported[i++] = prop_atoms.net_wm_user_time;
 281     supported[i++] = prop_atoms.net_wm_user_time_window;
 282     supported[i++] = prop_atoms.net_frame_extents;
 283     supported[i++] = prop_atoms.net_request_frame_extents;
 284     supported[i++] = prop_atoms.net_restack_window;
 285     supported[i++] = prop_atoms.net_startup_id;
 286 #ifdef SYNC
 287     supported[i++] = prop_atoms.net_wm_sync_request;
 288     supported[i++] = prop_atoms.net_wm_sync_request_counter;
 289 #endif
 290
 291     supported[i++] = prop_atoms.kde_wm_change_state;
 292     supported[i++] = prop_atoms.kde_net_wm_frame_strut;
 293     supported[i++] = prop_atoms.kde_net_wm_window_type_override;
 294
 295     supported[i++] = prop_atoms.ob_wm_action_undecorate;
 296     supported[i++] = prop_atoms.ob_wm_state_undecorated;
 297     supported[i++] = prop_atoms.openbox_pid;
 298     supported[i++] = prop_atoms.ob_theme;
 299     supported[i++] = prop_atoms.ob_control;
 300     g_assert(i == num_support);
 301
 302     PROP_SETA32(RootWindow(ob_display, ob_screen),
 303                 net_supported, atom, supported, num_support);
 304     g_free(supported);
 305
 306     screen_tell_ksplash();
 307
 308     return TRUE;
 309 }
 310
 311 static void screen_tell_ksplash()
 312 {
 313     XEvent e;
 314     char **argv;
 315
 316     argv = g_new(gchar*, 6);
 317     argv[0] = g_strdup("dcop");
 318     argv[1] = g_strdup("ksplash");
 319     argv[2] = g_strdup("ksplash");
 320     argv[3] = g_strdup("upAndRunning(QString)");
 321     argv[4] = g_strdup("wm started");
 322     argv[5] = NULL;
 323
 324     /* tell ksplash through the dcop server command line interface */
 325     g_spawn_async(NULL, argv, NULL,
 326                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
 327                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
 328                   NULL, NULL, NULL, NULL);
 329     g_strfreev(argv);
 330
 331     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
 332        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
 333        something. oh well. */
 334     e.xclient.type = ClientMessage;
 335     e.xclient.display = ob_display;
 336     e.xclient.window = RootWindow(ob_display, ob_screen);
 337     e.xclient.message_type =
 338         XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False );
 339     e.xclient.format = 8;
 340     strcpy(e.xclient.data.b, "wm started");
 341     XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
 342                False, SubstructureNotifyMask, &e );
 343 }
 344
 345 void screen_startup(gboolean reconfig)
 346 {
 347     gchar **names = NULL;
 348     guint32 d;
 349     gboolean namesexist = FALSE;
 350
 351     desktop_cycle_popup = pager_popup_new(FALSE);
 352     pager_popup_height(desktop_cycle_popup, POPUP_HEIGHT);
 353
 354     if (reconfig) {
 355         /* update the pager popup's width */
 356         pager_popup_text_width_to_strings(desktop_cycle_popup,
 357                                           screen_desktop_names,
 358                                           screen_num_desktops);
 359         return;
 360     }
 361
 362     /* get the initial size */
 363     screen_resize();
 364
 365     /* have names already been set for the desktops? */
 366     if (PROP_GETSS(RootWindow(ob_display, ob_screen),
 367                    net_desktop_names, utf8, &names))
 368     {
 369         g_strfreev(names);
 370         namesexist = TRUE;
 371     }
 372
 373     /* if names don't exist and we have session names, set those.
 374        do this stuff BEFORE setting the number of desktops, because that
 375        will create default names for them
 376     */
 377     if (!namesexist && session_desktop_names != NULL) {
 378         guint i, numnames;
 379         GSList *it;
 380
 381         /* get the desktop names */
 382         numnames = g_slist_length(session_desktop_names);
 383         names = g_new(gchar*, numnames + 1);
 384         names[numnames] = NULL;
 385         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
 386             names[i] = g_strdup(it->data);
 387
 388         /* set the root window property */
 389         PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
 390
 391         g_strfreev(names);
 392     }
 393
 394     /* set the number of desktops, if it's not already set.
 395
 396        this will also set the default names from the config file up for
 397        desktops that don't have names yet */
 398     screen_num_desktops = 0;
 399     if (PROP_GET32(RootWindow(ob_display, ob_screen),
 400                    net_number_of_desktops, cardinal, &d))
 401         screen_set_num_desktops(d);
 402     /* restore from session if possible */
 403     else if (session_num_desktops)
 404         screen_set_num_desktops(session_num_desktops);
 405     else
 406         screen_set_num_desktops(config_desktops_num);
 407
 408     screen_desktop = screen_num_desktops;  /* something invalid */
 409     /* start on the current desktop when a wm was already running */
 410     if (PROP_GET32(RootWindow(ob_display, ob_screen),
 411                    net_current_desktop, cardinal, &d) &&
 412         d < screen_num_desktops)
 413     {
 414         screen_set_desktop(d, FALSE);
 415     } else if (session_desktop >= 0)
 416         screen_set_desktop(MIN((guint)session_desktop,
 417                                screen_num_desktops), FALSE);
 418     else
 419         screen_set_desktop(MIN(config_screen_firstdesk,
 420                                screen_num_desktops) - 1, FALSE);
 421     screen_last_desktop = screen_desktop;
 422
 423     /* don't start in showing-desktop mode */
 424     screen_showing_desktop = FALSE;
 425     PROP_SET32(RootWindow(ob_display, ob_screen),
 426                net_showing_desktop, cardinal, screen_showing_desktop);
 427
 428     if (session_desktop_layout_present &&
 429         screen_validate_layout(&session_desktop_layout))
 430     {
 431         screen_desktop_layout = session_desktop_layout;
 432     }
 433     else
 434         screen_update_layout();
 435 }
 436
 437 void screen_shutdown(gboolean reconfig)
 438 {
 439     Rect **r;
 440
 441     pager_popup_free(desktop_cycle_popup);
 442
 443     if (reconfig)
 444         return;
 445
 446     XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
 447                  NoEventMask);
 448
 449     /* we're not running here no more! */
 450     PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
 451     /* not without us */
 452     PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
 453     /* don't keep this mode */
 454     PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
 455
 456     XDestroyWindow(ob_display, screen_support_win);
 457
 458     g_strfreev(screen_desktop_names);
 459     screen_desktop_names = NULL;
 460
 461     for (r = area; *r; ++r)
 462         g_free(*r);
 463     g_free(area);
 464     area = NULL;
 465 }
 466
 467 void screen_resize()
 468 {
 469     static gint oldw = 0, oldh = 0;
 470     gint w, h;
 471     GList *it;
 472     gulong geometry[2];
 473
 474     w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 475     h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 476
 477     if (w == oldw && h == oldh) return;
 478
 479     oldw = w; oldh = h;
 480
 481     /* Set the _NET_DESKTOP_GEOMETRY hint */
 482     screen_physical_size.width = geometry[0] = w;
 483     screen_physical_size.height = geometry[1] = h;
 484     PROP_SETA32(RootWindow(ob_display, ob_screen),
 485                 net_desktop_geometry, cardinal, geometry, 2);
 486
 487     if (ob_state() == OB_STATE_STARTING)
 488         return;
 489
 490     screen_update_areas();
 491     dock_configure();
 492
 493     for (it = client_list; it; it = g_list_next(it))
 494         client_move_onscreen(it->data, FALSE);
 495 }
 496
 497 void screen_set_num_desktops(guint num)
 498 {
 499     guint old;
 500     gulong *viewport;
 501     GList *it;
 502
 503     g_assert(num > 0);
 504
 505     if (screen_num_desktops == num) return;
 506
 507     old = screen_num_desktops;
 508     screen_num_desktops = num;
 509     PROP_SET32(RootWindow(ob_display, ob_screen),
 510                net_number_of_desktops, cardinal, num);
 511
 512     /* set the viewport hint */
 513     viewport = g_new0(gulong, num * 2);
 514     PROP_SETA32(RootWindow(ob_display, ob_screen),
 515                 net_desktop_viewport, cardinal, viewport, num * 2);
 516     g_free(viewport);
 517
 518     /* the number of rows/columns will differ */
 519     screen_update_layout();
 520
 521     /* move windows on desktops that will no longer exist! */
 522     for (it = client_list; it; it = g_list_next(it)) {
 523         ObClient *c = it->data;
 524         if (c->desktop >= num && c->desktop != DESKTOP_ALL)
 525             client_set_desktop(c, num - 1, FALSE);
 526     }
 527
 528     /* change our struts/area to match (after moving windows) */
 529     screen_update_areas();
 530
 531     /* may be some unnamed desktops that we need to fill in with names
 532      (after updating the areas so the popup can resize) */
 533     screen_update_desktop_names();
 534
 535     /* change our desktop if we're on one that no longer exists! */
 536     if (screen_desktop >= screen_num_desktops)
 537         screen_set_desktop(num - 1, TRUE);
 538 }
 539
 540 void screen_set_desktop(guint num, gboolean dofocus)
 541 {
 542     ObClient *c;
 543     GList *it;
 544     guint old;
 545
 546     g_assert(num < screen_num_desktops);
 547
 548     old = screen_desktop;
 549     screen_desktop = num;
 550
 551     if (old == num) return;
 552
 553     PROP_SET32(RootWindow(ob_display, ob_screen),
 554                net_current_desktop, cardinal, num);
 555
 556     screen_last_desktop = old;
 557
 558     ob_debug("Moving to desktop %d\n", num+1);
 559
 560     if (moveresize_client)
 561         client_set_desktop(moveresize_client, num, TRUE);
 562
 563     /* show windows before hiding the rest to lessen the enter/leave events */
 564
 565     /* show windows from top to bottom */
 566     for (it = stacking_list; it; it = g_list_next(it)) {
 567         if (WINDOW_IS_CLIENT(it->data)) {
 568             ObClient *c = it->data;
 569             client_show(c);
 570         }
 571     }
 572
 573     if (focus_client && ((client_normal(focus_client) &&
 574                           focus_client->desktop == DESKTOP_ALL) ||
 575                          focus_client->desktop == screen_desktop))
 576         dofocus = FALSE;
 577
 578     /* have to try focus here because when you leave an empty desktop
 579        there is no focus out to watch for. also, we have different rules
 580        here. we always allow it to look under the mouse pointer if
 581        config_focus_last is FALSE
 582
 583        do this before hiding the windows so if helper windows are coming
 584        with us, they don't get hidden
 585     */
 586     if (dofocus && (c = focus_fallback(TRUE, !config_focus_last)))
 587     {
 588         /* only do the flicker reducing stuff ahead of time if we are going
 589            to call xsetinputfocus on the window ourselves. otherwise there is
 590            no guarantee the window will actually take focus.. */
 591         if (c->can_focus) {
 592             /* reduce flicker by hiliting now rather than waiting for the
 593                server FocusIn event */
 594             frame_adjust_focus(c->frame, TRUE);
 595             /* do this here so that if you switch desktops to a window with
 596                helper windows then the helper windows won't flash */
 597             client_bring_helper_windows(c);
 598         }
 599     }
 600
 601     /* hide windows from bottom to top */
 602     for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
 603         if (WINDOW_IS_CLIENT(it->data)) {
 604             ObClient *c = it->data;
 605             client_hide(c);
 606         }
 607     }
 608
 609     event_ignore_all_queued_enters();
 610
 611     if (event_curtime != CurrentTime)
 612         screen_desktop_user_time = event_curtime;
 613 }
 614
 615 static void get_row_col(guint d, guint *r, guint *c)
 616 {
 617     switch (screen_desktop_layout.orientation) {
 618     case OB_ORIENTATION_HORZ:
 619         switch (screen_desktop_layout.start_corner) {
 620         case OB_CORNER_TOPLEFT:
 621             *r = d / screen_desktop_layout.columns;
 622             *c = d % screen_desktop_layout.columns;
 623             break;
 624         case OB_CORNER_BOTTOMLEFT:
 625             *r = screen_desktop_layout.rows - 1 -
 626                 d / screen_desktop_layout.columns;
 627             *c = d % screen_desktop_layout.columns;
 628             break;
 629         case OB_CORNER_TOPRIGHT:
 630             *r = d / screen_desktop_layout.columns;
 631             *c = screen_desktop_layout.columns - 1 -
 632                 d % screen_desktop_layout.columns;
 633             break;
 634         case OB_CORNER_BOTTOMRIGHT:
 635             *r = screen_desktop_layout.rows - 1 -
 636                 d / screen_desktop_layout.columns;
 637             *c = screen_desktop_layout.columns - 1 -
 638                 d % screen_desktop_layout.columns;
 639             break;
 640         }
 641         break;
 642     case OB_ORIENTATION_VERT:
 643         switch (screen_desktop_layout.start_corner) {
 644         case OB_CORNER_TOPLEFT:
 645             *r = d % screen_desktop_layout.rows;
 646             *c = d / screen_desktop_layout.rows;
 647             break;
 648         case OB_CORNER_BOTTOMLEFT:
 649             *r = screen_desktop_layout.rows - 1 -
 650                 d % screen_desktop_layout.rows;
 651             *c = d / screen_desktop_layout.rows;
 652             break;
 653         case OB_CORNER_TOPRIGHT:
 654             *r = d % screen_desktop_layout.rows;
 655             *c = screen_desktop_layout.columns - 1 -
 656                 d / screen_desktop_layout.rows;
 657             break;
 658         case OB_CORNER_BOTTOMRIGHT:
 659             *r = screen_desktop_layout.rows - 1 -
 660                 d % screen_desktop_layout.rows;
 661             *c = screen_desktop_layout.columns - 1 -
 662                 d / screen_desktop_layout.rows;
 663             break;
 664         }
 665         break;
 666     }
 667 }
 668
 669 static guint translate_row_col(guint r, guint c)
 670 {
 671     switch (screen_desktop_layout.orientation) {
 672     case OB_ORIENTATION_HORZ:
 673         switch (screen_desktop_layout.start_corner) {
 674         case OB_CORNER_TOPLEFT:
 675             return r % screen_desktop_layout.rows *
 676                 screen_desktop_layout.columns +
 677                 c % screen_desktop_layout.columns;
 678         case OB_CORNER_BOTTOMLEFT:
 679             return (screen_desktop_layout.rows - 1 -
 680                     r % screen_desktop_layout.rows) *
 681                 screen_desktop_layout.columns +
 682                 c % screen_desktop_layout.columns;
 683         case OB_CORNER_TOPRIGHT:
 684             return r % screen_desktop_layout.rows *
 685                 screen_desktop_layout.columns +
 686                 (screen_desktop_layout.columns - 1 -
 687                  c % screen_desktop_layout.columns);
 688         case OB_CORNER_BOTTOMRIGHT:
 689             return (screen_desktop_layout.rows - 1 -
 690                     r % screen_desktop_layout.rows) *
 691                 screen_desktop_layout.columns +
 692                 (screen_desktop_layout.columns - 1 -
 693                  c % screen_desktop_layout.columns);
 694         }
 695     case OB_ORIENTATION_VERT:
 696         switch (screen_desktop_layout.start_corner) {
 697         case OB_CORNER_TOPLEFT:
 698             return c % screen_desktop_layout.columns *
 699                 screen_desktop_layout.rows +
 700                 r % screen_desktop_layout.rows;
 701         case OB_CORNER_BOTTOMLEFT:
 702             return c % screen_desktop_layout.columns *
 703                 screen_desktop_layout.rows +
 704                 (screen_desktop_layout.rows - 1 -
 705                  r % screen_desktop_layout.rows);
 706         case OB_CORNER_TOPRIGHT:
 707             return (screen_desktop_layout.columns - 1 -
 708                     c % screen_desktop_layout.columns) *
 709                 screen_desktop_layout.rows +
 710                 r % screen_desktop_layout.rows;
 711         case OB_CORNER_BOTTOMRIGHT:
 712             return (screen_desktop_layout.columns - 1 -
 713                     c % screen_desktop_layout.columns) *
 714                 screen_desktop_layout.rows +
 715                 (screen_desktop_layout.rows - 1 -
 716                  r % screen_desktop_layout.rows);
 717         }
 718     }
 719     g_assert_not_reached();
 720     return 0;
 721 }
 722
 723 void screen_desktop_popup(guint d, gboolean show)
 724 {
 725     Rect *a;
 726
 727     if (!show) {
 728         pager_popup_hide(desktop_cycle_popup);
 729     } else {
 730         a = screen_physical_area_monitor(0);
 731         pager_popup_position(desktop_cycle_popup, CenterGravity,
 732                              a->x + a->width / 2, a->y + a->height / 2);
 733         pager_popup_icon_size_multiplier(desktop_cycle_popup,
 734                                          (screen_desktop_layout.columns /
 735                                           screen_desktop_layout.rows) / 2,
 736                                          (screen_desktop_layout.rows/
 737                                           screen_desktop_layout.columns) / 2);
 738         pager_popup_max_width(desktop_cycle_popup,
 739                               MAX(a->width/3, POPUP_WIDTH));
 740         pager_popup_show(desktop_cycle_popup, screen_desktop_names[d], d);
 741     }
 742 }
 743
 744 guint screen_cycle_desktop(ObDirection dir, gboolean wrap, gboolean linear,
 745                            gboolean dialog, gboolean done, gboolean cancel)
 746 {
 747     guint r, c;
 748     static guint d = (guint)-1;
 749     guint ret, oldd;
 750
 751     if (d == (guint)-1)
 752         d = screen_desktop;
 753
 754     if ((cancel || done) && dialog)
 755         goto show_cycle_dialog;
 756
 757     oldd = d;
 758     get_row_col(d, &r, &c);
 759
 760     if (linear) {
 761         switch (dir) {
 762         case OB_DIRECTION_EAST:
 763             if (d < screen_num_desktops - 1)
 764                 ++d;
 765             else if (wrap)
 766                 d = 0;
 767             break;
 768         case OB_DIRECTION_WEST:
 769             if (d > 0)
 770                 --d;
 771             else if (wrap)
 772                 d = screen_num_desktops - 1;
 773             break;
 774         default:
 775             assert(0);
 776             return screen_desktop;
 777         }
 778     } else {
 779         switch (dir) {
 780         case OB_DIRECTION_EAST:
 781             ++c;
 782             if (c >= screen_desktop_layout.columns) {
 783                 if (wrap)
 784                     c = 0;
 785                 else
 786                     goto show_cycle_dialog;
 787             }
 788             d = translate_row_col(r, c);
 789             if (d >= screen_num_desktops) {
 790                 if (wrap) {
 791                     ++c;
 792                 } else {
 793                     d = oldd;
 794                     goto show_cycle_dialog;
 795                 }
 796             }
 797             break;
 798         case OB_DIRECTION_WEST:
 799             --c;
 800             if (c >= screen_desktop_layout.columns) {
 801                 if (wrap)
 802                     c = screen_desktop_layout.columns - 1;
 803                 else
 804                     goto show_cycle_dialog;
 805             }
 806             d = translate_row_col(r, c);
 807             if (d >= screen_num_desktops) {
 808                 if (wrap) {
 809                     --c;
 810                 } else {
 811                     d = oldd;
 812                     goto show_cycle_dialog;
 813                 }
 814             }
 815             break;
 816         case OB_DIRECTION_SOUTH:
 817             ++r;
 818             if (r >= screen_desktop_layout.rows) {
 819                 if (wrap)
 820                     r = 0;
 821                 else
 822                     goto show_cycle_dialog;
 823             }
 824             d = translate_row_col(r, c);
 825             if (d >= screen_num_desktops) {
 826                 if (wrap) {
 827                     ++r;
 828                 } else {
 829                     d = oldd;
 830                     goto show_cycle_dialog;
 831                 }
 832             }
 833             break;
 834         case OB_DIRECTION_NORTH:
 835             --r;
 836             if (r >= screen_desktop_layout.rows) {
 837                 if (wrap)
 838                     r = screen_desktop_layout.rows - 1;
 839                 else
 840                     goto show_cycle_dialog;
 841             }
 842             d = translate_row_col(r, c);
 843             if (d >= screen_num_desktops) {
 844                 if (wrap) {
 845                     --r;
 846                 } else {
 847                     d = oldd;
 848                     goto show_cycle_dialog;
 849                 }
 850             }
 851             break;
 852         default:
 853             assert(0);
 854             return d = screen_desktop;
 855         }
 856
 857         d = translate_row_col(r, c);
 858     }
 859
 860 show_cycle_dialog:
 861     if (dialog && !cancel && !done) {
 862         screen_desktop_popup(d, TRUE);
 863     } else
 864         screen_desktop_popup(0, FALSE);
 865     ret = d;
 866
 867     if (!dialog || cancel || done)
 868         d = (guint)-1;
 869
 870     return ret;
 871 }
 872
 873 static gboolean screen_validate_layout(ObDesktopLayout *l)
 874 {
 875     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
 876         return FALSE;
 877
 878     /* fill in a zero rows/columns */
 879     if (l->columns == 0) {
 880         l->columns = screen_num_desktops / l->rows;
 881         if (l->rows * l->columns < screen_num_desktops)
 882             l->columns++;
 883         if (l->rows * l->columns >= screen_num_desktops + l->columns)
 884             l->rows--;
 885     } else if (l->rows == 0) {
 886         l->rows = screen_num_desktops / l->columns;
 887         if (l->columns * l->rows < screen_num_desktops)
 888             l->rows++;
 889         if (l->columns * l->rows >= screen_num_desktops + l->rows)
 890             l->columns--;
 891     }
 892
 893     /* bounds checking */
 894     if (l->orientation == OB_ORIENTATION_HORZ) {
 895         l->columns = MIN(screen_num_desktops, l->columns);
 896         l->rows = MIN(l->rows,
 897                       (screen_num_desktops + l->columns - 1) / l->columns);
 898         l->columns = screen_num_desktops / l->rows +
 899             !!(screen_num_desktops % l->rows);
 900     } else {
 901         l->rows = MIN(screen_num_desktops, l->rows);
 902         l->columns = MIN(l->columns,
 903                          (screen_num_desktops + l->rows - 1) / l->rows);
 904         l->rows = screen_num_desktops / l->columns +
 905             !!(screen_num_desktops % l->columns);
 906     }
 907     return TRUE;
 908 }
 909
 910 void screen_update_layout()
 911
 912 {
 913     ObDesktopLayout l;
 914     guint32 *data;
 915     guint num;
 916
 917     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
 918     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
 919     screen_desktop_layout.rows = 1;
 920     screen_desktop_layout.columns = screen_num_desktops;
 921
 922     if (PROP_GETA32(RootWindow(ob_display, ob_screen),
 923                     net_desktop_layout, cardinal, &data, &num)) {
 924         if (num == 3 || num == 4) {
 925
 926             if (data[0] == prop_atoms.net_wm_orientation_vert)
 927                 l.orientation = OB_ORIENTATION_VERT;
 928             else if (data[0] == prop_atoms.net_wm_orientation_horz)
 929                 l.orientation = OB_ORIENTATION_HORZ;
 930             else
 931                 return;
 932
 933             if (num < 4)
 934                 l.start_corner = OB_CORNER_TOPLEFT;
 935             else {
 936                 if (data[3] == prop_atoms.net_wm_topleft)
 937                     l.start_corner = OB_CORNER_TOPLEFT;
 938                 else if (data[3] == prop_atoms.net_wm_topright)
 939                     l.start_corner = OB_CORNER_TOPRIGHT;
 940                 else if (data[3] == prop_atoms.net_wm_bottomright)
 941                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
 942                 else if (data[3] == prop_atoms.net_wm_bottomleft)
 943                     l.start_corner = OB_CORNER_BOTTOMLEFT;
 944                 else
 945                     return;
 946             }
 947
 948             l.columns = data[1];
 949             l.rows = data[2];
 950
 951             if (screen_validate_layout(&l))
 952                 screen_desktop_layout = l;
 953
 954             g_free(data);
 955         }
 956     }
 957 }
 958
 959 void screen_update_desktop_names()
 960 {
 961     guint i;
 962
 963     /* empty the array */
 964     g_strfreev(screen_desktop_names);
 965     screen_desktop_names = NULL;
 966
 967     if (PROP_GETSS(RootWindow(ob_display, ob_screen),
 968                    net_desktop_names, utf8, &screen_desktop_names))
 969         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
 970     else
 971         i = 0;
 972     if (i < screen_num_desktops) {
 973         GSList *it;
 974
 975         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
 976                                        screen_num_desktops + 1);
 977         screen_desktop_names[screen_num_desktops] = NULL;
 978
 979         it = g_slist_nth(config_desktops_names, i);
 980
 981         for (; i < screen_num_desktops; ++i) {
 982             if (it && ((char*)it->data)[0]) /* not empty */
 983                 /* use the names from the config file when possible */
 984                 screen_desktop_names[i] = g_strdup(it->data);
 985             else
 986                 /* make up a nice name if it's not though */
 987                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
 988                                                           i + 1);
 989             if (it) it = g_slist_next(it);
 990         }
 991
 992         /* if we changed any names, then set the root property so we can
 993            all agree on the names */
 994         PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
 995                    screen_desktop_names);
 996     }
 997
 998     /* resize the pager for these names */
 999     pager_popup_text_width_to_strings(desktop_cycle_popup,
1000                                       screen_desktop_names,
1001                                       screen_num_desktops);
1002 }
1003
1004 void screen_show_desktop(gboolean show, ObClient *show_only)
1005 {
1006     GList *it;
1007
1008     if (show == screen_showing_desktop) return; /* no change */
1009
1010     screen_showing_desktop = show;
1011
1012     if (show) {
1013         /* hide windows bottom to top */
1014         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1015             if (WINDOW_IS_CLIENT(it->data)) {
1016                 ObClient *client = it->data;
1017                 client_showhide(client);
1018             }
1019         }
1020     }
1021     else {
1022         /* restore windows top to bottom */
1023         for (it = stacking_list; it; it = g_list_next(it)) {
1024             if (WINDOW_IS_CLIENT(it->data)) {
1025                 ObClient *client = it->data;
1026                 if (client_should_show(client)) {
1027                     if (!show_only || client == show_only)
1028                         client_show(client);
1029                     else
1030                         client_iconify(client, TRUE, FALSE, TRUE);
1031                 }
1032             }
1033         }
1034     }
1035
1036     if (show) {
1037         /* focus the desktop */
1038         for (it = focus_order; it; it = g_list_next(it)) {
1039             ObClient *c = it->data;
1040             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1041                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1042                 client_focus(it->data))
1043                 break;
1044         }
1045     }
1046     else if (!show_only) {
1047         ObClient *c;
1048
1049         if ((c = focus_fallback(TRUE, FALSE))) {
1050             /* only do the flicker reducing stuff ahead of time if we are going
1051                to call xsetinputfocus on the window ourselves. otherwise there
1052                is no guarantee the window will actually take focus.. */
1053             if (c->can_focus) {
1054                 /* reduce flicker by hiliting now rather than waiting for the
1055                    server FocusIn event */
1056                 frame_adjust_focus(c->frame, TRUE);
1057             }
1058         }
1059     }
1060
1061     show = !!show; /* make it boolean */
1062     PROP_SET32(RootWindow(ob_display, ob_screen),
1063                net_showing_desktop, cardinal, show);
1064 }
1065
1066 void screen_install_colormap(ObClient *client, gboolean install)
1067 {
1068     if (client == NULL || client->colormap == None) {
1069         if (install)
1070             XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1071         else
1072             XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1073     } else {
1074         xerror_set_ignore(TRUE);
1075         if (install)
1076             XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1077         else
1078             XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1079         xerror_set_ignore(FALSE);
1080     }
1081 }
1082
1083 static inline void
1084 screen_area_add_strut_left(const StrutPartial *s, const Rect *monitor_area,
1085                            gint edge, Strut *ret)
1086 {
1087     if (s->left &&
1088         ((s->left_end <= s->left_start) ||
1089          (RECT_TOP(*monitor_area) < s->left_end &&
1090           RECT_BOTTOM(*monitor_area) > s->left_start)))
1091         ret->left = MAX(ret->left, edge);
1092 }
1093
1094 static inline void
1095 screen_area_add_strut_top(const StrutPartial *s, const Rect *monitor_area,
1096                           gint edge, Strut *ret)
1097 {
1098     if (s->top &&
1099         ((s->top_end <= s->top_start) ||
1100          (RECT_LEFT(*monitor_area) < s->top_end &&
1101           RECT_RIGHT(*monitor_area) > s->top_start)))
1102         ret->top = MAX(ret->top, edge);
1103 }
1104
1105 static inline void
1106 screen_area_add_strut_right(const StrutPartial *s, const Rect *monitor_area,
1107                             gint edge, Strut *ret)
1108 {
1109     if (s->right &&
1110         ((s->right_end <= s->right_start) ||
1111          (RECT_TOP(*monitor_area) < s->right_end &&
1112           RECT_BOTTOM(*monitor_area) > s->right_start)))
1113         ret->right = MAX(ret->right, edge);
1114 }
1115
1116 static inline void
1117 screen_area_add_strut_bottom(const StrutPartial *s, const Rect *monitor_area,
1118                              gint edge, Strut *ret)
1119 {
1120     if (s->bottom &&
1121         ((s->bottom_end <= s->bottom_start) ||
1122          (RECT_LEFT(*monitor_area) < s->bottom_end &&
1123           RECT_RIGHT(*monitor_area) > s->bottom_start)))
1124         ret->bottom = MAX(ret->bottom, edge);
1125 }
1126
1127 void screen_update_areas()
1128 {
1129     guint i, x;
1130     gulong *dims;
1131     GList *it;
1132     gint o;
1133
1134     g_free(monitor_area);
1135     extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
1136
1137     if (area) {
1138         for (i = 0; area[i]; ++i)
1139             g_free(area[i]);
1140         g_free(area);
1141     }
1142
1143     area = g_new(Rect*, screen_num_desktops + 2);
1144     for (i = 0; i < screen_num_desktops + 1; ++i)
1145         area[i] = g_new0(Rect, screen_num_monitors + 1);
1146     area[i] = NULL;
1147
1148     dims = g_new(gulong, 4 * screen_num_desktops);
1149
1150     for (i = 0; i < screen_num_desktops + 1; ++i) {
1151         Strut *struts;
1152         gint l, r, t, b;
1153
1154         struts = g_new0(Strut, screen_num_monitors);
1155
1156         /* calc the xinerama areas */
1157         for (x = 0; x < screen_num_monitors; ++x) {
1158             area[i][x] = monitor_area[x];
1159             if (x == 0) {
1160                 l = monitor_area[x].x;
1161                 t = monitor_area[x].y;
1162                 r = monitor_area[x].x + monitor_area[x].width - 1;
1163                 b = monitor_area[x].y + monitor_area[x].height - 1;
1164             } else {
1165                 l = MIN(l, monitor_area[x].x);
1166                 t = MIN(t, monitor_area[x].y);
1167                 r = MAX(r, monitor_area[x].x + monitor_area[x].width - 1);
1168                 b = MAX(b, monitor_area[x].y + monitor_area[x].height - 1);
1169             }
1170         }
1171         RECT_SET(area[i][x], l, t, r - l + 1, b - t + 1);
1172
1173         /* apply the struts */
1174
1175         /* find the left-most xin heads, i do this in 2 loops :| */
1176         o = area[i][0].x;
1177         for (x = 1; x < screen_num_monitors; ++x)
1178             o = MIN(o, area[i][x].x);
1179
1180         for (x = 0; x < screen_num_monitors; ++x) {
1181             for (it = client_list; it; it = g_list_next(it)) {
1182                 ObClient *c = it->data;
1183                 screen_area_add_strut_left(&c->strut,
1184                                            &monitor_area[x],
1185                                            o + c->strut.left - area[i][x].x,
1186                                            &struts[x]);
1187             }
1188             screen_area_add_strut_left(&dock_strut,
1189                                        &monitor_area[x],
1190                                        o + dock_strut.left - area[i][x].x,
1191                                        &struts[x]);
1192
1193             area[i][x].x += struts[x].left;
1194             area[i][x].width -= struts[x].left;
1195         }
1196
1197         /* find the top-most xin heads, i do this in 2 loops :| */
1198         o = area[i][0].y;
1199         for (x = 1; x < screen_num_monitors; ++x)
1200             o = MIN(o, area[i][x].y);
1201
1202         for (x = 0; x < screen_num_monitors; ++x) {
1203             for (it = client_list; it; it = g_list_next(it)) {
1204                 ObClient *c = it->data;
1205                 screen_area_add_strut_top(&c->strut,
1206                                            &monitor_area[x],
1207                                            o + c->strut.top - area[i][x].y,
1208                                            &struts[x]);
1209             }
1210             screen_area_add_strut_top(&dock_strut,
1211                                       &monitor_area[x],
1212                                       o + dock_strut.top - area[i][x].y,
1213                                       &struts[x]);
1214
1215             area[i][x].y += struts[x].top;
1216             area[i][x].height -= struts[x].top;
1217         }
1218
1219         /* find the right-most xin heads, i do this in 2 loops :| */
1220         o = area[i][0].x + area[i][0].width - 1;
1221         for (x = 1; x < screen_num_monitors; ++x)
1222             o = MAX(o, area[i][x].x + area[i][x].width - 1);
1223
1224         for (x = 0; x < screen_num_monitors; ++x) {
1225             for (it = client_list; it; it = g_list_next(it)) {
1226                 ObClient *c = it->data;
1227                 screen_area_add_strut_right(&c->strut,
1228                                            &monitor_area[x],
1229                                            (area[i][x].x +
1230                                             area[i][x].width - 1) -
1231                                             (o - c->strut.right),
1232                                             &struts[x]);
1233             }
1234             screen_area_add_strut_right(&dock_strut,
1235                                         &monitor_area[x],
1236                                         (area[i][x].x +
1237                                          area[i][x].width - 1) -
1238                                         (o - dock_strut.right),
1239                                         &struts[x]);
1240
1241             area[i][x].width -= struts[x].right;
1242         }
1243
1244         /* find the bottom-most xin heads, i do this in 2 loops :| */
1245         o = area[i][0].y + area[i][0].height - 1;
1246         for (x = 1; x < screen_num_monitors; ++x)
1247             o = MAX(o, area[i][x].y + area[i][x].height - 1);
1248
1249         for (x = 0; x < screen_num_monitors; ++x) {
1250             for (it = client_list; it; it = g_list_next(it)) {
1251                 ObClient *c = it->data;
1252                 screen_area_add_strut_bottom(&c->strut,
1253                                              &monitor_area[x],
1254                                              (area[i][x].y +
1255                                               area[i][x].height - 1) - \
1256                                              (o - c->strut.bottom),
1257                                              &struts[x]);
1258             }
1259             screen_area_add_strut_bottom(&dock_strut,
1260                                          &monitor_area[x],
1261                                          (area[i][x].y +
1262                                           area[i][x].height - 1) - \
1263                                          (o - dock_strut.bottom),
1264                                          &struts[x]);
1265
1266             area[i][x].height -= struts[x].bottom;
1267         }
1268
1269         l = RECT_LEFT(area[i][0]);
1270         t = RECT_TOP(area[i][0]);
1271         r = RECT_RIGHT(area[i][0]);
1272         b = RECT_BOTTOM(area[i][0]);
1273         for (x = 1; x < screen_num_monitors; ++x) {
1274             l = MIN(l, RECT_LEFT(area[i][x]));
1275             t = MIN(l, RECT_TOP(area[i][x]));
1276             r = MAX(r, RECT_RIGHT(area[i][x]));
1277             b = MAX(b, RECT_BOTTOM(area[i][x]));
1278         }
1279         RECT_SET(area[i][screen_num_monitors], l, t,
1280                  r - l + 1, b - t + 1);
1281
1282         /* XXX optimize when this is run? */
1283
1284         /* the area has changed, adjust all the maximized
1285            windows */
1286         for (it = client_list; it; it = g_list_next(it)) {
1287             ObClient *c = it->data;
1288             if (i < screen_num_desktops) {
1289                 if (c->desktop == i)
1290                     client_reconfigure(c);
1291             } else if (c->desktop == DESKTOP_ALL)
1292                 client_reconfigure(c);
1293         }
1294         if (i < screen_num_desktops) {
1295             /* don't set these for the 'all desktops' area */
1296             dims[(i * 4) + 0] = area[i][screen_num_monitors].x;
1297             dims[(i * 4) + 1] = area[i][screen_num_monitors].y;
1298             dims[(i * 4) + 2] = area[i][screen_num_monitors].width;
1299             dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
1300         }
1301
1302         g_free(struts);
1303     }
1304
1305     PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1306                 dims, 4 * screen_num_desktops);
1307
1308     g_free(dims);
1309 }
1310
1311 Rect *screen_area(guint desktop)
1312 {
1313     return screen_area_monitor(desktop, screen_num_monitors);
1314 }
1315
1316 Rect *screen_area_monitor(guint desktop, guint head)
1317 {
1318     if (head > screen_num_monitors)
1319         return NULL;
1320     if (desktop >= screen_num_desktops) {
1321         if (desktop == DESKTOP_ALL)
1322             return &area[screen_num_desktops][head];
1323         return NULL;
1324     }
1325     return &area[desktop][head];
1326 }
1327
1328 guint screen_find_monitor(Rect *search)
1329 {
1330     guint i;
1331     guint most = 0;
1332     guint mostv = 0;
1333
1334     for (i = 0; i < screen_num_monitors; ++i) {
1335         Rect *area = screen_physical_area_monitor(i);
1336         if (RECT_INTERSECTS_RECT(*area, *search)) {
1337             Rect r;
1338             guint v;
1339
1340             RECT_SET_INTERSECTION(r, *area, *search);
1341             v = r.width * r.height;
1342
1343             if (v > mostv) {
1344                 mostv = v;
1345                 most = i;
1346             }
1347         }
1348     }
1349     return most;
1350 }
1351
1352 Rect *screen_physical_area()
1353 {
1354     return screen_physical_area_monitor(screen_num_monitors);
1355 }
1356
1357 Rect *screen_physical_area_monitor(guint head)
1358 {
1359     if (head > screen_num_monitors)
1360         return NULL;
1361     return &monitor_area[head];
1362 }
1363
1364 void screen_set_root_cursor()
1365 {
1366     if (sn_app_starting())
1367         XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1368                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1369     else
1370         XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1371                       ob_cursor(OB_CURSOR_POINTER));
1372 }
1373
1374 gboolean screen_pointer_pos(gint *x, gint *y)
1375 {
1376     Window w;
1377     gint i;
1378     guint u;
1379     gboolean ret;
1380
1381     ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1382                           &w, &w, x, y, &i, &i, &u);
1383     if (!ret) {
1384         for (i = 0; i < ScreenCount(ob_display); ++i)
1385             if (i != ob_screen)
1386                 if (XQueryPointer(ob_display, RootWindow(ob_display, i),
1387                                   &w, &w, x, y, &i, &i, &u))
1388                     break;
1389     }
1390     return ret;
1391 }