]> Dogcows Code - chaz/openbox/blob - openbox/client.c
add a focus_hilite variable
[chaz/openbox] / openbox / client.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3 client.c for the Openbox window manager
4 Copyright (c) 2003 Ben Jansens
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "client.h"
20 #include "debug.h"
21 #include "startupnotify.h"
22 #include "dock.h"
23 #include "xerror.h"
24 #include "screen.h"
25 #include "moveresize.h"
26 #include "place.h"
27 #include "prop.h"
28 #include "extensions.h"
29 #include "frame.h"
30 #include "session.h"
31 #include "event.h"
32 #include "grab.h"
33 #include "focus.h"
34 #include "stacking.h"
35 #include "openbox.h"
36 #include "group.h"
37 #include "config.h"
38 #include "menuframe.h"
39 #include "keyboard.h"
40 #include "mouse.h"
41 #include "render/render.h"
42
43 #include <glib.h>
44 #include <X11/Xutil.h>
45
46 /*! The event mask to grab on client windows */
47 #define CLIENT_EVENTMASK (PropertyChangeMask | FocusChangeMask | \
48 StructureNotifyMask)
49
50 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
51 ButtonMotionMask)
52
53 typedef struct
54 {
55 ObClientDestructor func;
56 gpointer data;
57 } Destructor;
58
59 GList *client_list = NULL;
60 GSList *client_destructors = NULL;
61
62 static void client_get_all(ObClient *self);
63 static void client_toggle_border(ObClient *self, gboolean show);
64 static void client_get_startup_id(ObClient *self);
65 static void client_get_area(ObClient *self);
66 static void client_get_desktop(ObClient *self);
67 static void client_get_state(ObClient *self);
68 static void client_get_shaped(ObClient *self);
69 static void client_get_mwm_hints(ObClient *self);
70 static void client_get_gravity(ObClient *self);
71 static void client_showhide(ObClient *self);
72 static void client_change_allowed_actions(ObClient *self);
73 static void client_change_state(ObClient *self);
74 static void client_apply_startup_state(ObClient *self);
75 static void client_restore_session_state(ObClient *self);
76 static void client_restore_session_stacking(ObClient *self);
77 static void client_urgent_notify(ObClient *self);
78
79 void client_startup(gboolean reconfig)
80 {
81 if (reconfig) return;
82
83 client_set_list();
84 }
85
86 void client_shutdown(gboolean reconfig)
87 {
88 }
89
90 void client_add_destructor(ObClientDestructor func, gpointer data)
91 {
92 Destructor *d = g_new(Destructor, 1);
93 d->func = func;
94 d->data = data;
95 client_destructors = g_slist_prepend(client_destructors, d);
96 }
97
98 void client_remove_destructor(ObClientDestructor func)
99 {
100 GSList *it;
101
102 for (it = client_destructors; it; it = g_slist_next(it)) {
103 Destructor *d = it->data;
104 if (d->func == func) {
105 g_free(d);
106 client_destructors = g_slist_delete_link(client_destructors, it);
107 break;
108 }
109 }
110 }
111
112 void client_set_list()
113 {
114 Window *windows, *win_it;
115 GList *it;
116 guint size = g_list_length(client_list);
117
118 /* create an array of the window ids */
119 if (size > 0) {
120 windows = g_new(Window, size);
121 win_it = windows;
122 for (it = client_list; it != NULL; it = it->next, ++win_it)
123 *win_it = ((ObClient*)it->data)->window;
124 } else
125 windows = NULL;
126
127 PROP_SETA32(RootWindow(ob_display, ob_screen),
128 net_client_list, window, (guint32*)windows, size);
129
130 if (windows)
131 g_free(windows);
132
133 stacking_set_list();
134 }
135
136 /*
137 void client_foreach_transient(ObClient *self, ObClientForeachFunc func, void *data)
138 {
139 GSList *it;
140
141 for (it = self->transients; it; it = it->next) {
142 if (!func(it->data, data)) return;
143 client_foreach_transient(it->data, func, data);
144 }
145 }
146
147 void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, void *data)
148 {
149 if (self->transient_for) {
150 if (self->transient_for != OB_TRAN_GROUP) {
151 if (!func(self->transient_for, data)) return;
152 client_foreach_ancestor(self->transient_for, func, data);
153 } else {
154 GSList *it;
155
156 for (it = self->group->members; it; it = it->next)
157 if (it->data != self &&
158 !((ObClient*)it->data)->transient_for) {
159 if (!func(it->data, data)) return;
160 client_foreach_ancestor(it->data, func, data);
161 }
162 }
163 }
164 }
165 */
166
167 void client_manage_all()
168 {
169 unsigned int i, j, nchild;
170 Window w, *children;
171 XWMHints *wmhints;
172 XWindowAttributes attrib;
173
174 XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
175 &w, &w, &children, &nchild);
176
177 /* remove all icon windows from the list */
178 for (i = 0; i < nchild; i++) {
179 if (children[i] == None) continue;
180 wmhints = XGetWMHints(ob_display, children[i]);
181 if (wmhints) {
182 if ((wmhints->flags & IconWindowHint) &&
183 (wmhints->icon_window != children[i]))
184 for (j = 0; j < nchild; j++)
185 if (children[j] == wmhints->icon_window) {
186 children[j] = None;
187 break;
188 }
189 XFree(wmhints);
190 }
191 }
192
193 for (i = 0; i < nchild; ++i) {
194 if (children[i] == None)
195 continue;
196 if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
197 if (attrib.override_redirect) continue;
198
199 if (attrib.map_state != IsUnmapped)
200 client_manage(children[i]);
201 }
202 }
203 XFree(children);
204 }
205
206 void client_manage(Window window)
207 {
208 ObClient *self;
209 XEvent e;
210 XWindowAttributes attrib;
211 XSetWindowAttributes attrib_set;
212 XWMHints *wmhint;
213 gboolean activate = FALSE;
214
215 grab_server(TRUE);
216
217 /* check if it has already been unmapped by the time we started mapping
218 the grab does a sync so we don't have to here */
219 if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
220 XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) {
221 XPutBackEvent(ob_display, &e);
222
223 grab_server(FALSE);
224 return; /* don't manage it */
225 }
226
227 /* make sure it isn't an override-redirect window */
228 if (!XGetWindowAttributes(ob_display, window, &attrib) ||
229 attrib.override_redirect) {
230 grab_server(FALSE);
231 return; /* don't manage it */
232 }
233
234 /* is the window a docking app */
235 if ((wmhint = XGetWMHints(ob_display, window))) {
236 if ((wmhint->flags & StateHint) &&
237 wmhint->initial_state == WithdrawnState) {
238 dock_add(window, wmhint);
239 grab_server(FALSE);
240 XFree(wmhint);
241 return;
242 }
243 XFree(wmhint);
244 }
245
246 ob_debug("Managing window: %lx\n", window);
247
248 /* choose the events we want to receive on the CLIENT window */
249 attrib_set.event_mask = CLIENT_EVENTMASK;
250 attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
251 XChangeWindowAttributes(ob_display, window,
252 CWEventMask|CWDontPropagate, &attrib_set);
253
254
255 /* create the ObClient struct, and populate it from the hints on the
256 window */
257 self = g_new0(ObClient, 1);
258 self->obwin.type = Window_Client;
259 self->window = window;
260
261 /* non-zero defaults */
262 self->title_count = 1;
263 self->wmstate = NormalState;
264 self->layer = -1;
265 self->desktop = screen_num_desktops; /* always an invalid value */
266
267 client_get_all(self);
268 client_restore_session_state(self);
269
270 sn_app_started(self->class);
271
272 client_change_state(self);
273
274 /* remove the client's border (and adjust re gravity) */
275 client_toggle_border(self, FALSE);
276
277 /* specify that if we exit, the window should not be destroyed and should
278 be reparented back to root automatically */
279 XChangeSaveSet(ob_display, window, SetModeInsert);
280
281 /* create the decoration frame for the client window */
282 self->frame = frame_new();
283
284 frame_grab_client(self->frame, self);
285
286 grab_server(FALSE);
287
288 client_apply_startup_state(self);
289
290 /* update the focus lists */
291 focus_order_add_new(self);
292
293 stacking_add(CLIENT_AS_WINDOW(self));
294 client_restore_session_stacking(self);
295
296 /* focus the new window? */
297 if (ob_state() != OB_STATE_STARTING &&
298 (config_focus_new || client_search_focus_parent(self)) &&
299 /* note the check against Type_Normal/Dialog, not client_normal(self),
300 which would also include other types. in this case we want more
301 strict rules for focus */
302 (self->type == OB_CLIENT_TYPE_NORMAL ||
303 self->type == OB_CLIENT_TYPE_DIALOG))
304 {
305 activate = TRUE;
306 #if 0
307 if (self->desktop != screen_desktop) {
308 /* activate the window */
309 activate = TRUE;
310 } else {
311 gboolean group_foc = FALSE;
312
313 if (self->group) {
314 GSList *it;
315
316 for (it = self->group->members; it; it = it->next)
317 {
318 if (client_focused(it->data))
319 {
320 group_foc = TRUE;
321 break;
322 }
323 }
324 }
325 if ((group_foc ||
326 (!self->transient_for && (!self->group ||
327 !self->group->members->next))) ||
328 client_search_focus_tree_full(self) ||
329 !focus_client ||
330 !client_normal(focus_client))
331 {
332 /* activate the window */
333 activate = TRUE;
334 }
335 }
336 #endif
337 }
338
339 if (ob_state() == OB_STATE_RUNNING) {
340 int x = self->area.x, ox = x;
341 int y = self->area.y, oy = y;
342
343 place_client(self, &x, &y);
344
345 /* make sure the window is visible */
346 client_find_onscreen(self, &x, &y,
347 self->frame->area.width,
348 self->frame->area.height,
349 client_normal(self));
350
351 if (x != ox || y != oy)
352 client_move(self, x, y);
353 }
354
355 client_showhide(self);
356
357 /* use client_focus instead of client_activate cuz client_activate does
358 stuff like switch desktops etc and I'm not interested in all that when
359 a window maps since its not based on an action from the user like
360 clicking a window to activate is. so keep the new window out of the way
361 but do focus it. */
362 if (activate) client_focus(self);
363
364 /* client_activate does this but we aret using it so we have to do it
365 here as well */
366 if (screen_showing_desktop)
367 screen_show_desktop(FALSE);
368
369 /* add to client list/map */
370 client_list = g_list_append(client_list, self);
371 g_hash_table_insert(window_map, &self->window, self);
372
373 /* this has to happen after we're in the client_list */
374 screen_update_areas();
375
376 /* update the list hints */
377 client_set_list();
378
379 keyboard_grab_for_client(self, TRUE);
380 mouse_grab_for_client(self, TRUE);
381
382 ob_debug("Managed window 0x%lx (%s)\n", window, self->class);
383 }
384
385 void client_unmanage_all()
386 {
387 while (client_list != NULL)
388 client_unmanage(client_list->data);
389 }
390
391 void client_unmanage(ObClient *self)
392 {
393 guint j;
394 GSList *it;
395
396 ob_debug("Unmanaging window: %lx (%s)\n", self->window, self->class);
397
398 g_assert(self != NULL);
399
400 keyboard_grab_for_client(self, FALSE);
401 mouse_grab_for_client(self, FALSE);
402
403 /* remove the window from our save set */
404 XChangeSaveSet(ob_display, self->window, SetModeDelete);
405
406 /* we dont want events no more */
407 XSelectInput(ob_display, self->window, NoEventMask);
408
409 frame_hide(self->frame);
410
411 client_list = g_list_remove(client_list, self);
412 stacking_remove(self);
413 g_hash_table_remove(window_map, &self->window);
414
415 /* update the focus lists */
416 focus_order_remove(self);
417
418 /* once the client is out of the list, update the struts to remove it's
419 influence */
420 screen_update_areas();
421
422 for (it = client_destructors; it; it = g_slist_next(it)) {
423 Destructor *d = it->data;
424 d->func(self, d->data);
425 }
426
427 if (focus_client == self) {
428 XEvent e;
429
430 /* focus the last focused window on the desktop, and ignore enter
431 events from the unmap so it doesnt mess with the focus */
432 while (XCheckTypedEvent(ob_display, EnterNotify, &e));
433 /* remove these flags so we don't end up getting focused in the
434 fallback! */
435 self->can_focus = FALSE;
436 self->focus_notify = FALSE;
437 self->modal = FALSE;
438 client_unfocus(self);
439 }
440
441 /* tell our parent(s) that we're gone */
442 if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
443 GSList *it;
444
445 for (it = self->group->members; it; it = it->next)
446 if (it->data != self)
447 ((ObClient*)it->data)->transients =
448 g_slist_remove(((ObClient*)it->data)->transients, self);
449 } else if (self->transient_for) { /* transient of window */
450 self->transient_for->transients =
451 g_slist_remove(self->transient_for->transients, self);
452 }
453
454 /* tell our transients that we're gone */
455 for (it = self->transients; it != NULL; it = it->next) {
456 if (((ObClient*)it->data)->transient_for != OB_TRAN_GROUP) {
457 ((ObClient*)it->data)->transient_for = NULL;
458 client_calc_layer(it->data);
459 }
460 }
461
462 /* remove from its group */
463 if (self->group) {
464 group_remove(self->group, self);
465 self->group = NULL;
466 }
467
468 /* give the client its border back */
469 client_toggle_border(self, TRUE);
470
471 /* reparent the window out of the frame, and free the frame */
472 frame_release_client(self->frame, self);
473 self->frame = NULL;
474
475 if (ob_state() != OB_STATE_EXITING) {
476 /* these values should not be persisted across a window
477 unmapping/mapping */
478 PROP_ERASE(self->window, net_wm_desktop);
479 PROP_ERASE(self->window, net_wm_state);
480 PROP_ERASE(self->window, wm_state);
481 } else {
482 /* if we're left in an iconic state, the client wont be mapped. this is
483 bad, since we will no longer be managing the window on restart */
484 if (self->iconic)
485 XMapWindow(ob_display, self->window);
486 }
487
488
489 ob_debug("Unmanaged window 0x%lx\n", self->window);
490
491 /* free all data allocated in the client struct */
492 g_slist_free(self->transients);
493 for (j = 0; j < self->nicons; ++j)
494 g_free(self->icons[j].data);
495 if (self->nicons > 0)
496 g_free(self->icons);
497 g_free(self->title);
498 g_free(self->icon_title);
499 g_free(self->name);
500 g_free(self->class);
501 g_free(self->role);
502 g_free(self->sm_client_id);
503 g_free(self);
504
505 /* update the list hints */
506 client_set_list();
507 }
508
509 static void client_urgent_notify(ObClient *self)
510 {
511 if (self->urgent)
512 frame_flash_start(self->frame);
513 else
514 frame_flash_stop(self->frame);
515 }
516
517 static void client_restore_session_state(ObClient *self)
518 {
519 GList *it;
520
521 if (!(it = session_state_find(self)))
522 return;
523
524 self->session = it->data;
525
526 RECT_SET(self->area, self->session->x, self->session->y,
527 self->session->w, self->session->h);
528 self->positioned = TRUE;
529 if (self->session->w > 0 && self->session->h > 0)
530 XResizeWindow(ob_display, self->window,
531 self->session->w, self->session->h);
532
533 self->desktop = (self->session->desktop == DESKTOP_ALL ?
534 self->session->desktop :
535 MIN(screen_num_desktops - 1, self->session->desktop));
536 PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
537
538 self->shaded = self->session->shaded;
539 self->iconic = self->session->iconic;
540 self->skip_pager = self->session->skip_pager;
541 self->skip_taskbar = self->session->skip_taskbar;
542 self->fullscreen = self->session->fullscreen;
543 self->above = self->session->above;
544 self->below = self->session->below;
545 self->max_horz = self->session->max_horz;
546 self->max_vert = self->session->max_vert;
547 }
548
549 static void client_restore_session_stacking(ObClient *self)
550 {
551 GList *it;
552
553 if (!self->session) return;
554
555 it = g_list_find(session_saved_state, self->session);
556 for (it = g_list_previous(it); it; it = g_list_previous(it)) {
557 GList *cit;
558
559 for (cit = client_list; cit; cit = g_list_next(cit))
560 if (session_state_cmp(it->data, cit->data))
561 break;
562 if (cit) {
563 client_calc_layer(self);
564 stacking_below(CLIENT_AS_WINDOW(self),
565 CLIENT_AS_WINDOW(cit->data));
566 break;
567 }
568 }
569 }
570
571 void client_move_onscreen(ObClient *self, gboolean rude)
572 {
573 int x = self->area.x;
574 int y = self->area.y;
575 if (client_find_onscreen(self, &x, &y,
576 self->frame->area.width,
577 self->frame->area.height, rude)) {
578 client_move(self, x, y);
579 }
580 }
581
582 gboolean client_find_onscreen(ObClient *self, int *x, int *y, int w, int h,
583 gboolean rude)
584 {
585 Rect *a;
586 int ox = *x, oy = *y;
587
588 frame_client_gravity(self->frame, x, y); /* get where the frame
589 would be */
590
591 /* XXX watch for xinerama dead areas */
592
593 a = screen_area(self->desktop);
594 if (client_normal(self)) {
595 if (!self->strut.right && *x >= a->x + a->width - 1)
596 *x = a->x + a->width - self->frame->area.width;
597 if (!self->strut.bottom && *y >= a->y + a->height - 1)
598 *y = a->y + a->height - self->frame->area.height;
599 if (!self->strut.left && *x + self->frame->area.width - 1 < a->x)
600 *x = a->x;
601 if (!self->strut.top && *y + self->frame->area.height - 1 < a->y)
602 *y = a->y;
603 }
604
605 if (rude) {
606 /* this is my MOZILLA BITCHSLAP. oh ya it fucking feels good.
607 Java can suck it too. */
608
609 /* dont let windows map/move into the strut unless they
610 are bigger than the available area */
611 if (w <= a->width) {
612 if (!self->strut.left && *x < a->x) *x = a->x;
613 if (!self->strut.right && *x + w > a->x + a->width)
614 *x = a->x + a->width - w;
615 }
616 if (h <= a->height) {
617 if (!self->strut.top && *y < a->y) *y = a->y;
618 if (!self->strut.bottom && *y + h > a->y + a->height)
619 *y = a->y + a->height - h;
620 }
621 }
622
623 frame_frame_gravity(self->frame, x, y); /* get where the client
624 should be */
625
626 return ox != *x || oy != *y;
627 }
628
629 static void client_toggle_border(ObClient *self, gboolean show)
630 {
631 /* adjust our idea of where the client is, based on its border. When the
632 border is removed, the client should now be considered to be in a
633 different position.
634 when re-adding the border to the client, the same operation needs to be
635 reversed. */
636 int oldx = self->area.x, oldy = self->area.y;
637 int x = oldx, y = oldy;
638 switch(self->gravity) {
639 default:
640 case NorthWestGravity:
641 case WestGravity:
642 case SouthWestGravity:
643 break;
644 case NorthEastGravity:
645 case EastGravity:
646 case SouthEastGravity:
647 if (show) x -= self->border_width * 2;
648 else x += self->border_width * 2;
649 break;
650 case NorthGravity:
651 case SouthGravity:
652 case CenterGravity:
653 case ForgetGravity:
654 case StaticGravity:
655 if (show) x -= self->border_width;
656 else x += self->border_width;
657 break;
658 }
659 switch(self->gravity) {
660 default:
661 case NorthWestGravity:
662 case NorthGravity:
663 case NorthEastGravity:
664 break;
665 case SouthWestGravity:
666 case SouthGravity:
667 case SouthEastGravity:
668 if (show) y -= self->border_width * 2;
669 else y += self->border_width * 2;
670 break;
671 case WestGravity:
672 case EastGravity:
673 case CenterGravity:
674 case ForgetGravity:
675 case StaticGravity:
676 if (show) y -= self->border_width;
677 else y += self->border_width;
678 break;
679 }
680 self->area.x = x;
681 self->area.y = y;
682
683 if (show) {
684 XSetWindowBorderWidth(ob_display, self->window, self->border_width);
685
686 /* move the client so it is back it the right spot _with_ its
687 border! */
688 if (x != oldx || y != oldy)
689 XMoveWindow(ob_display, self->window, x, y);
690 } else
691 XSetWindowBorderWidth(ob_display, self->window, 0);
692 }
693
694
695 static void client_get_all(ObClient *self)
696 {
697 client_get_area(self);
698 client_update_transient_for(self);
699 client_update_wmhints(self);
700 client_get_startup_id(self);
701 client_get_desktop(self);
702 client_get_state(self);
703 client_get_shaped(self);
704
705 client_get_mwm_hints(self);
706 client_get_type(self);/* this can change the mwmhints for special cases */
707
708 client_update_protocols(self);
709
710 client_get_gravity(self); /* get the attribute gravity */
711 client_update_normal_hints(self); /* this may override the attribute
712 gravity */
713
714 /* got the type, the mwmhints, the protocols, and the normal hints
715 (min/max sizes), so we're ready to set up the decorations/functions */
716 client_setup_decor_and_functions(self);
717
718 client_update_title(self);
719 client_update_class(self);
720 client_update_sm_client_id(self);
721 client_update_strut(self);
722 client_update_icons(self);
723 }
724
725 static void client_get_startup_id(ObClient *self)
726 {
727 if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
728 if (self->group)
729 PROP_GETS(self->group->leader,
730 net_startup_id, utf8, &self->startup_id);
731 }
732
733 static void client_get_area(ObClient *self)
734 {
735 XWindowAttributes wattrib;
736 Status ret;
737
738 ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
739 g_assert(ret != BadWindow);
740
741 RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
742 self->border_width = wattrib.border_width;
743 }
744
745 static void client_get_desktop(ObClient *self)
746 {
747 guint32 d = screen_num_desktops; /* an always-invalid value */
748
749 if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
750 if (d >= screen_num_desktops && d != DESKTOP_ALL)
751 self->desktop = screen_num_desktops - 1;
752 else
753 self->desktop = d;
754 } else {
755 gboolean trdesk = FALSE;
756
757 if (self->transient_for) {
758 if (self->transient_for != OB_TRAN_GROUP) {
759 self->desktop = self->transient_for->desktop;
760 trdesk = TRUE;
761 } else {
762 GSList *it;
763
764 for (it = self->group->members; it; it = it->next)
765 if (it->data != self &&
766 !((ObClient*)it->data)->transient_for) {
767 self->desktop = ((ObClient*)it->data)->desktop;
768 trdesk = TRUE;
769 break;
770 }
771 }
772 }
773 if (!trdesk) {
774 /* try get from the startup-notification protocol */
775 if (sn_get_desktop(self->startup_id, &self->desktop)) {
776 if (self->desktop >= screen_num_desktops &&
777 self->desktop != DESKTOP_ALL)
778 self->desktop = screen_num_desktops - 1;
779 } else
780 /* defaults to the current desktop */
781 self->desktop = screen_desktop;
782 }
783 }
784 if (self->desktop != d) {
785 /* set the desktop hint, to make sure that it always exists */
786 PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
787 }
788 }
789
790 static void client_get_state(ObClient *self)
791 {
792 guint32 *state;
793 guint num;
794
795 if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
796 gulong i;
797 for (i = 0; i < num; ++i) {
798 if (state[i] == prop_atoms.net_wm_state_modal)
799 self->modal = TRUE;
800 else if (state[i] == prop_atoms.net_wm_state_shaded)
801 self->shaded = TRUE;
802 else if (state[i] == prop_atoms.net_wm_state_hidden)
803 self->iconic = TRUE;
804 else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
805 self->skip_taskbar = TRUE;
806 else if (state[i] == prop_atoms.net_wm_state_skip_pager)
807 self->skip_pager = TRUE;
808 else if (state[i] == prop_atoms.net_wm_state_fullscreen)
809 self->fullscreen = TRUE;
810 else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
811 self->max_vert = TRUE;
812 else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
813 self->max_horz = TRUE;
814 else if (state[i] == prop_atoms.net_wm_state_above)
815 self->above = TRUE;
816 else if (state[i] == prop_atoms.net_wm_state_below)
817 self->below = TRUE;
818 else if (state[i] == prop_atoms.ob_wm_state_undecorated)
819 self->undecorated = TRUE;
820 }
821
822 g_free(state);
823 }
824 }
825
826 static void client_get_shaped(ObClient *self)
827 {
828 self->shaped = FALSE;
829 #ifdef SHAPE
830 if (extensions_shape) {
831 int foo;
832 guint ufoo;
833 int s;
834
835 XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
836
837 XShapeQueryExtents(ob_display, self->window, &s, &foo,
838 &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
839 &ufoo);
840 self->shaped = (s != 0);
841 }
842 #endif
843 }
844
845 void client_update_transient_for(ObClient *self)
846 {
847 Window t = None;
848 ObClient *target = NULL;
849
850 if (XGetTransientForHint(ob_display, self->window, &t)) {
851 self->transient = TRUE;
852 if (t != self->window) { /* cant be transient to itself! */
853 target = g_hash_table_lookup(window_map, &t);
854 /* if this happens then we need to check for it*/
855 g_assert(target != self);
856 if (target && !WINDOW_IS_CLIENT(target)) {
857 /* this can happen when a dialog is a child of
858 a dockapp, for example */
859 target = NULL;
860 }
861
862 if (!target && self->group) {
863 /* not transient to a client, see if it is transient for a
864 group */
865 if (t == self->group->leader ||
866 t == None ||
867 t == RootWindow(ob_display, ob_screen))
868 {
869 /* window is a transient for its group! */
870 target = OB_TRAN_GROUP;
871 }
872 }
873 }
874 } else
875 self->transient = FALSE;
876
877 /* if anything has changed... */
878 if (target != self->transient_for) {
879 if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
880 GSList *it;
881
882 /* remove from old parents */
883 for (it = self->group->members; it; it = g_slist_next(it)) {
884 ObClient *c = it->data;
885 if (c != self && !c->transient_for)
886 c->transients = g_slist_remove(c->transients, self);
887 }
888 } else if (self->transient_for != NULL) { /* transient of window */
889 /* remove from old parent */
890 self->transient_for->transients =
891 g_slist_remove(self->transient_for->transients, self);
892 }
893 self->transient_for = target;
894 if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
895 GSList *it;
896
897 /* add to new parents */
898 for (it = self->group->members; it; it = g_slist_next(it)) {
899 ObClient *c = it->data;
900 if (c != self && !c->transient_for)
901 c->transients = g_slist_append(c->transients, self);
902 }
903
904 /* remove all transients which are in the group, that causes
905 circlular pointer hell of doom */
906 for (it = self->group->members; it; it = g_slist_next(it)) {
907 GSList *sit, *next;
908 for (sit = self->transients; sit; sit = next) {
909 next = g_slist_next(sit);
910 if (sit->data == it->data)
911 self->transients =
912 g_slist_delete_link(self->transients, sit);
913 }
914 }
915 } else if (self->transient_for != NULL) { /* transient of window */
916 /* add to new parent */
917 self->transient_for->transients =
918 g_slist_append(self->transient_for->transients, self);
919 }
920 }
921 }
922
923 static void client_get_mwm_hints(ObClient *self)
924 {
925 guint num;
926 guint32 *hints;
927
928 self->mwmhints.flags = 0; /* default to none */
929
930 if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
931 &hints, &num)) {
932 if (num >= OB_MWM_ELEMENTS) {
933 self->mwmhints.flags = hints[0];
934 self->mwmhints.functions = hints[1];
935 self->mwmhints.decorations = hints[2];
936 }
937 g_free(hints);
938 }
939 }
940
941 void client_get_type(ObClient *self)
942 {
943 guint num, i;
944 guint32 *val;
945
946 self->type = -1;
947
948 if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
949 /* use the first value that we know about in the array */
950 for (i = 0; i < num; ++i) {
951 if (val[i] == prop_atoms.net_wm_window_type_desktop)
952 self->type = OB_CLIENT_TYPE_DESKTOP;
953 else if (val[i] == prop_atoms.net_wm_window_type_dock)
954 self->type = OB_CLIENT_TYPE_DOCK;
955 else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
956 self->type = OB_CLIENT_TYPE_TOOLBAR;
957 else if (val[i] == prop_atoms.net_wm_window_type_menu)
958 self->type = OB_CLIENT_TYPE_MENU;
959 else if (val[i] == prop_atoms.net_wm_window_type_utility)
960 self->type = OB_CLIENT_TYPE_UTILITY;
961 else if (val[i] == prop_atoms.net_wm_window_type_splash)
962 self->type = OB_CLIENT_TYPE_SPLASH;
963 else if (val[i] == prop_atoms.net_wm_window_type_dialog)
964 self->type = OB_CLIENT_TYPE_DIALOG;
965 else if (val[i] == prop_atoms.net_wm_window_type_normal)
966 self->type = OB_CLIENT_TYPE_NORMAL;
967 else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
968 /* prevent this window from getting any decor or
969 functionality */
970 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
971 OB_MWM_FLAG_DECORATIONS);
972 self->mwmhints.decorations = 0;
973 self->mwmhints.functions = 0;
974 }
975 if (self->type != (ObClientType) -1)
976 break; /* grab the first legit type */
977 }
978 g_free(val);
979 }
980
981 if (self->type == (ObClientType) -1) {
982 /*the window type hint was not set, which means we either classify
983 ourself as a normal window or a dialog, depending on if we are a
984 transient. */
985 if (self->transient)
986 self->type = OB_CLIENT_TYPE_DIALOG;
987 else
988 self->type = OB_CLIENT_TYPE_NORMAL;
989 }
990 }
991
992 void client_update_protocols(ObClient *self)
993 {
994 guint32 *proto;
995 guint num_return, i;
996
997 self->focus_notify = FALSE;
998 self->delete_window = FALSE;
999
1000 if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1001 for (i = 0; i < num_return; ++i) {
1002 if (proto[i] == prop_atoms.wm_delete_window) {
1003 /* this means we can request the window to close */
1004 self->delete_window = TRUE;
1005 } else if (proto[i] == prop_atoms.wm_take_focus)
1006 /* if this protocol is requested, then the window will be
1007 notified whenever we want it to receive focus */
1008 self->focus_notify = TRUE;
1009 }
1010 g_free(proto);
1011 }
1012 }
1013
1014 static void client_get_gravity(ObClient *self)
1015 {
1016 XWindowAttributes wattrib;
1017 Status ret;
1018
1019 ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1020 g_assert(ret != BadWindow);
1021 self->gravity = wattrib.win_gravity;
1022 }
1023
1024 void client_update_normal_hints(ObClient *self)
1025 {
1026 XSizeHints size;
1027 long ret;
1028 int oldgravity = self->gravity;
1029
1030 /* defaults */
1031 self->min_ratio = 0.0f;
1032 self->max_ratio = 0.0f;
1033 SIZE_SET(self->size_inc, 1, 1);
1034 SIZE_SET(self->base_size, 0, 0);
1035 SIZE_SET(self->min_size, 0, 0);
1036 SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1037
1038 /* get the hints from the window */
1039 if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1040 self->positioned = !!(size.flags & (PPosition|USPosition));
1041
1042 if (size.flags & PWinGravity) {
1043 self->gravity = size.win_gravity;
1044
1045 /* if the client has a frame, i.e. has already been mapped and
1046 is changing its gravity */
1047 if (self->frame && self->gravity != oldgravity) {
1048 /* move our idea of the client's position based on its new
1049 gravity */
1050 self->area.x = self->frame->area.x;
1051 self->area.y = self->frame->area.y;
1052 frame_frame_gravity(self->frame, &self->area.x, &self->area.y);
1053 }
1054 }
1055
1056 if (size.flags & PAspect) {
1057 if (size.min_aspect.y)
1058 self->min_ratio = (float)size.min_aspect.x / size.min_aspect.y;
1059 if (size.max_aspect.y)
1060 self->max_ratio = (float)size.max_aspect.x / size.max_aspect.y;
1061 }
1062
1063 if (size.flags & PMinSize)
1064 SIZE_SET(self->min_size, size.min_width, size.min_height);
1065
1066 if (size.flags & PMaxSize)
1067 SIZE_SET(self->max_size, size.max_width, size.max_height);
1068
1069 if (size.flags & PBaseSize)
1070 SIZE_SET(self->base_size, size.base_width, size.base_height);
1071
1072 if (size.flags & PResizeInc)
1073 SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1074 }
1075 }
1076
1077 void client_setup_decor_and_functions(ObClient *self)
1078 {
1079 /* start with everything (cept fullscreen) */
1080 self->decorations =
1081 (OB_FRAME_DECOR_TITLEBAR |
1082 (ob_rr_theme->show_handle ? OB_FRAME_DECOR_HANDLE : 0) |
1083 OB_FRAME_DECOR_GRIPS |
1084 OB_FRAME_DECOR_BORDER |
1085 OB_FRAME_DECOR_ICON |
1086 OB_FRAME_DECOR_ALLDESKTOPS |
1087 OB_FRAME_DECOR_ICONIFY |
1088 OB_FRAME_DECOR_MAXIMIZE |
1089 OB_FRAME_DECOR_SHADE);
1090 self->functions =
1091 (OB_CLIENT_FUNC_RESIZE |
1092 OB_CLIENT_FUNC_MOVE |
1093 OB_CLIENT_FUNC_ICONIFY |
1094 OB_CLIENT_FUNC_MAXIMIZE |
1095 OB_CLIENT_FUNC_SHADE);
1096 if (self->delete_window) {
1097 self->functions |= OB_CLIENT_FUNC_CLOSE;
1098 self->decorations |= OB_FRAME_DECOR_CLOSE;
1099 }
1100
1101 if (!(self->min_size.width < self->max_size.width ||
1102 self->min_size.height < self->max_size.height))
1103 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1104
1105 switch (self->type) {
1106 case OB_CLIENT_TYPE_NORMAL:
1107 /* normal windows retain all of the possible decorations and
1108 functionality, and are the only windows that you can fullscreen */
1109 self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1110 break;
1111
1112 case OB_CLIENT_TYPE_DIALOG:
1113 case OB_CLIENT_TYPE_UTILITY:
1114 /* these windows cannot be maximized */
1115 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1116 break;
1117
1118 case OB_CLIENT_TYPE_MENU:
1119 case OB_CLIENT_TYPE_TOOLBAR:
1120 /* these windows get less functionality */
1121 self->functions &= ~(OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_RESIZE);
1122 break;
1123
1124 case OB_CLIENT_TYPE_DESKTOP:
1125 case OB_CLIENT_TYPE_DOCK:
1126 case OB_CLIENT_TYPE_SPLASH:
1127 /* none of these windows are manipulated by the window manager */
1128 self->decorations = 0;
1129 self->functions = 0;
1130 break;
1131 }
1132
1133 /* Mwm Hints are applied subtractively to what has already been chosen for
1134 decor and functionality */
1135 if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1136 if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1137 if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1138 (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1139 /* if the mwm hints request no handle or title, then all
1140 decorations are disabled */
1141 self->decorations = 0;
1142 }
1143 }
1144
1145 if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1146 if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1147 if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1148 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1149 if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1150 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1151 /* dont let mwm hints kill any buttons
1152 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1153 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1154 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1155 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1156 */
1157 /* dont let mwm hints kill the close button
1158 if (! (self->mwmhints.functions & MwmFunc_Close))
1159 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1160 }
1161 }
1162
1163 if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1164 self->decorations &= ~OB_FRAME_DECOR_SHADE;
1165 if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1166 self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1167 if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1168 self->decorations &= ~OB_FRAME_DECOR_GRIPS;
1169
1170 /* can't maximize without moving/resizing */
1171 if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1172 (self->functions & OB_CLIENT_FUNC_MOVE) &&
1173 (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1174 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1175 self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1176 }
1177
1178 /* kill the handle on fully maxed windows */
1179 if (self->max_vert && self->max_horz)
1180 self->decorations &= ~OB_FRAME_DECOR_HANDLE;
1181
1182 /* finally, the user can have requested no decorations, which overrides
1183 everything */
1184 if (self->undecorated)
1185 self->decorations = OB_FRAME_DECOR_BORDER;
1186
1187 /* if we don't have a titlebar, then we cannot shade! */
1188 if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1189 self->functions &= ~OB_CLIENT_FUNC_SHADE;
1190
1191 /* now we need to check against rules for the client's current state */
1192 if (self->fullscreen) {
1193 self->functions &= (OB_CLIENT_FUNC_CLOSE |
1194 OB_CLIENT_FUNC_FULLSCREEN |
1195 OB_CLIENT_FUNC_ICONIFY);
1196 self->decorations = 0;
1197 }
1198
1199 client_change_allowed_actions(self);
1200
1201 if (self->frame) {
1202 /* adjust the client's decorations, etc. */
1203 client_reconfigure(self);
1204 } else {
1205 /* this makes sure that these windows appear on all desktops */
1206 if (self->type == OB_CLIENT_TYPE_DESKTOP &&
1207 self->desktop != DESKTOP_ALL)
1208 {
1209 self->desktop = DESKTOP_ALL;
1210 }
1211 }
1212 }
1213
1214 static void client_change_allowed_actions(ObClient *self)
1215 {
1216 guint32 actions[9];
1217 int num = 0;
1218
1219 /* desktop windows are kept on all desktops */
1220 if (self->type != OB_CLIENT_TYPE_DESKTOP)
1221 actions[num++] = prop_atoms.net_wm_action_change_desktop;
1222
1223 if (self->functions & OB_CLIENT_FUNC_SHADE)
1224 actions[num++] = prop_atoms.net_wm_action_shade;
1225 if (self->functions & OB_CLIENT_FUNC_CLOSE)
1226 actions[num++] = prop_atoms.net_wm_action_close;
1227 if (self->functions & OB_CLIENT_FUNC_MOVE)
1228 actions[num++] = prop_atoms.net_wm_action_move;
1229 if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1230 actions[num++] = prop_atoms.net_wm_action_minimize;
1231 if (self->functions & OB_CLIENT_FUNC_RESIZE)
1232 actions[num++] = prop_atoms.net_wm_action_resize;
1233 if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1234 actions[num++] = prop_atoms.net_wm_action_fullscreen;
1235 if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1236 actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1237 actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1238 }
1239
1240 PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1241
1242 /* make sure the window isn't breaking any rules now */
1243
1244 if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1245 if (self->frame) client_shade(self, FALSE);
1246 else self->shaded = FALSE;
1247 }
1248 if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
1249 if (self->frame) client_iconify(self, FALSE, TRUE);
1250 else self->iconic = FALSE;
1251 }
1252 if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1253 if (self->frame) client_fullscreen(self, FALSE, TRUE);
1254 else self->fullscreen = FALSE;
1255 }
1256 if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1257 self->max_vert)) {
1258 if (self->frame) client_maximize(self, FALSE, 0, TRUE);
1259 else self->max_vert = self->max_horz = FALSE;
1260 }
1261 }
1262
1263 void client_reconfigure(ObClient *self)
1264 {
1265 /* by making this pass FALSE for user, we avoid the emacs event storm where
1266 every configurenotify causes an update in its normal hints, i think this
1267 is generally what we want anyways... */
1268 client_configure(self, OB_CORNER_TOPLEFT, self->area.x, self->area.y,
1269 self->area.width, self->area.height, FALSE, TRUE);
1270 }
1271
1272 void client_update_wmhints(ObClient *self)
1273 {
1274 XWMHints *hints;
1275 gboolean ur = FALSE;
1276 GSList *it;
1277
1278 /* assume a window takes input if it doesnt specify */
1279 self->can_focus = TRUE;
1280
1281 if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1282 if (hints->flags & InputHint)
1283 self->can_focus = hints->input;
1284
1285 /* only do this when first managing the window *AND* when we aren't
1286 starting up! */
1287 if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1288 if (hints->flags & StateHint)
1289 self->iconic = hints->initial_state == IconicState;
1290
1291 if (hints->flags & XUrgencyHint)
1292 ur = TRUE;
1293
1294 if (!(hints->flags & WindowGroupHint))
1295 hints->window_group = None;
1296
1297 /* did the group state change? */
1298 if (hints->window_group !=
1299 (self->group ? self->group->leader : None)) {
1300 /* remove from the old group if there was one */
1301 if (self->group != NULL) {
1302 /* remove transients of the group */
1303 for (it = self->group->members; it; it = it->next)
1304 self->transients = g_slist_remove(self->transients,
1305 it->data);
1306
1307 /* remove myself from parents in the group */
1308 if (self->transient_for == OB_TRAN_GROUP) {
1309 for (it = self->group->members; it; it = it->next) {
1310 ObClient *c = it->data;
1311
1312 if (c != self && !c->transient_for)
1313 c->transients = g_slist_remove(c->transients,
1314 self);
1315 }
1316 }
1317
1318 group_remove(self->group, self);
1319 self->group = NULL;
1320 }
1321 if (hints->window_group != None) {
1322 self->group = group_add(hints->window_group, self);
1323
1324 /* i can only have transients from the group if i am not
1325 transient myself */
1326 if (!self->transient_for) {
1327 /* add other transients of the group that are already
1328 set up */
1329 for (it = self->group->members; it; it = it->next) {
1330 ObClient *c = it->data;
1331 if (c != self && c->transient_for == OB_TRAN_GROUP)
1332 self->transients =
1333 g_slist_append(self->transients, c);
1334 }
1335 }
1336 }
1337
1338 /* because the self->transient flag wont change from this call,
1339 we don't need to update the window's type and such, only its
1340 transient_for, and the transients lists of other windows in
1341 the group may be affected */
1342 client_update_transient_for(self);
1343 }
1344
1345 /* the WM_HINTS can contain an icon */
1346 client_update_icons(self);
1347
1348 XFree(hints);
1349 }
1350
1351 if (ur != self->urgent) {
1352 self->urgent = ur;
1353 /* fire the urgent callback if we're mapped, otherwise, wait until
1354 after we're mapped */
1355 if (self->frame)
1356 client_urgent_notify(self);
1357 }
1358 }
1359
1360 void client_update_title(ObClient *self)
1361 {
1362 GList *it;
1363 guint32 nums;
1364 guint i;
1365 gchar *data = NULL;
1366 gboolean read_title;
1367 gchar *old_title;
1368
1369 old_title = self->title;
1370
1371 /* try netwm */
1372 if (!PROP_GETS(self->window, net_wm_name, utf8, &data))
1373 /* try old x stuff */
1374 if (!PROP_GETS(self->window, wm_name, locale, &data))
1375 data = g_strdup("Unnamed Window");
1376
1377 /* did the title change? then reset the title_count */
1378 if (old_title && 0 != strncmp(old_title, data, strlen(data)))
1379 self->title_count = 1;
1380
1381 /* look for duplicates and append a number */
1382 nums = 0;
1383 for (it = client_list; it; it = it->next)
1384 if (it->data != self) {
1385 ObClient *c = it->data;
1386 if (0 == strncmp(c->title, data, strlen(data)))
1387 nums |= 1 << c->title_count;
1388 }
1389 /* find first free number */
1390 for (i = 1; i <= 32; ++i)
1391 if (!(nums & (1 << i))) {
1392 if (self->title_count == 1 || i == 1)
1393 self->title_count = i;
1394 break;
1395 }
1396 /* dont display the number for the first window */
1397 if (self->title_count > 1) {
1398 char *ndata;
1399 ndata = g_strdup_printf("%s - [%u]", data, self->title_count);
1400 g_free(data);
1401 data = ndata;
1402 }
1403
1404 PROP_SETS(self->window, net_wm_visible_name, data);
1405
1406 self->title = data;
1407
1408 if (self->frame)
1409 frame_adjust_title(self->frame);
1410
1411 g_free(old_title);
1412
1413 /* update the icon title */
1414 data = NULL;
1415 g_free(self->icon_title);
1416
1417 read_title = TRUE;
1418 /* try netwm */
1419 if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1420 /* try old x stuff */
1421 if (!PROP_GETS(self->window, wm_icon_name, locale, &data)) {
1422 data = g_strdup(self->title);
1423 read_title = FALSE;
1424 }
1425
1426 /* append the title count, dont display the number for the first window */
1427 if (read_title && self->title_count > 1) {
1428 char *vdata, *ndata;
1429 ndata = g_strdup_printf(" - [%u]", self->title_count);
1430 vdata = g_strconcat(data, ndata, NULL);
1431 g_free(ndata);
1432 g_free(data);
1433 data = vdata;
1434 }
1435
1436 PROP_SETS(self->window, net_wm_visible_icon_name, data);
1437
1438 self->icon_title = data;
1439 }
1440
1441 void client_update_class(ObClient *self)
1442 {
1443 char **data;
1444 char *s;
1445
1446 if (self->name) g_free(self->name);
1447 if (self->class) g_free(self->class);
1448 if (self->role) g_free(self->role);
1449
1450 self->name = self->class = self->role = NULL;
1451
1452 if (PROP_GETSS(self->window, wm_class, locale, &data)) {
1453 if (data[0]) {
1454 self->name = g_strdup(data[0]);
1455 if (data[1])
1456 self->class = g_strdup(data[1]);
1457 }
1458 g_strfreev(data);
1459 }
1460
1461 if (PROP_GETS(self->window, wm_window_role, locale, &s))
1462 self->role = s;
1463
1464 if (self->name == NULL) self->name = g_strdup("");
1465 if (self->class == NULL) self->class = g_strdup("");
1466 if (self->role == NULL) self->role = g_strdup("");
1467 }
1468
1469 void client_update_strut(ObClient *self)
1470 {
1471 guint num;
1472 guint32 *data;
1473 gboolean got = FALSE;
1474 StrutPartial strut;
1475
1476 if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
1477 &data, &num)) {
1478 if (num == 12) {
1479 got = TRUE;
1480 STRUT_PARTIAL_SET(strut,
1481 data[0], data[2], data[1], data[3],
1482 data[4], data[5], data[8], data[9],
1483 data[6], data[7], data[10], data[11]);
1484 }
1485 g_free(data);
1486 }
1487
1488 if (!got &&
1489 PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
1490 if (num == 4) {
1491 got = TRUE;
1492 STRUT_PARTIAL_SET(strut,
1493 data[0], data[2], data[1], data[3],
1494 0, 0, 0, 0, 0, 0, 0, 0);
1495 }
1496 g_free(data);
1497 }
1498
1499 if (!got)
1500 STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
1501 0, 0, 0, 0, 0, 0, 0, 0);
1502
1503 if (!STRUT_EQUAL(strut, self->strut)) {
1504 self->strut = strut;
1505
1506 /* updating here is pointless while we're being mapped cuz we're not in
1507 the client list yet */
1508 if (self->frame)
1509 screen_update_areas();
1510 }
1511 }
1512
1513 void client_update_icons(ObClient *self)
1514 {
1515 guint num;
1516 guint32 *data;
1517 guint w, h, i, j;
1518
1519 for (i = 0; i < self->nicons; ++i)
1520 g_free(self->icons[i].data);
1521 if (self->nicons > 0)
1522 g_free(self->icons);
1523 self->nicons = 0;
1524
1525 if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
1526 /* figure out how many valid icons are in here */
1527 i = 0;
1528 while (num - i > 2) {
1529 w = data[i++];
1530 h = data[i++];
1531 i += w * h;
1532 if (i > num || w*h == 0) break;
1533 ++self->nicons;
1534 }
1535
1536 self->icons = g_new(ObClientIcon, self->nicons);
1537
1538 /* store the icons */
1539 i = 0;
1540 for (j = 0; j < self->nicons; ++j) {
1541 guint x, y, t;
1542
1543 w = self->icons[j].width = data[i++];
1544 h = self->icons[j].height = data[i++];
1545
1546 if (w*h == 0) continue;
1547
1548 self->icons[j].data = g_new(RrPixel32, w * h);
1549 for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
1550 if (x >= w) {
1551 x = 0;
1552 ++y;
1553 }
1554 self->icons[j].data[t] =
1555 (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
1556 (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
1557 (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
1558 (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
1559 }
1560 g_assert(i <= num);
1561 }
1562
1563 g_free(data);
1564 } else if (PROP_GETA32(self->window, kwm_win_icon,
1565 kwm_win_icon, &data, &num)) {
1566 if (num == 2) {
1567 self->nicons++;
1568 self->icons = g_new(ObClientIcon, self->nicons);
1569 xerror_set_ignore(TRUE);
1570 if (!RrPixmapToRGBA(ob_rr_inst,
1571 data[0], data[1],
1572 &self->icons[self->nicons-1].width,
1573 &self->icons[self->nicons-1].height,
1574 &self->icons[self->nicons-1].data)) {
1575 g_free(&self->icons[self->nicons-1]);
1576 self->nicons--;
1577 }
1578 xerror_set_ignore(FALSE);
1579 }
1580 g_free(data);
1581 } else {
1582 XWMHints *hints;
1583
1584 if ((hints = XGetWMHints(ob_display, self->window))) {
1585 if (hints->flags & IconPixmapHint) {
1586 self->nicons++;
1587 self->icons = g_new(ObClientIcon, self->nicons);
1588 xerror_set_ignore(TRUE);
1589 if (!RrPixmapToRGBA(ob_rr_inst,
1590 hints->icon_pixmap,
1591 (hints->flags & IconMaskHint ?
1592 hints->icon_mask : None),
1593 &self->icons[self->nicons-1].width,
1594 &self->icons[self->nicons-1].height,
1595 &self->icons[self->nicons-1].data)){
1596 g_free(&self->icons[self->nicons-1]);
1597 self->nicons--;
1598 }
1599 xerror_set_ignore(FALSE);
1600 }
1601 XFree(hints);
1602 }
1603 }
1604
1605 if (self->frame)
1606 frame_adjust_icon(self->frame);
1607 }
1608
1609 static void client_change_state(ObClient *self)
1610 {
1611 guint32 state[2];
1612 guint32 netstate[11];
1613 guint num;
1614
1615 state[0] = self->wmstate;
1616 state[1] = None;
1617 PROP_SETA32(self->window, wm_state, wm_state, state, 2);
1618
1619 num = 0;
1620 if (self->modal)
1621 netstate[num++] = prop_atoms.net_wm_state_modal;
1622 if (self->shaded)
1623 netstate[num++] = prop_atoms.net_wm_state_shaded;
1624 if (self->iconic)
1625 netstate[num++] = prop_atoms.net_wm_state_hidden;
1626 if (self->skip_taskbar)
1627 netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
1628 if (self->skip_pager)
1629 netstate[num++] = prop_atoms.net_wm_state_skip_pager;
1630 if (self->fullscreen)
1631 netstate[num++] = prop_atoms.net_wm_state_fullscreen;
1632 if (self->max_vert)
1633 netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
1634 if (self->max_horz)
1635 netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
1636 if (self->above)
1637 netstate[num++] = prop_atoms.net_wm_state_above;
1638 if (self->below)
1639 netstate[num++] = prop_atoms.net_wm_state_below;
1640 if (self->undecorated)
1641 netstate[num++] = prop_atoms.ob_wm_state_undecorated;
1642 PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
1643
1644 client_calc_layer(self);
1645
1646 if (self->frame)
1647 frame_adjust_state(self->frame);
1648 }
1649
1650 ObClient *client_search_focus_tree(ObClient *self)
1651 {
1652 GSList *it;
1653 ObClient *ret;
1654
1655 for (it = self->transients; it != NULL; it = it->next) {
1656 if (client_focused(it->data)) return it->data;
1657 if ((ret = client_search_focus_tree(it->data))) return ret;
1658 }
1659 return NULL;
1660 }
1661
1662 ObClient *client_search_focus_tree_full(ObClient *self)
1663 {
1664 if (self->transient_for) {
1665 if (self->transient_for != OB_TRAN_GROUP) {
1666 return client_search_focus_tree_full(self->transient_for);
1667 } else {
1668 GSList *it;
1669 gboolean recursed = FALSE;
1670
1671 for (it = self->group->members; it; it = it->next)
1672 if (!((ObClient*)it->data)->transient_for) {
1673 ObClient *c;
1674 if ((c = client_search_focus_tree_full(it->data)))
1675 return c;
1676 recursed = TRUE;
1677 }
1678 if (recursed)
1679 return NULL;
1680 }
1681 }
1682
1683 /* this function checks the whole tree, the client_search_focus_tree~
1684 does not, so we need to check this window */
1685 if (client_focused(self))
1686 return self;
1687 return client_search_focus_tree(self);
1688 }
1689
1690 static ObStackingLayer calc_layer(ObClient *self)
1691 {
1692 ObStackingLayer l;
1693
1694 if (self->fullscreen &&
1695 (client_focused(self) || client_search_focus_tree(self)))
1696 l = OB_STACKING_LAYER_FULLSCREEN;
1697 else if (self->type == OB_CLIENT_TYPE_DESKTOP)
1698 l = OB_STACKING_LAYER_DESKTOP;
1699 else if (self->type == OB_CLIENT_TYPE_DOCK) {
1700 if (!self->below) l = OB_STACKING_LAYER_TOP;
1701 else l = OB_STACKING_LAYER_NORMAL;
1702 }
1703 else if (self->above) l = OB_STACKING_LAYER_ABOVE;
1704 else if (self->below) l = OB_STACKING_LAYER_BELOW;
1705 else l = OB_STACKING_LAYER_NORMAL;
1706
1707 return l;
1708 }
1709
1710 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
1711 ObStackingLayer l, gboolean raised)
1712 {
1713 ObStackingLayer old, own;
1714 GSList *it;
1715
1716 old = self->layer;
1717 own = calc_layer(self);
1718 self->layer = l > own ? l : own;
1719
1720 for (it = self->transients; it; it = it->next)
1721 client_calc_layer_recursive(it->data, orig,
1722 l, raised ? raised : l != old);
1723
1724 if (!raised && l != old)
1725 if (orig->frame) { /* only restack if the original window is managed */
1726 /* XXX add_non_intrusive ever? */
1727 stacking_remove(CLIENT_AS_WINDOW(self));
1728 stacking_add(CLIENT_AS_WINDOW(self));
1729 }
1730 }
1731
1732 void client_calc_layer(ObClient *self)
1733 {
1734 ObStackingLayer l;
1735 ObClient *orig;
1736
1737 orig = self;
1738
1739 /* transients take on the layer of their parents */
1740 self = client_search_top_transient(self);
1741
1742 l = calc_layer(self);
1743
1744 client_calc_layer_recursive(self, orig, l, FALSE);
1745 }
1746
1747 gboolean client_should_show(ObClient *self)
1748 {
1749 if (self->iconic) return FALSE;
1750 else if (!(self->desktop == screen_desktop ||
1751 self->desktop == DESKTOP_ALL)) return FALSE;
1752 else if (client_normal(self) && screen_showing_desktop) return FALSE;
1753
1754 return TRUE;
1755 }
1756
1757 static void client_showhide(ObClient *self)
1758 {
1759
1760 if (client_should_show(self))
1761 frame_show(self->frame);
1762 else
1763 frame_hide(self->frame);
1764 }
1765
1766 gboolean client_normal(ObClient *self) {
1767 return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
1768 self->type == OB_CLIENT_TYPE_DOCK ||
1769 self->type == OB_CLIENT_TYPE_SPLASH);
1770 }
1771
1772 static void client_apply_startup_state(ObClient *self)
1773 {
1774 /* these are in a carefully crafted order.. */
1775
1776 if (self->iconic) {
1777 self->iconic = FALSE;
1778 client_iconify(self, TRUE, FALSE);
1779 }
1780 if (self->fullscreen) {
1781 self->fullscreen = FALSE;
1782 client_fullscreen(self, TRUE, FALSE);
1783 }
1784 if (self->undecorated) {
1785 self->undecorated = FALSE;
1786 client_set_undecorated(self, TRUE);
1787 }
1788 if (self->shaded) {
1789 self->shaded = FALSE;
1790 client_shade(self, TRUE);
1791 }
1792 if (self->urgent)
1793 client_urgent_notify(self);
1794
1795 if (self->max_vert && self->max_horz) {
1796 self->max_vert = self->max_horz = FALSE;
1797 client_maximize(self, TRUE, 0, FALSE);
1798 } else if (self->max_vert) {
1799 self->max_vert = FALSE;
1800 client_maximize(self, TRUE, 2, FALSE);
1801 } else if (self->max_horz) {
1802 self->max_horz = FALSE;
1803 client_maximize(self, TRUE, 1, FALSE);
1804 }
1805
1806 /* nothing to do for the other states:
1807 skip_taskbar
1808 skip_pager
1809 modal
1810 above
1811 below
1812 */
1813 }
1814
1815 void client_configure_full(ObClient *self, ObCorner anchor,
1816 int x, int y, int w, int h,
1817 gboolean user, gboolean final,
1818 gboolean force_reply)
1819 {
1820 gint oldw, oldh;
1821 gboolean send_resize_client;
1822 gboolean moved = FALSE, resized = FALSE;
1823 guint fdecor = self->frame->decorations;
1824 gboolean fhorz = self->frame->max_horz;
1825
1826 /* make the frame recalculate its dimentions n shit without changing
1827 anything visible for real, this way the constraints below can work with
1828 the updated frame dimensions. */
1829 frame_adjust_area(self->frame, TRUE, TRUE, TRUE);
1830
1831 /* gets the frame's position */
1832 frame_client_gravity(self->frame, &x, &y);
1833
1834 /* these positions are frame positions, not client positions */
1835
1836 /* set the size and position if fullscreen */
1837 if (self->fullscreen) {
1838 #ifdef VIDMODE
1839 int dot;
1840 XF86VidModeModeLine mode;
1841 #endif
1842 Rect *a;
1843 guint i;
1844
1845 i = client_monitor(self);
1846 a = screen_physical_area_monitor(i);
1847
1848 #ifdef VIDMODE
1849 if (i == 0 && /* primary head */
1850 extensions_vidmode &&
1851 XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y) &&
1852 /* get the mode last so the mode.privsize isnt freed incorrectly */
1853 XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
1854 x += a->x;
1855 y += a->y;
1856 w = mode.hdisplay;
1857 h = mode.vdisplay;
1858 if (mode.privsize) XFree(mode.private);
1859 } else
1860 #endif
1861 {
1862 x = a->x;
1863 y = a->y;
1864 w = a->width;
1865 h = a->height;
1866 }
1867
1868 user = FALSE; /* ignore that increment etc shit when in fullscreen */
1869 } else {
1870 Rect *a;
1871
1872 a = screen_area_monitor(self->desktop, client_monitor(self));
1873
1874 /* set the size and position if maximized */
1875 if (self->max_horz) {
1876 x = a->x;
1877 w = a->width - self->frame->size.left - self->frame->size.right;
1878 }
1879 if (self->max_vert) {
1880 y = a->y;
1881 h = a->height - self->frame->size.top - self->frame->size.bottom;
1882 }
1883 }
1884
1885 /* gets the client's position */
1886 frame_frame_gravity(self->frame, &x, &y);
1887
1888 /* these override the above states! if you cant move you can't move! */
1889 if (user) {
1890 if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
1891 x = self->area.x;
1892 y = self->area.y;
1893 }
1894 if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
1895 w = self->area.width;
1896 h = self->area.height;
1897 }
1898 }
1899
1900 if (!(w == self->area.width && h == self->area.height)) {
1901 int basew, baseh, minw, minh;
1902
1903 /* base size is substituted with min size if not specified */
1904 if (self->base_size.width || self->base_size.height) {
1905 basew = self->base_size.width;
1906 baseh = self->base_size.height;
1907 } else {
1908 basew = self->min_size.width;
1909 baseh = self->min_size.height;
1910 }
1911 /* min size is substituted with base size if not specified */
1912 if (self->min_size.width || self->min_size.height) {
1913 minw = self->min_size.width;
1914 minh = self->min_size.height;
1915 } else {
1916 minw = self->base_size.width;
1917 minh = self->base_size.height;
1918 }
1919
1920 /* if this is a user-requested resize, then check against min/max
1921 sizes */
1922
1923 /* smaller than min size or bigger than max size? */
1924 if (w > self->max_size.width) w = self->max_size.width;
1925 if (w < minw) w = minw;
1926 if (h > self->max_size.height) h = self->max_size.height;
1927 if (h < minh) h = minh;
1928
1929 w -= basew;
1930 h -= baseh;
1931
1932 /* keep to the increments */
1933 w /= self->size_inc.width;
1934 h /= self->size_inc.height;
1935
1936 /* you cannot resize to nothing */
1937 if (basew + w < 1) w = 1 - basew;
1938 if (baseh + h < 1) h = 1 - baseh;
1939
1940 /* store the logical size */
1941 SIZE_SET(self->logical_size,
1942 self->size_inc.width > 1 ? w : w + basew,
1943 self->size_inc.height > 1 ? h : h + baseh);
1944
1945 w *= self->size_inc.width;
1946 h *= self->size_inc.height;
1947
1948 w += basew;
1949 h += baseh;
1950
1951 /* adjust the height to match the width for the aspect ratios.
1952 for this, min size is not substituted for base size ever. */
1953 w -= self->base_size.width;
1954 h -= self->base_size.height;
1955
1956 if (self->min_ratio)
1957 if (h * self->min_ratio > w) {
1958 h = (int)(w / self->min_ratio);
1959
1960 /* you cannot resize to nothing */
1961 if (h < 1) {
1962 h = 1;
1963 w = (int)(h * self->min_ratio);
1964 }
1965 }
1966 if (self->max_ratio)
1967 if (h * self->max_ratio < w) {
1968 h = (int)(w / self->max_ratio);
1969
1970 /* you cannot resize to nothing */
1971 if (h < 1) {
1972 h = 1;
1973 w = (int)(h * self->min_ratio);
1974 }
1975 }
1976
1977 w += self->base_size.width;
1978 h += self->base_size.height;
1979 }
1980
1981 g_assert(w > 0);
1982 g_assert(h > 0);
1983
1984 switch (anchor) {
1985 case OB_CORNER_TOPLEFT:
1986 break;
1987 case OB_CORNER_TOPRIGHT:
1988 x -= w - self->area.width;
1989 break;
1990 case OB_CORNER_BOTTOMLEFT:
1991 y -= h - self->area.height;
1992 break;
1993 case OB_CORNER_BOTTOMRIGHT:
1994 x -= w - self->area.width;
1995 y -= h - self->area.height;
1996 break;
1997 }
1998
1999 moved = x != self->area.x || y != self->area.y;
2000 resized = w != self->area.width || h != self->area.height;
2001
2002 oldw = self->area.width;
2003 oldh = self->area.height;
2004 RECT_SET(self->area, x, y, w, h);
2005
2006 /* for app-requested resizes, always resize if 'resized' is true.
2007 for user-requested ones, only resize if final is true, or when
2008 resizing in redraw mode */
2009 send_resize_client = ((!user && resized) ||
2010 (user && (final ||
2011 (resized && config_redraw_resize))));
2012
2013 /* if the client is enlarging, the resize the client before the frame */
2014 if (send_resize_client && user && (w > oldw || h > oldh))
2015 XResizeWindow(ob_display, self->window, MAX(w, oldw), MAX(h, oldh));
2016
2017 /* move/resize the frame to match the request */
2018 if (self->frame) {
2019 if (self->decorations != fdecor || self->max_horz != fhorz)
2020 moved = resized = TRUE;
2021
2022 if (moved || resized)
2023 frame_adjust_area(self->frame, moved, resized, FALSE);
2024
2025 if (!resized && (force_reply || ((!user && moved) || (user && final))))
2026 {
2027 XEvent event;
2028 event.type = ConfigureNotify;
2029 event.xconfigure.display = ob_display;
2030 event.xconfigure.event = self->window;
2031 event.xconfigure.window = self->window;
2032
2033 /* root window real coords */
2034 event.xconfigure.x = self->frame->area.x + self->frame->size.left -
2035 self->border_width;
2036 event.xconfigure.y = self->frame->area.y + self->frame->size.top -
2037 self->border_width;
2038 event.xconfigure.width = w;
2039 event.xconfigure.height = h;
2040 event.xconfigure.border_width = 0;
2041 event.xconfigure.above = self->frame->plate;
2042 event.xconfigure.override_redirect = FALSE;
2043 XSendEvent(event.xconfigure.display, event.xconfigure.window,
2044 FALSE, StructureNotifyMask, &event);
2045 }
2046 }
2047
2048 /* if the client is shrinking, then resize the frame before the client */
2049 if (send_resize_client && (!user || (w <= oldw || h <= oldh)))
2050 XResizeWindow(ob_display, self->window, w, h);
2051
2052 XFlush(ob_display);
2053 }
2054
2055 void client_fullscreen(ObClient *self, gboolean fs, gboolean savearea)
2056 {
2057 int x, y, w, h;
2058
2059 if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
2060 self->fullscreen == fs) return; /* already done */
2061
2062 self->fullscreen = fs;
2063 client_change_state(self); /* change the state hints on the client,
2064 and adjust out layer/stacking */
2065
2066 if (fs) {
2067 if (savearea)
2068 self->pre_fullscreen_area = self->area;
2069
2070 /* these are not actually used cuz client_configure will set them
2071 as appropriate when the window is fullscreened */
2072 x = y = w = h = 0;
2073 } else {
2074 Rect *a;
2075
2076 if (self->pre_fullscreen_area.width > 0 &&
2077 self->pre_fullscreen_area.height > 0)
2078 {
2079 x = self->pre_fullscreen_area.x;
2080 y = self->pre_fullscreen_area.y;
2081 w = self->pre_fullscreen_area.width;
2082 h = self->pre_fullscreen_area.height;
2083 RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
2084 } else {
2085 /* pick some fallbacks... */
2086 a = screen_area_monitor(self->desktop, 0);
2087 x = a->x + a->width / 4;
2088 y = a->y + a->height / 4;
2089 w = a->width / 2;
2090 h = a->height / 2;
2091 }
2092 }
2093
2094 client_setup_decor_and_functions(self);
2095
2096 client_move_resize(self, x, y, w, h);
2097
2098 /* try focus us when we go into fullscreen mode */
2099 client_focus(self);
2100 }
2101
2102 static void client_iconify_recursive(ObClient *self,
2103 gboolean iconic, gboolean curdesk)
2104 {
2105 GSList *it;
2106 gboolean changed = FALSE;
2107
2108
2109 if (self->iconic != iconic) {
2110 ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
2111 self->window);
2112
2113 self->iconic = iconic;
2114
2115 if (iconic) {
2116 if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
2117 long old;
2118
2119 old = self->wmstate;
2120 self->wmstate = IconicState;
2121 if (old != self->wmstate)
2122 PROP_MSG(self->window, kde_wm_change_state,
2123 self->wmstate, 1, 0, 0);
2124
2125 self->ignore_unmaps++;
2126 /* we unmap the client itself so that we can get MapRequest
2127 events, and because the ICCCM tells us to! */
2128 XUnmapWindow(ob_display, self->window);
2129
2130 /* update the focus lists.. iconic windows go to the bottom of
2131 the list, put the new iconic window at the 'top of the
2132 bottom'. */
2133 focus_order_to_top(self);
2134
2135 changed = TRUE;
2136 }
2137 } else {
2138 long old;
2139
2140 if (curdesk)
2141 client_set_desktop(self, screen_desktop, FALSE);
2142
2143 old = self->wmstate;
2144 self->wmstate = self->shaded ? IconicState : NormalState;
2145 if (old != self->wmstate)
2146 PROP_MSG(self->window, kde_wm_change_state,
2147 self->wmstate, 1, 0, 0);
2148
2149 XMapWindow(ob_display, self->window);
2150
2151 /* this puts it after the current focused window */
2152 focus_order_remove(self);
2153 focus_order_add_new(self);
2154
2155 /* this is here cuz with the VIDMODE extension, the viewport can
2156 change while a fullscreen window is iconic, and when it
2157 uniconifies, it would be nice if it did so to the new position
2158 of the viewport */
2159 client_reconfigure(self);
2160
2161 changed = TRUE;
2162 }
2163 }
2164
2165 if (changed) {
2166 client_change_state(self);
2167 client_showhide(self);
2168 screen_update_areas();
2169 }
2170
2171 /* iconify all transients */
2172 for (it = self->transients; it != NULL; it = it->next)
2173 if (it->data != self) client_iconify_recursive(it->data,
2174 iconic, curdesk);
2175 }
2176
2177 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk)
2178 {
2179 /* move up the transient chain as far as possible first */
2180 self = client_search_top_transient(self);
2181
2182 client_iconify_recursive(client_search_top_transient(self),
2183 iconic, curdesk);
2184 }
2185
2186 void client_maximize(ObClient *self, gboolean max, int dir, gboolean savearea)
2187 {
2188 int x, y, w, h;
2189
2190 g_assert(dir == 0 || dir == 1 || dir == 2);
2191 if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
2192
2193 /* check if already done */
2194 if (max) {
2195 if (dir == 0 && self->max_horz && self->max_vert) return;
2196 if (dir == 1 && self->max_horz) return;
2197 if (dir == 2 && self->max_vert) return;
2198 } else {
2199 if (dir == 0 && !self->max_horz && !self->max_vert) return;
2200 if (dir == 1 && !self->max_horz) return;
2201 if (dir == 2 && !self->max_vert) return;
2202 }
2203
2204 /* we just tell it to configure in the same place and client_configure
2205 worries about filling the screen with the window */
2206 x = self->area.x;
2207 y = self->area.y;
2208 w = self->area.width;
2209 h = self->area.height;
2210
2211 if (max) {
2212 if (savearea) {
2213 if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
2214 RECT_SET(self->pre_max_area,
2215 self->area.x, self->pre_max_area.y,
2216 self->area.width, self->pre_max_area.height);
2217 }
2218 if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
2219 RECT_SET(self->pre_max_area,
2220 self->pre_max_area.x, self->area.y,
2221 self->pre_max_area.width, self->area.height);
2222 }
2223 }
2224 } else {
2225 Rect *a;
2226
2227 a = screen_area_monitor(self->desktop, 0);
2228 if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
2229 if (self->pre_max_area.width > 0) {
2230 x = self->pre_max_area.x;
2231 w = self->pre_max_area.width;
2232
2233 RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
2234 0, self->pre_max_area.height);
2235 } else {
2236 /* pick some fallbacks... */
2237 x = a->x + a->width / 4;
2238 w = a->width / 2;
2239 }
2240 }
2241 if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
2242 if (self->pre_max_area.height > 0) {
2243 y = self->pre_max_area.y;
2244 h = self->pre_max_area.height;
2245
2246 RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
2247 self->pre_max_area.width, 0);
2248 } else {
2249 /* pick some fallbacks... */
2250 y = a->y + a->height / 4;
2251 h = a->height / 2;
2252 }
2253 }
2254 }
2255
2256 if (dir == 0 || dir == 1) /* horz */
2257 self->max_horz = max;
2258 if (dir == 0 || dir == 2) /* vert */
2259 self->max_vert = max;
2260
2261 client_change_state(self); /* change the state hints on the client */
2262
2263 client_setup_decor_and_functions(self);
2264
2265 client_move_resize(self, x, y, w, h);
2266 }
2267
2268 void client_shade(ObClient *self, gboolean shade)
2269 {
2270 if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
2271 shade) || /* can't shade */
2272 self->shaded == shade) return; /* already done */
2273
2274 /* when we're iconic, don't change the wmstate */
2275 if (!self->iconic) {
2276 long old;
2277
2278 old = self->wmstate;
2279 self->wmstate = shade ? IconicState : NormalState;
2280 if (old != self->wmstate)
2281 PROP_MSG(self->window, kde_wm_change_state,
2282 self->wmstate, 1, 0, 0);
2283 }
2284
2285 self->shaded = shade;
2286 client_change_state(self);
2287 /* resize the frame to just the titlebar */
2288 frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
2289 }
2290
2291 void client_close(ObClient *self)
2292 {
2293 XEvent ce;
2294
2295 if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
2296
2297 /*
2298 XXX: itd be cool to do timeouts and shit here for killing the client's
2299 process off
2300 like... if the window is around after 5 seconds, then the close button
2301 turns a nice red, and if this function is called again, the client is
2302 explicitly killed.
2303 */
2304
2305 ce.xclient.type = ClientMessage;
2306 ce.xclient.message_type = prop_atoms.wm_protocols;
2307 ce.xclient.display = ob_display;
2308 ce.xclient.window = self->window;
2309 ce.xclient.format = 32;
2310 ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
2311 ce.xclient.data.l[1] = event_lasttime;
2312 ce.xclient.data.l[2] = 0l;
2313 ce.xclient.data.l[3] = 0l;
2314 ce.xclient.data.l[4] = 0l;
2315 XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
2316 }
2317
2318 void client_kill(ObClient *self)
2319 {
2320 XKillClient(ob_display, self->window);
2321 }
2322
2323 void client_set_desktop_recursive(ObClient *self,
2324 guint target, gboolean donthide)
2325 {
2326 guint old;
2327 GSList *it;
2328
2329 if (target != self->desktop) {
2330
2331 ob_debug("Setting desktop %u\n", target+1);
2332
2333 g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
2334
2335 /* remove from the old desktop(s) */
2336 focus_order_remove(self);
2337
2338 old = self->desktop;
2339 self->desktop = target;
2340 PROP_SET32(self->window, net_wm_desktop, cardinal, target);
2341 /* the frame can display the current desktop state */
2342 frame_adjust_state(self->frame);
2343 /* 'move' the window to the new desktop */
2344 if (!donthide)
2345 client_showhide(self);
2346 /* raise if it was not already on the desktop */
2347 if (old != DESKTOP_ALL)
2348 client_raise(self);
2349 screen_update_areas();
2350
2351 /* add to the new desktop(s) */
2352 if (config_focus_new)
2353 focus_order_to_top(self);
2354 else
2355 focus_order_to_bottom(self);
2356 }
2357
2358 /* move all transients */
2359 for (it = self->transients; it != NULL; it = it->next)
2360 if (it->data != self) client_set_desktop_recursive(it->data,
2361 target, donthide);
2362 }
2363
2364 void client_set_desktop(ObClient *self, guint target, gboolean donthide)
2365 {
2366 client_set_desktop_recursive(client_search_top_transient(self),
2367 target, donthide);
2368 }
2369
2370 ObClient *client_search_modal_child(ObClient *self)
2371 {
2372 GSList *it;
2373 ObClient *ret;
2374
2375 for (it = self->transients; it != NULL; it = it->next) {
2376 ObClient *c = it->data;
2377 if ((ret = client_search_modal_child(c))) return ret;
2378 if (c->modal) return c;
2379 }
2380 return NULL;
2381 }
2382
2383 gboolean client_validate(ObClient *self)
2384 {
2385 XEvent e;
2386
2387 XSync(ob_display, FALSE); /* get all events on the server */
2388
2389 if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
2390 XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
2391 XPutBackEvent(ob_display, &e);
2392 return FALSE;
2393 }
2394
2395 return TRUE;
2396 }
2397
2398 void client_set_wm_state(ObClient *self, long state)
2399 {
2400 if (state == self->wmstate) return; /* no change */
2401
2402 switch (state) {
2403 case IconicState:
2404 client_iconify(self, TRUE, TRUE);
2405 break;
2406 case NormalState:
2407 client_iconify(self, FALSE, TRUE);
2408 break;
2409 }
2410 }
2411
2412 void client_set_state(ObClient *self, Atom action, long data1, long data2)
2413 {
2414 gboolean shaded = self->shaded;
2415 gboolean fullscreen = self->fullscreen;
2416 gboolean undecorated = self->undecorated;
2417 gboolean max_horz = self->max_horz;
2418 gboolean max_vert = self->max_vert;
2419 int i;
2420
2421 if (!(action == prop_atoms.net_wm_state_add ||
2422 action == prop_atoms.net_wm_state_remove ||
2423 action == prop_atoms.net_wm_state_toggle))
2424 /* an invalid action was passed to the client message, ignore it */
2425 return;
2426
2427 for (i = 0; i < 2; ++i) {
2428 Atom state = i == 0 ? data1 : data2;
2429
2430 if (!state) continue;
2431
2432 /* if toggling, then pick whether we're adding or removing */
2433 if (action == prop_atoms.net_wm_state_toggle) {
2434 if (state == prop_atoms.net_wm_state_modal)
2435 action = self->modal ? prop_atoms.net_wm_state_remove :
2436 prop_atoms.net_wm_state_add;
2437 else if (state == prop_atoms.net_wm_state_maximized_vert)
2438 action = self->max_vert ? prop_atoms.net_wm_state_remove :
2439 prop_atoms.net_wm_state_add;
2440 else if (state == prop_atoms.net_wm_state_maximized_horz)
2441 action = self->max_horz ? prop_atoms.net_wm_state_remove :
2442 prop_atoms.net_wm_state_add;
2443 else if (state == prop_atoms.net_wm_state_shaded)
2444 action = shaded ? prop_atoms.net_wm_state_remove :
2445 prop_atoms.net_wm_state_add;
2446 else if (state == prop_atoms.net_wm_state_skip_taskbar)
2447 action = self->skip_taskbar ?
2448 prop_atoms.net_wm_state_remove :
2449 prop_atoms.net_wm_state_add;
2450 else if (state == prop_atoms.net_wm_state_skip_pager)
2451 action = self->skip_pager ?
2452 prop_atoms.net_wm_state_remove :
2453 prop_atoms.net_wm_state_add;
2454 else if (state == prop_atoms.net_wm_state_fullscreen)
2455 action = fullscreen ?
2456 prop_atoms.net_wm_state_remove :
2457 prop_atoms.net_wm_state_add;
2458 else if (state == prop_atoms.net_wm_state_above)
2459 action = self->above ? prop_atoms.net_wm_state_remove :
2460 prop_atoms.net_wm_state_add;
2461 else if (state == prop_atoms.net_wm_state_below)
2462 action = self->below ? prop_atoms.net_wm_state_remove :
2463 prop_atoms.net_wm_state_add;
2464 else if (state == prop_atoms.ob_wm_state_undecorated)
2465 action = undecorated ? prop_atoms.net_wm_state_remove :
2466 prop_atoms.net_wm_state_add;
2467 }
2468
2469 if (action == prop_atoms.net_wm_state_add) {
2470 if (state == prop_atoms.net_wm_state_modal) {
2471 /* XXX raise here or something? */
2472 self->modal = TRUE;
2473 } else if (state == prop_atoms.net_wm_state_maximized_vert) {
2474 max_vert = TRUE;
2475 } else if (state == prop_atoms.net_wm_state_maximized_horz) {
2476 max_horz = TRUE;
2477 } else if (state == prop_atoms.net_wm_state_shaded) {
2478 shaded = TRUE;
2479 } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
2480 self->skip_taskbar = TRUE;
2481 } else if (state == prop_atoms.net_wm_state_skip_pager) {
2482 self->skip_pager = TRUE;
2483 } else if (state == prop_atoms.net_wm_state_fullscreen) {
2484 fullscreen = TRUE;
2485 } else if (state == prop_atoms.net_wm_state_above) {
2486 self->above = TRUE;
2487 } else if (state == prop_atoms.net_wm_state_below) {
2488 self->below = TRUE;
2489 } else if (state == prop_atoms.ob_wm_state_undecorated) {
2490 undecorated = TRUE;
2491 }
2492
2493 } else { /* action == prop_atoms.net_wm_state_remove */
2494 if (state == prop_atoms.net_wm_state_modal) {
2495 self->modal = FALSE;
2496 } else if (state == prop_atoms.net_wm_state_maximized_vert) {
2497 max_vert = FALSE;
2498 } else if (state == prop_atoms.net_wm_state_maximized_horz) {
2499 max_horz = FALSE;
2500 } else if (state == prop_atoms.net_wm_state_shaded) {
2501 shaded = FALSE;
2502 } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
2503 self->skip_taskbar = FALSE;
2504 } else if (state == prop_atoms.net_wm_state_skip_pager) {
2505 self->skip_pager = FALSE;
2506 } else if (state == prop_atoms.net_wm_state_fullscreen) {
2507 fullscreen = FALSE;
2508 } else if (state == prop_atoms.net_wm_state_above) {
2509 self->above = FALSE;
2510 } else if (state == prop_atoms.net_wm_state_below) {
2511 self->below = FALSE;
2512 } else if (state == prop_atoms.ob_wm_state_undecorated) {
2513 undecorated = FALSE;
2514 }
2515 }
2516 }
2517 if (max_horz != self->max_horz || max_vert != self->max_vert) {
2518 if (max_horz != self->max_horz && max_vert != self->max_vert) {
2519 /* toggling both */
2520 if (max_horz == max_vert) { /* both going the same way */
2521 client_maximize(self, max_horz, 0, TRUE);
2522 } else {
2523 client_maximize(self, max_horz, 1, TRUE);
2524 client_maximize(self, max_vert, 2, TRUE);
2525 }
2526 } else {
2527 /* toggling one */
2528 if (max_horz != self->max_horz)
2529 client_maximize(self, max_horz, 1, TRUE);
2530 else
2531 client_maximize(self, max_vert, 2, TRUE);
2532 }
2533 }
2534 /* change fullscreen state before shading, as it will affect if the window
2535 can shade or not */
2536 if (fullscreen != self->fullscreen)
2537 client_fullscreen(self, fullscreen, TRUE);
2538 if (shaded != self->shaded)
2539 client_shade(self, shaded);
2540 if (undecorated != self->undecorated)
2541 client_set_undecorated(self, undecorated);
2542 client_calc_layer(self);
2543 client_change_state(self); /* change the hint to reflect these changes */
2544 }
2545
2546 ObClient *client_focus_target(ObClient *self)
2547 {
2548 ObClient *child;
2549
2550 /* if we have a modal child, then focus it, not us */
2551 child = client_search_modal_child(client_search_top_transient(self));
2552 if (child) return child;
2553 return self;
2554 }
2555
2556 gboolean client_can_focus(ObClient *self)
2557 {
2558 XEvent ev;
2559
2560 /* choose the correct target */
2561 self = client_focus_target(self);
2562
2563 if (!self->frame->visible)
2564 return FALSE;
2565
2566 if (!(self->can_focus || self->focus_notify))
2567 return FALSE;
2568
2569 /* do a check to see if the window has already been unmapped or destroyed
2570 do this intelligently while watching out for unmaps we've generated
2571 (ignore_unmaps > 0) */
2572 if (XCheckTypedWindowEvent(ob_display, self->window,
2573 DestroyNotify, &ev)) {
2574 XPutBackEvent(ob_display, &ev);
2575 return FALSE;
2576 }
2577 while (XCheckTypedWindowEvent(ob_display, self->window,
2578 UnmapNotify, &ev)) {
2579 if (self->ignore_unmaps) {
2580 self->ignore_unmaps--;
2581 } else {
2582 XPutBackEvent(ob_display, &ev);
2583 return FALSE;
2584 }
2585 }
2586
2587 return TRUE;
2588 }
2589
2590 gboolean client_focus(ObClient *self)
2591 {
2592 /* choose the correct target */
2593 self = client_focus_target(self);
2594
2595 if (!client_can_focus(self)) {
2596 if (!self->frame->visible) {
2597 /* update the focus lists */
2598 focus_order_to_top(self);
2599 }
2600 return FALSE;
2601 }
2602
2603 if (self->can_focus) {
2604 /* RevertToPointerRoot causes much more headache than RevertToNone, so
2605 I choose to use it always, hopefully to find errors quicker, if any
2606 are left. (I hate X. I hate focus events.)
2607
2608 Update: Changing this to RevertToNone fixed a bug with mozilla (bug
2609 #799. So now it is RevertToNone again.
2610 */
2611 XSetInputFocus(ob_display, self->window, RevertToNone,
2612 event_lasttime);
2613 }
2614
2615 if (self->focus_notify) {
2616 XEvent ce;
2617 ce.xclient.type = ClientMessage;
2618 ce.xclient.message_type = prop_atoms.wm_protocols;
2619 ce.xclient.display = ob_display;
2620 ce.xclient.window = self->window;
2621 ce.xclient.format = 32;
2622 ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
2623 ce.xclient.data.l[1] = event_lasttime;
2624 ce.xclient.data.l[2] = 0l;
2625 ce.xclient.data.l[3] = 0l;
2626 ce.xclient.data.l[4] = 0l;
2627 XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
2628 }
2629
2630 #ifdef DEBUG_FOCUS
2631 ob_debug("%sively focusing %lx at %d\n",
2632 (self->can_focus ? "act" : "pass"),
2633 self->window, (int) event_lasttime);
2634 #endif
2635
2636 /* Cause the FocusIn to come back to us. Important for desktop switches,
2637 since otherwise we'll have no FocusIn on the queue and send it off to
2638 the focus_backup. */
2639 XSync(ob_display, FALSE);
2640 return TRUE;
2641 }
2642
2643 void client_unfocus(ObClient *self)
2644 {
2645 if (focus_client == self) {
2646 #ifdef DEBUG_FOCUS
2647 ob_debug("client_unfocus for %lx\n", self->window);
2648 #endif
2649 focus_fallback(OB_FOCUS_FALLBACK_UNFOCUSING);
2650 }
2651 }
2652
2653 void client_activate(ObClient *self, gboolean here)
2654 {
2655 if (client_normal(self) && screen_showing_desktop)
2656 screen_show_desktop(FALSE);
2657 if (self->iconic)
2658 client_iconify(self, FALSE, here);
2659 if (self->desktop != DESKTOP_ALL &&
2660 self->desktop != screen_desktop) {
2661 if (here)
2662 client_set_desktop(self, screen_desktop, FALSE);
2663 else
2664 screen_set_desktop(self->desktop);
2665 } else if (!self->frame->visible)
2666 /* if its not visible for other reasons, then don't mess
2667 with it */
2668 return;
2669 if (self->shaded)
2670 client_shade(self, FALSE);
2671
2672 client_focus(self);
2673
2674 /* we do this an action here. this is rather important. this is because
2675 we want the results from the focus change to take place BEFORE we go
2676 about raising the window. when a fullscreen window loses focus, we need
2677 this or else the raise wont be able to raise above the to-lose-focus
2678 fullscreen window. */
2679 client_raise(self);
2680 }
2681
2682 void client_raise(ObClient *self)
2683 {
2684 action_run_string("Raise", self);
2685 }
2686
2687 void client_lower(ObClient *self)
2688 {
2689 action_run_string("Raise", self);
2690 }
2691
2692 gboolean client_focused(ObClient *self)
2693 {
2694 return self == focus_client;
2695 }
2696
2697 static ObClientIcon* client_icon_recursive(ObClient *self, int w, int h)
2698 {
2699 guint i;
2700 /* si is the smallest image >= req */
2701 /* li is the largest image < req */
2702 unsigned long size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;
2703
2704 if (!self->nicons) {
2705 ObClientIcon *parent = NULL;
2706
2707 if (self->transient_for) {
2708 if (self->transient_for != OB_TRAN_GROUP)
2709 parent = client_icon_recursive(self->transient_for, w, h);
2710 else {
2711 GSList *it;
2712 for (it = self->group->members; it; it = g_slist_next(it)) {
2713 ObClient *c = it->data;
2714 if (c != self && !c->transient_for) {
2715 if ((parent = client_icon_recursive(c, w, h)))
2716 break;
2717 }
2718 }
2719 }
2720 }
2721
2722 return parent;
2723 }
2724
2725 for (i = 0; i < self->nicons; ++i) {
2726 size = self->icons[i].width * self->icons[i].height;
2727 if (size < smallest && size >= (unsigned)(w * h)) {
2728 smallest = size;
2729 si = i;
2730 }
2731 if (size > largest && size <= (unsigned)(w * h)) {
2732 largest = size;
2733 li = i;
2734 }
2735 }
2736 if (largest == 0) /* didnt find one smaller than the requested size */
2737 return &self->icons[si];
2738 return &self->icons[li];
2739 }
2740
2741 const ObClientIcon* client_icon(ObClient *self, int w, int h)
2742 {
2743 ObClientIcon *ret;
2744 static ObClientIcon deficon;
2745
2746 if (!(ret = client_icon_recursive(self, w, h))) {
2747 deficon.width = deficon.height = 48;
2748 deficon.data = ob_rr_theme->def_win_icon;
2749 ret = &deficon;
2750 }
2751 return ret;
2752 }
2753
2754 /* this be mostly ripped from fvwm */
2755 ObClient *client_find_directional(ObClient *c, ObDirection dir)
2756 {
2757 int my_cx, my_cy, his_cx, his_cy;
2758 int offset = 0;
2759 int distance = 0;
2760 int score, best_score;
2761 ObClient *best_client, *cur;
2762 GList *it;
2763
2764 if(!client_list)
2765 return NULL;
2766
2767 /* first, find the centre coords of the currently focused window */
2768 my_cx = c->frame->area.x + c->frame->area.width / 2;
2769 my_cy = c->frame->area.y + c->frame->area.height / 2;
2770
2771 best_score = -1;
2772 best_client = NULL;
2773
2774 for(it = g_list_first(client_list); it; it = it->next) {
2775 cur = it->data;
2776
2777 /* the currently selected window isn't interesting */
2778 if(cur == c)
2779 continue;
2780 if (!client_normal(cur))
2781 continue;
2782 if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
2783 continue;
2784 if(cur->iconic)
2785 continue;
2786 if(client_focus_target(cur) == cur &&
2787 !(cur->can_focus || cur->focus_notify))
2788 continue;
2789
2790 /* find the centre coords of this window, from the
2791 * currently focused window's point of view */
2792 his_cx = (cur->frame->area.x - my_cx)
2793 + cur->frame->area.width / 2;
2794 his_cy = (cur->frame->area.y - my_cy)
2795 + cur->frame->area.height / 2;
2796
2797 if(dir == OB_DIRECTION_NORTHEAST || dir == OB_DIRECTION_SOUTHEAST ||
2798 dir == OB_DIRECTION_SOUTHWEST || dir == OB_DIRECTION_NORTHWEST) {
2799 int tx;
2800 /* Rotate the diagonals 45 degrees counterclockwise.
2801 * To do this, multiply the matrix /+h +h\ with the
2802 * vector (x y). \-h +h/
2803 * h = sqrt(0.5). We can set h := 1 since absolute
2804 * distance doesn't matter here. */
2805 tx = his_cx + his_cy;
2806 his_cy = -his_cx + his_cy;
2807 his_cx = tx;
2808 }
2809
2810 switch(dir) {
2811 case OB_DIRECTION_NORTH:
2812 case OB_DIRECTION_SOUTH:
2813 case OB_DIRECTION_NORTHEAST:
2814 case OB_DIRECTION_SOUTHWEST:
2815 offset = (his_cx < 0) ? -his_cx : his_cx;
2816 distance = ((dir == OB_DIRECTION_NORTH ||
2817 dir == OB_DIRECTION_NORTHEAST) ?
2818 -his_cy : his_cy);
2819 break;
2820 case OB_DIRECTION_EAST:
2821 case OB_DIRECTION_WEST:
2822 case OB_DIRECTION_SOUTHEAST:
2823 case OB_DIRECTION_NORTHWEST:
2824 offset = (his_cy < 0) ? -his_cy : his_cy;
2825 distance = ((dir == OB_DIRECTION_WEST ||
2826 dir == OB_DIRECTION_NORTHWEST) ?
2827 -his_cx : his_cx);
2828 break;
2829 }
2830
2831 /* the target must be in the requested direction */
2832 if(distance <= 0)
2833 continue;
2834
2835 /* Calculate score for this window. The smaller the better. */
2836 score = distance + offset;
2837
2838 /* windows more than 45 degrees off the direction are
2839 * heavily penalized and will only be chosen if nothing
2840 * else within a million pixels */
2841 if(offset > distance)
2842 score += 1000000;
2843
2844 if(best_score == -1 || score < best_score)
2845 best_client = cur,
2846 best_score = score;
2847 }
2848
2849 return best_client;
2850 }
2851
2852 void client_set_layer(ObClient *self, int layer)
2853 {
2854 if (layer < 0) {
2855 self->below = TRUE;
2856 self->above = FALSE;
2857 } else if (layer == 0) {
2858 self->below = self->above = FALSE;
2859 } else {
2860 self->below = FALSE;
2861 self->above = TRUE;
2862 }
2863 client_calc_layer(self);
2864 client_change_state(self); /* reflect this in the state hints */
2865 }
2866
2867 void client_set_undecorated(ObClient *self, gboolean undecorated)
2868 {
2869 if (self->undecorated != undecorated) {
2870 self->undecorated = undecorated;
2871 client_setup_decor_and_functions(self);
2872 client_change_state(self); /* reflect this in the state hints */
2873 }
2874 }
2875
2876 guint client_monitor(ObClient *self)
2877 {
2878 guint i;
2879
2880 for (i = 0; i < screen_num_monitors; ++i) {
2881 Rect *area = screen_physical_area_monitor(i);
2882 if (RECT_INTERSECTS_RECT(*area, self->frame->area))
2883 break;
2884 }
2885 if (i == screen_num_monitors) i = 0;
2886 g_assert(i < screen_num_monitors);
2887 return i;
2888 }
2889
2890 ObClient *client_search_top_transient(ObClient *self)
2891 {
2892 /* move up the transient chain as far as possible */
2893 if (self->transient_for) {
2894 if (self->transient_for != OB_TRAN_GROUP) {
2895 return client_search_top_transient(self->transient_for);
2896 } else {
2897 GSList *it;
2898
2899 g_assert(self->group);
2900
2901 for (it = self->group->members; it; it = it->next) {
2902 ObClient *c = it->data;
2903
2904 /* checking transient_for prevents infinate loops! */
2905 if (c != self && !c->transient_for)
2906 break;
2907 }
2908 if (it)
2909 return it->data;
2910 }
2911 }
2912
2913 return self;
2914 }
2915
2916 ObClient *client_search_focus_parent(ObClient *self)
2917 {
2918 if (self->transient_for) {
2919 if (self->transient_for != OB_TRAN_GROUP) {
2920 if (client_focused(self->transient_for))
2921 return self->transient_for;
2922 } else {
2923 GSList *it;
2924
2925 for (it = self->group->members; it; it = it->next) {
2926 ObClient *c = it->data;
2927
2928 /* checking transient_for prevents infinate loops! */
2929 if (c != self && !c->transient_for)
2930 if (client_focused(c))
2931 return c;
2932 }
2933 }
2934 }
2935
2936 return NULL;
2937 }
2938
2939 ObClient *client_search_parent(ObClient *self, ObClient *search)
2940 {
2941 if (self->transient_for) {
2942 if (self->transient_for != OB_TRAN_GROUP) {
2943 if (self->transient_for == search)
2944 return search;
2945 } else {
2946 GSList *it;
2947
2948 for (it = self->group->members; it; it = it->next) {
2949 ObClient *c = it->data;
2950
2951 /* checking transient_for prevents infinate loops! */
2952 if (c != self && !c->transient_for)
2953 if (c == search)
2954 return search;
2955 }
2956 }
2957 }
2958
2959 return NULL;
2960 }
2961
2962 ObClient *client_search_transient(ObClient *self, ObClient *search)
2963 {
2964 GSList *sit;
2965
2966 for (sit = self->transients; sit; sit = g_slist_next(sit)) {
2967 if (sit->data == search)
2968 return search;
2969 if (client_search_transient(sit->data, search))
2970 return search;
2971 }
2972 return NULL;
2973 }
2974
2975 void client_update_sm_client_id(ObClient *self)
2976 {
2977 g_free(self->sm_client_id);
2978 self->sm_client_id = NULL;
2979
2980 if (!PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id) &&
2981 self->group)
2982 PROP_GETS(self->group->leader, sm_client_id, locale,
2983 &self->sm_client_id);
2984 }
2985
2986 /* finds the nearest edge in the given direction from the current client
2987 * note to self: the edge is the -frame- edge (the actual one), not the
2988 * client edge.
2989 */
2990 int client_directional_edge_search(ObClient *c, ObDirection dir)
2991 {
2992 int dest;
2993 int my_edge_start, my_edge_end, my_offset;
2994 GList *it;
2995 Rect *a;
2996
2997 if(!client_list)
2998 return -1;
2999
3000 a = screen_area(c->desktop);
3001
3002 switch(dir) {
3003 case OB_DIRECTION_NORTH:
3004 my_edge_start = c->frame->area.x;
3005 my_edge_end = c->frame->area.x + c->frame->area.width;
3006 my_offset = c->frame->area.y;
3007
3008 dest = a->y; /* default: top of screen */
3009
3010 for(it = g_list_first(client_list); it; it = it->next) {
3011 int his_edge_start, his_edge_end, his_offset;
3012 ObClient *cur = it->data;
3013
3014 if(cur == c)
3015 continue;
3016 if(!client_normal(cur))
3017 continue;
3018 if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3019 continue;
3020 if(cur->iconic)
3021 continue;
3022
3023 his_edge_start = cur->frame->area.x;
3024 his_edge_end = cur->frame->area.x + cur->frame->area.width;
3025 his_offset = cur->frame->area.y + cur->frame->area.height;
3026
3027 if(his_offset + 1 > my_offset)
3028 continue;
3029
3030 if(his_offset < dest)
3031 continue;
3032
3033 if(his_edge_start >= my_edge_start &&
3034 his_edge_start <= my_edge_end)
3035 dest = his_offset;
3036
3037 if(my_edge_start >= his_edge_start &&
3038 my_edge_start <= his_edge_end)
3039 dest = his_offset;
3040
3041 }
3042 break;
3043 case OB_DIRECTION_SOUTH:
3044 my_edge_start = c->frame->area.x;
3045 my_edge_end = c->frame->area.x + c->frame->area.width;
3046 my_offset = c->frame->area.y + c->frame->area.height;
3047
3048 dest = a->y + a->height; /* default: bottom of screen */
3049
3050 for(it = g_list_first(client_list); it; it = it->next) {
3051 int his_edge_start, his_edge_end, his_offset;
3052 ObClient *cur = it->data;
3053
3054 if(cur == c)
3055 continue;
3056 if(!client_normal(cur))
3057 continue;
3058 if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3059 continue;
3060 if(cur->iconic)
3061 continue;
3062
3063 his_edge_start = cur->frame->area.x;
3064 his_edge_end = cur->frame->area.x + cur->frame->area.width;
3065 his_offset = cur->frame->area.y;
3066
3067
3068 if(his_offset - 1 < my_offset)
3069 continue;
3070
3071 if(his_offset > dest)
3072 continue;
3073
3074 if(his_edge_start >= my_edge_start &&
3075 his_edge_start <= my_edge_end)
3076 dest = his_offset;
3077
3078 if(my_edge_start >= his_edge_start &&
3079 my_edge_start <= his_edge_end)
3080 dest = his_offset;
3081
3082 }
3083 break;
3084 case OB_DIRECTION_WEST:
3085 my_edge_start = c->frame->area.y;
3086 my_edge_end = c->frame->area.y + c->frame->area.height;
3087 my_offset = c->frame->area.x;
3088
3089 dest = a->x; /* default: leftmost egde of screen */
3090
3091 for(it = g_list_first(client_list); it; it = it->next) {
3092 int his_edge_start, his_edge_end, his_offset;
3093 ObClient *cur = it->data;
3094
3095 if(cur == c)
3096 continue;
3097 if(!client_normal(cur))
3098 continue;
3099 if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3100 continue;
3101 if(cur->iconic)
3102 continue;
3103
3104 his_edge_start = cur->frame->area.y;
3105 his_edge_end = cur->frame->area.y + cur->frame->area.height;
3106 his_offset = cur->frame->area.x + cur->frame->area.width;
3107
3108 if(his_offset + 1 > my_offset)
3109 continue;
3110
3111 if(his_offset < dest)
3112 continue;
3113
3114 if(his_edge_start >= my_edge_start &&
3115 his_edge_start <= my_edge_end)
3116 dest = his_offset;
3117
3118 if(my_edge_start >= his_edge_start &&
3119 my_edge_start <= his_edge_end)
3120 dest = his_offset;
3121
3122
3123 }
3124 break;
3125 case OB_DIRECTION_EAST:
3126 my_edge_start = c->frame->area.y;
3127 my_edge_end = c->frame->area.y + c->frame->area.height;
3128 my_offset = c->frame->area.x + c->frame->area.width;
3129
3130 dest = a->x + a->width; /* default: rightmost edge of screen */
3131
3132 for(it = g_list_first(client_list); it; it = it->next) {
3133 int his_edge_start, his_edge_end, his_offset;
3134 ObClient *cur = it->data;
3135
3136 if(cur == c)
3137 continue;
3138 if(!client_normal(cur))
3139 continue;
3140 if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3141 continue;
3142 if(cur->iconic)
3143 continue;
3144
3145 his_edge_start = cur->frame->area.y;
3146 his_edge_end = cur->frame->area.y + cur->frame->area.height;
3147 his_offset = cur->frame->area.x;
3148
3149 if(his_offset - 1 < my_offset)
3150 continue;
3151
3152 if(his_offset > dest)
3153 continue;
3154
3155 if(his_edge_start >= my_edge_start &&
3156 his_edge_start <= my_edge_end)
3157 dest = his_offset;
3158
3159 if(my_edge_start >= his_edge_start &&
3160 my_edge_start <= his_edge_end)
3161 dest = his_offset;
3162
3163 }
3164 break;
3165 case OB_DIRECTION_NORTHEAST:
3166 case OB_DIRECTION_SOUTHEAST:
3167 case OB_DIRECTION_NORTHWEST:
3168 case OB_DIRECTION_SOUTHWEST:
3169 /* not implemented */
3170 default:
3171 g_assert_not_reached();
3172 }
3173 return dest;
3174 }
3175
3176 ObClient* client_under_pointer()
3177 {
3178 int x, y;
3179 GList *it;
3180 ObClient *ret = NULL;
3181
3182 if (screen_pointer_pos(&x, &y)) {
3183 for (it = stacking_list; it != NULL; it = it->next) {
3184 if (WINDOW_IS_CLIENT(it->data)) {
3185 ObClient *c = WINDOW_AS_CLIENT(it->data);
3186 if (c->frame->visible &&
3187 RECT_CONTAINS(c->frame->area, x, y)) {
3188 ret = c;
3189 break;
3190 }
3191 }
3192 }
3193 }
3194 return ret;
3195 }
This page took 0.180677 seconds and 4 git commands to generate.