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 static void get_row_col(guint d
, guint
*r
, guint
*c
)
640 switch (screen_desktop_layout
.orientation
) {
641 case OB_ORIENTATION_HORZ
:
642 switch (screen_desktop_layout
.start_corner
) {
643 case OB_CORNER_TOPLEFT
:
644 *r
= d
/ screen_desktop_layout
.columns
;
645 *c
= d
% screen_desktop_layout
.columns
;
647 case OB_CORNER_BOTTOMLEFT
:
648 *r
= screen_desktop_layout
.rows
- 1 -
649 d
/ screen_desktop_layout
.columns
;
650 *c
= d
% screen_desktop_layout
.columns
;
652 case OB_CORNER_TOPRIGHT
:
653 *r
= d
/ screen_desktop_layout
.columns
;
654 *c
= screen_desktop_layout
.columns
- 1 -
655 d
% screen_desktop_layout
.columns
;
657 case OB_CORNER_BOTTOMRIGHT
:
658 *r
= screen_desktop_layout
.rows
- 1 -
659 d
/ screen_desktop_layout
.columns
;
660 *c
= screen_desktop_layout
.columns
- 1 -
661 d
% screen_desktop_layout
.columns
;
665 case OB_ORIENTATION_VERT
:
666 switch (screen_desktop_layout
.start_corner
) {
667 case OB_CORNER_TOPLEFT
:
668 *r
= d
% screen_desktop_layout
.rows
;
669 *c
= d
/ screen_desktop_layout
.rows
;
671 case OB_CORNER_BOTTOMLEFT
:
672 *r
= screen_desktop_layout
.rows
- 1 -
673 d
% screen_desktop_layout
.rows
;
674 *c
= d
/ screen_desktop_layout
.rows
;
676 case OB_CORNER_TOPRIGHT
:
677 *r
= d
% screen_desktop_layout
.rows
;
678 *c
= screen_desktop_layout
.columns
- 1 -
679 d
/ screen_desktop_layout
.rows
;
681 case OB_CORNER_BOTTOMRIGHT
:
682 *r
= screen_desktop_layout
.rows
- 1 -
683 d
% screen_desktop_layout
.rows
;
684 *c
= screen_desktop_layout
.columns
- 1 -
685 d
/ screen_desktop_layout
.rows
;
692 static guint
translate_row_col(guint r
, guint c
)
694 switch (screen_desktop_layout
.orientation
) {
695 case OB_ORIENTATION_HORZ
:
696 switch (screen_desktop_layout
.start_corner
) {
697 case OB_CORNER_TOPLEFT
:
698 return r
% screen_desktop_layout
.rows
*
699 screen_desktop_layout
.columns
+
700 c
% screen_desktop_layout
.columns
;
701 case OB_CORNER_BOTTOMLEFT
:
702 return (screen_desktop_layout
.rows
- 1 -
703 r
% screen_desktop_layout
.rows
) *
704 screen_desktop_layout
.columns
+
705 c
% screen_desktop_layout
.columns
;
706 case OB_CORNER_TOPRIGHT
:
707 return r
% screen_desktop_layout
.rows
*
708 screen_desktop_layout
.columns
+
709 (screen_desktop_layout
.columns
- 1 -
710 c
% screen_desktop_layout
.columns
);
711 case OB_CORNER_BOTTOMRIGHT
:
712 return (screen_desktop_layout
.rows
- 1 -
713 r
% screen_desktop_layout
.rows
) *
714 screen_desktop_layout
.columns
+
715 (screen_desktop_layout
.columns
- 1 -
716 c
% screen_desktop_layout
.columns
);
718 case OB_ORIENTATION_VERT
:
719 switch (screen_desktop_layout
.start_corner
) {
720 case OB_CORNER_TOPLEFT
:
721 return c
% screen_desktop_layout
.columns
*
722 screen_desktop_layout
.rows
+
723 r
% screen_desktop_layout
.rows
;
724 case OB_CORNER_BOTTOMLEFT
:
725 return c
% screen_desktop_layout
.columns
*
726 screen_desktop_layout
.rows
+
727 (screen_desktop_layout
.rows
- 1 -
728 r
% screen_desktop_layout
.rows
);
729 case OB_CORNER_TOPRIGHT
:
730 return (screen_desktop_layout
.columns
- 1 -
731 c
% screen_desktop_layout
.columns
) *
732 screen_desktop_layout
.rows
+
733 r
% screen_desktop_layout
.rows
;
734 case OB_CORNER_BOTTOMRIGHT
:
735 return (screen_desktop_layout
.columns
- 1 -
736 c
% screen_desktop_layout
.columns
) *
737 screen_desktop_layout
.rows
+
738 (screen_desktop_layout
.rows
- 1 -
739 r
% screen_desktop_layout
.rows
);
742 g_assert_not_reached();
746 void screen_desktop_popup(guint d
, gboolean show
)
751 pager_popup_hide(desktop_cycle_popup
);
753 a
= screen_physical_area_active();
754 pager_popup_position(desktop_cycle_popup
, CenterGravity
,
755 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
756 pager_popup_icon_size_multiplier(desktop_cycle_popup
,
757 (screen_desktop_layout
.columns
/
758 screen_desktop_layout
.rows
) / 2,
759 (screen_desktop_layout
.rows
/
760 screen_desktop_layout
.columns
) / 2);
761 pager_popup_max_width(desktop_cycle_popup
,
762 MAX(a
->width
/3, POPUP_WIDTH
));
763 pager_popup_show(desktop_cycle_popup
, screen_desktop_names
[d
], d
);
767 guint
screen_cycle_desktop(ObDirection dir
, gboolean wrap
, gboolean linear
,
768 gboolean dialog
, gboolean done
, gboolean cancel
)
771 static guint d
= (guint
)-1;
777 if ((cancel
|| done
) && dialog
)
778 goto show_cycle_dialog
;
781 get_row_col(d
, &r
, &c
);
785 case OB_DIRECTION_EAST
:
786 if (d
< screen_num_desktops
- 1)
791 case OB_DIRECTION_WEST
:
795 d
= screen_num_desktops
- 1;
799 return screen_desktop
;
803 case OB_DIRECTION_EAST
:
805 if (c
>= screen_desktop_layout
.columns
) {
809 goto show_cycle_dialog
;
811 d
= translate_row_col(r
, c
);
812 if (d
>= screen_num_desktops
) {
817 goto show_cycle_dialog
;
821 case OB_DIRECTION_WEST
:
823 if (c
>= screen_desktop_layout
.columns
) {
825 c
= screen_desktop_layout
.columns
- 1;
827 goto show_cycle_dialog
;
829 d
= translate_row_col(r
, c
);
830 if (d
>= screen_num_desktops
) {
835 goto show_cycle_dialog
;
839 case OB_DIRECTION_SOUTH
:
841 if (r
>= screen_desktop_layout
.rows
) {
845 goto show_cycle_dialog
;
847 d
= translate_row_col(r
, c
);
848 if (d
>= screen_num_desktops
) {
853 goto show_cycle_dialog
;
857 case OB_DIRECTION_NORTH
:
859 if (r
>= screen_desktop_layout
.rows
) {
861 r
= screen_desktop_layout
.rows
- 1;
863 goto show_cycle_dialog
;
865 d
= translate_row_col(r
, c
);
866 if (d
>= screen_num_desktops
) {
871 goto show_cycle_dialog
;
877 return d
= screen_desktop
;
880 d
= translate_row_col(r
, c
);
884 if (dialog
&& !cancel
&& !done
) {
885 screen_desktop_popup(d
, TRUE
);
887 screen_desktop_popup(0, FALSE
);
890 if (!dialog
|| cancel
|| done
)
896 static gboolean
screen_validate_layout(ObDesktopLayout
*l
)
898 if (l
->columns
== 0 && l
->rows
== 0) /* both 0's is bad data.. */
901 /* fill in a zero rows/columns */
902 if (l
->columns
== 0) {
903 l
->columns
= screen_num_desktops
/ l
->rows
;
904 if (l
->rows
* l
->columns
< screen_num_desktops
)
906 if (l
->rows
* l
->columns
>= screen_num_desktops
+ l
->columns
)
908 } else if (l
->rows
== 0) {
909 l
->rows
= screen_num_desktops
/ l
->columns
;
910 if (l
->columns
* l
->rows
< screen_num_desktops
)
912 if (l
->columns
* l
->rows
>= screen_num_desktops
+ l
->rows
)
916 /* bounds checking */
917 if (l
->orientation
== OB_ORIENTATION_HORZ
) {
918 l
->columns
= MIN(screen_num_desktops
, l
->columns
);
919 l
->rows
= MIN(l
->rows
,
920 (screen_num_desktops
+ l
->columns
- 1) / l
->columns
);
921 l
->columns
= screen_num_desktops
/ l
->rows
+
922 !!(screen_num_desktops
% l
->rows
);
924 l
->rows
= MIN(screen_num_desktops
, l
->rows
);
925 l
->columns
= MIN(l
->columns
,
926 (screen_num_desktops
+ l
->rows
- 1) / l
->rows
);
927 l
->rows
= screen_num_desktops
/ l
->columns
+
928 !!(screen_num_desktops
% l
->columns
);
933 void screen_update_layout()
940 screen_desktop_layout
.orientation
= OB_ORIENTATION_HORZ
;
941 screen_desktop_layout
.start_corner
= OB_CORNER_TOPLEFT
;
942 screen_desktop_layout
.rows
= 1;
943 screen_desktop_layout
.columns
= screen_num_desktops
;
945 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
946 net_desktop_layout
, cardinal
, &data
, &num
)) {
947 if (num
== 3 || num
== 4) {
949 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
950 l
.orientation
= OB_ORIENTATION_VERT
;
951 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
952 l
.orientation
= OB_ORIENTATION_HORZ
;
957 l
.start_corner
= OB_CORNER_TOPLEFT
;
959 if (data
[3] == prop_atoms
.net_wm_topleft
)
960 l
.start_corner
= OB_CORNER_TOPLEFT
;
961 else if (data
[3] == prop_atoms
.net_wm_topright
)
962 l
.start_corner
= OB_CORNER_TOPRIGHT
;
963 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
964 l
.start_corner
= OB_CORNER_BOTTOMRIGHT
;
965 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
966 l
.start_corner
= OB_CORNER_BOTTOMLEFT
;
974 if (screen_validate_layout(&l
))
975 screen_desktop_layout
= l
;
982 void screen_update_desktop_names()
986 /* empty the array */
987 g_strfreev(screen_desktop_names
);
988 screen_desktop_names
= NULL
;
990 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
991 net_desktop_names
, utf8
, &screen_desktop_names
))
992 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
995 if (i
< screen_num_desktops
) {
998 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
999 screen_num_desktops
+ 1);
1000 screen_desktop_names
[screen_num_desktops
] = NULL
;
1002 it
= g_slist_nth(config_desktops_names
, i
);
1004 for (; i
< screen_num_desktops
; ++i
) {
1005 if (it
&& ((char*)it
->data
)[0]) /* not empty */
1006 /* use the names from the config file when possible */
1007 screen_desktop_names
[i
] = g_strdup(it
->data
);
1009 /* make up a nice name if it's not though */
1010 screen_desktop_names
[i
] = g_strdup_printf(_("desktop %i"),
1012 if (it
) it
= g_slist_next(it
);
1015 /* if we changed any names, then set the root property so we can
1016 all agree on the names */
1017 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,
1018 screen_desktop_names
);
1021 /* resize the pager for these names */
1022 pager_popup_text_width_to_strings(desktop_cycle_popup
,
1023 screen_desktop_names
,
1024 screen_num_desktops
);
1027 void screen_show_desktop(gboolean show
, ObClient
*show_only
)
1031 if (show
== screen_showing_desktop
) return; /* no change */
1033 screen_showing_desktop
= show
;
1036 /* hide windows bottom to top */
1037 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
1038 if (WINDOW_IS_CLIENT(it
->data
)) {
1039 ObClient
*client
= it
->data
;
1040 client_showhide(client
);
1045 /* restore windows top to bottom */
1046 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
1047 if (WINDOW_IS_CLIENT(it
->data
)) {
1048 ObClient
*client
= it
->data
;
1049 if (client_should_show(client
)) {
1050 if (!show_only
|| client
== show_only
)
1051 client_show(client
);
1053 client_iconify(client
, TRUE
, FALSE
, TRUE
);
1060 /* focus the desktop */
1061 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
1062 ObClient
*c
= it
->data
;
1063 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
1064 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
1065 client_focus(it
->data
))
1069 else if (!show_only
) {
1072 if ((c
= focus_fallback(TRUE
, FALSE
, TRUE
))) {
1073 /* only do the flicker reducing stuff ahead of time if we are going
1074 to call xsetinputfocus on the window ourselves. otherwise there
1075 is no guarantee the window will actually take focus.. */
1077 /* reduce flicker by hiliting now rather than waiting for the
1078 server FocusIn event */
1079 frame_adjust_focus(c
->frame
, TRUE
);
1084 show
= !!show
; /* make it boolean */
1085 PROP_SET32(RootWindow(ob_display
, ob_screen
),
1086 net_showing_desktop
, cardinal
, show
);
1089 void screen_install_colormap(ObClient
*client
, gboolean install
)
1091 if (client
== NULL
|| client
->colormap
== None
) {
1093 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1095 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1097 xerror_set_ignore(TRUE
);
1099 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1101 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1102 xerror_set_ignore(FALSE
);
1106 #define STRUT_LEFT_ON_MONITOR(s, i) \
1107 (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
1108 monitor_area[i].y, monitor_area[i].height))
1109 #define STRUT_RIGHT_ON_MONITOR(s, i) \
1110 (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
1111 monitor_area[i].y, monitor_area[i].height))
1112 #define STRUT_TOP_ON_MONITOR(s, i) \
1113 (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
1114 monitor_area[i].x, monitor_area[i].width))
1115 #define STRUT_BOTTOM_ON_MONITOR(s, i) \
1116 (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
1117 monitor_area[i].x, monitor_area[i].width))
1121 StrutPartial
*strut
;
1124 #define RESET_STRUT_LIST(sl) \
1125 (g_slist_free(sl), sl = NULL)
1127 #define ADD_STRUT_TO_LIST(sl, d, s) \
1129 ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1132 sl = g_slist_prepend(sl, ss); \
1135 void screen_update_areas()
1142 ob_debug("updating screen areas\n");
1144 g_free(monitor_area
);
1145 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1147 dims
= g_new(gulong
, 4 * screen_num_desktops
* screen_num_monitors
);
1149 RESET_STRUT_LIST(struts_left
);
1150 RESET_STRUT_LIST(struts_top
);
1151 RESET_STRUT_LIST(struts_right
);
1152 RESET_STRUT_LIST(struts_bottom
);
1154 /* collect the struts */
1155 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1156 ObClient
*c
= it
->data
;
1158 ADD_STRUT_TO_LIST(struts_left
, c
->desktop
, &c
->strut
);
1160 ADD_STRUT_TO_LIST(struts_top
, c
->desktop
, &c
->strut
);
1162 ADD_STRUT_TO_LIST(struts_right
, c
->desktop
, &c
->strut
);
1163 if (c
->strut
.bottom
)
1164 ADD_STRUT_TO_LIST(struts_bottom
, c
->desktop
, &c
->strut
);
1166 if (dock_strut
.left
)
1167 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &dock_strut
);
1169 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &dock_strut
);
1170 if (dock_strut
.right
)
1171 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &dock_strut
);
1172 if (dock_strut
.bottom
)
1173 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &dock_strut
);
1175 /* set up the work areas to be full screen */
1176 for (i
= 0; i
< screen_num_monitors
; ++i
)
1177 for (j
= 0; j
< screen_num_desktops
; ++j
) {
1178 dims
[(i
* screen_num_desktops
+ j
) * 4+0] = monitor_area
[i
].x
;
1179 dims
[(i
* screen_num_desktops
+ j
) * 4+1] = monitor_area
[i
].y
;
1180 dims
[(i
* screen_num_desktops
+ j
) * 4+2] = monitor_area
[i
].width
;
1181 dims
[(i
* screen_num_desktops
+ j
) * 4+3] = monitor_area
[i
].height
;
1184 /* calculate the work areas from the struts */
1185 for (i
= 0; i
< screen_num_monitors
; ++i
)
1186 for (j
= 0; j
< screen_num_desktops
; ++j
) {
1187 gint l
= 0, r
= 0, t
= 0, b
= 0;
1189 /* only add the strut to the area if it touches the monitor */
1191 for (sit
= struts_left
; sit
; sit
= g_slist_next(sit
)) {
1192 ObScreenStrut
*s
= sit
->data
;
1193 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1194 STRUT_LEFT_ON_MONITOR(s
->strut
, i
))
1195 l
= MAX(l
, s
->strut
->left
);
1197 for (sit
= struts_top
; sit
; sit
= g_slist_next(sit
)) {
1198 ObScreenStrut
*s
= sit
->data
;
1199 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1200 STRUT_TOP_ON_MONITOR(s
->strut
, i
))
1201 t
= MAX(t
, s
->strut
->top
);
1203 for (sit
= struts_right
; sit
; sit
= g_slist_next(sit
)) {
1204 ObScreenStrut
*s
= sit
->data
;
1205 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1206 STRUT_RIGHT_ON_MONITOR(s
->strut
, i
))
1207 r
= MAX(r
, s
->strut
->right
);
1209 for (sit
= struts_bottom
; sit
; sit
= g_slist_next(sit
)) {
1210 ObScreenStrut
*s
= sit
->data
;
1211 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1212 STRUT_BOTTOM_ON_MONITOR(s
->strut
, i
))
1213 b
= MAX(b
, s
->strut
->bottom
);
1216 /* based on these margins, set the work area for the
1218 dims
[(i
* screen_num_desktops
+ j
) * 4 + 0] += l
;
1219 dims
[(i
* screen_num_desktops
+ j
) * 4 + 1] += t
;
1220 dims
[(i
* screen_num_desktops
+ j
) * 4 + 2] -= l
+ r
;
1221 dims
[(i
* screen_num_desktops
+ j
) * 4 + 3] -= t
+ b
;
1224 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1225 dims
, 4 * screen_num_desktops
* screen_num_monitors
);
1227 /* the area has changed, adjust all the windows if they need it */
1228 for (it
= client_list
; it
; it
= g_list_next(it
))
1229 client_reconfigure(it
->data
, FALSE
);
1235 Rect
* screen_area_all_monitors(guint desktop
)
1240 a
= screen_area_monitor(desktop
, 0);
1242 /* combine all the monitors together */
1243 for (i
= 1; i
< screen_num_monitors
; ++i
) {
1244 Rect
*m
= screen_area_monitor(desktop
, i
);
1247 l
= MIN(RECT_LEFT(*a
), RECT_LEFT(*m
));
1248 t
= MIN(RECT_TOP(*a
), RECT_TOP(*m
));
1249 r
= MAX(RECT_RIGHT(*a
), RECT_RIGHT(*m
));
1250 b
= MAX(RECT_BOTTOM(*a
), RECT_BOTTOM(*m
));
1252 RECT_SET(*a
, l
, t
, r
- l
+ 1, b
- t
+ 1);
1261 #define STRUT_LEFT_IN_SEARCH(s, search) \
1262 (RANGES_INTERSECT(search->y, search->height, \
1263 s->left_start, s->left_end - s->left_start + 1))
1264 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1265 (RANGES_INTERSECT(search->y, search->height, \
1266 s->right_start, s->right_end - s->right_start + 1))
1267 #define STRUT_TOP_IN_SEARCH(s, search) \
1268 (RANGES_INTERSECT(search->x, search->width, \
1269 s->top_start, s->top_end - s->top_start + 1))
1270 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1271 (RANGES_INTERSECT(search->x, search->width, \
1272 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1274 #define STRUT_LEFT_IGNORE(s, us, search) \
1275 (head == SCREEN_AREA_ALL_MONITORS && us && \
1276 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1277 #define STRUT_RIGHT_IGNORE(s, us, search) \
1278 (head == SCREEN_AREA_ALL_MONITORS && us && \
1279 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1280 #define STRUT_TOP_IGNORE(s, us, search) \
1281 (head == SCREEN_AREA_ALL_MONITORS && us && \
1282 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1283 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1284 (head == SCREEN_AREA_ALL_MONITORS && us && \
1285 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1287 Rect
* screen_area(guint desktop
, guint head
, Rect
*search
)
1291 gint l
, r
, t
, b
, al
, ar
, at
, ab
;
1293 gboolean us
= search
!= NULL
; /* user provided search */
1295 g_assert(desktop
< screen_num_desktops
|| desktop
== DESKTOP_ALL
);
1296 g_assert(head
< screen_num_monitors
|| head
== SCREEN_AREA_ONE_MONITOR
||
1297 head
== SCREEN_AREA_ALL_MONITORS
);
1298 g_assert(!(head
== SCREEN_AREA_ONE_MONITOR
&& search
== NULL
));
1300 /* find any struts for this monitor
1301 which will be affecting the search area.
1304 /* search everything if search is null */
1306 if (head
< screen_num_monitors
) search
= &monitor_area
[head
];
1307 else search
= &monitor_area
[screen_num_monitors
];
1309 if (head
== SCREEN_AREA_ONE_MONITOR
) head
= screen_find_monitor(search
);
1311 /* al is "all left" meaning the furthest left you can get, l is our
1312 "working left" meaning our current strut edge which we're calculating
1315 /* only include monitors which the search area lines up with */
1316 if (RECT_INTERSECTS_RECT(monitor_area
[screen_num_monitors
], *search
)) {
1317 al
= l
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1318 at
= t
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1319 ar
= r
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1320 ab
= b
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1321 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1322 /* add the monitor if applicable */
1323 if (RANGES_INTERSECT(search
->x
, search
->width
,
1324 monitor_area
[i
].x
, monitor_area
[i
].width
))
1326 at
= t
= MIN(t
, RECT_TOP(monitor_area
[i
]));
1327 ab
= b
= MAX(b
, RECT_BOTTOM(monitor_area
[i
]));
1329 if (RANGES_INTERSECT(search
->y
, search
->height
,
1330 monitor_area
[i
].y
, monitor_area
[i
].height
))
1332 al
= l
= MIN(l
, RECT_LEFT(monitor_area
[i
]));
1333 ar
= r
= MAX(r
, RECT_RIGHT(monitor_area
[i
]));
1337 al
= l
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1338 at
= t
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1339 ar
= r
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1340 ab
= b
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1343 for (d
= 0; d
< screen_num_desktops
; ++d
) {
1344 if (d
!= desktop
&& desktop
!= DESKTOP_ALL
) continue;
1346 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1347 if (head
!= SCREEN_AREA_ALL_MONITORS
&& head
!= i
) continue;
1349 for (it
= struts_left
; it
; it
= g_slist_next(it
)) {
1350 ObScreenStrut
*s
= it
->data
;
1351 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1352 STRUT_LEFT_IN_SEARCH(s
->strut
, search
) &&
1353 !STRUT_LEFT_IGNORE(s
->strut
, us
, search
))
1354 l
= MAX(l
, al
+ s
->strut
->left
);
1356 for (it
= struts_top
; it
; it
= g_slist_next(it
)) {
1357 ObScreenStrut
*s
= it
->data
;
1358 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1359 STRUT_TOP_IN_SEARCH(s
->strut
, search
) &&
1360 !STRUT_TOP_IGNORE(s
->strut
, us
, search
))
1361 t
= MAX(t
, at
+ s
->strut
->top
);
1363 for (it
= struts_right
; it
; it
= g_slist_next(it
)) {
1364 ObScreenStrut
*s
= it
->data
;
1365 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1366 STRUT_RIGHT_IN_SEARCH(s
->strut
, search
) &&
1367 !STRUT_RIGHT_IGNORE(s
->strut
, us
, search
))
1368 r
= MIN(r
, ar
- s
->strut
->right
);
1370 for (it
= struts_bottom
; it
; it
= g_slist_next(it
)) {
1371 ObScreenStrut
*s
= it
->data
;
1372 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1373 STRUT_BOTTOM_IN_SEARCH(s
->strut
, search
) &&
1374 !STRUT_BOTTOM_IGNORE(s
->strut
, us
, search
))
1375 b
= MIN(b
, ab
- s
->strut
->bottom
);
1378 /* limit to this monitor */
1380 l
= MAX(l
, RECT_LEFT(monitor_area
[i
]));
1381 t
= MAX(t
, RECT_TOP(monitor_area
[i
]));
1382 r
= MIN(r
, RECT_RIGHT(monitor_area
[i
]));
1383 b
= MIN(b
, RECT_BOTTOM(monitor_area
[i
]));
1391 a
->width
= r
- l
+ 1;
1392 a
->height
= b
- t
+ 1;
1396 guint
screen_find_monitor(Rect
*search
)
1402 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1403 Rect
*area
= screen_physical_area_monitor(i
);
1404 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1408 RECT_SET_INTERSECTION(r
, *area
, *search
);
1409 v
= r
.width
* r
.height
;
1421 Rect
* screen_physical_area_all_monitors()
1423 return screen_physical_area_monitor(screen_num_monitors
);
1426 Rect
* screen_physical_area_monitor(guint head
)
1429 g_assert(head
<= screen_num_monitors
);
1432 *a
= monitor_area
[head
];
1436 gboolean
screen_physical_area_monitor_contains(guint head
, Rect
*search
)
1438 g_assert(head
<= screen_num_monitors
);
1440 return RECT_INTERSECTS_RECT(monitor_area
[head
], *search
);
1443 Rect
* screen_physical_area_active()
1449 a
= screen_physical_area_monitor(client_monitor(focus_client
));
1452 if (screen_pointer_pos(&x
, &y
))
1453 RECT_SET(mon
, x
, y
, 1, 1);
1455 RECT_SET(mon
, 0, 0, 1, 1);
1456 a
= screen_physical_area_monitor(screen_find_monitor(&mon
));
1461 void screen_set_root_cursor()
1463 if (sn_app_starting())
1464 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1465 ob_cursor(OB_CURSOR_BUSYPOINTER
));
1467 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1468 ob_cursor(OB_CURSOR_POINTER
));
1471 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1478 ret
= !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1479 &w
, &w
, x
, y
, &i
, &i
, &u
);
1481 for (i
= 0; i
< ScreenCount(ob_display
); ++i
)
1483 if (XQueryPointer(ob_display
, RootWindow(ob_display
, i
),
1484 &w
, &w
, x
, y
, &i
, &i
, &u
))