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 guint screen_num_desktops
;
54 guint screen_num_monitors
;
56 guint screen_last_desktop
;
57 Size screen_physical_size
;
58 gboolean screen_showing_desktop
;
59 DesktopLayout screen_desktop_layout
;
60 gchar
**screen_desktop_names
;
61 Window screen_support_win
;
62 Time screen_desktop_user_time
= CurrentTime
;
64 static Rect
**area
; /* array of desktop holding array of xinerama areas */
65 static Rect
*monitor_area
;
67 static ObPagerPopup
*desktop_cycle_popup
;
69 static gboolean
replace_wm()
73 Window current_wm_sn_owner
;
76 wm_sn
= g_strdup_printf("WM_S%d", ob_screen
);
77 wm_sn_atom
= XInternAtom(ob_display
, wm_sn
, FALSE
);
80 current_wm_sn_owner
= XGetSelectionOwner(ob_display
, wm_sn_atom
);
81 if (current_wm_sn_owner
== screen_support_win
)
82 current_wm_sn_owner
= None
;
83 if (current_wm_sn_owner
) {
85 g_message(_("A window manager is already running on screen %d"),
89 xerror_set_ignore(TRUE
);
90 xerror_occured
= FALSE
;
92 /* We want to find out when the current selection owner dies */
93 XSelectInput(ob_display
, current_wm_sn_owner
, StructureNotifyMask
);
94 XSync(ob_display
, FALSE
);
96 xerror_set_ignore(FALSE
);
98 current_wm_sn_owner
= None
;
102 /* Generate a timestamp */
105 XSelectInput(ob_display
, screen_support_win
, PropertyChangeMask
);
107 XChangeProperty(ob_display
, screen_support_win
,
108 prop_atoms
.wm_class
, prop_atoms
.string
,
109 8, PropModeAppend
, NULL
, 0);
110 XWindowEvent(ob_display
, screen_support_win
,
111 PropertyChangeMask
, &event
);
113 XSelectInput(ob_display
, screen_support_win
, NoEventMask
);
115 timestamp
= event
.xproperty
.time
;
118 XSetSelectionOwner(ob_display
, wm_sn_atom
, screen_support_win
,
121 if (XGetSelectionOwner(ob_display
, wm_sn_atom
) != screen_support_win
) {
122 g_message(_("Could not acquire window manager selection on screen %d"),
127 /* Wait for old window manager to go away */
128 if (current_wm_sn_owner
) {
131 const gulong timeout
= G_USEC_PER_SEC
* 15; /* wait for 15s max */
133 while (wait
< timeout
) {
134 if (XCheckWindowEvent(ob_display
, current_wm_sn_owner
,
135 StructureNotifyMask
, &event
) &&
136 event
.type
== DestroyNotify
)
138 g_usleep(G_USEC_PER_SEC
/ 10);
139 wait
+= G_USEC_PER_SEC
/ 10;
142 if (wait
>= timeout
) {
143 g_message(_("The WM on screen %d is not exiting"), ob_screen
);
148 /* Send client message indicating that we are now the WM */
149 prop_message(RootWindow(ob_display
, ob_screen
), prop_atoms
.manager
,
150 timestamp
, wm_sn_atom
, screen_support_win
, 0,
151 SubstructureNotifyMask
);
156 gboolean
screen_annex(const gchar
*program_name
)
158 XSetWindowAttributes attrib
;
161 Atom
*prop_atoms_start
, *wm_supported_pos
;
164 /* create the netwm support window */
165 attrib
.override_redirect
= TRUE
;
166 screen_support_win
= XCreateWindow(ob_display
,
167 RootWindow(ob_display
, ob_screen
),
169 CopyFromParent
, InputOutput
,
171 CWOverrideRedirect
, &attrib
);
172 XMapWindow(ob_display
, screen_support_win
);
173 XLowerWindow(ob_display
, screen_support_win
);
176 XDestroyWindow(ob_display
, screen_support_win
);
180 xerror_set_ignore(TRUE
);
181 xerror_occured
= FALSE
;
182 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
184 xerror_set_ignore(FALSE
);
185 if (xerror_occured
) {
186 g_message(_("A window manager is already running on screen %d"),
189 XDestroyWindow(ob_display
, screen_support_win
);
194 screen_set_root_cursor();
196 /* set the OPENBOX_PID hint */
198 PROP_SET32(RootWindow(ob_display
, ob_screen
),
199 openbox_pid
, cardinal
, pid
);
201 /* set supporting window */
202 PROP_SET32(RootWindow(ob_display
, ob_screen
),
203 net_supporting_wm_check
, window
, screen_support_win
);
205 /* set properties on the supporting window */
206 PROP_SETS(screen_support_win
, net_wm_name
, program_name
);
207 PROP_SET32(screen_support_win
, net_supporting_wm_check
,
208 window
, screen_support_win
);
210 /* set the _NET_SUPPORTED_ATOMS hint */
212 /* this is all the atoms after net_supported in the prop_atoms struct */
213 prop_atoms_start
= (Atom
*)&prop_atoms
;
214 wm_supported_pos
= (Atom
*)&(prop_atoms
.net_supported
);
215 num_support
= sizeof(prop_atoms
) / sizeof(Atom
) -
216 (wm_supported_pos
- prop_atoms_start
) - 1;
218 supported
= g_new(gulong
, num_support
);
219 supported
[i
++] = prop_atoms
.net_supporting_wm_check
;
220 supported
[i
++] = prop_atoms
.net_wm_full_placement
;
221 supported
[i
++] = prop_atoms
.net_current_desktop
;
222 supported
[i
++] = prop_atoms
.net_number_of_desktops
;
223 supported
[i
++] = prop_atoms
.net_desktop_geometry
;
224 supported
[i
++] = prop_atoms
.net_desktop_viewport
;
225 supported
[i
++] = prop_atoms
.net_active_window
;
226 supported
[i
++] = prop_atoms
.net_workarea
;
227 supported
[i
++] = prop_atoms
.net_client_list
;
228 supported
[i
++] = prop_atoms
.net_client_list_stacking
;
229 supported
[i
++] = prop_atoms
.net_desktop_names
;
230 supported
[i
++] = prop_atoms
.net_close_window
;
231 supported
[i
++] = prop_atoms
.net_desktop_layout
;
232 supported
[i
++] = prop_atoms
.net_showing_desktop
;
233 supported
[i
++] = prop_atoms
.net_wm_name
;
234 supported
[i
++] = prop_atoms
.net_wm_visible_name
;
235 supported
[i
++] = prop_atoms
.net_wm_icon_name
;
236 supported
[i
++] = prop_atoms
.net_wm_visible_icon_name
;
237 supported
[i
++] = prop_atoms
.net_wm_desktop
;
238 supported
[i
++] = prop_atoms
.net_wm_strut
;
239 supported
[i
++] = prop_atoms
.net_wm_strut_partial
;
240 supported
[i
++] = prop_atoms
.net_wm_icon
;
241 supported
[i
++] = prop_atoms
.net_wm_icon_geometry
;
242 supported
[i
++] = prop_atoms
.net_wm_window_type
;
243 supported
[i
++] = prop_atoms
.net_wm_window_type_desktop
;
244 supported
[i
++] = prop_atoms
.net_wm_window_type_dock
;
245 supported
[i
++] = prop_atoms
.net_wm_window_type_toolbar
;
246 supported
[i
++] = prop_atoms
.net_wm_window_type_menu
;
247 supported
[i
++] = prop_atoms
.net_wm_window_type_utility
;
248 supported
[i
++] = prop_atoms
.net_wm_window_type_splash
;
249 supported
[i
++] = prop_atoms
.net_wm_window_type_dialog
;
250 supported
[i
++] = prop_atoms
.net_wm_window_type_normal
;
251 supported
[i
++] = prop_atoms
.net_wm_allowed_actions
;
252 supported
[i
++] = prop_atoms
.net_wm_action_move
;
253 supported
[i
++] = prop_atoms
.net_wm_action_resize
;
254 supported
[i
++] = prop_atoms
.net_wm_action_minimize
;
255 supported
[i
++] = prop_atoms
.net_wm_action_shade
;
256 supported
[i
++] = prop_atoms
.net_wm_action_maximize_horz
;
257 supported
[i
++] = prop_atoms
.net_wm_action_maximize_vert
;
258 supported
[i
++] = prop_atoms
.net_wm_action_fullscreen
;
259 supported
[i
++] = prop_atoms
.net_wm_action_change_desktop
;
260 supported
[i
++] = prop_atoms
.net_wm_action_close
;
261 supported
[i
++] = prop_atoms
.net_wm_state
;
262 supported
[i
++] = prop_atoms
.net_wm_state_modal
;
263 supported
[i
++] = prop_atoms
.net_wm_state_maximized_vert
;
264 supported
[i
++] = prop_atoms
.net_wm_state_maximized_horz
;
265 supported
[i
++] = prop_atoms
.net_wm_state_shaded
;
266 supported
[i
++] = prop_atoms
.net_wm_state_skip_taskbar
;
267 supported
[i
++] = prop_atoms
.net_wm_state_skip_pager
;
268 supported
[i
++] = prop_atoms
.net_wm_state_hidden
;
269 supported
[i
++] = prop_atoms
.net_wm_state_fullscreen
;
270 supported
[i
++] = prop_atoms
.net_wm_state_above
;
271 supported
[i
++] = prop_atoms
.net_wm_state_below
;
272 supported
[i
++] = prop_atoms
.net_wm_state_demands_attention
;
273 supported
[i
++] = prop_atoms
.net_moveresize_window
;
274 supported
[i
++] = prop_atoms
.net_wm_moveresize
;
275 supported
[i
++] = prop_atoms
.net_wm_user_time
;
276 supported
[i
++] = prop_atoms
.net_wm_user_time_window
;
277 supported
[i
++] = prop_atoms
.net_frame_extents
;
278 supported
[i
++] = prop_atoms
.net_request_frame_extents
;
279 supported
[i
++] = prop_atoms
.net_restack_window
;
280 supported
[i
++] = prop_atoms
.net_startup_id
;
282 supported
[i
++] = prop_atoms
.net_wm_sync_request
;
283 supported
[i
++] = prop_atoms
.net_wm_sync_request_counter
;
286 supported
[i
++] = prop_atoms
.kde_wm_change_state
;
287 supported
[i
++] = prop_atoms
.kde_net_wm_frame_strut
;
288 supported
[i
++] = prop_atoms
.kde_net_wm_window_type_override
;
290 supported
[i
++] = prop_atoms
.openbox_wm_state_undecorated
;
291 supported
[i
++] = prop_atoms
.openbox_pid
;
292 supported
[i
++] = prop_atoms
.openbox_config
;
293 supported
[i
++] = prop_atoms
.openbox_control
;
294 g_assert(i
== num_support
);
296 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
297 net_supported
, atom
, supported
, num_support
);
303 void screen_startup(gboolean reconfig
)
310 desktop_cycle_popup
= pager_popup_new(FALSE
);
311 pager_popup_height(desktop_cycle_popup
, POPUP_HEIGHT
);
316 /* get the initial size */
319 /* get the desktop names */
320 numnames
= g_slist_length(config_desktops_names
);
321 names
= g_new(gchar
*, numnames
+ 1);
322 names
[numnames
] = NULL
;
323 for (i
= 0, it
= config_desktops_names
; it
; ++i
, it
= g_slist_next(it
))
324 names
[i
] = g_strdup(it
->data
);
326 /* set the root window property */
327 PROP_SETSS(RootWindow(ob_display
, ob_screen
), net_desktop_names
,names
);
331 /* set the number of desktops */
332 screen_num_desktops
= 0;
333 screen_set_num_desktops(config_desktops_num
);
335 /* start on the current desktop when a wm was already running */
336 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
337 net_current_desktop
, cardinal
, &d
) &&
338 d
< screen_num_desktops
)
340 screen_set_desktop(d
, FALSE
);
341 } else if (session_desktop
>= 0)
342 screen_set_desktop(MIN((guint
)session_desktop
,
343 screen_num_desktops
), FALSE
);
345 screen_set_desktop(MIN(config_screen_firstdesk
,
346 screen_num_desktops
) - 1, FALSE
);
348 /* don't start in showing-desktop mode */
349 screen_showing_desktop
= FALSE
;
350 PROP_SET32(RootWindow(ob_display
, ob_screen
),
351 net_showing_desktop
, cardinal
, screen_showing_desktop
);
353 screen_update_layout();
356 void screen_shutdown(gboolean reconfig
)
360 pager_popup_free(desktop_cycle_popup
);
365 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
368 /* we're not running here no more! */
369 PROP_ERASE(RootWindow(ob_display
, ob_screen
), openbox_pid
);
371 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_supported
);
372 /* don't keep this mode */
373 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_showing_desktop
);
375 XDestroyWindow(ob_display
, screen_support_win
);
377 g_strfreev(screen_desktop_names
);
378 screen_desktop_names
= NULL
;
380 for (r
= area
; *r
; ++r
)
388 static gint oldw
= 0, oldh
= 0;
393 w
= WidthOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
394 h
= HeightOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
396 if (w
== oldw
&& h
== oldh
) return;
400 /* Set the _NET_DESKTOP_GEOMETRY hint */
401 screen_physical_size
.width
= geometry
[0] = w
;
402 screen_physical_size
.height
= geometry
[1] = h
;
403 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
404 net_desktop_geometry
, cardinal
, geometry
, 2);
406 if (ob_state() == OB_STATE_STARTING
)
409 screen_update_areas();
412 for (it
= client_list
; it
; it
= g_list_next(it
))
413 client_move_onscreen(it
->data
, FALSE
);
416 void screen_set_num_desktops(guint num
)
424 if (screen_num_desktops
== num
) return;
426 old
= screen_num_desktops
;
427 screen_num_desktops
= num
;
428 PROP_SET32(RootWindow(ob_display
, ob_screen
),
429 net_number_of_desktops
, cardinal
, num
);
431 /* set the viewport hint */
432 viewport
= g_new0(gulong
, num
* 2);
433 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
434 net_desktop_viewport
, cardinal
, viewport
, num
* 2);
437 /* the number of rows/columns will differ */
438 screen_update_layout();
440 /* move windows on desktops that will no longer exist! */
441 for (it
= client_list
; it
; it
= g_list_next(it
)) {
442 ObClient
*c
= it
->data
;
443 if (c
->desktop
>= num
&& c
->desktop
!= DESKTOP_ALL
)
444 client_set_desktop(c
, num
- 1, FALSE
);
447 /* change our struts/area to match (after moving windows) */
448 screen_update_areas();
450 /* may be some unnamed desktops that we need to fill in with names
451 (after updating the areas so the popup can resize) */
452 screen_update_desktop_names();
454 /* change our desktop if we're on one that no longer exists! */
455 if (screen_desktop
>= screen_num_desktops
)
456 screen_set_desktop(num
- 1, TRUE
);
459 void screen_set_desktop(guint num
, gboolean dofocus
)
465 g_assert(num
< screen_num_desktops
);
467 old
= screen_desktop
;
468 screen_desktop
= num
;
469 PROP_SET32(RootWindow(ob_display
, ob_screen
),
470 net_current_desktop
, cardinal
, num
);
472 if (old
== num
) return;
474 screen_last_desktop
= old
;
476 ob_debug("Moving to desktop %d\n", num
+1);
478 if (moveresize_client
)
479 client_set_desktop(moveresize_client
, num
, TRUE
);
481 /* show windows before hiding the rest to lessen the enter/leave events */
483 /* show windows from top to bottom */
484 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
485 if (WINDOW_IS_CLIENT(it
->data
)) {
486 ObClient
*c
= it
->data
;
491 /* have to try focus here because when you leave an empty desktop
492 there is no focus out to watch for
494 do this before hiding the windows so if helper windows are coming
495 with us, they don't get hidden
497 if (dofocus
&& (c
= focus_fallback_target(TRUE
, focus_client
))) {
498 /* only do the flicker reducing stuff ahead of time if we are going
499 to call xsetinputfocus on the window ourselves. otherwise there is
500 no guarantee the window will actually take focus.. */
502 /* do this here so that if you switch desktops to a window with
503 helper windows then the helper windows won't flash */
504 client_bring_helper_windows(c
);
505 /* reduce flicker by hiliting now rather than waiting for the
506 server FocusIn event */
507 frame_adjust_focus(c
->frame
, TRUE
);
512 /* hide windows from bottom to top */
513 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
514 if (WINDOW_IS_CLIENT(it
->data
)) {
515 ObClient
*c
= it
->data
;
520 event_ignore_queued_enters();
522 if (event_curtime
!= CurrentTime
)
523 screen_desktop_user_time
= event_curtime
;
526 static void get_row_col(guint d
, guint
*r
, guint
*c
)
528 switch (screen_desktop_layout
.orientation
) {
529 case OB_ORIENTATION_HORZ
:
530 switch (screen_desktop_layout
.start_corner
) {
531 case OB_CORNER_TOPLEFT
:
532 *r
= d
/ screen_desktop_layout
.columns
;
533 *c
= d
% screen_desktop_layout
.columns
;
535 case OB_CORNER_BOTTOMLEFT
:
536 *r
= screen_desktop_layout
.rows
- 1 -
537 d
/ screen_desktop_layout
.columns
;
538 *c
= d
% screen_desktop_layout
.columns
;
540 case OB_CORNER_TOPRIGHT
:
541 *r
= d
/ screen_desktop_layout
.columns
;
542 *c
= screen_desktop_layout
.columns
- 1 -
543 d
% screen_desktop_layout
.columns
;
545 case OB_CORNER_BOTTOMRIGHT
:
546 *r
= screen_desktop_layout
.rows
- 1 -
547 d
/ screen_desktop_layout
.columns
;
548 *c
= screen_desktop_layout
.columns
- 1 -
549 d
% screen_desktop_layout
.columns
;
553 case OB_ORIENTATION_VERT
:
554 switch (screen_desktop_layout
.start_corner
) {
555 case OB_CORNER_TOPLEFT
:
556 *r
= d
% screen_desktop_layout
.rows
;
557 *c
= d
/ screen_desktop_layout
.rows
;
559 case OB_CORNER_BOTTOMLEFT
:
560 *r
= screen_desktop_layout
.rows
- 1 -
561 d
% screen_desktop_layout
.rows
;
562 *c
= d
/ screen_desktop_layout
.rows
;
564 case OB_CORNER_TOPRIGHT
:
565 *r
= d
% screen_desktop_layout
.rows
;
566 *c
= screen_desktop_layout
.columns
- 1 -
567 d
/ screen_desktop_layout
.rows
;
569 case OB_CORNER_BOTTOMRIGHT
:
570 *r
= screen_desktop_layout
.rows
- 1 -
571 d
% screen_desktop_layout
.rows
;
572 *c
= screen_desktop_layout
.columns
- 1 -
573 d
/ screen_desktop_layout
.rows
;
580 static guint
translate_row_col(guint r
, guint c
)
582 switch (screen_desktop_layout
.orientation
) {
583 case OB_ORIENTATION_HORZ
:
584 switch (screen_desktop_layout
.start_corner
) {
585 case OB_CORNER_TOPLEFT
:
586 return r
% screen_desktop_layout
.rows
*
587 screen_desktop_layout
.columns
+
588 c
% screen_desktop_layout
.columns
;
589 case OB_CORNER_BOTTOMLEFT
:
590 return (screen_desktop_layout
.rows
- 1 -
591 r
% screen_desktop_layout
.rows
) *
592 screen_desktop_layout
.columns
+
593 c
% screen_desktop_layout
.columns
;
594 case OB_CORNER_TOPRIGHT
:
595 return r
% screen_desktop_layout
.rows
*
596 screen_desktop_layout
.columns
+
597 (screen_desktop_layout
.columns
- 1 -
598 c
% screen_desktop_layout
.columns
);
599 case OB_CORNER_BOTTOMRIGHT
:
600 return (screen_desktop_layout
.rows
- 1 -
601 r
% screen_desktop_layout
.rows
) *
602 screen_desktop_layout
.columns
+
603 (screen_desktop_layout
.columns
- 1 -
604 c
% screen_desktop_layout
.columns
);
606 case OB_ORIENTATION_VERT
:
607 switch (screen_desktop_layout
.start_corner
) {
608 case OB_CORNER_TOPLEFT
:
609 return c
% screen_desktop_layout
.columns
*
610 screen_desktop_layout
.rows
+
611 r
% screen_desktop_layout
.rows
;
612 case OB_CORNER_BOTTOMLEFT
:
613 return c
% screen_desktop_layout
.columns
*
614 screen_desktop_layout
.rows
+
615 (screen_desktop_layout
.rows
- 1 -
616 r
% screen_desktop_layout
.rows
);
617 case OB_CORNER_TOPRIGHT
:
618 return (screen_desktop_layout
.columns
- 1 -
619 c
% screen_desktop_layout
.columns
) *
620 screen_desktop_layout
.rows
+
621 r
% screen_desktop_layout
.rows
;
622 case OB_CORNER_BOTTOMRIGHT
:
623 return (screen_desktop_layout
.columns
- 1 -
624 c
% screen_desktop_layout
.columns
) *
625 screen_desktop_layout
.rows
+
626 (screen_desktop_layout
.rows
- 1 -
627 r
% screen_desktop_layout
.rows
);
630 g_assert_not_reached();
634 void screen_desktop_popup(guint d
, gboolean show
)
639 pager_popup_hide(desktop_cycle_popup
);
641 a
= screen_physical_area_monitor(0);
642 pager_popup_position(desktop_cycle_popup
, CenterGravity
,
643 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
644 pager_popup_icon_size_multiplier(desktop_cycle_popup
,
645 screen_desktop_layout
.columns
/
646 screen_desktop_layout
.rows
/ 2,
647 screen_desktop_layout
.rows
/
648 screen_desktop_layout
.columns
/ 2);
649 pager_popup_max_width(desktop_cycle_popup
,
650 MAX(a
->width
/3, POPUP_WIDTH
));
651 pager_popup_show(desktop_cycle_popup
, screen_desktop_names
[d
], d
);
655 guint
screen_cycle_desktop(ObDirection dir
, gboolean wrap
, gboolean linear
,
656 gboolean dialog
, gboolean done
, gboolean cancel
)
659 static guint d
= (guint
)-1;
662 if ((cancel
|| done
) && dialog
)
663 goto show_cycle_dialog
;
667 get_row_col(d
, &r
, &c
);
671 case OB_DIRECTION_EAST
:
672 if (d
< screen_num_desktops
- 1)
677 case OB_DIRECTION_WEST
:
681 d
= screen_num_desktops
- 1;
685 return screen_desktop
;
689 case OB_DIRECTION_EAST
:
691 if (c
>= screen_desktop_layout
.columns
) {
696 goto show_cycle_dialog
;
699 d
= translate_row_col(r
, c
);
700 if (d
>= screen_num_desktops
) {
705 goto show_cycle_dialog
;
709 case OB_DIRECTION_WEST
:
711 if (c
>= screen_desktop_layout
.columns
) {
713 c
= screen_desktop_layout
.columns
- 1;
716 goto show_cycle_dialog
;
719 d
= translate_row_col(r
, c
);
720 if (d
>= screen_num_desktops
) {
725 goto show_cycle_dialog
;
729 case OB_DIRECTION_SOUTH
:
731 if (r
>= screen_desktop_layout
.rows
) {
736 goto show_cycle_dialog
;
739 d
= translate_row_col(r
, c
);
740 if (d
>= screen_num_desktops
) {
745 goto show_cycle_dialog
;
749 case OB_DIRECTION_NORTH
:
751 if (r
>= screen_desktop_layout
.rows
) {
753 r
= screen_desktop_layout
.rows
- 1;
756 goto show_cycle_dialog
;
759 d
= translate_row_col(r
, c
);
760 if (d
>= screen_num_desktops
) {
765 goto show_cycle_dialog
;
771 return d
= screen_desktop
;
774 d
= translate_row_col(r
, c
);
778 if (dialog
&& !cancel
&& !done
) {
779 screen_desktop_popup(d
, TRUE
);
781 screen_desktop_popup(0, FALSE
);
784 if (!dialog
|| cancel
|| done
)
790 void screen_update_layout()
792 ObOrientation orient
;
798 gboolean valid
= FALSE
;
800 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
801 net_desktop_layout
, cardinal
, &data
, &num
)) {
802 if (num
== 3 || num
== 4) {
804 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
805 orient
= OB_ORIENTATION_VERT
;
806 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
807 orient
= OB_ORIENTATION_HORZ
;
809 goto screen_update_layout_bail
;
812 corner
= OB_CORNER_TOPLEFT
;
814 if (data
[3] == prop_atoms
.net_wm_topleft
)
815 corner
= OB_CORNER_TOPLEFT
;
816 else if (data
[3] == prop_atoms
.net_wm_topright
)
817 corner
= OB_CORNER_TOPRIGHT
;
818 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
819 corner
= OB_CORNER_BOTTOMRIGHT
;
820 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
821 corner
= OB_CORNER_BOTTOMLEFT
;
823 goto screen_update_layout_bail
;
829 /* fill in a zero rows/columns */
830 if ((cols
== 0 && rows
== 0)) { /* both 0's is bad data.. */
831 goto screen_update_layout_bail
;
834 cols
= screen_num_desktops
/ rows
;
835 if (rows
* cols
< screen_num_desktops
)
837 if (rows
* cols
>= screen_num_desktops
+ cols
)
839 } else if (rows
== 0) {
840 rows
= screen_num_desktops
/ cols
;
841 if (cols
* rows
< screen_num_desktops
)
843 if (cols
* rows
>= screen_num_desktops
+ rows
)
848 /* bounds checking */
849 if (orient
== OB_ORIENTATION_HORZ
) {
850 cols
= MIN(screen_num_desktops
, cols
);
851 rows
= MIN(rows
, (screen_num_desktops
+ cols
- 1) / cols
);
852 cols
= screen_num_desktops
/ rows
+
853 !!(screen_num_desktops
% rows
);
855 rows
= MIN(screen_num_desktops
, rows
);
856 cols
= MIN(cols
, (screen_num_desktops
+ rows
- 1) / rows
);
857 rows
= screen_num_desktops
/ cols
+
858 !!(screen_num_desktops
% cols
);
863 screen_update_layout_bail
:
869 orient
= OB_ORIENTATION_HORZ
;
870 corner
= OB_CORNER_TOPLEFT
;
872 cols
= screen_num_desktops
;
875 screen_desktop_layout
.orientation
= orient
;
876 screen_desktop_layout
.start_corner
= corner
;
877 screen_desktop_layout
.rows
= rows
;
878 screen_desktop_layout
.columns
= cols
;
881 void screen_update_desktop_names()
885 /* empty the array */
886 g_strfreev(screen_desktop_names
);
887 screen_desktop_names
= NULL
;
889 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
890 net_desktop_names
, utf8
, &screen_desktop_names
))
891 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
894 if (i
< screen_num_desktops
) {
895 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
896 screen_num_desktops
+ 1);
897 screen_desktop_names
[screen_num_desktops
] = NULL
;
898 for (; i
< screen_num_desktops
; ++i
)
899 screen_desktop_names
[i
] = g_strdup_printf("desktop %i", i
+ 1);
902 /* resize the pager for these names */
903 pager_popup_text_width_to_strings(desktop_cycle_popup
,
904 screen_desktop_names
,
905 screen_num_desktops
);
908 void screen_show_desktop(gboolean show
, gboolean restore_focus
)
912 if (show
== screen_showing_desktop
) return; /* no change */
914 screen_showing_desktop
= show
;
918 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
919 if (WINDOW_IS_CLIENT(it
->data
)) {
920 ObClient
*client
= it
->data
;
921 client_showhide(client
);
926 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
927 if (WINDOW_IS_CLIENT(it
->data
)) {
928 ObClient
*client
= it
->data
;
929 client_showhide(client
);
936 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
937 ObClient
*c
= it
->data
;
938 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
939 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
940 client_focus(it
->data
))
943 } else if (restore_focus
) {
946 /* use NULL for the "old" argument because the desktop was focused
947 and we don't want to fallback to the desktop by default */
948 if ((c
= focus_fallback_target(TRUE
, NULL
)))
952 show
= !!show
; /* make it boolean */
953 PROP_SET32(RootWindow(ob_display
, ob_screen
),
954 net_showing_desktop
, cardinal
, show
);
957 void screen_install_colormap(ObClient
*client
, gboolean install
)
959 if (client
== NULL
) {
961 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
963 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
965 xerror_set_ignore(TRUE
);
967 if (client
->colormap
!= None
)
968 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
970 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
971 xerror_set_ignore(FALSE
);
976 screen_area_add_strut_left(const StrutPartial
*s
, const Rect
*monitor_area
,
977 gint edge
, Strut
*ret
)
980 ((s
->left_end
<= s
->left_start
) ||
981 (RECT_TOP(*monitor_area
) < s
->left_end
&&
982 RECT_BOTTOM(*monitor_area
) > s
->left_start
)))
983 ret
->left
= MAX(ret
->left
, edge
);
987 screen_area_add_strut_top(const StrutPartial
*s
, const Rect
*monitor_area
,
988 gint edge
, Strut
*ret
)
991 ((s
->top_end
<= s
->top_start
) ||
992 (RECT_LEFT(*monitor_area
) < s
->top_end
&&
993 RECT_RIGHT(*monitor_area
) > s
->top_start
)))
994 ret
->top
= MAX(ret
->top
, edge
);
998 screen_area_add_strut_right(const StrutPartial
*s
, const Rect
*monitor_area
,
999 gint edge
, Strut
*ret
)
1002 ((s
->right_end
<= s
->right_start
) ||
1003 (RECT_TOP(*monitor_area
) < s
->right_end
&&
1004 RECT_BOTTOM(*monitor_area
) > s
->right_start
)))
1005 ret
->right
= MAX(ret
->right
, edge
);
1009 screen_area_add_strut_bottom(const StrutPartial
*s
, const Rect
*monitor_area
,
1010 gint edge
, Strut
*ret
)
1013 ((s
->bottom_end
<= s
->bottom_start
) ||
1014 (RECT_LEFT(*monitor_area
) < s
->bottom_end
&&
1015 RECT_RIGHT(*monitor_area
) > s
->bottom_start
)))
1016 ret
->bottom
= MAX(ret
->bottom
, edge
);
1019 void screen_update_areas()
1026 g_free(monitor_area
);
1027 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1030 for (i
= 0; area
[i
]; ++i
)
1035 area
= g_new(Rect
*, screen_num_desktops
+ 2);
1036 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
)
1037 area
[i
] = g_new0(Rect
, screen_num_monitors
+ 1);
1040 dims
= g_new(gulong
, 4 * screen_num_desktops
);
1042 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
) {
1046 struts
= g_new0(Strut
, screen_num_monitors
);
1048 /* calc the xinerama areas */
1049 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1050 area
[i
][x
] = monitor_area
[x
];
1052 l
= monitor_area
[x
].x
;
1053 t
= monitor_area
[x
].y
;
1054 r
= monitor_area
[x
].x
+ monitor_area
[x
].width
- 1;
1055 b
= monitor_area
[x
].y
+ monitor_area
[x
].height
- 1;
1057 l
= MIN(l
, monitor_area
[x
].x
);
1058 t
= MIN(t
, monitor_area
[x
].y
);
1059 r
= MAX(r
, monitor_area
[x
].x
+ monitor_area
[x
].width
- 1);
1060 b
= MAX(b
, monitor_area
[x
].y
+ monitor_area
[x
].height
- 1);
1063 RECT_SET(area
[i
][x
], l
, t
, r
- l
+ 1, b
- t
+ 1);
1065 /* apply the struts */
1067 /* find the left-most xin heads, i do this in 2 loops :| */
1069 for (x
= 1; x
< screen_num_monitors
; ++x
)
1070 o
= MIN(o
, area
[i
][x
].x
);
1072 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1073 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1074 ObClient
*c
= it
->data
;
1075 screen_area_add_strut_left(&c
->strut
,
1077 o
+ c
->strut
.left
- area
[i
][x
].x
,
1080 screen_area_add_strut_left(&dock_strut
,
1082 o
+ dock_strut
.left
- area
[i
][x
].x
,
1085 area
[i
][x
].x
+= struts
[x
].left
;
1086 area
[i
][x
].width
-= struts
[x
].left
;
1089 /* find the top-most xin heads, i do this in 2 loops :| */
1091 for (x
= 1; x
< screen_num_monitors
; ++x
)
1092 o
= MIN(o
, area
[i
][x
].y
);
1094 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1095 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1096 ObClient
*c
= it
->data
;
1097 screen_area_add_strut_top(&c
->strut
,
1099 o
+ c
->strut
.top
- area
[i
][x
].y
,
1102 screen_area_add_strut_top(&dock_strut
,
1104 o
+ dock_strut
.top
- area
[i
][x
].y
,
1107 area
[i
][x
].y
+= struts
[x
].top
;
1108 area
[i
][x
].height
-= struts
[x
].top
;
1111 /* find the right-most xin heads, i do this in 2 loops :| */
1112 o
= area
[i
][0].x
+ area
[i
][0].width
- 1;
1113 for (x
= 1; x
< screen_num_monitors
; ++x
)
1114 o
= MAX(o
, area
[i
][x
].x
+ area
[i
][x
].width
- 1);
1116 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1117 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1118 ObClient
*c
= it
->data
;
1119 screen_area_add_strut_right(&c
->strut
,
1122 area
[i
][x
].width
- 1) -
1123 (o
- c
->strut
.right
),
1126 screen_area_add_strut_right(&dock_strut
,
1129 area
[i
][x
].width
- 1) -
1130 (o
- dock_strut
.right
),
1133 area
[i
][x
].width
-= struts
[x
].right
;
1136 /* find the bottom-most xin heads, i do this in 2 loops :| */
1137 o
= area
[i
][0].y
+ area
[i
][0].height
- 1;
1138 for (x
= 1; x
< screen_num_monitors
; ++x
)
1139 o
= MAX(o
, area
[i
][x
].y
+ area
[i
][x
].height
- 1);
1141 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1142 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1143 ObClient
*c
= it
->data
;
1144 screen_area_add_strut_bottom(&c
->strut
,
1147 area
[i
][x
].height
- 1) - \
1148 (o
- c
->strut
.bottom
),
1151 screen_area_add_strut_bottom(&dock_strut
,
1154 area
[i
][x
].height
- 1) - \
1155 (o
- dock_strut
.bottom
),
1158 area
[i
][x
].height
-= struts
[x
].bottom
;
1161 l
= RECT_LEFT(area
[i
][0]);
1162 t
= RECT_TOP(area
[i
][0]);
1163 r
= RECT_RIGHT(area
[i
][0]);
1164 b
= RECT_BOTTOM(area
[i
][0]);
1165 for (x
= 1; x
< screen_num_monitors
; ++x
) {
1166 l
= MIN(l
, RECT_LEFT(area
[i
][x
]));
1167 t
= MIN(l
, RECT_TOP(area
[i
][x
]));
1168 r
= MAX(r
, RECT_RIGHT(area
[i
][x
]));
1169 b
= MAX(b
, RECT_BOTTOM(area
[i
][x
]));
1171 RECT_SET(area
[i
][screen_num_monitors
], l
, t
,
1172 r
- l
+ 1, b
- t
+ 1);
1174 /* XXX optimize when this is run? */
1176 /* the area has changed, adjust all the maximized
1178 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1179 ObClient
*c
= it
->data
;
1180 if (i
< screen_num_desktops
) {
1181 if (c
->desktop
== i
)
1182 client_reconfigure(c
);
1183 } else if (c
->desktop
== DESKTOP_ALL
)
1184 client_reconfigure(c
);
1186 if (i
< screen_num_desktops
) {
1187 /* don't set these for the 'all desktops' area */
1188 dims
[(i
* 4) + 0] = area
[i
][screen_num_monitors
].x
;
1189 dims
[(i
* 4) + 1] = area
[i
][screen_num_monitors
].y
;
1190 dims
[(i
* 4) + 2] = area
[i
][screen_num_monitors
].width
;
1191 dims
[(i
* 4) + 3] = area
[i
][screen_num_monitors
].height
;
1197 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1198 dims
, 4 * screen_num_desktops
);
1203 Rect
*screen_area(guint desktop
)
1205 return screen_area_monitor(desktop
, screen_num_monitors
);
1208 Rect
*screen_area_monitor(guint desktop
, guint head
)
1210 if (head
> screen_num_monitors
)
1212 if (desktop
>= screen_num_desktops
) {
1213 if (desktop
== DESKTOP_ALL
)
1214 return &area
[screen_num_desktops
][head
];
1217 return &area
[desktop
][head
];
1220 guint
screen_find_monitor(Rect
*search
)
1226 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1227 Rect
*area
= screen_physical_area_monitor(i
);
1228 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1232 RECT_SET_INTERSECTION(r
, *area
, *search
);
1233 v
= r
.width
* r
.height
;
1244 Rect
*screen_physical_area()
1246 return screen_physical_area_monitor(screen_num_monitors
);
1249 Rect
*screen_physical_area_monitor(guint head
)
1251 if (head
> screen_num_monitors
)
1253 return &monitor_area
[head
];
1256 void screen_set_root_cursor()
1258 if (sn_app_starting())
1259 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1260 ob_cursor(OB_CURSOR_BUSY
));
1262 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1263 ob_cursor(OB_CURSOR_POINTER
));
1266 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1273 ret
= !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1274 &w
, &w
, x
, y
, &i
, &i
, &u
);
1276 for (i
= 0; i
< ScreenCount(ob_display
); ++i
)
1278 if (XQueryPointer(ob_display
, RootWindow(ob_display
, i
),
1279 &w
, &w
, x
, y
, &i
, &i
, &u
))