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 ObScreenShowDestopMode screen_show_desktop_mode;
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
replace_wm(void)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
screen_annex(void)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_GROUP_NAME);
309 supported[i++] = OBT_PROP_ATOM(OB_APP_GROUP_CLASS);
310 supported[i++] = OBT_PROP_ATOM(OB_APP_TYPE);
311 g_assert(i == num_support);
312
313 OBT_PROP_SETA32(obt_root(ob_screen),
314 NET_SUPPORTED, ATOM, supported, num_support);
315 g_free(supported);
316
317 OBT_PROP_SETS(RootWindow(obt_display, ob_screen), OB_VERSION,
318 OPENBOX_VERSION);
319
320 screen_tell_ksplash();
321
322 return TRUE;
323 }
324
screen_tell_ksplash(void)325 static void screen_tell_ksplash(void)
326 {
327 XEvent e;
328 char **argv;
329
330 argv = g_new(gchar*, 6);
331 argv[0] = g_strdup("dcop");
332 argv[1] = g_strdup("ksplash");
333 argv[2] = g_strdup("ksplash");
334 argv[3] = g_strdup("upAndRunning(QString)");
335 argv[4] = g_strdup("wm started");
336 argv[5] = NULL;
337
338 /* tell ksplash through the dcop server command line interface */
339 g_spawn_async(NULL, argv, NULL,
340 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
341 G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
342 NULL, NULL, NULL, NULL);
343 g_strfreev(argv);
344
345 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
346 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
347 something. oh well. */
348 e.xclient.type = ClientMessage;
349 e.xclient.display = obt_display;
350 e.xclient.window = obt_root(ob_screen);
351 e.xclient.message_type =
352 XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
353 e.xclient.format = 8;
354 strcpy(e.xclient.data.b, "wm started");
355 XSendEvent(obt_display, obt_root(ob_screen),
356 False, SubstructureNotifyMask, &e);
357 }
358
screen_startup(gboolean reconfig)359 void screen_startup(gboolean reconfig)
360 {
361 gchar **names = NULL;
362 guint32 d;
363 gboolean namesexist = FALSE;
364
365 desktop_popup = pager_popup_new();
366 desktop_popup_perm = FALSE;
367 pager_popup_height(desktop_popup, POPUP_HEIGHT);
368
369 if (reconfig) {
370 /* update the pager popup's width */
371 pager_popup_text_width_to_strings(desktop_popup,
372 screen_desktop_names,
373 screen_num_desktops);
374 return;
375 }
376
377 /* get the initial size */
378 screen_resize();
379
380 /* have names already been set for the desktops? */
381 if (OBT_PROP_GETSS_UTF8(obt_root(ob_screen), NET_DESKTOP_NAMES, &names)) {
382 g_strfreev(names);
383 namesexist = TRUE;
384 }
385
386 /* if names don't exist and we have session names, set those.
387 do this stuff BEFORE setting the number of desktops, because that
388 will create default names for them
389 */
390 if (!namesexist && session_desktop_names != NULL) {
391 guint i, numnames;
392 GSList *it;
393
394 /* get the desktop names */
395 numnames = g_slist_length(session_desktop_names);
396 names = g_new(gchar*, numnames + 1);
397 names[numnames] = NULL;
398 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
399 names[i] = g_strdup(it->data);
400
401 /* set the root window property */
402 OBT_PROP_SETSS(obt_root(ob_screen),
403 NET_DESKTOP_NAMES, (const gchar*const*)names);
404
405 g_strfreev(names);
406 }
407
408 /* set the number of desktops, if it's not already set.
409
410 this will also set the default names from the config file up for
411 desktops that don't have names yet */
412 screen_num_desktops = 0;
413 if (OBT_PROP_GET32(obt_root(ob_screen),
414 NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
415 {
416 if (d != config_desktops_num) {
417 /* TRANSLATORS: If you need to specify a different order of the
418 arguments, you can use %1$d for the first one and %2$d for the
419 second one. For example,
420 "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
421 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),
422 config_desktops_num, d);
423 }
424 screen_set_num_desktops(d);
425 }
426 /* restore from session if possible */
427 else if (session_num_desktops)
428 screen_set_num_desktops(session_num_desktops);
429 else
430 screen_set_num_desktops(config_desktops_num);
431
432 screen_desktop = screen_num_desktops; /* something invalid */
433 /* start on the current desktop when a wm was already running */
434 if (OBT_PROP_GET32(obt_root(ob_screen),
435 NET_CURRENT_DESKTOP, CARDINAL, &d) &&
436 d < screen_num_desktops)
437 {
438 screen_set_desktop(d, FALSE);
439 } else if (session_desktop >= 0)
440 screen_set_desktop(MIN((guint)session_desktop,
441 screen_num_desktops), FALSE);
442 else
443 screen_set_desktop(MIN(config_screen_firstdesk,
444 screen_num_desktops) - 1, FALSE);
445 screen_last_desktop = screen_desktop;
446
447 /* don't start in showing-desktop mode */
448 screen_show_desktop_mode = SCREEN_SHOW_DESKTOP_NO;
449 OBT_PROP_SET32(obt_root(ob_screen),
450 NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop());
451
452 if (session_desktop_layout_present &&
453 screen_validate_layout(&session_desktop_layout))
454 {
455 screen_desktop_layout = session_desktop_layout;
456 }
457 else
458 screen_update_layout();
459 }
460
screen_shutdown(gboolean reconfig)461 void screen_shutdown(gboolean reconfig)
462 {
463 pager_popup_free(desktop_popup);
464
465 if (reconfig)
466 return;
467
468 XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
469
470 /* we're not running here no more! */
471 OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
472 /* not without us */
473 OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
474 /* don't keep this mode */
475 OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
476
477 XDestroyWindow(obt_display, screen_support_win);
478
479 g_strfreev(screen_desktop_names);
480 screen_desktop_names = NULL;
481 }
482
screen_resize(void)483 void screen_resize(void)
484 {
485 gint w, h;
486 GList *it;
487 gulong geometry[2];
488
489 w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
490 h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
491
492 /* Set the _NET_DESKTOP_GEOMETRY hint */
493 screen_physical_size.width = geometry[0] = w;
494 screen_physical_size.height = geometry[1] = h;
495 OBT_PROP_SETA32(obt_root(ob_screen),
496 NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
497
498 if (ob_state() != OB_STATE_RUNNING)
499 return;
500
501 /* this calls screen_update_areas(), which we need ! */
502 dock_configure();
503
504 for (it = client_list; it; it = g_list_next(it)) {
505 client_move_onscreen(it->data, FALSE);
506 client_reconfigure(it->data, FALSE);
507 }
508 }
509
screen_set_num_desktops(guint num)510 void screen_set_num_desktops(guint num)
511 {
512 gulong *viewport;
513 GList *it, *stacking_copy;
514
515 g_assert(num > 0);
516
517 if (screen_num_desktops == num) return;
518
519 screen_num_desktops = num;
520 OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
521
522 /* set the viewport hint */
523 viewport = g_new0(gulong, num * 2);
524 OBT_PROP_SETA32(obt_root(ob_screen),
525 NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
526 g_free(viewport);
527
528 /* the number of rows/columns will differ */
529 screen_update_layout();
530
531 /* move windows on desktops that will no longer exist!
532 make a copy of the list cuz we're changing it */
533 stacking_copy = g_list_copy(stacking_list);
534 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
535 if (WINDOW_IS_CLIENT(it->data)) {
536 ObClient *c = it->data;
537 if (c->desktop != DESKTOP_ALL && c->desktop >= num)
538 client_set_desktop(c, num - 1, FALSE, TRUE);
539 /* raise all the windows that are on the current desktop which
540 is being merged */
541 else if (screen_desktop == num - 1 &&
542 (c->desktop == DESKTOP_ALL ||
543 c->desktop == screen_desktop))
544 stacking_raise(CLIENT_AS_WINDOW(c));
545 }
546 }
547 g_list_free(stacking_copy);
548
549 /* change our struts/area to match (after moving windows) */
550 screen_update_areas();
551
552 /* may be some unnamed desktops that we need to fill in with names
553 (after updating the areas so the popup can resize) */
554 screen_update_desktop_names();
555
556 /* change our desktop if we're on one that no longer exists! */
557 if (screen_desktop >= screen_num_desktops)
558 screen_set_desktop(num - 1, TRUE);
559 }
560
screen_fallback_focus(void)561 static void screen_fallback_focus(void)
562 {
563 ObClient *c;
564 gboolean allow_omni;
565
566 /* only allow omnipresent windows to get focus on desktop change if
567 an omnipresent window is already focused (it'll keep focus probably, but
568 maybe not depending on mouse-focus options) */
569 allow_omni = focus_client && (client_normal(focus_client) &&
570 focus_client->desktop == DESKTOP_ALL);
571
572 /* the client moved there already so don't move focus. prevent flicker
573 on sendtodesktop + follow */
574 if (focus_client && focus_client->desktop == screen_desktop)
575 return;
576
577 /* have to try focus here because when you leave an empty desktop
578 there is no focus out to watch for. also, we have different rules
579 here. we always allow it to look under the mouse pointer if
580 config_focus_last is FALSE
581
582 do this before hiding the windows so if helper windows are coming
583 with us, they don't get hidden
584 */
585 if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
586 !allow_omni)))
587 {
588 /* only do the flicker reducing stuff ahead of time if we are going
589 to call xsetinputfocus on the window ourselves. otherwise there is
590 no guarantee the window will actually take focus.. */
591 if (c->can_focus) {
592 /* reduce flicker by hiliting now rather than waiting for the
593 server FocusIn event */
594 frame_adjust_focus(c->frame, TRUE);
595 /* do this here so that if you switch desktops to a window with
596 helper windows then the helper windows won't flash */
597 client_bring_helper_windows(c);
598 }
599 }
600 }
601
last_desktop_func(gpointer data)602 static gboolean last_desktop_func(gpointer data)
603 {
604 screen_desktop_timeout = TRUE;
605 screen_desktop_timer = 0;
606 return FALSE; /* don't repeat */
607 }
608
screen_set_desktop(guint num,gboolean dofocus)609 void screen_set_desktop(guint num, gboolean dofocus)
610 {
611 GList *it;
612 guint previous;
613 gulong ignore_start;
614
615 g_assert(num < screen_num_desktops);
616
617 previous = screen_desktop;
618 screen_desktop = num;
619
620 if (previous == num) return;
621
622 OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
623
624 /* This whole thing decides when/how to save the screen_last_desktop so
625 that it can be restored later if you want */
626 if (screen_desktop_timeout) {
627 /* If screen_desktop_timeout is true, then we've been on this desktop
628 long enough and we can save it as the last desktop. */
629
630 if (screen_last_desktop == previous)
631 /* this is the startup state only */
632 screen_old_desktop = screen_desktop;
633 else {
634 /* save the "last desktop" as the "old desktop" */
635 screen_old_desktop = screen_last_desktop;
636 /* save the desktop we're coming from as the "last desktop" */
637 screen_last_desktop = previous;
638 }
639 }
640 else {
641 /* If screen_desktop_timeout is false, then we just got to this desktop
642 and we are moving away again. */
643
644 if (screen_desktop == screen_last_desktop) {
645 /* If we are moving to the "last desktop" .. */
646 if (previous == screen_old_desktop) {
647 /* .. from the "old desktop", change the last desktop to
648 be where we are coming from */
649 screen_last_desktop = screen_old_desktop;
650 }
651 else if (screen_last_desktop == screen_old_desktop) {
652 /* .. and also to the "old desktop", change the "last
653 desktop" to be where we are coming from */
654 screen_last_desktop = previous;
655 }
656 else {
657 /* .. from some other desktop, then set the "last desktop" to
658 be the saved "old desktop", i.e. where we were before the
659 "last desktop" */
660 screen_last_desktop = screen_old_desktop;
661 }
662 }
663 else {
664 /* If we are moving to any desktop besides the "last desktop"..
665 (this is the normal case) */
666 if (screen_desktop == screen_old_desktop) {
667 /* If moving to the "old desktop", which is not the
668 "last desktop", don't save anything */
669 }
670 else if (previous == screen_old_desktop) {
671 /* If moving from the "old desktop", and not to the
672 "last desktop", don't save anything */
673 }
674 else if (screen_last_desktop == screen_old_desktop) {
675 /* If the "last desktop" is the same as "old desktop" and
676 you're not moving to the "last desktop" then save where
677 we're coming from as the "last desktop" */
678 screen_last_desktop = previous;
679 }
680 else {
681 /* If the "last desktop" is different from the "old desktop"
682 and you're not moving to the "last desktop", then don't save
683 anything */
684 }
685 }
686 }
687 screen_desktop_timeout = FALSE;
688 if (screen_desktop_timer) g_source_remove(screen_desktop_timer);
689 screen_desktop_timer = g_timeout_add(REMEMBER_LAST_DESKTOP_TIME,
690 last_desktop_func, NULL);
691
692 ob_debug("Moving to desktop %d", num+1);
693
694 if (ob_state() == OB_STATE_RUNNING)
695 screen_show_desktop_popup(screen_desktop, FALSE);
696
697 /* ignore enter events caused by the move */
698 ignore_start = event_start_ignore_all_enters();
699
700 if (moveresize_client)
701 client_set_desktop(moveresize_client, num, TRUE, FALSE);
702
703 /* show windows before hiding the rest to lessen the enter/leave events */
704
705 /* show windows from top to bottom */
706 for (it = stacking_list; it; it = g_list_next(it)) {
707 if (WINDOW_IS_CLIENT(it->data)) {
708 ObClient *c = it->data;
709 client_show(c);
710 }
711 }
712
713 if (dofocus) screen_fallback_focus();
714
715 /* hide windows from bottom to top */
716 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
717 if (WINDOW_IS_CLIENT(it->data)) {
718 ObClient *c = it->data;
719 if (client_hide(c)) {
720 if (c == focus_client) {
721 /* c was focused and we didn't do fallback clearly so make
722 sure openbox doesnt still consider the window focused.
723 this happens when using NextWindow with allDesktops,
724 since it doesnt want to move focus on desktop change,
725 but the focus is not going to stay with the current
726 window, which has now disappeared.
727 only do this if the client was actually hidden,
728 otherwise it can keep focus. */
729 focus_set_client(NULL);
730 }
731 }
732 }
733 }
734
735 focus_cycle_addremove(NULL, TRUE);
736
737 event_end_ignore_all_enters(ignore_start);
738
739 if (event_source_time() != CurrentTime)
740 screen_desktop_user_time = event_source_time();
741 }
742
screen_add_desktop(gboolean current)743 void screen_add_desktop(gboolean current)
744 {
745 gulong ignore_start;
746
747 /* ignore enter events caused by this */
748 ignore_start = event_start_ignore_all_enters();
749
750 screen_set_num_desktops(screen_num_desktops+1);
751
752 /* move all the clients over */
753 if (current) {
754 GList *it;
755
756 for (it = client_list; it; it = g_list_next(it)) {
757 ObClient *c = it->data;
758 if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
759 /* don't move direct children, they'll be moved with their
760 parent - which will have to be on the same desktop */
761 !client_direct_parent(c))
762 {
763 ob_debug("moving window %s", c->title);
764 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
765 }
766 }
767 }
768
769 event_end_ignore_all_enters(ignore_start);
770 }
771
screen_remove_desktop(gboolean current)772 void screen_remove_desktop(gboolean current)
773 {
774 guint rmdesktop, movedesktop;
775 GList *it, *stacking_copy;
776 gulong ignore_start;
777
778 if (screen_num_desktops <= 1) return;
779
780 /* ignore enter events caused by this */
781 ignore_start = event_start_ignore_all_enters();
782
783 /* what desktop are we removing and moving to? */
784 if (current)
785 rmdesktop = screen_desktop;
786 else
787 rmdesktop = screen_num_desktops - 1;
788 if (rmdesktop < screen_num_desktops - 1)
789 movedesktop = rmdesktop + 1;
790 else
791 movedesktop = rmdesktop;
792
793 /* make a copy of the list cuz we're changing it */
794 stacking_copy = g_list_copy(stacking_list);
795 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
796 if (WINDOW_IS_CLIENT(it->data)) {
797 ObClient *c = it->data;
798 guint d = c->desktop;
799 if (d != DESKTOP_ALL && d >= movedesktop &&
800 /* don't move direct children, they'll be moved with their
801 parent - which will have to be on the same desktop */
802 !client_direct_parent(c))
803 {
804 ob_debug("moving window %s", c->title);
805 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
806 }
807 /* raise all the windows that are on the current desktop which
808 is being merged */
809 if ((screen_desktop == rmdesktop - 1 ||
810 screen_desktop == rmdesktop) &&
811 (d == DESKTOP_ALL || d == screen_desktop))
812 {
813 stacking_raise(CLIENT_AS_WINDOW(c));
814 ob_debug("raising window %s", c->title);
815 }
816 }
817 }
818 g_list_free(stacking_copy);
819
820 /* fallback focus like we're changing desktops */
821 if (screen_desktop < screen_num_desktops - 1) {
822 screen_fallback_focus();
823 ob_debug("fake desktop change");
824 }
825
826 screen_set_num_desktops(screen_num_desktops-1);
827
828 event_end_ignore_all_enters(ignore_start);
829 }
830
get_row_col(guint d,guint * r,guint * c)831 static void get_row_col(guint d, guint *r, guint *c)
832 {
833 switch (screen_desktop_layout.orientation) {
834 case OB_ORIENTATION_HORZ:
835 switch (screen_desktop_layout.start_corner) {
836 case OB_CORNER_TOPLEFT:
837 *r = d / screen_desktop_layout.columns;
838 *c = d % screen_desktop_layout.columns;
839 break;
840 case OB_CORNER_BOTTOMLEFT:
841 *r = screen_desktop_layout.rows - 1 -
842 d / screen_desktop_layout.columns;
843 *c = d % screen_desktop_layout.columns;
844 break;
845 case OB_CORNER_TOPRIGHT:
846 *r = d / screen_desktop_layout.columns;
847 *c = screen_desktop_layout.columns - 1 -
848 d % screen_desktop_layout.columns;
849 break;
850 case OB_CORNER_BOTTOMRIGHT:
851 *r = screen_desktop_layout.rows - 1 -
852 d / screen_desktop_layout.columns;
853 *c = screen_desktop_layout.columns - 1 -
854 d % screen_desktop_layout.columns;
855 break;
856 }
857 break;
858 case OB_ORIENTATION_VERT:
859 switch (screen_desktop_layout.start_corner) {
860 case OB_CORNER_TOPLEFT:
861 *r = d % screen_desktop_layout.rows;
862 *c = d / screen_desktop_layout.rows;
863 break;
864 case OB_CORNER_BOTTOMLEFT:
865 *r = screen_desktop_layout.rows - 1 -
866 d % screen_desktop_layout.rows;
867 *c = d / screen_desktop_layout.rows;
868 break;
869 case OB_CORNER_TOPRIGHT:
870 *r = d % screen_desktop_layout.rows;
871 *c = screen_desktop_layout.columns - 1 -
872 d / screen_desktop_layout.rows;
873 break;
874 case OB_CORNER_BOTTOMRIGHT:
875 *r = screen_desktop_layout.rows - 1 -
876 d % screen_desktop_layout.rows;
877 *c = screen_desktop_layout.columns - 1 -
878 d / screen_desktop_layout.rows;
879 break;
880 }
881 break;
882 }
883 }
884
translate_row_col(guint r,guint c)885 static guint translate_row_col(guint r, guint c)
886 {
887 switch (screen_desktop_layout.orientation) {
888 case OB_ORIENTATION_HORZ:
889 switch (screen_desktop_layout.start_corner) {
890 case OB_CORNER_TOPLEFT:
891 return r % screen_desktop_layout.rows *
892 screen_desktop_layout.columns +
893 c % screen_desktop_layout.columns;
894 case OB_CORNER_BOTTOMLEFT:
895 return (screen_desktop_layout.rows - 1 -
896 r % screen_desktop_layout.rows) *
897 screen_desktop_layout.columns +
898 c % screen_desktop_layout.columns;
899 case OB_CORNER_TOPRIGHT:
900 return r % screen_desktop_layout.rows *
901 screen_desktop_layout.columns +
902 (screen_desktop_layout.columns - 1 -
903 c % screen_desktop_layout.columns);
904 case OB_CORNER_BOTTOMRIGHT:
905 return (screen_desktop_layout.rows - 1 -
906 r % screen_desktop_layout.rows) *
907 screen_desktop_layout.columns +
908 (screen_desktop_layout.columns - 1 -
909 c % screen_desktop_layout.columns);
910 }
911 case OB_ORIENTATION_VERT:
912 switch (screen_desktop_layout.start_corner) {
913 case OB_CORNER_TOPLEFT:
914 return c % screen_desktop_layout.columns *
915 screen_desktop_layout.rows +
916 r % screen_desktop_layout.rows;
917 case OB_CORNER_BOTTOMLEFT:
918 return c % screen_desktop_layout.columns *
919 screen_desktop_layout.rows +
920 (screen_desktop_layout.rows - 1 -
921 r % screen_desktop_layout.rows);
922 case OB_CORNER_TOPRIGHT:
923 return (screen_desktop_layout.columns - 1 -
924 c % screen_desktop_layout.columns) *
925 screen_desktop_layout.rows +
926 r % screen_desktop_layout.rows;
927 case OB_CORNER_BOTTOMRIGHT:
928 return (screen_desktop_layout.columns - 1 -
929 c % screen_desktop_layout.columns) *
930 screen_desktop_layout.rows +
931 (screen_desktop_layout.rows - 1 -
932 r % screen_desktop_layout.rows);
933 }
934 }
935 g_assert_not_reached();
936 return 0;
937 }
938
hide_desktop_popup_func(gpointer data)939 static gboolean hide_desktop_popup_func(gpointer data)
940 {
941 pager_popup_hide(desktop_popup);
942 desktop_popup_timer = 0;
943 return FALSE; /* don't repeat */
944 }
945
screen_show_desktop_popup(guint d,gboolean perm)946 void screen_show_desktop_popup(guint d, gboolean perm)
947 {
948 const Rect *a;
949
950 /* 0 means don't show the popup */
951 if (!config_desktop_popup_time) return;
952
953 a = screen_physical_area_primary(FALSE);
954 pager_popup_position(desktop_popup, CenterGravity,
955 a->x + a->width / 2, a->y + a->height / 2);
956 pager_popup_icon_size_multiplier(desktop_popup,
957 (screen_desktop_layout.columns /
958 screen_desktop_layout.rows) / 2,
959 (screen_desktop_layout.rows/
960 screen_desktop_layout.columns) / 2);
961 pager_popup_max_width(desktop_popup,
962 MAX(a->width/3, POPUP_WIDTH));
963 pager_popup_show(desktop_popup, screen_desktop_names[d], d);
964
965 if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
966 desktop_popup_timer = 0;
967 if (!perm && !desktop_popup_perm)
968 /* only hide if its not already being show permanently */
969 desktop_popup_timer = g_timeout_add(config_desktop_popup_time,
970 hide_desktop_popup_func,
971 desktop_popup);
972 if (perm)
973 desktop_popup_perm = TRUE;
974 }
975
screen_hide_desktop_popup(void)976 void screen_hide_desktop_popup(void)
977 {
978 if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
979 desktop_popup_timer = 0;
980 pager_popup_hide(desktop_popup);
981 desktop_popup_perm = FALSE;
982 }
983
screen_find_desktop(guint from,ObDirection dir,gboolean wrap,gboolean linear)984 guint screen_find_desktop(guint from, ObDirection dir,
985 gboolean wrap, gboolean linear)
986 {
987 guint r, c;
988 guint d;
989
990 d = from;
991 get_row_col(d, &r, &c);
992 if (linear) {
993 switch (dir) {
994 case OB_DIRECTION_EAST:
995 if (d < screen_num_desktops - 1)
996 ++d;
997 else if (wrap)
998 d = 0;
999 else
1000 return from;
1001 break;
1002 case OB_DIRECTION_WEST:
1003 if (d > 0)
1004 --d;
1005 else if (wrap)
1006 d = screen_num_desktops - 1;
1007 else
1008 return from;
1009 break;
1010 default:
1011 g_assert_not_reached();
1012 return from;
1013 }
1014 } else {
1015 switch (dir) {
1016 case OB_DIRECTION_EAST:
1017 ++c;
1018 if (c >= screen_desktop_layout.columns) {
1019 if (wrap)
1020 c = 0;
1021 else
1022 return from;
1023 }
1024 d = translate_row_col(r, c);
1025 if (d >= screen_num_desktops) {
1026 if (wrap)
1027 ++c;
1028 else
1029 return from;
1030 }
1031 break;
1032 case OB_DIRECTION_WEST:
1033 --c;
1034 if (c >= screen_desktop_layout.columns) {
1035 if (wrap)
1036 c = screen_desktop_layout.columns - 1;
1037 else
1038 return from;
1039 }
1040 d = translate_row_col(r, c);
1041 if (d >= screen_num_desktops) {
1042 if (wrap)
1043 --c;
1044 else
1045 return from;
1046 }
1047 break;
1048 case OB_DIRECTION_SOUTH:
1049 ++r;
1050 if (r >= screen_desktop_layout.rows) {
1051 if (wrap)
1052 r = 0;
1053 else
1054 return from;
1055 }
1056 d = translate_row_col(r, c);
1057 if (d >= screen_num_desktops) {
1058 if (wrap)
1059 ++r;
1060 else
1061 return from;
1062 }
1063 break;
1064 case OB_DIRECTION_NORTH:
1065 --r;
1066 if (r >= screen_desktop_layout.rows) {
1067 if (wrap)
1068 r = screen_desktop_layout.rows - 1;
1069 else
1070 return from;
1071 }
1072 d = translate_row_col(r, c);
1073 if (d >= screen_num_desktops) {
1074 if (wrap)
1075 --r;
1076 else
1077 return from;
1078 }
1079 break;
1080 default:
1081 g_assert_not_reached();
1082 return from;
1083 }
1084
1085 d = translate_row_col(r, c);
1086 }
1087 return d;
1088 }
1089
screen_validate_layout(ObDesktopLayout * l)1090 static gboolean screen_validate_layout(ObDesktopLayout *l)
1091 {
1092 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1093 return FALSE;
1094
1095 /* fill in a zero rows/columns */
1096 if (l->columns == 0) {
1097 l->columns = screen_num_desktops / l->rows;
1098 if (l->rows * l->columns < screen_num_desktops)
1099 l->columns++;
1100 if (l->rows * l->columns >= screen_num_desktops + l->columns)
1101 l->rows--;
1102 } else if (l->rows == 0) {
1103 l->rows = screen_num_desktops / l->columns;
1104 if (l->columns * l->rows < screen_num_desktops)
1105 l->rows++;
1106 if (l->columns * l->rows >= screen_num_desktops + l->rows)
1107 l->columns--;
1108 }
1109
1110 /* bounds checking */
1111 if (l->orientation == OB_ORIENTATION_HORZ) {
1112 l->columns = MIN(screen_num_desktops, l->columns);
1113 l->rows = MIN(l->rows,
1114 (screen_num_desktops + l->columns - 1) / l->columns);
1115 l->columns = screen_num_desktops / l->rows +
1116 !!(screen_num_desktops % l->rows);
1117 } else {
1118 l->rows = MIN(screen_num_desktops, l->rows);
1119 l->columns = MIN(l->columns,
1120 (screen_num_desktops + l->rows - 1) / l->rows);
1121 l->rows = screen_num_desktops / l->columns +
1122 !!(screen_num_desktops % l->columns);
1123 }
1124 return TRUE;
1125 }
1126
screen_update_layout(void)1127 void screen_update_layout(void)
1128
1129 {
1130 ObDesktopLayout l;
1131 guint32 *data;
1132 guint num;
1133
1134 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1135 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1136 screen_desktop_layout.rows = 1;
1137 screen_desktop_layout.columns = screen_num_desktops;
1138
1139 if (OBT_PROP_GETA32(obt_root(ob_screen),
1140 NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1141 if (num == 3 || num == 4) {
1142
1143 if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1144 l.orientation = OB_ORIENTATION_VERT;
1145 else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1146 l.orientation = OB_ORIENTATION_HORZ;
1147 else
1148 return;
1149
1150 if (num < 4)
1151 l.start_corner = OB_CORNER_TOPLEFT;
1152 else {
1153 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1154 l.start_corner = OB_CORNER_TOPLEFT;
1155 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1156 l.start_corner = OB_CORNER_TOPRIGHT;
1157 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1158 l.start_corner = OB_CORNER_BOTTOMRIGHT;
1159 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1160 l.start_corner = OB_CORNER_BOTTOMLEFT;
1161 else
1162 return;
1163 }
1164
1165 l.columns = data[1];
1166 l.rows = data[2];
1167
1168 if (screen_validate_layout(&l))
1169 screen_desktop_layout = l;
1170
1171 g_free(data);
1172 }
1173 }
1174 }
1175
screen_update_desktop_names(void)1176 void screen_update_desktop_names(void)
1177 {
1178 guint i;
1179
1180 /* empty the array */
1181 g_strfreev(screen_desktop_names);
1182 screen_desktop_names = NULL;
1183
1184 if (OBT_PROP_GETSS(obt_root(ob_screen),
1185 NET_DESKTOP_NAMES, &screen_desktop_names))
1186 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1187 else
1188 i = 0;
1189 if (i < screen_num_desktops) {
1190 GSList *it;
1191
1192 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1193 screen_num_desktops + 1);
1194 screen_desktop_names[screen_num_desktops] = NULL;
1195
1196 it = g_slist_nth(config_desktops_names, i);
1197
1198 for (; i < screen_num_desktops; ++i) {
1199 if (it && ((char*)it->data)[0]) /* not empty */
1200 /* use the names from the config file when possible */
1201 screen_desktop_names[i] = g_strdup(it->data);
1202 else
1203 /* make up a nice name if it's not though */
1204 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1205 i + 1);
1206 if (it) it = g_slist_next(it);
1207 }
1208
1209 /* if we changed any names, then set the root property so we can
1210 all agree on the names */
1211 OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1212 (const gchar*const*)screen_desktop_names);
1213 }
1214
1215 /* resize the pager for these names */
1216 pager_popup_text_width_to_strings(desktop_popup,
1217 screen_desktop_names,
1218 screen_num_desktops);
1219 }
1220
screen_show_desktop(ObScreenShowDestopMode show_mode,ObClient * show_only)1221 void screen_show_desktop(ObScreenShowDestopMode show_mode, ObClient *show_only)
1222 {
1223 GList *it;
1224
1225 ObScreenShowDestopMode before_mode = screen_show_desktop_mode;
1226
1227 gboolean showing_before = screen_showing_desktop();
1228 screen_show_desktop_mode = show_mode;
1229 gboolean showing_after = screen_showing_desktop();
1230
1231 if (showing_before == showing_after) {
1232 /* No change. */
1233 screen_show_desktop_mode = before_mode;
1234 return;
1235 }
1236
1237 if (screen_show_desktop_mode == SCREEN_SHOW_DESKTOP_UNTIL_TOGGLE &&
1238 show_only != NULL)
1239 {
1240 /* If we're showing the desktop until the show-mode is toggled, we
1241 don't allow breaking out of showing-desktop mode unless we're
1242 showing all the windows again. */
1243 screen_show_desktop_mode = before_mode;
1244 return;
1245 }
1246
1247 if (showing_after) {
1248 /* hide windows bottom to top */
1249 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1250 if (WINDOW_IS_CLIENT(it->data)) {
1251 ObClient *client = it->data;
1252 client_showhide(client);
1253 }
1254 }
1255 }
1256 else {
1257 /* restore windows top to bottom */
1258 for (it = stacking_list; it; it = g_list_next(it)) {
1259 if (WINDOW_IS_CLIENT(it->data)) {
1260 ObClient *client = it->data;
1261 if (client_should_show(client)) {
1262 if (!show_only || client == show_only)
1263 client_show(client);
1264 else
1265 client_iconify(client, TRUE, FALSE, TRUE);
1266 }
1267 }
1268 }
1269 }
1270
1271 if (showing_after) {
1272 /* focus the desktop */
1273 for (it = focus_order; it; it = g_list_next(it)) {
1274 ObClient *c = it->data;
1275 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1276 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1277 client_focus(it->data))
1278 break;
1279 }
1280 }
1281 else if (!show_only) {
1282 ObClient *c;
1283
1284 if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1285 /* only do the flicker reducing stuff ahead of time if we are going
1286 to call xsetinputfocus on the window ourselves. otherwise there
1287 is no guarantee the window will actually take focus.. */
1288 if (c->can_focus) {
1289 /* reduce flicker by hiliting now rather than waiting for the
1290 server FocusIn event */
1291 frame_adjust_focus(c->frame, TRUE);
1292 }
1293 }
1294 }
1295
1296 OBT_PROP_SET32(obt_root(ob_screen),
1297 NET_SHOWING_DESKTOP,
1298 CARDINAL,
1299 !!showing_after);
1300 }
1301
screen_showing_desktop()1302 gboolean screen_showing_desktop()
1303 {
1304 switch (screen_show_desktop_mode) {
1305 case SCREEN_SHOW_DESKTOP_NO:
1306 return FALSE;
1307 case SCREEN_SHOW_DESKTOP_UNTIL_WINDOW:
1308 case SCREEN_SHOW_DESKTOP_UNTIL_TOGGLE:
1309 return TRUE;
1310 }
1311 g_assert_not_reached();
1312 return FALSE;
1313 }
1314
screen_install_colormap(ObClient * client,gboolean install)1315 void screen_install_colormap(ObClient *client, gboolean install)
1316 {
1317 if (client == NULL || client->colormap == None) {
1318 if (install)
1319 XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1320 else
1321 XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1322 } else {
1323 obt_display_ignore_errors(TRUE);
1324 if (install)
1325 XInstallColormap(obt_display, client->colormap);
1326 else
1327 XUninstallColormap(obt_display, client->colormap);
1328 obt_display_ignore_errors(FALSE);
1329 }
1330 }
1331
1332 typedef struct {
1333 guint desktop;
1334 StrutPartial *strut;
1335 } ObScreenStrut;
1336
1337 #define RESET_STRUT_LIST(sl) \
1338 while (sl) { \
1339 g_slice_free(ObScreenStrut, (sl)->data); \
1340 sl = g_slist_delete_link(sl, sl); \
1341 }
1342
1343 #define ADD_STRUT_TO_LIST(sl, d, s) \
1344 { \
1345 ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1346 ss->desktop = d; \
1347 ss->strut = s; \
1348 sl = g_slist_prepend(sl, ss); \
1349 }
1350
1351 #define VALIDATE_STRUTS(sl, side, max) \
1352 { \
1353 GSList *it; \
1354 for (it = sl; it; it = g_slist_next(it)) { \
1355 ObScreenStrut *ss = it->data; \
1356 ss->strut->side = MIN(max, ss->strut->side); \
1357 } \
1358 }
1359
get_xinerama_screens(Rect ** xin_areas,guint * nxin)1360 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1361 {
1362 guint i;
1363 gint l, r, t, b;
1364 #ifdef XINERAMA
1365 gint n;
1366 XineramaScreenInfo *info;
1367 #endif
1368
1369 if (ob_debug_xinerama) {
1370 gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1371 gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1372 *nxin = 2;
1373 *xin_areas = g_new(Rect, *nxin + 1);
1374 RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1375 RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1376 }
1377 #ifdef XINERAMA
1378 else if (obt_display_extension_xinerama &&
1379 (info = XineramaQueryScreens(obt_display, &n))) {
1380 *nxin = n;
1381 *xin_areas = g_new(Rect, *nxin + 1);
1382 for (i = 0; i < *nxin; ++i)
1383 RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1384 info[i].width, info[i].height);
1385 XFree(info);
1386 }
1387 #endif
1388 else {
1389 *nxin = 1;
1390 *xin_areas = g_new(Rect, *nxin + 1);
1391 RECT_SET((*xin_areas)[0], 0, 0,
1392 WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1393 HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1394 }
1395
1396 /* returns one extra with the total area in it */
1397 l = (*xin_areas)[0].x;
1398 t = (*xin_areas)[0].y;
1399 r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1400 b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1401 for (i = 1; i < *nxin; ++i) {
1402 l = MIN(l, (*xin_areas)[i].x);
1403 t = MIN(l, (*xin_areas)[i].y);
1404 r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1405 b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1406 }
1407 RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1408
1409 for (i = 0; i < *nxin; ++i)
1410 ob_debug("Monitor %d @ %d,%d %dx%d\n", i,
1411 (*xin_areas)[i].x, (*xin_areas)[i].y,
1412 (*xin_areas)[i].width, (*xin_areas)[i].height);
1413 ob_debug("Full desktop @ %d,%d %dx%d\n",
1414 (*xin_areas)[i].x, (*xin_areas)[i].y,
1415 (*xin_areas)[i].width, (*xin_areas)[i].height);
1416 }
1417
screen_update_areas(void)1418 void screen_update_areas(void)
1419 {
1420 guint i;
1421 gulong *dims;
1422 GList *it, *onscreen;
1423
1424 /* collect the clients that are on screen */
1425 onscreen = NULL;
1426 for (it = client_list; it; it = g_list_next(it)) {
1427 if (client_monitor(it->data) != screen_num_monitors)
1428 onscreen = g_list_prepend(onscreen, it->data);
1429 }
1430
1431 g_free(monitor_area);
1432 get_xinerama_screens(&monitor_area, &screen_num_monitors);
1433
1434 /* set up the user-specified margins */
1435 config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1436 config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1437 config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1438 config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1439 config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1440 config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1441 config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1442 config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1443
1444 RESET_STRUT_LIST(struts_left);
1445 RESET_STRUT_LIST(struts_top);
1446 RESET_STRUT_LIST(struts_right);
1447 RESET_STRUT_LIST(struts_bottom);
1448
1449 /* collect the struts */
1450 for (it = client_list; it; it = g_list_next(it)) {
1451 ObClient *c = it->data;
1452 if (c->strut.left)
1453 ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1454 if (c->strut.top)
1455 ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1456 if (c->strut.right)
1457 ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1458 if (c->strut.bottom)
1459 ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1460 }
1461 if (dock_strut.left)
1462 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1463 if (dock_strut.top)
1464 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1465 if (dock_strut.right)
1466 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1467 if (dock_strut.bottom)
1468 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1469
1470 if (config_margins.left)
1471 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1472 if (config_margins.top)
1473 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1474 if (config_margins.right)
1475 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1476 if (config_margins.bottom)
1477 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1478
1479 VALIDATE_STRUTS(struts_left, left,
1480 monitor_area[screen_num_monitors].width / 2);
1481 VALIDATE_STRUTS(struts_right, right,
1482 monitor_area[screen_num_monitors].width / 2);
1483 VALIDATE_STRUTS(struts_top, top,
1484 monitor_area[screen_num_monitors].height / 2);
1485 VALIDATE_STRUTS(struts_bottom, bottom,
1486 monitor_area[screen_num_monitors].height / 2);
1487
1488 dims = g_new(gulong, 4 * screen_num_desktops);
1489 for (i = 0; i < screen_num_desktops; ++i) {
1490 Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1491 dims[i*4+0] = area->x;
1492 dims[i*4+1] = area->y;
1493 dims[i*4+2] = area->width;
1494 dims[i*4+3] = area->height;
1495 g_slice_free(Rect, area);
1496 }
1497
1498 /* set the legacy workarea hint to the union of all the monitors */
1499 OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1500 dims, 4 * screen_num_desktops);
1501
1502 /* the area has changed, adjust all the windows if they need it */
1503 for (it = onscreen; it; it = g_list_next(it))
1504 client_reconfigure(it->data, FALSE);
1505
1506 g_free(dims);
1507 }
1508
1509 #if 0
1510 Rect* screen_area_all_monitors(guint desktop)
1511 {
1512 guint i;
1513 Rect *a;
1514
1515 a = screen_area_monitor(desktop, 0);
1516
1517 /* combine all the monitors together */
1518 for (i = 1; i < screen_num_monitors; ++i) {
1519 Rect *m = screen_area_monitor(desktop, i);
1520 gint l, r, t, b;
1521
1522 l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1523 t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1524 r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1525 b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1526
1527 RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1528
1529 g_free(m);
1530 }
1531
1532 return a;
1533 }
1534 #endif
1535
1536 #define STRUT_LEFT_IN_SEARCH(s, search) \
1537 (RANGES_INTERSECT(search->y, search->height, \
1538 s->left_start, s->left_end - s->left_start + 1))
1539 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1540 (RANGES_INTERSECT(search->y, search->height, \
1541 s->right_start, s->right_end - s->right_start + 1))
1542 #define STRUT_TOP_IN_SEARCH(s, search) \
1543 (RANGES_INTERSECT(search->x, search->width, \
1544 s->top_start, s->top_end - s->top_start + 1))
1545 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1546 (RANGES_INTERSECT(search->x, search->width, \
1547 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1548
1549 #define STRUT_LEFT_IGNORE(s, us, search) \
1550 (head == SCREEN_AREA_ALL_MONITORS && us && \
1551 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1552 #define STRUT_RIGHT_IGNORE(s, us, search) \
1553 (head == SCREEN_AREA_ALL_MONITORS && us && \
1554 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1555 #define STRUT_TOP_IGNORE(s, us, search) \
1556 (head == SCREEN_AREA_ALL_MONITORS && us && \
1557 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1558 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1559 (head == SCREEN_AREA_ALL_MONITORS && us && \
1560 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1561
screen_area(guint desktop,guint head,Rect * search)1562 Rect* screen_area(guint desktop, guint head, Rect *search)
1563 {
1564 Rect *a;
1565 GSList *it;
1566 gint l, r, t, b;
1567 guint i, d;
1568 gboolean us = search != NULL; /* user provided search */
1569
1570 g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1571 g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1572 head == SCREEN_AREA_ALL_MONITORS);
1573 g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1574
1575 /* find any struts for this monitor
1576 which will be affecting the search area.
1577 */
1578
1579 /* search everything if search is null */
1580 if (!search) {
1581 if (head < screen_num_monitors) search = &monitor_area[head];
1582 else search = &monitor_area[screen_num_monitors];
1583 }
1584 if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1585
1586 /* al is "all left" meaning the furthest left you can get, l is our
1587 "working left" meaning our current strut edge which we're calculating
1588 */
1589
1590 /* only include monitors which the search area lines up with */
1591 if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1592 l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1593 t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1594 r = RECT_LEFT(monitor_area[screen_num_monitors]);
1595 b = RECT_TOP(monitor_area[screen_num_monitors]);
1596 for (i = 0; i < screen_num_monitors; ++i) {
1597 /* add the monitor if applicable */
1598 if (RANGES_INTERSECT(search->x, search->width,
1599 monitor_area[i].x, monitor_area[i].width))
1600 {
1601 t = MIN(t, RECT_TOP(monitor_area[i]));
1602 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1603 }
1604 if (RANGES_INTERSECT(search->y, search->height,
1605 monitor_area[i].y, monitor_area[i].height))
1606 {
1607 l = MIN(l, RECT_LEFT(monitor_area[i]));
1608 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1609 }
1610 }
1611 } else {
1612 l = RECT_LEFT(monitor_area[screen_num_monitors]);
1613 t = RECT_TOP(monitor_area[screen_num_monitors]);
1614 r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1615 b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1616 }
1617
1618 for (d = 0; d < screen_num_desktops; ++d) {
1619 if (d != desktop && desktop != DESKTOP_ALL) continue;
1620
1621 for (i = 0; i < screen_num_monitors; ++i) {
1622 if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1623
1624 for (it = struts_left; it; it = g_slist_next(it)) {
1625 ObScreenStrut *s = it->data;
1626 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1627 STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1628 !STRUT_LEFT_IGNORE(s->strut, us, search))
1629 l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1630 + s->strut->left);
1631 }
1632 for (it = struts_top; it; it = g_slist_next(it)) {
1633 ObScreenStrut *s = it->data;
1634 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1635 STRUT_TOP_IN_SEARCH(s->strut, search) &&
1636 !STRUT_TOP_IGNORE(s->strut, us, search))
1637 t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1638 + s->strut->top);
1639 }
1640 for (it = struts_right; it; it = g_slist_next(it)) {
1641 ObScreenStrut *s = it->data;
1642 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1643 STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1644 !STRUT_RIGHT_IGNORE(s->strut, us, search))
1645 r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1646 - s->strut->right);
1647 }
1648 for (it = struts_bottom; it; it = g_slist_next(it)) {
1649 ObScreenStrut *s = it->data;
1650 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1651 STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1652 !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1653 b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1654 - s->strut->bottom);
1655 }
1656
1657 /* limit to this monitor */
1658 if (head == i) {
1659 l = MAX(l, RECT_LEFT(monitor_area[i]));
1660 t = MAX(t, RECT_TOP(monitor_area[i]));
1661 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1662 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1663 }
1664 }
1665 }
1666
1667 a = g_slice_new(Rect);
1668 a->x = l;
1669 a->y = t;
1670 a->width = r - l + 1;
1671 a->height = b - t + 1;
1672 return a;
1673 }
1674
1675 typedef struct {
1676 Rect r;
1677 gboolean subtract;
1678 } RectArithmetic;
1679
screen_find_monitor(const Rect * search)1680 guint screen_find_monitor(const Rect *search)
1681 {
1682 guint i;
1683 guint mostpx_index = screen_num_monitors;
1684 glong mostpx = 0;
1685 guint closest_distance_index = screen_num_monitors;
1686 guint closest_distance = G_MAXUINT;
1687 GSList *counted = NULL;
1688
1689 /* we want to count the number of pixels search has on each monitor, but not
1690 double count. so if a pixel is counted on monitor A then we should not
1691 count it again on monitor B. in the end we want to return the monitor
1692 that had the most pixels counted under this scheme.
1693
1694 this assumes that monitors earlier in the list are more desirable to be
1695 considered the search area's monitor. we try the configured primary
1696 monitor first, so it gets the highest preference.
1697
1698 if we have counted an area A, then we want to subtract the intersection
1699 of A with the area on future monitors.
1700 but now consider if we count an area B that intersects A. we want to
1701 subtract the area B from that counted on future monitors, but not
1702 subtract the intersection of A and B twice! so we would add the
1703 intersection of A and B back, to account for it being subtracted both
1704 for A and B.
1705
1706 this is the idea behind the algorithm. we always subtract the full area
1707 for monitor M intersected with the search area. we'll call that AREA.
1708 but then we go through the list |counted| and for each rectangle in
1709 the list that is being subtracted from future monitors, we insert a
1710 request to add back the intersection of the subtracted rect with AREA.
1711 vice versa for a rect in |counted| that is getting added back.
1712 */
1713
1714 if (config_primary_monitor_index < screen_num_monitors) {
1715 const Rect *monitor;
1716 Rect on_current_monitor;
1717 glong area;
1718
1719 monitor = screen_physical_area_monitor(config_primary_monitor_index);
1720
1721 if (RECT_INTERSECTS_RECT(*monitor, *search)) {
1722 RECT_SET_INTERSECTION(on_current_monitor, *monitor, *search);
1723 area = RECT_AREA(on_current_monitor);
1724
1725 if (area > mostpx) {
1726 mostpx = area;
1727 mostpx_index = config_primary_monitor_index;
1728 }
1729
1730 /* add the intersection rect on the current monitor to the
1731 counted list. that's easy for the first one, we just mark it for
1732 subtraction */
1733 {
1734 RectArithmetic *ra = g_slice_new(RectArithmetic);
1735 ra->r = on_current_monitor;
1736 ra->subtract = TRUE;
1737 counted = g_slist_prepend(counted, ra);
1738 }
1739 }
1740 }
1741
1742 for (i = 0; i < screen_num_monitors; ++i) {
1743 const Rect *monitor;
1744 Rect on_current_monitor;
1745 glong area;
1746 GSList *it;
1747
1748 monitor = screen_physical_area_monitor(i);
1749
1750 if (!RECT_INTERSECTS_RECT(*monitor, *search)) {
1751 /* If we don't intersect then find the distance between the search
1752 rect and the monitor. We'll use the closest monitor from this
1753 metric if none of the monitors intersect. */
1754 guint distance = rect_manhatten_distance(*monitor, *search);
1755
1756 if (distance < closest_distance) {
1757 closest_distance = distance;
1758 closest_distance_index = i;
1759 }
1760 continue;
1761 }
1762
1763 if (i == config_primary_monitor_index)
1764 continue; /* already did this one */
1765
1766 RECT_SET_INTERSECTION(on_current_monitor, *monitor, *search);
1767 area = RECT_AREA(on_current_monitor);
1768
1769 /* remove pixels we already counted on any previous monitors. */
1770 for (it = counted; it; it = g_slist_next(it)) {
1771 RectArithmetic *ra = it->data;
1772 Rect intersection;
1773
1774 RECT_SET_INTERSECTION(intersection, ra->r, *search);
1775 if (ra->subtract) area -= RECT_AREA(intersection);
1776 else area += RECT_AREA(intersection);
1777 }
1778
1779 if (area > mostpx) {
1780 mostpx = area;
1781 mostpx_index = i;
1782 }
1783
1784 /* add the intersection rect on the current monitor I to the counted
1785 list.
1786 but now we need to compensate for every rectangle R already in the
1787 counted list, and add a new rect R' that is the intersection of
1788 R and I, but with the reverse subtraction/addition operation.
1789 */
1790 for (it = counted; it; it = g_slist_next(it)) {
1791 RectArithmetic *saved = it->data;
1792
1793 if (!RECT_INTERSECTS_RECT(saved->r, on_current_monitor))
1794 continue;
1795 /* we are going to subtract our rect from future monitors, but
1796 part of it may already be being subtracted/added, so compensate
1797 to not double add/subtract. */
1798 RectArithmetic *reverse = g_slice_new(RectArithmetic);
1799 RECT_SET_INTERSECTION(reverse->r, saved->r, on_current_monitor);
1800 reverse->subtract = !saved->subtract;
1801 /* prepend so we can continue thru the list uninterupted */
1802 counted = g_slist_prepend(counted, reverse);
1803 }
1804 {
1805 RectArithmetic *ra = g_slice_new(RectArithmetic);
1806 ra->r = on_current_monitor;
1807 ra->subtract = TRUE;
1808 counted = g_slist_prepend(counted, ra);
1809 }
1810 }
1811
1812 while (counted) {
1813 g_slice_free(RectArithmetic, counted->data);
1814 counted = g_slist_delete_link(counted, counted);
1815 }
1816
1817 if (mostpx_index < screen_num_monitors)
1818 return mostpx_index;
1819
1820 g_assert(closest_distance_index < screen_num_monitors);
1821 return closest_distance_index;
1822 }
1823
screen_physical_area_all_monitors(void)1824 const Rect* screen_physical_area_all_monitors(void)
1825 {
1826 return screen_physical_area_monitor(screen_num_monitors);
1827 }
1828
screen_physical_area_monitor(guint head)1829 const Rect* screen_physical_area_monitor(guint head)
1830 {
1831 g_assert(head <= screen_num_monitors);
1832
1833 return &monitor_area[head];
1834 }
1835
screen_physical_area_monitor_contains(guint head,Rect * search)1836 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1837 {
1838 g_assert(head <= screen_num_monitors);
1839 g_assert(search);
1840 return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1841 }
1842
screen_monitor_active(void)1843 guint screen_monitor_active(void)
1844 {
1845 if (moveresize_client)
1846 return client_monitor(moveresize_client);
1847 else if (focus_client)
1848 return client_monitor(focus_client);
1849 else
1850 return screen_monitor_pointer();
1851 }
1852
screen_physical_area_active(void)1853 const Rect* screen_physical_area_active(void)
1854 {
1855 return screen_physical_area_monitor(screen_monitor_active());
1856 }
1857
screen_monitor_primary(gboolean fixed)1858 guint screen_monitor_primary(gboolean fixed)
1859 {
1860 if (config_primary_monitor_index > 0) {
1861 if (config_primary_monitor_index-1 < screen_num_monitors)
1862 return config_primary_monitor_index - 1;
1863 else
1864 return 0;
1865 }
1866 else if (fixed)
1867 return 0;
1868 else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1869 return screen_monitor_active();
1870 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1871 return screen_monitor_pointer();
1872 }
1873
screen_physical_area_primary(gboolean fixed)1874 const Rect* screen_physical_area_primary(gboolean fixed)
1875 {
1876 return screen_physical_area_monitor(screen_monitor_primary(fixed));
1877 }
1878
screen_set_root_cursor(void)1879 void screen_set_root_cursor(void)
1880 {
1881 if (sn_app_starting())
1882 XDefineCursor(obt_display, obt_root(ob_screen),
1883 ob_cursor(OB_CURSOR_BUSYPOINTER));
1884 else
1885 XDefineCursor(obt_display, obt_root(ob_screen),
1886 ob_cursor(OB_CURSOR_POINTER));
1887 }
1888
screen_find_monitor_point(guint x,guint y)1889 guint screen_find_monitor_point(guint x, guint y)
1890 {
1891 Rect mon;
1892 RECT_SET(mon, x, y, 1, 1);
1893 return screen_find_monitor(&mon);
1894 }
1895
screen_monitor_pointer()1896 guint screen_monitor_pointer()
1897 {
1898 gint x, y;
1899 if (!screen_pointer_pos(&x, &y))
1900 x = y = 0;
1901 return screen_find_monitor_point(x, y);
1902 }
1903
screen_pointer_pos(gint * x,gint * y)1904 gboolean screen_pointer_pos(gint *x, gint *y)
1905 {
1906 Window w;
1907 gint i;
1908 guint u;
1909 gboolean ret;
1910
1911 ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1912 &w, &w, x, y, &i, &i, &u);
1913 if (!ret) {
1914 for (i = 0; i < ScreenCount(obt_display); ++i)
1915 if (i != ob_screen)
1916 if (XQueryPointer(obt_display, obt_root(i),
1917 &w, &w, x, y, &i, &i, &u))
1918 break;
1919 }
1920 return ret;
1921 }
1922
screen_compare_desktops(guint a,guint b)1923 gboolean screen_compare_desktops(guint a, guint b)
1924 {
1925 if (a == DESKTOP_ALL)
1926 a = screen_desktop;
1927 if (b == DESKTOP_ALL)
1928 b = screen_desktop;
1929 return a == b;
1930 }
1931
screen_apply_gravity_point(gint * x,gint * y,gint width,gint height,const GravityPoint * position,const Rect * area)1932 void screen_apply_gravity_point(gint *x, gint *y, gint width, gint height,
1933 const GravityPoint *position, const Rect *area)
1934 {
1935 if (position->x.center)
1936 *x = area->width / 2 - width / 2;
1937 else {
1938 *x = position->x.pos;
1939 if (position->x.denom)
1940 *x = (*x * area->width) / position->x.denom;
1941 if (position->x.opposite)
1942 *x = area->width - width - *x;
1943 }
1944
1945 if (position->y.center)
1946 *y = area->height / 2 - height / 2;
1947 else {
1948 *y = position->y.pos;
1949 if (position->y.denom)
1950 *y = (*y * area->height) / position->y.denom;
1951 if (position->y.opposite)
1952 *y = area->height - height - *y;
1953 }
1954
1955 *x += area->x;
1956 *y += area->y;
1957 }
1958