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