]> Dogcows Code - chaz/openbox/blob - openbox/screen.c
projects / chaz / openbox / blob
? search:


c1c61ed5b7ce476501ffce3136d2c8deadb50c49
[chaz/openbox] / openbox / screen.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3 screen.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003 Ben Jansens
6
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.
11
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.
16
17 See the COPYING file for a copy of the GNU General Public License.
18 */
19
20 #include "debug.h"
21 #include "openbox.h"
22 #include "dock.h"
23 #include "xerror.h"
24 #include "prop.h"
25 #include "grab.h"
26 #include "startupnotify.h"
27 #include "moveresize.h"
28 #include "config.h"
29 #include "screen.h"
30 #include "client.h"
31 #include "frame.h"
32 #include "event.h"
33 #include "focus.h"
34 #include "popup.h"
35 #include "extensions.h"
36 #include "render/render.h"
37
38 #include <X11/Xlib.h>
39 #ifdef HAVE_UNISTD_H
40 # include <sys/types.h>
41 # include <unistd.h>
42 #endif
43 #include <assert.h>
44
45 /*! The event mask to grab on the root window */
46 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
47 EnterWindowMask | LeaveWindowMask | \
48 SubstructureNotifyMask | SubstructureRedirectMask | \
49 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
50
51 guint screen_num_desktops;
52 guint screen_num_monitors;
53 guint screen_desktop;
54 guint screen_last_desktop;
55 Size screen_physical_size;
56 gboolean screen_showing_desktop;
57 DesktopLayout screen_desktop_layout;
58 gchar **screen_desktop_names;
59 Window screen_support_win;
60
61 static Rect **area; /* array of desktop holding array of xinerama areas */
62 static Rect *monitor_area;
63
64 static ObPagerPopup *desktop_cycle_popup;
65
66 static gboolean replace_wm()
67 {
68 gchar *wm_sn;
69 Atom wm_sn_atom;
70 Window current_wm_sn_owner;
71 Time timestamp;
72
73 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
74 wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
75 g_free(wm_sn);
76
77 current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
78 if (current_wm_sn_owner == screen_support_win)
79 current_wm_sn_owner = None;
80 if (current_wm_sn_owner) {
81 if (!ob_replace_wm) {
82 g_warning("A window manager is already running on screen %d",
83 ob_screen);
84 return FALSE;
85 }
86 xerror_set_ignore(TRUE);
87 xerror_occured = FALSE;
88
89 /* We want to find out when the current selection owner dies */
90 XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
91 XSync(ob_display, FALSE);
92
93 xerror_set_ignore(FALSE);
94 if (xerror_occured)
95 current_wm_sn_owner = None;
96 }
97
98 {
99 /* Generate a timestamp */
100 XEvent event;
101
102 XSelectInput(ob_display, screen_support_win, PropertyChangeMask);
103
104 XChangeProperty(ob_display, screen_support_win,
105 prop_atoms.wm_class, prop_atoms.string,
106 8, PropModeAppend, NULL, 0);
107 XWindowEvent(ob_display, screen_support_win,
108 PropertyChangeMask, &event);
109
110 XSelectInput(ob_display, screen_support_win, NoEventMask);
111
112 timestamp = event.xproperty.time;
113 }
114
115 XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
116 timestamp);
117
118 if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
119 g_warning("Could not acquire window manager selection on screen %d",
120 ob_screen);
121 return FALSE;
122 }
123
124 /* Wait for old window manager to go away */
125 if (current_wm_sn_owner) {
126 XEvent event;
127 gulong wait = 0;
128 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
129
130 while (wait < timeout) {
131 if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
132 StructureNotifyMask, &event) &&
133 event.type == DestroyNotify)
134 break;
135 g_usleep(G_USEC_PER_SEC / 10);
136 wait += G_USEC_PER_SEC / 10;
137 }
138
139 if (wait >= timeout) {
140 g_warning("Timeout expired while waiting for the current WM to die "
141 "on screen %d", ob_screen);
142 return FALSE;
143 }
144 }
145
146 /* Send client message indicating that we are now the WM */
147 prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
148 timestamp, wm_sn_atom, 0, 0, SubstructureNotifyMask);
149
150
151 return TRUE;
152 }
153
154 gboolean screen_annex()
155 {
156 XSetWindowAttributes attrib;
157 pid_t pid;
158 gint i, num_support;
159 gulong *supported;
160
161 /* create the netwm support window */
162 attrib.override_redirect = TRUE;
163 screen_support_win = XCreateWindow(ob_display,
164 RootWindow(ob_display, ob_screen),
165 -100, -100, 1, 1, 0,
166 CopyFromParent, InputOutput,
167 CopyFromParent,
168 CWOverrideRedirect, &attrib);
169 XMapRaised(ob_display, screen_support_win);
170
171 if (!replace_wm()) {
172 XDestroyWindow(ob_display, screen_support_win);
173 return FALSE;
174 }
175
176 xerror_set_ignore(TRUE);
177 xerror_occured = FALSE;
178 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
179 ROOT_EVENTMASK);
180 xerror_set_ignore(FALSE);
181 if (xerror_occured) {
182 g_warning("A window manager is already running on screen %d",
183 ob_screen);
184
185 XDestroyWindow(ob_display, screen_support_win);
186 return FALSE;
187 }
188
189
190 screen_set_root_cursor();
191
192 /* set the OPENBOX_PID hint */
193 pid = getpid();
194 PROP_SET32(RootWindow(ob_display, ob_screen),
195 openbox_pid, cardinal, pid);
196
197 /* set supporting window */
198 PROP_SET32(RootWindow(ob_display, ob_screen),
199 net_supporting_wm_check, window, screen_support_win);
200
201 /* set properties on the supporting window */
202 PROP_SETS(screen_support_win, net_wm_name, "Openbox");
203 PROP_SET32(screen_support_win, net_supporting_wm_check,
204 window, screen_support_win);
205
206 /* set the _NET_SUPPORTED_ATOMS hint */
207 num_support = 53;
208 i = 0;
209 supported = g_new(gulong, num_support);
210 supported[i++] = prop_atoms.net_current_desktop;
211 supported[i++] = prop_atoms.net_number_of_desktops;
212 supported[i++] = prop_atoms.net_desktop_geometry;
213 supported[i++] = prop_atoms.net_desktop_viewport;
214 supported[i++] = prop_atoms.net_active_window;
215 supported[i++] = prop_atoms.net_workarea;
216 supported[i++] = prop_atoms.net_client_list;
217 supported[i++] = prop_atoms.net_client_list_stacking;
218 supported[i++] = prop_atoms.net_desktop_names;
219 supported[i++] = prop_atoms.net_close_window;
220 supported[i++] = prop_atoms.net_desktop_layout;
221 supported[i++] = prop_atoms.net_showing_desktop;
222 supported[i++] = prop_atoms.net_wm_name;
223 supported[i++] = prop_atoms.net_wm_visible_name;
224 supported[i++] = prop_atoms.net_wm_icon_name;
225 supported[i++] = prop_atoms.net_wm_visible_icon_name;
226 supported[i++] = prop_atoms.net_wm_desktop;
227 supported[i++] = prop_atoms.net_wm_strut;
228 supported[i++] = prop_atoms.net_wm_window_type;
229 supported[i++] = prop_atoms.net_wm_window_type_desktop;
230 supported[i++] = prop_atoms.net_wm_window_type_dock;
231 supported[i++] = prop_atoms.net_wm_window_type_toolbar;
232 supported[i++] = prop_atoms.net_wm_window_type_menu;
233 supported[i++] = prop_atoms.net_wm_window_type_utility;
234 supported[i++] = prop_atoms.net_wm_window_type_splash;
235 supported[i++] = prop_atoms.net_wm_window_type_dialog;
236 supported[i++] = prop_atoms.net_wm_window_type_normal;
237 supported[i++] = prop_atoms.net_wm_allowed_actions;
238 supported[i++] = prop_atoms.net_wm_action_move;
239 supported[i++] = prop_atoms.net_wm_action_resize;
240 supported[i++] = prop_atoms.net_wm_action_minimize;
241 supported[i++] = prop_atoms.net_wm_action_shade;
242 supported[i++] = prop_atoms.net_wm_action_maximize_horz;
243 supported[i++] = prop_atoms.net_wm_action_maximize_vert;
244 supported[i++] = prop_atoms.net_wm_action_fullscreen;
245 supported[i++] = prop_atoms.net_wm_action_change_desktop;
246 supported[i++] = prop_atoms.net_wm_action_close;
247 supported[i++] = prop_atoms.net_wm_state;
248 supported[i++] = prop_atoms.net_wm_state_modal;
249 supported[i++] = prop_atoms.net_wm_state_maximized_vert;
250 supported[i++] = prop_atoms.net_wm_state_maximized_horz;
251 supported[i++] = prop_atoms.net_wm_state_shaded;
252 supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
253 supported[i++] = prop_atoms.net_wm_state_skip_pager;
254 supported[i++] = prop_atoms.net_wm_state_hidden;
255 supported[i++] = prop_atoms.net_wm_state_fullscreen;
256 supported[i++] = prop_atoms.net_wm_state_above;
257 supported[i++] = prop_atoms.net_wm_state_below;
258 supported[i++] = prop_atoms.net_wm_state_demands_attention;
259 supported[i++] = prop_atoms.net_moveresize_window;
260 supported[i++] = prop_atoms.net_wm_moveresize;
261 supported[i++] = prop_atoms.net_frame_extents;
262 supported[i++] = prop_atoms.ob_wm_state_undecorated;
263 g_assert(i == num_support);
264 /*
265 supported[] = prop_atoms.net_wm_action_stick;
266 */
267
268 PROP_SETA32(RootWindow(ob_display, ob_screen),
269 net_supported, atom, supported, num_support);
270 g_free(supported);
271
272 return TRUE;
273 }
274
275 void screen_startup(gboolean reconfig)
276 {
277 GSList *it;
278 guint i;
279
280 desktop_cycle_popup = pager_popup_new(FALSE);
281
282 if (!reconfig)
283 /* get the initial size */
284 screen_resize();
285
286 /* set the names */
287 screen_desktop_names = g_new(gchar*,
288 g_slist_length(config_desktops_names) + 1);
289 for (i = 0, it = config_desktops_names; it; ++i, it = g_slist_next(it))
290 screen_desktop_names[i] = it->data; /* dont strdup */
291 screen_desktop_names[i] = NULL;
292 PROP_SETSS(RootWindow(ob_display, ob_screen),
293 net_desktop_names, screen_desktop_names);
294 g_free(screen_desktop_names); /* dont free the individual strings */
295 screen_desktop_names = NULL;
296
297 if (!reconfig)
298 screen_num_desktops = 0;
299 screen_set_num_desktops(config_desktops_num);
300 if (!reconfig) {
301 screen_set_desktop(MIN(config_screen_firstdesk, screen_num_desktops)
302 - 1);
303
304 /* don't start in showing-desktop mode */
305 screen_showing_desktop = FALSE;
306 PROP_SET32(RootWindow(ob_display, ob_screen),
307 net_showing_desktop, cardinal, screen_showing_desktop);
308
309 screen_update_layout();
310 }
311 }
312
313 void screen_shutdown(gboolean reconfig)
314 {
315 Rect **r;
316
317 pager_popup_free(desktop_cycle_popup);
318
319 if (!reconfig) {
320 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
321 NoEventMask);
322
323 /* we're not running here no more! */
324 PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
325 /* not without us */
326 PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
327 /* don't keep this mode */
328 PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
329
330 XDestroyWindow(ob_display, screen_support_win);
331 }
332
333 g_strfreev(screen_desktop_names);
334 screen_desktop_names = NULL;
335 for (r = area; *r; ++r)
336 g_free(*r);
337 g_free(area);
338 area = NULL;
339 }
340
341 void screen_resize()
342 {
343 static gint oldw = 0, oldh = 0;
344 gint w, h;
345 GList *it;
346 gulong geometry[2];
347
348 w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
349 h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
350
351 if (w == oldw && h == oldh) return;
352
353 oldw = w; oldh = h;
354
355 /* Set the _NET_DESKTOP_GEOMETRY hint */
356 screen_physical_size.width = geometry[0] = w;
357 screen_physical_size.height = geometry[1] = h;
358 PROP_SETA32(RootWindow(ob_display, ob_screen),
359 net_desktop_geometry, cardinal, geometry, 2);
360
361 if (ob_state() == OB_STATE_STARTING)
362 return;
363
364 screen_update_areas();
365 dock_configure();
366
367 for (it = client_list; it; it = g_list_next(it))
368 client_move_onscreen(it->data, FALSE);
369 }
370
371 void screen_set_num_desktops(guint num)
372 {
373 guint i, old;
374 gulong *viewport;
375 GList *it;
376
377 g_assert(num > 0);
378
379 if (screen_num_desktops == num) return;
380
381 old = screen_num_desktops;
382 screen_num_desktops = num;
383 PROP_SET32(RootWindow(ob_display, ob_screen),
384 net_number_of_desktops, cardinal, num);
385
386 /* set the viewport hint */
387 viewport = g_new0(gulong, num * 2);
388 PROP_SETA32(RootWindow(ob_display, ob_screen),
389 net_desktop_viewport, cardinal, viewport, num * 2);
390 g_free(viewport);
391
392 /* the number of rows/columns will differ */
393 screen_update_layout();
394
395 /* may be some unnamed desktops that we need to fill in with names */
396 screen_update_desktop_names();
397
398 /* move windows on desktops that will no longer exist! */
399 for (it = client_list; it; it = g_list_next(it)) {
400 ObClient *c = it->data;
401 if (c->desktop >= num && c->desktop != DESKTOP_ALL)
402 client_set_desktop(c, num - 1, FALSE);
403 }
404
405 /* change our struts/area to match (after moving windows) */
406 screen_update_areas();
407
408 /* change our desktop if we're on one that no longer exists! */
409 if (screen_desktop >= screen_num_desktops)
410 screen_set_desktop(num - 1);
411
412 /* update the focus lists */
413 /* free our lists for the desktops which have disappeared */
414 for (i = num; i < old; ++i)
415 g_list_free(focus_order[i]);
416 /* realloc the array */
417 focus_order = g_renew(GList*, focus_order, num);
418 /* set the new lists to be empty */
419 for (i = old; i < num; ++i)
420 focus_order[i] = NULL;
421 }
422
423 void screen_set_desktop(guint num)
424 {
425 GList *it;
426 guint old;
427
428 g_assert(num < screen_num_desktops);
429
430 old = screen_desktop;
431 screen_desktop = num;
432 PROP_SET32(RootWindow(ob_display, ob_screen),
433 net_current_desktop, cardinal, num);
434
435 if (old == num) return;
436
437 screen_last_desktop = old;
438
439 ob_debug("Moving to desktop %d\n", num+1);
440
441 if (moveresize_client)
442 client_set_desktop(moveresize_client, num, TRUE);
443
444 /* show windows before hiding the rest to lessen the enter/leave events */
445
446 /* show windows from top to bottom */
447 for (it = stacking_list; it; it = g_list_next(it)) {
448 if (WINDOW_IS_CLIENT(it->data)) {
449 ObClient *c = it->data;
450 if (client_should_show(c))
451 frame_show(c->frame);
452 }
453 }
454
455 /* hide windows from bottom to top */
456 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
457 if (WINDOW_IS_CLIENT(it->data)) {
458 ObClient *c = it->data;
459 if (c->frame->visible && !client_should_show(c))
460 frame_hide(c->frame);
461 }
462 }
463
464 event_ignore_queued_enters();
465
466 focus_hilite = focus_fallback_target(OB_FOCUS_FALLBACK_NOFOCUS);
467 if (focus_hilite) {
468 frame_adjust_focus(focus_hilite->frame, TRUE);
469
470 /*!
471 When this focus_client check is not used, you can end up with races,
472 as demonstrated with gnome-panel, sometmies the window you click on
473 another desktop ends up losing focus cuz of the focus change here.
474 */
475 /*if (!focus_client)*/
476 client_focus(focus_hilite);
477 }
478 }
479
480 static void get_row_col(guint d, guint *r, guint *c)
481 {
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;
488 break;
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;
493 break;
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;
498 break;
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;
504 break;
505 }
506 break;
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;
512 break;
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;
517 break;
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;
522 break;
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;
528 break;
529 }
530 break;
531 }
532 }
533
534 static guint translate_row_col(guint r, guint c)
535 {
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);
559 }
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);
582 }
583 }
584 g_assert_not_reached();
585 return 0;
586 }
587
588 void screen_desktop_popup(guint d, gboolean show)
589 {
590 Rect *a;
591
592 if (!show) {
593 pager_popup_hide(desktop_cycle_popup);
594 } else {
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
599 */
600 pager_popup_size(desktop_cycle_popup, POPUP_WIDTH, POPUP_HEIGHT);
601
602 pager_popup_set_text_align(desktop_cycle_popup, RR_JUSTIFY_CENTER);
603
604 pager_popup_show(desktop_cycle_popup, screen_desktop_names[d], d);
605 }
606 }
607
608 guint screen_cycle_desktop(ObDirection dir, gboolean wrap, gboolean linear,
609 gboolean dialog, gboolean done, gboolean cancel)
610 {
611 static gboolean first = TRUE;
612 static guint origd, d;
613 guint r, c;
614
615 if (cancel) {
616 d = origd;
617 goto done_cycle;
618 } else if (done && dialog) {
619 goto done_cycle;
620 }
621 if (first) {
622 first = FALSE;
623 d = origd = screen_desktop;
624 }
625
626 get_row_col(d, &r, &c);
627
628 if (linear) {
629 switch (dir) {
630 case OB_DIRECTION_EAST:
631 if (d < screen_num_desktops - 1)
632 ++d;
633 else if (wrap)
634 d = 0;
635 break;
636 case OB_DIRECTION_WEST:
637 if (d > 0)
638 --d;
639 else if (wrap)
640 d = screen_num_desktops - 1;
641 break;
642 default:
643 assert(0);
644 return screen_desktop;
645 }
646 } else {
647 switch (dir) {
648 case OB_DIRECTION_EAST:
649 ++c;
650 if (c >= screen_desktop_layout.columns) {
651 if (wrap) {
652 c = 0;
653 } else {
654 d = screen_desktop;
655 goto show_cycle_dialog;
656 }
657 }
658 d = translate_row_col(r, c);
659 if (d >= screen_num_desktops) {
660 if (wrap) {
661 ++c;
662 } else {
663 d = screen_desktop;
664 goto show_cycle_dialog;
665 }
666 }
667 break;
668 case OB_DIRECTION_WEST:
669 --c;
670 if (c >= screen_desktop_layout.columns) {
671 if (wrap) {
672 c = screen_desktop_layout.columns - 1;
673 } else {
674 d = screen_desktop;
675 goto show_cycle_dialog;
676 }
677 }
678 d = translate_row_col(r, c);
679 if (d >= screen_num_desktops) {
680 if (wrap) {
681 --c;
682 } else {
683 d = screen_desktop;
684 goto show_cycle_dialog;
685 }
686 }
687 break;
688 case OB_DIRECTION_SOUTH:
689 ++r;
690 if (r >= screen_desktop_layout.rows) {
691 if (wrap) {
692 r = 0;
693 } else {
694 d = screen_desktop;
695 goto show_cycle_dialog;
696 }
697 }
698 d = translate_row_col(r, c);
699 if (d >= screen_num_desktops) {
700 if (wrap) {
701 ++r;
702 } else {
703 d = screen_desktop;
704 goto show_cycle_dialog;
705 }
706 }
707 break;
708 case OB_DIRECTION_NORTH:
709 --r;
710 if (r >= screen_desktop_layout.rows) {
711 if (wrap) {
712 r = screen_desktop_layout.rows - 1;
713 } else {
714 d = screen_desktop;
715 goto show_cycle_dialog;
716 }
717 }
718 d = translate_row_col(r, c);
719 if (d >= screen_num_desktops) {
720 if (wrap) {
721 --r;
722 } else {
723 d = screen_desktop;
724 goto show_cycle_dialog;
725 }
726 }
727 break;
728 default:
729 assert(0);
730 return d = screen_desktop;
731 }
732
733 d = translate_row_col(r, c);
734 }
735
736 show_cycle_dialog:
737 if (dialog) {
738 screen_desktop_popup(d, TRUE);
739 return d;
740 }
741
742 done_cycle:
743 first = TRUE;
744
745 screen_desktop_popup(0, FALSE);
746
747 return d;
748 }
749
750 void screen_update_layout()
751 {
752 ObOrientation orient;
753 ObCorner corner;
754 guint rows;
755 guint cols;
756 guint32 *data;
757 guint num;
758 gboolean valid = FALSE;
759
760 if (PROP_GETA32(RootWindow(ob_display, ob_screen),
761 net_desktop_layout, cardinal, &data, &num)) {
762 if (num == 3 || num == 4) {
763
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;
768 else
769 goto screen_update_layout_bail;
770
771 if (num < 4)
772 corner = OB_CORNER_TOPLEFT;
773 else {
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;
782 else
783 goto screen_update_layout_bail;
784 }
785
786 cols = data[1];
787 rows = data[2];
788
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;
792 } else {
793 if (cols == 0) {
794 cols = screen_num_desktops / rows;
795 if (rows * cols < screen_num_desktops)
796 cols++;
797 if (rows * cols >= screen_num_desktops + cols)
798 rows--;
799 } else if (rows == 0) {
800 rows = screen_num_desktops / cols;
801 if (cols * rows < screen_num_desktops)
802 rows++;
803 if (cols * rows >= screen_num_desktops + rows)
804 cols--;
805 }
806 }
807
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);
814 } else {
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);
819 }
820
821 valid = TRUE;
822 }
823 screen_update_layout_bail:
824 g_free(data);
825 }
826
827 if (!valid) {
828 /* defaults */
829 orient = OB_ORIENTATION_HORZ;
830 corner = OB_CORNER_TOPLEFT;
831 rows = 1;
832 cols = screen_num_desktops;
833 }
834
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;
839 }
840
841 void screen_update_desktop_names()
842 {
843 guint i;
844
845 /* empty the array */
846 g_strfreev(screen_desktop_names);
847 screen_desktop_names = NULL;
848
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);
852 else
853 i = 0;
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);
860 }
861 }
862
863 void screen_show_desktop(gboolean show)
864 {
865 GList *it;
866
867 if (show == screen_showing_desktop) return; /* no change */
868
869 screen_showing_desktop = show;
870
871 if (show) {
872 /* bottom to top */
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 if (client->frame->visible && !client_should_show(client))
877 frame_hide(client->frame);
878 }
879 }
880 } else {
881 /* top to bottom */
882 for (it = stacking_list; it; it = g_list_next(it)) {
883 if (WINDOW_IS_CLIENT(it->data)) {
884 ObClient *client = it->data;
885 if (!client->frame->visible && client_should_show(client))
886 frame_show(client->frame);
887 }
888 }
889 }
890
891 if (show) {
892 /* focus desktop */
893 for (it = focus_order[screen_desktop]; it; it = g_list_next(it))
894 if (((ObClient*)it->data)->type == OB_CLIENT_TYPE_DESKTOP &&
895 client_focus(it->data))
896 break;
897 } else {
898 focus_fallback(OB_FOCUS_FALLBACK_NOFOCUS);
899 }
900
901 show = !!show; /* make it boolean */
902 PROP_SET32(RootWindow(ob_display, ob_screen),
903 net_showing_desktop, cardinal, show);
904 }
905
906 void screen_install_colormap(ObClient *client, gboolean install)
907 {
908 XWindowAttributes wa;
909
910 if (client == NULL) {
911 if (install)
912 XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
913 else
914 XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
915 } else {
916 if (XGetWindowAttributes(ob_display, client->window, &wa) &&
917 wa.colormap != None) {
918 xerror_set_ignore(TRUE);
919 if (install)
920 XInstallColormap(RrDisplay(ob_rr_inst), wa.colormap);
921 else
922 XUninstallColormap(RrDisplay(ob_rr_inst), wa.colormap);
923 xerror_set_ignore(FALSE);
924 }
925 }
926 }
927
928 static inline void
929 screen_area_add_strut_left(const StrutPartial *s, const Rect *monitor_area,
930 gint edge, Strut *ret)
931 {
932 if (s->left &&
933 ((s->left_end <= s->left_start) ||
934 (RECT_TOP(*monitor_area) < s->left_end &&
935 RECT_BOTTOM(*monitor_area) > s->left_start)))
936 ret->left = MAX(ret->left, edge);
937 }
938
939 static inline void
940 screen_area_add_strut_top(const StrutPartial *s, const Rect *monitor_area,
941 gint edge, Strut *ret)
942 {
943 if (s->top &&
944 ((s->top_end <= s->top_start) ||
945 (RECT_LEFT(*monitor_area) < s->top_end &&
946 RECT_RIGHT(*monitor_area) > s->top_start)))
947 ret->top = MAX(ret->top, edge);
948 }
949
950 static inline void
951 screen_area_add_strut_right(const StrutPartial *s, const Rect *monitor_area,
952 gint edge, Strut *ret)
953 {
954 if (s->right &&
955 ((s->right_end <= s->right_start) ||
956 (RECT_TOP(*monitor_area) < s->right_end &&
957 RECT_BOTTOM(*monitor_area) > s->right_start)))
958 ret->right = MAX(ret->right, edge);
959 }
960
961 static inline void
962 screen_area_add_strut_bottom(const StrutPartial *s, const Rect *monitor_area,
963 gint edge, Strut *ret)
964 {
965 if (s->bottom &&
966 ((s->bottom_end <= s->bottom_start) ||
967 (RECT_LEFT(*monitor_area) < s->bottom_end &&
968 RECT_RIGHT(*monitor_area) > s->bottom_start)))
969 ret->bottom = MAX(ret->bottom, edge);
970 }
971
972 void screen_update_areas()
973 {
974 guint i, x;
975 gulong *dims;
976 GList *it;
977 gint o;
978
979 g_free(monitor_area);
980 extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
981
982 if (area) {
983 for (i = 0; area[i]; ++i)
984 g_free(area[i]);
985 g_free(area);
986 }
987
988 area = g_new(Rect*, screen_num_desktops + 2);
989 for (i = 0; i < screen_num_desktops + 1; ++i)
990 area[i] = g_new0(Rect, screen_num_monitors + 1);
991 area[i] = NULL;
992
993 dims = g_new(gulong, 4 * screen_num_desktops);
994
995 for (i = 0; i < screen_num_desktops + 1; ++i) {
996 Strut *struts;
997 gint l, r, t, b;
998
999 struts = g_new0(Strut, screen_num_monitors);
1000
1001 /* calc the xinerama areas */
1002 for (x = 0; x < screen_num_monitors; ++x) {
1003 area[i][x] = monitor_area[x];
1004 if (x == 0) {
1005 l = monitor_area[x].x;
1006 t = monitor_area[x].y;
1007 r = monitor_area[x].x + monitor_area[x].width - 1;
1008 b = monitor_area[x].y + monitor_area[x].height - 1;
1009 } else {
1010 l = MIN(l, monitor_area[x].x);
1011 t = MIN(t, monitor_area[x].y);
1012 r = MAX(r, monitor_area[x].x + monitor_area[x].width - 1);
1013 b = MAX(b, monitor_area[x].y + monitor_area[x].height - 1);
1014 }
1015 }
1016 RECT_SET(area[i][x], l, t, r - l + 1, b - t + 1);
1017
1018 /* apply the struts */
1019
1020 /* find the left-most xin heads, i do this in 2 loops :| */
1021 o = area[i][0].x;
1022 for (x = 1; x < screen_num_monitors; ++x)
1023 o = MIN(o, area[i][x].x);
1024
1025 for (x = 0; x < screen_num_monitors; ++x) {
1026 for (it = client_list; it; it = g_list_next(it)) {
1027 ObClient *c = it->data;
1028 screen_area_add_strut_left(&c->strut,
1029 &monitor_area[x],
1030 o + c->strut.left - area[i][x].x,
1031 &struts[x]);
1032 }
1033 screen_area_add_strut_left(&dock_strut,
1034 &monitor_area[x],
1035 o + dock_strut.left - area[i][x].x,
1036 &struts[x]);
1037
1038 area[i][x].x += struts[x].left;
1039 area[i][x].width -= struts[x].left;
1040 }
1041
1042 /* find the top-most xin heads, i do this in 2 loops :| */
1043 o = area[i][0].y;
1044 for (x = 1; x < screen_num_monitors; ++x)
1045 o = MIN(o, area[i][x].y);
1046
1047 for (x = 0; x < screen_num_monitors; ++x) {
1048 for (it = client_list; it; it = g_list_next(it)) {
1049 ObClient *c = it->data;
1050 screen_area_add_strut_top(&c->strut,
1051 &monitor_area[x],
1052 o + c->strut.top - area[i][x].y,
1053 &struts[x]);
1054 }
1055 screen_area_add_strut_top(&dock_strut,
1056 &monitor_area[x],
1057 o + dock_strut.top - area[i][x].y,
1058 &struts[x]);
1059
1060 area[i][x].y += struts[x].top;
1061 area[i][x].height -= struts[x].top;
1062 }
1063
1064 /* find the right-most xin heads, i do this in 2 loops :| */
1065 o = area[i][0].x + area[i][0].width - 1;
1066 for (x = 1; x < screen_num_monitors; ++x)
1067 o = MAX(o, area[i][x].x + area[i][x].width - 1);
1068
1069 for (x = 0; x < screen_num_monitors; ++x) {
1070 for (it = client_list; it; it = g_list_next(it)) {
1071 ObClient *c = it->data;
1072 screen_area_add_strut_right(&c->strut,
1073 &monitor_area[x],
1074 (area[i][x].x +
1075 area[i][x].width - 1) -
1076 (o - c->strut.right),
1077 &struts[x]);
1078 }
1079 screen_area_add_strut_right(&dock_strut,
1080 &monitor_area[x],
1081 (area[i][x].x +
1082 area[i][x].width - 1) -
1083 (o - dock_strut.right),
1084 &struts[x]);
1085
1086 area[i][x].width -= struts[x].right;
1087 }
1088
1089 /* find the bottom-most xin heads, i do this in 2 loops :| */
1090 o = area[i][0].y + area[i][0].height - 1;
1091 for (x = 1; x < screen_num_monitors; ++x)
1092 o = MAX(o, area[i][x].y + area[i][x].height - 1);
1093
1094 for (x = 0; x < screen_num_monitors; ++x) {
1095 for (it = client_list; it; it = g_list_next(it)) {
1096 ObClient *c = it->data;
1097 screen_area_add_strut_bottom(&c->strut,
1098 &monitor_area[x],
1099 (area[i][x].y +
1100 area[i][x].height - 1) - \
1101 (o - c->strut.bottom),
1102 &struts[x]);
1103 }
1104 screen_area_add_strut_bottom(&dock_strut,
1105 &monitor_area[x],
1106 (area[i][x].y +
1107 area[i][x].height - 1) - \
1108 (o - dock_strut.bottom),
1109 &struts[x]);
1110
1111 area[i][x].height -= struts[x].bottom;
1112 }
1113
1114 l = RECT_LEFT(area[i][0]);
1115 t = RECT_TOP(area[i][0]);
1116 r = RECT_RIGHT(area[i][0]);
1117 b = RECT_BOTTOM(area[i][0]);
1118 for (x = 1; x < screen_num_monitors; ++x) {
1119 l = MIN(l, RECT_LEFT(area[i][x]));
1120 t = MIN(l, RECT_TOP(area[i][x]));
1121 r = MAX(r, RECT_RIGHT(area[i][x]));
1122 b = MAX(b, RECT_BOTTOM(area[i][x]));
1123 }
1124 RECT_SET(area[i][screen_num_monitors], l, t,
1125 r - l + 1, b - t + 1);
1126
1127 /* XXX optimize when this is run? */
1128
1129 /* the area has changed, adjust all the maximized
1130 windows */
1131 for (it = client_list; it; it = g_list_next(it)) {
1132 ObClient *c = it->data;
1133 if (i < screen_num_desktops) {
1134 if (c->desktop == i)
1135 client_reconfigure(c);
1136 } else if (c->desktop == DESKTOP_ALL)
1137 client_reconfigure(c);
1138 }
1139 if (i < screen_num_desktops) {
1140 /* don't set these for the 'all desktops' area */
1141 dims[(i * 4) + 0] = area[i][screen_num_monitors].x;
1142 dims[(i * 4) + 1] = area[i][screen_num_monitors].y;
1143 dims[(i * 4) + 2] = area[i][screen_num_monitors].width;
1144 dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
1145 }
1146
1147 g_free(struts);
1148 }
1149
1150 PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1151 dims, 4 * screen_num_desktops);
1152
1153 g_free(dims);
1154 }
1155
1156 Rect *screen_area(guint desktop)
1157 {
1158 return screen_area_monitor(desktop, screen_num_monitors);
1159 }
1160
1161 Rect *screen_area_monitor(guint desktop, guint head)
1162 {
1163 if (head > screen_num_monitors)
1164 return NULL;
1165 if (desktop >= screen_num_desktops) {
1166 if (desktop == DESKTOP_ALL)
1167 return &area[screen_num_desktops][head];
1168 return NULL;
1169 }
1170 return &area[desktop][head];
1171 }
1172
1173 Rect *screen_physical_area()
1174 {
1175 return screen_physical_area_monitor(screen_num_monitors);
1176 }
1177
1178 Rect *screen_physical_area_monitor(guint head)
1179 {
1180 if (head > screen_num_monitors)
1181 return NULL;
1182 return &monitor_area[head];
1183 }
1184
1185 void screen_set_root_cursor()
1186 {
1187 if (sn_app_starting())
1188 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1189 ob_cursor(OB_CURSOR_BUSY));
1190 else
1191 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1192 ob_cursor(OB_CURSOR_POINTER));
1193 }
1194
1195 gboolean screen_pointer_pos(gint *x, gint *y)
1196 {
1197 Window w;
1198 gint i;
1199 guint u;
1200
1201 return !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1202 &w, &w, x, y, &i, &i, &u);
1203 }
my patches for the openbox window manager
This page took 0.084826 seconds and 4 git commands to generate.