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


f7d39fb59990b2d768899131271a6bc03e9d12de
[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 "grab.h"
24 #include "startupnotify.h"
25 #include "moveresize.h"
26 #include "config.h"
27 #include "screen.h"
28 #include "client.h"
29 #include "session.h"
30 #include "frame.h"
31 #include "event.h"
32 #include "focus.h"
33 #include "focus_cycle.h"
34 #include "popup.h"
35 #include "version.h"
36 #include "obrender/render.h"
37 #include "gettext.h"
38 #include "obt/display.h"
39 #include "obt/xqueue.h"
40 #include "obt/prop.h"
41
42 #include <X11/Xlib.h>
43 #ifdef HAVE_UNISTD_H
44 # include <sys/types.h>
45 # include <unistd.h>
46 #endif
47 #include <assert.h>
48
49 /*! The event mask to grab on the root window */
50 #define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
51 EnterWindowMask | LeaveWindowMask | \
52 SubstructureRedirectMask | FocusChangeMask | \
53 ButtonPressMask | ButtonReleaseMask)
54
55 static gboolean screen_validate_layout(ObDesktopLayout *l);
56 static gboolean replace_wm(void);
57 static void screen_tell_ksplash(void);
58 static void screen_fallback_focus(void);
59
60 guint screen_num_desktops;
61 guint screen_num_monitors;
62 guint screen_desktop;
63 guint screen_last_desktop;
64 gboolean screen_showing_desktop;
65 ObDesktopLayout screen_desktop_layout;
66 gchar **screen_desktop_names;
67 Window screen_support_win;
68 Time screen_desktop_user_time = CurrentTime;
69
70 static Size screen_physical_size;
71 static guint screen_old_desktop;
72 static gboolean screen_desktop_timeout = TRUE;
73 static guint screen_desktop_timer = 0;
74 /*! An array of desktops, holding an array of areas per monitor */
75 static Rect *monitor_area = NULL;
76 /*! An array of desktops, holding an array of struts */
77 static GSList *struts_top = NULL;
78 static GSList *struts_left = NULL;
79 static GSList *struts_right = NULL;
80 static GSList *struts_bottom = NULL;
81
82 static ObPagerPopup *desktop_popup;
83 static guint desktop_popup_timer = 0;
84 static gboolean desktop_popup_perm;
85
86 /*! The number of microseconds that you need to be on a desktop before it will
87 replace the remembered "last desktop" */
88 #define REMEMBER_LAST_DESKTOP_TIME 750
89
90 static gboolean replace_wm(void)
91 {
92 gchar *wm_sn;
93 Atom wm_sn_atom;
94 Window current_wm_sn_owner;
95 Time timestamp;
96
97 wm_sn = g_strdup_printf("WM_S%d", ob_screen);
98 wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
99 g_free(wm_sn);
100
101 current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
102 if (current_wm_sn_owner == screen_support_win)
103 current_wm_sn_owner = None;
104 if (current_wm_sn_owner) {
105 if (!ob_replace_wm) {
106 g_message(_("A window manager is already running on screen %d"),
107 ob_screen);
108 return FALSE;
109 }
110 obt_display_ignore_errors(TRUE);
111
112 /* We want to find out when the current selection owner dies */
113 XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
114 XSync(obt_display, FALSE);
115
116 obt_display_ignore_errors(FALSE);
117 if (obt_display_error_occured)
118 current_wm_sn_owner = None;
119 }
120
121 timestamp = event_time();
122
123 XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
124 timestamp);
125
126 if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
127 g_message(_("Could not acquire window manager selection on screen %d"),
128 ob_screen);
129 return FALSE;
130 }
131
132 /* Wait for old window manager to go away */
133 if (current_wm_sn_owner) {
134 gulong wait = 0;
135 const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
136 ObtXQueueWindowType wt;
137
138 wt.window = current_wm_sn_owner;
139 wt.type = DestroyNotify;
140
141 while (wait < timeout) {
142 /* Checks the local queue and incoming events for this event */
143 if (xqueue_exists_local(xqueue_match_window_type, &wt))
144 break;
145 g_usleep(G_USEC_PER_SEC / 10);
146 wait += G_USEC_PER_SEC / 10;
147 }
148
149 if (wait >= timeout) {
150 g_message(_("The WM on screen %d is not exiting"), ob_screen);
151 return FALSE;
152 }
153 }
154
155 /* Send client message indicating that we are now the WM */
156 obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
157 timestamp, wm_sn_atom, screen_support_win, 0, 0,
158 SubstructureNotifyMask);
159
160 return TRUE;
161 }
162
163 gboolean screen_annex(void)
164 {
165 XSetWindowAttributes attrib;
166 pid_t pid;
167 gint i, num_support;
168 gulong *supported;
169
170 /* create the netwm support window */
171 attrib.override_redirect = TRUE;
172 attrib.event_mask = PropertyChangeMask;
173 screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
174 -100, -100, 1, 1, 0,
175 CopyFromParent, InputOutput,
176 CopyFromParent,
177 CWEventMask | CWOverrideRedirect,
178 &attrib);
179 XMapWindow(obt_display, screen_support_win);
180 XLowerWindow(obt_display, screen_support_win);
181
182 if (!replace_wm()) {
183 XDestroyWindow(obt_display, screen_support_win);
184 return FALSE;
185 }
186
187 obt_display_ignore_errors(TRUE);
188 XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
189 obt_display_ignore_errors(FALSE);
190 if (obt_display_error_occured) {
191 g_message(_("A window manager is already running on screen %d"),
192 ob_screen);
193
194 XDestroyWindow(obt_display, screen_support_win);
195 return FALSE;
196 }
197
198 screen_set_root_cursor();
199
200 /* set the OPENBOX_PID hint */
201 pid = getpid();
202 OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
203
204 /* set supporting window */
205 OBT_PROP_SET32(obt_root(ob_screen),
206 NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
207
208 /* set properties on the supporting window */
209 OBT_PROP_SETS(screen_support_win, NET_WM_NAME, "Openbox");
210 OBT_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 ObtPropAtoms enum */
216 num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
217 i = 0;
218 supported = g_new(gulong, num_support);
219 supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
220 supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
221 supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
222 supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
223 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
224 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
225 supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
226 supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
227 supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
228 supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
229 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
230 supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
231 supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
232 supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
233 supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
234 supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
235 supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
236 supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
237 supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
238 supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
239 supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
240 supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
241 supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
242 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
243 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
244 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
245 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
246 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
247 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
248 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
249 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
250 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
251 supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
252 supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_OPACITY);
253 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
254 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
255 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
256 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
257 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
258 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
259 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
260 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
261 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
262 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
263 supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
264 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
265 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
266 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
267 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
268 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
269 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
270 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
271 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
272 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
273 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
274 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
275 supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
276 supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
277 supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
278 supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
279 /*
280 supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
281 */
282 supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
283 supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
284 supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
285 supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
286 #ifdef SYNC
287 supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
288 supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
289 #endif
290 supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
291 supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
292
293 supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
294 supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
295 supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
296
297 supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
298 supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
299 supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
300 supported[i++] = OBT_PROP_ATOM(OB_THEME);
301 supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
302 supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
303 supported[i++] = OBT_PROP_ATOM(OB_VERSION);
304 supported[i++] = OBT_PROP_ATOM(OB_APP_ROLE);
305 supported[i++] = OBT_PROP_ATOM(OB_APP_TITLE);
306 supported[i++] = OBT_PROP_ATOM(OB_APP_NAME);
307 supported[i++] = OBT_PROP_ATOM(OB_APP_CLASS);
308 supported[i++] = OBT_PROP_ATOM(OB_APP_TYPE);
309 g_assert(i == num_support);
310
311 OBT_PROP_SETA32(obt_root(ob_screen),
312 NET_SUPPORTED, ATOM, supported, num_support);
313 g_free(supported);
314
315 OBT_PROP_SETS(RootWindow(obt_display, ob_screen), OB_VERSION,
316 OPENBOX_VERSION);
317
318 screen_tell_ksplash();
319
320 return TRUE;
321 }
322
323 static void screen_tell_ksplash(void)
324 {
325 XEvent e;
326 char **argv;
327
328 argv = g_new(gchar*, 6);
329 argv[0] = g_strdup("dcop");
330 argv[1] = g_strdup("ksplash");
331 argv[2] = g_strdup("ksplash");
332 argv[3] = g_strdup("upAndRunning(QString)");
333 argv[4] = g_strdup("wm started");
334 argv[5] = NULL;
335
336 /* tell ksplash through the dcop server command line interface */
337 g_spawn_async(NULL, argv, NULL,
338 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
339 G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
340 NULL, NULL, NULL, NULL);
341 g_strfreev(argv);
342
343 /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
344 hear it anyways. perhaps it is for old ksplash. or new ksplash. or
345 something. oh well. */
346 e.xclient.type = ClientMessage;
347 e.xclient.display = obt_display;
348 e.xclient.window = obt_root(ob_screen);
349 e.xclient.message_type =
350 XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False);
351 e.xclient.format = 8;
352 strcpy(e.xclient.data.b, "wm started");
353 XSendEvent(obt_display, obt_root(ob_screen),
354 False, SubstructureNotifyMask, &e);
355 }
356
357 void screen_startup(gboolean reconfig)
358 {
359 gchar **names = NULL;
360 guint32 d;
361 gboolean namesexist = FALSE;
362
363 desktop_popup = pager_popup_new();
364 desktop_popup_perm = FALSE;
365 pager_popup_height(desktop_popup, POPUP_HEIGHT);
366
367 if (reconfig) {
368 /* update the pager popup's width */
369 pager_popup_text_width_to_strings(desktop_popup,
370 screen_desktop_names,
371 screen_num_desktops);
372 return;
373 }
374
375 /* get the initial size */
376 screen_resize();
377
378 /* have names already been set for the desktops? */
379 if (OBT_PROP_GETSS_UTF8(obt_root(ob_screen), NET_DESKTOP_NAMES, &names)) {
380 g_strfreev(names);
381 namesexist = TRUE;
382 }
383
384 /* if names don't exist and we have session names, set those.
385 do this stuff BEFORE setting the number of desktops, because that
386 will create default names for them
387 */
388 if (!namesexist && session_desktop_names != NULL) {
389 guint i, numnames;
390 GSList *it;
391
392 /* get the desktop names */
393 numnames = g_slist_length(session_desktop_names);
394 names = g_new(gchar*, numnames + 1);
395 names[numnames] = NULL;
396 for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
397 names[i] = g_strdup(it->data);
398
399 /* set the root window property */
400 OBT_PROP_SETSS(obt_root(ob_screen),
401 NET_DESKTOP_NAMES, (const gchar*const*)names);
402
403 g_strfreev(names);
404 }
405
406 /* set the number of desktops, if it's not already set.
407
408 this will also set the default names from the config file up for
409 desktops that don't have names yet */
410 screen_num_desktops = 0;
411 if (OBT_PROP_GET32(obt_root(ob_screen),
412 NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
413 {
414 if (d != config_desktops_num) {
415 /* TRANSLATORS: If you need to specify a different order of the
416 arguments, you can use %1$d for the first one and %2$d for the
417 second one. For example,
418 "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */
419 g_warning(ngettext("Openbox is configured for %d desktop, but the current session has %d. Overriding the Openbox configuration.", "Openbox is configured for %d desktops, but the current session has %d. Overriding the Openbox configuration.", config_desktops_num),
420 config_desktops_num, d);
421 }
422 screen_set_num_desktops(d);
423 }
424 /* restore from session if possible */
425 else if (session_num_desktops)
426 screen_set_num_desktops(session_num_desktops);
427 else
428 screen_set_num_desktops(config_desktops_num);
429
430 screen_desktop = screen_num_desktops; /* something invalid */
431 /* start on the current desktop when a wm was already running */
432 if (OBT_PROP_GET32(obt_root(ob_screen),
433 NET_CURRENT_DESKTOP, CARDINAL, &d) &&
434 d < screen_num_desktops)
435 {
436 screen_set_desktop(d, FALSE);
437 } else if (session_desktop >= 0)
438 screen_set_desktop(MIN((guint)session_desktop,
439 screen_num_desktops), FALSE);
440 else
441 screen_set_desktop(MIN(config_screen_firstdesk,
442 screen_num_desktops) - 1, FALSE);
443 screen_last_desktop = screen_desktop;
444
445 /* don't start in showing-desktop mode */
446 screen_showing_desktop = FALSE;
447 OBT_PROP_SET32(obt_root(ob_screen),
448 NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
449
450 if (session_desktop_layout_present &&
451 screen_validate_layout(&session_desktop_layout))
452 {
453 screen_desktop_layout = session_desktop_layout;
454 }
455 else
456 screen_update_layout();
457 }
458
459 void screen_shutdown(gboolean reconfig)
460 {
461 pager_popup_free(desktop_popup);
462
463 if (reconfig)
464 return;
465
466 XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
467
468 /* we're not running here no more! */
469 OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
470 /* not without us */
471 OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
472 /* don't keep this mode */
473 OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
474
475 XDestroyWindow(obt_display, screen_support_win);
476
477 g_strfreev(screen_desktop_names);
478 screen_desktop_names = NULL;
479 }
480
481 void screen_resize(void)
482 {
483 static gint oldw = 0, oldh = 0;
484 gint w, h;
485 GList *it;
486 gulong geometry[2];
487
488 w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
489 h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
490
491 if (w == oldw && h == oldh) return;
492
493 oldw = w; oldh = h;
494
495 /* Set the _NET_DESKTOP_GEOMETRY hint */
496 screen_physical_size.width = geometry[0] = w;
497 screen_physical_size.height = geometry[1] = h;
498 OBT_PROP_SETA32(obt_root(ob_screen),
499 NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
500
501 if (ob_state() != OB_STATE_RUNNING)
502 return;
503
504 /* this calls screen_update_areas(), which we need ! */
505 dock_configure();
506
507 if (oldw)
508 for (it = client_list; it; it = g_list_next(it))
509 client_move_onscreen(it->data, FALSE);
510 }
511
512 void screen_set_num_desktops(guint num)
513 {
514 gulong *viewport;
515 GList *it, *stacking_copy;
516
517 g_assert(num > 0);
518
519 if (screen_num_desktops == num) return;
520
521 screen_num_desktops = num;
522 OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
523
524 /* set the viewport hint */
525 viewport = g_new0(gulong, num * 2);
526 OBT_PROP_SETA32(obt_root(ob_screen),
527 NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
528 g_free(viewport);
529
530 /* the number of rows/columns will differ */
531 screen_update_layout();
532
533 /* move windows on desktops that will no longer exist!
534 make a copy of the list cuz we're changing it */
535 stacking_copy = g_list_copy(stacking_list);
536 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
537 if (WINDOW_IS_CLIENT(it->data)) {
538 ObClient *c = it->data;
539 if (c->desktop != DESKTOP_ALL && c->desktop >= num)
540 client_set_desktop(c, num - 1, FALSE, TRUE);
541 /* raise all the windows that are on the current desktop which
542 is being merged */
543 else if (screen_desktop == num - 1 &&
544 (c->desktop == DESKTOP_ALL ||
545 c->desktop == screen_desktop))
546 stacking_raise(CLIENT_AS_WINDOW(c));
547 }
548 }
549 g_list_free(stacking_copy);
550
551 /* change our struts/area to match (after moving windows) */
552 screen_update_areas();
553
554 /* may be some unnamed desktops that we need to fill in with names
555 (after updating the areas so the popup can resize) */
556 screen_update_desktop_names();
557
558 /* change our desktop if we're on one that no longer exists! */
559 if (screen_desktop >= screen_num_desktops)
560 screen_set_desktop(num - 1, TRUE);
561 }
562
563 static void screen_fallback_focus(void)
564 {
565 ObClient *c;
566 gboolean allow_omni;
567
568 /* only allow omnipresent windows to get focus on desktop change if
569 an omnipresent window is already focused (it'll keep focus probably, but
570 maybe not depending on mouse-focus options) */
571 allow_omni = focus_client && (client_normal(focus_client) &&
572 focus_client->desktop == DESKTOP_ALL);
573
574 /* the client moved there already so don't move focus. prevent flicker
575 on sendtodesktop + follow */
576 if (focus_client && focus_client->desktop == screen_desktop)
577 return;
578
579 /* have to try focus here because when you leave an empty desktop
580 there is no focus out to watch for. also, we have different rules
581 here. we always allow it to look under the mouse pointer if
582 config_focus_last is FALSE
583
584 do this before hiding the windows so if helper windows are coming
585 with us, they don't get hidden
586 */
587 if ((c = focus_fallback(TRUE, !config_focus_last, allow_omni,
588 !allow_omni)))
589 {
590 /* only do the flicker reducing stuff ahead of time if we are going
591 to call xsetinputfocus on the window ourselves. otherwise there is
592 no guarantee the window will actually take focus.. */
593 if (c->can_focus) {
594 /* reduce flicker by hiliting now rather than waiting for the
595 server FocusIn event */
596 frame_adjust_focus(c->frame, TRUE);
597 /* do this here so that if you switch desktops to a window with
598 helper windows then the helper windows won't flash */
599 client_bring_helper_windows(c);
600 }
601 }
602 }
603
604 static gboolean last_desktop_func(gpointer data)
605 {
606 screen_desktop_timeout = TRUE;
607 screen_desktop_timer = 0;
608 return FALSE; /* don't repeat */
609 }
610
611 void screen_set_desktop(guint num, gboolean dofocus)
612 {
613 GList *it;
614 guint previous;
615 gulong ignore_start;
616
617 g_assert(num < screen_num_desktops);
618
619 previous = screen_desktop;
620 screen_desktop = num;
621
622 if (previous == num) return;
623
624 OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
625
626 /* This whole thing decides when/how to save the screen_last_desktop so
627 that it can be restored later if you want */
628 if (screen_desktop_timeout) {
629 /* If screen_desktop_timeout is true, then we've been on this desktop
630 long enough and we can save it as the last desktop. */
631
632 if (screen_last_desktop == previous)
633 /* this is the startup state only */
634 screen_old_desktop = screen_desktop;
635 else {
636 /* save the "last desktop" as the "old desktop" */
637 screen_old_desktop = screen_last_desktop;
638 /* save the desktop we're coming from as the "last desktop" */
639 screen_last_desktop = previous;
640 }
641 }
642 else {
643 /* If screen_desktop_timeout is false, then we just got to this desktop
644 and we are moving away again. */
645
646 if (screen_desktop == screen_last_desktop) {
647 /* If we are moving to the "last desktop" .. */
648 if (previous == screen_old_desktop) {
649 /* .. from the "old desktop", change the last desktop to
650 be where we are coming from */
651 screen_last_desktop = screen_old_desktop;
652 }
653 else if (screen_last_desktop == screen_old_desktop) {
654 /* .. and also to the "old desktop", change the "last
655 desktop" to be where we are coming from */
656 screen_last_desktop = previous;
657 }
658 else {
659 /* .. from some other desktop, then set the "last desktop" to
660 be the saved "old desktop", i.e. where we were before the
661 "last desktop" */
662 screen_last_desktop = screen_old_desktop;
663 }
664 }
665 else {
666 /* If we are moving to any desktop besides the "last desktop"..
667 (this is the normal case) */
668 if (screen_desktop == screen_old_desktop) {
669 /* If moving to the "old desktop", which is not the
670 "last desktop", don't save anything */
671 }
672 else if (previous == screen_old_desktop) {
673 /* If moving from the "old desktop", and not to the
674 "last desktop", don't save anything */
675 }
676 else if (screen_last_desktop == screen_old_desktop) {
677 /* If the "last desktop" is the same as "old desktop" and
678 you're not moving to the "last desktop" then save where
679 we're coming from as the "last desktop" */
680 screen_last_desktop = previous;
681 }
682 else {
683 /* If the "last desktop" is different from the "old desktop"
684 and you're not moving to the "last desktop", then don't save
685 anything */
686 }
687 }
688 }
689 screen_desktop_timeout = FALSE;
690 if (screen_desktop_timer) g_source_remove(screen_desktop_timer);
691 screen_desktop_timer = g_timeout_add(REMEMBER_LAST_DESKTOP_TIME,
692 last_desktop_func, NULL);
693
694 ob_debug("Moving to desktop %d", num+1);
695
696 if (ob_state() == OB_STATE_RUNNING)
697 screen_show_desktop_popup(screen_desktop, FALSE);
698
699 /* ignore enter events caused by the move */
700 ignore_start = event_start_ignore_all_enters();
701
702 if (moveresize_client)
703 client_set_desktop(moveresize_client, num, TRUE, FALSE);
704
705 /* show windows before hiding the rest to lessen the enter/leave events */
706
707 /* show windows from top to bottom */
708 for (it = stacking_list; it; it = g_list_next(it)) {
709 if (WINDOW_IS_CLIENT(it->data)) {
710 ObClient *c = it->data;
711 client_show(c);
712 }
713 }
714
715 if (dofocus) screen_fallback_focus();
716
717 /* hide windows from bottom to top */
718 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
719 if (WINDOW_IS_CLIENT(it->data)) {
720 ObClient *c = it->data;
721 if (client_hide(c)) {
722 if (c == focus_client) {
723 /* c was focused and we didn't do fallback clearly so make
724 sure openbox doesnt still consider the window focused.
725 this happens when using NextWindow with allDesktops,
726 since it doesnt want to move focus on desktop change,
727 but the focus is not going to stay with the current
728 window, which has now disappeared.
729 only do this if the client was actually hidden,
730 otherwise it can keep focus. */
731 focus_set_client(NULL);
732 }
733 }
734 }
735 }
736
737 focus_cycle_addremove(NULL, TRUE);
738
739 event_end_ignore_all_enters(ignore_start);
740
741 if (event_source_time() != CurrentTime)
742 screen_desktop_user_time = event_source_time();
743 }
744
745 void screen_add_desktop(gboolean current)
746 {
747 gulong ignore_start;
748
749 /* ignore enter events caused by this */
750 ignore_start = event_start_ignore_all_enters();
751
752 screen_set_num_desktops(screen_num_desktops+1);
753
754 /* move all the clients over */
755 if (current) {
756 GList *it;
757
758 for (it = client_list; it; it = g_list_next(it)) {
759 ObClient *c = it->data;
760 if (c->desktop != DESKTOP_ALL && c->desktop >= screen_desktop &&
761 /* don't move direct children, they'll be moved with their
762 parent - which will have to be on the same desktop */
763 !client_direct_parent(c))
764 {
765 ob_debug("moving window %s", c->title);
766 client_set_desktop(c, c->desktop+1, FALSE, TRUE);
767 }
768 }
769 }
770
771 event_end_ignore_all_enters(ignore_start);
772 }
773
774 void screen_remove_desktop(gboolean current)
775 {
776 guint rmdesktop, movedesktop;
777 GList *it, *stacking_copy;
778 gulong ignore_start;
779
780 if (screen_num_desktops <= 1) return;
781
782 /* ignore enter events caused by this */
783 ignore_start = event_start_ignore_all_enters();
784
785 /* what desktop are we removing and moving to? */
786 if (current)
787 rmdesktop = screen_desktop;
788 else
789 rmdesktop = screen_num_desktops - 1;
790 if (rmdesktop < screen_num_desktops - 1)
791 movedesktop = rmdesktop + 1;
792 else
793 movedesktop = rmdesktop;
794
795 /* make a copy of the list cuz we're changing it */
796 stacking_copy = g_list_copy(stacking_list);
797 for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
798 if (WINDOW_IS_CLIENT(it->data)) {
799 ObClient *c = it->data;
800 guint d = c->desktop;
801 if (d != DESKTOP_ALL && d >= movedesktop &&
802 /* don't move direct children, they'll be moved with their
803 parent - which will have to be on the same desktop */
804 !client_direct_parent(c))
805 {
806 ob_debug("moving window %s", c->title);
807 client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
808 }
809 /* raise all the windows that are on the current desktop which
810 is being merged */
811 if ((screen_desktop == rmdesktop - 1 ||
812 screen_desktop == rmdesktop) &&
813 (d == DESKTOP_ALL || d == screen_desktop))
814 {
815 stacking_raise(CLIENT_AS_WINDOW(c));
816 ob_debug("raising window %s", c->title);
817 }
818 }
819 }
820 g_list_free(stacking_copy);
821
822 /* fallback focus like we're changing desktops */
823 if (screen_desktop < screen_num_desktops - 1) {
824 screen_fallback_focus();
825 ob_debug("fake desktop change");
826 }
827
828 screen_set_num_desktops(screen_num_desktops-1);
829
830 event_end_ignore_all_enters(ignore_start);
831 }
832
833 static void get_row_col(guint d, guint *r, guint *c)
834 {
835 switch (screen_desktop_layout.orientation) {
836 case OB_ORIENTATION_HORZ:
837 switch (screen_desktop_layout.start_corner) {
838 case OB_CORNER_TOPLEFT:
839 *r = d / screen_desktop_layout.columns;
840 *c = d % screen_desktop_layout.columns;
841 break;
842 case OB_CORNER_BOTTOMLEFT:
843 *r = screen_desktop_layout.rows - 1 -
844 d / screen_desktop_layout.columns;
845 *c = d % screen_desktop_layout.columns;
846 break;
847 case OB_CORNER_TOPRIGHT:
848 *r = d / screen_desktop_layout.columns;
849 *c = screen_desktop_layout.columns - 1 -
850 d % screen_desktop_layout.columns;
851 break;
852 case OB_CORNER_BOTTOMRIGHT:
853 *r = screen_desktop_layout.rows - 1 -
854 d / screen_desktop_layout.columns;
855 *c = screen_desktop_layout.columns - 1 -
856 d % screen_desktop_layout.columns;
857 break;
858 }
859 break;
860 case OB_ORIENTATION_VERT:
861 switch (screen_desktop_layout.start_corner) {
862 case OB_CORNER_TOPLEFT:
863 *r = d % screen_desktop_layout.rows;
864 *c = d / screen_desktop_layout.rows;
865 break;
866 case OB_CORNER_BOTTOMLEFT:
867 *r = screen_desktop_layout.rows - 1 -
868 d % screen_desktop_layout.rows;
869 *c = d / screen_desktop_layout.rows;
870 break;
871 case OB_CORNER_TOPRIGHT:
872 *r = d % screen_desktop_layout.rows;
873 *c = screen_desktop_layout.columns - 1 -
874 d / screen_desktop_layout.rows;
875 break;
876 case OB_CORNER_BOTTOMRIGHT:
877 *r = screen_desktop_layout.rows - 1 -
878 d % screen_desktop_layout.rows;
879 *c = screen_desktop_layout.columns - 1 -
880 d / screen_desktop_layout.rows;
881 break;
882 }
883 break;
884 }
885 }
886
887 static guint translate_row_col(guint r, guint c)
888 {
889 switch (screen_desktop_layout.orientation) {
890 case OB_ORIENTATION_HORZ:
891 switch (screen_desktop_layout.start_corner) {
892 case OB_CORNER_TOPLEFT:
893 return r % screen_desktop_layout.rows *
894 screen_desktop_layout.columns +
895 c % screen_desktop_layout.columns;
896 case OB_CORNER_BOTTOMLEFT:
897 return (screen_desktop_layout.rows - 1 -
898 r % screen_desktop_layout.rows) *
899 screen_desktop_layout.columns +
900 c % screen_desktop_layout.columns;
901 case OB_CORNER_TOPRIGHT:
902 return r % screen_desktop_layout.rows *
903 screen_desktop_layout.columns +
904 (screen_desktop_layout.columns - 1 -
905 c % screen_desktop_layout.columns);
906 case OB_CORNER_BOTTOMRIGHT:
907 return (screen_desktop_layout.rows - 1 -
908 r % screen_desktop_layout.rows) *
909 screen_desktop_layout.columns +
910 (screen_desktop_layout.columns - 1 -
911 c % screen_desktop_layout.columns);
912 }
913 case OB_ORIENTATION_VERT:
914 switch (screen_desktop_layout.start_corner) {
915 case OB_CORNER_TOPLEFT:
916 return c % screen_desktop_layout.columns *
917 screen_desktop_layout.rows +
918 r % screen_desktop_layout.rows;
919 case OB_CORNER_BOTTOMLEFT:
920 return c % screen_desktop_layout.columns *
921 screen_desktop_layout.rows +
922 (screen_desktop_layout.rows - 1 -
923 r % screen_desktop_layout.rows);
924 case OB_CORNER_TOPRIGHT:
925 return (screen_desktop_layout.columns - 1 -
926 c % screen_desktop_layout.columns) *
927 screen_desktop_layout.rows +
928 r % screen_desktop_layout.rows;
929 case OB_CORNER_BOTTOMRIGHT:
930 return (screen_desktop_layout.columns - 1 -
931 c % screen_desktop_layout.columns) *
932 screen_desktop_layout.rows +
933 (screen_desktop_layout.rows - 1 -
934 r % screen_desktop_layout.rows);
935 }
936 }
937 g_assert_not_reached();
938 return 0;
939 }
940
941 static gboolean hide_desktop_popup_func(gpointer data)
942 {
943 pager_popup_hide(desktop_popup);
944 desktop_popup_timer = 0;
945 return FALSE; /* don't repeat */
946 }
947
948 void screen_show_desktop_popup(guint d, gboolean perm)
949 {
950 const Rect *a;
951
952 /* 0 means don't show the popup */
953 if (!config_desktop_popup_time) return;
954
955 a = screen_physical_area_primary(FALSE);
956 pager_popup_position(desktop_popup, CenterGravity,
957 a->x + a->width / 2, a->y + a->height / 2);
958 pager_popup_icon_size_multiplier(desktop_popup,
959 (screen_desktop_layout.columns /
960 screen_desktop_layout.rows) / 2,
961 (screen_desktop_layout.rows/
962 screen_desktop_layout.columns) / 2);
963 pager_popup_max_width(desktop_popup,
964 MAX(a->width/3, POPUP_WIDTH));
965 pager_popup_show(desktop_popup, screen_desktop_names[d], d);
966
967 if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
968 desktop_popup_timer = 0;
969 if (!perm && !desktop_popup_perm)
970 /* only hide if its not already being show permanently */
971 desktop_popup_timer = g_timeout_add(config_desktop_popup_time,
972 hide_desktop_popup_func,
973 desktop_popup);
974 if (perm)
975 desktop_popup_perm = TRUE;
976 }
977
978 void screen_hide_desktop_popup(void)
979 {
980 if (desktop_popup_timer) g_source_remove(desktop_popup_timer);
981 desktop_popup_timer = 0;
982 pager_popup_hide(desktop_popup);
983 desktop_popup_perm = FALSE;
984 }
985
986 guint screen_find_desktop(guint from, ObDirection dir,
987 gboolean wrap, gboolean linear)
988 {
989 guint r, c;
990 guint d;
991
992 d = from;
993 get_row_col(d, &r, &c);
994 if (linear) {
995 switch (dir) {
996 case OB_DIRECTION_EAST:
997 if (d < screen_num_desktops - 1)
998 ++d;
999 else if (wrap)
1000 d = 0;
1001 else
1002 return from;
1003 break;
1004 case OB_DIRECTION_WEST:
1005 if (d > 0)
1006 --d;
1007 else if (wrap)
1008 d = screen_num_desktops - 1;
1009 else
1010 return from;
1011 break;
1012 default:
1013 g_assert_not_reached();
1014 return from;
1015 }
1016 } else {
1017 switch (dir) {
1018 case OB_DIRECTION_EAST:
1019 ++c;
1020 if (c >= screen_desktop_layout.columns) {
1021 if (wrap)
1022 c = 0;
1023 else
1024 return from;
1025 }
1026 d = translate_row_col(r, c);
1027 if (d >= screen_num_desktops) {
1028 if (wrap)
1029 ++c;
1030 else
1031 return from;
1032 }
1033 break;
1034 case OB_DIRECTION_WEST:
1035 --c;
1036 if (c >= screen_desktop_layout.columns) {
1037 if (wrap)
1038 c = screen_desktop_layout.columns - 1;
1039 else
1040 return from;
1041 }
1042 d = translate_row_col(r, c);
1043 if (d >= screen_num_desktops) {
1044 if (wrap)
1045 --c;
1046 else
1047 return from;
1048 }
1049 break;
1050 case OB_DIRECTION_SOUTH:
1051 ++r;
1052 if (r >= screen_desktop_layout.rows) {
1053 if (wrap)
1054 r = 0;
1055 else
1056 return from;
1057 }
1058 d = translate_row_col(r, c);
1059 if (d >= screen_num_desktops) {
1060 if (wrap)
1061 ++r;
1062 else
1063 return from;
1064 }
1065 break;
1066 case OB_DIRECTION_NORTH:
1067 --r;
1068 if (r >= screen_desktop_layout.rows) {
1069 if (wrap)
1070 r = screen_desktop_layout.rows - 1;
1071 else
1072 return from;
1073 }
1074 d = translate_row_col(r, c);
1075 if (d >= screen_num_desktops) {
1076 if (wrap)
1077 --r;
1078 else
1079 return from;
1080 }
1081 break;
1082 default:
1083 g_assert_not_reached();
1084 return from;
1085 }
1086
1087 d = translate_row_col(r, c);
1088 }
1089 return d;
1090 }
1091
1092 static gboolean screen_validate_layout(ObDesktopLayout *l)
1093 {
1094 if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
1095 return FALSE;
1096
1097 /* fill in a zero rows/columns */
1098 if (l->columns == 0) {
1099 l->columns = screen_num_desktops / l->rows;
1100 if (l->rows * l->columns < screen_num_desktops)
1101 l->columns++;
1102 if (l->rows * l->columns >= screen_num_desktops + l->columns)
1103 l->rows--;
1104 } else if (l->rows == 0) {
1105 l->rows = screen_num_desktops / l->columns;
1106 if (l->columns * l->rows < screen_num_desktops)
1107 l->rows++;
1108 if (l->columns * l->rows >= screen_num_desktops + l->rows)
1109 l->columns--;
1110 }
1111
1112 /* bounds checking */
1113 if (l->orientation == OB_ORIENTATION_HORZ) {
1114 l->columns = MIN(screen_num_desktops, l->columns);
1115 l->rows = MIN(l->rows,
1116 (screen_num_desktops + l->columns - 1) / l->columns);
1117 l->columns = screen_num_desktops / l->rows +
1118 !!(screen_num_desktops % l->rows);
1119 } else {
1120 l->rows = MIN(screen_num_desktops, l->rows);
1121 l->columns = MIN(l->columns,
1122 (screen_num_desktops + l->rows - 1) / l->rows);
1123 l->rows = screen_num_desktops / l->columns +
1124 !!(screen_num_desktops % l->columns);
1125 }
1126 return TRUE;
1127 }
1128
1129 void screen_update_layout(void)
1130
1131 {
1132 ObDesktopLayout l;
1133 guint32 *data;
1134 guint num;
1135
1136 screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
1137 screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
1138 screen_desktop_layout.rows = 1;
1139 screen_desktop_layout.columns = screen_num_desktops;
1140
1141 if (OBT_PROP_GETA32(obt_root(ob_screen),
1142 NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
1143 if (num == 3 || num == 4) {
1144
1145 if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
1146 l.orientation = OB_ORIENTATION_VERT;
1147 else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
1148 l.orientation = OB_ORIENTATION_HORZ;
1149 else
1150 return;
1151
1152 if (num < 4)
1153 l.start_corner = OB_CORNER_TOPLEFT;
1154 else {
1155 if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
1156 l.start_corner = OB_CORNER_TOPLEFT;
1157 else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
1158 l.start_corner = OB_CORNER_TOPRIGHT;
1159 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
1160 l.start_corner = OB_CORNER_BOTTOMRIGHT;
1161 else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
1162 l.start_corner = OB_CORNER_BOTTOMLEFT;
1163 else
1164 return;
1165 }
1166
1167 l.columns = data[1];
1168 l.rows = data[2];
1169
1170 if (screen_validate_layout(&l))
1171 screen_desktop_layout = l;
1172
1173 g_free(data);
1174 }
1175 }
1176 }
1177
1178 void screen_update_desktop_names(void)
1179 {
1180 guint i;
1181
1182 /* empty the array */
1183 g_strfreev(screen_desktop_names);
1184 screen_desktop_names = NULL;
1185
1186 if (OBT_PROP_GETSS(obt_root(ob_screen),
1187 NET_DESKTOP_NAMES, &screen_desktop_names))
1188 for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
1189 else
1190 i = 0;
1191 if (i < screen_num_desktops) {
1192 GSList *it;
1193
1194 screen_desktop_names = g_renew(gchar*, screen_desktop_names,
1195 screen_num_desktops + 1);
1196 screen_desktop_names[screen_num_desktops] = NULL;
1197
1198 it = g_slist_nth(config_desktops_names, i);
1199
1200 for (; i < screen_num_desktops; ++i) {
1201 if (it && ((char*)it->data)[0]) /* not empty */
1202 /* use the names from the config file when possible */
1203 screen_desktop_names[i] = g_strdup(it->data);
1204 else
1205 /* make up a nice name if it's not though */
1206 screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
1207 i + 1);
1208 if (it) it = g_slist_next(it);
1209 }
1210
1211 /* if we changed any names, then set the root property so we can
1212 all agree on the names */
1213 OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
1214 (const gchar*const*)screen_desktop_names);
1215 }
1216
1217 /* resize the pager for these names */
1218 pager_popup_text_width_to_strings(desktop_popup,
1219 screen_desktop_names,
1220 screen_num_desktops);
1221 }
1222
1223 void screen_show_desktop(gboolean show, ObClient *show_only)
1224 {
1225 GList *it;
1226
1227 if (show == screen_showing_desktop) return; /* no change */
1228
1229 screen_showing_desktop = show;
1230
1231 if (show) {
1232 /* hide windows bottom to top */
1233 for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
1234 if (WINDOW_IS_CLIENT(it->data)) {
1235 ObClient *client = it->data;
1236 client_showhide(client);
1237 }
1238 }
1239 }
1240 else {
1241 /* restore windows top to bottom */
1242 for (it = stacking_list; it; it = g_list_next(it)) {
1243 if (WINDOW_IS_CLIENT(it->data)) {
1244 ObClient *client = it->data;
1245 if (client_should_show(client)) {
1246 if (!show_only || client == show_only)
1247 client_show(client);
1248 else
1249 client_iconify(client, TRUE, FALSE, TRUE);
1250 }
1251 }
1252 }
1253 }
1254
1255 if (show) {
1256 /* focus the desktop */
1257 for (it = focus_order; it; it = g_list_next(it)) {
1258 ObClient *c = it->data;
1259 if (c->type == OB_CLIENT_TYPE_DESKTOP &&
1260 (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
1261 client_focus(it->data))
1262 break;
1263 }
1264 }
1265 else if (!show_only) {
1266 ObClient *c;
1267
1268 if ((c = focus_fallback(TRUE, FALSE, TRUE, FALSE))) {
1269 /* only do the flicker reducing stuff ahead of time if we are going
1270 to call xsetinputfocus on the window ourselves. otherwise there
1271 is no guarantee the window will actually take focus.. */
1272 if (c->can_focus) {
1273 /* reduce flicker by hiliting now rather than waiting for the
1274 server FocusIn event */
1275 frame_adjust_focus(c->frame, TRUE);
1276 }
1277 }
1278 }
1279
1280 show = !!show; /* make it boolean */
1281 OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
1282 }
1283
1284 void screen_install_colormap(ObClient *client, gboolean install)
1285 {
1286 if (client == NULL || client->colormap == None) {
1287 if (install)
1288 XInstallColormap(obt_display, RrColormap(ob_rr_inst));
1289 else
1290 XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
1291 } else {
1292 obt_display_ignore_errors(TRUE);
1293 if (install)
1294 XInstallColormap(obt_display, client->colormap);
1295 else
1296 XUninstallColormap(obt_display, client->colormap);
1297 obt_display_ignore_errors(FALSE);
1298 }
1299 }
1300
1301 typedef struct {
1302 guint desktop;
1303 StrutPartial *strut;
1304 } ObScreenStrut;
1305
1306 #define RESET_STRUT_LIST(sl) \
1307 while (sl) { \
1308 g_slice_free(ObScreenStrut, (sl)->data); \
1309 sl = g_slist_delete_link(sl, sl); \
1310 }
1311
1312 #define ADD_STRUT_TO_LIST(sl, d, s) \
1313 { \
1314 ObScreenStrut *ss = g_slice_new(ObScreenStrut); \
1315 ss->desktop = d; \
1316 ss->strut = s; \
1317 sl = g_slist_prepend(sl, ss); \
1318 }
1319
1320 #define VALIDATE_STRUTS(sl, side, max) \
1321 { \
1322 GSList *it; \
1323 for (it = sl; it; it = g_slist_next(it)) { \
1324 ObScreenStrut *ss = it->data; \
1325 ss->strut->side = MIN(max, ss->strut->side); \
1326 } \
1327 }
1328
1329 static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
1330 {
1331 guint i;
1332 gint n, l, r, t, b;
1333 #ifdef XINERAMA
1334 XineramaScreenInfo *info;
1335 #endif
1336
1337 if (ob_debug_xinerama) {
1338 gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1339 gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
1340 *nxin = 2;
1341 *xin_areas = g_new(Rect, *nxin + 1);
1342 RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
1343 RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
1344 }
1345 #ifdef XINERAMA
1346 else if (obt_display_extension_xinerama &&
1347 (info = XineramaQueryScreens(obt_display, &n))) {
1348 *nxin = n;
1349 *xin_areas = g_new(Rect, *nxin + 1);
1350 for (i = 0; i < *nxin; ++i)
1351 RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
1352 info[i].width, info[i].height);
1353 XFree(info);
1354 }
1355 #endif
1356 else {
1357 *nxin = 1;
1358 *xin_areas = g_new(Rect, *nxin + 1);
1359 RECT_SET((*xin_areas)[0], 0, 0,
1360 WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
1361 HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
1362 }
1363
1364 /* returns one extra with the total area in it */
1365 l = (*xin_areas)[0].x;
1366 t = (*xin_areas)[0].y;
1367 r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
1368 b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
1369 for (i = 1; i < *nxin; ++i) {
1370 l = MIN(l, (*xin_areas)[i].x);
1371 t = MIN(l, (*xin_areas)[i].y);
1372 r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
1373 b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
1374 }
1375 RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
1376 }
1377
1378 void screen_update_areas(void)
1379 {
1380 guint i;
1381 gulong *dims;
1382 GList *it, *onscreen;
1383
1384 /* collect the clients that are on screen */
1385 onscreen = NULL;
1386 for (it = client_list; it; it = g_list_next(it)) {
1387 if (client_monitor(it->data) != screen_num_monitors)
1388 onscreen = g_list_prepend(onscreen, it->data);
1389 }
1390
1391 g_free(monitor_area);
1392 get_xinerama_screens(&monitor_area, &screen_num_monitors);
1393
1394 /* set up the user-specified margins */
1395 config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1396 config_margins.top_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1397 config_margins.bottom_start = RECT_LEFT(monitor_area[screen_num_monitors]);
1398 config_margins.bottom_end = RECT_RIGHT(monitor_area[screen_num_monitors]);
1399 config_margins.left_start = RECT_TOP(monitor_area[screen_num_monitors]);
1400 config_margins.left_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1401 config_margins.right_start = RECT_TOP(monitor_area[screen_num_monitors]);
1402 config_margins.right_end = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1403
1404 RESET_STRUT_LIST(struts_left);
1405 RESET_STRUT_LIST(struts_top);
1406 RESET_STRUT_LIST(struts_right);
1407 RESET_STRUT_LIST(struts_bottom);
1408
1409 /* collect the struts */
1410 for (it = client_list; it; it = g_list_next(it)) {
1411 ObClient *c = it->data;
1412 if (c->strut.left)
1413 ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
1414 if (c->strut.top)
1415 ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
1416 if (c->strut.right)
1417 ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
1418 if (c->strut.bottom)
1419 ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
1420 }
1421 if (dock_strut.left)
1422 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
1423 if (dock_strut.top)
1424 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
1425 if (dock_strut.right)
1426 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
1427 if (dock_strut.bottom)
1428 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
1429
1430 if (config_margins.left)
1431 ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &config_margins);
1432 if (config_margins.top)
1433 ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &config_margins);
1434 if (config_margins.right)
1435 ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &config_margins);
1436 if (config_margins.bottom)
1437 ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &config_margins);
1438
1439 VALIDATE_STRUTS(struts_left, left,
1440 monitor_area[screen_num_monitors].width / 2);
1441 VALIDATE_STRUTS(struts_right, right,
1442 monitor_area[screen_num_monitors].width / 2);
1443 VALIDATE_STRUTS(struts_top, top,
1444 monitor_area[screen_num_monitors].height / 2);
1445 VALIDATE_STRUTS(struts_bottom, bottom,
1446 monitor_area[screen_num_monitors].height / 2);
1447
1448 dims = g_new(gulong, 4 * screen_num_desktops);
1449 for (i = 0; i < screen_num_desktops; ++i) {
1450 Rect *area = screen_area(i, SCREEN_AREA_ALL_MONITORS, NULL);
1451 dims[i*4+0] = area->x;
1452 dims[i*4+1] = area->y;
1453 dims[i*4+2] = area->width;
1454 dims[i*4+3] = area->height;
1455 g_slice_free(Rect, area);
1456 }
1457
1458 /* set the legacy workarea hint to the union of all the monitors */
1459 OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
1460 dims, 4 * screen_num_desktops);
1461
1462 /* the area has changed, adjust all the windows if they need it */
1463 for (it = onscreen; it; it = g_list_next(it))
1464 client_reconfigure(it->data, FALSE);
1465
1466 g_free(dims);
1467 }
1468
1469 #if 0
1470 Rect* screen_area_all_monitors(guint desktop)
1471 {
1472 guint i;
1473 Rect *a;
1474
1475 a = screen_area_monitor(desktop, 0);
1476
1477 /* combine all the monitors together */
1478 for (i = 1; i < screen_num_monitors; ++i) {
1479 Rect *m = screen_area_monitor(desktop, i);
1480 gint l, r, t, b;
1481
1482 l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
1483 t = MIN(RECT_TOP(*a), RECT_TOP(*m));
1484 r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
1485 b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
1486
1487 RECT_SET(*a, l, t, r - l + 1, b - t + 1);
1488
1489 g_free(m);
1490 }
1491
1492 return a;
1493 }
1494 #endif
1495
1496 #define STRUT_LEFT_IN_SEARCH(s, search) \
1497 (RANGES_INTERSECT(search->y, search->height, \
1498 s->left_start, s->left_end - s->left_start + 1))
1499 #define STRUT_RIGHT_IN_SEARCH(s, search) \
1500 (RANGES_INTERSECT(search->y, search->height, \
1501 s->right_start, s->right_end - s->right_start + 1))
1502 #define STRUT_TOP_IN_SEARCH(s, search) \
1503 (RANGES_INTERSECT(search->x, search->width, \
1504 s->top_start, s->top_end - s->top_start + 1))
1505 #define STRUT_BOTTOM_IN_SEARCH(s, search) \
1506 (RANGES_INTERSECT(search->x, search->width, \
1507 s->bottom_start, s->bottom_end - s->bottom_start + 1))
1508
1509 #define STRUT_LEFT_IGNORE(s, us, search) \
1510 (head == SCREEN_AREA_ALL_MONITORS && us && \
1511 RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
1512 #define STRUT_RIGHT_IGNORE(s, us, search) \
1513 (head == SCREEN_AREA_ALL_MONITORS && us && \
1514 RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
1515 #define STRUT_TOP_IGNORE(s, us, search) \
1516 (head == SCREEN_AREA_ALL_MONITORS && us && \
1517 RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
1518 #define STRUT_BOTTOM_IGNORE(s, us, search) \
1519 (head == SCREEN_AREA_ALL_MONITORS && us && \
1520 RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
1521
1522 Rect* screen_area(guint desktop, guint head, Rect *search)
1523 {
1524 Rect *a;
1525 GSList *it;
1526 gint l, r, t, b;
1527 guint i, d;
1528 gboolean us = search != NULL; /* user provided search */
1529
1530 g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
1531 g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
1532 head == SCREEN_AREA_ALL_MONITORS);
1533 g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
1534
1535 /* find any struts for this monitor
1536 which will be affecting the search area.
1537 */
1538
1539 /* search everything if search is null */
1540 if (!search) {
1541 if (head < screen_num_monitors) search = &monitor_area[head];
1542 else search = &monitor_area[screen_num_monitors];
1543 }
1544 if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
1545
1546 /* al is "all left" meaning the furthest left you can get, l is our
1547 "working left" meaning our current strut edge which we're calculating
1548 */
1549
1550 /* only include monitors which the search area lines up with */
1551 if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
1552 l = RECT_RIGHT(monitor_area[screen_num_monitors]);
1553 t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1554 r = RECT_LEFT(monitor_area[screen_num_monitors]);
1555 b = RECT_TOP(monitor_area[screen_num_monitors]);
1556 for (i = 0; i < screen_num_monitors; ++i) {
1557 /* add the monitor if applicable */
1558 if (RANGES_INTERSECT(search->x, search->width,
1559 monitor_area[i].x, monitor_area[i].width))
1560 {
1561 t = MIN(t, RECT_TOP(monitor_area[i]));
1562 b = MAX(b, RECT_BOTTOM(monitor_area[i]));
1563 }
1564 if (RANGES_INTERSECT(search->y, search->height,
1565 monitor_area[i].y, monitor_area[i].height))
1566 {
1567 l = MIN(l, RECT_LEFT(monitor_area[i]));
1568 r = MAX(r, RECT_RIGHT(monitor_area[i]));
1569 }
1570 }
1571 } else {
1572 l = RECT_LEFT(monitor_area[screen_num_monitors]);
1573 t = RECT_TOP(monitor_area[screen_num_monitors]);
1574 r = RECT_RIGHT(monitor_area[screen_num_monitors]);
1575 b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
1576 }
1577
1578 for (d = 0; d < screen_num_desktops; ++d) {
1579 if (d != desktop && desktop != DESKTOP_ALL) continue;
1580
1581 for (i = 0; i < screen_num_monitors; ++i) {
1582 if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
1583
1584 for (it = struts_left; it; it = g_slist_next(it)) {
1585 ObScreenStrut *s = it->data;
1586 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1587 STRUT_LEFT_IN_SEARCH(s->strut, search) &&
1588 !STRUT_LEFT_IGNORE(s->strut, us, search))
1589 l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors])
1590 + s->strut->left);
1591 }
1592 for (it = struts_top; it; it = g_slist_next(it)) {
1593 ObScreenStrut *s = it->data;
1594 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1595 STRUT_TOP_IN_SEARCH(s->strut, search) &&
1596 !STRUT_TOP_IGNORE(s->strut, us, search))
1597 t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors])
1598 + s->strut->top);
1599 }
1600 for (it = struts_right; it; it = g_slist_next(it)) {
1601 ObScreenStrut *s = it->data;
1602 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1603 STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
1604 !STRUT_RIGHT_IGNORE(s->strut, us, search))
1605 r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors])
1606 - s->strut->right);
1607 }
1608 for (it = struts_bottom; it; it = g_slist_next(it)) {
1609 ObScreenStrut *s = it->data;
1610 if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
1611 STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
1612 !STRUT_BOTTOM_IGNORE(s->strut, us, search))
1613 b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors])
1614 - s->strut->bottom);
1615 }
1616
1617 /* limit to this monitor */
1618 if (head == i) {
1619 l = MAX(l, RECT_LEFT(monitor_area[i]));
1620 t = MAX(t, RECT_TOP(monitor_area[i]));
1621 r = MIN(r, RECT_RIGHT(monitor_area[i]));
1622 b = MIN(b, RECT_BOTTOM(monitor_area[i]));
1623 }
1624 }
1625 }
1626
1627 a = g_slice_new(Rect);
1628 a->x = l;
1629 a->y = t;
1630 a->width = r - l + 1;
1631 a->height = b - t + 1;
1632 return a;
1633 }
1634
1635 guint screen_find_monitor(const Rect *search)
1636 {
1637 guint i;
1638 guint most = screen_num_monitors;
1639 guint mostv = 0;
1640
1641 for (i = 0; i < screen_num_monitors; ++i) {
1642 const Rect *area = screen_physical_area_monitor(i);
1643 if (RECT_INTERSECTS_RECT(*area, *search)) {
1644 Rect r;
1645 guint v;
1646
1647 RECT_SET_INTERSECTION(r, *area, *search);
1648 v = r.width * r.height;
1649
1650 if (v > mostv) {
1651 mostv = v;
1652 most = i;
1653 }
1654 }
1655 }
1656 return most < screen_num_monitors ? most : screen_monitor_primary(FALSE);
1657 }
1658
1659 const Rect* screen_physical_area_all_monitors(void)
1660 {
1661 return screen_physical_area_monitor(screen_num_monitors);
1662 }
1663
1664 const Rect* screen_physical_area_monitor(guint head)
1665 {
1666 g_assert(head <= screen_num_monitors);
1667
1668 return &monitor_area[head];
1669 }
1670
1671 gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
1672 {
1673 g_assert(head <= screen_num_monitors);
1674 g_assert(search);
1675 return RECT_INTERSECTS_RECT(monitor_area[head], *search);
1676 }
1677
1678 guint screen_monitor_active(void)
1679 {
1680 if (moveresize_client)
1681 return client_monitor(moveresize_client);
1682 else if (focus_client)
1683 return client_monitor(focus_client);
1684 else
1685 return screen_monitor_pointer();
1686 }
1687
1688 const Rect* screen_physical_area_active(void)
1689 {
1690 return screen_physical_area_monitor(screen_monitor_active());
1691 }
1692
1693 guint screen_monitor_primary(gboolean fixed)
1694 {
1695 if (config_primary_monitor_index > 0) {
1696 if (config_primary_monitor_index-1 < screen_num_monitors)
1697 return config_primary_monitor_index - 1;
1698 else
1699 return 0;
1700 }
1701 else if (fixed)
1702 return 0;
1703 else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE)
1704 return screen_monitor_active();
1705 else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */
1706 return screen_monitor_pointer();
1707 }
1708
1709 const Rect* screen_physical_area_primary(gboolean fixed)
1710 {
1711 return screen_physical_area_monitor(screen_monitor_primary(fixed));
1712 }
1713
1714 void screen_set_root_cursor(void)
1715 {
1716 if (sn_app_starting())
1717 XDefineCursor(obt_display, obt_root(ob_screen),
1718 ob_cursor(OB_CURSOR_BUSYPOINTER));
1719 else
1720 XDefineCursor(obt_display, obt_root(ob_screen),
1721 ob_cursor(OB_CURSOR_POINTER));
1722 }
1723
1724 guint screen_find_monitor_point(guint x, guint y)
1725 {
1726 Rect mon;
1727 RECT_SET(mon, x, y, 1, 1);
1728 return screen_find_monitor(&mon);
1729 }
1730
1731 guint screen_monitor_pointer()
1732 {
1733 gint x, y;
1734 if (!screen_pointer_pos(&x, &y))
1735 x = y = 0;
1736 return screen_find_monitor_point(x, y);
1737 }
1738
1739 gboolean screen_pointer_pos(gint *x, gint *y)
1740 {
1741 Window w;
1742 gint i;
1743 guint u;
1744 gboolean ret;
1745
1746 ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
1747 &w, &w, x, y, &i, &i, &u);
1748 if (!ret) {
1749 for (i = 0; i < ScreenCount(obt_display); ++i)
1750 if (i != ob_screen)
1751 if (XQueryPointer(obt_display, obt_root(i),
1752 &w, &w, x, y, &i, &i, &u))
1753 break;
1754 }
1755 return ret;
1756 }
1757
1758 gboolean screen_compare_desktops(guint a, guint b)
1759 {
1760 if (a == DESKTOP_ALL)
1761 a = screen_desktop;
1762 if (b == DESKTOP_ALL)
1763 b = screen_desktop;
1764 return a == b;
1765 }
my patches for the openbox window manager
This page took 0.112566 seconds and 4 git commands to generate.