1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 screen.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
26 #include "startupnotify.h"
27 #include "moveresize.h"
36 #include "focus_cycle.h"
38 #include "extensions.h"
39 #include "render/render.h"
44 # include <sys/types.h>
49 /*! The event mask to grab on the root window */
50 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
51 EnterWindowMask | LeaveWindowMask | \
52 SubstructureRedirectMask | FocusChangeMask | \
53 ButtonPressMask | ButtonReleaseMask)
55 static gboolean
screen_validate_layout(ObDesktopLayout
*l
);
56 static gboolean
replace_wm(void);
57 static void screen_tell_ksplash(void);
58 static void screen_fallback_focus(void);
60 guint screen_num_desktops
;
61 guint screen_num_monitors
;
63 guint screen_last_desktop
;
64 gboolean screen_showing_desktop
;
65 ObDesktopLayout screen_desktop_layout
;
66 gchar
**screen_desktop_names
;
67 Window screen_support_win
;
68 Time screen_desktop_user_time
= CurrentTime
;
70 static Size screen_physical_size
;
71 static guint screen_old_desktop
;
72 static gboolean screen_desktop_timeout
= TRUE
;
73 /*! An array of desktops, holding an array of areas per monitor */
74 static Rect
*monitor_area
= NULL
;
75 /*! An array of desktops, holding an array of struts */
76 static GSList
*struts_top
= NULL
;
77 static GSList
*struts_left
= NULL
;
78 static GSList
*struts_right
= NULL
;
79 static GSList
*struts_bottom
= NULL
;
81 static ObPagerPopup
*desktop_popup
;
83 /*! The number of microseconds that you need to be on a desktop before it will
84 replace the remembered "last desktop" */
85 #define REMEMBER_LAST_DESKTOP_TIME 750000
87 static gboolean
replace_wm(void)
91 Window current_wm_sn_owner
;
94 wm_sn
= g_strdup_printf("WM_S%d", ob_screen
);
95 wm_sn_atom
= XInternAtom(ob_display
, wm_sn
, FALSE
);
98 current_wm_sn_owner
= XGetSelectionOwner(ob_display
, wm_sn_atom
);
99 if (current_wm_sn_owner
== screen_support_win
)
100 current_wm_sn_owner
= None
;
101 if (current_wm_sn_owner
) {
102 if (!ob_replace_wm
) {
103 g_message(_("A window manager is already running on screen %d"),
107 xerror_set_ignore(TRUE
);
108 xerror_occured
= FALSE
;
110 /* We want to find out when the current selection owner dies */
111 XSelectInput(ob_display
, current_wm_sn_owner
, StructureNotifyMask
);
112 XSync(ob_display
, FALSE
);
114 xerror_set_ignore(FALSE
);
116 current_wm_sn_owner
= None
;
119 timestamp
= event_get_server_time();
121 XSetSelectionOwner(ob_display
, wm_sn_atom
, screen_support_win
,
124 if (XGetSelectionOwner(ob_display
, wm_sn_atom
) != screen_support_win
) {
125 g_message(_("Could not acquire window manager selection on screen %d"),
130 /* Wait for old window manager to go away */
131 if (current_wm_sn_owner
) {
134 const gulong timeout
= G_USEC_PER_SEC
* 15; /* wait for 15s max */
136 while (wait
< timeout
) {
137 if (XCheckWindowEvent(ob_display
, current_wm_sn_owner
,
138 StructureNotifyMask
, &event
) &&
139 event
.type
== DestroyNotify
)
141 g_usleep(G_USEC_PER_SEC
/ 10);
142 wait
+= G_USEC_PER_SEC
/ 10;
145 if (wait
>= timeout
) {
146 g_message(_("The WM on screen %d is not exiting"), ob_screen
);
151 /* Send client message indicating that we are now the WM */
152 prop_message(RootWindow(ob_display
, ob_screen
), prop_atoms
.manager
,
153 timestamp
, wm_sn_atom
, screen_support_win
, 0,
154 SubstructureNotifyMask
);
159 gboolean
screen_annex(void)
161 XSetWindowAttributes attrib
;
164 Atom
*prop_atoms_start
, *wm_supported_pos
;
167 /* create the netwm support window */
168 attrib
.override_redirect
= TRUE
;
169 attrib
.event_mask
= PropertyChangeMask
;
170 screen_support_win
= XCreateWindow(ob_display
,
171 RootWindow(ob_display
, ob_screen
),
173 CopyFromParent
, InputOutput
,
175 CWEventMask
| CWOverrideRedirect
,
177 XMapWindow(ob_display
, screen_support_win
);
178 XLowerWindow(ob_display
, screen_support_win
);
181 XDestroyWindow(ob_display
, screen_support_win
);
185 xerror_set_ignore(TRUE
);
186 xerror_occured
= FALSE
;
187 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
189 xerror_set_ignore(FALSE
);
190 if (xerror_occured
) {
191 g_message(_("A window manager is already running on screen %d"),
194 XDestroyWindow(ob_display
, screen_support_win
);
198 screen_set_root_cursor();
200 /* set the OPENBOX_PID hint */
202 PROP_SET32(RootWindow(ob_display
, ob_screen
),
203 openbox_pid
, cardinal
, pid
);
205 /* set supporting window */
206 PROP_SET32(RootWindow(ob_display
, ob_screen
),
207 net_supporting_wm_check
, window
, screen_support_win
);
209 /* set properties on the supporting window */
210 PROP_SETS(screen_support_win
, net_wm_name
, "Openbox");
211 PROP_SET32(screen_support_win
, net_supporting_wm_check
,
212 window
, screen_support_win
);
214 /* set the _NET_SUPPORTED_ATOMS hint */
216 /* this is all the atoms after net_supported in the prop_atoms struct */
217 prop_atoms_start
= (Atom
*)&prop_atoms
;
218 wm_supported_pos
= (Atom
*)&(prop_atoms
.net_supported
);
219 num_support
= sizeof(prop_atoms
) / sizeof(Atom
) -
220 (wm_supported_pos
- prop_atoms_start
) - 1;
222 supported
= g_new(gulong
, num_support
);
223 supported
[i
++] = prop_atoms
.net_supporting_wm_check
;
224 supported
[i
++] = prop_atoms
.net_wm_full_placement
;
225 supported
[i
++] = prop_atoms
.net_current_desktop
;
226 supported
[i
++] = prop_atoms
.net_number_of_desktops
;
227 supported
[i
++] = prop_atoms
.net_desktop_geometry
;
228 supported
[i
++] = prop_atoms
.net_desktop_viewport
;
229 supported
[i
++] = prop_atoms
.net_active_window
;
230 supported
[i
++] = prop_atoms
.net_workarea
;
231 supported
[i
++] = prop_atoms
.net_client_list
;
232 supported
[i
++] = prop_atoms
.net_client_list_stacking
;
233 supported
[i
++] = prop_atoms
.net_desktop_names
;
234 supported
[i
++] = prop_atoms
.net_close_window
;
235 supported
[i
++] = prop_atoms
.net_desktop_layout
;
236 supported
[i
++] = prop_atoms
.net_showing_desktop
;
237 supported
[i
++] = prop_atoms
.net_wm_name
;
238 supported
[i
++] = prop_atoms
.net_wm_visible_name
;
239 supported
[i
++] = prop_atoms
.net_wm_icon_name
;
240 supported
[i
++] = prop_atoms
.net_wm_visible_icon_name
;
241 supported
[i
++] = prop_atoms
.net_wm_desktop
;
242 supported
[i
++] = prop_atoms
.net_wm_strut
;
243 supported
[i
++] = prop_atoms
.net_wm_strut_partial
;
244 supported
[i
++] = prop_atoms
.net_wm_icon
;
245 supported
[i
++] = prop_atoms
.net_wm_icon_geometry
;
246 supported
[i
++] = prop_atoms
.net_wm_window_type
;
247 supported
[i
++] = prop_atoms
.net_wm_window_type_desktop
;
248 supported
[i
++] = prop_atoms
.net_wm_window_type_dock
;
249 supported
[i
++] = prop_atoms
.net_wm_window_type_toolbar
;
250 supported
[i
++] = prop_atoms
.net_wm_window_type_menu
;
251 supported
[i
++] = prop_atoms
.net_wm_window_type_utility
;
252 supported
[i
++] = prop_atoms
.net_wm_window_type_splash
;
253 supported
[i
++] = prop_atoms
.net_wm_window_type_dialog
;
254 supported
[i
++] = prop_atoms
.net_wm_window_type_normal
;
255 supported
[i
++] = prop_atoms
.net_wm_allowed_actions
;
256 supported
[i
++] = prop_atoms
.net_wm_action_move
;
257 supported
[i
++] = prop_atoms
.net_wm_action_resize
;
258 supported
[i
++] = prop_atoms
.net_wm_action_minimize
;
259 supported
[i
++] = prop_atoms
.net_wm_action_shade
;
260 supported
[i
++] = prop_atoms
.net_wm_action_maximize_horz
;
261 supported
[i
++] = prop_atoms
.net_wm_action_maximize_vert
;
262 supported
[i
++] = prop_atoms
.net_wm_action_fullscreen
;
263 supported
[i
++] = prop_atoms
.net_wm_action_change_desktop
;
264 supported
[i
++] = prop_atoms
.net_wm_action_close
;
265 supported
[i
++] = prop_atoms
.net_wm_action_above
;
266 supported
[i
++] = prop_atoms
.net_wm_action_below
;
267 supported
[i
++] = prop_atoms
.net_wm_state
;
268 supported
[i
++] = prop_atoms
.net_wm_state_modal
;
269 supported
[i
++] = prop_atoms
.net_wm_state_maximized_vert
;
270 supported
[i
++] = prop_atoms
.net_wm_state_maximized_horz
;
271 supported
[i
++] = prop_atoms
.net_wm_state_shaded
;
272 supported
[i
++] = prop_atoms
.net_wm_state_skip_taskbar
;
273 supported
[i
++] = prop_atoms
.net_wm_state_skip_pager
;
274 supported
[i
++] = prop_atoms
.net_wm_state_hidden
;
275 supported
[i
++] = prop_atoms
.net_wm_state_fullscreen
;
276 supported
[i
++] = prop_atoms
.net_wm_state_above
;
277 supported
[i
++] = prop_atoms
.net_wm_state_below
;
278 supported
[i
++] = prop_atoms
.net_wm_state_demands_attention
;
279 supported
[i
++] = prop_atoms
.net_moveresize_window
;
280 supported
[i
++] = prop_atoms
.net_wm_moveresize
;
281 supported
[i
++] = prop_atoms
.net_wm_user_time
;
283 supported[i++] = prop_atoms.net_wm_user_time_window;
285 supported
[i
++] = prop_atoms
.net_frame_extents
;
286 supported
[i
++] = prop_atoms
.net_request_frame_extents
;
287 supported
[i
++] = prop_atoms
.net_restack_window
;
288 supported
[i
++] = prop_atoms
.net_startup_id
;
290 supported
[i
++] = prop_atoms
.net_wm_sync_request
;
291 supported
[i
++] = prop_atoms
.net_wm_sync_request_counter
;
293 supported
[i
++] = prop_atoms
.net_wm_pid
;
294 supported
[i
++] = prop_atoms
.net_wm_ping
;
296 supported
[i
++] = prop_atoms
.kde_wm_change_state
;
297 supported
[i
++] = prop_atoms
.kde_net_wm_frame_strut
;
298 supported
[i
++] = prop_atoms
.kde_net_wm_window_type_override
;
300 supported
[i
++] = prop_atoms
.ob_wm_action_undecorate
;
301 supported
[i
++] = prop_atoms
.ob_wm_state_undecorated
;
302 supported
[i
++] = prop_atoms
.openbox_pid
;
303 supported
[i
++] = prop_atoms
.ob_theme
;
304 supported
[i
++] = prop_atoms
.ob_config_file
;
305 supported
[i
++] = prop_atoms
.ob_control
;
306 supported
[i
++] = prop_atoms
.ob_version
;
307 supported
[i
++] = prop_atoms
.ob_app_role
;
308 supported
[i
++] = prop_atoms
.ob_app_name
;
309 supported
[i
++] = prop_atoms
.ob_app_class
;
310 supported
[i
++] = prop_atoms
.ob_app_type
;
311 g_assert(i
== num_support
);
313 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
314 net_supported
, atom
, supported
, num_support
);
317 PROP_SETS(RootWindow(ob_display
, ob_screen
), ob_version
,
320 screen_tell_ksplash();
325 static void screen_tell_ksplash(void)
330 argv
= g_new(gchar
*, 6);
331 argv
[0] = g_strdup("dcop");
332 argv
[1] = g_strdup("ksplash");
333 argv
[2] = g_strdup("ksplash");
334 argv
[3] = g_strdup("upAndRunning(QString)");
335 argv
[4] = g_strdup("wm started");
338 /* tell ksplash through the dcop server command line interface */
339 g_spawn_async(NULL
, argv
, NULL
,
340 G_SPAWN_SEARCH_PATH
| G_SPAWN_DO_NOT_REAP_CHILD
|
341 G_SPAWN_STDERR_TO_DEV_NULL
| G_SPAWN_STDOUT_TO_DEV_NULL
,
342 NULL
, NULL
, NULL
, NULL
);
345 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
346 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
347 something. oh well. */
348 e
.xclient
.type
= ClientMessage
;
349 e
.xclient
.display
= ob_display
;
350 e
.xclient
.window
= RootWindow(ob_display
, ob_screen
);
351 e
.xclient
.message_type
=
352 XInternAtom(ob_display
, "_KDE_SPLASH_PROGRESS", False
);
353 e
.xclient
.format
= 8;
354 strcpy(e
.xclient
.data
.b
, "wm started");
355 XSendEvent(ob_display
, RootWindow(ob_display
, ob_screen
),
356 False
, SubstructureNotifyMask
, &e
);
359 void screen_startup(gboolean reconfig
)
361 gchar
**names
= NULL
;
363 gboolean namesexist
= FALSE
;
365 desktop_popup
= pager_popup_new();
366 pager_popup_height(desktop_popup
, POPUP_HEIGHT
);
369 /* update the pager popup's width */
370 pager_popup_text_width_to_strings(desktop_popup
,
371 screen_desktop_names
,
372 screen_num_desktops
);
376 /* get the initial size */
379 /* have names already been set for the desktops? */
380 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
381 net_desktop_names
, utf8
, &names
))
387 /* if names don't exist and we have session names, set those.
388 do this stuff BEFORE setting the number of desktops, because that
389 will create default names for them
391 if (!namesexist
&& session_desktop_names
!= NULL
) {
395 /* get the desktop names */
396 numnames
= g_slist_length(session_desktop_names
);
397 names
= g_new(gchar
*, numnames
+ 1);
398 names
[numnames
] = NULL
;
399 for (i
= 0, it
= session_desktop_names
; it
; ++i
, it
= g_slist_next(it
))
400 names
[i
] = g_strdup(it
->data
);
402 /* set the root window property */
403 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,names
);
408 /* set the number of desktops, if it's not already set.
410 this will also set the default names from the config file up for
411 desktops that don't have names yet */
412 screen_num_desktops
= 0;
413 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
414 net_number_of_desktops
, cardinal
, &d
))
416 if (d
!= config_desktops_num
) {
417 /* TRANSLATORS: If you need to specify a different order of the
418 arguments, you can use %1$d for the first one and %2$d for the
419 second one. For example,
420 "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
421 g_warning(ngettext("Openbox is configured for %d desktop, but the current session has %d. Overriding the Openbox configuration.", "Openbox is configured for %d desktops, but the current session has %d. Overriding the Openbox configuration.", config_desktops_num
),
422 config_desktops_num
, d
);
424 screen_set_num_desktops(d
);
426 /* restore from session if possible */
427 else if (session_num_desktops
)
428 screen_set_num_desktops(session_num_desktops
);
430 screen_set_num_desktops(config_desktops_num
);
432 screen_desktop
= screen_num_desktops
; /* something invalid */
433 /* start on the current desktop when a wm was already running */
434 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
435 net_current_desktop
, cardinal
, &d
) &&
436 d
< screen_num_desktops
)
438 screen_set_desktop(d
, FALSE
);
439 } else if (session_desktop
>= 0)
440 screen_set_desktop(MIN((guint
)session_desktop
,
441 screen_num_desktops
), FALSE
);
443 screen_set_desktop(MIN(config_screen_firstdesk
,
444 screen_num_desktops
) - 1, FALSE
);
445 screen_last_desktop
= screen_desktop
;
447 /* don't start in showing-desktop mode */
448 screen_showing_desktop
= FALSE
;
449 PROP_SET32(RootWindow(ob_display
, ob_screen
),
450 net_showing_desktop
, cardinal
, screen_showing_desktop
);
452 if (session_desktop_layout_present
&&
453 screen_validate_layout(&session_desktop_layout
))
455 screen_desktop_layout
= session_desktop_layout
;
458 screen_update_layout();
461 void screen_shutdown(gboolean reconfig
)
463 pager_popup_free(desktop_popup
);
468 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
471 /* we're not running here no more! */
472 PROP_ERASE(RootWindow(ob_display
, ob_screen
), openbox_pid
);
474 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_supported
);
475 /* don't keep this mode */
476 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_showing_desktop
);
478 XDestroyWindow(ob_display
, screen_support_win
);
480 g_strfreev(screen_desktop_names
);
481 screen_desktop_names
= NULL
;
484 void screen_resize(void)
486 static gint oldw
= 0, oldh
= 0;
491 w
= WidthOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
492 h
= HeightOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
494 if (w
== oldw
&& h
== oldh
) return;
498 /* Set the _NET_DESKTOP_GEOMETRY hint */
499 screen_physical_size
.width
= geometry
[0] = w
;
500 screen_physical_size
.height
= geometry
[1] = h
;
501 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
502 net_desktop_geometry
, cardinal
, geometry
, 2);
504 if (ob_state() != OB_STATE_RUNNING
)
507 screen_update_areas();
510 for (it
= client_list
; it
; it
= g_list_next(it
))
511 client_move_onscreen(it
->data
, FALSE
);
514 void screen_set_num_desktops(guint num
)
518 GList
*it
, *stacking_copy
;
522 if (screen_num_desktops
== num
) return;
524 old
= screen_num_desktops
;
525 screen_num_desktops
= num
;
526 PROP_SET32(RootWindow(ob_display
, ob_screen
),
527 net_number_of_desktops
, cardinal
, num
);
529 /* set the viewport hint */
530 viewport
= g_new0(gulong
, num
* 2);
531 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
532 net_desktop_viewport
, cardinal
, viewport
, num
* 2);
535 /* the number of rows/columns will differ */
536 screen_update_layout();
538 /* move windows on desktops that will no longer exist!
539 make a copy of the list cuz we're changing it */
540 stacking_copy
= g_list_copy(stacking_list
);
541 for (it
= g_list_last(stacking_copy
); it
; it
= g_list_previous(it
)) {
542 if (WINDOW_IS_CLIENT(it
->data
)) {
543 ObClient
*c
= it
->data
;
544 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
>= num
)
545 client_set_desktop(c
, num
- 1, FALSE
, TRUE
);
546 /* raise all the windows that are on the current desktop which
548 else if (screen_desktop
== num
- 1 &&
549 (c
->desktop
== DESKTOP_ALL
||
550 c
->desktop
== screen_desktop
))
551 stacking_raise(CLIENT_AS_WINDOW(c
));
554 g_list_free(stacking_copy
);
556 /* change our struts/area to match (after moving windows) */
557 screen_update_areas();
559 /* may be some unnamed desktops that we need to fill in with names
560 (after updating the areas so the popup can resize) */
561 screen_update_desktop_names();
563 /* change our desktop if we're on one that no longer exists! */
564 if (screen_desktop
>= screen_num_desktops
)
565 screen_set_desktop(num
- 1, TRUE
);
568 static void screen_fallback_focus(void)
573 /* only allow omnipresent windows to get focus on desktop change if
574 an omnipresent window is already focused (it'll keep focus probably, but
575 maybe not depending on mouse-focus options) */
576 allow_omni
= focus_client
&& (client_normal(focus_client
) &&
577 focus_client
->desktop
== DESKTOP_ALL
);
579 /* the client moved there already so don't move focus. prevent flicker
580 on sendtodesktop + follow */
581 if (focus_client
&& focus_client
->desktop
== screen_desktop
)
584 /* have to try focus here because when you leave an empty desktop
585 there is no focus out to watch for. also, we have different rules
586 here. we always allow it to look under the mouse pointer if
587 config_focus_last is FALSE
589 do this before hiding the windows so if helper windows are coming
590 with us, they don't get hidden
592 if ((c
= focus_fallback(TRUE
, !config_focus_last
, allow_omni
,
595 /* only do the flicker reducing stuff ahead of time if we are going
596 to call xsetinputfocus on the window ourselves. otherwise there is
597 no guarantee the window will actually take focus.. */
599 /* reduce flicker by hiliting now rather than waiting for the
600 server FocusIn event */
601 frame_adjust_focus(c
->frame
, TRUE
);
602 /* do this here so that if you switch desktops to a window with
603 helper windows then the helper windows won't flash */
604 client_bring_helper_windows(c
);
609 static gboolean
last_desktop_func(gpointer data
)
611 screen_desktop_timeout
= TRUE
;
615 void screen_set_desktop(guint num
, gboolean dofocus
)
621 g_assert(num
< screen_num_desktops
);
623 previous
= screen_desktop
;
624 screen_desktop
= num
;
626 if (previous
== num
) return;
628 PROP_SET32(RootWindow(ob_display
, ob_screen
),
629 net_current_desktop
, cardinal
, num
);
631 /* This whole thing decides when/how to save the screen_last_desktop so
632 that it can be restored later if you want */
633 if (screen_desktop_timeout
) {
634 /* If screen_desktop_timeout is true, then we've been on this desktop
635 long enough and we can save it as the last desktop. */
637 if (screen_last_desktop
== previous
)
638 /* this is the startup state only */
639 screen_old_desktop
= screen_desktop
;
641 /* save the "last desktop" as the "old desktop" */
642 screen_old_desktop
= screen_last_desktop
;
643 /* save the desktop we're coming from as the "last desktop" */
644 screen_last_desktop
= previous
;
648 /* If screen_desktop_timeout is false, then we just got to this desktop
649 and we are moving away again. */
651 if (screen_desktop
== screen_last_desktop
) {
652 /* If we are moving to the "last desktop" .. */
653 if (previous
== screen_old_desktop
) {
654 /* .. from the "old desktop", change the last desktop to
655 be where we are coming from */
656 screen_last_desktop
= screen_old_desktop
;
658 else if (screen_last_desktop
== screen_old_desktop
) {
659 /* .. and also to the "old desktop", change the "last
660 desktop" to be where we are coming from */
661 screen_last_desktop
= previous
;
664 /* .. from some other desktop, then set the "last desktop" to
665 be the saved "old desktop", i.e. where we were before the
667 screen_last_desktop
= screen_old_desktop
;
671 /* If we are moving to any desktop besides the "last desktop"..
672 (this is the normal case) */
673 if (screen_desktop
== screen_old_desktop
) {
674 /* If moving to the "old desktop", which is not the
675 "last desktop", don't save anything */
677 else if (previous
== screen_old_desktop
) {
678 /* If moving from the "old desktop", and not to the
679 "last desktop", don't save anything */
681 else if (screen_last_desktop
== screen_old_desktop
) {
682 /* If the "last desktop" is the same as "old desktop" and
683 you're not moving to the "last desktop" then save where
684 we're coming from as the "last desktop" */
685 screen_last_desktop
= previous
;
688 /* If the "last desktop" is different from the "old desktop"
689 and you're not moving to the "last desktop", then don't save
694 screen_desktop_timeout
= FALSE
;
695 ob_main_loop_timeout_remove(ob_main_loop
, last_desktop_func
);
696 ob_main_loop_timeout_add(ob_main_loop
, REMEMBER_LAST_DESKTOP_TIME
,
697 last_desktop_func
, NULL
, NULL
, NULL
);
699 ob_debug("Moving to desktop %d\n", num
+1);
701 if (ob_state() == OB_STATE_RUNNING
)
702 screen_show_desktop_popup(screen_desktop
);
704 /* ignore enter events caused by the move */
705 ignore_start
= event_start_ignore_all_enters();
707 if (moveresize_client
)
708 client_set_desktop(moveresize_client
, num
, TRUE
, FALSE
);
710 /* show windows before hiding the rest to lessen the enter/leave events */
712 /* show windows from top to bottom */
713 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
714 if (WINDOW_IS_CLIENT(it
->data
)) {
715 ObClient
*c
= it
->data
;
721 if (dofocus
) screen_fallback_focus();
723 /* hide windows from bottom to top */
724 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
725 if (WINDOW_IS_CLIENT(it
->data
)) {
726 ObClient
*c
= it
->data
;
727 if (client_hide(c
)) {
728 focus_cycle_remove(c
);
730 if (c
== focus_client
) {
731 /* c was focused and we didn't do fallback clearly so make
732 sure openbox doesnt still consider the window focused.
733 this happens when using NextWindow with allDesktops,
734 since it doesnt want to move focus on desktop change,
735 but the focus is not going to stay with the current
736 window, which has now disappeared.
737 only do this if the client was actually hidden,
738 otherwise it can keep focus. */
739 focus_set_client(NULL
);
745 event_end_ignore_all_enters(ignore_start
);
747 if (event_curtime
!= CurrentTime
)
748 screen_desktop_user_time
= event_curtime
;
751 void screen_add_desktop(gboolean current
)
755 /* ignore enter events caused by this */
756 ignore_start
= event_start_ignore_all_enters();
758 screen_set_num_desktops(screen_num_desktops
+1);
760 /* move all the clients over */
764 for (it
= client_list
; it
; it
= g_list_next(it
)) {
765 ObClient
*c
= it
->data
;
766 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
>= screen_desktop
&&
767 /* don't move direct children, they'll be moved with their
768 parent - which will have to be on the same desktop */
769 !client_direct_parent(c
))
771 ob_debug("moving window %s\n", c
->title
);
772 client_set_desktop(c
, c
->desktop
+1, FALSE
, TRUE
);
777 event_end_ignore_all_enters(ignore_start
);
780 void screen_remove_desktop(gboolean current
)
782 guint rmdesktop
, movedesktop
;
783 GList
*it
, *stacking_copy
;
786 if (screen_num_desktops
<= 1) return;
788 /* ignore enter events caused by this */
789 ignore_start
= event_start_ignore_all_enters();
791 /* what desktop are we removing and moving to? */
793 rmdesktop
= screen_desktop
;
795 rmdesktop
= screen_num_desktops
- 1;
796 if (rmdesktop
< screen_num_desktops
- 1)
797 movedesktop
= rmdesktop
+ 1;
799 movedesktop
= rmdesktop
;
801 /* make a copy of the list cuz we're changing it */
802 stacking_copy
= g_list_copy(stacking_list
);
803 for (it
= g_list_last(stacking_copy
); it
; it
= g_list_previous(it
)) {
804 if (WINDOW_IS_CLIENT(it
->data
)) {
805 ObClient
*c
= it
->data
;
806 guint d
= c
->desktop
;
807 if (d
!= DESKTOP_ALL
&& d
>= movedesktop
&&
808 /* don't move direct children, they'll be moved with their
809 parent - which will have to be on the same desktop */
810 !client_direct_parent(c
))
812 ob_debug("moving window %s\n", c
->title
);
813 client_set_desktop(c
, c
->desktop
- 1, TRUE
, TRUE
);
815 /* raise all the windows that are on the current desktop which
817 if ((screen_desktop
== rmdesktop
- 1 ||
818 screen_desktop
== rmdesktop
) &&
819 (d
== DESKTOP_ALL
|| d
== screen_desktop
))
821 stacking_raise(CLIENT_AS_WINDOW(c
));
822 ob_debug("raising window %s\n", c
->title
);
826 g_list_free(stacking_copy
);
828 /* fallback focus like we're changing desktops */
829 if (screen_desktop
< screen_num_desktops
- 1) {
830 screen_fallback_focus();
831 ob_debug("fake desktop change\n");
834 screen_set_num_desktops(screen_num_desktops
-1);
836 event_end_ignore_all_enters(ignore_start
);
839 static void get_row_col(guint d
, guint
*r
, guint
*c
)
841 switch (screen_desktop_layout
.orientation
) {
842 case OB_ORIENTATION_HORZ
:
843 switch (screen_desktop_layout
.start_corner
) {
844 case OB_CORNER_TOPLEFT
:
845 *r
= d
/ screen_desktop_layout
.columns
;
846 *c
= d
% screen_desktop_layout
.columns
;
848 case OB_CORNER_BOTTOMLEFT
:
849 *r
= screen_desktop_layout
.rows
- 1 -
850 d
/ screen_desktop_layout
.columns
;
851 *c
= d
% screen_desktop_layout
.columns
;
853 case OB_CORNER_TOPRIGHT
:
854 *r
= d
/ screen_desktop_layout
.columns
;
855 *c
= screen_desktop_layout
.columns
- 1 -
856 d
% screen_desktop_layout
.columns
;
858 case OB_CORNER_BOTTOMRIGHT
:
859 *r
= screen_desktop_layout
.rows
- 1 -
860 d
/ screen_desktop_layout
.columns
;
861 *c
= screen_desktop_layout
.columns
- 1 -
862 d
% screen_desktop_layout
.columns
;
866 case OB_ORIENTATION_VERT
:
867 switch (screen_desktop_layout
.start_corner
) {
868 case OB_CORNER_TOPLEFT
:
869 *r
= d
% screen_desktop_layout
.rows
;
870 *c
= d
/ screen_desktop_layout
.rows
;
872 case OB_CORNER_BOTTOMLEFT
:
873 *r
= screen_desktop_layout
.rows
- 1 -
874 d
% screen_desktop_layout
.rows
;
875 *c
= d
/ screen_desktop_layout
.rows
;
877 case OB_CORNER_TOPRIGHT
:
878 *r
= d
% screen_desktop_layout
.rows
;
879 *c
= screen_desktop_layout
.columns
- 1 -
880 d
/ screen_desktop_layout
.rows
;
882 case OB_CORNER_BOTTOMRIGHT
:
883 *r
= screen_desktop_layout
.rows
- 1 -
884 d
% screen_desktop_layout
.rows
;
885 *c
= screen_desktop_layout
.columns
- 1 -
886 d
/ screen_desktop_layout
.rows
;
893 static guint
translate_row_col(guint r
, guint c
)
895 switch (screen_desktop_layout
.orientation
) {
896 case OB_ORIENTATION_HORZ
:
897 switch (screen_desktop_layout
.start_corner
) {
898 case OB_CORNER_TOPLEFT
:
899 return r
% screen_desktop_layout
.rows
*
900 screen_desktop_layout
.columns
+
901 c
% screen_desktop_layout
.columns
;
902 case OB_CORNER_BOTTOMLEFT
:
903 return (screen_desktop_layout
.rows
- 1 -
904 r
% screen_desktop_layout
.rows
) *
905 screen_desktop_layout
.columns
+
906 c
% screen_desktop_layout
.columns
;
907 case OB_CORNER_TOPRIGHT
:
908 return r
% screen_desktop_layout
.rows
*
909 screen_desktop_layout
.columns
+
910 (screen_desktop_layout
.columns
- 1 -
911 c
% screen_desktop_layout
.columns
);
912 case OB_CORNER_BOTTOMRIGHT
:
913 return (screen_desktop_layout
.rows
- 1 -
914 r
% screen_desktop_layout
.rows
) *
915 screen_desktop_layout
.columns
+
916 (screen_desktop_layout
.columns
- 1 -
917 c
% screen_desktop_layout
.columns
);
919 case OB_ORIENTATION_VERT
:
920 switch (screen_desktop_layout
.start_corner
) {
921 case OB_CORNER_TOPLEFT
:
922 return c
% screen_desktop_layout
.columns
*
923 screen_desktop_layout
.rows
+
924 r
% screen_desktop_layout
.rows
;
925 case OB_CORNER_BOTTOMLEFT
:
926 return c
% screen_desktop_layout
.columns
*
927 screen_desktop_layout
.rows
+
928 (screen_desktop_layout
.rows
- 1 -
929 r
% screen_desktop_layout
.rows
);
930 case OB_CORNER_TOPRIGHT
:
931 return (screen_desktop_layout
.columns
- 1 -
932 c
% screen_desktop_layout
.columns
) *
933 screen_desktop_layout
.rows
+
934 r
% screen_desktop_layout
.rows
;
935 case OB_CORNER_BOTTOMRIGHT
:
936 return (screen_desktop_layout
.columns
- 1 -
937 c
% screen_desktop_layout
.columns
) *
938 screen_desktop_layout
.rows
+
939 (screen_desktop_layout
.rows
- 1 -
940 r
% screen_desktop_layout
.rows
);
943 g_assert_not_reached();
947 static gboolean
hide_desktop_popup_func(gpointer data
)
949 pager_popup_hide(desktop_popup
);
950 return FALSE
; /* don't repeat */
953 void screen_show_desktop_popup(guint d
)
957 /* 0 means don't show the popup */
958 if (!config_desktop_popup_time
) return;
960 a
= screen_physical_area_primary(FALSE
);
961 pager_popup_position(desktop_popup
, CenterGravity
,
962 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
963 pager_popup_icon_size_multiplier(desktop_popup
,
964 (screen_desktop_layout
.columns
/
965 screen_desktop_layout
.rows
) / 2,
966 (screen_desktop_layout
.rows
/
967 screen_desktop_layout
.columns
) / 2);
968 pager_popup_max_width(desktop_popup
,
969 MAX(a
->width
/3, POPUP_WIDTH
));
970 pager_popup_show(desktop_popup
, screen_desktop_names
[d
], d
);
972 ob_main_loop_timeout_remove(ob_main_loop
, hide_desktop_popup_func
);
973 ob_main_loop_timeout_add(ob_main_loop
, config_desktop_popup_time
* 1000,
974 hide_desktop_popup_func
, NULL
, NULL
, NULL
);
978 void screen_hide_desktop_popup(void)
980 ob_main_loop_timeout_remove(ob_main_loop
, hide_desktop_popup_func
);
981 pager_popup_hide(desktop_popup
);
984 guint
screen_find_desktop(guint from
, ObDirection dir
,
985 gboolean wrap
, gboolean linear
)
991 get_row_col(d
, &r
, &c
);
994 case OB_DIRECTION_EAST
:
995 if (d
< screen_num_desktops
- 1)
1002 case OB_DIRECTION_WEST
:
1006 d
= screen_num_desktops
- 1;
1011 g_assert_not_reached();
1016 case OB_DIRECTION_EAST
:
1018 if (c
>= screen_desktop_layout
.columns
) {
1024 d
= translate_row_col(r
, c
);
1025 if (d
>= screen_num_desktops
) {
1032 case OB_DIRECTION_WEST
:
1034 if (c
>= screen_desktop_layout
.columns
) {
1036 c
= screen_desktop_layout
.columns
- 1;
1040 d
= translate_row_col(r
, c
);
1041 if (d
>= screen_num_desktops
) {
1048 case OB_DIRECTION_SOUTH
:
1050 if (r
>= screen_desktop_layout
.rows
) {
1056 d
= translate_row_col(r
, c
);
1057 if (d
>= screen_num_desktops
) {
1064 case OB_DIRECTION_NORTH
:
1066 if (r
>= screen_desktop_layout
.rows
) {
1068 r
= screen_desktop_layout
.rows
- 1;
1072 d
= translate_row_col(r
, c
);
1073 if (d
>= screen_num_desktops
) {
1081 g_assert_not_reached();
1085 d
= translate_row_col(r
, c
);
1090 static gboolean
screen_validate_layout(ObDesktopLayout
*l
)
1092 if (l
->columns
== 0 && l
->rows
== 0) /* both 0's is bad data.. */
1095 /* fill in a zero rows/columns */
1096 if (l
->columns
== 0) {
1097 l
->columns
= screen_num_desktops
/ l
->rows
;
1098 if (l
->rows
* l
->columns
< screen_num_desktops
)
1100 if (l
->rows
* l
->columns
>= screen_num_desktops
+ l
->columns
)
1102 } else if (l
->rows
== 0) {
1103 l
->rows
= screen_num_desktops
/ l
->columns
;
1104 if (l
->columns
* l
->rows
< screen_num_desktops
)
1106 if (l
->columns
* l
->rows
>= screen_num_desktops
+ l
->rows
)
1110 /* bounds checking */
1111 if (l
->orientation
== OB_ORIENTATION_HORZ
) {
1112 l
->columns
= MIN(screen_num_desktops
, l
->columns
);
1113 l
->rows
= MIN(l
->rows
,
1114 (screen_num_desktops
+ l
->columns
- 1) / l
->columns
);
1115 l
->columns
= screen_num_desktops
/ l
->rows
+
1116 !!(screen_num_desktops
% l
->rows
);
1118 l
->rows
= MIN(screen_num_desktops
, l
->rows
);
1119 l
->columns
= MIN(l
->columns
,
1120 (screen_num_desktops
+ l
->rows
- 1) / l
->rows
);
1121 l
->rows
= screen_num_desktops
/ l
->columns
+
1122 !!(screen_num_desktops
% l
->columns
);
1127 void screen_update_layout(void)
1134 screen_desktop_layout
.orientation
= OB_ORIENTATION_HORZ
;
1135 screen_desktop_layout
.start_corner
= OB_CORNER_TOPLEFT
;
1136 screen_desktop_layout
.rows
= 1;
1137 screen_desktop_layout
.columns
= screen_num_desktops
;
1139 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
1140 net_desktop_layout
, cardinal
, &data
, &num
)) {
1141 if (num
== 3 || num
== 4) {
1143 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
1144 l
.orientation
= OB_ORIENTATION_VERT
;
1145 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
1146 l
.orientation
= OB_ORIENTATION_HORZ
;
1151 l
.start_corner
= OB_CORNER_TOPLEFT
;
1153 if (data
[3] == prop_atoms
.net_wm_topleft
)
1154 l
.start_corner
= OB_CORNER_TOPLEFT
;
1155 else if (data
[3] == prop_atoms
.net_wm_topright
)
1156 l
.start_corner
= OB_CORNER_TOPRIGHT
;
1157 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
1158 l
.start_corner
= OB_CORNER_BOTTOMRIGHT
;
1159 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
1160 l
.start_corner
= OB_CORNER_BOTTOMLEFT
;
1165 l
.columns
= data
[1];
1168 if (screen_validate_layout(&l
))
1169 screen_desktop_layout
= l
;
1176 void screen_update_desktop_names(void)
1180 /* empty the array */
1181 g_strfreev(screen_desktop_names
);
1182 screen_desktop_names
= NULL
;
1184 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
1185 net_desktop_names
, utf8
, &screen_desktop_names
))
1186 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
1189 if (i
< screen_num_desktops
) {
1192 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
1193 screen_num_desktops
+ 1);
1194 screen_desktop_names
[screen_num_desktops
] = NULL
;
1196 it
= g_slist_nth(config_desktops_names
, i
);
1198 for (; i
< screen_num_desktops
; ++i
) {
1199 if (it
&& ((char*)it
->data
)[0]) /* not empty */
1200 /* use the names from the config file when possible */
1201 screen_desktop_names
[i
] = g_strdup(it
->data
);
1203 /* make up a nice name if it's not though */
1204 screen_desktop_names
[i
] = g_strdup_printf(_("desktop %i"),
1206 if (it
) it
= g_slist_next(it
);
1209 /* if we changed any names, then set the root property so we can
1210 all agree on the names */
1211 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,
1212 screen_desktop_names
);
1215 /* resize the pager for these names */
1216 pager_popup_text_width_to_strings(desktop_popup
,
1217 screen_desktop_names
,
1218 screen_num_desktops
);
1221 void screen_show_desktop(gboolean show
, ObClient
*show_only
)
1225 if (show
== screen_showing_desktop
) return; /* no change */
1227 screen_showing_desktop
= show
;
1230 /* hide windows bottom to top */
1231 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
1232 if (WINDOW_IS_CLIENT(it
->data
)) {
1233 ObClient
*client
= it
->data
;
1234 client_showhide(client
);
1239 /* restore windows top to bottom */
1240 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
1241 if (WINDOW_IS_CLIENT(it
->data
)) {
1242 ObClient
*client
= it
->data
;
1243 if (client_should_show(client
)) {
1244 if (!show_only
|| client
== show_only
)
1245 client_show(client
);
1247 client_iconify(client
, TRUE
, FALSE
, TRUE
);
1254 /* focus the desktop */
1255 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
1256 ObClient
*c
= it
->data
;
1257 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
1258 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
1259 client_focus(it
->data
))
1263 else if (!show_only
) {
1266 if ((c
= focus_fallback(TRUE
, FALSE
, TRUE
, FALSE
))) {
1267 /* only do the flicker reducing stuff ahead of time if we are going
1268 to call xsetinputfocus on the window ourselves. otherwise there
1269 is no guarantee the window will actually take focus.. */
1271 /* reduce flicker by hiliting now rather than waiting for the
1272 server FocusIn event */
1273 frame_adjust_focus(c
->frame
, TRUE
);
1278 show
= !!show
; /* make it boolean */
1279 PROP_SET32(RootWindow(ob_display
, ob_screen
),
1280 net_showing_desktop
, cardinal
, show
);
1283 void screen_install_colormap(ObClient
*client
, gboolean install
)
1285 if (client
== NULL
|| client
->colormap
== None
) {
1287 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1289 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1291 xerror_set_ignore(TRUE
);
1293 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1295 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1296 xerror_set_ignore(FALSE
);
1302 StrutPartial
*strut
;
1305 #define RESET_STRUT_LIST(sl) \
1306 (g_slist_free(sl), sl = NULL)
1308 #define ADD_STRUT_TO_LIST(sl, d, s) \
1310 ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
1313 sl = g_slist_prepend(sl, ss); \
1316 #define VALIDATE_STRUTS(sl, side, max) \
1319 for (it = sl; it; it = g_slist_next(it)) { \
1320 ObScreenStrut *ss = it->data; \
1321 ss->strut->side = MIN(max, ss->strut->side); \
1325 void screen_update_areas(void)
1331 g_free(monitor_area
);
1332 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1334 /* set up the user-specified margins */
1335 config_margins
.top_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1336 config_margins
.top_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1337 config_margins
.bottom_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1338 config_margins
.bottom_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1339 config_margins
.left_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1340 config_margins
.left_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1341 config_margins
.right_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1342 config_margins
.right_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1344 RESET_STRUT_LIST(struts_left
);
1345 RESET_STRUT_LIST(struts_top
);
1346 RESET_STRUT_LIST(struts_right
);
1347 RESET_STRUT_LIST(struts_bottom
);
1349 /* collect the struts */
1350 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1351 ObClient
*c
= it
->data
;
1353 ADD_STRUT_TO_LIST(struts_left
, c
->desktop
, &c
->strut
);
1355 ADD_STRUT_TO_LIST(struts_top
, c
->desktop
, &c
->strut
);
1357 ADD_STRUT_TO_LIST(struts_right
, c
->desktop
, &c
->strut
);
1358 if (c
->strut
.bottom
)
1359 ADD_STRUT_TO_LIST(struts_bottom
, c
->desktop
, &c
->strut
);
1361 if (dock_strut
.left
)
1362 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &dock_strut
);
1364 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &dock_strut
);
1365 if (dock_strut
.right
)
1366 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &dock_strut
);
1367 if (dock_strut
.bottom
)
1368 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &dock_strut
);
1370 if (config_margins
.left
)
1371 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &config_margins
);
1372 if (config_margins
.top
)
1373 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &config_margins
);
1374 if (config_margins
.right
)
1375 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &config_margins
);
1376 if (config_margins
.bottom
)
1377 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &config_margins
);
1379 VALIDATE_STRUTS(struts_left
, left
,
1380 monitor_area
[screen_num_monitors
].width
/ 2);
1381 VALIDATE_STRUTS(struts_right
, right
,
1382 monitor_area
[screen_num_monitors
].width
/ 2);
1383 VALIDATE_STRUTS(struts_top
, top
,
1384 monitor_area
[screen_num_monitors
].height
/ 2);
1385 VALIDATE_STRUTS(struts_bottom
, bottom
,
1386 monitor_area
[screen_num_monitors
].height
/ 2);
1388 dims
= g_new(gulong
, 4 * screen_num_desktops
);
1389 for (i
= 0; i
< screen_num_desktops
; ++i
) {
1390 Rect
*area
= screen_area(i
, SCREEN_AREA_ALL_MONITORS
, NULL
);
1391 dims
[i
*4+0] = area
->x
;
1392 dims
[i
*4+1] = area
->y
;
1393 dims
[i
*4+2] = area
->width
;
1394 dims
[i
*4+3] = area
->height
;
1398 /* set the legacy workarea hint to the union of all the monitors */
1399 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1400 dims
, 4 * screen_num_desktops
);
1402 /* the area has changed, adjust all the windows if they need it */
1403 for (it
= client_list
; it
; it
= g_list_next(it
))
1404 client_reconfigure(it
->data
, FALSE
);
1410 Rect
* screen_area_all_monitors(guint desktop
)
1415 a
= screen_area_monitor(desktop
, 0);
1417 /* combine all the monitors together */
1418 for (i
= 1; i
< screen_num_monitors
; ++i
) {
1419 Rect
*m
= screen_area_monitor(desktop
, i
);
1422 l
= MIN(RECT_LEFT(*a
), RECT_LEFT(*m
));
1423 t
= MIN(RECT_TOP(*a
), RECT_TOP(*m
));
1424 r
= MAX(RECT_RIGHT(*a
), RECT_RIGHT(*m
));
1425 b
= MAX(RECT_BOTTOM(*a
), RECT_BOTTOM(*m
));
1427 RECT_SET(*a
, l
, t
, r
- l
+ 1, b
- t
+ 1);
1436 #define STRUT_LEFT_IN_SEARCH(s, search) \
1437 (RANGES_INTERSECT(search->y, search->height, \
1438 s->left_start, s->left_end - s->left_start + 1))
1439 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1440 (RANGES_INTERSECT(search->y, search->height, \
1441 s->right_start, s->right_end - s->right_start + 1))
1442 #define STRUT_TOP_IN_SEARCH(s, search) \
1443 (RANGES_INTERSECT(search->x, search->width, \
1444 s->top_start, s->top_end - s->top_start + 1))
1445 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1446 (RANGES_INTERSECT(search->x, search->width, \
1447 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1449 #define STRUT_LEFT_IGNORE(s, us, search) \
1450 (head == SCREEN_AREA_ALL_MONITORS && us && \
1451 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1452 #define STRUT_RIGHT_IGNORE(s, us, search) \
1453 (head == SCREEN_AREA_ALL_MONITORS && us && \
1454 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1455 #define STRUT_TOP_IGNORE(s, us, search) \
1456 (head == SCREEN_AREA_ALL_MONITORS && us && \
1457 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1458 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1459 (head == SCREEN_AREA_ALL_MONITORS && us && \
1460 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1462 Rect
* screen_area(guint desktop
, guint head
, Rect
*search
)
1466 gint l
, r
, t
, b
, al
, ar
, at
, ab
;
1468 gboolean us
= search
!= NULL
; /* user provided search */
1470 g_assert(desktop
< screen_num_desktops
|| desktop
== DESKTOP_ALL
);
1471 g_assert(head
< screen_num_monitors
|| head
== SCREEN_AREA_ONE_MONITOR
||
1472 head
== SCREEN_AREA_ALL_MONITORS
);
1473 g_assert(!(head
== SCREEN_AREA_ONE_MONITOR
&& search
== NULL
));
1475 /* find any struts for this monitor
1476 which will be affecting the search area.
1479 /* search everything if search is null */
1481 if (head
< screen_num_monitors
) search
= &monitor_area
[head
];
1482 else search
= &monitor_area
[screen_num_monitors
];
1484 if (head
== SCREEN_AREA_ONE_MONITOR
) head
= screen_find_monitor(search
);
1486 /* al is "all left" meaning the furthest left you can get, l is our
1487 "working left" meaning our current strut edge which we're calculating
1490 /* only include monitors which the search area lines up with */
1491 if (RECT_INTERSECTS_RECT(monitor_area
[screen_num_monitors
], *search
)) {
1492 al
= l
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1493 at
= t
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1494 ar
= r
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1495 ab
= b
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1496 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1497 /* add the monitor if applicable */
1498 if (RANGES_INTERSECT(search
->x
, search
->width
,
1499 monitor_area
[i
].x
, monitor_area
[i
].width
))
1501 at
= t
= MIN(t
, RECT_TOP(monitor_area
[i
]));
1502 ab
= b
= MAX(b
, RECT_BOTTOM(monitor_area
[i
]));
1504 if (RANGES_INTERSECT(search
->y
, search
->height
,
1505 monitor_area
[i
].y
, monitor_area
[i
].height
))
1507 al
= l
= MIN(l
, RECT_LEFT(monitor_area
[i
]));
1508 ar
= r
= MAX(r
, RECT_RIGHT(monitor_area
[i
]));
1512 al
= l
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1513 at
= t
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1514 ar
= r
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1515 ab
= b
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1518 for (d
= 0; d
< screen_num_desktops
; ++d
) {
1519 if (d
!= desktop
&& desktop
!= DESKTOP_ALL
) continue;
1521 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1522 if (head
!= SCREEN_AREA_ALL_MONITORS
&& head
!= i
) continue;
1524 for (it
= struts_left
; it
; it
= g_slist_next(it
)) {
1525 ObScreenStrut
*s
= it
->data
;
1526 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1527 STRUT_LEFT_IN_SEARCH(s
->strut
, search
) &&
1528 !STRUT_LEFT_IGNORE(s
->strut
, us
, search
))
1529 l
= MAX(l
, RECT_LEFT(monitor_area
[screen_num_monitors
])
1532 for (it
= struts_top
; it
; it
= g_slist_next(it
)) {
1533 ObScreenStrut
*s
= it
->data
;
1534 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1535 STRUT_TOP_IN_SEARCH(s
->strut
, search
) &&
1536 !STRUT_TOP_IGNORE(s
->strut
, us
, search
))
1537 t
= MAX(t
, RECT_TOP(monitor_area
[screen_num_monitors
])
1540 for (it
= struts_right
; it
; it
= g_slist_next(it
)) {
1541 ObScreenStrut
*s
= it
->data
;
1542 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1543 STRUT_RIGHT_IN_SEARCH(s
->strut
, search
) &&
1544 !STRUT_RIGHT_IGNORE(s
->strut
, us
, search
))
1545 r
= MIN(r
, RECT_RIGHT(monitor_area
[screen_num_monitors
])
1548 for (it
= struts_bottom
; it
; it
= g_slist_next(it
)) {
1549 ObScreenStrut
*s
= it
->data
;
1550 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1551 STRUT_BOTTOM_IN_SEARCH(s
->strut
, search
) &&
1552 !STRUT_BOTTOM_IGNORE(s
->strut
, us
, search
))
1553 b
= MIN(b
, RECT_BOTTOM(monitor_area
[screen_num_monitors
])
1554 - s
->strut
->bottom
);
1557 /* limit to this monitor */
1559 l
= MAX(l
, RECT_LEFT(monitor_area
[i
]));
1560 t
= MAX(t
, RECT_TOP(monitor_area
[i
]));
1561 r
= MIN(r
, RECT_RIGHT(monitor_area
[i
]));
1562 b
= MIN(b
, RECT_BOTTOM(monitor_area
[i
]));
1570 a
->width
= r
- l
+ 1;
1571 a
->height
= b
- t
+ 1;
1575 guint
screen_find_monitor(Rect
*search
)
1578 guint most
= screen_num_monitors
;
1581 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1582 Rect
*area
= screen_physical_area_monitor(i
);
1583 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1587 RECT_SET_INTERSECTION(r
, *area
, *search
);
1588 v
= r
.width
* r
.height
;
1600 Rect
* screen_physical_area_all_monitors(void)
1602 return screen_physical_area_monitor(screen_num_monitors
);
1605 Rect
* screen_physical_area_monitor(guint head
)
1608 g_assert(head
<= screen_num_monitors
);
1611 *a
= monitor_area
[head
];
1615 gboolean
screen_physical_area_monitor_contains(guint head
, Rect
*search
)
1617 g_assert(head
<= screen_num_monitors
);
1619 return RECT_INTERSECTS_RECT(monitor_area
[head
], *search
);
1622 guint
screen_monitor_active(void)
1624 if (moveresize_client
)
1625 return client_monitor(moveresize_client
);
1626 else if (focus_client
)
1627 return client_monitor(focus_client
);
1629 return screen_monitor_pointer();
1632 Rect
* screen_physical_area_active(void)
1634 return screen_physical_area_monitor(screen_monitor_active());
1637 guint
screen_monitor_primary(gboolean fixed
)
1639 if (config_primary_monitor_index
> 0) {
1640 if (config_primary_monitor_index
-1 < screen_num_monitors
)
1641 return config_primary_monitor_index
- 1;
1647 else if (config_primary_monitor
== OB_PLACE_MONITOR_ACTIVE
)
1648 return screen_monitor_active();
1649 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1650 return screen_monitor_pointer();
1653 Rect
*screen_physical_area_primary(gboolean fixed
)
1655 return screen_physical_area_monitor(screen_monitor_primary(fixed
));
1658 void screen_set_root_cursor(void)
1660 if (sn_app_starting())
1661 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1662 ob_cursor(OB_CURSOR_BUSYPOINTER
));
1664 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1665 ob_cursor(OB_CURSOR_POINTER
));
1668 guint
screen_find_monitor_point(guint x
, guint y
)
1671 RECT_SET(mon
, x
, y
, 1, 1);
1672 return screen_find_monitor(&mon
);
1675 guint
screen_monitor_pointer()
1678 if (!screen_pointer_pos(&x
, &y
))
1680 return screen_find_monitor_point(x
, y
);
1683 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1690 ret
= !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1691 &w
, &w
, x
, y
, &i
, &i
, &u
);
1693 for (i
= 0; i
< ScreenCount(ob_display
); ++i
)
1695 if (XQueryPointer(ob_display
, RootWindow(ob_display
, i
),
1696 &w
, &w
, x
, y
, &i
, &i
, &u
))