f4031f59591cf430edd1b93eaddcc7130c80536b
[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/xqueue.h"
40 #include "obt/prop.h"
41
42 #include <X11/Xlib.h>
43 #ifdef HAVE_UNISTD_H
44 #  include <sys/types.h>
45 #  include <unistd.h>
46 #endif
47 #include <assert.h>
48
49 /*! The event mask to grab on the root window */
50 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
51                         EnterWindowMask | LeaveWindowMask | \
52                         SubstructureRedirectMask | FocusChangeMask | \
53                         ButtonPressMask | ButtonReleaseMask)
54
55 static gboolean screen_validate_layout(ObDesktopLayout *l);
56 static gboolean replace_wm(void);
57 static void     screen_tell_ksplash(void);
58 static void     screen_fallback_focus(void);
59
60 guint           screen_num_desktops;
61 guint           screen_num_monitors;
62 guint           screen_desktop;
63 guint           screen_last_desktop;
64 gboolean        screen_showing_desktop;
65 ObDesktopLayout screen_desktop_layout;
66 gchar         **screen_desktop_names;
67 Window          screen_support_win;
68 Time            screen_desktop_user_time = CurrentTime;
69
70 static Size     screen_physical_size;
71 static guint    screen_old_desktop;
72 static gboolean screen_desktop_timeout = TRUE;
73 static guint    screen_desktop_timer = 0;
74 /*! An array of desktops, holding an array of areas per monitor */
75 static Rect  *monitor_area = NULL;
76 /*! An array of desktops, holding an array of struts */
77 static GSList *struts_top = NULL;
78 static GSList *struts_left = NULL;
79 static GSList *struts_right = NULL;
80 static GSList *struts_bottom = NULL;
81
82 static ObPagerPopup *desktop_popup;
83 static guint         desktop_popup_timer = 0;
84 static gboolean      desktop_popup_perm;
85
86 /*! The number of microseconds that you need to be on a desktop before it will
87   replace the remembered "last desktop" */
88 #define REMEMBER_LAST_DESKTOP_TIME 750
89
90 static gboolean replace_wm(void)
91 {
92     gchar *wm_sn;
93     Atom wm_sn_atom;
94     Window current_wm_sn_owner;
95     Time timestamp;
96
97     wm_sn = g_strdup_printf("WM_S%d", ob_screen);
98     wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
99     g_free(wm_sn);
100
101     current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
102     if (current_wm_sn_owner == screen_support_win)
103         current_wm_sn_owner = None;
104     if (current_wm_sn_owner) {
105         if (!ob_replace_wm) {
106             g_message(_("A window manager is already running on screen %d"),
107                       ob_screen);
108             return FALSE;
109         }
110         obt_display_ignore_errors(TRUE);
111
112         /* We want to find out when the current selection owner dies */
113         XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
114         XSync(obt_display, FALSE);
115
116         obt_display_ignore_errors(FALSE);
117         if (obt_display_error_occured)
118             current_wm_sn_owner = None;
119     }
120
121     timestamp = event_time();
122
123     XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
124                        timestamp);
125
126     if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
127         g_message(_("Could not acquire window manager selection on screen %d"),
128                   ob_screen);
129         return FALSE;
130     }
131
132     /* Wait for old window manager to go away */
133     if (current_wm_sn_owner) {
134       gulong wait = 0;
135       const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
136       ObtXQueueWindowType wt;
137
138       wt.window = current_wm_sn_owner;
139       wt.type = DestroyNotify;
140
141       while (wait < timeout) {
142           /* Checks the local queue and incoming events for this event */
143           if (xqueue_exists_local(xqueue_match_window_type, &wt))
144               break;
145           g_usleep(G_USEC_PER_SEC / 10);
146           wait += G_USEC_PER_SEC / 10;
147       }
148
149       if (wait >= timeout) {
150           g_message(_("The WM on screen %d is not exiting"), ob_screen);
151           return FALSE;
152       }
153     }
154
155     /* Send client message indicating that we are now the WM */
156     obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
157                      timestamp, wm_sn_atom, screen_support_win, 0, 0,
158                      SubstructureNotifyMask);
159
160     return TRUE;
161 }
162
163 gboolean screen_annex(void)
164 {
165     XSetWindowAttributes attrib;
166     pid_t pid;
167     gint i, num_support;
168     gulong *supported;
169
170     /* create the netwm support window */
171     attrib.override_redirect = TRUE;
172     attrib.event_mask = PropertyChangeMask;
173     screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
174                                        -100, -100, 1, 1, 0,
175                                        CopyFromParent, InputOutput,
176                                        CopyFromParent,
177                                        CWEventMask | CWOverrideRedirect,
178                                        &attrib);
179     XMapWindow(obt_display, screen_support_win);
180     XLowerWindow(obt_display, screen_support_win);
181
182     if (!replace_wm()) {
183         XDestroyWindow(obt_display, screen_support_win);
184         return FALSE;
185     }
186
187     obt_display_ignore_errors(TRUE);
188     XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
189     obt_display_ignore_errors(FALSE);
190     if (obt_display_error_occured) {
191         g_message(_("A window manager is already running on screen %d"),
192                   ob_screen);
193
194         XDestroyWindow(obt_display, screen_support_win);
195         return FALSE;
196     }
197
198     screen_set_root_cursor();
199
200     /* set the OPENBOX_PID hint */
201     pid = getpid();
202     OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
203
204     /* set supporting window */
205     OBT_PROP_SET32(obt_root(ob_screen),
206                    NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
207
208     /* set properties on the supporting window */
209     OBT_PROP_SETS(screen_support_win, NET_WM_NAME, "Openbox");
210     OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK,
211                    WINDOW, screen_support_win);
212
213     /* set the _NET_SUPPORTED_ATOMS hint */
214
215     /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
216     num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
217     i = 0;
218     supported = g_new(gulong, num_support);
219     supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
220     supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
221     supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
222     supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
223     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
224     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
225     supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
226     supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
227     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
228     supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
229     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
230     supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
231     supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
232     supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
233     supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
234     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
235     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
236     supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
237     supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
238     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
239     supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
240     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
241     supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
242     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
243     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
244     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
245     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
246     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
247     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
248     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
249     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
250     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
251     supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
252     supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_OPACITY);
253     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
254     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
255     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
256     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
257     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
258     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
259     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
260     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
261     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
262     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
263     supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
264     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
265     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
266     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
267     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
268     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
269     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
270     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
271     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
272     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
273     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
274     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
275     supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
276     supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
277     supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
278     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
279 /*
280     supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
281 */
282     supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
283     supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
284     supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
285     supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
286 #ifdef SYNC
287     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
288     supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
289 #endif
290     supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
291     supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
292
293     supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
294     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
295     supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
296
297     supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
298     supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
299     supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
300     supported[i++] = OBT_PROP_ATOM(OB_THEME);
301     supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
302     supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
303     supported[i++] = OBT_PROP_ATOM(OB_VERSION);
304     supported[i++] = OBT_PROP_ATOM(OB_APP_ROLE);
305     supported[i++] = OBT_PROP_ATOM(OB_APP_TITLE);
306     supported[i++] = OBT_PROP_ATOM(OB_APP_NAME);
307     supported[i++] = OBT_PROP_ATOM(OB_APP_CLASS);
308     supported[i++] = OBT_PROP_ATOM(OB_APP_TYPE);
309     g_assert(i == num_support);
310
311     OBT_PROP_SETA32(obt_root(ob_screen),
312                     NET_SUPPORTED, ATOM, supported, num_support);
313     g_free(supported);
314
315     OBT_PROP_SETS(RootWindow(obt_display, ob_screen), OB_VERSION,
316                   OPENBOX_VERSION);
317
318     screen_tell_ksplash();
319
320     return TRUE;
321 }
322
323 static void screen_tell_ksplash(void)
324 {
325     XEvent e;
326     char **argv;
327
328     argv = g_new(gchar*, 6);
329     argv[0] = g_strdup("dcop");
330     argv[1] = g_strdup("ksplash");
331     argv[2] = g_strdup("ksplash");
332     argv[3] = g_strdup("upAndRunning(QString)");
333     argv[4] = g_strdup("wm started");
334     argv[5] = NULL;
335
336     /* tell ksplash through the dcop server command line interface */
337     g_spawn_async(NULL, argv, NULL,
338                   G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
339                   G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
340                   NULL, NULL, NULL, NULL);
341     g_strfreev(argv);
342
343     /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
344        hear it anyways. perhaps it is for old ksplash. or new ksplash. or
345        something. oh well. */
346     e.xclient.type = ClientMessage;
347     e.xclient.display = obt_display;
348     e.xclient.window = obt_root(ob_screen);
349     e.xclient.message_type =
350         XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
351     e.xclient.format = 8;
352     strcpy(e.xclient.data.b, "wm started");
353     XSendEvent(obt_display, obt_root(ob_screen),
354                False, SubstructureNotifyMask, &e);
355 }
356
357 void screen_startup(gboolean reconfig)
358 {
359     gchar **names = NULL;
360     guint32 d;
361     gboolean namesexist = FALSE;
362
363     desktop_popup = pager_popup_new();
364     desktop_popup_perm = FALSE;
365     pager_popup_height(desktop_popup, POPUP_HEIGHT);
366
367     if (reconfig) {
368         /* update the pager popup's width */
369         pager_popup_text_width_to_strings(desktop_popup,
370                                           screen_desktop_names,
371                                           screen_num_desktops);
372         return;
373     }
374
375     /* get the initial size */
376     screen_resize();
377
378     /* have names already been set for the desktops? */
379     if (OBT_PROP_GETSS_UTF8(obt_root(ob_screen), NET_DESKTOP_NAMES, &names)) {
380         g_strfreev(names);
381         namesexist = TRUE;
382     }
383
384     /* if names don't exist and we have session names, set those.
385        do this stuff BEFORE setting the number of desktops, because that
386        will create default names for them
387     */
388     if (!namesexist && session_desktop_names != NULL) {
389         guint i, numnames;
390         GSList *it;
391
392         /* get the desktop names */
393         numnames = g_slist_length(session_desktop_names);
394         names = g_new(gchar*, numnames + 1);
395         names[numnames] = NULL;
396         for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
397             names[i] = g_strdup(it->data);
398
399         /* set the root window property */
400         OBT_PROP_SETSS(obt_root(ob_screen),
401                        NET_DESKTOP_NAMES, (const gchar*const*)names);
402
403         g_strfreev(names);
404     }
405
406     /* set the number of desktops, if it's not already set.
407
408        this will also set the default names from the config file up for
409        desktops that don't have names yet */
410     screen_num_desktops = 0;
411     if (OBT_PROP_GET32(obt_root(ob_screen),
412                        NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
413     {
414         if (d != config_desktops_num) {
415             /* TRANSLATORS: If you need to specify a different order of the
416                arguments, you can use %1$d for the first one and %2$d for the
417                second one. For example,
418                "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
419             g_warning(ngettext("Openbox is configured for %d desktop, but the current session has %d.  Overriding the Openbox configuration.", "Openbox is configured for %d desktops, but the current session has %d.  Overriding the Openbox configuration.", config_desktops_num),
420                       config_desktops_num, d);
421         }
422         screen_set_num_desktops(d);
423     }
424     /* restore from session if possible */
425     else if (session_num_desktops)
426         screen_set_num_desktops(session_num_desktops);
427     else
428         screen_set_num_desktops(config_desktops_num);
429
430     screen_desktop = screen_num_desktops;  /* something invalid */
431     /* start on the current desktop when a wm was already running */
432     if (OBT_PROP_GET32(obt_root(ob_screen),
433                        NET_CURRENT_DESKTOP, CARDINAL, &d) &&
434         d < screen_num_desktops)
435     {
436         screen_set_desktop(d, FALSE);
437     } else if (session_desktop >= 0)
438         screen_set_desktop(MIN((guint)session_desktop,
439                                screen_num_desktops), FALSE);
440     else
441         screen_set_desktop(MIN(config_screen_firstdesk,
442                                screen_num_desktops) - 1, FALSE);
443     screen_last_desktop = screen_desktop;
444
445     /* don't start in showing-desktop mode */
446     screen_showing_desktop = FALSE;
447     OBT_PROP_SET32(obt_root(ob_screen),
448                    NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
449
450     if (session_desktop_layout_present &&
451         screen_validate_layout(&session_desktop_layout))
452     {
453         screen_desktop_layout = session_desktop_layout;
454     }
455     else
456         screen_update_layout();
457 }
458
459 void screen_shutdown(gboolean reconfig)
460 {
461     pager_popup_free(desktop_popup);
462
463     if (reconfig)
464         return;
465
466     XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
467
468     /* we're not running here no more! */
469     OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
470     /* not without us */
471     OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
472     /* don't keep this mode */
473     OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
474
475     XDestroyWindow(obt_display, screen_support_win);
476
477     g_strfreev(screen_desktop_names);
478     screen_desktop_names = NULL;
479 }
480
481 void screen_resize(void)
482 {
483     gint w, h;
484     GList *it;
485     gulong geometry[2];
486
487     w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
488     h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
489
490     /* Set the _NET_DESKTOP_GEOMETRY hint */
491     screen_physical_size.width = geometry[0] = w;
492     screen_physical_size.height = geometry[1] = h;
493     OBT_PROP_SETA32(obt_root(ob_screen),
494                     NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
495
496     if (ob_state() != OB_STATE_RUNNING)
497         return;
498
499     /* this calls screen_update_areas(), which we need ! */
500     dock_configure();
501
502     for (it = client_list; it; it = g_list_next(it)) {
503         client_move_onscreen(it->data, FALSE);
504         client_reconfigure(it->data, FALSE);
505     }
506 }
507
508 void screen_set_num_desktops(guint num)
509 {
510     gulong *viewport;
511     GList *it, *stacking_copy;
512
513     g_assert(num > 0);
514
515     if (screen_num_desktops == num) return;
516
517     screen_num_desktops = num;
518     OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
519
520     /* set the viewport hint */
521     viewport = g_new0(gulong, num * 2);
522     OBT_PROP_SETA32(obt_root(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     screen_desktop_timer = 0;
604     return FALSE; /* don't repeat */
605 }
606
607 void screen_set_desktop(guint num, gboolean dofocus)
608 {
609     GList *it;
610     guint previous;
611     gulong ignore_start;
612
613     g_assert(num < screen_num_desktops);
614
615     previous = screen_desktop;
616     screen_desktop = num;
617
618     if (previous == num) return;
619
620     OBT_PROP_SET32(obt_root(ob_screen), 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     if (screen_desktop_timer) g_source_remove(screen_desktop_timer);
687     screen_desktop_timer = g_timeout_add(REMEMBER_LAST_DESKTOP_TIME,
688                                          last_desktop_func, NULL);
689
690     ob_debug("Moving to desktop %d", num+1);
691
692     if (ob_state() == OB_STATE_RUNNING)
693         screen_show_desktop_popup(screen_desktop, FALSE);
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             if (client_hide(c)) {
718                 if (c == focus_client) {
719                     /* c was focused and we didn't do fallback clearly so make
720                        sure openbox doesnt still consider the window focused.
721                        this happens when using NextWindow with allDesktops,
722                        since it doesnt want to move focus on desktop change,
723                        but the focus is not going to stay with the current
724                        window, which has now disappeared.
725                        only do this if the client was actually hidden,
726                        otherwise it can keep focus. */
727                     focus_set_client(NULL);
728                 }
729             }
730         }
731     }
732
733     focus_cycle_addremove(NULL, TRUE);
734
735     event_end_ignore_all_enters(ignore_start);
736
737     if (event_source_time() != CurrentTime)
738         screen_desktop_user_time = event_source_time();
739 }
740
741 void screen_add_desktop(gboolean current)
742 {
743     gulong ignore_start;
744
745     /* ignore enter events caused by this */
746     ignore_start = event_start_ignore_all_enters();
747
748     screen_set_num_desktops(screen_num_desktops+1);
749
750     /* move all the clients over */
751     if (current) {
752         GList *it;
753
754         for (it = client_list; it; it = g_list_next(it)) {
755             ObClient *c = it->data;
756             if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
757                 /* don't move direct children, they'll be moved with their
758                    parent - which will have to be on the same desktop */
759                 !client_direct_parent(c))
760             {
761                 ob_debug("moving window %s", c->title);
762                 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
763             }
764         }
765     }
766
767     event_end_ignore_all_enters(ignore_start);
768 }
769
770 void screen_remove_desktop(gboolean current)
771 {
772     guint rmdesktop, movedesktop;
773     GList *it, *stacking_copy;
774     gulong ignore_start;
775
776     if (screen_num_desktops <= 1) return;
777
778     /* ignore enter events caused by this */
779     ignore_start = event_start_ignore_all_enters();
780
781     /* what desktop are we removing and moving to? */
782     if (current)
783         rmdesktop = screen_desktop;
784     else
785         rmdesktop = screen_num_desktops - 1;
786     if (rmdesktop < screen_num_desktops - 1)
787         movedesktop = rmdesktop + 1;
788     else
789         movedesktop = rmdesktop;
790
791     /* make a copy of the list cuz we're changing it */
792     stacking_copy = g_list_copy(stacking_list);
793     for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
794         if (WINDOW_IS_CLIENT(it->data)) {
795             ObClient *c = it->data;
796             guint d = c->desktop;
797             if (d != DESKTOP_ALL && d >= movedesktop &&
798                 /* don't move direct children, they'll be moved with their
799                    parent - which will have to be on the same desktop */
800                 !client_direct_parent(c))
801             {
802                 ob_debug("moving window %s", c->title);
803                 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
804             }
805             /* raise all the windows that are on the current desktop which
806                is being merged */
807             if ((screen_desktop == rmdesktop - 1 ||
808                  screen_desktop == rmdesktop) &&
809                 (d == DESKTOP_ALL || d == screen_desktop))
810             {
811                 stacking_raise(CLIENT_AS_WINDOW(c));
812                 ob_debug("raising window %s", c->title);
813             }
814         }
815     }
816     g_list_free(stacking_copy);
817
818     /* fallback focus like we're changing desktops */
819     if (screen_desktop < screen_num_desktops - 1) {
820         screen_fallback_focus();
821         ob_debug("fake desktop change");
822     }
823
824     screen_set_num_desktops(screen_num_desktops-1);
825
826     event_end_ignore_all_enters(ignore_start);
827 }
828
829 static void get_row_col(guint d, guint *r, guint *c)
830 {
831     switch (screen_desktop_layout.orientation) {
832     case OB_ORIENTATION_HORZ:
833         switch (screen_desktop_layout.start_corner) {
834         case OB_CORNER_TOPLEFT:
835             *r = d / screen_desktop_layout.columns;
836             *c = d % screen_desktop_layout.columns;
837             break;
838         case OB_CORNER_BOTTOMLEFT:
839             *r = screen_desktop_layout.rows - 1 -
840                 d / screen_desktop_layout.columns;
841             *c = d % screen_desktop_layout.columns;
842             break;
843         case OB_CORNER_TOPRIGHT:
844             *r = d / screen_desktop_layout.columns;
845             *c = screen_desktop_layout.columns - 1 -
846                 d % screen_desktop_layout.columns;
847             break;
848         case OB_CORNER_BOTTOMRIGHT:
849             *r = screen_desktop_layout.rows - 1 -
850                 d / screen_desktop_layout.columns;
851             *c = screen_desktop_layout.columns - 1 -
852                 d % screen_desktop_layout.columns;
853             break;
854         }
855         break;
856     case OB_ORIENTATION_VERT:
857         switch (screen_desktop_layout.start_corner) {
858         case OB_CORNER_TOPLEFT:
859             *r = d % screen_desktop_layout.rows;
860             *c = d / screen_desktop_layout.rows;
861             break;
862         case OB_CORNER_BOTTOMLEFT:
863             *r = screen_desktop_layout.rows - 1 -
864                 d % screen_desktop_layout.rows;
865             *c = d / screen_desktop_layout.rows;
866             break;
867         case OB_CORNER_TOPRIGHT:
868             *r = d % screen_desktop_layout.rows;
869             *c = screen_desktop_layout.columns - 1 -
870                 d / screen_desktop_layout.rows;
871             break;
872         case OB_CORNER_BOTTOMRIGHT:
873             *r = screen_desktop_layout.rows - 1 -
874                 d % screen_desktop_layout.rows;
875             *c = screen_desktop_layout.columns - 1 -
876                 d / screen_desktop_layout.rows;
877             break;
878         }
879         break;
880     }
881 }
882
883 static guint translate_row_col(guint r, guint c)
884 {
885     switch (screen_desktop_layout.orientation) {
886     case OB_ORIENTATION_HORZ:
887         switch (screen_desktop_layout.start_corner) {
888         case OB_CORNER_TOPLEFT:
889             return r % screen_desktop_layout.rows *
890                 screen_desktop_layout.columns +
891                 c % screen_desktop_layout.columns;
892         case OB_CORNER_BOTTOMLEFT:
893             return (screen_desktop_layout.rows - 1 -
894                     r % screen_desktop_layout.rows) *
895                 screen_desktop_layout.columns +
896                 c % screen_desktop_layout.columns;
897         case OB_CORNER_TOPRIGHT:
898             return r % screen_desktop_layout.rows *
899                 screen_desktop_layout.columns +
900                 (screen_desktop_layout.columns - 1 -
901                  c % screen_desktop_layout.columns);
902         case OB_CORNER_BOTTOMRIGHT:
903             return (screen_desktop_layout.rows - 1 -
904                     r % screen_desktop_layout.rows) *
905                 screen_desktop_layout.columns +
906                 (screen_desktop_layout.columns - 1 -
907                  c % screen_desktop_layout.columns);
908         }
909     case OB_ORIENTATION_VERT:
910         switch (screen_desktop_layout.start_corner) {
911         case OB_CORNER_TOPLEFT:
912             return c % screen_desktop_layout.columns *
913                 screen_desktop_layout.rows +
914                 r % screen_desktop_layout.rows;
915         case OB_CORNER_BOTTOMLEFT:
916             return c % screen_desktop_layout.columns *
917                 screen_desktop_layout.rows +
918                 (screen_desktop_layout.rows - 1 -
919                  r % screen_desktop_layout.rows);
920         case OB_CORNER_TOPRIGHT:
921             return (screen_desktop_layout.columns - 1 -
922                     c % screen_desktop_layout.columns) *
923                 screen_desktop_layout.rows +
924                 r % screen_desktop_layout.rows;
925         case OB_CORNER_BOTTOMRIGHT:
926             return (screen_desktop_layout.columns - 1 -
927                     c % screen_desktop_layout.columns) *
928                 screen_desktop_layout.rows +
929                 (screen_desktop_layout.rows - 1 -
930                  r % screen_desktop_layout.rows);
931         }
932     }
933     g_assert_not_reached();
934     return 0;
935 }
936
937 static gboolean hide_desktop_popup_func(gpointer data)
938 {
939     pager_popup_hide(desktop_popup);
940     desktop_popup_timer = 0;
941     return FALSE; /* don't repeat */
942 }
943
944 void screen_show_desktop_popup(guint d, gboolean perm)
945 {
946     const Rect *a;
947
948     /* 0 means don't show the popup */
949     if (!config_desktop_popup_time) return;
950
951     a = screen_physical_area_primary(FALSE);
952     pager_popup_position(desktop_popup, CenterGravity,
953                          a->x + a->width / 2, a->y + a->height / 2);
954     pager_popup_icon_size_multiplier(desktop_popup,
955                                      (screen_desktop_layout.columns /
956                                       screen_desktop_layout.rows) / 2,
957                                      (screen_desktop_layout.rows/
958                                       screen_desktop_layout.columns) / 2);
959     pager_popup_max_width(desktop_popup,
960                           MAX(a->width/3, POPUP_WIDTH));
961     pager_popup_show(desktop_popup, screen_desktop_names[d], d);
962
963     if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
964     desktop_popup_timer = 0;
965     if (!perm && !desktop_popup_perm)
966         /* only hide if its not already being show permanently */
967         desktop_popup_timer = g_timeout_add(config_desktop_popup_time,
968                                             hide_desktop_popup_func,
969                                             desktop_popup);
970     if (perm)
971         desktop_popup_perm = TRUE;
972 }
973
974 void screen_hide_desktop_popup(void)
975 {
976     if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
977     desktop_popup_timer = 0;
978     pager_popup_hide(desktop_popup);
979     desktop_popup_perm = FALSE;
980 }
981
982 guint screen_find_desktop(guint from, ObDirection dir,
983                           gboolean wrap, gboolean linear)
984 {
985     guint r, c;
986     guint d;
987
988     d = from;
989     get_row_col(d, &r, &c);
990     if (linear) {
991         switch (dir) {
992         case OB_DIRECTION_EAST:
993             if (d < screen_num_desktops - 1)
994                 ++d;
995             else if (wrap)
996                 d = 0;
997             else
998                 return from;
999             break;
1000         case OB_DIRECTION_WEST:
1001             if (d > 0)
1002                 --d;
1003             else if (wrap)
1004                 d = screen_num_desktops - 1;
1005             else
1006                 return from;
1007             break;
1008         default:
1009             g_assert_not_reached();
1010             return from;
1011         }
1012     } else {
1013         switch (dir) {
1014         case OB_DIRECTION_EAST:
1015             ++c;
1016             if (c >= screen_desktop_layout.columns) {
1017                 if (wrap)
1018                     c = 0;
1019                 else
1020                     return from;
1021             }
1022             d = translate_row_col(r, c);
1023             if (d >= screen_num_desktops) {
1024                 if (wrap)
1025                     ++c;
1026                 else
1027                     return from;
1028             }
1029             break;
1030         case OB_DIRECTION_WEST:
1031             --c;
1032             if (c >= screen_desktop_layout.columns) {
1033                 if (wrap)
1034                     c = screen_desktop_layout.columns - 1;
1035                 else
1036                     return from;
1037             }
1038             d = translate_row_col(r, c);
1039             if (d >= screen_num_desktops) {
1040                 if (wrap)
1041                     --c;
1042                 else
1043                     return from;
1044             }
1045             break;
1046         case OB_DIRECTION_SOUTH:
1047             ++r;
1048             if (r >= screen_desktop_layout.rows) {
1049                 if (wrap)
1050                     r = 0;
1051                 else
1052                     return from;
1053             }
1054             d = translate_row_col(r, c);
1055             if (d >= screen_num_desktops) {
1056                 if (wrap)
1057                     ++r;
1058                 else
1059                     return from;
1060             }
1061             break;
1062         case OB_DIRECTION_NORTH:
1063             --r;
1064             if (r >= screen_desktop_layout.rows) {
1065                 if (wrap)
1066                     r = screen_desktop_layout.rows - 1;
1067                 else
1068                     return from;
1069             }
1070             d = translate_row_col(r, c);
1071             if (d >= screen_num_desktops) {
1072                 if (wrap)
1073                     --r;
1074                 else
1075                     return from;
1076             }
1077             break;
1078         default:
1079             g_assert_not_reached();
1080             return from;
1081         }
1082
1083         d = translate_row_col(r, c);
1084     }
1085     return d;
1086 }
1087
1088 static gboolean screen_validate_layout(ObDesktopLayout *l)
1089 {
1090     if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1091         return FALSE;
1092
1093     /* fill in a zero rows/columns */
1094     if (l->columns == 0) {
1095         l->columns = screen_num_desktops / l->rows;
1096         if (l->rows * l->columns < screen_num_desktops)
1097             l->columns++;
1098         if (l->rows * l->columns >= screen_num_desktops + l->columns)
1099             l->rows--;
1100     } else if (l->rows == 0) {
1101         l->rows = screen_num_desktops / l->columns;
1102         if (l->columns * l->rows < screen_num_desktops)
1103             l->rows++;
1104         if (l->columns * l->rows >= screen_num_desktops + l->rows)
1105             l->columns--;
1106     }
1107
1108     /* bounds checking */
1109     if (l->orientation == OB_ORIENTATION_HORZ) {
1110         l->columns = MIN(screen_num_desktops, l->columns);
1111         l->rows = MIN(l->rows,
1112                       (screen_num_desktops + l->columns - 1) / l->columns);
1113         l->columns = screen_num_desktops / l->rows +
1114             !!(screen_num_desktops % l->rows);
1115     } else {
1116         l->rows = MIN(screen_num_desktops, l->rows);
1117         l->columns = MIN(l->columns,
1118                          (screen_num_desktops + l->rows - 1) / l->rows);
1119         l->rows = screen_num_desktops / l->columns +
1120             !!(screen_num_desktops % l->columns);
1121     }
1122     return TRUE;
1123 }
1124
1125 void screen_update_layout(void)
1126
1127 {
1128     ObDesktopLayout l;
1129     guint32 *data;
1130     guint num;
1131
1132     screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1133     screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1134     screen_desktop_layout.rows = 1;
1135     screen_desktop_layout.columns = screen_num_desktops;
1136
1137     if (OBT_PROP_GETA32(obt_root(ob_screen),
1138                         NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1139         if (num == 3 || num == 4) {
1140
1141             if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1142                 l.orientation = OB_ORIENTATION_VERT;
1143             else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1144                 l.orientation = OB_ORIENTATION_HORZ;
1145             else
1146                 return;
1147
1148             if (num < 4)
1149                 l.start_corner = OB_CORNER_TOPLEFT;
1150             else {
1151                 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1152                     l.start_corner = OB_CORNER_TOPLEFT;
1153                 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1154                     l.start_corner = OB_CORNER_TOPRIGHT;
1155                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1156                     l.start_corner = OB_CORNER_BOTTOMRIGHT;
1157                 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1158                     l.start_corner = OB_CORNER_BOTTOMLEFT;
1159                 else
1160                     return;
1161             }
1162
1163             l.columns = data[1];
1164             l.rows = data[2];
1165
1166             if (screen_validate_layout(&l))
1167                 screen_desktop_layout = l;
1168
1169             g_free(data);
1170         }
1171     }
1172 }
1173
1174 void screen_update_desktop_names(void)
1175 {
1176     guint i;
1177
1178     /* empty the array */
1179     g_strfreev(screen_desktop_names);
1180     screen_desktop_names = NULL;
1181
1182     if (OBT_PROP_GETSS(obt_root(ob_screen),
1183                        NET_DESKTOP_NAMES, &screen_desktop_names))
1184         for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1185     else
1186         i = 0;
1187     if (i < screen_num_desktops) {
1188         GSList *it;
1189
1190         screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1191                                        screen_num_desktops + 1);
1192         screen_desktop_names[screen_num_desktops] = NULL;
1193
1194         it = g_slist_nth(config_desktops_names, i);
1195
1196         for (; i < screen_num_desktops; ++i) {
1197             if (it && ((char*)it->data)[0]) /* not empty */
1198                 /* use the names from the config file when possible */
1199                 screen_desktop_names[i] = g_strdup(it->data);
1200             else
1201                 /* make up a nice name if it's not though */
1202                 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1203                                                           i + 1);
1204             if (it) it = g_slist_next(it);
1205         }
1206
1207         /* if we changed any names, then set the root property so we can
1208            all agree on the names */
1209         OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1210                        (const gchar*const*)screen_desktop_names);
1211     }
1212
1213     /* resize the pager for these names */
1214     pager_popup_text_width_to_strings(desktop_popup,
1215                                       screen_desktop_names,
1216                                       screen_num_desktops);
1217 }
1218
1219 void screen_show_desktop(gboolean show, ObClient *show_only)
1220 {
1221     GList *it;
1222
1223     if (show == screen_showing_desktop) return; /* no change */
1224
1225     screen_showing_desktop = show;
1226
1227     if (show) {
1228         /* hide windows bottom to top */
1229         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1230             if (WINDOW_IS_CLIENT(it->data)) {
1231                 ObClient *client = it->data;
1232                 client_showhide(client);
1233             }
1234         }
1235     }
1236     else {
1237         /* restore windows top to bottom */
1238         for (it = stacking_list; it; it = g_list_next(it)) {
1239             if (WINDOW_IS_CLIENT(it->data)) {
1240                 ObClient *client = it->data;
1241                 if (client_should_show(client)) {
1242                     if (!show_only || client == show_only)
1243                         client_show(client);
1244                     else
1245                         client_iconify(client, TRUE, FALSE, TRUE);
1246                 }
1247             }
1248         }
1249     }
1250
1251     if (show) {
1252         /* focus the desktop */
1253         for (it = focus_order; it; it = g_list_next(it)) {
1254             ObClient *c = it->data;
1255             if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1256                 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1257                 client_focus(it->data))
1258                 break;
1259         }
1260     }
1261     else if (!show_only) {
1262         ObClient *c;
1263
1264         if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1265             /* only do the flicker reducing stuff ahead of time if we are going
1266                to call xsetinputfocus on the window ourselves. otherwise there
1267                is no guarantee the window will actually take focus.. */
1268             if (c->can_focus) {
1269                 /* reduce flicker by hiliting now rather than waiting for the
1270                    server FocusIn event */
1271                 frame_adjust_focus(c->frame, TRUE);
1272             }
1273         }
1274     }
1275
1276     show = !!show; /* make it boolean */
1277     OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1278 }
1279
1280 void screen_install_colormap(ObClient *client, gboolean install)
1281 {
1282     if (client == NULL || client->colormap == None) {
1283         if (install)
1284             XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1285         else
1286             XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1287     } else {
1288         obt_display_ignore_errors(TRUE);
1289         if (install)
1290             XInstallColormap(obt_display, client->colormap);
1291         else
1292             XUninstallColormap(obt_display, client->colormap);
1293         obt_display_ignore_errors(FALSE);
1294     }
1295 }
1296
1297 typedef struct {
1298     guint desktop;
1299     StrutPartial *strut;
1300 } ObScreenStrut;
1301
1302 #define RESET_STRUT_LIST(sl) \
1303     while (sl) { \
1304         g_slice_free(ObScreenStrut, (sl)->data); \
1305         sl = g_slist_delete_link(sl, sl); \
1306     }
1307
1308 #define ADD_STRUT_TO_LIST(sl, d, s) \
1309 { \
1310     ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1311     ss->desktop = d; \
1312     ss->strut = s;  \
1313     sl = g_slist_prepend(sl, ss); \
1314 }
1315
1316 #define VALIDATE_STRUTS(sl, side, max) \
1317 { \
1318     GSList *it; \
1319     for (it = sl; it; it = g_slist_next(it)) { \
1320       ObScreenStrut *ss = it->data; \
1321       ss->strut->side = MIN(max, ss->strut->side); \
1322     } \
1323 }
1324
1325 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1326 {
1327     guint i;
1328     gint n, l, r, t, b;
1329 #ifdef XINERAMA
1330     XineramaScreenInfo *info;
1331 #endif
1332
1333     if (ob_debug_xinerama) {
1334         gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1335         gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1336         *nxin = 2;
1337         *xin_areas = g_new(Rect, *nxin + 1);
1338         RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1339         RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1340     }
1341 #ifdef XINERAMA
1342     else if (obt_display_extension_xinerama &&
1343              (info = XineramaQueryScreens(obt_display, &n))) {
1344         *nxin = n;
1345         *xin_areas = g_new(Rect, *nxin + 1);
1346         for (i = 0; i < *nxin; ++i)
1347             RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1348                      info[i].width, info[i].height);
1349         XFree(info);
1350     }
1351 #endif
1352     else {
1353         *nxin = 1;
1354         *xin_areas = g_new(Rect, *nxin + 1);
1355         RECT_SET((*xin_areas)[0], 0, 0,
1356                  WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1357                  HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1358     }
1359
1360     /* returns one extra with the total area in it */
1361     l = (*xin_areas)[0].x;
1362     t = (*xin_areas)[0].y;
1363     r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1364     b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1365     for (i = 1; i < *nxin; ++i) {
1366         l = MIN(l, (*xin_areas)[i].x);
1367         t = MIN(l, (*xin_areas)[i].y);
1368         r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1369         b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1370     }
1371     RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1372
1373     for (i = 0; i < *nxin; ++i)
1374         ob_debug("Monitor %d @ %d,%d %dx%d\n", i,
1375                  (*xin_areas)[i].x, (*xin_areas)[i].y,
1376                  (*xin_areas)[i].width, (*xin_areas)[i].height);
1377     ob_debug("Full desktop @ %d,%d %dx%d\n",
1378              (*xin_areas)[i].x, (*xin_areas)[i].y,
1379              (*xin_areas)[i].width, (*xin_areas)[i].height);
1380 }
1381
1382 void screen_update_areas(void)
1383 {
1384     guint i;
1385     gulong *dims;
1386     GList *it, *onscreen;
1387
1388     /* collect the clients that are on screen */
1389     onscreen = NULL;
1390     for (it = client_list; it; it = g_list_next(it)) {
1391         if (client_monitor(it->data) != screen_num_monitors)
1392             onscreen = g_list_prepend(onscreen, it->data);
1393     }
1394
1395     g_free(monitor_area);
1396     get_xinerama_screens(&monitor_area, &screen_num_monitors);
1397
1398     /* set up the user-specified margins */
1399     config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1400     config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1401     config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1402     config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1403     config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1404     config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1405     config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1406     config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1407
1408     RESET_STRUT_LIST(struts_left);
1409     RESET_STRUT_LIST(struts_top);
1410     RESET_STRUT_LIST(struts_right);
1411     RESET_STRUT_LIST(struts_bottom);
1412
1413     /* collect the struts */
1414     for (it = client_list; it; it = g_list_next(it)) {
1415         ObClient *c = it->data;
1416         if (c->strut.left)
1417             ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1418         if (c->strut.top)
1419             ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1420         if (c->strut.right)
1421             ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1422         if (c->strut.bottom)
1423             ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1424     }
1425     if (dock_strut.left)
1426         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1427     if (dock_strut.top)
1428         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1429     if (dock_strut.right)
1430         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1431     if (dock_strut.bottom)
1432         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1433
1434     if (config_margins.left)
1435         ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1436     if (config_margins.top)
1437         ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1438     if (config_margins.right)
1439         ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1440     if (config_margins.bottom)
1441         ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1442
1443     VALIDATE_STRUTS(struts_left, left,
1444                     monitor_area[screen_num_monitors].width / 2);
1445     VALIDATE_STRUTS(struts_right, right,
1446                     monitor_area[screen_num_monitors].width / 2);
1447     VALIDATE_STRUTS(struts_top, top,
1448                     monitor_area[screen_num_monitors].height / 2);
1449     VALIDATE_STRUTS(struts_bottom, bottom,
1450                     monitor_area[screen_num_monitors].height / 2);
1451
1452     dims = g_new(gulong, 4 * screen_num_desktops);
1453     for (i = 0; i < screen_num_desktops; ++i) {
1454         Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1455         dims[i*4+0] = area->x;
1456         dims[i*4+1] = area->y;
1457         dims[i*4+2] = area->width;
1458         dims[i*4+3] = area->height;
1459         g_slice_free(Rect, area);
1460     }
1461
1462     /* set the legacy workarea hint to the union of all the monitors */
1463     OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1464                     dims, 4 * screen_num_desktops);
1465
1466     /* the area has changed, adjust all the windows if they need it */
1467     for (it = onscreen; it; it = g_list_next(it))
1468         client_reconfigure(it->data, FALSE);
1469
1470     g_free(dims);
1471 }
1472
1473 #if 0
1474 Rect* screen_area_all_monitors(guint desktop)
1475 {
1476     guint i;
1477     Rect *a;
1478
1479     a = screen_area_monitor(desktop, 0);
1480
1481     /* combine all the monitors together */
1482     for (i = 1; i < screen_num_monitors; ++i) {
1483         Rect *m = screen_area_monitor(desktop, i);
1484         gint l, r, t, b;
1485
1486         l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1487         t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1488         r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1489         b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1490
1491         RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1492
1493         g_free(m);
1494     }
1495
1496     return a;
1497 }
1498 #endif
1499
1500 #define STRUT_LEFT_IN_SEARCH(s, search) \
1501     (RANGES_INTERSECT(search->y, search->height, \
1502                       s->left_start, s->left_end - s->left_start + 1))
1503 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1504     (RANGES_INTERSECT(search->y, search->height, \
1505                       s->right_start, s->right_end - s->right_start + 1))
1506 #define STRUT_TOP_IN_SEARCH(s, search) \
1507     (RANGES_INTERSECT(search->x, search->width, \
1508                       s->top_start, s->top_end - s->top_start + 1))
1509 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1510     (RANGES_INTERSECT(search->x, search->width, \
1511                       s->bottom_start, s->bottom_end - s->bottom_start + 1))
1512
1513 #define STRUT_LEFT_IGNORE(s, us, search) \
1514     (head == SCREEN_AREA_ALL_MONITORS && us && \
1515      RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1516 #define STRUT_RIGHT_IGNORE(s, us, search) \
1517     (head == SCREEN_AREA_ALL_MONITORS && us && \
1518      RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1519 #define STRUT_TOP_IGNORE(s, us, search) \
1520     (head == SCREEN_AREA_ALL_MONITORS && us && \
1521      RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1522 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1523     (head == SCREEN_AREA_ALL_MONITORS && us && \
1524      RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1525
1526 Rect* screen_area(guint desktop, guint head, Rect *search)
1527 {
1528     Rect *a;
1529     GSList *it;
1530     gint l, r, t, b;
1531     guint i, d;
1532     gboolean us = search != NULL; /* user provided search */
1533
1534     g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1535     g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1536              head == SCREEN_AREA_ALL_MONITORS);
1537     g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1538
1539     /* find any struts for this monitor
1540        which will be affecting the search area.
1541     */
1542
1543     /* search everything if search is null */
1544     if (!search) {
1545         if (head < screen_num_monitors) search = &monitor_area[head];
1546         else search = &monitor_area[screen_num_monitors];
1547     }
1548     if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1549
1550     /* al is "all left" meaning the furthest left you can get, l is our
1551        "working left" meaning our current strut edge which we're calculating
1552     */
1553
1554     /* only include monitors which the search area lines up with */
1555     if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1556         l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1557         t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1558         r = RECT_LEFT(monitor_area[screen_num_monitors]);
1559         b = RECT_TOP(monitor_area[screen_num_monitors]);
1560         for (i = 0; i < screen_num_monitors; ++i) {
1561             /* add the monitor if applicable */
1562             if (RANGES_INTERSECT(search->x, search->width,
1563                                  monitor_area[i].x, monitor_area[i].width))
1564             {
1565                 t = MIN(t, RECT_TOP(monitor_area[i]));
1566                 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1567             }
1568             if (RANGES_INTERSECT(search->y, search->height,
1569                                  monitor_area[i].y, monitor_area[i].height))
1570             {
1571                 l = MIN(l, RECT_LEFT(monitor_area[i]));
1572                 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1573             }
1574         }
1575     } else {
1576         l = RECT_LEFT(monitor_area[screen_num_monitors]);
1577         t = RECT_TOP(monitor_area[screen_num_monitors]);
1578         r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1579         b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1580     }
1581
1582     for (d = 0; d < screen_num_desktops; ++d) {
1583         if (d != desktop && desktop != DESKTOP_ALL) continue;
1584
1585         for (i = 0; i < screen_num_monitors; ++i) {
1586             if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1587
1588             for (it = struts_left; it; it = g_slist_next(it)) {
1589                 ObScreenStrut *s = it->data;
1590                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1591                     STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1592                     !STRUT_LEFT_IGNORE(s->strut, us, search))
1593                     l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1594                                + s->strut->left);
1595             }
1596             for (it = struts_top; it; it = g_slist_next(it)) {
1597                 ObScreenStrut *s = it->data;
1598                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1599                     STRUT_TOP_IN_SEARCH(s->strut, search) &&
1600                     !STRUT_TOP_IGNORE(s->strut, us, search))
1601                     t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1602                                + s->strut->top);
1603             }
1604             for (it = struts_right; it; it = g_slist_next(it)) {
1605                 ObScreenStrut *s = it->data;
1606                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1607                     STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1608                     !STRUT_RIGHT_IGNORE(s->strut, us, search))
1609                     r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1610                                - s->strut->right);
1611             }
1612             for (it = struts_bottom; it; it = g_slist_next(it)) {
1613                 ObScreenStrut *s = it->data;
1614                 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1615                     STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1616                     !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1617                     b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1618                                - s->strut->bottom);
1619             }
1620
1621             /* limit to this monitor */
1622             if (head == i) {
1623                 l = MAX(l, RECT_LEFT(monitor_area[i]));
1624                 t = MAX(t, RECT_TOP(monitor_area[i]));
1625                 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1626                 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1627             }
1628         }
1629     }
1630
1631     a = g_slice_new(Rect);
1632     a->x = l;
1633     a->y = t;
1634     a->width = r - l + 1;
1635     a->height = b - t + 1;
1636     return a;
1637 }
1638
1639 typedef struct {
1640     Rect r;
1641     gboolean subtract;
1642 } RectArithmetic;
1643
1644 guint screen_find_monitor(const Rect *search)
1645 {
1646     guint i;
1647     guint mostpx_index = screen_num_monitors;
1648     guint mostpx = 0;
1649     guint closest_distance_index = screen_num_monitors;
1650     guint closest_distance = G_MAXUINT;
1651     GSList *counted = NULL;
1652
1653     /* we want to count the number of pixels search has on each monitor, but not
1654        double count.  so if a pixel is counted on monitor A then we should not
1655        count it again on monitor B. in the end we want to return the monitor
1656        that had the most pixels counted under this scheme.
1657
1658        this assumes that monitors earlier in the list are more desirable to be
1659        considered the search area's monitor.  we try the configured primary
1660        monitor first, so it gets the highest preference.
1661
1662        if we have counted an area A, then we want to subtract the intersection
1663        of A with the area on future monitors.
1664        but now consider if we count an area B that intersects A. we want to
1665        subtract the area B from that counted on future monitors, but not
1666        subtract the intersection of A and B twice! so we would add the
1667        intersection of A and B back, to account for it being subtracted both
1668        for A and B.
1669
1670        this is the idea behind the algorithm.  we always subtract the full area
1671        for monitor M intersected with the search area. we'll call that AREA.
1672        but then we go through the list |counted| and for each rectangle in
1673        the list that is being subtracted from future monitors, we insert a
1674        request to add back the intersection of the subtracted rect with AREA.
1675        vice versa for a rect in |counted| that is getting added back.
1676     */
1677
1678     if (config_primary_monitor_index < screen_num_monitors) {
1679         const Rect *monitor;
1680         Rect on_current_monitor;
1681         glong area;
1682
1683         monitor = screen_physical_area_monitor(config_primary_monitor_index);
1684
1685         if (RECT_INTERSECTS_RECT(*monitor, *search)) {
1686             RECT_SET_INTERSECTION(on_current_monitor, *monitor, *search);
1687             area = RECT_AREA(on_current_monitor);
1688
1689             if (area > mostpx) {
1690                 mostpx = area;
1691                 mostpx_index = config_primary_monitor_index;
1692             }
1693
1694             /* add the intersection rect on the current monitor to the
1695                counted list. that's easy for the first one, we just mark it for
1696                subtraction */
1697             {
1698                 RectArithmetic *ra = g_slice_new(RectArithmetic);
1699                 ra->r = on_current_monitor;
1700                 ra->subtract = TRUE;
1701                 counted = g_slist_prepend(counted, ra);
1702             }
1703         }
1704     }
1705
1706     for (i = 0; i < screen_num_monitors; ++i) {
1707         const Rect *monitor;
1708         Rect on_current_monitor;
1709         glong area;
1710         GSList *it;
1711
1712         monitor = screen_physical_area_monitor(i);
1713
1714         if (!RECT_INTERSECTS_RECT(*monitor, *search)) {
1715             /* If we don't intersect then find the distance between the search
1716                rect and the monitor. We'll use the closest monitor from this
1717                metric if none of the monitors intersect. */
1718             guint distance = rect_manhatten_distance(*monitor, *search);
1719
1720             if (distance < closest_distance) {
1721                 closest_distance = distance;
1722                 closest_distance_index = i;
1723             }
1724             continue;
1725         }
1726
1727         if (i == config_primary_monitor_index)
1728             continue;  /* already did this one */
1729
1730         RECT_SET_INTERSECTION(on_current_monitor, *monitor, *search);
1731         area = RECT_AREA(on_current_monitor);
1732
1733         /* remove pixels we already counted on any previous monitors. */
1734         for (it = counted; it; it = g_slist_next(it)) {
1735             RectArithmetic *ra = it->data;
1736             Rect intersection;
1737
1738             RECT_SET_INTERSECTION(intersection, ra->r, *search);
1739             if (ra->subtract) area -= RECT_AREA(intersection);
1740             else area += RECT_AREA(intersection);
1741         }
1742
1743         if (area > mostpx) {
1744             mostpx = area;
1745             mostpx_index = i;
1746         }
1747
1748         /* add the intersection rect on the current monitor I to the counted
1749            list.
1750            but now we need to compensate for every rectangle R already in the
1751            counted list, and add a new rect R' that is the intersection of
1752            R and I, but with the reverse subtraction/addition operation.
1753         */
1754         for (it = counted; it; it = g_slist_next(it)) {
1755             RectArithmetic *saved = it->data;
1756
1757             if (!RECT_INTERSECTS_RECT(saved->r, on_current_monitor))
1758                 continue;
1759             /* we are going to subtract our rect from future monitors, but
1760                part of it may already be being subtracted/added, so compensate
1761                to not double add/subtract. */
1762             RectArithmetic *reverse = g_slice_new(RectArithmetic);
1763             RECT_SET_INTERSECTION(reverse->r, saved->r, on_current_monitor);
1764             reverse->subtract = !saved->subtract;
1765             /* prepend so we can continue thru the list uninterupted */
1766             counted = g_slist_prepend(counted, reverse);
1767         }
1768         {
1769             RectArithmetic *ra = g_slice_new(RectArithmetic);
1770             ra->r = on_current_monitor;
1771             ra->subtract = TRUE;
1772             counted = g_slist_prepend(counted, ra);
1773         }
1774     }
1775
1776     while (counted) {
1777         g_slice_free(RectArithmetic, counted->data);
1778         counted = g_slist_delete_link(counted, counted);
1779     }
1780
1781     if (mostpx_index < screen_num_monitors)
1782         return mostpx_index;
1783
1784     g_assert(closest_distance_index < screen_num_monitors);
1785     return closest_distance_index;
1786 }
1787
1788 const Rect* screen_physical_area_all_monitors(void)
1789 {
1790     return screen_physical_area_monitor(screen_num_monitors);
1791 }
1792
1793 const Rect* screen_physical_area_monitor(guint head)
1794 {
1795     g_assert(head <= screen_num_monitors);
1796
1797     return &monitor_area[head];
1798 }
1799
1800 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1801 {
1802     g_assert(head <= screen_num_monitors);
1803     g_assert(search);
1804     return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1805 }
1806
1807 guint screen_monitor_active(void)
1808 {
1809     if (moveresize_client)
1810         return client_monitor(moveresize_client);
1811     else if (focus_client)
1812         return client_monitor(focus_client);
1813     else
1814         return screen_monitor_pointer();
1815 }
1816
1817 const Rect* screen_physical_area_active(void)
1818 {
1819     return screen_physical_area_monitor(screen_monitor_active());
1820 }
1821
1822 guint screen_monitor_primary(gboolean fixed)
1823 {
1824     if (config_primary_monitor_index > 0) {
1825         if (config_primary_monitor_index-1 < screen_num_monitors)
1826             return config_primary_monitor_index - 1;
1827         else
1828             return 0;
1829     }
1830     else if (fixed)
1831         return 0;
1832     else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1833         return screen_monitor_active();
1834     else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1835         return screen_monitor_pointer();
1836 }
1837
1838 const Rect* screen_physical_area_primary(gboolean fixed)
1839 {
1840     return screen_physical_area_monitor(screen_monitor_primary(fixed));
1841 }
1842
1843 void screen_set_root_cursor(void)
1844 {
1845     if (sn_app_starting())
1846         XDefineCursor(obt_display, obt_root(ob_screen),
1847                       ob_cursor(OB_CURSOR_BUSYPOINTER));
1848     else
1849         XDefineCursor(obt_display, obt_root(ob_screen),
1850                       ob_cursor(OB_CURSOR_POINTER));
1851 }
1852
1853 guint screen_find_monitor_point(guint x, guint y)
1854 {
1855     Rect mon;
1856     RECT_SET(mon, x, y, 1, 1);
1857     return screen_find_monitor(&mon);
1858 }
1859
1860 guint screen_monitor_pointer()
1861 {
1862     gint x, y;
1863     if (!screen_pointer_pos(&x, &y))
1864         x = y = 0;
1865     return screen_find_monitor_point(x, y);
1866 }
1867
1868 gboolean screen_pointer_pos(gint *x, gint *y)
1869 {
1870     Window w;
1871     gint i;
1872     guint u;
1873     gboolean ret;
1874
1875     ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1876                           &w, &w, x, y, &i, &i, &u);
1877     if (!ret) {
1878         for (i = 0; i < ScreenCount(obt_display); ++i)
1879             if (i != ob_screen)
1880                 if (XQueryPointer(obt_display, obt_root(i),
1881                                   &w, &w, x, y, &i, &i, &u))
1882                     break;
1883     }
1884     return ret;
1885 }
1886
1887 gboolean screen_compare_desktops(guint a, guint b)
1888 {
1889     if (a == DESKTOP_ALL)
1890         a = screen_desktop;
1891     if (b == DESKTOP_ALL)
1892         b = screen_desktop;
1893     return a == b;
1894 }