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