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"
30 #include "composite.h"
37 #include "extensions.h"
38 #include "render/render.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 | ButtonMotionMask)
54 static gboolean screen_validate_layout(ObDesktopLayout *l);
55 static gboolean replace_wm();
56 static void screen_tell_ksplash();
58 guint screen_num_desktops;
59 guint screen_num_monitors;
61 guint screen_last_desktop;
62 Size screen_physical_size;
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 /*! An array of desktops, holding array of areas per monitor */
70 static Rect *monitor_area = NULL;
71 /*! An array of desktops, holding an array of struts */
72 static GSList *struts_top = NULL;
73 static GSList *struts_left = NULL;
74 static GSList *struts_right = NULL;
75 static GSList *struts_bottom = NULL;
77 static ObPagerPopup *desktop_cycle_popup;
79 static gboolean replace_wm()
83 Window current_wm_sn_owner;
86 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
87 wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
90 current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
91 if (current_wm_sn_owner == screen_support_win)
92 current_wm_sn_owner = None;
93 if (current_wm_sn_owner) {
95 g_message(_("A window manager is already running on screen %d"),
99 xerror_set_ignore(TRUE);
100 xerror_occured = FALSE;
102 /* We want to find out when the current selection owner dies */
103 XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
104 XSync(ob_display, FALSE);
106 xerror_set_ignore(FALSE);
108 current_wm_sn_owner = None;
112 /* Generate a timestamp */
115 XSelectInput(ob_display, screen_support_win, PropertyChangeMask);
117 XChangeProperty(ob_display, screen_support_win,
118 prop_atoms.wm_class, prop_atoms.string,
119 8, PropModeAppend, NULL, 0);
120 XWindowEvent(ob_display, screen_support_win,
121 PropertyChangeMask, &event);
123 XSelectInput(ob_display, screen_support_win, NoEventMask);
125 timestamp = event.xproperty.time;
128 XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
131 if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
132 g_message(_("Could not acquire window manager selection on screen %d"),
137 /* Wait for old window manager to go away */
138 if (current_wm_sn_owner) {
141 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
143 while (wait < timeout) {
144 if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
145 StructureNotifyMask, &event) &&
146 event.type == DestroyNotify)
148 g_usleep(G_USEC_PER_SEC / 10);
149 wait += G_USEC_PER_SEC / 10;
152 if (wait >= timeout) {
153 g_message(_("The WM on screen %d is not exiting"), ob_screen);
158 /* Send client message indicating that we are now the WM */
159 prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
160 timestamp, wm_sn_atom, screen_support_win, 0,
161 SubstructureNotifyMask);
166 gboolean screen_annex()
168 XSetWindowAttributes attrib;
171 Atom *prop_atoms_start, *wm_supported_pos;
174 /* create the netwm support window */
175 attrib.override_redirect = TRUE;
176 screen_support_win = XCreateWindow(ob_display,
177 RootWindow(ob_display, ob_screen),
179 CopyFromParent, InputOutput,
181 CWOverrideRedirect, &attrib);
182 XMapWindow(ob_display, screen_support_win);
183 XLowerWindow(ob_display, screen_support_win);
186 XDestroyWindow(ob_display, screen_support_win);
190 xerror_set_ignore(TRUE);
191 xerror_occured = FALSE;
192 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
194 xerror_set_ignore(FALSE);
195 if (xerror_occured) {
196 g_message(_("A window manager is already running on screen %d"),
199 XDestroyWindow(ob_display, screen_support_win);
203 screen_set_root_cursor();
205 /* set the OPENBOX_PID hint */
207 PROP_SET32(RootWindow(ob_display, ob_screen),
208 openbox_pid, cardinal, pid);
210 /* set supporting window */
211 PROP_SET32(RootWindow(ob_display, ob_screen),
212 net_supporting_wm_check, window, screen_support_win);
214 /* set properties on the supporting window */
215 PROP_SETS(screen_support_win, net_wm_name, "Openbox");
216 PROP_SET32(screen_support_win, net_supporting_wm_check,
217 window, screen_support_win);
219 /* set the _NET_SUPPORTED_ATOMS hint */
221 /* this is all the atoms after net_supported in the prop_atoms struct */
222 prop_atoms_start = (Atom*)&prop_atoms;
223 wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
224 num_support = sizeof(prop_atoms) / sizeof(Atom) -
225 (wm_supported_pos - prop_atoms_start) - 1;
227 supported = g_new(gulong, num_support);
228 supported[i++] = prop_atoms.net_supporting_wm_check;
229 supported[i++] = prop_atoms.net_wm_full_placement;
230 supported[i++] = prop_atoms.net_current_desktop;
231 supported[i++] = prop_atoms.net_number_of_desktops;
232 supported[i++] = prop_atoms.net_desktop_geometry;
233 supported[i++] = prop_atoms.net_desktop_viewport;
234 supported[i++] = prop_atoms.net_active_window;
235 supported[i++] = prop_atoms.net_workarea;
236 supported[i++] = prop_atoms.net_client_list;
237 supported[i++] = prop_atoms.net_client_list_stacking;
238 supported[i++] = prop_atoms.net_desktop_names;
239 supported[i++] = prop_atoms.net_close_window;
240 supported[i++] = prop_atoms.net_desktop_layout;
241 supported[i++] = prop_atoms.net_showing_desktop;
242 supported[i++] = prop_atoms.net_wm_name;
243 supported[i++] = prop_atoms.net_wm_visible_name;
244 supported[i++] = prop_atoms.net_wm_icon_name;
245 supported[i++] = prop_atoms.net_wm_visible_icon_name;
246 supported[i++] = prop_atoms.net_wm_desktop;
247 supported[i++] = prop_atoms.net_wm_strut;
248 supported[i++] = prop_atoms.net_wm_strut_partial;
249 supported[i++] = prop_atoms.net_wm_icon;
250 supported[i++] = prop_atoms.net_wm_icon_geometry;
251 supported[i++] = prop_atoms.net_wm_window_type;
252 supported[i++] = prop_atoms.net_wm_window_type_desktop;
253 supported[i++] = prop_atoms.net_wm_window_type_dock;
254 supported[i++] = prop_atoms.net_wm_window_type_toolbar;
255 supported[i++] = prop_atoms.net_wm_window_type_menu;
256 supported[i++] = prop_atoms.net_wm_window_type_utility;
257 supported[i++] = prop_atoms.net_wm_window_type_splash;
258 supported[i++] = prop_atoms.net_wm_window_type_dialog;
259 supported[i++] = prop_atoms.net_wm_window_type_normal;
260 supported[i++] = prop_atoms.net_wm_allowed_actions;
261 supported[i++] = prop_atoms.net_wm_action_move;
262 supported[i++] = prop_atoms.net_wm_action_resize;
263 supported[i++] = prop_atoms.net_wm_action_minimize;
264 supported[i++] = prop_atoms.net_wm_action_shade;
265 supported[i++] = prop_atoms.net_wm_action_maximize_horz;
266 supported[i++] = prop_atoms.net_wm_action_maximize_vert;
267 supported[i++] = prop_atoms.net_wm_action_fullscreen;
268 supported[i++] = prop_atoms.net_wm_action_change_desktop;
269 supported[i++] = prop_atoms.net_wm_action_close;
270 supported[i++] = prop_atoms.net_wm_action_above;
271 supported[i++] = prop_atoms.net_wm_action_below;
272 supported[i++] = prop_atoms.net_wm_state;
273 supported[i++] = prop_atoms.net_wm_state_modal;
274 supported[i++] = prop_atoms.net_wm_state_maximized_vert;
275 supported[i++] = prop_atoms.net_wm_state_maximized_horz;
276 supported[i++] = prop_atoms.net_wm_state_shaded;
277 supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
278 supported[i++] = prop_atoms.net_wm_state_skip_pager;
279 supported[i++] = prop_atoms.net_wm_state_hidden;
280 supported[i++] = prop_atoms.net_wm_state_fullscreen;
281 supported[i++] = prop_atoms.net_wm_state_above;
282 supported[i++] = prop_atoms.net_wm_state_below;
283 supported[i++] = prop_atoms.net_wm_state_demands_attention;
284 supported[i++] = prop_atoms.net_moveresize_window;
285 supported[i++] = prop_atoms.net_wm_moveresize;
286 supported[i++] = prop_atoms.net_wm_user_time;
287 supported[i++] = prop_atoms.net_wm_user_time_window;
288 supported[i++] = prop_atoms.net_frame_extents;
289 supported[i++] = prop_atoms.net_request_frame_extents;
290 supported[i++] = prop_atoms.net_restack_window;
291 supported[i++] = prop_atoms.net_startup_id;
293 supported[i++] = prop_atoms.net_wm_sync_request;
294 supported[i++] = prop_atoms.net_wm_sync_request_counter;
297 supported[i++] = prop_atoms.kde_wm_change_state;
298 supported[i++] = prop_atoms.kde_net_wm_frame_strut;
299 supported[i++] = prop_atoms.kde_net_wm_window_type_override;
301 supported[i++] = prop_atoms.ob_wm_action_undecorate;
302 supported[i++] = prop_atoms.ob_wm_state_undecorated;
303 supported[i++] = prop_atoms.openbox_pid;
304 supported[i++] = prop_atoms.ob_theme;
305 supported[i++] = prop_atoms.ob_control;
306 g_assert(i == num_support);
308 PROP_SETA32(RootWindow(ob_display, ob_screen),
309 net_supported, atom, supported, num_support);
312 screen_tell_ksplash();
317 static void screen_tell_ksplash()
322 argv = g_new(gchar*, 6);
323 argv[0] = g_strdup("dcop");
324 argv[1] = g_strdup("ksplash");
325 argv[2] = g_strdup("ksplash");
326 argv[3] = g_strdup("upAndRunning(QString)");
327 argv[4] = g_strdup("wm started");
330 /* tell ksplash through the dcop server command line interface */
331 g_spawn_async(NULL, argv, NULL,
332 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
333 G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
334 NULL, NULL, NULL, NULL);
337 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
338 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
339 something. oh well. */
340 e.xclient.type = ClientMessage;
341 e.xclient.display = ob_display;
342 e.xclient.window = RootWindow(ob_display, ob_screen);
343 e.xclient.message_type =
344 XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False );
345 e.xclient.format = 8;
346 strcpy(e.xclient.data.b, "wm started");
347 XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
348 False, SubstructureNotifyMask, &e );
351 void screen_startup(gboolean reconfig)
353 gchar **names = NULL;
355 gboolean namesexist = FALSE;
357 desktop_cycle_popup = pager_popup_new(FALSE);
358 pager_popup_height(desktop_cycle_popup, POPUP_HEIGHT);
361 /* update the pager popup's width */
362 pager_popup_text_width_to_strings(desktop_cycle_popup,
363 screen_desktop_names,
364 screen_num_desktops);
368 /* get the initial size */
371 /* have names already been set for the desktops? */
372 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
373 net_desktop_names, utf8, &names))
379 /* if names don't exist and we have session names, set those.
380 do this stuff BEFORE setting the number of desktops, because that
381 will create default names for them
383 if (!namesexist && session_desktop_names != NULL) {
387 /* get the desktop names */
388 numnames = g_slist_length(session_desktop_names);
389 names = g_new(gchar*, numnames + 1);
390 names[numnames] = NULL;
391 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
392 names[i] = g_strdup(it->data);
394 /* set the root window property */
395 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
400 /* set the number of desktops, if it's not already set.
402 this will also set the default names from the config file up for
403 desktops that don't have names yet */
404 screen_num_desktops = 0;
405 if (PROP_GET32(RootWindow(ob_display, ob_screen),
406 net_number_of_desktops, cardinal, &d))
407 screen_set_num_desktops(d);
408 /* restore from session if possible */
409 else if (session_num_desktops)
410 screen_set_num_desktops(session_num_desktops);
412 screen_set_num_desktops(config_desktops_num);
414 screen_desktop = screen_num_desktops; /* something invalid */
415 /* start on the current desktop when a wm was already running */
416 if (PROP_GET32(RootWindow(ob_display, ob_screen),
417 net_current_desktop, cardinal, &d) &&
418 d < screen_num_desktops)
420 screen_set_desktop(d, FALSE);
421 } else if (session_desktop >= 0)
422 screen_set_desktop(MIN((guint)session_desktop,
423 screen_num_desktops), FALSE);
425 screen_set_desktop(MIN(config_screen_firstdesk,
426 screen_num_desktops) - 1, FALSE);
427 screen_last_desktop = screen_desktop;
429 /* don't start in showing-desktop mode */
430 screen_showing_desktop = FALSE;
431 PROP_SET32(RootWindow(ob_display, ob_screen),
432 net_showing_desktop, cardinal, screen_showing_desktop);
434 if (session_desktop_layout_present &&
435 screen_validate_layout(&session_desktop_layout))
437 screen_desktop_layout = session_desktop_layout;
440 screen_update_layout();
443 void screen_shutdown(gboolean reconfig)
445 pager_popup_free(desktop_cycle_popup);
450 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
453 /* we're not running here no more! */
454 PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
456 PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
457 /* don't keep this mode */
458 PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
460 XDestroyWindow(ob_display, screen_support_win);
462 g_strfreev(screen_desktop_names);
463 screen_desktop_names = NULL;
468 static gint oldw = 0, oldh = 0;
473 w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
474 h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
476 if (w == oldw && h == oldh) return;
480 /* Set the _NET_DESKTOP_GEOMETRY hint */
481 screen_physical_size.width = geometry[0] = w;
482 screen_physical_size.height = geometry[1] = h;
483 PROP_SETA32(RootWindow(ob_display, ob_screen),
484 net_desktop_geometry, cardinal, geometry, 2);
486 if (ob_state() == OB_STATE_STARTING)
489 screen_update_areas();
492 for (it = client_list; it; it = g_list_next(it))
493 client_move_onscreen(it->data, FALSE);
495 /* this needs to be setup whenever the root window's size changes */
496 composite_setup_root_window();
499 void screen_set_num_desktops(guint num)
503 GList *it, *stacking_copy;
507 if (screen_num_desktops == num) return;
509 old = screen_num_desktops;
510 screen_num_desktops = num;
511 PROP_SET32(RootWindow(ob_display, ob_screen),
512 net_number_of_desktops, cardinal, num);
514 /* set the viewport hint */
515 viewport = g_new0(gulong, num * 2);
516 PROP_SETA32(RootWindow(ob_display, ob_screen),
517 net_desktop_viewport, cardinal, viewport, num * 2);
520 /* the number of rows/columns will differ */
521 screen_update_layout();
523 /* move windows on desktops that will no longer exist!
524 make a copy of the list cuz we're changing it */
525 stacking_copy = g_list_copy(stacking_list);
526 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
527 if (WINDOW_IS_CLIENT(it->data)) {
528 ObClient *c = it->data;
529 if (c->desktop != DESKTOP_ALL && c->desktop >= num)
530 client_set_desktop(c, num - 1, FALSE, TRUE);
531 /* raise all the windows that are on the current desktop which
533 else if (screen_desktop == num - 1 &&
534 (c->desktop == DESKTOP_ALL ||
535 c->desktop == screen_desktop))
536 stacking_raise(CLIENT_AS_WINDOW(c));
540 /* change our struts/area to match (after moving windows) */
541 screen_update_areas();
543 /* may be some unnamed desktops that we need to fill in with names
544 (after updating the areas so the popup can resize) */
545 screen_update_desktop_names();
547 /* change our desktop if we're on one that no longer exists! */
548 if (screen_desktop >= screen_num_desktops)
549 screen_set_desktop(num - 1, TRUE);
552 void screen_set_desktop(guint num, gboolean dofocus)
560 g_assert(num < screen_num_desktops);
562 old = screen_desktop;
563 screen_desktop = num;
565 if (old == num) return;
567 PROP_SET32(RootWindow(ob_display, ob_screen),
568 net_current_desktop, cardinal, num);
570 screen_last_desktop = old;
572 ob_debug("Moving to desktop %d\n", num+1);
574 /* ignore enter events caused by the move */
575 ignore_start = event_start_ignore_all_enters();
577 if (moveresize_client)
578 client_set_desktop(moveresize_client, num, TRUE, FALSE);
580 /* show windows before hiding the rest to lessen the enter/leave events */
582 /* show windows from top to bottom */
583 for (it = stacking_list; it; it = g_list_next(it)) {
584 if (WINDOW_IS_CLIENT(it->data)) {
585 ObClient *c = it->data;
590 /* only allow omnipresent windows to get focus on desktop change if
591 an omnipresent window is already focused (it'll keep focus probably, but
592 maybe not depending on mouse-focus options) */
593 allow_omni = focus_client && (client_normal(focus_client) &&
594 focus_client->desktop == DESKTOP_ALL);
596 /* the client moved there already so don't move focus. prevent flicker
597 on sendtodesktop + follow */
598 if (focus_client && focus_client->desktop == screen_desktop)
601 /* have to try focus here because when you leave an empty desktop
602 there is no focus out to watch for. also, we have different rules
603 here. we always allow it to look under the mouse pointer if
604 config_focus_last is FALSE
606 do this before hiding the windows so if helper windows are coming
607 with us, they don't get hidden
609 if (dofocus && (c = focus_fallback(TRUE, !config_focus_last, allow_omni)))
611 /* only do the flicker reducing stuff ahead of time if we are going
612 to call xsetinputfocus on the window ourselves. otherwise there is
613 no guarantee the window will actually take focus.. */
615 /* reduce flicker by hiliting now rather than waiting for the
616 server FocusIn event */
617 frame_adjust_focus(c->frame, TRUE);
618 /* do this here so that if you switch desktops to a window with
619 helper windows then the helper windows won't flash */
620 client_bring_helper_windows(c);
624 /* hide windows from bottom to top */
625 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
626 if (WINDOW_IS_CLIENT(it->data)) {
627 ObClient *c = it->data;
632 event_end_ignore_all_enters(ignore_start);
634 if (event_curtime != CurrentTime)
635 screen_desktop_user_time = event_curtime;
638 void screen_add_desktop(gboolean current)
640 screen_set_num_desktops(screen_num_desktops+1);
642 /* move all the clients over */
646 for (it = client_list; it; it = g_list_next(it)) {
647 ObClient *c = it->data;
648 if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop)
649 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
654 void screen_remove_desktop(gboolean current)
656 guint rmdesktop, movedesktop;
657 GList *it, *stacking_copy;
659 if (screen_num_desktops <= 1) return;
661 /* what desktop are we removing and moving to? */
663 rmdesktop = screen_desktop;
665 rmdesktop = screen_num_desktops - 1;
666 if (rmdesktop < screen_num_desktops - 1)
667 movedesktop = rmdesktop + 1;
669 movedesktop = rmdesktop;
671 /* make a copy of the list cuz we're changing it */
672 stacking_copy = g_list_copy(stacking_list);
673 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
674 if (WINDOW_IS_CLIENT(it->data)) {
675 ObClient *c = it->data;
676 guint d = c->desktop;
677 if (d != DESKTOP_ALL && d >= movedesktop) {
678 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
679 ob_debug("moving window %s\n", c->title);
681 /* raise all the windows that are on the current desktop which
683 if ((screen_desktop == rmdesktop - 1 ||
684 screen_desktop == rmdesktop) &&
685 (d == DESKTOP_ALL || d == screen_desktop))
687 stacking_raise(CLIENT_AS_WINDOW(c));
688 ob_debug("raising window %s\n", c->title);
693 /* act like we're changing desktops */
694 if (screen_desktop < screen_num_desktops - 1) {
695 gint d = screen_desktop;
696 screen_desktop = screen_last_desktop;
697 screen_set_desktop(d, TRUE);
698 ob_debug("fake desktop change\n");
701 screen_set_num_desktops(screen_num_desktops-1);
704 static void get_row_col(guint d, guint *r, guint *c)
706 switch (screen_desktop_layout.orientation) {
707 case OB_ORIENTATION_HORZ:
708 switch (screen_desktop_layout.start_corner) {
709 case OB_CORNER_TOPLEFT:
710 *r = d / screen_desktop_layout.columns;
711 *c = d % screen_desktop_layout.columns;
713 case OB_CORNER_BOTTOMLEFT:
714 *r = screen_desktop_layout.rows - 1 -
715 d / screen_desktop_layout.columns;
716 *c = d % screen_desktop_layout.columns;
718 case OB_CORNER_TOPRIGHT:
719 *r = d / screen_desktop_layout.columns;
720 *c = screen_desktop_layout.columns - 1 -
721 d % screen_desktop_layout.columns;
723 case OB_CORNER_BOTTOMRIGHT:
724 *r = screen_desktop_layout.rows - 1 -
725 d / screen_desktop_layout.columns;
726 *c = screen_desktop_layout.columns - 1 -
727 d % screen_desktop_layout.columns;
731 case OB_ORIENTATION_VERT:
732 switch (screen_desktop_layout.start_corner) {
733 case OB_CORNER_TOPLEFT:
734 *r = d % screen_desktop_layout.rows;
735 *c = d / screen_desktop_layout.rows;
737 case OB_CORNER_BOTTOMLEFT:
738 *r = screen_desktop_layout.rows - 1 -
739 d % screen_desktop_layout.rows;
740 *c = d / screen_desktop_layout.rows;
742 case OB_CORNER_TOPRIGHT:
743 *r = d % screen_desktop_layout.rows;
744 *c = screen_desktop_layout.columns - 1 -
745 d / screen_desktop_layout.rows;
747 case OB_CORNER_BOTTOMRIGHT:
748 *r = screen_desktop_layout.rows - 1 -
749 d % screen_desktop_layout.rows;
750 *c = screen_desktop_layout.columns - 1 -
751 d / screen_desktop_layout.rows;
758 static guint translate_row_col(guint r, guint c)
760 switch (screen_desktop_layout.orientation) {
761 case OB_ORIENTATION_HORZ:
762 switch (screen_desktop_layout.start_corner) {
763 case OB_CORNER_TOPLEFT:
764 return r % screen_desktop_layout.rows *
765 screen_desktop_layout.columns +
766 c % screen_desktop_layout.columns;
767 case OB_CORNER_BOTTOMLEFT:
768 return (screen_desktop_layout.rows - 1 -
769 r % screen_desktop_layout.rows) *
770 screen_desktop_layout.columns +
771 c % screen_desktop_layout.columns;
772 case OB_CORNER_TOPRIGHT:
773 return r % screen_desktop_layout.rows *
774 screen_desktop_layout.columns +
775 (screen_desktop_layout.columns - 1 -
776 c % screen_desktop_layout.columns);
777 case OB_CORNER_BOTTOMRIGHT:
778 return (screen_desktop_layout.rows - 1 -
779 r % screen_desktop_layout.rows) *
780 screen_desktop_layout.columns +
781 (screen_desktop_layout.columns - 1 -
782 c % screen_desktop_layout.columns);
784 case OB_ORIENTATION_VERT:
785 switch (screen_desktop_layout.start_corner) {
786 case OB_CORNER_TOPLEFT:
787 return c % screen_desktop_layout.columns *
788 screen_desktop_layout.rows +
789 r % screen_desktop_layout.rows;
790 case OB_CORNER_BOTTOMLEFT:
791 return c % screen_desktop_layout.columns *
792 screen_desktop_layout.rows +
793 (screen_desktop_layout.rows - 1 -
794 r % screen_desktop_layout.rows);
795 case OB_CORNER_TOPRIGHT:
796 return (screen_desktop_layout.columns - 1 -
797 c % screen_desktop_layout.columns) *
798 screen_desktop_layout.rows +
799 r % screen_desktop_layout.rows;
800 case OB_CORNER_BOTTOMRIGHT:
801 return (screen_desktop_layout.columns - 1 -
802 c % screen_desktop_layout.columns) *
803 screen_desktop_layout.rows +
804 (screen_desktop_layout.rows - 1 -
805 r % screen_desktop_layout.rows);
808 g_assert_not_reached();
812 void screen_desktop_popup(guint d, gboolean show)
817 pager_popup_hide(desktop_cycle_popup);
819 a = screen_physical_area_active();
820 pager_popup_position(desktop_cycle_popup, CenterGravity,
821 a->x + a->width / 2, a->y + a->height / 2);
822 pager_popup_icon_size_multiplier(desktop_cycle_popup,
823 (screen_desktop_layout.columns /
824 screen_desktop_layout.rows) / 2,
825 (screen_desktop_layout.rows/
826 screen_desktop_layout.columns) / 2);
827 pager_popup_max_width(desktop_cycle_popup,
828 MAX(a->width/3, POPUP_WIDTH));
829 pager_popup_show(desktop_cycle_popup, screen_desktop_names[d], d);
833 guint screen_cycle_desktop(ObDirection dir, gboolean wrap, gboolean linear,
834 gboolean dialog, gboolean done, gboolean cancel)
837 static guint d = (guint)-1;
843 if ((cancel || done) && dialog)
844 goto show_cycle_dialog;
847 get_row_col(d, &r, &c);
851 case OB_DIRECTION_EAST:
852 if (d < screen_num_desktops - 1)
857 case OB_DIRECTION_WEST:
861 d = screen_num_desktops - 1;
865 return screen_desktop;
869 case OB_DIRECTION_EAST:
871 if (c >= screen_desktop_layout.columns) {
875 goto show_cycle_dialog;
877 d = translate_row_col(r, c);
878 if (d >= screen_num_desktops) {
883 goto show_cycle_dialog;
887 case OB_DIRECTION_WEST:
889 if (c >= screen_desktop_layout.columns) {
891 c = screen_desktop_layout.columns - 1;
893 goto show_cycle_dialog;
895 d = translate_row_col(r, c);
896 if (d >= screen_num_desktops) {
901 goto show_cycle_dialog;
905 case OB_DIRECTION_SOUTH:
907 if (r >= screen_desktop_layout.rows) {
911 goto show_cycle_dialog;
913 d = translate_row_col(r, c);
914 if (d >= screen_num_desktops) {
919 goto show_cycle_dialog;
923 case OB_DIRECTION_NORTH:
925 if (r >= screen_desktop_layout.rows) {
927 r = screen_desktop_layout.rows - 1;
929 goto show_cycle_dialog;
931 d = translate_row_col(r, c);
932 if (d >= screen_num_desktops) {
937 goto show_cycle_dialog;
943 return d = screen_desktop;
946 d = translate_row_col(r, c);
950 if (dialog && !cancel && !done) {
951 screen_desktop_popup(d, TRUE);
953 screen_desktop_popup(0, FALSE);
956 if (!dialog || cancel || done)
962 static gboolean screen_validate_layout(ObDesktopLayout *l)
964 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
967 /* fill in a zero rows/columns */
968 if (l->columns == 0) {
969 l->columns = screen_num_desktops / l->rows;
970 if (l->rows * l->columns < screen_num_desktops)
972 if (l->rows * l->columns >= screen_num_desktops + l->columns)
974 } else if (l->rows == 0) {
975 l->rows = screen_num_desktops / l->columns;
976 if (l->columns * l->rows < screen_num_desktops)
978 if (l->columns * l->rows >= screen_num_desktops + l->rows)
982 /* bounds checking */
983 if (l->orientation == OB_ORIENTATION_HORZ) {
984 l->columns = MIN(screen_num_desktops, l->columns);
985 l->rows = MIN(l->rows,
986 (screen_num_desktops + l->columns - 1) / l->columns);
987 l->columns = screen_num_desktops / l->rows +
988 !!(screen_num_desktops % l->rows);
990 l->rows = MIN(screen_num_desktops, l->rows);
991 l->columns = MIN(l->columns,
992 (screen_num_desktops + l->rows - 1) / l->rows);
993 l->rows = screen_num_desktops / l->columns +
994 !!(screen_num_desktops % l->columns);
999 void screen_update_layout()
1006 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1007 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1008 screen_desktop_layout.rows = 1;
1009 screen_desktop_layout.columns = screen_num_desktops;
1011 if (PROP_GETA32(RootWindow(ob_display, ob_screen),
1012 net_desktop_layout, cardinal, &data, &num)) {
1013 if (num == 3 || num == 4) {
1015 if (data[0] == prop_atoms.net_wm_orientation_vert)
1016 l.orientation = OB_ORIENTATION_VERT;
1017 else if (data[0] == prop_atoms.net_wm_orientation_horz)
1018 l.orientation = OB_ORIENTATION_HORZ;
1023 l.start_corner = OB_CORNER_TOPLEFT;
1025 if (data[3] == prop_atoms.net_wm_topleft)
1026 l.start_corner = OB_CORNER_TOPLEFT;
1027 else if (data[3] == prop_atoms.net_wm_topright)
1028 l.start_corner = OB_CORNER_TOPRIGHT;
1029 else if (data[3] == prop_atoms.net_wm_bottomright)
1030 l.start_corner = OB_CORNER_BOTTOMRIGHT;
1031 else if (data[3] == prop_atoms.net_wm_bottomleft)
1032 l.start_corner = OB_CORNER_BOTTOMLEFT;
1037 l.columns = data[1];
1040 if (screen_validate_layout(&l))
1041 screen_desktop_layout = l;
1048 void screen_update_desktop_names()
1052 /* empty the array */
1053 g_strfreev(screen_desktop_names);
1054 screen_desktop_names = NULL;
1056 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
1057 net_desktop_names, utf8, &screen_desktop_names))
1058 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1061 if (i < screen_num_desktops) {
1064 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1065 screen_num_desktops + 1);
1066 screen_desktop_names[screen_num_desktops] = NULL;
1068 it = g_slist_nth(config_desktops_names, i);
1070 for (; i < screen_num_desktops; ++i) {
1071 if (it && ((char*)it->data)[0]) /* not empty */
1072 /* use the names from the config file when possible */
1073 screen_desktop_names[i] = g_strdup(it->data);
1075 /* make up a nice name if it's not though */
1076 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1078 if (it) it = g_slist_next(it);
1081 /* if we changed any names, then set the root property so we can
1082 all agree on the names */
1083 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
1084 screen_desktop_names);
1087 /* resize the pager for these names */
1088 pager_popup_text_width_to_strings(desktop_cycle_popup,
1089 screen_desktop_names,
1090 screen_num_desktops);
1093 void screen_show_desktop(gboolean show, ObClient *show_only)
1097 if (show == screen_showing_desktop) return; /* no change */
1099 screen_showing_desktop = show;
1102 /* hide windows bottom to top */
1103 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1104 if (WINDOW_IS_CLIENT(it->data)) {
1105 ObClient *client = it->data;
1106 client_showhide(client);
1111 /* restore windows top to bottom */
1112 for (it = stacking_list; it; it = g_list_next(it)) {
1113 if (WINDOW_IS_CLIENT(it->data)) {
1114 ObClient *client = it->data;
1115 if (client_should_show(client)) {
1116 if (!show_only || client == show_only)
1117 client_show(client);
1119 client_iconify(client, TRUE, FALSE, TRUE);
1126 /* focus the desktop */
1127 for (it = focus_order; it; it = g_list_next(it)) {
1128 ObClient *c = it->data;
1129 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1130 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1131 client_focus(it->data))
1135 else if (!show_only) {
1138 if ((c = focus_fallback(TRUE, FALSE, TRUE))) {
1139 /* only do the flicker reducing stuff ahead of time if we are going
1140 to call xsetinputfocus on the window ourselves. otherwise there
1141 is no guarantee the window will actually take focus.. */
1143 /* reduce flicker by hiliting now rather than waiting for the
1144 server FocusIn event */
1145 frame_adjust_focus(c->frame, TRUE);
1150 show = !!show; /* make it boolean */
1151 PROP_SET32(RootWindow(ob_display, ob_screen),
1152 net_showing_desktop, cardinal, show);
1155 void screen_install_colormap(ObClient *client, gboolean install)
1157 if (client == NULL || client->colormap == None) {
1159 XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1161 XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1163 xerror_set_ignore(TRUE);
1165 XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1167 XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1168 xerror_set_ignore(FALSE);
1172 #define STRUT_LEFT_ON_MONITOR(s, i) \
1173 (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
1174 monitor_area[i].y, monitor_area[i].height))
1175 #define STRUT_RIGHT_ON_MONITOR(s, i) \
1176 (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
1177 monitor_area[i].y, monitor_area[i].height))
1178 #define STRUT_TOP_ON_MONITOR(s, i) \
1179 (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
1180 monitor_area[i].x, monitor_area[i].width))
1181 #define STRUT_BOTTOM_ON_MONITOR(s, i) \
1182 (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
1183 monitor_area[i].x, monitor_area[i].width))
1187 StrutPartial *strut;
1190 #define RESET_STRUT_LIST(sl) \
1191 (g_slist_free(sl), sl = NULL)
1193 #define ADD_STRUT_TO_LIST(sl, d, s) \
1195 ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1198 sl = g_slist_prepend(sl, ss); \
1201 void screen_update_areas()
1208 ob_debug("updating screen areas\n");
1210 g_free(monitor_area);
1211 extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
1213 dims = g_new(gulong, 4 * screen_num_desktops * screen_num_monitors);
1215 RESET_STRUT_LIST(struts_left);
1216 RESET_STRUT_LIST(struts_top);
1217 RESET_STRUT_LIST(struts_right);
1218 RESET_STRUT_LIST(struts_bottom);
1220 /* collect the struts */
1221 for (it = client_list; it; it = g_list_next(it)) {
1222 ObClient *c = it->data;
1224 ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1226 ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1228 ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1229 if (c->strut.bottom)
1230 ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1232 if (dock_strut.left)
1233 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1235 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1236 if (dock_strut.right)
1237 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1238 if (dock_strut.bottom)
1239 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1241 /* set up the work areas to be full screen */
1242 for (i = 0; i < screen_num_monitors; ++i)
1243 for (j = 0; j < screen_num_desktops; ++j) {
1244 dims[(i * screen_num_desktops + j) * 4+0] = monitor_area[i].x;
1245 dims[(i * screen_num_desktops + j) * 4+1] = monitor_area[i].y;
1246 dims[(i * screen_num_desktops + j) * 4+2] = monitor_area[i].width;
1247 dims[(i * screen_num_desktops + j) * 4+3] = monitor_area[i].height;
1250 /* calculate the work areas from the struts */
1251 for (i = 0; i < screen_num_monitors; ++i)
1252 for (j = 0; j < screen_num_desktops; ++j) {
1253 gint l = 0, r = 0, t = 0, b = 0;
1255 /* only add the strut to the area if it touches the monitor */
1257 for (sit = struts_left; sit; sit = g_slist_next(sit)) {
1258 ObScreenStrut *s = sit->data;
1259 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1260 STRUT_LEFT_ON_MONITOR(s->strut, i))
1261 l = MAX(l, s->strut->left);
1263 for (sit = struts_top; sit; sit = g_slist_next(sit)) {
1264 ObScreenStrut *s = sit->data;
1265 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1266 STRUT_TOP_ON_MONITOR(s->strut, i))
1267 t = MAX(t, s->strut->top);
1269 for (sit = struts_right; sit; sit = g_slist_next(sit)) {
1270 ObScreenStrut *s = sit->data;
1271 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1272 STRUT_RIGHT_ON_MONITOR(s->strut, i))
1273 r = MAX(r, s->strut->right);
1275 for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
1276 ObScreenStrut *s = sit->data;
1277 if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
1278 STRUT_BOTTOM_ON_MONITOR(s->strut, i))
1279 b = MAX(b, s->strut->bottom);
1282 /* based on these margins, set the work area for the
1284 dims[(i * screen_num_desktops + j) * 4 + 0] += l;
1285 dims[(i * screen_num_desktops + j) * 4 + 1] += t;
1286 dims[(i * screen_num_desktops + j) * 4 + 2] -= l + r;
1287 dims[(i * screen_num_desktops + j) * 4 + 3] -= t + b;
1290 PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1291 dims, 4 * screen_num_desktops * screen_num_monitors);
1293 /* the area has changed, adjust all the windows if they need it */
1294 for (it = client_list; it; it = g_list_next(it))
1295 client_reconfigure(it->data, FALSE);
1301 Rect* screen_area_all_monitors(guint desktop)
1306 a = screen_area_monitor(desktop, 0);
1308 /* combine all the monitors together */
1309 for (i = 1; i < screen_num_monitors; ++i) {
1310 Rect *m = screen_area_monitor(desktop, i);
1313 l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1314 t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1315 r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1316 b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1318 RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1327 #define STRUT_LEFT_IN_SEARCH(s, search) \
1328 (RANGES_INTERSECT(search->y, search->height, \
1329 s->left_start, s->left_end - s->left_start + 1))
1330 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1331 (RANGES_INTERSECT(search->y, search->height, \
1332 s->right_start, s->right_end - s->right_start + 1))
1333 #define STRUT_TOP_IN_SEARCH(s, search) \
1334 (RANGES_INTERSECT(search->x, search->width, \
1335 s->top_start, s->top_end - s->top_start + 1))
1336 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1337 (RANGES_INTERSECT(search->x, search->width, \
1338 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1340 #define STRUT_LEFT_IGNORE(s, us, search) \
1341 (head == SCREEN_AREA_ALL_MONITORS && us && \
1342 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1343 #define STRUT_RIGHT_IGNORE(s, us, search) \
1344 (head == SCREEN_AREA_ALL_MONITORS && us && \
1345 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1346 #define STRUT_TOP_IGNORE(s, us, search) \
1347 (head == SCREEN_AREA_ALL_MONITORS && us && \
1348 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1349 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1350 (head == SCREEN_AREA_ALL_MONITORS && us && \
1351 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1353 Rect* screen_area(guint desktop, guint head, Rect *search)
1357 gint l, r, t, b, al, ar, at, ab;
1359 gboolean us = search != NULL; /* user provided search */
1361 g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1362 g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1363 head == SCREEN_AREA_ALL_MONITORS);
1364 g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1366 /* find any struts for this monitor
1367 which will be affecting the search area.
1370 /* search everything if search is null */
1372 if (head < screen_num_monitors) search = &monitor_area[head];
1373 else search = &monitor_area[screen_num_monitors];
1375 if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1377 /* al is "all left" meaning the furthest left you can get, l is our
1378 "working left" meaning our current strut edge which we're calculating
1381 /* only include monitors which the search area lines up with */
1382 if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1383 al = l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1384 at = t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1385 ar = r = RECT_LEFT(monitor_area[screen_num_monitors]);
1386 ab = b = RECT_TOP(monitor_area[screen_num_monitors]);
1387 for (i = 0; i < screen_num_monitors; ++i) {
1388 /* add the monitor if applicable */
1389 if (RANGES_INTERSECT(search->x, search->width,
1390 monitor_area[i].x, monitor_area[i].width))
1392 at = t = MIN(t, RECT_TOP(monitor_area[i]));
1393 ab = b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1395 if (RANGES_INTERSECT(search->y, search->height,
1396 monitor_area[i].y, monitor_area[i].height))
1398 al = l = MIN(l, RECT_LEFT(monitor_area[i]));
1399 ar = r = MAX(r, RECT_RIGHT(monitor_area[i]));
1403 al = l = RECT_LEFT(monitor_area[screen_num_monitors]);
1404 at = t = RECT_TOP(monitor_area[screen_num_monitors]);
1405 ar = r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1406 ab = b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1409 for (d = 0; d < screen_num_desktops; ++d) {
1410 if (d != desktop && desktop != DESKTOP_ALL) continue;
1412 for (i = 0; i < screen_num_monitors; ++i) {
1413 if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1415 for (it = struts_left; it; it = g_slist_next(it)) {
1416 ObScreenStrut *s = it->data;
1417 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1418 STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1419 !STRUT_LEFT_IGNORE(s->strut, us, search))
1420 l = MAX(l, al + s->strut->left);
1422 for (it = struts_top; it; it = g_slist_next(it)) {
1423 ObScreenStrut *s = it->data;
1424 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1425 STRUT_TOP_IN_SEARCH(s->strut, search) &&
1426 !STRUT_TOP_IGNORE(s->strut, us, search))
1427 t = MAX(t, at + s->strut->top);
1429 for (it = struts_right; it; it = g_slist_next(it)) {
1430 ObScreenStrut *s = it->data;
1431 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1432 STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1433 !STRUT_RIGHT_IGNORE(s->strut, us, search))
1434 r = MIN(r, ar - s->strut->right);
1436 for (it = struts_bottom; it; it = g_slist_next(it)) {
1437 ObScreenStrut *s = it->data;
1438 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1439 STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1440 !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1441 b = MIN(b, ab - s->strut->bottom);
1444 /* limit to this monitor */
1446 l = MAX(l, RECT_LEFT(monitor_area[i]));
1447 t = MAX(t, RECT_TOP(monitor_area[i]));
1448 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1449 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1457 a->width = r - l + 1;
1458 a->height = b - t + 1;
1462 guint screen_find_monitor(Rect *search)
1468 for (i = 0; i < screen_num_monitors; ++i) {
1469 Rect *area = screen_physical_area_monitor(i);
1470 if (RECT_INTERSECTS_RECT(*area, *search)) {
1474 RECT_SET_INTERSECTION(r, *area, *search);
1475 v = r.width * r.height;
1487 Rect* screen_physical_area_all_monitors()
1489 return screen_physical_area_monitor(screen_num_monitors);
1492 Rect* screen_physical_area_monitor(guint head)
1495 g_assert(head <= screen_num_monitors);
1498 *a = monitor_area[head];
1502 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1504 g_assert(head <= screen_num_monitors);
1506 return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1509 Rect* screen_physical_area_active()
1515 a = screen_physical_area_monitor(client_monitor(focus_client));
1518 if (screen_pointer_pos(&x, &y))
1519 RECT_SET(mon, x, y, 1, 1);
1521 RECT_SET(mon, 0, 0, 1, 1);
1522 a = screen_physical_area_monitor(screen_find_monitor(&mon));
1527 void screen_set_root_cursor()
1529 if (sn_app_starting())
1530 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1531 ob_cursor(OB_CURSOR_BUSYPOINTER));
1533 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1534 ob_cursor(OB_CURSOR_POINTER));
1537 gboolean screen_pointer_pos(gint *x, gint *y)
1544 ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1545 &w, &w, x, y, &i, &i, &u);
1547 for (i = 0; i < ScreenCount(ob_display); ++i)
1549 if (XQueryPointer(ob_display, RootWindow(ob_display, i),
1550 &w, &w, x, y, &i, &i, &u))