1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2003 Ben Jansens
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.
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.
16 See the COPYING file for a copy of the GNU General Public License.
21 #include "startupnotify.h"
25 #include "moveresize.h"
28 #include "extensions.h"
38 #include "menuframe.h"
41 #include "render/render.h"
44 #include <X11/Xutil.h>
46 /*! The event mask to grab on client windows */
47 #define CLIENT_EVENTMASK (PropertyChangeMask | FocusChangeMask | \
50 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
55 ObClientDestructor func
;
59 GList
*client_list
= NULL
;
60 GSList
*client_destructors
= NULL
;
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
);
79 void client_startup(gboolean reconfig
)
86 void client_shutdown(gboolean reconfig
)
90 void client_add_destructor(ObClientDestructor func
, gpointer data
)
92 Destructor
*d
= g_new(Destructor
, 1);
95 client_destructors
= g_slist_prepend(client_destructors
, d
);
98 void client_remove_destructor(ObClientDestructor func
)
102 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
103 Destructor
*d
= it
->data
;
104 if (d
->func
== func
) {
106 client_destructors
= g_slist_delete_link(client_destructors
, it
);
112 void client_set_list()
114 Window
*windows
, *win_it
;
116 guint size
= g_list_length(client_list
);
118 /* create an array of the window ids */
120 windows
= g_new(Window
, size
);
122 for (it
= client_list
; it
!= NULL
; it
= it
->next
, ++win_it
)
123 *win_it
= ((ObClient
*)it
->data
)->window
;
127 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
128 net_client_list
, window
, (guint32
*)windows
, size
);
137 void client_foreach_transient(ObClient *self, ObClientForeachFunc func, void *data)
141 for (it = self->transients; it; it = it->next) {
142 if (!func(it->data, data)) return;
143 client_foreach_transient(it->data, func, data);
147 void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, void *data)
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);
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);
167 void client_manage_all()
172 XWindowAttributes attrib
;
174 XQueryTree(ob_display
, RootWindow(ob_display
, ob_screen
),
175 &w
, &w
, &children
, &nchild
);
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
]);
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
) {
193 for (i
= 0; i
< nchild
; ++i
) {
194 if (children
[i
] == None
)
196 if (XGetWindowAttributes(ob_display
, children
[i
], &attrib
)) {
197 if (attrib
.override_redirect
) continue;
199 if (attrib
.map_state
!= IsUnmapped
)
200 client_manage(children
[i
]);
206 void client_manage(Window window
)
210 XWindowAttributes attrib
;
211 XSetWindowAttributes attrib_set
;
213 gboolean activate
= FALSE
;
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
);
224 return; /* don't manage it */
227 /* make sure it isn't an override-redirect window */
228 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
229 attrib
.override_redirect
) {
231 return; /* don't manage it */
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
);
246 ob_debug("Managing window: %lx\n", window
);
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
);
255 /* create the ObClient struct, and populate it from the hints on the
257 self
= g_new0(ObClient
, 1);
258 self
->obwin
.type
= Window_Client
;
259 self
->window
= window
;
261 /* non-zero defaults */
262 self
->title_count
= 1;
263 self
->wmstate
= NormalState
;
265 self
->desktop
= screen_num_desktops
; /* always an invalid value */
267 client_get_all(self
);
268 client_restore_session_state(self
);
270 sn_app_started(self
->class);
272 client_change_state(self
);
274 /* remove the client's border (and adjust re gravity) */
275 client_toggle_border(self
, FALSE
);
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
);
281 /* create the decoration frame for the client window */
282 self
->frame
= frame_new();
284 frame_grab_client(self
->frame
, self
);
288 client_apply_startup_state(self
);
290 /* update the focus lists */
291 focus_order_add_new(self
);
293 stacking_add(CLIENT_AS_WINDOW(self
));
294 client_restore_session_stacking(self
);
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
))
307 if (self
->desktop
!= screen_desktop
) {
308 /* activate the window */
311 gboolean group_foc
= FALSE
;
316 for (it
= self
->group
->members
; it
; it
= it
->next
)
318 if (client_focused(it
->data
))
326 (!self
->transient_for
&& (!self
->group
||
327 !self
->group
->members
->next
))) ||
328 client_search_focus_tree_full(self
) ||
330 !client_normal(focus_client
))
332 /* activate the window */
339 if (ob_state() == OB_STATE_RUNNING
) {
340 gint x
= self
->area
.x
, ox
= x
;
341 gint y
= self
->area
.y
, oy
= y
;
343 place_client(self
, &x
, &y
);
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 /* non-normal clients has less rules, and
350 windows that are being restored from a session
351 do also. we can assume you want it back where
353 client_normal(self
) && !self
->session
);
355 if (x
!= ox
|| y
!= oy
)
356 client_move(self
, x
, y
);
359 client_showhide(self
);
361 /* use client_focus instead of client_activate cuz client_activate does
362 stuff like switch desktops etc and I'm not interested in all that when
363 a window maps since its not based on an action from the user like
364 clicking a window to activate is. so keep the new window out of the way
367 /* if using focus_delay, stop the timer now so that focus doesn't go
369 event_halt_focus_delay();
372 /* since focus can change the stacking orders, if we focus the window
373 then the standard raise it gets is not enough, we need to queue one
374 for after the focus change takes place */
378 /* client_activate does this but we aret using it so we have to do it
380 if (screen_showing_desktop
)
381 screen_show_desktop(FALSE
);
383 /* add to client list/map */
384 client_list
= g_list_append(client_list
, self
);
385 g_hash_table_insert(window_map
, &self
->window
, self
);
387 /* this has to happen after we're in the client_list */
388 screen_update_areas();
390 /* update the list hints */
393 keyboard_grab_for_client(self
, TRUE
);
394 mouse_grab_for_client(self
, TRUE
);
396 ob_debug("Managed window 0x%lx (%s)\n", window
, self
->class);
399 void client_unmanage_all()
401 while (client_list
!= NULL
)
402 client_unmanage(client_list
->data
);
405 void client_unmanage(ObClient
*self
)
410 ob_debug("Unmanaging window: %lx (%s)\n", self
->window
, self
->class);
412 g_assert(self
!= NULL
);
414 keyboard_grab_for_client(self
, FALSE
);
415 mouse_grab_for_client(self
, FALSE
);
417 /* remove the window from our save set */
418 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
420 /* we dont want events no more */
421 XSelectInput(ob_display
, self
->window
, NoEventMask
);
423 frame_hide(self
->frame
);
425 client_list
= g_list_remove(client_list
, self
);
426 stacking_remove(self
);
427 g_hash_table_remove(window_map
, &self
->window
);
429 /* update the focus lists */
430 focus_order_remove(self
);
432 /* once the client is out of the list, update the struts to remove it's
434 screen_update_areas();
436 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
437 Destructor
*d
= it
->data
;
438 d
->func(self
, d
->data
);
441 if (focus_client
== self
) {
444 /* focus the last focused window on the desktop, and ignore enter
445 events from the unmap so it doesnt mess with the focus */
446 while (XCheckTypedEvent(ob_display
, EnterNotify
, &e
));
447 /* remove these flags so we don't end up getting focused in the
449 self
->can_focus
= FALSE
;
450 self
->focus_notify
= FALSE
;
452 client_unfocus(self
);
455 /* tell our parent(s) that we're gone */
456 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
459 for (it
= self
->group
->members
; it
; it
= it
->next
)
460 if (it
->data
!= self
)
461 ((ObClient
*)it
->data
)->transients
=
462 g_slist_remove(((ObClient
*)it
->data
)->transients
, self
);
463 } else if (self
->transient_for
) { /* transient of window */
464 self
->transient_for
->transients
=
465 g_slist_remove(self
->transient_for
->transients
, self
);
468 /* tell our transients that we're gone */
469 for (it
= self
->transients
; it
!= NULL
; it
= it
->next
) {
470 if (((ObClient
*)it
->data
)->transient_for
!= OB_TRAN_GROUP
) {
471 ((ObClient
*)it
->data
)->transient_for
= NULL
;
472 client_calc_layer(it
->data
);
476 /* remove from its group */
478 group_remove(self
->group
, self
);
482 /* give the client its border back */
483 client_toggle_border(self
, TRUE
);
485 /* reparent the window out of the frame, and free the frame */
486 frame_release_client(self
->frame
, self
);
489 if (ob_state() != OB_STATE_EXITING
) {
490 /* these values should not be persisted across a window
492 PROP_ERASE(self
->window
, net_wm_desktop
);
493 PROP_ERASE(self
->window
, net_wm_state
);
494 PROP_ERASE(self
->window
, wm_state
);
496 /* if we're left in an unmapped state, the client wont be mapped. this
497 is bad, since we will no longer be managing the window on restart */
498 XMapWindow(ob_display
, self
->window
);
502 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
504 /* free all data allocated in the client struct */
505 g_slist_free(self
->transients
);
506 for (j
= 0; j
< self
->nicons
; ++j
)
507 g_free(self
->icons
[j
].data
);
508 if (self
->nicons
> 0)
511 g_free(self
->icon_title
);
515 g_free(self
->sm_client_id
);
518 /* update the list hints */
522 static void client_urgent_notify(ObClient
*self
)
525 frame_flash_start(self
->frame
);
527 frame_flash_stop(self
->frame
);
530 static void client_restore_session_state(ObClient
*self
)
534 if (!(it
= session_state_find(self
)))
537 self
->session
= it
->data
;
539 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
540 self
->positioned
= TRUE
;
541 if (self
->session
->w
> 0)
542 self
->area
.width
= self
->session
->w
;
543 if (self
->session
->h
> 0)
544 self
->area
.height
= self
->session
->h
;
545 XResizeWindow(ob_display
, self
->window
,
546 self
->area
.width
, self
->area
.height
);
548 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
549 self
->session
->desktop
:
550 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
551 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
553 self
->shaded
= self
->session
->shaded
;
554 self
->iconic
= self
->session
->iconic
;
555 self
->skip_pager
= self
->session
->skip_pager
;
556 self
->skip_taskbar
= self
->session
->skip_taskbar
;
557 self
->fullscreen
= self
->session
->fullscreen
;
558 self
->above
= self
->session
->above
;
559 self
->below
= self
->session
->below
;
560 self
->max_horz
= self
->session
->max_horz
;
561 self
->max_vert
= self
->session
->max_vert
;
564 static void client_restore_session_stacking(ObClient
*self
)
568 if (!self
->session
) return;
570 it
= g_list_find(session_saved_state
, self
->session
);
571 for (it
= g_list_previous(it
); it
; it
= g_list_previous(it
)) {
574 for (cit
= client_list
; cit
; cit
= g_list_next(cit
))
575 if (session_state_cmp(it
->data
, cit
->data
))
578 client_calc_layer(self
);
579 stacking_below(CLIENT_AS_WINDOW(self
),
580 CLIENT_AS_WINDOW(cit
->data
));
586 void client_move_onscreen(ObClient
*self
, gboolean rude
)
588 gint x
= self
->area
.x
;
589 gint y
= self
->area
.y
;
590 if (client_find_onscreen(self
, &x
, &y
,
591 self
->frame
->area
.width
,
592 self
->frame
->area
.height
, rude
)) {
593 client_move(self
, x
, y
);
597 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
601 gint ox
= *x
, oy
= *y
;
603 frame_client_gravity(self
->frame
, x
, y
); /* get where the frame
606 /* XXX watch for xinerama dead areas */
608 a
= screen_area(self
->desktop
);
609 if (client_normal(self
)) {
610 if (!self
->strut
.right
&& *x
>= a
->x
+ a
->width
- 1)
611 *x
= a
->x
+ a
->width
- self
->frame
->area
.width
;
612 if (!self
->strut
.bottom
&& *y
>= a
->y
+ a
->height
- 1)
613 *y
= a
->y
+ a
->height
- self
->frame
->area
.height
;
614 if (!self
->strut
.left
&& *x
+ self
->frame
->area
.width
- 1 < a
->x
)
616 if (!self
->strut
.top
&& *y
+ self
->frame
->area
.height
- 1 < a
->y
)
621 /* this is my MOZILLA BITCHSLAP. oh ya it fucking feels good.
622 Java can suck it too. */
624 /* dont let windows map/move into the strut unless they
625 are bigger than the available area */
627 if (!self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
628 if (!self
->strut
.right
&& *x
+ w
> a
->x
+ a
->width
)
629 *x
= a
->x
+ a
->width
- w
;
631 if (h
<= a
->height
) {
632 if (!self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
633 if (!self
->strut
.bottom
&& *y
+ h
> a
->y
+ a
->height
)
634 *y
= a
->y
+ a
->height
- h
;
638 frame_frame_gravity(self
->frame
, x
, y
); /* get where the client
641 return ox
!= *x
|| oy
!= *y
;
644 static void client_toggle_border(ObClient
*self
, gboolean show
)
646 /* adjust our idea of where the client is, based on its border. When the
647 border is removed, the client should now be considered to be in a
649 when re-adding the border to the client, the same operation needs to be
651 gint oldx
= self
->area
.x
, oldy
= self
->area
.y
;
652 gint x
= oldx
, y
= oldy
;
653 switch(self
->gravity
) {
655 case NorthWestGravity
:
657 case SouthWestGravity
:
659 case NorthEastGravity
:
661 case SouthEastGravity
:
662 if (show
) x
-= self
->border_width
* 2;
663 else x
+= self
->border_width
* 2;
670 if (show
) x
-= self
->border_width
;
671 else x
+= self
->border_width
;
674 switch(self
->gravity
) {
676 case NorthWestGravity
:
678 case NorthEastGravity
:
680 case SouthWestGravity
:
682 case SouthEastGravity
:
683 if (show
) y
-= self
->border_width
* 2;
684 else y
+= self
->border_width
* 2;
691 if (show
) y
-= self
->border_width
;
692 else y
+= self
->border_width
;
699 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
701 /* move the client so it is back it the right spot _with_ its
703 if (x
!= oldx
|| y
!= oldy
)
704 XMoveWindow(ob_display
, self
->window
, x
, y
);
706 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
710 static void client_get_all(ObClient
*self
)
712 client_get_area(self
);
713 client_update_transient_for(self
);
714 client_update_wmhints(self
);
715 client_get_startup_id(self
);
716 client_get_desktop(self
);
717 client_get_state(self
);
718 client_get_shaped(self
);
720 client_get_mwm_hints(self
);
721 client_get_type(self
);/* this can change the mwmhints for special cases */
724 /* a couple type-based defaults for new windows */
726 /* this makes sure that these windows appear on all desktops */
727 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
728 self
->desktop
= DESKTOP_ALL
;
730 /* dock windows default to ABOVE */
731 if (self
->type
== OB_CLIENT_TYPE_DOCK
&& !self
->below
)
735 client_update_protocols(self
);
737 client_get_gravity(self
); /* get the attribute gravity */
738 client_update_normal_hints(self
); /* this may override the attribute
741 /* got the type, the mwmhints, the protocols, and the normal hints
742 (min/max sizes), so we're ready to set up the decorations/functions */
743 client_setup_decor_and_functions(self
);
745 client_update_title(self
);
746 client_update_class(self
);
747 client_update_sm_client_id(self
);
748 client_update_strut(self
);
749 client_update_icons(self
);
752 static void client_get_startup_id(ObClient
*self
)
754 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
756 PROP_GETS(self
->group
->leader
,
757 net_startup_id
, utf8
, &self
->startup_id
);
760 static void client_get_area(ObClient
*self
)
762 XWindowAttributes wattrib
;
765 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
766 g_assert(ret
!= BadWindow
);
768 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
769 self
->border_width
= wattrib
.border_width
;
772 static void client_get_desktop(ObClient
*self
)
774 guint32 d
= screen_num_desktops
; /* an always-invalid value */
776 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
777 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
778 self
->desktop
= screen_num_desktops
- 1;
782 gboolean trdesk
= FALSE
;
784 if (self
->transient_for
) {
785 if (self
->transient_for
!= OB_TRAN_GROUP
) {
786 self
->desktop
= self
->transient_for
->desktop
;
791 for (it
= self
->group
->members
; it
; it
= it
->next
)
792 if (it
->data
!= self
&&
793 !((ObClient
*)it
->data
)->transient_for
) {
794 self
->desktop
= ((ObClient
*)it
->data
)->desktop
;
801 /* try get from the startup-notification protocol */
802 if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
803 if (self
->desktop
>= screen_num_desktops
&&
804 self
->desktop
!= DESKTOP_ALL
)
805 self
->desktop
= screen_num_desktops
- 1;
807 /* defaults to the current desktop */
808 self
->desktop
= screen_desktop
;
811 if (self
->desktop
!= d
) {
812 /* set the desktop hint, to make sure that it always exists */
813 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
817 static void client_get_state(ObClient
*self
)
822 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
824 for (i
= 0; i
< num
; ++i
) {
825 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
827 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
829 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
831 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
832 self
->skip_taskbar
= TRUE
;
833 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
834 self
->skip_pager
= TRUE
;
835 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
836 self
->fullscreen
= TRUE
;
837 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
838 self
->max_vert
= TRUE
;
839 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
840 self
->max_horz
= TRUE
;
841 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
843 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
845 else if (state
[i
] == prop_atoms
.ob_wm_state_undecorated
)
846 self
->undecorated
= TRUE
;
852 if (!(self
->above
|| self
->below
)) {
854 /* apply stuff from the group */
858 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
859 ObClient
*c
= it
->data
;
860 if (c
!= self
&& !client_search_transient(self
, c
) &&
861 client_normal(self
) == client_normal(c
))
864 (c
->above
? 1 : (c
->below
? -1 : 0)));
878 g_assert_not_reached();
885 static void client_get_shaped(ObClient
*self
)
887 self
->shaped
= FALSE
;
889 if (extensions_shape
) {
894 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
896 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
897 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
899 self
->shaped
= (s
!= 0);
904 void client_update_transient_for(ObClient
*self
)
907 ObClient
*target
= NULL
;
909 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
910 self
->transient
= TRUE
;
911 if (t
!= self
->window
) { /* cant be transient to itself! */
912 target
= g_hash_table_lookup(window_map
, &t
);
913 /* if this happens then we need to check for it*/
914 g_assert(target
!= self
);
915 if (target
&& !WINDOW_IS_CLIENT(target
)) {
916 /* this can happen when a dialog is a child of
917 a dockapp, for example */
921 if (!target
&& self
->group
) {
922 /* not transient to a client, see if it is transient for a
924 if (t
== self
->group
->leader
||
926 t
== RootWindow(ob_display
, ob_screen
))
928 /* window is a transient for its group! */
929 target
= OB_TRAN_GROUP
;
934 self
->transient
= FALSE
;
936 /* if anything has changed... */
937 if (target
!= self
->transient_for
) {
938 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
941 /* remove from old parents */
942 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
943 ObClient
*c
= it
->data
;
944 if (c
!= self
&& !c
->transient_for
)
945 c
->transients
= g_slist_remove(c
->transients
, self
);
947 } else if (self
->transient_for
!= NULL
) { /* transient of window */
948 /* remove from old parent */
949 self
->transient_for
->transients
=
950 g_slist_remove(self
->transient_for
->transients
, self
);
952 self
->transient_for
= target
;
953 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
956 /* add to new parents */
957 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
958 ObClient
*c
= it
->data
;
959 if (c
!= self
&& !c
->transient_for
)
960 c
->transients
= g_slist_append(c
->transients
, self
);
963 /* remove all transients which are in the group, that causes
964 circlular pointer hell of doom */
965 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
967 for (sit
= self
->transients
; sit
; sit
= next
) {
968 next
= g_slist_next(sit
);
969 if (sit
->data
== it
->data
)
971 g_slist_delete_link(self
->transients
, sit
);
974 } else if (self
->transient_for
!= NULL
) { /* transient of window */
975 /* add to new parent */
976 self
->transient_for
->transients
=
977 g_slist_append(self
->transient_for
->transients
, self
);
982 static void client_get_mwm_hints(ObClient
*self
)
987 self
->mwmhints
.flags
= 0; /* default to none */
989 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
991 if (num
>= OB_MWM_ELEMENTS
) {
992 self
->mwmhints
.flags
= hints
[0];
993 self
->mwmhints
.functions
= hints
[1];
994 self
->mwmhints
.decorations
= hints
[2];
1000 void client_get_type(ObClient
*self
)
1007 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1008 /* use the first value that we know about in the array */
1009 for (i
= 0; i
< num
; ++i
) {
1010 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1011 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1012 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1013 self
->type
= OB_CLIENT_TYPE_DOCK
;
1014 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1015 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1016 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1017 self
->type
= OB_CLIENT_TYPE_MENU
;
1018 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1019 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1020 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1021 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1022 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1023 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1024 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1025 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1026 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1027 /* prevent this window from getting any decor or
1029 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1030 OB_MWM_FLAG_DECORATIONS
);
1031 self
->mwmhints
.decorations
= 0;
1032 self
->mwmhints
.functions
= 0;
1034 if (self
->type
!= (ObClientType
) -1)
1035 break; /* grab the first legit type */
1040 if (self
->type
== (ObClientType
) -1) {
1041 /*the window type hint was not set, which means we either classify
1042 ourself as a normal window or a dialog, depending on if we are a
1044 if (self
->transient
)
1045 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1047 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1051 void client_update_protocols(ObClient
*self
)
1054 guint num_return
, i
;
1056 self
->focus_notify
= FALSE
;
1057 self
->delete_window
= FALSE
;
1059 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1060 for (i
= 0; i
< num_return
; ++i
) {
1061 if (proto
[i
] == prop_atoms
.wm_delete_window
) {
1062 /* this means we can request the window to close */
1063 self
->delete_window
= TRUE
;
1064 } else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1065 /* if this protocol is requested, then the window will be
1066 notified whenever we want it to receive focus */
1067 self
->focus_notify
= TRUE
;
1073 static void client_get_gravity(ObClient
*self
)
1075 XWindowAttributes wattrib
;
1078 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1079 g_assert(ret
!= BadWindow
);
1080 self
->gravity
= wattrib
.win_gravity
;
1083 void client_update_normal_hints(ObClient
*self
)
1087 gint oldgravity
= self
->gravity
;
1090 self
->min_ratio
= 0.0f
;
1091 self
->max_ratio
= 0.0f
;
1092 SIZE_SET(self
->size_inc
, 1, 1);
1093 SIZE_SET(self
->base_size
, 0, 0);
1094 SIZE_SET(self
->min_size
, 0, 0);
1095 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1097 /* get the hints from the window */
1098 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1099 /* normal windows can't request placement! har har
1100 if (!client_normal(self))
1102 self
->positioned
= !!(size
.flags
& (PPosition
|USPosition
));
1104 if (size
.flags
& PWinGravity
) {
1105 self
->gravity
= size
.win_gravity
;
1107 /* if the client has a frame, i.e. has already been mapped and
1108 is changing its gravity */
1109 if (self
->frame
&& self
->gravity
!= oldgravity
) {
1110 /* move our idea of the client's position based on its new
1112 self
->area
.x
= self
->frame
->area
.x
;
1113 self
->area
.y
= self
->frame
->area
.y
;
1114 frame_frame_gravity(self
->frame
, &self
->area
.x
, &self
->area
.y
);
1118 if (size
.flags
& PAspect
) {
1119 if (size
.min_aspect
.y
)
1121 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1122 if (size
.max_aspect
.y
)
1124 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1127 if (size
.flags
& PMinSize
)
1128 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1130 if (size
.flags
& PMaxSize
)
1131 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1133 if (size
.flags
& PBaseSize
)
1134 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1136 if (size
.flags
& PResizeInc
)
1137 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1141 void client_setup_decor_and_functions(ObClient
*self
)
1143 /* start with everything (cept fullscreen) */
1145 (OB_FRAME_DECOR_TITLEBAR
|
1146 (ob_rr_theme
->show_handle
? OB_FRAME_DECOR_HANDLE
: 0) |
1147 OB_FRAME_DECOR_GRIPS
|
1148 OB_FRAME_DECOR_BORDER
|
1149 OB_FRAME_DECOR_ICON
|
1150 OB_FRAME_DECOR_ALLDESKTOPS
|
1151 OB_FRAME_DECOR_ICONIFY
|
1152 OB_FRAME_DECOR_MAXIMIZE
|
1153 OB_FRAME_DECOR_SHADE
|
1154 OB_FRAME_DECOR_CLOSE
);
1156 (OB_CLIENT_FUNC_RESIZE
|
1157 OB_CLIENT_FUNC_MOVE
|
1158 OB_CLIENT_FUNC_ICONIFY
|
1159 OB_CLIENT_FUNC_MAXIMIZE
|
1160 OB_CLIENT_FUNC_SHADE
|
1161 OB_CLIENT_FUNC_CLOSE
);
1163 if (!(self
->min_size
.width
< self
->max_size
.width
||
1164 self
->min_size
.height
< self
->max_size
.height
))
1165 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1167 switch (self
->type
) {
1168 case OB_CLIENT_TYPE_NORMAL
:
1169 /* normal windows retain all of the possible decorations and
1170 functionality, and are the only windows that you can fullscreen */
1171 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1174 case OB_CLIENT_TYPE_DIALOG
:
1175 case OB_CLIENT_TYPE_UTILITY
:
1176 /* these windows cannot be maximized */
1177 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1180 case OB_CLIENT_TYPE_MENU
:
1181 case OB_CLIENT_TYPE_TOOLBAR
:
1182 /* these windows get less functionality */
1183 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
| OB_CLIENT_FUNC_RESIZE
);
1186 case OB_CLIENT_TYPE_DESKTOP
:
1187 case OB_CLIENT_TYPE_DOCK
:
1188 case OB_CLIENT_TYPE_SPLASH
:
1189 /* none of these windows are manipulated by the window manager */
1190 self
->decorations
= 0;
1191 self
->functions
= 0;
1195 /* Mwm Hints are applied subtractively to what has already been chosen for
1196 decor and functionality */
1197 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1198 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1199 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1200 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1201 /* if the mwm hints request no handle or title, then all
1202 decorations are disabled */
1203 self
->decorations
= 0;
1207 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1208 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1209 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1210 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1211 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1212 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1213 /* dont let mwm hints kill any buttons
1214 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1215 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1216 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1217 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1219 /* dont let mwm hints kill the close button
1220 if (! (self->mwmhints.functions & MwmFunc_Close))
1221 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1225 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1226 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1227 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1228 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1229 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1230 self
->decorations
&= ~OB_FRAME_DECOR_GRIPS
;
1232 /* can't maximize without moving/resizing */
1233 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1234 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1235 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1236 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1237 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1240 /* kill the handle on fully maxed windows */
1241 if (self
->max_vert
&& self
->max_horz
)
1242 self
->decorations
&= ~OB_FRAME_DECOR_HANDLE
;
1244 /* finally, the user can have requested no decorations, which overrides
1245 everything (but doesnt give it a border if it doesnt have one) */
1246 if (self
->undecorated
)
1247 self
->decorations
&= OB_FRAME_DECOR_BORDER
;
1249 /* if we don't have a titlebar, then we cannot shade! */
1250 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1251 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1253 /* now we need to check against rules for the client's current state */
1254 if (self
->fullscreen
) {
1255 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1256 OB_CLIENT_FUNC_FULLSCREEN
|
1257 OB_CLIENT_FUNC_ICONIFY
);
1258 self
->decorations
= 0;
1261 client_change_allowed_actions(self
);
1264 /* adjust the client's decorations, etc. */
1265 client_reconfigure(self
);
1269 static void client_change_allowed_actions(ObClient
*self
)
1274 /* desktop windows are kept on all desktops */
1275 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1276 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1278 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1279 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1280 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1281 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1282 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1283 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1284 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1285 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1286 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1287 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1288 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1289 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1290 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1291 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1292 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1295 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1297 /* make sure the window isn't breaking any rules now */
1299 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1300 if (self
->frame
) client_shade(self
, FALSE
);
1301 else self
->shaded
= FALSE
;
1303 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
) && self
->iconic
) {
1304 if (self
->frame
) client_iconify(self
, FALSE
, TRUE
);
1305 else self
->iconic
= FALSE
;
1307 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1308 if (self
->frame
) client_fullscreen(self
, FALSE
, TRUE
);
1309 else self
->fullscreen
= FALSE
;
1311 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1313 if (self
->frame
) client_maximize(self
, FALSE
, 0, TRUE
);
1314 else self
->max_vert
= self
->max_horz
= FALSE
;
1318 void client_reconfigure(ObClient
*self
)
1320 /* by making this pass FALSE for user, we avoid the emacs event storm where
1321 every configurenotify causes an update in its normal hints, i think this
1322 is generally what we want anyways... */
1323 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
1324 self
->area
.width
, self
->area
.height
, FALSE
, TRUE
);
1327 void client_update_wmhints(ObClient
*self
)
1330 gboolean ur
= FALSE
;
1333 /* assume a window takes input if it doesnt specify */
1334 self
->can_focus
= TRUE
;
1336 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1337 if (hints
->flags
& InputHint
)
1338 self
->can_focus
= hints
->input
;
1340 /* only do this when first managing the window *AND* when we aren't
1342 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1343 if (hints
->flags
& StateHint
)
1344 self
->iconic
= hints
->initial_state
== IconicState
;
1346 if (hints
->flags
& XUrgencyHint
)
1349 if (!(hints
->flags
& WindowGroupHint
))
1350 hints
->window_group
= None
;
1352 /* did the group state change? */
1353 if (hints
->window_group
!=
1354 (self
->group
? self
->group
->leader
: None
)) {
1355 /* remove from the old group if there was one */
1356 if (self
->group
!= NULL
) {
1357 /* remove transients of the group */
1358 for (it
= self
->group
->members
; it
; it
= it
->next
)
1359 self
->transients
= g_slist_remove(self
->transients
,
1362 /* remove myself from parents in the group */
1363 if (self
->transient_for
== OB_TRAN_GROUP
) {
1364 for (it
= self
->group
->members
; it
; it
= it
->next
) {
1365 ObClient
*c
= it
->data
;
1367 if (c
!= self
&& !c
->transient_for
)
1368 c
->transients
= g_slist_remove(c
->transients
,
1373 group_remove(self
->group
, self
);
1376 if (hints
->window_group
!= None
) {
1377 self
->group
= group_add(hints
->window_group
, self
);
1379 /* i can only have transients from the group if i am not
1381 if (!self
->transient_for
) {
1382 /* add other transients of the group that are already
1384 for (it
= self
->group
->members
; it
; it
= it
->next
) {
1385 ObClient
*c
= it
->data
;
1386 if (c
!= self
&& c
->transient_for
== OB_TRAN_GROUP
)
1388 g_slist_append(self
->transients
, c
);
1393 /* because the self->transient flag wont change from this call,
1394 we don't need to update the window's type and such, only its
1395 transient_for, and the transients lists of other windows in
1396 the group may be affected */
1397 client_update_transient_for(self
);
1400 /* the WM_HINTS can contain an icon */
1401 client_update_icons(self
);
1406 if (ur
!= self
->urgent
) {
1408 /* fire the urgent callback if we're mapped, otherwise, wait until
1409 after we're mapped */
1411 client_urgent_notify(self
);
1415 void client_update_title(ObClient
*self
)
1421 gboolean read_title
;
1424 old_title
= self
->title
;
1427 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
))
1428 /* try old x stuff */
1429 if (!PROP_GETS(self
->window
, wm_name
, locale
, &data
))
1430 data
= g_strdup("Unnamed Window");
1432 /* did the title change? then reset the title_count */
1433 if (old_title
&& 0 != strncmp(old_title
, data
, strlen(data
)))
1434 self
->title_count
= 1;
1436 /* look for duplicates and append a number */
1438 for (it
= client_list
; it
; it
= it
->next
)
1439 if (it
->data
!= self
) {
1440 ObClient
*c
= it
->data
;
1441 if (0 == strncmp(c
->title
, data
, strlen(data
)))
1442 nums
|= 1 << c
->title_count
;
1444 /* find first free number */
1445 for (i
= 1; i
<= 32; ++i
)
1446 if (!(nums
& (1 << i
))) {
1447 if (self
->title_count
== 1 || i
== 1)
1448 self
->title_count
= i
;
1451 /* dont display the number for the first window */
1452 if (self
->title_count
> 1) {
1454 ndata
= g_strdup_printf("%s - [%u]", data
, self
->title_count
);
1459 PROP_SETS(self
->window
, net_wm_visible_name
, data
);
1464 frame_adjust_title(self
->frame
);
1468 /* update the icon title */
1470 g_free(self
->icon_title
);
1474 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
1475 /* try old x stuff */
1476 if (!PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
)) {
1477 data
= g_strdup(self
->title
);
1481 /* append the title count, dont display the number for the first window */
1482 if (read_title
&& self
->title_count
> 1) {
1483 gchar
*vdata
, *ndata
;
1484 ndata
= g_strdup_printf(" - [%u]", self
->title_count
);
1485 vdata
= g_strconcat(data
, ndata
, NULL
);
1491 PROP_SETS(self
->window
, net_wm_visible_icon_name
, data
);
1493 self
->icon_title
= data
;
1496 void client_update_class(ObClient
*self
)
1501 if (self
->name
) g_free(self
->name
);
1502 if (self
->class) g_free(self
->class);
1503 if (self
->role
) g_free(self
->role
);
1505 self
->name
= self
->class = self
->role
= NULL
;
1507 if (PROP_GETSS(self
->window
, wm_class
, locale
, &data
)) {
1509 self
->name
= g_strdup(data
[0]);
1511 self
->class = g_strdup(data
[1]);
1516 if (PROP_GETS(self
->window
, wm_window_role
, locale
, &s
))
1519 if (self
->name
== NULL
) self
->name
= g_strdup("");
1520 if (self
->class == NULL
) self
->class = g_strdup("");
1521 if (self
->role
== NULL
) self
->role
= g_strdup("");
1524 void client_update_strut(ObClient
*self
)
1528 gboolean got
= FALSE
;
1531 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
1535 STRUT_PARTIAL_SET(strut
,
1536 data
[0], data
[2], data
[1], data
[3],
1537 data
[4], data
[5], data
[8], data
[9],
1538 data
[6], data
[7], data
[10], data
[11]);
1544 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
1550 /* use the screen's width/height */
1551 a
= screen_physical_area();
1553 STRUT_PARTIAL_SET(strut
,
1554 data
[0], data
[2], data
[1], data
[3],
1555 a
->y
, a
->y
+ a
->height
- 1,
1556 a
->x
, a
->x
+ a
->width
- 1,
1557 a
->y
, a
->y
+ a
->height
- 1,
1558 a
->x
, a
->x
+ a
->width
- 1);
1564 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
1565 0, 0, 0, 0, 0, 0, 0, 0);
1567 if (!STRUT_EQUAL(strut
, self
->strut
)) {
1568 self
->strut
= strut
;
1570 /* updating here is pointless while we're being mapped cuz we're not in
1571 the client list yet */
1573 screen_update_areas();
1577 void client_update_icons(ObClient
*self
)
1583 for (i
= 0; i
< self
->nicons
; ++i
)
1584 g_free(self
->icons
[i
].data
);
1585 if (self
->nicons
> 0)
1586 g_free(self
->icons
);
1589 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
1590 /* figure out how many valid icons are in here */
1592 while (num
- i
> 2) {
1596 if (i
> num
|| w
*h
== 0) break;
1600 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1602 /* store the icons */
1604 for (j
= 0; j
< self
->nicons
; ++j
) {
1607 w
= self
->icons
[j
].width
= data
[i
++];
1608 h
= self
->icons
[j
].height
= data
[i
++];
1610 if (w
*h
== 0) continue;
1612 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
1613 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
1618 self
->icons
[j
].data
[t
] =
1619 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
1620 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
1621 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
1622 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
1628 } else if (PROP_GETA32(self
->window
, kwm_win_icon
,
1629 kwm_win_icon
, &data
, &num
)) {
1632 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1633 xerror_set_ignore(TRUE
);
1634 if (!RrPixmapToRGBA(ob_rr_inst
,
1636 &self
->icons
[self
->nicons
-1].width
,
1637 &self
->icons
[self
->nicons
-1].height
,
1638 &self
->icons
[self
->nicons
-1].data
)) {
1639 g_free(&self
->icons
[self
->nicons
-1]);
1642 xerror_set_ignore(FALSE
);
1648 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
1649 if (hints
->flags
& IconPixmapHint
) {
1651 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1652 xerror_set_ignore(TRUE
);
1653 if (!RrPixmapToRGBA(ob_rr_inst
,
1655 (hints
->flags
& IconMaskHint
?
1656 hints
->icon_mask
: None
),
1657 &self
->icons
[self
->nicons
-1].width
,
1658 &self
->icons
[self
->nicons
-1].height
,
1659 &self
->icons
[self
->nicons
-1].data
)){
1660 g_free(&self
->icons
[self
->nicons
-1]);
1663 xerror_set_ignore(FALSE
);
1670 frame_adjust_icon(self
->frame
);
1673 static void client_change_state(ObClient
*self
)
1676 guint32 netstate
[11];
1679 state
[0] = self
->wmstate
;
1681 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
1685 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
1687 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
1689 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
1690 if (self
->skip_taskbar
)
1691 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
1692 if (self
->skip_pager
)
1693 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
1694 if (self
->fullscreen
)
1695 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
1697 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
1699 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
1701 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
1703 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
1704 if (self
->undecorated
)
1705 netstate
[num
++] = prop_atoms
.ob_wm_state_undecorated
;
1706 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
1708 client_calc_layer(self
);
1711 frame_adjust_state(self
->frame
);
1714 ObClient
*client_search_focus_tree(ObClient
*self
)
1719 for (it
= self
->transients
; it
!= NULL
; it
= it
->next
) {
1720 if (client_focused(it
->data
)) return it
->data
;
1721 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
1726 ObClient
*client_search_focus_tree_full(ObClient
*self
)
1728 if (self
->transient_for
) {
1729 if (self
->transient_for
!= OB_TRAN_GROUP
) {
1730 return client_search_focus_tree_full(self
->transient_for
);
1733 gboolean recursed
= FALSE
;
1735 for (it
= self
->group
->members
; it
; it
= it
->next
)
1736 if (!((ObClient
*)it
->data
)->transient_for
) {
1738 if ((c
= client_search_focus_tree_full(it
->data
)))
1747 /* this function checks the whole tree, the client_search_focus_tree~
1748 does not, so we need to check this window */
1749 if (client_focused(self
))
1751 return client_search_focus_tree(self
);
1754 static ObStackingLayer
calc_layer(ObClient
*self
)
1758 if (self
->fullscreen
&&
1759 (client_focused(self
) || client_search_focus_tree(self
)))
1760 l
= OB_STACKING_LAYER_FULLSCREEN
;
1761 else if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
1762 l
= OB_STACKING_LAYER_DESKTOP
;
1763 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
1764 if (self
->above
) l
= OB_STACKING_LAYER_DOCK_ABOVE
;
1765 else if (self
->below
) l
= OB_STACKING_LAYER_DOCK_BELOW
;
1766 else l
= OB_STACKING_LAYER_NORMAL
;
1768 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
1769 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
1770 else l
= OB_STACKING_LAYER_NORMAL
;
1775 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
1776 ObStackingLayer l
, gboolean raised
)
1778 ObStackingLayer old
, own
;
1782 own
= calc_layer(self
);
1783 self
->layer
= l
> own
? l
: own
;
1785 for (it
= self
->transients
; it
; it
= it
->next
)
1786 client_calc_layer_recursive(it
->data
, orig
,
1787 l
, raised
? raised
: l
!= old
);
1789 if (!raised
&& l
!= old
)
1790 if (orig
->frame
) { /* only restack if the original window is managed */
1791 stacking_remove(CLIENT_AS_WINDOW(self
));
1792 stacking_add(CLIENT_AS_WINDOW(self
));
1796 void client_calc_layer(ObClient
*self
)
1803 /* transients take on the layer of their parents */
1804 self
= client_search_top_transient(self
);
1806 l
= calc_layer(self
);
1808 client_calc_layer_recursive(self
, orig
, l
, FALSE
);
1811 gboolean
client_should_show(ObClient
*self
)
1815 if (client_normal(self
) && screen_showing_desktop
)
1818 if (self->transient_for) {
1819 if (self->transient_for != OB_TRAN_GROUP)
1820 return client_should_show(self->transient_for);
1824 for (it = self->group->members; it; it = g_slist_next(it)) {
1825 ObClient *c = it->data;
1826 if (c != self && !c->transient_for) {
1827 if (client_should_show(c))
1834 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
1840 static void client_showhide(ObClient
*self
)
1843 if (client_should_show(self
))
1844 frame_show(self
->frame
);
1846 frame_hide(self
->frame
);
1849 gboolean
client_normal(ObClient
*self
) {
1850 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
1851 self
->type
== OB_CLIENT_TYPE_DOCK
||
1852 self
->type
== OB_CLIENT_TYPE_SPLASH
);
1855 static void client_apply_startup_state(ObClient
*self
)
1857 /* these are in a carefully crafted order.. */
1860 self
->iconic
= FALSE
;
1861 client_iconify(self
, TRUE
, FALSE
);
1863 if (self
->fullscreen
) {
1864 self
->fullscreen
= FALSE
;
1865 client_fullscreen(self
, TRUE
, FALSE
);
1867 if (self
->undecorated
) {
1868 self
->undecorated
= FALSE
;
1869 client_set_undecorated(self
, TRUE
);
1872 self
->shaded
= FALSE
;
1873 client_shade(self
, TRUE
);
1876 client_urgent_notify(self
);
1878 if (self
->max_vert
&& self
->max_horz
) {
1879 self
->max_vert
= self
->max_horz
= FALSE
;
1880 client_maximize(self
, TRUE
, 0, FALSE
);
1881 } else if (self
->max_vert
) {
1882 self
->max_vert
= FALSE
;
1883 client_maximize(self
, TRUE
, 2, FALSE
);
1884 } else if (self
->max_horz
) {
1885 self
->max_horz
= FALSE
;
1886 client_maximize(self
, TRUE
, 1, FALSE
);
1889 /* nothing to do for the other states:
1898 void client_configure_full(ObClient
*self
, ObCorner anchor
,
1899 gint x
, gint y
, gint w
, gint h
,
1900 gboolean user
, gboolean final
,
1901 gboolean force_reply
)
1904 gboolean send_resize_client
;
1905 gboolean moved
= FALSE
, resized
= FALSE
;
1906 guint fdecor
= self
->frame
->decorations
;
1907 gboolean fhorz
= self
->frame
->max_horz
;
1909 /* make the frame recalculate its dimentions n shit without changing
1910 anything visible for real, this way the constraints below can work with
1911 the updated frame dimensions. */
1912 frame_adjust_area(self
->frame
, TRUE
, TRUE
, TRUE
);
1914 /* gets the frame's position */
1915 frame_client_gravity(self
->frame
, &x
, &y
);
1917 /* these positions are frame positions, not client positions */
1919 /* set the size and position if fullscreen */
1920 if (self
->fullscreen
) {
1923 XF86VidModeModeLine mode
;
1928 i
= client_monitor(self
);
1929 a
= screen_physical_area_monitor(i
);
1932 if (i
== 0 && /* primary head */
1933 extensions_vidmode
&&
1934 XF86VidModeGetViewPort(ob_display
, ob_screen
, &x
, &y
) &&
1935 /* get the mode last so the mode.privsize isnt freed incorrectly */
1936 XF86VidModeGetModeLine(ob_display
, ob_screen
, &dot
, &mode
)) {
1941 if (mode
.privsize
) XFree(mode
.private);
1951 user
= FALSE
; /* ignore that increment etc shit when in fullscreen */
1955 a
= screen_area_monitor(self
->desktop
, client_monitor(self
));
1957 /* set the size and position if maximized */
1958 if (self
->max_horz
) {
1960 w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
1962 if (self
->max_vert
) {
1964 h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
1968 /* gets the client's position */
1969 frame_frame_gravity(self
->frame
, &x
, &y
);
1971 /* these override the above states! if you cant move you can't move! */
1973 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
1977 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
1978 w
= self
->area
.width
;
1979 h
= self
->area
.height
;
1983 if (!(w
== self
->area
.width
&& h
== self
->area
.height
)) {
1984 gint basew
, baseh
, minw
, minh
;
1986 /* base size is substituted with min size if not specified */
1987 if (self
->base_size
.width
|| self
->base_size
.height
) {
1988 basew
= self
->base_size
.width
;
1989 baseh
= self
->base_size
.height
;
1991 basew
= self
->min_size
.width
;
1992 baseh
= self
->min_size
.height
;
1994 /* min size is substituted with base size if not specified */
1995 if (self
->min_size
.width
|| self
->min_size
.height
) {
1996 minw
= self
->min_size
.width
;
1997 minh
= self
->min_size
.height
;
1999 minw
= self
->base_size
.width
;
2000 minh
= self
->base_size
.height
;
2003 /* if this is a user-requested resize, then check against min/max
2006 /* smaller than min size or bigger than max size? */
2007 if (w
> self
->max_size
.width
) w
= self
->max_size
.width
;
2008 if (w
< minw
) w
= minw
;
2009 if (h
> self
->max_size
.height
) h
= self
->max_size
.height
;
2010 if (h
< minh
) h
= minh
;
2015 /* keep to the increments */
2016 w
/= self
->size_inc
.width
;
2017 h
/= self
->size_inc
.height
;
2019 /* you cannot resize to nothing */
2020 if (basew
+ w
< 1) w
= 1 - basew
;
2021 if (baseh
+ h
< 1) h
= 1 - baseh
;
2023 /* store the logical size */
2024 SIZE_SET(self
->logical_size
,
2025 self
->size_inc
.width
> 1 ? w
: w
+ basew
,
2026 self
->size_inc
.height
> 1 ? h
: h
+ baseh
);
2028 w
*= self
->size_inc
.width
;
2029 h
*= self
->size_inc
.height
;
2034 /* adjust the height to match the width for the aspect ratios.
2035 for this, min size is not substituted for base size ever. */
2036 w
-= self
->base_size
.width
;
2037 h
-= self
->base_size
.height
;
2039 if (self
->min_ratio
)
2040 if (h
* self
->min_ratio
> w
) {
2041 h
= (gint
)(w
/ self
->min_ratio
);
2043 /* you cannot resize to nothing */
2046 w
= (gint
)(h
* self
->min_ratio
);
2049 if (self
->max_ratio
)
2050 if (h
* self
->max_ratio
< w
) {
2051 h
= (gint
)(w
/ self
->max_ratio
);
2053 /* you cannot resize to nothing */
2056 w
= (gint
)(h
* self
->min_ratio
);
2060 w
+= self
->base_size
.width
;
2061 h
+= self
->base_size
.height
;
2068 case OB_CORNER_TOPLEFT
:
2070 case OB_CORNER_TOPRIGHT
:
2071 x
-= w
- self
->area
.width
;
2073 case OB_CORNER_BOTTOMLEFT
:
2074 y
-= h
- self
->area
.height
;
2076 case OB_CORNER_BOTTOMRIGHT
:
2077 x
-= w
- self
->area
.width
;
2078 y
-= h
- self
->area
.height
;
2082 moved
= x
!= self
->area
.x
|| y
!= self
->area
.y
;
2083 resized
= w
!= self
->area
.width
|| h
!= self
->area
.height
;
2085 oldw
= self
->area
.width
;
2086 oldh
= self
->area
.height
;
2087 RECT_SET(self
->area
, x
, y
, w
, h
);
2089 /* for app-requested resizes, always resize if 'resized' is true.
2090 for user-requested ones, only resize if final is true, or when
2091 resizing in redraw mode */
2092 send_resize_client
= ((!user
&& resized
) ||
2094 (resized
&& config_redraw_resize
))));
2096 /* if the client is enlarging, the resize the client before the frame */
2097 if (send_resize_client
&& user
&& (w
> oldw
|| h
> oldh
))
2098 XResizeWindow(ob_display
, self
->window
, MAX(w
, oldw
), MAX(h
, oldh
));
2100 /* move/resize the frame to match the request */
2102 if (self
->decorations
!= fdecor
|| self
->max_horz
!= fhorz
)
2103 moved
= resized
= TRUE
;
2105 if (moved
|| resized
)
2106 frame_adjust_area(self
->frame
, moved
, resized
, FALSE
);
2108 if (!resized
&& (force_reply
|| ((!user
&& moved
) || (user
&& final
))))
2111 event
.type
= ConfigureNotify
;
2112 event
.xconfigure
.display
= ob_display
;
2113 event
.xconfigure
.event
= self
->window
;
2114 event
.xconfigure
.window
= self
->window
;
2116 /* root window real coords */
2117 event
.xconfigure
.x
= self
->frame
->area
.x
+ self
->frame
->size
.left
-
2119 event
.xconfigure
.y
= self
->frame
->area
.y
+ self
->frame
->size
.top
-
2121 event
.xconfigure
.width
= w
;
2122 event
.xconfigure
.height
= h
;
2123 event
.xconfigure
.border_width
= 0;
2124 event
.xconfigure
.above
= self
->frame
->plate
;
2125 event
.xconfigure
.override_redirect
= FALSE
;
2126 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
2127 FALSE
, StructureNotifyMask
, &event
);
2131 /* if the client is shrinking, then resize the frame before the client */
2132 if (send_resize_client
&& (!user
|| (w
<= oldw
|| h
<= oldh
)))
2133 XResizeWindow(ob_display
, self
->window
, w
, h
);
2138 void client_fullscreen(ObClient
*self
, gboolean fs
, gboolean savearea
)
2142 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
2143 self
->fullscreen
== fs
) return; /* already done */
2145 self
->fullscreen
= fs
;
2146 client_change_state(self
); /* change the state hints on the client,
2147 and adjust out layer/stacking */
2151 self
->pre_fullscreen_area
= self
->area
;
2153 /* these are not actually used cuz client_configure will set them
2154 as appropriate when the window is fullscreened */
2159 if (self
->pre_fullscreen_area
.width
> 0 &&
2160 self
->pre_fullscreen_area
.height
> 0)
2162 x
= self
->pre_fullscreen_area
.x
;
2163 y
= self
->pre_fullscreen_area
.y
;
2164 w
= self
->pre_fullscreen_area
.width
;
2165 h
= self
->pre_fullscreen_area
.height
;
2166 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
2168 /* pick some fallbacks... */
2169 a
= screen_area_monitor(self
->desktop
, 0);
2170 x
= a
->x
+ a
->width
/ 4;
2171 y
= a
->y
+ a
->height
/ 4;
2177 client_setup_decor_and_functions(self
);
2179 client_move_resize(self
, x
, y
, w
, h
);
2181 /* try focus us when we go into fullscreen mode */
2185 static void client_iconify_recursive(ObClient
*self
,
2186 gboolean iconic
, gboolean curdesk
)
2189 gboolean changed
= FALSE
;
2192 if (self
->iconic
!= iconic
) {
2193 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
2196 self
->iconic
= iconic
;
2199 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
) {
2202 old
= self
->wmstate
;
2203 self
->wmstate
= IconicState
;
2204 if (old
!= self
->wmstate
)
2205 PROP_MSG(self
->window
, kde_wm_change_state
,
2206 self
->wmstate
, 1, 0, 0);
2208 /* update the focus lists.. iconic windows go to the bottom of
2209 the list, put the new iconic window at the 'top of the
2211 focus_order_to_top(self
);
2219 client_set_desktop(self
, screen_desktop
, FALSE
);
2221 old
= self
->wmstate
;
2222 self
->wmstate
= self
->shaded
? IconicState
: NormalState
;
2223 if (old
!= self
->wmstate
)
2224 PROP_MSG(self
->window
, kde_wm_change_state
,
2225 self
->wmstate
, 1, 0, 0);
2227 /* this puts it after the current focused window */
2228 focus_order_remove(self
);
2229 focus_order_add_new(self
);
2231 /* this is here cuz with the VIDMODE extension, the viewport can
2232 change while a fullscreen window is iconic, and when it
2233 uniconifies, it would be nice if it did so to the new position
2235 client_reconfigure(self
);
2242 client_change_state(self
);
2243 client_showhide(self
);
2244 screen_update_areas();
2247 /* iconify all transients */
2248 for (it
= self
->transients
; it
!= NULL
; it
= it
->next
)
2249 if (it
->data
!= self
) client_iconify_recursive(it
->data
,
2253 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
)
2255 /* move up the transient chain as far as possible first */
2256 self
= client_search_top_transient(self
);
2258 client_iconify_recursive(client_search_top_transient(self
),
2262 void client_maximize(ObClient
*self
, gboolean max
, gint dir
, gboolean savearea
)
2266 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
2267 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
2269 /* check if already done */
2271 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
2272 if (dir
== 1 && self
->max_horz
) return;
2273 if (dir
== 2 && self
->max_vert
) return;
2275 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
2276 if (dir
== 1 && !self
->max_horz
) return;
2277 if (dir
== 2 && !self
->max_vert
) return;
2280 /* we just tell it to configure in the same place and client_configure
2281 worries about filling the screen with the window */
2284 w
= self
->area
.width
;
2285 h
= self
->area
.height
;
2289 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
2290 RECT_SET(self
->pre_max_area
,
2291 self
->area
.x
, self
->pre_max_area
.y
,
2292 self
->area
.width
, self
->pre_max_area
.height
);
2294 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
2295 RECT_SET(self
->pre_max_area
,
2296 self
->pre_max_area
.x
, self
->area
.y
,
2297 self
->pre_max_area
.width
, self
->area
.height
);
2303 a
= screen_area_monitor(self
->desktop
, 0);
2304 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
2305 if (self
->pre_max_area
.width
> 0) {
2306 x
= self
->pre_max_area
.x
;
2307 w
= self
->pre_max_area
.width
;
2309 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
2310 0, self
->pre_max_area
.height
);
2312 /* pick some fallbacks... */
2313 x
= a
->x
+ a
->width
/ 4;
2317 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
2318 if (self
->pre_max_area
.height
> 0) {
2319 y
= self
->pre_max_area
.y
;
2320 h
= self
->pre_max_area
.height
;
2322 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
2323 self
->pre_max_area
.width
, 0);
2325 /* pick some fallbacks... */
2326 y
= a
->y
+ a
->height
/ 4;
2332 if (dir
== 0 || dir
== 1) /* horz */
2333 self
->max_horz
= max
;
2334 if (dir
== 0 || dir
== 2) /* vert */
2335 self
->max_vert
= max
;
2337 client_change_state(self
); /* change the state hints on the client */
2339 client_setup_decor_and_functions(self
);
2341 client_move_resize(self
, x
, y
, w
, h
);
2344 void client_shade(ObClient
*self
, gboolean shade
)
2346 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
2347 shade
) || /* can't shade */
2348 self
->shaded
== shade
) return; /* already done */
2350 /* when we're iconic, don't change the wmstate */
2351 if (!self
->iconic
) {
2354 old
= self
->wmstate
;
2355 self
->wmstate
= shade
? IconicState
: NormalState
;
2356 if (old
!= self
->wmstate
)
2357 PROP_MSG(self
->window
, kde_wm_change_state
,
2358 self
->wmstate
, 1, 0, 0);
2361 self
->shaded
= shade
;
2362 client_change_state(self
);
2363 /* resize the frame to just the titlebar */
2364 frame_adjust_area(self
->frame
, FALSE
, FALSE
, FALSE
);
2367 void client_close(ObClient
*self
)
2371 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
2373 /* in the case that the client provides no means to requesting that it
2374 close, we just kill it */
2375 if (!self
->delete_window
)
2379 XXX: itd be cool to do timeouts and shit here for killing the client's
2381 like... if the window is around after 5 seconds, then the close button
2382 turns a nice red, and if this function is called again, the client is
2386 ce
.xclient
.type
= ClientMessage
;
2387 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2388 ce
.xclient
.display
= ob_display
;
2389 ce
.xclient
.window
= self
->window
;
2390 ce
.xclient
.format
= 32;
2391 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_delete_window
;
2392 ce
.xclient
.data
.l
[1] = event_lasttime
;
2393 ce
.xclient
.data
.l
[2] = 0l;
2394 ce
.xclient
.data
.l
[3] = 0l;
2395 ce
.xclient
.data
.l
[4] = 0l;
2396 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2399 void client_kill(ObClient
*self
)
2401 XKillClient(ob_display
, self
->window
);
2404 void client_set_desktop_recursive(ObClient
*self
,
2405 guint target
, gboolean donthide
)
2410 if (target
!= self
->desktop
) {
2412 ob_debug("Setting desktop %u\n", target
+1);
2414 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
2416 /* remove from the old desktop(s) */
2417 focus_order_remove(self
);
2419 old
= self
->desktop
;
2420 self
->desktop
= target
;
2421 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
2422 /* the frame can display the current desktop state */
2423 frame_adjust_state(self
->frame
);
2424 /* 'move' the window to the new desktop */
2426 client_showhide(self
);
2427 /* raise if it was not already on the desktop */
2428 if (old
!= DESKTOP_ALL
)
2430 screen_update_areas();
2432 /* add to the new desktop(s) */
2433 if (config_focus_new
)
2434 focus_order_to_top(self
);
2436 focus_order_to_bottom(self
);
2439 /* move all transients */
2440 for (it
= self
->transients
; it
!= NULL
; it
= it
->next
)
2441 if (it
->data
!= self
) client_set_desktop_recursive(it
->data
,
2445 void client_set_desktop(ObClient
*self
, guint target
, gboolean donthide
)
2447 client_set_desktop_recursive(client_search_top_transient(self
),
2451 ObClient
*client_search_modal_child(ObClient
*self
)
2456 for (it
= self
->transients
; it
!= NULL
; it
= it
->next
) {
2457 ObClient
*c
= it
->data
;
2458 if ((ret
= client_search_modal_child(c
))) return ret
;
2459 if (c
->modal
) return c
;
2464 gboolean
client_validate(ObClient
*self
)
2468 XSync(ob_display
, FALSE
); /* get all events on the server */
2470 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
) ||
2471 XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
2472 XPutBackEvent(ob_display
, &e
);
2479 void client_set_wm_state(ObClient
*self
, glong state
)
2481 if (state
== self
->wmstate
) return; /* no change */
2485 client_iconify(self
, TRUE
, TRUE
);
2488 client_iconify(self
, FALSE
, TRUE
);
2493 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
2495 gboolean shaded
= self
->shaded
;
2496 gboolean fullscreen
= self
->fullscreen
;
2497 gboolean undecorated
= self
->undecorated
;
2498 gboolean max_horz
= self
->max_horz
;
2499 gboolean max_vert
= self
->max_vert
;
2500 gboolean modal
= self
->modal
;
2503 if (!(action
== prop_atoms
.net_wm_state_add
||
2504 action
== prop_atoms
.net_wm_state_remove
||
2505 action
== prop_atoms
.net_wm_state_toggle
))
2506 /* an invalid action was passed to the client message, ignore it */
2509 for (i
= 0; i
< 2; ++i
) {
2510 Atom state
= i
== 0 ? data1
: data2
;
2512 if (!state
) continue;
2514 /* if toggling, then pick whether we're adding or removing */
2515 if (action
== prop_atoms
.net_wm_state_toggle
) {
2516 if (state
== prop_atoms
.net_wm_state_modal
)
2517 action
= modal
? prop_atoms
.net_wm_state_remove
:
2518 prop_atoms
.net_wm_state_add
;
2519 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
2520 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
2521 prop_atoms
.net_wm_state_add
;
2522 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
2523 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
2524 prop_atoms
.net_wm_state_add
;
2525 else if (state
== prop_atoms
.net_wm_state_shaded
)
2526 action
= shaded
? prop_atoms
.net_wm_state_remove
:
2527 prop_atoms
.net_wm_state_add
;
2528 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
2529 action
= self
->skip_taskbar
?
2530 prop_atoms
.net_wm_state_remove
:
2531 prop_atoms
.net_wm_state_add
;
2532 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
2533 action
= self
->skip_pager
?
2534 prop_atoms
.net_wm_state_remove
:
2535 prop_atoms
.net_wm_state_add
;
2536 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
2537 action
= fullscreen
?
2538 prop_atoms
.net_wm_state_remove
:
2539 prop_atoms
.net_wm_state_add
;
2540 else if (state
== prop_atoms
.net_wm_state_above
)
2541 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
2542 prop_atoms
.net_wm_state_add
;
2543 else if (state
== prop_atoms
.net_wm_state_below
)
2544 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
2545 prop_atoms
.net_wm_state_add
;
2546 else if (state
== prop_atoms
.ob_wm_state_undecorated
)
2547 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
2548 prop_atoms
.net_wm_state_add
;
2551 if (action
== prop_atoms
.net_wm_state_add
) {
2552 if (state
== prop_atoms
.net_wm_state_modal
) {
2554 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2556 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2558 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2560 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2561 self
->skip_taskbar
= TRUE
;
2562 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2563 self
->skip_pager
= TRUE
;
2564 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2566 } else if (state
== prop_atoms
.net_wm_state_above
) {
2568 } else if (state
== prop_atoms
.net_wm_state_below
) {
2570 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2574 } else { /* action == prop_atoms.net_wm_state_remove */
2575 if (state
== prop_atoms
.net_wm_state_modal
) {
2577 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2579 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2581 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2583 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2584 self
->skip_taskbar
= FALSE
;
2585 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2586 self
->skip_pager
= FALSE
;
2587 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2589 } else if (state
== prop_atoms
.net_wm_state_above
) {
2590 self
->above
= FALSE
;
2591 } else if (state
== prop_atoms
.net_wm_state_below
) {
2592 self
->below
= FALSE
;
2593 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2594 undecorated
= FALSE
;
2598 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
2599 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
2601 if (max_horz
== max_vert
) { /* both going the same way */
2602 client_maximize(self
, max_horz
, 0, TRUE
);
2604 client_maximize(self
, max_horz
, 1, TRUE
);
2605 client_maximize(self
, max_vert
, 2, TRUE
);
2609 if (max_horz
!= self
->max_horz
)
2610 client_maximize(self
, max_horz
, 1, TRUE
);
2612 client_maximize(self
, max_vert
, 2, TRUE
);
2615 /* change fullscreen state before shading, as it will affect if the window
2617 if (fullscreen
!= self
->fullscreen
)
2618 client_fullscreen(self
, fullscreen
, TRUE
);
2619 if (shaded
!= self
->shaded
)
2620 client_shade(self
, shaded
);
2621 if (undecorated
!= self
->undecorated
)
2622 client_set_undecorated(self
, undecorated
);
2623 if (modal
!= self
->modal
) {
2624 self
->modal
= modal
;
2625 /* when a window changes modality, then its stacking order with its
2626 transients needs to change */
2629 client_calc_layer(self
);
2630 client_change_state(self
); /* change the hint to reflect these changes */
2633 ObClient
*client_focus_target(ObClient
*self
)
2637 /* if we have a modal child, then focus it, not us */
2638 child
= client_search_modal_child(client_search_top_transient(self
));
2639 if (child
) return child
;
2643 gboolean
client_can_focus(ObClient
*self
)
2647 /* choose the correct target */
2648 self
= client_focus_target(self
);
2650 if (!self
->frame
->visible
)
2653 if (!(self
->can_focus
|| self
->focus_notify
))
2656 /* do a check to see if the window has already been unmapped or destroyed
2657 do this intelligently while watching out for unmaps we've generated
2658 (ignore_unmaps > 0) */
2659 if (XCheckTypedWindowEvent(ob_display
, self
->window
,
2660 DestroyNotify
, &ev
)) {
2661 XPutBackEvent(ob_display
, &ev
);
2664 while (XCheckTypedWindowEvent(ob_display
, self
->window
,
2665 UnmapNotify
, &ev
)) {
2666 if (self
->ignore_unmaps
) {
2667 self
->ignore_unmaps
--;
2669 XPutBackEvent(ob_display
, &ev
);
2677 gboolean
client_focus(ObClient
*self
)
2679 /* choose the correct target */
2680 self
= client_focus_target(self
);
2682 if (!client_can_focus(self
)) {
2683 if (!self
->frame
->visible
) {
2684 /* update the focus lists */
2685 focus_order_to_top(self
);
2690 if (self
->can_focus
) {
2691 /* RevertToPointerRoot causes much more headache than RevertToNone, so
2692 I choose to use it always, hopefully to find errors quicker, if any
2693 are left. (I hate X. I hate focus events.)
2695 Update: Changing this to RevertToNone fixed a bug with mozilla (bug
2696 #799. So now it is RevertToNone again.
2698 XSetInputFocus(ob_display
, self
->window
, RevertToNone
,
2702 if (self
->focus_notify
) {
2704 ce
.xclient
.type
= ClientMessage
;
2705 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2706 ce
.xclient
.display
= ob_display
;
2707 ce
.xclient
.window
= self
->window
;
2708 ce
.xclient
.format
= 32;
2709 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
2710 ce
.xclient
.data
.l
[1] = event_lasttime
;
2711 ce
.xclient
.data
.l
[2] = 0l;
2712 ce
.xclient
.data
.l
[3] = 0l;
2713 ce
.xclient
.data
.l
[4] = 0l;
2714 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2718 ob_debug("%sively focusing %lx at %d\n",
2719 (self
->can_focus
? "act" : "pass"),
2720 self
->window
, (gint
) event_lasttime
);
2723 /* Cause the FocusIn to come back to us. Important for desktop switches,
2724 since otherwise we'll have no FocusIn on the queue and send it off to
2725 the focus_backup. */
2726 XSync(ob_display
, FALSE
);
2730 void client_unfocus(ObClient
*self
)
2732 if (focus_client
== self
) {
2734 ob_debug("client_unfocus for %lx\n", self
->window
);
2736 focus_fallback(OB_FOCUS_FALLBACK_UNFOCUSING
);
2740 void client_activate(ObClient
*self
, gboolean here
)
2742 if (client_normal(self
) && screen_showing_desktop
)
2743 screen_show_desktop(FALSE
);
2745 client_iconify(self
, FALSE
, here
);
2746 if (self
->desktop
!= DESKTOP_ALL
&&
2747 self
->desktop
!= screen_desktop
) {
2749 client_set_desktop(self
, screen_desktop
, FALSE
);
2751 screen_set_desktop(self
->desktop
);
2752 } else if (!self
->frame
->visible
)
2753 /* if its not visible for other reasons, then don't mess
2757 client_shade(self
, FALSE
);
2761 /* we do this an action here. this is rather important. this is because
2762 we want the results from the focus change to take place BEFORE we go
2763 about raising the window. when a fullscreen window loses focus, we need
2764 this or else the raise wont be able to raise above the to-lose-focus
2765 fullscreen window. */
2769 void client_raise(ObClient
*self
)
2771 action_run_string("Raise", self
);
2774 void client_lower(ObClient
*self
)
2776 action_run_string("Raise", self
);
2779 gboolean
client_focused(ObClient
*self
)
2781 return self
== focus_client
;
2784 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
2787 /* si is the smallest image >= req */
2788 /* li is the largest image < req */
2789 gulong size
, smallest
= 0xffffffff, largest
= 0, si
= 0, li
= 0;
2791 if (!self
->nicons
) {
2792 ObClientIcon
*parent
= NULL
;
2794 if (self
->transient_for
) {
2795 if (self
->transient_for
!= OB_TRAN_GROUP
)
2796 parent
= client_icon_recursive(self
->transient_for
, w
, h
);
2799 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
2800 ObClient
*c
= it
->data
;
2801 if (c
!= self
&& !c
->transient_for
) {
2802 if ((parent
= client_icon_recursive(c
, w
, h
)))
2812 for (i
= 0; i
< self
->nicons
; ++i
) {
2813 size
= self
->icons
[i
].width
* self
->icons
[i
].height
;
2814 if (size
< smallest
&& size
>= (unsigned)(w
* h
)) {
2818 if (size
> largest
&& size
<= (unsigned)(w
* h
)) {
2823 if (largest
== 0) /* didnt find one smaller than the requested size */
2824 return &self
->icons
[si
];
2825 return &self
->icons
[li
];
2828 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
2831 static ObClientIcon deficon
;
2833 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
2834 deficon
.width
= deficon
.height
= 48;
2835 deficon
.data
= ob_rr_theme
->def_win_icon
;
2841 /* this be mostly ripped from fvwm */
2842 ObClient
*client_find_directional(ObClient
*c
, ObDirection dir
)
2844 gint my_cx
, my_cy
, his_cx
, his_cy
;
2847 gint score
, best_score
;
2848 ObClient
*best_client
, *cur
;
2854 /* first, find the centre coords of the currently focused window */
2855 my_cx
= c
->frame
->area
.x
+ c
->frame
->area
.width
/ 2;
2856 my_cy
= c
->frame
->area
.y
+ c
->frame
->area
.height
/ 2;
2861 for(it
= g_list_first(client_list
); it
; it
= it
->next
) {
2864 /* the currently selected window isn't interesting */
2867 if (!client_normal(cur
))
2869 if(c
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
2873 if(client_focus_target(cur
) == cur
&&
2874 !(cur
->can_focus
|| cur
->focus_notify
))
2877 /* find the centre coords of this window, from the
2878 * currently focused window's point of view */
2879 his_cx
= (cur
->frame
->area
.x
- my_cx
)
2880 + cur
->frame
->area
.width
/ 2;
2881 his_cy
= (cur
->frame
->area
.y
- my_cy
)
2882 + cur
->frame
->area
.height
/ 2;
2884 if(dir
== OB_DIRECTION_NORTHEAST
|| dir
== OB_DIRECTION_SOUTHEAST
||
2885 dir
== OB_DIRECTION_SOUTHWEST
|| dir
== OB_DIRECTION_NORTHWEST
) {
2887 /* Rotate the diagonals 45 degrees counterclockwise.
2888 * To do this, multiply the matrix /+h +h\ with the
2889 * vector (x y). \-h +h/
2890 * h = sqrt(0.5). We can set h := 1 since absolute
2891 * distance doesn't matter here. */
2892 tx
= his_cx
+ his_cy
;
2893 his_cy
= -his_cx
+ his_cy
;
2898 case OB_DIRECTION_NORTH
:
2899 case OB_DIRECTION_SOUTH
:
2900 case OB_DIRECTION_NORTHEAST
:
2901 case OB_DIRECTION_SOUTHWEST
:
2902 offset
= (his_cx
< 0) ? -his_cx
: his_cx
;
2903 distance
= ((dir
== OB_DIRECTION_NORTH
||
2904 dir
== OB_DIRECTION_NORTHEAST
) ?
2907 case OB_DIRECTION_EAST
:
2908 case OB_DIRECTION_WEST
:
2909 case OB_DIRECTION_SOUTHEAST
:
2910 case OB_DIRECTION_NORTHWEST
:
2911 offset
= (his_cy
< 0) ? -his_cy
: his_cy
;
2912 distance
= ((dir
== OB_DIRECTION_WEST
||
2913 dir
== OB_DIRECTION_NORTHWEST
) ?
2918 /* the target must be in the requested direction */
2922 /* Calculate score for this window. The smaller the better. */
2923 score
= distance
+ offset
;
2925 /* windows more than 45 degrees off the direction are
2926 * heavily penalized and will only be chosen if nothing
2927 * else within a million pixels */
2928 if(offset
> distance
)
2931 if(best_score
== -1 || score
< best_score
)
2939 void client_set_layer(ObClient
*self
, gint layer
)
2943 self
->above
= FALSE
;
2944 } else if (layer
== 0) {
2945 self
->below
= self
->above
= FALSE
;
2947 self
->below
= FALSE
;
2950 client_calc_layer(self
);
2951 client_change_state(self
); /* reflect this in the state hints */
2954 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
2956 if (self
->undecorated
!= undecorated
) {
2957 self
->undecorated
= undecorated
;
2958 client_setup_decor_and_functions(self
);
2959 client_change_state(self
); /* reflect this in the state hints */
2963 guint
client_monitor(ObClient
*self
)
2969 for (i
= 0; i
< screen_num_monitors
; ++i
) {
2970 Rect
*area
= screen_physical_area_monitor(i
);
2971 if (RECT_INTERSECTS_RECT(*area
, self
->frame
->area
)) {
2975 RECT_SET_INTERSECTION(r
, *area
, self
->frame
->area
);
2976 v
= r
.width
* r
.height
;
2987 ObClient
*client_search_top_transient(ObClient
*self
)
2989 /* move up the transient chain as far as possible */
2990 if (self
->transient_for
) {
2991 if (self
->transient_for
!= OB_TRAN_GROUP
) {
2992 return client_search_top_transient(self
->transient_for
);
2996 g_assert(self
->group
);
2998 for (it
= self
->group
->members
; it
; it
= it
->next
) {
2999 ObClient
*c
= it
->data
;
3001 /* checking transient_for prevents infinate loops! */
3002 if (c
!= self
&& !c
->transient_for
)
3013 ObClient
*client_search_focus_parent(ObClient
*self
)
3015 if (self
->transient_for
) {
3016 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3017 if (client_focused(self
->transient_for
))
3018 return self
->transient_for
;
3022 for (it
= self
->group
->members
; it
; it
= it
->next
) {
3023 ObClient
*c
= it
->data
;
3025 /* checking transient_for prevents infinate loops! */
3026 if (c
!= self
&& !c
->transient_for
)
3027 if (client_focused(c
))
3036 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3038 if (self
->transient_for
) {
3039 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3040 if (self
->transient_for
== search
)
3045 for (it
= self
->group
->members
; it
; it
= it
->next
) {
3046 ObClient
*c
= it
->data
;
3048 /* checking transient_for prevents infinate loops! */
3049 if (c
!= self
&& !c
->transient_for
)
3059 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3063 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3064 if (sit
->data
== search
)
3066 if (client_search_transient(sit
->data
, search
))
3072 void client_update_sm_client_id(ObClient
*self
)
3074 g_free(self
->sm_client_id
);
3075 self
->sm_client_id
= NULL
;
3077 if (!PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
) &&
3079 PROP_GETS(self
->group
->leader
, sm_client_id
, locale
,
3080 &self
->sm_client_id
);
3083 /* finds the nearest edge in the given direction from the current client
3084 * note to self: the edge is the -frame- edge (the actual one), not the
3087 gint
client_directional_edge_search(ObClient
*c
, ObDirection dir
)
3090 gint my_edge_start
, my_edge_end
, my_offset
;
3097 a
= screen_area(c
->desktop
);
3100 case OB_DIRECTION_NORTH
:
3101 my_edge_start
= c
->frame
->area
.x
;
3102 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3103 my_offset
= c
->frame
->area
.y
;
3105 /* default: top of screen */
3108 for(it
= g_list_first(client_list
); it
; it
= it
->next
) {
3109 gint his_edge_start
, his_edge_end
, his_offset
;
3110 ObClient
*cur
= it
->data
;
3114 if(!client_normal(cur
))
3116 if(c
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3121 his_edge_start
= cur
->frame
->area
.x
;
3122 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3123 his_offset
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3125 if(his_offset
+ 1 > my_offset
)
3128 if(his_offset
< dest
)
3131 if(his_edge_start
>= my_edge_start
&&
3132 his_edge_start
<= my_edge_end
)
3135 if(my_edge_start
>= his_edge_start
&&
3136 my_edge_start
<= his_edge_end
)
3141 case OB_DIRECTION_SOUTH
:
3142 my_edge_start
= c
->frame
->area
.x
;
3143 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3144 my_offset
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3146 /* default: bottom of screen */
3147 dest
= a
->y
+ a
->height
;
3149 for(it
= g_list_first(client_list
); it
; it
= it
->next
) {
3150 gint his_edge_start
, his_edge_end
, his_offset
;
3151 ObClient
*cur
= it
->data
;
3155 if(!client_normal(cur
))
3157 if(c
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3162 his_edge_start
= cur
->frame
->area
.x
;
3163 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3164 his_offset
= cur
->frame
->area
.y
;
3167 if(his_offset
- 1 < my_offset
)
3170 if(his_offset
> dest
)
3173 if(his_edge_start
>= my_edge_start
&&
3174 his_edge_start
<= my_edge_end
)
3177 if(my_edge_start
>= his_edge_start
&&
3178 my_edge_start
<= his_edge_end
)
3183 case OB_DIRECTION_WEST
:
3184 my_edge_start
= c
->frame
->area
.y
;
3185 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3186 my_offset
= c
->frame
->area
.x
;
3188 /* default: leftmost egde of screen */
3191 for(it
= g_list_first(client_list
); it
; it
= it
->next
) {
3192 gint his_edge_start
, his_edge_end
, his_offset
;
3193 ObClient
*cur
= it
->data
;
3197 if(!client_normal(cur
))
3199 if(c
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3204 his_edge_start
= cur
->frame
->area
.y
;
3205 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3206 his_offset
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3208 if(his_offset
+ 1 > my_offset
)
3211 if(his_offset
< dest
)
3214 if(his_edge_start
>= my_edge_start
&&
3215 his_edge_start
<= my_edge_end
)
3218 if(my_edge_start
>= his_edge_start
&&
3219 my_edge_start
<= his_edge_end
)
3225 case OB_DIRECTION_EAST
:
3226 my_edge_start
= c
->frame
->area
.y
;
3227 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3228 my_offset
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3230 /* default: rightmost edge of screen */
3231 dest
= a
->x
+ a
->width
;
3233 for(it
= g_list_first(client_list
); it
; it
= it
->next
) {
3234 gint his_edge_start
, his_edge_end
, his_offset
;
3235 ObClient
*cur
= it
->data
;
3239 if(!client_normal(cur
))
3241 if(c
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3246 his_edge_start
= cur
->frame
->area
.y
;
3247 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3248 his_offset
= cur
->frame
->area
.x
;
3250 if(his_offset
- 1 < my_offset
)
3253 if(his_offset
> dest
)
3256 if(his_edge_start
>= my_edge_start
&&
3257 his_edge_start
<= my_edge_end
)
3260 if(my_edge_start
>= his_edge_start
&&
3261 my_edge_start
<= his_edge_end
)
3266 case OB_DIRECTION_NORTHEAST
:
3267 case OB_DIRECTION_SOUTHEAST
:
3268 case OB_DIRECTION_NORTHWEST
:
3269 case OB_DIRECTION_SOUTHWEST
:
3270 /* not implemented */
3272 g_assert_not_reached();
3277 ObClient
* client_under_pointer()
3281 ObClient
*ret
= NULL
;
3283 if (screen_pointer_pos(&x
, &y
)) {
3284 for (it
= stacking_list
; it
!= NULL
; it
= it
->next
) {
3285 if (WINDOW_IS_CLIENT(it
->data
)) {
3286 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
3287 if (c
->frame
->visible
&&
3288 RECT_CONTAINS(c
->frame
->area
, x
, y
)) {
3298 gboolean
client_has_group_siblings(ObClient
*self
)
3300 return self
->group
&& self
->group
->members
->next
;