1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2006 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
222 * string matches the beginning of the role, since apps like to set
223 * the role to things like browser-window-23c4b2f */
225 || !strncmp(app
->role
, client
->role
, strlen(app
->role
)))
234 void client_manage(Window window
)
238 XWindowAttributes attrib
;
239 XSetWindowAttributes attrib_set
;
241 gboolean activate
= FALSE
;
242 ObAppSettings
*settings
;
246 /* check if it has already been unmapped by the time we started mapping
247 the grab does a sync so we don't have to here */
248 if (XCheckTypedWindowEvent(ob_display
, window
, DestroyNotify
, &e
) ||
249 XCheckTypedWindowEvent(ob_display
, window
, UnmapNotify
, &e
))
251 XPutBackEvent(ob_display
, &e
);
254 return; /* don't manage it */
257 /* make sure it isn't an override-redirect window */
258 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
259 attrib
.override_redirect
)
262 return; /* don't manage it */
265 /* is the window a docking app */
266 if ((wmhint
= XGetWMHints(ob_display
, window
))) {
267 if ((wmhint
->flags
& StateHint
) &&
268 wmhint
->initial_state
== WithdrawnState
)
270 dock_add(window
, wmhint
);
278 ob_debug("Managing window: %lx\n", window
);
280 /* choose the events we want to receive on the CLIENT window */
281 attrib_set
.event_mask
= CLIENT_EVENTMASK
;
282 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
283 XChangeWindowAttributes(ob_display
, window
,
284 CWEventMask
|CWDontPropagate
, &attrib_set
);
287 /* create the ObClient struct, and populate it from the hints on the
289 self
= g_new0(ObClient
, 1);
290 self
->obwin
.type
= Window_Client
;
291 self
->window
= window
;
293 /* non-zero defaults */
294 self
->title_count
= 1;
295 self
->wmstate
= NormalState
;
297 self
->desktop
= screen_num_desktops
; /* always an invalid value */
299 client_get_all(self
);
300 client_restore_session_state(self
);
302 sn_app_started(self
->class);
304 /* update the focus lists, do this before the call to change_state or
305 it can end up in the list twice! */
306 focus_order_add_new(self
);
308 client_change_state(self
);
310 /* remove the client's border (and adjust re gravity) */
311 client_toggle_border(self
, FALSE
);
313 /* specify that if we exit, the window should not be destroyed and should
314 be reparented back to root automatically */
315 XChangeSaveSet(ob_display
, window
, SetModeInsert
);
317 /* create the decoration frame for the client window */
318 self
->frame
= frame_new(self
);
320 frame_grab_client(self
->frame
, self
);
324 client_apply_startup_state(self
);
326 /* get and set application level settings */
327 settings
= get_settings(self
);
329 stacking_add(CLIENT_AS_WINDOW(self
));
330 client_restore_session_stacking(self
);
333 /* Don't worry, we won't actually both shade and undecorate the
334 * window when push comes to shove. */
335 if (settings
->shade
!= -1)
336 client_shade(self
, !!settings
->shade
);
337 if (settings
->decor
!= -1)
338 client_set_undecorated(self
, !settings
->decor
);
339 if (settings
->iconic
!= -1)
340 client_iconify(self
, !!settings
->iconic
, FALSE
);
341 if (settings
->skip_pager
!= -1) {
342 self
->skip_pager
= !!settings
->skip_pager
;
343 client_change_state(self
);
345 if (settings
->skip_taskbar
!= -1) {
346 self
->skip_taskbar
= !!settings
->skip_taskbar
;
347 client_change_state(self
);
350 /* 1 && -1 shouldn't be possible by the code in config.c */
351 if (settings
->max_vert
== 1 && settings
->max_horz
== 1)
352 client_maximize(self
, TRUE
, 0, TRUE
);
353 else if (settings
->max_vert
== 0 && settings
->max_horz
== 0)
354 client_maximize(self
, FALSE
, 0, TRUE
);
355 else if (settings
->max_vert
== 1 && settings
->max_horz
== 0) {
356 client_maximize(self
, TRUE
, 2, TRUE
);
357 client_maximize(self
, FALSE
, 1, TRUE
);
358 } else if (settings
->max_vert
== 0 && settings
->max_horz
== 1) {
359 client_maximize(self
, TRUE
, 1, TRUE
);
360 client_maximize(self
, FALSE
, 2, TRUE
);
363 if (settings
->fullscreen
!= -1)
364 client_fullscreen(self
, !!settings
->fullscreen
, TRUE
);
366 if (settings
->desktop
< screen_num_desktops
367 || settings
->desktop
== DESKTOP_ALL
)
368 client_set_desktop(self
, settings
->desktop
, TRUE
);
370 if (settings
->layer
> -2 && settings
->layer
< 2)
371 client_set_layer(self
, settings
->layer
);
375 /* focus the new window? */
376 if (ob_state() != OB_STATE_STARTING
&&
377 /* this means focus=true for window is same as config_focus_new=true */
378 ((config_focus_new
|| (settings
&& settings
->focus
== 1)) ||
379 client_search_focus_parent(self
)) &&
380 /* this checks for focus=false for the window */
381 (!settings
|| settings
->focus
!= 0) &&
382 /* note the check against Type_Normal/Dialog, not client_normal(self),
383 which would also include other types. in this case we want more
384 strict rules for focus */
385 (self
->type
== OB_CLIENT_TYPE_NORMAL
||
386 self
->type
== OB_CLIENT_TYPE_DIALOG
))
390 if (self
->desktop
!= screen_desktop
) {
391 /* activate the window */
394 gboolean group_foc
= FALSE
;
399 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
401 if (client_focused(it
->data
))
409 (!self
->transient_for
&& (!self
->group
||
410 !self
->group
->members
->next
))) ||
411 client_search_focus_tree_full(self
) ||
413 !client_normal(focus_client
))
415 /* activate the window */
422 if (ob_state() == OB_STATE_RUNNING
) {
423 gint x
= self
->area
.x
, ox
= x
;
424 gint y
= self
->area
.y
, oy
= y
;
427 transient
= place_client(self
, &x
, &y
, settings
);
429 /* make sure the window is visible. */
430 client_find_onscreen(self
, &x
, &y
,
431 self
->frame
->area
.width
,
432 self
->frame
->area
.height
,
433 /* non-normal clients has less rules, and
434 windows that are being restored from a
435 session do also. we can assume you want
436 it back where you saved it. Clients saying
437 they placed themselves are subjected to
438 harder rules, ones that are placed by
439 place.c or by the user are allowed partially
440 off-screen and on xinerama divides (ie,
441 it is up to the placement routines to avoid
442 the xinerama divides) */
444 (((self
->positioned
& PPosition
) &&
445 !(self
->positioned
& USPosition
)) &&
446 client_normal(self
) &&
448 if (x
!= ox
|| y
!= oy
)
449 client_move(self
, x
, y
);
452 keyboard_grab_for_client(self
, TRUE
);
453 mouse_grab_for_client(self
, TRUE
);
455 client_showhide(self
);
457 /* use client_focus instead of client_activate cuz client_activate does
458 stuff like switch desktops etc and I'm not interested in all that when
459 a window maps since its not based on an action from the user like
460 clicking a window to activate is. so keep the new window out of the way
463 /* if using focus_delay, stop the timer now so that focus doesn't go
465 event_halt_focus_delay();
468 /* since focus can change the stacking orders, if we focus the window
469 then the standard raise it gets is not enough, we need to queue one
470 for after the focus change takes place */
474 /* client_activate does this but we aret using it so we have to do it
476 if (screen_showing_desktop
)
477 screen_show_desktop(FALSE
);
479 /* add to client list/map */
480 client_list
= g_list_append(client_list
, self
);
481 g_hash_table_insert(window_map
, &self
->window
, self
);
483 /* this has to happen after we're in the client_list */
484 if (STRUT_EXISTS(self
->strut
))
485 screen_update_areas();
487 /* update the list hints */
490 ob_debug("Managed window 0x%lx (%s)\n", window
, self
->class);
493 void client_unmanage_all()
495 while (client_list
!= NULL
)
496 client_unmanage(client_list
->data
);
499 void client_unmanage(ObClient
*self
)
504 ob_debug("Unmanaging window: %lx (%s)\n", self
->window
, self
->class);
506 g_assert(self
!= NULL
);
508 keyboard_grab_for_client(self
, FALSE
);
509 mouse_grab_for_client(self
, FALSE
);
511 /* potentially fix focusLast */
512 if (config_focus_last
)
513 grab_pointer(TRUE
, OB_CURSOR_NONE
);
515 /* remove the window from our save set */
516 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
518 /* we dont want events no more */
519 XSelectInput(ob_display
, self
->window
, NoEventMask
);
521 frame_hide(self
->frame
);
523 client_list
= g_list_remove(client_list
, self
);
524 stacking_remove(self
);
525 g_hash_table_remove(window_map
, &self
->window
);
527 /* update the focus lists */
528 focus_order_remove(self
);
530 /* once the client is out of the list, update the struts to remove it's
532 if (STRUT_EXISTS(self
->strut
))
533 screen_update_areas();
535 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
536 Destructor
*d
= it
->data
;
537 d
->func(self
, d
->data
);
540 if (focus_client
== self
) {
543 /* focus the last focused window on the desktop, and ignore enter
544 events from the unmap so it doesnt mess with the focus */
545 while (XCheckTypedEvent(ob_display
, EnterNotify
, &e
));
546 /* remove these flags so we don't end up getting focused in the
548 self
->can_focus
= FALSE
;
549 self
->focus_notify
= FALSE
;
551 client_unfocus(self
);
554 /* tell our parent(s) that we're gone */
555 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
556 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
557 if (it
->data
!= self
)
558 ((ObClient
*)it
->data
)->transients
=
559 g_slist_remove(((ObClient
*)it
->data
)->transients
, self
);
560 } else if (self
->transient_for
) { /* transient of window */
561 self
->transient_for
->transients
=
562 g_slist_remove(self
->transient_for
->transients
, self
);
565 /* tell our transients that we're gone */
566 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
567 if (((ObClient
*)it
->data
)->transient_for
!= OB_TRAN_GROUP
) {
568 ((ObClient
*)it
->data
)->transient_for
= NULL
;
569 client_calc_layer(it
->data
);
573 /* remove from its group */
575 group_remove(self
->group
, self
);
579 /* give the client its border back */
580 client_toggle_border(self
, TRUE
);
582 /* reparent the window out of the frame, and free the frame */
583 frame_release_client(self
->frame
, self
);
586 if (ob_state() != OB_STATE_EXITING
) {
587 /* these values should not be persisted across a window
589 PROP_ERASE(self
->window
, net_wm_desktop
);
590 PROP_ERASE(self
->window
, net_wm_state
);
591 PROP_ERASE(self
->window
, wm_state
);
593 /* if we're left in an unmapped state, the client wont be mapped. this
594 is bad, since we will no longer be managing the window on restart */
595 XMapWindow(ob_display
, self
->window
);
599 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
601 /* free all data allocated in the client struct */
602 g_slist_free(self
->transients
);
603 for (j
= 0; j
< self
->nicons
; ++j
)
604 g_free(self
->icons
[j
].data
);
605 if (self
->nicons
> 0)
608 g_free(self
->icon_title
);
612 g_free(self
->sm_client_id
);
615 /* update the list hints */
618 if (config_focus_last
)
619 grab_pointer(FALSE
, OB_CURSOR_NONE
);
622 static void client_urgent_notify(ObClient
*self
)
625 frame_flash_start(self
->frame
);
627 frame_flash_stop(self
->frame
);
630 static void client_restore_session_state(ObClient
*self
)
634 if (!(it
= session_state_find(self
)))
637 self
->session
= it
->data
;
639 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
640 self
->positioned
= PPosition
;
641 if (self
->session
->w
> 0)
642 self
->area
.width
= self
->session
->w
;
643 if (self
->session
->h
> 0)
644 self
->area
.height
= self
->session
->h
;
645 XResizeWindow(ob_display
, self
->window
,
646 self
->area
.width
, self
->area
.height
);
648 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
649 self
->session
->desktop
:
650 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
651 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
653 self
->shaded
= self
->session
->shaded
;
654 self
->iconic
= self
->session
->iconic
;
655 self
->skip_pager
= self
->session
->skip_pager
;
656 self
->skip_taskbar
= self
->session
->skip_taskbar
;
657 self
->fullscreen
= self
->session
->fullscreen
;
658 self
->above
= self
->session
->above
;
659 self
->below
= self
->session
->below
;
660 self
->max_horz
= self
->session
->max_horz
;
661 self
->max_vert
= self
->session
->max_vert
;
664 static void client_restore_session_stacking(ObClient
*self
)
668 if (!self
->session
) return;
670 it
= g_list_find(session_saved_state
, self
->session
);
671 for (it
= g_list_previous(it
); it
; it
= g_list_previous(it
)) {
674 for (cit
= client_list
; cit
; cit
= g_list_next(cit
))
675 if (session_state_cmp(it
->data
, cit
->data
))
678 client_calc_layer(self
);
679 stacking_below(CLIENT_AS_WINDOW(self
),
680 CLIENT_AS_WINDOW(cit
->data
));
686 void client_move_onscreen(ObClient
*self
, gboolean rude
)
688 gint x
= self
->area
.x
;
689 gint y
= self
->area
.y
;
690 if (client_find_onscreen(self
, &x
, &y
,
691 self
->frame
->area
.width
,
692 self
->frame
->area
.height
, rude
)) {
693 client_move(self
, x
, y
);
697 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
701 gint ox
= *x
, oy
= *y
;
703 frame_client_gravity(self
->frame
, x
, y
); /* get where the frame
706 /* XXX watch for xinerama dead areas */
707 /* This makes sure windows aren't entirely outside of the screen so you
708 * can't see them at all */
709 if (client_normal(self
)) {
710 a
= screen_area(self
->desktop
);
711 if (!self
->strut
.right
&& *x
>= a
->x
+ a
->width
- 1)
712 *x
= a
->x
+ a
->width
- self
->frame
->area
.width
;
713 if (!self
->strut
.bottom
&& *y
>= a
->y
+ a
->height
- 1)
714 *y
= a
->y
+ a
->height
- self
->frame
->area
.height
;
715 if (!self
->strut
.left
&& *x
+ self
->frame
->area
.width
- 1 < a
->x
)
717 if (!self
->strut
.top
&& *y
+ self
->frame
->area
.height
- 1 < a
->y
)
721 /* This here doesn't let windows even a pixel outside the screen,
722 * when called from client_manage, programs placing themselves are
723 * forced completely onscreen, while things like
724 * xterm -geometry resolution-width/2 will work fine. Trying to
725 * place it completely offscreen will be handled in the above code.
726 * Sorry for this confused comment, i am tired. */
728 /* avoid the xinerama monitor divide while we're at it,
729 * remember to fix the placement stuff to avoid it also and
730 * then remove this XXX */
731 a
= screen_physical_area_monitor(client_monitor(self
));
732 /* dont let windows map/move into the strut unless they
733 are bigger than the available area */
735 if (!self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
736 if (!self
->strut
.right
&& *x
+ w
> a
->x
+ a
->width
)
737 *x
= a
->x
+ a
->width
- w
;
739 if (h
<= a
->height
) {
740 if (!self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
741 if (!self
->strut
.bottom
&& *y
+ h
> a
->y
+ a
->height
)
742 *y
= a
->y
+ a
->height
- h
;
746 frame_frame_gravity(self
->frame
, x
, y
); /* get where the client
749 return ox
!= *x
|| oy
!= *y
;
752 static void client_toggle_border(ObClient
*self
, gboolean show
)
754 /* adjust our idea of where the client is, based on its border. When the
755 border is removed, the client should now be considered to be in a
757 when re-adding the border to the client, the same operation needs to be
759 gint oldx
= self
->area
.x
, oldy
= self
->area
.y
;
760 gint x
= oldx
, y
= oldy
;
761 switch(self
->gravity
) {
763 case NorthWestGravity
:
765 case SouthWestGravity
:
767 case NorthEastGravity
:
769 case SouthEastGravity
:
770 if (show
) x
-= self
->border_width
* 2;
771 else x
+= self
->border_width
* 2;
778 if (show
) x
-= self
->border_width
;
779 else x
+= self
->border_width
;
782 switch(self
->gravity
) {
784 case NorthWestGravity
:
786 case NorthEastGravity
:
788 case SouthWestGravity
:
790 case SouthEastGravity
:
791 if (show
) y
-= self
->border_width
* 2;
792 else y
+= self
->border_width
* 2;
799 if (show
) y
-= self
->border_width
;
800 else y
+= self
->border_width
;
807 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
809 /* move the client so it is back it the right spot _with_ its
811 if (x
!= oldx
|| y
!= oldy
)
812 XMoveWindow(ob_display
, self
->window
, x
, y
);
814 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
818 static void client_get_all(ObClient
*self
)
820 client_get_area(self
);
821 client_get_mwm_hints(self
);
823 /* The transient hint is used to pick a type, but the type can also affect
824 transiency (dialogs are always made transients of their group if they
825 have one). This is Havoc's idea, but it is needed to make some apps
826 work right (eg tsclient). */
827 client_update_transient_for(self
);
828 client_get_type(self
);/* this can change the mwmhints for special cases */
829 client_update_transient_for(self
);
831 client_update_wmhints(self
);
832 client_get_startup_id(self
);
833 client_get_desktop(self
);/* uses transient data/group/startup id if a
834 desktop is not specified */
835 client_get_shaped(self
);
837 client_get_state(self
);
840 /* a couple type-based defaults for new windows */
842 /* this makes sure that these windows appear on all desktops */
843 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
844 self
->desktop
= DESKTOP_ALL
;
847 client_update_protocols(self
);
849 client_get_gravity(self
); /* get the attribute gravity */
850 client_update_normal_hints(self
); /* this may override the attribute
853 /* got the type, the mwmhints, the protocols, and the normal hints
854 (min/max sizes), so we're ready to set up the decorations/functions */
855 client_setup_decor_and_functions(self
);
857 client_update_title(self
);
858 client_update_class(self
);
859 client_update_sm_client_id(self
);
860 client_update_strut(self
);
861 client_update_icons(self
);
864 static void client_get_startup_id(ObClient
*self
)
866 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
868 PROP_GETS(self
->group
->leader
,
869 net_startup_id
, utf8
, &self
->startup_id
);
872 static void client_get_area(ObClient
*self
)
874 XWindowAttributes wattrib
;
877 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
878 g_assert(ret
!= BadWindow
);
880 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
881 self
->border_width
= wattrib
.border_width
;
884 static void client_get_desktop(ObClient
*self
)
886 guint32 d
= screen_num_desktops
; /* an always-invalid value */
888 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
889 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
890 self
->desktop
= screen_num_desktops
- 1;
894 gboolean trdesk
= FALSE
;
896 if (self
->transient_for
) {
897 if (self
->transient_for
!= OB_TRAN_GROUP
) {
898 self
->desktop
= self
->transient_for
->desktop
;
903 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
904 if (it
->data
!= self
&&
905 !((ObClient
*)it
->data
)->transient_for
) {
906 self
->desktop
= ((ObClient
*)it
->data
)->desktop
;
913 /* try get from the startup-notification protocol */
914 if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
915 if (self
->desktop
>= screen_num_desktops
&&
916 self
->desktop
!= DESKTOP_ALL
)
917 self
->desktop
= screen_num_desktops
- 1;
919 /* defaults to the current desktop */
920 self
->desktop
= screen_desktop
;
923 if (self
->desktop
!= d
) {
924 /* set the desktop hint, to make sure that it always exists */
925 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
929 static void client_get_state(ObClient
*self
)
934 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
936 for (i
= 0; i
< num
; ++i
) {
937 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
939 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
941 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
943 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
944 self
->skip_taskbar
= TRUE
;
945 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
946 self
->skip_pager
= TRUE
;
947 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
948 self
->fullscreen
= TRUE
;
949 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
950 self
->max_vert
= TRUE
;
951 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
952 self
->max_horz
= TRUE
;
953 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
955 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
957 else if (state
[i
] == prop_atoms
.ob_wm_state_undecorated
)
958 self
->undecorated
= TRUE
;
964 if (!(self
->above
|| self
->below
)) {
966 /* apply stuff from the group */
970 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
971 ObClient
*c
= it
->data
;
972 if (c
!= self
&& !client_search_transient(self
, c
) &&
973 client_normal(self
) && client_normal(c
))
976 (c
->above
? 1 : (c
->below
? -1 : 0)));
990 g_assert_not_reached();
997 static void client_get_shaped(ObClient
*self
)
999 self
->shaped
= FALSE
;
1001 if (extensions_shape
) {
1006 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
1008 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
1009 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
1011 self
->shaped
= (s
!= 0);
1016 void client_update_transient_for(ObClient
*self
)
1019 ObClient
*target
= NULL
;
1021 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
1022 self
->transient
= TRUE
;
1023 if (t
!= self
->window
) { /* cant be transient to itself! */
1024 target
= g_hash_table_lookup(window_map
, &t
);
1025 /* if this happens then we need to check for it*/
1026 g_assert(target
!= self
);
1027 if (target
&& !WINDOW_IS_CLIENT(target
)) {
1028 /* this can happen when a dialog is a child of
1029 a dockapp, for example */
1033 if (!target
&& self
->group
) {
1034 /* not transient to a client, see if it is transient for a
1036 if (t
== self
->group
->leader
||
1038 t
== RootWindow(ob_display
, ob_screen
))
1040 /* window is a transient for its group! */
1041 target
= OB_TRAN_GROUP
;
1045 } else if (self
->type
== OB_CLIENT_TYPE_DIALOG
&& self
->group
) {
1046 self
->transient
= TRUE
;
1047 target
= OB_TRAN_GROUP
;
1049 self
->transient
= FALSE
;
1051 /* if anything has changed... */
1052 if (target
!= self
->transient_for
) {
1053 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
1056 /* remove from old parents */
1057 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1058 ObClient
*c
= it
->data
;
1059 if (c
!= self
&& !c
->transient_for
)
1060 c
->transients
= g_slist_remove(c
->transients
, self
);
1062 } else if (self
->transient_for
!= NULL
) { /* transient of window */
1063 /* remove from old parent */
1064 self
->transient_for
->transients
=
1065 g_slist_remove(self
->transient_for
->transients
, self
);
1067 self
->transient_for
= target
;
1068 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
1071 /* add to new parents */
1072 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1073 ObClient
*c
= it
->data
;
1074 if (c
!= self
&& !c
->transient_for
)
1075 c
->transients
= g_slist_append(c
->transients
, self
);
1078 /* remove all transients which are in the group, that causes
1079 circlular pointer hell of doom */
1080 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1082 for (sit
= self
->transients
; sit
; sit
= next
) {
1083 next
= g_slist_next(sit
);
1084 if (sit
->data
== it
->data
)
1086 g_slist_delete_link(self
->transients
, sit
);
1089 } else if (self
->transient_for
!= NULL
) { /* transient of window */
1090 /* add to new parent */
1091 self
->transient_for
->transients
=
1092 g_slist_append(self
->transient_for
->transients
, self
);
1097 static void client_get_mwm_hints(ObClient
*self
)
1102 self
->mwmhints
.flags
= 0; /* default to none */
1104 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
1106 if (num
>= OB_MWM_ELEMENTS
) {
1107 self
->mwmhints
.flags
= hints
[0];
1108 self
->mwmhints
.functions
= hints
[1];
1109 self
->mwmhints
.decorations
= hints
[2];
1115 void client_get_type(ObClient
*self
)
1122 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1123 /* use the first value that we know about in the array */
1124 for (i
= 0; i
< num
; ++i
) {
1125 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1126 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1127 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1128 self
->type
= OB_CLIENT_TYPE_DOCK
;
1129 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1130 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1131 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1132 self
->type
= OB_CLIENT_TYPE_MENU
;
1133 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1134 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1135 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1136 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1137 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1138 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1139 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1140 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1141 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1142 /* prevent this window from getting any decor or
1144 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1145 OB_MWM_FLAG_DECORATIONS
);
1146 self
->mwmhints
.decorations
= 0;
1147 self
->mwmhints
.functions
= 0;
1149 if (self
->type
!= (ObClientType
) -1)
1150 break; /* grab the first legit type */
1155 if (self
->type
== (ObClientType
) -1) {
1156 /*the window type hint was not set, which means we either classify
1157 ourself as a normal window or a dialog, depending on if we are a
1159 if (self
->transient
)
1160 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1162 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1166 void client_update_protocols(ObClient
*self
)
1169 guint num_return
, i
;
1171 self
->focus_notify
= FALSE
;
1172 self
->delete_window
= FALSE
;
1174 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1175 for (i
= 0; i
< num_return
; ++i
) {
1176 if (proto
[i
] == prop_atoms
.wm_delete_window
) {
1177 /* this means we can request the window to close */
1178 self
->delete_window
= TRUE
;
1179 } else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1180 /* if this protocol is requested, then the window will be
1181 notified whenever we want it to receive focus */
1182 self
->focus_notify
= TRUE
;
1188 static void client_get_gravity(ObClient
*self
)
1190 XWindowAttributes wattrib
;
1193 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1194 g_assert(ret
!= BadWindow
);
1195 self
->gravity
= wattrib
.win_gravity
;
1198 void client_update_normal_hints(ObClient
*self
)
1202 gint oldgravity
= self
->gravity
;
1205 self
->min_ratio
= 0.0f
;
1206 self
->max_ratio
= 0.0f
;
1207 SIZE_SET(self
->size_inc
, 1, 1);
1208 SIZE_SET(self
->base_size
, 0, 0);
1209 SIZE_SET(self
->min_size
, 0, 0);
1210 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1212 /* get the hints from the window */
1213 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1214 /* normal windows can't request placement! har har
1215 if (!client_normal(self))
1217 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1219 if (size
.flags
& PWinGravity
) {
1220 self
->gravity
= size
.win_gravity
;
1222 /* if the client has a frame, i.e. has already been mapped and
1223 is changing its gravity */
1224 if (self
->frame
&& self
->gravity
!= oldgravity
) {
1225 /* move our idea of the client's position based on its new
1227 self
->area
.x
= self
->frame
->area
.x
;
1228 self
->area
.y
= self
->frame
->area
.y
;
1229 frame_frame_gravity(self
->frame
, &self
->area
.x
, &self
->area
.y
);
1233 if (size
.flags
& PAspect
) {
1234 if (size
.min_aspect
.y
)
1236 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1237 if (size
.max_aspect
.y
)
1239 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1242 if (size
.flags
& PMinSize
)
1243 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1245 if (size
.flags
& PMaxSize
)
1246 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1248 if (size
.flags
& PBaseSize
)
1249 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1251 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1252 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1256 void client_setup_decor_and_functions(ObClient
*self
)
1258 /* start with everything (cept fullscreen) */
1260 (OB_FRAME_DECOR_TITLEBAR
|
1261 OB_FRAME_DECOR_HANDLE
|
1262 OB_FRAME_DECOR_GRIPS
|
1263 OB_FRAME_DECOR_BORDER
|
1264 OB_FRAME_DECOR_ICON
|
1265 OB_FRAME_DECOR_ALLDESKTOPS
|
1266 OB_FRAME_DECOR_ICONIFY
|
1267 OB_FRAME_DECOR_MAXIMIZE
|
1268 OB_FRAME_DECOR_SHADE
|
1269 OB_FRAME_DECOR_CLOSE
);
1271 (OB_CLIENT_FUNC_RESIZE
|
1272 OB_CLIENT_FUNC_MOVE
|
1273 OB_CLIENT_FUNC_ICONIFY
|
1274 OB_CLIENT_FUNC_MAXIMIZE
|
1275 OB_CLIENT_FUNC_SHADE
|
1276 OB_CLIENT_FUNC_CLOSE
);
1278 if (!(self
->min_size
.width
< self
->max_size
.width
||
1279 self
->min_size
.height
< self
->max_size
.height
))
1280 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1282 switch (self
->type
) {
1283 case OB_CLIENT_TYPE_NORMAL
:
1284 /* normal windows retain all of the possible decorations and
1285 functionality, and are the only windows that you can fullscreen */
1286 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1289 case OB_CLIENT_TYPE_DIALOG
:
1290 case OB_CLIENT_TYPE_UTILITY
:
1291 /* these windows cannot be maximized */
1292 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1295 case OB_CLIENT_TYPE_MENU
:
1296 case OB_CLIENT_TYPE_TOOLBAR
:
1297 /* these windows get less functionality */
1298 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
| OB_CLIENT_FUNC_RESIZE
);
1301 case OB_CLIENT_TYPE_DESKTOP
:
1302 case OB_CLIENT_TYPE_DOCK
:
1303 case OB_CLIENT_TYPE_SPLASH
:
1304 /* none of these windows are manipulated by the window manager */
1305 self
->decorations
= 0;
1306 self
->functions
= 0;
1310 /* Mwm Hints are applied subtractively to what has already been chosen for
1311 decor and functionality */
1312 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1313 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1314 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1315 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1317 /* if the mwm hints request no handle or title, then all
1318 decorations are disabled, but keep the border if that's
1320 if (self
->mwmhints
.decorations
& OB_MWM_DECOR_BORDER
)
1321 self
->decorations
= OB_FRAME_DECOR_BORDER
;
1323 self
->decorations
= 0;
1328 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1329 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1330 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1331 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1332 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1333 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1334 /* dont let mwm hints kill any buttons
1335 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1336 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1337 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1338 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1340 /* dont let mwm hints kill the close button
1341 if (! (self->mwmhints.functions & MwmFunc_Close))
1342 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1346 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1347 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1348 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1349 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1350 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1351 self
->decorations
&= ~OB_FRAME_DECOR_GRIPS
;
1353 /* can't maximize without moving/resizing */
1354 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1355 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1356 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1357 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1358 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1361 /* kill the handle on fully maxed windows */
1362 if (self
->max_vert
&& self
->max_horz
)
1363 self
->decorations
&= ~OB_FRAME_DECOR_HANDLE
;
1365 /* finally, the user can have requested no decorations, which overrides
1366 everything (but doesnt give it a border if it doesnt have one) */
1367 if (self
->undecorated
) {
1368 if (config_theme_keepborder
)
1369 self
->decorations
&= OB_FRAME_DECOR_BORDER
;
1371 self
->decorations
= 0;
1374 /* if we don't have a titlebar, then we cannot shade! */
1375 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1376 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1378 /* now we need to check against rules for the client's current state */
1379 if (self
->fullscreen
) {
1380 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1381 OB_CLIENT_FUNC_FULLSCREEN
|
1382 OB_CLIENT_FUNC_ICONIFY
);
1383 self
->decorations
= 0;
1386 client_change_allowed_actions(self
);
1389 /* adjust the client's decorations, etc. */
1390 client_reconfigure(self
);
1394 static void client_change_allowed_actions(ObClient
*self
)
1399 /* desktop windows are kept on all desktops */
1400 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1401 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1403 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1404 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1405 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1406 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1407 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1408 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1409 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1410 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1411 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1412 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1413 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1414 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1415 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1416 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1417 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1420 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1422 /* make sure the window isn't breaking any rules now */
1424 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1425 if (self
->frame
) client_shade(self
, FALSE
);
1426 else self
->shaded
= FALSE
;
1428 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
) && self
->iconic
) {
1429 if (self
->frame
) client_iconify(self
, FALSE
, TRUE
);
1430 else self
->iconic
= FALSE
;
1432 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1433 if (self
->frame
) client_fullscreen(self
, FALSE
, TRUE
);
1434 else self
->fullscreen
= FALSE
;
1436 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1438 if (self
->frame
) client_maximize(self
, FALSE
, 0, TRUE
);
1439 else self
->max_vert
= self
->max_horz
= FALSE
;
1443 void client_reconfigure(ObClient
*self
)
1445 /* by making this pass FALSE for user, we avoid the emacs event storm where
1446 every configurenotify causes an update in its normal hints, i think this
1447 is generally what we want anyways... */
1448 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
1449 self
->area
.width
, self
->area
.height
, FALSE
, TRUE
);
1452 void client_update_wmhints(ObClient
*self
)
1455 gboolean ur
= FALSE
;
1458 /* assume a window takes input if it doesnt specify */
1459 self
->can_focus
= TRUE
;
1461 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1462 if (hints
->flags
& InputHint
)
1463 self
->can_focus
= hints
->input
;
1465 /* only do this when first managing the window *AND* when we aren't
1467 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1468 if (hints
->flags
& StateHint
)
1469 self
->iconic
= hints
->initial_state
== IconicState
;
1471 if (hints
->flags
& XUrgencyHint
)
1474 if (!(hints
->flags
& WindowGroupHint
))
1475 hints
->window_group
= None
;
1477 /* did the group state change? */
1478 if (hints
->window_group
!=
1479 (self
->group
? self
->group
->leader
: None
)) {
1480 /* remove from the old group if there was one */
1481 if (self
->group
!= NULL
) {
1482 /* remove transients of the group */
1483 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1484 self
->transients
= g_slist_remove(self
->transients
,
1487 /* remove myself from parents in the group */
1488 if (self
->transient_for
== OB_TRAN_GROUP
) {
1489 for (it
= self
->group
->members
; it
;
1490 it
= g_slist_next(it
))
1492 ObClient
*c
= it
->data
;
1494 if (c
!= self
&& !c
->transient_for
)
1495 c
->transients
= g_slist_remove(c
->transients
,
1500 group_remove(self
->group
, self
);
1503 if (hints
->window_group
!= None
) {
1504 self
->group
= group_add(hints
->window_group
, self
);
1506 /* i can only have transients from the group if i am not
1508 if (!self
->transient_for
) {
1509 /* add other transients of the group that are already
1511 for (it
= self
->group
->members
; it
;
1512 it
= g_slist_next(it
))
1514 ObClient
*c
= it
->data
;
1515 if (c
!= self
&& c
->transient_for
== OB_TRAN_GROUP
)
1517 g_slist_append(self
->transients
, c
);
1522 /* because the self->transient flag wont change from this call,
1523 we don't need to update the window's type and such, only its
1524 transient_for, and the transients lists of other windows in
1525 the group may be affected */
1526 client_update_transient_for(self
);
1529 /* the WM_HINTS can contain an icon */
1530 client_update_icons(self
);
1535 if (ur
!= self
->urgent
) {
1537 /* fire the urgent callback if we're mapped, otherwise, wait until
1538 after we're mapped */
1540 client_urgent_notify(self
);
1544 void client_update_title(ObClient
*self
)
1550 gboolean read_title
;
1553 old_title
= self
->title
;
1556 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
)) {
1557 /* try old x stuff */
1558 if (!(PROP_GETS(self
->window
, wm_name
, locale
, &data
)
1559 || PROP_GETS(self
->window
, wm_name
, utf8
, &data
))) {
1560 // http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1561 if (self
->transient
) {
1562 data
= g_strdup("");
1565 data
= g_strdup("Unnamed Window");
1569 if (config_title_number
) {
1571 /* did the title change? then reset the title_count */
1572 if (old_title
&& 0 != strncmp(old_title
, data
, strlen(data
)))
1573 self
->title_count
= 1;
1575 /* look for duplicates and append a number */
1577 for (it
= client_list
; it
; it
= g_list_next(it
))
1578 if (it
->data
!= self
) {
1579 ObClient
*c
= it
->data
;
1581 if (c
->title_count
== 1) {
1582 if (!strcmp(c
->title
, data
))
1583 nums
|= 1 << c
->title_count
;
1588 /* find the beginning of our " - [%u]", this relies on
1589 that syntax being used */
1590 end
= strrchr(c
->title
, '-') - 1;
1591 len
= end
- c
->title
;
1592 if (!strncmp(c
->title
, data
, len
))
1593 nums
|= 1 << c
->title_count
;
1596 /* find first free number */
1597 for (i
= 1; i
<= 32; ++i
)
1598 if (!(nums
& (1 << i
))) {
1599 if (self
->title_count
== 1 || i
== 1)
1600 self
->title_count
= i
;
1603 /* dont display the number for the first window */
1604 if (self
->title_count
> 1) {
1606 ndata
= g_strdup_printf("%s - [%u]", data
, self
->title_count
);
1611 self
->title_count
= 1;
1614 PROP_SETS(self
->window
, net_wm_visible_name
, data
);
1618 frame_adjust_title(self
->frame
);
1622 /* update the icon title */
1624 g_free(self
->icon_title
);
1628 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
1629 /* try old x stuff */
1630 if (!(PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
)
1631 || PROP_GETS(self
->window
, wm_icon_name
, utf8
, &data
))) {
1632 data
= g_strdup(self
->title
);
1636 /* append the title count, dont display the number for the first window.
1637 * We don't need to check for config_title_number here since title_count
1638 * is not set above 1 then. */
1639 if (read_title
&& self
->title_count
> 1) {
1641 newdata
= g_strdup_printf("%s - [%u]", data
, self
->title_count
);
1646 PROP_SETS(self
->window
, net_wm_visible_icon_name
, data
);
1648 self
->icon_title
= data
;
1651 void client_update_class(ObClient
*self
)
1656 if (self
->name
) g_free(self
->name
);
1657 if (self
->class) g_free(self
->class);
1658 if (self
->role
) g_free(self
->role
);
1660 self
->name
= self
->class = self
->role
= NULL
;
1662 if (PROP_GETSS(self
->window
, wm_class
, locale
, &data
)) {
1664 self
->name
= g_strdup(data
[0]);
1666 self
->class = g_strdup(data
[1]);
1671 if (PROP_GETS(self
->window
, wm_window_role
, locale
, &s
))
1674 if (self
->name
== NULL
) self
->name
= g_strdup("");
1675 if (self
->class == NULL
) self
->class = g_strdup("");
1676 if (self
->role
== NULL
) self
->role
= g_strdup("");
1679 void client_update_strut(ObClient
*self
)
1683 gboolean got
= FALSE
;
1686 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
1690 STRUT_PARTIAL_SET(strut
,
1691 data
[0], data
[2], data
[1], data
[3],
1692 data
[4], data
[5], data
[8], data
[9],
1693 data
[6], data
[7], data
[10], data
[11]);
1699 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
1705 /* use the screen's width/height */
1706 a
= screen_physical_area();
1708 STRUT_PARTIAL_SET(strut
,
1709 data
[0], data
[2], data
[1], data
[3],
1710 a
->y
, a
->y
+ a
->height
- 1,
1711 a
->x
, a
->x
+ a
->width
- 1,
1712 a
->y
, a
->y
+ a
->height
- 1,
1713 a
->x
, a
->x
+ a
->width
- 1);
1719 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
1720 0, 0, 0, 0, 0, 0, 0, 0);
1722 if (!STRUT_EQUAL(strut
, self
->strut
)) {
1723 self
->strut
= strut
;
1725 /* updating here is pointless while we're being mapped cuz we're not in
1726 the client list yet */
1728 screen_update_areas();
1732 void client_update_icons(ObClient
*self
)
1738 for (i
= 0; i
< self
->nicons
; ++i
)
1739 g_free(self
->icons
[i
].data
);
1740 if (self
->nicons
> 0)
1741 g_free(self
->icons
);
1744 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
1745 /* figure out how many valid icons are in here */
1747 while (num
- i
> 2) {
1751 if (i
> num
|| w
*h
== 0) break;
1755 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1757 /* store the icons */
1759 for (j
= 0; j
< self
->nicons
; ++j
) {
1762 w
= self
->icons
[j
].width
= data
[i
++];
1763 h
= self
->icons
[j
].height
= data
[i
++];
1765 if (w
*h
== 0) continue;
1767 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
1768 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
1773 self
->icons
[j
].data
[t
] =
1774 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
1775 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
1776 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
1777 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
1783 } else if (PROP_GETA32(self
->window
, kwm_win_icon
,
1784 kwm_win_icon
, &data
, &num
)) {
1787 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1788 xerror_set_ignore(TRUE
);
1789 if (!RrPixmapToRGBA(ob_rr_inst
,
1791 &self
->icons
[self
->nicons
-1].width
,
1792 &self
->icons
[self
->nicons
-1].height
,
1793 &self
->icons
[self
->nicons
-1].data
)) {
1794 g_free(&self
->icons
[self
->nicons
-1]);
1797 xerror_set_ignore(FALSE
);
1803 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
1804 if (hints
->flags
& IconPixmapHint
) {
1806 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1807 xerror_set_ignore(TRUE
);
1808 if (!RrPixmapToRGBA(ob_rr_inst
,
1810 (hints
->flags
& IconMaskHint
?
1811 hints
->icon_mask
: None
),
1812 &self
->icons
[self
->nicons
-1].width
,
1813 &self
->icons
[self
->nicons
-1].height
,
1814 &self
->icons
[self
->nicons
-1].data
)){
1815 g_free(&self
->icons
[self
->nicons
-1]);
1818 xerror_set_ignore(FALSE
);
1825 frame_adjust_icon(self
->frame
);
1828 static void client_change_state(ObClient
*self
)
1831 gulong netstate
[11];
1834 state
[0] = self
->wmstate
;
1836 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
1840 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
1842 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
1844 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
1845 if (self
->skip_taskbar
)
1846 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
1847 if (self
->skip_pager
)
1848 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
1849 if (self
->fullscreen
)
1850 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
1852 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
1854 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
1856 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
1858 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
1859 if (self
->undecorated
)
1860 netstate
[num
++] = prop_atoms
.ob_wm_state_undecorated
;
1861 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
1863 client_calc_layer(self
);
1866 frame_adjust_state(self
->frame
);
1869 ObClient
*client_search_focus_tree(ObClient
*self
)
1874 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
1875 if (client_focused(it
->data
)) return it
->data
;
1876 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
1881 ObClient
*client_search_focus_tree_full(ObClient
*self
)
1883 if (self
->transient_for
) {
1884 if (self
->transient_for
!= OB_TRAN_GROUP
) {
1885 return client_search_focus_tree_full(self
->transient_for
);
1888 gboolean recursed
= FALSE
;
1890 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1891 if (!((ObClient
*)it
->data
)->transient_for
) {
1893 if ((c
= client_search_focus_tree_full(it
->data
)))
1902 /* this function checks the whole tree, the client_search_focus_tree~
1903 does not, so we need to check this window */
1904 if (client_focused(self
))
1906 return client_search_focus_tree(self
);
1909 static ObStackingLayer
calc_layer(ObClient
*self
)
1913 if (self
->fullscreen
&&
1914 (client_focused(self
) || client_search_focus_tree(self
)))
1915 l
= OB_STACKING_LAYER_FULLSCREEN
;
1916 else if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
1917 l
= OB_STACKING_LAYER_DESKTOP
;
1918 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
1919 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
1920 else l
= OB_STACKING_LAYER_ABOVE
;
1922 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
1923 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
1924 else l
= OB_STACKING_LAYER_NORMAL
;
1929 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
1930 ObStackingLayer l
, gboolean raised
)
1932 ObStackingLayer old
, own
;
1936 own
= calc_layer(self
);
1937 self
->layer
= l
> own
? l
: own
;
1939 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
1940 client_calc_layer_recursive(it
->data
, orig
,
1941 l
, raised
? raised
: l
!= old
);
1943 if (!raised
&& l
!= old
)
1944 if (orig
->frame
) { /* only restack if the original window is managed */
1945 stacking_remove(CLIENT_AS_WINDOW(self
));
1946 stacking_add(CLIENT_AS_WINDOW(self
));
1950 void client_calc_layer(ObClient
*self
)
1957 /* transients take on the layer of their parents */
1958 self
= client_search_top_transient(self
);
1960 l
= calc_layer(self
);
1962 client_calc_layer_recursive(self
, orig
, l
, FALSE
);
1965 gboolean
client_should_show(ObClient
*self
)
1969 if (client_normal(self
) && screen_showing_desktop
)
1972 if (self->transient_for) {
1973 if (self->transient_for != OB_TRAN_GROUP)
1974 return client_should_show(self->transient_for);
1978 for (it = self->group->members; it; it = g_slist_next(it)) {
1979 ObClient *c = it->data;
1980 if (c != self && !c->transient_for) {
1981 if (client_should_show(c))
1988 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
1994 static void client_showhide(ObClient
*self
)
1997 if (client_should_show(self
))
1998 frame_show(self
->frame
);
2000 frame_hide(self
->frame
);
2003 gboolean
client_normal(ObClient
*self
) {
2004 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
2005 self
->type
== OB_CLIENT_TYPE_DOCK
||
2006 self
->type
== OB_CLIENT_TYPE_SPLASH
);
2009 static void client_apply_startup_state(ObClient
*self
)
2011 /* these are in a carefully crafted order.. */
2014 self
->iconic
= FALSE
;
2015 client_iconify(self
, TRUE
, FALSE
);
2017 if (self
->fullscreen
) {
2018 self
->fullscreen
= FALSE
;
2019 client_fullscreen(self
, TRUE
, FALSE
);
2021 if (self
->undecorated
) {
2022 self
->undecorated
= FALSE
;
2023 client_set_undecorated(self
, TRUE
);
2026 self
->shaded
= FALSE
;
2027 client_shade(self
, TRUE
);
2030 client_urgent_notify(self
);
2032 if (self
->max_vert
&& self
->max_horz
) {
2033 self
->max_vert
= self
->max_horz
= FALSE
;
2034 client_maximize(self
, TRUE
, 0, FALSE
);
2035 } else if (self
->max_vert
) {
2036 self
->max_vert
= FALSE
;
2037 client_maximize(self
, TRUE
, 2, FALSE
);
2038 } else if (self
->max_horz
) {
2039 self
->max_horz
= FALSE
;
2040 client_maximize(self
, TRUE
, 1, FALSE
);
2043 /* nothing to do for the other states:
2052 void client_configure_full(ObClient
*self
, ObCorner anchor
,
2053 gint x
, gint y
, gint w
, gint h
,
2054 gboolean user
, gboolean final
,
2055 gboolean force_reply
)
2058 gboolean send_resize_client
;
2059 gboolean moved
= FALSE
, resized
= FALSE
;
2060 guint fdecor
= self
->frame
->decorations
;
2061 gboolean fhorz
= self
->frame
->max_horz
;
2063 /* make the frame recalculate its dimentions n shit without changing
2064 anything visible for real, this way the constraints below can work with
2065 the updated frame dimensions. */
2066 frame_adjust_area(self
->frame
, TRUE
, TRUE
, TRUE
);
2068 /* gets the frame's position */
2069 frame_client_gravity(self
->frame
, &x
, &y
);
2071 /* these positions are frame positions, not client positions */
2073 /* set the size and position if fullscreen */
2074 if (self
->fullscreen
) {
2078 i
= client_monitor(self
);
2079 a
= screen_physical_area_monitor(i
);
2086 user
= FALSE
; /* ignore that increment etc shit when in fullscreen */
2090 a
= screen_area_monitor(self
->desktop
, client_monitor(self
));
2092 /* set the size and position if maximized */
2093 if (self
->max_horz
) {
2095 w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2097 if (self
->max_vert
) {
2099 h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2103 /* gets the client's position */
2104 frame_frame_gravity(self
->frame
, &x
, &y
);
2106 /* these override the above states! if you cant move you can't move! */
2108 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2112 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2113 w
= self
->area
.width
;
2114 h
= self
->area
.height
;
2118 if (!(w
== self
->area
.width
&& h
== self
->area
.height
)) {
2119 gint basew
, baseh
, minw
, minh
;
2121 /* base size is substituted with min size if not specified */
2122 if (self
->base_size
.width
|| self
->base_size
.height
) {
2123 basew
= self
->base_size
.width
;
2124 baseh
= self
->base_size
.height
;
2126 basew
= self
->min_size
.width
;
2127 baseh
= self
->min_size
.height
;
2129 /* min size is substituted with base size if not specified */
2130 if (self
->min_size
.width
|| self
->min_size
.height
) {
2131 minw
= self
->min_size
.width
;
2132 minh
= self
->min_size
.height
;
2134 minw
= self
->base_size
.width
;
2135 minh
= self
->base_size
.height
;
2138 /* if this is a user-requested resize, then check against min/max
2141 /* smaller than min size or bigger than max size? */
2142 if (w
> self
->max_size
.width
) w
= self
->max_size
.width
;
2143 if (w
< minw
) w
= minw
;
2144 if (h
> self
->max_size
.height
) h
= self
->max_size
.height
;
2145 if (h
< minh
) h
= minh
;
2150 /* keep to the increments */
2151 w
/= self
->size_inc
.width
;
2152 h
/= self
->size_inc
.height
;
2154 /* you cannot resize to nothing */
2155 if (basew
+ w
< 1) w
= 1 - basew
;
2156 if (baseh
+ h
< 1) h
= 1 - baseh
;
2158 /* store the logical size */
2159 SIZE_SET(self
->logical_size
,
2160 self
->size_inc
.width
> 1 ? w
: w
+ basew
,
2161 self
->size_inc
.height
> 1 ? h
: h
+ baseh
);
2163 w
*= self
->size_inc
.width
;
2164 h
*= self
->size_inc
.height
;
2169 /* adjust the height to match the width for the aspect ratios.
2170 for this, min size is not substituted for base size ever. */
2171 w
-= self
->base_size
.width
;
2172 h
-= self
->base_size
.height
;
2174 if (!self
->fullscreen
) {
2175 if (self
->min_ratio
)
2176 if (h
* self
->min_ratio
> w
) {
2177 h
= (gint
)(w
/ self
->min_ratio
);
2179 /* you cannot resize to nothing */
2182 w
= (gint
)(h
* self
->min_ratio
);
2185 if (self
->max_ratio
)
2186 if (h
* self
->max_ratio
< w
) {
2187 h
= (gint
)(w
/ self
->max_ratio
);
2189 /* you cannot resize to nothing */
2192 w
= (gint
)(h
* self
->min_ratio
);
2197 w
+= self
->base_size
.width
;
2198 h
+= self
->base_size
.height
;
2205 case OB_CORNER_TOPLEFT
:
2207 case OB_CORNER_TOPRIGHT
:
2208 x
-= w
- self
->area
.width
;
2210 case OB_CORNER_BOTTOMLEFT
:
2211 y
-= h
- self
->area
.height
;
2213 case OB_CORNER_BOTTOMRIGHT
:
2214 x
-= w
- self
->area
.width
;
2215 y
-= h
- self
->area
.height
;
2219 moved
= x
!= self
->area
.x
|| y
!= self
->area
.y
;
2220 resized
= w
!= self
->area
.width
|| h
!= self
->area
.height
;
2222 oldw
= self
->area
.width
;
2223 oldh
= self
->area
.height
;
2224 RECT_SET(self
->area
, x
, y
, w
, h
);
2226 /* for app-requested resizes, always resize if 'resized' is true.
2227 for user-requested ones, only resize if final is true, or when
2228 resizing in redraw mode */
2229 send_resize_client
= ((!user
&& resized
) ||
2231 (resized
&& config_resize_redraw
))));
2233 /* if the client is enlarging, then resize the client before the frame */
2234 if (send_resize_client
&& user
&& (w
> oldw
|| h
> oldh
))
2235 XResizeWindow(ob_display
, self
->window
, MAX(w
, oldw
), MAX(h
, oldh
));
2237 /* move/resize the frame to match the request */
2239 if (self
->decorations
!= fdecor
|| self
->max_horz
!= fhorz
)
2240 moved
= resized
= TRUE
;
2242 if (moved
|| resized
)
2243 frame_adjust_area(self
->frame
, moved
, resized
, FALSE
);
2245 if (!resized
&& (force_reply
|| ((!user
&& moved
) || (user
&& final
))))
2248 event
.type
= ConfigureNotify
;
2249 event
.xconfigure
.display
= ob_display
;
2250 event
.xconfigure
.event
= self
->window
;
2251 event
.xconfigure
.window
= self
->window
;
2253 /* root window real coords */
2254 event
.xconfigure
.x
= self
->frame
->area
.x
+ self
->frame
->size
.left
-
2256 event
.xconfigure
.y
= self
->frame
->area
.y
+ self
->frame
->size
.top
-
2258 event
.xconfigure
.width
= w
;
2259 event
.xconfigure
.height
= h
;
2260 event
.xconfigure
.border_width
= 0;
2261 event
.xconfigure
.above
= self
->frame
->plate
;
2262 event
.xconfigure
.override_redirect
= FALSE
;
2263 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
2264 FALSE
, StructureNotifyMask
, &event
);
2268 /* if the client is shrinking, then resize the frame before the client */
2269 if (send_resize_client
&& (!user
|| (w
<= oldw
|| h
<= oldh
)))
2270 XResizeWindow(ob_display
, self
->window
, w
, h
);
2275 void client_fullscreen(ObClient
*self
, gboolean fs
, gboolean savearea
)
2279 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
2280 self
->fullscreen
== fs
) return; /* already done */
2282 self
->fullscreen
= fs
;
2283 client_change_state(self
); /* change the state hints on the client,
2284 and adjust out layer/stacking */
2288 self
->pre_fullscreen_area
= self
->area
;
2290 /* these are not actually used cuz client_configure will set them
2291 as appropriate when the window is fullscreened */
2296 if (self
->pre_fullscreen_area
.width
> 0 &&
2297 self
->pre_fullscreen_area
.height
> 0)
2299 x
= self
->pre_fullscreen_area
.x
;
2300 y
= self
->pre_fullscreen_area
.y
;
2301 w
= self
->pre_fullscreen_area
.width
;
2302 h
= self
->pre_fullscreen_area
.height
;
2303 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
2305 /* pick some fallbacks... */
2306 a
= screen_area_monitor(self
->desktop
, 0);
2307 x
= a
->x
+ a
->width
/ 4;
2308 y
= a
->y
+ a
->height
/ 4;
2314 client_setup_decor_and_functions(self
);
2316 client_move_resize(self
, x
, y
, w
, h
);
2318 /* try focus us when we go into fullscreen mode */
2322 static void client_iconify_recursive(ObClient
*self
,
2323 gboolean iconic
, gboolean curdesk
)
2326 gboolean changed
= FALSE
;
2329 if (self
->iconic
!= iconic
) {
2330 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
2333 self
->iconic
= iconic
;
2336 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
) {
2339 old
= self
->wmstate
;
2340 self
->wmstate
= IconicState
;
2341 if (old
!= self
->wmstate
)
2342 PROP_MSG(self
->window
, kde_wm_change_state
,
2343 self
->wmstate
, 1, 0, 0);
2345 /* update the focus lists.. iconic windows go to the bottom of
2346 the list, put the new iconic window at the 'top of the
2348 focus_order_to_top(self
);
2356 client_set_desktop(self
, screen_desktop
, FALSE
);
2358 old
= self
->wmstate
;
2359 self
->wmstate
= self
->shaded
? IconicState
: NormalState
;
2360 if (old
!= self
->wmstate
)
2361 PROP_MSG(self
->window
, kde_wm_change_state
,
2362 self
->wmstate
, 1, 0, 0);
2364 /* this puts it after the current focused window */
2365 focus_order_remove(self
);
2366 focus_order_add_new(self
);
2373 client_change_state(self
);
2374 client_showhide(self
);
2375 if (STRUT_EXISTS(self
->strut
))
2376 screen_update_areas();
2379 /* iconify all transients */
2380 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2381 if (it
->data
!= self
) client_iconify_recursive(it
->data
,
2385 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
)
2387 /* move up the transient chain as far as possible first */
2388 self
= client_search_top_transient(self
);
2390 client_iconify_recursive(client_search_top_transient(self
),
2394 void client_maximize(ObClient
*self
, gboolean max
, gint dir
, gboolean savearea
)
2398 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
2399 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
2401 /* check if already done */
2403 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
2404 if (dir
== 1 && self
->max_horz
) return;
2405 if (dir
== 2 && self
->max_vert
) return;
2407 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
2408 if (dir
== 1 && !self
->max_horz
) return;
2409 if (dir
== 2 && !self
->max_vert
) return;
2412 /* we just tell it to configure in the same place and client_configure
2413 worries about filling the screen with the window */
2416 w
= self
->area
.width
;
2417 h
= self
->area
.height
;
2421 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
2422 RECT_SET(self
->pre_max_area
,
2423 self
->area
.x
, self
->pre_max_area
.y
,
2424 self
->area
.width
, self
->pre_max_area
.height
);
2426 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
2427 RECT_SET(self
->pre_max_area
,
2428 self
->pre_max_area
.x
, self
->area
.y
,
2429 self
->pre_max_area
.width
, self
->area
.height
);
2435 a
= screen_area_monitor(self
->desktop
, 0);
2436 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
2437 if (self
->pre_max_area
.width
> 0) {
2438 x
= self
->pre_max_area
.x
;
2439 w
= self
->pre_max_area
.width
;
2441 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
2442 0, self
->pre_max_area
.height
);
2444 /* pick some fallbacks... */
2445 x
= a
->x
+ a
->width
/ 4;
2449 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
2450 if (self
->pre_max_area
.height
> 0) {
2451 y
= self
->pre_max_area
.y
;
2452 h
= self
->pre_max_area
.height
;
2454 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
2455 self
->pre_max_area
.width
, 0);
2457 /* pick some fallbacks... */
2458 y
= a
->y
+ a
->height
/ 4;
2464 if (dir
== 0 || dir
== 1) /* horz */
2465 self
->max_horz
= max
;
2466 if (dir
== 0 || dir
== 2) /* vert */
2467 self
->max_vert
= max
;
2469 client_change_state(self
); /* change the state hints on the client */
2471 client_setup_decor_and_functions(self
);
2473 client_move_resize(self
, x
, y
, w
, h
);
2476 void client_shade(ObClient
*self
, gboolean shade
)
2478 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
2479 shade
) || /* can't shade */
2480 self
->shaded
== shade
) return; /* already done */
2482 /* when we're iconic, don't change the wmstate */
2483 if (!self
->iconic
) {
2486 old
= self
->wmstate
;
2487 self
->wmstate
= shade
? IconicState
: NormalState
;
2488 if (old
!= self
->wmstate
)
2489 PROP_MSG(self
->window
, kde_wm_change_state
,
2490 self
->wmstate
, 1, 0, 0);
2493 self
->shaded
= shade
;
2494 client_change_state(self
);
2495 /* resize the frame to just the titlebar */
2496 frame_adjust_area(self
->frame
, FALSE
, FALSE
, FALSE
);
2499 void client_close(ObClient
*self
)
2503 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
2505 /* in the case that the client provides no means to requesting that it
2506 close, we just kill it */
2507 if (!self
->delete_window
)
2511 XXX: itd be cool to do timeouts and shit here for killing the client's
2513 like... if the window is around after 5 seconds, then the close button
2514 turns a nice red, and if this function is called again, the client is
2518 ce
.xclient
.type
= ClientMessage
;
2519 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2520 ce
.xclient
.display
= ob_display
;
2521 ce
.xclient
.window
= self
->window
;
2522 ce
.xclient
.format
= 32;
2523 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_delete_window
;
2524 ce
.xclient
.data
.l
[1] = event_curtime
;
2525 ce
.xclient
.data
.l
[2] = 0l;
2526 ce
.xclient
.data
.l
[3] = 0l;
2527 ce
.xclient
.data
.l
[4] = 0l;
2528 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2531 void client_kill(ObClient
*self
)
2533 XKillClient(ob_display
, self
->window
);
2536 void client_set_desktop_recursive(ObClient
*self
,
2537 guint target
, gboolean donthide
)
2542 if (target
!= self
->desktop
) {
2544 ob_debug("Setting desktop %u\n", target
+1);
2546 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
2548 /* remove from the old desktop(s) */
2549 focus_order_remove(self
);
2551 old
= self
->desktop
;
2552 self
->desktop
= target
;
2553 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
2554 /* the frame can display the current desktop state */
2555 frame_adjust_state(self
->frame
);
2556 /* 'move' the window to the new desktop */
2558 client_showhide(self
);
2559 /* raise if it was not already on the desktop */
2560 if (old
!= DESKTOP_ALL
)
2562 if (STRUT_EXISTS(self
->strut
))
2563 screen_update_areas();
2565 /* add to the new desktop(s) */
2566 if (config_focus_new
)
2567 focus_order_to_top(self
);
2569 focus_order_to_bottom(self
);
2572 /* move all transients */
2573 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2574 if (it
->data
!= self
) client_set_desktop_recursive(it
->data
,
2578 void client_set_desktop(ObClient
*self
, guint target
, gboolean donthide
)
2580 client_set_desktop_recursive(client_search_top_transient(self
),
2584 ObClient
*client_search_modal_child(ObClient
*self
)
2589 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2590 ObClient
*c
= it
->data
;
2591 if ((ret
= client_search_modal_child(c
))) return ret
;
2592 if (c
->modal
) return c
;
2597 gboolean
client_validate(ObClient
*self
)
2601 XSync(ob_display
, FALSE
); /* get all events on the server */
2603 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
) ||
2604 XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
2605 XPutBackEvent(ob_display
, &e
);
2612 void client_set_wm_state(ObClient
*self
, glong state
)
2614 if (state
== self
->wmstate
) return; /* no change */
2618 client_iconify(self
, TRUE
, TRUE
);
2621 client_iconify(self
, FALSE
, TRUE
);
2626 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
2628 gboolean shaded
= self
->shaded
;
2629 gboolean fullscreen
= self
->fullscreen
;
2630 gboolean undecorated
= self
->undecorated
;
2631 gboolean max_horz
= self
->max_horz
;
2632 gboolean max_vert
= self
->max_vert
;
2633 gboolean modal
= self
->modal
;
2634 gboolean iconic
= self
->iconic
;
2637 if (!(action
== prop_atoms
.net_wm_state_add
||
2638 action
== prop_atoms
.net_wm_state_remove
||
2639 action
== prop_atoms
.net_wm_state_toggle
))
2640 /* an invalid action was passed to the client message, ignore it */
2643 for (i
= 0; i
< 2; ++i
) {
2644 Atom state
= i
== 0 ? data1
: data2
;
2646 if (!state
) continue;
2648 /* if toggling, then pick whether we're adding or removing */
2649 if (action
== prop_atoms
.net_wm_state_toggle
) {
2650 if (state
== prop_atoms
.net_wm_state_modal
)
2651 action
= modal
? prop_atoms
.net_wm_state_remove
:
2652 prop_atoms
.net_wm_state_add
;
2653 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
2654 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
2655 prop_atoms
.net_wm_state_add
;
2656 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
2657 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
2658 prop_atoms
.net_wm_state_add
;
2659 else if (state
== prop_atoms
.net_wm_state_shaded
)
2660 action
= shaded
? prop_atoms
.net_wm_state_remove
:
2661 prop_atoms
.net_wm_state_add
;
2662 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
2663 action
= self
->skip_taskbar
?
2664 prop_atoms
.net_wm_state_remove
:
2665 prop_atoms
.net_wm_state_add
;
2666 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
2667 action
= self
->skip_pager
?
2668 prop_atoms
.net_wm_state_remove
:
2669 prop_atoms
.net_wm_state_add
;
2670 else if (state
== prop_atoms
.net_wm_state_hidden
)
2671 action
= self
->iconic
?
2672 prop_atoms
.net_wm_state_remove
:
2673 prop_atoms
.net_wm_state_add
;
2674 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
2675 action
= fullscreen
?
2676 prop_atoms
.net_wm_state_remove
:
2677 prop_atoms
.net_wm_state_add
;
2678 else if (state
== prop_atoms
.net_wm_state_above
)
2679 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
2680 prop_atoms
.net_wm_state_add
;
2681 else if (state
== prop_atoms
.net_wm_state_below
)
2682 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
2683 prop_atoms
.net_wm_state_add
;
2684 else if (state
== prop_atoms
.ob_wm_state_undecorated
)
2685 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
2686 prop_atoms
.net_wm_state_add
;
2689 if (action
== prop_atoms
.net_wm_state_add
) {
2690 if (state
== prop_atoms
.net_wm_state_modal
) {
2692 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2694 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2696 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2698 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2699 self
->skip_taskbar
= TRUE
;
2700 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2701 self
->skip_pager
= TRUE
;
2702 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
2704 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2706 } else if (state
== prop_atoms
.net_wm_state_above
) {
2708 self
->below
= FALSE
;
2709 } else if (state
== prop_atoms
.net_wm_state_below
) {
2710 self
->above
= FALSE
;
2712 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2716 } else { /* action == prop_atoms.net_wm_state_remove */
2717 if (state
== prop_atoms
.net_wm_state_modal
) {
2719 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2721 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2723 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2725 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2726 self
->skip_taskbar
= FALSE
;
2727 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2728 self
->skip_pager
= FALSE
;
2729 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
2731 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2733 } else if (state
== prop_atoms
.net_wm_state_above
) {
2734 self
->above
= FALSE
;
2735 } else if (state
== prop_atoms
.net_wm_state_below
) {
2736 self
->below
= FALSE
;
2737 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2738 undecorated
= FALSE
;
2742 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
2743 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
2745 if (max_horz
== max_vert
) { /* both going the same way */
2746 client_maximize(self
, max_horz
, 0, TRUE
);
2748 client_maximize(self
, max_horz
, 1, TRUE
);
2749 client_maximize(self
, max_vert
, 2, TRUE
);
2753 if (max_horz
!= self
->max_horz
)
2754 client_maximize(self
, max_horz
, 1, TRUE
);
2756 client_maximize(self
, max_vert
, 2, TRUE
);
2759 /* change fullscreen state before shading, as it will affect if the window
2761 if (fullscreen
!= self
->fullscreen
)
2762 client_fullscreen(self
, fullscreen
, TRUE
);
2763 if (shaded
!= self
->shaded
)
2764 client_shade(self
, shaded
);
2765 if (undecorated
!= self
->undecorated
)
2766 client_set_undecorated(self
, undecorated
);
2767 if (modal
!= self
->modal
) {
2768 self
->modal
= modal
;
2769 /* when a window changes modality, then its stacking order with its
2770 transients needs to change */
2773 if (iconic
!= self
->iconic
)
2774 client_iconify(self
, iconic
, FALSE
);
2776 client_calc_layer(self
);
2777 client_change_state(self
); /* change the hint to reflect these changes */
2780 ObClient
*client_focus_target(ObClient
*self
)
2784 /* if we have a modal child, then focus it, not us */
2785 child
= client_search_modal_child(client_search_top_transient(self
));
2786 if (child
) return child
;
2790 gboolean
client_can_focus(ObClient
*self
)
2794 /* choose the correct target */
2795 self
= client_focus_target(self
);
2797 if (!self
->frame
->visible
)
2800 if (!(self
->can_focus
|| self
->focus_notify
))
2803 /* do a check to see if the window has already been unmapped or destroyed
2804 do this intelligently while watching out for unmaps we've generated
2805 (ignore_unmaps > 0) */
2806 if (XCheckTypedWindowEvent(ob_display
, self
->window
,
2807 DestroyNotify
, &ev
)) {
2808 XPutBackEvent(ob_display
, &ev
);
2811 while (XCheckTypedWindowEvent(ob_display
, self
->window
,
2812 UnmapNotify
, &ev
)) {
2813 if (self
->ignore_unmaps
) {
2814 self
->ignore_unmaps
--;
2816 XPutBackEvent(ob_display
, &ev
);
2824 gboolean
client_focus(ObClient
*self
)
2826 /* choose the correct target */
2827 self
= client_focus_target(self
);
2829 if (!client_can_focus(self
)) {
2830 if (!self
->frame
->visible
) {
2831 /* update the focus lists */
2832 focus_order_to_top(self
);
2837 if (self
->can_focus
) {
2838 /* RevertToPointerRoot causes much more headache than RevertToNone, so
2839 I choose to use it always, hopefully to find errors quicker, if any
2840 are left. (I hate X. I hate focus events.)
2842 Update: Changing this to RevertToNone fixed a bug with mozilla (bug
2843 #799. So now it is RevertToNone again.
2845 XSetInputFocus(ob_display
, self
->window
, RevertToNone
,
2849 if (self
->focus_notify
) {
2851 ce
.xclient
.type
= ClientMessage
;
2852 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2853 ce
.xclient
.display
= ob_display
;
2854 ce
.xclient
.window
= self
->window
;
2855 ce
.xclient
.format
= 32;
2856 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
2857 ce
.xclient
.data
.l
[1] = event_curtime
;
2858 ce
.xclient
.data
.l
[2] = 0l;
2859 ce
.xclient
.data
.l
[3] = 0l;
2860 ce
.xclient
.data
.l
[4] = 0l;
2861 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2865 ob_debug("%sively focusing %lx at %d\n",
2866 (self
->can_focus
? "act" : "pass"),
2867 self
->window
, (gint
) event_curtime
);
2870 /* Cause the FocusIn to come back to us. Important for desktop switches,
2871 since otherwise we'll have no FocusIn on the queue and send it off to
2872 the focus_backup. */
2873 XSync(ob_display
, FALSE
);
2877 /* Used when the current client is closed, focus_last will then prevent
2878 * focus from going to the mouse pointer */
2879 void client_unfocus(ObClient
*self
)
2881 if (focus_client
== self
) {
2883 ob_debug("client_unfocus for %lx\n", self
->window
);
2885 focus_fallback(OB_FOCUS_FALLBACK_CLOSED
);
2889 void client_activate(ObClient
*self
, gboolean here
, gboolean user
)
2891 /* XXX do some stuff here if user is false to determine if we really want
2892 to activate it or not (a parent or group member is currently active) */
2894 if (client_normal(self
) && screen_showing_desktop
)
2895 screen_show_desktop(FALSE
);
2897 client_iconify(self
, FALSE
, here
);
2898 if (self
->desktop
!= DESKTOP_ALL
&&
2899 self
->desktop
!= screen_desktop
) {
2901 client_set_desktop(self
, screen_desktop
, FALSE
);
2903 screen_set_desktop(self
->desktop
);
2904 } else if (!self
->frame
->visible
)
2905 /* if its not visible for other reasons, then don't mess
2909 client_shade(self
, FALSE
);
2913 /* we do this an action here. this is rather important. this is because
2914 we want the results from the focus change to take place BEFORE we go
2915 about raising the window. when a fullscreen window loses focus, we need
2916 this or else the raise wont be able to raise above the to-lose-focus
2917 fullscreen window. */
2921 void client_raise(ObClient
*self
)
2923 action_run_string("Raise", self
);
2926 void client_lower(ObClient
*self
)
2928 action_run_string("Lower", self
);
2931 gboolean
client_focused(ObClient
*self
)
2933 return self
== focus_client
;
2936 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
2939 /* si is the smallest image >= req */
2940 /* li is the largest image < req */
2941 gulong size
, smallest
= 0xffffffff, largest
= 0, si
= 0, li
= 0;
2943 if (!self
->nicons
) {
2944 ObClientIcon
*parent
= NULL
;
2946 if (self
->transient_for
) {
2947 if (self
->transient_for
!= OB_TRAN_GROUP
)
2948 parent
= client_icon_recursive(self
->transient_for
, w
, h
);
2951 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
2952 ObClient
*c
= it
->data
;
2953 if (c
!= self
&& !c
->transient_for
) {
2954 if ((parent
= client_icon_recursive(c
, w
, h
)))
2964 for (i
= 0; i
< self
->nicons
; ++i
) {
2965 size
= self
->icons
[i
].width
* self
->icons
[i
].height
;
2966 if (size
< smallest
&& size
>= (unsigned)(w
* h
)) {
2970 if (size
> largest
&& size
<= (unsigned)(w
* h
)) {
2975 if (largest
== 0) /* didnt find one smaller than the requested size */
2976 return &self
->icons
[si
];
2977 return &self
->icons
[li
];
2980 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
2983 static ObClientIcon deficon
;
2985 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
2986 deficon
.width
= deficon
.height
= 48;
2987 deficon
.data
= ob_rr_theme
->def_win_icon
;
2993 /* this be mostly ripped from fvwm */
2994 ObClient
*client_find_directional(ObClient
*c
, ObDirection dir
)
2996 gint my_cx
, my_cy
, his_cx
, his_cy
;
2999 gint score
, best_score
;
3000 ObClient
*best_client
, *cur
;
3006 /* first, find the centre coords of the currently focused window */
3007 my_cx
= c
->frame
->area
.x
+ c
->frame
->area
.width
/ 2;
3008 my_cy
= c
->frame
->area
.y
+ c
->frame
->area
.height
/ 2;
3013 for(it
= g_list_first(client_list
); it
; it
= g_list_next(it
)) {
3016 /* the currently selected window isn't interesting */
3019 if (!client_normal(cur
))
3021 /* using c->desktop instead of screen_desktop doesn't work if the
3022 * current window was omnipresent, hope this doesn't have any other
3024 if(screen_desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
)
3028 if(!(client_focus_target(cur
) == cur
&&
3029 client_can_focus(cur
)))
3032 /* find the centre coords of this window, from the
3033 * currently focused window's point of view */
3034 his_cx
= (cur
->frame
->area
.x
- my_cx
)
3035 + cur
->frame
->area
.width
/ 2;
3036 his_cy
= (cur
->frame
->area
.y
- my_cy
)
3037 + cur
->frame
->area
.height
/ 2;
3039 if(dir
== OB_DIRECTION_NORTHEAST
|| dir
== OB_DIRECTION_SOUTHEAST
||
3040 dir
== OB_DIRECTION_SOUTHWEST
|| dir
== OB_DIRECTION_NORTHWEST
) {
3042 /* Rotate the diagonals 45 degrees counterclockwise.
3043 * To do this, multiply the matrix /+h +h\ with the
3044 * vector (x y). \-h +h/
3045 * h = sqrt(0.5). We can set h := 1 since absolute
3046 * distance doesn't matter here. */
3047 tx
= his_cx
+ his_cy
;
3048 his_cy
= -his_cx
+ his_cy
;
3053 case OB_DIRECTION_NORTH
:
3054 case OB_DIRECTION_SOUTH
:
3055 case OB_DIRECTION_NORTHEAST
:
3056 case OB_DIRECTION_SOUTHWEST
:
3057 offset
= (his_cx
< 0) ? -his_cx
: his_cx
;
3058 distance
= ((dir
== OB_DIRECTION_NORTH
||
3059 dir
== OB_DIRECTION_NORTHEAST
) ?
3062 case OB_DIRECTION_EAST
:
3063 case OB_DIRECTION_WEST
:
3064 case OB_DIRECTION_SOUTHEAST
:
3065 case OB_DIRECTION_NORTHWEST
:
3066 offset
= (his_cy
< 0) ? -his_cy
: his_cy
;
3067 distance
= ((dir
== OB_DIRECTION_WEST
||
3068 dir
== OB_DIRECTION_NORTHWEST
) ?
3073 /* the target must be in the requested direction */
3077 /* Calculate score for this window. The smaller the better. */
3078 score
= distance
+ offset
;
3080 /* windows more than 45 degrees off the direction are
3081 * heavily penalized and will only be chosen if nothing
3082 * else within a million pixels */
3083 if(offset
> distance
)
3086 if(best_score
== -1 || score
< best_score
)
3094 void client_set_layer(ObClient
*self
, gint layer
)
3098 self
->above
= FALSE
;
3099 } else if (layer
== 0) {
3100 self
->below
= self
->above
= FALSE
;
3102 self
->below
= FALSE
;
3105 client_calc_layer(self
);
3106 client_change_state(self
); /* reflect this in the state hints */
3109 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
3111 if (self
->undecorated
!= undecorated
) {
3112 self
->undecorated
= undecorated
;
3113 client_setup_decor_and_functions(self
);
3114 /* Make sure the client knows it might have moved. Maybe there is a
3115 * better way of doing this so only one client_configure is sent, but
3116 * since 125 of these are sent per second when moving the window (with
3117 * user = FALSE) i doubt it matters much.
3119 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
3120 self
->area
.width
, self
->area
.height
, TRUE
, TRUE
);
3121 client_change_state(self
); /* reflect this in the state hints */
3125 /* Determines which physical monitor a client is on by calculating the
3126 area of the part of the client on each monitor. The number of the
3127 monitor containing the greatest area of the client is returned.*/
3128 guint
client_monitor(ObClient
*self
)
3134 for (i
= 0; i
< screen_num_monitors
; ++i
) {
3135 Rect
*area
= screen_physical_area_monitor(i
);
3136 if (RECT_INTERSECTS_RECT(*area
, self
->frame
->area
)) {
3140 RECT_SET_INTERSECTION(r
, *area
, self
->frame
->area
);
3141 v
= r
.width
* r
.height
;
3152 ObClient
*client_search_top_transient(ObClient
*self
)
3154 /* move up the transient chain as far as possible */
3155 if (self
->transient_for
) {
3156 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3157 return client_search_top_transient(self
->transient_for
);
3161 g_assert(self
->group
);
3163 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3164 ObClient
*c
= it
->data
;
3166 /* checking transient_for prevents infinate loops! */
3167 if (c
!= self
&& !c
->transient_for
)
3178 ObClient
*client_search_focus_parent(ObClient
*self
)
3180 if (self
->transient_for
) {
3181 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3182 if (client_focused(self
->transient_for
))
3183 return self
->transient_for
;
3187 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3188 ObClient
*c
= it
->data
;
3190 /* checking transient_for prevents infinate loops! */
3191 if (c
!= self
&& !c
->transient_for
)
3192 if (client_focused(c
))
3201 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3203 if (self
->transient_for
) {
3204 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3205 if (self
->transient_for
== search
)
3210 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3211 ObClient
*c
= it
->data
;
3213 /* checking transient_for prevents infinate loops! */
3214 if (c
!= self
&& !c
->transient_for
)
3224 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3228 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3229 if (sit
->data
== search
)
3231 if (client_search_transient(sit
->data
, search
))
3237 void client_update_sm_client_id(ObClient
*self
)
3239 g_free(self
->sm_client_id
);
3240 self
->sm_client_id
= NULL
;
3242 if (!PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
) &&
3244 PROP_GETS(self
->group
->leader
, sm_client_id
, locale
,
3245 &self
->sm_client_id
);
3248 #define WANT_EDGE(cur, c) \
3251 if(!client_normal(cur)) \
3253 if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL) \
3257 if(cur->layer < c->layer && !config_resist_layers_below) \
3260 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3261 if ((his_edge_start >= my_edge_start && \
3262 his_edge_start <= my_edge_end) || \
3263 (my_edge_start >= his_edge_start && \
3264 my_edge_start <= his_edge_end)) \
3267 /* finds the nearest edge in the given direction from the current client
3268 * note to self: the edge is the -frame- edge (the actual one), not the
3271 gint
client_directional_edge_search(ObClient
*c
, ObDirection dir
, gboolean hang
)
3273 gint dest
, monitor_dest
;
3274 gint my_edge_start
, my_edge_end
, my_offset
;
3281 a
= screen_area(c
->desktop
);
3282 monitor
= screen_area_monitor(c
->desktop
, client_monitor(c
));
3285 case OB_DIRECTION_NORTH
:
3286 my_edge_start
= c
->frame
->area
.x
;
3287 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3288 my_offset
= c
->frame
->area
.y
+ (hang
? c
->frame
->area
.height
: 0);
3290 /* default: top of screen */
3291 dest
= a
->y
+ (hang
? c
->frame
->area
.height
: 0);
3292 monitor_dest
= monitor
->y
+ (hang
? c
->frame
->area
.height
: 0);
3293 /* if the monitor edge comes before the screen edge, */
3294 /* use that as the destination instead. (For xinerama) */
3295 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3296 dest
= monitor_dest
;
3298 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3299 gint his_edge_start
, his_edge_end
, his_offset
;
3300 ObClient
*cur
= it
->data
;
3304 his_edge_start
= cur
->frame
->area
.x
;
3305 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3306 his_offset
= cur
->frame
->area
.y
+
3307 (hang
? 0 : cur
->frame
->area
.height
);
3309 if(his_offset
+ 1 > my_offset
)
3312 if(his_offset
< dest
)
3315 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3318 case OB_DIRECTION_SOUTH
:
3319 my_edge_start
= c
->frame
->area
.x
;
3320 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3321 my_offset
= c
->frame
->area
.y
+ (hang
? 0 : c
->frame
->area
.height
);
3323 /* default: bottom of screen */
3324 dest
= a
->y
+ a
->height
- (hang
? c
->frame
->area
.height
: 0);
3325 monitor_dest
= monitor
->y
+ monitor
->height
-
3326 (hang
? c
->frame
->area
.height
: 0);
3327 /* if the monitor edge comes before the screen edge, */
3328 /* use that as the destination instead. (For xinerama) */
3329 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3330 dest
= monitor_dest
;
3332 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3333 gint his_edge_start
, his_edge_end
, his_offset
;
3334 ObClient
*cur
= it
->data
;
3338 his_edge_start
= cur
->frame
->area
.x
;
3339 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3340 his_offset
= cur
->frame
->area
.y
+
3341 (hang
? cur
->frame
->area
.height
: 0);
3344 if(his_offset
- 1 < my_offset
)
3347 if(his_offset
> dest
)
3350 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3353 case OB_DIRECTION_WEST
:
3354 my_edge_start
= c
->frame
->area
.y
;
3355 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3356 my_offset
= c
->frame
->area
.x
+ (hang
? c
->frame
->area
.width
: 0);
3358 /* default: leftmost egde of screen */
3359 dest
= a
->x
+ (hang
? c
->frame
->area
.width
: 0);
3360 monitor_dest
= monitor
->x
+ (hang
? c
->frame
->area
.width
: 0);
3361 /* if the monitor edge comes before the screen edge, */
3362 /* use that as the destination instead. (For xinerama) */
3363 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3364 dest
= monitor_dest
;
3366 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3367 gint his_edge_start
, his_edge_end
, his_offset
;
3368 ObClient
*cur
= it
->data
;
3372 his_edge_start
= cur
->frame
->area
.y
;
3373 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3374 his_offset
= cur
->frame
->area
.x
+
3375 (hang
? 0 : cur
->frame
->area
.width
);
3377 if(his_offset
+ 1 > my_offset
)
3380 if(his_offset
< dest
)
3383 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3386 case OB_DIRECTION_EAST
:
3387 my_edge_start
= c
->frame
->area
.y
;
3388 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3389 my_offset
= c
->frame
->area
.x
+ (hang
? 0 : c
->frame
->area
.width
);
3391 /* default: rightmost edge of screen */
3392 dest
= a
->x
+ a
->width
- (hang
? c
->frame
->area
.width
: 0);
3393 monitor_dest
= monitor
->x
+ monitor
->width
-
3394 (hang
? c
->frame
->area
.width
: 0);
3395 /* if the monitor edge comes before the screen edge, */
3396 /* use that as the destination instead. (For xinerama) */
3397 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3398 dest
= monitor_dest
;
3400 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3401 gint his_edge_start
, his_edge_end
, his_offset
;
3402 ObClient
*cur
= it
->data
;
3406 his_edge_start
= cur
->frame
->area
.y
;
3407 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3408 his_offset
= cur
->frame
->area
.x
+
3409 (hang
? cur
->frame
->area
.width
: 0);
3411 if(his_offset
- 1 < my_offset
)
3414 if(his_offset
> dest
)
3417 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3420 case OB_DIRECTION_NORTHEAST
:
3421 case OB_DIRECTION_SOUTHEAST
:
3422 case OB_DIRECTION_NORTHWEST
:
3423 case OB_DIRECTION_SOUTHWEST
:
3424 /* not implemented */
3426 g_assert_not_reached();
3427 dest
= 0; /* suppress warning */
3432 ObClient
* client_under_pointer()
3436 ObClient
*ret
= NULL
;
3438 if (screen_pointer_pos(&x
, &y
)) {
3439 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
3440 if (WINDOW_IS_CLIENT(it
->data
)) {
3441 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
3442 if (c
->frame
->visible
&&
3443 RECT_CONTAINS(c
->frame
->area
, x
, y
)) {
3453 gboolean
client_has_group_siblings(ObClient
*self
)
3455 return self
->group
&& self
->group
->members
->next
;