1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2004 Mikael Magnusson
5 Copyright (c) 2003 Ben Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
22 #include "startupnotify.h"
26 #include "moveresize.h"
29 #include "extensions.h"
39 #include "menuframe.h"
42 #include "render/render.h"
45 #include <X11/Xutil.h>
47 /*! The event mask to grab on client windows */
48 #define CLIENT_EVENTMASK (PropertyChangeMask | FocusChangeMask | \
51 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
56 ObClientDestructor func
;
60 GList
*client_list
= NULL
;
61 GSList
*client_destructors
= NULL
;
63 static void client_get_all(ObClient
*self
);
64 static void client_toggle_border(ObClient
*self
, gboolean show
);
65 static void client_get_startup_id(ObClient
*self
);
66 static void client_get_area(ObClient
*self
);
67 static void client_get_desktop(ObClient
*self
);
68 static void client_get_state(ObClient
*self
);
69 static void client_get_shaped(ObClient
*self
);
70 static void client_get_mwm_hints(ObClient
*self
);
71 static void client_get_gravity(ObClient
*self
);
72 static void client_showhide(ObClient
*self
);
73 static void client_change_allowed_actions(ObClient
*self
);
74 static void client_change_state(ObClient
*self
);
75 static void client_apply_startup_state(ObClient
*self
);
76 static void client_restore_session_state(ObClient
*self
);
77 static void client_restore_session_stacking(ObClient
*self
);
78 static void client_urgent_notify(ObClient
*self
);
80 void client_startup(gboolean reconfig
)
87 void client_shutdown(gboolean reconfig
)
91 void client_add_destructor(ObClientDestructor func
, gpointer data
)
93 Destructor
*d
= g_new(Destructor
, 1);
96 client_destructors
= g_slist_prepend(client_destructors
, d
);
99 void client_remove_destructor(ObClientDestructor func
)
103 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
104 Destructor
*d
= it
->data
;
105 if (d
->func
== func
) {
107 client_destructors
= g_slist_delete_link(client_destructors
, it
);
113 void client_set_list()
115 Window
*windows
, *win_it
;
117 guint size
= g_list_length(client_list
);
119 /* create an array of the window ids */
121 windows
= g_new(Window
, size
);
123 for (it
= client_list
; it
; it
= g_list_next(it
), ++win_it
)
124 *win_it
= ((ObClient
*)it
->data
)->window
;
128 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
129 net_client_list
, window
, (gulong
*)windows
, size
);
138 void client_foreach_transient(ObClient *self, ObClientForeachFunc func, gpointer data)
142 for (it = self->transients; it; it = g_slist_next(it)) {
143 if (!func(it->data, data)) return;
144 client_foreach_transient(it->data, func, data);
148 void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, gpointer data)
150 if (self->transient_for) {
151 if (self->transient_for != OB_TRAN_GROUP) {
152 if (!func(self->transient_for, data)) return;
153 client_foreach_ancestor(self->transient_for, func, data);
157 for (it = self->group->members; it; it = g_slist_next(it))
158 if (it->data != self &&
159 !((ObClient*)it->data)->transient_for) {
160 if (!func(it->data, data)) return;
161 client_foreach_ancestor(it->data, func, data);
168 void client_manage_all()
173 XWindowAttributes attrib
;
175 XQueryTree(ob_display
, RootWindow(ob_display
, ob_screen
),
176 &w
, &w
, &children
, &nchild
);
178 /* remove all icon windows from the list */
179 for (i
= 0; i
< nchild
; i
++) {
180 if (children
[i
] == None
) continue;
181 wmhints
= XGetWMHints(ob_display
, children
[i
]);
183 if ((wmhints
->flags
& IconWindowHint
) &&
184 (wmhints
->icon_window
!= children
[i
]))
185 for (j
= 0; j
< nchild
; j
++)
186 if (children
[j
] == wmhints
->icon_window
) {
194 for (i
= 0; i
< nchild
; ++i
) {
195 if (children
[i
] == None
)
197 if (XGetWindowAttributes(ob_display
, children
[i
], &attrib
)) {
198 if (attrib
.override_redirect
) continue;
200 if (attrib
.map_state
!= IsUnmapped
)
201 client_manage(children
[i
]);
207 static ObAppSettings
*get_settings(ObClient
*client
)
209 GSList
*a
= config_per_app_settings
;
212 ObAppSettings
*app
= (ObAppSettings
*) a
->data
;
215 (app
->name
&& !app
->class && !strcmp(app
->name
, client
->name
))
216 || (app
->class && !app
->name
&& !strcmp(app
->class, client
->class))
217 || (app
->class && app
->name
&& !strcmp(app
->class, client
->class)
218 && !strcmp(app
->name
, client
->name
))
220 ob_debug("Window matching: %s\n", app
->name
);
221 /* Match if no role was specified in the per app setting, or if the string
222 * matches the beginning of the role, since apps like to set the role to
223 * things like browser-window-23c4b2f */
224 if (!app
->role
|| !strncmp(app
->role
, client
->role
, strlen(app
->role
)))
233 void client_manage(Window window
)
237 XWindowAttributes attrib
;
238 XSetWindowAttributes attrib_set
;
240 gboolean activate
= FALSE
;
241 ObAppSettings
*settings
;
245 /* check if it has already been unmapped by the time we started mapping
246 the grab does a sync so we don't have to here */
247 if (XCheckTypedWindowEvent(ob_display
, window
, DestroyNotify
, &e
) ||
248 XCheckTypedWindowEvent(ob_display
, window
, UnmapNotify
, &e
)) {
249 XPutBackEvent(ob_display
, &e
);
252 return; /* don't manage it */
255 /* make sure it isn't an override-redirect window */
256 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
257 attrib
.override_redirect
) {
259 return; /* don't manage it */
262 /* is the window a docking app */
263 if ((wmhint
= XGetWMHints(ob_display
, window
))) {
264 if ((wmhint
->flags
& StateHint
) &&
265 wmhint
->initial_state
== WithdrawnState
) {
266 dock_add(window
, wmhint
);
274 ob_debug("Managing window: %lx\n", window
);
276 /* choose the events we want to receive on the CLIENT window */
277 attrib_set
.event_mask
= CLIENT_EVENTMASK
;
278 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
279 XChangeWindowAttributes(ob_display
, window
,
280 CWEventMask
|CWDontPropagate
, &attrib_set
);
283 /* create the ObClient struct, and populate it from the hints on the
285 self
= g_new0(ObClient
, 1);
286 self
->obwin
.type
= Window_Client
;
287 self
->window
= window
;
289 /* non-zero defaults */
290 self
->title_count
= 1;
291 self
->wmstate
= NormalState
;
293 self
->desktop
= screen_num_desktops
; /* always an invalid value */
295 client_get_all(self
);
296 client_restore_session_state(self
);
298 sn_app_started(self
->class);
300 /* update the focus lists, do this before the call to change_state or
301 it can end up in the list twice! */
302 focus_order_add_new(self
);
304 client_change_state(self
);
306 /* remove the client's border (and adjust re gravity) */
307 client_toggle_border(self
, FALSE
);
309 /* specify that if we exit, the window should not be destroyed and should
310 be reparented back to root automatically */
311 XChangeSaveSet(ob_display
, window
, SetModeInsert
);
313 /* create the decoration frame for the client window */
314 self
->frame
= frame_new();
316 frame_grab_client(self
->frame
, self
);
320 client_apply_startup_state(self
);
322 /* get and set application level settings */
323 settings
= get_settings(self
);
325 stacking_add(CLIENT_AS_WINDOW(self
));
326 client_restore_session_stacking(self
);
329 /* Don't worry, we won't actually both shade and undecorate the
330 * window when push comes to shove. */
331 if (settings
->shade
!= -1)
332 client_shade(self
, settings
->shade
);
333 if (settings
->decor
!= -1)
334 client_set_undecorated(self
, !settings
->decor
);
335 if (settings
->iconic
!= -1)
336 client_iconify(self
, settings
->iconic
, FALSE
);
337 if (settings
->skip_pager
!= -1) {
338 self
->skip_pager
= !!settings
->skip_pager
;
339 client_change_state(self
);
341 if (settings
->skip_taskbar
!= -1) {
342 self
->skip_taskbar
= !!settings
->skip_taskbar
;
343 client_change_state(self
);
346 /* 1 && -1 shouldn't be possible by the code in config.c */
347 if (settings
->max_vert
== 1 && settings
->max_horz
== 1)
348 client_maximize(self
, TRUE
, 0, TRUE
);
349 else if (settings
->max_vert
== 0 && settings
->max_horz
== 0)
350 client_maximize(self
, FALSE
, 0, TRUE
);
351 else if (settings
->max_vert
== 1 && settings
->max_horz
== 0) {
352 client_maximize(self
, TRUE
, 2, TRUE
);
353 client_maximize(self
, FALSE
, 1, TRUE
);
354 } else if (settings
->max_vert
== 0 && settings
->max_horz
== 1) {
355 client_maximize(self
, TRUE
, 1, TRUE
);
356 client_maximize(self
, FALSE
, 2, TRUE
);
359 if (settings
->fullscreen
!= -1)
360 client_fullscreen(self
, !!settings
->fullscreen
, TRUE
);
362 if (settings
->desktop
< screen_num_desktops
)
363 client_set_desktop(self
, settings
->desktop
, FALSE
);
365 if (settings
->layer
> -2 && settings
->layer
< 2)
366 client_set_layer(self
, settings
->layer
);
370 /* focus the new window? */
371 if (ob_state() != OB_STATE_STARTING
&&
372 (config_focus_new
|| client_search_focus_parent(self
)) ||
373 (settings
&& settings
->focus
== TRUE
) &&
374 /* note the check against Type_Normal/Dialog, not client_normal(self),
375 which would also include other types. in this case we want more
376 strict rules for focus */
377 (self
->type
== OB_CLIENT_TYPE_NORMAL
||
378 self
->type
== OB_CLIENT_TYPE_DIALOG
))
382 if (self
->desktop
!= screen_desktop
) {
383 /* activate the window */
386 gboolean group_foc
= FALSE
;
391 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
393 if (client_focused(it
->data
))
401 (!self
->transient_for
&& (!self
->group
||
402 !self
->group
->members
->next
))) ||
403 client_search_focus_tree_full(self
) ||
405 !client_normal(focus_client
))
407 /* activate the window */
414 if (ob_state() == OB_STATE_RUNNING
) {
415 gint x
= self
->area
.x
, ox
= x
;
416 gint y
= self
->area
.y
, oy
= y
;
418 place_client(self
, &x
, &y
, settings
);
420 /* make sure the window is visible. */
421 client_find_onscreen(self
, &x
, &y
,
422 self
->frame
->area
.width
,
423 self
->frame
->area
.height
,
424 /* non-normal clients has less rules, and
425 windows that are being restored from a
426 session do also. we can assume you want
427 it back where you saved it. Clients saying
428 they placed themselves are subjected to
429 harder rules, ones that are placed by
430 place.c or by the user are allowed partially
431 off-screen and on xinerama divides (ie,
432 it is up to the placement routines to avoid
433 the xinerama divides) */
434 ((self
->positioned
& PPosition
) &&
435 !(self
->positioned
& USPosition
)) &&
436 client_normal(self
) &&
438 if (x
!= ox
|| y
!= oy
)
439 client_move(self
, x
, y
);
442 keyboard_grab_for_client(self
, TRUE
);
443 mouse_grab_for_client(self
, TRUE
);
445 client_showhide(self
);
447 /* use client_focus instead of client_activate cuz client_activate does
448 stuff like switch desktops etc and I'm not interested in all that when
449 a window maps since its not based on an action from the user like
450 clicking a window to activate is. so keep the new window out of the way
453 /* if using focus_delay, stop the timer now so that focus doesn't go
455 event_halt_focus_delay();
458 /* since focus can change the stacking orders, if we focus the window
459 then the standard raise it gets is not enough, we need to queue one
460 for after the focus change takes place */
464 /* client_activate does this but we aret using it so we have to do it
466 if (screen_showing_desktop
)
467 screen_show_desktop(FALSE
);
469 /* add to client list/map */
470 client_list
= g_list_append(client_list
, self
);
471 g_hash_table_insert(window_map
, &self
->window
, self
);
473 /* this has to happen after we're in the client_list */
474 screen_update_areas();
476 /* update the list hints */
479 ob_debug("Managed window 0x%lx (%s)\n", window
, self
->class);
482 void client_unmanage_all()
484 while (client_list
!= NULL
)
485 client_unmanage(client_list
->data
);
488 void client_unmanage(ObClient
*self
)
493 ob_debug("Unmanaging window: %lx (%s)\n", self
->window
, self
->class);
495 g_assert(self
!= NULL
);
497 keyboard_grab_for_client(self
, FALSE
);
498 mouse_grab_for_client(self
, FALSE
);
500 /* potentially fix focusLast */
501 if (config_focus_last
)
502 grab_pointer(TRUE
, OB_CURSOR_NONE
);
504 /* remove the window from our save set */
505 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
507 /* we dont want events no more */
508 XSelectInput(ob_display
, self
->window
, NoEventMask
);
510 frame_hide(self
->frame
);
512 client_list
= g_list_remove(client_list
, self
);
513 stacking_remove(self
);
514 g_hash_table_remove(window_map
, &self
->window
);
516 /* update the focus lists */
517 focus_order_remove(self
);
519 /* once the client is out of the list, update the struts to remove it's
521 screen_update_areas();
523 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
524 Destructor
*d
= it
->data
;
525 d
->func(self
, d
->data
);
528 if (focus_client
== self
) {
531 /* focus the last focused window on the desktop, and ignore enter
532 events from the unmap so it doesnt mess with the focus */
533 while (XCheckTypedEvent(ob_display
, EnterNotify
, &e
));
534 /* remove these flags so we don't end up getting focused in the
536 self
->can_focus
= FALSE
;
537 self
->focus_notify
= FALSE
;
539 client_unfocus(self
);
542 /* tell our parent(s) that we're gone */
543 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
544 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
545 if (it
->data
!= self
)
546 ((ObClient
*)it
->data
)->transients
=
547 g_slist_remove(((ObClient
*)it
->data
)->transients
, self
);
548 } else if (self
->transient_for
) { /* transient of window */
549 self
->transient_for
->transients
=
550 g_slist_remove(self
->transient_for
->transients
, self
);
553 /* tell our transients that we're gone */
554 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
555 if (((ObClient
*)it
->data
)->transient_for
!= OB_TRAN_GROUP
) {
556 ((ObClient
*)it
->data
)->transient_for
= NULL
;
557 client_calc_layer(it
->data
);
561 /* remove from its group */
563 group_remove(self
->group
, self
);
567 /* give the client its border back */
568 client_toggle_border(self
, TRUE
);
570 /* reparent the window out of the frame, and free the frame */
571 frame_release_client(self
->frame
, self
);
574 if (ob_state() != OB_STATE_EXITING
) {
575 /* these values should not be persisted across a window
577 PROP_ERASE(self
->window
, net_wm_desktop
);
578 PROP_ERASE(self
->window
, net_wm_state
);
579 PROP_ERASE(self
->window
, wm_state
);
581 /* if we're left in an unmapped state, the client wont be mapped. this
582 is bad, since we will no longer be managing the window on restart */
583 XMapWindow(ob_display
, self
->window
);
587 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
589 /* free all data allocated in the client struct */
590 g_slist_free(self
->transients
);
591 for (j
= 0; j
< self
->nicons
; ++j
)
592 g_free(self
->icons
[j
].data
);
593 if (self
->nicons
> 0)
596 g_free(self
->icon_title
);
600 g_free(self
->sm_client_id
);
603 /* update the list hints */
606 if (config_focus_last
)
607 grab_pointer(FALSE
, OB_CURSOR_NONE
);
610 static void client_urgent_notify(ObClient
*self
)
613 frame_flash_start(self
->frame
);
615 frame_flash_stop(self
->frame
);
618 static void client_restore_session_state(ObClient
*self
)
622 if (!(it
= session_state_find(self
)))
625 self
->session
= it
->data
;
627 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
628 self
->positioned
= PPosition
;
629 if (self
->session
->w
> 0)
630 self
->area
.width
= self
->session
->w
;
631 if (self
->session
->h
> 0)
632 self
->area
.height
= self
->session
->h
;
633 XResizeWindow(ob_display
, self
->window
,
634 self
->area
.width
, self
->area
.height
);
636 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
637 self
->session
->desktop
:
638 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
639 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
641 self
->shaded
= self
->session
->shaded
;
642 self
->iconic
= self
->session
->iconic
;
643 self
->skip_pager
= self
->session
->skip_pager
;
644 self
->skip_taskbar
= self
->session
->skip_taskbar
;
645 self
->fullscreen
= self
->session
->fullscreen
;
646 self
->above
= self
->session
->above
;
647 self
->below
= self
->session
->below
;
648 self
->max_horz
= self
->session
->max_horz
;
649 self
->max_vert
= self
->session
->max_vert
;
652 static void client_restore_session_stacking(ObClient
*self
)
656 if (!self
->session
) return;
658 it
= g_list_find(session_saved_state
, self
->session
);
659 for (it
= g_list_previous(it
); it
; it
= g_list_previous(it
)) {
662 for (cit
= client_list
; cit
; cit
= g_list_next(cit
))
663 if (session_state_cmp(it
->data
, cit
->data
))
666 client_calc_layer(self
);
667 stacking_below(CLIENT_AS_WINDOW(self
),
668 CLIENT_AS_WINDOW(cit
->data
));
674 void client_move_onscreen(ObClient
*self
, gboolean rude
)
676 gint x
= self
->area
.x
;
677 gint y
= self
->area
.y
;
678 if (client_find_onscreen(self
, &x
, &y
,
679 self
->frame
->area
.width
,
680 self
->frame
->area
.height
, rude
)) {
681 client_move(self
, x
, y
);
685 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
689 gint ox
= *x
, oy
= *y
;
691 frame_client_gravity(self
->frame
, x
, y
); /* get where the frame
694 /* XXX watch for xinerama dead areas */
695 /* This makes sure windows aren't entirely outside of the screen so you
696 * can't see them at all */
697 if (client_normal(self
)) {
698 a
= screen_area(self
->desktop
);
699 if (!self
->strut
.right
&& *x
>= a
->x
+ a
->width
- 1)
700 *x
= a
->x
+ a
->width
- self
->frame
->area
.width
;
701 if (!self
->strut
.bottom
&& *y
>= a
->y
+ a
->height
- 1)
702 *y
= a
->y
+ a
->height
- self
->frame
->area
.height
;
703 if (!self
->strut
.left
&& *x
+ self
->frame
->area
.width
- 1 < a
->x
)
705 if (!self
->strut
.top
&& *y
+ self
->frame
->area
.height
- 1 < a
->y
)
709 /* This here doesn't let windows even a pixel outside the screen,
710 * when called from client_manage, programs placing themselves are
711 * forced completely onscreen, while things like
712 * xterm -geometry resolution-width/2 will work fine. Trying to
713 * place it completely offscreen will be handled in the above code.
714 * Sorry for this confused comment, i am tired. */
716 /* avoid the xinerama monitor divide while we're at it,
717 * remember to fix the placement stuff to avoid it also and
718 * then remove this XXX */
719 a
= screen_physical_area_monitor(client_monitor(self
));
720 /* dont let windows map/move into the strut unless they
721 are bigger than the available area */
723 if (!self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
724 if (!self
->strut
.right
&& *x
+ w
> a
->x
+ a
->width
)
725 *x
= a
->x
+ a
->width
- w
;
727 if (h
<= a
->height
) {
728 if (!self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
729 if (!self
->strut
.bottom
&& *y
+ h
> a
->y
+ a
->height
)
730 *y
= a
->y
+ a
->height
- h
;
734 frame_frame_gravity(self
->frame
, x
, y
); /* get where the client
737 return ox
!= *x
|| oy
!= *y
;
740 static void client_toggle_border(ObClient
*self
, gboolean show
)
742 /* adjust our idea of where the client is, based on its border. When the
743 border is removed, the client should now be considered to be in a
745 when re-adding the border to the client, the same operation needs to be
747 gint oldx
= self
->area
.x
, oldy
= self
->area
.y
;
748 gint x
= oldx
, y
= oldy
;
749 switch(self
->gravity
) {
751 case NorthWestGravity
:
753 case SouthWestGravity
:
755 case NorthEastGravity
:
757 case SouthEastGravity
:
758 if (show
) x
-= self
->border_width
* 2;
759 else x
+= self
->border_width
* 2;
766 if (show
) x
-= self
->border_width
;
767 else x
+= self
->border_width
;
770 switch(self
->gravity
) {
772 case NorthWestGravity
:
774 case NorthEastGravity
:
776 case SouthWestGravity
:
778 case SouthEastGravity
:
779 if (show
) y
-= self
->border_width
* 2;
780 else y
+= self
->border_width
* 2;
787 if (show
) y
-= self
->border_width
;
788 else y
+= self
->border_width
;
795 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
797 /* move the client so it is back it the right spot _with_ its
799 if (x
!= oldx
|| y
!= oldy
)
800 XMoveWindow(ob_display
, self
->window
, x
, y
);
802 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
806 static void client_get_all(ObClient
*self
)
808 client_get_area(self
);
809 client_update_transient_for(self
);
810 client_update_wmhints(self
);
811 client_get_startup_id(self
);
812 client_get_desktop(self
);
813 client_get_shaped(self
);
815 client_get_mwm_hints(self
);
816 client_get_type(self
);/* this can change the mwmhints for special cases */
818 /* The transient hint is used to pick a type, but the type can also affect
819 transiency (dialogs are always made transients). This is Havoc's idea,
820 but it is needed to make some apps work right (eg tsclient). */
821 client_update_transient_for(self
);
823 client_get_state(self
);
826 /* a couple type-based defaults for new windows */
828 /* this makes sure that these windows appear on all desktops */
829 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
830 self
->desktop
= DESKTOP_ALL
;
833 client_update_protocols(self
);
835 client_get_gravity(self
); /* get the attribute gravity */
836 client_update_normal_hints(self
); /* this may override the attribute
839 /* got the type, the mwmhints, the protocols, and the normal hints
840 (min/max sizes), so we're ready to set up the decorations/functions */
841 client_setup_decor_and_functions(self
);
843 client_update_title(self
);
844 client_update_class(self
);
845 client_update_sm_client_id(self
);
846 client_update_strut(self
);
847 client_update_icons(self
);
850 static void client_get_startup_id(ObClient
*self
)
852 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
854 PROP_GETS(self
->group
->leader
,
855 net_startup_id
, utf8
, &self
->startup_id
);
858 static void client_get_area(ObClient
*self
)
860 XWindowAttributes wattrib
;
863 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
864 g_assert(ret
!= BadWindow
);
866 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
867 self
->border_width
= wattrib
.border_width
;
870 static void client_get_desktop(ObClient
*self
)
872 guint32 d
= screen_num_desktops
; /* an always-invalid value */
874 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
875 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
876 self
->desktop
= screen_num_desktops
- 1;
880 gboolean trdesk
= FALSE
;
882 if (self
->transient_for
) {
883 if (self
->transient_for
!= OB_TRAN_GROUP
) {
884 self
->desktop
= self
->transient_for
->desktop
;
889 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
890 if (it
->data
!= self
&&
891 !((ObClient
*)it
->data
)->transient_for
) {
892 self
->desktop
= ((ObClient
*)it
->data
)->desktop
;
899 /* try get from the startup-notification protocol */
900 if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
901 if (self
->desktop
>= screen_num_desktops
&&
902 self
->desktop
!= DESKTOP_ALL
)
903 self
->desktop
= screen_num_desktops
- 1;
905 /* defaults to the current desktop */
906 self
->desktop
= screen_desktop
;
909 if (self
->desktop
!= d
) {
910 /* set the desktop hint, to make sure that it always exists */
911 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
915 static void client_get_state(ObClient
*self
)
920 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
922 for (i
= 0; i
< num
; ++i
) {
923 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
925 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
927 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
929 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
930 self
->skip_taskbar
= TRUE
;
931 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
932 self
->skip_pager
= TRUE
;
933 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
934 self
->fullscreen
= TRUE
;
935 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
936 self
->max_vert
= TRUE
;
937 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
938 self
->max_horz
= TRUE
;
939 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
941 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
943 else if (state
[i
] == prop_atoms
.ob_wm_state_undecorated
)
944 self
->undecorated
= TRUE
;
950 if (!(self
->above
|| self
->below
)) {
952 /* apply stuff from the group */
956 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
957 ObClient
*c
= it
->data
;
958 if (c
!= self
&& !client_search_transient(self
, c
) &&
959 client_normal(self
) && client_normal(c
))
962 (c
->above
? 1 : (c
->below
? -1 : 0)));
976 g_assert_not_reached();
983 static void client_get_shaped(ObClient
*self
)
985 self
->shaped
= FALSE
;
987 if (extensions_shape
) {
992 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
994 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
995 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
997 self
->shaped
= (s
!= 0);
1002 void client_update_transient_for(ObClient
*self
)
1005 ObClient
*target
= NULL
;
1007 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
1008 self
->transient
= TRUE
;
1009 if (t
!= self
->window
) { /* cant be transient to itself! */
1010 target
= g_hash_table_lookup(window_map
, &t
);
1011 /* if this happens then we need to check for it*/
1012 g_assert(target
!= self
);
1013 if (target
&& !WINDOW_IS_CLIENT(target
)) {
1014 /* this can happen when a dialog is a child of
1015 a dockapp, for example */
1019 if (!target
&& self
->group
) {
1020 /* not transient to a client, see if it is transient for a
1022 if (t
== self
->group
->leader
||
1024 t
== RootWindow(ob_display
, ob_screen
))
1026 /* window is a transient for its group! */
1027 target
= OB_TRAN_GROUP
;
1031 } else if (self
->type
== OB_CLIENT_TYPE_DIALOG
&& self
->group
) {
1032 self
->transient
= TRUE
;
1033 target
= OB_TRAN_GROUP
;
1035 self
->transient
= FALSE
;
1037 /* if anything has changed... */
1038 if (target
!= self
->transient_for
) {
1039 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
1042 /* remove from old parents */
1043 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1044 ObClient
*c
= it
->data
;
1045 if (c
!= self
&& !c
->transient_for
)
1046 c
->transients
= g_slist_remove(c
->transients
, self
);
1048 } else if (self
->transient_for
!= NULL
) { /* transient of window */
1049 /* remove from old parent */
1050 self
->transient_for
->transients
=
1051 g_slist_remove(self
->transient_for
->transients
, self
);
1053 self
->transient_for
= target
;
1054 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
1057 /* add to new parents */
1058 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1059 ObClient
*c
= it
->data
;
1060 if (c
!= self
&& !c
->transient_for
)
1061 c
->transients
= g_slist_append(c
->transients
, self
);
1064 /* remove all transients which are in the group, that causes
1065 circlular pointer hell of doom */
1066 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1068 for (sit
= self
->transients
; sit
; sit
= next
) {
1069 next
= g_slist_next(sit
);
1070 if (sit
->data
== it
->data
)
1072 g_slist_delete_link(self
->transients
, sit
);
1075 } else if (self
->transient_for
!= NULL
) { /* transient of window */
1076 /* add to new parent */
1077 self
->transient_for
->transients
=
1078 g_slist_append(self
->transient_for
->transients
, self
);
1083 static void client_get_mwm_hints(ObClient
*self
)
1088 self
->mwmhints
.flags
= 0; /* default to none */
1090 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
1092 if (num
>= OB_MWM_ELEMENTS
) {
1093 self
->mwmhints
.flags
= hints
[0];
1094 self
->mwmhints
.functions
= hints
[1];
1095 self
->mwmhints
.decorations
= hints
[2];
1101 void client_get_type(ObClient
*self
)
1108 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1109 /* use the first value that we know about in the array */
1110 for (i
= 0; i
< num
; ++i
) {
1111 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1112 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1113 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1114 self
->type
= OB_CLIENT_TYPE_DOCK
;
1115 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1116 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1117 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1118 self
->type
= OB_CLIENT_TYPE_MENU
;
1119 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1120 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1121 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1122 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1123 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1124 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1125 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1126 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1127 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1128 /* prevent this window from getting any decor or
1130 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1131 OB_MWM_FLAG_DECORATIONS
);
1132 self
->mwmhints
.decorations
= 0;
1133 self
->mwmhints
.functions
= 0;
1135 if (self
->type
!= (ObClientType
) -1)
1136 break; /* grab the first legit type */
1141 if (self
->type
== (ObClientType
) -1) {
1142 /*the window type hint was not set, which means we either classify
1143 ourself as a normal window or a dialog, depending on if we are a
1145 if (self
->transient
)
1146 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1148 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1152 void client_update_protocols(ObClient
*self
)
1155 guint num_return
, i
;
1157 self
->focus_notify
= FALSE
;
1158 self
->delete_window
= FALSE
;
1160 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1161 for (i
= 0; i
< num_return
; ++i
) {
1162 if (proto
[i
] == prop_atoms
.wm_delete_window
) {
1163 /* this means we can request the window to close */
1164 self
->delete_window
= TRUE
;
1165 } else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1166 /* if this protocol is requested, then the window will be
1167 notified whenever we want it to receive focus */
1168 self
->focus_notify
= TRUE
;
1174 static void client_get_gravity(ObClient
*self
)
1176 XWindowAttributes wattrib
;
1179 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1180 g_assert(ret
!= BadWindow
);
1181 self
->gravity
= wattrib
.win_gravity
;
1184 void client_update_normal_hints(ObClient
*self
)
1188 gint oldgravity
= self
->gravity
;
1191 self
->min_ratio
= 0.0f
;
1192 self
->max_ratio
= 0.0f
;
1193 SIZE_SET(self
->size_inc
, 1, 1);
1194 SIZE_SET(self
->base_size
, 0, 0);
1195 SIZE_SET(self
->min_size
, 0, 0);
1196 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1198 /* get the hints from the window */
1199 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1200 /* normal windows can't request placement! har har
1201 if (!client_normal(self))
1203 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1205 if (size
.flags
& PWinGravity
) {
1206 self
->gravity
= size
.win_gravity
;
1208 /* if the client has a frame, i.e. has already been mapped and
1209 is changing its gravity */
1210 if (self
->frame
&& self
->gravity
!= oldgravity
) {
1211 /* move our idea of the client's position based on its new
1213 self
->area
.x
= self
->frame
->area
.x
;
1214 self
->area
.y
= self
->frame
->area
.y
;
1215 frame_frame_gravity(self
->frame
, &self
->area
.x
, &self
->area
.y
);
1219 if (size
.flags
& PAspect
) {
1220 if (size
.min_aspect
.y
)
1222 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1223 if (size
.max_aspect
.y
)
1225 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1228 if (size
.flags
& PMinSize
)
1229 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1231 if (size
.flags
& PMaxSize
)
1232 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1234 if (size
.flags
& PBaseSize
)
1235 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1237 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1238 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1242 void client_setup_decor_and_functions(ObClient
*self
)
1244 /* start with everything (cept fullscreen) */
1246 (OB_FRAME_DECOR_TITLEBAR
|
1247 OB_FRAME_DECOR_HANDLE
|
1248 OB_FRAME_DECOR_GRIPS
|
1249 OB_FRAME_DECOR_BORDER
|
1250 OB_FRAME_DECOR_ICON
|
1251 OB_FRAME_DECOR_ALLDESKTOPS
|
1252 OB_FRAME_DECOR_ICONIFY
|
1253 OB_FRAME_DECOR_MAXIMIZE
|
1254 OB_FRAME_DECOR_SHADE
|
1255 OB_FRAME_DECOR_CLOSE
);
1257 (OB_CLIENT_FUNC_RESIZE
|
1258 OB_CLIENT_FUNC_MOVE
|
1259 OB_CLIENT_FUNC_ICONIFY
|
1260 OB_CLIENT_FUNC_MAXIMIZE
|
1261 OB_CLIENT_FUNC_SHADE
|
1262 OB_CLIENT_FUNC_CLOSE
);
1264 if (!(self
->min_size
.width
< self
->max_size
.width
||
1265 self
->min_size
.height
< self
->max_size
.height
))
1266 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1268 switch (self
->type
) {
1269 case OB_CLIENT_TYPE_NORMAL
:
1270 /* normal windows retain all of the possible decorations and
1271 functionality, and are the only windows that you can fullscreen */
1272 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1275 case OB_CLIENT_TYPE_DIALOG
:
1276 case OB_CLIENT_TYPE_UTILITY
:
1277 /* these windows cannot be maximized */
1278 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1281 case OB_CLIENT_TYPE_MENU
:
1282 case OB_CLIENT_TYPE_TOOLBAR
:
1283 /* these windows get less functionality */
1284 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
| OB_CLIENT_FUNC_RESIZE
);
1287 case OB_CLIENT_TYPE_DESKTOP
:
1288 case OB_CLIENT_TYPE_DOCK
:
1289 case OB_CLIENT_TYPE_SPLASH
:
1290 /* none of these windows are manipulated by the window manager */
1291 self
->decorations
= 0;
1292 self
->functions
= 0;
1296 /* Mwm Hints are applied subtractively to what has already been chosen for
1297 decor and functionality */
1298 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1299 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1300 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1301 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1302 /* if the mwm hints request no handle or title, then all
1303 decorations are disabled */
1304 self
->decorations
= config_theme_keepborder
? OB_FRAME_DECOR_BORDER
: 0;
1308 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1309 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1310 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1311 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1312 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1313 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1314 /* dont let mwm hints kill any buttons
1315 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1316 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1317 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1318 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1320 /* dont let mwm hints kill the close button
1321 if (! (self->mwmhints.functions & MwmFunc_Close))
1322 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1326 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1327 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1328 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1329 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1330 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1331 self
->decorations
&= ~OB_FRAME_DECOR_GRIPS
;
1333 /* can't maximize without moving/resizing */
1334 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1335 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1336 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1337 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1338 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1341 /* kill the handle on fully maxed windows */
1342 if (self
->max_vert
&& self
->max_horz
)
1343 self
->decorations
&= ~OB_FRAME_DECOR_HANDLE
;
1345 /* finally, the user can have requested no decorations, which overrides
1346 everything (but doesnt give it a border if it doesnt have one) */
1347 if (self
->undecorated
) {
1348 if (config_theme_keepborder
)
1349 self
->decorations
&= OB_FRAME_DECOR_BORDER
;
1351 self
->decorations
= 0;
1354 /* if we don't have a titlebar, then we cannot shade! */
1355 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1356 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1358 /* now we need to check against rules for the client's current state */
1359 if (self
->fullscreen
) {
1360 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1361 OB_CLIENT_FUNC_FULLSCREEN
|
1362 OB_CLIENT_FUNC_ICONIFY
);
1363 self
->decorations
= 0;
1366 client_change_allowed_actions(self
);
1369 /* adjust the client's decorations, etc. */
1370 client_reconfigure(self
);
1374 static void client_change_allowed_actions(ObClient
*self
)
1379 /* desktop windows are kept on all desktops */
1380 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1381 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1383 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1384 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1385 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1386 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1387 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1388 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1389 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1390 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1391 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1392 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1393 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1394 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1395 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1396 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1397 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1400 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1402 /* make sure the window isn't breaking any rules now */
1404 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1405 if (self
->frame
) client_shade(self
, FALSE
);
1406 else self
->shaded
= FALSE
;
1408 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
) && self
->iconic
) {
1409 if (self
->frame
) client_iconify(self
, FALSE
, TRUE
);
1410 else self
->iconic
= FALSE
;
1412 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1413 if (self
->frame
) client_fullscreen(self
, FALSE
, TRUE
);
1414 else self
->fullscreen
= FALSE
;
1416 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1418 if (self
->frame
) client_maximize(self
, FALSE
, 0, TRUE
);
1419 else self
->max_vert
= self
->max_horz
= FALSE
;
1423 void client_reconfigure(ObClient
*self
)
1425 /* by making this pass FALSE for user, we avoid the emacs event storm where
1426 every configurenotify causes an update in its normal hints, i think this
1427 is generally what we want anyways... */
1428 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
1429 self
->area
.width
, self
->area
.height
, FALSE
, TRUE
);
1432 void client_update_wmhints(ObClient
*self
)
1435 gboolean ur
= FALSE
;
1438 /* assume a window takes input if it doesnt specify */
1439 self
->can_focus
= TRUE
;
1441 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1442 if (hints
->flags
& InputHint
)
1443 self
->can_focus
= hints
->input
;
1445 /* only do this when first managing the window *AND* when we aren't
1447 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1448 if (hints
->flags
& StateHint
)
1449 self
->iconic
= hints
->initial_state
== IconicState
;
1451 if (hints
->flags
& XUrgencyHint
)
1454 if (!(hints
->flags
& WindowGroupHint
))
1455 hints
->window_group
= None
;
1457 /* did the group state change? */
1458 if (hints
->window_group
!=
1459 (self
->group
? self
->group
->leader
: None
)) {
1460 /* remove from the old group if there was one */
1461 if (self
->group
!= NULL
) {
1462 /* remove transients of the group */
1463 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1464 self
->transients
= g_slist_remove(self
->transients
,
1467 /* remove myself from parents in the group */
1468 if (self
->transient_for
== OB_TRAN_GROUP
) {
1469 for (it
= self
->group
->members
; it
;
1470 it
= g_slist_next(it
))
1472 ObClient
*c
= it
->data
;
1474 if (c
!= self
&& !c
->transient_for
)
1475 c
->transients
= g_slist_remove(c
->transients
,
1480 group_remove(self
->group
, self
);
1483 if (hints
->window_group
!= None
) {
1484 self
->group
= group_add(hints
->window_group
, self
);
1486 /* i can only have transients from the group if i am not
1488 if (!self
->transient_for
) {
1489 /* add other transients of the group that are already
1491 for (it
= self
->group
->members
; it
;
1492 it
= g_slist_next(it
))
1494 ObClient
*c
= it
->data
;
1495 if (c
!= self
&& c
->transient_for
== OB_TRAN_GROUP
)
1497 g_slist_append(self
->transients
, c
);
1502 /* because the self->transient flag wont change from this call,
1503 we don't need to update the window's type and such, only its
1504 transient_for, and the transients lists of other windows in
1505 the group may be affected */
1506 client_update_transient_for(self
);
1509 /* the WM_HINTS can contain an icon */
1510 client_update_icons(self
);
1515 if (ur
!= self
->urgent
) {
1517 /* fire the urgent callback if we're mapped, otherwise, wait until
1518 after we're mapped */
1520 client_urgent_notify(self
);
1524 void client_update_title(ObClient
*self
)
1530 gboolean read_title
;
1533 old_title
= self
->title
;
1536 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
)) {
1537 /* try old x stuff */
1538 if (!(PROP_GETS(self
->window
, wm_name
, locale
, &data
)
1539 || PROP_GETS(self
->window
, wm_name
, utf8
, &data
))) {
1540 // http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1541 if (self
->transient
) {
1542 data
= g_strdup("");
1545 data
= g_strdup("Unnamed Window");
1549 if (config_title_number
) {
1551 /* did the title change? then reset the title_count */
1552 if (old_title
&& 0 != strncmp(old_title
, data
, strlen(data
)))
1553 self
->title_count
= 1;
1555 /* look for duplicates and append a number */
1557 for (it
= client_list
; it
; it
= g_list_next(it
))
1558 if (it
->data
!= self
) {
1559 ObClient
*c
= it
->data
;
1560 if (0 == strncmp(c
->title
, data
, strlen(data
)))
1561 nums
|= 1 << c
->title_count
;
1563 /* find first free number */
1564 for (i
= 1; i
<= 32; ++i
)
1565 if (!(nums
& (1 << i
))) {
1566 if (self
->title_count
== 1 || i
== 1)
1567 self
->title_count
= i
;
1570 /* dont display the number for the first window */
1571 if (self
->title_count
> 1) {
1573 ndata
= g_strdup_printf("%s - [%u]", data
, self
->title_count
);
1578 self
->title_count
= 1;
1581 PROP_SETS(self
->window
, net_wm_visible_name
, data
);
1585 frame_adjust_title(self
->frame
);
1589 /* update the icon title */
1591 g_free(self
->icon_title
);
1595 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
1596 /* try old x stuff */
1597 if (!(PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
)
1598 || PROP_GETS(self
->window
, wm_icon_name
, utf8
, &data
))) {
1599 data
= g_strdup(self
->title
);
1603 /* append the title count, dont display the number for the first window.
1604 * We don't need to check for config_title_number here since title_count
1605 * is not set above 1 then. */
1606 if (read_title
&& self
->title_count
> 1) {
1607 gchar
*vdata
, *ndata
;
1608 ndata
= g_strdup_printf(" - [%u]", self
->title_count
);
1609 vdata
= g_strconcat(data
, ndata
, NULL
);
1615 PROP_SETS(self
->window
, net_wm_visible_icon_name
, data
);
1617 self
->icon_title
= data
;
1620 void client_update_class(ObClient
*self
)
1625 if (self
->name
) g_free(self
->name
);
1626 if (self
->class) g_free(self
->class);
1627 if (self
->role
) g_free(self
->role
);
1629 self
->name
= self
->class = self
->role
= NULL
;
1631 if (PROP_GETSS(self
->window
, wm_class
, locale
, &data
)) {
1633 self
->name
= g_strdup(data
[0]);
1635 self
->class = g_strdup(data
[1]);
1640 if (PROP_GETS(self
->window
, wm_window_role
, locale
, &s
))
1643 if (self
->name
== NULL
) self
->name
= g_strdup("");
1644 if (self
->class == NULL
) self
->class = g_strdup("");
1645 if (self
->role
== NULL
) self
->role
= g_strdup("");
1648 void client_update_strut(ObClient
*self
)
1652 gboolean got
= FALSE
;
1655 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
1659 STRUT_PARTIAL_SET(strut
,
1660 data
[0], data
[2], data
[1], data
[3],
1661 data
[4], data
[5], data
[8], data
[9],
1662 data
[6], data
[7], data
[10], data
[11]);
1668 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
1674 /* use the screen's width/height */
1675 a
= screen_physical_area();
1677 STRUT_PARTIAL_SET(strut
,
1678 data
[0], data
[2], data
[1], data
[3],
1679 a
->y
, a
->y
+ a
->height
- 1,
1680 a
->x
, a
->x
+ a
->width
- 1,
1681 a
->y
, a
->y
+ a
->height
- 1,
1682 a
->x
, a
->x
+ a
->width
- 1);
1688 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
1689 0, 0, 0, 0, 0, 0, 0, 0);
1691 if (!STRUT_EQUAL(strut
, self
->strut
)) {
1692 self
->strut
= strut
;
1694 /* updating here is pointless while we're being mapped cuz we're not in
1695 the client list yet */
1697 screen_update_areas();
1701 void client_update_icons(ObClient
*self
)
1707 for (i
= 0; i
< self
->nicons
; ++i
)
1708 g_free(self
->icons
[i
].data
);
1709 if (self
->nicons
> 0)
1710 g_free(self
->icons
);
1713 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
1714 /* figure out how many valid icons are in here */
1716 while (num
- i
> 2) {
1720 if (i
> num
|| w
*h
== 0) break;
1724 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1726 /* store the icons */
1728 for (j
= 0; j
< self
->nicons
; ++j
) {
1731 w
= self
->icons
[j
].width
= data
[i
++];
1732 h
= self
->icons
[j
].height
= data
[i
++];
1734 if (w
*h
== 0) continue;
1736 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
1737 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
1742 self
->icons
[j
].data
[t
] =
1743 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
1744 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
1745 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
1746 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
1752 } else if (PROP_GETA32(self
->window
, kwm_win_icon
,
1753 kwm_win_icon
, &data
, &num
)) {
1756 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1757 xerror_set_ignore(TRUE
);
1758 if (!RrPixmapToRGBA(ob_rr_inst
,
1760 &self
->icons
[self
->nicons
-1].width
,
1761 &self
->icons
[self
->nicons
-1].height
,
1762 &self
->icons
[self
->nicons
-1].data
)) {
1763 g_free(&self
->icons
[self
->nicons
-1]);
1766 xerror_set_ignore(FALSE
);
1772 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
1773 if (hints
->flags
& IconPixmapHint
) {
1775 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1776 xerror_set_ignore(TRUE
);
1777 if (!RrPixmapToRGBA(ob_rr_inst
,
1779 (hints
->flags
& IconMaskHint
?
1780 hints
->icon_mask
: None
),
1781 &self
->icons
[self
->nicons
-1].width
,
1782 &self
->icons
[self
->nicons
-1].height
,
1783 &self
->icons
[self
->nicons
-1].data
)){
1784 g_free(&self
->icons
[self
->nicons
-1]);
1787 xerror_set_ignore(FALSE
);
1794 frame_adjust_icon(self
->frame
);
1797 static void client_change_state(ObClient
*self
)
1800 gulong netstate
[11];
1803 state
[0] = self
->wmstate
;
1805 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
1809 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
1811 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
1813 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
1814 if (self
->skip_taskbar
)
1815 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
1816 if (self
->skip_pager
)
1817 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
1818 if (self
->fullscreen
)
1819 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
1821 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
1823 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
1825 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
1827 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
1828 if (self
->undecorated
)
1829 netstate
[num
++] = prop_atoms
.ob_wm_state_undecorated
;
1830 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
1832 client_calc_layer(self
);
1835 frame_adjust_state(self
->frame
);
1838 ObClient
*client_search_focus_tree(ObClient
*self
)
1843 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
1844 if (client_focused(it
->data
)) return it
->data
;
1845 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
1850 ObClient
*client_search_focus_tree_full(ObClient
*self
)
1852 if (self
->transient_for
) {
1853 if (self
->transient_for
!= OB_TRAN_GROUP
) {
1854 return client_search_focus_tree_full(self
->transient_for
);
1857 gboolean recursed
= FALSE
;
1859 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1860 if (!((ObClient
*)it
->data
)->transient_for
) {
1862 if ((c
= client_search_focus_tree_full(it
->data
)))
1871 /* this function checks the whole tree, the client_search_focus_tree~
1872 does not, so we need to check this window */
1873 if (client_focused(self
))
1875 return client_search_focus_tree(self
);
1878 static ObStackingLayer
calc_layer(ObClient
*self
)
1882 if (self
->fullscreen
&&
1883 (client_focused(self
) || client_search_focus_tree(self
)))
1884 l
= OB_STACKING_LAYER_FULLSCREEN
;
1885 else if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
1886 l
= OB_STACKING_LAYER_DESKTOP
;
1887 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
1888 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
1889 else l
= OB_STACKING_LAYER_ABOVE
;
1891 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
1892 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
1893 else l
= OB_STACKING_LAYER_NORMAL
;
1898 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
1899 ObStackingLayer l
, gboolean raised
)
1901 ObStackingLayer old
, own
;
1905 own
= calc_layer(self
);
1906 self
->layer
= l
> own
? l
: own
;
1908 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
1909 client_calc_layer_recursive(it
->data
, orig
,
1910 l
, raised
? raised
: l
!= old
);
1912 if (!raised
&& l
!= old
)
1913 if (orig
->frame
) { /* only restack if the original window is managed */
1914 stacking_remove(CLIENT_AS_WINDOW(self
));
1915 stacking_add(CLIENT_AS_WINDOW(self
));
1919 void client_calc_layer(ObClient
*self
)
1926 /* transients take on the layer of their parents */
1927 self
= client_search_top_transient(self
);
1929 l
= calc_layer(self
);
1931 client_calc_layer_recursive(self
, orig
, l
, FALSE
);
1934 gboolean
client_should_show(ObClient
*self
)
1938 if (client_normal(self
) && screen_showing_desktop
)
1941 if (self->transient_for) {
1942 if (self->transient_for != OB_TRAN_GROUP)
1943 return client_should_show(self->transient_for);
1947 for (it = self->group->members; it; it = g_slist_next(it)) {
1948 ObClient *c = it->data;
1949 if (c != self && !c->transient_for) {
1950 if (client_should_show(c))
1957 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
1963 static void client_showhide(ObClient
*self
)
1966 if (client_should_show(self
))
1967 frame_show(self
->frame
);
1969 frame_hide(self
->frame
);
1972 gboolean
client_normal(ObClient
*self
) {
1973 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
1974 self
->type
== OB_CLIENT_TYPE_DOCK
||
1975 self
->type
== OB_CLIENT_TYPE_SPLASH
);
1978 static void client_apply_startup_state(ObClient
*self
)
1980 /* these are in a carefully crafted order.. */
1983 self
->iconic
= FALSE
;
1984 client_iconify(self
, TRUE
, FALSE
);
1986 if (self
->fullscreen
) {
1987 self
->fullscreen
= FALSE
;
1988 client_fullscreen(self
, TRUE
, FALSE
);
1990 if (self
->undecorated
) {
1991 self
->undecorated
= FALSE
;
1992 client_set_undecorated(self
, TRUE
);
1995 self
->shaded
= FALSE
;
1996 client_shade(self
, TRUE
);
1999 client_urgent_notify(self
);
2001 if (self
->max_vert
&& self
->max_horz
) {
2002 self
->max_vert
= self
->max_horz
= FALSE
;
2003 client_maximize(self
, TRUE
, 0, FALSE
);
2004 } else if (self
->max_vert
) {
2005 self
->max_vert
= FALSE
;
2006 client_maximize(self
, TRUE
, 2, FALSE
);
2007 } else if (self
->max_horz
) {
2008 self
->max_horz
= FALSE
;
2009 client_maximize(self
, TRUE
, 1, FALSE
);
2012 /* nothing to do for the other states:
2021 void client_configure_full(ObClient
*self
, ObCorner anchor
,
2022 gint x
, gint y
, gint w
, gint h
,
2023 gboolean user
, gboolean final
,
2024 gboolean force_reply
)
2027 gboolean send_resize_client
;
2028 gboolean moved
= FALSE
, resized
= FALSE
;
2029 guint fdecor
= self
->frame
->decorations
;
2030 gboolean fhorz
= self
->frame
->max_horz
;
2032 /* make the frame recalculate its dimentions n shit without changing
2033 anything visible for real, this way the constraints below can work with
2034 the updated frame dimensions. */
2035 frame_adjust_area(self
->frame
, TRUE
, TRUE
, TRUE
);
2037 /* gets the frame's position */
2038 frame_client_gravity(self
->frame
, &x
, &y
);
2040 /* these positions are frame positions, not client positions */
2042 /* set the size and position if fullscreen */
2043 if (self
->fullscreen
) {
2047 i
= client_monitor(self
);
2048 a
= screen_physical_area_monitor(i
);
2055 user
= FALSE
; /* ignore that increment etc shit when in fullscreen */
2059 a
= screen_area_monitor(self
->desktop
, client_monitor(self
));
2061 /* set the size and position if maximized */
2062 if (self
->max_horz
) {
2064 w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2066 if (self
->max_vert
) {
2068 h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2072 /* gets the client's position */
2073 frame_frame_gravity(self
->frame
, &x
, &y
);
2075 /* these override the above states! if you cant move you can't move! */
2077 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2081 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2082 w
= self
->area
.width
;
2083 h
= self
->area
.height
;
2087 if (!(w
== self
->area
.width
&& h
== self
->area
.height
)) {
2088 gint basew
, baseh
, minw
, minh
;
2090 /* base size is substituted with min size if not specified */
2091 if (self
->base_size
.width
|| self
->base_size
.height
) {
2092 basew
= self
->base_size
.width
;
2093 baseh
= self
->base_size
.height
;
2095 basew
= self
->min_size
.width
;
2096 baseh
= self
->min_size
.height
;
2098 /* min size is substituted with base size if not specified */
2099 if (self
->min_size
.width
|| self
->min_size
.height
) {
2100 minw
= self
->min_size
.width
;
2101 minh
= self
->min_size
.height
;
2103 minw
= self
->base_size
.width
;
2104 minh
= self
->base_size
.height
;
2107 /* if this is a user-requested resize, then check against min/max
2110 /* smaller than min size or bigger than max size? */
2111 if (w
> self
->max_size
.width
) w
= self
->max_size
.width
;
2112 if (w
< minw
) w
= minw
;
2113 if (h
> self
->max_size
.height
) h
= self
->max_size
.height
;
2114 if (h
< minh
) h
= minh
;
2119 /* keep to the increments */
2120 w
/= self
->size_inc
.width
;
2121 h
/= self
->size_inc
.height
;
2123 /* you cannot resize to nothing */
2124 if (basew
+ w
< 1) w
= 1 - basew
;
2125 if (baseh
+ h
< 1) h
= 1 - baseh
;
2127 /* store the logical size */
2128 SIZE_SET(self
->logical_size
,
2129 self
->size_inc
.width
> 1 ? w
: w
+ basew
,
2130 self
->size_inc
.height
> 1 ? h
: h
+ baseh
);
2132 w
*= self
->size_inc
.width
;
2133 h
*= self
->size_inc
.height
;
2138 /* adjust the height to match the width for the aspect ratios.
2139 for this, min size is not substituted for base size ever. */
2140 w
-= self
->base_size
.width
;
2141 h
-= self
->base_size
.height
;
2143 if (!self
->fullscreen
) {
2144 if (self
->min_ratio
)
2145 if (h
* self
->min_ratio
> w
) {
2146 h
= (gint
)(w
/ self
->min_ratio
);
2148 /* you cannot resize to nothing */
2151 w
= (gint
)(h
* self
->min_ratio
);
2154 if (self
->max_ratio
)
2155 if (h
* self
->max_ratio
< w
) {
2156 h
= (gint
)(w
/ self
->max_ratio
);
2158 /* you cannot resize to nothing */
2161 w
= (gint
)(h
* self
->min_ratio
);
2166 w
+= self
->base_size
.width
;
2167 h
+= self
->base_size
.height
;
2174 case OB_CORNER_TOPLEFT
:
2176 case OB_CORNER_TOPRIGHT
:
2177 x
-= w
- self
->area
.width
;
2179 case OB_CORNER_BOTTOMLEFT
:
2180 y
-= h
- self
->area
.height
;
2182 case OB_CORNER_BOTTOMRIGHT
:
2183 x
-= w
- self
->area
.width
;
2184 y
-= h
- self
->area
.height
;
2188 moved
= x
!= self
->area
.x
|| y
!= self
->area
.y
;
2189 resized
= w
!= self
->area
.width
|| h
!= self
->area
.height
;
2191 oldw
= self
->area
.width
;
2192 oldh
= self
->area
.height
;
2193 RECT_SET(self
->area
, x
, y
, w
, h
);
2195 /* for app-requested resizes, always resize if 'resized' is true.
2196 for user-requested ones, only resize if final is true, or when
2197 resizing in redraw mode */
2198 send_resize_client
= ((!user
&& resized
) ||
2200 (resized
&& config_resize_redraw
))));
2202 /* if the client is enlarging, then resize the client before the frame */
2203 if (send_resize_client
&& user
&& (w
> oldw
|| h
> oldh
))
2204 XResizeWindow(ob_display
, self
->window
, MAX(w
, oldw
), MAX(h
, oldh
));
2206 /* move/resize the frame to match the request */
2208 if (self
->decorations
!= fdecor
|| self
->max_horz
!= fhorz
)
2209 moved
= resized
= TRUE
;
2211 if (moved
|| resized
)
2212 frame_adjust_area(self
->frame
, moved
, resized
, FALSE
);
2214 if (!resized
&& (force_reply
|| ((!user
&& moved
) || (user
&& final
))))
2217 event
.type
= ConfigureNotify
;
2218 event
.xconfigure
.display
= ob_display
;
2219 event
.xconfigure
.event
= self
->window
;
2220 event
.xconfigure
.window
= self
->window
;
2222 /* root window real coords */
2223 event
.xconfigure
.x
= self
->frame
->area
.x
+ self
->frame
->size
.left
-
2225 event
.xconfigure
.y
= self
->frame
->area
.y
+ self
->frame
->size
.top
-
2227 event
.xconfigure
.width
= w
;
2228 event
.xconfigure
.height
= h
;
2229 event
.xconfigure
.border_width
= 0;
2230 event
.xconfigure
.above
= self
->frame
->plate
;
2231 event
.xconfigure
.override_redirect
= FALSE
;
2232 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
2233 FALSE
, StructureNotifyMask
, &event
);
2237 /* if the client is shrinking, then resize the frame before the client */
2238 if (send_resize_client
&& (!user
|| (w
<= oldw
|| h
<= oldh
)))
2239 XResizeWindow(ob_display
, self
->window
, w
, h
);
2244 void client_fullscreen(ObClient
*self
, gboolean fs
, gboolean savearea
)
2248 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
2249 self
->fullscreen
== fs
) return; /* already done */
2251 self
->fullscreen
= fs
;
2252 client_change_state(self
); /* change the state hints on the client,
2253 and adjust out layer/stacking */
2257 self
->pre_fullscreen_area
= self
->area
;
2259 /* these are not actually used cuz client_configure will set them
2260 as appropriate when the window is fullscreened */
2265 if (self
->pre_fullscreen_area
.width
> 0 &&
2266 self
->pre_fullscreen_area
.height
> 0)
2268 x
= self
->pre_fullscreen_area
.x
;
2269 y
= self
->pre_fullscreen_area
.y
;
2270 w
= self
->pre_fullscreen_area
.width
;
2271 h
= self
->pre_fullscreen_area
.height
;
2272 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
2274 /* pick some fallbacks... */
2275 a
= screen_area_monitor(self
->desktop
, 0);
2276 x
= a
->x
+ a
->width
/ 4;
2277 y
= a
->y
+ a
->height
/ 4;
2283 client_setup_decor_and_functions(self
);
2285 client_move_resize(self
, x
, y
, w
, h
);
2287 /* try focus us when we go into fullscreen mode */
2291 static void client_iconify_recursive(ObClient
*self
,
2292 gboolean iconic
, gboolean curdesk
)
2295 gboolean changed
= FALSE
;
2298 if (self
->iconic
!= iconic
) {
2299 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
2302 self
->iconic
= iconic
;
2305 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
) {
2308 old
= self
->wmstate
;
2309 self
->wmstate
= IconicState
;
2310 if (old
!= self
->wmstate
)
2311 PROP_MSG(self
->window
, kde_wm_change_state
,
2312 self
->wmstate
, 1, 0, 0);
2314 /* update the focus lists.. iconic windows go to the bottom of
2315 the list, put the new iconic window at the 'top of the
2317 focus_order_to_top(self
);
2325 client_set_desktop(self
, screen_desktop
, FALSE
);
2327 old
= self
->wmstate
;
2328 self
->wmstate
= self
->shaded
? IconicState
: NormalState
;
2329 if (old
!= self
->wmstate
)
2330 PROP_MSG(self
->window
, kde_wm_change_state
,
2331 self
->wmstate
, 1, 0, 0);
2333 /* this puts it after the current focused window */
2334 focus_order_remove(self
);
2335 focus_order_add_new(self
);
2342 client_change_state(self
);
2343 client_showhide(self
);
2344 screen_update_areas();
2347 /* iconify all transients */
2348 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2349 if (it
->data
!= self
) client_iconify_recursive(it
->data
,
2353 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
)
2355 /* move up the transient chain as far as possible first */
2356 self
= client_search_top_transient(self
);
2358 client_iconify_recursive(client_search_top_transient(self
),
2362 void client_maximize(ObClient
*self
, gboolean max
, gint dir
, gboolean savearea
)
2366 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
2367 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
2369 /* check if already done */
2371 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
2372 if (dir
== 1 && self
->max_horz
) return;
2373 if (dir
== 2 && self
->max_vert
) return;
2375 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
2376 if (dir
== 1 && !self
->max_horz
) return;
2377 if (dir
== 2 && !self
->max_vert
) return;
2380 /* we just tell it to configure in the same place and client_configure
2381 worries about filling the screen with the window */
2384 w
= self
->area
.width
;
2385 h
= self
->area
.height
;
2389 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
2390 RECT_SET(self
->pre_max_area
,
2391 self
->area
.x
, self
->pre_max_area
.y
,
2392 self
->area
.width
, self
->pre_max_area
.height
);
2394 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
2395 RECT_SET(self
->pre_max_area
,
2396 self
->pre_max_area
.x
, self
->area
.y
,
2397 self
->pre_max_area
.width
, self
->area
.height
);
2403 a
= screen_area_monitor(self
->desktop
, 0);
2404 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
2405 if (self
->pre_max_area
.width
> 0) {
2406 x
= self
->pre_max_area
.x
;
2407 w
= self
->pre_max_area
.width
;
2409 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
2410 0, self
->pre_max_area
.height
);
2412 /* pick some fallbacks... */
2413 x
= a
->x
+ a
->width
/ 4;
2417 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
2418 if (self
->pre_max_area
.height
> 0) {
2419 y
= self
->pre_max_area
.y
;
2420 h
= self
->pre_max_area
.height
;
2422 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
2423 self
->pre_max_area
.width
, 0);
2425 /* pick some fallbacks... */
2426 y
= a
->y
+ a
->height
/ 4;
2432 if (dir
== 0 || dir
== 1) /* horz */
2433 self
->max_horz
= max
;
2434 if (dir
== 0 || dir
== 2) /* vert */
2435 self
->max_vert
= max
;
2437 client_change_state(self
); /* change the state hints on the client */
2439 client_setup_decor_and_functions(self
);
2441 client_move_resize(self
, x
, y
, w
, h
);
2444 void client_shade(ObClient
*self
, gboolean shade
)
2446 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
2447 shade
) || /* can't shade */
2448 self
->shaded
== shade
) return; /* already done */
2450 /* when we're iconic, don't change the wmstate */
2451 if (!self
->iconic
) {
2454 old
= self
->wmstate
;
2455 self
->wmstate
= shade
? IconicState
: NormalState
;
2456 if (old
!= self
->wmstate
)
2457 PROP_MSG(self
->window
, kde_wm_change_state
,
2458 self
->wmstate
, 1, 0, 0);
2461 self
->shaded
= shade
;
2462 client_change_state(self
);
2463 /* resize the frame to just the titlebar */
2464 frame_adjust_area(self
->frame
, FALSE
, FALSE
, FALSE
);
2467 void client_close(ObClient
*self
)
2471 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
2473 /* in the case that the client provides no means to requesting that it
2474 close, we just kill it */
2475 if (!self
->delete_window
)
2479 XXX: itd be cool to do timeouts and shit here for killing the client's
2481 like... if the window is around after 5 seconds, then the close button
2482 turns a nice red, and if this function is called again, the client is
2486 ce
.xclient
.type
= ClientMessage
;
2487 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2488 ce
.xclient
.display
= ob_display
;
2489 ce
.xclient
.window
= self
->window
;
2490 ce
.xclient
.format
= 32;
2491 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_delete_window
;
2492 ce
.xclient
.data
.l
[1] = event_lasttime
;
2493 ce
.xclient
.data
.l
[2] = 0l;
2494 ce
.xclient
.data
.l
[3] = 0l;
2495 ce
.xclient
.data
.l
[4] = 0l;
2496 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2499 void client_kill(ObClient
*self
)
2501 XKillClient(ob_display
, self
->window
);
2504 void client_set_desktop_recursive(ObClient
*self
,
2505 guint target
, gboolean donthide
)
2510 if (target
!= self
->desktop
) {
2512 ob_debug("Setting desktop %u\n", target
+1);
2514 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
2516 /* remove from the old desktop(s) */
2517 focus_order_remove(self
);
2519 old
= self
->desktop
;
2520 self
->desktop
= target
;
2521 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
2522 /* the frame can display the current desktop state */
2523 frame_adjust_state(self
->frame
);
2524 /* 'move' the window to the new desktop */
2526 client_showhide(self
);
2527 /* raise if it was not already on the desktop */
2528 if (old
!= DESKTOP_ALL
)
2530 screen_update_areas();
2532 /* add to the new desktop(s) */
2533 if (config_focus_new
)
2534 focus_order_to_top(self
);
2536 focus_order_to_bottom(self
);
2539 /* move all transients */
2540 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2541 if (it
->data
!= self
) client_set_desktop_recursive(it
->data
,
2545 void client_set_desktop(ObClient
*self
, guint target
, gboolean donthide
)
2547 client_set_desktop_recursive(client_search_top_transient(self
),
2551 ObClient
*client_search_modal_child(ObClient
*self
)
2556 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2557 ObClient
*c
= it
->data
;
2558 if ((ret
= client_search_modal_child(c
))) return ret
;
2559 if (c
->modal
) return c
;
2564 gboolean
client_validate(ObClient
*self
)
2568 XSync(ob_display
, FALSE
); /* get all events on the server */
2570 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
) ||
2571 XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
2572 XPutBackEvent(ob_display
, &e
);
2579 void client_set_wm_state(ObClient
*self
, glong state
)
2581 if (state
== self
->wmstate
) return; /* no change */
2585 client_iconify(self
, TRUE
, TRUE
);
2588 client_iconify(self
, FALSE
, TRUE
);
2593 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
2595 gboolean shaded
= self
->shaded
;
2596 gboolean fullscreen
= self
->fullscreen
;
2597 gboolean undecorated
= self
->undecorated
;
2598 gboolean max_horz
= self
->max_horz
;
2599 gboolean max_vert
= self
->max_vert
;
2600 gboolean modal
= self
->modal
;
2601 gboolean iconic
= self
->iconic
;
2604 if (!(action
== prop_atoms
.net_wm_state_add
||
2605 action
== prop_atoms
.net_wm_state_remove
||
2606 action
== prop_atoms
.net_wm_state_toggle
))
2607 /* an invalid action was passed to the client message, ignore it */
2610 for (i
= 0; i
< 2; ++i
) {
2611 Atom state
= i
== 0 ? data1
: data2
;
2613 if (!state
) continue;
2615 /* if toggling, then pick whether we're adding or removing */
2616 if (action
== prop_atoms
.net_wm_state_toggle
) {
2617 if (state
== prop_atoms
.net_wm_state_modal
)
2618 action
= modal
? prop_atoms
.net_wm_state_remove
:
2619 prop_atoms
.net_wm_state_add
;
2620 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
2621 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
2622 prop_atoms
.net_wm_state_add
;
2623 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
2624 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
2625 prop_atoms
.net_wm_state_add
;
2626 else if (state
== prop_atoms
.net_wm_state_shaded
)
2627 action
= shaded
? prop_atoms
.net_wm_state_remove
:
2628 prop_atoms
.net_wm_state_add
;
2629 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
2630 action
= self
->skip_taskbar
?
2631 prop_atoms
.net_wm_state_remove
:
2632 prop_atoms
.net_wm_state_add
;
2633 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
2634 action
= self
->skip_pager
?
2635 prop_atoms
.net_wm_state_remove
:
2636 prop_atoms
.net_wm_state_add
;
2637 else if (state
== prop_atoms
.net_wm_state_hidden
)
2638 action
= self
->iconic
?
2639 prop_atoms
.net_wm_state_remove
:
2640 prop_atoms
.net_wm_state_add
;
2641 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
2642 action
= fullscreen
?
2643 prop_atoms
.net_wm_state_remove
:
2644 prop_atoms
.net_wm_state_add
;
2645 else if (state
== prop_atoms
.net_wm_state_above
)
2646 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
2647 prop_atoms
.net_wm_state_add
;
2648 else if (state
== prop_atoms
.net_wm_state_below
)
2649 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
2650 prop_atoms
.net_wm_state_add
;
2651 else if (state
== prop_atoms
.ob_wm_state_undecorated
)
2652 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
2653 prop_atoms
.net_wm_state_add
;
2656 if (action
== prop_atoms
.net_wm_state_add
) {
2657 if (state
== prop_atoms
.net_wm_state_modal
) {
2659 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2661 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2663 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2665 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2666 self
->skip_taskbar
= TRUE
;
2667 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2668 self
->skip_pager
= TRUE
;
2669 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
2671 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2673 } else if (state
== prop_atoms
.net_wm_state_above
) {
2675 self
->below
= FALSE
;
2676 } else if (state
== prop_atoms
.net_wm_state_below
) {
2677 self
->above
= FALSE
;
2679 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2683 } else { /* action == prop_atoms.net_wm_state_remove */
2684 if (state
== prop_atoms
.net_wm_state_modal
) {
2686 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2688 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2690 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2692 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2693 self
->skip_taskbar
= FALSE
;
2694 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2695 self
->skip_pager
= FALSE
;
2696 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
2698 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2700 } else if (state
== prop_atoms
.net_wm_state_above
) {
2701 self
->above
= FALSE
;
2702 } else if (state
== prop_atoms
.net_wm_state_below
) {
2703 self
->below
= FALSE
;
2704 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2705 undecorated
= FALSE
;
2709 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
2710 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
2712 if (max_horz
== max_vert
) { /* both going the same way */
2713 client_maximize(self
, max_horz
, 0, TRUE
);
2715 client_maximize(self
, max_horz
, 1, TRUE
);
2716 client_maximize(self
, max_vert
, 2, TRUE
);
2720 if (max_horz
!= self
->max_horz
)
2721 client_maximize(self
, max_horz
, 1, TRUE
);
2723 client_maximize(self
, max_vert
, 2, TRUE
);
2726 /* change fullscreen state before shading, as it will affect if the window
2728 if (fullscreen
!= self
->fullscreen
)
2729 client_fullscreen(self
, fullscreen
, TRUE
);
2730 if (shaded
!= self
->shaded
)
2731 client_shade(self
, shaded
);
2732 if (undecorated
!= self
->undecorated
)
2733 client_set_undecorated(self
, undecorated
);
2734 if (modal
!= self
->modal
) {
2735 self
->modal
= modal
;
2736 /* when a window changes modality, then its stacking order with its
2737 transients needs to change */
2740 if (iconic
!= self
->iconic
)
2741 client_iconify(self
, iconic
, FALSE
);
2743 client_calc_layer(self
);
2744 client_change_state(self
); /* change the hint to reflect these changes */
2747 ObClient
*client_focus_target(ObClient
*self
)
2751 /* if we have a modal child, then focus it, not us */
2752 child
= client_search_modal_child(client_search_top_transient(self
));
2753 if (child
) return child
;
2757 gboolean
client_can_focus(ObClient
*self
)
2761 /* choose the correct target */
2762 self
= client_focus_target(self
);
2764 if (!self
->frame
->visible
)
2767 if (!(self
->can_focus
|| self
->focus_notify
))
2770 /* do a check to see if the window has already been unmapped or destroyed
2771 do this intelligently while watching out for unmaps we've generated
2772 (ignore_unmaps > 0) */
2773 if (XCheckTypedWindowEvent(ob_display
, self
->window
,
2774 DestroyNotify
, &ev
)) {
2775 XPutBackEvent(ob_display
, &ev
);
2778 while (XCheckTypedWindowEvent(ob_display
, self
->window
,
2779 UnmapNotify
, &ev
)) {
2780 if (self
->ignore_unmaps
) {
2781 self
->ignore_unmaps
--;
2783 XPutBackEvent(ob_display
, &ev
);
2791 gboolean
client_focus(ObClient
*self
)
2793 /* choose the correct target */
2794 self
= client_focus_target(self
);
2796 if (!client_can_focus(self
)) {
2797 if (!self
->frame
->visible
) {
2798 /* update the focus lists */
2799 focus_order_to_top(self
);
2804 if (self
->can_focus
) {
2805 /* RevertToPointerRoot causes much more headache than RevertToNone, so
2806 I choose to use it always, hopefully to find errors quicker, if any
2807 are left. (I hate X. I hate focus events.)
2809 Update: Changing this to RevertToNone fixed a bug with mozilla (bug
2810 #799. So now it is RevertToNone again.
2812 XSetInputFocus(ob_display
, self
->window
, RevertToNone
,
2816 if (self
->focus_notify
) {
2818 ce
.xclient
.type
= ClientMessage
;
2819 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2820 ce
.xclient
.display
= ob_display
;
2821 ce
.xclient
.window
= self
->window
;
2822 ce
.xclient
.format
= 32;
2823 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
2824 ce
.xclient
.data
.l
[1] = event_lasttime
;
2825 ce
.xclient
.data
.l
[2] = 0l;
2826 ce
.xclient
.data
.l
[3] = 0l;
2827 ce
.xclient
.data
.l
[4] = 0l;
2828 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2832 ob_debug("%sively focusing %lx at %d\n",
2833 (self
->can_focus
? "act" : "pass"),
2834 self
->window
, (gint
) event_lasttime
);
2837 /* Cause the FocusIn to come back to us. Important for desktop switches,
2838 since otherwise we'll have no FocusIn on the queue and send it off to
2839 the focus_backup. */
2840 XSync(ob_display
, FALSE
);
2844 /* Used when the current client is closed, focus_last will then prevent
2845 * focus from going to the mouse pointer */
2846 void client_unfocus(ObClient
*self
)
2848 if (focus_client
== self
) {
2850 ob_debug("client_unfocus for %lx\n", self
->window
);
2852 focus_fallback(OB_FOCUS_FALLBACK_CLOSED
);
2856 void client_activate(ObClient
*self
, gboolean here
)
2858 /* This check is for the client_list_menu trying to activate
2859 * a closed client. */
2860 if (!g_list_find(client_list
, self
)) return;
2861 if (client_normal(self
) && screen_showing_desktop
)
2862 screen_show_desktop(FALSE
);
2864 client_iconify(self
, FALSE
, here
);
2865 if (self
->desktop
!= DESKTOP_ALL
&&
2866 self
->desktop
!= screen_desktop
) {
2868 client_set_desktop(self
, screen_desktop
, FALSE
);
2870 screen_set_desktop(self
->desktop
);
2871 } else if (!self
->frame
->visible
)
2872 /* if its not visible for other reasons, then don't mess
2876 client_shade(self
, FALSE
);
2880 /* we do this an action here. this is rather important. this is because
2881 we want the results from the focus change to take place BEFORE we go
2882 about raising the window. when a fullscreen window loses focus, we need
2883 this or else the raise wont be able to raise above the to-lose-focus
2884 fullscreen window. */
2888 void client_raise(ObClient
*self
)
2890 action_run_string("Raise", self
);
2893 void client_lower(ObClient
*self
)
2895 action_run_string("Lower", self
);
2898 gboolean
client_focused(ObClient
*self
)
2900 return self
== focus_client
;
2903 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
2906 /* si is the smallest image >= req */
2907 /* li is the largest image < req */
2908 gulong size
, smallest
= 0xffffffff, largest
= 0, si
= 0, li
= 0;
2910 if (!self
->nicons
) {
2911 ObClientIcon
*parent
= NULL
;
2913 if (self
->transient_for
) {
2914 if (self
->transient_for
!= OB_TRAN_GROUP
)
2915 parent
= client_icon_recursive(self
->transient_for
, w
, h
);
2918 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
2919 ObClient
*c
= it
->data
;
2920 if (c
!= self
&& !c
->transient_for
) {
2921 if ((parent
= client_icon_recursive(c
, w
, h
)))
2931 for (i
= 0; i
< self
->nicons
; ++i
) {
2932 size
= self
->icons
[i
].width
* self
->icons
[i
].height
;
2933 if (size
< smallest
&& size
>= (unsigned)(w
* h
)) {
2937 if (size
> largest
&& size
<= (unsigned)(w
* h
)) {
2942 if (largest
== 0) /* didnt find one smaller than the requested size */
2943 return &self
->icons
[si
];
2944 return &self
->icons
[li
];
2947 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
2950 static ObClientIcon deficon
;
2952 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
2953 deficon
.width
= deficon
.height
= 48;
2954 deficon
.data
= ob_rr_theme
->def_win_icon
;
2960 /* this be mostly ripped from fvwm */
2961 ObClient
*client_find_directional(ObClient
*c
, ObDirection dir
)
2963 gint my_cx
, my_cy
, his_cx
, his_cy
;
2966 gint score
, best_score
;
2967 ObClient
*best_client
, *cur
;
2973 /* first, find the centre coords of the currently focused window */
2974 my_cx
= c
->frame
->area
.x
+ c
->frame
->area
.width
/ 2;
2975 my_cy
= c
->frame
->area
.y
+ c
->frame
->area
.height
/ 2;
2980 for(it
= g_list_first(client_list
); it
; it
= g_list_next(it
)) {
2983 /* the currently selected window isn't interesting */
2986 if (!client_normal(cur
))
2988 /* using c->desktop instead of screen_desktop doesn't work if the
2989 * current window was omnipresent, hope this doesn't have any other
2991 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
2995 if(client_focus_target(cur
) == cur
&&
2996 !(cur
->can_focus
|| cur
->focus_notify
))
2999 /* find the centre coords of this window, from the
3000 * currently focused window's point of view */
3001 his_cx
= (cur
->frame
->area
.x
- my_cx
)
3002 + cur
->frame
->area
.width
/ 2;
3003 his_cy
= (cur
->frame
->area
.y
- my_cy
)
3004 + cur
->frame
->area
.height
/ 2;
3006 if(dir
== OB_DIRECTION_NORTHEAST
|| dir
== OB_DIRECTION_SOUTHEAST
||
3007 dir
== OB_DIRECTION_SOUTHWEST
|| dir
== OB_DIRECTION_NORTHWEST
) {
3009 /* Rotate the diagonals 45 degrees counterclockwise.
3010 * To do this, multiply the matrix /+h +h\ with the
3011 * vector (x y). \-h +h/
3012 * h = sqrt(0.5). We can set h := 1 since absolute
3013 * distance doesn't matter here. */
3014 tx
= his_cx
+ his_cy
;
3015 his_cy
= -his_cx
+ his_cy
;
3020 case OB_DIRECTION_NORTH
:
3021 case OB_DIRECTION_SOUTH
:
3022 case OB_DIRECTION_NORTHEAST
:
3023 case OB_DIRECTION_SOUTHWEST
:
3024 offset
= (his_cx
< 0) ? -his_cx
: his_cx
;
3025 distance
= ((dir
== OB_DIRECTION_NORTH
||
3026 dir
== OB_DIRECTION_NORTHEAST
) ?
3029 case OB_DIRECTION_EAST
:
3030 case OB_DIRECTION_WEST
:
3031 case OB_DIRECTION_SOUTHEAST
:
3032 case OB_DIRECTION_NORTHWEST
:
3033 offset
= (his_cy
< 0) ? -his_cy
: his_cy
;
3034 distance
= ((dir
== OB_DIRECTION_WEST
||
3035 dir
== OB_DIRECTION_NORTHWEST
) ?
3040 /* the target must be in the requested direction */
3044 /* Calculate score for this window. The smaller the better. */
3045 score
= distance
+ offset
;
3047 /* windows more than 45 degrees off the direction are
3048 * heavily penalized and will only be chosen if nothing
3049 * else within a million pixels */
3050 if(offset
> distance
)
3053 if(best_score
== -1 || score
< best_score
)
3061 void client_set_layer(ObClient
*self
, gint layer
)
3065 self
->above
= FALSE
;
3066 } else if (layer
== 0) {
3067 self
->below
= self
->above
= FALSE
;
3069 self
->below
= FALSE
;
3072 client_calc_layer(self
);
3073 client_change_state(self
); /* reflect this in the state hints */
3076 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
3078 if (self
->undecorated
!= undecorated
) {
3079 self
->undecorated
= undecorated
;
3080 client_setup_decor_and_functions(self
);
3081 /* Make sure the client knows it might have moved. Maybe there is a
3082 * better way of doing this so only one client_configure is sent, but
3083 * since 125 of these are sent per second when moving the window (with
3084 * user = FALSE) i doubt it matters much.
3086 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
3087 self
->area
.width
, self
->area
.height
, TRUE
, TRUE
);
3088 client_change_state(self
); /* reflect this in the state hints */
3092 /* Determines which physical monitor a client is on by calculating the
3093 area of the part of the client on each monitor. The number of the
3094 monitor containing the greatest area of the client is returned.*/
3095 guint
client_monitor(ObClient
*self
)
3101 for (i
= 0; i
< screen_num_monitors
; ++i
) {
3102 Rect
*area
= screen_physical_area_monitor(i
);
3103 if (RECT_INTERSECTS_RECT(*area
, self
->frame
->area
)) {
3107 RECT_SET_INTERSECTION(r
, *area
, self
->frame
->area
);
3108 v
= r
.width
* r
.height
;
3119 ObClient
*client_search_top_transient(ObClient
*self
)
3121 /* move up the transient chain as far as possible */
3122 if (self
->transient_for
) {
3123 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3124 return client_search_top_transient(self
->transient_for
);
3128 g_assert(self
->group
);
3130 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3131 ObClient
*c
= it
->data
;
3133 /* checking transient_for prevents infinate loops! */
3134 if (c
!= self
&& !c
->transient_for
)
3145 ObClient
*client_search_focus_parent(ObClient
*self
)
3147 if (self
->transient_for
) {
3148 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3149 if (client_focused(self
->transient_for
))
3150 return self
->transient_for
;
3154 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3155 ObClient
*c
= it
->data
;
3157 /* checking transient_for prevents infinate loops! */
3158 if (c
!= self
&& !c
->transient_for
)
3159 if (client_focused(c
))
3168 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3170 if (self
->transient_for
) {
3171 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3172 if (self
->transient_for
== search
)
3177 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3178 ObClient
*c
= it
->data
;
3180 /* checking transient_for prevents infinate loops! */
3181 if (c
!= self
&& !c
->transient_for
)
3191 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3195 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3196 if (sit
->data
== search
)
3198 if (client_search_transient(sit
->data
, search
))
3204 void client_update_sm_client_id(ObClient
*self
)
3206 g_free(self
->sm_client_id
);
3207 self
->sm_client_id
= NULL
;
3209 if (!PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
) &&
3211 PROP_GETS(self
->group
->leader
, sm_client_id
, locale
,
3212 &self
->sm_client_id
);
3215 /* finds the nearest edge in the given direction from the current client
3216 * note to self: the edge is the -frame- edge (the actual one), not the
3219 gint
client_directional_edge_search(ObClient
*c
, ObDirection dir
)
3221 gint dest
, monitor_dest
;
3222 gint my_edge_start
, my_edge_end
, my_offset
;
3229 a
= screen_area(c
->desktop
);
3230 monitor
= screen_area_monitor(c
->desktop
, client_monitor(c
));
3233 case OB_DIRECTION_NORTH
:
3234 my_edge_start
= c
->frame
->area
.x
;
3235 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3236 my_offset
= c
->frame
->area
.y
;
3238 /* default: top of screen */
3240 monitor_dest
= monitor
->y
;
3241 /* if the monitor edge comes before the screen edge, */
3242 /* use that as the destination instead. (For xinerama) */
3243 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3244 dest
= monitor_dest
;
3246 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3247 gint his_edge_start
, his_edge_end
, his_offset
;
3248 ObClient
*cur
= it
->data
;
3252 if(!client_normal(cur
))
3254 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3258 if(cur
->layer
< c
->layer
&& !config_resist_layers_below
)
3261 his_edge_start
= cur
->frame
->area
.x
;
3262 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3263 his_offset
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3265 if(his_offset
+ 1 > my_offset
)
3268 if(his_offset
< dest
)
3271 if(his_edge_start
>= my_edge_start
&&
3272 his_edge_start
<= my_edge_end
)
3275 if(my_edge_start
>= his_edge_start
&&
3276 my_edge_start
<= his_edge_end
)
3281 case OB_DIRECTION_SOUTH
:
3282 my_edge_start
= c
->frame
->area
.x
;
3283 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3284 my_offset
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3286 /* default: bottom of screen */
3287 dest
= a
->y
+ a
->height
;
3288 monitor_dest
= monitor
->y
+ monitor
->height
;
3289 /* if the monitor edge comes before the screen edge, */
3290 /* use that as the destination instead. (For xinerama) */
3291 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3292 dest
= monitor_dest
;
3294 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3295 gint his_edge_start
, his_edge_end
, his_offset
;
3296 ObClient
*cur
= it
->data
;
3300 if(!client_normal(cur
))
3302 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3306 if(cur
->layer
< c
->layer
&& !config_resist_layers_below
)
3309 his_edge_start
= cur
->frame
->area
.x
;
3310 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3311 his_offset
= cur
->frame
->area
.y
;
3314 if(his_offset
- 1 < my_offset
)
3317 if(his_offset
> dest
)
3320 if(his_edge_start
>= my_edge_start
&&
3321 his_edge_start
<= my_edge_end
)
3324 if(my_edge_start
>= his_edge_start
&&
3325 my_edge_start
<= his_edge_end
)
3330 case OB_DIRECTION_WEST
:
3331 my_edge_start
= c
->frame
->area
.y
;
3332 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3333 my_offset
= c
->frame
->area
.x
;
3335 /* default: leftmost egde of screen */
3337 monitor_dest
= monitor
->x
;
3338 /* if the monitor edge comes before the screen edge, */
3339 /* use that as the destination instead. (For xinerama) */
3340 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3341 dest
= monitor_dest
;
3343 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3344 gint his_edge_start
, his_edge_end
, his_offset
;
3345 ObClient
*cur
= it
->data
;
3349 if(!client_normal(cur
))
3351 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3355 if(cur
->layer
< c
->layer
&& !config_resist_layers_below
)
3358 his_edge_start
= cur
->frame
->area
.y
;
3359 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3360 his_offset
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3362 if(his_offset
+ 1 > my_offset
)
3365 if(his_offset
< dest
)
3368 if(his_edge_start
>= my_edge_start
&&
3369 his_edge_start
<= my_edge_end
)
3372 if(my_edge_start
>= his_edge_start
&&
3373 my_edge_start
<= his_edge_end
)
3379 case OB_DIRECTION_EAST
:
3380 my_edge_start
= c
->frame
->area
.y
;
3381 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3382 my_offset
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3384 /* default: rightmost edge of screen */
3385 dest
= a
->x
+ a
->width
;
3386 monitor_dest
= monitor
->x
+ monitor
->width
;
3387 /* if the monitor edge comes before the screen edge, */
3388 /* use that as the destination instead. (For xinerama) */
3389 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3390 dest
= monitor_dest
;
3392 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3393 gint his_edge_start
, his_edge_end
, his_offset
;
3394 ObClient
*cur
= it
->data
;
3398 if(!client_normal(cur
))
3400 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3404 if(cur
->layer
< c
->layer
&& !config_resist_layers_below
)
3407 his_edge_start
= cur
->frame
->area
.y
;
3408 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3409 his_offset
= cur
->frame
->area
.x
;
3411 if(his_offset
- 1 < my_offset
)
3414 if(his_offset
> dest
)
3417 if(his_edge_start
>= my_edge_start
&&
3418 his_edge_start
<= my_edge_end
)
3421 if(my_edge_start
>= his_edge_start
&&
3422 my_edge_start
<= his_edge_end
)
3427 case OB_DIRECTION_NORTHEAST
:
3428 case OB_DIRECTION_SOUTHEAST
:
3429 case OB_DIRECTION_NORTHWEST
:
3430 case OB_DIRECTION_SOUTHWEST
:
3431 /* not implemented */
3433 g_assert_not_reached();
3434 dest
= 0; /* suppress warning */
3439 ObClient
* client_under_pointer()
3443 ObClient
*ret
= NULL
;
3445 if (screen_pointer_pos(&x
, &y
)) {
3446 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
3447 if (WINDOW_IS_CLIENT(it
->data
)) {
3448 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
3449 if (c
->frame
->visible
&&
3450 RECT_CONTAINS(c
->frame
->area
, x
, y
)) {
3460 gboolean
client_has_group_siblings(ObClient
*self
)
3462 return self
->group
&& self
->group
->members
->next
;