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;
665 if ((cancel
|| done
) && dialog
)
666 goto show_cycle_dialog
;
668 get_row_col(d
, &r
, &c
);
672 case OB_DIRECTION_EAST
:
673 if (d
< screen_num_desktops
- 1)
678 case OB_DIRECTION_WEST
:
682 d
= screen_num_desktops
- 1;
686 return screen_desktop
;
690 case OB_DIRECTION_EAST
:
692 if (c
>= screen_desktop_layout
.columns
) {
697 goto show_cycle_dialog
;
700 d
= translate_row_col(r
, c
);
701 if (d
>= screen_num_desktops
) {
706 goto show_cycle_dialog
;
710 case OB_DIRECTION_WEST
:
712 if (c
>= screen_desktop_layout
.columns
) {
714 c
= screen_desktop_layout
.columns
- 1;
717 goto show_cycle_dialog
;
720 d
= translate_row_col(r
, c
);
721 if (d
>= screen_num_desktops
) {
726 goto show_cycle_dialog
;
730 case OB_DIRECTION_SOUTH
:
732 if (r
>= screen_desktop_layout
.rows
) {
737 goto show_cycle_dialog
;
740 d
= translate_row_col(r
, c
);
741 if (d
>= screen_num_desktops
) {
746 goto show_cycle_dialog
;
750 case OB_DIRECTION_NORTH
:
752 if (r
>= screen_desktop_layout
.rows
) {
754 r
= screen_desktop_layout
.rows
- 1;
757 goto show_cycle_dialog
;
760 d
= translate_row_col(r
, c
);
761 if (d
>= screen_num_desktops
) {
766 goto show_cycle_dialog
;
772 return d
= screen_desktop
;
775 d
= translate_row_col(r
, c
);
779 if (dialog
&& !cancel
&& !done
) {
780 screen_desktop_popup(d
, TRUE
);
782 screen_desktop_popup(0, FALSE
);
785 if (!dialog
|| cancel
|| done
)
791 void screen_update_layout()
793 ObOrientation orient
;
799 gboolean valid
= FALSE
;
801 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
802 net_desktop_layout
, cardinal
, &data
, &num
)) {
803 if (num
== 3 || num
== 4) {
805 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
806 orient
= OB_ORIENTATION_VERT
;
807 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
808 orient
= OB_ORIENTATION_HORZ
;
810 goto screen_update_layout_bail
;
813 corner
= OB_CORNER_TOPLEFT
;
815 if (data
[3] == prop_atoms
.net_wm_topleft
)
816 corner
= OB_CORNER_TOPLEFT
;
817 else if (data
[3] == prop_atoms
.net_wm_topright
)
818 corner
= OB_CORNER_TOPRIGHT
;
819 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
820 corner
= OB_CORNER_BOTTOMRIGHT
;
821 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
822 corner
= OB_CORNER_BOTTOMLEFT
;
824 goto screen_update_layout_bail
;
830 /* fill in a zero rows/columns */
831 if ((cols
== 0 && rows
== 0)) { /* both 0's is bad data.. */
832 goto screen_update_layout_bail
;
835 cols
= screen_num_desktops
/ rows
;
836 if (rows
* cols
< screen_num_desktops
)
838 if (rows
* cols
>= screen_num_desktops
+ cols
)
840 } else if (rows
== 0) {
841 rows
= screen_num_desktops
/ cols
;
842 if (cols
* rows
< screen_num_desktops
)
844 if (cols
* rows
>= screen_num_desktops
+ rows
)
849 /* bounds checking */
850 if (orient
== OB_ORIENTATION_HORZ
) {
851 cols
= MIN(screen_num_desktops
, cols
);
852 rows
= MIN(rows
, (screen_num_desktops
+ cols
- 1) / cols
);
853 cols
= screen_num_desktops
/ rows
+
854 !!(screen_num_desktops
% rows
);
856 rows
= MIN(screen_num_desktops
, rows
);
857 cols
= MIN(cols
, (screen_num_desktops
+ rows
- 1) / rows
);
858 rows
= screen_num_desktops
/ cols
+
859 !!(screen_num_desktops
% cols
);
864 screen_update_layout_bail
:
870 orient
= OB_ORIENTATION_HORZ
;
871 corner
= OB_CORNER_TOPLEFT
;
873 cols
= screen_num_desktops
;
876 screen_desktop_layout
.orientation
= orient
;
877 screen_desktop_layout
.start_corner
= corner
;
878 screen_desktop_layout
.rows
= rows
;
879 screen_desktop_layout
.columns
= cols
;
882 void screen_update_desktop_names()
886 /* empty the array */
887 g_strfreev(screen_desktop_names
);
888 screen_desktop_names
= NULL
;
890 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
891 net_desktop_names
, utf8
, &screen_desktop_names
))
892 for (i
= 0; screen_desktop_names
[i
] && i
< screen_num_desktops
; ++i
);
895 if (i
< screen_num_desktops
) {
896 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
897 screen_num_desktops
+ 1);
898 screen_desktop_names
[screen_num_desktops
] = NULL
;
899 for (; i
< screen_num_desktops
; ++i
)
900 screen_desktop_names
[i
] = g_strdup_printf("desktop %i", i
+ 1);
903 /* resize the pager for these names */
904 pager_popup_text_width_to_strings(desktop_cycle_popup
,
905 screen_desktop_names
,
906 screen_num_desktops
);
909 void screen_show_desktop(gboolean show
, gboolean restore_focus
)
913 if (show
== screen_showing_desktop
) return; /* no change */
915 screen_showing_desktop
= show
;
919 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
920 if (WINDOW_IS_CLIENT(it
->data
)) {
921 ObClient
*client
= it
->data
;
922 client_showhide(client
);
927 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
928 if (WINDOW_IS_CLIENT(it
->data
)) {
929 ObClient
*client
= it
->data
;
930 client_showhide(client
);
937 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
938 ObClient
*c
= it
->data
;
939 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
940 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
941 client_focus(it
->data
))
944 } else if (restore_focus
) {
947 /* use NULL for the "old" argument because the desktop was focused
948 and we don't want to fallback to the desktop by default */
949 if ((c
= focus_fallback_target(TRUE
, NULL
)))
953 show
= !!show
; /* make it boolean */
954 PROP_SET32(RootWindow(ob_display
, ob_screen
),
955 net_showing_desktop
, cardinal
, show
);
958 void screen_install_colormap(ObClient
*client
, gboolean install
)
960 if (client
== NULL
) {
962 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
964 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
966 xerror_set_ignore(TRUE
);
968 if (client
->colormap
!= None
)
969 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
971 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
972 xerror_set_ignore(FALSE
);
977 screen_area_add_strut_left(const StrutPartial
*s
, const Rect
*monitor_area
,
978 gint edge
, Strut
*ret
)
981 ((s
->left_end
<= s
->left_start
) ||
982 (RECT_TOP(*monitor_area
) < s
->left_end
&&
983 RECT_BOTTOM(*monitor_area
) > s
->left_start
)))
984 ret
->left
= MAX(ret
->left
, edge
);
988 screen_area_add_strut_top(const StrutPartial
*s
, const Rect
*monitor_area
,
989 gint edge
, Strut
*ret
)
992 ((s
->top_end
<= s
->top_start
) ||
993 (RECT_LEFT(*monitor_area
) < s
->top_end
&&
994 RECT_RIGHT(*monitor_area
) > s
->top_start
)))
995 ret
->top
= MAX(ret
->top
, edge
);
999 screen_area_add_strut_right(const StrutPartial
*s
, const Rect
*monitor_area
,
1000 gint edge
, Strut
*ret
)
1003 ((s
->right_end
<= s
->right_start
) ||
1004 (RECT_TOP(*monitor_area
) < s
->right_end
&&
1005 RECT_BOTTOM(*monitor_area
) > s
->right_start
)))
1006 ret
->right
= MAX(ret
->right
, edge
);
1010 screen_area_add_strut_bottom(const StrutPartial
*s
, const Rect
*monitor_area
,
1011 gint edge
, Strut
*ret
)
1014 ((s
->bottom_end
<= s
->bottom_start
) ||
1015 (RECT_LEFT(*monitor_area
) < s
->bottom_end
&&
1016 RECT_RIGHT(*monitor_area
) > s
->bottom_start
)))
1017 ret
->bottom
= MAX(ret
->bottom
, edge
);
1020 void screen_update_areas()
1027 g_free(monitor_area
);
1028 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
1031 for (i
= 0; area
[i
]; ++i
)
1036 area
= g_new(Rect
*, screen_num_desktops
+ 2);
1037 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
)
1038 area
[i
] = g_new0(Rect
, screen_num_monitors
+ 1);
1041 dims
= g_new(gulong
, 4 * screen_num_desktops
);
1043 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
) {
1047 struts
= g_new0(Strut
, screen_num_monitors
);
1049 /* calc the xinerama areas */
1050 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1051 area
[i
][x
] = monitor_area
[x
];
1053 l
= monitor_area
[x
].x
;
1054 t
= monitor_area
[x
].y
;
1055 r
= monitor_area
[x
].x
+ monitor_area
[x
].width
- 1;
1056 b
= monitor_area
[x
].y
+ monitor_area
[x
].height
- 1;
1058 l
= MIN(l
, monitor_area
[x
].x
);
1059 t
= MIN(t
, monitor_area
[x
].y
);
1060 r
= MAX(r
, monitor_area
[x
].x
+ monitor_area
[x
].width
- 1);
1061 b
= MAX(b
, monitor_area
[x
].y
+ monitor_area
[x
].height
- 1);
1064 RECT_SET(area
[i
][x
], l
, t
, r
- l
+ 1, b
- t
+ 1);
1066 /* apply the struts */
1068 /* find the left-most xin heads, i do this in 2 loops :| */
1070 for (x
= 1; x
< screen_num_monitors
; ++x
)
1071 o
= MIN(o
, area
[i
][x
].x
);
1073 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1074 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1075 ObClient
*c
= it
->data
;
1076 screen_area_add_strut_left(&c
->strut
,
1078 o
+ c
->strut
.left
- area
[i
][x
].x
,
1081 screen_area_add_strut_left(&dock_strut
,
1083 o
+ dock_strut
.left
- area
[i
][x
].x
,
1086 area
[i
][x
].x
+= struts
[x
].left
;
1087 area
[i
][x
].width
-= struts
[x
].left
;
1090 /* find the top-most xin heads, i do this in 2 loops :| */
1092 for (x
= 1; x
< screen_num_monitors
; ++x
)
1093 o
= MIN(o
, area
[i
][x
].y
);
1095 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1096 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1097 ObClient
*c
= it
->data
;
1098 screen_area_add_strut_top(&c
->strut
,
1100 o
+ c
->strut
.top
- area
[i
][x
].y
,
1103 screen_area_add_strut_top(&dock_strut
,
1105 o
+ dock_strut
.top
- area
[i
][x
].y
,
1108 area
[i
][x
].y
+= struts
[x
].top
;
1109 area
[i
][x
].height
-= struts
[x
].top
;
1112 /* find the right-most xin heads, i do this in 2 loops :| */
1113 o
= area
[i
][0].x
+ area
[i
][0].width
- 1;
1114 for (x
= 1; x
< screen_num_monitors
; ++x
)
1115 o
= MAX(o
, area
[i
][x
].x
+ area
[i
][x
].width
- 1);
1117 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1118 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1119 ObClient
*c
= it
->data
;
1120 screen_area_add_strut_right(&c
->strut
,
1123 area
[i
][x
].width
- 1) -
1124 (o
- c
->strut
.right
),
1127 screen_area_add_strut_right(&dock_strut
,
1130 area
[i
][x
].width
- 1) -
1131 (o
- dock_strut
.right
),
1134 area
[i
][x
].width
-= struts
[x
].right
;
1137 /* find the bottom-most xin heads, i do this in 2 loops :| */
1138 o
= area
[i
][0].y
+ area
[i
][0].height
- 1;
1139 for (x
= 1; x
< screen_num_monitors
; ++x
)
1140 o
= MAX(o
, area
[i
][x
].y
+ area
[i
][x
].height
- 1);
1142 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1143 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1144 ObClient
*c
= it
->data
;
1145 screen_area_add_strut_bottom(&c
->strut
,
1148 area
[i
][x
].height
- 1) - \
1149 (o
- c
->strut
.bottom
),
1152 screen_area_add_strut_bottom(&dock_strut
,
1155 area
[i
][x
].height
- 1) - \
1156 (o
- dock_strut
.bottom
),
1159 area
[i
][x
].height
-= struts
[x
].bottom
;
1162 l
= RECT_LEFT(area
[i
][0]);
1163 t
= RECT_TOP(area
[i
][0]);
1164 r
= RECT_RIGHT(area
[i
][0]);
1165 b
= RECT_BOTTOM(area
[i
][0]);
1166 for (x
= 1; x
< screen_num_monitors
; ++x
) {
1167 l
= MIN(l
, RECT_LEFT(area
[i
][x
]));
1168 t
= MIN(l
, RECT_TOP(area
[i
][x
]));
1169 r
= MAX(r
, RECT_RIGHT(area
[i
][x
]));
1170 b
= MAX(b
, RECT_BOTTOM(area
[i
][x
]));
1172 RECT_SET(area
[i
][screen_num_monitors
], l
, t
,
1173 r
- l
+ 1, b
- t
+ 1);
1175 /* XXX optimize when this is run? */
1177 /* the area has changed, adjust all the maximized
1179 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1180 ObClient
*c
= it
->data
;
1181 if (i
< screen_num_desktops
) {
1182 if (c
->desktop
== i
)
1183 client_reconfigure(c
);
1184 } else if (c
->desktop
== DESKTOP_ALL
)
1185 client_reconfigure(c
);
1187 if (i
< screen_num_desktops
) {
1188 /* don't set these for the 'all desktops' area */
1189 dims
[(i
* 4) + 0] = area
[i
][screen_num_monitors
].x
;
1190 dims
[(i
* 4) + 1] = area
[i
][screen_num_monitors
].y
;
1191 dims
[(i
* 4) + 2] = area
[i
][screen_num_monitors
].width
;
1192 dims
[(i
* 4) + 3] = area
[i
][screen_num_monitors
].height
;
1198 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1199 dims
, 4 * screen_num_desktops
);
1204 Rect
*screen_area(guint desktop
)
1206 return screen_area_monitor(desktop
, screen_num_monitors
);
1209 Rect
*screen_area_monitor(guint desktop
, guint head
)
1211 if (head
> screen_num_monitors
)
1213 if (desktop
>= screen_num_desktops
) {
1214 if (desktop
== DESKTOP_ALL
)
1215 return &area
[screen_num_desktops
][head
];
1218 return &area
[desktop
][head
];
1221 guint
screen_find_monitor(Rect
*search
)
1227 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1228 Rect
*area
= screen_physical_area_monitor(i
);
1229 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1233 RECT_SET_INTERSECTION(r
, *area
, *search
);
1234 v
= r
.width
* r
.height
;
1245 Rect
*screen_physical_area()
1247 return screen_physical_area_monitor(screen_num_monitors
);
1250 Rect
*screen_physical_area_monitor(guint head
)
1252 if (head
> screen_num_monitors
)
1254 return &monitor_area
[head
];
1257 void screen_set_root_cursor()
1259 if (sn_app_starting())
1260 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1261 ob_cursor(OB_CURSOR_BUSY
));
1263 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1264 ob_cursor(OB_CURSOR_POINTER
));
1267 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1274 ret
= !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1275 &w
, &w
, x
, y
, &i
, &i
, &u
);
1277 for (i
= 0; i
< ScreenCount(ob_display
); ++i
)
1279 if (XQueryPointer(ob_display
, RootWindow(ob_display
, i
),
1280 &w
, &w
, x
, y
, &i
, &i
, &u
))