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


7e2d8645ce3fd3602f7c1d37615f90246cbfec7e
[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-2007 Dana 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 "session.h"
32 #include "frame.h"
33 #include "event.h"
34 #include "focus.h"
35 #include "popup.h"
36 #include "extensions.h"
37 #include "render/render.h"
38 #include "gettext.h"
39
40 #include <X11/Xlib.h>
41 #ifdef HAVE_UNISTD_H
42 # include <sys/types.h>
43 # include <unistd.h>
44 #endif
45 #include <assert.h>
46
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)
52
53 static gboolean screen_validate_layout(ObDesktopLayout *l);
54 static gboolean replace_wm();
55 static void screen_tell_ksplash();
56
57 guint screen_num_desktops;
58 guint screen_num_monitors;
59 guint screen_desktop;
60 guint screen_last_desktop;
61 Size screen_physical_size;
62 gboolean screen_showing_desktop;
63 ObDesktopLayout screen_desktop_layout;
64 gchar **screen_desktop_names;
65 Window screen_support_win;
66 Time screen_desktop_user_time = CurrentTime;
67
68 static Rect **area; /* array of desktop holding array of xinerama areas */
69 static Rect *monitor_area;
70
71 static ObPagerPopup *desktop_cycle_popup;
72
73 static gboolean replace_wm()
74 {
75 gchar *wm_sn;
76 Atom wm_sn_atom;
77 Window current_wm_sn_owner;
78 Time timestamp;
79
80 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
81 wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
82 g_free(wm_sn);
83
84 current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
85 if (current_wm_sn_owner == screen_support_win)
86 current_wm_sn_owner = None;
87 if (current_wm_sn_owner) {
88 if (!ob_replace_wm) {
89 g_message(_("A window manager is already running on screen %d"),
90 ob_screen);
91 return FALSE;
92 }
93 xerror_set_ignore(TRUE);
94 xerror_occured = FALSE;
95
96 /* We want to find out when the current selection owner dies */
97 XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
98 XSync(ob_display, FALSE);
99
100 xerror_set_ignore(FALSE);
101 if (xerror_occured)
102 current_wm_sn_owner = None;
103 }
104
105 {
106 /* Generate a timestamp */
107 XEvent event;
108
109 XSelectInput(ob_display, screen_support_win, PropertyChangeMask);
110
111 XChangeProperty(ob_display, screen_support_win,
112 prop_atoms.wm_class, prop_atoms.string,
113 8, PropModeAppend, NULL, 0);
114 XWindowEvent(ob_display, screen_support_win,
115 PropertyChangeMask, &event);
116
117 XSelectInput(ob_display, screen_support_win, NoEventMask);
118
119 timestamp = event.xproperty.time;
120 }
121
122 XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
123 timestamp);
124
125 if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
126 g_message(_("Could not acquire window manager selection on screen %d"),
127 ob_screen);
128 return FALSE;
129 }
130
131 /* Wait for old window manager to go away */
132 if (current_wm_sn_owner) {
133 XEvent event;
134 gulong wait = 0;
135 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
136
137 while (wait < timeout) {
138 if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
139 StructureNotifyMask, &event) &&
140 event.type == DestroyNotify)
141 break;
142 g_usleep(G_USEC_PER_SEC / 10);
143 wait += G_USEC_PER_SEC / 10;
144 }
145
146 if (wait >= timeout) {
147 g_message(_("The WM on screen %d is not exiting"), ob_screen);
148 return FALSE;
149 }
150 }
151
152 /* Send client message indicating that we are now the WM */
153 prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
154 timestamp, wm_sn_atom, screen_support_win, 0,
155 SubstructureNotifyMask);
156
157 return TRUE;
158 }
159
160 gboolean screen_annex()
161 {
162 XSetWindowAttributes attrib;
163 pid_t pid;
164 gint i, num_support;
165 Atom *prop_atoms_start, *wm_supported_pos;
166 gulong *supported;
167
168 /* create the netwm support window */
169 attrib.override_redirect = TRUE;
170 screen_support_win = XCreateWindow(ob_display,
171 RootWindow(ob_display, ob_screen),
172 -100, -100, 1, 1, 0,
173 CopyFromParent, InputOutput,
174 CopyFromParent,
175 CWOverrideRedirect, &attrib);
176 XMapWindow(ob_display, screen_support_win);
177 XLowerWindow(ob_display, screen_support_win);
178
179 if (!replace_wm()) {
180 XDestroyWindow(ob_display, screen_support_win);
181 return FALSE;
182 }
183
184 xerror_set_ignore(TRUE);
185 xerror_occured = FALSE;
186 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
187 ROOT_EVENTMASK);
188 xerror_set_ignore(FALSE);
189 if (xerror_occured) {
190 g_message(_("A window manager is already running on screen %d"),
191 ob_screen);
192
193 XDestroyWindow(ob_display, screen_support_win);
194 return FALSE;
195 }
196
197 screen_set_root_cursor();
198
199 /* set the OPENBOX_PID hint */
200 pid = getpid();
201 PROP_SET32(RootWindow(ob_display, ob_screen),
202 openbox_pid, cardinal, pid);
203
204 /* set supporting window */
205 PROP_SET32(RootWindow(ob_display, ob_screen),
206 net_supporting_wm_check, window, screen_support_win);
207
208 /* set properties on the supporting window */
209 PROP_SETS(screen_support_win, net_wm_name, "Openbox");
210 PROP_SET32(screen_support_win, net_supporting_wm_check,
211 window, screen_support_win);
212
213 /* set the _NET_SUPPORTED_ATOMS hint */
214
215 /* this is all the atoms after net_supported in the prop_atoms struct */
216 prop_atoms_start = (Atom*)&prop_atoms;
217 wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
218 num_support = sizeof(prop_atoms) / sizeof(Atom) -
219 (wm_supported_pos - prop_atoms_start) - 1;
220 i = 0;
221 supported = g_new(gulong, num_support);
222 supported[i++] = prop_atoms.net_supporting_wm_check;
223 supported[i++] = prop_atoms.net_wm_full_placement;
224 supported[i++] = prop_atoms.net_current_desktop;
225 supported[i++] = prop_atoms.net_number_of_desktops;
226 supported[i++] = prop_atoms.net_desktop_geometry;
227 supported[i++] = prop_atoms.net_desktop_viewport;
228 supported[i++] = prop_atoms.net_active_window;
229 supported[i++] = prop_atoms.net_workarea;
230 supported[i++] = prop_atoms.net_client_list;
231 supported[i++] = prop_atoms.net_client_list_stacking;
232 supported[i++] = prop_atoms.net_desktop_names;
233 supported[i++] = prop_atoms.net_close_window;
234 supported[i++] = prop_atoms.net_desktop_layout;
235 supported[i++] = prop_atoms.net_showing_desktop;
236 supported[i++] = prop_atoms.net_wm_name;
237 supported[i++] = prop_atoms.net_wm_visible_name;
238 supported[i++] = prop_atoms.net_wm_icon_name;
239 supported[i++] = prop_atoms.net_wm_visible_icon_name;
240 supported[i++] = prop_atoms.net_wm_desktop;
241 supported[i++] = prop_atoms.net_wm_strut;
242 supported[i++] = prop_atoms.net_wm_strut_partial;
243 supported[i++] = prop_atoms.net_wm_icon;
244 supported[i++] = prop_atoms.net_wm_icon_geometry;
245 supported[i++] = prop_atoms.net_wm_window_type;
246 supported[i++] = prop_atoms.net_wm_window_type_desktop;
247 supported[i++] = prop_atoms.net_wm_window_type_dock;
248 supported[i++] = prop_atoms.net_wm_window_type_toolbar;
249 supported[i++] = prop_atoms.net_wm_window_type_menu;
250 supported[i++] = prop_atoms.net_wm_window_type_utility;
251 supported[i++] = prop_atoms.net_wm_window_type_splash;
252 supported[i++] = prop_atoms.net_wm_window_type_dialog;
253 supported[i++] = prop_atoms.net_wm_window_type_normal;
254 supported[i++] = prop_atoms.net_wm_allowed_actions;
255 supported[i++] = prop_atoms.net_wm_action_move;
256 supported[i++] = prop_atoms.net_wm_action_resize;
257 supported[i++] = prop_atoms.net_wm_action_minimize;
258 supported[i++] = prop_atoms.net_wm_action_shade;
259 supported[i++] = prop_atoms.net_wm_action_maximize_horz;
260 supported[i++] = prop_atoms.net_wm_action_maximize_vert;
261 supported[i++] = prop_atoms.net_wm_action_fullscreen;
262 supported[i++] = prop_atoms.net_wm_action_change_desktop;
263 supported[i++] = prop_atoms.net_wm_action_close;
264 supported[i++] = prop_atoms.net_wm_action_above;
265 supported[i++] = prop_atoms.net_wm_action_below;
266 supported[i++] = prop_atoms.net_wm_state;
267 supported[i++] = prop_atoms.net_wm_state_modal;
268 supported[i++] = prop_atoms.net_wm_state_maximized_vert;
269 supported[i++] = prop_atoms.net_wm_state_maximized_horz;
270 supported[i++] = prop_atoms.net_wm_state_shaded;
271 supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
272 supported[i++] = prop_atoms.net_wm_state_skip_pager;
273 supported[i++] = prop_atoms.net_wm_state_hidden;
274 supported[i++] = prop_atoms.net_wm_state_fullscreen;
275 supported[i++] = prop_atoms.net_wm_state_above;
276 supported[i++] = prop_atoms.net_wm_state_below;
277 supported[i++] = prop_atoms.net_wm_state_demands_attention;
278 supported[i++] = prop_atoms.net_moveresize_window;
279 supported[i++] = prop_atoms.net_wm_moveresize;
280 supported[i++] = prop_atoms.net_wm_user_time;
281 supported[i++] = prop_atoms.net_wm_user_time_window;
282 supported[i++] = prop_atoms.net_frame_extents;
283 supported[i++] = prop_atoms.net_request_frame_extents;
284 supported[i++] = prop_atoms.net_restack_window;
285 supported[i++] = prop_atoms.net_startup_id;
286 #ifdef SYNC
287 supported[i++] = prop_atoms.net_wm_sync_request;
288 supported[i++] = prop_atoms.net_wm_sync_request_counter;
289 #endif
290
291 supported[i++] = prop_atoms.kde_wm_change_state;
292 supported[i++] = prop_atoms.kde_net_wm_frame_strut;
293 supported[i++] = prop_atoms.kde_net_wm_window_type_override;
294
295 supported[i++] = prop_atoms.ob_wm_action_undecorate;
296 supported[i++] = prop_atoms.ob_wm_state_undecorated;
297 supported[i++] = prop_atoms.openbox_pid;
298 supported[i++] = prop_atoms.ob_theme;
299 supported[i++] = prop_atoms.ob_control;
300 g_assert(i == num_support);
301
302 PROP_SETA32(RootWindow(ob_display, ob_screen),
303 net_supported, atom, supported, num_support);
304 g_free(supported);
305
306 screen_tell_ksplash();
307
308 return TRUE;
309 }
310
311 static void screen_tell_ksplash()
312 {
313 XEvent e;
314 char **argv;
315
316 argv = g_new(gchar*, 6);
317 argv[0] = g_strdup("dcop");
318 argv[1] = g_strdup("ksplash");
319 argv[2] = g_strdup("ksplash");
320 argv[3] = g_strdup("upAndRunning(QString)");
321 argv[4] = g_strdup("wm started");
322 argv[5] = NULL;
323
324 /* tell ksplash through the dcop server command line interface */
325 g_spawn_async(NULL, argv, NULL,
326 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
327 G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
328 NULL, NULL, NULL, NULL);
329 g_strfreev(argv);
330
331 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
332 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
333 something. oh well. */
334 e.xclient.type = ClientMessage;
335 e.xclient.display = ob_display;
336 e.xclient.window = RootWindow(ob_display, ob_screen);
337 e.xclient.message_type =
338 XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False );
339 e.xclient.format = 8;
340 strcpy(e.xclient.data.b, "wm started");
341 XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
342 False, SubstructureNotifyMask, &e );
343 }
344
345 void screen_startup(gboolean reconfig)
346 {
347 gchar **names = NULL;
348 guint32 d;
349 gboolean namesexist = FALSE;
350
351 desktop_cycle_popup = pager_popup_new(FALSE);
352 pager_popup_height(desktop_cycle_popup, POPUP_HEIGHT);
353
354 if (reconfig) {
355 /* update the pager popup's width */
356 pager_popup_text_width_to_strings(desktop_cycle_popup,
357 screen_desktop_names,
358 screen_num_desktops);
359 return;
360 }
361
362 /* get the initial size */
363 screen_resize();
364
365 /* have names already been set for the desktops? */
366 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
367 net_desktop_names, utf8, &names))
368 {
369 g_strfreev(names);
370 namesexist = TRUE;
371 }
372
373 /* if names don't exist and we have session names, set those.
374 do this stuff BEFORE setting the number of desktops, because that
375 will create default names for them
376 */
377 if (!namesexist && session_desktop_names != NULL) {
378 guint i, numnames;
379 GSList *it;
380
381 /* get the desktop names */
382 numnames = g_slist_length(session_desktop_names);
383 names = g_new(gchar*, numnames + 1);
384 names[numnames] = NULL;
385 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
386 names[i] = g_strdup(it->data);
387
388 /* set the root window property */
389 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
390
391 g_strfreev(names);
392 }
393
394 /* set the number of desktops, if it's not already set.
395
396 this will also set the default names from the config file up for
397 desktops that don't have names yet */
398 screen_num_desktops = 0;
399 if (PROP_GET32(RootWindow(ob_display, ob_screen),
400 net_number_of_desktops, cardinal, &d))
401 screen_set_num_desktops(d);
402 /* restore from session if possible */
403 else if (session_num_desktops)
404 screen_set_num_desktops(session_num_desktops);
405 else
406 screen_set_num_desktops(config_desktops_num);
407
408 screen_desktop = screen_num_desktops; /* something invalid */
409 /* start on the current desktop when a wm was already running */
410 if (PROP_GET32(RootWindow(ob_display, ob_screen),
411 net_current_desktop, cardinal, &d) &&
412 d < screen_num_desktops)
413 {
414 screen_set_desktop(d, FALSE);
415 } else if (session_desktop >= 0)
416 screen_set_desktop(MIN((guint)session_desktop,
417 screen_num_desktops), FALSE);
418 else
419 screen_set_desktop(MIN(config_screen_firstdesk,
420 screen_num_desktops) - 1, FALSE);
421 screen_last_desktop = screen_desktop;
422
423 /* don't start in showing-desktop mode */
424 screen_showing_desktop = FALSE;
425 PROP_SET32(RootWindow(ob_display, ob_screen),
426 net_showing_desktop, cardinal, screen_showing_desktop);
427
428 if (session_desktop_layout_present &&
429 screen_validate_layout(&session_desktop_layout))
430 {
431 screen_desktop_layout = session_desktop_layout;
432 }
433 else
434 screen_update_layout();
435 }
436
437 void screen_shutdown(gboolean reconfig)
438 {
439 Rect **r;
440
441 pager_popup_free(desktop_cycle_popup);
442
443 if (reconfig)
444 return;
445
446 XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
447 NoEventMask);
448
449 /* we're not running here no more! */
450 PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
451 /* not without us */
452 PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
453 /* don't keep this mode */
454 PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
455
456 XDestroyWindow(ob_display, screen_support_win);
457
458 g_strfreev(screen_desktop_names);
459 screen_desktop_names = NULL;
460
461 for (r = area; *r; ++r)
462 g_free(*r);
463 g_free(area);
464 area = NULL;
465 }
466
467 void screen_resize()
468 {
469 static gint oldw = 0, oldh = 0;
470 gint w, h;
471 GList *it;
472 gulong geometry[2];
473
474 w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
475 h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
476
477 if (w == oldw && h == oldh) return;
478
479 oldw = w; oldh = h;
480
481 /* Set the _NET_DESKTOP_GEOMETRY hint */
482 screen_physical_size.width = geometry[0] = w;
483 screen_physical_size.height = geometry[1] = h;
484 PROP_SETA32(RootWindow(ob_display, ob_screen),
485 net_desktop_geometry, cardinal, geometry, 2);
486
487 if (ob_state() == OB_STATE_STARTING)
488 return;
489
490 screen_update_areas();
491 dock_configure();
492
493 for (it = client_list; it; it = g_list_next(it))
494 client_move_onscreen(it->data, FALSE);
495 }
496
497 void screen_set_num_desktops(guint num)
498 {
499 guint old;
500 gulong *viewport;
501 GList *it;
502
503 g_assert(num > 0);
504
505 if (screen_num_desktops == num) return;
506
507 old = screen_num_desktops;
508 screen_num_desktops = num;
509 PROP_SET32(RootWindow(ob_display, ob_screen),
510 net_number_of_desktops, cardinal, num);
511
512 /* set the viewport hint */
513 viewport = g_new0(gulong, num * 2);
514 PROP_SETA32(RootWindow(ob_display, ob_screen),
515 net_desktop_viewport, cardinal, viewport, num * 2);
516 g_free(viewport);
517
518 /* the number of rows/columns will differ */
519 screen_update_layout();
520
521 /* move windows on desktops that will no longer exist! */
522 for (it = client_list; it; it = g_list_next(it)) {
523 ObClient *c = it->data;
524 if (c->desktop >= num && c->desktop != DESKTOP_ALL)
525 client_set_desktop(c, num - 1, FALSE);
526 }
527
528 /* change our struts/area to match (after moving windows) */
529 screen_update_areas();
530
531 /* may be some unnamed desktops that we need to fill in with names
532 (after updating the areas so the popup can resize) */
533 screen_update_desktop_names();
534
535 /* change our desktop if we're on one that no longer exists! */
536 if (screen_desktop >= screen_num_desktops)
537 screen_set_desktop(num - 1, TRUE);
538 }
539
540 void screen_set_desktop(guint num, gboolean dofocus)
541 {
542 ObClient *c;
543 GList *it;
544 guint old;
545 gulong ignore_start;
546 gboolean allow_omni;
547
548 g_assert(num < screen_num_desktops);
549
550 old = screen_desktop;
551 screen_desktop = num;
552
553 if (old == num) return;
554
555 PROP_SET32(RootWindow(ob_display, ob_screen),
556 net_current_desktop, cardinal, num);
557
558 screen_last_desktop = old;
559
560 ob_debug("Moving to desktop %d\n", num+1);
561
562 /* ignore enter events caused by the move */
563 ignore_start = event_start_ignore_all_enters();
564
565 if (moveresize_client)
566 client_set_desktop(moveresize_client, num, TRUE);
567
568 /* show windows before hiding the rest to lessen the enter/leave events */
569
570 /* show windows from top to bottom */
571 for (it = stacking_list; it; it = g_list_next(it)) {
572 if (WINDOW_IS_CLIENT(it->data)) {
573 ObClient *c = it->data;
574 client_show(c);
575 }
576 }
577
578 /* only allow omnipresent windows to get focus on desktop change if
579 an omnipresent window is already focused (it'll keep focus probably, but
580 maybe not depending on mouse-focus options) */
581 allow_omni = focus_client && (client_normal(focus_client) &&
582 focus_client->desktop == DESKTOP_ALL);
583
584 /* have to try focus here because when you leave an empty desktop
585 there is no focus out to watch for. also, we have different rules
586 here. we always allow it to look under the mouse pointer if
587 config_focus_last is FALSE
588
589 do this before hiding the windows so if helper windows are coming
590 with us, they don't get hidden
591 */
592 if (dofocus && (c = focus_fallback(TRUE, !config_focus_last, allow_omni)))
593 {
594 /* only do the flicker reducing stuff ahead of time if we are going
595 to call xsetinputfocus on the window ourselves. otherwise there is
596 no guarantee the window will actually take focus.. */
597 if (c->can_focus) {
598 /* reduce flicker by hiliting now rather than waiting for the
599 server FocusIn event */
600 frame_adjust_focus(c->frame, TRUE);
601 /* do this here so that if you switch desktops to a window with
602 helper windows then the helper windows won't flash */
603 client_bring_helper_windows(c);
604 }
605 }
606
607 /* hide windows from bottom to top */
608 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
609 if (WINDOW_IS_CLIENT(it->data)) {
610 ObClient *c = it->data;
611 client_hide(c);
612 }
613 }
614
615 event_end_ignore_all_enters(ignore_start);
616
617 if (event_curtime != CurrentTime)
618 screen_desktop_user_time = event_curtime;
619 }
620
621 static void get_row_col(guint d, guint *r, guint *c)
622 {
623 switch (screen_desktop_layout.orientation) {
624 case OB_ORIENTATION_HORZ:
625 switch (screen_desktop_layout.start_corner) {
626 case OB_CORNER_TOPLEFT:
627 *r = d / screen_desktop_layout.columns;
628 *c = d % screen_desktop_layout.columns;
629 break;
630 case OB_CORNER_BOTTOMLEFT:
631 *r = screen_desktop_layout.rows - 1 -
632 d / screen_desktop_layout.columns;
633 *c = d % screen_desktop_layout.columns;
634 break;
635 case OB_CORNER_TOPRIGHT:
636 *r = d / screen_desktop_layout.columns;
637 *c = screen_desktop_layout.columns - 1 -
638 d % screen_desktop_layout.columns;
639 break;
640 case OB_CORNER_BOTTOMRIGHT:
641 *r = screen_desktop_layout.rows - 1 -
642 d / screen_desktop_layout.columns;
643 *c = screen_desktop_layout.columns - 1 -
644 d % screen_desktop_layout.columns;
645 break;
646 }
647 break;
648 case OB_ORIENTATION_VERT:
649 switch (screen_desktop_layout.start_corner) {
650 case OB_CORNER_TOPLEFT:
651 *r = d % screen_desktop_layout.rows;
652 *c = d / screen_desktop_layout.rows;
653 break;
654 case OB_CORNER_BOTTOMLEFT:
655 *r = screen_desktop_layout.rows - 1 -
656 d % screen_desktop_layout.rows;
657 *c = d / screen_desktop_layout.rows;
658 break;
659 case OB_CORNER_TOPRIGHT:
660 *r = d % screen_desktop_layout.rows;
661 *c = screen_desktop_layout.columns - 1 -
662 d / screen_desktop_layout.rows;
663 break;
664 case OB_CORNER_BOTTOMRIGHT:
665 *r = screen_desktop_layout.rows - 1 -
666 d % screen_desktop_layout.rows;
667 *c = screen_desktop_layout.columns - 1 -
668 d / screen_desktop_layout.rows;
669 break;
670 }
671 break;
672 }
673 }
674
675 static guint translate_row_col(guint r, guint c)
676 {
677 switch (screen_desktop_layout.orientation) {
678 case OB_ORIENTATION_HORZ:
679 switch (screen_desktop_layout.start_corner) {
680 case OB_CORNER_TOPLEFT:
681 return r % screen_desktop_layout.rows *
682 screen_desktop_layout.columns +
683 c % screen_desktop_layout.columns;
684 case OB_CORNER_BOTTOMLEFT:
685 return (screen_desktop_layout.rows - 1 -
686 r % screen_desktop_layout.rows) *
687 screen_desktop_layout.columns +
688 c % screen_desktop_layout.columns;
689 case OB_CORNER_TOPRIGHT:
690 return r % screen_desktop_layout.rows *
691 screen_desktop_layout.columns +
692 (screen_desktop_layout.columns - 1 -
693 c % screen_desktop_layout.columns);
694 case OB_CORNER_BOTTOMRIGHT:
695 return (screen_desktop_layout.rows - 1 -
696 r % screen_desktop_layout.rows) *
697 screen_desktop_layout.columns +
698 (screen_desktop_layout.columns - 1 -
699 c % screen_desktop_layout.columns);
700 }
701 case OB_ORIENTATION_VERT:
702 switch (screen_desktop_layout.start_corner) {
703 case OB_CORNER_TOPLEFT:
704 return c % screen_desktop_layout.columns *
705 screen_desktop_layout.rows +
706 r % screen_desktop_layout.rows;
707 case OB_CORNER_BOTTOMLEFT:
708 return c % screen_desktop_layout.columns *
709 screen_desktop_layout.rows +
710 (screen_desktop_layout.rows - 1 -
711 r % screen_desktop_layout.rows);
712 case OB_CORNER_TOPRIGHT:
713 return (screen_desktop_layout.columns - 1 -
714 c % screen_desktop_layout.columns) *
715 screen_desktop_layout.rows +
716 r % screen_desktop_layout.rows;
717 case OB_CORNER_BOTTOMRIGHT:
718 return (screen_desktop_layout.columns - 1 -
719 c % screen_desktop_layout.columns) *
720 screen_desktop_layout.rows +
721 (screen_desktop_layout.rows - 1 -
722 r % screen_desktop_layout.rows);
723 }
724 }
725 g_assert_not_reached();
726 return 0;
727 }
728
729 void screen_desktop_popup(guint d, gboolean show)
730 {
731 Rect *a;
732
733 if (!show) {
734 pager_popup_hide(desktop_cycle_popup);
735 } else {
736 a = screen_physical_area_monitor_active();
737 pager_popup_position(desktop_cycle_popup, CenterGravity,
738 a->x + a->width / 2, a->y + a->height / 2);
739 pager_popup_icon_size_multiplier(desktop_cycle_popup,
740 (screen_desktop_layout.columns /
741 screen_desktop_layout.rows) / 2,
742 (screen_desktop_layout.rows/
743 screen_desktop_layout.columns) / 2);
744 pager_popup_max_width(desktop_cycle_popup,
745 MAX(a->width/3, POPUP_WIDTH));
746 pager_popup_show(desktop_cycle_popup, screen_desktop_names[d], d);
747 }
748 }
749
750 guint screen_cycle_desktop(ObDirection dir, gboolean wrap, gboolean linear,
751 gboolean dialog, gboolean done, gboolean cancel)
752 {
753 guint r, c;
754 static guint d = (guint)-1;
755 guint ret, oldd;
756
757 if (d == (guint)-1)
758 d = screen_desktop;
759
760 if ((cancel || done) && dialog)
761 goto show_cycle_dialog;
762
763 oldd = d;
764 get_row_col(d, &r, &c);
765
766 if (linear) {
767 switch (dir) {
768 case OB_DIRECTION_EAST:
769 if (d < screen_num_desktops - 1)
770 ++d;
771 else if (wrap)
772 d = 0;
773 break;
774 case OB_DIRECTION_WEST:
775 if (d > 0)
776 --d;
777 else if (wrap)
778 d = screen_num_desktops - 1;
779 break;
780 default:
781 assert(0);
782 return screen_desktop;
783 }
784 } else {
785 switch (dir) {
786 case OB_DIRECTION_EAST:
787 ++c;
788 if (c >= screen_desktop_layout.columns) {
789 if (wrap)
790 c = 0;
791 else
792 goto show_cycle_dialog;
793 }
794 d = translate_row_col(r, c);
795 if (d >= screen_num_desktops) {
796 if (wrap) {
797 ++c;
798 } else {
799 d = oldd;
800 goto show_cycle_dialog;
801 }
802 }
803 break;
804 case OB_DIRECTION_WEST:
805 --c;
806 if (c >= screen_desktop_layout.columns) {
807 if (wrap)
808 c = screen_desktop_layout.columns - 1;
809 else
810 goto show_cycle_dialog;
811 }
812 d = translate_row_col(r, c);
813 if (d >= screen_num_desktops) {
814 if (wrap) {
815 --c;
816 } else {
817 d = oldd;
818 goto show_cycle_dialog;
819 }
820 }
821 break;
822 case OB_DIRECTION_SOUTH:
823 ++r;
824 if (r >= screen_desktop_layout.rows) {
825 if (wrap)
826 r = 0;
827 else
828 goto show_cycle_dialog;
829 }
830 d = translate_row_col(r, c);
831 if (d >= screen_num_desktops) {
832 if (wrap) {
833 ++r;
834 } else {
835 d = oldd;
836 goto show_cycle_dialog;
837 }
838 }
839 break;
840 case OB_DIRECTION_NORTH:
841 --r;
842 if (r >= screen_desktop_layout.rows) {
843 if (wrap)
844 r = screen_desktop_layout.rows - 1;
845 else
846 goto show_cycle_dialog;
847 }
848 d = translate_row_col(r, c);
849 if (d >= screen_num_desktops) {
850 if (wrap) {
851 --r;
852 } else {
853 d = oldd;
854 goto show_cycle_dialog;
855 }
856 }
857 break;
858 default:
859 assert(0);
860 return d = screen_desktop;
861 }
862
863 d = translate_row_col(r, c);
864 }
865
866 show_cycle_dialog:
867 if (dialog && !cancel && !done) {
868 screen_desktop_popup(d, TRUE);
869 } else
870 screen_desktop_popup(0, FALSE);
871 ret = d;
872
873 if (!dialog || cancel || done)
874 d = (guint)-1;
875
876 return ret;
877 }
878
879 static gboolean screen_validate_layout(ObDesktopLayout *l)
880 {
881 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
882 return FALSE;
883
884 /* fill in a zero rows/columns */
885 if (l->columns == 0) {
886 l->columns = screen_num_desktops / l->rows;
887 if (l->rows * l->columns < screen_num_desktops)
888 l->columns++;
889 if (l->rows * l->columns >= screen_num_desktops + l->columns)
890 l->rows--;
891 } else if (l->rows == 0) {
892 l->rows = screen_num_desktops / l->columns;
893 if (l->columns * l->rows < screen_num_desktops)
894 l->rows++;
895 if (l->columns * l->rows >= screen_num_desktops + l->rows)
896 l->columns--;
897 }
898
899 /* bounds checking */
900 if (l->orientation == OB_ORIENTATION_HORZ) {
901 l->columns = MIN(screen_num_desktops, l->columns);
902 l->rows = MIN(l->rows,
903 (screen_num_desktops + l->columns - 1) / l->columns);
904 l->columns = screen_num_desktops / l->rows +
905 !!(screen_num_desktops % l->rows);
906 } else {
907 l->rows = MIN(screen_num_desktops, l->rows);
908 l->columns = MIN(l->columns,
909 (screen_num_desktops + l->rows - 1) / l->rows);
910 l->rows = screen_num_desktops / l->columns +
911 !!(screen_num_desktops % l->columns);
912 }
913 return TRUE;
914 }
915
916 void screen_update_layout()
917
918 {
919 ObDesktopLayout l;
920 guint32 *data;
921 guint num;
922
923 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
924 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
925 screen_desktop_layout.rows = 1;
926 screen_desktop_layout.columns = screen_num_desktops;
927
928 if (PROP_GETA32(RootWindow(ob_display, ob_screen),
929 net_desktop_layout, cardinal, &data, &num)) {
930 if (num == 3 || num == 4) {
931
932 if (data[0] == prop_atoms.net_wm_orientation_vert)
933 l.orientation = OB_ORIENTATION_VERT;
934 else if (data[0] == prop_atoms.net_wm_orientation_horz)
935 l.orientation = OB_ORIENTATION_HORZ;
936 else
937 return;
938
939 if (num < 4)
940 l.start_corner = OB_CORNER_TOPLEFT;
941 else {
942 if (data[3] == prop_atoms.net_wm_topleft)
943 l.start_corner = OB_CORNER_TOPLEFT;
944 else if (data[3] == prop_atoms.net_wm_topright)
945 l.start_corner = OB_CORNER_TOPRIGHT;
946 else if (data[3] == prop_atoms.net_wm_bottomright)
947 l.start_corner = OB_CORNER_BOTTOMRIGHT;
948 else if (data[3] == prop_atoms.net_wm_bottomleft)
949 l.start_corner = OB_CORNER_BOTTOMLEFT;
950 else
951 return;
952 }
953
954 l.columns = data[1];
955 l.rows = data[2];
956
957 if (screen_validate_layout(&l))
958 screen_desktop_layout = l;
959
960 g_free(data);
961 }
962 }
963 }
964
965 void screen_update_desktop_names()
966 {
967 guint i;
968
969 /* empty the array */
970 g_strfreev(screen_desktop_names);
971 screen_desktop_names = NULL;
972
973 if (PROP_GETSS(RootWindow(ob_display, ob_screen),
974 net_desktop_names, utf8, &screen_desktop_names))
975 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
976 else
977 i = 0;
978 if (i < screen_num_desktops) {
979 GSList *it;
980
981 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
982 screen_num_desktops + 1);
983 screen_desktop_names[screen_num_desktops] = NULL;
984
985 it = g_slist_nth(config_desktops_names, i);
986
987 for (; i < screen_num_desktops; ++i) {
988 if (it && ((char*)it->data)[0]) /* not empty */
989 /* use the names from the config file when possible */
990 screen_desktop_names[i] = g_strdup(it->data);
991 else
992 /* make up a nice name if it's not though */
993 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
994 i + 1);
995 if (it) it = g_slist_next(it);
996 }
997
998 /* if we changed any names, then set the root property so we can
999 all agree on the names */
1000 PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
1001 screen_desktop_names);
1002 }
1003
1004 /* resize the pager for these names */
1005 pager_popup_text_width_to_strings(desktop_cycle_popup,
1006 screen_desktop_names,
1007 screen_num_desktops);
1008 }
1009
1010 void screen_show_desktop(gboolean show, ObClient *show_only)
1011 {
1012 GList *it;
1013
1014 if (show == screen_showing_desktop) return; /* no change */
1015
1016 screen_showing_desktop = show;
1017
1018 if (show) {
1019 /* hide windows bottom to top */
1020 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1021 if (WINDOW_IS_CLIENT(it->data)) {
1022 ObClient *client = it->data;
1023 client_showhide(client);
1024 }
1025 }
1026 }
1027 else {
1028 /* restore windows top to bottom */
1029 for (it = stacking_list; it; it = g_list_next(it)) {
1030 if (WINDOW_IS_CLIENT(it->data)) {
1031 ObClient *client = it->data;
1032 if (client_should_show(client)) {
1033 if (!show_only || client == show_only)
1034 client_show(client);
1035 else
1036 client_iconify(client, TRUE, FALSE, TRUE);
1037 }
1038 }
1039 }
1040 }
1041
1042 if (show) {
1043 /* focus the desktop */
1044 for (it = focus_order; it; it = g_list_next(it)) {
1045 ObClient *c = it->data;
1046 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1047 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1048 client_focus(it->data))
1049 break;
1050 }
1051 }
1052 else if (!show_only) {
1053 ObClient *c;
1054
1055 if ((c = focus_fallback(TRUE, FALSE, TRUE))) {
1056 /* only do the flicker reducing stuff ahead of time if we are going
1057 to call xsetinputfocus on the window ourselves. otherwise there
1058 is no guarantee the window will actually take focus.. */
1059 if (c->can_focus) {
1060 /* reduce flicker by hiliting now rather than waiting for the
1061 server FocusIn event */
1062 frame_adjust_focus(c->frame, TRUE);
1063 }
1064 }
1065 }
1066
1067 show = !!show; /* make it boolean */
1068 PROP_SET32(RootWindow(ob_display, ob_screen),
1069 net_showing_desktop, cardinal, show);
1070 }
1071
1072 void screen_install_colormap(ObClient *client, gboolean install)
1073 {
1074 if (client == NULL || client->colormap == None) {
1075 if (install)
1076 XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1077 else
1078 XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
1079 } else {
1080 xerror_set_ignore(TRUE);
1081 if (install)
1082 XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1083 else
1084 XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
1085 xerror_set_ignore(FALSE);
1086 }
1087 }
1088
1089 static inline void
1090 screen_area_add_strut_left(const StrutPartial *s, const Rect *monitor_area,
1091 gint edge, Strut *ret)
1092 {
1093 if (s->left &&
1094 ((s->left_end <= s->left_start) ||
1095 (RECT_TOP(*monitor_area) < s->left_end &&
1096 RECT_BOTTOM(*monitor_area) > s->left_start)))
1097 ret->left = MAX(ret->left, edge);
1098 }
1099
1100 static inline void
1101 screen_area_add_strut_top(const StrutPartial *s, const Rect *monitor_area,
1102 gint edge, Strut *ret)
1103 {
1104 if (s->top &&
1105 ((s->top_end <= s->top_start) ||
1106 (RECT_LEFT(*monitor_area) < s->top_end &&
1107 RECT_RIGHT(*monitor_area) > s->top_start)))
1108 ret->top = MAX(ret->top, edge);
1109 }
1110
1111 static inline void
1112 screen_area_add_strut_right(const StrutPartial *s, const Rect *monitor_area,
1113 gint edge, Strut *ret)
1114 {
1115 if (s->right &&
1116 ((s->right_end <= s->right_start) ||
1117 (RECT_TOP(*monitor_area) < s->right_end &&
1118 RECT_BOTTOM(*monitor_area) > s->right_start)))
1119 ret->right = MAX(ret->right, edge);
1120 }
1121
1122 static inline void
1123 screen_area_add_strut_bottom(const StrutPartial *s, const Rect *monitor_area,
1124 gint edge, Strut *ret)
1125 {
1126 if (s->bottom &&
1127 ((s->bottom_end <= s->bottom_start) ||
1128 (RECT_LEFT(*monitor_area) < s->bottom_end &&
1129 RECT_RIGHT(*monitor_area) > s->bottom_start)))
1130 ret->bottom = MAX(ret->bottom, edge);
1131 }
1132
1133 void screen_update_areas()
1134 {
1135 guint i, x;
1136 gulong *dims;
1137 GList *it;
1138 gint o;
1139
1140 g_free(monitor_area);
1141 extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
1142
1143 if (area) {
1144 for (i = 0; area[i]; ++i)
1145 g_free(area[i]);
1146 g_free(area);
1147 }
1148
1149 area = g_new(Rect*, screen_num_desktops + 2);
1150 for (i = 0; i < screen_num_desktops + 1; ++i)
1151 area[i] = g_new0(Rect, screen_num_monitors + 1);
1152 area[i] = NULL;
1153
1154 dims = g_new(gulong, 4 * screen_num_desktops);
1155
1156 for (i = 0; i < screen_num_desktops + 1; ++i) {
1157 Strut *struts;
1158 gint l, r, t, b;
1159
1160 struts = g_new0(Strut, screen_num_monitors);
1161
1162 /* calc the xinerama areas */
1163 for (x = 0; x < screen_num_monitors; ++x) {
1164 area[i][x] = monitor_area[x];
1165 if (x == 0) {
1166 l = monitor_area[x].x;
1167 t = monitor_area[x].y;
1168 r = monitor_area[x].x + monitor_area[x].width - 1;
1169 b = monitor_area[x].y + monitor_area[x].height - 1;
1170 } else {
1171 l = MIN(l, monitor_area[x].x);
1172 t = MIN(t, monitor_area[x].y);
1173 r = MAX(r, monitor_area[x].x + monitor_area[x].width - 1);
1174 b = MAX(b, monitor_area[x].y + monitor_area[x].height - 1);
1175 }
1176 }
1177 RECT_SET(area[i][x], l, t, r - l + 1, b - t + 1);
1178
1179 /* apply the struts */
1180
1181 /* find the left-most xin heads, i do this in 2 loops :| */
1182 o = area[i][0].x;
1183 for (x = 1; x < screen_num_monitors; ++x)
1184 o = MIN(o, area[i][x].x);
1185
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_left(&c->strut,
1190 &monitor_area[x],
1191 o + c->strut.left - area[i][x].x,
1192 &struts[x]);
1193 }
1194 screen_area_add_strut_left(&dock_strut,
1195 &monitor_area[x],
1196 o + dock_strut.left - area[i][x].x,
1197 &struts[x]);
1198
1199 area[i][x].x += struts[x].left;
1200 area[i][x].width -= struts[x].left;
1201 }
1202
1203 /* find the top-most xin heads, i do this in 2 loops :| */
1204 o = area[i][0].y;
1205 for (x = 1; x < screen_num_monitors; ++x)
1206 o = MIN(o, area[i][x].y);
1207
1208 for (x = 0; x < screen_num_monitors; ++x) {
1209 for (it = client_list; it; it = g_list_next(it)) {
1210 ObClient *c = it->data;
1211 screen_area_add_strut_top(&c->strut,
1212 &monitor_area[x],
1213 o + c->strut.top - area[i][x].y,
1214 &struts[x]);
1215 }
1216 screen_area_add_strut_top(&dock_strut,
1217 &monitor_area[x],
1218 o + dock_strut.top - area[i][x].y,
1219 &struts[x]);
1220
1221 area[i][x].y += struts[x].top;
1222 area[i][x].height -= struts[x].top;
1223 }
1224
1225 /* find the right-most xin heads, i do this in 2 loops :| */
1226 o = area[i][0].x + area[i][0].width - 1;
1227 for (x = 1; x < screen_num_monitors; ++x)
1228 o = MAX(o, area[i][x].x + area[i][x].width - 1);
1229
1230 for (x = 0; x < screen_num_monitors; ++x) {
1231 for (it = client_list; it; it = g_list_next(it)) {
1232 ObClient *c = it->data;
1233 screen_area_add_strut_right(&c->strut,
1234 &monitor_area[x],
1235 (area[i][x].x +
1236 area[i][x].width - 1) -
1237 (o - c->strut.right),
1238 &struts[x]);
1239 }
1240 screen_area_add_strut_right(&dock_strut,
1241 &monitor_area[x],
1242 (area[i][x].x +
1243 area[i][x].width - 1) -
1244 (o - dock_strut.right),
1245 &struts[x]);
1246
1247 area[i][x].width -= struts[x].right;
1248 }
1249
1250 /* find the bottom-most xin heads, i do this in 2 loops :| */
1251 o = area[i][0].y + area[i][0].height - 1;
1252 for (x = 1; x < screen_num_monitors; ++x)
1253 o = MAX(o, area[i][x].y + area[i][x].height - 1);
1254
1255 for (x = 0; x < screen_num_monitors; ++x) {
1256 for (it = client_list; it; it = g_list_next(it)) {
1257 ObClient *c = it->data;
1258 screen_area_add_strut_bottom(&c->strut,
1259 &monitor_area[x],
1260 (area[i][x].y +
1261 area[i][x].height - 1) - \
1262 (o - c->strut.bottom),
1263 &struts[x]);
1264 }
1265 screen_area_add_strut_bottom(&dock_strut,
1266 &monitor_area[x],
1267 (area[i][x].y +
1268 area[i][x].height - 1) - \
1269 (o - dock_strut.bottom),
1270 &struts[x]);
1271
1272 area[i][x].height -= struts[x].bottom;
1273 }
1274
1275 l = RECT_LEFT(area[i][0]);
1276 t = RECT_TOP(area[i][0]);
1277 r = RECT_RIGHT(area[i][0]);
1278 b = RECT_BOTTOM(area[i][0]);
1279 for (x = 1; x < screen_num_monitors; ++x) {
1280 l = MIN(l, RECT_LEFT(area[i][x]));
1281 t = MIN(l, RECT_TOP(area[i][x]));
1282 r = MAX(r, RECT_RIGHT(area[i][x]));
1283 b = MAX(b, RECT_BOTTOM(area[i][x]));
1284 }
1285 RECT_SET(area[i][screen_num_monitors], l, t,
1286 r - l + 1, b - t + 1);
1287
1288 /* XXX optimize when this is run? */
1289
1290 /* the area has changed, adjust all the maximized
1291 windows */
1292 for (it = client_list; it; it = g_list_next(it)) {
1293 ObClient *c = it->data;
1294 if (i < screen_num_desktops) {
1295 if (c->desktop == i)
1296 client_reconfigure(c);
1297 } else if (c->desktop == DESKTOP_ALL)
1298 client_reconfigure(c);
1299 }
1300 if (i < screen_num_desktops) {
1301 /* don't set these for the 'all desktops' area */
1302 dims[(i * 4) + 0] = area[i][screen_num_monitors].x;
1303 dims[(i * 4) + 1] = area[i][screen_num_monitors].y;
1304 dims[(i * 4) + 2] = area[i][screen_num_monitors].width;
1305 dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
1306 }
1307
1308 g_free(struts);
1309 }
1310
1311 PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
1312 dims, 4 * screen_num_desktops);
1313
1314 g_free(dims);
1315 }
1316
1317 Rect *screen_area(guint desktop)
1318 {
1319 return screen_area_monitor(desktop, screen_num_monitors);
1320 }
1321
1322 Rect *screen_area_monitor(guint desktop, guint head)
1323 {
1324 if (head > screen_num_monitors)
1325 return NULL;
1326 if (desktop >= screen_num_desktops) {
1327 if (desktop == DESKTOP_ALL)
1328 return &area[screen_num_desktops][head];
1329 return NULL;
1330 }
1331 return &area[desktop][head];
1332 }
1333
1334 guint screen_find_monitor(Rect *search)
1335 {
1336 guint i;
1337 guint most = 0;
1338 guint mostv = 0;
1339
1340 for (i = 0; i < screen_num_monitors; ++i) {
1341 Rect *area = screen_physical_area_monitor(i);
1342 if (RECT_INTERSECTS_RECT(*area, *search)) {
1343 Rect r;
1344 guint v;
1345
1346 RECT_SET_INTERSECTION(r, *area, *search);
1347 v = r.width * r.height;
1348
1349 if (v > mostv) {
1350 mostv = v;
1351 most = i;
1352 }
1353 }
1354 }
1355 return most;
1356 }
1357
1358 Rect *screen_physical_area()
1359 {
1360 return screen_physical_area_monitor(screen_num_monitors);
1361 }
1362
1363 Rect *screen_physical_area_monitor(guint head)
1364 {
1365 if (head > screen_num_monitors)
1366 return NULL;
1367 return &monitor_area[head];
1368 }
1369
1370 Rect *screen_physical_area_monitor_active()
1371 {
1372 Rect *a;
1373 gint x, y;
1374
1375 if (focus_client)
1376 a = screen_physical_area_monitor(client_monitor(focus_client));
1377 else {
1378 Rect mon;
1379 if (screen_pointer_pos(&x, &y))
1380 RECT_SET(mon, x, y, 1, 1);
1381 else
1382 RECT_SET(mon, 0, 0, 1, 1);
1383 a = screen_physical_area_monitor(screen_find_monitor(&mon));
1384 }
1385 return a;
1386 }
1387
1388 void screen_set_root_cursor()
1389 {
1390 if (sn_app_starting())
1391 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1392 ob_cursor(OB_CURSOR_BUSYPOINTER));
1393 else
1394 XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
1395 ob_cursor(OB_CURSOR_POINTER));
1396 }
1397
1398 gboolean screen_pointer_pos(gint *x, gint *y)
1399 {
1400 Window w;
1401 gint i;
1402 guint u;
1403 gboolean ret;
1404
1405 ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
1406 &w, &w, x, y, &i, &i, &u);
1407 if (!ret) {
1408 for (i = 0; i < ScreenCount(ob_display); ++i)
1409 if (i != ob_screen)
1410 if (XQueryPointer(ob_display, RootWindow(ob_display, i),
1411 &w, &w, x, y, &i, &i, &u))
1412 break;
1413 }
1414 return ret;
1415 }
my patches for the openbox window manager
This page took 0.088351 seconds and 3 git commands to generate.