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"
35 #include "extensions.h"
36 #include "render/render.h"
41 # include <sys/types.h>
46 /*! The event mask to grab on the root window */
47 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
48 EnterWindowMask | LeaveWindowMask | \
49 SubstructureRedirectMask | FocusChangeMask | \
50 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
52 guint screen_num_desktops
;
53 guint screen_num_monitors
;
55 guint screen_last_desktop
;
56 Size screen_physical_size
;
57 gboolean screen_showing_desktop
;
58 DesktopLayout screen_desktop_layout
;
59 gchar
**screen_desktop_names
;
60 Window screen_support_win
;
62 static Rect
**area
; /* array of desktop holding array of xinerama areas */
63 static Rect
*monitor_area
;
65 static ObPagerPopup
*desktop_cycle_popup
;
67 static gboolean
replace_wm()
71 Window current_wm_sn_owner
;
74 wm_sn
= g_strdup_printf("WM_S%d", ob_screen
);
75 wm_sn_atom
= XInternAtom(ob_display
, wm_sn
, FALSE
);
78 current_wm_sn_owner
= XGetSelectionOwner(ob_display
, wm_sn_atom
);
79 if (current_wm_sn_owner
== screen_support_win
)
80 current_wm_sn_owner
= None
;
81 if (current_wm_sn_owner
) {
83 g_message(_("A window manager is already running on screen %d"),
87 xerror_set_ignore(TRUE
);
88 xerror_occured
= FALSE
;
90 /* We want to find out when the current selection owner dies */
91 XSelectInput(ob_display
, current_wm_sn_owner
, StructureNotifyMask
);
92 XSync(ob_display
, FALSE
);
94 xerror_set_ignore(FALSE
);
96 current_wm_sn_owner
= None
;
100 /* Generate a timestamp */
103 XSelectInput(ob_display
, screen_support_win
, PropertyChangeMask
);
105 XChangeProperty(ob_display
, screen_support_win
,
106 prop_atoms
.wm_class
, prop_atoms
.string
,
107 8, PropModeAppend
, NULL
, 0);
108 XWindowEvent(ob_display
, screen_support_win
,
109 PropertyChangeMask
, &event
);
111 XSelectInput(ob_display
, screen_support_win
, NoEventMask
);
113 timestamp
= event
.xproperty
.time
;
116 XSetSelectionOwner(ob_display
, wm_sn_atom
, screen_support_win
,
119 if (XGetSelectionOwner(ob_display
, wm_sn_atom
) != screen_support_win
) {
120 g_message(_("Could not acquire window manager selection on screen %d"),
125 /* Wait for old window manager to go away */
126 if (current_wm_sn_owner
) {
129 const gulong timeout
= G_USEC_PER_SEC
* 15; /* wait for 15s max */
131 while (wait
< timeout
) {
132 if (XCheckWindowEvent(ob_display
, current_wm_sn_owner
,
133 StructureNotifyMask
, &event
) &&
134 event
.type
== DestroyNotify
)
136 g_usleep(G_USEC_PER_SEC
/ 10);
137 wait
+= G_USEC_PER_SEC
/ 10;
140 if (wait
>= timeout
) {
141 g_message(_("Timeout expired while waiting for the current WM to die"
142 " on screen %d"), ob_screen
);
147 /* Send client message indicating that we are now the WM */
148 prop_message(RootWindow(ob_display
, ob_screen
), prop_atoms
.manager
,
149 timestamp
, wm_sn_atom
, 0, 0, SubstructureNotifyMask
);
155 gboolean
screen_annex()
157 XSetWindowAttributes attrib
;
162 /* create the netwm support window */
163 attrib
.override_redirect
= TRUE
;
164 screen_support_win
= XCreateWindow(ob_display
,
165 RootWindow(ob_display
, ob_screen
),
167 CopyFromParent
, InputOutput
,
169 CWOverrideRedirect
, &attrib
);
170 XMapWindow(ob_display
, screen_support_win
);
173 XDestroyWindow(ob_display
, screen_support_win
);
177 xerror_set_ignore(TRUE
);
178 xerror_occured
= FALSE
;
179 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
181 xerror_set_ignore(FALSE
);
182 if (xerror_occured
) {
183 g_message(_("A window manager is already running on screen %d"),
186 XDestroyWindow(ob_display
, screen_support_win
);
191 screen_set_root_cursor();
193 /* set the OPENBOX_PID hint */
195 PROP_SET32(RootWindow(ob_display
, ob_screen
),
196 openbox_pid
, cardinal
, pid
);
198 /* set supporting window */
199 PROP_SET32(RootWindow(ob_display
, ob_screen
),
200 net_supporting_wm_check
, window
, screen_support_win
);
202 /* set properties on the supporting window */
203 PROP_SETS(screen_support_win
, net_wm_name
, "Openbox");
204 PROP_SET32(screen_support_win
, net_supporting_wm_check
,
205 window
, screen_support_win
);
207 /* set the _NET_SUPPORTED_ATOMS hint */
213 supported
= g_new(gulong
, num_support
);
214 supported
[i
++] = prop_atoms
.net_wm_full_placement
;
215 supported
[i
++] = prop_atoms
.net_current_desktop
;
216 supported
[i
++] = prop_atoms
.net_number_of_desktops
;
217 supported
[i
++] = prop_atoms
.net_desktop_geometry
;
218 supported
[i
++] = prop_atoms
.net_desktop_viewport
;
219 supported
[i
++] = prop_atoms
.net_active_window
;
220 supported
[i
++] = prop_atoms
.net_workarea
;
221 supported
[i
++] = prop_atoms
.net_client_list
;
222 supported
[i
++] = prop_atoms
.net_client_list_stacking
;
223 supported
[i
++] = prop_atoms
.net_desktop_names
;
224 supported
[i
++] = prop_atoms
.net_close_window
;
225 supported
[i
++] = prop_atoms
.net_desktop_layout
;
226 supported
[i
++] = prop_atoms
.net_showing_desktop
;
227 supported
[i
++] = prop_atoms
.net_wm_name
;
228 supported
[i
++] = prop_atoms
.net_wm_visible_name
;
229 supported
[i
++] = prop_atoms
.net_wm_icon_name
;
230 supported
[i
++] = prop_atoms
.net_wm_visible_icon_name
;
231 supported
[i
++] = prop_atoms
.net_wm_desktop
;
232 supported
[i
++] = prop_atoms
.net_wm_strut
;
233 supported
[i
++] = prop_atoms
.net_wm_window_type
;
234 supported
[i
++] = prop_atoms
.net_wm_window_type_desktop
;
235 supported
[i
++] = prop_atoms
.net_wm_window_type_dock
;
236 supported
[i
++] = prop_atoms
.net_wm_window_type_toolbar
;
237 supported
[i
++] = prop_atoms
.net_wm_window_type_menu
;
238 supported
[i
++] = prop_atoms
.net_wm_window_type_utility
;
239 supported
[i
++] = prop_atoms
.net_wm_window_type_splash
;
240 supported
[i
++] = prop_atoms
.net_wm_window_type_dialog
;
241 supported
[i
++] = prop_atoms
.net_wm_window_type_normal
;
242 supported
[i
++] = prop_atoms
.net_wm_allowed_actions
;
243 supported
[i
++] = prop_atoms
.net_wm_action_move
;
244 supported
[i
++] = prop_atoms
.net_wm_action_resize
;
245 supported
[i
++] = prop_atoms
.net_wm_action_minimize
;
246 supported
[i
++] = prop_atoms
.net_wm_action_shade
;
247 supported
[i
++] = prop_atoms
.net_wm_action_maximize_horz
;
248 supported
[i
++] = prop_atoms
.net_wm_action_maximize_vert
;
249 supported
[i
++] = prop_atoms
.net_wm_action_fullscreen
;
250 supported
[i
++] = prop_atoms
.net_wm_action_change_desktop
;
251 supported
[i
++] = prop_atoms
.net_wm_action_close
;
252 supported
[i
++] = prop_atoms
.net_wm_state
;
253 supported
[i
++] = prop_atoms
.net_wm_state_modal
;
254 supported
[i
++] = prop_atoms
.net_wm_state_maximized_vert
;
255 supported
[i
++] = prop_atoms
.net_wm_state_maximized_horz
;
256 supported
[i
++] = prop_atoms
.net_wm_state_shaded
;
257 supported
[i
++] = prop_atoms
.net_wm_state_skip_taskbar
;
258 supported
[i
++] = prop_atoms
.net_wm_state_skip_pager
;
259 supported
[i
++] = prop_atoms
.net_wm_state_hidden
;
260 supported
[i
++] = prop_atoms
.net_wm_state_fullscreen
;
261 supported
[i
++] = prop_atoms
.net_wm_state_above
;
262 supported
[i
++] = prop_atoms
.net_wm_state_below
;
263 supported
[i
++] = prop_atoms
.net_wm_state_demands_attention
;
264 supported
[i
++] = prop_atoms
.net_moveresize_window
;
265 supported
[i
++] = prop_atoms
.net_wm_moveresize
;
266 supported
[i
++] = prop_atoms
.net_wm_user_time
;
267 supported
[i
++] = prop_atoms
.net_frame_extents
;
269 supported
[i
++] = prop_atoms
.net_wm_sync_request
;
270 supported
[i
++] = prop_atoms
.net_wm_sync_request_counter
;
272 supported
[i
++] = prop_atoms
.ob_wm_state_undecorated
;
273 g_assert(i
== num_support
);
275 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
276 net_supported
, atom
, supported
, num_support
);
282 void screen_startup(gboolean reconfig
)
287 desktop_cycle_popup
= pager_popup_new(FALSE
);
290 /* get the initial size */
294 screen_desktop_names
= g_new(gchar
*,
295 g_slist_length(config_desktops_names
) + 1);
296 for (i
= 0, it
= config_desktops_names
; it
; ++i
, it
= g_slist_next(it
))
297 screen_desktop_names
[i
] = it
->data
; /* dont strdup */
298 screen_desktop_names
[i
] = NULL
;
299 PROP_SETSS(RootWindow(ob_display
, ob_screen
),
300 net_desktop_names
, screen_desktop_names
);
301 g_free(screen_desktop_names
); /* dont free the individual strings */
302 screen_desktop_names
= NULL
;
305 screen_num_desktops
= 0;
306 screen_set_num_desktops(config_desktops_num
);
309 /* start on the current desktop when a wm was already running */
310 if (PROP_GET32(RootWindow(ob_display
, ob_screen
),
311 net_current_desktop
, cardinal
, &d
) &&
312 d
< screen_num_desktops
)
314 screen_set_desktop(d
);
316 screen_set_desktop(MIN(config_screen_firstdesk
,
317 screen_num_desktops
) - 1);
319 /* don't start in showing-desktop mode */
320 screen_showing_desktop
= FALSE
;
321 PROP_SET32(RootWindow(ob_display
, ob_screen
),
322 net_showing_desktop
, cardinal
, screen_showing_desktop
);
324 screen_update_layout();
328 void screen_shutdown(gboolean reconfig
)
332 pager_popup_free(desktop_cycle_popup
);
335 XSelectInput(ob_display
, RootWindow(ob_display
, ob_screen
),
338 /* we're not running here no more! */
339 PROP_ERASE(RootWindow(ob_display
, ob_screen
), openbox_pid
);
341 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_supported
);
342 /* don't keep this mode */
343 PROP_ERASE(RootWindow(ob_display
, ob_screen
), net_showing_desktop
);
345 XDestroyWindow(ob_display
, screen_support_win
);
348 g_strfreev(screen_desktop_names
);
349 screen_desktop_names
= NULL
;
350 for (r
= area
; *r
; ++r
)
358 static gint oldw
= 0, oldh
= 0;
363 w
= WidthOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
364 h
= HeightOfScreen(ScreenOfDisplay(ob_display
, ob_screen
));
366 if (w
== oldw
&& h
== oldh
) return;
370 /* Set the _NET_DESKTOP_GEOMETRY hint */
371 screen_physical_size
.width
= geometry
[0] = w
;
372 screen_physical_size
.height
= geometry
[1] = h
;
373 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
374 net_desktop_geometry
, cardinal
, geometry
, 2);
376 if (ob_state() == OB_STATE_STARTING
)
379 screen_update_areas();
382 for (it
= client_list
; it
; it
= g_list_next(it
))
383 client_move_onscreen(it
->data
, FALSE
);
386 void screen_set_num_desktops(guint num
)
394 if (screen_num_desktops
== num
) return;
396 old
= screen_num_desktops
;
397 screen_num_desktops
= num
;
398 PROP_SET32(RootWindow(ob_display
, ob_screen
),
399 net_number_of_desktops
, cardinal
, num
);
401 /* set the viewport hint */
402 viewport
= g_new0(gulong
, num
* 2);
403 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
404 net_desktop_viewport
, cardinal
, viewport
, num
* 2);
407 /* the number of rows/columns will differ */
408 screen_update_layout();
410 /* may be some unnamed desktops that we need to fill in with names */
411 screen_update_desktop_names();
413 /* move windows on desktops that will no longer exist! */
414 for (it
= client_list
; it
; it
= g_list_next(it
)) {
415 ObClient
*c
= it
->data
;
416 if (c
->desktop
>= num
&& c
->desktop
!= DESKTOP_ALL
)
417 client_set_desktop(c
, num
- 1, FALSE
);
420 /* change our struts/area to match (after moving windows) */
421 screen_update_areas();
423 /* change our desktop if we're on one that no longer exists! */
424 if (screen_desktop
>= screen_num_desktops
)
425 screen_set_desktop(num
- 1);
428 void screen_set_desktop(guint num
)
434 g_assert(num
< screen_num_desktops
);
436 old
= screen_desktop
;
437 screen_desktop
= num
;
438 PROP_SET32(RootWindow(ob_display
, ob_screen
),
439 net_current_desktop
, cardinal
, num
);
441 if (old
== num
) return;
443 screen_last_desktop
= old
;
445 ob_debug("Moving to desktop %d\n", num
+1);
447 if (moveresize_client
)
448 client_set_desktop(moveresize_client
, num
, TRUE
);
450 /* show windows before hiding the rest to lessen the enter/leave events */
452 /* show/hide windows from top to bottom */
453 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
454 if (WINDOW_IS_CLIENT(it
->data
)) {
455 ObClient
*c
= it
->data
;
460 /* hide windows from bottom to top */
461 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
462 if (WINDOW_IS_CLIENT(it
->data
)) {
463 ObClient
*c
= it
->data
;
468 /* have to try focus here because when you leave an empty desktop
469 there is no focus out to watch for */
470 if ((c
= focus_fallback_target(TRUE
, focus_client
))) {
471 /* reduce flicker by hiliting now rather than waiting for the server
473 frame_adjust_focus(c
->frame
, TRUE
);
477 event_ignore_queued_enters();
480 static void get_row_col(guint d
, guint
*r
, guint
*c
)
482 switch (screen_desktop_layout
.orientation
) {
483 case OB_ORIENTATION_HORZ
:
484 switch (screen_desktop_layout
.start_corner
) {
485 case OB_CORNER_TOPLEFT
:
486 *r
= d
/ screen_desktop_layout
.columns
;
487 *c
= d
% screen_desktop_layout
.columns
;
489 case OB_CORNER_BOTTOMLEFT
:
490 *r
= screen_desktop_layout
.rows
- 1 -
491 d
/ screen_desktop_layout
.columns
;
492 *c
= d
% screen_desktop_layout
.columns
;
494 case OB_CORNER_TOPRIGHT
:
495 *r
= d
/ screen_desktop_layout
.columns
;
496 *c
= screen_desktop_layout
.columns
- 1 -
497 d
% screen_desktop_layout
.columns
;
499 case OB_CORNER_BOTTOMRIGHT
:
500 *r
= screen_desktop_layout
.rows
- 1 -
501 d
/ screen_desktop_layout
.columns
;
502 *c
= screen_desktop_layout
.columns
- 1 -
503 d
% screen_desktop_layout
.columns
;
507 case OB_ORIENTATION_VERT
:
508 switch (screen_desktop_layout
.start_corner
) {
509 case OB_CORNER_TOPLEFT
:
510 *r
= d
% screen_desktop_layout
.rows
;
511 *c
= d
/ screen_desktop_layout
.rows
;
513 case OB_CORNER_BOTTOMLEFT
:
514 *r
= screen_desktop_layout
.rows
- 1 -
515 d
% screen_desktop_layout
.rows
;
516 *c
= d
/ screen_desktop_layout
.rows
;
518 case OB_CORNER_TOPRIGHT
:
519 *r
= d
% screen_desktop_layout
.rows
;
520 *c
= screen_desktop_layout
.columns
- 1 -
521 d
/ screen_desktop_layout
.rows
;
523 case OB_CORNER_BOTTOMRIGHT
:
524 *r
= screen_desktop_layout
.rows
- 1 -
525 d
% screen_desktop_layout
.rows
;
526 *c
= screen_desktop_layout
.columns
- 1 -
527 d
/ screen_desktop_layout
.rows
;
534 static guint
translate_row_col(guint r
, guint c
)
536 switch (screen_desktop_layout
.orientation
) {
537 case OB_ORIENTATION_HORZ
:
538 switch (screen_desktop_layout
.start_corner
) {
539 case OB_CORNER_TOPLEFT
:
540 return r
% screen_desktop_layout
.rows
*
541 screen_desktop_layout
.columns
+
542 c
% screen_desktop_layout
.columns
;
543 case OB_CORNER_BOTTOMLEFT
:
544 return (screen_desktop_layout
.rows
- 1 -
545 r
% screen_desktop_layout
.rows
) *
546 screen_desktop_layout
.columns
+
547 c
% screen_desktop_layout
.columns
;
548 case OB_CORNER_TOPRIGHT
:
549 return r
% screen_desktop_layout
.rows
*
550 screen_desktop_layout
.columns
+
551 (screen_desktop_layout
.columns
- 1 -
552 c
% screen_desktop_layout
.columns
);
553 case OB_CORNER_BOTTOMRIGHT
:
554 return (screen_desktop_layout
.rows
- 1 -
555 r
% screen_desktop_layout
.rows
) *
556 screen_desktop_layout
.columns
+
557 (screen_desktop_layout
.columns
- 1 -
558 c
% screen_desktop_layout
.columns
);
560 case OB_ORIENTATION_VERT
:
561 switch (screen_desktop_layout
.start_corner
) {
562 case OB_CORNER_TOPLEFT
:
563 return c
% screen_desktop_layout
.columns
*
564 screen_desktop_layout
.rows
+
565 r
% screen_desktop_layout
.rows
;
566 case OB_CORNER_BOTTOMLEFT
:
567 return c
% screen_desktop_layout
.columns
*
568 screen_desktop_layout
.rows
+
569 (screen_desktop_layout
.rows
- 1 -
570 r
% screen_desktop_layout
.rows
);
571 case OB_CORNER_TOPRIGHT
:
572 return (screen_desktop_layout
.columns
- 1 -
573 c
% screen_desktop_layout
.columns
) *
574 screen_desktop_layout
.rows
+
575 r
% screen_desktop_layout
.rows
;
576 case OB_CORNER_BOTTOMRIGHT
:
577 return (screen_desktop_layout
.columns
- 1 -
578 c
% screen_desktop_layout
.columns
) *
579 screen_desktop_layout
.rows
+
580 (screen_desktop_layout
.rows
- 1 -
581 r
% screen_desktop_layout
.rows
);
584 g_assert_not_reached();
588 void screen_desktop_popup(guint d
, gboolean show
)
593 pager_popup_hide(desktop_cycle_popup
);
595 a
= screen_physical_area_monitor(0);
596 pager_popup_position(desktop_cycle_popup
, CenterGravity
,
597 a
->x
+ a
->width
/ 2, a
->y
+ a
->height
/ 2);
598 /* XXX the size and the font extents need to be related on some level
600 pager_popup_size(desktop_cycle_popup
, POPUP_WIDTH
, POPUP_HEIGHT
);
602 pager_popup_set_text_align(desktop_cycle_popup
, RR_JUSTIFY_CENTER
);
604 pager_popup_show(desktop_cycle_popup
, screen_desktop_names
[d
], d
);
608 guint
screen_cycle_desktop(ObDirection dir
, gboolean wrap
, gboolean linear
,
609 gboolean dialog
, gboolean done
, gboolean cancel
)
611 static gboolean first
= TRUE
;
612 static guint origd
, d
;
618 } else if (done
&& dialog
) {
623 d
= origd
= screen_desktop
;
626 get_row_col(d
, &r
, &c
);
630 case OB_DIRECTION_EAST
:
631 if (d
< screen_num_desktops
- 1)
636 case OB_DIRECTION_WEST
:
640 d
= screen_num_desktops
- 1;
644 return screen_desktop
;
648 case OB_DIRECTION_EAST
:
650 if (c
>= screen_desktop_layout
.columns
) {
655 goto show_cycle_dialog
;
658 d
= translate_row_col(r
, c
);
659 if (d
>= screen_num_desktops
) {
664 goto show_cycle_dialog
;
668 case OB_DIRECTION_WEST
:
670 if (c
>= screen_desktop_layout
.columns
) {
672 c
= screen_desktop_layout
.columns
- 1;
675 goto show_cycle_dialog
;
678 d
= translate_row_col(r
, c
);
679 if (d
>= screen_num_desktops
) {
684 goto show_cycle_dialog
;
688 case OB_DIRECTION_SOUTH
:
690 if (r
>= screen_desktop_layout
.rows
) {
695 goto show_cycle_dialog
;
698 d
= translate_row_col(r
, c
);
699 if (d
>= screen_num_desktops
) {
704 goto show_cycle_dialog
;
708 case OB_DIRECTION_NORTH
:
710 if (r
>= screen_desktop_layout
.rows
) {
712 r
= screen_desktop_layout
.rows
- 1;
715 goto show_cycle_dialog
;
718 d
= translate_row_col(r
, c
);
719 if (d
>= screen_num_desktops
) {
724 goto show_cycle_dialog
;
730 return d
= screen_desktop
;
733 d
= translate_row_col(r
, c
);
738 screen_desktop_popup(d
, TRUE
);
745 screen_desktop_popup(0, FALSE
);
750 void screen_update_layout()
752 ObOrientation orient
;
758 gboolean valid
= FALSE
;
760 if (PROP_GETA32(RootWindow(ob_display
, ob_screen
),
761 net_desktop_layout
, cardinal
, &data
, &num
)) {
762 if (num
== 3 || num
== 4) {
764 if (data
[0] == prop_atoms
.net_wm_orientation_vert
)
765 orient
= OB_ORIENTATION_VERT
;
766 else if (data
[0] == prop_atoms
.net_wm_orientation_horz
)
767 orient
= OB_ORIENTATION_HORZ
;
769 goto screen_update_layout_bail
;
772 corner
= OB_CORNER_TOPLEFT
;
774 if (data
[3] == prop_atoms
.net_wm_topleft
)
775 corner
= OB_CORNER_TOPLEFT
;
776 else if (data
[3] == prop_atoms
.net_wm_topright
)
777 corner
= OB_CORNER_TOPRIGHT
;
778 else if (data
[3] == prop_atoms
.net_wm_bottomright
)
779 corner
= OB_CORNER_BOTTOMRIGHT
;
780 else if (data
[3] == prop_atoms
.net_wm_bottomleft
)
781 corner
= OB_CORNER_BOTTOMLEFT
;
783 goto screen_update_layout_bail
;
789 /* fill in a zero rows/columns */
790 if ((cols
== 0 && rows
== 0)) { /* both 0's is bad data.. */
791 goto screen_update_layout_bail
;
794 cols
= screen_num_desktops
/ rows
;
795 if (rows
* cols
< screen_num_desktops
)
797 if (rows
* cols
>= screen_num_desktops
+ cols
)
799 } else if (rows
== 0) {
800 rows
= screen_num_desktops
/ cols
;
801 if (cols
* rows
< screen_num_desktops
)
803 if (cols
* rows
>= screen_num_desktops
+ rows
)
808 /* bounds checking */
809 if (orient
== OB_ORIENTATION_HORZ
) {
810 cols
= MIN(screen_num_desktops
, cols
);
811 rows
= MIN(rows
, (screen_num_desktops
+ cols
- 1) / cols
);
812 cols
= screen_num_desktops
/ rows
+
813 !!(screen_num_desktops
% rows
);
815 rows
= MIN(screen_num_desktops
, rows
);
816 cols
= MIN(cols
, (screen_num_desktops
+ rows
- 1) / rows
);
817 rows
= screen_num_desktops
/ cols
+
818 !!(screen_num_desktops
% cols
);
823 screen_update_layout_bail
:
829 orient
= OB_ORIENTATION_HORZ
;
830 corner
= OB_CORNER_TOPLEFT
;
832 cols
= screen_num_desktops
;
835 screen_desktop_layout
.orientation
= orient
;
836 screen_desktop_layout
.start_corner
= corner
;
837 screen_desktop_layout
.rows
= rows
;
838 screen_desktop_layout
.columns
= cols
;
841 void screen_update_desktop_names()
845 /* empty the array */
846 g_strfreev(screen_desktop_names
);
847 screen_desktop_names
= NULL
;
849 if (PROP_GETSS(RootWindow(ob_display
, ob_screen
),
850 net_desktop_names
, utf8
, &screen_desktop_names
))
851 for (i
= 0; screen_desktop_names
[i
] && i
<= screen_num_desktops
; ++i
);
854 if (i
<= screen_num_desktops
) {
855 screen_desktop_names
= g_renew(gchar
*, screen_desktop_names
,
856 screen_num_desktops
+ 1);
857 screen_desktop_names
[screen_num_desktops
] = NULL
;
858 for (; i
< screen_num_desktops
; ++i
)
859 screen_desktop_names
[i
] = g_strdup_printf("Desktop %i", i
+ 1);
863 void screen_show_desktop(gboolean show
)
867 if (show
== screen_showing_desktop
) return; /* no change */
869 screen_showing_desktop
= show
;
873 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
874 if (WINDOW_IS_CLIENT(it
->data
)) {
875 ObClient
*client
= it
->data
;
876 client_showhide(client
);
881 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
882 if (WINDOW_IS_CLIENT(it
->data
)) {
883 ObClient
*client
= it
->data
;
884 client_showhide(client
);
891 for (it
= focus_order
; it
; it
= g_list_next(it
)) {
892 ObClient
*c
= it
->data
;
893 if (c
->type
== OB_CLIENT_TYPE_DESKTOP
&&
894 (c
->desktop
== screen_desktop
|| c
->desktop
== DESKTOP_ALL
) &&
895 client_focus(it
->data
))
901 /* use NULL for the "old" argument because the desktop was focused
902 and we don't want to fallback to the desktop by default */
903 if ((c
= focus_fallback_target(TRUE
, NULL
)))
907 show
= !!show
; /* make it boolean */
908 PROP_SET32(RootWindow(ob_display
, ob_screen
),
909 net_showing_desktop
, cardinal
, show
);
912 void screen_install_colormap(ObClient
*client
, gboolean install
)
914 if (client
== NULL
) {
916 XInstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
918 XUninstallColormap(RrDisplay(ob_rr_inst
), RrColormap(ob_rr_inst
));
920 xerror_set_ignore(TRUE
);
922 if (client
->colormap
!= None
)
923 XInstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
925 XUninstallColormap(RrDisplay(ob_rr_inst
), client
->colormap
);
926 xerror_set_ignore(FALSE
);
931 screen_area_add_strut_left(const StrutPartial
*s
, const Rect
*monitor_area
,
932 gint edge
, Strut
*ret
)
935 ((s
->left_end
<= s
->left_start
) ||
936 (RECT_TOP(*monitor_area
) < s
->left_end
&&
937 RECT_BOTTOM(*monitor_area
) > s
->left_start
)))
938 ret
->left
= MAX(ret
->left
, edge
);
942 screen_area_add_strut_top(const StrutPartial
*s
, const Rect
*monitor_area
,
943 gint edge
, Strut
*ret
)
946 ((s
->top_end
<= s
->top_start
) ||
947 (RECT_LEFT(*monitor_area
) < s
->top_end
&&
948 RECT_RIGHT(*monitor_area
) > s
->top_start
)))
949 ret
->top
= MAX(ret
->top
, edge
);
953 screen_area_add_strut_right(const StrutPartial
*s
, const Rect
*monitor_area
,
954 gint edge
, Strut
*ret
)
957 ((s
->right_end
<= s
->right_start
) ||
958 (RECT_TOP(*monitor_area
) < s
->right_end
&&
959 RECT_BOTTOM(*monitor_area
) > s
->right_start
)))
960 ret
->right
= MAX(ret
->right
, edge
);
964 screen_area_add_strut_bottom(const StrutPartial
*s
, const Rect
*monitor_area
,
965 gint edge
, Strut
*ret
)
968 ((s
->bottom_end
<= s
->bottom_start
) ||
969 (RECT_LEFT(*monitor_area
) < s
->bottom_end
&&
970 RECT_RIGHT(*monitor_area
) > s
->bottom_start
)))
971 ret
->bottom
= MAX(ret
->bottom
, edge
);
974 void screen_update_areas()
981 g_free(monitor_area
);
982 extensions_xinerama_screens(&monitor_area
, &screen_num_monitors
);
985 for (i
= 0; area
[i
]; ++i
)
990 area
= g_new(Rect
*, screen_num_desktops
+ 2);
991 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
)
992 area
[i
] = g_new0(Rect
, screen_num_monitors
+ 1);
995 dims
= g_new(gulong
, 4 * screen_num_desktops
);
997 for (i
= 0; i
< screen_num_desktops
+ 1; ++i
) {
1001 struts
= g_new0(Strut
, screen_num_monitors
);
1003 /* calc the xinerama areas */
1004 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1005 area
[i
][x
] = monitor_area
[x
];
1007 l
= monitor_area
[x
].x
;
1008 t
= monitor_area
[x
].y
;
1009 r
= monitor_area
[x
].x
+ monitor_area
[x
].width
- 1;
1010 b
= monitor_area
[x
].y
+ monitor_area
[x
].height
- 1;
1012 l
= MIN(l
, monitor_area
[x
].x
);
1013 t
= MIN(t
, monitor_area
[x
].y
);
1014 r
= MAX(r
, monitor_area
[x
].x
+ monitor_area
[x
].width
- 1);
1015 b
= MAX(b
, monitor_area
[x
].y
+ monitor_area
[x
].height
- 1);
1018 RECT_SET(area
[i
][x
], l
, t
, r
- l
+ 1, b
- t
+ 1);
1020 /* apply the struts */
1022 /* find the left-most xin heads, i do this in 2 loops :| */
1024 for (x
= 1; x
< screen_num_monitors
; ++x
)
1025 o
= MIN(o
, area
[i
][x
].x
);
1027 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1028 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1029 ObClient
*c
= it
->data
;
1030 screen_area_add_strut_left(&c
->strut
,
1032 o
+ c
->strut
.left
- area
[i
][x
].x
,
1035 screen_area_add_strut_left(&dock_strut
,
1037 o
+ dock_strut
.left
- area
[i
][x
].x
,
1040 area
[i
][x
].x
+= struts
[x
].left
;
1041 area
[i
][x
].width
-= struts
[x
].left
;
1044 /* find the top-most xin heads, i do this in 2 loops :| */
1046 for (x
= 1; x
< screen_num_monitors
; ++x
)
1047 o
= MIN(o
, area
[i
][x
].y
);
1049 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1050 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1051 ObClient
*c
= it
->data
;
1052 screen_area_add_strut_top(&c
->strut
,
1054 o
+ c
->strut
.top
- area
[i
][x
].y
,
1057 screen_area_add_strut_top(&dock_strut
,
1059 o
+ dock_strut
.top
- area
[i
][x
].y
,
1062 area
[i
][x
].y
+= struts
[x
].top
;
1063 area
[i
][x
].height
-= struts
[x
].top
;
1066 /* find the right-most xin heads, i do this in 2 loops :| */
1067 o
= area
[i
][0].x
+ area
[i
][0].width
- 1;
1068 for (x
= 1; x
< screen_num_monitors
; ++x
)
1069 o
= MAX(o
, area
[i
][x
].x
+ area
[i
][x
].width
- 1);
1071 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1072 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1073 ObClient
*c
= it
->data
;
1074 screen_area_add_strut_right(&c
->strut
,
1077 area
[i
][x
].width
- 1) -
1078 (o
- c
->strut
.right
),
1081 screen_area_add_strut_right(&dock_strut
,
1084 area
[i
][x
].width
- 1) -
1085 (o
- dock_strut
.right
),
1088 area
[i
][x
].width
-= struts
[x
].right
;
1091 /* find the bottom-most xin heads, i do this in 2 loops :| */
1092 o
= area
[i
][0].y
+ area
[i
][0].height
- 1;
1093 for (x
= 1; x
< screen_num_monitors
; ++x
)
1094 o
= MAX(o
, area
[i
][x
].y
+ area
[i
][x
].height
- 1);
1096 for (x
= 0; x
< screen_num_monitors
; ++x
) {
1097 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1098 ObClient
*c
= it
->data
;
1099 screen_area_add_strut_bottom(&c
->strut
,
1102 area
[i
][x
].height
- 1) - \
1103 (o
- c
->strut
.bottom
),
1106 screen_area_add_strut_bottom(&dock_strut
,
1109 area
[i
][x
].height
- 1) - \
1110 (o
- dock_strut
.bottom
),
1113 area
[i
][x
].height
-= struts
[x
].bottom
;
1116 l
= RECT_LEFT(area
[i
][0]);
1117 t
= RECT_TOP(area
[i
][0]);
1118 r
= RECT_RIGHT(area
[i
][0]);
1119 b
= RECT_BOTTOM(area
[i
][0]);
1120 for (x
= 1; x
< screen_num_monitors
; ++x
) {
1121 l
= MIN(l
, RECT_LEFT(area
[i
][x
]));
1122 t
= MIN(l
, RECT_TOP(area
[i
][x
]));
1123 r
= MAX(r
, RECT_RIGHT(area
[i
][x
]));
1124 b
= MAX(b
, RECT_BOTTOM(area
[i
][x
]));
1126 RECT_SET(area
[i
][screen_num_monitors
], l
, t
,
1127 r
- l
+ 1, b
- t
+ 1);
1129 /* XXX optimize when this is run? */
1131 /* the area has changed, adjust all the maximized
1133 for (it
= client_list
; it
; it
= g_list_next(it
)) {
1134 ObClient
*c
= it
->data
;
1135 if (i
< screen_num_desktops
) {
1136 if (c
->desktop
== i
)
1137 client_reconfigure(c
);
1138 } else if (c
->desktop
== DESKTOP_ALL
)
1139 client_reconfigure(c
);
1141 if (i
< screen_num_desktops
) {
1142 /* don't set these for the 'all desktops' area */
1143 dims
[(i
* 4) + 0] = area
[i
][screen_num_monitors
].x
;
1144 dims
[(i
* 4) + 1] = area
[i
][screen_num_monitors
].y
;
1145 dims
[(i
* 4) + 2] = area
[i
][screen_num_monitors
].width
;
1146 dims
[(i
* 4) + 3] = area
[i
][screen_num_monitors
].height
;
1152 PROP_SETA32(RootWindow(ob_display
, ob_screen
), net_workarea
, cardinal
,
1153 dims
, 4 * screen_num_desktops
);
1158 Rect
*screen_area(guint desktop
)
1160 return screen_area_monitor(desktop
, screen_num_monitors
);
1163 Rect
*screen_area_monitor(guint desktop
, guint head
)
1165 if (head
> screen_num_monitors
)
1167 if (desktop
>= screen_num_desktops
) {
1168 if (desktop
== DESKTOP_ALL
)
1169 return &area
[screen_num_desktops
][head
];
1172 return &area
[desktop
][head
];
1175 guint
screen_find_monitor(Rect
*search
)
1181 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1182 Rect
*area
= screen_physical_area_monitor(i
);
1183 if (RECT_INTERSECTS_RECT(*area
, *search
)) {
1187 RECT_SET_INTERSECTION(r
, *area
, *search
);
1188 v
= r
.width
* r
.height
;
1199 Rect
*screen_physical_area()
1201 return screen_physical_area_monitor(screen_num_monitors
);
1204 Rect
*screen_physical_area_monitor(guint head
)
1206 if (head
> screen_num_monitors
)
1208 return &monitor_area
[head
];
1211 void screen_set_root_cursor()
1213 if (sn_app_starting())
1214 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1215 ob_cursor(OB_CURSOR_BUSY
));
1217 XDefineCursor(ob_display
, RootWindow(ob_display
, ob_screen
),
1218 ob_cursor(OB_CURSOR_POINTER
));
1221 gboolean
screen_pointer_pos(gint
*x
, gint
*y
)
1227 return !!XQueryPointer(ob_display
, RootWindow(ob_display
, ob_screen
),
1228 &w
, &w
, x
, y
, &i
, &i
, &u
);