1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 screen.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
26 #include "startupnotify.h"
27 #include "moveresize.h"
36 #include "extensions.h"
37 #include "render/render.h"
42 # include <sys/types.h>
47 /*! The event mask to grab on the root window */
48 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
49 EnterWindowMask | LeaveWindowMask | \
50 SubstructureRedirectMask | FocusChangeMask | \
51 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
53 static gboolean
screen_validate_layout(ObDesktopLayout
*l
);
54 static gboolean
replace_wm();
55 static void screen_tell_ksplash();
57 guint screen_num_desktops
;
58 guint screen_num_monitors
;
60 guint screen_last_desktop
;
61 Size screen_physical_size
;
62 gboolean screen_showing_desktop
;
63 ObDesktopLayout screen_desktop_layout
;
64 gchar
**screen_desktop_names
;
65 Window screen_support_win
;
66 Time screen_desktop_user_time
= CurrentTime
;
68 static Rect
**area
; /* array of desktop holding array of xinerama areas */
69 static Rect
*monitor_area
;
71 static ObPagerPopup
*desktop_cycle_popup
;
73 static gboolean
replace_wm()
77 Window current_wm_sn_owner
;
80 wm_sn
= g_strdup_printf("WM_S%d", ob_screen
);
81 wm_sn_atom
= XInternAtom(ob_display
, wm_sn
, FALSE
);
84 current_wm_sn_owner
= XGetSelectionOwner(ob_display
, wm_sn_atom
);
85 if (current_wm_sn_owner
== screen_support_win
)
86 current_wm_sn_owner
= None
;
87 if (current_wm_sn_owner
) {
89 g_message(_("A window manager is already running on screen %d"),
93 xerror_set_ignore(TRUE
);
94 xerror_occured
= FALSE
;
96 /* We want to find out when the current selection owner dies */
97 XSelectInput(ob_display
, current_wm_sn_owner
, StructureNotifyMask
);
98 XSync(ob_display
, FALSE
);
100 xerror_set_ignore(FALSE
);
102 current_wm_sn_owner
= None
;
106 /* Generate a timestamp */
109 XSelectInput(ob_display
, screen_support_win
, PropertyChangeMask
);
111 XChangeProperty(ob_display
, screen_support_win
,
112 prop_atoms
.wm_class
, prop_atoms
.string
,
113 8, PropModeAppend
, NULL
, 0);
114 XWindowEvent(ob_display
, screen_support_win
,
115 PropertyChangeMask
, &event
);
117 XSelectInput(ob_display
, screen_support_win
, NoEventMask
);
119 timestamp
= event
.xproperty
.time
;
122 XSetSelectionOwner(ob_display
, wm_sn_atom
, screen_support_win
,
125 if (XGetSelectionOwner(ob_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
) {
135 const gulong timeout
= G_USEC_PER_SEC
* 15; /* wait for 15s max */
137 while (wait
< timeout
) {
138 if (XCheckWindowEvent(ob_display
, current_wm_sn_owner
,
139 StructureNotifyMask
, &event
) &&
140 event
.type
== DestroyNotify
)
142 g_usleep(G_USEC_PER_SEC
/ 10);
143 wait
+= G_USEC_PER_SEC
/ 10;
146 if (wait
>= timeout
) {
147 g_message(_("The WM on screen %d is not exiting"), ob_screen
);
152 /* Send client message indicating that we are now the WM */
153 prop_message(RootWindow(ob_display
, ob_screen
), prop_atoms
.manager
,
154 timestamp
, wm_sn_atom
, screen_support_win
, 0,
155 SubstructureNotifyMask
);
160 gboolean
screen_annex()
162 XSetWindowAttributes attrib
;
165 Atom
*prop_atoms_start
, *wm_supported_pos
;
168 /* create the netwm support window */
169 attrib
.override_redirect
= TRUE
;
170 screen_support_win
= XCreateWindow(ob_display
,
171 RootWindow(ob_display
, ob_screen
),
173 CopyFromParent
, InputOutput
,
175 CWOverrideRedirect
, &attrib
);
176 XMapWindow(ob_display
, screen_support_win
);
177 XLowerWindow(ob_display
, screen_support_win
);
180 XDestroyWindow(ob_display
, screen_support_win
);
184 xerror_set_ignore(TRUE
);
185 xerror_occured
= FALSE
;
186 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
188 xerror_set_ignore(FALSE
);
189 if (xerror_occured
) {
190 g_message(_("A window manager is already running on screen %d"),
193 XDestroyWindow(ob_display
, screen_support_win
);
197 screen_set_root_cursor();
199 /* set the OPENBOX_PID hint */
201 PROP_SET32(RootWindow(ob_display
, ob_screen
),
202 openbox_pid
, cardinal
, pid
);
204 /* set supporting window */
205 PROP_SET32(RootWindow(ob_display
, ob_screen
),
206 net_supporting_wm_check
, window
, screen_support_win
);
208 /* set properties on the supporting window */
209 PROP_SETS(screen_support_win
, net_wm_name
, "Openbox");
210 PROP_SET32(screen_support_win
, net_supporting_wm_check
,
211 window
, screen_support_win
);
213 /* set the _NET_SUPPORTED_ATOMS hint */
215 /* this is all the atoms after net_supported in the prop_atoms struct */
216 prop_atoms_start
= (Atom
*)&prop_atoms
;
217 wm_supported_pos
= (Atom
*)&(prop_atoms
.net_supported
);
218 num_support
= sizeof(prop_atoms
) / sizeof(Atom
) -
219 (wm_supported_pos
- prop_atoms_start
) - 1;
221 supported
= g_new(gulong
, num_support
);
222 supported
[i
++] = prop_atoms
.net_supporting_wm_check
;
223 supported
[i
++] = prop_atoms
.net_wm_full_placement
;
224 supported
[i
++] = prop_atoms
.net_current_desktop
;
225 supported
[i
++] = prop_atoms
.net_number_of_desktops
;
226 supported
[i
++] = prop_atoms
.net_desktop_geometry
;
227 supported
[i
++] = prop_atoms
.net_desktop_viewport
;
228 supported
[i
++] = prop_atoms
.net_active_window
;
229 supported
[i
++] = prop_atoms
.net_workarea
;
230 supported
[i
++] = prop_atoms
.net_client_list
;
231 supported
[i
++] = prop_atoms
.net_client_list_stacking
;
232 supported
[i
++] = prop_atoms
.net_desktop_names
;
233 supported
[i
++] = prop_atoms
.net_close_window
;
234 supported
[i
++] = prop_atoms
.net_desktop_layout
;
235 supported
[i
++] = prop_atoms
.net_showing_desktop
;
236 supported
[i
++] = prop_atoms
.net_wm_name
;
237 supported
[i
++] = prop_atoms
.net_wm_visible_name
;
238 supported
[i
++] = prop_atoms
.net_wm_icon_name
;
239 supported
[i
++] = prop_atoms
.net_wm_visible_icon_name
;
240 supported
[i
++] = prop_atoms
.net_wm_desktop
;
241 supported
[i
++] = prop_atoms
.net_wm_strut
;
242 supported
[i
++] = prop_atoms
.net_wm_strut_partial
;
243 supported
[i
++] = prop_atoms
.net_wm_icon
;
244 supported
[i
++] = prop_atoms
.net_wm_icon_geometry
;
245 supported
[i
++] = prop_atoms
.net_wm_window_type
;
246 supported
[i
++] = prop_atoms
.net_wm_window_type_desktop
;
247 supported
[i
++] = prop_atoms
.net_wm_window_type_dock
;
248 supported
[i
++] = prop_atoms
.net_wm_window_type_toolbar
;
249 supported
[i
++] = prop_atoms
.net_wm_window_type_menu
;
250 supported
[i
++] = prop_atoms
.net_wm_window_type_utility
;
251 supported
[i
++] = prop_atoms
.net_wm_window_type_splash
;
252 supported
[i
++] = prop_atoms
.net_wm_window_type_dialog
;
253 supported
[i
++] = prop_atoms
.net_wm_window_type_normal
;
254 supported
[i
++] = prop_atoms
.net_wm_allowed_actions
;
255 supported
[i
++] = prop_atoms
.net_wm_action_move
;
256 supported
[i
++] = prop_atoms
.net_wm_action_resize
;
257 supported
[i
++] = prop_atoms
.net_wm_action_minimize
;
258 supported
[i
++] = prop_atoms
.net_wm_action_shade
;
259 supported
[i
++] = prop_atoms
.net_wm_action_maximize_horz
;
260 supported
[i
++] = prop_atoms
.net_wm_action_maximize_vert
;
261 supported
[i
++] = prop_atoms
.net_wm_action_fullscreen
;
262 supported
[i
++] = prop_atoms
.net_wm_action_change_desktop
;
263 supported
[i
++] = prop_atoms
.net_wm_action_close
;
264 supported
[i
++] = prop_atoms
.net_wm_action_above
;
265 supported
[i
++] = prop_atoms
.net_wm_action_below
;
266 supported
[i
++] = prop_atoms
.net_wm_state
;
267 supported
[i
++] = prop_atoms
.net_wm_state_modal
;
268 supported
[i
++] = prop_atoms
.net_wm_state_maximized_vert
;
269 supported
[i
++] = prop_atoms
.net_wm_state_maximized_horz
;
270 supported
[i
++] = prop_atoms
.net_wm_state_shaded
;
271 supported
[i
++] = prop_atoms
.net_wm_state_skip_taskbar
;
272 supported
[i
++] = prop_atoms
.net_wm_state_skip_pager
;
273 supported
[i
++] = prop_atoms
.net_wm_state_hidden
;
274 supported
[i
++] = prop_atoms
.net_wm_state_fullscreen
;
275 supported
[i
++] = prop_atoms
.net_wm_state_above
;
276 supported
[i
++] = prop_atoms
.net_wm_state_below
;
277 supported
[i
++] = prop_atoms
.net_wm_state_demands_attention
;
278 supported
[i
++] = prop_atoms
.net_moveresize_window
;
279 supported
[i
++] = prop_atoms
.net_wm_moveresize
;
280 supported
[i
++] = prop_atoms
.net_wm_user_time
;
281 supported
[i
++] = prop_atoms
.net_wm_user_time_window
;
282 supported
[i
++] = prop_atoms
.net_frame_extents
;
283 supported
[i
++] = prop_atoms
.net_request_frame_extents
;
284 supported
[i
++] = prop_atoms
.net_restack_window
;
285 supported
[i
++] = prop_atoms
.net_startup_id
;
287 supported
[i
++] = prop_atoms
.net_wm_sync_request
;
288 supported
[i
++] = prop_atoms
.net_wm_sync_request_counter
;
291 supported
[i
++] = prop_atoms
.kde_wm_change_state
;
292 supported
[i
++] = prop_atoms
.kde_net_wm_frame_strut
;
293 supported
[i
++] = prop_atoms
.kde_net_wm_window_type_override
;
295 supported
[i
++] = prop_atoms
.ob_wm_action_undecorate
;
296 supported
[i
++] = prop_atoms
.ob_wm_state_undecorated
;
297 supported
[i
++] = prop_atoms
.openbox_pid
;
298 supported
[i
++] = prop_atoms
.ob_theme
;
299 supported
[i
++] = prop_atoms
.ob_control
;
300 g_assert(i
== num_support
);
302 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
303 net_supported
, atom
, supported
, num_support
);
306 screen_tell_ksplash();
311 static void screen_tell_ksplash()
316 argv
= g_new(gchar
*, 6);
317 argv
[0] = g_strdup("dcop");
318 argv
[1] = g_strdup("ksplash");
319 argv
[2] = g_strdup("ksplash");
320 argv
[3] = g_strdup("upAndRunning(QString)");
321 argv
[4] = g_strdup("wm started");
324 /* tell ksplash through the dcop server command line interface */
325 g_spawn_async(NULL
, argv
, NULL
,
326 G_SPAWN_SEARCH_PATH
| G_SPAWN_DO_NOT_REAP_CHILD
|
327 G_SPAWN_STDERR_TO_DEV_NULL
| G_SPAWN_STDOUT_TO_DEV_NULL
,
328 NULL
, NULL
, NULL
, NULL
);
331 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
332 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
333 something. oh well. */
334 e
.xclient
.type
= ClientMessage
;
335 e
.xclient
.display
= ob_display
;
336 e
.xclient
.window
= RootWindow(ob_display
, ob_screen
);
337 e
.xclient
.message_type
=
338 XInternAtom(ob_display
, "_KDE_SPLASH_PROGRESS", False
);
339 e
.xclient
.format
= 8;
340 strcpy(e
.xclient
.data
.b
, "wm started");
341 XSendEvent(ob_display
, RootWindow(ob_display
, ob_screen
),
342 False
, SubstructureNotifyMask
, &e
);
345 void screen_startup(gboolean reconfig
)
347 gchar
**names
= NULL
;
349 gboolean namesexist
= FALSE
;
351 desktop_cycle_popup
= pager_popup_new(FALSE
);
352 pager_popup_height(desktop_cycle_popup
, POPUP_HEIGHT
);
355 /* update the pager popup's width */
356 pager_popup_text_width_to_strings(desktop_cycle_popup
,
357 screen_desktop_names
,
358 screen_num_desktops
);
362 /* get the initial size */
365 /* have names already been set for the desktops? */
366 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
367 net_desktop_names
, utf8
, &names
))
373 /* if names don't exist and we have session names, set those.
374 do this stuff BEFORE setting the number of desktops, because that
375 will create default names for them
377 if (!namesexist
&& session_desktop_names
!= NULL
) {
381 /* get the desktop names */
382 numnames
= g_slist_length(session_desktop_names
);
383 names
= g_new(gchar
*, numnames
+ 1);
384 names
[numnames
] = NULL
;
385 for (i
= 0, it
= session_desktop_names
; it
; ++i
, it
= g_slist_next(it
))
386 names
[i
] = g_strdup(it
->data
);
388 /* set the root window property */
389 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,names
);
394 /* set the number of desktops, if it's not already set.
396 this will also set the default names from the config file up for
397 desktops that don't have names yet */
398 screen_num_desktops
= 0;
399 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
400 net_number_of_desktops
, cardinal
, &d
))
401 screen_set_num_desktops(d
);
402 /* restore from session if possible */
403 else if (session_num_desktops
)
404 screen_set_num_desktops(session_num_desktops
);
406 screen_set_num_desktops(config_desktops_num
);
408 screen_desktop
= screen_num_desktops
; /* something invalid */
409 /* start on the current desktop when a wm was already running */
410 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
411 net_current_desktop
, cardinal
, &d
) &&
412 d
< screen_num_desktops
)
414 screen_set_desktop(d
, FALSE
);
415 } else if (session_desktop
>= 0)
416 screen_set_desktop(MIN((guint
)session_desktop
,
417 screen_num_desktops
), FALSE
);
419 screen_set_desktop(MIN(config_screen_firstdesk
,
420 screen_num_desktops
) - 1, FALSE
);
421 screen_last_desktop
= screen_desktop
;
423 /* don't start in showing-desktop mode */
424 screen_showing_desktop
= FALSE
;
425 PROP_SET32(RootWindow(ob_display
, ob_screen
),
426 net_showing_desktop
, cardinal
, screen_showing_desktop
);
428 if (session_desktop_layout_present
&&
429 screen_validate_layout(&session_desktop_layout
))
431 screen_desktop_layout
= session_desktop_layout
;
434 screen_update_layout();
437 void screen_shutdown(gboolean reconfig
)
441 pager_popup_free(desktop_cycle_popup
);
446 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
449 /* we're not running here no more! */
450 PROP_ERASE(RootWindow(ob_display
, ob_screen
), openbox_pid
);
452 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_supported
);
453 /* don't keep this mode */
454 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_showing_desktop
);
456 XDestroyWindow(ob_display
, screen_support_win
);
458 g_strfreev(screen_desktop_names
);
459 screen_desktop_names
= NULL
;
461 for (r
= area
; *r
; ++r
)
469 static gint oldw
= 0, oldh
= 0;
474 w
= WidthOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
475 h
= HeightOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
477 if (w
== oldw
&& h
== oldh
) return;
481 /* Set the _NET_DESKTOP_GEOMETRY hint */
482 screen_physical_size
.width
= geometry
[0] = w
;
483 screen_physical_size
.height
= geometry
[1] = h
;
484 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
485 net_desktop_geometry
, cardinal
, geometry
, 2);
487 if (ob_state() == OB_STATE_STARTING
)
490 screen_update_areas();
493 for (it
= client_list
; it
; it
= g_list_next(it
))
494 client_move_onscreen(it
->data
, FALSE
);
497 void screen_set_num_desktops(guint num
)
505 if (screen_num_desktops
== num
) return;
507 old
= screen_num_desktops
;
508 screen_num_desktops
= num
;
509 PROP_SET32(RootWindow(ob_display
, ob_screen
),
510 net_number_of_desktops
, cardinal
, num
);
512 /* set the viewport hint */
513 viewport
= g_new0(gulong
, num
* 2);
514 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
515 net_desktop_viewport
, cardinal
, viewport
, num
* 2);
518 /* the number of rows/columns will differ */
519 screen_update_layout();
521 /* move windows on desktops that will no longer exist! */
522 for (it
= client_list
; it
; it
= g_list_next(it
)) {
523 ObClient
*c
= it
->data
;
524 if (c
->desktop
>= num
&& c
->desktop
!= DESKTOP_ALL
)
525 client_set_desktop(c
, num
- 1, FALSE
);
528 /* change our struts/area to match (after moving windows) */
529 screen_update_areas();
531 /* may be some unnamed desktops that we need to fill in with names
532 (after updating the areas so the popup can resize) */
533 screen_update_desktop_names();
535 /* change our desktop if we're on one that no longer exists! */
536 if (screen_desktop
>= screen_num_desktops
)
537 screen_set_desktop(num
- 1, TRUE
);
540 void screen_set_desktop(guint num
, gboolean dofocus
)
548 g_assert(num
< screen_num_desktops
);
550 old
= screen_desktop
;
551 screen_desktop
= num
;
553 if (old
== num
) return;
555 PROP_SET32(RootWindow(ob_display
, ob_screen
),
556 net_current_desktop
, cardinal
, num
);
558 screen_last_desktop
= old
;
560 ob_debug("Moving to desktop %d\n", num
+1);
562 /* ignore enter events caused by the move */
563 ignore_start
= event_start_ignore_all_enters();
565 if (moveresize_client
)
566 client_set_desktop(moveresize_client
, num
, TRUE
);
568 /* show windows before hiding the rest to lessen the enter/leave events */
570 /* show windows from top to bottom */
571 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
572 if (WINDOW_IS_CLIENT(it
->data
)) {
573 ObClient
*c
= it
->data
;
578 /* only allow omnipresent windows to get focus on desktop change if
579 an omnipresent window is already focused (it'll keep focus probably, but
580 maybe not depending on mouse-focus options) */
581 allow_omni
= focus_client
&& (client_normal(focus_client
) &&
582 focus_client
->desktop
== DESKTOP_ALL
);
584 /* have to try focus here because when you leave an empty desktop
585 there is no focus out to watch for. also, we have different rules
586 here. we always allow it to look under the mouse pointer if
587 config_focus_last is FALSE
589 do this before hiding the windows so if helper windows are coming
590 with us, they don't get hidden
592 if (dofocus
&& (c
= focus_fallback(TRUE
, !config_focus_last
, allow_omni
)))
594 /* only do the flicker reducing stuff ahead of time if we are going
595 to call xsetinputfocus on the window ourselves. otherwise there is
596 no guarantee the window will actually take focus.. */
598 /* reduce flicker by hiliting now rather than waiting for the
599 server FocusIn event */
600 frame_adjust_focus(c
->frame
, TRUE
);
601 /* do this here so that if you switch desktops to a window with
602 helper windows then the helper windows won't flash */
603 client_bring_helper_windows(c
);
607 /* hide windows from bottom to top */
608 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
609 if (WINDOW_IS_CLIENT(it
->data
)) {
610 ObClient
*c
= it
->data
;
615 event_end_ignore_all_enters(ignore_start
);
617 if (event_curtime
!= CurrentTime
)
618 screen_desktop_user_time
= event_curtime
;
621 static void get_row_col(guint d
, guint
*r
, guint
*c
)
623 switch (screen_desktop_layout
.orientation
) {
624 case OB_ORIENTATION_HORZ
:
625 switch (screen_desktop_layout
.start_corner
) {
626 case OB_CORNER_TOPLEFT
:
627 *r
= d
/ screen_desktop_layout
.columns
;
628 *c
= d
% screen_desktop_layout
.columns
;
630 case OB_CORNER_BOTTOMLEFT
:
631 *r
= screen_desktop_layout
.rows
- 1 -
632 d
/ screen_desktop_layout
.columns
;
633 *c
= d
% screen_desktop_layout
.columns
;
635 case OB_CORNER_TOPRIGHT
:
636 *r
= d
/ screen_desktop_layout
.columns
;
637 *c
= screen_desktop_layout
.columns
- 1 -
638 d
% screen_desktop_layout
.columns
;
640 case OB_CORNER_BOTTOMRIGHT
:
641 *r
= screen_desktop_layout
.rows
- 1 -
642 d
/ screen_desktop_layout
.columns
;
643 *c
= screen_desktop_layout
.columns
- 1 -
644 d
% screen_desktop_layout
.columns
;
648 case OB_ORIENTATION_VERT
:
649 switch (screen_desktop_layout
.start_corner
) {
650 case OB_CORNER_TOPLEFT
:
651 *r
= d
% screen_desktop_layout
.rows
;
652 *c
= d
/ screen_desktop_layout
.rows
;
654 case OB_CORNER_BOTTOMLEFT
:
655 *r
= screen_desktop_layout
.rows
- 1 -
656 d
% screen_desktop_layout
.rows
;
657 *c
= d
/ screen_desktop_layout
.rows
;
659 case OB_CORNER_TOPRIGHT
:
660 *r
= d
% screen_desktop_layout
.rows
;
661 *c
= screen_desktop_layout
.columns
- 1 -
662 d
/ screen_desktop_layout
.rows
;
664 case OB_CORNER_BOTTOMRIGHT
:
665 *r
= screen_desktop_layout
.rows
- 1 -
666 d
% screen_desktop_layout
.rows
;
667 *c
= screen_desktop_layout
.columns
- 1 -
668 d
/ screen_desktop_layout
.rows
;
675 static guint
translate_row_col(guint r
, guint c
)
677 switch (screen_desktop_layout
.orientation
) {
678 case OB_ORIENTATION_HORZ
:
679 switch (screen_desktop_layout
.start_corner
) {
680 case OB_CORNER_TOPLEFT
:
681 return r
% screen_desktop_layout
.rows
*
682 screen_desktop_layout
.columns
+
683 c
% screen_desktop_layout
.columns
;
684 case OB_CORNER_BOTTOMLEFT
:
685 return (screen_desktop_layout
.rows
- 1 -
686 r
% screen_desktop_layout
.rows
) *
687 screen_desktop_layout
.columns
+
688 c
% screen_desktop_layout
.columns
;
689 case OB_CORNER_TOPRIGHT
:
690 return r
% screen_desktop_layout
.rows
*
691 screen_desktop_layout
.columns
+
692 (screen_desktop_layout
.columns
- 1 -
693 c
% screen_desktop_layout
.columns
);
694 case OB_CORNER_BOTTOMRIGHT
:
695 return (screen_desktop_layout
.rows
- 1 -
696 r
% screen_desktop_layout
.rows
) *
697 screen_desktop_layout
.columns
+
698 (screen_desktop_layout
.columns
- 1 -
699 c
% screen_desktop_layout
.columns
);
701 case OB_ORIENTATION_VERT
:
702 switch (screen_desktop_layout
.start_corner
) {
703 case OB_CORNER_TOPLEFT
:
704 return c
% screen_desktop_layout
.columns
*
705 screen_desktop_layout
.rows
+
706 r
% screen_desktop_layout
.rows
;
707 case OB_CORNER_BOTTOMLEFT
:
708 return c
% screen_desktop_layout
.columns
*
709 screen_desktop_layout
.rows
+
710 (screen_desktop_layout
.rows
- 1 -
711 r
% screen_desktop_layout
.rows
);
712 case OB_CORNER_TOPRIGHT
:
713 return (screen_desktop_layout
.columns
- 1 -
714 c
% screen_desktop_layout
.columns
) *
715 screen_desktop_layout
.rows
+
716 r
% screen_desktop_layout
.rows
;
717 case OB_CORNER_BOTTOMRIGHT
:
718 return (screen_desktop_layout
.columns
- 1 -
719 c
% screen_desktop_layout
.columns
) *
720 screen_desktop_layout
.rows
+
721 (screen_desktop_layout
.rows
- 1 -
722 r
% screen_desktop_layout
.rows
);
725 g_assert_not_reached();
729 void screen_desktop_popup(guint d
, gboolean show
)
734 pager_popup_hide(desktop_cycle_popup
);
736 a
= screen_physical_area_monitor_active();
737 pager_popup_position(desktop_cycle_popup
, CenterGravity
,
738 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
739 pager_popup_icon_size_multiplier(desktop_cycle_popup
,
740 (screen_desktop_layout
.columns
/
741 screen_desktop_layout
.rows
) / 2,
742 (screen_desktop_layout
.rows
/
743 screen_desktop_layout
.columns
) / 2);
744 pager_popup_max_width(desktop_cycle_popup
,
745 MAX(a
->width
/3, POPUP_WIDTH
));
746 pager_popup_show(desktop_cycle_popup
, screen_desktop_names
[d
], d
);
750 guint
screen_cycle_desktop(ObDirection dir
, gboolean wrap
, gboolean linear
,
751 gboolean dialog
, gboolean done
, gboolean cancel
)
754 static guint d
= (guint
)-1;
760 if ((cancel
|| done
) && dialog
)
761 goto show_cycle_dialog
;
764 get_row_col(d
, &r
, &c
);
768 case OB_DIRECTION_EAST
:
769 if (d
< screen_num_desktops
- 1)
774 case OB_DIRECTION_WEST
:
778 d
= screen_num_desktops
- 1;
782 return screen_desktop
;
786 case OB_DIRECTION_EAST
:
788 if (c
>= screen_desktop_layout
.columns
) {
792 goto show_cycle_dialog
;
794 d
= translate_row_col(r
, c
);
795 if (d
>= screen_num_desktops
) {
800 goto show_cycle_dialog
;
804 case OB_DIRECTION_WEST
:
806 if (c
>= screen_desktop_layout
.columns
) {
808 c
= screen_desktop_layout
.columns
- 1;
810 goto show_cycle_dialog
;
812 d
= translate_row_col(r
, c
);
813 if (d
>= screen_num_desktops
) {
818 goto show_cycle_dialog
;
822 case OB_DIRECTION_SOUTH
:
824 if (r
>= screen_desktop_layout
.rows
) {
828 goto show_cycle_dialog
;
830 d
= translate_row_col(r
, c
);
831 if (d
>= screen_num_desktops
) {
836 goto show_cycle_dialog
;
840 case OB_DIRECTION_NORTH
:
842 if (r
>= screen_desktop_layout
.rows
) {
844 r
= screen_desktop_layout
.rows
- 1;
846 goto show_cycle_dialog
;
848 d
= translate_row_col(r
, c
);
849 if (d
>= screen_num_desktops
) {
854 goto show_cycle_dialog
;
860 return d
= screen_desktop
;
863 d
= translate_row_col(r
, c
);
867 if (dialog
&& !cancel
&& !done
) {
868 screen_desktop_popup(d
, TRUE
);
870 screen_desktop_popup(0, FALSE
);
873 if (!dialog
|| cancel
|| done
)
879 static gboolean
screen_validate_layout(ObDesktopLayout
*l
)
881 if (l
->columns
== 0 && l
->rows
== 0) /* both 0's is bad data.. */
884 /* fill in a zero rows/columns */
885 if (l
->columns
== 0) {
886 l
->columns
= screen_num_desktops
/ l
->rows
;
887 if (l
->rows
* l
->columns
< screen_num_desktops
)
889 if (l
->rows
* l
->columns
>= screen_num_desktops
+ l
->columns
)
891 } else if (l
->rows
== 0) {
892 l
->rows
= screen_num_desktops
/ l
->columns
;
893 if (l
->columns
* l
->rows
< screen_num_desktops
)
895 if (l
->columns
* l
->rows
>= screen_num_desktops
+ l
->rows
)
899 /* bounds checking */
900 if (l
->orientation
== OB_ORIENTATION_HORZ
) {
901 l
->columns
= MIN(screen_num_desktops
, l
->columns
);
902 l
->rows
= MIN(l
->rows
,
903 (screen_num_desktops
+ l
->columns
- 1) / l
->columns
);
904 l
->columns
= screen_num_desktops
/ l
->rows
+
905 !!(screen_num_desktops
% l
->rows
);
907 l
->rows
= MIN(screen_num_desktops
, l
->rows
);
908 l
->columns
= MIN(l
->columns
,
909 (screen_num_desktops
+ l
->rows
- 1) / l
->rows
);
910 l
->rows
= screen_num_desktops
/ l
->columns
+
911 !!(screen_num_desktops
% l
->columns
);
916 void screen_update_layout()
923 screen_desktop_layout
.orientation
= OB_ORIENTATION_HORZ
;
924 screen_desktop_layout
.start_corner
= OB_CORNER_TOPLEFT
;
925 screen_desktop_layout
.rows
= 1;
926 screen_desktop_layout
.columns
= screen_num_desktops
;
928 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
929 net_desktop_layout
, cardinal
, &data
, &num
)) {
930 if (num
== 3 || num
== 4) {
932 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
933 l
.orientation
= OB_ORIENTATION_VERT
;
934 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
935 l
.orientation
= OB_ORIENTATION_HORZ
;
940 l
.start_corner
= OB_CORNER_TOPLEFT
;
942 if (data
[3] == prop_atoms
.net_wm_topleft
)
943 l
.start_corner
= OB_CORNER_TOPLEFT
;
944 else if (data
[3] == prop_atoms
.net_wm_topright
)
945 l
.start_corner
= OB_CORNER_TOPRIGHT
;
946 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
947 l
.start_corner
= OB_CORNER_BOTTOMRIGHT
;
948 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
949 l
.start_corner
= OB_CORNER_BOTTOMLEFT
;
957 if (screen_validate_layout(&l
))
958 screen_desktop_layout
= l
;
965 void screen_update_desktop_names()
969 /* empty the array */
970 g_strfreev(screen_desktop_names
);
971 screen_desktop_names
= NULL
;
973 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
974 net_desktop_names
, utf8
, &screen_desktop_names
))
975 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
978 if (i
< screen_num_desktops
) {
981 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
982 screen_num_desktops
+ 1);
983 screen_desktop_names
[screen_num_desktops
] = NULL
;
985 it
= g_slist_nth(config_desktops_names
, i
);
987 for (; i
< screen_num_desktops
; ++i
) {
988 if (it
&& ((char*)it
->data
)[0]) /* not empty */
989 /* use the names from the config file when possible */
990 screen_desktop_names
[i
] = g_strdup(it
->data
);
992 /* make up a nice name if it's not though */
993 screen_desktop_names
[i
] = g_strdup_printf(_("desktop %i"),
995 if (it
) it
= g_slist_next(it
);
998 /* if we changed any names, then set the root property so we can
999 all agree on the names */
1000 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,
1001 screen_desktop_names
);
1004 /* resize the pager for these names */
1005 pager_popup_text_width_to_strings(desktop_cycle_popup
,
1006 screen_desktop_names
,
1007 screen_num_desktops
);
1010 void screen_show_desktop(gboolean show
, ObClient
*show_only
)
1014 if (show
== screen_showing_desktop
) return; /* no change */
1016 screen_showing_desktop
= show
;
1019 /* hide windows bottom to top */
1020 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
1021 if (WINDOW_IS_CLIENT(it
->data
)) {
1022 ObClient
*client
= it
->data
;
1023 client_showhide(client
);
1028 /* restore windows top to bottom */
1029 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
1030 if (WINDOW_IS_CLIENT(it
->data
)) {
1031 ObClient
*client
= it
->data
;
1032 if (client_should_show(client
)) {
1033 if (!show_only
|| client
== show_only
)
1034 client_show(client
);
1036 client_iconify(client
, TRUE
, FALSE
, TRUE
);
1043 /* focus the desktop */
1044 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
1045 ObClient
*c
= it
->data
;
1046 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
1047 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
1048 client_focus(it
->data
))
1052 else if (!show_only
) {
1055 if ((c
= focus_fallback(TRUE
, FALSE
, TRUE
))) {
1056 /* only do the flicker reducing stuff ahead of time if we are going
1057 to call xsetinputfocus on the window ourselves. otherwise there
1058 is no guarantee the window will actually take focus.. */
1060 /* reduce flicker by hiliting now rather than waiting for the
1061 server FocusIn event */
1062 frame_adjust_focus(c
->frame
, TRUE
);
1067 show
= !!show
; /* make it boolean */
1068 PROP_SET32(RootWindow(ob_display
, ob_screen
),
1069 net_showing_desktop
, cardinal
, show
);
1072 void screen_install_colormap(ObClient
*client
, gboolean install
)
1074 if (client
== NULL
|| client
->colormap
== None
) {
1076 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1078 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
1080 xerror_set_ignore(TRUE
);
1082 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1084 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
1085 xerror_set_ignore(FALSE
);
1090 screen_area_add_strut_left(const StrutPartial
*s
, const Rect
*monitor_area
,
1091 gint edge
, Strut
*ret
)
1094 ((s
->left_end
<= s
->left_start
) ||
1095 (RECT_TOP(*monitor_area
) < s
->left_end
&&
1096 RECT_BOTTOM(*monitor_area
) > s
->left_start
)))
1097 ret
->left
= MAX(ret
->left
, edge
);
1101 screen_area_add_strut_top(const StrutPartial
*s
, const Rect
*monitor_area
,
1102 gint edge
, Strut
*ret
)
1105 ((s
->top_end
<= s
->top_start
) ||
1106 (RECT_LEFT(*monitor_area
) < s
->top_end
&&
1107 RECT_RIGHT(*monitor_area
) > s
->top_start
)))
1108 ret
->top
= MAX(ret
->top
, edge
);
1112 screen_area_add_strut_right(const StrutPartial
*s
, const Rect
*monitor_area
,
1113 gint edge
, Strut
*ret
)
1116 ((s
->right_end
<= s
->right_start
) ||
1117 (RECT_TOP(*monitor_area
) < s
->right_end
&&
1118 RECT_BOTTOM(*monitor_area
) > s
->right_start
)))
1119 ret
->right
= MAX(ret
->right
, edge
);
1123 screen_area_add_strut_bottom(const StrutPartial
*s
, const Rect
*monitor_area
,
1124 gint edge
, Strut
*ret
)
1127 ((s
->bottom_end
<= s
->bottom_start
) ||
1128 (RECT_LEFT(*monitor_area
) < s
->bottom_end
&&
1129 RECT_RIGHT(*monitor_area
) > s
->bottom_start
)))
1130 ret
->bottom
= MAX(ret
->bottom
, edge
);
1133 void screen_update_areas()
1140 g_free(monitor_area
);
1141 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1144 for (i
= 0; area
[i
]; ++i
)
1149 area
= g_new(Rect
*, screen_num_desktops
+ 2);
1150 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
)
1151 area
[i
] = g_new0(Rect
, screen_num_monitors
+ 1);
1154 dims
= g_new(gulong
, 4 * screen_num_desktops
);
1156 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
) {
1160 struts
= g_new0(Strut
, screen_num_monitors
);
1162 /* calc the xinerama areas */
1163 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1164 area
[i
][x
] = monitor_area
[x
];
1166 l
= monitor_area
[x
].x
;
1167 t
= monitor_area
[x
].y
;
1168 r
= monitor_area
[x
].x
+ monitor_area
[x
].width
- 1;
1169 b
= monitor_area
[x
].y
+ monitor_area
[x
].height
- 1;
1171 l
= MIN(l
, monitor_area
[x
].x
);
1172 t
= MIN(t
, monitor_area
[x
].y
);
1173 r
= MAX(r
, monitor_area
[x
].x
+ monitor_area
[x
].width
- 1);
1174 b
= MAX(b
, monitor_area
[x
].y
+ monitor_area
[x
].height
- 1);
1177 RECT_SET(area
[i
][x
], l
, t
, r
- l
+ 1, b
- t
+ 1);
1179 /* apply the struts */
1181 /* find the left-most xin heads, i do this in 2 loops :| */
1183 for (x
= 1; x
< screen_num_monitors
; ++x
)
1184 o
= MIN(o
, area
[i
][x
].x
);
1186 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1187 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1188 ObClient
*c
= it
->data
;
1189 screen_area_add_strut_left(&c
->strut
,
1191 o
+ c
->strut
.left
- area
[i
][x
].x
,
1194 screen_area_add_strut_left(&dock_strut
,
1196 o
+ dock_strut
.left
- area
[i
][x
].x
,
1199 area
[i
][x
].x
+= struts
[x
].left
;
1200 area
[i
][x
].width
-= struts
[x
].left
;
1203 /* find the top-most xin heads, i do this in 2 loops :| */
1205 for (x
= 1; x
< screen_num_monitors
; ++x
)
1206 o
= MIN(o
, area
[i
][x
].y
);
1208 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1209 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1210 ObClient
*c
= it
->data
;
1211 screen_area_add_strut_top(&c
->strut
,
1213 o
+ c
->strut
.top
- area
[i
][x
].y
,
1216 screen_area_add_strut_top(&dock_strut
,
1218 o
+ dock_strut
.top
- area
[i
][x
].y
,
1221 area
[i
][x
].y
+= struts
[x
].top
;
1222 area
[i
][x
].height
-= struts
[x
].top
;
1225 /* find the right-most xin heads, i do this in 2 loops :| */
1226 o
= area
[i
][0].x
+ area
[i
][0].width
- 1;
1227 for (x
= 1; x
< screen_num_monitors
; ++x
)
1228 o
= MAX(o
, area
[i
][x
].x
+ area
[i
][x
].width
- 1);
1230 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1231 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1232 ObClient
*c
= it
->data
;
1233 screen_area_add_strut_right(&c
->strut
,
1236 area
[i
][x
].width
- 1) -
1237 (o
- c
->strut
.right
),
1240 screen_area_add_strut_right(&dock_strut
,
1243 area
[i
][x
].width
- 1) -
1244 (o
- dock_strut
.right
),
1247 area
[i
][x
].width
-= struts
[x
].right
;
1250 /* find the bottom-most xin heads, i do this in 2 loops :| */
1251 o
= area
[i
][0].y
+ area
[i
][0].height
- 1;
1252 for (x
= 1; x
< screen_num_monitors
; ++x
)
1253 o
= MAX(o
, area
[i
][x
].y
+ area
[i
][x
].height
- 1);
1255 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1256 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1257 ObClient
*c
= it
->data
;
1258 screen_area_add_strut_bottom(&c
->strut
,
1261 area
[i
][x
].height
- 1) - \
1262 (o
- c
->strut
.bottom
),
1265 screen_area_add_strut_bottom(&dock_strut
,
1268 area
[i
][x
].height
- 1) - \
1269 (o
- dock_strut
.bottom
),
1272 area
[i
][x
].height
-= struts
[x
].bottom
;
1275 l
= RECT_LEFT(area
[i
][0]);
1276 t
= RECT_TOP(area
[i
][0]);
1277 r
= RECT_RIGHT(area
[i
][0]);
1278 b
= RECT_BOTTOM(area
[i
][0]);
1279 for (x
= 1; x
< screen_num_monitors
; ++x
) {
1280 l
= MIN(l
, RECT_LEFT(area
[i
][x
]));
1281 t
= MIN(l
, RECT_TOP(area
[i
][x
]));
1282 r
= MAX(r
, RECT_RIGHT(area
[i
][x
]));
1283 b
= MAX(b
, RECT_BOTTOM(area
[i
][x
]));
1285 RECT_SET(area
[i
][screen_num_monitors
], l
, t
,
1286 r
- l
+ 1, b
- t
+ 1);
1288 /* XXX optimize when this is run? */
1290 /* the area has changed, adjust all the maximized
1292 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1293 ObClient
*c
= it
->data
;
1294 if (i
< screen_num_desktops
) {
1295 if (c
->desktop
== i
)
1296 client_reconfigure(c
);
1297 } else if (c
->desktop
== DESKTOP_ALL
)
1298 client_reconfigure(c
);
1300 if (i
< screen_num_desktops
) {
1301 /* don't set these for the 'all desktops' area */
1302 dims
[(i
* 4) + 0] = area
[i
][screen_num_monitors
].x
;
1303 dims
[(i
* 4) + 1] = area
[i
][screen_num_monitors
].y
;
1304 dims
[(i
* 4) + 2] = area
[i
][screen_num_monitors
].width
;
1305 dims
[(i
* 4) + 3] = area
[i
][screen_num_monitors
].height
;
1311 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1312 dims
, 4 * screen_num_desktops
);
1317 Rect
*screen_area(guint desktop
)
1319 return screen_area_monitor(desktop
, screen_num_monitors
);
1322 Rect
*screen_area_monitor(guint desktop
, guint head
)
1324 if (head
> screen_num_monitors
)
1326 if (desktop
>= screen_num_desktops
) {
1327 if (desktop
== DESKTOP_ALL
)
1328 return &area
[screen_num_desktops
][head
];
1331 return &area
[desktop
][head
];
1334 guint
screen_find_monitor(Rect
*search
)
1340 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1341 Rect
*area
= screen_physical_area_monitor(i
);
1342 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1346 RECT_SET_INTERSECTION(r
, *area
, *search
);
1347 v
= r
.width
* r
.height
;
1358 Rect
*screen_physical_area()
1360 return screen_physical_area_monitor(screen_num_monitors
);
1363 Rect
*screen_physical_area_monitor(guint head
)
1365 if (head
> screen_num_monitors
)
1367 return &monitor_area
[head
];
1370 Rect
*screen_physical_area_monitor_active()
1376 a
= screen_physical_area_monitor(client_monitor(focus_client
));
1379 if (screen_pointer_pos(&x
, &y
))
1380 RECT_SET(mon
, x
, y
, 1, 1);
1382 RECT_SET(mon
, 0, 0, 1, 1);
1383 a
= screen_physical_area_monitor(screen_find_monitor(&mon
));
1388 void screen_set_root_cursor()
1390 if (sn_app_starting())
1391 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1392 ob_cursor(OB_CURSOR_BUSYPOINTER
));
1394 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1395 ob_cursor(OB_CURSOR_POINTER
));
1398 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1405 ret
= !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1406 &w
, &w
, x
, y
, &i
, &i
, &u
);
1408 for (i
= 0; i
< ScreenCount(ob_display
); ++i
)
1410 if (XQueryPointer(ob_display
, RootWindow(ob_display
, i
),
1411 &w
, &w
, x
, y
, &i
, &i
, &u
))