cbcaad798604af9eb61d2a119c3459aa6ea9e222
[dana/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/prop.h"
40 #include "obt/mainloop.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 /*! An array of desktops, holding an array of areas per monitor */
74 static Rect  *monitor_area = NULL;
75 /*! An array of desktops, holding an array of struts */
76 static GSList *struts_top = NULL;
77 static GSList *struts_left = NULL;
78 static GSList *struts_right = NULL;
79 static GSList *struts_bottom = NULL;
80
81 static ObPagerPopup *desktop_popup;
82 static gboolean      desktop_popup_perm;
83
84 /*! The number of microseconds that you need to be on a desktop before it will
85   replace the remembered "last desktop" */
86 #define REMEMBER_LAST_DESKTOP_TIME 750000
87
88 static gboolean replace_wm(void)
89 {
90     gchar *wm_sn;
91     Atom wm_sn_atom;
92     Window current_wm_sn_owner;
93     Time timestamp;
94
95     wm_sn = g_strdup_printf("WM_S%d", ob_screen);
96     wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
97     g_free(wm_sn);
98
99     current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
100     if (current_wm_sn_owner == screen_support_win)
101         current_wm_sn_owner = None;
102     if (current_wm_sn_owner) {
103         if (!ob_replace_wm) {
104             g_message(_("A window manager is already running on screen %d"),
105                       ob_screen);
106             return FALSE;
107         }
108         obt_display_ignore_errors(TRUE);
109
110         /* We want to find out when the current selection owner dies */
111         XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
112         XSync(obt_display, FALSE);
113
114         obt_display_ignore_errors(FALSE);
115         if (obt_display_error_occured)
116             current_wm_sn_owner = None;
117     }
118
119     timestamp = event_get_server_time();
120
121     XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
122                        timestamp);
123
124     if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
125         g_message(_("Could not acquire window manager selection on screen %d"),
126                   ob_screen);
127         return FALSE;
128     }
129
130     /* Wait for old window manager to go away */
131     if (current_wm_sn_owner) {
132       XEvent event;
133       gulong wait = 0;
134       const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
135
136       while (wait < timeout) {
137           if (XCheckWindowEvent(obt_display, current_wm_sn_owner,
138                                 StructureNotifyMask, &event) &&
139               event.type == DestroyNotify)
140               break;
141           g_usleep(G_USEC_PER_SEC / 10);
142           wait += G_USEC_PER_SEC / 10;
143       }
144
145       if (wait >= timeout) {
146           g_message(_("The WM on screen %d is not exiting"), ob_screen);
147           return FALSE;
148       }
149     }
150
151     /* Send client message indicating that we are now the WM */
152     obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
153                      timestamp, wm_sn_atom, screen_support_win, 0, 0,
154                      SubstructureNotifyMask);
155
156     return TRUE;
157 }
158
159 gboolean screen_annex(void)
160 {
161     XSetWindowAttributes attrib;
162     pid_t pid;
163     gint i, num_support;
164     gulong *supported;
165
166     /* create the netwm support window */
167     attrib.override_redirect = TRUE;
168     attrib.event_mask = PropertyChangeMask;
169     screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
170                                        -100, -100, 1, 1, 0,
171                                        CopyFromParent, InputOutput,
172                                        CopyFromParent,
173                                        CWEventMask | CWOverrideRedirect,
174                                        &attrib);
175     XMapWindow(obt_display, screen_support_win);
176     XLowerWindow(obt_display, screen_support_win);
177
178     if (!replace_wm()) {
179         XDestroyWindow(obt_display, screen_support_win);
180         return FALSE;
181     }
182
183     obt_display_ignore_errors(TRUE);
184     XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
185     obt_display_ignore_errors(FALSE);
186     if (obt_display_error_occured) {
187         g_message(_("A window manager is already running on screen %d"),
188                   ob_screen);
189
190         XDestroyWindow(obt_display, screen_support_win);
191         return FALSE;
192     }
193
194     screen_set_root_cursor();
195
196     /* set the OPENBOX_PID hint */
197     pid = getpid();
198     OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
199
200     /* set supporting window */
201     OBT_PROP_SET32(obt_root(ob_screen),
202                    NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
203
204     /* set properties on the supporting window */
205     OBT_PROP_SETS(screen_support_win, NET_WM_NAME, utf8, "Openbox");
206     OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK,
207                    WINDOW, screen_support_win);
208
209     /* set the _NET_SUPPORTED_ATOMS hint */
210
211     /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
212     num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
213     i = 0;
214     supported = g_new(gulong, num_support);
215     supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
216     supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
217     supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
218     supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
219     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
220     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
221     supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
222     supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
223     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
224     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
225     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
226     supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
227     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
228     supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
229     supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
230     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
231     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
232     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
233     supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
234     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
235     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
236     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
237     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
238     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
239     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
240     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
241     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
242     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
243     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
244     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
245     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
246     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
247     supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
248     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
249     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
250     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
251     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
252     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
253     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
254     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
255     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
256     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
257     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
258     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
259     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
260     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
261     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
262     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
263     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
264     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
265     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
266     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
267     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
268     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
269     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
270     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
271     supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
272     supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
273     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
274 /*
275     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
276 */
277     supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
278     supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
279     supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
280     supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
281 #ifdef SYNC
282     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
283     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
284 #endif
285     supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
286     supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
287
288     supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
289     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
290     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
291
292     supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
293     supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
294     supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
295     supported[i++] = OBT_PROP_ATOM(OB_THEME);
296     supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
297     supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
298     supported[i++] = OBT_PROP_ATOM(OB_VERSION);
299     supported[i++] = OBT_PROP_ATOM(OB_APP_ROLE);
300     supported[i++] = OBT_PROP_ATOM(OB_APP_TITLE);
301     supported[i++] = OBT_PROP_ATOM(OB_APP_NAME);
302     supported[i++] = OBT_PROP_ATOM(OB_APP_CLASS);
303     supported[i++] = OBT_PROP_ATOM(OB_APP_TYPE);
304     g_assert(i == num_support);
305
306     OBT_PROP_SETA32(obt_root(ob_screen),
307                     NET_SUPPORTED, ATOM, supported, num_support);
308     g_free(supported);
309
310     OBT_PROP_SETS(RootWindow(obt_display, ob_screen), OB_VERSION, utf8,
311                   OPENBOX_VERSION);
312
313     screen_tell_ksplash();
314
315     return TRUE;
316 }
317
318 static void screen_tell_ksplash(void)
319 {
320     XEvent e;
321     char **argv;
322
323     argv = g_new(gchar*, 6);
324     argv[0] = g_strdup("dcop");
325     argv[1] = g_strdup("ksplash");
326     argv[2] = g_strdup("ksplash");
327     argv[3] = g_strdup("upAndRunning(QString)");
328     argv[4] = g_strdup("wm started");
329     argv[5] = NULL;
330
331     /* tell ksplash through the dcop server command line interface */
332     g_spawn_async(NULL, argv, NULL,
333                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
334                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
335                   NULL, NULL, NULL, NULL);
336     g_strfreev(argv);
337
338     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
339        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
340        something. oh well. */
341     e.xclient.type = ClientMessage;
342     e.xclient.display = obt_display;
343     e.xclient.window = obt_root(ob_screen);
344     e.xclient.message_type =
345         XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
346     e.xclient.format = 8;
347     strcpy(e.xclient.data.b, "wm started");
348     XSendEvent(obt_display, obt_root(ob_screen),
349                False, SubstructureNotifyMask, &e);
350 }
351
352 void screen_startup(gboolean reconfig)
353 {
354     gchar **names = NULL;
355     guint32 d;
356     gboolean namesexist = FALSE;
357
358     desktop_popup = pager_popup_new();
359     desktop_popup_perm = FALSE;
360     pager_popup_height(desktop_popup, POPUP_HEIGHT);
361
362     if (reconfig) {
363         /* update the pager popup's width */
364         pager_popup_text_width_to_strings(desktop_popup,
365                                           screen_desktop_names,
366                                           screen_num_desktops);
367         return;
368     }
369
370     /* get the initial size */
371     screen_resize();
372
373     /* have names already been set for the desktops? */
374     if (OBT_PROP_GETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, utf8, &names)) {
375         g_strfreev(names);
376         namesexist = TRUE;
377     }
378
379     /* if names don't exist and we have session names, set those.
380        do this stuff BEFORE setting the number of desktops, because that
381        will create default names for them
382     */
383     if (!namesexist && session_desktop_names != NULL) {
384         guint i, numnames;
385         GSList *it;
386
387         /* get the desktop names */
388         numnames = g_slist_length(session_desktop_names);
389         names = g_new(gchar*, numnames + 1);
390         names[numnames] = NULL;
391         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
392             names[i] = g_strdup(it->data);
393
394         /* set the root window property */
395         OBT_PROP_SETSS(obt_root(ob_screen),
396                        NET_DESKTOP_NAMES, utf8, (const gchar**)names);
397
398         g_strfreev(names);
399     }
400
401     /* set the number of desktops, if it's not already set.
402
403        this will also set the default names from the config file up for
404        desktops that don't have names yet */
405     screen_num_desktops = 0;
406     if (OBT_PROP_GET32(obt_root(ob_screen),
407                        NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
408     {
409         if (d != config_desktops_num) {
410             /* TRANSLATORS: If you need to specify a different order of the
411                arguments, you can use %1$d for the first one and %2$d for the
412                second one. For example,
413                "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
414             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),
415                       config_desktops_num, d);
416         }
417         screen_set_num_desktops(d);
418     }
419     /* restore from session if possible */
420     else if (session_num_desktops)
421         screen_set_num_desktops(session_num_desktops);
422     else
423         screen_set_num_desktops(config_desktops_num);
424
425     screen_desktop = screen_num_desktops;  /* something invalid */
426     /* start on the current desktop when a wm was already running */
427     if (OBT_PROP_GET32(obt_root(ob_screen),
428                        NET_CURRENT_DESKTOP, CARDINAL, &d) &&
429         d < screen_num_desktops)
430     {
431         screen_set_desktop(d, FALSE);
432     } else if (session_desktop >= 0)
433         screen_set_desktop(MIN((guint)session_desktop,
434                                screen_num_desktops), FALSE);
435     else
436         screen_set_desktop(MIN(config_screen_firstdesk,
437                                screen_num_desktops) - 1, FALSE);
438     screen_last_desktop = screen_desktop;
439
440     /* don't start in showing-desktop mode */
441     screen_showing_desktop = FALSE;
442     OBT_PROP_SET32(obt_root(ob_screen),
443                    NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
444
445     if (session_desktop_layout_present &&
446         screen_validate_layout(&session_desktop_layout))
447     {
448         screen_desktop_layout = session_desktop_layout;
449     }
450     else
451         screen_update_layout();
452 }
453
454 void screen_shutdown(gboolean reconfig)
455 {
456     pager_popup_free(desktop_popup);
457
458     if (reconfig)
459         return;
460
461     XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
462
463     /* we're not running here no more! */
464     OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
465     /* not without us */
466     OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
467     /* don't keep this mode */
468     OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
469
470     XDestroyWindow(obt_display, screen_support_win);
471
472     g_strfreev(screen_desktop_names);
473     screen_desktop_names = NULL;
474 }
475
476 void screen_resize(void)
477 {
478     static gint oldw = 0, oldh = 0;
479     gint w, h;
480     GList *it;
481     gulong geometry[2];
482
483     w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
484     h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
485
486     if (w == oldw && h == oldh) return;
487
488     oldw = w; oldh = h;
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     screen_update_areas();
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     return FALSE;
602 }
603
604 void screen_set_desktop(guint num, gboolean dofocus)
605 {
606     GList *it;
607     guint previous;
608     gulong ignore_start;
609
610     g_assert(num < screen_num_desktops);
611
612     previous = screen_desktop;
613     screen_desktop = num;
614
615     if (previous == num) return;
616
617     OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
618
619     /* This whole thing decides when/how to save the screen_last_desktop so
620        that it can be restored later if you want */
621     if (screen_desktop_timeout) {
622         /* If screen_desktop_timeout is true, then we've been on this desktop
623            long enough and we can save it as the last desktop. */
624
625         if (screen_last_desktop == previous)
626             /* this is the startup state only */
627             screen_old_desktop = screen_desktop;
628         else {
629             /* save the "last desktop" as the "old desktop" */
630             screen_old_desktop = screen_last_desktop;
631             /* save the desktop we're coming from as the "last desktop" */
632             screen_last_desktop = previous;
633         }
634     }
635     else {
636         /* If screen_desktop_timeout is false, then we just got to this desktop
637            and we are moving away again. */
638
639         if (screen_desktop == screen_last_desktop) {
640             /* If we are moving to the "last desktop" .. */
641             if (previous == screen_old_desktop) {
642                 /* .. from the "old desktop", change the last desktop to
643                    be where we are coming from */
644                 screen_last_desktop = screen_old_desktop;
645             }
646             else if (screen_last_desktop == screen_old_desktop) {
647                 /* .. and also to the "old desktop", change the "last
648                    desktop" to be where we are coming from */
649                 screen_last_desktop = previous;
650             }
651             else {
652                 /* .. from some other desktop, then set the "last desktop" to
653                    be the saved "old desktop", i.e. where we were before the
654                    "last desktop" */
655                 screen_last_desktop = screen_old_desktop;
656             }
657         }
658         else {
659             /* If we are moving to any desktop besides the "last desktop"..
660                (this is the normal case) */
661             if (screen_desktop == screen_old_desktop) {
662                 /* If moving to the "old desktop", which is not the
663                    "last desktop", don't save anything */
664             }
665             else if (previous == screen_old_desktop) {
666                 /* If moving from the "old desktop", and not to the
667                    "last desktop", don't save anything */
668             }
669             else if (screen_last_desktop == screen_old_desktop) {
670                 /* If the "last desktop" is the same as "old desktop" and
671                    you're not moving to the "last desktop" then save where
672                    we're coming from as the "last desktop" */
673                 screen_last_desktop = previous;
674             }
675             else {
676                 /* If the "last desktop" is different from the "old desktop"
677                    and you're not moving to the "last desktop", then don't save
678                    anything */
679             }
680         }
681     }
682     screen_desktop_timeout = FALSE;
683     obt_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
684     obt_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
685                               last_desktop_func, NULL, NULL, NULL);
686
687     ob_debug("Moving to desktop %d", num+1);
688
689     if (ob_state() == OB_STATE_RUNNING)
690         screen_show_desktop_popup(screen_desktop, FALSE);
691
692     /* ignore enter events caused by the move */
693     ignore_start = event_start_ignore_all_enters();
694
695     if (moveresize_client)
696         client_set_desktop(moveresize_client, num, TRUE, FALSE);
697
698     /* show windows before hiding the rest to lessen the enter/leave events */
699
700     /* show windows from top to bottom */
701     for (it = stacking_list; it; it = g_list_next(it)) {
702         if (WINDOW_IS_CLIENT(it->data)) {
703             ObClient *c = it->data;
704             client_show(c);
705         }
706     }
707
708     if (dofocus) screen_fallback_focus();
709
710     /* hide windows from bottom to top */
711     for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
712         if (WINDOW_IS_CLIENT(it->data)) {
713             ObClient *c = it->data;
714             if (client_hide(c)) {
715                 if (c == focus_client) {
716                     /* c was focused and we didn't do fallback clearly so make
717                        sure openbox doesnt still consider the window focused.
718                        this happens when using NextWindow with allDesktops,
719                        since it doesnt want to move focus on desktop change,
720                        but the focus is not going to stay with the current
721                        window, which has now disappeared.
722                        only do this if the client was actually hidden,
723                        otherwise it can keep focus. */
724                     focus_set_client(NULL);
725                 }
726             }
727         }
728     }
729
730     focus_cycle_addremove(NULL, TRUE);
731
732     event_end_ignore_all_enters(ignore_start);
733
734     if (event_curtime != CurrentTime)
735         screen_desktop_user_time = event_curtime;
736 }
737
738 void screen_add_desktop(gboolean current)
739 {
740     gulong ignore_start;
741
742     /* ignore enter events caused by this */
743     ignore_start = event_start_ignore_all_enters();
744
745     screen_set_num_desktops(screen_num_desktops+1);
746
747     /* move all the clients over */
748     if (current) {
749         GList *it;
750
751         for (it = client_list; it; it = g_list_next(it)) {
752             ObClient *c = it->data;
753             if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
754                 /* don't move direct children, they'll be moved with their
755                    parent - which will have to be on the same desktop */
756                 !client_direct_parent(c))
757             {
758                 ob_debug("moving window %s", c->title);
759                 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
760             }
761         }
762     }
763
764     event_end_ignore_all_enters(ignore_start);
765 }
766
767 void screen_remove_desktop(gboolean current)
768 {
769     guint rmdesktop, movedesktop;
770     GList *it, *stacking_copy;
771     gulong ignore_start;
772
773     if (screen_num_desktops <= 1) return;
774
775     /* ignore enter events caused by this */
776     ignore_start = event_start_ignore_all_enters();
777
778     /* what desktop are we removing and moving to? */
779     if (current)
780         rmdesktop = screen_desktop;
781     else
782         rmdesktop = screen_num_desktops - 1;
783     if (rmdesktop < screen_num_desktops - 1)
784         movedesktop = rmdesktop + 1;
785     else
786         movedesktop = rmdesktop;
787
788     /* make a copy of the list cuz we're changing it */
789     stacking_copy = g_list_copy(stacking_list);
790     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
791         if (WINDOW_IS_CLIENT(it->data)) {
792             ObClient *c = it->data;
793             guint d = c->desktop;
794             if (d != DESKTOP_ALL && d >= movedesktop &&
795                 /* don't move direct children, they'll be moved with their
796                    parent - which will have to be on the same desktop */
797                 !client_direct_parent(c))
798             {
799                 ob_debug("moving window %s", c->title);
800                 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
801             }
802             /* raise all the windows that are on the current desktop which
803                is being merged */
804             if ((screen_desktop == rmdesktop - 1 ||
805                  screen_desktop == rmdesktop) &&
806                 (d == DESKTOP_ALL || d == screen_desktop))
807             {
808                 stacking_raise(CLIENT_AS_WINDOW(c));
809                 ob_debug("raising window %s", c->title);
810             }
811         }
812     }
813     g_list_free(stacking_copy);
814
815     /* fallback focus like we're changing desktops */
816     if (screen_desktop < screen_num_desktops - 1) {
817         screen_fallback_focus();
818         ob_debug("fake desktop change");
819     }
820
821     screen_set_num_desktops(screen_num_desktops-1);
822
823     event_end_ignore_all_enters(ignore_start);
824 }
825
826 static void get_row_col(guint d, guint *r, guint *c)
827 {
828     switch (screen_desktop_layout.orientation) {
829     case OB_ORIENTATION_HORZ:
830         switch (screen_desktop_layout.start_corner) {
831         case OB_CORNER_TOPLEFT:
832             *r = d / screen_desktop_layout.columns;
833             *c = d % screen_desktop_layout.columns;
834             break;
835         case OB_CORNER_BOTTOMLEFT:
836             *r = screen_desktop_layout.rows - 1 -
837                 d / screen_desktop_layout.columns;
838             *c = d % screen_desktop_layout.columns;
839             break;
840         case OB_CORNER_TOPRIGHT:
841             *r = d / screen_desktop_layout.columns;
842             *c = screen_desktop_layout.columns - 1 -
843                 d % screen_desktop_layout.columns;
844             break;
845         case OB_CORNER_BOTTOMRIGHT:
846             *r = screen_desktop_layout.rows - 1 -
847                 d / screen_desktop_layout.columns;
848             *c = screen_desktop_layout.columns - 1 -
849                 d % screen_desktop_layout.columns;
850             break;
851         }
852         break;
853     case OB_ORIENTATION_VERT:
854         switch (screen_desktop_layout.start_corner) {
855         case OB_CORNER_TOPLEFT:
856             *r = d % screen_desktop_layout.rows;
857             *c = d / screen_desktop_layout.rows;
858             break;
859         case OB_CORNER_BOTTOMLEFT:
860             *r = screen_desktop_layout.rows - 1 -
861                 d % screen_desktop_layout.rows;
862             *c = d / screen_desktop_layout.rows;
863             break;
864         case OB_CORNER_TOPRIGHT:
865             *r = d % screen_desktop_layout.rows;
866             *c = screen_desktop_layout.columns - 1 -
867                 d / screen_desktop_layout.rows;
868             break;
869         case OB_CORNER_BOTTOMRIGHT:
870             *r = screen_desktop_layout.rows - 1 -
871                 d % screen_desktop_layout.rows;
872             *c = screen_desktop_layout.columns - 1 -
873                 d / screen_desktop_layout.rows;
874             break;
875         }
876         break;
877     }
878 }
879
880 static guint translate_row_col(guint r, guint c)
881 {
882     switch (screen_desktop_layout.orientation) {
883     case OB_ORIENTATION_HORZ:
884         switch (screen_desktop_layout.start_corner) {
885         case OB_CORNER_TOPLEFT:
886             return r % screen_desktop_layout.rows *
887                 screen_desktop_layout.columns +
888                 c % screen_desktop_layout.columns;
889         case OB_CORNER_BOTTOMLEFT:
890             return (screen_desktop_layout.rows - 1 -
891                     r % screen_desktop_layout.rows) *
892                 screen_desktop_layout.columns +
893                 c % screen_desktop_layout.columns;
894         case OB_CORNER_TOPRIGHT:
895             return r % screen_desktop_layout.rows *
896                 screen_desktop_layout.columns +
897                 (screen_desktop_layout.columns - 1 -
898                  c % screen_desktop_layout.columns);
899         case OB_CORNER_BOTTOMRIGHT:
900             return (screen_desktop_layout.rows - 1 -
901                     r % screen_desktop_layout.rows) *
902                 screen_desktop_layout.columns +
903                 (screen_desktop_layout.columns - 1 -
904                  c % screen_desktop_layout.columns);
905         }
906     case OB_ORIENTATION_VERT:
907         switch (screen_desktop_layout.start_corner) {
908         case OB_CORNER_TOPLEFT:
909             return c % screen_desktop_layout.columns *
910                 screen_desktop_layout.rows +
911                 r % screen_desktop_layout.rows;
912         case OB_CORNER_BOTTOMLEFT:
913             return c % screen_desktop_layout.columns *
914                 screen_desktop_layout.rows +
915                 (screen_desktop_layout.rows - 1 -
916                  r % screen_desktop_layout.rows);
917         case OB_CORNER_TOPRIGHT:
918             return (screen_desktop_layout.columns - 1 -
919                     c % screen_desktop_layout.columns) *
920                 screen_desktop_layout.rows +
921                 r % screen_desktop_layout.rows;
922         case OB_CORNER_BOTTOMRIGHT:
923             return (screen_desktop_layout.columns - 1 -
924                     c % screen_desktop_layout.columns) *
925                 screen_desktop_layout.rows +
926                 (screen_desktop_layout.rows - 1 -
927                  r % screen_desktop_layout.rows);
928         }
929     }
930     g_assert_not_reached();
931     return 0;
932 }
933
934 static gboolean hide_desktop_popup_func(gpointer data)
935 {
936     pager_popup_hide(desktop_popup);
937     return FALSE; /* don't repeat */
938 }
939
940 void screen_show_desktop_popup(guint d, gboolean perm)
941 {
942     Rect *a;
943
944     /* 0 means don't show the popup */
945     if (!config_desktop_popup_time) return;
946
947     a = screen_physical_area_primary(FALSE);
948     pager_popup_position(desktop_popup, CenterGravity,
949                          a->x + a->width / 2, a->y + a->height / 2);
950     pager_popup_icon_size_multiplier(desktop_popup,
951                                      (screen_desktop_layout.columns /
952                                       screen_desktop_layout.rows) / 2,
953                                      (screen_desktop_layout.rows/
954                                       screen_desktop_layout.columns) / 2);
955     pager_popup_max_width(desktop_popup,
956                           MAX(a->width/3, POPUP_WIDTH));
957     pager_popup_show(desktop_popup, screen_desktop_names[d], d);
958
959     obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
960     if (!perm && !desktop_popup_perm)
961         /* only hide if its not already being show permanently */
962         obt_main_loop_timeout_add(ob_main_loop,
963                                   config_desktop_popup_time * 1000,
964                                   hide_desktop_popup_func, desktop_popup,
965                                   g_direct_equal, NULL);
966     if (perm)
967         desktop_popup_perm = TRUE;
968
969     g_free(a);
970 }
971
972 void screen_hide_desktop_popup(void)
973 {
974     obt_main_loop_timeout_remove_data(ob_main_loop, hide_desktop_popup_func,
975                                       desktop_popup, FALSE);
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, utf8, &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                        utf8, (const gchar**)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     (g_slist_free(sl), sl = NULL)
1302
1303 #define ADD_STRUT_TO_LIST(sl, d, s) \
1304 { \
1305     ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1306     ss->desktop = d; \
1307     ss->strut = s;  \
1308     sl = g_slist_prepend(sl, ss); \
1309 }
1310
1311 #define VALIDATE_STRUTS(sl, side, max) \
1312 { \
1313     GSList *it; \
1314     for (it = sl; it; it = g_slist_next(it)) { \
1315       ObScreenStrut *ss = it->data; \
1316       ss->strut->side = MIN(max, ss->strut->side); \
1317     } \
1318 }
1319
1320 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1321 {
1322     guint i;
1323     gint n, l, r, t, b;
1324 #ifdef XINERAMA
1325     XineramaScreenInfo *info;
1326 #endif
1327
1328     if (ob_debug_xinerama) {
1329         gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1330         gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1331         *nxin = 2;
1332         *xin_areas = g_new(Rect, *nxin + 1);
1333         RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1334         RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1335     }
1336 #ifdef XINERAMA
1337     else if (obt_display_extension_xinerama &&
1338              (info = XineramaQueryScreens(obt_display, &n))) {
1339         *nxin = n;
1340         *xin_areas = g_new(Rect, *nxin + 1);
1341         for (i = 0; i < *nxin; ++i)
1342             RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1343                      info[i].width, info[i].height);
1344         XFree(info);
1345     }
1346 #endif
1347     else {
1348         *nxin = 1;
1349         *xin_areas = g_new(Rect, *nxin + 1);
1350         RECT_SET((*xin_areas)[0], 0, 0,
1351                  WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1352                  HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1353     }
1354
1355     /* returns one extra with the total area in it */
1356     l = (*xin_areas)[0].x;
1357     t = (*xin_areas)[0].y;
1358     r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1359     b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1360     for (i = 1; i < *nxin; ++i) {
1361         l = MIN(l, (*xin_areas)[i].x);
1362         t = MIN(l, (*xin_areas)[i].y);
1363         r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1364         b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1365     }
1366     RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1367 }
1368
1369 void screen_update_areas(void)
1370 {
1371     guint i;
1372     gulong *dims;
1373     GList *it;
1374
1375     g_free(monitor_area);
1376     get_xinerama_screens(&monitor_area, &screen_num_monitors);
1377
1378     /* set up the user-specified margins */
1379     config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1380     config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1381     config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1382     config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1383     config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1384     config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1385     config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1386     config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1387
1388     RESET_STRUT_LIST(struts_left);
1389     RESET_STRUT_LIST(struts_top);
1390     RESET_STRUT_LIST(struts_right);
1391     RESET_STRUT_LIST(struts_bottom);
1392
1393     /* collect the struts */
1394     for (it = client_list; it; it = g_list_next(it)) {
1395         ObClient *c = it->data;
1396         if (c->strut.left)
1397             ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1398         if (c->strut.top)
1399             ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1400         if (c->strut.right)
1401             ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1402         if (c->strut.bottom)
1403             ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1404     }
1405     if (dock_strut.left)
1406         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1407     if (dock_strut.top)
1408         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1409     if (dock_strut.right)
1410         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1411     if (dock_strut.bottom)
1412         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1413
1414     if (config_margins.left)
1415         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1416     if (config_margins.top)
1417         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1418     if (config_margins.right)
1419         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1420     if (config_margins.bottom)
1421         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1422
1423     VALIDATE_STRUTS(struts_left, left,
1424                     monitor_area[screen_num_monitors].width / 2);
1425     VALIDATE_STRUTS(struts_right, right,
1426                     monitor_area[screen_num_monitors].width / 2);
1427     VALIDATE_STRUTS(struts_top, top,
1428                     monitor_area[screen_num_monitors].height / 2);
1429     VALIDATE_STRUTS(struts_bottom, bottom,
1430                     monitor_area[screen_num_monitors].height / 2);
1431
1432     dims = g_new(gulong, 4 * screen_num_desktops);
1433     for (i = 0; i < screen_num_desktops; ++i) {
1434         Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1435         dims[i*4+0] = area->x;
1436         dims[i*4+1] = area->y;
1437         dims[i*4+2] = area->width;
1438         dims[i*4+3] = area->height;
1439         g_free(area);
1440     }
1441
1442     /* set the legacy workarea hint to the union of all the monitors */
1443     OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1444                     dims, 4 * screen_num_desktops);
1445
1446     /* the area has changed, adjust all the windows if they need it */
1447     for (it = client_list; it; it = g_list_next(it))
1448         client_reconfigure(it->data, FALSE);
1449
1450     g_free(dims);
1451 }
1452
1453 #if 0
1454 Rect* screen_area_all_monitors(guint desktop)
1455 {
1456     guint i;
1457     Rect *a;
1458
1459     a = screen_area_monitor(desktop, 0);
1460
1461     /* combine all the monitors together */
1462     for (i = 1; i < screen_num_monitors; ++i) {
1463         Rect *m = screen_area_monitor(desktop, i);
1464         gint l, r, t, b;
1465
1466         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1467         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1468         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1469         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1470
1471         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1472
1473         g_free(m);
1474     }
1475
1476     return a;
1477 }
1478 #endif
1479
1480 #define STRUT_LEFT_IN_SEARCH(s, search) \
1481     (RANGES_INTERSECT(search->y, search->height, \
1482                       s->left_start, s->left_end - s->left_start + 1))
1483 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1484     (RANGES_INTERSECT(search->y, search->height, \
1485                       s->right_start, s->right_end - s->right_start + 1))
1486 #define STRUT_TOP_IN_SEARCH(s, search) \
1487     (RANGES_INTERSECT(search->x, search->width, \
1488                       s->top_start, s->top_end - s->top_start + 1))
1489 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1490     (RANGES_INTERSECT(search->x, search->width, \
1491                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1492
1493 #define STRUT_LEFT_IGNORE(s, us, search) \
1494     (head == SCREEN_AREA_ALL_MONITORS && us && \
1495      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1496 #define STRUT_RIGHT_IGNORE(s, us, search) \
1497     (head == SCREEN_AREA_ALL_MONITORS && us && \
1498      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1499 #define STRUT_TOP_IGNORE(s, us, search) \
1500     (head == SCREEN_AREA_ALL_MONITORS && us && \
1501      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1502 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1503     (head == SCREEN_AREA_ALL_MONITORS && us && \
1504      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1505
1506 Rect* screen_area(guint desktop, guint head, Rect *search)
1507 {
1508     Rect *a;
1509     GSList *it;
1510     gint l, r, t, b;
1511     guint i, d;
1512     gboolean us = search != NULL; /* user provided search */
1513
1514     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1515     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1516              head == SCREEN_AREA_ALL_MONITORS);
1517     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1518
1519     /* find any struts for this monitor
1520        which will be affecting the search area.
1521     */
1522
1523     /* search everything if search is null */
1524     if (!search) {
1525         if (head < screen_num_monitors) search = &monitor_area[head];
1526         else search = &monitor_area[screen_num_monitors];
1527     }
1528     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1529
1530     /* al is "all left" meaning the furthest left you can get, l is our
1531        "working left" meaning our current strut edge which we're calculating
1532     */
1533
1534     /* only include monitors which the search area lines up with */
1535     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1536         l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1537         t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1538         r = RECT_LEFT(monitor_area[screen_num_monitors]);
1539         b = RECT_TOP(monitor_area[screen_num_monitors]);
1540         for (i = 0; i < screen_num_monitors; ++i) {
1541             /* add the monitor if applicable */
1542             if (RANGES_INTERSECT(search->x, search->width,
1543                                  monitor_area[i].x, monitor_area[i].width))
1544             {
1545                 t = MIN(t, RECT_TOP(monitor_area[i]));
1546                 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1547             }
1548             if (RANGES_INTERSECT(search->y, search->height,
1549                                  monitor_area[i].y, monitor_area[i].height))
1550             {
1551                 l = MIN(l, RECT_LEFT(monitor_area[i]));
1552                 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1553             }
1554         }
1555     } else {
1556         l = RECT_LEFT(monitor_area[screen_num_monitors]);
1557         t = RECT_TOP(monitor_area[screen_num_monitors]);
1558         r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1559         b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1560     }
1561
1562     for (d = 0; d < screen_num_desktops; ++d) {
1563         if (d != desktop && desktop != DESKTOP_ALL) continue;
1564
1565         for (i = 0; i < screen_num_monitors; ++i) {
1566             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1567
1568             for (it = struts_left; it; it = g_slist_next(it)) {
1569                 ObScreenStrut *s = it->data;
1570                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1571                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1572                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1573                     l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1574                                + s->strut->left);
1575             }
1576             for (it = struts_top; it; it = g_slist_next(it)) {
1577                 ObScreenStrut *s = it->data;
1578                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1579                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1580                     !STRUT_TOP_IGNORE(s->strut, us, search))
1581                     t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1582                                + s->strut->top);
1583             }
1584             for (it = struts_right; it; it = g_slist_next(it)) {
1585                 ObScreenStrut *s = it->data;
1586                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1587                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1588                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1589                     r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1590                                - s->strut->right);
1591             }
1592             for (it = struts_bottom; it; it = g_slist_next(it)) {
1593                 ObScreenStrut *s = it->data;
1594                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1595                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1596                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1597                     b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1598                                - s->strut->bottom);
1599             }
1600
1601             /* limit to this monitor */
1602             if (head == i) {
1603                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1604                 t = MAX(t, RECT_TOP(monitor_area[i]));
1605                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1606                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1607             }
1608         }
1609     }
1610
1611     a = g_new(Rect, 1);
1612     a->x = l;
1613     a->y = t;
1614     a->width = r - l + 1;
1615     a->height = b - t + 1;
1616     return a;
1617 }
1618
1619 guint screen_find_monitor(Rect *search)
1620 {
1621     guint i;
1622     guint most = screen_num_monitors;
1623     guint mostv = 0;
1624
1625     for (i = 0; i < screen_num_monitors; ++i) {
1626         Rect *area = screen_physical_area_monitor(i);
1627         if (RECT_INTERSECTS_RECT(*area, *search)) {
1628             Rect r;
1629             guint v;
1630
1631             RECT_SET_INTERSECTION(r, *area, *search);
1632             v = r.width * r.height;
1633
1634             if (v > mostv) {
1635                 mostv = v;
1636                 most = i;
1637             }
1638         }
1639         g_free(area);
1640     }
1641     return most;
1642 }
1643
1644 Rect* screen_physical_area_all_monitors(void)
1645 {
1646     return screen_physical_area_monitor(screen_num_monitors);
1647 }
1648
1649 Rect* screen_physical_area_monitor(guint head)
1650 {
1651     Rect *a;
1652     g_assert(head <= screen_num_monitors);
1653
1654     a = g_new(Rect, 1);
1655     *a = monitor_area[head];
1656     return a;
1657 }
1658
1659 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1660 {
1661     g_assert(head <= screen_num_monitors);
1662     g_assert(search);
1663     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1664 }
1665
1666 guint screen_monitor_active(void)
1667 {
1668     if (moveresize_client)
1669         return client_monitor(moveresize_client);
1670     else if (focus_client)
1671         return client_monitor(focus_client);
1672     else
1673         return screen_monitor_pointer();
1674 }
1675
1676 Rect* screen_physical_area_active(void)
1677 {
1678     return screen_physical_area_monitor(screen_monitor_active());
1679 }
1680
1681 guint screen_monitor_primary(gboolean fixed)
1682 {
1683     if (config_primary_monitor_index > 0) {
1684         if (config_primary_monitor_index-1 < screen_num_monitors)
1685             return config_primary_monitor_index - 1;
1686         else
1687             return 0;
1688     }
1689     else if (fixed)
1690         return 0;
1691     else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1692         return screen_monitor_active();
1693     else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1694         return screen_monitor_pointer();
1695 }
1696
1697 Rect *screen_physical_area_primary(gboolean fixed)
1698 {
1699     return screen_physical_area_monitor(screen_monitor_primary(fixed));
1700 }
1701
1702 void screen_set_root_cursor(void)
1703 {
1704     if (sn_app_starting())
1705         XDefineCursor(obt_display, obt_root(ob_screen),
1706                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1707     else
1708         XDefineCursor(obt_display, obt_root(ob_screen),
1709                       ob_cursor(OB_CURSOR_POINTER));
1710 }
1711
1712 guint screen_find_monitor_point(guint x, guint y)
1713 {
1714     Rect mon;
1715     RECT_SET(mon, x, y, 1, 1);
1716     return screen_find_monitor(&mon);
1717 }
1718
1719 guint screen_monitor_pointer()
1720 {
1721     gint x, y;
1722     if (!screen_pointer_pos(&x, &y))
1723         x = y = 0;
1724     return screen_find_monitor_point(x, y);
1725 }
1726
1727 gboolean screen_pointer_pos(gint *x, gint *y)
1728 {
1729     Window w;
1730     gint i;
1731     guint u;
1732     gboolean ret;
1733
1734     ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1735                           &w, &w, x, y, &i, &i, &u);
1736     if (!ret) {
1737         for (i = 0; i < ScreenCount(obt_display); ++i)
1738             if (i != ob_screen)
1739                 if (XQueryPointer(obt_display, obt_root(i),
1740                                   &w, &w, x, y, &i, &i, &u))
1741                     break;
1742     }
1743     return ret;
1744 }