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.
24 #include "startupnotify.h"
25 #include "moveresize.h"
33 #include "focus_cycle.h"
36 #include "obrender/render.h"
38 #include "obt/display.h"
39 #include "obt/xqueue.h"
41 #include "obt/mainloop.h"
45 # include <sys/types.h>
50 /*! The event mask to grab on the root window */
51 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
52 EnterWindowMask | LeaveWindowMask | \
53 SubstructureRedirectMask | FocusChangeMask | \
54 ButtonPressMask | ButtonReleaseMask)
56 static gboolean
screen_validate_layout(ObDesktopLayout
*l
);
57 static gboolean
replace_wm(void);
58 static void screen_tell_ksplash(void);
59 static void screen_fallback_focus(void);
61 guint screen_num_desktops
;
62 guint screen_num_monitors
;
64 guint screen_last_desktop
;
65 gboolean screen_showing_desktop
;
66 ObDesktopLayout screen_desktop_layout
;
67 gchar
**screen_desktop_names
;
68 Window screen_support_win
;
69 Time screen_desktop_user_time
= CurrentTime
;
71 static Size screen_physical_size
;
72 static guint screen_old_desktop
;
73 static gboolean screen_desktop_timeout
= TRUE
;
74 /*! An array of desktops, holding an array of areas per monitor */
75 static Rect
*monitor_area
= NULL
;
76 /*! An array of desktops, holding an array of struts */
77 static GSList
*struts_top
= NULL
;
78 static GSList
*struts_left
= NULL
;
79 static GSList
*struts_right
= NULL
;
80 static GSList
*struts_bottom
= NULL
;
82 static ObPagerPopup
*desktop_popup
;
83 static gboolean desktop_popup_perm
;
85 /*! The number of microseconds that you need to be on a desktop before it will
86 replace the remembered "last desktop" */
87 #define REMEMBER_LAST_DESKTOP_TIME 750000
89 static gboolean
replace_wm(void)
93 Window current_wm_sn_owner
;
96 wm_sn
= g_strdup_printf("WM_S%d", ob_screen
);
97 wm_sn_atom
= XInternAtom(obt_display
, wm_sn
, FALSE
);
100 current_wm_sn_owner
= XGetSelectionOwner(obt_display
, wm_sn_atom
);
101 if (current_wm_sn_owner
== screen_support_win
)
102 current_wm_sn_owner
= None
;
103 if (current_wm_sn_owner
) {
104 if (!ob_replace_wm
) {
105 g_message(_("A window manager is already running on screen %d"),
109 obt_display_ignore_errors(TRUE
);
111 /* We want to find out when the current selection owner dies */
112 XSelectInput(obt_display
, current_wm_sn_owner
, StructureNotifyMask
);
113 XSync(obt_display
, FALSE
);
115 obt_display_ignore_errors(FALSE
);
116 if (obt_display_error_occured
)
117 current_wm_sn_owner
= None
;
120 timestamp
= event_time();
122 XSetSelectionOwner(obt_display
, wm_sn_atom
, screen_support_win
,
125 if (XGetSelectionOwner(obt_display
, wm_sn_atom
) != screen_support_win
) {
126 g_message(_("Could not acquire window manager selection on screen %d"),
131 /* Wait for old window manager to go away */
132 if (current_wm_sn_owner
) {
134 const gulong timeout
= G_USEC_PER_SEC
* 15; /* wait for 15s max */
135 ObtXQueueWindowType wt
;
137 wt
.window
= current_wm_sn_owner
;
138 wt
.type
= DestroyNotify
;
140 while (wait
< timeout
) {
141 /* Checks the local queue and incoming events for this event */
142 if (xqueue_exists_local(xqueue_match_window_type
, &wt
))
144 g_usleep(G_USEC_PER_SEC
/ 10);
145 wait
+= G_USEC_PER_SEC
/ 10;
148 if (wait
>= timeout
) {
149 g_message(_("The WM on screen %d is not exiting"), ob_screen
);
154 /* Send client message indicating that we are now the WM */
155 obt_prop_message(ob_screen
, obt_root(ob_screen
), OBT_PROP_ATOM(MANAGER
),
156 timestamp
, wm_sn_atom
, screen_support_win
, 0, 0,
157 SubstructureNotifyMask
);
162 gboolean
screen_annex(void)
164 XSetWindowAttributes attrib
;
169 /* create the netwm support window */
170 attrib
.override_redirect
= TRUE
;
171 attrib
.event_mask
= PropertyChangeMask
;
172 screen_support_win
= XCreateWindow(obt_display
, obt_root(ob_screen
),
174 CopyFromParent
, InputOutput
,
176 CWEventMask
| CWOverrideRedirect
,
178 XMapWindow(obt_display
, screen_support_win
);
179 XLowerWindow(obt_display
, screen_support_win
);
182 XDestroyWindow(obt_display
, screen_support_win
);
186 obt_display_ignore_errors(TRUE
);
187 XSelectInput(obt_display
, obt_root(ob_screen
), ROOT_EVENTMASK
);
188 obt_display_ignore_errors(FALSE
);
189 if (obt_display_error_occured
) {
190 g_message(_("A window manager is already running on screen %d"),
193 XDestroyWindow(obt_display
, screen_support_win
);
197 screen_set_root_cursor();
199 /* set the OPENBOX_PID hint */
201 OBT_PROP_SET32(obt_root(ob_screen
), OPENBOX_PID
, CARDINAL
, pid
);
203 /* set supporting window */
204 OBT_PROP_SET32(obt_root(ob_screen
),
205 NET_SUPPORTING_WM_CHECK
, WINDOW
, screen_support_win
);
207 /* set properties on the supporting window */
208 OBT_PROP_SETS(screen_support_win
, NET_WM_NAME
, utf8
, "Openbox");
209 OBT_PROP_SET32(screen_support_win
, NET_SUPPORTING_WM_CHECK
,
210 WINDOW
, screen_support_win
);
212 /* set the _NET_SUPPORTED_ATOMS hint */
214 /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
215 num_support
= OBT_PROP_NUM_ATOMS
- OBT_PROP_NET_SUPPORTED
- 1;
217 supported
= g_new(gulong
, num_support
);
218 supported
[i
++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK
);
219 supported
[i
++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT
);
220 supported
[i
++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP
);
221 supported
[i
++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS
);
222 supported
[i
++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY
);
223 supported
[i
++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT
);
224 supported
[i
++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW
);
225 supported
[i
++] = OBT_PROP_ATOM(NET_WORKAREA
);
226 supported
[i
++] = OBT_PROP_ATOM(NET_CLIENT_LIST
);
227 supported
[i
++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING
);
228 supported
[i
++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES
);
229 supported
[i
++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW
);
230 supported
[i
++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT
);
231 supported
[i
++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP
);
232 supported
[i
++] = OBT_PROP_ATOM(NET_WM_NAME
);
233 supported
[i
++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME
);
234 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ICON_NAME
);
235 supported
[i
++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME
);
236 supported
[i
++] = OBT_PROP_ATOM(NET_WM_DESKTOP
);
237 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STRUT
);
238 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL
);
239 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ICON
);
240 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY
);
241 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE
);
242 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP
);
243 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK
);
244 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR
);
245 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU
);
246 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY
);
247 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH
);
248 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG
);
249 supported
[i
++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL
);
250 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS
);
251 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE
);
252 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE
);
253 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE
);
254 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE
);
255 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ
);
256 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT
);
257 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN
);
258 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP
);
259 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE
);
260 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE
);
261 supported
[i
++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW
);
262 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE
);
263 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL
);
264 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT
);
265 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ
);
266 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED
);
267 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR
);
268 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER
);
269 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN
);
270 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN
);
271 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE
);
272 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW
);
273 supported
[i
++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION
);
274 supported
[i
++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW
);
275 supported
[i
++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE
);
276 supported
[i
++] = OBT_PROP_ATOM(NET_WM_USER_TIME
);
278 supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
280 supported
[i
++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS
);
281 supported
[i
++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS
);
282 supported
[i
++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW
);
283 supported
[i
++] = OBT_PROP_ATOM(NET_STARTUP_ID
);
285 supported
[i
++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST
);
286 supported
[i
++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER
);
288 supported
[i
++] = OBT_PROP_ATOM(NET_WM_PID
);
289 supported
[i
++] = OBT_PROP_ATOM(NET_WM_PING
);
291 supported
[i
++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE
);
292 supported
[i
++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT
);
293 supported
[i
++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE
);
295 supported
[i
++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE
);
296 supported
[i
++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED
);
297 supported
[i
++] = OBT_PROP_ATOM(OPENBOX_PID
);
298 supported
[i
++] = OBT_PROP_ATOM(OB_THEME
);
299 supported
[i
++] = OBT_PROP_ATOM(OB_CONFIG_FILE
);
300 supported
[i
++] = OBT_PROP_ATOM(OB_CONTROL
);
301 supported
[i
++] = OBT_PROP_ATOM(OB_VERSION
);
302 supported
[i
++] = OBT_PROP_ATOM(OB_APP_ROLE
);
303 supported
[i
++] = OBT_PROP_ATOM(OB_APP_TITLE
);
304 supported
[i
++] = OBT_PROP_ATOM(OB_APP_NAME
);
305 supported
[i
++] = OBT_PROP_ATOM(OB_APP_CLASS
);
306 supported
[i
++] = OBT_PROP_ATOM(OB_APP_TYPE
);
307 g_assert(i
== num_support
);
309 OBT_PROP_SETA32(obt_root(ob_screen
),
310 NET_SUPPORTED
, ATOM
, supported
, num_support
);
313 OBT_PROP_SETS(RootWindow(obt_display
, ob_screen
), OB_VERSION
, utf8
,
316 screen_tell_ksplash();
321 static void screen_tell_ksplash(void)
326 argv
= g_new(gchar
*, 6);
327 argv
[0] = g_strdup("dcop");
328 argv
[1] = g_strdup("ksplash");
329 argv
[2] = g_strdup("ksplash");
330 argv
[3] = g_strdup("upAndRunning(QString)");
331 argv
[4] = g_strdup("wm started");
334 /* tell ksplash through the dcop server command line interface */
335 g_spawn_async(NULL
, argv
, NULL
,
336 G_SPAWN_SEARCH_PATH
| G_SPAWN_DO_NOT_REAP_CHILD
|
337 G_SPAWN_STDERR_TO_DEV_NULL
| G_SPAWN_STDOUT_TO_DEV_NULL
,
338 NULL
, NULL
, NULL
, NULL
);
341 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
342 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
343 something. oh well. */
344 e
.xclient
.type
= ClientMessage
;
345 e
.xclient
.display
= obt_display
;
346 e
.xclient
.window
= obt_root(ob_screen
);
347 e
.xclient
.message_type
=
348 XInternAtom(obt_display
, "_KDE_SPLASH_PROGRESS", False
);
349 e
.xclient
.format
= 8;
350 strcpy(e
.xclient
.data
.b
, "wm started");
351 XSendEvent(obt_display
, obt_root(ob_screen
),
352 False
, SubstructureNotifyMask
, &e
);
355 void screen_startup(gboolean reconfig
)
357 gchar
**names
= NULL
;
359 gboolean namesexist
= FALSE
;
361 desktop_popup
= pager_popup_new();
362 desktop_popup_perm
= FALSE
;
363 pager_popup_height(desktop_popup
, POPUP_HEIGHT
);
366 /* update the pager popup's width */
367 pager_popup_text_width_to_strings(desktop_popup
,
368 screen_desktop_names
,
369 screen_num_desktops
);
373 /* get the initial size */
376 /* have names already been set for the desktops? */
377 if (OBT_PROP_GETSS(obt_root(ob_screen
), NET_DESKTOP_NAMES
, utf8
, &names
)) {
382 /* if names don't exist and we have session names, set those.
383 do this stuff BEFORE setting the number of desktops, because that
384 will create default names for them
386 if (!namesexist
&& session_desktop_names
!= NULL
) {
390 /* get the desktop names */
391 numnames
= g_slist_length(session_desktop_names
);
392 names
= g_new(gchar
*, numnames
+ 1);
393 names
[numnames
] = NULL
;
394 for (i
= 0, it
= session_desktop_names
; it
; ++i
, it
= g_slist_next(it
))
395 names
[i
] = g_strdup(it
->data
);
397 /* set the root window property */
398 OBT_PROP_SETSS(obt_root(ob_screen
),
399 NET_DESKTOP_NAMES
, utf8
, (const gchar
**)names
);
404 /* set the number of desktops, if it's not already set.
406 this will also set the default names from the config file up for
407 desktops that don't have names yet */
408 screen_num_desktops
= 0;
409 if (OBT_PROP_GET32(obt_root(ob_screen
),
410 NET_NUMBER_OF_DESKTOPS
, CARDINAL
, &d
))
412 if (d
!= config_desktops_num
) {
413 /* TRANSLATORS: If you need to specify a different order of the
414 arguments, you can use %1$d for the first one and %2$d for the
415 second one. For example,
416 "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
417 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
),
418 config_desktops_num
, d
);
420 screen_set_num_desktops(d
);
422 /* restore from session if possible */
423 else if (session_num_desktops
)
424 screen_set_num_desktops(session_num_desktops
);
426 screen_set_num_desktops(config_desktops_num
);
428 screen_desktop
= screen_num_desktops
; /* something invalid */
429 /* start on the current desktop when a wm was already running */
430 if (OBT_PROP_GET32(obt_root(ob_screen
),
431 NET_CURRENT_DESKTOP
, CARDINAL
, &d
) &&
432 d
< screen_num_desktops
)
434 screen_set_desktop(d
, FALSE
);
435 } else if (session_desktop
>= 0)
436 screen_set_desktop(MIN((guint
)session_desktop
,
437 screen_num_desktops
), FALSE
);
439 screen_set_desktop(MIN(config_screen_firstdesk
,
440 screen_num_desktops
) - 1, FALSE
);
441 screen_last_desktop
= screen_desktop
;
443 /* don't start in showing-desktop mode */
444 screen_showing_desktop
= FALSE
;
445 OBT_PROP_SET32(obt_root(ob_screen
),
446 NET_SHOWING_DESKTOP
, CARDINAL
, screen_showing_desktop
);
448 if (session_desktop_layout_present
&&
449 screen_validate_layout(&session_desktop_layout
))
451 screen_desktop_layout
= session_desktop_layout
;
454 screen_update_layout();
457 void screen_shutdown(gboolean reconfig
)
459 pager_popup_free(desktop_popup
);
464 XSelectInput(obt_display
, obt_root(ob_screen
), NoEventMask
);
466 /* we're not running here no more! */
467 OBT_PROP_ERASE(obt_root(ob_screen
), OPENBOX_PID
);
469 OBT_PROP_ERASE(obt_root(ob_screen
), NET_SUPPORTED
);
470 /* don't keep this mode */
471 OBT_PROP_ERASE(obt_root(ob_screen
), NET_SHOWING_DESKTOP
);
473 XDestroyWindow(obt_display
, screen_support_win
);
475 g_strfreev(screen_desktop_names
);
476 screen_desktop_names
= NULL
;
479 void screen_resize(void)
481 static gint oldw
= 0, oldh
= 0;
486 w
= WidthOfScreen(ScreenOfDisplay(obt_display
, ob_screen
));
487 h
= HeightOfScreen(ScreenOfDisplay(obt_display
, ob_screen
));
489 if (w
== oldw
&& h
== oldh
) return;
493 /* Set the _NET_DESKTOP_GEOMETRY hint */
494 screen_physical_size
.width
= geometry
[0] = w
;
495 screen_physical_size
.height
= geometry
[1] = h
;
496 OBT_PROP_SETA32(obt_root(ob_screen
),
497 NET_DESKTOP_GEOMETRY
, CARDINAL
, geometry
, 2);
499 if (ob_state() != OB_STATE_RUNNING
)
502 screen_update_areas();
505 for (it
= client_list
; it
; it
= g_list_next(it
))
506 client_move_onscreen(it
->data
, FALSE
);
509 void screen_set_num_desktops(guint num
)
512 GList
*it
, *stacking_copy
;
516 if (screen_num_desktops
== num
) return;
518 screen_num_desktops
= num
;
519 OBT_PROP_SET32(obt_root(ob_screen
), NET_NUMBER_OF_DESKTOPS
, CARDINAL
, num
);
521 /* set the viewport hint */
522 viewport
= g_new0(gulong
, num
* 2);
523 OBT_PROP_SETA32(obt_root(ob_screen
),
524 NET_DESKTOP_VIEWPORT
, CARDINAL
, viewport
, num
* 2);
527 /* the number of rows/columns will differ */
528 screen_update_layout();
530 /* move windows on desktops that will no longer exist!
531 make a copy of the list cuz we're changing it */
532 stacking_copy
= g_list_copy(stacking_list
);
533 for (it
= g_list_last(stacking_copy
); it
; it
= g_list_previous(it
)) {
534 if (WINDOW_IS_CLIENT(it
->data
)) {
535 ObClient
*c
= it
->data
;
536 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
>= num
)
537 client_set_desktop(c
, num
- 1, FALSE
, TRUE
);
538 /* raise all the windows that are on the current desktop which
540 else if (screen_desktop
== num
- 1 &&
541 (c
->desktop
== DESKTOP_ALL
||
542 c
->desktop
== screen_desktop
))
543 stacking_raise(CLIENT_AS_WINDOW(c
));
546 g_list_free(stacking_copy
);
548 /* change our struts/area to match (after moving windows) */
549 screen_update_areas();
551 /* may be some unnamed desktops that we need to fill in with names
552 (after updating the areas so the popup can resize) */
553 screen_update_desktop_names();
555 /* change our desktop if we're on one that no longer exists! */
556 if (screen_desktop
>= screen_num_desktops
)
557 screen_set_desktop(num
- 1, TRUE
);
560 static void screen_fallback_focus(void)
565 /* only allow omnipresent windows to get focus on desktop change if
566 an omnipresent window is already focused (it'll keep focus probably, but
567 maybe not depending on mouse-focus options) */
568 allow_omni
= focus_client
&& (client_normal(focus_client
) &&
569 focus_client
->desktop
== DESKTOP_ALL
);
571 /* the client moved there already so don't move focus. prevent flicker
572 on sendtodesktop + follow */
573 if (focus_client
&& focus_client
->desktop
== screen_desktop
)
576 /* have to try focus here because when you leave an empty desktop
577 there is no focus out to watch for. also, we have different rules
578 here. we always allow it to look under the mouse pointer if
579 config_focus_last is FALSE
581 do this before hiding the windows so if helper windows are coming
582 with us, they don't get hidden
584 if ((c
= focus_fallback(TRUE
, !config_focus_last
, allow_omni
,
587 /* only do the flicker reducing stuff ahead of time if we are going
588 to call xsetinputfocus on the window ourselves. otherwise there is
589 no guarantee the window will actually take focus.. */
591 /* reduce flicker by hiliting now rather than waiting for the
592 server FocusIn event */
593 frame_adjust_focus(c
->frame
, TRUE
);
594 /* do this here so that if you switch desktops to a window with
595 helper windows then the helper windows won't flash */
596 client_bring_helper_windows(c
);
601 static gboolean
last_desktop_func(gpointer data
)
603 screen_desktop_timeout
= TRUE
;
607 void screen_set_desktop(guint num
, gboolean dofocus
)
613 g_assert(num
< screen_num_desktops
);
615 previous
= screen_desktop
;
616 screen_desktop
= num
;
618 if (previous
== num
) return;
620 OBT_PROP_SET32(obt_root(ob_screen
), 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 obt_main_loop_timeout_remove(ob_main_loop
, last_desktop_func
);
687 obt_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", num
+1);
692 if (ob_state() == OB_STATE_RUNNING
)
693 screen_show_desktop_popup(screen_desktop
, FALSE
);
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
;
717 if (client_hide(c
)) {
718 if (c
== focus_client
) {
719 /* c was focused and we didn't do fallback clearly so make
720 sure openbox doesnt still consider the window focused.
721 this happens when using NextWindow with allDesktops,
722 since it doesnt want to move focus on desktop change,
723 but the focus is not going to stay with the current
724 window, which has now disappeared.
725 only do this if the client was actually hidden,
726 otherwise it can keep focus. */
727 focus_set_client(NULL
);
733 focus_cycle_addremove(NULL
, TRUE
);
735 event_end_ignore_all_enters(ignore_start
);
737 if (event_source_time() != CurrentTime
)
738 screen_desktop_user_time
= event_source_time();
741 void screen_add_desktop(gboolean current
)
745 /* ignore enter events caused by this */
746 ignore_start
= event_start_ignore_all_enters();
748 screen_set_num_desktops(screen_num_desktops
+1);
750 /* move all the clients over */
754 for (it
= client_list
; it
; it
= g_list_next(it
)) {
755 ObClient
*c
= it
->data
;
756 if (c
->desktop
!= DESKTOP_ALL
&& c
->desktop
>= screen_desktop
&&
757 /* don't move direct children, they'll be moved with their
758 parent - which will have to be on the same desktop */
759 !client_direct_parent(c
))
761 ob_debug("moving window %s", c
->title
);
762 client_set_desktop(c
, c
->desktop
+1, FALSE
, TRUE
);
767 event_end_ignore_all_enters(ignore_start
);
770 void screen_remove_desktop(gboolean current
)
772 guint rmdesktop
, movedesktop
;
773 GList
*it
, *stacking_copy
;
776 if (screen_num_desktops
<= 1) return;
778 /* ignore enter events caused by this */
779 ignore_start
= event_start_ignore_all_enters();
781 /* what desktop are we removing and moving to? */
783 rmdesktop
= screen_desktop
;
785 rmdesktop
= screen_num_desktops
- 1;
786 if (rmdesktop
< screen_num_desktops
- 1)
787 movedesktop
= rmdesktop
+ 1;
789 movedesktop
= rmdesktop
;
791 /* make a copy of the list cuz we're changing it */
792 stacking_copy
= g_list_copy(stacking_list
);
793 for (it
= g_list_last(stacking_copy
); it
; it
= g_list_previous(it
)) {
794 if (WINDOW_IS_CLIENT(it
->data
)) {
795 ObClient
*c
= it
->data
;
796 guint d
= c
->desktop
;
797 if (d
!= DESKTOP_ALL
&& d
>= movedesktop
&&
798 /* don't move direct children, they'll be moved with their
799 parent - which will have to be on the same desktop */
800 !client_direct_parent(c
))
802 ob_debug("moving window %s", c
->title
);
803 client_set_desktop(c
, c
->desktop
- 1, TRUE
, TRUE
);
805 /* raise all the windows that are on the current desktop which
807 if ((screen_desktop
== rmdesktop
- 1 ||
808 screen_desktop
== rmdesktop
) &&
809 (d
== DESKTOP_ALL
|| d
== screen_desktop
))
811 stacking_raise(CLIENT_AS_WINDOW(c
));
812 ob_debug("raising window %s", c
->title
);
816 g_list_free(stacking_copy
);
818 /* fallback focus like we're changing desktops */
819 if (screen_desktop
< screen_num_desktops
- 1) {
820 screen_fallback_focus();
821 ob_debug("fake desktop change");
824 screen_set_num_desktops(screen_num_desktops
-1);
826 event_end_ignore_all_enters(ignore_start
);
829 static void get_row_col(guint d
, guint
*r
, guint
*c
)
831 switch (screen_desktop_layout
.orientation
) {
832 case OB_ORIENTATION_HORZ
:
833 switch (screen_desktop_layout
.start_corner
) {
834 case OB_CORNER_TOPLEFT
:
835 *r
= d
/ screen_desktop_layout
.columns
;
836 *c
= d
% screen_desktop_layout
.columns
;
838 case OB_CORNER_BOTTOMLEFT
:
839 *r
= screen_desktop_layout
.rows
- 1 -
840 d
/ screen_desktop_layout
.columns
;
841 *c
= d
% screen_desktop_layout
.columns
;
843 case OB_CORNER_TOPRIGHT
:
844 *r
= d
/ screen_desktop_layout
.columns
;
845 *c
= screen_desktop_layout
.columns
- 1 -
846 d
% screen_desktop_layout
.columns
;
848 case OB_CORNER_BOTTOMRIGHT
:
849 *r
= screen_desktop_layout
.rows
- 1 -
850 d
/ screen_desktop_layout
.columns
;
851 *c
= screen_desktop_layout
.columns
- 1 -
852 d
% screen_desktop_layout
.columns
;
856 case OB_ORIENTATION_VERT
:
857 switch (screen_desktop_layout
.start_corner
) {
858 case OB_CORNER_TOPLEFT
:
859 *r
= d
% screen_desktop_layout
.rows
;
860 *c
= d
/ screen_desktop_layout
.rows
;
862 case OB_CORNER_BOTTOMLEFT
:
863 *r
= screen_desktop_layout
.rows
- 1 -
864 d
% screen_desktop_layout
.rows
;
865 *c
= d
/ screen_desktop_layout
.rows
;
867 case OB_CORNER_TOPRIGHT
:
868 *r
= d
% screen_desktop_layout
.rows
;
869 *c
= screen_desktop_layout
.columns
- 1 -
870 d
/ screen_desktop_layout
.rows
;
872 case OB_CORNER_BOTTOMRIGHT
:
873 *r
= screen_desktop_layout
.rows
- 1 -
874 d
% screen_desktop_layout
.rows
;
875 *c
= screen_desktop_layout
.columns
- 1 -
876 d
/ screen_desktop_layout
.rows
;
883 static guint
translate_row_col(guint r
, guint c
)
885 switch (screen_desktop_layout
.orientation
) {
886 case OB_ORIENTATION_HORZ
:
887 switch (screen_desktop_layout
.start_corner
) {
888 case OB_CORNER_TOPLEFT
:
889 return r
% screen_desktop_layout
.rows
*
890 screen_desktop_layout
.columns
+
891 c
% screen_desktop_layout
.columns
;
892 case OB_CORNER_BOTTOMLEFT
:
893 return (screen_desktop_layout
.rows
- 1 -
894 r
% screen_desktop_layout
.rows
) *
895 screen_desktop_layout
.columns
+
896 c
% screen_desktop_layout
.columns
;
897 case OB_CORNER_TOPRIGHT
:
898 return r
% screen_desktop_layout
.rows
*
899 screen_desktop_layout
.columns
+
900 (screen_desktop_layout
.columns
- 1 -
901 c
% screen_desktop_layout
.columns
);
902 case OB_CORNER_BOTTOMRIGHT
:
903 return (screen_desktop_layout
.rows
- 1 -
904 r
% screen_desktop_layout
.rows
) *
905 screen_desktop_layout
.columns
+
906 (screen_desktop_layout
.columns
- 1 -
907 c
% screen_desktop_layout
.columns
);
909 case OB_ORIENTATION_VERT
:
910 switch (screen_desktop_layout
.start_corner
) {
911 case OB_CORNER_TOPLEFT
:
912 return c
% screen_desktop_layout
.columns
*
913 screen_desktop_layout
.rows
+
914 r
% screen_desktop_layout
.rows
;
915 case OB_CORNER_BOTTOMLEFT
:
916 return c
% screen_desktop_layout
.columns
*
917 screen_desktop_layout
.rows
+
918 (screen_desktop_layout
.rows
- 1 -
919 r
% screen_desktop_layout
.rows
);
920 case OB_CORNER_TOPRIGHT
:
921 return (screen_desktop_layout
.columns
- 1 -
922 c
% screen_desktop_layout
.columns
) *
923 screen_desktop_layout
.rows
+
924 r
% screen_desktop_layout
.rows
;
925 case OB_CORNER_BOTTOMRIGHT
:
926 return (screen_desktop_layout
.columns
- 1 -
927 c
% screen_desktop_layout
.columns
) *
928 screen_desktop_layout
.rows
+
929 (screen_desktop_layout
.rows
- 1 -
930 r
% screen_desktop_layout
.rows
);
933 g_assert_not_reached();
937 static gboolean
hide_desktop_popup_func(gpointer data
)
939 pager_popup_hide(desktop_popup
);
940 return FALSE
; /* don't repeat */
943 void screen_show_desktop_popup(guint d
, gboolean perm
)
947 /* 0 means don't show the popup */
948 if (!config_desktop_popup_time
) return;
950 a
= screen_physical_area_primary(FALSE
);
951 pager_popup_position(desktop_popup
, CenterGravity
,
952 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
953 pager_popup_icon_size_multiplier(desktop_popup
,
954 (screen_desktop_layout
.columns
/
955 screen_desktop_layout
.rows
) / 2,
956 (screen_desktop_layout
.rows
/
957 screen_desktop_layout
.columns
) / 2);
958 pager_popup_max_width(desktop_popup
,
959 MAX(a
->width
/3, POPUP_WIDTH
));
960 pager_popup_show(desktop_popup
, screen_desktop_names
[d
], d
);
962 obt_main_loop_timeout_remove(ob_main_loop
, hide_desktop_popup_func
);
963 if (!perm
&& !desktop_popup_perm
)
964 /* only hide if its not already being show permanently */
965 obt_main_loop_timeout_add(ob_main_loop
,
966 config_desktop_popup_time
* 1000,
967 hide_desktop_popup_func
, desktop_popup
,
968 g_direct_equal
, NULL
);
970 desktop_popup_perm
= TRUE
;
973 void screen_hide_desktop_popup(void)
975 obt_main_loop_timeout_remove_data(ob_main_loop
, hide_desktop_popup_func
,
976 desktop_popup
, FALSE
);
977 pager_popup_hide(desktop_popup
);
978 desktop_popup_perm
= FALSE
;
981 guint
screen_find_desktop(guint from
, ObDirection dir
,
982 gboolean wrap
, gboolean linear
)
988 get_row_col(d
, &r
, &c
);
991 case OB_DIRECTION_EAST
:
992 if (d
< screen_num_desktops
- 1)
999 case OB_DIRECTION_WEST
:
1003 d
= screen_num_desktops
- 1;
1008 g_assert_not_reached();
1013 case OB_DIRECTION_EAST
:
1015 if (c
>= screen_desktop_layout
.columns
) {
1021 d
= translate_row_col(r
, c
);
1022 if (d
>= screen_num_desktops
) {
1029 case OB_DIRECTION_WEST
:
1031 if (c
>= screen_desktop_layout
.columns
) {
1033 c
= screen_desktop_layout
.columns
- 1;
1037 d
= translate_row_col(r
, c
);
1038 if (d
>= screen_num_desktops
) {
1045 case OB_DIRECTION_SOUTH
:
1047 if (r
>= screen_desktop_layout
.rows
) {
1053 d
= translate_row_col(r
, c
);
1054 if (d
>= screen_num_desktops
) {
1061 case OB_DIRECTION_NORTH
:
1063 if (r
>= screen_desktop_layout
.rows
) {
1065 r
= screen_desktop_layout
.rows
- 1;
1069 d
= translate_row_col(r
, c
);
1070 if (d
>= screen_num_desktops
) {
1078 g_assert_not_reached();
1082 d
= translate_row_col(r
, c
);
1087 static gboolean
screen_validate_layout(ObDesktopLayout
*l
)
1089 if (l
->columns
== 0 && l
->rows
== 0) /* both 0's is bad data.. */
1092 /* fill in a zero rows/columns */
1093 if (l
->columns
== 0) {
1094 l
->columns
= screen_num_desktops
/ l
->rows
;
1095 if (l
->rows
* l
->columns
< screen_num_desktops
)
1097 if (l
->rows
* l
->columns
>= screen_num_desktops
+ l
->columns
)
1099 } else if (l
->rows
== 0) {
1100 l
->rows
= screen_num_desktops
/ l
->columns
;
1101 if (l
->columns
* l
->rows
< screen_num_desktops
)
1103 if (l
->columns
* l
->rows
>= screen_num_desktops
+ l
->rows
)
1107 /* bounds checking */
1108 if (l
->orientation
== OB_ORIENTATION_HORZ
) {
1109 l
->columns
= MIN(screen_num_desktops
, l
->columns
);
1110 l
->rows
= MIN(l
->rows
,
1111 (screen_num_desktops
+ l
->columns
- 1) / l
->columns
);
1112 l
->columns
= screen_num_desktops
/ l
->rows
+
1113 !!(screen_num_desktops
% l
->rows
);
1115 l
->rows
= MIN(screen_num_desktops
, l
->rows
);
1116 l
->columns
= MIN(l
->columns
,
1117 (screen_num_desktops
+ l
->rows
- 1) / l
->rows
);
1118 l
->rows
= screen_num_desktops
/ l
->columns
+
1119 !!(screen_num_desktops
% l
->columns
);
1124 void screen_update_layout(void)
1131 screen_desktop_layout
.orientation
= OB_ORIENTATION_HORZ
;
1132 screen_desktop_layout
.start_corner
= OB_CORNER_TOPLEFT
;
1133 screen_desktop_layout
.rows
= 1;
1134 screen_desktop_layout
.columns
= screen_num_desktops
;
1136 if (OBT_PROP_GETA32(obt_root(ob_screen
),
1137 NET_DESKTOP_LAYOUT
, CARDINAL
, &data
, &num
)) {
1138 if (num
== 3 || num
== 4) {
1140 if (data
[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT
))
1141 l
.orientation
= OB_ORIENTATION_VERT
;
1142 else if (data
[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ
))
1143 l
.orientation
= OB_ORIENTATION_HORZ
;
1148 l
.start_corner
= OB_CORNER_TOPLEFT
;
1150 if (data
[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT
))
1151 l
.start_corner
= OB_CORNER_TOPLEFT
;
1152 else if (data
[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT
))
1153 l
.start_corner
= OB_CORNER_TOPRIGHT
;
1154 else if (data
[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT
))
1155 l
.start_corner
= OB_CORNER_BOTTOMRIGHT
;
1156 else if (data
[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT
))
1157 l
.start_corner
= OB_CORNER_BOTTOMLEFT
;
1162 l
.columns
= data
[1];
1165 if (screen_validate_layout(&l
))
1166 screen_desktop_layout
= l
;
1173 void screen_update_desktop_names(void)
1177 /* empty the array */
1178 g_strfreev(screen_desktop_names
);
1179 screen_desktop_names
= NULL
;
1181 if (OBT_PROP_GETSS(obt_root(ob_screen
),
1182 NET_DESKTOP_NAMES
, utf8
, &screen_desktop_names
))
1183 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
1186 if (i
< screen_num_desktops
) {
1189 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
1190 screen_num_desktops
+ 1);
1191 screen_desktop_names
[screen_num_desktops
] = NULL
;
1193 it
= g_slist_nth(config_desktops_names
, i
);
1195 for (; i
< screen_num_desktops
; ++i
) {
1196 if (it
&& ((char*)it
->data
)[0]) /* not empty */
1197 /* use the names from the config file when possible */
1198 screen_desktop_names
[i
] = g_strdup(it
->data
);
1200 /* make up a nice name if it's not though */
1201 screen_desktop_names
[i
] = g_strdup_printf(_("desktop %i"),
1203 if (it
) it
= g_slist_next(it
);
1206 /* if we changed any names, then set the root property so we can
1207 all agree on the names */
1208 OBT_PROP_SETSS(obt_root(ob_screen
), NET_DESKTOP_NAMES
,
1209 utf8
, (const gchar
**)screen_desktop_names
);
1212 /* resize the pager for these names */
1213 pager_popup_text_width_to_strings(desktop_popup
,
1214 screen_desktop_names
,
1215 screen_num_desktops
);
1218 void screen_show_desktop(gboolean show
, ObClient
*show_only
)
1222 if (show
== screen_showing_desktop
) return; /* no change */
1224 screen_showing_desktop
= show
;
1227 /* hide windows bottom to top */
1228 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
1229 if (WINDOW_IS_CLIENT(it
->data
)) {
1230 ObClient
*client
= it
->data
;
1231 client_showhide(client
);
1236 /* restore windows top to bottom */
1237 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
1238 if (WINDOW_IS_CLIENT(it
->data
)) {
1239 ObClient
*client
= it
->data
;
1240 if (client_should_show(client
)) {
1241 if (!show_only
|| client
== show_only
)
1242 client_show(client
);
1244 client_iconify(client
, TRUE
, FALSE
, TRUE
);
1251 /* focus the desktop */
1252 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
1253 ObClient
*c
= it
->data
;
1254 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
1255 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
1256 client_focus(it
->data
))
1260 else if (!show_only
) {
1263 if ((c
= focus_fallback(TRUE
, FALSE
, TRUE
, FALSE
))) {
1264 /* only do the flicker reducing stuff ahead of time if we are going
1265 to call xsetinputfocus on the window ourselves. otherwise there
1266 is no guarantee the window will actually take focus.. */
1268 /* reduce flicker by hiliting now rather than waiting for the
1269 server FocusIn event */
1270 frame_adjust_focus(c
->frame
, TRUE
);
1275 show
= !!show
; /* make it boolean */
1276 OBT_PROP_SET32(obt_root(ob_screen
), NET_SHOWING_DESKTOP
, CARDINAL
, show
);
1279 void screen_install_colormap(ObClient
*client
, gboolean install
)
1281 if (client
== NULL
|| client
->colormap
== None
) {
1283 XInstallColormap(obt_display
, RrColormap(ob_rr_inst
));
1285 XUninstallColormap(obt_display
, RrColormap(ob_rr_inst
));
1287 obt_display_ignore_errors(TRUE
);
1289 XInstallColormap(obt_display
, client
->colormap
);
1291 XUninstallColormap(obt_display
, client
->colormap
);
1292 obt_display_ignore_errors(FALSE
);
1298 StrutPartial
*strut
;
1301 #define RESET_STRUT_LIST(sl) \
1303 g_slice_free(ObScreenStrut, (sl)->data); \
1304 sl = g_slist_delete_link(sl, sl); \
1307 #define ADD_STRUT_TO_LIST(sl, d, s) \
1309 ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1312 sl = g_slist_prepend(sl, ss); \
1315 #define VALIDATE_STRUTS(sl, side, max) \
1318 for (it = sl; it; it = g_slist_next(it)) { \
1319 ObScreenStrut *ss = it->data; \
1320 ss->strut->side = MIN(max, ss->strut->side); \
1324 static void get_xinerama_screens(Rect
**xin_areas
, guint
*nxin
)
1329 XineramaScreenInfo
*info
;
1332 if (ob_debug_xinerama
) {
1333 gint w
= WidthOfScreen(ScreenOfDisplay(obt_display
, ob_screen
));
1334 gint h
= HeightOfScreen(ScreenOfDisplay(obt_display
, ob_screen
));
1336 *xin_areas
= g_new(Rect
, *nxin
+ 1);
1337 RECT_SET((*xin_areas
)[0], 0, 0, w
/2, h
);
1338 RECT_SET((*xin_areas
)[1], w
/2, 0, w
-(w
/2), h
);
1341 else if (obt_display_extension_xinerama
&&
1342 (info
= XineramaQueryScreens(obt_display
, &n
))) {
1344 *xin_areas
= g_new(Rect
, *nxin
+ 1);
1345 for (i
= 0; i
< *nxin
; ++i
)
1346 RECT_SET((*xin_areas
)[i
], info
[i
].x_org
, info
[i
].y_org
,
1347 info
[i
].width
, info
[i
].height
);
1353 *xin_areas
= g_new(Rect
, *nxin
+ 1);
1354 RECT_SET((*xin_areas
)[0], 0, 0,
1355 WidthOfScreen(ScreenOfDisplay(obt_display
, ob_screen
)),
1356 HeightOfScreen(ScreenOfDisplay(obt_display
, ob_screen
)));
1359 /* returns one extra with the total area in it */
1360 l
= (*xin_areas
)[0].x
;
1361 t
= (*xin_areas
)[0].y
;
1362 r
= (*xin_areas
)[0].x
+ (*xin_areas
)[0].width
- 1;
1363 b
= (*xin_areas
)[0].y
+ (*xin_areas
)[0].height
- 1;
1364 for (i
= 1; i
< *nxin
; ++i
) {
1365 l
= MIN(l
, (*xin_areas
)[i
].x
);
1366 t
= MIN(l
, (*xin_areas
)[i
].y
);
1367 r
= MAX(r
, (*xin_areas
)[i
].x
+ (*xin_areas
)[i
].width
- 1);
1368 b
= MAX(b
, (*xin_areas
)[i
].y
+ (*xin_areas
)[i
].height
- 1);
1370 RECT_SET((*xin_areas
)[*nxin
], l
, t
, r
- l
+ 1, b
- t
+ 1);
1373 void screen_update_areas(void)
1379 g_free(monitor_area
);
1380 get_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1382 /* set up the user-specified margins */
1383 config_margins
.top_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1384 config_margins
.top_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1385 config_margins
.bottom_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1386 config_margins
.bottom_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1387 config_margins
.left_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1388 config_margins
.left_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1389 config_margins
.right_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1390 config_margins
.right_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1392 RESET_STRUT_LIST(struts_left
);
1393 RESET_STRUT_LIST(struts_top
);
1394 RESET_STRUT_LIST(struts_right
);
1395 RESET_STRUT_LIST(struts_bottom
);
1397 /* collect the struts */
1398 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1399 ObClient
*c
= it
->data
;
1401 ADD_STRUT_TO_LIST(struts_left
, c
->desktop
, &c
->strut
);
1403 ADD_STRUT_TO_LIST(struts_top
, c
->desktop
, &c
->strut
);
1405 ADD_STRUT_TO_LIST(struts_right
, c
->desktop
, &c
->strut
);
1406 if (c
->strut
.bottom
)
1407 ADD_STRUT_TO_LIST(struts_bottom
, c
->desktop
, &c
->strut
);
1409 if (dock_strut
.left
)
1410 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &dock_strut
);
1412 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &dock_strut
);
1413 if (dock_strut
.right
)
1414 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &dock_strut
);
1415 if (dock_strut
.bottom
)
1416 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &dock_strut
);
1418 if (config_margins
.left
)
1419 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &config_margins
);
1420 if (config_margins
.top
)
1421 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &config_margins
);
1422 if (config_margins
.right
)
1423 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &config_margins
);
1424 if (config_margins
.bottom
)
1425 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &config_margins
);
1427 VALIDATE_STRUTS(struts_left
, left
,
1428 monitor_area
[screen_num_monitors
].width
/ 2);
1429 VALIDATE_STRUTS(struts_right
, right
,
1430 monitor_area
[screen_num_monitors
].width
/ 2);
1431 VALIDATE_STRUTS(struts_top
, top
,
1432 monitor_area
[screen_num_monitors
].height
/ 2);
1433 VALIDATE_STRUTS(struts_bottom
, bottom
,
1434 monitor_area
[screen_num_monitors
].height
/ 2);
1436 dims
= g_new(gulong
, 4 * screen_num_desktops
);
1437 for (i
= 0; i
< screen_num_desktops
; ++i
) {
1438 Rect
*area
= screen_area(i
, SCREEN_AREA_ALL_MONITORS
, NULL
);
1439 dims
[i
*4+0] = area
->x
;
1440 dims
[i
*4+1] = area
->y
;
1441 dims
[i
*4+2] = area
->width
;
1442 dims
[i
*4+3] = area
->height
;
1443 g_slice_free(Rect
, area
);
1446 /* set the legacy workarea hint to the union of all the monitors */
1447 OBT_PROP_SETA32(obt_root(ob_screen
), NET_WORKAREA
, CARDINAL
,
1448 dims
, 4 * screen_num_desktops
);
1450 /* the area has changed, adjust all the windows if they need it */
1451 for (it
= client_list
; it
; it
= g_list_next(it
))
1452 client_reconfigure(it
->data
, FALSE
);
1458 Rect
* screen_area_all_monitors(guint desktop
)
1463 a
= screen_area_monitor(desktop
, 0);
1465 /* combine all the monitors together */
1466 for (i
= 1; i
< screen_num_monitors
; ++i
) {
1467 Rect
*m
= screen_area_monitor(desktop
, i
);
1470 l
= MIN(RECT_LEFT(*a
), RECT_LEFT(*m
));
1471 t
= MIN(RECT_TOP(*a
), RECT_TOP(*m
));
1472 r
= MAX(RECT_RIGHT(*a
), RECT_RIGHT(*m
));
1473 b
= MAX(RECT_BOTTOM(*a
), RECT_BOTTOM(*m
));
1475 RECT_SET(*a
, l
, t
, r
- l
+ 1, b
- t
+ 1);
1484 #define STRUT_LEFT_IN_SEARCH(s, search) \
1485 (RANGES_INTERSECT(search->y, search->height, \
1486 s->left_start, s->left_end - s->left_start + 1))
1487 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1488 (RANGES_INTERSECT(search->y, search->height, \
1489 s->right_start, s->right_end - s->right_start + 1))
1490 #define STRUT_TOP_IN_SEARCH(s, search) \
1491 (RANGES_INTERSECT(search->x, search->width, \
1492 s->top_start, s->top_end - s->top_start + 1))
1493 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1494 (RANGES_INTERSECT(search->x, search->width, \
1495 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1497 #define STRUT_LEFT_IGNORE(s, us, search) \
1498 (head == SCREEN_AREA_ALL_MONITORS && us && \
1499 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1500 #define STRUT_RIGHT_IGNORE(s, us, search) \
1501 (head == SCREEN_AREA_ALL_MONITORS && us && \
1502 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1503 #define STRUT_TOP_IGNORE(s, us, search) \
1504 (head == SCREEN_AREA_ALL_MONITORS && us && \
1505 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1506 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1507 (head == SCREEN_AREA_ALL_MONITORS && us && \
1508 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1510 Rect
* screen_area(guint desktop
, guint head
, Rect
*search
)
1516 gboolean us
= search
!= NULL
; /* user provided search */
1518 g_assert(desktop
< screen_num_desktops
|| desktop
== DESKTOP_ALL
);
1519 g_assert(head
< screen_num_monitors
|| head
== SCREEN_AREA_ONE_MONITOR
||
1520 head
== SCREEN_AREA_ALL_MONITORS
);
1521 g_assert(!(head
== SCREEN_AREA_ONE_MONITOR
&& search
== NULL
));
1523 /* find any struts for this monitor
1524 which will be affecting the search area.
1527 /* search everything if search is null */
1529 if (head
< screen_num_monitors
) search
= &monitor_area
[head
];
1530 else search
= &monitor_area
[screen_num_monitors
];
1532 if (head
== SCREEN_AREA_ONE_MONITOR
) head
= screen_find_monitor(search
);
1534 /* al is "all left" meaning the furthest left you can get, l is our
1535 "working left" meaning our current strut edge which we're calculating
1538 /* only include monitors which the search area lines up with */
1539 if (RECT_INTERSECTS_RECT(monitor_area
[screen_num_monitors
], *search
)) {
1540 l
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1541 t
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1542 r
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1543 b
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1544 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1545 /* add the monitor if applicable */
1546 if (RANGES_INTERSECT(search
->x
, search
->width
,
1547 monitor_area
[i
].x
, monitor_area
[i
].width
))
1549 t
= MIN(t
, RECT_TOP(monitor_area
[i
]));
1550 b
= MAX(b
, RECT_BOTTOM(monitor_area
[i
]));
1552 if (RANGES_INTERSECT(search
->y
, search
->height
,
1553 monitor_area
[i
].y
, monitor_area
[i
].height
))
1555 l
= MIN(l
, RECT_LEFT(monitor_area
[i
]));
1556 r
= MAX(r
, RECT_RIGHT(monitor_area
[i
]));
1560 l
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1561 t
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1562 r
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1563 b
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1566 for (d
= 0; d
< screen_num_desktops
; ++d
) {
1567 if (d
!= desktop
&& desktop
!= DESKTOP_ALL
) continue;
1569 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1570 if (head
!= SCREEN_AREA_ALL_MONITORS
&& head
!= i
) continue;
1572 for (it
= struts_left
; it
; it
= g_slist_next(it
)) {
1573 ObScreenStrut
*s
= it
->data
;
1574 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1575 STRUT_LEFT_IN_SEARCH(s
->strut
, search
) &&
1576 !STRUT_LEFT_IGNORE(s
->strut
, us
, search
))
1577 l
= MAX(l
, RECT_LEFT(monitor_area
[screen_num_monitors
])
1580 for (it
= struts_top
; it
; it
= g_slist_next(it
)) {
1581 ObScreenStrut
*s
= it
->data
;
1582 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1583 STRUT_TOP_IN_SEARCH(s
->strut
, search
) &&
1584 !STRUT_TOP_IGNORE(s
->strut
, us
, search
))
1585 t
= MAX(t
, RECT_TOP(monitor_area
[screen_num_monitors
])
1588 for (it
= struts_right
; it
; it
= g_slist_next(it
)) {
1589 ObScreenStrut
*s
= it
->data
;
1590 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1591 STRUT_RIGHT_IN_SEARCH(s
->strut
, search
) &&
1592 !STRUT_RIGHT_IGNORE(s
->strut
, us
, search
))
1593 r
= MIN(r
, RECT_RIGHT(monitor_area
[screen_num_monitors
])
1596 for (it
= struts_bottom
; it
; it
= g_slist_next(it
)) {
1597 ObScreenStrut
*s
= it
->data
;
1598 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1599 STRUT_BOTTOM_IN_SEARCH(s
->strut
, search
) &&
1600 !STRUT_BOTTOM_IGNORE(s
->strut
, us
, search
))
1601 b
= MIN(b
, RECT_BOTTOM(monitor_area
[screen_num_monitors
])
1602 - s
->strut
->bottom
);
1605 /* limit to this monitor */
1607 l
= MAX(l
, RECT_LEFT(monitor_area
[i
]));
1608 t
= MAX(t
, RECT_TOP(monitor_area
[i
]));
1609 r
= MIN(r
, RECT_RIGHT(monitor_area
[i
]));
1610 b
= MIN(b
, RECT_BOTTOM(monitor_area
[i
]));
1615 a
= g_slice_new(Rect
);
1618 a
->width
= r
- l
+ 1;
1619 a
->height
= b
- t
+ 1;
1623 guint
screen_find_monitor(const Rect
*search
)
1626 guint most
= screen_num_monitors
;
1629 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1630 const Rect
*area
= screen_physical_area_monitor(i
);
1631 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1635 RECT_SET_INTERSECTION(r
, *area
, *search
);
1636 v
= r
.width
* r
.height
;
1647 const Rect
* screen_physical_area_all_monitors(void)
1649 return screen_physical_area_monitor(screen_num_monitors
);
1652 const Rect
* screen_physical_area_monitor(guint head
)
1654 g_assert(head
<= screen_num_monitors
);
1656 return &monitor_area
[head
];
1659 gboolean
screen_physical_area_monitor_contains(guint head
, Rect
*search
)
1661 g_assert(head
<= screen_num_monitors
);
1663 return RECT_INTERSECTS_RECT(monitor_area
[head
], *search
);
1666 guint
screen_monitor_active(void)
1668 if (moveresize_client
)
1669 return client_monitor(moveresize_client
);
1670 else if (focus_client
)
1671 return client_monitor(focus_client
);
1673 return screen_monitor_pointer();
1676 const Rect
* screen_physical_area_active(void)
1678 return screen_physical_area_monitor(screen_monitor_active());
1681 guint
screen_monitor_primary(gboolean fixed
)
1683 if (config_primary_monitor_index
> 0) {
1684 if (config_primary_monitor_index
-1 < screen_num_monitors
)
1685 return config_primary_monitor_index
- 1;
1691 else if (config_primary_monitor
== OB_PLACE_MONITOR_ACTIVE
)
1692 return screen_monitor_active();
1693 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1694 return screen_monitor_pointer();
1697 const Rect
* screen_physical_area_primary(gboolean fixed
)
1699 return screen_physical_area_monitor(screen_monitor_primary(fixed
));
1702 void screen_set_root_cursor(void)
1704 if (sn_app_starting())
1705 XDefineCursor(obt_display
, obt_root(ob_screen
),
1706 ob_cursor(OB_CURSOR_BUSYPOINTER
));
1708 XDefineCursor(obt_display
, obt_root(ob_screen
),
1709 ob_cursor(OB_CURSOR_POINTER
));
1712 guint
screen_find_monitor_point(guint x
, guint y
)
1715 RECT_SET(mon
, x
, y
, 1, 1);
1716 return screen_find_monitor(&mon
);
1719 guint
screen_monitor_pointer()
1722 if (!screen_pointer_pos(&x
, &y
))
1724 return screen_find_monitor_point(x
, y
);
1727 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1734 ret
= !!XQueryPointer(obt_display
, obt_root(ob_screen
),
1735 &w
, &w
, x
, y
, &i
, &i
, &u
);
1737 for (i
= 0; i
< ScreenCount(obt_display
); ++i
)
1739 if (XQueryPointer(obt_display
, obt_root(i
),
1740 &w
, &w
, x
, y
, &i
, &i
, &u
))