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)
1377 GList
*it
, *onscreen
;
1379 /* collect the clients that are on screen */
1381 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1382 if (client_monitor(it
->data
) != screen_num_monitors
)
1383 onscreen
= g_list_prepend(onscreen
, it
->data
);
1386 g_free(monitor_area
);
1387 get_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1389 /* set up the user-specified margins */
1390 config_margins
.top_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1391 config_margins
.top_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1392 config_margins
.bottom_start
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1393 config_margins
.bottom_end
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1394 config_margins
.left_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1395 config_margins
.left_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1396 config_margins
.right_start
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1397 config_margins
.right_end
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1399 RESET_STRUT_LIST(struts_left
);
1400 RESET_STRUT_LIST(struts_top
);
1401 RESET_STRUT_LIST(struts_right
);
1402 RESET_STRUT_LIST(struts_bottom
);
1404 /* collect the struts */
1405 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1406 ObClient
*c
= it
->data
;
1408 ADD_STRUT_TO_LIST(struts_left
, c
->desktop
, &c
->strut
);
1410 ADD_STRUT_TO_LIST(struts_top
, c
->desktop
, &c
->strut
);
1412 ADD_STRUT_TO_LIST(struts_right
, c
->desktop
, &c
->strut
);
1413 if (c
->strut
.bottom
)
1414 ADD_STRUT_TO_LIST(struts_bottom
, c
->desktop
, &c
->strut
);
1416 if (dock_strut
.left
)
1417 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &dock_strut
);
1419 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &dock_strut
);
1420 if (dock_strut
.right
)
1421 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &dock_strut
);
1422 if (dock_strut
.bottom
)
1423 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &dock_strut
);
1425 if (config_margins
.left
)
1426 ADD_STRUT_TO_LIST(struts_left
, DESKTOP_ALL
, &config_margins
);
1427 if (config_margins
.top
)
1428 ADD_STRUT_TO_LIST(struts_top
, DESKTOP_ALL
, &config_margins
);
1429 if (config_margins
.right
)
1430 ADD_STRUT_TO_LIST(struts_right
, DESKTOP_ALL
, &config_margins
);
1431 if (config_margins
.bottom
)
1432 ADD_STRUT_TO_LIST(struts_bottom
, DESKTOP_ALL
, &config_margins
);
1434 VALIDATE_STRUTS(struts_left
, left
,
1435 monitor_area
[screen_num_monitors
].width
/ 2);
1436 VALIDATE_STRUTS(struts_right
, right
,
1437 monitor_area
[screen_num_monitors
].width
/ 2);
1438 VALIDATE_STRUTS(struts_top
, top
,
1439 monitor_area
[screen_num_monitors
].height
/ 2);
1440 VALIDATE_STRUTS(struts_bottom
, bottom
,
1441 monitor_area
[screen_num_monitors
].height
/ 2);
1443 dims
= g_new(gulong
, 4 * screen_num_desktops
);
1444 for (i
= 0; i
< screen_num_desktops
; ++i
) {
1445 Rect
*area
= screen_area(i
, SCREEN_AREA_ALL_MONITORS
, NULL
);
1446 dims
[i
*4+0] = area
->x
;
1447 dims
[i
*4+1] = area
->y
;
1448 dims
[i
*4+2] = area
->width
;
1449 dims
[i
*4+3] = area
->height
;
1450 g_slice_free(Rect
, area
);
1453 /* set the legacy workarea hint to the union of all the monitors */
1454 OBT_PROP_SETA32(obt_root(ob_screen
), NET_WORKAREA
, CARDINAL
,
1455 dims
, 4 * screen_num_desktops
);
1457 /* the area has changed, adjust all the windows if they need it */
1458 for (it
= onscreen
; it
; it
= g_list_next(it
)) {
1459 client_move_onscreen(it
->data
, FALSE
);
1460 client_reconfigure(it
->data
, FALSE
);
1467 Rect
* screen_area_all_monitors(guint desktop
)
1472 a
= screen_area_monitor(desktop
, 0);
1474 /* combine all the monitors together */
1475 for (i
= 1; i
< screen_num_monitors
; ++i
) {
1476 Rect
*m
= screen_area_monitor(desktop
, i
);
1479 l
= MIN(RECT_LEFT(*a
), RECT_LEFT(*m
));
1480 t
= MIN(RECT_TOP(*a
), RECT_TOP(*m
));
1481 r
= MAX(RECT_RIGHT(*a
), RECT_RIGHT(*m
));
1482 b
= MAX(RECT_BOTTOM(*a
), RECT_BOTTOM(*m
));
1484 RECT_SET(*a
, l
, t
, r
- l
+ 1, b
- t
+ 1);
1493 #define STRUT_LEFT_IN_SEARCH(s, search) \
1494 (RANGES_INTERSECT(search->y, search->height, \
1495 s->left_start, s->left_end - s->left_start + 1))
1496 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1497 (RANGES_INTERSECT(search->y, search->height, \
1498 s->right_start, s->right_end - s->right_start + 1))
1499 #define STRUT_TOP_IN_SEARCH(s, search) \
1500 (RANGES_INTERSECT(search->x, search->width, \
1501 s->top_start, s->top_end - s->top_start + 1))
1502 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1503 (RANGES_INTERSECT(search->x, search->width, \
1504 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1506 #define STRUT_LEFT_IGNORE(s, us, search) \
1507 (head == SCREEN_AREA_ALL_MONITORS && us && \
1508 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1509 #define STRUT_RIGHT_IGNORE(s, us, search) \
1510 (head == SCREEN_AREA_ALL_MONITORS && us && \
1511 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1512 #define STRUT_TOP_IGNORE(s, us, search) \
1513 (head == SCREEN_AREA_ALL_MONITORS && us && \
1514 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1515 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1516 (head == SCREEN_AREA_ALL_MONITORS && us && \
1517 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1519 Rect
* screen_area(guint desktop
, guint head
, Rect
*search
)
1525 gboolean us
= search
!= NULL
; /* user provided search */
1527 g_assert(desktop
< screen_num_desktops
|| desktop
== DESKTOP_ALL
);
1528 g_assert(head
< screen_num_monitors
|| head
== SCREEN_AREA_ONE_MONITOR
||
1529 head
== SCREEN_AREA_ALL_MONITORS
);
1530 g_assert(!(head
== SCREEN_AREA_ONE_MONITOR
&& search
== NULL
));
1532 /* find any struts for this monitor
1533 which will be affecting the search area.
1536 /* search everything if search is null */
1538 if (head
< screen_num_monitors
) search
= &monitor_area
[head
];
1539 else search
= &monitor_area
[screen_num_monitors
];
1541 if (head
== SCREEN_AREA_ONE_MONITOR
) head
= screen_find_monitor(search
);
1543 /* al is "all left" meaning the furthest left you can get, l is our
1544 "working left" meaning our current strut edge which we're calculating
1547 /* only include monitors which the search area lines up with */
1548 if (RECT_INTERSECTS_RECT(monitor_area
[screen_num_monitors
], *search
)) {
1549 l
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1550 t
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1551 r
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1552 b
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1553 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1554 /* add the monitor if applicable */
1555 if (RANGES_INTERSECT(search
->x
, search
->width
,
1556 monitor_area
[i
].x
, monitor_area
[i
].width
))
1558 t
= MIN(t
, RECT_TOP(monitor_area
[i
]));
1559 b
= MAX(b
, RECT_BOTTOM(monitor_area
[i
]));
1561 if (RANGES_INTERSECT(search
->y
, search
->height
,
1562 monitor_area
[i
].y
, monitor_area
[i
].height
))
1564 l
= MIN(l
, RECT_LEFT(monitor_area
[i
]));
1565 r
= MAX(r
, RECT_RIGHT(monitor_area
[i
]));
1569 l
= RECT_LEFT(monitor_area
[screen_num_monitors
]);
1570 t
= RECT_TOP(monitor_area
[screen_num_monitors
]);
1571 r
= RECT_RIGHT(monitor_area
[screen_num_monitors
]);
1572 b
= RECT_BOTTOM(monitor_area
[screen_num_monitors
]);
1575 for (d
= 0; d
< screen_num_desktops
; ++d
) {
1576 if (d
!= desktop
&& desktop
!= DESKTOP_ALL
) continue;
1578 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1579 if (head
!= SCREEN_AREA_ALL_MONITORS
&& head
!= i
) continue;
1581 for (it
= struts_left
; it
; it
= g_slist_next(it
)) {
1582 ObScreenStrut
*s
= it
->data
;
1583 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1584 STRUT_LEFT_IN_SEARCH(s
->strut
, search
) &&
1585 !STRUT_LEFT_IGNORE(s
->strut
, us
, search
))
1586 l
= MAX(l
, RECT_LEFT(monitor_area
[screen_num_monitors
])
1589 for (it
= struts_top
; it
; it
= g_slist_next(it
)) {
1590 ObScreenStrut
*s
= it
->data
;
1591 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1592 STRUT_TOP_IN_SEARCH(s
->strut
, search
) &&
1593 !STRUT_TOP_IGNORE(s
->strut
, us
, search
))
1594 t
= MAX(t
, RECT_TOP(monitor_area
[screen_num_monitors
])
1597 for (it
= struts_right
; it
; it
= g_slist_next(it
)) {
1598 ObScreenStrut
*s
= it
->data
;
1599 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1600 STRUT_RIGHT_IN_SEARCH(s
->strut
, search
) &&
1601 !STRUT_RIGHT_IGNORE(s
->strut
, us
, search
))
1602 r
= MIN(r
, RECT_RIGHT(monitor_area
[screen_num_monitors
])
1605 for (it
= struts_bottom
; it
; it
= g_slist_next(it
)) {
1606 ObScreenStrut
*s
= it
->data
;
1607 if ((s
->desktop
== d
|| s
->desktop
== DESKTOP_ALL
) &&
1608 STRUT_BOTTOM_IN_SEARCH(s
->strut
, search
) &&
1609 !STRUT_BOTTOM_IGNORE(s
->strut
, us
, search
))
1610 b
= MIN(b
, RECT_BOTTOM(monitor_area
[screen_num_monitors
])
1611 - s
->strut
->bottom
);
1614 /* limit to this monitor */
1616 l
= MAX(l
, RECT_LEFT(monitor_area
[i
]));
1617 t
= MAX(t
, RECT_TOP(monitor_area
[i
]));
1618 r
= MIN(r
, RECT_RIGHT(monitor_area
[i
]));
1619 b
= MIN(b
, RECT_BOTTOM(monitor_area
[i
]));
1624 a
= g_slice_new(Rect
);
1627 a
->width
= r
- l
+ 1;
1628 a
->height
= b
- t
+ 1;
1632 guint
screen_find_monitor(const Rect
*search
)
1635 guint most
= screen_num_monitors
;
1638 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1639 const Rect
*area
= screen_physical_area_monitor(i
);
1640 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1644 RECT_SET_INTERSECTION(r
, *area
, *search
);
1645 v
= r
.width
* r
.height
;
1656 const Rect
* screen_physical_area_all_monitors(void)
1658 return screen_physical_area_monitor(screen_num_monitors
);
1661 const Rect
* screen_physical_area_monitor(guint head
)
1663 g_assert(head
<= screen_num_monitors
);
1665 return &monitor_area
[head
];
1668 gboolean
screen_physical_area_monitor_contains(guint head
, Rect
*search
)
1670 g_assert(head
<= screen_num_monitors
);
1672 return RECT_INTERSECTS_RECT(monitor_area
[head
], *search
);
1675 guint
screen_monitor_active(void)
1677 if (moveresize_client
)
1678 return client_monitor(moveresize_client
);
1679 else if (focus_client
)
1680 return client_monitor(focus_client
);
1682 return screen_monitor_pointer();
1685 const Rect
* screen_physical_area_active(void)
1687 return screen_physical_area_monitor(screen_monitor_active());
1690 guint
screen_monitor_primary(gboolean fixed
)
1692 if (config_primary_monitor_index
> 0) {
1693 if (config_primary_monitor_index
-1 < screen_num_monitors
)
1694 return config_primary_monitor_index
- 1;
1700 else if (config_primary_monitor
== OB_PLACE_MONITOR_ACTIVE
)
1701 return screen_monitor_active();
1702 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1703 return screen_monitor_pointer();
1706 const Rect
* screen_physical_area_primary(gboolean fixed
)
1708 return screen_physical_area_monitor(screen_monitor_primary(fixed
));
1711 void screen_set_root_cursor(void)
1713 if (sn_app_starting())
1714 XDefineCursor(obt_display
, obt_root(ob_screen
),
1715 ob_cursor(OB_CURSOR_BUSYPOINTER
));
1717 XDefineCursor(obt_display
, obt_root(ob_screen
),
1718 ob_cursor(OB_CURSOR_POINTER
));
1721 guint
screen_find_monitor_point(guint x
, guint y
)
1724 RECT_SET(mon
, x
, y
, 1, 1);
1725 return screen_find_monitor(&mon
);
1728 guint
screen_monitor_pointer()
1731 if (!screen_pointer_pos(&x
, &y
))
1733 return screen_find_monitor_point(x
, y
);
1736 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1743 ret
= !!XQueryPointer(obt_display
, obt_root(ob_screen
),
1744 &w
, &w
, x
, y
, &i
, &i
, &u
);
1746 for (i
= 0; i
< ScreenCount(obt_display
); ++i
)
1748 if (XQueryPointer(obt_display
, obt_root(i
),
1749 &w
, &w
, x
, y
, &i
, &i
, &u
))