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