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 "grab.h"
  24 #include "startupnotify.h"
  25 #include "moveresize.h"
  26 #include "config.h"
  27 #include "screen.h"
  28 #include "client.h"
  29 #include "session.h"
  30 #include "frame.h"
  31 #include "event.h"
  32 #include "focus.h"
  33 #include "focus_cycle.h"
  34 #include "popup.h"
  35 #include "version.h"
  36 #include "obrender/render.h"
  37 #include "gettext.h"
  38 #include "obt/display.h"
  39 #include "obt/xqueue.h"
  40 #include "obt/prop.h"
  41
  42 #include <X11/Xlib.h>
  43 #ifdef HAVE_UNISTD_H
  44 #  include <sys/types.h>
  45 #  include <unistd.h>
  46 #endif
  47 #include <assert.h>
  48
  49 /*! The event mask to grab on the root window */
  50 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
  51                         EnterWindowMask | LeaveWindowMask | \
  52                         SubstructureRedirectMask | FocusChangeMask | \
  53                         ButtonPressMask | ButtonReleaseMask)
  54
  55 static gboolean screen_validate_layout(ObDesktopLayout *l);
  56 static gboolean replace_wm(void);
  57 static void     screen_tell_ksplash(void);
  58 static void     screen_fallback_focus(void);
  59
  60 guint                  screen_num_desktops;
  61 guint                  screen_num_monitors;
  62 guint                  screen_desktop;
  63 guint                  screen_last_desktop;
  64 ObScreenShowDestopMode screen_show_desktop_mode;
  65 ObDesktopLayout        screen_desktop_layout;
  66 gchar                **screen_desktop_names;
  67 Window                 screen_support_win;
  68 Time                   screen_desktop_user_time = CurrentTime;
  69
  70 static Size     screen_physical_size;
  71 static guint    screen_old_desktop;
  72 static gboolean screen_desktop_timeout = TRUE;
  73 static guint    screen_desktop_timer = 0;
  74 /*! An array of desktops, holding an array of areas per monitor */
  75 static Rect  *monitor_area = NULL;
  76 /*! An array of desktops, holding an array of struts */
  77 static GSList *struts_top = NULL;
  78 static GSList *struts_left = NULL;
  79 static GSList *struts_right = NULL;
  80 static GSList *struts_bottom = NULL;
  81
  82 static ObPagerPopup *desktop_popup;
  83 static guint         desktop_popup_timer = 0;
  84 static gboolean      desktop_popup_perm;
  85
  86 /*! The number of microseconds that you need to be on a desktop before it will
  87   replace the remembered "last desktop" */
  88 #define REMEMBER_LAST_DESKTOP_TIME 750
  89
  90 static gboolean replace_wm(void)
  91 {
  92     gchar *wm_sn;
  93     Atom wm_sn_atom;
  94     Window current_wm_sn_owner;
  95     Time timestamp;
  96
  97     wm_sn = g_strdup_printf("WM_S%d", ob_screen);
  98     wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
  99     g_free(wm_sn);
 100
 101     current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
 102     if (current_wm_sn_owner == screen_support_win)
 103         current_wm_sn_owner = None;
 104     if (current_wm_sn_owner) {
 105         if (!ob_replace_wm) {
 106             g_message(_("A window manager is already running on screen %d"),
 107                       ob_screen);
 108             return FALSE;
 109         }
 110         obt_display_ignore_errors(TRUE);
 111
 112         /* We want to find out when the current selection owner dies */
 113         XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
 114         XSync(obt_display, FALSE);
 115
 116         obt_display_ignore_errors(FALSE);
 117         if (obt_display_error_occured)
 118             current_wm_sn_owner = None;
 119     }
 120
 121     timestamp = event_time();
 122
 123     XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
 124                        timestamp);
 125
 126     if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
 127         g_message(_("Could not acquire window manager selection on screen %d"),
 128                   ob_screen);
 129         return FALSE;
 130     }
 131
 132     /* Wait for old window manager to go away */
 133     if (current_wm_sn_owner) {
 134       gulong wait = 0;
 135       const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
 136       ObtXQueueWindowType wt;
 137
 138       wt.window = current_wm_sn_owner;
 139       wt.type = DestroyNotify;
 140
 141       while (wait < timeout) {
 142           /* Checks the local queue and incoming events for this event */
 143           if (xqueue_exists_local(xqueue_match_window_type, &wt))
 144               break;
 145           g_usleep(G_USEC_PER_SEC / 10);
 146           wait += G_USEC_PER_SEC / 10;
 147       }
 148
 149       if (wait >= timeout) {
 150           g_message(_("The WM on screen %d is not exiting"), ob_screen);
 151           return FALSE;
 152       }
 153     }
 154
 155     /* Send client message indicating that we are now the WM */
 156     obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
 157                      timestamp, wm_sn_atom, screen_support_win, 0, 0,
 158                      SubstructureNotifyMask);
 159
 160     return TRUE;
 161 }
 162
 163 gboolean screen_annex(void)
 164 {
 165     XSetWindowAttributes attrib;
 166     pid_t pid;
 167     gint i, num_support;
 168     gulong *supported;
 169
 170     /* create the netwm support window */
 171     attrib.override_redirect = TRUE;
 172     attrib.event_mask = PropertyChangeMask;
 173     screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
 174                                        -100, -100, 1, 1, 0,
 175                                        CopyFromParent, InputOutput,
 176                                        CopyFromParent,
 177                                        CWEventMask | CWOverrideRedirect,
 178                                        &attrib);
 179     XMapWindow(obt_display, screen_support_win);
 180     XLowerWindow(obt_display, screen_support_win);
 181
 182     if (!replace_wm()) {
 183         XDestroyWindow(obt_display, screen_support_win);
 184         return FALSE;
 185     }
 186
 187     obt_display_ignore_errors(TRUE);
 188     XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
 189     obt_display_ignore_errors(FALSE);
 190     if (obt_display_error_occured) {
 191         g_message(_("A window manager is already running on screen %d"),
 192                   ob_screen);
 193
 194         XDestroyWindow(obt_display, screen_support_win);
 195         return FALSE;
 196     }
 197
 198     screen_set_root_cursor();
 199
 200     /* set the OPENBOX_PID hint */
 201     pid = getpid();
 202     OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
 203
 204     /* set supporting window */
 205     OBT_PROP_SET32(obt_root(ob_screen),
 206                    NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
 207
 208     /* set properties on the supporting window */
 209     OBT_PROP_SETS(screen_support_win, NET_WM_NAME, "Openbox");
 210     OBT_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 ObtPropAtoms enum */
 216     num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
 217     i = 0;
 218     supported = g_new(gulong, num_support);
 219     supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
 220     supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
 221     supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
 222     supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
 223     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
 224     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
 225     supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
 226     supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
 227     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
 228     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
 229     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
 230     supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
 231     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
 232     supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
 233     supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
 234     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
 235     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
 236     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
 237     supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
 238     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
 239     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
 240     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
 241     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
 242     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
 243     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
 244     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
 245     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
 246     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
 247     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
 248     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
 249     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
 250     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
 251     supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
 252     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_OPACITY);
 253     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
 254     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
 255     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
 256     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
 257     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
 258     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
 259     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
 260     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
 261     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
 262     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
 263     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
 264     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
 265     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
 266     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
 267     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
 268     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
 269     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
 270     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
 271     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
 272     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
 273     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
 274     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
 275     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
 276     supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
 277     supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
 278     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
 279 /*
 280     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
 281 */
 282     supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
 283     supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
 284     supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
 285     supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
 286 #ifdef SYNC
 287     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
 288     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
 289 #endif
 290     supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
 291     supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
 292
 293     supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
 294     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
 295     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
 296
 297     supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
 298     supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
 299     supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_LOCKED);
 300     supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
 301     supported[i++] = OBT_PROP_ATOM(OB_THEME);
 302     supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
 303     supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
 304     supported[i++] = OBT_PROP_ATOM(OB_VERSION);
 305     supported[i++] = OBT_PROP_ATOM(OB_APP_ROLE);
 306     supported[i++] = OBT_PROP_ATOM(OB_APP_TITLE);
 307     supported[i++] = OBT_PROP_ATOM(OB_APP_NAME);
 308     supported[i++] = OBT_PROP_ATOM(OB_APP_CLASS);
 309     supported[i++] = OBT_PROP_ATOM(OB_APP_GROUP_NAME);
 310     supported[i++] = OBT_PROP_ATOM(OB_APP_GROUP_CLASS);
 311     supported[i++] = OBT_PROP_ATOM(OB_APP_TYPE);
 312     supported[i++] = OBT_PROP_ATOM(OB_TARGET_WINDOW);
 313     g_assert(i == num_support);
 314
 315     OBT_PROP_SETA32(obt_root(ob_screen),
 316                     NET_SUPPORTED, ATOM, supported, num_support);
 317     g_free(supported);
 318
 319     OBT_PROP_SETS(RootWindow(obt_display, ob_screen), OB_VERSION,
 320                   OPENBOX_VERSION);
 321
 322     screen_tell_ksplash();
 323
 324     return TRUE;
 325 }
 326
 327 static void screen_tell_ksplash(void)
 328 {
 329     XEvent e;
 330     char **argv;
 331
 332     argv = g_new(gchar*, 6);
 333     argv[0] = g_strdup("dcop");
 334     argv[1] = g_strdup("ksplash");
 335     argv[2] = g_strdup("ksplash");
 336     argv[3] = g_strdup("upAndRunning(QString)");
 337     argv[4] = g_strdup("wm started");
 338     argv[5] = NULL;
 339
 340     /* tell ksplash through the dcop server command line interface */
 341     g_spawn_async(NULL, argv, NULL,
 342                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
 343                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
 344                   NULL, NULL, NULL, NULL);
 345     g_strfreev(argv);
 346
 347     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
 348        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
 349        something. oh well. */
 350     e.xclient.type = ClientMessage;
 351     e.xclient.display = obt_display;
 352     e.xclient.window = obt_root(ob_screen);
 353     e.xclient.message_type =
 354         XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
 355     e.xclient.format = 8;
 356     strcpy(e.xclient.data.b, "wm started");
 357     XSendEvent(obt_display, obt_root(ob_screen),
 358                False, SubstructureNotifyMask, &e);
 359 }
 360
 361 void screen_startup(gboolean reconfig)
 362 {
 363     gchar **names = NULL;
 364     guint32 d;
 365     gboolean namesexist = FALSE;
 366
 367     desktop_popup = pager_popup_new();
 368     desktop_popup_perm = FALSE;
 369     pager_popup_height(desktop_popup, POPUP_HEIGHT);
 370
 371     if (reconfig) {
 372         /* update the pager popup's width */
 373         pager_popup_text_width_to_strings(desktop_popup,
 374                                           screen_desktop_names,
 375                                           screen_num_desktops);
 376         return;
 377     }
 378
 379     /* get the initial size */
 380     screen_resize();
 381
 382     /* have names already been set for the desktops? */
 383     if (OBT_PROP_GETSS_UTF8(obt_root(ob_screen), NET_DESKTOP_NAMES, &names)) {
 384         g_strfreev(names);
 385         namesexist = TRUE;
 386     }
 387
 388     /* if names don't exist and we have session names, set those.
 389        do this stuff BEFORE setting the number of desktops, because that
 390        will create default names for them
 391     */
 392     if (!namesexist && session_desktop_names != NULL) {
 393         guint i, numnames;
 394         GSList *it;
 395
 396         /* get the desktop names */
 397         numnames = g_slist_length(session_desktop_names);
 398         names = g_new(gchar*, numnames + 1);
 399         names[numnames] = NULL;
 400         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
 401             names[i] = g_strdup(it->data);
 402
 403         /* set the root window property */
 404         OBT_PROP_SETSS(obt_root(ob_screen),
 405                        NET_DESKTOP_NAMES, (const gchar*const*)names);
 406
 407         g_strfreev(names);
 408     }
 409
 410     /* set the number of desktops, if it's not already set.
 411
 412        this will also set the default names from the config file up for
 413        desktops that don't have names yet */
 414     screen_num_desktops = 0;
 415     if (OBT_PROP_GET32(obt_root(ob_screen),
 416                        NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
 417     {
 418         if (d != config_desktops_num) {
 419             /* TRANSLATORS: If you need to specify a different order of the
 420                arguments, you can use %1$d for the first one and %2$d for the
 421                second one. For example,
 422                "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
 423             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),
 424                       config_desktops_num, d);
 425         }
 426         screen_set_num_desktops(d);
 427     }
 428     /* restore from session if possible */
 429     else if (session_num_desktops)
 430         screen_set_num_desktops(session_num_desktops);
 431     else
 432         screen_set_num_desktops(config_desktops_num);
 433
 434     screen_desktop = screen_num_desktops;  /* something invalid */
 435     /* start on the current desktop when a wm was already running */
 436     if (OBT_PROP_GET32(obt_root(ob_screen),
 437                        NET_CURRENT_DESKTOP, CARDINAL, &d) &&
 438         d < screen_num_desktops)
 439     {
 440         screen_set_desktop(d, FALSE);
 441     } else if (session_desktop >= 0)
 442         screen_set_desktop(MIN((guint)session_desktop,
 443                                screen_num_desktops), FALSE);
 444     else
 445         screen_set_desktop(MIN(config_screen_firstdesk,
 446                                screen_num_desktops) - 1, FALSE);
 447     screen_last_desktop = screen_desktop;
 448
 449     /* don't start in showing-desktop mode */
 450     screen_show_desktop_mode = SCREEN_SHOW_DESKTOP_NO;
 451     OBT_PROP_SET32(obt_root(ob_screen),
 452                    NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop());
 453
 454     if (session_desktop_layout_present &&
 455         screen_validate_layout(&session_desktop_layout))
 456     {
 457         screen_desktop_layout = session_desktop_layout;
 458     }
 459     else
 460         screen_update_layout();
 461 }
 462
 463 void screen_shutdown(gboolean reconfig)
 464 {
 465     pager_popup_free(desktop_popup);
 466
 467     if (reconfig)
 468         return;
 469
 470     XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
 471
 472     /* we're not running here no more! */
 473     OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
 474     /* not without us */
 475     OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
 476     /* don't keep this mode */
 477     OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
 478
 479     XDestroyWindow(obt_display, screen_support_win);
 480
 481     g_strfreev(screen_desktop_names);
 482     screen_desktop_names = NULL;
 483 }
 484
 485 void screen_resize(void)
 486 {
 487     gint w, h;
 488     GList *it;
 489     gulong geometry[2];
 490
 491     w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 492     h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 493
 494     /* Set the _NET_DESKTOP_GEOMETRY hint */
 495     screen_physical_size.width = geometry[0] = w;
 496     screen_physical_size.height = geometry[1] = h;
 497     OBT_PROP_SETA32(obt_root(ob_screen),
 498                     NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
 499
 500     if (ob_state() != OB_STATE_RUNNING)
 501         return;
 502
 503     /* this calls screen_update_areas(), which we need ! */
 504     dock_configure();
 505
 506     for (it = client_list; it; it = g_list_next(it)) {
 507         client_move_onscreen(it->data, FALSE);
 508         client_reconfigure(it->data, FALSE);
 509     }
 510 }
 511
 512 void screen_set_num_desktops(guint num)
 513 {
 514     gulong *viewport;
 515     GList *it, *stacking_copy;
 516
 517     g_assert(num > 0);
 518
 519     if (screen_num_desktops == num) return;
 520
 521     screen_num_desktops = num;
 522     OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
 523
 524     /* set the viewport hint */
 525     viewport = g_new0(gulong, num * 2);
 526     OBT_PROP_SETA32(obt_root(ob_screen),
 527                     NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
 528     g_free(viewport);
 529
 530     /* the number of rows/columns will differ */
 531     screen_update_layout();
 532
 533     /* move windows on desktops that will no longer exist!
 534        make a copy of the list cuz we're changing it */
 535     stacking_copy = g_list_copy(stacking_list);
 536     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 537         if (WINDOW_IS_CLIENT(it->data)) {
 538             ObClient *c = it->data;
 539             if (c->desktop != DESKTOP_ALL && c->desktop >= num)
 540                 client_set_desktop(c, num - 1, FALSE, TRUE);
 541             /* raise all the windows that are on the current desktop which
 542                is being merged */
 543             else if (screen_desktop == num - 1 &&
 544                      (c->desktop == DESKTOP_ALL ||
 545                       c->desktop == screen_desktop))
 546                 stacking_raise(CLIENT_AS_WINDOW(c));
 547         }
 548     }
 549     g_list_free(stacking_copy);
 550
 551     /* change our struts/area to match (after moving windows) */
 552     screen_update_areas();
 553
 554     /* may be some unnamed desktops that we need to fill in with names
 555        (after updating the areas so the popup can resize) */
 556     screen_update_desktop_names();
 557
 558     /* change our desktop if we're on one that no longer exists! */
 559     if (screen_desktop >= screen_num_desktops)
 560         screen_set_desktop(num - 1, TRUE);
 561 }
 562
 563 static void screen_fallback_focus(void)
 564 {
 565     ObClient *c;
 566     gboolean allow_omni;
 567
 568     /* only allow omnipresent windows to get focus on desktop change if
 569        an omnipresent window is already focused (it'll keep focus probably, but
 570        maybe not depending on mouse-focus options) */
 571     allow_omni = focus_client && (client_normal(focus_client) &&
 572                                   focus_client->desktop == DESKTOP_ALL);
 573
 574     /* the client moved there already so don't move focus. prevent flicker
 575        on sendtodesktop + follow */
 576     if (focus_client && focus_client->desktop == screen_desktop)
 577         return;
 578
 579     /* have to try focus here because when you leave an empty desktop
 580        there is no focus out to watch for. also, we have different rules
 581        here. we always allow it to look under the mouse pointer if
 582        config_focus_last is FALSE
 583
 584        do this before hiding the windows so if helper windows are coming
 585        with us, they don't get hidden
 586     */
 587     if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
 588                             !allow_omni)))
 589     {
 590         /* only do the flicker reducing stuff ahead of time if we are going
 591            to call xsetinputfocus on the window ourselves. otherwise there is
 592            no guarantee the window will actually take focus.. */
 593         if (c->can_focus) {
 594             /* reduce flicker by hiliting now rather than waiting for the
 595                server FocusIn event */
 596             frame_adjust_focus(c->frame, TRUE);
 597             /* do this here so that if you switch desktops to a window with
 598                helper windows then the helper windows won't flash */
 599             client_bring_helper_windows(c);
 600         }
 601     }
 602 }
 603
 604 static gboolean last_desktop_func(gpointer data)
 605 {
 606     screen_desktop_timeout = TRUE;
 607     screen_desktop_timer = 0;
 608     return FALSE; /* don't repeat */
 609 }
 610
 611 void screen_set_desktop(guint num, gboolean dofocus)
 612 {
 613     GList *it;
 614     guint previous;
 615     gulong ignore_start;
 616
 617     g_assert(num < screen_num_desktops);
 618
 619     previous = screen_desktop;
 620     screen_desktop = num;
 621
 622     if (previous == num) return;
 623
 624     OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
 625
 626     /* This whole thing decides when/how to save the screen_last_desktop so
 627        that it can be restored later if you want */
 628     if (screen_desktop_timeout) {
 629         /* If screen_desktop_timeout is true, then we've been on this desktop
 630            long enough and we can save it as the last desktop. */
 631
 632         if (screen_last_desktop == previous)
 633             /* this is the startup state only */
 634             screen_old_desktop = screen_desktop;
 635         else {
 636             /* save the "last desktop" as the "old desktop" */
 637             screen_old_desktop = screen_last_desktop;
 638             /* save the desktop we're coming from as the "last desktop" */
 639             screen_last_desktop = previous;
 640         }
 641     }
 642     else {
 643         /* If screen_desktop_timeout is false, then we just got to this desktop
 644            and we are moving away again. */
 645
 646         if (screen_desktop == screen_last_desktop) {
 647             /* If we are moving to the "last desktop" .. */
 648             if (previous == screen_old_desktop) {
 649                 /* .. from the "old desktop", change the last desktop to
 650                    be where we are coming from */
 651                 screen_last_desktop = screen_old_desktop;
 652             }
 653             else if (screen_last_desktop == screen_old_desktop) {
 654                 /* .. and also to the "old desktop", change the "last
 655                    desktop" to be where we are coming from */
 656                 screen_last_desktop = previous;
 657             }
 658             else {
 659                 /* .. from some other desktop, then set the "last desktop" to
 660                    be the saved "old desktop", i.e. where we were before the
 661                    "last desktop" */
 662                 screen_last_desktop = screen_old_desktop;
 663             }
 664         }
 665         else {
 666             /* If we are moving to any desktop besides the "last desktop"..
 667                (this is the normal case) */
 668             if (screen_desktop == screen_old_desktop) {
 669                 /* If moving to the "old desktop", which is not the
 670                    "last desktop", don't save anything */
 671             }
 672             else if (previous == screen_old_desktop) {
 673                 /* If moving from the "old desktop", and not to the
 674                    "last desktop", don't save anything */
 675             }
 676             else if (screen_last_desktop == screen_old_desktop) {
 677                 /* If the "last desktop" is the same as "old desktop" and
 678                    you're not moving to the "last desktop" then save where
 679                    we're coming from as the "last desktop" */
 680                 screen_last_desktop = previous;
 681             }
 682             else {
 683                 /* If the "last desktop" is different from the "old desktop"
 684                    and you're not moving to the "last desktop", then don't save
 685                    anything */
 686             }
 687         }
 688     }
 689     screen_desktop_timeout = FALSE;
 690     if (screen_desktop_timer) g_source_remove(screen_desktop_timer);
 691     screen_desktop_timer = g_timeout_add(REMEMBER_LAST_DESKTOP_TIME,
 692                                          last_desktop_func, NULL);
 693
 694     ob_debug("Moving to desktop %d", num+1);
 695
 696     if (ob_state() == OB_STATE_RUNNING)
 697         screen_show_desktop_popup(screen_desktop, FALSE);
 698
 699     /* ignore enter events caused by the move */
 700     ignore_start = event_start_ignore_all_enters();
 701
 702     if (moveresize_client)
 703         client_set_desktop(moveresize_client, num, TRUE, FALSE);
 704
 705     /* show windows before hiding the rest to lessen the enter/leave events */
 706
 707     /* show windows from top to bottom */
 708     for (it = stacking_list; it; it = g_list_next(it)) {
 709         if (WINDOW_IS_CLIENT(it->data)) {
 710             ObClient *c = it->data;
 711             client_show(c);
 712         }
 713     }
 714
 715     if (dofocus) screen_fallback_focus();
 716
 717     /* hide windows from bottom to top */
 718     for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
 719         if (WINDOW_IS_CLIENT(it->data)) {
 720             ObClient *c = it->data;
 721             if (client_hide(c)) {
 722                 if (c == focus_client) {
 723                     /* c was focused and we didn't do fallback clearly so make
 724                        sure openbox doesnt still consider the window focused.
 725                        this happens when using NextWindow with allDesktops,
 726                        since it doesnt want to move focus on desktop change,
 727                        but the focus is not going to stay with the current
 728                        window, which has now disappeared.
 729                        only do this if the client was actually hidden,
 730                        otherwise it can keep focus. */
 731                     focus_set_client(NULL);
 732                 }
 733             }
 734         }
 735     }
 736
 737     focus_cycle_addremove(NULL, TRUE);
 738
 739     event_end_ignore_all_enters(ignore_start);
 740
 741     if (event_source_time() != CurrentTime)
 742         screen_desktop_user_time = event_source_time();
 743 }
 744
 745 void screen_add_desktop(gboolean current)
 746 {
 747     gulong ignore_start;
 748
 749     /* ignore enter events caused by this */
 750     ignore_start = event_start_ignore_all_enters();
 751
 752     screen_set_num_desktops(screen_num_desktops+1);
 753
 754     /* move all the clients over */
 755     if (current) {
 756         GList *it;
 757
 758         for (it = client_list; it; it = g_list_next(it)) {
 759             ObClient *c = it->data;
 760             if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
 761                 /* don't move direct children, they'll be moved with their
 762                    parent - which will have to be on the same desktop */
 763                 !client_direct_parent(c))
 764             {
 765                 ob_debug("moving window %s", c->title);
 766                 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
 767             }
 768         }
 769     }
 770
 771     event_end_ignore_all_enters(ignore_start);
 772 }
 773
 774 void screen_remove_desktop(gboolean current)
 775 {
 776     guint rmdesktop, movedesktop;
 777     GList *it, *stacking_copy;
 778     gulong ignore_start;
 779
 780     if (screen_num_desktops <= 1) return;
 781
 782     /* ignore enter events caused by this */
 783     ignore_start = event_start_ignore_all_enters();
 784
 785     /* what desktop are we removing and moving to? */
 786     if (current)
 787         rmdesktop = screen_desktop;
 788     else
 789         rmdesktop = screen_num_desktops - 1;
 790     if (rmdesktop < screen_num_desktops - 1)
 791         movedesktop = rmdesktop + 1;
 792     else
 793         movedesktop = rmdesktop;
 794
 795     /* make a copy of the list cuz we're changing it */
 796     stacking_copy = g_list_copy(stacking_list);
 797     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 798         if (WINDOW_IS_CLIENT(it->data)) {
 799             ObClient *c = it->data;
 800             guint d = c->desktop;
 801             if (d != DESKTOP_ALL && d >= movedesktop &&
 802                 /* don't move direct children, they'll be moved with their
 803                    parent - which will have to be on the same desktop */
 804                 !client_direct_parent(c))
 805             {
 806                 ob_debug("moving window %s", c->title);
 807                 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
 808             }
 809             /* raise all the windows that are on the current desktop which
 810                is being merged */
 811             if ((screen_desktop == rmdesktop - 1 ||
 812                  screen_desktop == rmdesktop) &&
 813                 (d == DESKTOP_ALL || d == screen_desktop))
 814             {
 815                 stacking_raise(CLIENT_AS_WINDOW(c));
 816                 ob_debug("raising window %s", c->title);
 817             }
 818         }
 819     }
 820     g_list_free(stacking_copy);
 821
 822     /* fallback focus like we're changing desktops */
 823     if (screen_desktop < screen_num_desktops - 1) {
 824         screen_fallback_focus();
 825         ob_debug("fake desktop change");
 826     }
 827
 828     screen_set_num_desktops(screen_num_desktops-1);
 829
 830     event_end_ignore_all_enters(ignore_start);
 831 }
 832
 833 static void get_row_col(guint d, guint *r, guint *c)
 834 {
 835     switch (screen_desktop_layout.orientation) {
 836     case OB_ORIENTATION_HORZ:
 837         switch (screen_desktop_layout.start_corner) {
 838         case OB_CORNER_TOPLEFT:
 839             *r = d / screen_desktop_layout.columns;
 840             *c = d % screen_desktop_layout.columns;
 841             break;
 842         case OB_CORNER_BOTTOMLEFT:
 843             *r = screen_desktop_layout.rows - 1 -
 844                 d / screen_desktop_layout.columns;
 845             *c = d % screen_desktop_layout.columns;
 846             break;
 847         case OB_CORNER_TOPRIGHT:
 848             *r = d / screen_desktop_layout.columns;
 849             *c = screen_desktop_layout.columns - 1 -
 850                 d % screen_desktop_layout.columns;
 851             break;
 852         case OB_CORNER_BOTTOMRIGHT:
 853             *r = screen_desktop_layout.rows - 1 -
 854                 d / screen_desktop_layout.columns;
 855             *c = screen_desktop_layout.columns - 1 -
 856                 d % screen_desktop_layout.columns;
 857             break;
 858         }
 859         break;
 860     case OB_ORIENTATION_VERT:
 861         switch (screen_desktop_layout.start_corner) {
 862         case OB_CORNER_TOPLEFT:
 863             *r = d % screen_desktop_layout.rows;
 864             *c = d / screen_desktop_layout.rows;
 865             break;
 866         case OB_CORNER_BOTTOMLEFT:
 867             *r = screen_desktop_layout.rows - 1 -
 868                 d % screen_desktop_layout.rows;
 869             *c = d / screen_desktop_layout.rows;
 870             break;
 871         case OB_CORNER_TOPRIGHT:
 872             *r = d % screen_desktop_layout.rows;
 873             *c = screen_desktop_layout.columns - 1 -
 874                 d / screen_desktop_layout.rows;
 875             break;
 876         case OB_CORNER_BOTTOMRIGHT:
 877             *r = screen_desktop_layout.rows - 1 -
 878                 d % screen_desktop_layout.rows;
 879             *c = screen_desktop_layout.columns - 1 -
 880                 d / screen_desktop_layout.rows;
 881             break;
 882         }
 883         break;
 884     }
 885 }
 886
 887 static guint translate_row_col(guint r, guint c)
 888 {
 889     switch (screen_desktop_layout.orientation) {
 890     case OB_ORIENTATION_HORZ:
 891         switch (screen_desktop_layout.start_corner) {
 892         case OB_CORNER_TOPLEFT:
 893             return r % screen_desktop_layout.rows *
 894                 screen_desktop_layout.columns +
 895                 c % screen_desktop_layout.columns;
 896         case OB_CORNER_BOTTOMLEFT:
 897             return (screen_desktop_layout.rows - 1 -
 898                     r % screen_desktop_layout.rows) *
 899                 screen_desktop_layout.columns +
 900                 c % screen_desktop_layout.columns;
 901         case OB_CORNER_TOPRIGHT:
 902             return r % screen_desktop_layout.rows *
 903                 screen_desktop_layout.columns +
 904                 (screen_desktop_layout.columns - 1 -
 905                  c % screen_desktop_layout.columns);
 906         case OB_CORNER_BOTTOMRIGHT:
 907             return (screen_desktop_layout.rows - 1 -
 908                     r % screen_desktop_layout.rows) *
 909                 screen_desktop_layout.columns +
 910                 (screen_desktop_layout.columns - 1 -
 911                  c % screen_desktop_layout.columns);
 912         }
 913     case OB_ORIENTATION_VERT:
 914         switch (screen_desktop_layout.start_corner) {
 915         case OB_CORNER_TOPLEFT:
 916             return c % screen_desktop_layout.columns *
 917                 screen_desktop_layout.rows +
 918                 r % screen_desktop_layout.rows;
 919         case OB_CORNER_BOTTOMLEFT:
 920             return c % screen_desktop_layout.columns *
 921                 screen_desktop_layout.rows +
 922                 (screen_desktop_layout.rows - 1 -
 923                  r % screen_desktop_layout.rows);
 924         case OB_CORNER_TOPRIGHT:
 925             return (screen_desktop_layout.columns - 1 -
 926                     c % screen_desktop_layout.columns) *
 927                 screen_desktop_layout.rows +
 928                 r % screen_desktop_layout.rows;
 929         case OB_CORNER_BOTTOMRIGHT:
 930             return (screen_desktop_layout.columns - 1 -
 931                     c % screen_desktop_layout.columns) *
 932                 screen_desktop_layout.rows +
 933                 (screen_desktop_layout.rows - 1 -
 934                  r % screen_desktop_layout.rows);
 935         }
 936     }
 937     g_assert_not_reached();
 938     return 0;
 939 }
 940
 941 static gboolean hide_desktop_popup_func(gpointer data)
 942 {
 943     pager_popup_hide(desktop_popup);
 944     desktop_popup_timer = 0;
 945     return FALSE; /* don't repeat */
 946 }
 947
 948 void screen_show_desktop_popup(guint d, gboolean perm)
 949 {
 950     const Rect *a;
 951
 952     /* 0 means don't show the popup */
 953     if (!config_desktop_popup_time) return;
 954
 955     a = screen_physical_area_primary(FALSE);
 956     pager_popup_position(desktop_popup, CenterGravity,
 957                          a->x + a->width / 2, a->y + a->height / 2);
 958     pager_popup_icon_size_multiplier(desktop_popup,
 959                                      (screen_desktop_layout.columns /
 960                                       screen_desktop_layout.rows) / 2,
 961                                      (screen_desktop_layout.rows/
 962                                       screen_desktop_layout.columns) / 2);
 963     pager_popup_max_width(desktop_popup,
 964                           MAX(a->width/3, POPUP_WIDTH));
 965     pager_popup_show(desktop_popup, screen_desktop_names[d], d);
 966
 967     if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
 968     desktop_popup_timer = 0;
 969     if (!perm && !desktop_popup_perm)
 970         /* only hide if its not already being show permanently */
 971         desktop_popup_timer = g_timeout_add(config_desktop_popup_time,
 972                                             hide_desktop_popup_func,
 973                                             desktop_popup);
 974     if (perm)
 975         desktop_popup_perm = TRUE;
 976 }
 977
 978 void screen_hide_desktop_popup(void)
 979 {
 980     if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
 981     desktop_popup_timer = 0;
 982     pager_popup_hide(desktop_popup);
 983     desktop_popup_perm = FALSE;
 984 }
 985
 986 guint screen_find_desktop(guint from, ObDirection dir,
 987                           gboolean wrap, gboolean linear)
 988 {
 989     guint r, c;
 990     guint d;
 991
 992     d = from;
 993     get_row_col(d, &r, &c);
 994     if (linear) {
 995         switch (dir) {
 996         case OB_DIRECTION_EAST:
 997             if (d < screen_num_desktops - 1)
 998                 ++d;
 999             else if (wrap)
1000                 d = 0;
1001             else
1002                 return from;
1003             break;
1004         case OB_DIRECTION_WEST:
1005             if (d > 0)
1006                 --d;
1007             else if (wrap)
1008                 d = screen_num_desktops - 1;
1009             else
1010                 return from;
1011             break;
1012         default:
1013             g_assert_not_reached();
1014             return from;
1015         }
1016     } else {
1017         switch (dir) {
1018         case OB_DIRECTION_EAST:
1019             ++c;
1020             if (c >= screen_desktop_layout.columns) {
1021                 if (wrap)
1022                     c = 0;
1023                 else
1024                     return from;
1025             }
1026             d = translate_row_col(r, c);
1027             if (d >= screen_num_desktops) {
1028                 if (wrap)
1029                     ++c;
1030                 else
1031                     return from;
1032             }
1033             break;
1034         case OB_DIRECTION_WEST:
1035             --c;
1036             if (c >= screen_desktop_layout.columns) {
1037                 if (wrap)
1038                     c = screen_desktop_layout.columns - 1;
1039                 else
1040                     return from;
1041             }
1042             d = translate_row_col(r, c);
1043             if (d >= screen_num_desktops) {
1044                 if (wrap)
1045                     --c;
1046                 else
1047                     return from;
1048             }
1049             break;
1050         case OB_DIRECTION_SOUTH:
1051             ++r;
1052             if (r >= screen_desktop_layout.rows) {
1053                 if (wrap)
1054                     r = 0;
1055                 else
1056                     return from;
1057             }
1058             d = translate_row_col(r, c);
1059             if (d >= screen_num_desktops) {
1060                 if (wrap)
1061                     ++r;
1062                 else
1063                     return from;
1064             }
1065             break;
1066         case OB_DIRECTION_NORTH:
1067             --r;
1068             if (r >= screen_desktop_layout.rows) {
1069                 if (wrap)
1070                     r = screen_desktop_layout.rows - 1;
1071                 else
1072                     return from;
1073             }
1074             d = translate_row_col(r, c);
1075             if (d >= screen_num_desktops) {
1076                 if (wrap)
1077                     --r;
1078                 else
1079                     return from;
1080             }
1081             break;
1082         default:
1083             g_assert_not_reached();
1084             return from;
1085         }
1086
1087         d = translate_row_col(r, c);
1088     }
1089     return d;
1090 }
1091
1092 static gboolean screen_validate_layout(ObDesktopLayout *l)
1093 {
1094     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1095         return FALSE;
1096
1097     /* fill in a zero rows/columns */
1098     if (l->columns == 0) {
1099         l->columns = screen_num_desktops / l->rows;
1100         if (l->rows * l->columns < screen_num_desktops)
1101             l->columns++;
1102         if (l->rows * l->columns >= screen_num_desktops + l->columns)
1103             l->rows--;
1104     } else if (l->rows == 0) {
1105         l->rows = screen_num_desktops / l->columns;
1106         if (l->columns * l->rows < screen_num_desktops)
1107             l->rows++;
1108         if (l->columns * l->rows >= screen_num_desktops + l->rows)
1109             l->columns--;
1110     }
1111
1112     /* bounds checking */
1113     if (l->orientation == OB_ORIENTATION_HORZ) {
1114         l->columns = MIN(screen_num_desktops, l->columns);
1115         l->rows = MIN(l->rows,
1116                       (screen_num_desktops + l->columns - 1) / l->columns);
1117         l->columns = screen_num_desktops / l->rows +
1118             !!(screen_num_desktops % l->rows);
1119     } else {
1120         l->rows = MIN(screen_num_desktops, l->rows);
1121         l->columns = MIN(l->columns,
1122                          (screen_num_desktops + l->rows - 1) / l->rows);
1123         l->rows = screen_num_desktops / l->columns +
1124             !!(screen_num_desktops % l->columns);
1125     }
1126     return TRUE;
1127 }
1128
1129 void screen_update_layout(void)
1130
1131 {
1132     ObDesktopLayout l;
1133     guint32 *data;
1134     guint num;
1135
1136     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1137     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1138     screen_desktop_layout.rows = 1;
1139     screen_desktop_layout.columns = screen_num_desktops;
1140
1141     if (OBT_PROP_GETA32(obt_root(ob_screen),
1142                         NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1143         if (num == 3 || num == 4) {
1144
1145             if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1146                 l.orientation = OB_ORIENTATION_VERT;
1147             else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1148                 l.orientation = OB_ORIENTATION_HORZ;
1149             else
1150                 return;
1151
1152             if (num < 4)
1153                 l.start_corner = OB_CORNER_TOPLEFT;
1154             else {
1155                 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1156                     l.start_corner = OB_CORNER_TOPLEFT;
1157                 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1158                     l.start_corner = OB_CORNER_TOPRIGHT;
1159                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1160                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
1161                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1162                     l.start_corner = OB_CORNER_BOTTOMLEFT;
1163                 else
1164                     return;
1165             }
1166
1167             l.columns = data[1];
1168             l.rows = data[2];
1169
1170             if (screen_validate_layout(&l))
1171                 screen_desktop_layout = l;
1172
1173             g_free(data);
1174         }
1175     }
1176 }
1177
1178 void screen_update_desktop_names(void)
1179 {
1180     guint i;
1181
1182     /* empty the array */
1183     g_strfreev(screen_desktop_names);
1184     screen_desktop_names = NULL;
1185
1186     if (OBT_PROP_GETSS(obt_root(ob_screen),
1187                        NET_DESKTOP_NAMES, &screen_desktop_names))
1188         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1189     else
1190         i = 0;
1191     if (i < screen_num_desktops) {
1192         GSList *it;
1193
1194         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1195                                        screen_num_desktops + 1);
1196         screen_desktop_names[screen_num_desktops] = NULL;
1197
1198         it = g_slist_nth(config_desktops_names, i);
1199
1200         for (; i < screen_num_desktops; ++i) {
1201             if (it && ((char*)it->data)[0]) /* not empty */
1202                 /* use the names from the config file when possible */
1203                 screen_desktop_names[i] = g_strdup(it->data);
1204             else
1205                 /* make up a nice name if it's not though */
1206                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1207                                                           i + 1);
1208             if (it) it = g_slist_next(it);
1209         }
1210
1211         /* if we changed any names, then set the root property so we can
1212            all agree on the names */
1213         OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1214                        (const gchar*const*)screen_desktop_names);
1215     }
1216
1217     /* resize the pager for these names */
1218     pager_popup_text_width_to_strings(desktop_popup,
1219                                       screen_desktop_names,
1220                                       screen_num_desktops);
1221 }
1222
1223 void screen_show_desktop(ObScreenShowDestopMode show_mode, ObClient *show_only)
1224 {
1225     GList *it;
1226
1227     ObScreenShowDestopMode before_mode = screen_show_desktop_mode;
1228
1229     gboolean showing_before = screen_showing_desktop();
1230     screen_show_desktop_mode = show_mode;
1231     gboolean showing_after = screen_showing_desktop();
1232
1233     if (showing_before == showing_after) {
1234         /* No change. */
1235         screen_show_desktop_mode = before_mode;
1236         return;
1237     }
1238
1239     if (screen_show_desktop_mode == SCREEN_SHOW_DESKTOP_UNTIL_TOGGLE &&
1240         show_only != NULL)
1241     {
1242         /* If we're showing the desktop until the show-mode is toggled, we
1243            don't allow breaking out of showing-desktop mode unless we're
1244            showing all the windows again. */
1245         screen_show_desktop_mode = before_mode;
1246         return;
1247     }
1248
1249     if (showing_after) {
1250         /* hide windows bottom to top */
1251         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1252             if (WINDOW_IS_CLIENT(it->data)) {
1253                 ObClient *client = it->data;
1254                 client_showhide(client);
1255             }
1256         }
1257     }
1258     else {
1259         /* restore windows top to bottom */
1260         for (it = stacking_list; it; it = g_list_next(it)) {
1261             if (WINDOW_IS_CLIENT(it->data)) {
1262                 ObClient *client = it->data;
1263                 if (client_should_show(client)) {
1264                     if (!show_only || client == show_only)
1265                         client_show(client);
1266                     else
1267                         client_iconify(client, TRUE, FALSE, TRUE);
1268                 }
1269             }
1270         }
1271     }
1272
1273     if (showing_after) {
1274         /* focus the desktop */
1275         for (it = focus_order; it; it = g_list_next(it)) {
1276             ObClient *c = it->data;
1277             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1278                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1279                 client_focus(it->data))
1280                 break;
1281         }
1282     }
1283     else if (!show_only) {
1284         ObClient *c;
1285
1286         if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1287             /* only do the flicker reducing stuff ahead of time if we are going
1288                to call xsetinputfocus on the window ourselves. otherwise there
1289                is no guarantee the window will actually take focus.. */
1290             if (c->can_focus) {
1291                 /* reduce flicker by hiliting now rather than waiting for the
1292                    server FocusIn event */
1293                 frame_adjust_focus(c->frame, TRUE);
1294             }
1295         }
1296     }
1297
1298     OBT_PROP_SET32(obt_root(ob_screen),
1299                    NET_SHOWING_DESKTOP,
1300                    CARDINAL,
1301                    !!showing_after);
1302 }
1303
1304 gboolean screen_showing_desktop()
1305 {
1306     switch (screen_show_desktop_mode) {
1307     case SCREEN_SHOW_DESKTOP_NO:
1308         return FALSE;
1309     case SCREEN_SHOW_DESKTOP_UNTIL_WINDOW:
1310     case SCREEN_SHOW_DESKTOP_UNTIL_TOGGLE:
1311         return TRUE;
1312     }
1313     g_assert_not_reached();
1314     return FALSE;
1315 }
1316
1317 void screen_install_colormap(ObClient *client, gboolean install)
1318 {
1319     if (client == NULL || client->colormap == None) {
1320         if (install)
1321             XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1322         else
1323             XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1324     } else {
1325         obt_display_ignore_errors(TRUE);
1326         if (install)
1327             XInstallColormap(obt_display, client->colormap);
1328         else
1329             XUninstallColormap(obt_display, client->colormap);
1330         obt_display_ignore_errors(FALSE);
1331     }
1332 }
1333
1334 typedef struct {
1335     guint desktop;
1336     StrutPartial *strut;
1337 } ObScreenStrut;
1338
1339 #define RESET_STRUT_LIST(sl) \
1340     while (sl) { \
1341         g_slice_free(ObScreenStrut, (sl)->data); \
1342         sl = g_slist_delete_link(sl, sl); \
1343     }
1344
1345 #define ADD_STRUT_TO_LIST(sl, d, s) \
1346 { \
1347     ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1348     ss->desktop = d; \
1349     ss->strut = s;  \
1350     sl = g_slist_prepend(sl, ss); \
1351 }
1352
1353 #define VALIDATE_STRUTS(sl, side, max) \
1354 { \
1355     GSList *it; \
1356     for (it = sl; it; it = g_slist_next(it)) { \
1357       ObScreenStrut *ss = it->data; \
1358       ss->strut->side = MIN(max, ss->strut->side); \
1359     } \
1360 }
1361
1362 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1363 {
1364     guint i;
1365     gint l, r, t, b;
1366 #ifdef XINERAMA
1367     gint n;
1368     XineramaScreenInfo *info;
1369 #endif
1370
1371     if (ob_debug_xinerama) {
1372         gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1373         gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1374         *nxin = 2;
1375         *xin_areas = g_new(Rect, *nxin + 1);
1376         RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1377         RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1378     }
1379 #ifdef XINERAMA
1380     else if (obt_display_extension_xinerama &&
1381              (info = XineramaQueryScreens(obt_display, &n))) {
1382         *nxin = n;
1383         *xin_areas = g_new(Rect, *nxin + 1);
1384         for (i = 0; i < *nxin; ++i)
1385             RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1386                      info[i].width, info[i].height);
1387         XFree(info);
1388     }
1389 #endif
1390     else {
1391         *nxin = 1;
1392         *xin_areas = g_new(Rect, *nxin + 1);
1393         RECT_SET((*xin_areas)[0], 0, 0,
1394                  WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1395                  HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1396     }
1397
1398     /* returns one extra with the total area in it */
1399     l = (*xin_areas)[0].x;
1400     t = (*xin_areas)[0].y;
1401     r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1402     b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1403     for (i = 1; i < *nxin; ++i) {
1404         l = MIN(l, (*xin_areas)[i].x);
1405         t = MIN(l, (*xin_areas)[i].y);
1406         r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1407         b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1408     }
1409     RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1410
1411     for (i = 0; i < *nxin; ++i)
1412         ob_debug("Monitor %d @ %d,%d %dx%d\n", i,
1413                  (*xin_areas)[i].x, (*xin_areas)[i].y,
1414                  (*xin_areas)[i].width, (*xin_areas)[i].height);
1415     ob_debug("Full desktop @ %d,%d %dx%d\n",
1416              (*xin_areas)[i].x, (*xin_areas)[i].y,
1417              (*xin_areas)[i].width, (*xin_areas)[i].height);
1418 }
1419
1420 void screen_update_areas(void)
1421 {
1422     guint i;
1423     gulong *dims;
1424     GList *it, *onscreen;
1425
1426     /* collect the clients that are on screen */
1427     onscreen = NULL;
1428     for (it = client_list; it; it = g_list_next(it)) {
1429         if (client_monitor(it->data) != screen_num_monitors)
1430             onscreen = g_list_prepend(onscreen, it->data);
1431     }
1432
1433     g_free(monitor_area);
1434     get_xinerama_screens(&monitor_area, &screen_num_monitors);
1435
1436     /* set up the user-specified margins */
1437     config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1438     config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1439     config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1440     config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1441     config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1442     config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1443     config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1444     config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1445
1446     RESET_STRUT_LIST(struts_left);
1447     RESET_STRUT_LIST(struts_top);
1448     RESET_STRUT_LIST(struts_right);
1449     RESET_STRUT_LIST(struts_bottom);
1450
1451     /* collect the struts */
1452     for (it = client_list; it; it = g_list_next(it)) {
1453         ObClient *c = it->data;
1454         if (c->strut.left)
1455             ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1456         if (c->strut.top)
1457             ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1458         if (c->strut.right)
1459             ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1460         if (c->strut.bottom)
1461             ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1462     }
1463     if (dock_strut.left)
1464         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1465     if (dock_strut.top)
1466         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1467     if (dock_strut.right)
1468         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1469     if (dock_strut.bottom)
1470         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1471
1472     if (config_margins.left)
1473         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1474     if (config_margins.top)
1475         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1476     if (config_margins.right)
1477         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1478     if (config_margins.bottom)
1479         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1480
1481     VALIDATE_STRUTS(struts_left, left,
1482                     monitor_area[screen_num_monitors].width / 2);
1483     VALIDATE_STRUTS(struts_right, right,
1484                     monitor_area[screen_num_monitors].width / 2);
1485     VALIDATE_STRUTS(struts_top, top,
1486                     monitor_area[screen_num_monitors].height / 2);
1487     VALIDATE_STRUTS(struts_bottom, bottom,
1488                     monitor_area[screen_num_monitors].height / 2);
1489
1490     dims = g_new(gulong, 4 * screen_num_desktops);
1491     for (i = 0; i < screen_num_desktops; ++i) {
1492         Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1493         dims[i*4+0] = area->x;
1494         dims[i*4+1] = area->y;
1495         dims[i*4+2] = area->width;
1496         dims[i*4+3] = area->height;
1497         g_slice_free(Rect, area);
1498     }
1499
1500     /* set the legacy workarea hint to the union of all the monitors */
1501     OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1502                     dims, 4 * screen_num_desktops);
1503
1504     /* the area has changed, adjust all the windows if they need it */
1505     for (it = onscreen; it; it = g_list_next(it))
1506         client_reconfigure(it->data, FALSE);
1507
1508     g_free(dims);
1509 }
1510
1511 #if 0
1512 Rect* screen_area_all_monitors(guint desktop)
1513 {
1514     guint i;
1515     Rect *a;
1516
1517     a = screen_area_monitor(desktop, 0);
1518
1519     /* combine all the monitors together */
1520     for (i = 1; i < screen_num_monitors; ++i) {
1521         Rect *m = screen_area_monitor(desktop, i);
1522         gint l, r, t, b;
1523
1524         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1525         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1526         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1527         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1528
1529         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1530
1531         g_free(m);
1532     }
1533
1534     return a;
1535 }
1536 #endif
1537
1538 #define STRUT_LEFT_IN_SEARCH(s, search) \
1539     (RANGES_INTERSECT(search->y, search->height, \
1540                       s->left_start, s->left_end - s->left_start + 1))
1541 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1542     (RANGES_INTERSECT(search->y, search->height, \
1543                       s->right_start, s->right_end - s->right_start + 1))
1544 #define STRUT_TOP_IN_SEARCH(s, search) \
1545     (RANGES_INTERSECT(search->x, search->width, \
1546                       s->top_start, s->top_end - s->top_start + 1))
1547 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1548     (RANGES_INTERSECT(search->x, search->width, \
1549                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1550
1551 #define STRUT_LEFT_IGNORE(s, us, search) \
1552     (head == SCREEN_AREA_ALL_MONITORS && us && \
1553      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1554 #define STRUT_RIGHT_IGNORE(s, us, search) \
1555     (head == SCREEN_AREA_ALL_MONITORS && us && \
1556      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1557 #define STRUT_TOP_IGNORE(s, us, search) \
1558     (head == SCREEN_AREA_ALL_MONITORS && us && \
1559      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1560 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1561     (head == SCREEN_AREA_ALL_MONITORS && us && \
1562      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1563
1564 Rect* screen_area(guint desktop, guint head, Rect *search)
1565 {
1566     Rect *a;
1567     GSList *it;
1568     gint l, r, t, b;
1569     guint i, d;
1570     gboolean us = search != NULL; /* user provided search */
1571
1572     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1573     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1574              head == SCREEN_AREA_ALL_MONITORS);
1575     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1576
1577     /* find any struts for this monitor
1578        which will be affecting the search area.
1579     */
1580
1581     /* search everything if search is null */
1582     if (!search) {
1583         if (head < screen_num_monitors) search = &monitor_area[head];
1584         else search = &monitor_area[screen_num_monitors];
1585     }
1586     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1587
1588     /* al is "all left" meaning the furthest left you can get, l is our
1589        "working left" meaning our current strut edge which we're calculating
1590     */
1591
1592     /* only include monitors which the search area lines up with */
1593     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1594         l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1595         t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1596         r = RECT_LEFT(monitor_area[screen_num_monitors]);
1597         b = RECT_TOP(monitor_area[screen_num_monitors]);
1598         for (i = 0; i < screen_num_monitors; ++i) {
1599             /* add the monitor if applicable */
1600             if (RANGES_INTERSECT(search->x, search->width,
1601                                  monitor_area[i].x, monitor_area[i].width))
1602             {
1603                 t = MIN(t, RECT_TOP(monitor_area[i]));
1604                 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1605             }
1606             if (RANGES_INTERSECT(search->y, search->height,
1607                                  monitor_area[i].y, monitor_area[i].height))
1608             {
1609                 l = MIN(l, RECT_LEFT(monitor_area[i]));
1610                 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1611             }
1612         }
1613     } else {
1614         l = RECT_LEFT(monitor_area[screen_num_monitors]);
1615         t = RECT_TOP(monitor_area[screen_num_monitors]);
1616         r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1617         b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1618     }
1619
1620     for (d = 0; d < screen_num_desktops; ++d) {
1621         if (d != desktop && desktop != DESKTOP_ALL) continue;
1622
1623         for (i = 0; i < screen_num_monitors; ++i) {
1624             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1625
1626             for (it = struts_left; it; it = g_slist_next(it)) {
1627                 ObScreenStrut *s = it->data;
1628                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1629                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1630                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1631                     l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1632                                + s->strut->left);
1633             }
1634             for (it = struts_top; it; it = g_slist_next(it)) {
1635                 ObScreenStrut *s = it->data;
1636                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1637                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1638                     !STRUT_TOP_IGNORE(s->strut, us, search))
1639                     t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1640                                + s->strut->top);
1641             }
1642             for (it = struts_right; it; it = g_slist_next(it)) {
1643                 ObScreenStrut *s = it->data;
1644                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1645                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1646                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1647                     r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1648                                - s->strut->right);
1649             }
1650             for (it = struts_bottom; it; it = g_slist_next(it)) {
1651                 ObScreenStrut *s = it->data;
1652                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1653                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1654                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1655                     b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1656                                - s->strut->bottom);
1657             }
1658
1659             /* limit to this monitor */
1660             if (head == i) {
1661                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1662                 t = MAX(t, RECT_TOP(monitor_area[i]));
1663                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1664                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1665             }
1666         }
1667     }
1668
1669     a = g_slice_new(Rect);
1670     a->x = l;
1671     a->y = t;
1672     a->width = r - l + 1;
1673     a->height = b - t + 1;
1674     return a;
1675 }
1676
1677 typedef struct {
1678     Rect r;
1679     gboolean subtract;
1680 } RectArithmetic;
1681
1682 guint screen_find_monitor(const Rect *search)
1683 {
1684     guint i;
1685     guint mostpx_index = screen_num_monitors;
1686     glong mostpx = 0;
1687     guint closest_distance_index = screen_num_monitors;
1688     guint closest_distance = G_MAXUINT;
1689     GSList *counted = NULL;
1690
1691     /* we want to count the number of pixels search has on each monitor, but not
1692        double count.  so if a pixel is counted on monitor A then we should not
1693        count it again on monitor B. in the end we want to return the monitor
1694        that had the most pixels counted under this scheme.
1695
1696        this assumes that monitors earlier in the list are more desirable to be
1697        considered the search area's monitor.  we try the configured primary
1698        monitor first, so it gets the highest preference.
1699
1700        if we have counted an area A, then we want to subtract the intersection
1701        of A with the area on future monitors.
1702        but now consider if we count an area B that intersects A. we want to
1703        subtract the area B from that counted on future monitors, but not
1704        subtract the intersection of A and B twice! so we would add the
1705        intersection of A and B back, to account for it being subtracted both
1706        for A and B.
1707
1708        this is the idea behind the algorithm.  we always subtract the full area
1709        for monitor M intersected with the search area. we'll call that AREA.
1710        but then we go through the list |counted| and for each rectangle in
1711        the list that is being subtracted from future monitors, we insert a
1712        request to add back the intersection of the subtracted rect with AREA.
1713        vice versa for a rect in |counted| that is getting added back.
1714     */
1715
1716     if (config_primary_monitor_index < screen_num_monitors) {
1717         const Rect *monitor;
1718         Rect on_current_monitor;
1719         glong area;
1720
1721         monitor = screen_physical_area_monitor(config_primary_monitor_index);
1722
1723         if (RECT_INTERSECTS_RECT(*monitor, *search)) {
1724             RECT_SET_INTERSECTION(on_current_monitor, *monitor, *search);
1725             area = RECT_AREA(on_current_monitor);
1726
1727             if (area > mostpx) {
1728                 mostpx = area;
1729                 mostpx_index = config_primary_monitor_index;
1730             }
1731
1732             /* add the intersection rect on the current monitor to the
1733                counted list. that's easy for the first one, we just mark it for
1734                subtraction */
1735             {
1736                 RectArithmetic *ra = g_slice_new(RectArithmetic);
1737                 ra->r = on_current_monitor;
1738                 ra->subtract = TRUE;
1739                 counted = g_slist_prepend(counted, ra);
1740             }
1741         }
1742     }
1743
1744     for (i = 0; i < screen_num_monitors; ++i) {
1745         const Rect *monitor;
1746         Rect on_current_monitor;
1747         glong area;
1748         GSList *it;
1749
1750         monitor = screen_physical_area_monitor(i);
1751
1752         if (!RECT_INTERSECTS_RECT(*monitor, *search)) {
1753             /* If we don't intersect then find the distance between the search
1754                rect and the monitor. We'll use the closest monitor from this
1755                metric if none of the monitors intersect. */
1756             guint distance = rect_manhatten_distance(*monitor, *search);
1757
1758             if (distance < closest_distance) {
1759                 closest_distance = distance;
1760                 closest_distance_index = i;
1761             }
1762             continue;
1763         }
1764
1765         if (i == config_primary_monitor_index)
1766             continue;  /* already did this one */
1767
1768         RECT_SET_INTERSECTION(on_current_monitor, *monitor, *search);
1769         area = RECT_AREA(on_current_monitor);
1770
1771         /* remove pixels we already counted on any previous monitors. */
1772         for (it = counted; it; it = g_slist_next(it)) {
1773             RectArithmetic *ra = it->data;
1774             Rect intersection;
1775
1776             RECT_SET_INTERSECTION(intersection, ra->r, *search);
1777             if (ra->subtract) area -= RECT_AREA(intersection);
1778             else area += RECT_AREA(intersection);
1779         }
1780
1781         if (area > mostpx) {
1782             mostpx = area;
1783             mostpx_index = i;
1784         }
1785
1786         /* add the intersection rect on the current monitor I to the counted
1787            list.
1788            but now we need to compensate for every rectangle R already in the
1789            counted list, and add a new rect R' that is the intersection of
1790            R and I, but with the reverse subtraction/addition operation.
1791         */
1792         for (it = counted; it; it = g_slist_next(it)) {
1793             RectArithmetic *saved = it->data;
1794
1795             if (!RECT_INTERSECTS_RECT(saved->r, on_current_monitor))
1796                 continue;
1797             /* we are going to subtract our rect from future monitors, but
1798                part of it may already be being subtracted/added, so compensate
1799                to not double add/subtract. */
1800             RectArithmetic *reverse = g_slice_new(RectArithmetic);
1801             RECT_SET_INTERSECTION(reverse->r, saved->r, on_current_monitor);
1802             reverse->subtract = !saved->subtract;
1803             /* prepend so we can continue thru the list uninterupted */
1804             counted = g_slist_prepend(counted, reverse);
1805         }
1806         {
1807             RectArithmetic *ra = g_slice_new(RectArithmetic);
1808             ra->r = on_current_monitor;
1809             ra->subtract = TRUE;
1810             counted = g_slist_prepend(counted, ra);
1811         }
1812     }
1813
1814     while (counted) {
1815         g_slice_free(RectArithmetic, counted->data);
1816         counted = g_slist_delete_link(counted, counted);
1817     }
1818
1819     if (mostpx_index < screen_num_monitors)
1820         return mostpx_index;
1821
1822     g_assert(closest_distance_index < screen_num_monitors);
1823     return closest_distance_index;
1824 }
1825
1826 const Rect* screen_physical_area_all_monitors(void)
1827 {
1828     return screen_physical_area_monitor(screen_num_monitors);
1829 }
1830
1831 const Rect* screen_physical_area_monitor(guint head)
1832 {
1833     g_assert(head <= screen_num_monitors);
1834
1835     return &monitor_area[head];
1836 }
1837
1838 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1839 {
1840     g_assert(head <= screen_num_monitors);
1841     g_assert(search);
1842     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1843 }
1844
1845 guint screen_monitor_active(void)
1846 {
1847     if (moveresize_client)
1848         return client_monitor(moveresize_client);
1849     else if (focus_client)
1850         return client_monitor(focus_client);
1851     else
1852         return screen_monitor_pointer();
1853 }
1854
1855 const Rect* screen_physical_area_active(void)
1856 {
1857     return screen_physical_area_monitor(screen_monitor_active());
1858 }
1859
1860 guint screen_monitor_primary(gboolean fixed)
1861 {
1862     if (config_primary_monitor_index > 0) {
1863         if (config_primary_monitor_index-1 < screen_num_monitors)
1864             return config_primary_monitor_index - 1;
1865         else
1866             return 0;
1867     }
1868     else if (fixed)
1869         return 0;
1870     else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1871         return screen_monitor_active();
1872     else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1873         return screen_monitor_pointer();
1874 }
1875
1876 const Rect* screen_physical_area_primary(gboolean fixed)
1877 {
1878     return screen_physical_area_monitor(screen_monitor_primary(fixed));
1879 }
1880
1881 void screen_set_root_cursor(void)
1882 {
1883     if (sn_app_starting())
1884         XDefineCursor(obt_display, obt_root(ob_screen),
1885                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1886     else
1887         XDefineCursor(obt_display, obt_root(ob_screen),
1888                       ob_cursor(OB_CURSOR_POINTER));
1889 }
1890
1891 guint screen_find_monitor_point(guint x, guint y)
1892 {
1893     Rect mon;
1894     RECT_SET(mon, x, y, 1, 1);
1895     return screen_find_monitor(&mon);
1896 }
1897
1898 guint screen_monitor_pointer()
1899 {
1900     gint x, y;
1901     if (!screen_pointer_pos(&x, &y))
1902         x = y = 0;
1903     return screen_find_monitor_point(x, y);
1904 }
1905
1906 gboolean screen_pointer_pos(gint *x, gint *y)
1907 {
1908     Window w;
1909     gint i;
1910     guint u;
1911     gboolean ret;
1912
1913     ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1914                           &w, &w, x, y, &i, &i, &u);
1915     if (!ret) {
1916         for (i = 0; i < ScreenCount(obt_display); ++i)
1917             if (i != ob_screen)
1918                 if (XQueryPointer(obt_display, obt_root(i),
1919                                   &w, &w, x, y, &i, &i, &u))
1920                     break;
1921     }
1922     return ret;
1923 }
1924
1925 gboolean screen_compare_desktops(guint a, guint b)
1926 {
1927     if (a == DESKTOP_ALL)
1928         a = screen_desktop;
1929     if (b == DESKTOP_ALL)
1930         b = screen_desktop;
1931     return a == b;
1932 }
1933
1934 void screen_apply_gravity_point(gint *x, gint *y, gint width, gint height,
1935                                 const GravityPoint *position, const Rect *area)
1936 {
1937     if (position->x.center)
1938         *x = area->width / 2 - width / 2;
1939     else {
1940         *x = position->x.pos;
1941         if (position->x.denom)
1942             *x = (*x * area->width) / position->x.denom;
1943         if (position->x.opposite)
1944             *x = area->width - width - *x;
1945     }
1946
1947     if (position->y.center)
1948         *y = area->height / 2 - height / 2;
1949     else {
1950         *y = position->y.pos;
1951         if (position->y.denom)
1952             *y = (*y * area->height) / position->y.denom;
1953         if (position->y.opposite)
1954             *y = area->height - height - *y;
1955     }
1956
1957     *x += area->x;
1958     *y += area->y;
1959 }