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