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