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-2007 Dana 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"
49 #include <X11/Xutil.h>
51 /*! The event mask to grab on client windows */
52 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
55 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
60 ObClientDestructor func
;
64 GList
*client_list
= NULL
;
66 static GSList
*client_destructors
= NULL
;
68 static void client_get_all(ObClient
*self
);
69 static void client_toggle_border(ObClient
*self
, gboolean show
);
70 static void client_get_startup_id(ObClient
*self
);
71 static void client_get_area(ObClient
*self
);
72 static void client_get_desktop(ObClient
*self
);
73 static void client_get_state(ObClient
*self
);
74 static void client_get_layer(ObClient
*self
);
75 static void client_get_shaped(ObClient
*self
);
76 static void client_get_mwm_hints(ObClient
*self
);
77 static void client_get_gravity(ObClient
*self
);
78 static void client_get_client_machine(ObClient
*self
);
79 static void client_get_colormap(ObClient
*self
);
80 static void client_change_allowed_actions(ObClient
*self
);
81 static void client_change_state(ObClient
*self
);
82 static void client_change_wm_state(ObClient
*self
);
83 static void client_apply_startup_state(ObClient
*self
, gint x
, gint y
);
84 static void client_restore_session_state(ObClient
*self
);
85 static void client_restore_session_stacking(ObClient
*self
);
86 static ObAppSettings
*client_get_settings_state(ObClient
*self
);
88 void client_startup(gboolean reconfig
)
95 void client_shutdown(gboolean reconfig
)
99 void client_add_destructor(ObClientDestructor func
, gpointer data
)
101 Destructor
*d
= g_new(Destructor
, 1);
104 client_destructors
= g_slist_prepend(client_destructors
, d
);
107 void client_remove_destructor(ObClientDestructor func
)
111 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
112 Destructor
*d
= it
->data
;
113 if (d
->func
== func
) {
115 client_destructors
= g_slist_delete_link(client_destructors
, it
);
121 void client_set_list()
123 Window
*windows
, *win_it
;
125 guint size
= g_list_length(client_list
);
127 /* create an array of the window ids */
129 windows
= g_new(Window
, size
);
131 for (it
= client_list
; it
; it
= g_list_next(it
), ++win_it
)
132 *win_it
= ((ObClient
*)it
->data
)->window
;
136 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
137 net_client_list
, window
, (gulong
*)windows
, size
);
146 void client_foreach_transient(ObClient *self, ObClientForeachFunc func, gpointer data)
150 for (it = self->transients; it; it = g_slist_next(it)) {
151 if (!func(it->data, data)) return;
152 client_foreach_transient(it->data, func, data);
156 void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, gpointer data)
158 if (self->transient_for) {
159 if (self->transient_for != OB_TRAN_GROUP) {
160 if (!func(self->transient_for, data)) return;
161 client_foreach_ancestor(self->transient_for, func, data);
165 for (it = self->group->members; it; it = g_slist_next(it))
166 if (it->data != self &&
167 !((ObClient*)it->data)->transient_for) {
168 if (!func(it->data, data)) return;
169 client_foreach_ancestor(it->data, func, data);
176 void client_manage_all()
181 XWindowAttributes attrib
;
183 XQueryTree(ob_display
, RootWindow(ob_display
, ob_screen
),
184 &w
, &w
, &children
, &nchild
);
186 /* remove all icon windows from the list */
187 for (i
= 0; i
< nchild
; i
++) {
188 if (children
[i
] == None
) continue;
189 wmhints
= XGetWMHints(ob_display
, children
[i
]);
191 if ((wmhints
->flags
& IconWindowHint
) &&
192 (wmhints
->icon_window
!= children
[i
]))
193 for (j
= 0; j
< nchild
; j
++)
194 if (children
[j
] == wmhints
->icon_window
) {
202 for (i
= 0; i
< nchild
; ++i
) {
203 if (children
[i
] == None
)
205 if (XGetWindowAttributes(ob_display
, children
[i
], &attrib
)) {
206 if (attrib
.override_redirect
) continue;
208 if (attrib
.map_state
!= IsUnmapped
)
209 client_manage(children
[i
]);
215 void client_manage(Window window
)
219 XWindowAttributes attrib
;
220 XSetWindowAttributes attrib_set
;
222 gboolean activate
= FALSE
;
223 ObAppSettings
*settings
;
228 /* check if it has already been unmapped by the time we started mapping.
229 the grab does a sync so we don't have to here */
230 if (XCheckTypedWindowEvent(ob_display
, window
, DestroyNotify
, &e
) ||
231 XCheckTypedWindowEvent(ob_display
, window
, UnmapNotify
, &e
))
233 XPutBackEvent(ob_display
, &e
);
235 ob_debug("Trying to manage unmapped window. Aborting that.\n");
237 return; /* don't manage it */
240 /* make sure it isn't an override-redirect window */
241 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
242 attrib
.override_redirect
)
245 return; /* don't manage it */
248 /* is the window a docking app */
249 if ((wmhint
= XGetWMHints(ob_display
, window
))) {
250 if ((wmhint
->flags
& StateHint
) &&
251 wmhint
->initial_state
== WithdrawnState
)
253 dock_add(window
, wmhint
);
261 ob_debug("Managing window: %lx\n", window
);
263 /* choose the events we want to receive on the CLIENT window */
264 attrib_set
.event_mask
= CLIENT_EVENTMASK
;
265 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
266 XChangeWindowAttributes(ob_display
, window
,
267 CWEventMask
|CWDontPropagate
, &attrib_set
);
270 /* create the ObClient struct, and populate it from the hints on the
272 self
= g_new0(ObClient
, 1);
273 self
->obwin
.type
= Window_Client
;
274 self
->window
= window
;
276 /* non-zero defaults */
277 self
->wmstate
= WithdrawnState
; /* make sure it gets updated first time */
279 self
->desktop
= screen_num_desktops
; /* always an invalid value */
280 self
->user_time
= CurrentTime
;
282 client_get_all(self
);
283 /* per-app settings override stuff, and return the settings for other
285 settings
= client_get_settings_state(self
);
286 /* the session should get the last say */
287 client_restore_session_state(self
);
289 client_calc_layer(self
);
292 Time t
= sn_app_started(self
->startup_id
, self
->class);
293 if (t
) self
->user_time
= t
;
296 /* update the focus lists, do this before the call to change_state or
297 it can end up in the list twice! */
298 focus_order_add_new(self
);
300 /* remove the client's border (and adjust re gravity) */
301 client_toggle_border(self
, FALSE
);
303 /* specify that if we exit, the window should not be destroyed and should
304 be reparented back to root automatically */
305 XChangeSaveSet(ob_display
, window
, SetModeInsert
);
307 /* create the decoration frame for the client window */
308 self
->frame
= frame_new(self
);
310 frame_grab_client(self
->frame
, self
);
312 /* do this after we have a frame.. it uses the frame to help determine the
313 WM_STATE to apply. */
314 client_change_state(self
);
318 stacking_add_nonintrusive(CLIENT_AS_WINDOW(self
));
319 client_restore_session_stacking(self
);
321 /* focus the new window? */
322 if (ob_state() != OB_STATE_STARTING
&&
323 /* this means focus=true for window is same as config_focus_new=true */
324 ((config_focus_new
|| (settings
&& settings
->focus
== 1)) ||
325 client_search_focus_parent(self
)) &&
326 /* this checks for focus=false for the window */
327 (!settings
|| settings
->focus
!= 0) &&
328 /* note the check against Type_Normal/Dialog, not client_normal(self),
329 which would also include other types. in this case we want more
330 strict rules for focus */
331 (self
->type
== OB_CLIENT_TYPE_NORMAL
||
332 self
->type
== OB_CLIENT_TYPE_DIALOG
))
336 if (self
->desktop
!= screen_desktop
) {
337 /* activate the window */
340 gboolean group_foc
= FALSE
;
345 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
347 if (client_focused(it
->data
))
355 (!self
->transient_for
&& (!self
->group
||
356 !self
->group
->members
->next
))) ||
357 client_search_focus_tree_full(self
) ||
359 !client_normal(focus_client
))
361 /* activate the window */
368 /* get the current position */
372 /* figure out placement for the window */
373 if (ob_state() == OB_STATE_RUNNING
) {
376 transient
= place_client(self
, &newx
, &newy
, settings
);
378 /* make sure the window is visible. */
379 client_find_onscreen(self
, &newx
, &newy
,
380 self
->frame
->area
.width
,
381 self
->frame
->area
.height
,
382 /* non-normal clients has less rules, and
383 windows that are being restored from a
384 session do also. we can assume you want
385 it back where you saved it. Clients saying
386 they placed themselves are subjected to
387 harder rules, ones that are placed by
388 place.c or by the user are allowed partially
389 off-screen and on xinerama divides (ie,
390 it is up to the placement routines to avoid
391 the xinerama divides) */
393 (((self
->positioned
& PPosition
) &&
394 !(self
->positioned
& USPosition
)) &&
395 client_normal(self
) &&
399 /* do this after the window is placed, so the premax/prefullscreen numbers
401 also, this moves the window to the position where it has been placed
403 ob_debug("placing window 0x%x at %d, %d with size %d x %d\n",
404 self
->window
, newx
, newy
, self
->area
.width
, self
->area
.height
);
405 client_apply_startup_state(self
, newx
, newy
);
407 keyboard_grab_for_client(self
, TRUE
);
408 mouse_grab_for_client(self
, TRUE
);
411 guint32 last_time
= focus_client
?
412 focus_client
->user_time
: CurrentTime
;
414 /* This is focus stealing prevention */
415 ob_debug("Want to focus new window 0x%x with time %u (last time %u)\n",
416 self
->window
, self
->user_time
, last_time
);
418 /* If a nothing at all, or a parent was focused, then focus this
421 if (!focus_client
|| client_search_focus_parent(self
) != NULL
)
425 /* If time stamp is old, don't steal focus */
426 if (self
->user_time
&& last_time
&&
427 !event_time_after(self
->user_time
, last_time
))
431 /* Don't steal focus from globally active clients.
432 I stole this idea from KWin. It seems nice.
434 if (!(focus_client
->can_focus
|| focus_client
->focus_notify
))
440 /* since focus can change the stacking orders, if we focus the
441 window then the standard raise it gets is not enough, we need
442 to queue one for after the focus change takes place */
445 ob_debug("Focus stealing prevention activated for %s with time %u "
447 self
->title
, self
->user_time
, last_time
);
448 /* if the client isn't focused, then hilite it so the user
450 client_hilite(self
, TRUE
);
454 /* This may look rather odd. Well it's because new windows are added
455 to the stacking order non-intrusively. If we're not going to focus
456 the new window or hilite it, then we raise it to the top. This will
457 take affect for things that don't get focused like splash screens.
458 Also if you don't have focus_new enabled, then it's going to get
459 raised to the top. Legacy begets legacy I guess?
464 /* this has to happen before we try focus the window, but we want it to
465 happen after the client's stacking has been determined or it looks bad
469 /* use client_focus instead of client_activate cuz client_activate does
470 stuff like switch desktops etc and I'm not interested in all that when
471 a window maps since its not based on an action from the user like
472 clicking a window to activate it. so keep the new window out of the way
475 /* if using focus_delay, stop the timer now so that focus doesn't
477 event_halt_focus_delay();
481 /* client_activate does this but we aren't using it so we have to do it
483 if (screen_showing_desktop
)
484 screen_show_desktop(FALSE
);
486 /* add to client list/map */
487 client_list
= g_list_append(client_list
, self
);
488 g_hash_table_insert(window_map
, &self
->window
, self
);
490 /* this has to happen after we're in the client_list */
491 if (STRUT_EXISTS(self
->strut
))
492 screen_update_areas();
494 /* update the list hints */
497 ob_debug("Managed window 0x%lx (%s)\n", window
, self
->class);
500 void client_unmanage_all()
502 while (client_list
!= NULL
)
503 client_unmanage(client_list
->data
);
506 void client_unmanage(ObClient
*self
)
511 ob_debug("Unmanaging window: %lx (%s) (%s)\n", self
->window
, self
->class,
512 self
->title
? self
->title
: "");
514 g_assert(self
!= NULL
);
516 /* we dont want events no more. do this before hiding the frame so we
517 don't generate more events */
518 XSelectInput(ob_display
, self
->window
, NoEventMask
);
520 frame_hide(self
->frame
);
521 /* flush to send the hide to the server quickly */
524 if (focus_client
== self
) {
525 /* ignore enter events from the unmap so it doesnt mess with the focus
527 event_ignore_queued_enters();
530 keyboard_grab_for_client(self
, FALSE
);
531 mouse_grab_for_client(self
, FALSE
);
533 /* remove the window from our save set */
534 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
536 /* update the focus lists */
537 focus_order_remove(self
);
539 client_list
= g_list_remove(client_list
, self
);
540 stacking_remove(self
);
541 g_hash_table_remove(window_map
, &self
->window
);
543 /* once the client is out of the list, update the struts to remove its
545 if (STRUT_EXISTS(self
->strut
))
546 screen_update_areas();
548 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
549 Destructor
*d
= it
->data
;
550 d
->func(self
, d
->data
);
553 /* tell our parent(s) that we're gone */
554 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
555 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
556 if (it
->data
!= self
)
557 ((ObClient
*)it
->data
)->transients
=
558 g_slist_remove(((ObClient
*)it
->data
)->transients
, self
);
559 } else if (self
->transient_for
) { /* transient of window */
560 self
->transient_for
->transients
=
561 g_slist_remove(self
->transient_for
->transients
, self
);
564 /* tell our transients that we're gone */
565 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
566 if (((ObClient
*)it
->data
)->transient_for
!= OB_TRAN_GROUP
) {
567 ((ObClient
*)it
->data
)->transient_for
= NULL
;
568 client_calc_layer(it
->data
);
572 /* remove from its group */
574 group_remove(self
->group
, self
);
578 /* restore the window's original geometry so it is not lost */
582 if (self
->fullscreen
)
583 a
= self
->pre_fullscreen_area
;
584 else if (self
->max_horz
|| self
->max_vert
) {
585 if (self
->max_horz
) {
586 a
.x
= self
->pre_max_area
.x
;
587 a
.width
= self
->pre_max_area
.width
;
589 if (self
->max_vert
) {
590 a
.y
= self
->pre_max_area
.y
;
591 a
.height
= self
->pre_max_area
.height
;
595 /* give the client its border back */
596 client_toggle_border(self
, TRUE
);
598 self
->fullscreen
= self
->max_horz
= self
->max_vert
= FALSE
;
599 self
->decorations
= 0; /* unmanaged windows have no decor */
601 client_move_resize(self
, a
.x
, a
.y
, a
.width
, a
.height
);
604 /* reparent the window out of the frame, and free the frame */
605 frame_release_client(self
->frame
, self
);
608 if (ob_state() != OB_STATE_EXITING
) {
609 /* these values should not be persisted across a window
611 PROP_ERASE(self
->window
, net_wm_desktop
);
612 PROP_ERASE(self
->window
, net_wm_state
);
613 PROP_ERASE(self
->window
, wm_state
);
615 /* if we're left in an unmapped state, the client wont be mapped. this
616 is bad, since we will no longer be managing the window on restart */
617 XMapWindow(ob_display
, self
->window
);
620 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
622 /* free all data allocated in the client struct */
623 g_slist_free(self
->transients
);
624 for (j
= 0; j
< self
->nicons
; ++j
)
625 g_free(self
->icons
[j
].data
);
626 if (self
->nicons
> 0)
629 g_free(self
->icon_title
);
633 g_free(self
->client_machine
);
634 g_free(self
->sm_client_id
);
637 /* update the list hints */
641 static ObAppSettings
*client_get_settings_state(ObClient
*self
)
643 ObAppSettings
*settings
= NULL
;
646 for (it
= config_per_app_settings
; it
; it
= g_slist_next(it
)) {
647 ObAppSettings
*app
= it
->data
;
649 if ((app
->name
&& !app
->class && !strcmp(app
->name
, self
->name
))
650 || (app
->class && !app
->name
&& !strcmp(app
->class, self
->class))
651 || (app
->class && app
->name
&& !strcmp(app
->class, self
->class)
652 && !strcmp(app
->name
, self
->name
)))
654 ob_debug("Window matching: %s\n", app
->name
);
655 /* Match if no role was specified in the per app setting, or if the
656 * string matches the beginning of the role, since apps like to set
657 * the role to things like browser-window-23c4b2f */
659 || !strncmp(app
->role
, self
->role
, strlen(app
->role
)))
669 if (settings
->shade
!= -1)
670 self
->shaded
= !!settings
->shade
;
671 if (settings
->decor
!= -1)
672 self
->undecorated
= !settings
->decor
;
673 if (settings
->iconic
!= -1)
674 self
->iconic
= !!settings
->iconic
;
675 if (settings
->skip_pager
!= -1)
676 self
->skip_pager
= !!settings
->skip_pager
;
677 if (settings
->skip_taskbar
!= -1)
678 self
->skip_taskbar
= !!settings
->skip_taskbar
;
680 if (settings
->max_vert
!= -1)
681 self
->max_vert
= !!settings
->max_vert
;
682 if (settings
->max_horz
!= -1)
683 self
->max_vert
= !!settings
->max_horz
;
685 if (settings
->fullscreen
!= -1)
686 self
->fullscreen
= !!settings
->fullscreen
;
688 if (settings
->desktop
< screen_num_desktops
689 || settings
->desktop
== DESKTOP_ALL
)
690 self
->desktop
= settings
->desktop
;
692 if (settings
->layer
== -1) {
696 else if (settings
->layer
== 0) {
700 else if (settings
->layer
== 1) {
708 static void client_restore_session_state(ObClient
*self
)
712 if (!(it
= session_state_find(self
)))
715 self
->session
= it
->data
;
717 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
718 self
->positioned
= PPosition
;
719 if (self
->session
->w
> 0)
720 self
->area
.width
= self
->session
->w
;
721 if (self
->session
->h
> 0)
722 self
->area
.height
= self
->session
->h
;
723 XResizeWindow(ob_display
, self
->window
,
724 self
->area
.width
, self
->area
.height
);
726 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
727 self
->session
->desktop
:
728 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
729 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
731 self
->shaded
= self
->session
->shaded
;
732 self
->iconic
= self
->session
->iconic
;
733 self
->skip_pager
= self
->session
->skip_pager
;
734 self
->skip_taskbar
= self
->session
->skip_taskbar
;
735 self
->fullscreen
= self
->session
->fullscreen
;
736 self
->above
= self
->session
->above
;
737 self
->below
= self
->session
->below
;
738 self
->max_horz
= self
->session
->max_horz
;
739 self
->max_vert
= self
->session
->max_vert
;
742 static void client_restore_session_stacking(ObClient
*self
)
746 if (!self
->session
) return;
748 it
= g_list_find(session_saved_state
, self
->session
);
749 for (it
= g_list_previous(it
); it
; it
= g_list_previous(it
)) {
752 for (cit
= client_list
; cit
; cit
= g_list_next(cit
))
753 if (session_state_cmp(it
->data
, cit
->data
))
756 client_calc_layer(self
);
757 stacking_below(CLIENT_AS_WINDOW(self
),
758 CLIENT_AS_WINDOW(cit
->data
));
764 void client_move_onscreen(ObClient
*self
, gboolean rude
)
766 gint x
= self
->area
.x
;
767 gint y
= self
->area
.y
;
768 if (client_find_onscreen(self
, &x
, &y
,
769 self
->frame
->area
.width
,
770 self
->frame
->area
.height
, rude
)) {
771 client_move(self
, x
, y
);
775 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
779 gint ox
= *x
, oy
= *y
;
781 frame_client_gravity(self
->frame
, x
, y
); /* get where the frame
784 /* XXX watch for xinerama dead areas */
785 /* This makes sure windows aren't entirely outside of the screen so you
786 can't see them at all.
787 It makes sure 10% of the window is on the screen at least. At don't let
788 it move itself off the top of the screen, which would hide the titlebar
789 on you. (The user can still do this if they want too, it's only limiting
792 if (client_normal(self
)) {
793 a
= screen_area(self
->desktop
);
794 if (!self
->strut
.right
&&
795 *x
+ self
->frame
->area
.width
/10 >= a
->x
+ a
->width
- 1)
796 *x
= a
->x
+ a
->width
- self
->frame
->area
.width
/10;
797 if (!self
->strut
.bottom
&&
798 *y
+ self
->frame
->area
.height
/10 >= a
->y
+ a
->height
- 1)
799 *y
= a
->y
+ a
->height
- self
->frame
->area
.height
/10;
800 if (!self
->strut
.left
&& *x
+ self
->frame
->area
.width
*9/10 - 1 < a
->x
)
801 *x
= a
->x
- self
->frame
->area
.width
*9/10;
802 if (!self
->strut
.top
&& *y
+ self
->frame
->area
.height
*9/10 - 1 < a
->y
)
803 *y
= a
->y
- self
->frame
->area
.width
*9/10;
806 /* This here doesn't let windows even a pixel outside the screen,
807 * when called from client_manage, programs placing themselves are
808 * forced completely onscreen, while things like
809 * xterm -geometry resolution-width/2 will work fine. Trying to
810 * place it completely offscreen will be handled in the above code.
811 * Sorry for this confused comment, i am tired. */
813 /* avoid the xinerama monitor divide while we're at it,
814 * remember to fix the placement stuff to avoid it also and
815 * then remove this XXX */
816 a
= screen_area_monitor(self
->desktop
, client_monitor(self
));
817 /* dont let windows map into the strut unless they
818 are bigger than the available area */
820 if (!self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
821 if (!self
->strut
.right
&& *x
+ w
> a
->x
+ a
->width
)
822 *x
= a
->x
+ a
->width
- w
;
824 if (h
<= a
->height
) {
825 if (!self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
826 if (!self
->strut
.bottom
&& *y
+ h
> a
->y
+ a
->height
)
827 *y
= a
->y
+ a
->height
- h
;
831 frame_frame_gravity(self
->frame
, x
, y
); /* get where the client
834 return ox
!= *x
|| oy
!= *y
;
837 static void client_toggle_border(ObClient
*self
, gboolean show
)
839 /* adjust our idea of where the client is, based on its border. When the
840 border is removed, the client should now be considered to be in a
842 when re-adding the border to the client, the same operation needs to be
844 gint oldx
= self
->area
.x
, oldy
= self
->area
.y
;
845 gint x
= oldx
, y
= oldy
;
846 switch(self
->gravity
) {
848 case NorthWestGravity
:
850 case SouthWestGravity
:
852 case NorthEastGravity
:
854 case SouthEastGravity
:
855 if (show
) x
-= self
->border_width
* 2;
856 else x
+= self
->border_width
* 2;
863 if (show
) x
-= self
->border_width
;
864 else x
+= self
->border_width
;
867 switch(self
->gravity
) {
869 case NorthWestGravity
:
871 case NorthEastGravity
:
873 case SouthWestGravity
:
875 case SouthEastGravity
:
876 if (show
) y
-= self
->border_width
* 2;
877 else y
+= self
->border_width
* 2;
884 if (show
) y
-= self
->border_width
;
885 else y
+= self
->border_width
;
892 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
894 /* set border_width to 0 because there is no border to add into
895 calculations anymore */
896 self
->border_width
= 0;
898 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
902 static void client_get_all(ObClient
*self
)
904 client_get_area(self
);
905 client_get_mwm_hints(self
);
907 /* The transient hint is used to pick a type, but the type can also affect
908 transiency (dialogs are always made transients of their group if they
909 have one). This is Havoc's idea, but it is needed to make some apps
910 work right (eg tsclient). */
911 client_update_transient_for(self
);
912 client_get_type(self
);/* this can change the mwmhints for special cases */
913 client_get_state(self
);
914 client_update_transient_for(self
);
916 client_update_wmhints(self
);
917 client_get_startup_id(self
);
918 client_get_desktop(self
);/* uses transient data/group/startup id if a
919 desktop is not specified */
920 client_get_shaped(self
);
922 client_get_layer(self
); /* if layer hasn't been specified, get it from
923 other sources if possible */
926 /* a couple type-based defaults for new windows */
928 /* this makes sure that these windows appear on all desktops */
929 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
930 self
->desktop
= DESKTOP_ALL
;
933 client_update_protocols(self
);
935 client_get_gravity(self
); /* get the attribute gravity */
936 client_update_normal_hints(self
); /* this may override the attribute
939 /* got the type, the mwmhints, the protocols, and the normal hints
940 (min/max sizes), so we're ready to set up the decorations/functions */
941 client_setup_decor_and_functions(self
);
943 client_get_client_machine(self
);
944 client_get_colormap(self
);
945 client_update_title(self
);
946 client_update_class(self
);
947 client_update_sm_client_id(self
);
948 client_update_strut(self
);
949 client_update_icons(self
);
950 client_update_user_time(self
);
953 static void client_get_startup_id(ObClient
*self
)
955 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
957 PROP_GETS(self
->group
->leader
,
958 net_startup_id
, utf8
, &self
->startup_id
);
961 static void client_get_area(ObClient
*self
)
963 XWindowAttributes wattrib
;
966 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
967 g_assert(ret
!= BadWindow
);
969 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
970 POINT_SET(self
->root_pos
, wattrib
.x
, wattrib
.y
);
971 self
->border_width
= wattrib
.border_width
;
973 ob_debug("client area: %d %d %d %d\n", wattrib
.x
, wattrib
.y
,
974 wattrib
.width
, wattrib
.height
);
977 static void client_get_desktop(ObClient
*self
)
979 guint32 d
= screen_num_desktops
; /* an always-invalid value */
981 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
982 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
983 self
->desktop
= screen_num_desktops
- 1;
987 gboolean trdesk
= FALSE
;
989 if (self
->transient_for
) {
990 if (self
->transient_for
!= OB_TRAN_GROUP
) {
991 self
->desktop
= self
->transient_for
->desktop
;
996 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
997 if (it
->data
!= self
&&
998 !((ObClient
*)it
->data
)->transient_for
) {
999 self
->desktop
= ((ObClient
*)it
->data
)->desktop
;
1006 /* try get from the startup-notification protocol */
1007 if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
1008 if (self
->desktop
>= screen_num_desktops
&&
1009 self
->desktop
!= DESKTOP_ALL
)
1010 self
->desktop
= screen_num_desktops
- 1;
1012 /* defaults to the current desktop */
1013 self
->desktop
= screen_desktop
;
1016 if (self
->desktop
!= d
) {
1017 /* set the desktop hint, to make sure that it always exists */
1018 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
1022 static void client_get_layer(ObClient
*self
)
1024 if (!(self
->above
|| self
->below
)) {
1026 /* apply stuff from the group */
1030 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1031 ObClient
*c
= it
->data
;
1032 if (c
!= self
&& !client_search_transient(self
, c
) &&
1033 client_normal(self
) && client_normal(c
))
1036 (c
->above
? 1 : (c
->below
? -1 : 0)));
1050 g_assert_not_reached();
1057 static void client_get_state(ObClient
*self
)
1062 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
1064 for (i
= 0; i
< num
; ++i
) {
1065 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
1067 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
1068 self
->shaded
= TRUE
;
1069 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
1070 self
->iconic
= TRUE
;
1071 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
1072 self
->skip_taskbar
= TRUE
;
1073 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
1074 self
->skip_pager
= TRUE
;
1075 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
1076 self
->fullscreen
= TRUE
;
1077 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
1078 self
->max_vert
= TRUE
;
1079 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
1080 self
->max_horz
= TRUE
;
1081 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
1083 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
1085 else if (state
[i
] == prop_atoms
.net_wm_state_demands_attention
)
1086 self
->demands_attention
= TRUE
;
1087 else if (state
[i
] == prop_atoms
.ob_wm_state_undecorated
)
1088 self
->undecorated
= TRUE
;
1095 static void client_get_shaped(ObClient
*self
)
1097 self
->shaped
= FALSE
;
1099 if (extensions_shape
) {
1104 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
1106 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
1107 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
1109 self
->shaped
= (s
!= 0);
1114 void client_update_transient_for(ObClient
*self
)
1117 ObClient
*target
= NULL
;
1119 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
1120 self
->transient
= TRUE
;
1121 if (t
!= self
->window
) { /* cant be transient to itself! */
1122 target
= g_hash_table_lookup(window_map
, &t
);
1123 /* if this happens then we need to check for it*/
1124 g_assert(target
!= self
);
1125 if (target
&& !WINDOW_IS_CLIENT(target
)) {
1126 /* this can happen when a dialog is a child of
1127 a dockapp, for example */
1131 /* THIS IS SO ANNOYING ! ! ! ! Let me explain.... have a seat..
1133 Setting the transient_for to Root is actually illegal, however
1134 applications from time have done this to specify transient for
1137 Now you can do that by being a TYPE_DIALOG and not setting
1138 the transient_for hint at all on your window. But people still
1139 use Root, and Kwin is very strange in this regard.
1141 KWin 3.0 will not consider windows with transient_for set to
1142 Root as transient for their group *UNLESS* they are also modal.
1143 In that case, it will make them transient for the group. This
1144 leads to all sorts of weird behavior from KDE apps which are
1145 only tested in KWin. I'd like to follow their behavior just to
1146 make this work right with KDE stuff, but that seems wrong.
1148 if (!target
&& self
->group
) {
1149 /* not transient to a client, see if it is transient for a
1151 if (t
== RootWindow(ob_display
, ob_screen
)) {
1152 /* window is a transient for its group! */
1153 target
= OB_TRAN_GROUP
;
1157 } else if (self
->group
) {
1158 if (self
->type
== OB_CLIENT_TYPE_DIALOG
||
1159 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
1160 self
->type
== OB_CLIENT_TYPE_MENU
||
1161 self
->type
== OB_CLIENT_TYPE_UTILITY
)
1163 self
->transient
= TRUE
;
1164 target
= OB_TRAN_GROUP
;
1167 self
->transient
= FALSE
;
1169 /* if anything has changed... */
1170 if (target
!= self
->transient_for
) {
1171 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
1174 /* remove from old parents */
1175 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1176 ObClient
*c
= it
->data
;
1177 if (c
!= self
&& !c
->transient_for
)
1178 c
->transients
= g_slist_remove(c
->transients
, self
);
1180 } else if (self
->transient_for
!= NULL
) { /* transient of window */
1181 /* remove from old parent */
1182 self
->transient_for
->transients
=
1183 g_slist_remove(self
->transient_for
->transients
, self
);
1185 self
->transient_for
= target
;
1186 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
1189 /* add to new parents */
1190 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1191 ObClient
*c
= it
->data
;
1192 if (c
!= self
&& !c
->transient_for
)
1193 c
->transients
= g_slist_append(c
->transients
, self
);
1196 /* remove all transients which are in the group, that causes
1197 circlular pointer hell of doom */
1198 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1200 for (sit
= self
->transients
; sit
; sit
= next
) {
1201 next
= g_slist_next(sit
);
1202 if (sit
->data
== it
->data
)
1204 g_slist_delete_link(self
->transients
, sit
);
1207 } else if (self
->transient_for
!= NULL
) { /* transient of window */
1208 /* add to new parent */
1209 self
->transient_for
->transients
=
1210 g_slist_append(self
->transient_for
->transients
, self
);
1215 static void client_get_mwm_hints(ObClient
*self
)
1220 self
->mwmhints
.flags
= 0; /* default to none */
1222 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
1224 if (num
>= OB_MWM_ELEMENTS
) {
1225 self
->mwmhints
.flags
= hints
[0];
1226 self
->mwmhints
.functions
= hints
[1];
1227 self
->mwmhints
.decorations
= hints
[2];
1233 void client_get_type(ObClient
*self
)
1240 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1241 /* use the first value that we know about in the array */
1242 for (i
= 0; i
< num
; ++i
) {
1243 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1244 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1245 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1246 self
->type
= OB_CLIENT_TYPE_DOCK
;
1247 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1248 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1249 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1250 self
->type
= OB_CLIENT_TYPE_MENU
;
1251 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1252 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1253 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1254 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1255 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1256 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1257 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1258 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1259 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1260 /* prevent this window from getting any decor or
1262 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1263 OB_MWM_FLAG_DECORATIONS
);
1264 self
->mwmhints
.decorations
= 0;
1265 self
->mwmhints
.functions
= 0;
1267 if (self
->type
!= (ObClientType
) -1)
1268 break; /* grab the first legit type */
1273 if (self
->type
== (ObClientType
) -1) {
1274 /*the window type hint was not set, which means we either classify
1275 ourself as a normal window or a dialog, depending on if we are a
1277 if (self
->transient
)
1278 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1280 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1284 void client_update_protocols(ObClient
*self
)
1287 guint num_return
, i
;
1289 self
->focus_notify
= FALSE
;
1290 self
->delete_window
= FALSE
;
1292 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1293 for (i
= 0; i
< num_return
; ++i
) {
1294 if (proto
[i
] == prop_atoms
.wm_delete_window
) {
1295 /* this means we can request the window to close */
1296 self
->delete_window
= TRUE
;
1297 } else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1298 /* if this protocol is requested, then the window will be
1299 notified whenever we want it to receive focus */
1300 self
->focus_notify
= TRUE
;
1306 static void client_get_gravity(ObClient
*self
)
1308 XWindowAttributes wattrib
;
1311 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1312 g_assert(ret
!= BadWindow
);
1313 self
->gravity
= wattrib
.win_gravity
;
1316 void client_get_colormap(ObClient
*self
)
1318 XWindowAttributes wa
;
1320 if (XGetWindowAttributes(ob_display
, self
->window
, &wa
))
1321 client_update_colormap(self
, wa
.colormap
);
1324 void client_update_colormap(ObClient
*self
, Colormap colormap
)
1326 self
->colormap
= colormap
;
1329 void client_update_normal_hints(ObClient
*self
)
1333 gint oldgravity
= self
->gravity
;
1336 self
->min_ratio
= 0.0f
;
1337 self
->max_ratio
= 0.0f
;
1338 SIZE_SET(self
->size_inc
, 1, 1);
1339 SIZE_SET(self
->base_size
, 0, 0);
1340 SIZE_SET(self
->min_size
, 0, 0);
1341 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1343 /* get the hints from the window */
1344 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1345 /* normal windows can't request placement! har har
1346 if (!client_normal(self))
1348 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1350 if (size
.flags
& PWinGravity
) {
1351 self
->gravity
= size
.win_gravity
;
1353 /* if the client has a frame, i.e. has already been mapped and
1354 is changing its gravity */
1355 if (self
->frame
&& self
->gravity
!= oldgravity
) {
1356 /* move our idea of the client's position based on its new
1358 self
->area
.x
= self
->frame
->area
.x
;
1359 self
->area
.y
= self
->frame
->area
.y
;
1360 frame_frame_gravity(self
->frame
, &self
->area
.x
, &self
->area
.y
);
1364 if (size
.flags
& PAspect
) {
1365 if (size
.min_aspect
.y
)
1367 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1368 if (size
.max_aspect
.y
)
1370 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1373 if (size
.flags
& PMinSize
)
1374 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1376 if (size
.flags
& PMaxSize
)
1377 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1379 if (size
.flags
& PBaseSize
)
1380 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1382 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1383 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1387 void client_setup_decor_and_functions(ObClient
*self
)
1389 /* start with everything (cept fullscreen) */
1391 (OB_FRAME_DECOR_TITLEBAR
|
1392 OB_FRAME_DECOR_HANDLE
|
1393 OB_FRAME_DECOR_GRIPS
|
1394 OB_FRAME_DECOR_BORDER
|
1395 OB_FRAME_DECOR_ICON
|
1396 OB_FRAME_DECOR_ALLDESKTOPS
|
1397 OB_FRAME_DECOR_ICONIFY
|
1398 OB_FRAME_DECOR_MAXIMIZE
|
1399 OB_FRAME_DECOR_SHADE
|
1400 OB_FRAME_DECOR_CLOSE
);
1402 (OB_CLIENT_FUNC_RESIZE
|
1403 OB_CLIENT_FUNC_MOVE
|
1404 OB_CLIENT_FUNC_ICONIFY
|
1405 OB_CLIENT_FUNC_MAXIMIZE
|
1406 OB_CLIENT_FUNC_SHADE
|
1407 OB_CLIENT_FUNC_CLOSE
);
1409 if (!(self
->min_size
.width
< self
->max_size
.width
||
1410 self
->min_size
.height
< self
->max_size
.height
))
1411 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1413 switch (self
->type
) {
1414 case OB_CLIENT_TYPE_NORMAL
:
1415 /* normal windows retain all of the possible decorations and
1416 functionality, and are the only windows that you can fullscreen */
1417 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1420 case OB_CLIENT_TYPE_DIALOG
:
1421 case OB_CLIENT_TYPE_UTILITY
:
1422 /* these windows cannot be maximized */
1423 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1426 case OB_CLIENT_TYPE_MENU
:
1427 case OB_CLIENT_TYPE_TOOLBAR
:
1428 /* these windows get less functionality */
1429 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
| OB_CLIENT_FUNC_RESIZE
);
1432 case OB_CLIENT_TYPE_DESKTOP
:
1433 case OB_CLIENT_TYPE_DOCK
:
1434 case OB_CLIENT_TYPE_SPLASH
:
1435 /* none of these windows are manipulated by the window manager */
1436 self
->decorations
= 0;
1437 self
->functions
= 0;
1441 /* Mwm Hints are applied subtractively to what has already been chosen for
1442 decor and functionality */
1443 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1444 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1445 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1446 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1448 /* if the mwm hints request no handle or title, then all
1449 decorations are disabled, but keep the border if that's
1451 if (self
->mwmhints
.decorations
& OB_MWM_DECOR_BORDER
)
1452 self
->decorations
= OB_FRAME_DECOR_BORDER
;
1454 self
->decorations
= 0;
1459 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1460 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1461 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1462 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1463 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1464 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1465 /* dont let mwm hints kill any buttons
1466 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1467 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1468 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1469 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1471 /* dont let mwm hints kill the close button
1472 if (! (self->mwmhints.functions & MwmFunc_Close))
1473 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1477 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1478 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1479 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1480 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1481 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1482 self
->decorations
&= ~OB_FRAME_DECOR_GRIPS
;
1484 /* can't maximize without moving/resizing */
1485 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1486 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1487 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1488 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1489 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1492 /* kill the handle on fully maxed windows */
1493 if (self
->max_vert
&& self
->max_horz
)
1494 self
->decorations
&= ~OB_FRAME_DECOR_HANDLE
;
1496 /* finally, the user can have requested no decorations, which overrides
1497 everything (but doesnt give it a border if it doesnt have one) */
1498 if (self
->undecorated
) {
1499 if (config_theme_keepborder
)
1500 self
->decorations
&= OB_FRAME_DECOR_BORDER
;
1502 self
->decorations
= 0;
1505 /* if we don't have a titlebar, then we cannot shade! */
1506 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1507 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1509 /* now we need to check against rules for the client's current state */
1510 if (self
->fullscreen
) {
1511 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1512 OB_CLIENT_FUNC_FULLSCREEN
|
1513 OB_CLIENT_FUNC_ICONIFY
);
1514 self
->decorations
= 0;
1517 client_change_allowed_actions(self
);
1520 /* adjust the client's decorations, etc. */
1521 client_reconfigure(self
);
1525 static void client_change_allowed_actions(ObClient
*self
)
1530 /* desktop windows are kept on all desktops */
1531 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1532 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1534 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1535 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1536 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1537 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1538 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1539 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1540 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1541 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1542 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1543 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1544 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1545 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1546 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1547 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1548 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1551 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1553 /* make sure the window isn't breaking any rules now */
1555 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1556 if (self
->frame
) client_shade(self
, FALSE
);
1557 else self
->shaded
= FALSE
;
1559 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
) && self
->iconic
) {
1560 if (self
->frame
) client_iconify(self
, FALSE
, TRUE
);
1561 else self
->iconic
= FALSE
;
1563 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1564 if (self
->frame
) client_fullscreen(self
, FALSE
);
1565 else self
->fullscreen
= FALSE
;
1567 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1569 if (self
->frame
) client_maximize(self
, FALSE
, 0);
1570 else self
->max_vert
= self
->max_horz
= FALSE
;
1574 void client_reconfigure(ObClient
*self
)
1576 /* by making this pass FALSE for user, we avoid the emacs event storm where
1577 every configurenotify causes an update in its normal hints, i think this
1578 is generally what we want anyways... */
1579 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
1580 self
->area
.width
, self
->area
.height
, FALSE
, TRUE
);
1583 void client_update_wmhints(ObClient
*self
)
1588 /* assume a window takes input if it doesnt specify */
1589 self
->can_focus
= TRUE
;
1591 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1592 if (hints
->flags
& InputHint
)
1593 self
->can_focus
= hints
->input
;
1595 /* only do this when first managing the window *AND* when we aren't
1597 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1598 if (hints
->flags
& StateHint
)
1599 self
->iconic
= hints
->initial_state
== IconicState
;
1601 if (!(hints
->flags
& WindowGroupHint
))
1602 hints
->window_group
= None
;
1604 /* did the group state change? */
1605 if (hints
->window_group
!=
1606 (self
->group
? self
->group
->leader
: None
)) {
1607 /* remove from the old group if there was one */
1608 if (self
->group
!= NULL
) {
1609 /* remove transients of the group */
1610 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1611 self
->transients
= g_slist_remove(self
->transients
,
1614 /* remove myself from parents in the group */
1615 if (self
->transient_for
== OB_TRAN_GROUP
) {
1616 for (it
= self
->group
->members
; it
;
1617 it
= g_slist_next(it
))
1619 ObClient
*c
= it
->data
;
1621 if (c
!= self
&& !c
->transient_for
)
1622 c
->transients
= g_slist_remove(c
->transients
,
1627 group_remove(self
->group
, self
);
1630 if (hints
->window_group
!= None
) {
1631 self
->group
= group_add(hints
->window_group
, self
);
1633 /* i can only have transients from the group if i am not
1635 if (!self
->transient_for
) {
1636 /* add other transients of the group that are already
1638 for (it
= self
->group
->members
; it
;
1639 it
= g_slist_next(it
))
1641 ObClient
*c
= it
->data
;
1642 if (c
!= self
&& c
->transient_for
== OB_TRAN_GROUP
)
1644 g_slist_append(self
->transients
, c
);
1649 /* because the self->transient flag wont change from this call,
1650 we don't need to update the window's type and such, only its
1651 transient_for, and the transients lists of other windows in
1652 the group may be affected */
1653 client_update_transient_for(self
);
1656 /* the WM_HINTS can contain an icon */
1657 client_update_icons(self
);
1663 void client_update_title(ObClient
*self
)
1666 gchar
*visible
= NULL
;
1668 g_free(self
->title
);
1671 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
)) {
1672 /* try old x stuff */
1673 if (!(PROP_GETS(self
->window
, wm_name
, locale
, &data
)
1674 || PROP_GETS(self
->window
, wm_name
, utf8
, &data
))) {
1675 if (self
->transient
) {
1677 GNOME alert windows are not given titles:
1678 http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1680 data
= g_strdup("");
1682 data
= g_strdup("Unnamed Window");
1686 if (self
->client_machine
) {
1687 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
1692 PROP_SETS(self
->window
, net_wm_visible_name
, visible
);
1693 self
->title
= visible
;
1696 frame_adjust_title(self
->frame
);
1698 /* update the icon title */
1700 g_free(self
->icon_title
);
1703 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
1704 /* try old x stuff */
1705 if (!(PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
) ||
1706 PROP_GETS(self
->window
, wm_icon_name
, utf8
, &data
)))
1707 data
= g_strdup(self
->title
);
1709 PROP_SETS(self
->window
, net_wm_visible_icon_name
, data
);
1710 self
->icon_title
= data
;
1713 void client_update_class(ObClient
*self
)
1718 if (self
->name
) g_free(self
->name
);
1719 if (self
->class) g_free(self
->class);
1720 if (self
->role
) g_free(self
->role
);
1722 self
->name
= self
->class = self
->role
= NULL
;
1724 if (PROP_GETSS(self
->window
, wm_class
, locale
, &data
)) {
1726 self
->name
= g_strdup(data
[0]);
1728 self
->class = g_strdup(data
[1]);
1733 if (PROP_GETS(self
->window
, wm_window_role
, locale
, &s
))
1736 if (self
->name
== NULL
) self
->name
= g_strdup("");
1737 if (self
->class == NULL
) self
->class = g_strdup("");
1738 if (self
->role
== NULL
) self
->role
= g_strdup("");
1741 void client_update_strut(ObClient
*self
)
1745 gboolean got
= FALSE
;
1748 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
1752 STRUT_PARTIAL_SET(strut
,
1753 data
[0], data
[2], data
[1], data
[3],
1754 data
[4], data
[5], data
[8], data
[9],
1755 data
[6], data
[7], data
[10], data
[11]);
1761 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
1767 /* use the screen's width/height */
1768 a
= screen_physical_area();
1770 STRUT_PARTIAL_SET(strut
,
1771 data
[0], data
[2], data
[1], data
[3],
1772 a
->y
, a
->y
+ a
->height
- 1,
1773 a
->x
, a
->x
+ a
->width
- 1,
1774 a
->y
, a
->y
+ a
->height
- 1,
1775 a
->x
, a
->x
+ a
->width
- 1);
1781 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
1782 0, 0, 0, 0, 0, 0, 0, 0);
1784 if (!STRUT_EQUAL(strut
, self
->strut
)) {
1785 self
->strut
= strut
;
1787 /* updating here is pointless while we're being mapped cuz we're not in
1788 the client list yet */
1790 screen_update_areas();
1794 void client_update_icons(ObClient
*self
)
1800 for (i
= 0; i
< self
->nicons
; ++i
)
1801 g_free(self
->icons
[i
].data
);
1802 if (self
->nicons
> 0)
1803 g_free(self
->icons
);
1806 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
1807 /* figure out how many valid icons are in here */
1809 while (num
- i
> 2) {
1813 if (i
> num
|| w
*h
== 0) break;
1817 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1819 /* store the icons */
1821 for (j
= 0; j
< self
->nicons
; ++j
) {
1824 w
= self
->icons
[j
].width
= data
[i
++];
1825 h
= self
->icons
[j
].height
= data
[i
++];
1827 if (w
*h
== 0) continue;
1829 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
1830 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
1835 self
->icons
[j
].data
[t
] =
1836 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
1837 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
1838 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
1839 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
1848 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
1849 if (hints
->flags
& IconPixmapHint
) {
1851 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1852 xerror_set_ignore(TRUE
);
1853 if (!RrPixmapToRGBA(ob_rr_inst
,
1855 (hints
->flags
& IconMaskHint
?
1856 hints
->icon_mask
: None
),
1857 &self
->icons
[self
->nicons
-1].width
,
1858 &self
->icons
[self
->nicons
-1].height
,
1859 &self
->icons
[self
->nicons
-1].data
)){
1860 g_free(&self
->icons
[self
->nicons
-1]);
1863 xerror_set_ignore(FALSE
);
1870 frame_adjust_icon(self
->frame
);
1873 void client_update_user_time(ObClient
*self
)
1877 if (PROP_GET32(self
->window
, net_wm_user_time
, cardinal
, &time
)) {
1878 /* we set this every time, not just when it grows, because in practice
1879 sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
1880 backward we don't want all windows to stop focusing. we'll just
1881 assume noone is setting times older than the last one, cuz that
1882 would be pretty stupid anyways
1884 self
->user_time
= time
;
1887 ob_debug("window %s user time %u\n", self->title, time);
1892 static void client_get_client_machine(ObClient
*self
)
1895 gchar localhost
[128];
1897 g_free(self
->client_machine
);
1899 if (PROP_GETS(self
->window
, wm_client_machine
, locale
, &data
)) {
1900 gethostname(localhost
, 127);
1901 localhost
[127] = '\0';
1902 if (strcmp(localhost
, data
))
1903 self
->client_machine
= data
;
1907 static void client_change_wm_state(ObClient
*self
)
1912 old
= self
->wmstate
;
1914 if (self
->shaded
|| self
->iconic
|| !self
->frame
->visible
)
1915 self
->wmstate
= IconicState
;
1917 self
->wmstate
= NormalState
;
1919 if (old
!= self
->wmstate
) {
1920 PROP_MSG(self
->window
, kde_wm_change_state
,
1921 self
->wmstate
, 1, 0, 0);
1923 state
[0] = self
->wmstate
;
1925 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
1929 static void client_change_state(ObClient
*self
)
1931 gulong netstate
[11];
1936 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
1938 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
1940 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
1941 if (self
->skip_taskbar
)
1942 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
1943 if (self
->skip_pager
)
1944 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
1945 if (self
->fullscreen
)
1946 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
1948 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
1950 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
1952 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
1954 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
1955 if (self
->demands_attention
)
1956 netstate
[num
++] = prop_atoms
.net_wm_state_demands_attention
;
1957 if (self
->undecorated
)
1958 netstate
[num
++] = prop_atoms
.ob_wm_state_undecorated
;
1959 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
1962 frame_adjust_state(self
->frame
);
1965 ObClient
*client_search_focus_tree(ObClient
*self
)
1970 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
1971 if (client_focused(it
->data
)) return it
->data
;
1972 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
1977 ObClient
*client_search_focus_tree_full(ObClient
*self
)
1979 if (self
->transient_for
) {
1980 if (self
->transient_for
!= OB_TRAN_GROUP
) {
1981 return client_search_focus_tree_full(self
->transient_for
);
1984 gboolean recursed
= FALSE
;
1986 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1987 if (!((ObClient
*)it
->data
)->transient_for
) {
1989 if ((c
= client_search_focus_tree_full(it
->data
)))
1998 /* this function checks the whole tree, the client_search_focus_tree~
1999 does not, so we need to check this window */
2000 if (client_focused(self
))
2002 return client_search_focus_tree(self
);
2005 static ObStackingLayer
calc_layer(ObClient
*self
)
2009 if (self
->fullscreen
&&
2010 (client_focused(self
) || client_search_focus_tree(self
)))
2011 l
= OB_STACKING_LAYER_FULLSCREEN
;
2012 else if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
2013 l
= OB_STACKING_LAYER_DESKTOP
;
2014 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
2015 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
2016 else l
= OB_STACKING_LAYER_ABOVE
;
2018 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
2019 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
2020 else l
= OB_STACKING_LAYER_NORMAL
;
2025 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
2026 ObStackingLayer min
, gboolean raised
)
2028 ObStackingLayer old
, own
;
2032 own
= calc_layer(self
);
2033 self
->layer
= MAX(own
, min
);
2035 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2036 client_calc_layer_recursive(it
->data
, orig
,
2038 raised
? raised
: self
->layer
!= old
);
2040 if (!raised
&& self
->layer
!= old
)
2041 if (orig
->frame
) { /* only restack if the original window is managed */
2042 stacking_remove(CLIENT_AS_WINDOW(self
));
2043 stacking_add(CLIENT_AS_WINDOW(self
));
2047 void client_calc_layer(ObClient
*self
)
2054 /* transients take on the layer of their parents */
2055 it
= client_search_all_top_parents(self
);
2057 for (; it
; it
= g_slist_next(it
))
2058 client_calc_layer_recursive(it
->data
, orig
, 0, FALSE
);
2061 gboolean
client_should_show(ObClient
*self
)
2065 if (client_normal(self
) && screen_showing_desktop
)
2068 if (self->transient_for) {
2069 if (self->transient_for != OB_TRAN_GROUP)
2070 return client_should_show(self->transient_for);
2074 for (it = self->group->members; it; it = g_slist_next(it)) {
2075 ObClient *c = it->data;
2076 if (c != self && !c->transient_for) {
2077 if (client_should_show(c))
2084 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
2090 void client_show(ObClient
*self
)
2093 if (client_should_show(self
)) {
2094 frame_show(self
->frame
);
2097 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2098 needs to be in IconicState. This includes when it is on another
2101 client_change_wm_state(self
);
2104 void client_hide(ObClient
*self
)
2106 if (!client_should_show(self
)) {
2107 frame_hide(self
->frame
);
2110 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2111 needs to be in IconicState. This includes when it is on another
2114 client_change_wm_state(self
);
2117 void client_showhide(ObClient
*self
)
2120 if (client_should_show(self
)) {
2121 frame_show(self
->frame
);
2124 frame_hide(self
->frame
);
2127 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2128 needs to be in IconicState. This includes when it is on another
2131 client_change_wm_state(self
);
2134 gboolean
client_normal(ObClient
*self
) {
2135 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
2136 self
->type
== OB_CLIENT_TYPE_DOCK
||
2137 self
->type
== OB_CLIENT_TYPE_SPLASH
);
2140 static void client_apply_startup_state(ObClient
*self
, gint x
, gint y
)
2142 gboolean pos
= FALSE
; /* has the window's position been configured? */
2145 /* save the position, and set self->area for these to use */
2151 /* these are in a carefully crafted order.. */
2154 self
->iconic
= FALSE
;
2155 client_iconify(self
, TRUE
, FALSE
);
2157 if (self
->fullscreen
) {
2158 self
->fullscreen
= FALSE
;
2159 client_fullscreen(self
, TRUE
);
2162 if (self
->undecorated
) {
2163 self
->undecorated
= FALSE
;
2164 client_set_undecorated(self
, TRUE
);
2167 self
->shaded
= FALSE
;
2168 client_shade(self
, TRUE
);
2170 if (self
->demands_attention
) {
2171 self
->demands_attention
= FALSE
;
2172 client_hilite(self
, TRUE
);
2175 if (self
->max_vert
&& self
->max_horz
) {
2176 self
->max_vert
= self
->max_horz
= FALSE
;
2177 client_maximize(self
, TRUE
, 0);
2179 } else if (self
->max_vert
) {
2180 self
->max_vert
= FALSE
;
2181 client_maximize(self
, TRUE
, 2);
2183 } else if (self
->max_horz
) {
2184 self
->max_horz
= FALSE
;
2185 client_maximize(self
, TRUE
, 1);
2189 /* if the client didn't get positioned yet, then do so now
2190 call client_move even if the window is not being moved anywhere, because
2191 when we reparent it and decorate it, it is getting moved and we need to
2192 be telling it so with a ConfigureNotify event.
2195 /* use the saved position */
2198 client_move(self
, x
, y
);
2201 /* nothing to do for the other states:
2210 void client_try_configure(ObClient
*self
, ObCorner anchor
,
2211 gint
*x
, gint
*y
, gint
*w
, gint
*h
,
2212 gint
*logicalw
, gint
*logicalh
,
2215 Rect desired_area
= {*x
, *y
, *w
, *h
};
2217 /* make the frame recalculate its dimentions n shit without changing
2218 anything visible for real, this way the constraints below can work with
2219 the updated frame dimensions. */
2220 frame_adjust_area(self
->frame
, TRUE
, TRUE
, TRUE
);
2222 /* work within the prefered sizes given by the window */
2223 if (!(*w
== self
->area
.width
&& *h
== self
->area
.height
)) {
2224 gint basew
, baseh
, minw
, minh
;
2226 /* base size is substituted with min size if not specified */
2227 if (self
->base_size
.width
|| self
->base_size
.height
) {
2228 basew
= self
->base_size
.width
;
2229 baseh
= self
->base_size
.height
;
2231 basew
= self
->min_size
.width
;
2232 baseh
= self
->min_size
.height
;
2234 /* min size is substituted with base size if not specified */
2235 if (self
->min_size
.width
|| self
->min_size
.height
) {
2236 minw
= self
->min_size
.width
;
2237 minh
= self
->min_size
.height
;
2239 minw
= self
->base_size
.width
;
2240 minh
= self
->base_size
.height
;
2243 /* if this is a user-requested resize, then check against min/max
2246 /* smaller than min size or bigger than max size? */
2247 if (*w
> self
->max_size
.width
) *w
= self
->max_size
.width
;
2248 if (*w
< minw
) *w
= minw
;
2249 if (*h
> self
->max_size
.height
) *h
= self
->max_size
.height
;
2250 if (*h
< minh
) *h
= minh
;
2255 /* keep to the increments */
2256 *w
/= self
->size_inc
.width
;
2257 *h
/= self
->size_inc
.height
;
2259 /* you cannot resize to nothing */
2260 if (basew
+ *w
< 1) *w
= 1 - basew
;
2261 if (baseh
+ *h
< 1) *h
= 1 - baseh
;
2263 /* save the logical size */
2264 *logicalw
= self
->size_inc
.width
> 1 ? *w
: *w
+ basew
;
2265 *logicalh
= self
->size_inc
.height
> 1 ? *h
: *h
+ baseh
;
2267 *w
*= self
->size_inc
.width
;
2268 *h
*= self
->size_inc
.height
;
2273 /* adjust the height to match the width for the aspect ratios.
2274 for this, min size is not substituted for base size ever. */
2275 *w
-= self
->base_size
.width
;
2276 *h
-= self
->base_size
.height
;
2278 if (!self
->fullscreen
) {
2279 if (self
->min_ratio
)
2280 if (*h
* self
->min_ratio
> *w
) {
2281 *h
= (gint
)(*w
/ self
->min_ratio
);
2283 /* you cannot resize to nothing */
2286 *w
= (gint
)(*h
* self
->min_ratio
);
2289 if (self
->max_ratio
)
2290 if (*h
* self
->max_ratio
< *w
) {
2291 *h
= (gint
)(*w
/ self
->max_ratio
);
2293 /* you cannot resize to nothing */
2296 *w
= (gint
)(*h
* self
->min_ratio
);
2301 *w
+= self
->base_size
.width
;
2302 *h
+= self
->base_size
.height
;
2305 /* gets the frame's position */
2306 frame_client_gravity(self
->frame
, x
, y
);
2308 /* these positions are frame positions, not client positions */
2310 /* set the size and position if fullscreen */
2311 if (self
->fullscreen
) {
2315 i
= screen_find_monitor(&desired_area
);
2316 a
= screen_physical_area_monitor(i
);
2323 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2324 is entering fullscreen */
2325 } else if (self
->max_horz
|| self
->max_vert
) {
2329 i
= screen_find_monitor(&desired_area
);
2330 a
= screen_area_monitor(self
->desktop
, i
);
2332 /* set the size and position if maximized */
2333 if (self
->max_horz
) {
2335 *w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2337 if (self
->max_vert
) {
2339 *h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2342 /* maximizing is not allowed if the user can't move+resize the window
2346 /* gets the client's position */
2347 frame_frame_gravity(self
->frame
, x
, y
);
2349 /* these override the above states! if you cant move you can't move! */
2351 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2355 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2356 *w
= self
->area
.width
;
2357 *h
= self
->area
.height
;
2365 case OB_CORNER_TOPLEFT
:
2367 case OB_CORNER_TOPRIGHT
:
2368 *x
-= *w
- self
->area
.width
;
2370 case OB_CORNER_BOTTOMLEFT
:
2371 *y
-= *h
- self
->area
.height
;
2373 case OB_CORNER_BOTTOMRIGHT
:
2374 *x
-= *w
- self
->area
.width
;
2375 *y
-= *h
- self
->area
.height
;
2381 void client_configure_full(ObClient
*self
, ObCorner anchor
,
2382 gint x
, gint y
, gint w
, gint h
,
2383 gboolean user
, gboolean final
,
2384 gboolean force_reply
)
2386 gint oldw
, oldh
, oldrx
, oldry
;
2387 gboolean send_resize_client
;
2388 gboolean moved
= FALSE
, resized
= FALSE
, rootmoved
= FALSE
;
2389 guint fdecor
= self
->frame
->decorations
;
2390 gboolean fhorz
= self
->frame
->max_horz
;
2391 gint logicalw
, logicalh
;
2393 /* find the new x, y, width, and height (and logical size) */
2394 client_try_configure(self
, anchor
, &x
, &y
, &w
, &h
,
2395 &logicalw
, &logicalh
, user
);
2397 /* set the logical size if things changed */
2398 if (!(w
== self
->area
.width
&& h
== self
->area
.height
))
2399 SIZE_SET(self
->logical_size
, logicalw
, logicalh
);
2401 /* figure out if we moved or resized or what */
2402 moved
= x
!= self
->area
.x
|| y
!= self
->area
.y
;
2403 resized
= w
!= self
->area
.width
|| h
!= self
->area
.height
;
2405 oldw
= self
->area
.width
;
2406 oldh
= self
->area
.height
;
2407 RECT_SET(self
->area
, x
, y
, w
, h
);
2409 /* for app-requested resizes, always resize if 'resized' is true.
2410 for user-requested ones, only resize if final is true, or when
2411 resizing in redraw mode */
2412 send_resize_client
= ((!user
&& resized
) ||
2414 (resized
&& config_resize_redraw
))));
2416 /* if the client is enlarging, then resize the client before the frame */
2417 if (send_resize_client
&& user
&& (w
> oldw
|| h
> oldh
)) {
2418 XResizeWindow(ob_display
, self
->window
, MAX(w
, oldw
), MAX(h
, oldh
));
2419 frame_adjust_client_area(self
->frame
);
2422 /* find the frame's dimensions and move/resize it */
2423 if (self
->decorations
!= fdecor
|| self
->max_horz
!= fhorz
)
2424 moved
= resized
= TRUE
;
2425 if (moved
|| resized
)
2426 frame_adjust_area(self
->frame
, moved
, resized
, FALSE
);
2428 /* find the client's position relative to the root window */
2429 oldrx
= self
->root_pos
.x
;
2430 oldry
= self
->root_pos
.y
;
2431 rootmoved
= (oldrx
!= (signed)(self
->frame
->area
.x
+
2432 self
->frame
->size
.left
-
2433 self
->border_width
) ||
2434 oldry
!= (signed)(self
->frame
->area
.y
+
2435 self
->frame
->size
.top
-
2436 self
->border_width
));
2438 if (force_reply
|| ((!user
|| (user
&& final
)) && rootmoved
))
2442 POINT_SET(self
->root_pos
,
2443 self
->frame
->area
.x
+ self
->frame
->size
.left
-
2445 self
->frame
->area
.y
+ self
->frame
->size
.top
-
2446 self
->border_width
);
2448 event
.type
= ConfigureNotify
;
2449 event
.xconfigure
.display
= ob_display
;
2450 event
.xconfigure
.event
= self
->window
;
2451 event
.xconfigure
.window
= self
->window
;
2453 /* root window real coords */
2454 event
.xconfigure
.x
= self
->root_pos
.x
;
2455 event
.xconfigure
.y
= self
->root_pos
.y
;
2456 event
.xconfigure
.width
= w
;
2457 event
.xconfigure
.height
= h
;
2458 event
.xconfigure
.border_width
= 0;
2459 event
.xconfigure
.above
= self
->frame
->plate
;
2460 event
.xconfigure
.override_redirect
= FALSE
;
2461 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
2462 FALSE
, StructureNotifyMask
, &event
);
2465 /* if the client is shrinking, then resize the frame before the client */
2466 if (send_resize_client
&& (!user
|| (w
<= oldw
|| h
<= oldh
))) {
2467 frame_adjust_client_area(self
->frame
);
2468 XResizeWindow(ob_display
, self
->window
, w
, h
);
2474 void client_fullscreen(ObClient
*self
, gboolean fs
)
2478 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
2479 self
->fullscreen
== fs
) return; /* already done */
2481 self
->fullscreen
= fs
;
2482 client_change_state(self
); /* change the state hints on the client */
2483 client_calc_layer(self
); /* and adjust out layer/stacking */
2486 self
->pre_fullscreen_area
= self
->area
;
2487 /* if the window is maximized, its area isn't all that meaningful.
2488 save it's premax area instead. */
2489 if (self
->max_horz
) {
2490 self
->pre_fullscreen_area
.x
= self
->pre_max_area
.x
;
2491 self
->pre_fullscreen_area
.width
= self
->pre_max_area
.width
;
2493 if (self
->max_vert
) {
2494 self
->pre_fullscreen_area
.y
= self
->pre_max_area
.y
;
2495 self
->pre_fullscreen_area
.height
= self
->pre_max_area
.height
;
2498 /* these are not actually used cuz client_configure will set them
2499 as appropriate when the window is fullscreened */
2504 if (self
->pre_fullscreen_area
.width
> 0 &&
2505 self
->pre_fullscreen_area
.height
> 0)
2507 x
= self
->pre_fullscreen_area
.x
;
2508 y
= self
->pre_fullscreen_area
.y
;
2509 w
= self
->pre_fullscreen_area
.width
;
2510 h
= self
->pre_fullscreen_area
.height
;
2511 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
2513 /* pick some fallbacks... */
2514 a
= screen_area_monitor(self
->desktop
, 0);
2515 x
= a
->x
+ a
->width
/ 4;
2516 y
= a
->y
+ a
->height
/ 4;
2522 client_setup_decor_and_functions(self
);
2524 client_move_resize(self
, x
, y
, w
, h
);
2526 /* try focus us when we go into fullscreen mode */
2530 static void client_iconify_recursive(ObClient
*self
,
2531 gboolean iconic
, gboolean curdesk
)
2534 gboolean changed
= FALSE
;
2537 if (self
->iconic
!= iconic
) {
2538 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
2542 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
) {
2543 self
->iconic
= iconic
;
2545 /* update the focus lists.. iconic windows go to the bottom of
2546 the list, put the new iconic window at the 'top of the
2548 focus_order_to_top(self
);
2553 self
->iconic
= iconic
;
2556 client_set_desktop(self
, screen_desktop
, FALSE
);
2558 /* this puts it after the current focused window */
2559 focus_order_remove(self
);
2560 focus_order_add_new(self
);
2567 client_change_state(self
);
2568 client_showhide(self
);
2569 if (STRUT_EXISTS(self
->strut
))
2570 screen_update_areas();
2573 /* iconify all direct transients */
2574 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2575 if (it
->data
!= self
)
2576 if (client_is_direct_child(self
, it
->data
))
2577 client_iconify_recursive(it
->data
, iconic
, curdesk
);
2580 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
)
2582 /* move up the transient chain as far as possible first */
2583 self
= client_search_top_parent(self
);
2584 client_iconify_recursive(self
, iconic
, curdesk
);
2587 void client_maximize(ObClient
*self
, gboolean max
, gint dir
)
2591 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
2592 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
2594 /* check if already done */
2596 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
2597 if (dir
== 1 && self
->max_horz
) return;
2598 if (dir
== 2 && self
->max_vert
) return;
2600 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
2601 if (dir
== 1 && !self
->max_horz
) return;
2602 if (dir
== 2 && !self
->max_vert
) return;
2605 /* we just tell it to configure in the same place and client_configure
2606 worries about filling the screen with the window */
2609 w
= self
->area
.width
;
2610 h
= self
->area
.height
;
2613 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
2614 RECT_SET(self
->pre_max_area
,
2615 self
->area
.x
, self
->pre_max_area
.y
,
2616 self
->area
.width
, self
->pre_max_area
.height
);
2618 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
2619 RECT_SET(self
->pre_max_area
,
2620 self
->pre_max_area
.x
, self
->area
.y
,
2621 self
->pre_max_area
.width
, self
->area
.height
);
2626 a
= screen_area_monitor(self
->desktop
, 0);
2627 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
2628 if (self
->pre_max_area
.width
> 0) {
2629 x
= self
->pre_max_area
.x
;
2630 w
= self
->pre_max_area
.width
;
2632 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
2633 0, self
->pre_max_area
.height
);
2635 /* pick some fallbacks... */
2636 x
= a
->x
+ a
->width
/ 4;
2640 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
2641 if (self
->pre_max_area
.height
> 0) {
2642 y
= self
->pre_max_area
.y
;
2643 h
= self
->pre_max_area
.height
;
2645 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
2646 self
->pre_max_area
.width
, 0);
2648 /* pick some fallbacks... */
2649 y
= a
->y
+ a
->height
/ 4;
2655 if (dir
== 0 || dir
== 1) /* horz */
2656 self
->max_horz
= max
;
2657 if (dir
== 0 || dir
== 2) /* vert */
2658 self
->max_vert
= max
;
2660 client_change_state(self
); /* change the state hints on the client */
2662 client_setup_decor_and_functions(self
);
2664 client_move_resize(self
, x
, y
, w
, h
);
2667 void client_shade(ObClient
*self
, gboolean shade
)
2669 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
2670 shade
) || /* can't shade */
2671 self
->shaded
== shade
) return; /* already done */
2673 self
->shaded
= shade
;
2674 client_change_state(self
);
2675 client_change_wm_state(self
); /* the window is being hidden/shown */
2676 /* resize the frame to just the titlebar */
2677 frame_adjust_area(self
->frame
, FALSE
, FALSE
, FALSE
);
2680 void client_close(ObClient
*self
)
2684 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
2686 /* in the case that the client provides no means to requesting that it
2687 close, we just kill it */
2688 if (!self
->delete_window
)
2692 XXX: itd be cool to do timeouts and shit here for killing the client's
2694 like... if the window is around after 5 seconds, then the close button
2695 turns a nice red, and if this function is called again, the client is
2699 ce
.xclient
.type
= ClientMessage
;
2700 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2701 ce
.xclient
.display
= ob_display
;
2702 ce
.xclient
.window
= self
->window
;
2703 ce
.xclient
.format
= 32;
2704 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_delete_window
;
2705 ce
.xclient
.data
.l
[1] = event_curtime
;
2706 ce
.xclient
.data
.l
[2] = 0l;
2707 ce
.xclient
.data
.l
[3] = 0l;
2708 ce
.xclient
.data
.l
[4] = 0l;
2709 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2712 void client_kill(ObClient
*self
)
2714 XKillClient(ob_display
, self
->window
);
2717 void client_hilite(ObClient
*self
, gboolean hilite
)
2719 if (self
->demands_attention
== hilite
)
2720 return; /* no change */
2722 /* don't allow focused windows to hilite */
2723 self
->demands_attention
= hilite
&& !client_focused(self
);
2724 if (self
->demands_attention
)
2725 frame_flash_start(self
->frame
);
2727 frame_flash_stop(self
->frame
);
2728 client_change_state(self
);
2731 void client_set_desktop_recursive(ObClient
*self
,
2732 guint target
, gboolean donthide
)
2737 if (target
!= self
->desktop
) {
2739 ob_debug("Setting desktop %u\n", target
+1);
2741 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
2743 /* remove from the old desktop(s) */
2744 focus_order_remove(self
);
2746 old
= self
->desktop
;
2747 self
->desktop
= target
;
2748 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
2749 /* the frame can display the current desktop state */
2750 frame_adjust_state(self
->frame
);
2751 /* 'move' the window to the new desktop */
2753 client_showhide(self
);
2754 /* raise if it was not already on the desktop */
2755 if (old
!= DESKTOP_ALL
)
2757 if (STRUT_EXISTS(self
->strut
))
2758 screen_update_areas();
2760 /* add to the new desktop(s) */
2761 if (config_focus_new
)
2762 focus_order_to_top(self
);
2764 focus_order_to_bottom(self
);
2767 /* move all transients */
2768 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2769 if (it
->data
!= self
)
2770 if (client_is_direct_child(self
, it
->data
))
2771 client_set_desktop_recursive(it
->data
, target
, donthide
);
2774 void client_set_desktop(ObClient
*self
, guint target
, gboolean donthide
)
2776 self
= client_search_top_parent(self
);
2777 client_set_desktop_recursive(self
, target
, donthide
);
2780 gboolean
client_is_direct_child(ObClient
*parent
, ObClient
*child
)
2782 while (child
!= parent
&&
2783 child
->transient_for
&& child
->transient_for
!= OB_TRAN_GROUP
)
2784 child
= child
->transient_for
;
2785 return child
== parent
;
2788 ObClient
*client_search_modal_child(ObClient
*self
)
2793 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2794 ObClient
*c
= it
->data
;
2795 if ((ret
= client_search_modal_child(c
))) return ret
;
2796 if (c
->modal
) return c
;
2801 gboolean
client_validate(ObClient
*self
)
2805 XSync(ob_display
, FALSE
); /* get all events on the server */
2807 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
) ||
2808 XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
2809 XPutBackEvent(ob_display
, &e
);
2816 void client_set_wm_state(ObClient
*self
, glong state
)
2818 if (state
== self
->wmstate
) return; /* no change */
2822 client_iconify(self
, TRUE
, TRUE
);
2825 client_iconify(self
, FALSE
, TRUE
);
2830 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
2832 gboolean shaded
= self
->shaded
;
2833 gboolean fullscreen
= self
->fullscreen
;
2834 gboolean undecorated
= self
->undecorated
;
2835 gboolean max_horz
= self
->max_horz
;
2836 gboolean max_vert
= self
->max_vert
;
2837 gboolean modal
= self
->modal
;
2838 gboolean iconic
= self
->iconic
;
2839 gboolean demands_attention
= self
->demands_attention
;
2842 if (!(action
== prop_atoms
.net_wm_state_add
||
2843 action
== prop_atoms
.net_wm_state_remove
||
2844 action
== prop_atoms
.net_wm_state_toggle
))
2845 /* an invalid action was passed to the client message, ignore it */
2848 for (i
= 0; i
< 2; ++i
) {
2849 Atom state
= i
== 0 ? data1
: data2
;
2851 if (!state
) continue;
2853 /* if toggling, then pick whether we're adding or removing */
2854 if (action
== prop_atoms
.net_wm_state_toggle
) {
2855 if (state
== prop_atoms
.net_wm_state_modal
)
2856 action
= modal
? prop_atoms
.net_wm_state_remove
:
2857 prop_atoms
.net_wm_state_add
;
2858 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
2859 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
2860 prop_atoms
.net_wm_state_add
;
2861 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
2862 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
2863 prop_atoms
.net_wm_state_add
;
2864 else if (state
== prop_atoms
.net_wm_state_shaded
)
2865 action
= shaded
? prop_atoms
.net_wm_state_remove
:
2866 prop_atoms
.net_wm_state_add
;
2867 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
2868 action
= self
->skip_taskbar
?
2869 prop_atoms
.net_wm_state_remove
:
2870 prop_atoms
.net_wm_state_add
;
2871 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
2872 action
= self
->skip_pager
?
2873 prop_atoms
.net_wm_state_remove
:
2874 prop_atoms
.net_wm_state_add
;
2875 else if (state
== prop_atoms
.net_wm_state_hidden
)
2876 action
= self
->iconic
?
2877 prop_atoms
.net_wm_state_remove
:
2878 prop_atoms
.net_wm_state_add
;
2879 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
2880 action
= fullscreen
?
2881 prop_atoms
.net_wm_state_remove
:
2882 prop_atoms
.net_wm_state_add
;
2883 else if (state
== prop_atoms
.net_wm_state_above
)
2884 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
2885 prop_atoms
.net_wm_state_add
;
2886 else if (state
== prop_atoms
.net_wm_state_below
)
2887 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
2888 prop_atoms
.net_wm_state_add
;
2889 else if (state
== prop_atoms
.net_wm_state_demands_attention
)
2890 action
= self
->demands_attention
?
2891 prop_atoms
.net_wm_state_remove
:
2892 prop_atoms
.net_wm_state_add
;
2893 else if (state
== prop_atoms
.ob_wm_state_undecorated
)
2894 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
2895 prop_atoms
.net_wm_state_add
;
2898 if (action
== prop_atoms
.net_wm_state_add
) {
2899 if (state
== prop_atoms
.net_wm_state_modal
) {
2901 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2903 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2905 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2907 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2908 self
->skip_taskbar
= TRUE
;
2909 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2910 self
->skip_pager
= TRUE
;
2911 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
2913 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2915 } else if (state
== prop_atoms
.net_wm_state_above
) {
2917 self
->below
= FALSE
;
2918 } else if (state
== prop_atoms
.net_wm_state_below
) {
2919 self
->above
= FALSE
;
2921 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
2922 demands_attention
= TRUE
;
2923 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2927 } else { /* action == prop_atoms.net_wm_state_remove */
2928 if (state
== prop_atoms
.net_wm_state_modal
) {
2930 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
2932 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
2934 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
2936 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
2937 self
->skip_taskbar
= FALSE
;
2938 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
2939 self
->skip_pager
= FALSE
;
2940 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
2942 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
2944 } else if (state
== prop_atoms
.net_wm_state_above
) {
2945 self
->above
= FALSE
;
2946 } else if (state
== prop_atoms
.net_wm_state_below
) {
2947 self
->below
= FALSE
;
2948 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
2949 demands_attention
= FALSE
;
2950 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
2951 undecorated
= FALSE
;
2955 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
2956 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
2958 if (max_horz
== max_vert
) { /* both going the same way */
2959 client_maximize(self
, max_horz
, 0);
2961 client_maximize(self
, max_horz
, 1);
2962 client_maximize(self
, max_vert
, 2);
2966 if (max_horz
!= self
->max_horz
)
2967 client_maximize(self
, max_horz
, 1);
2969 client_maximize(self
, max_vert
, 2);
2972 /* change fullscreen state before shading, as it will affect if the window
2974 if (fullscreen
!= self
->fullscreen
)
2975 client_fullscreen(self
, fullscreen
);
2976 if (shaded
!= self
->shaded
)
2977 client_shade(self
, shaded
);
2978 if (undecorated
!= self
->undecorated
)
2979 client_set_undecorated(self
, undecorated
);
2980 if (modal
!= self
->modal
) {
2981 self
->modal
= modal
;
2982 /* when a window changes modality, then its stacking order with its
2983 transients needs to change */
2986 if (iconic
!= self
->iconic
)
2987 client_iconify(self
, iconic
, FALSE
);
2989 if (demands_attention
!= self
->demands_attention
)
2990 client_hilite(self
, demands_attention
);
2992 client_change_state(self
); /* change the hint to reflect these changes */
2995 ObClient
*client_focus_target(ObClient
*self
)
2997 ObClient
*child
= NULL
;
2999 child
= client_search_modal_child(self
);
3000 if (child
) return child
;
3004 gboolean
client_can_focus(ObClient
*self
)
3008 /* choose the correct target */
3009 self
= client_focus_target(self
);
3011 if (!self
->frame
->visible
)
3014 if (!(self
->can_focus
|| self
->focus_notify
))
3017 /* do a check to see if the window has already been unmapped or destroyed
3018 do this intelligently while watching out for unmaps we've generated
3019 (ignore_unmaps > 0) */
3020 if (XCheckTypedWindowEvent(ob_display
, self
->window
,
3021 DestroyNotify
, &ev
)) {
3022 XPutBackEvent(ob_display
, &ev
);
3025 while (XCheckTypedWindowEvent(ob_display
, self
->window
,
3026 UnmapNotify
, &ev
)) {
3027 if (self
->ignore_unmaps
) {
3028 self
->ignore_unmaps
--;
3030 XPutBackEvent(ob_display
, &ev
);
3038 gboolean
client_focus(ObClient
*self
)
3040 /* choose the correct target */
3041 self
= client_focus_target(self
);
3043 if (!client_can_focus(self
)) {
3044 if (!self
->frame
->visible
) {
3045 /* update the focus lists */
3046 focus_order_to_top(self
);
3051 ob_debug_type(OB_DEBUG_FOCUS
,
3052 "Focusing client \"%s\" at time %u\n",
3053 self
->title
, event_curtime
);
3055 if (self
->can_focus
) {
3056 /* This can cause a BadMatch error with CurrentTime, or if an app
3057 passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3058 xerror_set_ignore(TRUE
);
3059 XSetInputFocus(ob_display
, self
->window
, RevertToPointerRoot
,
3061 xerror_set_ignore(FALSE
);
3064 if (self
->focus_notify
) {
3066 ce
.xclient
.type
= ClientMessage
;
3067 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
3068 ce
.xclient
.display
= ob_display
;
3069 ce
.xclient
.window
= self
->window
;
3070 ce
.xclient
.format
= 32;
3071 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
3072 ce
.xclient
.data
.l
[1] = event_curtime
;
3073 ce
.xclient
.data
.l
[2] = 0l;
3074 ce
.xclient
.data
.l
[3] = 0l;
3075 ce
.xclient
.data
.l
[4] = 0l;
3076 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
3080 ob_debug("%sively focusing %lx at %d\n",
3081 (self
->can_focus
? "act" : "pass"),
3082 self
->window
, (gint
) event_curtime
);
3085 /* Cause the FocusIn to come back to us. Important for desktop switches,
3086 since otherwise we'll have no FocusIn on the queue and send it off to
3087 the focus_backup. */
3088 XSync(ob_display
, FALSE
);
3092 void client_activate(ObClient
*self
, gboolean here
, gboolean user
)
3094 guint32 last_time
= focus_client
? focus_client
->user_time
: CurrentTime
;
3096 /* XXX do some stuff here if user is false to determine if we really want
3097 to activate it or not (a parent or group member is currently
3100 ob_debug("Want to activate window 0x%x with time %u (last time %u), "
3102 self
->window
, event_curtime
, last_time
,
3103 (user
? "user" : "application"));
3105 if (!user
&& event_curtime
&& last_time
&&
3106 !event_time_after(event_curtime
, last_time
))
3108 client_hilite(self
, TRUE
);
3110 if (client_normal(self
) && screen_showing_desktop
)
3111 screen_show_desktop(FALSE
);
3113 client_iconify(self
, FALSE
, here
);
3114 if (self
->desktop
!= DESKTOP_ALL
&&
3115 self
->desktop
!= screen_desktop
) {
3117 client_set_desktop(self
, screen_desktop
, FALSE
);
3119 screen_set_desktop(self
->desktop
);
3120 } else if (!self
->frame
->visible
)
3121 /* if its not visible for other reasons, then don't mess
3125 client_shade(self
, FALSE
);
3129 /* we do this an action here. this is rather important. this is because
3130 we want the results from the focus change to take place BEFORE we go
3131 about raising the window. when a fullscreen window loses focus, we
3132 need this or else the raise wont be able to raise above the
3133 to-lose-focus fullscreen window. */
3138 void client_raise(ObClient
*self
)
3140 action_run_string("Raise", self
, CurrentTime
);
3143 void client_lower(ObClient
*self
)
3145 action_run_string("Lower", self
, CurrentTime
);
3148 gboolean
client_focused(ObClient
*self
)
3150 return self
== focus_client
;
3153 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
3156 /* si is the smallest image >= req */
3157 /* li is the largest image < req */
3158 gulong size
, smallest
= 0xffffffff, largest
= 0, si
= 0, li
= 0;
3160 if (!self
->nicons
) {
3161 ObClientIcon
*parent
= NULL
;
3163 if (self
->transient_for
) {
3164 if (self
->transient_for
!= OB_TRAN_GROUP
)
3165 parent
= client_icon_recursive(self
->transient_for
, w
, h
);
3168 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3169 ObClient
*c
= it
->data
;
3170 if (c
!= self
&& !c
->transient_for
) {
3171 if ((parent
= client_icon_recursive(c
, w
, h
)))
3181 for (i
= 0; i
< self
->nicons
; ++i
) {
3182 size
= self
->icons
[i
].width
* self
->icons
[i
].height
;
3183 if (size
< smallest
&& size
>= (unsigned)(w
* h
)) {
3187 if (size
> largest
&& size
<= (unsigned)(w
* h
)) {
3192 if (largest
== 0) /* didnt find one smaller than the requested size */
3193 return &self
->icons
[si
];
3194 return &self
->icons
[li
];
3197 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
3200 static ObClientIcon deficon
;
3202 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
3203 deficon
.width
= deficon
.height
= 48;
3204 deficon
.data
= ob_rr_theme
->def_win_icon
;
3210 void client_set_layer(ObClient
*self
, gint layer
)
3214 self
->above
= FALSE
;
3215 } else if (layer
== 0) {
3216 self
->below
= self
->above
= FALSE
;
3218 self
->below
= FALSE
;
3221 client_calc_layer(self
);
3222 client_change_state(self
); /* reflect this in the state hints */
3225 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
3227 if (self
->undecorated
!= undecorated
) {
3228 self
->undecorated
= undecorated
;
3229 client_setup_decor_and_functions(self
);
3230 /* Make sure the client knows it might have moved. Maybe there is a
3231 * better way of doing this so only one client_configure is sent, but
3232 * since 125 of these are sent per second when moving the window (with
3233 * user = FALSE) i doubt it matters much.
3235 client_configure(self
, OB_CORNER_TOPLEFT
, self
->area
.x
, self
->area
.y
,
3236 self
->area
.width
, self
->area
.height
, TRUE
, TRUE
);
3237 client_change_state(self
); /* reflect this in the state hints */
3241 guint
client_monitor(ObClient
*self
)
3243 return screen_find_monitor(&self
->frame
->area
);
3246 ObClient
*client_search_top_parent(ObClient
*self
)
3248 while (self
->transient_for
&& self
->transient_for
!= OB_TRAN_GROUP
&&
3249 client_normal(self
))
3250 self
= self
->transient_for
;
3254 GSList
*client_search_all_top_parents(ObClient
*self
)
3258 /* move up the direct transient chain as far as possible */
3259 while (self
->transient_for
&& self
->transient_for
!= OB_TRAN_GROUP
)
3260 self
= self
->transient_for
;
3262 if (!self
->transient_for
)
3263 ret
= g_slist_prepend(ret
, self
);
3267 g_assert(self
->group
);
3269 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3270 ObClient
*c
= it
->data
;
3272 if (!c
->transient_for
&& client_normal(c
))
3273 ret
= g_slist_prepend(ret
, c
);
3276 if (ret
== NULL
) /* no group parents */
3277 ret
= g_slist_prepend(ret
, self
);
3283 ObClient
*client_search_focus_parent(ObClient
*self
)
3285 if (self
->transient_for
) {
3286 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3287 if (client_focused(self
->transient_for
))
3288 return self
->transient_for
;
3292 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3293 ObClient
*c
= it
->data
;
3295 /* checking transient_for prevents infinate loops! */
3296 if (c
!= self
&& !c
->transient_for
)
3297 if (client_focused(c
))
3306 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3308 if (self
->transient_for
) {
3309 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3310 if (self
->transient_for
== search
)
3315 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3316 ObClient
*c
= it
->data
;
3318 /* checking transient_for prevents infinate loops! */
3319 if (c
!= self
&& !c
->transient_for
)
3329 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3333 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3334 if (sit
->data
== search
)
3336 if (client_search_transient(sit
->data
, search
))
3342 void client_update_sm_client_id(ObClient
*self
)
3344 g_free(self
->sm_client_id
);
3345 self
->sm_client_id
= NULL
;
3347 if (!PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
) &&
3349 PROP_GETS(self
->group
->leader
, sm_client_id
, locale
,
3350 &self
->sm_client_id
);
3353 #define WANT_EDGE(cur, c) \
3356 if(!client_normal(cur)) \
3358 if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL) \
3362 if(cur->layer < c->layer && !config_resist_layers_below) \
3365 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3366 if ((his_edge_start >= my_edge_start && \
3367 his_edge_start <= my_edge_end) || \
3368 (my_edge_start >= his_edge_start && \
3369 my_edge_start <= his_edge_end)) \
3372 /* finds the nearest edge in the given direction from the current client
3373 * note to self: the edge is the -frame- edge (the actual one), not the
3376 gint
client_directional_edge_search(ObClient
*c
, ObDirection dir
, gboolean hang
)
3378 gint dest
, monitor_dest
;
3379 gint my_edge_start
, my_edge_end
, my_offset
;
3386 a
= screen_area(c
->desktop
);
3387 monitor
= screen_area_monitor(c
->desktop
, client_monitor(c
));
3390 case OB_DIRECTION_NORTH
:
3391 my_edge_start
= c
->frame
->area
.x
;
3392 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3393 my_offset
= c
->frame
->area
.y
+ (hang
? c
->frame
->area
.height
: 0);
3395 /* default: top of screen */
3396 dest
= a
->y
+ (hang
? c
->frame
->area
.height
: 0);
3397 monitor_dest
= monitor
->y
+ (hang
? c
->frame
->area
.height
: 0);
3398 /* if the monitor edge comes before the screen edge, */
3399 /* use that as the destination instead. (For xinerama) */
3400 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3401 dest
= monitor_dest
;
3403 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3404 gint his_edge_start
, his_edge_end
, his_offset
;
3405 ObClient
*cur
= it
->data
;
3409 his_edge_start
= cur
->frame
->area
.x
;
3410 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3411 his_offset
= cur
->frame
->area
.y
+
3412 (hang
? 0 : cur
->frame
->area
.height
);
3414 if(his_offset
+ 1 > my_offset
)
3417 if(his_offset
< dest
)
3420 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3423 case OB_DIRECTION_SOUTH
:
3424 my_edge_start
= c
->frame
->area
.x
;
3425 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3426 my_offset
= c
->frame
->area
.y
+ (hang
? 0 : c
->frame
->area
.height
);
3428 /* default: bottom of screen */
3429 dest
= a
->y
+ a
->height
- (hang
? c
->frame
->area
.height
: 0);
3430 monitor_dest
= monitor
->y
+ monitor
->height
-
3431 (hang
? c
->frame
->area
.height
: 0);
3432 /* if the monitor edge comes before the screen edge, */
3433 /* use that as the destination instead. (For xinerama) */
3434 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3435 dest
= monitor_dest
;
3437 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3438 gint his_edge_start
, his_edge_end
, his_offset
;
3439 ObClient
*cur
= it
->data
;
3443 his_edge_start
= cur
->frame
->area
.x
;
3444 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3445 his_offset
= cur
->frame
->area
.y
+
3446 (hang
? cur
->frame
->area
.height
: 0);
3449 if(his_offset
- 1 < my_offset
)
3452 if(his_offset
> dest
)
3455 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3458 case OB_DIRECTION_WEST
:
3459 my_edge_start
= c
->frame
->area
.y
;
3460 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3461 my_offset
= c
->frame
->area
.x
+ (hang
? c
->frame
->area
.width
: 0);
3463 /* default: leftmost egde of screen */
3464 dest
= a
->x
+ (hang
? c
->frame
->area
.width
: 0);
3465 monitor_dest
= monitor
->x
+ (hang
? c
->frame
->area
.width
: 0);
3466 /* if the monitor edge comes before the screen edge, */
3467 /* use that as the destination instead. (For xinerama) */
3468 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3469 dest
= monitor_dest
;
3471 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3472 gint his_edge_start
, his_edge_end
, his_offset
;
3473 ObClient
*cur
= it
->data
;
3477 his_edge_start
= cur
->frame
->area
.y
;
3478 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3479 his_offset
= cur
->frame
->area
.x
+
3480 (hang
? 0 : cur
->frame
->area
.width
);
3482 if(his_offset
+ 1 > my_offset
)
3485 if(his_offset
< dest
)
3488 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3491 case OB_DIRECTION_EAST
:
3492 my_edge_start
= c
->frame
->area
.y
;
3493 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3494 my_offset
= c
->frame
->area
.x
+ (hang
? 0 : c
->frame
->area
.width
);
3496 /* default: rightmost edge of screen */
3497 dest
= a
->x
+ a
->width
- (hang
? c
->frame
->area
.width
: 0);
3498 monitor_dest
= monitor
->x
+ monitor
->width
-
3499 (hang
? c
->frame
->area
.width
: 0);
3500 /* if the monitor edge comes before the screen edge, */
3501 /* use that as the destination instead. (For xinerama) */
3502 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3503 dest
= monitor_dest
;
3505 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3506 gint his_edge_start
, his_edge_end
, his_offset
;
3507 ObClient
*cur
= it
->data
;
3511 his_edge_start
= cur
->frame
->area
.y
;
3512 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3513 his_offset
= cur
->frame
->area
.x
+
3514 (hang
? cur
->frame
->area
.width
: 0);
3516 if(his_offset
- 1 < my_offset
)
3519 if(his_offset
> dest
)
3522 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3525 case OB_DIRECTION_NORTHEAST
:
3526 case OB_DIRECTION_SOUTHEAST
:
3527 case OB_DIRECTION_NORTHWEST
:
3528 case OB_DIRECTION_SOUTHWEST
:
3529 /* not implemented */
3531 g_assert_not_reached();
3532 dest
= 0; /* suppress warning */
3537 ObClient
* client_under_pointer()
3541 ObClient
*ret
= NULL
;
3543 if (screen_pointer_pos(&x
, &y
)) {
3544 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
3545 if (WINDOW_IS_CLIENT(it
->data
)) {
3546 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
3547 if (c
->frame
->visible
&&
3548 RECT_CONTAINS(c
->frame
->area
, x
, y
)) {
3558 gboolean
client_has_group_siblings(ObClient
*self
)
3560 return self
->group
&& self
->group
->members
->next
;