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