1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 screen.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
26 #include "startupnotify.h"
27 #include "moveresize.h"
36 #include "extensions.h"
37 #include "render/render.h"
42 # include <sys/types.h>
47 /*! The event mask to grab on the root window */
48 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
49 EnterWindowMask | LeaveWindowMask | \
50 SubstructureRedirectMask | FocusChangeMask | \
51 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
53 static gboolean screen_validate_layout(ObDesktopLayout *l);
54 static gboolean replace_wm();
56 guint screen_num_desktops;
57 guint screen_num_monitors;
59 guint screen_last_desktop;
60 Size screen_physical_size;
61 gboolean screen_showing_desktop;
62 ObDesktopLayout screen_desktop_layout;
63 gchar **screen_desktop_names;
64 Window screen_support_win;
65 Time screen_desktop_user_time = CurrentTime;
67 static Rect **area; /* array of desktop holding array of xinerama areas */
68 static Rect *monitor_area;
70 static ObPagerPopup *desktop_cycle_popup;
72 static gboolean replace_wm()
76 Window current_wm_sn_owner;
79 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
80 wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
83 current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
84 if (current_wm_sn_owner == screen_support_win)
85 current_wm_sn_owner = None;
86 if (current_wm_sn_owner) {
88 g_message(_("A window manager is already running on screen %d"),
92 xerror_set_ignore(TRUE);
93 xerror_occured = FALSE;
95 /* We want to find out when the current selection owner dies */
96 XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
97 XSync(ob_display, FALSE);
99 xerror_set_ignore(FALSE);
101 current_wm_sn_owner = None;
105 /* Generate a timestamp */
108 XSelectInput(ob_display, screen_support_win, PropertyChangeMask);
110 XChangeProperty(ob_display, screen_support_win,
111 prop_atoms.wm_class, prop_atoms.string,
112 8, PropModeAppend, NULL, 0);
113 XWindowEvent(ob_display, screen_support_win,
114 PropertyChangeMask, &event);
116 XSelectInput(ob_display, screen_support_win, NoEventMask);
118 timestamp = event.xproperty.time;
121 XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
124 if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
125 g_message(_("Could not acquire window manager selection on screen %d"),
130 /* Wait for old window manager to go away */
131 if (current_wm_sn_owner) {
134 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
136 while (wait < timeout) {
137 if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
138 StructureNotifyMask, &event) &&
139 event.type == DestroyNotify)
141 g_usleep(G_USEC_PER_SEC / 10);
142 wait += G_USEC_PER_SEC / 10;
145 if (wait >= timeout) {
146 g_message(_("The WM on screen %d is not exiting"), ob_screen);
151 /* Send client message indicating that we are now the WM */
152 prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
153 timestamp, wm_sn_atom, screen_support_win, 0,
154 SubstructureNotifyMask);
159 gboolean screen_annex()
161 XSetWindowAttributes attrib;
164 Atom *prop_atoms_start, *wm_supported_pos;
167 /* create the netwm support window */
168 attrib.override_redirect = TRUE;
169 screen_support_win = XCreateWindow(ob_display,
170 RootWindow(ob_display, ob_screen),
172 CopyFromParent, InputOutput,
174 CWOverrideRedirect, &attrib);
175 XMapWindow(ob_display, screen_support_win);
176 XLowerWindow(ob_display, screen_support_win);
179 XDestroyWindow(ob_display, screen_support_win);
183 xerror_set_ignore(TRUE);
184 xerror_occured = FALSE;
185 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
187 xerror_set_ignore(FALSE);
188 if (xerror_occured) {
189 g_message(_("A window manager is already running on screen %d"),
192 XDestroyWindow(ob_display, screen_support_win);
196 screen_set_root_cursor();
198 /* set the OPENBOX_PID hint */
200 PROP_SET32(RootWindow(ob_display, ob_screen),
201 openbox_pid, cardinal, pid);
203 /* set supporting window */
204 PROP_SET32(RootWindow(ob_display, ob_screen),
205 net_supporting_wm_check, window, screen_support_win);
207 /* set properties on the supporting window */
208 PROP_SETS(screen_support_win, net_wm_name, "Openbox");
209 PROP_SET32(screen_support_win, net_supporting_wm_check,
210 window, screen_support_win);
212 /* set the _NET_SUPPORTED_ATOMS hint */
214 /* this is all the atoms after net_supported in the prop_atoms struct */
215 prop_atoms_start = (Atom*)&prop_atoms;
216 wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
217 num_support = sizeof(prop_atoms) / sizeof(Atom) -
218 (wm_supported_pos - prop_atoms_start) - 1;
220 supported = g_new(gulong, num_support);
221 supported[i++] = prop_atoms.net_supporting_wm_check;
222 supported[i++] = prop_atoms.net_wm_full_placement;
223 supported[i++] = prop_atoms.net_current_desktop;
224 supported[i++] = prop_atoms.net_number_of_desktops;
225 supported[i++] = prop_atoms.net_desktop_geometry;
226 supported[i++] = prop_atoms.net_desktop_viewport;
227 supported[i++] = prop_atoms.net_active_window;
228 supported[i++] = prop_atoms.net_workarea;
229 supported[i++] = prop_atoms.net_client_list;
230 supported[i++] = prop_atoms.net_client_list_stacking;
231 supported[i++] = prop_atoms.net_desktop_names;
232 supported[i++] = prop_atoms.net_close_window;
233 supported[i++] = prop_atoms.net_desktop_layout;
234 supported[i++] = prop_atoms.net_showing_desktop;
235 supported[i++] = prop_atoms.net_wm_name;
236 supported[i++] = prop_atoms.net_wm_visible_name;
237 supported[i++] = prop_atoms.net_wm_icon_name;
238 supported[i++] = prop_atoms.net_wm_visible_icon_name;
239 supported[i++] = prop_atoms.net_wm_desktop;
240 supported[i++] = prop_atoms.net_wm_strut;
241 supported[i++] = prop_atoms.net_wm_strut_partial;
242 supported[i++] = prop_atoms.net_wm_icon;
243 supported[i++] = prop_atoms.net_wm_icon_geometry;
244 supported[i++] = prop_atoms.net_wm_window_type;
245 supported[i++] = prop_atoms.net_wm_window_type_desktop;
246 supported[i++] = prop_atoms.net_wm_window_type_dock;
247 supported[i++] = prop_atoms.net_wm_window_type_toolbar;
248 supported[i++] = prop_atoms.net_wm_window_type_menu;
249 supported[i++] = prop_atoms.net_wm_window_type_utility;
250 supported[i++] = prop_atoms.net_wm_window_type_splash;
251 supported[i++] = prop_atoms.net_wm_window_type_dialog;
252 supported[i++] = prop_atoms.net_wm_window_type_normal;
253 supported[i++] = prop_atoms.net_wm_allowed_actions;
254 supported[i++] = prop_atoms.net_wm_action_move;
255 supported[i++] = prop_atoms.net_wm_action_resize;
256 supported[i++] = prop_atoms.net_wm_action_minimize;
257 supported[i++] = prop_atoms.net_wm_action_shade;
258 supported[i++] = prop_atoms.net_wm_action_maximize_horz;
259 supported[i++] = prop_atoms.net_wm_action_maximize_vert;
260 supported[i++] = prop_atoms.net_wm_action_fullscreen;
261 supported[i++] = prop_atoms.net_wm_action_change_desktop;
262 supported[i++] = prop_atoms.net_wm_action_close;
263 supported[i++] = prop_atoms.net_wm_action_above;
264 supported[i++] = prop_atoms.net_wm_action_below;
265 supported[i++] = prop_atoms.net_wm_state;
266 supported[i++] = prop_atoms.net_wm_state_modal;
267 supported[i++] = prop_atoms.net_wm_state_maximized_vert;
268 supported[i++] = prop_atoms.net_wm_state_maximized_horz;
269 supported[i++] = prop_atoms.net_wm_state_shaded;
270 supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
271 supported[i++] = prop_atoms.net_wm_state_skip_pager;
272 supported[i++] = prop_atoms.net_wm_state_hidden;
273 supported[i++] = prop_atoms.net_wm_state_fullscreen;
274 supported[i++] = prop_atoms.net_wm_state_above;
275 supported[i++] = prop_atoms.net_wm_state_below;
276 supported[i++] = prop_atoms.net_wm_state_demands_attention;
277 supported[i++] = prop_atoms.net_moveresize_window;
278 supported[i++] = prop_atoms.net_wm_moveresize;
279 supported[i++] = prop_atoms.net_wm_user_time;
280 supported[i++] = prop_atoms.net_wm_user_time_window;
281 supported[i++] = prop_atoms.net_frame_extents;
282 supported[i++] = prop_atoms.net_request_frame_extents;
283 supported[i++] = prop_atoms.net_restack_window;
284 supported[i++] = prop_atoms.net_startup_id;
286 supported[i++] = prop_atoms.net_wm_sync_request;
287 supported[i++] = prop_atoms.net_wm_sync_request_counter;
290 supported[i++] = prop_atoms.kde_wm_change_state;
291 supported[i++] = prop_atoms.kde_net_wm_frame_strut;
292 supported[i++] = prop_atoms.kde_net_wm_window_type_override;
294 supported[i++] = prop_atoms.ob_wm_action_undecorate;
295 supported[i++] = prop_atoms.ob_wm_state_undecorated;
296 supported[i++] = prop_atoms.openbox_pid;
297 supported[i++] = prop_atoms.ob_control;
298 g_assert(i == num_support);
300 PROP_SETA32(RootWindow(ob_display, ob_screen),
301 net_supported, atom, supported, num_support);
307 void screen_startup(gboolean reconfig)
309 gchar **names = NULL;
311 gboolean namesexist = FALSE;
313 desktop_cycle_popup = pager_popup_new(FALSE);
314 pager_popup_height(desktop_cycle_popup, POPUP_HEIGHT);
317 /* update the pager popup's width */
318 pager_popup_text_width_to_strings(desktop_cycle_popup,
319 screen_desktop_names,
320 screen_num_desktops);
324 /* get the initial size */
327 /* have names already been set for the desktops? */
328 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
329 net_desktop_names, utf8, &names))
335 /* if names don't exist and we have session names, set those.
336 do this stuff BEFORE setting the number of desktops, because that
337 will create default names for them
339 if (!namesexist && session_desktop_names != NULL) {
343 /* get the desktop names */
344 numnames = g_slist_length(session_desktop_names);
345 names = g_new(gchar*, numnames + 1);
346 names[numnames] = NULL;
347 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
348 names[i] = g_strdup(it->data);
350 /* set the root window property */
351 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
356 /* set the number of desktops, if it's not already set.
358 this will also set the default names from the config file up for
359 desktops that don't have names yet */
360 screen_num_desktops = 0;
361 if (PROP_GET32(RootWindow(ob_display, ob_screen),
362 net_number_of_desktops, cardinal, &d))
363 screen_set_num_desktops(d);
364 /* restore from session if possible */
365 else if (session_num_desktops)
366 screen_set_num_desktops(session_num_desktops);
368 screen_set_num_desktops(config_desktops_num);
370 screen_desktop = screen_num_desktops; /* something invalid */
371 /* start on the current desktop when a wm was already running */
372 if (PROP_GET32(RootWindow(ob_display, ob_screen),
373 net_current_desktop, cardinal, &d) &&
374 d < screen_num_desktops)
376 screen_set_desktop(d, FALSE);
377 } else if (session_desktop >= 0)
378 screen_set_desktop(MIN((guint)session_desktop,
379 screen_num_desktops), FALSE);
381 screen_set_desktop(MIN(config_screen_firstdesk,
382 screen_num_desktops) - 1, FALSE);
383 screen_last_desktop = screen_desktop;
385 /* don't start in showing-desktop mode */
386 screen_showing_desktop = FALSE;
387 PROP_SET32(RootWindow(ob_display, ob_screen),
388 net_showing_desktop, cardinal, screen_showing_desktop);
390 if (session_desktop_layout_present &&
391 screen_validate_layout(&session_desktop_layout))
393 screen_desktop_layout = session_desktop_layout;
396 screen_update_layout();
399 void screen_shutdown(gboolean reconfig)
403 pager_popup_free(desktop_cycle_popup);
408 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
411 /* we're not running here no more! */
412 PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
414 PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
415 /* don't keep this mode */
416 PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
418 XDestroyWindow(ob_display, screen_support_win);
420 g_strfreev(screen_desktop_names);
421 screen_desktop_names = NULL;
423 for (r = area; *r; ++r)
431 static gint oldw = 0, oldh = 0;
436 w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
437 h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
439 if (w == oldw && h == oldh) return;
443 /* Set the _NET_DESKTOP_GEOMETRY hint */
444 screen_physical_size.width = geometry[0] = w;
445 screen_physical_size.height = geometry[1] = h;
446 PROP_SETA32(RootWindow(ob_display, ob_screen),
447 net_desktop_geometry, cardinal, geometry, 2);
449 if (ob_state() == OB_STATE_STARTING)
452 screen_update_areas();
455 for (it = client_list; it; it = g_list_next(it))
456 client_move_onscreen(it->data, FALSE);
459 void screen_set_num_desktops(guint num)
467 if (screen_num_desktops == num) return;
469 old = screen_num_desktops;
470 screen_num_desktops = num;
471 PROP_SET32(RootWindow(ob_display, ob_screen),
472 net_number_of_desktops, cardinal, num);
474 /* set the viewport hint */
475 viewport = g_new0(gulong, num * 2);
476 PROP_SETA32(RootWindow(ob_display, ob_screen),
477 net_desktop_viewport, cardinal, viewport, num * 2);
480 /* the number of rows/columns will differ */
481 screen_update_layout();
483 /* move windows on desktops that will no longer exist! */
484 for (it = client_list; it; it = g_list_next(it)) {
485 ObClient *c = it->data;
486 if (c->desktop >= num && c->desktop != DESKTOP_ALL)
487 client_set_desktop(c, num - 1, FALSE);
490 /* change our struts/area to match (after moving windows) */
491 screen_update_areas();
493 /* may be some unnamed desktops that we need to fill in with names
494 (after updating the areas so the popup can resize) */
495 screen_update_desktop_names();
497 /* change our desktop if we're on one that no longer exists! */
498 if (screen_desktop >= screen_num_desktops)
499 screen_set_desktop(num - 1, TRUE);
502 void screen_set_desktop(guint num, gboolean dofocus)
508 g_assert(num < screen_num_desktops);
510 old = screen_desktop;
511 screen_desktop = num;
513 if (old == num) return;
515 PROP_SET32(RootWindow(ob_display, ob_screen),
516 net_current_desktop, cardinal, num);
518 screen_last_desktop = old;
520 ob_debug("Moving to desktop %d\n", num+1);
522 if (moveresize_client)
523 client_set_desktop(moveresize_client, num, TRUE);
525 /* show windows before hiding the rest to lessen the enter/leave events */
527 /* show windows from top to bottom */
528 for (it = stacking_list; it; it = g_list_next(it)) {
529 if (WINDOW_IS_CLIENT(it->data)) {
530 ObClient *c = it->data;
535 if (focus_client && ((client_normal(focus_client) &&
536 focus_client->desktop == DESKTOP_ALL) ||
537 focus_client->desktop == screen_desktop))
540 /* have to try focus here because when you leave an empty desktop
541 there is no focus out to watch for. also, we have different rules
542 here. we always allow it to look under the mouse pointer if
543 config_focus_last is FALSE
545 do this before hiding the windows so if helper windows are coming
546 with us, they don't get hidden
548 if (dofocus && (c = focus_fallback(TRUE, !config_focus_last)))
550 /* only do the flicker reducing stuff ahead of time if we are going
551 to call xsetinputfocus on the window ourselves. otherwise there is
552 no guarantee the window will actually take focus.. */
554 /* reduce flicker by hiliting now rather than waiting for the
555 server FocusIn event */
556 frame_adjust_focus(c->frame, TRUE);
557 /* do this here so that if you switch desktops to a window with
558 helper windows then the helper windows won't flash */
559 client_bring_helper_windows(c);
563 /* hide windows from bottom to top */
564 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
565 if (WINDOW_IS_CLIENT(it->data)) {
566 ObClient *c = it->data;
571 event_ignore_all_queued_enters();
573 if (event_curtime != CurrentTime)
574 screen_desktop_user_time = event_curtime;
577 static void get_row_col(guint d, guint *r, guint *c)
579 switch (screen_desktop_layout.orientation) {
580 case OB_ORIENTATION_HORZ:
581 switch (screen_desktop_layout.start_corner) {
582 case OB_CORNER_TOPLEFT:
583 *r = d / screen_desktop_layout.columns;
584 *c = d % screen_desktop_layout.columns;
586 case OB_CORNER_BOTTOMLEFT:
587 *r = screen_desktop_layout.rows - 1 -
588 d / screen_desktop_layout.columns;
589 *c = d % screen_desktop_layout.columns;
591 case OB_CORNER_TOPRIGHT:
592 *r = d / screen_desktop_layout.columns;
593 *c = screen_desktop_layout.columns - 1 -
594 d % screen_desktop_layout.columns;
596 case OB_CORNER_BOTTOMRIGHT:
597 *r = screen_desktop_layout.rows - 1 -
598 d / screen_desktop_layout.columns;
599 *c = screen_desktop_layout.columns - 1 -
600 d % screen_desktop_layout.columns;
604 case OB_ORIENTATION_VERT:
605 switch (screen_desktop_layout.start_corner) {
606 case OB_CORNER_TOPLEFT:
607 *r = d % screen_desktop_layout.rows;
608 *c = d / screen_desktop_layout.rows;
610 case OB_CORNER_BOTTOMLEFT:
611 *r = screen_desktop_layout.rows - 1 -
612 d % screen_desktop_layout.rows;
613 *c = d / screen_desktop_layout.rows;
615 case OB_CORNER_TOPRIGHT:
616 *r = d % screen_desktop_layout.rows;
617 *c = screen_desktop_layout.columns - 1 -
618 d / screen_desktop_layout.rows;
620 case OB_CORNER_BOTTOMRIGHT:
621 *r = screen_desktop_layout.rows - 1 -
622 d % screen_desktop_layout.rows;
623 *c = screen_desktop_layout.columns - 1 -
624 d / screen_desktop_layout.rows;
631 static guint translate_row_col(guint r, guint c)
633 switch (screen_desktop_layout.orientation) {
634 case OB_ORIENTATION_HORZ:
635 switch (screen_desktop_layout.start_corner) {
636 case OB_CORNER_TOPLEFT:
637 return r % screen_desktop_layout.rows *
638 screen_desktop_layout.columns +
639 c % screen_desktop_layout.columns;
640 case OB_CORNER_BOTTOMLEFT:
641 return (screen_desktop_layout.rows - 1 -
642 r % screen_desktop_layout.rows) *
643 screen_desktop_layout.columns +
644 c % screen_desktop_layout.columns;
645 case OB_CORNER_TOPRIGHT:
646 return r % screen_desktop_layout.rows *
647 screen_desktop_layout.columns +
648 (screen_desktop_layout.columns - 1 -
649 c % screen_desktop_layout.columns);
650 case OB_CORNER_BOTTOMRIGHT:
651 return (screen_desktop_layout.rows - 1 -
652 r % screen_desktop_layout.rows) *
653 screen_desktop_layout.columns +
654 (screen_desktop_layout.columns - 1 -
655 c % screen_desktop_layout.columns);
657 case OB_ORIENTATION_VERT:
658 switch (screen_desktop_layout.start_corner) {
659 case OB_CORNER_TOPLEFT:
660 return c % screen_desktop_layout.columns *
661 screen_desktop_layout.rows +
662 r % screen_desktop_layout.rows;
663 case OB_CORNER_BOTTOMLEFT:
664 return c % screen_desktop_layout.columns *
665 screen_desktop_layout.rows +
666 (screen_desktop_layout.rows - 1 -
667 r % screen_desktop_layout.rows);
668 case OB_CORNER_TOPRIGHT:
669 return (screen_desktop_layout.columns - 1 -
670 c % screen_desktop_layout.columns) *
671 screen_desktop_layout.rows +
672 r % screen_desktop_layout.rows;
673 case OB_CORNER_BOTTOMRIGHT:
674 return (screen_desktop_layout.columns - 1 -
675 c % screen_desktop_layout.columns) *
676 screen_desktop_layout.rows +
677 (screen_desktop_layout.rows - 1 -
678 r % screen_desktop_layout.rows);
681 g_assert_not_reached();
685 void screen_desktop_popup(guint d, gboolean show)
690 pager_popup_hide(desktop_cycle_popup);
692 a = screen_physical_area_monitor(0);
693 pager_popup_position(desktop_cycle_popup, CenterGravity,
694 a->x + a->width / 2, a->y + a->height / 2);
695 pager_popup_icon_size_multiplier(desktop_cycle_popup,
696 (screen_desktop_layout.columns /
697 screen_desktop_layout.rows) / 2,
698 (screen_desktop_layout.rows/
699 screen_desktop_layout.columns) / 2);
700 pager_popup_max_width(desktop_cycle_popup,
701 MAX(a->width/3, POPUP_WIDTH));
702 pager_popup_show(desktop_cycle_popup, screen_desktop_names[d], d);
706 guint screen_cycle_desktop(ObDirection dir, gboolean wrap, gboolean linear,
707 gboolean dialog, gboolean done, gboolean cancel)
710 static guint d = (guint)-1;
716 if ((cancel || done) && dialog)
717 goto show_cycle_dialog;
720 get_row_col(d, &r, &c);
724 case OB_DIRECTION_EAST:
725 if (d < screen_num_desktops - 1)
730 case OB_DIRECTION_WEST:
734 d = screen_num_desktops - 1;
738 return screen_desktop;
742 case OB_DIRECTION_EAST:
744 if (c >= screen_desktop_layout.columns) {
748 goto show_cycle_dialog;
750 d = translate_row_col(r, c);
751 if (d >= screen_num_desktops) {
756 goto show_cycle_dialog;
760 case OB_DIRECTION_WEST:
762 if (c >= screen_desktop_layout.columns) {
764 c = screen_desktop_layout.columns - 1;
766 goto show_cycle_dialog;
768 d = translate_row_col(r, c);
769 if (d >= screen_num_desktops) {
774 goto show_cycle_dialog;
778 case OB_DIRECTION_SOUTH:
780 if (r >= screen_desktop_layout.rows) {
784 goto show_cycle_dialog;
786 d = translate_row_col(r, c);
787 if (d >= screen_num_desktops) {
792 goto show_cycle_dialog;
796 case OB_DIRECTION_NORTH:
798 if (r >= screen_desktop_layout.rows) {
800 r = screen_desktop_layout.rows - 1;
802 goto show_cycle_dialog;
804 d = translate_row_col(r, c);
805 if (d >= screen_num_desktops) {
810 goto show_cycle_dialog;
816 return d = screen_desktop;
819 d = translate_row_col(r, c);
823 if (dialog && !cancel && !done) {
824 screen_desktop_popup(d, TRUE);
826 screen_desktop_popup(0, FALSE);
829 if (!dialog || cancel || done)
835 static gboolean screen_validate_layout(ObDesktopLayout *l)
837 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
840 /* fill in a zero rows/columns */
841 if (l->columns == 0) {
842 l->columns = screen_num_desktops / l->rows;
843 if (l->rows * l->columns < screen_num_desktops)
845 if (l->rows * l->columns >= screen_num_desktops + l->columns)
847 } else if (l->rows == 0) {
848 l->rows = screen_num_desktops / l->columns;
849 if (l->columns * l->rows < screen_num_desktops)
851 if (l->columns * l->rows >= screen_num_desktops + l->rows)
855 /* bounds checking */
856 if (l->orientation == OB_ORIENTATION_HORZ) {
857 l->columns = MIN(screen_num_desktops, l->columns);
858 l->rows = MIN(l->rows,
859 (screen_num_desktops + l->columns - 1) / l->columns);
860 l->columns = screen_num_desktops / l->rows +
861 !!(screen_num_desktops % l->rows);
863 l->rows = MIN(screen_num_desktops, l->rows);
864 l->columns = MIN(l->columns,
865 (screen_num_desktops + l->rows - 1) / l->rows);
866 l->rows = screen_num_desktops / l->columns +
867 !!(screen_num_desktops % l->columns);
872 void screen_update_layout()
879 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
880 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
881 screen_desktop_layout.rows = 1;
882 screen_desktop_layout.columns = screen_num_desktops;
884 if (PROP_GETA32(RootWindow(ob_display, ob_screen),
885 net_desktop_layout, cardinal, &data, &num)) {
886 if (num == 3 || num == 4) {
888 if (data[0] == prop_atoms.net_wm_orientation_vert)
889 l.orientation = OB_ORIENTATION_VERT;
890 else if (data[0] == prop_atoms.net_wm_orientation_horz)
891 l.orientation = OB_ORIENTATION_HORZ;
896 l.start_corner = OB_CORNER_TOPLEFT;
898 if (data[3] == prop_atoms.net_wm_topleft)
899 l.start_corner = OB_CORNER_TOPLEFT;
900 else if (data[3] == prop_atoms.net_wm_topright)
901 l.start_corner = OB_CORNER_TOPRIGHT;
902 else if (data[3] == prop_atoms.net_wm_bottomright)
903 l.start_corner = OB_CORNER_BOTTOMRIGHT;
904 else if (data[3] == prop_atoms.net_wm_bottomleft)
905 l.start_corner = OB_CORNER_BOTTOMLEFT;
913 if (screen_validate_layout(&l))
914 screen_desktop_layout = l;
921 void screen_update_desktop_names()
925 /* empty the array */
926 g_strfreev(screen_desktop_names);
927 screen_desktop_names = NULL;
929 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
930 net_desktop_names, utf8, &screen_desktop_names))
931 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
934 if (i < screen_num_desktops) {
937 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
938 screen_num_desktops + 1);
939 screen_desktop_names[screen_num_desktops] = NULL;
941 it = g_slist_nth(config_desktops_names, i);
943 for (; i < screen_num_desktops; ++i) {
944 if (it && ((char*)it->data)[0]) /* not empty */
945 /* use the names from the config file when possible */
946 screen_desktop_names[i] = g_strdup(it->data);
948 /* make up a nice name if it's not though */
949 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
951 if (it) it = g_slist_next(it);
954 /* if we changed any names, then set the root property so we can
955 all agree on the names */
956 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
957 screen_desktop_names);
960 /* resize the pager for these names */
961 pager_popup_text_width_to_strings(desktop_cycle_popup,
962 screen_desktop_names,
963 screen_num_desktops);
966 void screen_show_desktop(gboolean show, ObClient *show_only)
970 if (show == screen_showing_desktop) return; /* no change */
972 screen_showing_desktop = show;
975 /* hide windows bottom to top */
976 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
977 if (WINDOW_IS_CLIENT(it->data)) {
978 ObClient *client = it->data;
979 client_showhide(client);
984 /* restore windows top to bottom */
985 for (it = stacking_list; it; it = g_list_next(it)) {
986 if (WINDOW_IS_CLIENT(it->data)) {
987 ObClient *client = it->data;
988 if (client_should_show(client)) {
989 if (!show_only || client == show_only)
992 client_iconify(client, TRUE, FALSE, TRUE);
999 /* focus the desktop */
1000 for (it = focus_order; it; it = g_list_next(it)) {
1001 ObClient *c = it->data;
1002 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1003 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1004 client_focus(it->data))
1008 else if (!show_only) {
1011 if ((c = focus_fallback(TRUE, FALSE))) {
1012 /* only do the flicker reducing stuff ahead of time if we are going
1013 to call xsetinputfocus on the window ourselves. otherwise there
1014 is no guarantee the window will actually take focus.. */
1016 /* reduce flicker by hiliting now rather than waiting for the
1017 server FocusIn event */
1018 frame_adjust_focus(c->frame, TRUE);
1023 show = !!show; /* make it boolean */
1024 PROP_SET32(RootWindow(ob_display, ob_screen),
1025 net_showing_desktop, cardinal, show);
1028 void screen_install_colormap(ObClient *client, gboolean install)
1030 if (client == NULL || client->colormap == None) {
1032 XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1034 XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1036 xerror_set_ignore(TRUE);
1038 XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1040 XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1041 xerror_set_ignore(FALSE);
1046 screen_area_add_strut_left(const StrutPartial *s, const Rect *monitor_area,
1047 gint edge, Strut *ret)
1050 ((s->left_end <= s->left_start) ||
1051 (RECT_TOP(*monitor_area) < s->left_end &&
1052 RECT_BOTTOM(*monitor_area) > s->left_start)))
1053 ret->left = MAX(ret->left, edge);
1057 screen_area_add_strut_top(const StrutPartial *s, const Rect *monitor_area,
1058 gint edge, Strut *ret)
1061 ((s->top_end <= s->top_start) ||
1062 (RECT_LEFT(*monitor_area) < s->top_end &&
1063 RECT_RIGHT(*monitor_area) > s->top_start)))
1064 ret->top = MAX(ret->top, edge);
1068 screen_area_add_strut_right(const StrutPartial *s, const Rect *monitor_area,
1069 gint edge, Strut *ret)
1072 ((s->right_end <= s->right_start) ||
1073 (RECT_TOP(*monitor_area) < s->right_end &&
1074 RECT_BOTTOM(*monitor_area) > s->right_start)))
1075 ret->right = MAX(ret->right, edge);
1079 screen_area_add_strut_bottom(const StrutPartial *s, const Rect *monitor_area,
1080 gint edge, Strut *ret)
1083 ((s->bottom_end <= s->bottom_start) ||
1084 (RECT_LEFT(*monitor_area) < s->bottom_end &&
1085 RECT_RIGHT(*monitor_area) > s->bottom_start)))
1086 ret->bottom = MAX(ret->bottom, edge);
1089 void screen_update_areas()
1096 g_free(monitor_area);
1097 extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
1100 for (i = 0; area[i]; ++i)
1105 area = g_new(Rect*, screen_num_desktops + 2);
1106 for (i = 0; i < screen_num_desktops + 1; ++i)
1107 area[i] = g_new0(Rect, screen_num_monitors + 1);
1110 dims = g_new(gulong, 4 * screen_num_desktops);
1112 for (i = 0; i < screen_num_desktops + 1; ++i) {
1116 struts = g_new0(Strut, screen_num_monitors);
1118 /* calc the xinerama areas */
1119 for (x = 0; x < screen_num_monitors; ++x) {
1120 area[i][x] = monitor_area[x];
1122 l = monitor_area[x].x;
1123 t = monitor_area[x].y;
1124 r = monitor_area[x].x + monitor_area[x].width - 1;
1125 b = monitor_area[x].y + monitor_area[x].height - 1;
1127 l = MIN(l, monitor_area[x].x);
1128 t = MIN(t, monitor_area[x].y);
1129 r = MAX(r, monitor_area[x].x + monitor_area[x].width - 1);
1130 b = MAX(b, monitor_area[x].y + monitor_area[x].height - 1);
1133 RECT_SET(area[i][x], l, t, r - l + 1, b - t + 1);
1135 /* apply the struts */
1137 /* find the left-most xin heads, i do this in 2 loops :| */
1139 for (x = 1; x < screen_num_monitors; ++x)
1140 o = MIN(o, area[i][x].x);
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_left(&c->strut,
1147 o + c->strut.left - area[i][x].x,
1150 screen_area_add_strut_left(&dock_strut,
1152 o + dock_strut.left - area[i][x].x,
1155 area[i][x].x += struts[x].left;
1156 area[i][x].width -= struts[x].left;
1159 /* find the top-most xin heads, i do this in 2 loops :| */
1161 for (x = 1; x < screen_num_monitors; ++x)
1162 o = MIN(o, area[i][x].y);
1164 for (x = 0; x < screen_num_monitors; ++x) {
1165 for (it = client_list; it; it = g_list_next(it)) {
1166 ObClient *c = it->data;
1167 screen_area_add_strut_top(&c->strut,
1169 o + c->strut.top - area[i][x].y,
1172 screen_area_add_strut_top(&dock_strut,
1174 o + dock_strut.top - area[i][x].y,
1177 area[i][x].y += struts[x].top;
1178 area[i][x].height -= struts[x].top;
1181 /* find the right-most xin heads, i do this in 2 loops :| */
1182 o = area[i][0].x + area[i][0].width - 1;
1183 for (x = 1; x < screen_num_monitors; ++x)
1184 o = MAX(o, area[i][x].x + area[i][x].width - 1);
1186 for (x = 0; x < screen_num_monitors; ++x) {
1187 for (it = client_list; it; it = g_list_next(it)) {
1188 ObClient *c = it->data;
1189 screen_area_add_strut_right(&c->strut,
1192 area[i][x].width - 1) -
1193 (o - c->strut.right),
1196 screen_area_add_strut_right(&dock_strut,
1199 area[i][x].width - 1) -
1200 (o - dock_strut.right),
1203 area[i][x].width -= struts[x].right;
1206 /* find the bottom-most xin heads, i do this in 2 loops :| */
1207 o = area[i][0].y + area[i][0].height - 1;
1208 for (x = 1; x < screen_num_monitors; ++x)
1209 o = MAX(o, area[i][x].y + area[i][x].height - 1);
1211 for (x = 0; x < screen_num_monitors; ++x) {
1212 for (it = client_list; it; it = g_list_next(it)) {
1213 ObClient *c = it->data;
1214 screen_area_add_strut_bottom(&c->strut,
1217 area[i][x].height - 1) - \
1218 (o - c->strut.bottom),
1221 screen_area_add_strut_bottom(&dock_strut,
1224 area[i][x].height - 1) - \
1225 (o - dock_strut.bottom),
1228 area[i][x].height -= struts[x].bottom;
1231 l = RECT_LEFT(area[i][0]);
1232 t = RECT_TOP(area[i][0]);
1233 r = RECT_RIGHT(area[i][0]);
1234 b = RECT_BOTTOM(area[i][0]);
1235 for (x = 1; x < screen_num_monitors; ++x) {
1236 l = MIN(l, RECT_LEFT(area[i][x]));
1237 t = MIN(l, RECT_TOP(area[i][x]));
1238 r = MAX(r, RECT_RIGHT(area[i][x]));
1239 b = MAX(b, RECT_BOTTOM(area[i][x]));
1241 RECT_SET(area[i][screen_num_monitors], l, t,
1242 r - l + 1, b - t + 1);
1244 /* XXX optimize when this is run? */
1246 /* the area has changed, adjust all the maximized
1248 for (it = client_list; it; it = g_list_next(it)) {
1249 ObClient *c = it->data;
1250 if (i < screen_num_desktops) {
1251 if (c->desktop == i)
1252 client_reconfigure(c);
1253 } else if (c->desktop == DESKTOP_ALL)
1254 client_reconfigure(c);
1256 if (i < screen_num_desktops) {
1257 /* don't set these for the 'all desktops' area */
1258 dims[(i * 4) + 0] = area[i][screen_num_monitors].x;
1259 dims[(i * 4) + 1] = area[i][screen_num_monitors].y;
1260 dims[(i * 4) + 2] = area[i][screen_num_monitors].width;
1261 dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
1267 PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1268 dims, 4 * screen_num_desktops);
1273 Rect *screen_area(guint desktop)
1275 return screen_area_monitor(desktop, screen_num_monitors);
1278 Rect *screen_area_monitor(guint desktop, guint head)
1280 if (head > screen_num_monitors)
1282 if (desktop >= screen_num_desktops) {
1283 if (desktop == DESKTOP_ALL)
1284 return &area[screen_num_desktops][head];
1287 return &area[desktop][head];
1290 guint screen_find_monitor(Rect *search)
1296 for (i = 0; i < screen_num_monitors; ++i) {
1297 Rect *area = screen_physical_area_monitor(i);
1298 if (RECT_INTERSECTS_RECT(*area, *search)) {
1302 RECT_SET_INTERSECTION(r, *area, *search);
1303 v = r.width * r.height;
1314 Rect *screen_physical_area()
1316 return screen_physical_area_monitor(screen_num_monitors);
1319 Rect *screen_physical_area_monitor(guint head)
1321 if (head > screen_num_monitors)
1323 return &monitor_area[head];
1326 void screen_set_root_cursor()
1328 if (sn_app_starting())
1329 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1330 ob_cursor(OB_CURSOR_BUSYPOINTER));
1332 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1333 ob_cursor(OB_CURSOR_POINTER));
1336 gboolean screen_pointer_pos(gint *x, gint *y)
1343 ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1344 &w, &w, x, y, &i, &i, &u);
1346 for (i = 0; i < ScreenCount(ob_display); ++i)
1348 if (XQueryPointer(ob_display, RootWindow(ob_display, i),
1349 &w, &w, x, y, &i, &i, &u))