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