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