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"
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)
54 static gboolean
screen_validate_layout(ObDesktopLayout
*l
);
55 static gboolean
replace_wm(void);
56 static void screen_tell_ksplash(void);
57 static void screen_fallback_focus(void);
59 guint screen_num_desktops
;
60 guint screen_num_monitors
;
62 guint screen_last_desktop
;
63 gboolean screen_showing_desktop
;
64 ObDesktopLayout screen_desktop_layout
;
65 gchar
**screen_desktop_names
;
66 Window screen_support_win
;
67 Time screen_desktop_user_time
= CurrentTime
;
69 static Size screen_physical_size
;
70 static guint screen_old_desktop
;
71 static gboolean screen_desktop_timeout
= TRUE
;
72 /*! An array of desktops, holding an array of areas per monitor */
73 static Rect
*monitor_area
= NULL
;
74 /*! An array of desktops, holding an array of struts */
75 static GSList
*struts_top
= NULL
;
76 static GSList
*struts_left
= NULL
;
77 static GSList
*struts_right
= NULL
;
78 static GSList
*struts_bottom
= NULL
;
80 static ObPagerPopup
*desktop_popup
;
82 /*! The number of microseconds that you need to be on a desktop before it will
83 replace the remembered "last desktop" */
84 #define REMEMBER_LAST_DESKTOP_TIME 750000
86 static gboolean
replace_wm(void)
90 Window current_wm_sn_owner
;
93 wm_sn
= g_strdup_printf("WM_S%d", ob_screen
);
94 wm_sn_atom
= XInternAtom(ob_display
, wm_sn
, FALSE
);
97 current_wm_sn_owner
= XGetSelectionOwner(ob_display
, wm_sn_atom
);
98 if (current_wm_sn_owner
== screen_support_win
)
99 current_wm_sn_owner
= None
;
100 if (current_wm_sn_owner
) {
101 if (!ob_replace_wm
) {
102 g_message(_("A window manager is already running on screen %d"),
106 xerror_set_ignore(TRUE
);
107 xerror_occured
= FALSE
;
109 /* We want to find out when the current selection owner dies */
110 XSelectInput(ob_display
, current_wm_sn_owner
, StructureNotifyMask
);
111 XSync(ob_display
, FALSE
);
113 xerror_set_ignore(FALSE
);
115 current_wm_sn_owner
= None
;
118 timestamp
= event_get_server_time();
120 XSetSelectionOwner(ob_display
, wm_sn_atom
, screen_support_win
,
123 if (XGetSelectionOwner(ob_display
, wm_sn_atom
) != screen_support_win
) {
124 g_message(_("Could not acquire window manager selection on screen %d"),
129 /* Wait for old window manager to go away */
130 if (current_wm_sn_owner
) {
133 const gulong timeout
= G_USEC_PER_SEC
* 15; /* wait for 15s max */
135 while (wait
< timeout
) {
136 if (XCheckWindowEvent(ob_display
, current_wm_sn_owner
,
137 StructureNotifyMask
, &event
) &&
138 event
.type
== DestroyNotify
)
140 g_usleep(G_USEC_PER_SEC
/ 10);
141 wait
+= G_USEC_PER_SEC
/ 10;
144 if (wait
>= timeout
) {
145 g_message(_("The WM on screen %d is not exiting"), ob_screen
);
150 /* Send client message indicating that we are now the WM */
151 prop_message(RootWindow(ob_display
, ob_screen
), prop_atoms
.manager
,
152 timestamp
, wm_sn_atom
, screen_support_win
, 0,
153 SubstructureNotifyMask
);
158 gboolean
screen_annex(void)
160 XSetWindowAttributes attrib
;
163 Atom
*prop_atoms_start
, *wm_supported_pos
;
166 /* create the netwm support window */
167 attrib
.override_redirect
= TRUE
;
168 attrib
.event_mask
= PropertyChangeMask
;
169 screen_support_win
= XCreateWindow(ob_display
,
170 RootWindow(ob_display
, ob_screen
),
172 CopyFromParent
, InputOutput
,
174 CWEventMask
| CWOverrideRedirect
,
176 XMapWindow(ob_display
, screen_support_win
);
177 XLowerWindow(ob_display
, screen_support_win
);
180 XDestroyWindow(ob_display
, screen_support_win
);
184 xerror_set_ignore(TRUE
);
185 xerror_occured
= FALSE
;
186 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
188 xerror_set_ignore(FALSE
);
189 if (xerror_occured
) {
190 g_message(_("A window manager is already running on screen %d"),
193 XDestroyWindow(ob_display
, screen_support_win
);
197 screen_set_root_cursor();
199 /* set the OPENBOX_PID hint */
201 PROP_SET32(RootWindow(ob_display
, ob_screen
),
202 openbox_pid
, cardinal
, pid
);
204 /* set supporting window */
205 PROP_SET32(RootWindow(ob_display
, ob_screen
),
206 net_supporting_wm_check
, window
, screen_support_win
);
208 /* set properties on the supporting window */
209 PROP_SETS(screen_support_win
, net_wm_name
, "Openbox");
210 PROP_SET32(screen_support_win
, net_supporting_wm_check
,
211 window
, screen_support_win
);
213 /* set the _NET_SUPPORTED_ATOMS hint */
215 /* this is all the atoms after net_supported in the prop_atoms struct */
216 prop_atoms_start
= (Atom
*)&prop_atoms
;
217 wm_supported_pos
= (Atom
*)&(prop_atoms
.net_supported
);
218 num_support
= sizeof(prop_atoms
) / sizeof(Atom
) -
219 (wm_supported_pos
- prop_atoms_start
) - 1;
221 supported
= g_new(gulong
, num_support
);
222 supported
[i
++] = prop_atoms
.net_supporting_wm_check
;
223 supported
[i
++] = prop_atoms
.net_wm_full_placement
;
224 supported
[i
++] = prop_atoms
.net_current_desktop
;
225 supported
[i
++] = prop_atoms
.net_number_of_desktops
;
226 supported
[i
++] = prop_atoms
.net_desktop_geometry
;
227 supported
[i
++] = prop_atoms
.net_desktop_viewport
;
228 supported
[i
++] = prop_atoms
.net_active_window
;
229 supported
[i
++] = prop_atoms
.net_workarea
;
230 supported
[i
++] = prop_atoms
.net_client_list
;
231 supported
[i
++] = prop_atoms
.net_client_list_stacking
;
232 supported
[i
++] = prop_atoms
.net_desktop_names
;
233 supported
[i
++] = prop_atoms
.net_close_window
;
234 supported
[i
++] = prop_atoms
.net_desktop_layout
;
235 supported
[i
++] = prop_atoms
.net_showing_desktop
;
236 supported
[i
++] = prop_atoms
.net_wm_name
;
237 supported
[i
++] = prop_atoms
.net_wm_visible_name
;
238 supported
[i
++] = prop_atoms
.net_wm_icon_name
;
239 supported
[i
++] = prop_atoms
.net_wm_visible_icon_name
;
240 supported
[i
++] = prop_atoms
.net_wm_desktop
;
241 supported
[i
++] = prop_atoms
.net_wm_strut
;
242 supported
[i
++] = prop_atoms
.net_wm_strut_partial
;
243 supported
[i
++] = prop_atoms
.net_wm_icon
;
244 supported
[i
++] = prop_atoms
.net_wm_icon_geometry
;
245 supported
[i
++] = prop_atoms
.net_wm_window_type
;
246 supported
[i
++] = prop_atoms
.net_wm_window_type_desktop
;
247 supported
[i
++] = prop_atoms
.net_wm_window_type_dock
;
248 supported
[i
++] = prop_atoms
.net_wm_window_type_toolbar
;
249 supported
[i
++] = prop_atoms
.net_wm_window_type_menu
;
250 supported
[i
++] = prop_atoms
.net_wm_window_type_utility
;
251 supported
[i
++] = prop_atoms
.net_wm_window_type_splash
;
252 supported
[i
++] = prop_atoms
.net_wm_window_type_dialog
;
253 supported
[i
++] = prop_atoms
.net_wm_window_type_normal
;
254 supported
[i
++] = prop_atoms
.net_wm_allowed_actions
;
255 supported
[i
++] = prop_atoms
.net_wm_action_move
;
256 supported
[i
++] = prop_atoms
.net_wm_action_resize
;
257 supported
[i
++] = prop_atoms
.net_wm_action_minimize
;
258 supported
[i
++] = prop_atoms
.net_wm_action_shade
;
259 supported
[i
++] = prop_atoms
.net_wm_action_maximize_horz
;
260 supported
[i
++] = prop_atoms
.net_wm_action_maximize_vert
;
261 supported
[i
++] = prop_atoms
.net_wm_action_fullscreen
;
262 supported
[i
++] = prop_atoms
.net_wm_action_change_desktop
;
263 supported
[i
++] = prop_atoms
.net_wm_action_close
;
264 supported
[i
++] = prop_atoms
.net_wm_action_above
;
265 supported
[i
++] = prop_atoms
.net_wm_action_below
;
266 supported
[i
++] = prop_atoms
.net_wm_state
;
267 supported
[i
++] = prop_atoms
.net_wm_state_modal
;
268 supported
[i
++] = prop_atoms
.net_wm_state_maximized_vert
;
269 supported
[i
++] = prop_atoms
.net_wm_state_maximized_horz
;
270 supported
[i
++] = prop_atoms
.net_wm_state_shaded
;
271 supported
[i
++] = prop_atoms
.net_wm_state_skip_taskbar
;
272 supported
[i
++] = prop_atoms
.net_wm_state_skip_pager
;
273 supported
[i
++] = prop_atoms
.net_wm_state_hidden
;
274 supported
[i
++] = prop_atoms
.net_wm_state_fullscreen
;
275 supported
[i
++] = prop_atoms
.net_wm_state_above
;
276 supported
[i
++] = prop_atoms
.net_wm_state_below
;
277 supported
[i
++] = prop_atoms
.net_wm_state_demands_attention
;
278 supported
[i
++] = prop_atoms
.net_moveresize_window
;
279 supported
[i
++] = prop_atoms
.net_wm_moveresize
;
280 supported
[i
++] = prop_atoms
.net_wm_user_time
;
282 supported[i++] = prop_atoms.net_wm_user_time_window;
284 supported
[i
++] = prop_atoms
.net_frame_extents
;
285 supported
[i
++] = prop_atoms
.net_request_frame_extents
;
286 supported
[i
++] = prop_atoms
.net_restack_window
;
287 supported
[i
++] = prop_atoms
.net_startup_id
;
289 supported
[i
++] = prop_atoms
.net_wm_sync_request
;
290 supported
[i
++] = prop_atoms
.net_wm_sync_request_counter
;
292 supported
[i
++] = prop_atoms
.net_wm_pid
;
293 supported
[i
++] = prop_atoms
.net_wm_ping
;
295 supported
[i
++] = prop_atoms
.kde_wm_change_state
;
296 supported
[i
++] = prop_atoms
.kde_net_wm_frame_strut
;
297 supported
[i
++] = prop_atoms
.kde_net_wm_window_type_override
;
299 supported
[i
++] = prop_atoms
.ob_wm_action_undecorate
;
300 supported
[i
++] = prop_atoms
.ob_wm_state_undecorated
;
301 supported
[i
++] = prop_atoms
.openbox_pid
;
302 supported
[i
++] = prop_atoms
.ob_theme
;
303 supported
[i
++] = prop_atoms
.ob_config_file
;
304 supported
[i
++] = prop_atoms
.ob_control
;
305 g_assert(i
== num_support
);
307 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
308 net_supported
, atom
, supported
, num_support
);
311 screen_tell_ksplash();
316 static void screen_tell_ksplash(void)
321 argv
= g_new(gchar
*, 6);
322 argv
[0] = g_strdup("dcop");
323 argv
[1] = g_strdup("ksplash");
324 argv
[2] = g_strdup("ksplash");
325 argv
[3] = g_strdup("upAndRunning(QString)");
326 argv
[4] = g_strdup("wm started");
329 /* tell ksplash through the dcop server command line interface */
330 g_spawn_async(NULL
, argv
, NULL
,
331 G_SPAWN_SEARCH_PATH
| G_SPAWN_DO_NOT_REAP_CHILD
|
332 G_SPAWN_STDERR_TO_DEV_NULL
| G_SPAWN_STDOUT_TO_DEV_NULL
,
333 NULL
, NULL
, NULL
, NULL
);
336 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
337 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
338 something. oh well. */
339 e
.xclient
.type
= ClientMessage
;
340 e
.xclient
.display
= ob_display
;
341 e
.xclient
.window
= RootWindow(ob_display
, ob_screen
);
342 e
.xclient
.message_type
=
343 XInternAtom(ob_display
, "_KDE_SPLASH_PROGRESS", False
);
344 e
.xclient
.format
= 8;
345 strcpy(e
.xclient
.data
.b
, "wm started");
346 XSendEvent(ob_display
, RootWindow(ob_display
, ob_screen
),
347 False
, SubstructureNotifyMask
, &e
);
350 void screen_startup(gboolean reconfig
)
352 gchar
**names
= NULL
;
354 gboolean namesexist
= FALSE
;
356 desktop_popup
= pager_popup_new();
357 pager_popup_height(desktop_popup
, POPUP_HEIGHT
);
360 /* update the pager popup's width */
361 pager_popup_text_width_to_strings(desktop_popup
,
362 screen_desktop_names
,
363 screen_num_desktops
);
367 /* get the initial size */
370 /* have names already been set for the desktops? */
371 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
372 net_desktop_names
, utf8
, &names
))
378 /* if names don't exist and we have session names, set those.
379 do this stuff BEFORE setting the number of desktops, because that
380 will create default names for them
382 if (!namesexist
&& session_desktop_names
!= NULL
) {
386 /* get the desktop names */
387 numnames
= g_slist_length(session_desktop_names
);
388 names
= g_new(gchar
*, numnames
+ 1);
389 names
[numnames
] = NULL
;
390 for (i
= 0, it
= session_desktop_names
; it
; ++i
, it
= g_slist_next(it
))
391 names
[i
] = g_strdup(it
->data
);
393 /* set the root window property */
394 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,names
);
399 /* set the number of desktops, if it's not already set.
401 this will also set the default names from the config file up for
402 desktops that don't have names yet */
403 screen_num_desktops
= 0;
404 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
405 net_number_of_desktops
, cardinal
, &d
))
407 if (d
!= config_desktops_num
) {
408 /* TRANSLATORS: If you need to specify a different order of the
409 arguments, you can use %1$d for the first one and %2$d for the
410 second one. For example,
411 "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
412 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
),
413 config_desktops_num
, d
);
415 screen_set_num_desktops(d
);
417 /* restore from session if possible */
418 else if (session_num_desktops
)
419 screen_set_num_desktops(session_num_desktops
);
421 screen_set_num_desktops(config_desktops_num
);
423 screen_desktop
= screen_num_desktops
; /* something invalid */
424 /* start on the current desktop when a wm was already running */
425 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
426 net_current_desktop
, cardinal
, &d
) &&
427 d
< screen_num_desktops
)
429 screen_set_desktop(d
, FALSE
);
430 } else if (session_desktop
>= 0)
431 screen_set_desktop(MIN((guint
)session_desktop
,
432 screen_num_desktops
), FALSE
);
434 screen_set_desktop(MIN(config_screen_firstdesk
,
435 screen_num_desktops
) - 1, FALSE
);
436 screen_last_desktop
= screen_desktop
;
438 /* don't start in showing-desktop mode */
439 screen_showing_desktop
= FALSE
;
440 PROP_SET32(RootWindow(ob_display
, ob_screen
),
441 net_showing_desktop
, cardinal
, screen_showing_desktop
);
443 if (session_desktop_layout_present
&&
444 screen_validate_layout(&session_desktop_layout
))
446 screen_desktop_layout
= session_desktop_layout
;
449 screen_update_layout();
452 void screen_shutdown(gboolean reconfig
)
454 pager_popup_free(desktop_popup
);
459 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
462 /* we're not running here no more! */
463 PROP_ERASE(RootWindow(ob_display
, ob_screen
), openbox_pid
);
465 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_supported
);
466 /* don't keep this mode */
467 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_showing_desktop
);
469 XDestroyWindow(ob_display
, screen_support_win
);
471 g_strfreev(screen_desktop_names
);
472 screen_desktop_names
= NULL
;
475 void screen_resize(void)
477 static gint oldw
= 0, oldh
= 0;
482 w
= WidthOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
483 h
= HeightOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
485 if (w
== oldw
&& h
== oldh
) return;
489 /* Set the _NET_DESKTOP_GEOMETRY hint */
490 screen_physical_size
.width
= geometry
[0] = w
;
491 screen_physical_size
.height
= geometry
[1] = h
;
492 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
493 net_desktop_geometry
, cardinal
, geometry
, 2);
495 if (ob_state() != OB_STATE_RUNNING
)
498 screen_update_areas();
501 for (it
= client_list
; it
; it
= g_list_next(it
))
502 client_move_onscreen(it
->data
, FALSE
);
505 void screen_set_num_desktops(guint num
)
509 GList
*it
, *stacking_copy
;
513 if (screen_num_desktops
== num
) return;
515 old
= screen_num_desktops
;
516 screen_num_desktops
= num
;
517 PROP_SET32(RootWindow(ob_display
, ob_screen
),
518 net_number_of_desktops
, cardinal
, num
);
520 /* set the viewport hint */
521 viewport
= g_new0(gulong
, num
* 2);
522 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
523 net_desktop_viewport
, cardinal
, viewport
, num
* 2);
526 /* the number of rows/columns will differ */
527 screen_update_layout();
529 /* move windows on desktops that will no longer exist!
530 make a copy of the list cuz we're changing it */
531 stacking_copy
= g_list_copy(stacking_list
);
532 for (it
= g_list_last(stacking_copy
); it
; it
= g_list_previous(it
)) {
533 if (WINDOW_IS_CLIENT(it
->data
)) {
534 ObClient
*c
= it
->data
;
535 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
>= num
)
536 client_set_desktop(c
, num
- 1, FALSE
, TRUE
);
537 /* raise all the windows that are on the current desktop which
539 else if (screen_desktop
== num
- 1 &&
540 (c
->desktop
== DESKTOP_ALL
||
541 c
->desktop
== screen_desktop
))
542 stacking_raise(CLIENT_AS_WINDOW(c
));
545 g_list_free(stacking_copy
);
547 /* change our struts/area to match (after moving windows) */
548 screen_update_areas();
550 /* may be some unnamed desktops that we need to fill in with names
551 (after updating the areas so the popup can resize) */
552 screen_update_desktop_names();
554 /* change our desktop if we're on one that no longer exists! */
555 if (screen_desktop
>= screen_num_desktops
)
556 screen_set_desktop(num
- 1, TRUE
);
559 static void screen_fallback_focus(void)
564 /* only allow omnipresent windows to get focus on desktop change if
565 an omnipresent window is already focused (it'll keep focus probably, but
566 maybe not depending on mouse-focus options) */
567 allow_omni
= focus_client
&& (client_normal(focus_client
) &&
568 focus_client
->desktop
== DESKTOP_ALL
);
570 /* the client moved there already so don't move focus. prevent flicker
571 on sendtodesktop + follow */
572 if (focus_client
&& focus_client
->desktop
== screen_desktop
)
575 /* have to try focus here because when you leave an empty desktop
576 there is no focus out to watch for. also, we have different rules
577 here. we always allow it to look under the mouse pointer if
578 config_focus_last is FALSE
580 do this before hiding the windows so if helper windows are coming
581 with us, they don't get hidden
583 if ((c
= focus_fallback(TRUE
, !config_focus_last
, allow_omni
,
586 /* only do the flicker reducing stuff ahead of time if we are going
587 to call xsetinputfocus on the window ourselves. otherwise there is
588 no guarantee the window will actually take focus.. */
590 /* reduce flicker by hiliting now rather than waiting for the
591 server FocusIn event */
592 frame_adjust_focus(c
->frame
, TRUE
);
593 /* do this here so that if you switch desktops to a window with
594 helper windows then the helper windows won't flash */
595 client_bring_helper_windows(c
);
600 static gboolean
last_desktop_func(gpointer data
)
602 screen_desktop_timeout
= TRUE
;
606 void screen_set_desktop(guint num
, gboolean dofocus
)
612 g_assert(num
< screen_num_desktops
);
614 previous
= screen_desktop
;
615 screen_desktop
= num
;
617 if (previous
== num
) return;
619 PROP_SET32(RootWindow(ob_display
, ob_screen
),
620 net_current_desktop
, cardinal
, num
);
622 /* This whole thing decides when/how to save the screen_last_desktop so
623 that it can be restored later if you want */
624 if (screen_desktop_timeout
) {
625 /* If screen_desktop_timeout is true, then we've been on this desktop
626 long enough and we can save it as the last desktop. */
628 if (screen_last_desktop
== previous
)
629 /* this is the startup state only */
630 screen_old_desktop
= screen_desktop
;
632 /* save the "last desktop" as the "old desktop" */
633 screen_old_desktop
= screen_last_desktop
;
634 /* save the desktop we're coming from as the "last desktop" */
635 screen_last_desktop
= previous
;
639 /* If screen_desktop_timeout is false, then we just got to this desktop
640 and we are moving away again. */
642 if (screen_desktop
== screen_last_desktop
) {
643 /* If we are moving to the "last desktop" .. */
644 if (previous
== screen_old_desktop
) {
645 /* .. from the "old desktop", change the last desktop to
646 be where we are coming from */
647 screen_last_desktop
= screen_old_desktop
;
649 else if (screen_last_desktop
== screen_old_desktop
) {
650 /* .. and also to the "old desktop", change the "last
651 desktop" to be where we are coming from */
652 screen_last_desktop
= previous
;
655 /* .. from some other desktop, then set the "last desktop" to
656 be the saved "old desktop", i.e. where we were before the
658 screen_last_desktop
= screen_old_desktop
;
662 /* If we are moving to any desktop besides the "last desktop"..
663 (this is the normal case) */
664 if (screen_desktop
== screen_old_desktop
) {
665 /* If moving to the "old desktop", which is not the
666 "last desktop", don't save anything */
668 else if (previous
== screen_old_desktop
) {
669 /* If moving from the "old desktop", and not to the
670 "last desktop", don't save anything */
672 else if (screen_last_desktop
== screen_old_desktop
) {
673 /* If the "last desktop" is the same as "old desktop" and
674 you're not moving to the "last desktop" then save where
675 we're coming from as the "last desktop" */
676 screen_last_desktop
= previous
;
679 /* If the "last desktop" is different from the "old desktop"
680 and you're not moving to the "last desktop", then don't save
685 screen_desktop_timeout
= FALSE
;
686 ob_main_loop_timeout_remove(ob_main_loop
, last_desktop_func
);
687 ob_main_loop_timeout_add(ob_main_loop
, REMEMBER_LAST_DESKTOP_TIME
,
688 last_desktop_func
, NULL
, NULL
, NULL
);
690 ob_debug("Moving to desktop %d\n", num
+1);
692 if (ob_state() == OB_STATE_RUNNING
)
693 screen_show_desktop_popup(screen_desktop
);
695 /* ignore enter events caused by the move */
696 ignore_start
= event_start_ignore_all_enters();
698 if (moveresize_client
)
699 client_set_desktop(moveresize_client
, num
, TRUE
, FALSE
);
701 /* show windows before hiding the rest to lessen the enter/leave events */
703 /* show windows from top to bottom */
704 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
705 if (WINDOW_IS_CLIENT(it
->data
)) {
706 ObClient
*c
= it
->data
;
711 if (dofocus
) screen_fallback_focus();
713 /* hide windows from bottom to top */
714 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
715 if (WINDOW_IS_CLIENT(it
->data
)) {
716 ObClient
*c
= it
->data
;
718 if (c
== focus_client
) {
719 /* c was focused and we didn't do fallback clearly so make sure
720 openbox doesnt still consider the window focused.
721 this happens when using NextWindow with allDesktops, since
722 it doesnt want to move focus on desktop change, but the
723 focus is not going to stay with the current window, which
724 has now disappeared */
725 focus_set_client(NULL
);
730 event_end_ignore_all_enters(ignore_start
);
732 if (event_curtime
!= CurrentTime
)
733 screen_desktop_user_time
= event_curtime
;
736 void screen_add_desktop(gboolean current
)
740 /* ignore enter events caused by this */
741 ignore_start
= event_start_ignore_all_enters();
743 screen_set_num_desktops(screen_num_desktops
+1);
745 /* move all the clients over */
749 for (it
= client_list
; it
; it
= g_list_next(it
)) {
750 ObClient
*c
= it
->data
;
751 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
>= screen_desktop
&&
752 /* don't move direct children, they'll be moved with their
753 parent - which will have to be on the same desktop */
754 !client_direct_parent(c
))
756 ob_debug("moving window %s\n", c
->title
);
757 client_set_desktop(c
, c
->desktop
+1, FALSE
, TRUE
);
762 event_end_ignore_all_enters(ignore_start
);
765 void screen_remove_desktop(gboolean current
)
767 guint rmdesktop
, movedesktop
;
768 GList
*it
, *stacking_copy
;
771 if (screen_num_desktops
<= 1) return;
773 /* ignore enter events caused by this */
774 ignore_start
= event_start_ignore_all_enters();
776 /* what desktop are we removing and moving to? */
778 rmdesktop
= screen_desktop
;
780 rmdesktop
= screen_num_desktops
- 1;
781 if (rmdesktop
< screen_num_desktops
- 1)
782 movedesktop
= rmdesktop
+ 1;
784 movedesktop
= rmdesktop
;
786 /* make a copy of the list cuz we're changing it */
787 stacking_copy
= g_list_copy(stacking_list
);
788 for (it
= g_list_last(stacking_copy
); it
; it
= g_list_previous(it
)) {
789 if (WINDOW_IS_CLIENT(it
->data
)) {
790 ObClient
*c
= it
->data
;
791 guint d
= c
->desktop
;
792 if (d
!= DESKTOP_ALL
&& d
>= movedesktop
&&
793 /* don't move direct children, they'll be moved with their
794 parent - which will have to be on the same desktop */
795 !client_direct_parent(c
))
797 ob_debug("moving window %s\n", c
->title
);
798 client_set_desktop(c
, c
->desktop
- 1, TRUE
, TRUE
);
800 /* raise all the windows that are on the current desktop which
802 if ((screen_desktop
== rmdesktop
- 1 ||
803 screen_desktop
== rmdesktop
) &&
804 (d
== DESKTOP_ALL
|| d
== screen_desktop
))
806 stacking_raise(CLIENT_AS_WINDOW(c
));
807 ob_debug("raising window %s\n", c
->title
);
811 g_list_free(stacking_copy
);
813 /* fallback focus like we're changing desktops */
814 if (screen_desktop
< screen_num_desktops
- 1) {
815 screen_fallback_focus();
816 ob_debug("fake desktop change\n");
819 screen_set_num_desktops(screen_num_desktops
-1);
821 event_end_ignore_all_enters(ignore_start
);
824 static void get_row_col(guint d
, guint
*r
, guint
*c
)
826 switch (screen_desktop_layout
.orientation
) {
827 case OB_ORIENTATION_HORZ
:
828 switch (screen_desktop_layout
.start_corner
) {
829 case OB_CORNER_TOPLEFT
:
830 *r
= d
/ screen_desktop_layout
.columns
;
831 *c
= d
% screen_desktop_layout
.columns
;
833 case OB_CORNER_BOTTOMLEFT
:
834 *r
= screen_desktop_layout
.rows
- 1 -
835 d
/ screen_desktop_layout
.columns
;
836 *c
= d
% screen_desktop_layout
.columns
;
838 case OB_CORNER_TOPRIGHT
:
839 *r
= d
/ screen_desktop_layout
.columns
;
840 *c
= screen_desktop_layout
.columns
- 1 -
841 d
% screen_desktop_layout
.columns
;
843 case OB_CORNER_BOTTOMRIGHT
:
844 *r
= screen_desktop_layout
.rows
- 1 -
845 d
/ screen_desktop_layout
.columns
;
846 *c
= screen_desktop_layout
.columns
- 1 -
847 d
% screen_desktop_layout
.columns
;
851 case OB_ORIENTATION_VERT
:
852 switch (screen_desktop_layout
.start_corner
) {
853 case OB_CORNER_TOPLEFT
:
854 *r
= d
% screen_desktop_layout
.rows
;
855 *c
= d
/ screen_desktop_layout
.rows
;
857 case OB_CORNER_BOTTOMLEFT
:
858 *r
= screen_desktop_layout
.rows
- 1 -
859 d
% screen_desktop_layout
.rows
;
860 *c
= d
/ screen_desktop_layout
.rows
;
862 case OB_CORNER_TOPRIGHT
:
863 *r
= d
% screen_desktop_layout
.rows
;
864 *c
= screen_desktop_layout
.columns
- 1 -
865 d
/ screen_desktop_layout
.rows
;
867 case OB_CORNER_BOTTOMRIGHT
:
868 *r
= screen_desktop_layout
.rows
- 1 -
869 d
% screen_desktop_layout
.rows
;
870 *c
= screen_desktop_layout
.columns
- 1 -
871 d
/ screen_desktop_layout
.rows
;
878 static guint
translate_row_col(guint r
, guint c
)
880 switch (screen_desktop_layout
.orientation
) {
881 case OB_ORIENTATION_HORZ
:
882 switch (screen_desktop_layout
.start_corner
) {
883 case OB_CORNER_TOPLEFT
:
884 return r
% screen_desktop_layout
.rows
*
885 screen_desktop_layout
.columns
+
886 c
% screen_desktop_layout
.columns
;
887 case OB_CORNER_BOTTOMLEFT
:
888 return (screen_desktop_layout
.rows
- 1 -
889 r
% screen_desktop_layout
.rows
) *
890 screen_desktop_layout
.columns
+
891 c
% screen_desktop_layout
.columns
;
892 case OB_CORNER_TOPRIGHT
:
893 return r
% screen_desktop_layout
.rows
*
894 screen_desktop_layout
.columns
+
895 (screen_desktop_layout
.columns
- 1 -
896 c
% screen_desktop_layout
.columns
);
897 case OB_CORNER_BOTTOMRIGHT
:
898 return (screen_desktop_layout
.rows
- 1 -
899 r
% screen_desktop_layout
.rows
) *
900 screen_desktop_layout
.columns
+
901 (screen_desktop_layout
.columns
- 1 -
902 c
% screen_desktop_layout
.columns
);
904 case OB_ORIENTATION_VERT
:
905 switch (screen_desktop_layout
.start_corner
) {
906 case OB_CORNER_TOPLEFT
:
907 return c
% screen_desktop_layout
.columns
*
908 screen_desktop_layout
.rows
+
909 r
% screen_desktop_layout
.rows
;
910 case OB_CORNER_BOTTOMLEFT
:
911 return c
% screen_desktop_layout
.columns
*
912 screen_desktop_layout
.rows
+
913 (screen_desktop_layout
.rows
- 1 -
914 r
% screen_desktop_layout
.rows
);
915 case OB_CORNER_TOPRIGHT
:
916 return (screen_desktop_layout
.columns
- 1 -
917 c
% screen_desktop_layout
.columns
) *
918 screen_desktop_layout
.rows
+
919 r
% screen_desktop_layout
.rows
;
920 case OB_CORNER_BOTTOMRIGHT
:
921 return (screen_desktop_layout
.columns
- 1 -
922 c
% screen_desktop_layout
.columns
) *
923 screen_desktop_layout
.rows
+
924 (screen_desktop_layout
.rows
- 1 -
925 r
% screen_desktop_layout
.rows
);
928 g_assert_not_reached();
932 static gboolean
hide_desktop_popup_func(gpointer data
)
934 pager_popup_hide(desktop_popup
);
935 return FALSE
; /* don't repeat */
938 void screen_show_desktop_popup(guint d
)
942 /* 0 means don't show the popup */
943 if (!config_desktop_popup_time
) return;
945 a
= screen_physical_area_primary();
946 pager_popup_position(desktop_popup
, CenterGravity
,
947 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
948 pager_popup_icon_size_multiplier(desktop_popup
,
949 (screen_desktop_layout
.columns
/
950 screen_desktop_layout
.rows
) / 2,
951 (screen_desktop_layout
.rows
/
952 screen_desktop_layout
.columns
) / 2);
953 pager_popup_max_width(desktop_popup
,
954 MAX(a
->width
/3, POPUP_WIDTH
));
955 pager_popup_show(desktop_popup
, screen_desktop_names
[d
], d
);
957 ob_main_loop_timeout_remove(ob_main_loop
, hide_desktop_popup_func
);
958 ob_main_loop_timeout_add(ob_main_loop
, config_desktop_popup_time
* 1000,
959 hide_desktop_popup_func
, NULL
, NULL
, NULL
);
963 void screen_hide_desktop_popup(void)
965 ob_main_loop_timeout_remove(ob_main_loop
, hide_desktop_popup_func
);
966 pager_popup_hide(desktop_popup
);
969 guint
screen_find_desktop(guint from
, ObDirection dir
,
970 gboolean wrap
, gboolean linear
)
976 get_row_col(d
, &r
, &c
);
979 case OB_DIRECTION_EAST
:
980 if (d
< screen_num_desktops
- 1)
987 case OB_DIRECTION_WEST
:
991 d
= screen_num_desktops
- 1;
996 g_assert_not_reached();
1001 case OB_DIRECTION_EAST
:
1003 if (c
>= screen_desktop_layout
.columns
) {
1009 d
= translate_row_col(r
, c
);
1010 if (d
>= screen_num_desktops
) {
1017 case OB_DIRECTION_WEST
:
1019 if (c
>= screen_desktop_layout
.columns
) {
1021 c
= screen_desktop_layout
.columns
- 1;
1025 d
= translate_row_col(r
, c
);
1026 if (d
>= screen_num_desktops
) {
1033 case OB_DIRECTION_SOUTH
:
1035 if (r
>= screen_desktop_layout
.rows
) {
1041 d
= translate_row_col(r
, c
);
1042 if (d
>= screen_num_desktops
) {
1049 case OB_DIRECTION_NORTH
:
1051 if (r
>= screen_desktop_layout
.rows
) {
1053 r
= screen_desktop_layout
.rows
- 1;
1057 d
= translate_row_col(r
, c
);
1058 if (d
>= screen_num_desktops
) {
1066 g_assert_not_reached();
1070 d
= translate_row_col(r
, c
);
1075 static gboolean
screen_validate_layout(ObDesktopLayout
*l
)
1077 if (l
->columns
== 0 && l
->rows
== 0) /* both 0's is bad data.. */
1080 /* fill in a zero rows/columns */
1081 if (l
->columns
== 0) {
1082 l
->columns
= screen_num_desktops
/ l
->rows
;
1083 if (l
->rows
* l
->columns
< screen_num_desktops
)
1085 if (l
->rows
* l
->columns
>= screen_num_desktops
+ l
->columns
)
1087 } else if (l
->rows
== 0) {
1088 l
->rows
= screen_num_desktops
/ l
->columns
;
1089 if (l
->columns
* l
->rows
< screen_num_desktops
)
1091 if (l
->columns
* l
->rows
>= screen_num_desktops
+ l
->rows
)
1095 /* bounds checking */
1096 if (l
->orientation
== OB_ORIENTATION_HORZ
) {
1097 l
->columns
= MIN(screen_num_desktops
, l
->columns
);
1098 l
->rows
= MIN(l
->rows
,
1099 (screen_num_desktops
+ l
->columns
- 1) / l
->columns
);
1100 l
->columns
= screen_num_desktops
/ l
->rows
+
1101 !!(screen_num_desktops
% l
->rows
);
1103 l
->rows
= MIN(screen_num_desktops
, l
->rows
);
1104 l
->columns
= MIN(l
->columns
,
1105 (screen_num_desktops
+ l
->rows
- 1) / l
->rows
);
1106 l
->rows
= screen_num_desktops
/ l
->columns
+
1107 !!(screen_num_desktops
% l
->columns
);
1112 void screen_update_layout(void)
1119 screen_desktop_layout
.orientation
= OB_ORIENTATION_HORZ
;
1120 screen_desktop_layout
.start_corner
= OB_CORNER_TOPLEFT
;
1121 screen_desktop_layout
.rows
= 1;
1122 screen_desktop_layout
.columns
= screen_num_desktops
;
1124 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
1125 net_desktop_layout
, cardinal
, &data
, &num
)) {
1126 if (num
== 3 || num
== 4) {
1128 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
1129 l
.orientation
= OB_ORIENTATION_VERT
;
1130 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
1131 l
.orientation
= OB_ORIENTATION_HORZ
;
1136 l
.start_corner
= OB_CORNER_TOPLEFT
;
1138 if (data
[3] == prop_atoms
.net_wm_topleft
)
1139 l
.start_corner
= OB_CORNER_TOPLEFT
;
1140 else if (data
[3] == prop_atoms
.net_wm_topright
)
1141 l
.start_corner
= OB_CORNER_TOPRIGHT
;
1142 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
1143 l
.start_corner
= OB_CORNER_BOTTOMRIGHT
;
1144 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
1145 l
.start_corner
= OB_CORNER_BOTTOMLEFT
;
1150 l
.columns
= data
[1];
1153 if (screen_validate_layout(&l
))
1154 screen_desktop_layout
= l
;
1161 void screen_update_desktop_names(void)
1165 /* empty the array */
1166 g_strfreev(screen_desktop_names
);
1167 screen_desktop_names
= NULL
;
1169 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
1170 net_desktop_names
, utf8
, &screen_desktop_names
))
1171 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
1174 if (i
< screen_num_desktops
) {
1177 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
1178 screen_num_desktops
+ 1);
1179 screen_desktop_names
[screen_num_desktops
] = NULL
;
1181 it
= g_slist_nth(config_desktops_names
, i
);
1183 for (; i
< screen_num_desktops
; ++i
) {
1184 if (it
&& ((char*)it
->data
)[0]) /* not empty */
1185 /* use the names from the config file when possible */
1186 screen_desktop_names
[i
] = g_strdup(it
->data
);
1188 /* make up a nice name if it's not though */
1189 screen_desktop_names
[i
] = g_strdup_printf(_("desktop %i"),
1191 if (it
) it
= g_slist_next(it
);
1194 /* if we changed any names, then set the root property so we can
1195 all agree on the names */
1196 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,
1197 screen_desktop_names
);
1200 /* resize the pager for these names */
1201 pager_popup_text_width_to_strings(desktop_popup
,
1202 screen_desktop_names
,
1203 screen_num_desktops
);
1206 void screen_show_desktop(gboolean show
, ObClient
*show_only
)
1210 if (show
== screen_showing_desktop
) return; /* no change */
1212 screen_showing_desktop
= show
;
1215 /* hide windows bottom to top */
1216 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
1217 if (WINDOW_IS_CLIENT(it
->data
)) {
1218 ObClient
*client
= it
->data
;
1219 client_showhide(client
);
1224 /* restore windows top to bottom */
1225 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
1226 if (WINDOW_IS_CLIENT(it
->data
)) {
1227 ObClient
*client
= it
->data
;
1228 if (client_should_show(client
)) {
1229 if (!show_only
|| client
== show_only
)
1230 client_show(client
);
1232 client_iconify(client
, TRUE
, FALSE
, TRUE
);
1239 /* focus the desktop */
1240 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
1241 ObClient
*c
= it
->data
;
1242 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
1243 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
1244 client_focus(it
->data
))
1248 else if (!show_only
) {
1251 if ((c
= focus_fallback(TRUE
, FALSE
, TRUE
, FALSE
))) {
1252 /* only do the flicker reducing stuff ahead of time if we are going
1253 to call xsetinputfocus on the window ourselves. otherwise there
1254 is no guarantee the window will actually take focus.. */
1256 /* reduce flicker by hiliting now rather than waiting for the
1257 server FocusIn event */
1258 frame_adjust_focus(c
->frame
, TRUE
);
1263 show
= !!show
; /* make it boolean */
1264 PROP_SET32(RootWindow(ob_display
, ob_screen
),
1265 net_showing_desktop
, cardinal
, show
);
1268 void screen_install_colormap(ObClient
*client
, gboolean install
)
1270 if (client
== NULL
|| client
->colormap
== None
) {
1272 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1274 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1276 xerror_set_ignore(TRUE
);
1278 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1280 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1281 xerror_set_ignore(FALSE
);
1285 #define STRUT_LEFT_ON_MONITOR(s, i) \
1286 (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
1287 monitor_area[i].y, monitor_area[i].height))
1288 #define STRUT_RIGHT_ON_MONITOR(s, i) \
1289 (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
1290 monitor_area[i].y, monitor_area[i].height))
1291 #define STRUT_TOP_ON_MONITOR(s, i) \
1292 (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
1293 monitor_area[i].x, monitor_area[i].width))
1294 #define STRUT_BOTTOM_ON_MONITOR(s, i) \
1295 (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
1296 monitor_area[i].x, monitor_area[i].width))
1300 StrutPartial
*strut
;
1303 #define RESET_STRUT_LIST(sl) \
1304 (g_slist_free(sl), sl = NULL)
1306 #define ADD_STRUT_TO_LIST(sl, d, s) \
1308 ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1311 sl = g_slist_prepend(sl, ss); \
1314 #define VALIDATE_STRUTS(sl, side, max) \
1317 for (it = sl; it; it = g_slist_next(it)) { \
1318 ObScreenStrut *ss = it->data; \
1319 ss->strut->side = MIN(max, ss->strut->side); \
1323 void screen_update_areas(void)
1330 g_free(monitor_area
);
1331 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1333 /* set up the user-specified margins */
1334 config_margins
.top_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1335 config_margins
.top_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1336 config_margins
.bottom_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1337 config_margins
.bottom_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1338 config_margins
.left_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1339 config_margins
.left_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1340 config_margins
.right_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1341 config_margins
.right_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1343 dims
= g_new(gulong
, 4 * screen_num_desktops
* screen_num_monitors
);
1345 RESET_STRUT_LIST(struts_left
);
1346 RESET_STRUT_LIST(struts_top
);
1347 RESET_STRUT_LIST(struts_right
);
1348 RESET_STRUT_LIST(struts_bottom
);
1350 /* collect the struts */
1351 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1352 ObClient
*c
= it
->data
;
1354 ADD_STRUT_TO_LIST(struts_left
, c
->desktop
, &c
->strut
);
1356 ADD_STRUT_TO_LIST(struts_top
, c
->desktop
, &c
->strut
);
1358 ADD_STRUT_TO_LIST(struts_right
, c
->desktop
, &c
->strut
);
1359 if (c
->strut
.bottom
)
1360 ADD_STRUT_TO_LIST(struts_bottom
, c
->desktop
, &c
->strut
);
1362 if (dock_strut
.left
)
1363 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &dock_strut
);
1365 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &dock_strut
);
1366 if (dock_strut
.right
)
1367 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &dock_strut
);
1368 if (dock_strut
.bottom
)
1369 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &dock_strut
);
1371 if (config_margins
.left
)
1372 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &config_margins
);
1373 if (config_margins
.top
)
1374 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &config_margins
);
1375 if (config_margins
.right
)
1376 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &config_margins
);
1377 if (config_margins
.bottom
)
1378 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &config_margins
);
1380 VALIDATE_STRUTS(struts_left
, left
,
1381 monitor_area
[screen_num_monitors
].width
/ 2);
1382 VALIDATE_STRUTS(struts_right
, right
,
1383 monitor_area
[screen_num_monitors
].width
/ 2);
1384 VALIDATE_STRUTS(struts_top
, top
,
1385 monitor_area
[screen_num_monitors
].height
/ 2);
1386 VALIDATE_STRUTS(struts_bottom
, bottom
,
1387 monitor_area
[screen_num_monitors
].height
/ 2);
1389 /* set up the work areas to be full screen */
1390 for (i
= 0; i
< screen_num_monitors
; ++i
)
1391 for (j
= 0; j
< screen_num_desktops
; ++j
) {
1392 dims
[(i
* screen_num_desktops
+ j
) * 4+0] = monitor_area
[i
].x
;
1393 dims
[(i
* screen_num_desktops
+ j
) * 4+1] = monitor_area
[i
].y
;
1394 dims
[(i
* screen_num_desktops
+ j
) * 4+2] = monitor_area
[i
].width
;
1395 dims
[(i
* screen_num_desktops
+ j
) * 4+3] = monitor_area
[i
].height
;
1398 /* calculate the work areas from the struts */
1399 for (i
= 0; i
< screen_num_monitors
; ++i
)
1400 for (j
= 0; j
< screen_num_desktops
; ++j
) {
1401 gint l
= 0, r
= 0, t
= 0, b
= 0;
1403 /* only add the strut to the area if it touches the monitor */
1405 for (sit
= struts_left
; sit
; sit
= g_slist_next(sit
)) {
1406 ObScreenStrut
*s
= sit
->data
;
1407 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1408 STRUT_LEFT_ON_MONITOR(s
->strut
, i
))
1409 l
= MAX(l
, s
->strut
->left
);
1411 for (sit
= struts_top
; sit
; sit
= g_slist_next(sit
)) {
1412 ObScreenStrut
*s
= sit
->data
;
1413 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1414 STRUT_TOP_ON_MONITOR(s
->strut
, i
))
1415 t
= MAX(t
, s
->strut
->top
);
1417 for (sit
= struts_right
; sit
; sit
= g_slist_next(sit
)) {
1418 ObScreenStrut
*s
= sit
->data
;
1419 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1420 STRUT_RIGHT_ON_MONITOR(s
->strut
, i
))
1421 r
= MAX(r
, s
->strut
->right
);
1423 for (sit
= struts_bottom
; sit
; sit
= g_slist_next(sit
)) {
1424 ObScreenStrut
*s
= sit
->data
;
1425 if ((s
->desktop
== j
|| s
->desktop
== DESKTOP_ALL
) &&
1426 STRUT_BOTTOM_ON_MONITOR(s
->strut
, i
))
1427 b
= MAX(b
, s
->strut
->bottom
);
1430 /* if the monitor is not against the edge of the root window,
1431 the struts will include the distance from the root window's edge
1432 to the monitor, so add that back into the monitor's work area */
1433 if (l
) l
+= RECT_LEFT (monitor_area
[screen_num_monitors
])
1434 - RECT_LEFT (monitor_area
[i
]);
1435 if (t
) t
+= RECT_TOP (monitor_area
[screen_num_monitors
])
1436 - RECT_TOP (monitor_area
[i
]);
1437 if (r
) r
-= RECT_RIGHT (monitor_area
[screen_num_monitors
])
1438 - RECT_RIGHT (monitor_area
[i
]);
1439 if (b
) b
-= RECT_BOTTOM(monitor_area
[screen_num_monitors
])
1440 - RECT_BOTTOM(monitor_area
[i
]);
1442 /* based on these margins, set the work area for the
1444 dims
[(i
* screen_num_desktops
+ j
) * 4 + 0] += l
;
1445 dims
[(i
* screen_num_desktops
+ j
) * 4 + 1] += t
;
1446 dims
[(i
* screen_num_desktops
+ j
) * 4 + 2] -= l
+ r
;
1447 dims
[(i
* screen_num_desktops
+ j
) * 4 + 3] -= t
+ b
;
1450 /* all the work areas are not used here, only the ones for the first
1452 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1453 dims
, 4 * screen_num_desktops
);
1455 /* the area has changed, adjust all the windows if they need it */
1456 for (it
= client_list
; it
; it
= g_list_next(it
))
1457 client_reconfigure(it
->data
, FALSE
);
1463 Rect
* screen_area_all_monitors(guint desktop
)
1468 a
= screen_area_monitor(desktop
, 0);
1470 /* combine all the monitors together */
1471 for (i
= 1; i
< screen_num_monitors
; ++i
) {
1472 Rect
*m
= screen_area_monitor(desktop
, i
);
1475 l
= MIN(RECT_LEFT(*a
), RECT_LEFT(*m
));
1476 t
= MIN(RECT_TOP(*a
), RECT_TOP(*m
));
1477 r
= MAX(RECT_RIGHT(*a
), RECT_RIGHT(*m
));
1478 b
= MAX(RECT_BOTTOM(*a
), RECT_BOTTOM(*m
));
1480 RECT_SET(*a
, l
, t
, r
- l
+ 1, b
- t
+ 1);
1489 #define STRUT_LEFT_IN_SEARCH(s, search) \
1490 (RANGES_INTERSECT(search->y, search->height, \
1491 s->left_start, s->left_end - s->left_start + 1))
1492 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1493 (RANGES_INTERSECT(search->y, search->height, \
1494 s->right_start, s->right_end - s->right_start + 1))
1495 #define STRUT_TOP_IN_SEARCH(s, search) \
1496 (RANGES_INTERSECT(search->x, search->width, \
1497 s->top_start, s->top_end - s->top_start + 1))
1498 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1499 (RANGES_INTERSECT(search->x, search->width, \
1500 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1502 #define STRUT_LEFT_IGNORE(s, us, search) \
1503 (head == SCREEN_AREA_ALL_MONITORS && us && \
1504 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1505 #define STRUT_RIGHT_IGNORE(s, us, search) \
1506 (head == SCREEN_AREA_ALL_MONITORS && us && \
1507 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1508 #define STRUT_TOP_IGNORE(s, us, search) \
1509 (head == SCREEN_AREA_ALL_MONITORS && us && \
1510 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1511 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1512 (head == SCREEN_AREA_ALL_MONITORS && us && \
1513 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1515 Rect
* screen_area(guint desktop
, guint head
, Rect
*search
)
1519 gint l
, r
, t
, b
, al
, ar
, at
, ab
;
1521 gboolean us
= search
!= NULL
; /* user provided search */
1523 g_assert(desktop
< screen_num_desktops
|| desktop
== DESKTOP_ALL
);
1524 g_assert(head
< screen_num_monitors
|| head
== SCREEN_AREA_ONE_MONITOR
||
1525 head
== SCREEN_AREA_ALL_MONITORS
);
1526 g_assert(!(head
== SCREEN_AREA_ONE_MONITOR
&& search
== NULL
));
1528 /* find any struts for this monitor
1529 which will be affecting the search area.
1532 /* search everything if search is null */
1534 if (head
< screen_num_monitors
) search
= &monitor_area
[head
];
1535 else search
= &monitor_area
[screen_num_monitors
];
1537 if (head
== SCREEN_AREA_ONE_MONITOR
) head
= screen_find_monitor(search
);
1539 /* al is "all left" meaning the furthest left you can get, l is our
1540 "working left" meaning our current strut edge which we're calculating
1543 /* only include monitors which the search area lines up with */
1544 if (RECT_INTERSECTS_RECT(monitor_area
[screen_num_monitors
], *search
)) {
1545 al
= l
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1546 at
= t
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1547 ar
= r
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1548 ab
= b
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1549 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1550 /* add the monitor if applicable */
1551 if (RANGES_INTERSECT(search
->x
, search
->width
,
1552 monitor_area
[i
].x
, monitor_area
[i
].width
))
1554 at
= t
= MIN(t
, RECT_TOP(monitor_area
[i
]));
1555 ab
= b
= MAX(b
, RECT_BOTTOM(monitor_area
[i
]));
1557 if (RANGES_INTERSECT(search
->y
, search
->height
,
1558 monitor_area
[i
].y
, monitor_area
[i
].height
))
1560 al
= l
= MIN(l
, RECT_LEFT(monitor_area
[i
]));
1561 ar
= r
= MAX(r
, RECT_RIGHT(monitor_area
[i
]));
1565 al
= l
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1566 at
= t
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1567 ar
= r
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1568 ab
= b
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1571 for (d
= 0; d
< screen_num_desktops
; ++d
) {
1572 if (d
!= desktop
&& desktop
!= DESKTOP_ALL
) continue;
1574 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1575 if (head
!= SCREEN_AREA_ALL_MONITORS
&& head
!= i
) continue;
1577 for (it
= struts_left
; it
; it
= g_slist_next(it
)) {
1578 ObScreenStrut
*s
= it
->data
;
1579 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1580 STRUT_LEFT_IN_SEARCH(s
->strut
, search
) &&
1581 !STRUT_LEFT_IGNORE(s
->strut
, us
, search
))
1582 l
= MAX(l
, RECT_LEFT(monitor_area
[screen_num_monitors
])
1585 for (it
= struts_top
; it
; it
= g_slist_next(it
)) {
1586 ObScreenStrut
*s
= it
->data
;
1587 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1588 STRUT_TOP_IN_SEARCH(s
->strut
, search
) &&
1589 !STRUT_TOP_IGNORE(s
->strut
, us
, search
))
1590 t
= MAX(t
, RECT_TOP(monitor_area
[screen_num_monitors
])
1593 for (it
= struts_right
; it
; it
= g_slist_next(it
)) {
1594 ObScreenStrut
*s
= it
->data
;
1595 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1596 STRUT_RIGHT_IN_SEARCH(s
->strut
, search
) &&
1597 !STRUT_RIGHT_IGNORE(s
->strut
, us
, search
))
1598 r
= MIN(r
, RECT_RIGHT(monitor_area
[screen_num_monitors
])
1601 for (it
= struts_bottom
; it
; it
= g_slist_next(it
)) {
1602 ObScreenStrut
*s
= it
->data
;
1603 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1604 STRUT_BOTTOM_IN_SEARCH(s
->strut
, search
) &&
1605 !STRUT_BOTTOM_IGNORE(s
->strut
, us
, search
))
1606 b
= MIN(b
, RECT_BOTTOM(monitor_area
[screen_num_monitors
])
1607 - s
->strut
->bottom
);
1610 /* limit to this monitor */
1612 l
= MAX(l
, RECT_LEFT(monitor_area
[i
]));
1613 t
= MAX(t
, RECT_TOP(monitor_area
[i
]));
1614 r
= MIN(r
, RECT_RIGHT(monitor_area
[i
]));
1615 b
= MIN(b
, RECT_BOTTOM(monitor_area
[i
]));
1623 a
->width
= r
- l
+ 1;
1624 a
->height
= b
- t
+ 1;
1628 guint
screen_find_monitor(Rect
*search
)
1631 guint most
= screen_num_monitors
;
1634 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1635 Rect
*area
= screen_physical_area_monitor(i
);
1636 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1640 RECT_SET_INTERSECTION(r
, *area
, *search
);
1641 v
= r
.width
* r
.height
;
1653 Rect
* screen_physical_area_all_monitors(void)
1655 return screen_physical_area_monitor(screen_num_monitors
);
1658 Rect
* screen_physical_area_monitor(guint head
)
1661 g_assert(head
<= screen_num_monitors
);
1664 *a
= monitor_area
[head
];
1668 gboolean
screen_physical_area_monitor_contains(guint head
, Rect
*search
)
1670 g_assert(head
<= screen_num_monitors
);
1672 return RECT_INTERSECTS_RECT(monitor_area
[head
], *search
);
1675 guint
screen_monitor_active(void)
1677 if (moveresize_client
)
1678 return client_monitor(moveresize_client
);
1679 else if (focus_client
)
1680 return client_monitor(focus_client
);
1682 return screen_monitor_pointer();
1685 Rect
* screen_physical_area_active(void)
1687 return screen_physical_area_monitor(screen_monitor_active());
1690 guint
screen_monitor_primary(void)
1692 if (config_primary_monitor_index
> 0) {
1693 if (config_primary_monitor_index
-1 < screen_num_monitors
)
1694 return config_primary_monitor_index
- 1;
1698 else if (config_primary_monitor
== OB_PLACE_MONITOR_ACTIVE
)
1699 return screen_monitor_active();
1700 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1701 return screen_monitor_pointer();
1704 Rect
*screen_physical_area_primary(void)
1706 return screen_physical_area_monitor(screen_monitor_primary());
1709 void screen_set_root_cursor(void)
1711 if (sn_app_starting())
1712 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1713 ob_cursor(OB_CURSOR_BUSYPOINTER
));
1715 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1716 ob_cursor(OB_CURSOR_POINTER
));
1719 guint
screen_monitor_pointer()
1723 if (screen_pointer_pos(&x
, &y
))
1724 RECT_SET(mon
, x
, y
, 1, 1);
1726 RECT_SET(mon
, 0, 0, 1, 1);
1727 return screen_find_monitor(&mon
);
1730 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1737 ret
= !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1738 &w
, &w
, x
, y
, &i
, &i
, &u
);
1740 for (i
= 0; i
< ScreenCount(ob_display
); ++i
)
1742 if (XQueryPointer(ob_display
, RootWindow(ob_display
, i
),
1743 &w
, &w
, x
, y
, &i
, &i
, &u
))