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