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.
26 #include "startupnotify.h"
27 #include "moveresize.h"
36 #include "focus_cycle.h"
38 #include "extensions.h"
39 #include "render/render.h"
44 # include <sys/types.h>
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)
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);
60 guint screen_num_desktops;
61 guint screen_num_monitors;
63 guint screen_last_desktop;
64 gboolean screen_showing_desktop;
65 ObDesktopLayout screen_desktop_layout;
66 gchar **screen_desktop_names;
67 Window screen_support_win;
68 Time screen_desktop_user_time = CurrentTime;
70 static Size screen_physical_size;
71 static guint screen_old_desktop;
72 static gboolean screen_desktop_timeout = TRUE;
73 /*! An array of desktops, holding an array of areas per monitor */
74 static Rect *monitor_area = NULL;
75 /*! An array of desktops, holding an array of struts */
76 static GSList *struts_top = NULL;
77 static GSList *struts_left = NULL;
78 static GSList *struts_right = NULL;
79 static GSList *struts_bottom = NULL;
81 static ObPagerPopup *desktop_popup;
83 /*! The number of microseconds that you need to be on a desktop before it will
84 replace the remembered "last desktop" */
85 #define REMEMBER_LAST_DESKTOP_TIME 750000
87 static gboolean replace_wm(void)
91 Window current_wm_sn_owner;
94 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
95 wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
98 current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
99 if (current_wm_sn_owner == screen_support_win)
100 current_wm_sn_owner = None;
101 if (current_wm_sn_owner) {
102 if (!ob_replace_wm) {
103 g_message(_("A window manager is already running on screen %d"),
107 xerror_set_ignore(TRUE);
108 xerror_occured = FALSE;
110 /* We want to find out when the current selection owner dies */
111 XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
112 XSync(ob_display, FALSE);
114 xerror_set_ignore(FALSE);
116 current_wm_sn_owner = None;
119 timestamp = event_get_server_time();
121 XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
124 if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
125 g_message(_("Could not acquire window manager selection on screen %d"),
130 /* Wait for old window manager to go away */
131 if (current_wm_sn_owner) {
134 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
136 while (wait < timeout) {
137 if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
138 StructureNotifyMask, &event) &&
139 event.type == DestroyNotify)
141 g_usleep(G_USEC_PER_SEC / 10);
142 wait += G_USEC_PER_SEC / 10;
145 if (wait >= timeout) {
146 g_message(_("The WM on screen %d is not exiting"), ob_screen);
151 /* Send client message indicating that we are now the WM */
152 prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
153 timestamp, wm_sn_atom, screen_support_win, 0,
154 SubstructureNotifyMask);
159 gboolean screen_annex(void)
161 XSetWindowAttributes attrib;
164 Atom *prop_atoms_start, *wm_supported_pos;
167 /* create the netwm support window */
168 attrib.override_redirect = TRUE;
169 attrib.event_mask = PropertyChangeMask;
170 screen_support_win = XCreateWindow(ob_display,
171 RootWindow(ob_display, ob_screen),
173 CopyFromParent, InputOutput,
175 CWEventMask | CWOverrideRedirect,
177 XMapWindow(ob_display, screen_support_win);
178 XLowerWindow(ob_display, screen_support_win);
181 XDestroyWindow(ob_display, screen_support_win);
185 xerror_set_ignore(TRUE);
186 xerror_occured = FALSE;
187 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
189 xerror_set_ignore(FALSE);
190 if (xerror_occured) {
191 g_message(_("A window manager is already running on screen %d"),
194 XDestroyWindow(ob_display, screen_support_win);
198 screen_set_root_cursor();
200 /* set the OPENBOX_PID hint */
202 PROP_SET32(RootWindow(ob_display, ob_screen),
203 openbox_pid, cardinal, pid);
205 /* set supporting window */
206 PROP_SET32(RootWindow(ob_display, ob_screen),
207 net_supporting_wm_check, window, screen_support_win);
209 /* set properties on the supporting window */
210 PROP_SETS(screen_support_win, net_wm_name, "Openbox");
211 PROP_SET32(screen_support_win, net_supporting_wm_check,
212 window, screen_support_win);
214 /* set the _NET_SUPPORTED_ATOMS hint */
216 /* this is all the atoms after net_supported in the prop_atoms struct */
217 prop_atoms_start = (Atom*)&prop_atoms;
218 wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
219 num_support = sizeof(prop_atoms) / sizeof(Atom) -
220 (wm_supported_pos - prop_atoms_start) - 1;
222 supported = g_new(gulong, num_support);
223 supported[i++] = prop_atoms.net_supporting_wm_check;
224 supported[i++] = prop_atoms.net_wm_full_placement;
225 supported[i++] = prop_atoms.net_current_desktop;
226 supported[i++] = prop_atoms.net_number_of_desktops;
227 supported[i++] = prop_atoms.net_desktop_geometry;
228 supported[i++] = prop_atoms.net_desktop_viewport;
229 supported[i++] = prop_atoms.net_active_window;
230 supported[i++] = prop_atoms.net_workarea;
231 supported[i++] = prop_atoms.net_client_list;
232 supported[i++] = prop_atoms.net_client_list_stacking;
233 supported[i++] = prop_atoms.net_desktop_names;
234 supported[i++] = prop_atoms.net_close_window;
235 supported[i++] = prop_atoms.net_desktop_layout;
236 supported[i++] = prop_atoms.net_showing_desktop;
237 supported[i++] = prop_atoms.net_wm_name;
238 supported[i++] = prop_atoms.net_wm_visible_name;
239 supported[i++] = prop_atoms.net_wm_icon_name;
240 supported[i++] = prop_atoms.net_wm_visible_icon_name;
241 supported[i++] = prop_atoms.net_wm_desktop;
242 supported[i++] = prop_atoms.net_wm_strut;
243 supported[i++] = prop_atoms.net_wm_strut_partial;
244 supported[i++] = prop_atoms.net_wm_icon;
245 supported[i++] = prop_atoms.net_wm_icon_geometry;
246 supported[i++] = prop_atoms.net_wm_window_type;
247 supported[i++] = prop_atoms.net_wm_window_type_desktop;
248 supported[i++] = prop_atoms.net_wm_window_type_dock;
249 supported[i++] = prop_atoms.net_wm_window_type_toolbar;
250 supported[i++] = prop_atoms.net_wm_window_type_menu;
251 supported[i++] = prop_atoms.net_wm_window_type_utility;
252 supported[i++] = prop_atoms.net_wm_window_type_splash;
253 supported[i++] = prop_atoms.net_wm_window_type_dialog;
254 supported[i++] = prop_atoms.net_wm_window_type_normal;
255 supported[i++] = prop_atoms.net_wm_allowed_actions;
256 supported[i++] = prop_atoms.net_wm_action_move;
257 supported[i++] = prop_atoms.net_wm_action_resize;
258 supported[i++] = prop_atoms.net_wm_action_minimize;
259 supported[i++] = prop_atoms.net_wm_action_shade;
260 supported[i++] = prop_atoms.net_wm_action_maximize_horz;
261 supported[i++] = prop_atoms.net_wm_action_maximize_vert;
262 supported[i++] = prop_atoms.net_wm_action_fullscreen;
263 supported[i++] = prop_atoms.net_wm_action_change_desktop;
264 supported[i++] = prop_atoms.net_wm_action_close;
265 supported[i++] = prop_atoms.net_wm_action_above;
266 supported[i++] = prop_atoms.net_wm_action_below;
267 supported[i++] = prop_atoms.net_wm_state;
268 supported[i++] = prop_atoms.net_wm_state_modal;
269 supported[i++] = prop_atoms.net_wm_state_maximized_vert;
270 supported[i++] = prop_atoms.net_wm_state_maximized_horz;
271 supported[i++] = prop_atoms.net_wm_state_shaded;
272 supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
273 supported[i++] = prop_atoms.net_wm_state_skip_pager;
274 supported[i++] = prop_atoms.net_wm_state_hidden;
275 supported[i++] = prop_atoms.net_wm_state_fullscreen;
276 supported[i++] = prop_atoms.net_wm_state_above;
277 supported[i++] = prop_atoms.net_wm_state_below;
278 supported[i++] = prop_atoms.net_wm_state_demands_attention;
279 supported[i++] = prop_atoms.net_moveresize_window;
280 supported[i++] = prop_atoms.net_wm_moveresize;
281 supported[i++] = prop_atoms.net_wm_user_time;
283 supported[i++] = prop_atoms.net_wm_user_time_window;
285 supported[i++] = prop_atoms.net_frame_extents;
286 supported[i++] = prop_atoms.net_request_frame_extents;
287 supported[i++] = prop_atoms.net_restack_window;
288 supported[i++] = prop_atoms.net_startup_id;
290 supported[i++] = prop_atoms.net_wm_sync_request;
291 supported[i++] = prop_atoms.net_wm_sync_request_counter;
293 supported[i++] = prop_atoms.net_wm_pid;
294 supported[i++] = prop_atoms.net_wm_ping;
296 supported[i++] = prop_atoms.kde_wm_change_state;
297 supported[i++] = prop_atoms.kde_net_wm_frame_strut;
298 supported[i++] = prop_atoms.kde_net_wm_window_type_override;
300 supported[i++] = prop_atoms.ob_wm_action_undecorate;
301 supported[i++] = prop_atoms.ob_wm_state_undecorated;
302 supported[i++] = prop_atoms.openbox_pid;
303 supported[i++] = prop_atoms.ob_theme;
304 supported[i++] = prop_atoms.ob_config_file;
305 supported[i++] = prop_atoms.ob_control;
306 supported[i++] = prop_atoms.ob_version;
307 supported[i++] = prop_atoms.ob_app_role;
308 supported[i++] = prop_atoms.ob_app_name;
309 supported[i++] = prop_atoms.ob_app_class;
310 supported[i++] = prop_atoms.ob_app_type;
311 g_assert(i == num_support);
313 PROP_SETA32(RootWindow(ob_display, ob_screen),
314 net_supported, atom, supported, num_support);
317 PROP_SETS(RootWindow(ob_display, ob_screen), ob_version,
320 screen_tell_ksplash();
325 static void screen_tell_ksplash(void)
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");
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);
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 = ob_display;
350 e.xclient.window = RootWindow(ob_display, ob_screen);
351 e.xclient.message_type =
352 XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False);
353 e.xclient.format = 8;
354 strcpy(e.xclient.data.b, "wm started");
355 XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
356 False, SubstructureNotifyMask, &e );
359 void screen_startup(gboolean reconfig)
361 gchar **names = NULL;
363 gboolean namesexist = FALSE;
365 desktop_popup = pager_popup_new();
366 pager_popup_height(desktop_popup, POPUP_HEIGHT);
369 /* update the pager popup's width */
370 pager_popup_text_width_to_strings(desktop_popup,
371 screen_desktop_names,
372 screen_num_desktops);
376 /* get the initial size */
379 /* have names already been set for the desktops? */
380 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
381 net_desktop_names, utf8, &names))
387 /* if names don't exist and we have session names, set those.
388 do this stuff BEFORE setting the number of desktops, because that
389 will create default names for them
391 if (!namesexist && session_desktop_names != NULL) {
395 /* get the desktop names */
396 numnames = g_slist_length(session_desktop_names);
397 names = g_new(gchar*, numnames + 1);
398 names[numnames] = NULL;
399 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
400 names[i] = g_strdup(it->data);
402 /* set the root window property */
403 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
408 /* set the number of desktops, if it's not already set.
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 (PROP_GET32(RootWindow(ob_display, ob_screen),
414 net_number_of_desktops, cardinal, &d))
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);
424 screen_set_num_desktops(d);
426 /* restore from session if possible */
427 else if (session_num_desktops)
428 screen_set_num_desktops(session_num_desktops);
430 screen_set_num_desktops(config_desktops_num);
432 screen_desktop = screen_num_desktops; /* something invalid */
433 /* start on the current desktop when a wm was already running */
434 if (PROP_GET32(RootWindow(ob_display, ob_screen),
435 net_current_desktop, cardinal, &d) &&
436 d < screen_num_desktops)
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);
443 screen_set_desktop(MIN(config_screen_firstdesk,
444 screen_num_desktops) - 1, FALSE);
445 screen_last_desktop = screen_desktop;
447 /* don't start in showing-desktop mode */
448 screen_showing_desktop = FALSE;
449 PROP_SET32(RootWindow(ob_display, ob_screen),
450 net_showing_desktop, cardinal, screen_showing_desktop);
452 if (session_desktop_layout_present &&
453 screen_validate_layout(&session_desktop_layout))
455 screen_desktop_layout = session_desktop_layout;
458 screen_update_layout();
461 void screen_shutdown(gboolean reconfig)
463 pager_popup_free(desktop_popup);
468 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
471 /* we're not running here no more! */
472 PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
474 PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
475 /* don't keep this mode */
476 PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
478 XDestroyWindow(ob_display, screen_support_win);
480 g_strfreev(screen_desktop_names);
481 screen_desktop_names = NULL;
484 void screen_resize(void)
486 static gint oldw = 0, oldh = 0;
491 w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
492 h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
494 if (w == oldw && h == oldh) return;
498 /* Set the _NET_DESKTOP_GEOMETRY hint */
499 screen_physical_size.width = geometry[0] = w;
500 screen_physical_size.height = geometry[1] = h;
501 PROP_SETA32(RootWindow(ob_display, ob_screen),
502 net_desktop_geometry, cardinal, geometry, 2);
504 if (ob_state() != OB_STATE_RUNNING)
507 screen_update_areas();
510 for (it = client_list; it; it = g_list_next(it))
511 client_move_onscreen(it->data, FALSE);
514 void screen_set_num_desktops(guint num)
517 GList *it, *stacking_copy;
521 if (screen_num_desktops == num) return;
523 screen_num_desktops = num;
524 PROP_SET32(RootWindow(ob_display, ob_screen),
525 net_number_of_desktops, cardinal, num);
527 /* set the viewport hint */
528 viewport = g_new0(gulong, num * 2);
529 PROP_SETA32(RootWindow(ob_display, ob_screen),
530 net_desktop_viewport, cardinal, viewport, num * 2);
533 /* the number of rows/columns will differ */
534 screen_update_layout();
536 /* move windows on desktops that will no longer exist!
537 make a copy of the list cuz we're changing it */
538 stacking_copy = g_list_copy(stacking_list);
539 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
540 if (WINDOW_IS_CLIENT(it->data)) {
541 ObClient *c = it->data;
542 if (c->desktop != DESKTOP_ALL && c->desktop >= num)
543 client_set_desktop(c, num - 1, FALSE, TRUE);
544 /* raise all the windows that are on the current desktop which
546 else if (screen_desktop == num - 1 &&
547 (c->desktop == DESKTOP_ALL ||
548 c->desktop == screen_desktop))
549 stacking_raise(CLIENT_AS_WINDOW(c));
552 g_list_free(stacking_copy);
554 /* change our struts/area to match (after moving windows) */
555 screen_update_areas();
557 /* may be some unnamed desktops that we need to fill in with names
558 (after updating the areas so the popup can resize) */
559 screen_update_desktop_names();
561 /* change our desktop if we're on one that no longer exists! */
562 if (screen_desktop >= screen_num_desktops)
563 screen_set_desktop(num - 1, TRUE);
566 static void screen_fallback_focus(void)
571 /* only allow omnipresent windows to get focus on desktop change if
572 an omnipresent window is already focused (it'll keep focus probably, but
573 maybe not depending on mouse-focus options) */
574 allow_omni = focus_client && (client_normal(focus_client) &&
575 focus_client->desktop == DESKTOP_ALL);
577 /* the client moved there already so don't move focus. prevent flicker
578 on sendtodesktop + follow */
579 if (focus_client && focus_client->desktop == screen_desktop)
582 /* have to try focus here because when you leave an empty desktop
583 there is no focus out to watch for. also, we have different rules
584 here. we always allow it to look under the mouse pointer if
585 config_focus_last is FALSE
587 do this before hiding the windows so if helper windows are coming
588 with us, they don't get hidden
590 if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
593 /* only do the flicker reducing stuff ahead of time if we are going
594 to call xsetinputfocus on the window ourselves. otherwise there is
595 no guarantee the window will actually take focus.. */
597 /* reduce flicker by hiliting now rather than waiting for the
598 server FocusIn event */
599 frame_adjust_focus(c->frame, TRUE);
600 /* do this here so that if you switch desktops to a window with
601 helper windows then the helper windows won't flash */
602 client_bring_helper_windows(c);
607 static gboolean last_desktop_func(gpointer data)
609 screen_desktop_timeout = TRUE;
613 void screen_set_desktop(guint num, gboolean dofocus)
619 g_assert(num < screen_num_desktops);
621 previous = screen_desktop;
622 screen_desktop = num;
624 if (previous == num) return;
626 PROP_SET32(RootWindow(ob_display, ob_screen),
627 net_current_desktop, cardinal, num);
629 /* This whole thing decides when/how to save the screen_last_desktop so
630 that it can be restored later if you want */
631 if (screen_desktop_timeout) {
632 /* If screen_desktop_timeout is true, then we've been on this desktop
633 long enough and we can save it as the last desktop. */
635 if (screen_last_desktop == previous)
636 /* this is the startup state only */
637 screen_old_desktop = screen_desktop;
639 /* save the "last desktop" as the "old desktop" */
640 screen_old_desktop = screen_last_desktop;
641 /* save the desktop we're coming from as the "last desktop" */
642 screen_last_desktop = previous;
646 /* If screen_desktop_timeout is false, then we just got to this desktop
647 and we are moving away again. */
649 if (screen_desktop == screen_last_desktop) {
650 /* If we are moving to the "last desktop" .. */
651 if (previous == screen_old_desktop) {
652 /* .. from the "old desktop", change the last desktop to
653 be where we are coming from */
654 screen_last_desktop = screen_old_desktop;
656 else if (screen_last_desktop == screen_old_desktop) {
657 /* .. and also to the "old desktop", change the "last
658 desktop" to be where we are coming from */
659 screen_last_desktop = previous;
662 /* .. from some other desktop, then set the "last desktop" to
663 be the saved "old desktop", i.e. where we were before the
665 screen_last_desktop = screen_old_desktop;
669 /* If we are moving to any desktop besides the "last desktop"..
670 (this is the normal case) */
671 if (screen_desktop == screen_old_desktop) {
672 /* If moving to the "old desktop", which is not the
673 "last desktop", don't save anything */
675 else if (previous == screen_old_desktop) {
676 /* If moving from the "old desktop", and not to the
677 "last desktop", don't save anything */
679 else if (screen_last_desktop == screen_old_desktop) {
680 /* If the "last desktop" is the same as "old desktop" and
681 you're not moving to the "last desktop" then save where
682 we're coming from as the "last desktop" */
683 screen_last_desktop = previous;
686 /* If the "last desktop" is different from the "old desktop"
687 and you're not moving to the "last desktop", then don't save
692 screen_desktop_timeout = FALSE;
693 ob_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
694 ob_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
695 last_desktop_func, NULL, NULL, NULL);
697 ob_debug("Moving to desktop %d\n", num+1);
699 if (ob_state() == OB_STATE_RUNNING)
700 screen_show_desktop_popup(screen_desktop);
702 /* ignore enter events caused by the move */
703 ignore_start = event_start_ignore_all_enters();
705 if (moveresize_client)
706 client_set_desktop(moveresize_client, num, TRUE, FALSE);
708 /* show windows before hiding the rest to lessen the enter/leave events */
710 /* show windows from top to bottom */
711 for (it = stacking_list; it; it = g_list_next(it)) {
712 if (WINDOW_IS_CLIENT(it->data)) {
713 ObClient *c = it->data;
718 if (dofocus) screen_fallback_focus();
720 /* hide windows from bottom to top */
721 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
722 if (WINDOW_IS_CLIENT(it->data)) {
723 ObClient *c = it->data;
724 if (client_hide(c)) {
725 if (c == focus_client) {
726 /* c was focused and we didn't do fallback clearly so make
727 sure openbox doesnt still consider the window focused.
728 this happens when using NextWindow with allDesktops,
729 since it doesnt want to move focus on desktop change,
730 but the focus is not going to stay with the current
731 window, which has now disappeared.
732 only do this if the client was actually hidden,
733 otherwise it can keep focus. */
734 focus_set_client(NULL);
740 focus_cycle_addremove(NULL, TRUE);
742 event_end_ignore_all_enters(ignore_start);
744 if (event_curtime != CurrentTime)
745 screen_desktop_user_time = event_curtime;
748 void screen_add_desktop(gboolean current)
752 /* ignore enter events caused by this */
753 ignore_start = event_start_ignore_all_enters();
755 screen_set_num_desktops(screen_num_desktops+1);
757 /* move all the clients over */
761 for (it = client_list; it; it = g_list_next(it)) {
762 ObClient *c = it->data;
763 if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
764 /* don't move direct children, they'll be moved with their
765 parent - which will have to be on the same desktop */
766 !client_direct_parent(c))
768 ob_debug("moving window %s\n", c->title);
769 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
774 event_end_ignore_all_enters(ignore_start);
777 void screen_remove_desktop(gboolean current)
779 guint rmdesktop, movedesktop;
780 GList *it, *stacking_copy;
783 if (screen_num_desktops <= 1) return;
785 /* ignore enter events caused by this */
786 ignore_start = event_start_ignore_all_enters();
788 /* what desktop are we removing and moving to? */
790 rmdesktop = screen_desktop;
792 rmdesktop = screen_num_desktops - 1;
793 if (rmdesktop < screen_num_desktops - 1)
794 movedesktop = rmdesktop + 1;
796 movedesktop = rmdesktop;
798 /* make a copy of the list cuz we're changing it */
799 stacking_copy = g_list_copy(stacking_list);
800 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
801 if (WINDOW_IS_CLIENT(it->data)) {
802 ObClient *c = it->data;
803 guint d = c->desktop;
804 if (d != DESKTOP_ALL && d >= movedesktop &&
805 /* don't move direct children, they'll be moved with their
806 parent - which will have to be on the same desktop */
807 !client_direct_parent(c))
809 ob_debug("moving window %s\n", c->title);
810 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
812 /* raise all the windows that are on the current desktop which
814 if ((screen_desktop == rmdesktop - 1 ||
815 screen_desktop == rmdesktop) &&
816 (d == DESKTOP_ALL || d == screen_desktop))
818 stacking_raise(CLIENT_AS_WINDOW(c));
819 ob_debug("raising window %s\n", c->title);
823 g_list_free(stacking_copy);
825 /* fallback focus like we're changing desktops */
826 if (screen_desktop < screen_num_desktops - 1) {
827 screen_fallback_focus();
828 ob_debug("fake desktop change\n");
831 screen_set_num_desktops(screen_num_desktops-1);
833 event_end_ignore_all_enters(ignore_start);
836 static void get_row_col(guint d, guint *r, guint *c)
838 switch (screen_desktop_layout.orientation) {
839 case OB_ORIENTATION_HORZ:
840 switch (screen_desktop_layout.start_corner) {
841 case OB_CORNER_TOPLEFT:
842 *r = d / screen_desktop_layout.columns;
843 *c = d % screen_desktop_layout.columns;
845 case OB_CORNER_BOTTOMLEFT:
846 *r = screen_desktop_layout.rows - 1 -
847 d / screen_desktop_layout.columns;
848 *c = d % screen_desktop_layout.columns;
850 case OB_CORNER_TOPRIGHT:
851 *r = d / screen_desktop_layout.columns;
852 *c = screen_desktop_layout.columns - 1 -
853 d % screen_desktop_layout.columns;
855 case OB_CORNER_BOTTOMRIGHT:
856 *r = screen_desktop_layout.rows - 1 -
857 d / screen_desktop_layout.columns;
858 *c = screen_desktop_layout.columns - 1 -
859 d % screen_desktop_layout.columns;
863 case OB_ORIENTATION_VERT:
864 switch (screen_desktop_layout.start_corner) {
865 case OB_CORNER_TOPLEFT:
866 *r = d % screen_desktop_layout.rows;
867 *c = d / screen_desktop_layout.rows;
869 case OB_CORNER_BOTTOMLEFT:
870 *r = screen_desktop_layout.rows - 1 -
871 d % screen_desktop_layout.rows;
872 *c = d / screen_desktop_layout.rows;
874 case OB_CORNER_TOPRIGHT:
875 *r = d % screen_desktop_layout.rows;
876 *c = screen_desktop_layout.columns - 1 -
877 d / screen_desktop_layout.rows;
879 case OB_CORNER_BOTTOMRIGHT:
880 *r = screen_desktop_layout.rows - 1 -
881 d % screen_desktop_layout.rows;
882 *c = screen_desktop_layout.columns - 1 -
883 d / screen_desktop_layout.rows;
890 static guint translate_row_col(guint r, guint c)
892 switch (screen_desktop_layout.orientation) {
893 case OB_ORIENTATION_HORZ:
894 switch (screen_desktop_layout.start_corner) {
895 case OB_CORNER_TOPLEFT:
896 return r % screen_desktop_layout.rows *
897 screen_desktop_layout.columns +
898 c % screen_desktop_layout.columns;
899 case OB_CORNER_BOTTOMLEFT:
900 return (screen_desktop_layout.rows - 1 -
901 r % screen_desktop_layout.rows) *
902 screen_desktop_layout.columns +
903 c % screen_desktop_layout.columns;
904 case OB_CORNER_TOPRIGHT:
905 return r % screen_desktop_layout.rows *
906 screen_desktop_layout.columns +
907 (screen_desktop_layout.columns - 1 -
908 c % screen_desktop_layout.columns);
909 case OB_CORNER_BOTTOMRIGHT:
910 return (screen_desktop_layout.rows - 1 -
911 r % screen_desktop_layout.rows) *
912 screen_desktop_layout.columns +
913 (screen_desktop_layout.columns - 1 -
914 c % screen_desktop_layout.columns);
916 case OB_ORIENTATION_VERT:
917 switch (screen_desktop_layout.start_corner) {
918 case OB_CORNER_TOPLEFT:
919 return c % screen_desktop_layout.columns *
920 screen_desktop_layout.rows +
921 r % screen_desktop_layout.rows;
922 case OB_CORNER_BOTTOMLEFT:
923 return c % screen_desktop_layout.columns *
924 screen_desktop_layout.rows +
925 (screen_desktop_layout.rows - 1 -
926 r % screen_desktop_layout.rows);
927 case OB_CORNER_TOPRIGHT:
928 return (screen_desktop_layout.columns - 1 -
929 c % screen_desktop_layout.columns) *
930 screen_desktop_layout.rows +
931 r % screen_desktop_layout.rows;
932 case OB_CORNER_BOTTOMRIGHT:
933 return (screen_desktop_layout.columns - 1 -
934 c % screen_desktop_layout.columns) *
935 screen_desktop_layout.rows +
936 (screen_desktop_layout.rows - 1 -
937 r % screen_desktop_layout.rows);
940 g_assert_not_reached();
944 static gboolean hide_desktop_popup_func(gpointer data)
946 pager_popup_hide(desktop_popup);
947 return FALSE; /* don't repeat */
950 void screen_show_desktop_popup(guint d)
954 /* 0 means don't show the popup */
955 if (!config_desktop_popup_time) return;
957 a = screen_physical_area_primary(FALSE);
958 pager_popup_position(desktop_popup, CenterGravity,
959 a->x + a->width / 2, a->y + a->height / 2);
960 pager_popup_icon_size_multiplier(desktop_popup,
961 (screen_desktop_layout.columns /
962 screen_desktop_layout.rows) / 2,
963 (screen_desktop_layout.rows/
964 screen_desktop_layout.columns) / 2);
965 pager_popup_max_width(desktop_popup,
966 MAX(a->width/3, POPUP_WIDTH));
967 pager_popup_show(desktop_popup, screen_desktop_names[d], d);
969 ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
970 ob_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
971 hide_desktop_popup_func, NULL, NULL, NULL);
975 void screen_hide_desktop_popup(void)
977 ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
978 pager_popup_hide(desktop_popup);
981 guint screen_find_desktop(guint from, ObDirection dir,
982 gboolean wrap, gboolean linear)
988 get_row_col(d, &r, &c);
991 case OB_DIRECTION_EAST:
992 if (d < screen_num_desktops - 1)
999 case OB_DIRECTION_WEST:
1003 d = screen_num_desktops - 1;
1008 g_assert_not_reached();
1013 case OB_DIRECTION_EAST:
1015 if (c >= screen_desktop_layout.columns) {
1021 d = translate_row_col(r, c);
1022 if (d >= screen_num_desktops) {
1029 case OB_DIRECTION_WEST:
1031 if (c >= screen_desktop_layout.columns) {
1033 c = screen_desktop_layout.columns - 1;
1037 d = translate_row_col(r, c);
1038 if (d >= screen_num_desktops) {
1045 case OB_DIRECTION_SOUTH:
1047 if (r >= screen_desktop_layout.rows) {
1053 d = translate_row_col(r, c);
1054 if (d >= screen_num_desktops) {
1061 case OB_DIRECTION_NORTH:
1063 if (r >= screen_desktop_layout.rows) {
1065 r = screen_desktop_layout.rows - 1;
1069 d = translate_row_col(r, c);
1070 if (d >= screen_num_desktops) {
1078 g_assert_not_reached();
1082 d = translate_row_col(r, c);
1087 static gboolean screen_validate_layout(ObDesktopLayout *l)
1089 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1092 /* fill in a zero rows/columns */
1093 if (l->columns == 0) {
1094 l->columns = screen_num_desktops / l->rows;
1095 if (l->rows * l->columns < screen_num_desktops)
1097 if (l->rows * l->columns >= screen_num_desktops + l->columns)
1099 } else if (l->rows == 0) {
1100 l->rows = screen_num_desktops / l->columns;
1101 if (l->columns * l->rows < screen_num_desktops)
1103 if (l->columns * l->rows >= screen_num_desktops + l->rows)
1107 /* bounds checking */
1108 if (l->orientation == OB_ORIENTATION_HORZ) {
1109 l->columns = MIN(screen_num_desktops, l->columns);
1110 l->rows = MIN(l->rows,
1111 (screen_num_desktops + l->columns - 1) / l->columns);
1112 l->columns = screen_num_desktops / l->rows +
1113 !!(screen_num_desktops % l->rows);
1115 l->rows = MIN(screen_num_desktops, l->rows);
1116 l->columns = MIN(l->columns,
1117 (screen_num_desktops + l->rows - 1) / l->rows);
1118 l->rows = screen_num_desktops / l->columns +
1119 !!(screen_num_desktops % l->columns);
1124 void screen_update_layout(void)
1131 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1132 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1133 screen_desktop_layout.rows = 1;
1134 screen_desktop_layout.columns = screen_num_desktops;
1136 if (PROP_GETA32(RootWindow(ob_display, ob_screen),
1137 net_desktop_layout, cardinal, &data, &num)) {
1138 if (num == 3 || num == 4) {
1140 if (data[0] == prop_atoms.net_wm_orientation_vert)
1141 l.orientation = OB_ORIENTATION_VERT;
1142 else if (data[0] == prop_atoms.net_wm_orientation_horz)
1143 l.orientation = OB_ORIENTATION_HORZ;
1148 l.start_corner = OB_CORNER_TOPLEFT;
1150 if (data[3] == prop_atoms.net_wm_topleft)
1151 l.start_corner = OB_CORNER_TOPLEFT;
1152 else if (data[3] == prop_atoms.net_wm_topright)
1153 l.start_corner = OB_CORNER_TOPRIGHT;
1154 else if (data[3] == prop_atoms.net_wm_bottomright)
1155 l.start_corner = OB_CORNER_BOTTOMRIGHT;
1156 else if (data[3] == prop_atoms.net_wm_bottomleft)
1157 l.start_corner = OB_CORNER_BOTTOMLEFT;
1162 l.columns = data[1];
1165 if (screen_validate_layout(&l))
1166 screen_desktop_layout = l;
1173 void screen_update_desktop_names(void)
1177 /* empty the array */
1178 g_strfreev(screen_desktop_names);
1179 screen_desktop_names = NULL;
1181 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
1182 net_desktop_names, utf8, &screen_desktop_names))
1183 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1186 if (i < screen_num_desktops) {
1189 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1190 screen_num_desktops + 1);
1191 screen_desktop_names[screen_num_desktops] = NULL;
1193 it = g_slist_nth(config_desktops_names, i);
1195 for (; i < screen_num_desktops; ++i) {
1196 if (it && ((char*)it->data)[0]) /* not empty */
1197 /* use the names from the config file when possible */
1198 screen_desktop_names[i] = g_strdup(it->data);
1200 /* make up a nice name if it's not though */
1201 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1203 if (it) it = g_slist_next(it);
1206 /* if we changed any names, then set the root property so we can
1207 all agree on the names */
1208 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
1209 screen_desktop_names);
1212 /* resize the pager for these names */
1213 pager_popup_text_width_to_strings(desktop_popup,
1214 screen_desktop_names,
1215 screen_num_desktops);
1218 void screen_show_desktop(gboolean show, ObClient *show_only)
1222 if (show == screen_showing_desktop) return; /* no change */
1224 screen_showing_desktop = show;
1227 /* hide windows bottom to top */
1228 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1229 if (WINDOW_IS_CLIENT(it->data)) {
1230 ObClient *client = it->data;
1231 client_showhide(client);
1236 /* restore windows top to bottom */
1237 for (it = stacking_list; it; it = g_list_next(it)) {
1238 if (WINDOW_IS_CLIENT(it->data)) {
1239 ObClient *client = it->data;
1240 if (client_should_show(client)) {
1241 if (!show_only || client == show_only)
1242 client_show(client);
1244 client_iconify(client, TRUE, FALSE, TRUE);
1251 /* focus the desktop */
1252 for (it = focus_order; it; it = g_list_next(it)) {
1253 ObClient *c = it->data;
1254 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1255 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1256 client_focus(it->data))
1260 else if (!show_only) {
1263 if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1264 /* only do the flicker reducing stuff ahead of time if we are going
1265 to call xsetinputfocus on the window ourselves. otherwise there
1266 is no guarantee the window will actually take focus.. */
1268 /* reduce flicker by hiliting now rather than waiting for the
1269 server FocusIn event */
1270 frame_adjust_focus(c->frame, TRUE);
1275 show = !!show; /* make it boolean */
1276 PROP_SET32(RootWindow(ob_display, ob_screen),
1277 net_showing_desktop, cardinal, show);
1280 void screen_install_colormap(ObClient *client, gboolean install)
1282 if (client == NULL || client->colormap == None) {
1284 XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1286 XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1288 xerror_set_ignore(TRUE);
1290 XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1292 XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1293 xerror_set_ignore(FALSE);
1299 StrutPartial *strut;
1302 #define RESET_STRUT_LIST(sl) \
1303 (g_slist_free(sl), sl = NULL)
1305 #define ADD_STRUT_TO_LIST(sl, d, s) \
1307 ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1310 sl = g_slist_prepend(sl, ss); \
1313 #define VALIDATE_STRUTS(sl, side, max) \
1316 for (it = sl; it; it = g_slist_next(it)) { \
1317 ObScreenStrut *ss = it->data; \
1318 ss->strut->side = MIN(max, ss->strut->side); \
1322 void screen_update_areas(void)
1328 g_free(monitor_area);
1329 extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
1331 /* set up the user-specified margins */
1332 config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1333 config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1334 config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1335 config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1336 config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1337 config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1338 config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1339 config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1341 RESET_STRUT_LIST(struts_left);
1342 RESET_STRUT_LIST(struts_top);
1343 RESET_STRUT_LIST(struts_right);
1344 RESET_STRUT_LIST(struts_bottom);
1346 /* collect the struts */
1347 for (it = client_list; it; it = g_list_next(it)) {
1348 ObClient *c = it->data;
1350 ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1352 ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1354 ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1355 if (c->strut.bottom)
1356 ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1358 if (dock_strut.left)
1359 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1361 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1362 if (dock_strut.right)
1363 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1364 if (dock_strut.bottom)
1365 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1367 if (config_margins.left)
1368 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1369 if (config_margins.top)
1370 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1371 if (config_margins.right)
1372 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1373 if (config_margins.bottom)
1374 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1376 VALIDATE_STRUTS(struts_left, left,
1377 monitor_area[screen_num_monitors].width / 2);
1378 VALIDATE_STRUTS(struts_right, right,
1379 monitor_area[screen_num_monitors].width / 2);
1380 VALIDATE_STRUTS(struts_top, top,
1381 monitor_area[screen_num_monitors].height / 2);
1382 VALIDATE_STRUTS(struts_bottom, bottom,
1383 monitor_area[screen_num_monitors].height / 2);
1385 dims = g_new(gulong, 4 * screen_num_desktops);
1386 for (i = 0; i < screen_num_desktops; ++i) {
1387 Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1388 dims[i*4+0] = area->x;
1389 dims[i*4+1] = area->y;
1390 dims[i*4+2] = area->width;
1391 dims[i*4+3] = area->height;
1395 /* set the legacy workarea hint to the union of all the monitors */
1396 PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1397 dims, 4 * screen_num_desktops);
1399 /* the area has changed, adjust all the windows if they need it */
1400 for (it = client_list; it; it = g_list_next(it))
1401 client_reconfigure(it->data, FALSE);
1407 Rect* screen_area_all_monitors(guint desktop)
1412 a = screen_area_monitor(desktop, 0);
1414 /* combine all the monitors together */
1415 for (i = 1; i < screen_num_monitors; ++i) {
1416 Rect *m = screen_area_monitor(desktop, i);
1419 l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1420 t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1421 r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1422 b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1424 RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1433 #define STRUT_LEFT_IN_SEARCH(s, search) \
1434 (RANGES_INTERSECT(search->y, search->height, \
1435 s->left_start, s->left_end - s->left_start + 1))
1436 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1437 (RANGES_INTERSECT(search->y, search->height, \
1438 s->right_start, s->right_end - s->right_start + 1))
1439 #define STRUT_TOP_IN_SEARCH(s, search) \
1440 (RANGES_INTERSECT(search->x, search->width, \
1441 s->top_start, s->top_end - s->top_start + 1))
1442 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1443 (RANGES_INTERSECT(search->x, search->width, \
1444 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1446 #define STRUT_LEFT_IGNORE(s, us, search) \
1447 (head == SCREEN_AREA_ALL_MONITORS && us && \
1448 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1449 #define STRUT_RIGHT_IGNORE(s, us, search) \
1450 (head == SCREEN_AREA_ALL_MONITORS && us && \
1451 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1452 #define STRUT_TOP_IGNORE(s, us, search) \
1453 (head == SCREEN_AREA_ALL_MONITORS && us && \
1454 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1455 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1456 (head == SCREEN_AREA_ALL_MONITORS && us && \
1457 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1459 Rect* screen_area(guint desktop, guint head, Rect *search)
1465 gboolean us = search != NULL; /* user provided search */
1467 g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1468 g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1469 head == SCREEN_AREA_ALL_MONITORS);
1470 g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1472 /* find any struts for this monitor
1473 which will be affecting the search area.
1476 /* search everything if search is null */
1478 if (head < screen_num_monitors) search = &monitor_area[head];
1479 else search = &monitor_area[screen_num_monitors];
1481 if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1483 /* only include monitors which the search area lines up with */
1484 if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1485 l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1486 t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1487 r = RECT_LEFT(monitor_area[screen_num_monitors]);
1488 b = RECT_TOP(monitor_area[screen_num_monitors]);
1489 for (i = 0; i < screen_num_monitors; ++i) {
1490 /* add the monitor if applicable */
1491 if (RANGES_INTERSECT(search->x, search->width,
1492 monitor_area[i].x, monitor_area[i].width))
1494 t = MIN(t, RECT_TOP(monitor_area[i]));
1495 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1497 if (RANGES_INTERSECT(search->y, search->height,
1498 monitor_area[i].y, monitor_area[i].height))
1500 l = MIN(l, RECT_LEFT(monitor_area[i]));
1501 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1505 l = RECT_LEFT(monitor_area[screen_num_monitors]);
1506 t = RECT_TOP(monitor_area[screen_num_monitors]);
1507 r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1508 b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1511 for (d = 0; d < screen_num_desktops; ++d) {
1512 if (d != desktop && desktop != DESKTOP_ALL) continue;
1514 for (i = 0; i < screen_num_monitors; ++i) {
1515 if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1517 for (it = struts_left; it; it = g_slist_next(it)) {
1518 ObScreenStrut *s = it->data;
1519 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1520 STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1521 !STRUT_LEFT_IGNORE(s->strut, us, search))
1522 l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1525 for (it = struts_top; it; it = g_slist_next(it)) {
1526 ObScreenStrut *s = it->data;
1527 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1528 STRUT_TOP_IN_SEARCH(s->strut, search) &&
1529 !STRUT_TOP_IGNORE(s->strut, us, search))
1530 t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1533 for (it = struts_right; it; it = g_slist_next(it)) {
1534 ObScreenStrut *s = it->data;
1535 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1536 STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1537 !STRUT_RIGHT_IGNORE(s->strut, us, search))
1538 r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1541 for (it = struts_bottom; it; it = g_slist_next(it)) {
1542 ObScreenStrut *s = it->data;
1543 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1544 STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1545 !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1546 b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1547 - s->strut->bottom);
1550 /* limit to this monitor */
1552 l = MAX(l, RECT_LEFT(monitor_area[i]));
1553 t = MAX(t, RECT_TOP(monitor_area[i]));
1554 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1555 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1563 a->width = r - l + 1;
1564 a->height = b - t + 1;
1568 guint screen_find_monitor(Rect *search)
1571 guint most = screen_num_monitors;
1574 for (i = 0; i < screen_num_monitors; ++i) {
1575 Rect *area = screen_physical_area_monitor(i);
1576 if (RECT_INTERSECTS_RECT(*area, *search)) {
1580 RECT_SET_INTERSECTION(r, *area, *search);
1581 v = r.width * r.height;
1593 Rect* screen_physical_area_all_monitors(void)
1595 return screen_physical_area_monitor(screen_num_monitors);
1598 Rect* screen_physical_area_monitor(guint head)
1601 g_assert(head <= screen_num_monitors);
1604 *a = monitor_area[head];
1608 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1610 g_assert(head <= screen_num_monitors);
1612 return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1615 guint screen_monitor_active(void)
1617 if (moveresize_client)
1618 return client_monitor(moveresize_client);
1619 else if (focus_client)
1620 return client_monitor(focus_client);
1622 return screen_monitor_pointer();
1625 Rect* screen_physical_area_active(void)
1627 return screen_physical_area_monitor(screen_monitor_active());
1630 guint screen_monitor_primary(gboolean fixed)
1632 if (config_primary_monitor_index > 0) {
1633 if (config_primary_monitor_index-1 < screen_num_monitors)
1634 return config_primary_monitor_index - 1;
1640 else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1641 return screen_monitor_active();
1642 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1643 return screen_monitor_pointer();
1646 Rect *screen_physical_area_primary(gboolean fixed)
1648 return screen_physical_area_monitor(screen_monitor_primary(fixed));
1651 void screen_set_root_cursor(void)
1653 if (sn_app_starting())
1654 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1655 ob_cursor(OB_CURSOR_BUSYPOINTER));
1657 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1658 ob_cursor(OB_CURSOR_POINTER));
1661 guint screen_find_monitor_point(guint x, guint y)
1664 RECT_SET(mon, x, y, 1, 1);
1665 return screen_find_monitor(&mon);
1668 guint screen_monitor_pointer()
1671 if (!screen_pointer_pos(&x, &y))
1673 return screen_find_monitor_point(x, y);
1676 gboolean screen_pointer_pos(gint *x, gint *y)
1683 ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1684 &w, &w, x, y, &i, &i, &u);
1686 for (i = 0; i < ScreenCount(ob_display); ++i)
1688 if (XQueryPointer(ob_display, RootWindow(ob_display, i),
1689 &w, &w, x, y, &i, &i, &u))