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();
  56 static void     screen_tell_ksplash();
  57 static void     screen_fallback_focus();
  58
  59 guint    screen_num_desktops;
  60 guint    screen_num_monitors;
  61 guint    screen_desktop;
  62 guint    screen_last_desktop;
  63 Size     screen_physical_size;
  64 gboolean screen_showing_desktop;
  65 ObDesktopLayout screen_desktop_layout;
  66 gchar  **screen_desktop_names;
  67 Window   screen_support_win;
  68 Time     screen_desktop_user_time = CurrentTime;
  69
  70 /*! An array of desktops, holding array of areas per monitor */
  71 static Rect  *monitor_area = NULL;
  72 /*! An array of desktops, holding an array of struts */
  73 static GSList *struts_top = NULL;
  74 static GSList *struts_left = NULL;
  75 static GSList *struts_right = NULL;
  76 static GSList *struts_bottom = NULL;
  77
  78 static ObPagerPopup *desktop_popup;
  79
  80 static gboolean replace_wm()
  81 {
  82     gchar *wm_sn;
  83     Atom wm_sn_atom;
  84     Window current_wm_sn_owner;
  85     Time timestamp;
  86
  87     wm_sn = g_strdup_printf("WM_S%d", ob_screen);
  88     wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
  89     g_free(wm_sn);
  90
  91     current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
  92     if (current_wm_sn_owner == screen_support_win)
  93         current_wm_sn_owner = None;
  94     if (current_wm_sn_owner) {
  95         if (!ob_replace_wm) {
  96             g_message(_("A window manager is already running on screen %d"),
  97                       ob_screen);
  98             return FALSE;
  99         }
 100         xerror_set_ignore(TRUE);
 101         xerror_occured = FALSE;
 102
 103         /* We want to find out when the current selection owner dies */
 104         XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
 105         XSync(ob_display, FALSE);
 106
 107         xerror_set_ignore(FALSE);
 108         if (xerror_occured)
 109             current_wm_sn_owner = None;
 110     }
 111
 112     timestamp = event_get_server_time();
 113
 114     XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
 115                        timestamp);
 116
 117     if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
 118         g_message(_("Could not acquire window manager selection on screen %d"),
 119                   ob_screen);
 120         return FALSE;
 121     }
 122
 123     /* Wait for old window manager to go away */
 124     if (current_wm_sn_owner) {
 125       XEvent event;
 126       gulong wait = 0;
 127       const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
 128
 129       while (wait < timeout) {
 130           if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
 131                                 StructureNotifyMask, &event) &&
 132               event.type == DestroyNotify)
 133               break;
 134           g_usleep(G_USEC_PER_SEC / 10);
 135           wait += G_USEC_PER_SEC / 10;
 136       }
 137
 138       if (wait >= timeout) {
 139           g_message(_("The WM on screen %d is not exiting"), ob_screen);
 140           return FALSE;
 141       }
 142     }
 143
 144     /* Send client message indicating that we are now the WM */
 145     prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
 146                  timestamp, wm_sn_atom, screen_support_win, 0,
 147                  SubstructureNotifyMask);
 148
 149     return TRUE;
 150 }
 151
 152 gboolean screen_annex()
 153 {
 154     XSetWindowAttributes attrib;
 155     pid_t pid;
 156     gint i, num_support;
 157     Atom *prop_atoms_start, *wm_supported_pos;
 158     gulong *supported;
 159
 160     /* create the netwm support window */
 161     attrib.override_redirect = TRUE;
 162     attrib.event_mask = PropertyChangeMask;
 163     screen_support_win = XCreateWindow(ob_display,
 164                                        RootWindow(ob_display, ob_screen),
 165                                        -100, -100, 1, 1, 0,
 166                                        CopyFromParent, InputOutput,
 167                                        CopyFromParent,
 168                                        CWEventMask | CWOverrideRedirect,
 169                                        &attrib);
 170     XMapWindow(ob_display, screen_support_win);
 171     XLowerWindow(ob_display, screen_support_win);
 172
 173     if (!replace_wm()) {
 174         XDestroyWindow(ob_display, screen_support_win);
 175         return FALSE;
 176     }
 177
 178     xerror_set_ignore(TRUE);
 179     xerror_occured = FALSE;
 180     XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
 181                  ROOT_EVENTMASK);
 182     xerror_set_ignore(FALSE);
 183     if (xerror_occured) {
 184         g_message(_("A window manager is already running on screen %d"),
 185                   ob_screen);
 186
 187         XDestroyWindow(ob_display, screen_support_win);
 188         return FALSE;
 189     }
 190
 191     screen_set_root_cursor();
 192
 193     /* set the OPENBOX_PID hint */
 194     pid = getpid();
 195     PROP_SET32(RootWindow(ob_display, ob_screen),
 196                openbox_pid, cardinal, pid);
 197
 198     /* set supporting window */
 199     PROP_SET32(RootWindow(ob_display, ob_screen),
 200                net_supporting_wm_check, window, screen_support_win);
 201
 202     /* set properties on the supporting window */
 203     PROP_SETS(screen_support_win, net_wm_name, "Openbox");
 204     PROP_SET32(screen_support_win, net_supporting_wm_check,
 205                window, screen_support_win);
 206
 207     /* set the _NET_SUPPORTED_ATOMS hint */
 208
 209     /* this is all the atoms after net_supported in the prop_atoms struct */
 210     prop_atoms_start = (Atom*)&prop_atoms;
 211     wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
 212     num_support = sizeof(prop_atoms) / sizeof(Atom) -
 213         (wm_supported_pos - prop_atoms_start) - 1;
 214     i = 0;
 215     supported = g_new(gulong, num_support);
 216     supported[i++] = prop_atoms.net_supporting_wm_check;
 217     supported[i++] = prop_atoms.net_wm_full_placement;
 218     supported[i++] = prop_atoms.net_current_desktop;
 219     supported[i++] = prop_atoms.net_number_of_desktops;
 220     supported[i++] = prop_atoms.net_desktop_geometry;
 221     supported[i++] = prop_atoms.net_desktop_viewport;
 222     supported[i++] = prop_atoms.net_active_window;
 223     supported[i++] = prop_atoms.net_workarea;
 224     supported[i++] = prop_atoms.net_client_list;
 225     supported[i++] = prop_atoms.net_client_list_stacking;
 226     supported[i++] = prop_atoms.net_desktop_names;
 227     supported[i++] = prop_atoms.net_close_window;
 228     supported[i++] = prop_atoms.net_desktop_layout;
 229     supported[i++] = prop_atoms.net_showing_desktop;
 230     supported[i++] = prop_atoms.net_wm_name;
 231     supported[i++] = prop_atoms.net_wm_visible_name;
 232     supported[i++] = prop_atoms.net_wm_icon_name;
 233     supported[i++] = prop_atoms.net_wm_visible_icon_name;
 234     supported[i++] = prop_atoms.net_wm_desktop;
 235     supported[i++] = prop_atoms.net_wm_strut;
 236     supported[i++] = prop_atoms.net_wm_strut_partial;
 237     supported[i++] = prop_atoms.net_wm_icon;
 238     supported[i++] = prop_atoms.net_wm_icon_geometry;
 239     supported[i++] = prop_atoms.net_wm_window_type;
 240     supported[i++] = prop_atoms.net_wm_window_type_desktop;
 241     supported[i++] = prop_atoms.net_wm_window_type_dock;
 242     supported[i++] = prop_atoms.net_wm_window_type_toolbar;
 243     supported[i++] = prop_atoms.net_wm_window_type_menu;
 244     supported[i++] = prop_atoms.net_wm_window_type_utility;
 245     supported[i++] = prop_atoms.net_wm_window_type_splash;
 246     supported[i++] = prop_atoms.net_wm_window_type_dialog;
 247     supported[i++] = prop_atoms.net_wm_window_type_normal;
 248     supported[i++] = prop_atoms.net_wm_allowed_actions;
 249     supported[i++] = prop_atoms.net_wm_action_move;
 250     supported[i++] = prop_atoms.net_wm_action_resize;
 251     supported[i++] = prop_atoms.net_wm_action_minimize;
 252     supported[i++] = prop_atoms.net_wm_action_shade;
 253     supported[i++] = prop_atoms.net_wm_action_maximize_horz;
 254     supported[i++] = prop_atoms.net_wm_action_maximize_vert;
 255     supported[i++] = prop_atoms.net_wm_action_fullscreen;
 256     supported[i++] = prop_atoms.net_wm_action_change_desktop;
 257     supported[i++] = prop_atoms.net_wm_action_close;
 258     supported[i++] = prop_atoms.net_wm_action_above;
 259     supported[i++] = prop_atoms.net_wm_action_below;
 260     supported[i++] = prop_atoms.net_wm_state;
 261     supported[i++] = prop_atoms.net_wm_state_modal;
 262     supported[i++] = prop_atoms.net_wm_state_maximized_vert;
 263     supported[i++] = prop_atoms.net_wm_state_maximized_horz;
 264     supported[i++] = prop_atoms.net_wm_state_shaded;
 265     supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
 266     supported[i++] = prop_atoms.net_wm_state_skip_pager;
 267     supported[i++] = prop_atoms.net_wm_state_hidden;
 268     supported[i++] = prop_atoms.net_wm_state_fullscreen;
 269     supported[i++] = prop_atoms.net_wm_state_above;
 270     supported[i++] = prop_atoms.net_wm_state_below;
 271     supported[i++] = prop_atoms.net_wm_state_demands_attention;
 272     supported[i++] = prop_atoms.net_moveresize_window;
 273     supported[i++] = prop_atoms.net_wm_moveresize;
 274     supported[i++] = prop_atoms.net_wm_user_time;
 275 /*
 276     supported[i++] = prop_atoms.net_wm_user_time_window;
 277 */
 278     supported[i++] = prop_atoms.net_frame_extents;
 279     supported[i++] = prop_atoms.net_request_frame_extents;
 280     supported[i++] = prop_atoms.net_restack_window;
 281     supported[i++] = prop_atoms.net_startup_id;
 282 #ifdef SYNC
 283     supported[i++] = prop_atoms.net_wm_sync_request;
 284     supported[i++] = prop_atoms.net_wm_sync_request_counter;
 285 #endif
 286
 287     supported[i++] = prop_atoms.kde_wm_change_state;
 288     supported[i++] = prop_atoms.kde_net_wm_frame_strut;
 289     supported[i++] = prop_atoms.kde_net_wm_window_type_override;
 290
 291     supported[i++] = prop_atoms.ob_wm_action_undecorate;
 292     supported[i++] = prop_atoms.ob_wm_state_undecorated;
 293     supported[i++] = prop_atoms.openbox_pid;
 294     supported[i++] = prop_atoms.ob_theme;
 295     supported[i++] = prop_atoms.ob_control;
 296     g_assert(i == num_support);
 297
 298     PROP_SETA32(RootWindow(ob_display, ob_screen),
 299                 net_supported, atom, supported, num_support);
 300     g_free(supported);
 301
 302     screen_tell_ksplash();
 303
 304     return TRUE;
 305 }
 306
 307 static void screen_tell_ksplash()
 308 {
 309     XEvent e;
 310     char **argv;
 311
 312     argv = g_new(gchar*, 6);
 313     argv[0] = g_strdup("dcop");
 314     argv[1] = g_strdup("ksplash");
 315     argv[2] = g_strdup("ksplash");
 316     argv[3] = g_strdup("upAndRunning(QString)");
 317     argv[4] = g_strdup("wm started");
 318     argv[5] = NULL;
 319
 320     /* tell ksplash through the dcop server command line interface */
 321     g_spawn_async(NULL, argv, NULL,
 322                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
 323                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
 324                   NULL, NULL, NULL, NULL);
 325     g_strfreev(argv);
 326
 327     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
 328        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
 329        something. oh well. */
 330     e.xclient.type = ClientMessage;
 331     e.xclient.display = ob_display;
 332     e.xclient.window = RootWindow(ob_display, ob_screen);
 333     e.xclient.message_type =
 334         XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False );
 335     e.xclient.format = 8;
 336     strcpy(e.xclient.data.b, "wm started");
 337     XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
 338                False, SubstructureNotifyMask, &e );
 339 }
 340
 341 void screen_startup(gboolean reconfig)
 342 {
 343     gchar **names = NULL;
 344     guint32 d;
 345     gboolean namesexist = FALSE;
 346
 347     desktop_popup = pager_popup_new(FALSE);
 348     pager_popup_height(desktop_popup, POPUP_HEIGHT);
 349
 350     if (reconfig) {
 351         /* update the pager popup's width */
 352         pager_popup_text_width_to_strings(desktop_popup,
 353                                           screen_desktop_names,
 354                                           screen_num_desktops);
 355         return;
 356     }
 357
 358     /* get the initial size */
 359     screen_resize();
 360
 361     /* have names already been set for the desktops? */
 362     if (PROP_GETSS(RootWindow(ob_display, ob_screen),
 363                    net_desktop_names, utf8, &names))
 364     {
 365         g_strfreev(names);
 366         namesexist = TRUE;
 367     }
 368
 369     /* if names don't exist and we have session names, set those.
 370        do this stuff BEFORE setting the number of desktops, because that
 371        will create default names for them
 372     */
 373     if (!namesexist && session_desktop_names != NULL) {
 374         guint i, numnames;
 375         GSList *it;
 376
 377         /* get the desktop names */
 378         numnames = g_slist_length(session_desktop_names);
 379         names = g_new(gchar*, numnames + 1);
 380         names[numnames] = NULL;
 381         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
 382             names[i] = g_strdup(it->data);
 383
 384         /* set the root window property */
 385         PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
 386
 387         g_strfreev(names);
 388     }
 389
 390     /* set the number of desktops, if it's not already set.
 391
 392        this will also set the default names from the config file up for
 393        desktops that don't have names yet */
 394     screen_num_desktops = 0;
 395     if (PROP_GET32(RootWindow(ob_display, ob_screen),
 396                    net_number_of_desktops, cardinal, &d))
 397         screen_set_num_desktops(d);
 398     /* restore from session if possible */
 399     else if (session_num_desktops)
 400         screen_set_num_desktops(session_num_desktops);
 401     else
 402         screen_set_num_desktops(config_desktops_num);
 403
 404     screen_desktop = screen_num_desktops;  /* something invalid */
 405     /* start on the current desktop when a wm was already running */
 406     if (PROP_GET32(RootWindow(ob_display, ob_screen),
 407                    net_current_desktop, cardinal, &d) &&
 408         d < screen_num_desktops)
 409     {
 410         screen_set_desktop(d, FALSE);
 411     } else if (session_desktop >= 0)
 412         screen_set_desktop(MIN((guint)session_desktop,
 413                                screen_num_desktops), FALSE);
 414     else
 415         screen_set_desktop(MIN(config_screen_firstdesk,
 416                                screen_num_desktops) - 1, FALSE);
 417     screen_last_desktop = screen_desktop;
 418
 419     /* don't start in showing-desktop mode */
 420     screen_showing_desktop = FALSE;
 421     PROP_SET32(RootWindow(ob_display, ob_screen),
 422                net_showing_desktop, cardinal, screen_showing_desktop);
 423
 424     if (session_desktop_layout_present &&
 425         screen_validate_layout(&session_desktop_layout))
 426     {
 427         screen_desktop_layout = session_desktop_layout;
 428     }
 429     else
 430         screen_update_layout();
 431 }
 432
 433 void screen_shutdown(gboolean reconfig)
 434 {
 435     pager_popup_free(desktop_popup);
 436
 437     if (reconfig)
 438         return;
 439
 440     XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
 441                  NoEventMask);
 442
 443     /* we're not running here no more! */
 444     PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
 445     /* not without us */
 446     PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
 447     /* don't keep this mode */
 448     PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
 449
 450     XDestroyWindow(ob_display, screen_support_win);
 451
 452     g_strfreev(screen_desktop_names);
 453     screen_desktop_names = NULL;
 454 }
 455
 456 void screen_resize()
 457 {
 458     static gint oldw = 0, oldh = 0;
 459     gint w, h;
 460     GList *it;
 461     gulong geometry[2];
 462
 463     w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 464     h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 465
 466     if (w == oldw && h == oldh) return;
 467
 468     oldw = w; oldh = h;
 469
 470     /* Set the _NET_DESKTOP_GEOMETRY hint */
 471     screen_physical_size.width = geometry[0] = w;
 472     screen_physical_size.height = geometry[1] = h;
 473     PROP_SETA32(RootWindow(ob_display, ob_screen),
 474                 net_desktop_geometry, cardinal, geometry, 2);
 475
 476     if (ob_state() == OB_STATE_STARTING)
 477         return;
 478
 479     screen_update_areas();
 480     dock_configure();
 481
 482     for (it = client_list; it; it = g_list_next(it))
 483         client_move_onscreen(it->data, FALSE);
 484 }
 485
 486 void screen_set_num_desktops(guint num)
 487 {
 488     guint old;
 489     gulong *viewport;
 490     GList *it, *stacking_copy;
 491
 492     g_assert(num > 0);
 493
 494     if (screen_num_desktops == num) return;
 495
 496     old = screen_num_desktops;
 497     screen_num_desktops = num;
 498     PROP_SET32(RootWindow(ob_display, ob_screen),
 499                net_number_of_desktops, cardinal, num);
 500
 501     /* set the viewport hint */
 502     viewport = g_new0(gulong, num * 2);
 503     PROP_SETA32(RootWindow(ob_display, ob_screen),
 504                 net_desktop_viewport, cardinal, viewport, num * 2);
 505     g_free(viewport);
 506
 507     /* the number of rows/columns will differ */
 508     screen_update_layout();
 509
 510     /* move windows on desktops that will no longer exist!
 511        make a copy of the list cuz we're changing it */
 512     stacking_copy = g_list_copy(stacking_list);
 513     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 514         if (WINDOW_IS_CLIENT(it->data)) {
 515             ObClient *c = it->data;
 516             if (c->desktop != DESKTOP_ALL && c->desktop >= num)
 517                 client_set_desktop(c, num - 1, FALSE, TRUE);
 518             /* raise all the windows that are on the current desktop which
 519                is being merged */
 520             else if (screen_desktop == num - 1 &&
 521                      (c->desktop == DESKTOP_ALL ||
 522                       c->desktop == screen_desktop))
 523                 stacking_raise(CLIENT_AS_WINDOW(c));
 524         }
 525     }
 526
 527     /* change our struts/area to match (after moving windows) */
 528     screen_update_areas();
 529
 530     /* may be some unnamed desktops that we need to fill in with names
 531      (after updating the areas so the popup can resize) */
 532     screen_update_desktop_names();
 533
 534     /* change our desktop if we're on one that no longer exists! */
 535     if (screen_desktop >= screen_num_desktops)
 536         screen_set_desktop(num - 1, TRUE);
 537 }
 538
 539 static void screen_fallback_focus()
 540 {
 541     ObClient *c;
 542     gboolean allow_omni;
 543
 544     /* only allow omnipresent windows to get focus on desktop change if
 545        an omnipresent window is already focused (it'll keep focus probably, but
 546        maybe not depending on mouse-focus options) */
 547     allow_omni = focus_client && (client_normal(focus_client) &&
 548                                   focus_client->desktop == DESKTOP_ALL);
 549
 550     /* the client moved there already so don't move focus. prevent flicker
 551        on sendtodesktop + follow */
 552     if (focus_client && focus_client->desktop == screen_desktop)
 553         return;
 554
 555     /* have to try focus here because when you leave an empty desktop
 556        there is no focus out to watch for. also, we have different rules
 557        here. we always allow it to look under the mouse pointer if
 558        config_focus_last is FALSE
 559
 560        do this before hiding the windows so if helper windows are coming
 561        with us, they don't get hidden
 562     */
 563     if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
 564                             !allow_omni)))
 565     {
 566         /* only do the flicker reducing stuff ahead of time if we are going
 567            to call xsetinputfocus on the window ourselves. otherwise there is
 568            no guarantee the window will actually take focus.. */
 569         if (c->can_focus) {
 570             /* reduce flicker by hiliting now rather than waiting for the
 571                server FocusIn event */
 572             frame_adjust_focus(c->frame, TRUE);
 573             /* do this here so that if you switch desktops to a window with
 574                helper windows then the helper windows won't flash */
 575             client_bring_helper_windows(c);
 576         }
 577     }
 578 }
 579
 580 void screen_set_desktop(guint num, gboolean dofocus)
 581 {
 582     GList *it;
 583     guint old;
 584     gulong ignore_start;
 585
 586     g_assert(num < screen_num_desktops);
 587
 588     old = screen_desktop;
 589     screen_desktop = num;
 590
 591     if (old == num) return;
 592
 593     PROP_SET32(RootWindow(ob_display, ob_screen),
 594                net_current_desktop, cardinal, num);
 595
 596     screen_last_desktop = old;
 597
 598     ob_debug("Moving to desktop %d\n", num+1);
 599
 600     /* ignore enter events caused by the move */
 601     ignore_start = event_start_ignore_all_enters();
 602
 603     if (moveresize_client)
 604         client_set_desktop(moveresize_client, num, TRUE, FALSE);
 605
 606     /* show windows before hiding the rest to lessen the enter/leave events */
 607
 608     /* show windows from top to bottom */
 609     for (it = stacking_list; it; it = g_list_next(it)) {
 610         if (WINDOW_IS_CLIENT(it->data)) {
 611             ObClient *c = it->data;
 612             client_show(c);
 613         }
 614     }
 615
 616     if (dofocus) screen_fallback_focus();
 617
 618     /* hide windows from bottom to top */
 619     for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
 620         if (WINDOW_IS_CLIENT(it->data)) {
 621             ObClient *c = it->data;
 622             client_hide(c);
 623         }
 624     }
 625
 626     event_end_ignore_all_enters(ignore_start);
 627
 628     if (event_curtime != CurrentTime)
 629         screen_desktop_user_time = event_curtime;
 630
 631     if (ob_state() == OB_STATE_RUNNING)
 632         screen_show_desktop_popup(screen_desktop);
 633 }
 634
 635 void screen_add_desktop(gboolean current)
 636 {
 637     gulong ignore_start;
 638
 639     /* ignore enter events caused by this */
 640     ignore_start = event_start_ignore_all_enters();
 641
 642     screen_set_num_desktops(screen_num_desktops+1);
 643
 644     /* move all the clients over */
 645     if (current) {
 646         GList *it;
 647
 648         for (it = client_list; it; it = g_list_next(it)) {
 649             ObClient *c = it->data;
 650             if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
 651                 /* don't move direct children, they'll be moved with their
 652                    parent - which will have to be on the same desktop */
 653                 !client_direct_parent(c))
 654             {
 655                 ob_debug("moving window %s\n", c->title);
 656                 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
 657             }
 658         }
 659     }
 660
 661     event_end_ignore_all_enters(ignore_start);
 662 }
 663
 664 void screen_remove_desktop(gboolean current)
 665 {
 666     guint rmdesktop, movedesktop;
 667     GList *it, *stacking_copy;
 668     gulong ignore_start;
 669
 670     if (screen_num_desktops <= 1) return;
 671
 672     /* ignore enter events caused by this */
 673     ignore_start = event_start_ignore_all_enters();
 674
 675     /* what desktop are we removing and moving to? */
 676     if (current)
 677         rmdesktop = screen_desktop;
 678     else
 679         rmdesktop = screen_num_desktops - 1;
 680     if (rmdesktop < screen_num_desktops - 1)
 681         movedesktop = rmdesktop + 1;
 682     else
 683         movedesktop = rmdesktop;
 684
 685     /* make a copy of the list cuz we're changing it */
 686     stacking_copy = g_list_copy(stacking_list);
 687     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
 688         if (WINDOW_IS_CLIENT(it->data)) {
 689             ObClient *c = it->data;
 690             guint d = c->desktop;
 691             if (d != DESKTOP_ALL && d >= movedesktop &&
 692                 /* don't move direct children, they'll be moved with their
 693                    parent - which will have to be on the same desktop */
 694                 !client_direct_parent(c))
 695             {
 696                 ob_debug("moving window %s\n", c->title);
 697                 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
 698             }
 699             /* raise all the windows that are on the current desktop which
 700                is being merged */
 701             if ((screen_desktop == rmdesktop - 1 ||
 702                  screen_desktop == rmdesktop) &&
 703                 (d == DESKTOP_ALL || d == screen_desktop))
 704             {
 705                 stacking_raise(CLIENT_AS_WINDOW(c));
 706                 ob_debug("raising window %s\n", c->title);
 707             }
 708         }
 709     }
 710
 711     /* fallback focus like we're changing desktops */
 712     if (screen_desktop < screen_num_desktops - 1) {
 713         screen_fallback_focus();
 714         ob_debug("fake desktop change\n");
 715     }
 716
 717     screen_set_num_desktops(screen_num_desktops-1);
 718
 719     event_end_ignore_all_enters(ignore_start);
 720 }
 721
 722 static void get_row_col(guint d, guint *r, guint *c)
 723 {
 724     switch (screen_desktop_layout.orientation) {
 725     case OB_ORIENTATION_HORZ:
 726         switch (screen_desktop_layout.start_corner) {
 727         case OB_CORNER_TOPLEFT:
 728             *r = d / screen_desktop_layout.columns;
 729             *c = d % screen_desktop_layout.columns;
 730             break;
 731         case OB_CORNER_BOTTOMLEFT:
 732             *r = screen_desktop_layout.rows - 1 -
 733                 d / screen_desktop_layout.columns;
 734             *c = d % screen_desktop_layout.columns;
 735             break;
 736         case OB_CORNER_TOPRIGHT:
 737             *r = d / screen_desktop_layout.columns;
 738             *c = screen_desktop_layout.columns - 1 -
 739                 d % screen_desktop_layout.columns;
 740             break;
 741         case OB_CORNER_BOTTOMRIGHT:
 742             *r = screen_desktop_layout.rows - 1 -
 743                 d / screen_desktop_layout.columns;
 744             *c = screen_desktop_layout.columns - 1 -
 745                 d % screen_desktop_layout.columns;
 746             break;
 747         }
 748         break;
 749     case OB_ORIENTATION_VERT:
 750         switch (screen_desktop_layout.start_corner) {
 751         case OB_CORNER_TOPLEFT:
 752             *r = d % screen_desktop_layout.rows;
 753             *c = d / screen_desktop_layout.rows;
 754             break;
 755         case OB_CORNER_BOTTOMLEFT:
 756             *r = screen_desktop_layout.rows - 1 -
 757                 d % screen_desktop_layout.rows;
 758             *c = d / screen_desktop_layout.rows;
 759             break;
 760         case OB_CORNER_TOPRIGHT:
 761             *r = d % screen_desktop_layout.rows;
 762             *c = screen_desktop_layout.columns - 1 -
 763                 d / screen_desktop_layout.rows;
 764             break;
 765         case OB_CORNER_BOTTOMRIGHT:
 766             *r = screen_desktop_layout.rows - 1 -
 767                 d % screen_desktop_layout.rows;
 768             *c = screen_desktop_layout.columns - 1 -
 769                 d / screen_desktop_layout.rows;
 770             break;
 771         }
 772         break;
 773     }
 774 }
 775
 776 static guint translate_row_col(guint r, guint c)
 777 {
 778     switch (screen_desktop_layout.orientation) {
 779     case OB_ORIENTATION_HORZ:
 780         switch (screen_desktop_layout.start_corner) {
 781         case OB_CORNER_TOPLEFT:
 782             return r % screen_desktop_layout.rows *
 783                 screen_desktop_layout.columns +
 784                 c % screen_desktop_layout.columns;
 785         case OB_CORNER_BOTTOMLEFT:
 786             return (screen_desktop_layout.rows - 1 -
 787                     r % screen_desktop_layout.rows) *
 788                 screen_desktop_layout.columns +
 789                 c % screen_desktop_layout.columns;
 790         case OB_CORNER_TOPRIGHT:
 791             return r % screen_desktop_layout.rows *
 792                 screen_desktop_layout.columns +
 793                 (screen_desktop_layout.columns - 1 -
 794                  c % screen_desktop_layout.columns);
 795         case OB_CORNER_BOTTOMRIGHT:
 796             return (screen_desktop_layout.rows - 1 -
 797                     r % screen_desktop_layout.rows) *
 798                 screen_desktop_layout.columns +
 799                 (screen_desktop_layout.columns - 1 -
 800                  c % screen_desktop_layout.columns);
 801         }
 802     case OB_ORIENTATION_VERT:
 803         switch (screen_desktop_layout.start_corner) {
 804         case OB_CORNER_TOPLEFT:
 805             return c % screen_desktop_layout.columns *
 806                 screen_desktop_layout.rows +
 807                 r % screen_desktop_layout.rows;
 808         case OB_CORNER_BOTTOMLEFT:
 809             return c % screen_desktop_layout.columns *
 810                 screen_desktop_layout.rows +
 811                 (screen_desktop_layout.rows - 1 -
 812                  r % screen_desktop_layout.rows);
 813         case OB_CORNER_TOPRIGHT:
 814             return (screen_desktop_layout.columns - 1 -
 815                     c % screen_desktop_layout.columns) *
 816                 screen_desktop_layout.rows +
 817                 r % screen_desktop_layout.rows;
 818         case OB_CORNER_BOTTOMRIGHT:
 819             return (screen_desktop_layout.columns - 1 -
 820                     c % screen_desktop_layout.columns) *
 821                 screen_desktop_layout.rows +
 822                 (screen_desktop_layout.rows - 1 -
 823                  r % screen_desktop_layout.rows);
 824         }
 825     }
 826     g_assert_not_reached();
 827     return 0;
 828 }
 829
 830 static gboolean hide_desktop_popup_func(gpointer data)
 831 {
 832     pager_popup_hide(desktop_popup);
 833     return FALSE; /* don't repeat */
 834 }
 835
 836 void screen_show_desktop_popup(guint d)
 837 {
 838     Rect *a;
 839
 840     /* 0 means don't show the popup */
 841     if (!config_desktop_popup_time) return;
 842
 843     a = screen_physical_area_active();
 844     pager_popup_position(desktop_popup, CenterGravity,
 845                          a->x + a->width / 2, a->y + a->height / 2);
 846     pager_popup_icon_size_multiplier(desktop_popup,
 847                                      (screen_desktop_layout.columns /
 848                                       screen_desktop_layout.rows) / 2,
 849                                      (screen_desktop_layout.rows/
 850                                       screen_desktop_layout.columns) / 2);
 851     pager_popup_max_width(desktop_popup,
 852                           MAX(a->width/3, POPUP_WIDTH));
 853     pager_popup_show(desktop_popup, screen_desktop_names[d], d);
 854
 855     ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 856     ob_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
 857                              hide_desktop_popup_func, NULL, NULL, NULL);
 858     g_free(a);
 859 }
 860
 861 guint screen_find_desktop(guint from, ObDirection dir,
 862                           gboolean wrap, gboolean linear)
 863 {
 864     guint r, c;
 865     guint d;
 866
 867     d = from;
 868     get_row_col(d, &r, &c);
 869     if (linear) {
 870         switch (dir) {
 871         case OB_DIRECTION_EAST:
 872             if (d < screen_num_desktops - 1)
 873                 ++d;
 874             else if (wrap)
 875                 d = 0;
 876             else
 877                 return from;
 878             break;
 879         case OB_DIRECTION_WEST:
 880             if (d > 0)
 881                 --d;
 882             else if (wrap)
 883                 d = screen_num_desktops - 1;
 884             else
 885                 return from;
 886             break;
 887         default:
 888             g_assert_not_reached();
 889             return from;
 890         }
 891     } else {
 892         switch (dir) {
 893         case OB_DIRECTION_EAST:
 894             ++c;
 895             if (c >= screen_desktop_layout.columns) {
 896                 if (wrap)
 897                     c = 0;
 898                 else
 899                     return from;
 900             }
 901             d = translate_row_col(r, c);
 902             if (d >= screen_num_desktops) {
 903                 if (wrap)
 904                     ++c;
 905                 else
 906                     return from;
 907             }
 908             break;
 909         case OB_DIRECTION_WEST:
 910             --c;
 911             if (c >= screen_desktop_layout.columns) {
 912                 if (wrap)
 913                     c = screen_desktop_layout.columns - 1;
 914                 else
 915                     return from;
 916             }
 917             d = translate_row_col(r, c);
 918             if (d >= screen_num_desktops) {
 919                 if (wrap)
 920                     --c;
 921                 else
 922                     return from;
 923             }
 924             break;
 925         case OB_DIRECTION_SOUTH:
 926             ++r;
 927             if (r >= screen_desktop_layout.rows) {
 928                 if (wrap)
 929                     r = 0;
 930                 else
 931                     return from;
 932             }
 933             d = translate_row_col(r, c);
 934             if (d >= screen_num_desktops) {
 935                 if (wrap)
 936                     ++r;
 937                 else
 938                     return from;
 939             }
 940             break;
 941         case OB_DIRECTION_NORTH:
 942             --r;
 943             if (r >= screen_desktop_layout.rows) {
 944                 if (wrap)
 945                     r = screen_desktop_layout.rows - 1;
 946                 else
 947                     return from;
 948             }
 949             d = translate_row_col(r, c);
 950             if (d >= screen_num_desktops) {
 951                 if (wrap)
 952                     --r;
 953                 else
 954                     return from;
 955             }
 956             break;
 957         default:
 958             g_assert_not_reached();
 959             return from;
 960         }
 961
 962         d = translate_row_col(r, c);
 963     }
 964     return d;
 965 }
 966
 967 static gboolean screen_validate_layout(ObDesktopLayout *l)
 968 {
 969     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
 970         return FALSE;
 971
 972     /* fill in a zero rows/columns */
 973     if (l->columns == 0) {
 974         l->columns = screen_num_desktops / l->rows;
 975         if (l->rows * l->columns < screen_num_desktops)
 976             l->columns++;
 977         if (l->rows * l->columns >= screen_num_desktops + l->columns)
 978             l->rows--;
 979     } else if (l->rows == 0) {
 980         l->rows = screen_num_desktops / l->columns;
 981         if (l->columns * l->rows < screen_num_desktops)
 982             l->rows++;
 983         if (l->columns * l->rows >= screen_num_desktops + l->rows)
 984             l->columns--;
 985     }
 986
 987     /* bounds checking */
 988     if (l->orientation == OB_ORIENTATION_HORZ) {
 989         l->columns = MIN(screen_num_desktops, l->columns);
 990         l->rows = MIN(l->rows,
 991                       (screen_num_desktops + l->columns - 1) / l->columns);
 992         l->columns = screen_num_desktops / l->rows +
 993             !!(screen_num_desktops % l->rows);
 994     } else {
 995         l->rows = MIN(screen_num_desktops, l->rows);
 996         l->columns = MIN(l->columns,
 997                          (screen_num_desktops + l->rows - 1) / l->rows);
 998         l->rows = screen_num_desktops / l->columns +
 999             !!(screen_num_desktops % l->columns);
1000     }
1001     return TRUE;
1002 }
1003
1004 void screen_update_layout()
1005
1006 {
1007     ObDesktopLayout l;
1008     guint32 *data;
1009     guint num;
1010
1011     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1012     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1013     screen_desktop_layout.rows = 1;
1014     screen_desktop_layout.columns = screen_num_desktops;
1015
1016     if (PROP_GETA32(RootWindow(ob_display, ob_screen),
1017                     net_desktop_layout, cardinal, &data, &num)) {
1018         if (num == 3 || num == 4) {
1019
1020             if (data[0] == prop_atoms.net_wm_orientation_vert)
1021                 l.orientation = OB_ORIENTATION_VERT;
1022             else if (data[0] == prop_atoms.net_wm_orientation_horz)
1023                 l.orientation = OB_ORIENTATION_HORZ;
1024             else
1025                 return;
1026
1027             if (num < 4)
1028                 l.start_corner = OB_CORNER_TOPLEFT;
1029             else {
1030                 if (data[3] == prop_atoms.net_wm_topleft)
1031                     l.start_corner = OB_CORNER_TOPLEFT;
1032                 else if (data[3] == prop_atoms.net_wm_topright)
1033                     l.start_corner = OB_CORNER_TOPRIGHT;
1034                 else if (data[3] == prop_atoms.net_wm_bottomright)
1035                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
1036                 else if (data[3] == prop_atoms.net_wm_bottomleft)
1037                     l.start_corner = OB_CORNER_BOTTOMLEFT;
1038                 else
1039                     return;
1040             }
1041
1042             l.columns = data[1];
1043             l.rows = data[2];
1044
1045             if (screen_validate_layout(&l))
1046                 screen_desktop_layout = l;
1047
1048             g_free(data);
1049         }
1050     }
1051 }
1052
1053 void screen_update_desktop_names()
1054 {
1055     guint i;
1056
1057     /* empty the array */
1058     g_strfreev(screen_desktop_names);
1059     screen_desktop_names = NULL;
1060
1061     if (PROP_GETSS(RootWindow(ob_display, ob_screen),
1062                    net_desktop_names, utf8, &screen_desktop_names))
1063         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1064     else
1065         i = 0;
1066     if (i < screen_num_desktops) {
1067         GSList *it;
1068
1069         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1070                                        screen_num_desktops + 1);
1071         screen_desktop_names[screen_num_desktops] = NULL;
1072
1073         it = g_slist_nth(config_desktops_names, i);
1074
1075         for (; i < screen_num_desktops; ++i) {
1076             if (it && ((char*)it->data)[0]) /* not empty */
1077                 /* use the names from the config file when possible */
1078                 screen_desktop_names[i] = g_strdup(it->data);
1079             else
1080                 /* make up a nice name if it's not though */
1081                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1082                                                           i + 1);
1083             if (it) it = g_slist_next(it);
1084         }
1085
1086         /* if we changed any names, then set the root property so we can
1087            all agree on the names */
1088         PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
1089                    screen_desktop_names);
1090     }
1091
1092     /* resize the pager for these names */
1093     pager_popup_text_width_to_strings(desktop_popup,
1094                                       screen_desktop_names,
1095                                       screen_num_desktops);
1096 }
1097
1098 void screen_show_desktop(gboolean show, ObClient *show_only)
1099 {
1100     GList *it;
1101
1102     if (show == screen_showing_desktop) return; /* no change */
1103
1104     screen_showing_desktop = show;
1105
1106     if (show) {
1107         /* hide windows bottom to top */
1108         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1109             if (WINDOW_IS_CLIENT(it->data)) {
1110                 ObClient *client = it->data;
1111                 client_showhide(client);
1112             }
1113         }
1114     }
1115     else {
1116         /* restore windows top to bottom */
1117         for (it = stacking_list; it; it = g_list_next(it)) {
1118             if (WINDOW_IS_CLIENT(it->data)) {
1119                 ObClient *client = it->data;
1120                 if (client_should_show(client)) {
1121                     if (!show_only || client == show_only)
1122                         client_show(client);
1123                     else
1124                         client_iconify(client, TRUE, FALSE, TRUE);
1125                 }
1126             }
1127         }
1128     }
1129
1130     if (show) {
1131         /* focus the desktop */
1132         for (it = focus_order; it; it = g_list_next(it)) {
1133             ObClient *c = it->data;
1134             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1135                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1136                 client_focus(it->data))
1137                 break;
1138         }
1139     }
1140     else if (!show_only) {
1141         ObClient *c;
1142
1143         if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1144             /* only do the flicker reducing stuff ahead of time if we are going
1145                to call xsetinputfocus on the window ourselves. otherwise there
1146                is no guarantee the window will actually take focus.. */
1147             if (c->can_focus) {
1148                 /* reduce flicker by hiliting now rather than waiting for the
1149                    server FocusIn event */
1150                 frame_adjust_focus(c->frame, TRUE);
1151             }
1152         }
1153     }
1154
1155     show = !!show; /* make it boolean */
1156     PROP_SET32(RootWindow(ob_display, ob_screen),
1157                net_showing_desktop, cardinal, show);
1158 }
1159
1160 void screen_install_colormap(ObClient *client, gboolean install)
1161 {
1162     if (client == NULL || client->colormap == None) {
1163         if (install)
1164             XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1165         else
1166             XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1167     } else {
1168         xerror_set_ignore(TRUE);
1169         if (install)
1170             XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1171         else
1172             XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1173         xerror_set_ignore(FALSE);
1174     }
1175 }
1176
1177 #define STRUT_LEFT_ON_MONITOR(s, i) \
1178     (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
1179                       monitor_area[i].y, monitor_area[i].height))
1180 #define STRUT_RIGHT_ON_MONITOR(s, i) \
1181     (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
1182                       monitor_area[i].y, monitor_area[i].height))
1183 #define STRUT_TOP_ON_MONITOR(s, i) \
1184     (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
1185                       monitor_area[i].x, monitor_area[i].width))
1186 #define STRUT_BOTTOM_ON_MONITOR(s, i) \
1187     (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
1188                       monitor_area[i].x, monitor_area[i].width))
1189
1190 typedef struct {
1191     guint desktop;
1192     StrutPartial *strut;
1193 } ObScreenStrut;
1194
1195 #define RESET_STRUT_LIST(sl) \
1196     (g_slist_free(sl), sl = NULL)
1197
1198 #define ADD_STRUT_TO_LIST(sl, d, s) \
1199 { \
1200     ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1201     ss->desktop = d; \
1202     ss->strut = s;  \
1203     sl = g_slist_prepend(sl, ss); \
1204 }
1205
1206 #define VALIDATE_STRUTS(sl, side, max) \
1207 { \
1208     GSList *it; \
1209     for (it = sl; it; it = g_slist_next(it)) { \
1210       ObScreenStrut *ss = it->data; \
1211       ss->strut->side = MIN(max, ss->strut->side); \
1212     } \
1213 }
1214
1215 void screen_update_areas()
1216 {
1217     guint i, j;
1218     gulong *dims;
1219     GList *it;
1220     GSList *sit;
1221
1222     g_free(monitor_area);
1223     extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
1224
1225     /* set up the user-specified margins */
1226     config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1227     config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1228     config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1229     config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1230     config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1231     config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1232     config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1233     config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1234
1235     dims = g_new(gulong, 4 * screen_num_desktops * screen_num_monitors);
1236
1237     RESET_STRUT_LIST(struts_left);
1238     RESET_STRUT_LIST(struts_top);
1239     RESET_STRUT_LIST(struts_right);
1240     RESET_STRUT_LIST(struts_bottom);
1241
1242     /* collect the struts */
1243     for (it = client_list; it; it = g_list_next(it)) {
1244         ObClient *c = it->data;
1245         if (c->strut.left)
1246             ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1247         if (c->strut.top)
1248             ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1249         if (c->strut.right)
1250             ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1251         if (c->strut.bottom)
1252             ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1253     }
1254     if (dock_strut.left)
1255         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1256     if (dock_strut.top)
1257         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1258     if (dock_strut.right)
1259         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1260     if (dock_strut.bottom)
1261         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1262
1263     if (config_margins.left)
1264         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1265     if (config_margins.top)
1266         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1267     if (config_margins.right)
1268         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1269     if (config_margins.bottom)
1270         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1271
1272     VALIDATE_STRUTS(struts_left, left,
1273                     monitor_area[screen_num_monitors].width / 2);
1274     VALIDATE_STRUTS(struts_right, right,
1275                     monitor_area[screen_num_monitors].width / 2);
1276     VALIDATE_STRUTS(struts_top, top,
1277                     monitor_area[screen_num_monitors].height / 2);
1278     VALIDATE_STRUTS(struts_bottom, bottom,
1279                     monitor_area[screen_num_monitors].height / 2);
1280
1281     /* set up the work areas to be full screen */
1282     for (i = 0; i < screen_num_monitors; ++i)
1283         for (j = 0; j < screen_num_desktops; ++j) {
1284             dims[(i * screen_num_desktops + j) * 4+0] = monitor_area[i].x;
1285             dims[(i * screen_num_desktops + j) * 4+1] = monitor_area[i].y;
1286             dims[(i * screen_num_desktops + j) * 4+2] = monitor_area[i].width;
1287             dims[(i * screen_num_desktops + j) * 4+3] = monitor_area[i].height;
1288         }
1289
1290     /* calculate the work areas from the struts */
1291     for (i = 0; i < screen_num_monitors; ++i)
1292         for (j = 0; j < screen_num_desktops; ++j) {
1293             gint l = 0, r = 0, t = 0, b = 0;
1294
1295             /* only add the strut to the area if it touches the monitor */
1296
1297             for (sit = struts_left; sit; sit = g_slist_next(sit)) {
1298                 ObScreenStrut *s = sit->data;
1299                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1300                     STRUT_LEFT_ON_MONITOR(s->strut, i))
1301                     l = MAX(l, s->strut->left);
1302             }
1303             for (sit = struts_top; sit; sit = g_slist_next(sit)) {
1304                 ObScreenStrut *s = sit->data;
1305                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1306                     STRUT_TOP_ON_MONITOR(s->strut, i))
1307                     t = MAX(t, s->strut->top);
1308             }
1309             for (sit = struts_right; sit; sit = g_slist_next(sit)) {
1310                 ObScreenStrut *s = sit->data;
1311                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1312                     STRUT_RIGHT_ON_MONITOR(s->strut, i))
1313                     r = MAX(r, s->strut->right);
1314             }
1315             for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
1316                 ObScreenStrut *s = sit->data;
1317                 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1318                     STRUT_BOTTOM_ON_MONITOR(s->strut, i))
1319                     b = MAX(b, s->strut->bottom);
1320             }
1321
1322             /* based on these margins, set the work area for the
1323                monitor/desktop */
1324             dims[(i * screen_num_desktops + j) * 4 + 0] += l;
1325             dims[(i * screen_num_desktops + j) * 4 + 1] += t;
1326             dims[(i * screen_num_desktops + j) * 4 + 2] -= l + r;
1327             dims[(i * screen_num_desktops + j) * 4 + 3] -= t + b;
1328         }
1329
1330     /* all the work areas are not used here, only the ones for the first
1331        monitor are */
1332     PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1333                 dims, 4 * screen_num_desktops);
1334
1335     /* the area has changed, adjust all the windows if they need it */
1336     for (it = client_list; it; it = g_list_next(it))
1337         client_reconfigure(it->data, FALSE);
1338
1339     g_free(dims);
1340 }
1341
1342 #if 0
1343 Rect* screen_area_all_monitors(guint desktop)
1344 {
1345     guint i;
1346     Rect *a;
1347
1348     a = screen_area_monitor(desktop, 0);
1349
1350     /* combine all the monitors together */
1351     for (i = 1; i < screen_num_monitors; ++i) {
1352         Rect *m = screen_area_monitor(desktop, i);
1353         gint l, r, t, b;
1354
1355         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1356         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1357         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1358         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1359
1360         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1361
1362         g_free(m);
1363     }
1364
1365     return a;
1366 }
1367 #endif
1368
1369 #define STRUT_LEFT_IN_SEARCH(s, search) \
1370     (RANGES_INTERSECT(search->y, search->height, \
1371                       s->left_start, s->left_end - s->left_start + 1))
1372 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1373     (RANGES_INTERSECT(search->y, search->height, \
1374                       s->right_start, s->right_end - s->right_start + 1))
1375 #define STRUT_TOP_IN_SEARCH(s, search) \
1376     (RANGES_INTERSECT(search->x, search->width, \
1377                       s->top_start, s->top_end - s->top_start + 1))
1378 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1379     (RANGES_INTERSECT(search->x, search->width, \
1380                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1381
1382 #define STRUT_LEFT_IGNORE(s, us, search) \
1383     (head == SCREEN_AREA_ALL_MONITORS && us && \
1384      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1385 #define STRUT_RIGHT_IGNORE(s, us, search) \
1386     (head == SCREEN_AREA_ALL_MONITORS && us && \
1387      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1388 #define STRUT_TOP_IGNORE(s, us, search) \
1389     (head == SCREEN_AREA_ALL_MONITORS && us && \
1390      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1391 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1392     (head == SCREEN_AREA_ALL_MONITORS && us && \
1393      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1394
1395 Rect* screen_area(guint desktop, guint head, Rect *search)
1396 {
1397     Rect *a;
1398     GSList *it;
1399     gint l, r, t, b, al, ar, at, ab;
1400     guint i, d;
1401     gboolean us = search != NULL; /* user provided search */
1402
1403     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1404     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1405              head == SCREEN_AREA_ALL_MONITORS);
1406     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1407
1408     /* find any struts for this monitor
1409        which will be affecting the search area.
1410     */
1411
1412     /* search everything if search is null */
1413     if (!search) {
1414         if (head < screen_num_monitors) search = &monitor_area[head];
1415         else search = &monitor_area[screen_num_monitors];
1416     }
1417     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1418
1419     /* al is "all left" meaning the furthest left you can get, l is our
1420        "working left" meaning our current strut edge which we're calculating
1421     */
1422
1423     /* only include monitors which the search area lines up with */
1424     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1425         al = l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1426         at = t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1427         ar = r = RECT_LEFT(monitor_area[screen_num_monitors]);
1428         ab = b = RECT_TOP(monitor_area[screen_num_monitors]);
1429         for (i = 0; i < screen_num_monitors; ++i) {
1430             /* add the monitor if applicable */
1431             if (RANGES_INTERSECT(search->x, search->width,
1432                                  monitor_area[i].x, monitor_area[i].width))
1433             {
1434                 at = t = MIN(t, RECT_TOP(monitor_area[i]));
1435                 ab = b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1436             }
1437             if (RANGES_INTERSECT(search->y, search->height,
1438                                  monitor_area[i].y, monitor_area[i].height))
1439             {
1440                 al = l = MIN(l, RECT_LEFT(monitor_area[i]));
1441                 ar = r = MAX(r, RECT_RIGHT(monitor_area[i]));
1442             }
1443         }
1444     } else {
1445         al = l = RECT_LEFT(monitor_area[screen_num_monitors]);
1446         at = t = RECT_TOP(monitor_area[screen_num_monitors]);
1447         ar = r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1448         ab = b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1449     }
1450
1451     for (d = 0; d < screen_num_desktops; ++d) {
1452         if (d != desktop && desktop != DESKTOP_ALL) continue;
1453
1454         for (i = 0; i < screen_num_monitors; ++i) {
1455             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1456
1457             for (it = struts_left; it; it = g_slist_next(it)) {
1458                 ObScreenStrut *s = it->data;
1459                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1460                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1461                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1462                     l = MAX(l, al + s->strut->left);
1463             }
1464             for (it = struts_top; it; it = g_slist_next(it)) {
1465                 ObScreenStrut *s = it->data;
1466                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1467                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1468                     !STRUT_TOP_IGNORE(s->strut, us, search))
1469                     t = MAX(t, at + s->strut->top);
1470             }
1471             for (it = struts_right; it; it = g_slist_next(it)) {
1472                 ObScreenStrut *s = it->data;
1473                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1474                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1475                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1476                     r = MIN(r, ar - s->strut->right);
1477             }
1478             for (it = struts_bottom; it; it = g_slist_next(it)) {
1479                 ObScreenStrut *s = it->data;
1480                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1481                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1482                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1483                     b = MIN(b, ab - s->strut->bottom);
1484             }
1485
1486             /* limit to this monitor */
1487             if (head == i) {
1488                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1489                 t = MAX(t, RECT_TOP(monitor_area[i]));
1490                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1491                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1492             }
1493         }
1494     }
1495
1496     a = g_new(Rect, 1);
1497     a->x = l;
1498     a->y = t;
1499     a->width = r - l + 1;
1500     a->height = b - t + 1;
1501     return a;
1502 }
1503
1504 guint screen_find_monitor(Rect *search)
1505 {
1506     guint i;
1507     guint most = 0;
1508     guint mostv = 0;
1509
1510     for (i = 0; i < screen_num_monitors; ++i) {
1511         Rect *area = screen_physical_area_monitor(i);
1512         if (RECT_INTERSECTS_RECT(*area, *search)) {
1513             Rect r;
1514             guint v;
1515
1516             RECT_SET_INTERSECTION(r, *area, *search);
1517             v = r.width * r.height;
1518
1519             if (v > mostv) {
1520                 mostv = v;
1521                 most = i;
1522             }
1523         }
1524         g_free(area);
1525     }
1526     return most;
1527 }
1528
1529 Rect* screen_physical_area_all_monitors()
1530 {
1531     return screen_physical_area_monitor(screen_num_monitors);
1532 }
1533
1534 Rect* screen_physical_area_monitor(guint head)
1535 {
1536     Rect *a;
1537     g_assert(head <= screen_num_monitors);
1538
1539     a = g_new(Rect, 1);
1540     *a = monitor_area[head];
1541     return a;
1542 }
1543
1544 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1545 {
1546     g_assert(head <= screen_num_monitors);
1547     g_assert(search);
1548     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1549 }
1550
1551 Rect* screen_physical_area_active()
1552 {
1553     Rect *a;
1554     gint x, y;
1555
1556     if (moveresize_client)
1557         a = screen_physical_area_monitor(client_monitor(focus_client));
1558     else if (focus_client)
1559         a = screen_physical_area_monitor(client_monitor(focus_client));
1560     else {
1561         Rect mon;
1562         if (screen_pointer_pos(&x, &y))
1563             RECT_SET(mon, x, y, 1, 1);
1564         else
1565             RECT_SET(mon, 0, 0, 1, 1);
1566         a = screen_physical_area_monitor(screen_find_monitor(&mon));
1567     }
1568     return a;
1569 }
1570
1571 void screen_set_root_cursor()
1572 {
1573     if (sn_app_starting())
1574         XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1575                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1576     else
1577         XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1578                       ob_cursor(OB_CURSOR_POINTER));
1579 }
1580
1581 gboolean screen_pointer_pos(gint *x, gint *y)
1582 {
1583     Window w;
1584     gint i;
1585     guint u;
1586     gboolean ret;
1587
1588     ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1589                           &w, &w, x, y, &i, &i, &u);
1590     if (!ret) {
1591         for (i = 0; i < ScreenCount(ob_display); ++i)
1592             if (i != ob_screen)
1593                 if (XQueryPointer(ob_display, RootWindow(ob_display, i),
1594                                   &w, &w, x, y, &i, &i, &u))
1595                     break;
1596     }
1597     return ret;
1598 }