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