1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 screen.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
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.
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.
17 See the COPYING file for a copy of the GNU General Public License.
24 #include "startupnotify.h"
25 #include "moveresize.h"
35 #include "render/render.h"
37 #include "obt/display.h"
39 #include "obt/mainloop.h"
43 # include <sys/types.h>
48 /*! The event mask to grab on the root window */
49 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
50 EnterWindowMask | LeaveWindowMask | \
51 SubstructureRedirectMask | FocusChangeMask | \
52 ButtonPressMask | ButtonReleaseMask)
54 static gboolean screen_validate_layout(ObDesktopLayout *l);
55 static gboolean replace_wm(void);
56 static void screen_tell_ksplash(void);
57 static void screen_fallback_focus(void);
59 guint screen_num_desktops;
60 guint screen_num_monitors;
62 guint screen_last_desktop;
63 gboolean screen_showing_desktop;
64 ObDesktopLayout screen_desktop_layout;
65 gchar **screen_desktop_names;
66 Window screen_support_win;
67 Time screen_desktop_user_time = CurrentTime;
69 static Size screen_physical_size;
70 static guint screen_old_desktop;
71 static gboolean screen_desktop_timeout = TRUE;
72 /*! An array of desktops, holding an array of areas per monitor */
73 static Rect *monitor_area = NULL;
74 /*! An array of desktops, holding an array of struts */
75 static GSList *struts_top = NULL;
76 static GSList *struts_left = NULL;
77 static GSList *struts_right = NULL;
78 static GSList *struts_bottom = NULL;
80 static ObPagerPopup *desktop_popup;
82 /*! The number of microseconds that you need to be on a desktop before it will
83 replace the remembered "last desktop" */
84 #define REMEMBER_LAST_DESKTOP_TIME 750000
86 static gboolean replace_wm(void)
90 Window current_wm_sn_owner;
93 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
94 wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
97 current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
98 if (current_wm_sn_owner == screen_support_win)
99 current_wm_sn_owner = None;
100 if (current_wm_sn_owner) {
101 if (!ob_replace_wm) {
102 g_message(_("A window manager is already running on screen %d"),
106 obt_display_ignore_errors(TRUE);
108 /* We want to find out when the current selection owner dies */
109 XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
110 XSync(obt_display, FALSE);
112 obt_display_ignore_errors(FALSE);
113 if (obt_display_error_occured)
114 current_wm_sn_owner = None;
117 timestamp = event_get_server_time();
119 XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
122 if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
123 g_message(_("Could not acquire window manager selection on screen %d"),
128 /* Wait for old window manager to go away */
129 if (current_wm_sn_owner) {
132 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
134 while (wait < timeout) {
135 if (XCheckWindowEvent(obt_display, current_wm_sn_owner,
136 StructureNotifyMask, &event) &&
137 event.type == DestroyNotify)
139 g_usleep(G_USEC_PER_SEC / 10);
140 wait += G_USEC_PER_SEC / 10;
143 if (wait >= timeout) {
144 g_message(_("The WM on screen %d is not exiting"), ob_screen);
149 /* Send client message indicating that we are now the WM */
150 obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
151 timestamp, wm_sn_atom, screen_support_win, 0, 0,
152 SubstructureNotifyMask);
157 gboolean screen_annex(void)
159 XSetWindowAttributes attrib;
164 /* create the netwm support window */
165 attrib.override_redirect = TRUE;
166 attrib.event_mask = PropertyChangeMask;
167 screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
169 CopyFromParent, InputOutput,
171 CWEventMask | CWOverrideRedirect,
173 XMapWindow(obt_display, screen_support_win);
174 XLowerWindow(obt_display, screen_support_win);
177 XDestroyWindow(obt_display, screen_support_win);
181 obt_display_ignore_errors(TRUE);
182 XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
183 obt_display_ignore_errors(FALSE);
184 if (obt_display_error_occured) {
185 g_message(_("A window manager is already running on screen %d"),
188 XDestroyWindow(obt_display, screen_support_win);
192 screen_set_root_cursor();
194 /* set the OPENBOX_PID hint */
196 OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
198 /* set supporting window */
199 OBT_PROP_SET32(obt_root(ob_screen),
200 NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
202 /* set properties on the supporting window */
203 OBT_PROP_SETS(screen_support_win, NET_WM_NAME, utf8, "Openbox");
204 OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK,
205 WINDOW, screen_support_win);
207 /* set the _NET_SUPPORTED_ATOMS hint */
209 /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
210 num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
212 supported = g_new(gulong, num_support);
213 supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
214 supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
215 supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
216 supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
217 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
218 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
219 supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
220 supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
221 supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
222 supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
223 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
224 supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
225 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
226 supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
227 supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
228 supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
229 supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
230 supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
231 supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
232 supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
233 supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
234 supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
235 supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
236 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
237 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
238 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
239 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
240 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
241 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
242 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
243 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
244 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
245 supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
246 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
247 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
248 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
249 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
250 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
251 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
252 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
253 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
254 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
255 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
256 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
257 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
258 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
259 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
260 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
261 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
262 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
263 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
264 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
265 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
266 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
267 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
268 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
269 supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
270 supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
271 supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
273 supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
275 supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
276 supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
277 supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
278 supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
280 supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
281 supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
283 supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
284 supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
286 supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
287 supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
288 supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
290 supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
291 supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
292 supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
293 supported[i++] = OBT_PROP_ATOM(OB_THEME);
294 supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
295 supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
296 g_assert(i == num_support);
298 OBT_PROP_SETA32(obt_root(ob_screen),
299 NET_SUPPORTED, ATOM, supported, num_support);
302 screen_tell_ksplash();
307 static void screen_tell_ksplash(void)
312 argv = g_new(gchar*, 6);
313 argv[0] = g_strdup("dcop");
314 argv[1] = g_strdup("ksplash");
315 argv[2] = g_strdup("ksplash");
316 argv[3] = g_strdup("upAndRunning(QString)");
317 argv[4] = g_strdup("wm started");
320 /* tell ksplash through the dcop server command line interface */
321 g_spawn_async(NULL, argv, NULL,
322 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
323 G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
324 NULL, NULL, NULL, NULL);
327 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
328 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
329 something. oh well. */
330 e.xclient.type = ClientMessage;
331 e.xclient.display = obt_display;
332 e.xclient.window = obt_root(ob_screen);
333 e.xclient.message_type =
334 XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
335 e.xclient.format = 8;
336 strcpy(e.xclient.data.b, "wm started");
337 XSendEvent(obt_display, obt_root(ob_screen),
338 False, SubstructureNotifyMask, &e);
341 void screen_startup(gboolean reconfig)
343 gchar **names = NULL;
345 gboolean namesexist = FALSE;
347 desktop_popup = pager_popup_new();
348 pager_popup_height(desktop_popup, POPUP_HEIGHT);
351 /* update the pager popup's width */
352 pager_popup_text_width_to_strings(desktop_popup,
353 screen_desktop_names,
354 screen_num_desktops);
358 /* get the initial size */
361 /* have names already been set for the desktops? */
362 if (OBT_PROP_GETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, utf8, &names)) {
367 /* if names don't exist and we have session names, set those.
368 do this stuff BEFORE setting the number of desktops, because that
369 will create default names for them
371 if (!namesexist && session_desktop_names != NULL) {
375 /* get the desktop names */
376 numnames = g_slist_length(session_desktop_names);
377 names = g_new(gchar*, numnames + 1);
378 names[numnames] = NULL;
379 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
380 names[i] = g_strdup(it->data);
382 /* set the root window property */
383 OBT_PROP_SETSS(obt_root(ob_screen),
384 NET_DESKTOP_NAMES, utf8, (const gchar**)names);
389 /* set the number of desktops, if it's not already set.
391 this will also set the default names from the config file up for
392 desktops that don't have names yet */
393 screen_num_desktops = 0;
394 if (OBT_PROP_GET32(obt_root(ob_screen),
395 NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
397 if (d != config_desktops_num) {
398 /* TRANSLATORS: If you need to specify a different order of the
399 arguments, you can use %1$d for the first one and %2$d for the
400 second one. For example,
401 "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
402 g_warning(_("Openbox is configured for %d desktops, but the current session has %d. Overriding the Openbox configuration."),
403 config_desktops_num, d);
405 screen_set_num_desktops(d);
407 /* restore from session if possible */
408 else if (session_num_desktops)
409 screen_set_num_desktops(session_num_desktops);
411 screen_set_num_desktops(config_desktops_num);
413 screen_desktop = screen_num_desktops; /* something invalid */
414 /* start on the current desktop when a wm was already running */
415 if (OBT_PROP_GET32(obt_root(ob_screen),
416 NET_CURRENT_DESKTOP, CARDINAL, &d) &&
417 d < screen_num_desktops)
419 screen_set_desktop(d, FALSE);
420 } else if (session_desktop >= 0)
421 screen_set_desktop(MIN((guint)session_desktop,
422 screen_num_desktops), FALSE);
424 screen_set_desktop(MIN(config_screen_firstdesk,
425 screen_num_desktops) - 1, FALSE);
426 screen_last_desktop = screen_desktop;
428 /* don't start in showing-desktop mode */
429 screen_showing_desktop = FALSE;
430 OBT_PROP_SET32(obt_root(ob_screen),
431 NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
433 if (session_desktop_layout_present &&
434 screen_validate_layout(&session_desktop_layout))
436 screen_desktop_layout = session_desktop_layout;
439 screen_update_layout();
442 void screen_shutdown(gboolean reconfig)
444 pager_popup_free(desktop_popup);
449 XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
451 /* we're not running here no more! */
452 OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
454 OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
455 /* don't keep this mode */
456 OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
458 XDestroyWindow(obt_display, screen_support_win);
460 g_strfreev(screen_desktop_names);
461 screen_desktop_names = NULL;
464 void screen_resize(void)
466 static gint oldw = 0, oldh = 0;
471 w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
472 h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
474 if (w == oldw && h == oldh) return;
478 /* Set the _NET_DESKTOP_GEOMETRY hint */
479 screen_physical_size.width = geometry[0] = w;
480 screen_physical_size.height = geometry[1] = h;
481 OBT_PROP_SETA32(obt_root(ob_screen),
482 NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
484 if (ob_state() != OB_STATE_RUNNING)
487 screen_update_areas();
490 for (it = client_list; it; it = g_list_next(it))
491 client_move_onscreen(it->data, FALSE);
494 void screen_set_num_desktops(guint num)
498 GList *it, *stacking_copy;
502 if (screen_num_desktops == num) return;
504 old = screen_num_desktops;
505 screen_num_desktops = num;
506 OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
508 /* set the viewport hint */
509 viewport = g_new0(gulong, num * 2);
510 OBT_PROP_SETA32(obt_root(ob_screen),
511 NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
514 /* the number of rows/columns will differ */
515 screen_update_layout();
517 /* move windows on desktops that will no longer exist!
518 make a copy of the list cuz we're changing it */
519 stacking_copy = g_list_copy(stacking_list);
520 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
521 if (WINDOW_IS_CLIENT(it->data)) {
522 ObClient *c = it->data;
523 if (c->desktop != DESKTOP_ALL && c->desktop >= num)
524 client_set_desktop(c, num - 1, FALSE, TRUE);
525 /* raise all the windows that are on the current desktop which
527 else if (screen_desktop == num - 1 &&
528 (c->desktop == DESKTOP_ALL ||
529 c->desktop == screen_desktop))
530 stacking_raise(CLIENT_AS_WINDOW(c));
533 g_list_free(stacking_copy);
535 /* change our struts/area to match (after moving windows) */
536 screen_update_areas();
538 /* may be some unnamed desktops that we need to fill in with names
539 (after updating the areas so the popup can resize) */
540 screen_update_desktop_names();
542 /* change our desktop if we're on one that no longer exists! */
543 if (screen_desktop >= screen_num_desktops)
544 screen_set_desktop(num - 1, TRUE);
547 static void screen_fallback_focus(void)
552 /* only allow omnipresent windows to get focus on desktop change if
553 an omnipresent window is already focused (it'll keep focus probably, but
554 maybe not depending on mouse-focus options) */
555 allow_omni = focus_client && (client_normal(focus_client) &&
556 focus_client->desktop == DESKTOP_ALL);
558 /* the client moved there already so don't move focus. prevent flicker
559 on sendtodesktop + follow */
560 if (focus_client && focus_client->desktop == screen_desktop)
563 /* have to try focus here because when you leave an empty desktop
564 there is no focus out to watch for. also, we have different rules
565 here. we always allow it to look under the mouse pointer if
566 config_focus_last is FALSE
568 do this before hiding the windows so if helper windows are coming
569 with us, they don't get hidden
571 if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
574 /* only do the flicker reducing stuff ahead of time if we are going
575 to call xsetinputfocus on the window ourselves. otherwise there is
576 no guarantee the window will actually take focus.. */
578 /* reduce flicker by hiliting now rather than waiting for the
579 server FocusIn event */
580 frame_adjust_focus(c->frame, TRUE);
581 /* do this here so that if you switch desktops to a window with
582 helper windows then the helper windows won't flash */
583 client_bring_helper_windows(c);
588 static gboolean last_desktop_func(gpointer data)
590 screen_desktop_timeout = TRUE;
594 void screen_set_desktop(guint num, gboolean dofocus)
600 g_assert(num < screen_num_desktops);
602 previous = screen_desktop;
603 screen_desktop = num;
605 if (previous == num) return;
607 OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
609 /* This whole thing decides when/how to save the screen_last_desktop so
610 that it can be restored later if you want */
611 if (screen_desktop_timeout) {
612 /* If screen_desktop_timeout is true, then we've been on this desktop
613 long enough and we can save it as the last desktop. */
615 if (screen_last_desktop == previous)
616 /* this is the startup state only */
617 screen_old_desktop = screen_desktop;
619 /* save the "last desktop" as the "old desktop" */
620 screen_old_desktop = screen_last_desktop;
621 /* save the desktop we're coming from as the "last desktop" */
622 screen_last_desktop = previous;
626 /* If screen_desktop_timeout is false, then we just got to this desktop
627 and we are moving away again. */
629 if (screen_desktop == screen_last_desktop) {
630 /* If we are moving to the "last desktop" .. */
631 if (previous == screen_old_desktop) {
632 /* .. from the "old desktop", change the last desktop to
633 be where we are coming from */
634 screen_last_desktop = screen_old_desktop;
636 else if (screen_last_desktop == screen_old_desktop) {
637 /* .. and also to the "old desktop", change the "last
638 desktop" to be where we are coming from */
639 screen_last_desktop = previous;
642 /* .. from some other desktop, then set the "last desktop" to
643 be the saved "old desktop", i.e. where we were before the
645 screen_last_desktop = screen_old_desktop;
649 /* If we are moving to any desktop besides the "last desktop"..
650 (this is the normal case) */
651 if (screen_desktop == screen_old_desktop) {
652 /* If moving to the "old desktop", which is not the
653 "last desktop", don't save anything */
655 else if (previous == screen_old_desktop) {
656 /* If moving from the "old desktop", and not to the
657 "last desktop", don't save anything */
659 else if (screen_last_desktop == screen_old_desktop) {
660 /* If the "last desktop" is the same as "old desktop" and
661 you're not moving to the "last desktop" then save where
662 we're coming from as the "last desktop" */
663 screen_last_desktop = previous;
666 /* If the "last desktop" is different from the "old desktop"
667 and you're not moving to the "last desktop", then don't save
672 screen_desktop_timeout = FALSE;
673 obt_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
674 obt_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
675 last_desktop_func, NULL, NULL, NULL);
677 ob_debug("Moving to desktop %d", num+1);
679 if (ob_state() == OB_STATE_RUNNING)
680 screen_show_desktop_popup(screen_desktop);
682 /* ignore enter events caused by the move */
683 ignore_start = event_start_ignore_all_enters();
685 if (moveresize_client)
686 client_set_desktop(moveresize_client, num, TRUE, FALSE);
688 /* show windows before hiding the rest to lessen the enter/leave events */
690 /* show windows from top to bottom */
691 for (it = stacking_list; it; it = g_list_next(it)) {
692 if (WINDOW_IS_CLIENT(it->data)) {
693 ObClient *c = it->data;
698 if (dofocus) screen_fallback_focus();
700 /* hide windows from bottom to top */
701 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
702 if (WINDOW_IS_CLIENT(it->data)) {
703 ObClient *c = it->data;
708 event_end_ignore_all_enters(ignore_start);
710 if (event_curtime != CurrentTime)
711 screen_desktop_user_time = event_curtime;
713 hooks_queue(OB_HOOK_SCREEN_DESK_CHANGE, NULL);
716 void screen_add_desktop(gboolean current)
720 /* ignore enter events caused by this */
721 ignore_start = event_start_ignore_all_enters();
723 screen_set_num_desktops(screen_num_desktops+1);
725 /* move all the clients over */
729 for (it = client_list; it; it = g_list_next(it)) {
730 ObClient *c = it->data;
731 if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
732 /* don't move direct children, they'll be moved with their
733 parent - which will have to be on the same desktop */
734 !client_direct_parent(c))
736 ob_debug("moving window %s", c->title);
737 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
742 event_end_ignore_all_enters(ignore_start);
745 void screen_remove_desktop(gboolean current)
747 guint rmdesktop, movedesktop;
748 GList *it, *stacking_copy;
751 if (screen_num_desktops <= 1) return;
753 /* ignore enter events caused by this */
754 ignore_start = event_start_ignore_all_enters();
756 /* what desktop are we removing and moving to? */
758 rmdesktop = screen_desktop;
760 rmdesktop = screen_num_desktops - 1;
761 if (rmdesktop < screen_num_desktops - 1)
762 movedesktop = rmdesktop + 1;
764 movedesktop = rmdesktop;
766 /* make a copy of the list cuz we're changing it */
767 stacking_copy = g_list_copy(stacking_list);
768 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
769 if (WINDOW_IS_CLIENT(it->data)) {
770 ObClient *c = it->data;
771 guint d = c->desktop;
772 if (d != DESKTOP_ALL && d >= movedesktop &&
773 /* don't move direct children, they'll be moved with their
774 parent - which will have to be on the same desktop */
775 !client_direct_parent(c))
777 ob_debug("moving window %s", c->title);
778 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
780 /* raise all the windows that are on the current desktop which
782 if ((screen_desktop == rmdesktop - 1 ||
783 screen_desktop == rmdesktop) &&
784 (d == DESKTOP_ALL || d == screen_desktop))
786 stacking_raise(CLIENT_AS_WINDOW(c));
787 ob_debug("raising window %s", c->title);
791 g_list_free(stacking_copy);
793 /* fallback focus like we're changing desktops */
794 if (screen_desktop < screen_num_desktops - 1) {
795 screen_fallback_focus();
796 ob_debug("fake desktop change");
799 screen_set_num_desktops(screen_num_desktops-1);
801 event_end_ignore_all_enters(ignore_start);
804 static void get_row_col(guint d, guint *r, guint *c)
806 switch (screen_desktop_layout.orientation) {
807 case OB_ORIENTATION_HORZ:
808 switch (screen_desktop_layout.start_corner) {
809 case OB_CORNER_TOPLEFT:
810 *r = d / screen_desktop_layout.columns;
811 *c = d % screen_desktop_layout.columns;
813 case OB_CORNER_BOTTOMLEFT:
814 *r = screen_desktop_layout.rows - 1 -
815 d / screen_desktop_layout.columns;
816 *c = d % screen_desktop_layout.columns;
818 case OB_CORNER_TOPRIGHT:
819 *r = d / screen_desktop_layout.columns;
820 *c = screen_desktop_layout.columns - 1 -
821 d % screen_desktop_layout.columns;
823 case OB_CORNER_BOTTOMRIGHT:
824 *r = screen_desktop_layout.rows - 1 -
825 d / screen_desktop_layout.columns;
826 *c = screen_desktop_layout.columns - 1 -
827 d % screen_desktop_layout.columns;
831 case OB_ORIENTATION_VERT:
832 switch (screen_desktop_layout.start_corner) {
833 case OB_CORNER_TOPLEFT:
834 *r = d % screen_desktop_layout.rows;
835 *c = d / screen_desktop_layout.rows;
837 case OB_CORNER_BOTTOMLEFT:
838 *r = screen_desktop_layout.rows - 1 -
839 d % screen_desktop_layout.rows;
840 *c = d / screen_desktop_layout.rows;
842 case OB_CORNER_TOPRIGHT:
843 *r = d % screen_desktop_layout.rows;
844 *c = screen_desktop_layout.columns - 1 -
845 d / screen_desktop_layout.rows;
847 case OB_CORNER_BOTTOMRIGHT:
848 *r = screen_desktop_layout.rows - 1 -
849 d % screen_desktop_layout.rows;
850 *c = screen_desktop_layout.columns - 1 -
851 d / screen_desktop_layout.rows;
858 static guint translate_row_col(guint r, guint c)
860 switch (screen_desktop_layout.orientation) {
861 case OB_ORIENTATION_HORZ:
862 switch (screen_desktop_layout.start_corner) {
863 case OB_CORNER_TOPLEFT:
864 return r % screen_desktop_layout.rows *
865 screen_desktop_layout.columns +
866 c % screen_desktop_layout.columns;
867 case OB_CORNER_BOTTOMLEFT:
868 return (screen_desktop_layout.rows - 1 -
869 r % screen_desktop_layout.rows) *
870 screen_desktop_layout.columns +
871 c % screen_desktop_layout.columns;
872 case OB_CORNER_TOPRIGHT:
873 return r % screen_desktop_layout.rows *
874 screen_desktop_layout.columns +
875 (screen_desktop_layout.columns - 1 -
876 c % screen_desktop_layout.columns);
877 case OB_CORNER_BOTTOMRIGHT:
878 return (screen_desktop_layout.rows - 1 -
879 r % screen_desktop_layout.rows) *
880 screen_desktop_layout.columns +
881 (screen_desktop_layout.columns - 1 -
882 c % screen_desktop_layout.columns);
884 case OB_ORIENTATION_VERT:
885 switch (screen_desktop_layout.start_corner) {
886 case OB_CORNER_TOPLEFT:
887 return c % screen_desktop_layout.columns *
888 screen_desktop_layout.rows +
889 r % screen_desktop_layout.rows;
890 case OB_CORNER_BOTTOMLEFT:
891 return c % screen_desktop_layout.columns *
892 screen_desktop_layout.rows +
893 (screen_desktop_layout.rows - 1 -
894 r % screen_desktop_layout.rows);
895 case OB_CORNER_TOPRIGHT:
896 return (screen_desktop_layout.columns - 1 -
897 c % screen_desktop_layout.columns) *
898 screen_desktop_layout.rows +
899 r % screen_desktop_layout.rows;
900 case OB_CORNER_BOTTOMRIGHT:
901 return (screen_desktop_layout.columns - 1 -
902 c % screen_desktop_layout.columns) *
903 screen_desktop_layout.rows +
904 (screen_desktop_layout.rows - 1 -
905 r % screen_desktop_layout.rows);
908 g_assert_not_reached();
912 static gboolean hide_desktop_popup_func(gpointer data)
914 pager_popup_hide(desktop_popup);
915 return FALSE; /* don't repeat */
918 void screen_show_desktop_popup(guint d)
922 /* 0 means don't show the popup */
923 if (!config_desktop_popup_time) return;
925 a = screen_physical_area_active();
926 pager_popup_position(desktop_popup, CenterGravity,
927 a->x + a->width / 2, a->y + a->height / 2);
928 pager_popup_icon_size_multiplier(desktop_popup,
929 (screen_desktop_layout.columns /
930 screen_desktop_layout.rows) / 2,
931 (screen_desktop_layout.rows/
932 screen_desktop_layout.columns) / 2);
933 pager_popup_max_width(desktop_popup,
934 MAX(a->width/3, POPUP_WIDTH));
935 pager_popup_show(desktop_popup, screen_desktop_names[d], d);
937 obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
938 obt_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
939 hide_desktop_popup_func, NULL, NULL, NULL);
943 void screen_hide_desktop_popup(void)
945 obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
946 pager_popup_hide(desktop_popup);
949 guint screen_find_desktop(guint from, ObDirection dir,
950 gboolean wrap, gboolean linear)
956 get_row_col(d, &r, &c);
959 case OB_DIRECTION_EAST:
960 if (d < screen_num_desktops - 1)
967 case OB_DIRECTION_WEST:
971 d = screen_num_desktops - 1;
976 g_assert_not_reached();
981 case OB_DIRECTION_EAST:
983 if (c >= screen_desktop_layout.columns) {
989 d = translate_row_col(r, c);
990 if (d >= screen_num_desktops) {
997 case OB_DIRECTION_WEST:
999 if (c >= screen_desktop_layout.columns) {
1001 c = screen_desktop_layout.columns - 1;
1005 d = translate_row_col(r, c);
1006 if (d >= screen_num_desktops) {
1013 case OB_DIRECTION_SOUTH:
1015 if (r >= screen_desktop_layout.rows) {
1021 d = translate_row_col(r, c);
1022 if (d >= screen_num_desktops) {
1029 case OB_DIRECTION_NORTH:
1031 if (r >= screen_desktop_layout.rows) {
1033 r = screen_desktop_layout.rows - 1;
1037 d = translate_row_col(r, c);
1038 if (d >= screen_num_desktops) {
1046 g_assert_not_reached();
1050 d = translate_row_col(r, c);
1055 static gboolean screen_validate_layout(ObDesktopLayout *l)
1057 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1060 /* fill in a zero rows/columns */
1061 if (l->columns == 0) {
1062 l->columns = screen_num_desktops / l->rows;
1063 if (l->rows * l->columns < screen_num_desktops)
1065 if (l->rows * l->columns >= screen_num_desktops + l->columns)
1067 } else if (l->rows == 0) {
1068 l->rows = screen_num_desktops / l->columns;
1069 if (l->columns * l->rows < screen_num_desktops)
1071 if (l->columns * l->rows >= screen_num_desktops + l->rows)
1075 /* bounds checking */
1076 if (l->orientation == OB_ORIENTATION_HORZ) {
1077 l->columns = MIN(screen_num_desktops, l->columns);
1078 l->rows = MIN(l->rows,
1079 (screen_num_desktops + l->columns - 1) / l->columns);
1080 l->columns = screen_num_desktops / l->rows +
1081 !!(screen_num_desktops % l->rows);
1083 l->rows = MIN(screen_num_desktops, l->rows);
1084 l->columns = MIN(l->columns,
1085 (screen_num_desktops + l->rows - 1) / l->rows);
1086 l->rows = screen_num_desktops / l->columns +
1087 !!(screen_num_desktops % l->columns);
1092 void screen_update_layout(void)
1099 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1100 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1101 screen_desktop_layout.rows = 1;
1102 screen_desktop_layout.columns = screen_num_desktops;
1104 if (OBT_PROP_GETA32(obt_root(ob_screen),
1105 NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1106 if (num == 3 || num == 4) {
1108 if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1109 l.orientation = OB_ORIENTATION_VERT;
1110 else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1111 l.orientation = OB_ORIENTATION_HORZ;
1116 l.start_corner = OB_CORNER_TOPLEFT;
1118 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1119 l.start_corner = OB_CORNER_TOPLEFT;
1120 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1121 l.start_corner = OB_CORNER_TOPRIGHT;
1122 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1123 l.start_corner = OB_CORNER_BOTTOMRIGHT;
1124 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1125 l.start_corner = OB_CORNER_BOTTOMLEFT;
1130 l.columns = data[1];
1133 if (screen_validate_layout(&l))
1134 screen_desktop_layout = l;
1141 void screen_update_desktop_names(void)
1145 /* empty the array */
1146 g_strfreev(screen_desktop_names);
1147 screen_desktop_names = NULL;
1149 if (OBT_PROP_GETSS(obt_root(ob_screen),
1150 NET_DESKTOP_NAMES, utf8, &screen_desktop_names))
1151 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1154 if (i < screen_num_desktops) {
1157 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1158 screen_num_desktops + 1);
1159 screen_desktop_names[screen_num_desktops] = NULL;
1161 it = g_slist_nth(config_desktops_names, i);
1163 for (; i < screen_num_desktops; ++i) {
1164 if (it && ((char*)it->data)[0]) /* not empty */
1165 /* use the names from the config file when possible */
1166 screen_desktop_names[i] = g_strdup(it->data);
1168 /* make up a nice name if it's not though */
1169 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1171 if (it) it = g_slist_next(it);
1174 /* if we changed any names, then set the root property so we can
1175 all agree on the names */
1176 OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1177 utf8, (const gchar**)screen_desktop_names);
1180 /* resize the pager for these names */
1181 pager_popup_text_width_to_strings(desktop_popup,
1182 screen_desktop_names,
1183 screen_num_desktops);
1186 void screen_show_desktop(gboolean show, ObClient *show_only)
1190 if (show == screen_showing_desktop) return; /* no change */
1192 screen_showing_desktop = show;
1195 /* hide windows bottom to top */
1196 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1197 if (WINDOW_IS_CLIENT(it->data)) {
1198 ObClient *client = it->data;
1199 client_showhide(client);
1204 /* restore windows top to bottom */
1205 for (it = stacking_list; it; it = g_list_next(it)) {
1206 if (WINDOW_IS_CLIENT(it->data)) {
1207 ObClient *client = it->data;
1208 if (client_should_show(client)) {
1209 if (!show_only || client == show_only)
1210 client_show(client);
1212 client_iconify(client, TRUE, FALSE, TRUE);
1219 /* focus the desktop */
1220 for (it = focus_order; it; it = g_list_next(it)) {
1221 ObClient *c = it->data;
1222 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1223 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1224 client_focus(it->data))
1228 else if (!show_only) {
1231 if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1232 /* only do the flicker reducing stuff ahead of time if we are going
1233 to call xsetinputfocus on the window ourselves. otherwise there
1234 is no guarantee the window will actually take focus.. */
1236 /* reduce flicker by hiliting now rather than waiting for the
1237 server FocusIn event */
1238 frame_adjust_focus(c->frame, TRUE);
1243 show = !!show; /* make it boolean */
1244 OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1247 void screen_install_colormap(ObClient *client, gboolean install)
1249 if (client == NULL || client->colormap == None) {
1251 XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1253 XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1255 obt_display_ignore_errors(TRUE);
1257 XInstallColormap(obt_display, client->colormap);
1259 XUninstallColormap(obt_display, client->colormap);
1260 obt_display_ignore_errors(FALSE);
1264 #define STRUT_LEFT_ON_MONITOR(s, i) \
1265 (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
1266 monitor_area[i].y, monitor_area[i].height))
1267 #define STRUT_RIGHT_ON_MONITOR(s, i) \
1268 (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
1269 monitor_area[i].y, monitor_area[i].height))
1270 #define STRUT_TOP_ON_MONITOR(s, i) \
1271 (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
1272 monitor_area[i].x, monitor_area[i].width))
1273 #define STRUT_BOTTOM_ON_MONITOR(s, i) \
1274 (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
1275 monitor_area[i].x, monitor_area[i].width))
1279 StrutPartial *strut;
1282 #define RESET_STRUT_LIST(sl) \
1283 (g_slist_free(sl), sl = NULL)
1285 #define ADD_STRUT_TO_LIST(sl, d, s) \
1287 ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1290 sl = g_slist_prepend(sl, ss); \
1293 #define VALIDATE_STRUTS(sl, side, max) \
1296 for (it = sl; it; it = g_slist_next(it)) { \
1297 ObScreenStrut *ss = it->data; \
1298 ss->strut->side = MIN(max, ss->strut->side); \
1302 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1307 if (ob_debug_xinerama) {
1308 gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1309 gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1311 *xin_areas = g_new(Rect, *nxin + 1);
1312 RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1313 RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1316 else if (obt_display_extension_xinerama) {
1319 XineramaScreenInfo *info = XineramaQueryScreens(obt_display, &n);
1321 *xin_areas = g_new(Rect, *nxin + 1);
1322 for (i = 0; i < *nxin; ++i)
1323 RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1324 info[i].width, info[i].height);
1330 *xin_areas = g_new(Rect, *nxin + 1);
1331 RECT_SET((*xin_areas)[0], 0, 0,
1332 WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1333 HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1336 /* returns one extra with the total area in it */
1337 l = (*xin_areas)[0].x;
1338 t = (*xin_areas)[0].y;
1339 r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1340 b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1341 for (i = 1; i < *nxin; ++i) {
1342 l = MIN(l, (*xin_areas)[i].x);
1343 t = MIN(l, (*xin_areas)[i].y);
1344 r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1345 b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1347 RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1350 void screen_update_areas(void)
1357 g_free(monitor_area);
1358 get_xinerama_screens(&monitor_area, &screen_num_monitors);
1360 /* set up the user-specified margins */
1361 config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1362 config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1363 config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1364 config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1365 config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1366 config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1367 config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1368 config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1370 dims = g_new(gulong, 4 * screen_num_desktops * screen_num_monitors);
1372 RESET_STRUT_LIST(struts_left);
1373 RESET_STRUT_LIST(struts_top);
1374 RESET_STRUT_LIST(struts_right);
1375 RESET_STRUT_LIST(struts_bottom);
1377 /* collect the struts */
1378 for (it = client_list; it; it = g_list_next(it)) {
1379 ObClient *c = it->data;
1381 ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1383 ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1385 ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1386 if (c->strut.bottom)
1387 ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1389 if (dock_strut.left)
1390 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1392 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1393 if (dock_strut.right)
1394 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1395 if (dock_strut.bottom)
1396 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1398 if (config_margins.left)
1399 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1400 if (config_margins.top)
1401 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1402 if (config_margins.right)
1403 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1404 if (config_margins.bottom)
1405 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1407 VALIDATE_STRUTS(struts_left, left,
1408 monitor_area[screen_num_monitors].width / 2);
1409 VALIDATE_STRUTS(struts_right, right,
1410 monitor_area[screen_num_monitors].width / 2);
1411 VALIDATE_STRUTS(struts_top, top,
1412 monitor_area[screen_num_monitors].height / 2);
1413 VALIDATE_STRUTS(struts_bottom, bottom,
1414 monitor_area[screen_num_monitors].height / 2);
1416 /* set up the work areas to be full screen */
1417 for (i = 0; i < screen_num_monitors; ++i)
1418 for (j = 0; j < screen_num_desktops; ++j) {
1419 dims[(i * screen_num_desktops + j) * 4+0] = monitor_area[i].x;
1420 dims[(i * screen_num_desktops + j) * 4+1] = monitor_area[i].y;
1421 dims[(i * screen_num_desktops + j) * 4+2] = monitor_area[i].width;
1422 dims[(i * screen_num_desktops + j) * 4+3] = monitor_area[i].height;
1425 /* calculate the work areas from the struts */
1426 for (i = 0; i < screen_num_monitors; ++i)
1427 for (j = 0; j < screen_num_desktops; ++j) {
1428 gint l = 0, r = 0, t = 0, b = 0;
1430 /* only add the strut to the area if it touches the monitor */
1432 for (sit = struts_left; sit; sit = g_slist_next(sit)) {
1433 ObScreenStrut *s = sit->data;
1434 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1435 STRUT_LEFT_ON_MONITOR(s->strut, i))
1436 l = MAX(l, s->strut->left);
1438 for (sit = struts_top; sit; sit = g_slist_next(sit)) {
1439 ObScreenStrut *s = sit->data;
1440 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1441 STRUT_TOP_ON_MONITOR(s->strut, i))
1442 t = MAX(t, s->strut->top);
1444 for (sit = struts_right; sit; sit = g_slist_next(sit)) {
1445 ObScreenStrut *s = sit->data;
1446 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1447 STRUT_RIGHT_ON_MONITOR(s->strut, i))
1448 r = MAX(r, s->strut->right);
1450 for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
1451 ObScreenStrut *s = sit->data;
1452 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1453 STRUT_BOTTOM_ON_MONITOR(s->strut, i))
1454 b = MAX(b, s->strut->bottom);
1457 /* based on these margins, set the work area for the
1459 dims[(i * screen_num_desktops + j) * 4 + 0] += l;
1460 dims[(i * screen_num_desktops + j) * 4 + 1] += t;
1461 dims[(i * screen_num_desktops + j) * 4 + 2] -= l + r;
1462 dims[(i * screen_num_desktops + j) * 4 + 3] -= t + b;
1465 /* all the work areas are not used here, only the ones for the first
1467 OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1468 dims, 4 * screen_num_desktops);
1470 /* the area has changed, adjust all the windows if they need it */
1471 for (it = client_list; it; it = g_list_next(it))
1472 client_reconfigure(it->data, FALSE);
1478 Rect* screen_area_all_monitors(guint desktop)
1483 a = screen_area_monitor(desktop, 0);
1485 /* combine all the monitors together */
1486 for (i = 1; i < screen_num_monitors; ++i) {
1487 Rect *m = screen_area_monitor(desktop, i);
1490 l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1491 t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1492 r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1493 b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1495 RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1504 #define STRUT_LEFT_IN_SEARCH(s, search) \
1505 (RANGES_INTERSECT(search->y, search->height, \
1506 s->left_start, s->left_end - s->left_start + 1))
1507 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1508 (RANGES_INTERSECT(search->y, search->height, \
1509 s->right_start, s->right_end - s->right_start + 1))
1510 #define STRUT_TOP_IN_SEARCH(s, search) \
1511 (RANGES_INTERSECT(search->x, search->width, \
1512 s->top_start, s->top_end - s->top_start + 1))
1513 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1514 (RANGES_INTERSECT(search->x, search->width, \
1515 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1517 #define STRUT_LEFT_IGNORE(s, us, search) \
1518 (head == SCREEN_AREA_ALL_MONITORS && us && \
1519 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1520 #define STRUT_RIGHT_IGNORE(s, us, search) \
1521 (head == SCREEN_AREA_ALL_MONITORS && us && \
1522 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1523 #define STRUT_TOP_IGNORE(s, us, search) \
1524 (head == SCREEN_AREA_ALL_MONITORS && us && \
1525 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1526 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1527 (head == SCREEN_AREA_ALL_MONITORS && us && \
1528 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1530 Rect* screen_area(guint desktop, guint head, Rect *search)
1534 gint l, r, t, b, al, ar, at, ab;
1536 gboolean us = search != NULL; /* user provided search */
1538 g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1539 g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1540 head == SCREEN_AREA_ALL_MONITORS);
1541 g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1543 /* find any struts for this monitor
1544 which will be affecting the search area.
1547 /* search everything if search is null */
1549 if (head < screen_num_monitors) search = &monitor_area[head];
1550 else search = &monitor_area[screen_num_monitors];
1552 if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1554 /* al is "all left" meaning the furthest left you can get, l is our
1555 "working left" meaning our current strut edge which we're calculating
1558 /* only include monitors which the search area lines up with */
1559 if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1560 al = l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1561 at = t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1562 ar = r = RECT_LEFT(monitor_area[screen_num_monitors]);
1563 ab = b = RECT_TOP(monitor_area[screen_num_monitors]);
1564 for (i = 0; i < screen_num_monitors; ++i) {
1565 /* add the monitor if applicable */
1566 if (RANGES_INTERSECT(search->x, search->width,
1567 monitor_area[i].x, monitor_area[i].width))
1569 at = t = MIN(t, RECT_TOP(monitor_area[i]));
1570 ab = b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1572 if (RANGES_INTERSECT(search->y, search->height,
1573 monitor_area[i].y, monitor_area[i].height))
1575 al = l = MIN(l, RECT_LEFT(monitor_area[i]));
1576 ar = r = MAX(r, RECT_RIGHT(monitor_area[i]));
1580 al = l = RECT_LEFT(monitor_area[screen_num_monitors]);
1581 at = t = RECT_TOP(monitor_area[screen_num_monitors]);
1582 ar = r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1583 ab = b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1586 for (d = 0; d < screen_num_desktops; ++d) {
1587 if (d != desktop && desktop != DESKTOP_ALL) continue;
1589 for (i = 0; i < screen_num_monitors; ++i) {
1590 if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1592 for (it = struts_left; it; it = g_slist_next(it)) {
1593 ObScreenStrut *s = it->data;
1594 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1595 STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1596 !STRUT_LEFT_IGNORE(s->strut, us, search))
1597 l = MAX(l, al + s->strut->left);
1599 for (it = struts_top; it; it = g_slist_next(it)) {
1600 ObScreenStrut *s = it->data;
1601 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1602 STRUT_TOP_IN_SEARCH(s->strut, search) &&
1603 !STRUT_TOP_IGNORE(s->strut, us, search))
1604 t = MAX(t, at + s->strut->top);
1606 for (it = struts_right; it; it = g_slist_next(it)) {
1607 ObScreenStrut *s = it->data;
1608 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1609 STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1610 !STRUT_RIGHT_IGNORE(s->strut, us, search))
1611 r = MIN(r, ar - s->strut->right);
1613 for (it = struts_bottom; it; it = g_slist_next(it)) {
1614 ObScreenStrut *s = it->data;
1615 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1616 STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1617 !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1618 b = MIN(b, ab - s->strut->bottom);
1621 /* limit to this monitor */
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]));
1634 a->width = r - l + 1;
1635 a->height = b - t + 1;
1639 guint screen_find_monitor(Rect *search)
1642 guint most = screen_num_monitors;
1645 for (i = 0; i < screen_num_monitors; ++i) {
1646 Rect *area = screen_physical_area_monitor(i);
1647 if (RECT_INTERSECTS_RECT(*area, *search)) {
1651 RECT_SET_INTERSECTION(r, *area, *search);
1652 v = r.width * r.height;
1664 Rect* screen_physical_area_all_monitors(void)
1666 return screen_physical_area_monitor(screen_num_monitors);
1669 Rect* screen_physical_area_monitor(guint head)
1672 g_assert(head <= screen_num_monitors);
1675 *a = monitor_area[head];
1679 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1681 g_assert(head <= screen_num_monitors);
1683 return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1686 Rect* screen_physical_area_active(void)
1691 if (moveresize_client)
1692 a = screen_physical_area_monitor(client_monitor(focus_client));
1693 else if (focus_client)
1694 a = screen_physical_area_monitor(client_monitor(focus_client));
1697 if (screen_pointer_pos(&x, &y))
1698 RECT_SET(mon, x, y, 1, 1);
1700 RECT_SET(mon, 0, 0, 1, 1);
1701 a = screen_physical_area_monitor(screen_find_monitor(&mon));
1706 void screen_set_root_cursor(void)
1708 if (sn_app_starting())
1709 XDefineCursor(obt_display, obt_root(ob_screen),
1710 ob_cursor(OB_CURSOR_BUSYPOINTER));
1712 XDefineCursor(obt_display, obt_root(ob_screen),
1713 ob_cursor(OB_CURSOR_POINTER));
1716 gboolean screen_pointer_pos(gint *x, gint *y)
1723 ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1724 &w, &w, x, y, &i, &i, &u);
1726 for (i = 0; i < ScreenCount(obt_display); ++i)
1728 if (XQueryPointer(obt_display, obt_root(i),
1729 &w, &w, x, y, &i, &i, &u))