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"
25 #include "moveresize.h"
38 #include "menuframe.h"
41 #include "render/render.h"
43 #include "obt/display.h"
51 # include <signal.h> /* for kill() */
55 #include <X11/Xutil.h>
57 /*! The event mask to grab on client windows */
58 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
61 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
66 ObClientCallback func
;
70 GList
*client_list
= NULL
;
72 static GSList
*client_destroy_notifies
= NULL
;
74 static void client_get_all(ObClient
*self
, gboolean real
);
75 static void client_get_startup_id(ObClient
*self
);
76 static void client_get_session_ids(ObClient
*self
);
77 static void client_get_area(ObClient
*self
);
78 static void client_get_desktop(ObClient
*self
);
79 static void client_get_state(ObClient
*self
);
80 static void client_get_shaped(ObClient
*self
);
81 static void client_get_mwm_hints(ObClient
*self
);
82 static void client_get_colormap(ObClient
*self
);
83 static void client_set_desktop_recursive(ObClient
*self
,
87 static void client_change_allowed_actions(ObClient
*self
);
88 static void client_change_state(ObClient
*self
);
89 static void client_change_wm_state(ObClient
*self
);
90 static void client_apply_startup_state(ObClient
*self
,
91 gint x
, gint y
, gint w
, gint h
);
92 static void client_restore_session_state(ObClient
*self
);
93 static gboolean
client_restore_session_stacking(ObClient
*self
);
94 static ObAppSettings
*client_get_settings_state(ObClient
*self
);
95 static void client_update_transient_tree(ObClient
*self
,
96 ObGroup
*oldgroup
, ObGroup
*newgroup
,
97 gboolean oldgtran
, gboolean newgtran
,
100 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
,
102 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
104 ObStackingLayer layer
);
105 static void client_call_notifies(ObClient
*self
, GSList
*list
);
106 static void client_ping_event(ObClient
*self
, gboolean dead
);
107 static void client_prompt_kill(ObClient
*self
);
110 void client_startup(gboolean reconfig
)
112 if (reconfig
) return;
117 void client_shutdown(gboolean reconfig
)
119 if (reconfig
) return;
122 static void client_call_notifies(ObClient
*self
, GSList
*list
)
126 for (it
= list
; it
; it
= g_slist_next(it
)) {
127 ClientCallback
*d
= it
->data
;
128 d
->func(self
, d
->data
);
132 void client_add_destroy_notify(ObClientCallback func
, gpointer data
)
134 ClientCallback
*d
= g_new(ClientCallback
, 1);
137 client_destroy_notifies
= g_slist_prepend(client_destroy_notifies
, d
);
140 void client_remove_destroy_notify(ObClientCallback func
)
144 for (it
= client_destroy_notifies
; it
; it
= g_slist_next(it
)) {
145 ClientCallback
*d
= it
->data
;
146 if (d
->func
== func
) {
148 client_destroy_notifies
=
149 g_slist_delete_link(client_destroy_notifies
, it
);
155 void client_set_list(void)
157 Window
*windows
, *win_it
;
159 guint size
= g_list_length(client_list
);
161 /* create an array of the window ids */
163 windows
= g_new(Window
, size
);
165 for (it
= client_list
; it
; it
= g_list_next(it
), ++win_it
)
166 *win_it
= ((ObClient
*)it
->data
)->window
;
170 OBT_PROP_SETA32(obt_root(ob_screen
), NET_CLIENT_LIST
, WINDOW
,
171 (gulong
*)windows
, size
);
179 void client_manage(Window window
, ObPrompt
*prompt
)
182 XSetWindowAttributes attrib_set
;
183 gboolean activate
= FALSE
;
184 ObAppSettings
*settings
;
185 gboolean transient
= FALSE
;
186 Rect place
, *monitor
;
187 Time launch_time
, map_time
;
189 ob_debug("Managing window: 0x%lx", window
);
191 map_time
= event_get_server_time();
193 /* choose the events we want to receive on the CLIENT window
194 (ObPrompt windows can request events too) */
195 attrib_set
.event_mask
= CLIENT_EVENTMASK
|
196 (prompt
? prompt
->event_mask
: 0);
197 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
198 XChangeWindowAttributes(obt_display
, window
,
199 CWEventMask
|CWDontPropagate
, &attrib_set
);
201 /* create the ObClient struct, and populate it from the hints on the
203 self
= g_new0(ObClient
, 1);
204 self
->obwin
.type
= OB_WINDOW_CLASS_CLIENT
;
205 self
->window
= window
;
206 self
->prompt
= prompt
;
208 /* non-zero defaults */
209 self
->wmstate
= WithdrawnState
; /* make sure it gets updated first time */
210 self
->gravity
= NorthWestGravity
;
211 self
->desktop
= screen_num_desktops
; /* always an invalid value */
213 /* get all the stuff off the window */
214 client_get_all(self
, TRUE
);
216 ob_debug("Window type: %d", self
->type
);
217 ob_debug("Window group: 0x%x", self
->group
?self
->group
->leader
:0);
219 /* now we have all of the window's information so we can set this up.
220 do this before creating the frame, so it can tell that we are still
221 mapping and doesn't go applying things right away */
222 client_setup_decor_and_functions(self
, FALSE
);
224 /* specify that if we exit, the window should not be destroyed and
225 should be reparented back to root automatically, unless we are managing
226 an internal ObPrompt window */
228 XChangeSaveSet(obt_display
, window
, SetModeInsert
);
230 /* create the decoration frame for the client window */
231 self
->frame
= frame_new(self
);
233 frame_grab_client(self
->frame
);
235 /* we've grabbed everything and set everything that we need to at mapping
239 /* per-app settings override stuff from client_get_all, and return the
240 settings for other uses too. the returned settings is a shallow copy,
241 that needs to be freed with g_free(). */
242 settings
= client_get_settings_state(self
);
243 /* the session should get the last say though */
244 client_restore_session_state(self
);
246 /* tell startup notification that this app started */
247 launch_time
= sn_app_started(self
->startup_id
, self
->class, self
->name
);
249 /* do this after we have a frame.. it uses the frame to help determine the
250 WM_STATE to apply. */
251 client_change_state(self
);
253 /* add ourselves to the focus order */
254 focus_order_add_new(self
);
256 /* do this to add ourselves to the stacking list in a non-intrusive way */
257 client_calc_layer(self
);
259 /* focus the new window? */
260 if (ob_state() != OB_STATE_STARTING
&&
261 (!self
->session
|| self
->session
->focused
) &&
262 /* this means focus=true for window is same as config_focus_new=true */
263 ((config_focus_new
|| (settings
&& settings
->focus
== 1)) ||
264 client_search_focus_tree_full(self
)) &&
265 /* this checks for focus=false for the window */
266 (!settings
|| settings
->focus
!= 0) &&
267 focus_valid_target(self
, FALSE
, FALSE
, TRUE
, FALSE
, FALSE
))
272 /* remove the client's border */
273 XSetWindowBorderWidth(obt_display
, self
->window
, 0);
275 /* adjust the frame to the client's size before showing or placing
277 frame_adjust_area(self
->frame
, FALSE
, TRUE
, FALSE
);
278 frame_adjust_client_area(self
->frame
);
280 /* where the frame was placed is where the window was originally */
282 monitor
= screen_physical_area_monitor(screen_find_monitor(&place
));
284 /* figure out placement for the window if the window is new */
285 if (ob_state() == OB_STATE_RUNNING
) {
286 ob_debug("Positioned: %s @ %d %d",
287 (!self
->positioned
? "no" :
288 (self
->positioned
== PPosition
? "program specified" :
289 (self
->positioned
== USPosition
? "user specified" :
290 (self
->positioned
== (PPosition
| USPosition
) ?
291 "program + user specified" :
292 "BADNESS !?")))), place
.x
, place
.y
);
294 ob_debug("Sized: %s @ %d %d",
295 (!self
->sized
? "no" :
296 (self
->sized
== PSize
? "program specified" :
297 (self
->sized
== USSize
? "user specified" :
298 (self
->sized
== (PSize
| USSize
) ?
299 "program + user specified" :
300 "BADNESS !?")))), place
.width
, place
.height
);
302 /* splash screens are also returned as TRUE for transient,
303 and so will be forced on screen below */
304 transient
= place_client(self
, &place
.x
, &place
.y
, settings
);
306 /* make sure the window is visible. */
307 client_find_onscreen(self
, &place
.x
, &place
.y
,
308 place
.width
, place
.height
,
309 /* non-normal clients has less rules, and
310 windows that are being restored from a
311 session do also. we can assume you want
312 it back where you saved it. Clients saying
313 they placed themselves are subjected to
314 harder rules, ones that are placed by
315 place.c or by the user are allowed partially
316 off-screen and on xinerama divides (ie,
317 it is up to the placement routines to avoid
318 the xinerama divides)
320 splash screens get "transient" set to TRUE by
321 the place_client call
323 ob_state() == OB_STATE_RUNNING
&&
325 (!((self
->positioned
& USPosition
) ||
326 (settings
&& settings
->pos_given
)) &&
327 client_normal(self
) &&
329 /* don't move oldschool fullscreen windows to
330 fit inside the struts (fixes Acroread, which
331 makes its fullscreen window fit the screen
332 but it is not USSize'd or USPosition'd) */
333 !(self
->decorations
== 0 &&
334 RECT_EQUAL(place
, *monitor
)))));
337 /* if the window isn't user-sized, then make it fit inside
338 the visible screen area on its monitor. Use basically the same rules
339 for forcing the window on screen in the client_find_onscreen call.
341 do this after place_client, it chooses the monitor!
343 splash screens get "transient" set to TRUE by
344 the place_client call
346 if (ob_state() == OB_STATE_RUNNING
&&
348 (!(self
->sized
& USSize
|| self
->positioned
& USPosition
) &&
349 client_normal(self
) &&
351 /* don't shrink oldschool fullscreen windows to fit inside the
352 struts (fixes Acroread, which makes its fullscreen window
353 fit the screen but it is not USSize'd or USPosition'd) */
354 !(self
->decorations
== 0 && RECT_EQUAL(place
, *monitor
)))))
356 Rect
*a
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
, &place
);
358 /* get the size of the frame */
359 place
.width
+= self
->frame
->size
.left
+ self
->frame
->size
.right
;
360 place
.height
+= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
362 /* fit the window inside the area */
363 place
.width
= MIN(place
.width
, a
->width
);
364 place
.height
= MIN(place
.height
, a
->height
);
366 ob_debug("setting window size to %dx%d", place
.width
, place
.height
);
368 /* get the size of the client back */
369 place
.width
-= self
->frame
->size
.left
+ self
->frame
->size
.right
;
370 place
.height
-= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
375 ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
376 "some restrictions may apply",
377 self
->window
, place
.x
, place
.y
, place
.width
, place
.height
);
379 ob_debug(" but session requested %d, %d %d x %d instead, "
381 self
->session
->x
, self
->session
->y
,
382 self
->session
->w
, self
->session
->h
);
384 /* do this after the window is placed, so the premax/prefullscreen numbers
387 this also places the window
389 client_apply_startup_state(self
, place
.x
, place
.y
,
390 place
.width
, place
.height
);
395 ob_debug_type(OB_DEBUG_FOCUS
, "Going to try activate new window? %s",
396 activate
? "yes" : "no");
398 gboolean raise
= FALSE
;
400 /* This is focus stealing prevention */
401 ob_debug_type(OB_DEBUG_FOCUS
,
402 "Want to focus new window 0x%x at time %u "
403 "launched at %u (last user interaction time %u)",
404 self
->window
, map_time
, launch_time
,
405 event_last_user_time
);
407 if (menu_frame_visible
|| moveresize_in_progress
) {
410 ob_debug_type(OB_DEBUG_FOCUS
,
411 "Not focusing the window because the user is inside "
412 "an Openbox menu or is move/resizing a window and "
413 "we don't want to interrupt them");
416 /* if it's on another desktop */
417 else if (!(self
->desktop
== screen_desktop
||
418 self
->desktop
== DESKTOP_ALL
) &&
419 /* the timestamp is from before you changed desktops */
420 launch_time
&& screen_desktop_user_time
&&
421 !event_time_after(launch_time
, screen_desktop_user_time
))
425 ob_debug_type(OB_DEBUG_FOCUS
,
426 "Not focusing the window because its on another "
429 /* If something is focused, and it's not our relative... */
430 else if (focus_client
&& client_search_focus_tree_full(self
) == NULL
&&
431 client_search_focus_group_full(self
) == NULL
)
433 /* If the user is working in another window right now, then don't
435 if (event_last_user_time
&& launch_time
&&
436 event_time_after(event_last_user_time
, launch_time
) &&
437 event_last_user_time
!= launch_time
&&
438 event_time_after(event_last_user_time
,
439 map_time
- OB_EVENT_USER_TIME_DELAY
))
442 ob_debug_type(OB_DEBUG_FOCUS
,
443 "Not focusing the window because the user is "
444 "working in another window");
446 /* If its a transient (and its parents aren't focused) */
447 else if (client_has_parent(self
)) {
449 ob_debug_type(OB_DEBUG_FOCUS
,
450 "Not focusing the window because it is a "
451 "transient, and its relatives aren't focused");
453 /* Don't steal focus from globally active clients.
454 I stole this idea from KWin. It seems nice.
456 else if (!(focus_client
->can_focus
||
457 focus_client
->focus_notify
))
460 ob_debug_type(OB_DEBUG_FOCUS
,
461 "Not focusing the window because a globally "
462 "active client has focus");
464 /* Don't move focus if it's not going to go to this window
466 else if (client_focus_target(self
) != self
) {
469 ob_debug_type(OB_DEBUG_FOCUS
,
470 "Not focusing the window because another window "
471 "would get the focus anyway");
473 else if (!(self
->desktop
== screen_desktop
||
474 self
->desktop
== DESKTOP_ALL
))
478 ob_debug_type(OB_DEBUG_FOCUS
,
479 "Not focusing the window because it is on "
480 "another desktop and no relatives are focused ");
485 ob_debug_type(OB_DEBUG_FOCUS
,
486 "Focus stealing prevention activated for %s at "
487 "time %u (last user interactioon time %u)",
488 self
->title
, map_time
, event_last_user_time
);
489 /* if the client isn't focused, then hilite it so the user
491 client_hilite(self
, TRUE
);
492 /* we may want to raise it even tho we're not activating it */
493 if (raise
&& !client_restore_session_stacking(self
))
494 stacking_raise(CLIENT_AS_WINDOW(self
));
498 /* This may look rather odd. Well it's because new windows are added
499 to the stacking order non-intrusively. If we're not going to focus
500 the new window or hilite it, then we raise it to the top. This will
501 take affect for things that don't get focused like splash screens.
502 Also if you don't have focus_new enabled, then it's going to get
503 raised to the top. Legacy begets legacy I guess?
505 if (!client_restore_session_stacking(self
))
506 stacking_raise(CLIENT_AS_WINDOW(self
));
509 mouse_grab_for_client(self
, TRUE
);
511 /* this has to happen before we try focus the window, but we want it to
512 happen after the client's stacking has been determined or it looks bad
516 if (!config_focus_under_mouse
)
517 ignore_start
= event_start_ignore_all_enters();
521 if (!config_focus_under_mouse
)
522 event_end_ignore_all_enters(ignore_start
);
526 gboolean stacked
= client_restore_session_stacking(self
);
527 client_present(self
, FALSE
, !stacked
, TRUE
);
530 /* add to client list/map */
531 client_list
= g_list_append(client_list
, self
);
532 window_add(&self
->window
, CLIENT_AS_WINDOW(self
));
534 /* this has to happen after we're in the client_list */
535 if (STRUT_EXISTS(self
->strut
))
536 screen_update_areas();
538 /* update the list hints */
541 /* watch for when the application stops responding. only do this for
542 normal windows, i.e. windows which have titlebars and close buttons
543 and things like that.
544 we don't need to stop pinging on unmanage, because it will be handled
545 automatically by the destroy callback!
547 if (self
->ping
&& client_normal(self
))
548 ping_start(self
, client_ping_event
);
550 /* free the ObAppSettings shallow copy */
553 ob_debug("Managed window 0x%lx plate 0x%x (%s)",
554 window
, self
->frame
->window
, self
->class);
558 ObClient
*client_fake_manage(Window window
)
561 ObAppSettings
*settings
;
563 ob_debug("Pretend-managing window: %lx", window
);
565 /* do this minimal stuff to figure out the client's decorations */
567 self
= g_new0(ObClient
, 1);
568 self
->window
= window
;
570 client_get_all(self
, FALSE
);
571 /* per-app settings override stuff, and return the settings for other
572 uses too. this returns a shallow copy that needs to be freed */
573 settings
= client_get_settings_state(self
);
575 client_setup_decor_and_functions(self
, FALSE
);
577 /* create the decoration frame for the client window and adjust its size */
578 self
->frame
= frame_new(self
);
579 frame_adjust_area(self
->frame
, FALSE
, TRUE
, TRUE
);
581 ob_debug("gave extents left %d right %d top %d bottom %d",
582 self
->frame
->size
.left
, self
->frame
->size
.right
,
583 self
->frame
->size
.top
, self
->frame
->size
.bottom
);
585 /* free the ObAppSettings shallow copy */
591 void client_unmanage_all(void)
593 while (client_list
!= NULL
)
594 client_unmanage(client_list
->data
);
597 void client_unmanage(ObClient
*self
)
603 ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)",
604 self
->window
, self
->frame
->window
,
605 self
->class, self
->title
? self
->title
: "");
607 g_assert(self
!= NULL
);
609 /* we dont want events no more. do this before hiding the frame so we
610 don't generate more events */
611 XSelectInput(obt_display
, self
->window
, NoEventMask
);
613 /* ignore enter events from the unmap so it doesnt mess with the focus */
614 if (!config_focus_under_mouse
)
615 ignore_start
= event_start_ignore_all_enters();
617 frame_hide(self
->frame
);
618 /* flush to send the hide to the server quickly */
621 if (!config_focus_under_mouse
)
622 event_end_ignore_all_enters(ignore_start
);
624 mouse_grab_for_client(self
, FALSE
);
626 /* remove the window from our save set, unless we are managing an internal
629 XChangeSaveSet(obt_display
, self
->window
, SetModeDelete
);
631 /* update the focus lists */
632 focus_order_remove(self
);
633 if (client_focused(self
)) {
634 /* don't leave an invalid focus_client */
638 /* if we're prompting to kill the client, close that */
639 prompt_unref(self
->kill_prompt
);
640 self
->kill_prompt
= NULL
;
642 client_list
= g_list_remove(client_list
, self
);
643 stacking_remove(self
);
644 window_remove(self
->window
);
646 /* once the client is out of the list, update the struts to remove its
648 if (STRUT_EXISTS(self
->strut
))
649 screen_update_areas();
651 client_call_notifies(self
, client_destroy_notifies
);
653 /* tell our parent(s) that we're gone */
654 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
655 ((ObClient
*)it
->data
)->transients
=
656 g_slist_remove(((ObClient
*)it
->data
)->transients
,self
);
658 /* tell our transients that we're gone */
659 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
660 ((ObClient
*)it
->data
)->parents
=
661 g_slist_remove(((ObClient
*)it
->data
)->parents
, self
);
662 /* we could be keeping our children in a higher layer */
663 client_calc_layer(it
->data
);
666 /* remove from its group */
668 group_remove(self
->group
, self
);
672 /* restore the window's original geometry so it is not lost */
678 if (self
->fullscreen
)
679 a
= self
->pre_fullscreen_area
;
680 else if (self
->max_horz
|| self
->max_vert
) {
681 if (self
->max_horz
) {
682 a
.x
= self
->pre_max_area
.x
;
683 a
.width
= self
->pre_max_area
.width
;
685 if (self
->max_vert
) {
686 a
.y
= self
->pre_max_area
.y
;
687 a
.height
= self
->pre_max_area
.height
;
691 self
->fullscreen
= self
->max_horz
= self
->max_vert
= FALSE
;
692 /* let it be moved and resized no matter what */
693 self
->functions
= OB_CLIENT_FUNC_MOVE
| OB_CLIENT_FUNC_RESIZE
;
694 self
->decorations
= 0; /* unmanaged windows have no decor */
696 /* give the client its border back */
697 XSetWindowBorderWidth(obt_display
, self
->window
, self
->border_width
);
699 client_move_resize(self
, a
.x
, a
.y
, a
.width
, a
.height
);
702 /* reparent the window out of the frame, and free the frame */
703 frame_release_client(self
->frame
);
704 frame_free(self
->frame
);
707 if (ob_state() != OB_STATE_EXITING
) {
708 /* these values should not be persisted across a window
710 OBT_PROP_ERASE(self
->window
, NET_WM_DESKTOP
);
711 OBT_PROP_ERASE(self
->window
, NET_WM_STATE
);
712 OBT_PROP_ERASE(self
->window
, WM_STATE
);
714 /* if we're left in an unmapped state, the client wont be mapped.
715 this is bad, since we will no longer be managing the window on
717 XMapWindow(obt_display
, self
->window
);
720 /* these should not be left on the window ever. other window managers
721 don't necessarily use them and it will mess them up (like compiz) */
722 OBT_PROP_ERASE(self
->window
, NET_WM_VISIBLE_NAME
);
723 OBT_PROP_ERASE(self
->window
, NET_WM_VISIBLE_ICON_NAME
);
725 /* update the list hints */
728 ob_debug("Unmanaged window 0x%lx", self
->window
);
730 /* free all data allocated in the client struct */
731 g_slist_free(self
->transients
);
732 for (j
= 0; j
< self
->nicons
; ++j
)
733 g_free(self
->icons
[j
].data
);
734 if (self
->nicons
> 0)
736 g_free(self
->startup_id
);
737 g_free(self
->wm_command
);
739 g_free(self
->icon_title
);
740 g_free(self
->original_title
);
744 g_free(self
->client_machine
);
745 g_free(self
->sm_client_id
);
749 void client_fake_unmanage(ObClient
*self
)
751 /* this is all that got allocated to get the decorations */
753 frame_free(self
->frame
);
757 /*! Returns a new structure containing the per-app settings for this client.
758 The returned structure needs to be freed with g_free. */
759 static ObAppSettings
*client_get_settings_state(ObClient
*self
)
761 ObAppSettings
*settings
;
764 settings
= config_create_app_settings();
766 for (it
= config_per_app_settings
; it
; it
= g_slist_next(it
)) {
767 ObAppSettings
*app
= it
->data
;
768 gboolean match
= TRUE
;
770 g_assert(app
->name
!= NULL
|| app
->class != NULL
);
772 /* we know that either name or class is not NULL so it will have to
773 match to use the rule */
775 !g_pattern_match(app
->name
, strlen(self
->name
), self
->name
, NULL
))
777 else if (app
->class &&
778 !g_pattern_match(app
->class,
779 strlen(self
->class), self
->class, NULL
))
781 else if (app
->role
&&
782 !g_pattern_match(app
->role
,
783 strlen(self
->role
), self
->role
, NULL
))
787 ob_debug("Window matching: %s", app
->name
);
789 /* copy the settings to our struct, overriding the existing
790 settings if they are not defaults */
791 config_app_settings_copy_non_defaults(app
, settings
);
795 if (settings
->shade
!= -1)
796 self
->shaded
= !!settings
->shade
;
797 if (settings
->decor
!= -1)
798 self
->undecorated
= !settings
->decor
;
799 if (settings
->iconic
!= -1)
800 self
->iconic
= !!settings
->iconic
;
801 if (settings
->skip_pager
!= -1)
802 self
->skip_pager
= !!settings
->skip_pager
;
803 if (settings
->skip_taskbar
!= -1)
804 self
->skip_taskbar
= !!settings
->skip_taskbar
;
806 if (settings
->max_vert
!= -1)
807 self
->max_vert
= !!settings
->max_vert
;
808 if (settings
->max_horz
!= -1)
809 self
->max_horz
= !!settings
->max_horz
;
811 if (settings
->fullscreen
!= -1)
812 self
->fullscreen
= !!settings
->fullscreen
;
814 if (settings
->desktop
) {
815 if (settings
->desktop
== DESKTOP_ALL
)
816 self
->desktop
= settings
->desktop
;
817 else if (settings
->desktop
> 0 &&
818 settings
->desktop
<= screen_num_desktops
)
819 self
->desktop
= settings
->desktop
- 1;
822 if (settings
->layer
== -1) {
826 else if (settings
->layer
== 0) {
830 else if (settings
->layer
== 1) {
837 static void client_restore_session_state(ObClient
*self
)
841 ob_debug_type(OB_DEBUG_SM
,
842 "Restore session for client %s", self
->title
);
844 if (!(it
= session_state_find(self
))) {
845 ob_debug_type(OB_DEBUG_SM
,
846 "Session data not found for client %s", self
->title
);
850 self
->session
= it
->data
;
852 ob_debug_type(OB_DEBUG_SM
, "Session data loaded for client %s",
855 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
856 self
->positioned
= USPosition
;
857 self
->sized
= USSize
;
858 if (self
->session
->w
> 0)
859 self
->area
.width
= self
->session
->w
;
860 if (self
->session
->h
> 0)
861 self
->area
.height
= self
->session
->h
;
862 XResizeWindow(obt_display
, self
->window
,
863 self
->area
.width
, self
->area
.height
);
865 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
866 self
->session
->desktop
:
867 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
868 OBT_PROP_SET32(self
->window
, NET_WM_DESKTOP
, CARDINAL
, self
->desktop
);
870 self
->shaded
= self
->session
->shaded
;
871 self
->iconic
= self
->session
->iconic
;
872 self
->skip_pager
= self
->session
->skip_pager
;
873 self
->skip_taskbar
= self
->session
->skip_taskbar
;
874 self
->fullscreen
= self
->session
->fullscreen
;
875 self
->above
= self
->session
->above
;
876 self
->below
= self
->session
->below
;
877 self
->max_horz
= self
->session
->max_horz
;
878 self
->max_vert
= self
->session
->max_vert
;
879 self
->undecorated
= self
->session
->undecorated
;
882 static gboolean
client_restore_session_stacking(ObClient
*self
)
886 if (!self
->session
) return FALSE
;
888 mypos
= g_list_find(session_saved_state
, self
->session
);
889 if (!mypos
) return FALSE
;
891 /* start above me and look for the first client */
892 for (it
= g_list_previous(mypos
); it
; it
= g_list_previous(it
)) {
895 for (cit
= client_list
; cit
; cit
= g_list_next(cit
)) {
896 ObClient
*c
= cit
->data
;
897 /* found a client that was in the session, so go below it */
898 if (c
->session
== it
->data
) {
899 stacking_below(CLIENT_AS_WINDOW(self
),
900 CLIENT_AS_WINDOW(cit
->data
));
908 void client_move_onscreen(ObClient
*self
, gboolean rude
)
910 gint x
= self
->area
.x
;
911 gint y
= self
->area
.y
;
912 if (client_find_onscreen(self
, &x
, &y
,
914 self
->area
.height
, rude
)) {
915 client_move(self
, x
, y
);
919 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
922 gint ox
= *x
, oy
= *y
;
923 gboolean rudel
= rude
, ruder
= rude
, rudet
= rude
, rudeb
= rude
;
929 RECT_SET(desired
, *x
, *y
, w
, h
);
930 frame_rect_to_frame(self
->frame
, &desired
);
932 /* get where the frame would be */
933 frame_client_gravity(self
->frame
, x
, y
);
935 /* get the requested size of the window with decorations */
936 fw
= self
->frame
->size
.left
+ w
+ self
->frame
->size
.right
;
937 fh
= self
->frame
->size
.top
+ h
+ self
->frame
->size
.bottom
;
939 /* If rudeness wasn't requested, then still be rude in a given direction
940 if the client is not moving, only resizing in that direction */
942 Point oldtl
, oldtr
, oldbl
, oldbr
;
943 Point newtl
, newtr
, newbl
, newbr
;
944 gboolean stationary_l
, stationary_r
, stationary_t
, stationary_b
;
946 POINT_SET(oldtl
, self
->frame
->area
.x
, self
->frame
->area
.y
);
947 POINT_SET(oldbr
, self
->frame
->area
.x
+ self
->frame
->area
.width
- 1,
948 self
->frame
->area
.y
+ self
->frame
->area
.height
- 1);
949 POINT_SET(oldtr
, oldbr
.x
, oldtl
.y
);
950 POINT_SET(oldbl
, oldtl
.x
, oldbr
.y
);
952 POINT_SET(newtl
, *x
, *y
);
953 POINT_SET(newbr
, *x
+ fw
- 1, *y
+ fh
- 1);
954 POINT_SET(newtr
, newbr
.x
, newtl
.y
);
955 POINT_SET(newbl
, newtl
.x
, newbr
.y
);
957 /* is it moving or just resizing from some corner? */
958 stationary_l
= oldtl
.x
== newtl
.x
;
959 stationary_r
= oldtr
.x
== newtr
.x
;
960 stationary_t
= oldtl
.y
== newtl
.y
;
961 stationary_b
= oldbl
.y
== newbl
.y
;
963 /* if left edge is growing and didnt move right edge */
964 if (stationary_r
&& newtl
.x
< oldtl
.x
)
966 /* if right edge is growing and didnt move left edge */
967 if (stationary_l
&& newtr
.x
> oldtr
.x
)
969 /* if top edge is growing and didnt move bottom edge */
970 if (stationary_b
&& newtl
.y
< oldtl
.y
)
972 /* if bottom edge is growing and didnt move top edge */
973 if (stationary_t
&& newbl
.y
> oldbl
.y
)
977 /* we iterate through every monitor that the window is at least partially
978 on, to make sure it is obeying the rules on them all
980 if the window does not appear on any monitors, then use the first one
983 for (i
= 0; i
< screen_num_monitors
; ++i
) {
986 if (!screen_physical_area_monitor_contains(i
, &desired
)) {
987 if (i
< screen_num_monitors
- 1 || found_mon
)
990 /* the window is not inside any monitor! so just use the first
992 a
= screen_area(self
->desktop
, 0, NULL
);
995 a
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
, &desired
);
998 /* This makes sure windows aren't entirely outside of the screen so you
999 can't see them at all.
1000 It makes sure 10% of the window is on the screen at least. At don't
1001 let it move itself off the top of the screen, which would hide the
1002 titlebar on you. (The user can still do this if they want too, it's
1003 only limiting the application.
1005 if (client_normal(self
)) {
1006 if (!self
->strut
.right
&& *x
+ fw
/10 >= a
->x
+ a
->width
- 1)
1007 *x
= a
->x
+ a
->width
- fw
/10;
1008 if (!self
->strut
.bottom
&& *y
+ fh
/10 >= a
->y
+ a
->height
- 1)
1009 *y
= a
->y
+ a
->height
- fh
/10;
1010 if (!self
->strut
.left
&& *x
+ fw
*9/10 - 1 < a
->x
)
1011 *x
= a
->x
- fw
*9/10;
1012 if (!self
->strut
.top
&& *y
+ fh
*9/10 - 1 < a
->y
)
1013 *y
= a
->y
- fh
*9/10;
1016 /* This here doesn't let windows even a pixel outside the
1017 struts/screen. When called from client_manage, programs placing
1018 themselves are forced completely onscreen, while things like
1019 xterm -geometry resolution-width/2 will work fine. Trying to
1020 place it completely offscreen will be handled in the above code.
1021 Sorry for this confused comment, i am tired. */
1022 if (rudel
&& !self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
1023 if (ruder
&& !self
->strut
.right
&& *x
+ fw
> a
->x
+ a
->width
)
1024 *x
= a
->x
+ MAX(0, a
->width
- fw
);
1026 if (rudet
&& !self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
1027 if (rudeb
&& !self
->strut
.bottom
&& *y
+ fh
> a
->y
+ a
->height
)
1028 *y
= a
->y
+ MAX(0, a
->height
- fh
);
1033 /* get where the client should be */
1034 frame_frame_gravity(self
->frame
, x
, y
);
1036 return ox
!= *x
|| oy
!= *y
;
1039 static void client_get_all(ObClient
*self
, gboolean real
)
1041 /* this is needed for the frame to set itself up */
1042 client_get_area(self
);
1044 /* these things can change the decor and functions of the window */
1046 client_get_mwm_hints(self
);
1047 /* this can change the mwmhints for special cases */
1048 client_get_type_and_transientness(self
);
1049 client_get_state(self
);
1050 client_update_normal_hints(self
);
1052 /* get the session related properties, these can change decorations
1053 from per-app settings */
1054 client_get_session_ids(self
);
1056 /* now we got everything that can affect the decorations */
1060 /* get this early so we have it for debugging */
1061 client_update_title(self
);
1063 client_update_protocols(self
);
1065 client_update_wmhints(self
);
1066 /* this may have already been called from client_update_wmhints */
1067 if (!self
->parents
&& !self
->transient_for_group
)
1068 client_update_transient_for(self
);
1070 client_get_startup_id(self
);
1071 client_get_desktop(self
);/* uses transient data/group/startup id if a
1072 desktop is not specified */
1073 client_get_shaped(self
);
1076 /* a couple type-based defaults for new windows */
1078 /* this makes sure that these windows appear on all desktops */
1079 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
1080 self
->desktop
= DESKTOP_ALL
;
1084 client_update_sync_request_counter(self
);
1087 client_get_colormap(self
);
1088 client_update_strut(self
);
1089 client_update_icons(self
);
1090 client_update_icon_geometry(self
);
1093 static void client_get_startup_id(ObClient
*self
)
1095 if (!(OBT_PROP_GETS(self
->window
, NET_STARTUP_ID
, utf8
,
1096 &self
->startup_id
)))
1098 OBT_PROP_GETS(self
->group
->leader
,
1099 NET_STARTUP_ID
, utf8
, &self
->startup_id
);
1102 static void client_get_area(ObClient
*self
)
1104 XWindowAttributes wattrib
;
1107 ret
= XGetWindowAttributes(obt_display
, self
->window
, &wattrib
);
1108 g_assert(ret
!= BadWindow
);
1110 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
1111 POINT_SET(self
->root_pos
, wattrib
.x
, wattrib
.y
);
1112 self
->border_width
= wattrib
.border_width
;
1114 ob_debug("client area: %d %d %d %d bw %d", wattrib
.x
, wattrib
.y
,
1115 wattrib
.width
, wattrib
.height
, wattrib
.border_width
);
1118 static void client_get_desktop(ObClient
*self
)
1120 guint32 d
= screen_num_desktops
; /* an always-invalid value */
1122 if (OBT_PROP_GET32(self
->window
, NET_WM_DESKTOP
, CARDINAL
, &d
)) {
1123 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
1124 self
->desktop
= screen_num_desktops
- 1;
1127 ob_debug("client requested desktop 0x%x", self
->desktop
);
1130 gboolean first
= TRUE
;
1131 guint all
= screen_num_desktops
; /* not a valid value */
1133 /* if they are all on one desktop, then open it on the
1135 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
1136 ObClient
*c
= it
->data
;
1138 if (c
->desktop
== DESKTOP_ALL
) continue;
1144 else if (all
!= c
->desktop
)
1145 all
= screen_num_desktops
; /* make it invalid */
1147 if (all
!= screen_num_desktops
) {
1148 self
->desktop
= all
;
1150 ob_debug("client desktop set from parents: 0x%x",
1153 /* try get from the startup-notification protocol */
1154 else if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
1155 if (self
->desktop
>= screen_num_desktops
&&
1156 self
->desktop
!= DESKTOP_ALL
)
1157 self
->desktop
= screen_num_desktops
- 1;
1158 ob_debug("client desktop set from startup-notification: 0x%x",
1161 /* defaults to the current desktop */
1163 self
->desktop
= screen_desktop
;
1164 ob_debug("client desktop set to the current desktop: %d",
1170 static void client_get_state(ObClient
*self
)
1175 if (OBT_PROP_GETA32(self
->window
, NET_WM_STATE
, ATOM
, &state
, &num
)) {
1177 for (i
= 0; i
< num
; ++i
) {
1178 if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_MODAL
))
1180 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_SHADED
))
1181 self
->shaded
= TRUE
;
1182 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN
))
1183 self
->iconic
= TRUE
;
1184 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR
))
1185 self
->skip_taskbar
= TRUE
;
1186 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER
))
1187 self
->skip_pager
= TRUE
;
1188 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN
))
1189 self
->fullscreen
= TRUE
;
1190 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT
))
1191 self
->max_vert
= TRUE
;
1192 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ
))
1193 self
->max_horz
= TRUE
;
1194 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_ABOVE
))
1196 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_BELOW
))
1198 else if (state
[i
] == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION
))
1199 self
->demands_attention
= TRUE
;
1200 else if (state
[i
] == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED
))
1201 self
->undecorated
= TRUE
;
1208 static void client_get_shaped(ObClient
*self
)
1210 self
->shaped
= FALSE
;
1212 if (obt_display_extension_shape
) {
1217 XShapeSelectInput(obt_display
, self
->window
, ShapeNotifyMask
);
1219 XShapeQueryExtents(obt_display
, self
->window
, &s
, &foo
,
1220 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
1222 self
->shaped
= (s
!= 0);
1227 void client_update_transient_for(ObClient
*self
)
1230 ObClient
*target
= NULL
;
1231 gboolean trangroup
= FALSE
;
1233 if (XGetTransientForHint(obt_display
, self
->window
, &t
)) {
1234 if (t
!= self
->window
) { /* cant be transient to itself! */
1235 ObWindow
*tw
= window_find(t
);
1236 /* if this happens then we need to check for it*/
1237 g_assert(tw
!= CLIENT_AS_WINDOW(self
));
1238 if (tw
&& WINDOW_IS_CLIENT(tw
)) {
1239 /* watch out for windows with a parent that is something
1240 different, like a dockapp for example */
1241 target
= WINDOW_AS_CLIENT(tw
);
1245 /* Setting the transient_for to Root is actually illegal, however
1246 applications from time have done this to specify transient for
1248 if (!target
&& self
->group
&& t
== obt_root(ob_screen
))
1250 } else if (self
->group
&& self
->transient
)
1253 client_update_transient_tree(self
, self
->group
, self
->group
,
1254 self
->transient_for_group
, trangroup
,
1255 client_direct_parent(self
), target
);
1256 self
->transient_for_group
= trangroup
;
1260 static void client_update_transient_tree(ObClient
*self
,
1261 ObGroup
*oldgroup
, ObGroup
*newgroup
,
1262 gboolean oldgtran
, gboolean newgtran
,
1263 ObClient
* oldparent
,
1264 ObClient
*newparent
)
1269 g_assert(!oldgtran
|| oldgroup
);
1270 g_assert(!newgtran
|| newgroup
);
1271 g_assert((!oldgtran
&& !oldparent
) ||
1272 (oldgtran
&& !oldparent
) ||
1273 (!oldgtran
&& oldparent
));
1274 g_assert((!newgtran
&& !newparent
) ||
1275 (newgtran
&& !newparent
) ||
1276 (!newgtran
&& newparent
));
1279 Group transient windows are not allowed to have other group
1280 transient windows as their children.
1284 /* No change has occured */
1285 if (oldgroup
== newgroup
&&
1286 oldgtran
== newgtran
&&
1287 oldparent
== newparent
) return;
1289 /** Remove the client from the transient tree **/
1291 for (it
= self
->transients
; it
; it
= next
) {
1292 next
= g_slist_next(it
);
1294 self
->transients
= g_slist_delete_link(self
->transients
, it
);
1295 c
->parents
= g_slist_remove(c
->parents
, self
);
1297 for (it
= self
->parents
; it
; it
= next
) {
1298 next
= g_slist_next(it
);
1300 self
->parents
= g_slist_delete_link(self
->parents
, it
);
1301 c
->transients
= g_slist_remove(c
->transients
, self
);
1304 /** Re-add the client to the transient tree **/
1306 /* If we're transient for a group then we need to add ourselves to all our
1309 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1312 !client_search_top_direct_parent(c
)->transient_for_group
&&
1315 c
->transients
= g_slist_prepend(c
->transients
, self
);
1316 self
->parents
= g_slist_prepend(self
->parents
, c
);
1321 /* If we are now transient for a single window we need to add ourselves to
1324 WARNING: Cyclical transient ness is possible if two windows are
1325 transient for eachother.
1327 else if (newparent
&&
1328 /* don't make ourself its child if it is already our child */
1329 !client_is_direct_child(self
, newparent
) &&
1330 client_normal(newparent
))
1332 newparent
->transients
= g_slist_prepend(newparent
->transients
, self
);
1333 self
->parents
= g_slist_prepend(self
->parents
, newparent
);
1336 /* Add any group transient windows to our children. But if we're transient
1337 for the group, then other group transients are not our children.
1339 WARNING: Cyclical transient-ness is possible. For e.g. if:
1340 A is transient for the group
1341 B is transient for A
1342 C is transient for B
1343 A can't be transient for C or we have a cycle
1345 if (!newgtran
&& newgroup
&&
1347 !client_search_top_direct_parent(newparent
)->transient_for_group
) &&
1348 client_normal(self
))
1350 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1352 if (c
!= self
&& c
->transient_for_group
&&
1353 /* Don't make it our child if it is already our parent */
1354 !client_is_direct_child(c
, self
))
1356 self
->transients
= g_slist_prepend(self
->transients
, c
);
1357 c
->parents
= g_slist_prepend(c
->parents
, self
);
1362 /** If we change our group transient-ness, our children change their
1363 effect group transient-ness, which affects how they relate to other
1366 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
1368 if (!c
->transient_for_group
)
1369 client_update_transient_tree(c
, c
->group
, c
->group
,
1370 c
->transient_for_group
,
1371 c
->transient_for_group
,
1372 client_direct_parent(c
),
1373 client_direct_parent(c
));
1377 static void client_get_mwm_hints(ObClient
*self
)
1382 self
->mwmhints
.flags
= 0; /* default to none */
1384 if (OBT_PROP_GETA32(self
->window
, MOTIF_WM_HINTS
, MOTIF_WM_HINTS
,
1386 if (num
>= OB_MWM_ELEMENTS
) {
1387 self
->mwmhints
.flags
= hints
[0];
1388 self
->mwmhints
.functions
= hints
[1];
1389 self
->mwmhints
.decorations
= hints
[2];
1395 void client_get_type_and_transientness(ObClient
*self
)
1402 self
->transient
= FALSE
;
1404 if (OBT_PROP_GETA32(self
->window
, NET_WM_WINDOW_TYPE
, ATOM
, &val
, &num
)) {
1405 /* use the first value that we know about in the array */
1406 for (i
= 0; i
< num
; ++i
) {
1407 if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP
))
1408 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1409 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK
))
1410 self
->type
= OB_CLIENT_TYPE_DOCK
;
1411 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR
))
1412 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1413 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU
))
1414 self
->type
= OB_CLIENT_TYPE_MENU
;
1415 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY
))
1416 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1417 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH
))
1418 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1419 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG
))
1420 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1421 else if (val
[i
] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL
))
1422 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1423 else if (val
[i
] == OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE
))
1425 /* prevent this window from getting any decor or
1427 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1428 OB_MWM_FLAG_DECORATIONS
);
1429 self
->mwmhints
.decorations
= 0;
1430 self
->mwmhints
.functions
= 0;
1432 if (self
->type
!= (ObClientType
) -1)
1433 break; /* grab the first legit type */
1438 if (XGetTransientForHint(obt_display
, self
->window
, &t
))
1439 self
->transient
= TRUE
;
1441 if (self
->type
== (ObClientType
) -1) {
1442 /*the window type hint was not set, which means we either classify
1443 ourself as a normal window or a dialog, depending on if we are a
1445 if (self
->transient
)
1446 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1448 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1451 /* then, based on our type, we can update our transientness.. */
1452 if (self
->type
== OB_CLIENT_TYPE_DIALOG
||
1453 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
1454 self
->type
== OB_CLIENT_TYPE_MENU
||
1455 self
->type
== OB_CLIENT_TYPE_UTILITY
)
1457 self
->transient
= TRUE
;
1461 void client_update_protocols(ObClient
*self
)
1466 self
->focus_notify
= FALSE
;
1467 self
->delete_window
= FALSE
;
1469 if (OBT_PROP_GETA32(self
->window
, WM_PROTOCOLS
, ATOM
, &proto
, &num_ret
)) {
1470 for (i
= 0; i
< num_ret
; ++i
) {
1471 if (proto
[i
] == OBT_PROP_ATOM(WM_DELETE_WINDOW
))
1472 /* this means we can request the window to close */
1473 self
->delete_window
= TRUE
;
1474 else if (proto
[i
] == OBT_PROP_ATOM(WM_TAKE_FOCUS
))
1475 /* if this protocol is requested, then the window will be
1476 notified whenever we want it to receive focus */
1477 self
->focus_notify
= TRUE
;
1478 else if (proto
[i
] == OBT_PROP_ATOM(NET_WM_PING
))
1479 /* if this protocol is requested, then the window will allow
1480 pings to determine if it is still alive */
1483 else if (proto
[i
] == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST
))
1484 /* if this protocol is requested, then resizing the
1485 window will be synchronized between the frame and the
1487 self
->sync_request
= TRUE
;
1495 void client_update_sync_request_counter(ObClient
*self
)
1499 if (OBT_PROP_GET32(self
->window
, NET_WM_SYNC_REQUEST_COUNTER
, CARDINAL
,&i
))
1501 self
->sync_counter
= i
;
1503 self
->sync_counter
= None
;
1507 static void client_get_colormap(ObClient
*self
)
1509 XWindowAttributes wa
;
1511 if (XGetWindowAttributes(obt_display
, self
->window
, &wa
))
1512 client_update_colormap(self
, wa
.colormap
);
1515 void client_update_colormap(ObClient
*self
, Colormap colormap
)
1517 if (colormap
== self
->colormap
) return;
1519 ob_debug("Setting client %s colormap: 0x%x", self
->title
, colormap
);
1521 if (client_focused(self
)) {
1522 screen_install_colormap(self
, FALSE
); /* uninstall old one */
1523 self
->colormap
= colormap
;
1524 screen_install_colormap(self
, FALSE
); /* install new one */
1526 self
->colormap
= colormap
;
1529 void client_update_normal_hints(ObClient
*self
)
1535 self
->min_ratio
= 0.0f
;
1536 self
->max_ratio
= 0.0f
;
1537 SIZE_SET(self
->size_inc
, 1, 1);
1538 SIZE_SET(self
->base_size
, 0, 0);
1539 SIZE_SET(self
->min_size
, 0, 0);
1540 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1542 /* get the hints from the window */
1543 if (XGetWMNormalHints(obt_display
, self
->window
, &size
, &ret
)) {
1544 /* normal windows can't request placement! har har
1545 if (!client_normal(self))
1547 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1548 self
->sized
= (size
.flags
& (PSize
|USSize
));
1550 if (size
.flags
& PWinGravity
)
1551 self
->gravity
= size
.win_gravity
;
1553 if (size
.flags
& PAspect
) {
1554 if (size
.min_aspect
.y
)
1556 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1557 if (size
.max_aspect
.y
)
1559 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1562 if (size
.flags
& PMinSize
)
1563 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1565 if (size
.flags
& PMaxSize
)
1566 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1568 if (size
.flags
& PBaseSize
)
1569 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1571 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1572 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1574 ob_debug("Normal hints: min size (%d %d) max size (%d %d)",
1575 self
->min_size
.width
, self
->min_size
.height
,
1576 self
->max_size
.width
, self
->max_size
.height
);
1577 ob_debug("size inc (%d %d) base size (%d %d)",
1578 self
->size_inc
.width
, self
->size_inc
.height
,
1579 self
->base_size
.width
, self
->base_size
.height
);
1582 ob_debug("Normal hints: not set");
1585 void client_setup_decor_and_functions(ObClient
*self
, gboolean reconfig
)
1587 /* start with everything (cept fullscreen) */
1589 (OB_FRAME_DECOR_TITLEBAR
|
1590 OB_FRAME_DECOR_HANDLE
|
1591 OB_FRAME_DECOR_GRIPS
|
1592 OB_FRAME_DECOR_BORDER
|
1593 OB_FRAME_DECOR_ICON
|
1594 OB_FRAME_DECOR_ALLDESKTOPS
|
1595 OB_FRAME_DECOR_ICONIFY
|
1596 OB_FRAME_DECOR_MAXIMIZE
|
1597 OB_FRAME_DECOR_SHADE
|
1598 OB_FRAME_DECOR_CLOSE
);
1600 (OB_CLIENT_FUNC_RESIZE
|
1601 OB_CLIENT_FUNC_MOVE
|
1602 OB_CLIENT_FUNC_ICONIFY
|
1603 OB_CLIENT_FUNC_MAXIMIZE
|
1604 OB_CLIENT_FUNC_SHADE
|
1605 OB_CLIENT_FUNC_CLOSE
|
1606 OB_CLIENT_FUNC_BELOW
|
1607 OB_CLIENT_FUNC_ABOVE
|
1608 OB_CLIENT_FUNC_UNDECORATE
);
1610 if (!(self
->min_size
.width
< self
->max_size
.width
||
1611 self
->min_size
.height
< self
->max_size
.height
))
1612 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1614 switch (self
->type
) {
1615 case OB_CLIENT_TYPE_NORMAL
:
1616 /* normal windows retain all of the possible decorations and
1617 functionality, and can be fullscreen */
1618 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1621 case OB_CLIENT_TYPE_DIALOG
:
1622 /* sometimes apps make dialog windows fullscreen for some reason (for
1623 e.g. kpdf does this..) */
1624 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1627 case OB_CLIENT_TYPE_UTILITY
:
1628 /* these windows don't have anything added or removed by default */
1631 case OB_CLIENT_TYPE_MENU
:
1632 case OB_CLIENT_TYPE_TOOLBAR
:
1633 /* these windows can't iconify or maximize */
1634 self
->decorations
&= ~(OB_FRAME_DECOR_ICONIFY
|
1635 OB_FRAME_DECOR_MAXIMIZE
);
1636 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
|
1637 OB_CLIENT_FUNC_MAXIMIZE
);
1640 case OB_CLIENT_TYPE_SPLASH
:
1641 /* these don't get get any decorations, and the only thing you can
1642 do with them is move them */
1643 self
->decorations
= 0;
1644 self
->functions
= OB_CLIENT_FUNC_MOVE
;
1647 case OB_CLIENT_TYPE_DESKTOP
:
1648 /* these windows are not manipulated by the window manager */
1649 self
->decorations
= 0;
1650 self
->functions
= 0;
1653 case OB_CLIENT_TYPE_DOCK
:
1654 /* these windows are not manipulated by the window manager, but they
1655 can set below layer which has a special meaning */
1656 self
->decorations
= 0;
1657 self
->functions
= OB_CLIENT_FUNC_BELOW
;
1661 /* Mwm Hints are applied subtractively to what has already been chosen for
1662 decor and functionality */
1663 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1664 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1665 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1666 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1668 /* if the mwm hints request no handle or title, then all
1669 decorations are disabled, but keep the border if that's
1671 if (self
->mwmhints
.decorations
& OB_MWM_DECOR_BORDER
)
1672 self
->decorations
= OB_FRAME_DECOR_BORDER
;
1674 self
->decorations
= 0;
1679 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1680 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1681 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1682 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1683 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1684 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1685 /* dont let mwm hints kill any buttons
1686 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1687 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1688 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1689 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1691 /* dont let mwm hints kill the close button
1692 if (! (self->mwmhints.functions & MwmFunc_Close))
1693 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1697 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1698 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1699 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1700 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1701 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1702 self
->decorations
&= ~(OB_FRAME_DECOR_GRIPS
| OB_FRAME_DECOR_HANDLE
);
1704 /* can't maximize without moving/resizing */
1705 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1706 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1707 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1708 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1709 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1712 if (self
->max_horz
&& self
->max_vert
) {
1713 /* you can't resize fully maximized windows */
1714 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1715 /* kill the handle on fully maxed windows */
1716 self
->decorations
&= ~(OB_FRAME_DECOR_HANDLE
| OB_FRAME_DECOR_GRIPS
);
1719 /* If there are no decorations to remove, don't allow the user to try
1721 if (self
->decorations
== 0)
1722 self
->functions
&= ~OB_CLIENT_FUNC_UNDECORATE
;
1724 /* finally, the user can have requested no decorations, which overrides
1725 everything (but doesnt give it a border if it doesnt have one) */
1726 if (self
->undecorated
)
1727 self
->decorations
= 0;
1729 /* if we don't have a titlebar, then we cannot shade! */
1730 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1731 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1733 /* now we need to check against rules for the client's current state */
1734 if (self
->fullscreen
) {
1735 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1736 OB_CLIENT_FUNC_FULLSCREEN
|
1737 OB_CLIENT_FUNC_ICONIFY
);
1738 self
->decorations
= 0;
1741 client_change_allowed_actions(self
);
1744 /* force reconfigure to make sure decorations are updated */
1745 client_reconfigure(self
, TRUE
);
1748 static void client_change_allowed_actions(ObClient
*self
)
1753 /* desktop windows are kept on all desktops */
1754 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1755 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP
);
1757 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1758 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE
);
1759 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1760 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE
);
1761 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1762 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE
);
1763 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1764 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE
);
1765 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1766 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE
);
1767 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1768 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN
);
1769 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1770 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ
);
1771 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT
);
1773 if (self
->functions
& OB_CLIENT_FUNC_ABOVE
)
1774 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE
);
1775 if (self
->functions
& OB_CLIENT_FUNC_BELOW
)
1776 actions
[num
++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW
);
1777 if (self
->functions
& OB_CLIENT_FUNC_UNDECORATE
)
1778 actions
[num
++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE
);
1780 OBT_PROP_SETA32(self
->window
, NET_WM_ALLOWED_ACTIONS
, ATOM
, actions
, num
);
1782 /* make sure the window isn't breaking any rules now
1784 don't check ICONIFY here. just cuz a window can't iconify doesnt mean
1785 it can't be iconified with its parent
1788 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1789 if (self
->frame
) client_shade(self
, FALSE
);
1790 else self
->shaded
= FALSE
;
1792 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1793 if (self
->frame
) client_fullscreen(self
, FALSE
);
1794 else self
->fullscreen
= FALSE
;
1796 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1798 if (self
->frame
) client_maximize(self
, FALSE
, 0);
1799 else self
->max_vert
= self
->max_horz
= FALSE
;
1803 void client_update_wmhints(ObClient
*self
)
1807 /* assume a window takes input if it doesnt specify */
1808 self
->can_focus
= TRUE
;
1810 if ((hints
= XGetWMHints(obt_display
, self
->window
)) != NULL
) {
1813 if (hints
->flags
& InputHint
)
1814 self
->can_focus
= hints
->input
;
1816 /* only do this when first managing the window *AND* when we aren't
1818 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1819 if (hints
->flags
& StateHint
)
1820 self
->iconic
= hints
->initial_state
== IconicState
;
1823 self
->urgent
= (hints
->flags
& XUrgencyHint
);
1824 if (self
->urgent
&& !ur
)
1825 client_hilite(self
, TRUE
);
1826 else if (!self
->urgent
&& ur
&& self
->demands_attention
)
1827 client_hilite(self
, FALSE
);
1829 if (!(hints
->flags
& WindowGroupHint
))
1830 hints
->window_group
= None
;
1832 /* did the group state change? */
1833 if (hints
->window_group
!=
1834 (self
->group
? self
->group
->leader
: None
))
1836 ObGroup
*oldgroup
= self
->group
;
1838 /* remove from the old group if there was one */
1839 if (self
->group
!= NULL
) {
1840 group_remove(self
->group
, self
);
1844 /* add ourself to the group if we have one */
1845 if (hints
->window_group
!= None
) {
1846 self
->group
= group_add(hints
->window_group
, self
);
1849 /* Put ourselves into the new group's transient tree, and remove
1850 ourselves from the old group's */
1851 client_update_transient_tree(self
, oldgroup
, self
->group
,
1852 self
->transient_for_group
,
1853 self
->transient_for_group
,
1854 client_direct_parent(self
),
1855 client_direct_parent(self
));
1857 /* Lastly, being in a group, or not, can change if the window is
1858 transient for anything.
1860 The logic for this is:
1861 self->transient = TRUE always if the window wants to be
1862 transient for something, even if transient_for was NULL because
1863 it wasn't in a group before.
1865 If parents was NULL and oldgroup was NULL we can assume
1866 that when we add the new group, it will become transient for
1869 If transient_for_group is TRUE, then it must have already
1870 had a group. If it is getting a new group, the above call to
1871 client_update_transient_tree has already taken care of
1872 everything ! If it is losing all group status then it will
1873 no longer be transient for anything and that needs to be
1876 if (self
->transient
&&
1877 ((self
->parents
== NULL
&& oldgroup
== NULL
) ||
1878 (self
->transient_for_group
&& !self
->group
)))
1879 client_update_transient_for(self
);
1882 /* the WM_HINTS can contain an icon */
1883 if (hints
->flags
& IconPixmapHint
)
1884 client_update_icons(self
);
1890 void client_update_title(ObClient
*self
)
1893 gchar
*visible
= NULL
;
1895 g_free(self
->title
);
1896 g_free(self
->original_title
);
1899 if (!OBT_PROP_GETS(self
->window
, NET_WM_NAME
, utf8
, &data
)) {
1900 /* try old x stuff */
1901 if (!(OBT_PROP_GETS(self
->window
, WM_NAME
, locale
, &data
)
1902 || OBT_PROP_GETS(self
->window
, WM_NAME
, utf8
, &data
))) {
1903 if (self
->transient
) {
1905 GNOME alert windows are not given titles:
1906 http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1908 data
= g_strdup("");
1910 data
= g_strdup("Unnamed Window");
1913 self
->original_title
= g_strdup(data
);
1915 if (self
->client_machine
) {
1916 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
1921 if (self
->not_responding
) {
1923 if (self
->kill_level
> 0)
1924 visible
= g_strdup_printf("%s - [%s]", data
, _("Killing..."));
1926 visible
= g_strdup_printf("%s - [%s]", data
, _("Not Responding"));
1930 OBT_PROP_SETS(self
->window
, NET_WM_VISIBLE_NAME
, utf8
, visible
);
1931 self
->title
= visible
;
1934 frame_adjust_title(self
->frame
);
1936 /* update the icon title */
1938 g_free(self
->icon_title
);
1941 if (!OBT_PROP_GETS(self
->window
, NET_WM_ICON_NAME
, utf8
, &data
))
1942 /* try old x stuff */
1943 if (!(OBT_PROP_GETS(self
->window
, WM_ICON_NAME
, locale
, &data
) ||
1944 OBT_PROP_GETS(self
->window
, WM_ICON_NAME
, utf8
, &data
)))
1945 data
= g_strdup(self
->title
);
1947 if (self
->client_machine
) {
1948 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
1953 if (self
->not_responding
) {
1955 if (self
->kill_level
> 0)
1956 visible
= g_strdup_printf("%s - [%s]", data
, _("Killing..."));
1958 visible
= g_strdup_printf("%s - [%s]", data
, _("Not Responding"));
1962 OBT_PROP_SETS(self
->window
, NET_WM_VISIBLE_ICON_NAME
, utf8
, visible
);
1963 self
->icon_title
= visible
;
1966 void client_update_strut(ObClient
*self
)
1970 gboolean got
= FALSE
;
1973 if (OBT_PROP_GETA32(self
->window
, NET_WM_STRUT_PARTIAL
, CARDINAL
,
1978 STRUT_PARTIAL_SET(strut
,
1979 data
[0], data
[2], data
[1], data
[3],
1980 data
[4], data
[5], data
[8], data
[9],
1981 data
[6], data
[7], data
[10], data
[11]);
1987 OBT_PROP_GETA32(self
->window
, NET_WM_STRUT
, CARDINAL
, &data
, &num
)) {
1993 /* use the screen's width/height */
1994 a
= screen_physical_area_all_monitors();
1996 STRUT_PARTIAL_SET(strut
,
1997 data
[0], data
[2], data
[1], data
[3],
1998 a
->y
, a
->y
+ a
->height
- 1,
1999 a
->x
, a
->x
+ a
->width
- 1,
2000 a
->y
, a
->y
+ a
->height
- 1,
2001 a
->x
, a
->x
+ a
->width
- 1);
2008 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
2009 0, 0, 0, 0, 0, 0, 0, 0);
2011 if (!STRUT_EQUAL(strut
, self
->strut
)) {
2012 self
->strut
= strut
;
2014 /* updating here is pointless while we're being mapped cuz we're not in
2015 the client list yet */
2017 screen_update_areas();
2021 /* Avoid storing icons above this size if possible */
2022 #define AVOID_ABOVE 64
2024 void client_update_icons(ObClient
*self
)
2029 guint num_seen
; /* number of icons present */
2030 guint num_small_seen
; /* number of icons small enough present */
2031 guint smallest
, smallest_area
;
2033 for (i
= 0; i
< self
->nicons
; ++i
)
2034 g_free(self
->icons
[i
].data
);
2035 if (self
->nicons
> 0)
2036 g_free(self
->icons
);
2039 if (OBT_PROP_GETA32(self
->window
, NET_WM_ICON
, CARDINAL
, &data
, &num
)) {
2040 /* figure out how many valid icons are in here */
2042 num_seen
= num_small_seen
= 0;
2043 smallest
= smallest_area
= 0;
2049 /* watch for it being too small for the specified size, or for
2050 zero sized icons. */
2051 if (i
> num
|| w
== 0 || h
== 0) break;
2053 if (!smallest_area
|| w
*h
< smallest_area
) {
2054 smallest
= num_seen
;
2055 smallest_area
= w
*h
;
2058 if (w
<= AVOID_ABOVE
&& h
<= AVOID_ABOVE
)
2061 if (num_small_seen
> 0)
2062 self
->nicons
= num_small_seen
;
2066 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
2068 /* store the icons */
2070 for (j
= 0; j
< self
->nicons
;) {
2073 w
= self
->icons
[j
].width
= data
[i
++];
2074 h
= self
->icons
[j
].height
= data
[i
++];
2076 /* if there are some icons smaller than the threshold, we're
2077 skipping all the ones above */
2078 if (num_small_seen
> 0) {
2079 if (w
> AVOID_ABOVE
|| h
> AVOID_ABOVE
) {
2084 /* if there were no icons smaller than the threshold, then we are
2085 only taking the smallest available one we saw */
2086 else if (j
!= smallest
) {
2091 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
2092 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
2097 self
->icons
[j
].data
[t
] =
2098 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
2099 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
2100 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
2101 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
2112 if ((hints
= XGetWMHints(obt_display
, self
->window
))) {
2113 if (hints
->flags
& IconPixmapHint
) {
2115 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
2116 obt_display_ignore_errors(TRUE
);
2117 if (!RrPixmapToRGBA(ob_rr_inst
,
2119 (hints
->flags
& IconMaskHint
?
2120 hints
->icon_mask
: None
),
2121 &self
->icons
[0].width
,
2122 &self
->icons
[0].height
,
2123 &self
->icons
[0].data
))
2125 g_free(self
->icons
);
2128 obt_display_ignore_errors(FALSE
);
2134 /* set the default icon onto the window
2135 in theory, this could be a race, but if a window doesn't set an icon
2136 or removes it entirely, it's not very likely it is going to set one
2137 right away afterwards
2139 if it has parents, then one of them will have an icon already
2141 if (self
->nicons
== 0 && !self
->parents
) {
2142 RrPixel32
*icon
= ob_rr_theme
->def_win_icon
;
2145 data
= g_new(gulong
, 48*48+2);
2146 data
[0] = data
[1] = 48;
2147 for (i
= 0; i
< 48*48; ++i
)
2148 data
[i
+2] = (((icon
[i
] >> RrDefaultAlphaOffset
) & 0xff) << 24) +
2149 (((icon
[i
] >> RrDefaultRedOffset
) & 0xff) << 16) +
2150 (((icon
[i
] >> RrDefaultGreenOffset
) & 0xff) << 8) +
2151 (((icon
[i
] >> RrDefaultBlueOffset
) & 0xff) << 0);
2152 OBT_PROP_SETA32(self
->window
, NET_WM_ICON
, CARDINAL
, data
, 48*48+2);
2154 } else if (self
->frame
)
2155 /* don't draw the icon empty if we're just setting one now anyways,
2156 we'll get the property change any second */
2157 frame_adjust_icon(self
->frame
);
2160 void client_update_icon_geometry(ObClient
*self
)
2165 RECT_SET(self
->icon_geometry
, 0, 0, 0, 0);
2167 if (OBT_PROP_GETA32(self
->window
, NET_WM_ICON_GEOMETRY
, CARDINAL
,
2171 /* don't let them set it with an area < 0 */
2172 RECT_SET(self
->icon_geometry
, data
[0], data
[1],
2173 MAX(data
[2],0), MAX(data
[3],0));
2178 static void client_get_session_ids(ObClient
*self
)
2185 if (!OBT_PROP_GET32(self
->window
, WM_CLIENT_LEADER
, WINDOW
, &leader
))
2188 /* get the SM_CLIENT_ID */
2191 got
= OBT_PROP_GETS(leader
, SM_CLIENT_ID
, locale
, &self
->sm_client_id
);
2193 OBT_PROP_GETS(self
->window
, SM_CLIENT_ID
, locale
, &self
->sm_client_id
);
2195 /* get the WM_CLASS (name and class). make them "" if they are not
2199 got
= OBT_PROP_GETSS(leader
, WM_CLASS
, locale
, &ss
);
2201 got
= OBT_PROP_GETSS(self
->window
, WM_CLASS
, locale
, &ss
);
2205 self
->name
= g_strdup(ss
[0]);
2207 self
->class = g_strdup(ss
[1]);
2212 if (self
->name
== NULL
) self
->name
= g_strdup("");
2213 if (self
->class == NULL
) self
->class = g_strdup("");
2215 /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2218 got
= OBT_PROP_GETS(leader
, WM_WINDOW_ROLE
, locale
, &s
);
2220 got
= OBT_PROP_GETS(self
->window
, WM_WINDOW_ROLE
, locale
, &s
);
2225 self
->role
= g_strdup("");
2227 /* get the WM_COMMAND */
2231 got
= OBT_PROP_GETSS(leader
, WM_COMMAND
, locale
, &ss
);
2233 got
= OBT_PROP_GETSS(self
->window
, WM_COMMAND
, locale
, &ss
);
2236 /* merge/mash them all together */
2237 gchar
*merge
= NULL
;
2240 for (i
= 0; ss
[i
]; ++i
) {
2243 merge
= g_strconcat(merge
, ss
[i
], NULL
);
2245 merge
= g_strconcat(ss
[i
], NULL
);
2250 self
->wm_command
= merge
;
2253 /* get the WM_CLIENT_MACHINE */
2256 got
= OBT_PROP_GETS(leader
, WM_CLIENT_MACHINE
, locale
, &s
);
2258 got
= OBT_PROP_GETS(self
->window
, WM_CLIENT_MACHINE
, locale
, &s
);
2261 gchar localhost
[128];
2264 gethostname(localhost
, 127);
2265 localhost
[127] = '\0';
2266 if (strcmp(localhost
, s
) != 0)
2267 self
->client_machine
= s
;
2271 /* see if it has the PID set too (the PID requires that the
2272 WM_CLIENT_MACHINE be set) */
2273 if (OBT_PROP_GET32(self
->window
, NET_WM_PID
, CARDINAL
, &pid
))
2278 static void client_change_wm_state(ObClient
*self
)
2283 old
= self
->wmstate
;
2285 if (self
->shaded
|| self
->iconic
||
2286 (self
->desktop
!= DESKTOP_ALL
&& self
->desktop
!= screen_desktop
))
2288 self
->wmstate
= IconicState
;
2290 self
->wmstate
= NormalState
;
2292 if (old
!= self
->wmstate
) {
2293 OBT_PROP_MSG(ob_screen
, self
->window
, KDE_WM_CHANGE_STATE
,
2294 self
->wmstate
, 1, 0, 0, 0);
2296 state
[0] = self
->wmstate
;
2298 OBT_PROP_SETA32(self
->window
, WM_STATE
, WM_STATE
, state
, 2);
2302 static void client_change_state(ObClient
*self
)
2304 gulong netstate
[12];
2309 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL
);
2311 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED
);
2313 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN
);
2314 if (self
->skip_taskbar
)
2315 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR
);
2316 if (self
->skip_pager
)
2317 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER
);
2318 if (self
->fullscreen
)
2319 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN
);
2321 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT
);
2323 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ
);
2325 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE
);
2327 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW
);
2328 if (self
->demands_attention
)
2329 netstate
[num
++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION
);
2330 if (self
->undecorated
)
2331 netstate
[num
++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED
);
2332 OBT_PROP_SETA32(self
->window
, NET_WM_STATE
, ATOM
, netstate
, num
);
2335 frame_adjust_state(self
->frame
);
2338 ObClient
*client_search_focus_tree(ObClient
*self
)
2343 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2344 if (client_focused(it
->data
)) return it
->data
;
2345 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
2350 ObClient
*client_search_focus_tree_full(ObClient
*self
)
2352 if (self
->parents
) {
2355 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
2356 ObClient
*c
= it
->data
;
2357 if ((c
= client_search_focus_tree_full(it
->data
))) return c
;
2363 /* this function checks the whole tree, the client_search_focus_tree
2364 does not, so we need to check this window */
2365 if (client_focused(self
))
2367 return client_search_focus_tree(self
);
2371 ObClient
*client_search_focus_group_full(ObClient
*self
)
2376 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
2377 ObClient
*c
= it
->data
;
2379 if (client_focused(c
)) return c
;
2380 if ((c
= client_search_focus_tree(it
->data
))) return c
;
2383 if (client_focused(self
)) return self
;
2387 gboolean
client_has_parent(ObClient
*self
)
2389 return self
->parents
!= NULL
;
2392 static ObStackingLayer
calc_layer(ObClient
*self
)
2397 monitor
= screen_physical_area_monitor(client_monitor(self
));
2399 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
2400 l
= OB_STACKING_LAYER_DESKTOP
;
2401 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
2402 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
2403 else l
= OB_STACKING_LAYER_ABOVE
;
2405 else if ((self
->fullscreen
||
2406 /* No decorations and fills the monitor = oldskool fullscreen.
2407 But not for maximized windows.
2409 (self
->decorations
== 0 &&
2410 !(self
->max_horz
&& self
->max_vert
) &&
2411 RECT_EQUAL(self
->area
, *monitor
))) &&
2412 /* you are fullscreen while you or your children are focused.. */
2413 (client_focused(self
) || client_search_focus_tree(self
) ||
2414 /* you can be fullscreen if you're on another desktop */
2415 (self
->desktop
!= screen_desktop
&&
2416 self
->desktop
!= DESKTOP_ALL
) ||
2417 /* and you can also be fullscreen if the focused client is on
2418 another monitor, or nothing else is focused */
2420 client_monitor(focus_client
) != client_monitor(self
))))
2421 l
= OB_STACKING_LAYER_FULLSCREEN
;
2422 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
2423 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
2424 else l
= OB_STACKING_LAYER_NORMAL
;
2431 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
2432 ObStackingLayer min
)
2434 ObStackingLayer old
, own
;
2438 own
= calc_layer(self
);
2439 self
->layer
= MAX(own
, min
);
2441 if (self
->layer
!= old
) {
2442 stacking_remove(CLIENT_AS_WINDOW(self
));
2443 stacking_add_nonintrusive(CLIENT_AS_WINDOW(self
));
2446 /* we've been restacked */
2447 self
->visited
= TRUE
;
2449 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2450 client_calc_layer_recursive(it
->data
, orig
,
2454 static void client_calc_layer_internal(ObClient
*self
)
2458 /* transients take on the layer of their parents */
2459 sit
= client_search_all_top_parents(self
);
2461 for (; sit
; sit
= g_slist_next(sit
))
2462 client_calc_layer_recursive(sit
->data
, self
, 0);
2465 void client_calc_layer(ObClient
*self
)
2469 /* skip over stuff above fullscreen layer */
2470 for (it
= stacking_list
; it
; it
= g_list_next(it
))
2471 if (window_layer(it
->data
) <= OB_STACKING_LAYER_FULLSCREEN
) break;
2473 /* find the windows in the fullscreen layer, and mark them not-visited */
2474 for (; it
; it
= g_list_next(it
)) {
2475 if (window_layer(it
->data
) < OB_STACKING_LAYER_FULLSCREEN
) break;
2476 else if (WINDOW_IS_CLIENT(it
->data
))
2477 WINDOW_AS_CLIENT(it
->data
)->visited
= FALSE
;
2480 client_calc_layer_internal(self
);
2482 /* skip over stuff above fullscreen layer */
2483 for (it
= stacking_list
; it
; it
= g_list_next(it
))
2484 if (window_layer(it
->data
) <= OB_STACKING_LAYER_FULLSCREEN
) break;
2486 /* now recalc any windows in the fullscreen layer which have not
2487 had their layer recalced already */
2488 for (; it
; it
= g_list_next(it
)) {
2489 if (window_layer(it
->data
) < OB_STACKING_LAYER_FULLSCREEN
) break;
2490 else if (WINDOW_IS_CLIENT(it
->data
) &&
2491 !WINDOW_AS_CLIENT(it
->data
)->visited
)
2492 client_calc_layer_internal(it
->data
);
2496 gboolean
client_should_show(ObClient
*self
)
2500 if (client_normal(self
) && screen_showing_desktop
)
2502 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
2508 gboolean
client_show(ObClient
*self
)
2510 gboolean show
= FALSE
;
2512 if (client_should_show(self
)) {
2513 frame_show(self
->frame
);
2516 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2517 it needs to be in IconicState. This includes when it is on another
2520 client_change_wm_state(self
);
2525 gboolean
client_hide(ObClient
*self
)
2527 gboolean hide
= FALSE
;
2529 if (!client_should_show(self
)) {
2530 if (self
== focus_client
) {
2531 /* if there is a grab going on, then we need to cancel it. if we
2532 move focus during the grab, applications will get
2533 NotifyWhileGrabbed events and ignore them !
2535 actions should not rely on being able to move focus during an
2538 event_cancel_all_key_grabs();
2541 /* We don't need to ignore enter events here.
2542 The window can hide/iconify in 3 different ways:
2543 1 - through an x message. in this case we ignore all enter events
2544 caused by responding to the x message (unless underMouse)
2545 2 - by a keyboard action. in this case we ignore all enter events
2546 caused by the action
2547 3 - by a mouse action. in this case they are doing stuff with the
2548 mouse and focus _should_ move.
2550 Also in action_end, we simulate an enter event that can't be ignored
2551 so trying to ignore them is futile in case 3 anyways
2554 frame_hide(self
->frame
);
2557 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2558 it needs to be in IconicState. This includes when it is on another
2561 client_change_wm_state(self
);
2566 void client_showhide(ObClient
*self
)
2568 if (!client_show(self
))
2572 gboolean
client_normal(ObClient
*self
) {
2573 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
2574 self
->type
== OB_CLIENT_TYPE_DOCK
||
2575 self
->type
== OB_CLIENT_TYPE_SPLASH
);
2578 gboolean
client_helper(ObClient
*self
)
2580 return (self
->type
== OB_CLIENT_TYPE_UTILITY
||
2581 self
->type
== OB_CLIENT_TYPE_MENU
||
2582 self
->type
== OB_CLIENT_TYPE_TOOLBAR
);
2585 gboolean
client_mouse_focusable(ObClient
*self
)
2587 return !(self
->type
== OB_CLIENT_TYPE_MENU
||
2588 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
2589 self
->type
== OB_CLIENT_TYPE_SPLASH
||
2590 self
->type
== OB_CLIENT_TYPE_DOCK
);
2593 gboolean
client_enter_focusable(ObClient
*self
)
2595 /* you can focus desktops but it shouldn't on enter */
2596 return (client_mouse_focusable(self
) &&
2597 self
->type
!= OB_CLIENT_TYPE_DESKTOP
);
2601 static void client_apply_startup_state(ObClient
*self
,
2602 gint x
, gint y
, gint w
, gint h
)
2604 /* save the states that we are going to apply */
2605 gboolean iconic
= self
->iconic
;
2606 gboolean fullscreen
= self
->fullscreen
;
2607 gboolean undecorated
= self
->undecorated
;
2608 gboolean shaded
= self
->shaded
;
2609 gboolean demands_attention
= self
->demands_attention
;
2610 gboolean max_horz
= self
->max_horz
;
2611 gboolean max_vert
= self
->max_vert
;
2615 /* turn them all off in the client, so they won't affect the window
2617 self
->iconic
= self
->fullscreen
= self
->undecorated
= self
->shaded
=
2618 self
->demands_attention
= self
->max_horz
= self
->max_vert
= FALSE
;
2620 /* move the client to its placed position, or it it's already there,
2621 generate a ConfigureNotify telling the client where it is.
2623 do this after adjusting the frame. otherwise it gets all weird and
2624 clients don't work right
2626 do this before applying the states so they have the correct
2627 pre-max/pre-fullscreen values
2629 client_try_configure(self
, &x
, &y
, &w
, &h
, &l
, &l
, FALSE
);
2630 ob_debug("placed window 0x%x at %d, %d with size %d x %d",
2631 self
->window
, x
, y
, w
, h
);
2632 /* save the area, and make it where it should be for the premax stuff */
2633 oldarea
= self
->area
;
2634 RECT_SET(self
->area
, x
, y
, w
, h
);
2636 /* apply the states. these are in a carefully crafted order.. */
2639 client_iconify(self
, TRUE
, FALSE
, TRUE
);
2641 client_fullscreen(self
, TRUE
);
2643 client_set_undecorated(self
, TRUE
);
2645 client_shade(self
, TRUE
);
2646 if (demands_attention
)
2647 client_hilite(self
, TRUE
);
2649 if (max_vert
&& max_horz
)
2650 client_maximize(self
, TRUE
, 0);
2652 client_maximize(self
, TRUE
, 2);
2654 client_maximize(self
, TRUE
, 1);
2656 /* if the window hasn't been configured yet, then do so now, in fact the
2657 x,y,w,h may _not_ be the same as the area rect, which can end up
2658 meaning that the client isn't properly moved/resized by the fullscreen
2660 pho can cause this because it maps at size of the screen but not 0,0
2661 so openbox moves it on screen to 0,0 (thus x,y=0,0 and area.x,y don't).
2662 then fullscreen'ing makes it go to 0,0 which it thinks it already is at
2663 cuz thats where the pre-fullscreen will be. however the actual area is
2664 not, so this needs to be called even if we have fullscreened/maxed
2666 self
->area
= oldarea
;
2667 client_configure(self
, x
, y
, w
, h
, FALSE
, TRUE
, FALSE
);
2669 /* set the desktop hint, to make sure that it always exists */
2670 OBT_PROP_SET32(self
->window
, NET_WM_DESKTOP
, CARDINAL
, self
->desktop
);
2672 /* nothing to do for the other states:
2681 void client_gravity_resize_w(ObClient
*self
, gint
*x
, gint oldw
, gint neww
)
2683 /* these should be the current values. this is for when you're not moving,
2685 g_assert(*x
== self
->area
.x
);
2686 g_assert(oldw
== self
->area
.width
);
2689 switch (self
->gravity
) {
2691 case NorthWestGravity
:
2693 case SouthWestGravity
:
2700 *x
-= (neww
- oldw
) / 2;
2702 case NorthEastGravity
:
2704 case SouthEastGravity
:
2710 void client_gravity_resize_h(ObClient
*self
, gint
*y
, gint oldh
, gint newh
)
2712 /* these should be the current values. this is for when you're not moving,
2714 g_assert(*y
== self
->area
.y
);
2715 g_assert(oldh
== self
->area
.height
);
2718 switch (self
->gravity
) {
2720 case NorthWestGravity
:
2722 case NorthEastGravity
:
2729 *y
-= (newh
- oldh
) / 2;
2731 case SouthWestGravity
:
2733 case SouthEastGravity
:
2739 void client_try_configure(ObClient
*self
, gint
*x
, gint
*y
, gint
*w
, gint
*h
,
2740 gint
*logicalw
, gint
*logicalh
,
2743 Rect desired
= {*x
, *y
, *w
, *h
};
2744 frame_rect_to_frame(self
->frame
, &desired
);
2746 /* make the frame recalculate its dimentions n shit without changing
2747 anything visible for real, this way the constraints below can work with
2748 the updated frame dimensions. */
2749 frame_adjust_area(self
->frame
, FALSE
, TRUE
, TRUE
);
2751 /* gets the frame's position */
2752 frame_client_gravity(self
->frame
, x
, y
);
2754 /* these positions are frame positions, not client positions */
2756 /* set the size and position if fullscreen */
2757 if (self
->fullscreen
) {
2761 i
= screen_find_monitor(&desired
);
2762 a
= screen_physical_area_monitor(i
);
2769 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2773 } else if (self
->max_horz
|| self
->max_vert
) {
2777 /* use all possible struts when maximizing to the full screen */
2778 i
= screen_find_monitor(&desired
);
2779 a
= screen_area(self
->desktop
, i
,
2780 (self
->max_horz
&& self
->max_vert
? NULL
: &desired
));
2782 /* set the size and position if maximized */
2783 if (self
->max_horz
) {
2785 *w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2787 if (self
->max_vert
) {
2789 *h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2792 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2798 /* gets the client's position */
2799 frame_frame_gravity(self
->frame
, x
, y
);
2801 /* work within the prefered sizes given by the window */
2802 if (!(*w
== self
->area
.width
&& *h
== self
->area
.height
)) {
2803 gint basew
, baseh
, minw
, minh
;
2805 gfloat minratio
, maxratio
;
2807 incw
= self
->fullscreen
|| self
->max_horz
? 1 : self
->size_inc
.width
;
2808 inch
= self
->fullscreen
|| self
->max_vert
? 1 : self
->size_inc
.height
;
2809 minratio
= self
->fullscreen
|| (self
->max_horz
&& self
->max_vert
) ?
2810 0 : self
->min_ratio
;
2811 maxratio
= self
->fullscreen
|| (self
->max_horz
&& self
->max_vert
) ?
2812 0 : self
->max_ratio
;
2814 /* base size is substituted with min size if not specified */
2815 if (self
->base_size
.width
|| self
->base_size
.height
) {
2816 basew
= self
->base_size
.width
;
2817 baseh
= self
->base_size
.height
;
2819 basew
= self
->min_size
.width
;
2820 baseh
= self
->min_size
.height
;
2822 /* min size is substituted with base size if not specified */
2823 if (self
->min_size
.width
|| self
->min_size
.height
) {
2824 minw
= self
->min_size
.width
;
2825 minh
= self
->min_size
.height
;
2827 minw
= self
->base_size
.width
;
2828 minh
= self
->base_size
.height
;
2831 /* if this is a user-requested resize, then check against min/max
2834 /* smaller than min size or bigger than max size? */
2835 if (*w
> self
->max_size
.width
) *w
= self
->max_size
.width
;
2836 if (*w
< minw
) *w
= minw
;
2837 if (*h
> self
->max_size
.height
) *h
= self
->max_size
.height
;
2838 if (*h
< minh
) *h
= minh
;
2843 /* keep to the increments */
2847 /* you cannot resize to nothing */
2848 if (basew
+ *w
< 1) *w
= 1 - basew
;
2849 if (baseh
+ *h
< 1) *h
= 1 - baseh
;
2851 /* save the logical size */
2852 *logicalw
= incw
> 1 ? *w
: *w
+ basew
;
2853 *logicalh
= inch
> 1 ? *h
: *h
+ baseh
;
2861 /* adjust the height to match the width for the aspect ratios.
2862 for this, min size is not substituted for base size ever. */
2863 *w
-= self
->base_size
.width
;
2864 *h
-= self
->base_size
.height
;
2867 if (*h
* minratio
> *w
) {
2868 *h
= (gint
)(*w
/ minratio
);
2870 /* you cannot resize to nothing */
2873 *w
= (gint
)(*h
* minratio
);
2877 if (*h
* maxratio
< *w
) {
2878 *h
= (gint
)(*w
/ maxratio
);
2880 /* you cannot resize to nothing */
2883 *w
= (gint
)(*h
* minratio
);
2887 *w
+= self
->base_size
.width
;
2888 *h
+= self
->base_size
.height
;
2891 /* these override the above states! if you cant move you can't move! */
2893 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2897 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2898 *w
= self
->area
.width
;
2899 *h
= self
->area
.height
;
2908 void client_configure(ObClient
*self
, gint x
, gint y
, gint w
, gint h
,
2909 gboolean user
, gboolean final
, gboolean force_reply
)
2913 gboolean send_resize_client
;
2914 gboolean moved
= FALSE
, resized
= FALSE
, rootmoved
= FALSE
;
2915 gboolean fmoved
, fresized
;
2916 guint fdecor
= self
->frame
->decorations
;
2917 gboolean fhorz
= self
->frame
->max_horz
;
2918 gboolean fvert
= self
->frame
->max_vert
;
2919 gint logicalw
, logicalh
;
2921 /* find the new x, y, width, and height (and logical size) */
2922 client_try_configure(self
, &x
, &y
, &w
, &h
, &logicalw
, &logicalh
, user
);
2924 /* set the logical size if things changed */
2925 if (!(w
== self
->area
.width
&& h
== self
->area
.height
))
2926 SIZE_SET(self
->logical_size
, logicalw
, logicalh
);
2928 /* figure out if we moved or resized or what */
2929 moved
= (x
!= self
->area
.x
|| y
!= self
->area
.y
);
2930 resized
= (w
!= self
->area
.width
|| h
!= self
->area
.height
);
2932 oldw
= self
->area
.width
;
2933 oldh
= self
->area
.height
;
2934 oldframe
= self
->frame
->area
;
2935 RECT_SET(self
->area
, x
, y
, w
, h
);
2937 /* for app-requested resizes, always resize if 'resized' is true.
2938 for user-requested ones, only resize if final is true, or when
2939 resizing in redraw mode */
2940 send_resize_client
= ((!user
&& resized
) ||
2942 (resized
&& config_resize_redraw
))));
2944 /* if the client is enlarging, then resize the client before the frame */
2945 if (send_resize_client
&& (w
> oldw
|| h
> oldh
)) {
2946 XMoveResizeWindow(obt_display
, self
->window
,
2947 self
->frame
->size
.left
, self
->frame
->size
.top
,
2948 MAX(w
, oldw
), MAX(h
, oldh
));
2949 frame_adjust_client_area(self
->frame
);
2952 /* find the frame's dimensions and move/resize it */
2956 /* if decorations changed, then readjust everything for the frame */
2957 if (self
->decorations
!= fdecor
||
2958 self
->max_horz
!= fhorz
|| self
->max_vert
!= fvert
)
2960 fmoved
= fresized
= TRUE
;
2963 /* adjust the frame */
2964 if (fmoved
|| fresized
) {
2965 gulong ignore_start
;
2967 ignore_start
= event_start_ignore_all_enters();
2969 frame_adjust_area(self
->frame
, fmoved
, fresized
, FALSE
);
2972 event_end_ignore_all_enters(ignore_start
);
2975 if (!user
|| final
) {
2976 gint oldrx
= self
->root_pos
.x
;
2977 gint oldry
= self
->root_pos
.y
;
2978 /* we have reset the client to 0 border width, so don't include
2979 it in these coords */
2980 POINT_SET(self
->root_pos
,
2981 self
->frame
->area
.x
+ self
->frame
->size
.left
-
2983 self
->frame
->area
.y
+ self
->frame
->size
.top
-
2984 self
->border_width
);
2985 if (self
->root_pos
.x
!= oldrx
|| self
->root_pos
.y
!= oldry
)
2989 /* This is kinda tricky and should not be changed.. let me explain!
2991 When user = FALSE, then the request is coming from the application
2992 itself, and we are more strict about when to send a synthetic
2993 ConfigureNotify. We strictly follow the rules of the ICCCM sec 4.1.5
2994 in this case (if force_reply is true)
2996 When user = TRUE, then the request is coming from "us", like when we
2997 maximize a window or something. In this case we are more lenient. We
2998 used to follow the same rules as above, but _Java_ Swing can't handle
2999 this. So just to appease Swing, when user = TRUE, we always send
3000 a synthetic ConfigureNotify to give the window its root coordinates.
3002 if ((!user
&& !resized
&& (rootmoved
|| force_reply
)) ||
3003 (user
&& final
&& rootmoved
))
3007 event
.type
= ConfigureNotify
;
3008 event
.xconfigure
.display
= obt_display
;
3009 event
.xconfigure
.event
= self
->window
;
3010 event
.xconfigure
.window
= self
->window
;
3012 ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d",
3013 self
->title
, self
->root_pos
.x
, self
->root_pos
.y
, w
, h
);
3015 /* root window real coords */
3016 event
.xconfigure
.x
= self
->root_pos
.x
;
3017 event
.xconfigure
.y
= self
->root_pos
.y
;
3018 event
.xconfigure
.width
= w
;
3019 event
.xconfigure
.height
= h
;
3020 event
.xconfigure
.border_width
= self
->border_width
;
3021 event
.xconfigure
.above
= None
;
3022 event
.xconfigure
.override_redirect
= FALSE
;
3023 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
3024 FALSE
, StructureNotifyMask
, &event
);
3027 /* if the client is shrinking, then resize the frame before the client.
3029 both of these resize sections may run, because the top one only resizes
3030 in the direction that is growing
3032 if (send_resize_client
&& (w
<= oldw
|| h
<= oldh
)) {
3033 frame_adjust_client_area(self
->frame
);
3034 XMoveResizeWindow(obt_display
, self
->window
,
3035 self
->frame
->size
.left
, self
->frame
->size
.top
, w
, h
);
3038 XFlush(obt_display
);
3040 /* if it moved between monitors, then this can affect the stacking
3041 layer of this window or others - for fullscreen windows */
3042 if (screen_find_monitor(&self
->frame
->area
) !=
3043 screen_find_monitor(&oldframe
))
3045 client_calc_layer(self
);
3049 void client_fullscreen(ObClient
*self
, gboolean fs
)
3053 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
3054 self
->fullscreen
== fs
) return; /* already done */
3056 self
->fullscreen
= fs
;
3057 client_change_state(self
); /* change the state hints on the client */
3060 self
->pre_fullscreen_area
= self
->area
;
3061 /* if the window is maximized, its area isn't all that meaningful.
3062 save it's premax area instead. */
3063 if (self
->max_horz
) {
3064 self
->pre_fullscreen_area
.x
= self
->pre_max_area
.x
;
3065 self
->pre_fullscreen_area
.width
= self
->pre_max_area
.width
;
3067 if (self
->max_vert
) {
3068 self
->pre_fullscreen_area
.y
= self
->pre_max_area
.y
;
3069 self
->pre_fullscreen_area
.height
= self
->pre_max_area
.height
;
3072 /* these will help configure_full figure out where to fullscreen
3076 w
= self
->area
.width
;
3077 h
= self
->area
.height
;
3079 g_assert(self
->pre_fullscreen_area
.width
> 0 &&
3080 self
->pre_fullscreen_area
.height
> 0);
3082 x
= self
->pre_fullscreen_area
.x
;
3083 y
= self
->pre_fullscreen_area
.y
;
3084 w
= self
->pre_fullscreen_area
.width
;
3085 h
= self
->pre_fullscreen_area
.height
;
3086 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
3089 ob_debug("Window %s going fullscreen (%d)",
3090 self
->title
, self
->fullscreen
);
3092 client_setup_decor_and_functions(self
, FALSE
);
3093 client_move_resize(self
, x
, y
, w
, h
);
3095 /* and adjust our layer/stacking. do this after resizing the window,
3096 and applying decorations, because windows which fill the screen are
3097 considered "fullscreen" and it affects their layer */
3098 client_calc_layer(self
);
3101 /* try focus us when we go into fullscreen mode */
3106 static void client_iconify_recursive(ObClient
*self
,
3107 gboolean iconic
, gboolean curdesk
,
3108 gboolean hide_animation
)
3111 gboolean changed
= FALSE
;
3114 if (self
->iconic
!= iconic
) {
3115 ob_debug("%sconifying window: 0x%lx", (iconic
? "I" : "Uni"),
3119 /* don't let non-normal windows iconify along with their parents
3121 if (client_normal(self
)) {
3122 self
->iconic
= iconic
;
3124 /* update the focus lists.. iconic windows go to the bottom of
3126 focus_order_to_bottom(self
);
3131 self
->iconic
= iconic
;
3133 if (curdesk
&& self
->desktop
!= screen_desktop
&&
3134 self
->desktop
!= DESKTOP_ALL
)
3135 client_set_desktop(self
, screen_desktop
, FALSE
, FALSE
);
3137 /* this puts it after the current focused window */
3138 focus_order_remove(self
);
3139 focus_order_add_new(self
);
3146 client_change_state(self
);
3147 if (config_animate_iconify
&& !hide_animation
)
3148 frame_begin_iconify_animation(self
->frame
, iconic
);
3149 /* do this after starting the animation so it doesn't flash */
3150 client_showhide(self
);
3153 /* iconify all direct transients, and deiconify all transients
3155 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3156 if (it
->data
!= self
)
3157 if (client_is_direct_child(self
, it
->data
) || !iconic
)
3158 client_iconify_recursive(it
->data
, iconic
, curdesk
,
3162 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
,
3163 gboolean hide_animation
)
3165 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
|| !iconic
) {
3166 /* move up the transient chain as far as possible first */
3167 self
= client_search_top_direct_parent(self
);
3168 client_iconify_recursive(self
, iconic
, curdesk
, hide_animation
);
3172 void client_maximize(ObClient
*self
, gboolean max
, gint dir
)
3176 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
3177 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
3179 /* check if already done */
3181 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
3182 if (dir
== 1 && self
->max_horz
) return;
3183 if (dir
== 2 && self
->max_vert
) return;
3185 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
3186 if (dir
== 1 && !self
->max_horz
) return;
3187 if (dir
== 2 && !self
->max_vert
) return;
3190 /* these will help configure_full figure out which screen to fill with
3194 w
= self
->area
.width
;
3195 h
= self
->area
.height
;
3198 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
3199 RECT_SET(self
->pre_max_area
,
3200 self
->area
.x
, self
->pre_max_area
.y
,
3201 self
->area
.width
, self
->pre_max_area
.height
);
3203 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
3204 RECT_SET(self
->pre_max_area
,
3205 self
->pre_max_area
.x
, self
->area
.y
,
3206 self
->pre_max_area
.width
, self
->area
.height
);
3209 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
3210 g_assert(self
->pre_max_area
.width
> 0);
3212 x
= self
->pre_max_area
.x
;
3213 w
= self
->pre_max_area
.width
;
3215 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
3216 0, self
->pre_max_area
.height
);
3218 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
3219 g_assert(self
->pre_max_area
.height
> 0);
3221 y
= self
->pre_max_area
.y
;
3222 h
= self
->pre_max_area
.height
;
3224 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
3225 self
->pre_max_area
.width
, 0);
3229 if (dir
== 0 || dir
== 1) /* horz */
3230 self
->max_horz
= max
;
3231 if (dir
== 0 || dir
== 2) /* vert */
3232 self
->max_vert
= max
;
3234 client_change_state(self
); /* change the state hints on the client */
3236 client_setup_decor_and_functions(self
, FALSE
);
3237 client_move_resize(self
, x
, y
, w
, h
);
3240 void client_shade(ObClient
*self
, gboolean shade
)
3242 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
3243 shade
) || /* can't shade */
3244 self
->shaded
== shade
) return; /* already done */
3246 self
->shaded
= shade
;
3247 client_change_state(self
);
3248 client_change_wm_state(self
); /* the window is being hidden/shown */
3249 /* resize the frame to just the titlebar */
3250 frame_adjust_area(self
->frame
, FALSE
, TRUE
, FALSE
);
3253 static void client_ping_event(ObClient
*self
, gboolean dead
)
3255 self
->not_responding
= dead
;
3256 client_update_title(self
);
3259 /* it came back to life ! */
3261 if (self
->kill_prompt
) {
3262 prompt_unref(self
->kill_prompt
);
3263 self
->kill_prompt
= NULL
;
3266 self
->kill_level
= 0;
3270 void client_close(ObClient
*self
)
3272 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
3275 prompt_cancel(self
->prompt
);
3279 /* in the case that the client provides no means to requesting that it
3280 close, we just kill it */
3281 if (!self
->delete_window
)
3282 /* don't use client_kill(), we should only kill based on PID in
3283 response to a lack of PING replies */
3284 XKillClient(obt_display
, self
->window
);
3286 /* request the client to close with WM_DELETE_WINDOW */
3287 OBT_PROP_MSG_TO(self
->window
, self
->window
, WM_PROTOCOLS
,
3288 OBT_PROP_ATOM(WM_DELETE_WINDOW
), event_curtime
,
3289 0, 0, 0, NoEventMask
);
3291 if (self
->not_responding
)
3292 client_prompt_kill(self
);
3296 #define OB_KILL_RESULT_NO 0
3297 #define OB_KILL_RESULT_YES 1
3299 static void client_kill_requested(ObPrompt
*p
, gint result
, gpointer data
)
3301 ObClient
*self
= data
;
3303 if (result
== OB_KILL_RESULT_YES
)
3306 prompt_unref(self
->kill_prompt
);
3307 self
->kill_prompt
= NULL
;
3310 static void client_prompt_kill(ObClient
*self
)
3312 /* check if we're already prompting */
3313 if (!self
->kill_prompt
) {
3314 ObPromptAnswer answers
[] = {
3315 { _("No"), OB_KILL_RESULT_NO
},
3316 { _("Yes"), OB_KILL_RESULT_YES
}
3321 (_("The window \"%s\" does not seem to be responding. Do you want to force it to exit?"), self
->original_title
);
3323 self
->kill_prompt
= prompt_new(m
, answers
,
3324 sizeof(answers
)/sizeof(answers
[0]),
3325 OB_KILL_RESULT_NO
, /* default = no */
3326 OB_KILL_RESULT_NO
, /* cancel = no */
3327 client_kill_requested
, self
);
3331 prompt_show(self
->kill_prompt
, self
);
3334 void client_kill(ObClient
*self
)
3336 if (!self
->client_machine
&& self
->pid
) {
3337 /* running on the local host */
3338 if (self
->kill_level
== 0) {
3339 ob_debug("killing window 0x%x with pid %lu, with SIGTERM",
3340 self
->window
, self
->pid
);
3341 kill(self
->pid
, SIGTERM
);
3344 /* show that we're trying to kill it */
3345 client_update_title(self
);
3348 ob_debug("killing window 0x%x with pid %lu, with SIGKILL",
3349 self
->window
, self
->pid
);
3350 kill(self
->pid
, SIGKILL
); /* kill -9 */
3354 /* running on a remote host */
3355 XKillClient(obt_display
, self
->window
);
3359 void client_hilite(ObClient
*self
, gboolean hilite
)
3361 if (self
->demands_attention
== hilite
)
3362 return; /* no change */
3364 /* don't allow focused windows to hilite */
3365 self
->demands_attention
= hilite
&& !client_focused(self
);
3366 if (self
->frame
!= NULL
) { /* if we're mapping, just set the state */
3367 if (self
->demands_attention
)
3368 frame_flash_start(self
->frame
);
3370 frame_flash_stop(self
->frame
);
3371 client_change_state(self
);
3375 static void client_set_desktop_recursive(ObClient
*self
,
3383 if (target
!= self
->desktop
&& self
->type
!= OB_CLIENT_TYPE_DESKTOP
) {
3385 ob_debug("Setting desktop %u", target
+1);
3387 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
3389 old
= self
->desktop
;
3390 self
->desktop
= target
;
3391 OBT_PROP_SET32(self
->window
, NET_WM_DESKTOP
, CARDINAL
, target
);
3392 /* the frame can display the current desktop state */
3393 frame_adjust_state(self
->frame
);
3394 /* 'move' the window to the new desktop */
3398 /* raise if it was not already on the desktop */
3399 if (old
!= DESKTOP_ALL
&& !dontraise
)
3400 stacking_raise(CLIENT_AS_WINDOW(self
));
3401 if (STRUT_EXISTS(self
->strut
))
3402 screen_update_areas();
3404 /* the new desktop's geometry may be different, so we may need to
3405 resize, for example if we are maximized */
3406 client_reconfigure(self
, FALSE
);
3409 /* move all transients */
3410 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3411 if (it
->data
!= self
)
3412 if (client_is_direct_child(self
, it
->data
))
3413 client_set_desktop_recursive(it
->data
, target
,
3414 donthide
, dontraise
);
3417 void client_set_desktop(ObClient
*self
, guint target
,
3418 gboolean donthide
, gboolean dontraise
)
3420 self
= client_search_top_direct_parent(self
);
3421 client_set_desktop_recursive(self
, target
, donthide
, dontraise
);
3424 gboolean
client_is_direct_child(ObClient
*parent
, ObClient
*child
)
3426 while (child
!= parent
&& (child
= client_direct_parent(child
)));
3427 return child
== parent
;
3430 ObClient
*client_search_modal_child(ObClient
*self
)
3435 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
3436 ObClient
*c
= it
->data
;
3437 if ((ret
= client_search_modal_child(c
))) return ret
;
3438 if (c
->modal
) return c
;
3443 gboolean
client_validate(ObClient
*self
)
3447 XSync(obt_display
, FALSE
); /* get all events on the server */
3449 if (XCheckTypedWindowEvent(obt_display
, self
->window
, DestroyNotify
, &e
) ||
3450 XCheckTypedWindowEvent(obt_display
, self
->window
, UnmapNotify
, &e
))
3452 XPutBackEvent(obt_display
, &e
);
3459 void client_set_wm_state(ObClient
*self
, glong state
)
3461 if (state
== self
->wmstate
) return; /* no change */
3465 client_iconify(self
, TRUE
, TRUE
, FALSE
);
3468 client_iconify(self
, FALSE
, TRUE
, FALSE
);
3473 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
3475 gboolean shaded
= self
->shaded
;
3476 gboolean fullscreen
= self
->fullscreen
;
3477 gboolean undecorated
= self
->undecorated
;
3478 gboolean max_horz
= self
->max_horz
;
3479 gboolean max_vert
= self
->max_vert
;
3480 gboolean modal
= self
->modal
;
3481 gboolean iconic
= self
->iconic
;
3482 gboolean demands_attention
= self
->demands_attention
;
3483 gboolean above
= self
->above
;
3484 gboolean below
= self
->below
;
3487 if (!(action
== OBT_PROP_ATOM(NET_WM_STATE_ADD
) ||
3488 action
== OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) ||
3489 action
== OBT_PROP_ATOM(NET_WM_STATE_TOGGLE
)))
3490 /* an invalid action was passed to the client message, ignore it */
3493 for (i
= 0; i
< 2; ++i
) {
3494 Atom state
= i
== 0 ? data1
: data2
;
3496 if (!state
) continue;
3498 /* if toggling, then pick whether we're adding or removing */
3499 if (action
== OBT_PROP_ATOM(NET_WM_STATE_TOGGLE
)) {
3500 if (state
== OBT_PROP_ATOM(NET_WM_STATE_MODAL
))
3501 action
= modal
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3502 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3503 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT
))
3504 action
= self
->max_vert
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3505 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3506 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ
))
3507 action
= self
->max_horz
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3508 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3509 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SHADED
))
3510 action
= shaded
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3511 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3512 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR
))
3513 action
= self
->skip_taskbar
?
3514 OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3515 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3516 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER
))
3517 action
= self
->skip_pager
?
3518 OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3519 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3520 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_HIDDEN
))
3521 action
= self
->iconic
?
3522 OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3523 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3524 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN
))
3525 action
= fullscreen
?
3526 OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3527 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3528 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_ABOVE
))
3529 action
= self
->above
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3530 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3531 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_BELOW
))
3532 action
= self
->below
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3533 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3534 else if (state
== OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION
))
3535 action
= self
->demands_attention
?
3536 OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3537 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3538 else if (state
== OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED
))
3539 action
= undecorated
? OBT_PROP_ATOM(NET_WM_STATE_REMOVE
) :
3540 OBT_PROP_ATOM(NET_WM_STATE_ADD
);
3543 if (action
== OBT_PROP_ATOM(NET_WM_STATE_ADD
)) {
3544 if (state
== OBT_PROP_ATOM(NET_WM_STATE_MODAL
)) {
3546 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT
)) {
3548 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ
)) {
3550 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SHADED
)) {
3552 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR
)) {
3553 self
->skip_taskbar
= TRUE
;
3554 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER
)) {
3555 self
->skip_pager
= TRUE
;
3556 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_HIDDEN
)) {
3558 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN
)) {
3560 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_ABOVE
)) {
3563 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_BELOW
)) {
3566 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION
)){
3567 demands_attention
= TRUE
;
3568 } else if (state
== OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED
)) {
3572 } else { /* action == OBT_PROP_ATOM(NET_WM_STATE_REMOVE) */
3573 if (state
== OBT_PROP_ATOM(NET_WM_STATE_MODAL
)) {
3575 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT
)) {
3577 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ
)) {
3579 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SHADED
)) {
3581 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR
)) {
3582 self
->skip_taskbar
= FALSE
;
3583 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER
)) {
3584 self
->skip_pager
= FALSE
;
3585 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_HIDDEN
)) {
3587 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN
)) {
3589 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_ABOVE
)) {
3591 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_BELOW
)) {
3593 } else if (state
== OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION
)){
3594 demands_attention
= FALSE
;
3595 } else if (state
== OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED
)) {
3596 undecorated
= FALSE
;
3601 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
3602 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
3604 if (max_horz
== max_vert
) { /* both going the same way */
3605 client_maximize(self
, max_horz
, 0);
3607 client_maximize(self
, max_horz
, 1);
3608 client_maximize(self
, max_vert
, 2);
3612 if (max_horz
!= self
->max_horz
)
3613 client_maximize(self
, max_horz
, 1);
3615 client_maximize(self
, max_vert
, 2);
3618 /* change fullscreen state before shading, as it will affect if the window
3620 if (fullscreen
!= self
->fullscreen
)
3621 client_fullscreen(self
, fullscreen
);
3622 if (shaded
!= self
->shaded
)
3623 client_shade(self
, shaded
);
3624 if (undecorated
!= self
->undecorated
)
3625 client_set_undecorated(self
, undecorated
);
3626 if (above
!= self
->above
|| below
!= self
->below
) {
3627 self
->above
= above
;
3628 self
->below
= below
;
3629 client_calc_layer(self
);
3632 if (modal
!= self
->modal
) {
3633 self
->modal
= modal
;
3634 /* when a window changes modality, then its stacking order with its
3635 transients needs to change */
3636 stacking_raise(CLIENT_AS_WINDOW(self
));
3638 /* it also may get focused. if something is focused that shouldn't
3639 be focused anymore, then move the focus */
3640 if (focus_client
&& client_focus_target(focus_client
) != focus_client
)
3641 client_focus(focus_client
);
3644 if (iconic
!= self
->iconic
)
3645 client_iconify(self
, iconic
, FALSE
, FALSE
);
3647 if (demands_attention
!= self
->demands_attention
)
3648 client_hilite(self
, demands_attention
);
3650 client_change_state(self
); /* change the hint to reflect these changes */
3653 ObClient
*client_focus_target(ObClient
*self
)
3655 ObClient
*child
= NULL
;
3657 child
= client_search_modal_child(self
);
3658 if (child
) return child
;
3662 gboolean
client_can_focus(ObClient
*self
)
3664 /* choose the correct target */
3665 self
= client_focus_target(self
);
3667 if (!self
->frame
->visible
)
3670 if (!(self
->can_focus
|| self
->focus_notify
))
3676 gboolean
client_focus(ObClient
*self
)
3678 /* we might not focus this window, so if we have modal children which would
3679 be focused instead, bring them to this desktop */
3680 client_bring_modal_windows(self
);
3682 /* choose the correct target */
3683 self
= client_focus_target(self
);
3685 if (!client_can_focus(self
)) {
3686 ob_debug_type(OB_DEBUG_FOCUS
,
3687 "Client %s can't be focused", self
->title
);
3691 ob_debug_type(OB_DEBUG_FOCUS
,
3692 "Focusing client \"%s\" (0x%x) at time %u",
3693 self
->title
, self
->window
, event_curtime
);
3695 /* if using focus_delay, stop the timer now so that focus doesn't
3697 event_halt_focus_delay();
3699 /* if there is a grab going on, then we need to cancel it. if we move
3700 focus during the grab, applications will get NotifyWhileGrabbed events
3703 actions should not rely on being able to move focus during an
3706 event_cancel_all_key_grabs();
3708 obt_display_ignore_errors(TRUE
);
3710 if (self
->can_focus
) {
3711 /* This can cause a BadMatch error with CurrentTime, or if an app
3712 passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3713 XSetInputFocus(obt_display
, self
->window
, RevertToPointerRoot
,
3717 if (self
->focus_notify
) {
3719 ce
.xclient
.type
= ClientMessage
;
3720 ce
.xclient
.message_type
= OBT_PROP_ATOM(WM_PROTOCOLS
);
3721 ce
.xclient
.display
= obt_display
;
3722 ce
.xclient
.window
= self
->window
;
3723 ce
.xclient
.format
= 32;
3724 ce
.xclient
.data
.l
[0] = OBT_PROP_ATOM(WM_TAKE_FOCUS
);
3725 ce
.xclient
.data
.l
[1] = event_curtime
;
3726 ce
.xclient
.data
.l
[2] = 0l;
3727 ce
.xclient
.data
.l
[3] = 0l;
3728 ce
.xclient
.data
.l
[4] = 0l;
3729 XSendEvent(obt_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
3732 obt_display_ignore_errors(FALSE
);
3734 ob_debug_type(OB_DEBUG_FOCUS
, "Error focusing? %d",
3735 obt_display_error_occured
);
3736 return !obt_display_error_occured
;
3739 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
,
3742 if (client_normal(self
) && screen_showing_desktop
)
3743 screen_show_desktop(FALSE
, self
);
3745 client_iconify(self
, FALSE
, here
, FALSE
);
3746 if (self
->desktop
!= DESKTOP_ALL
&&
3747 self
->desktop
!= screen_desktop
)
3750 client_set_desktop(self
, screen_desktop
, FALSE
, TRUE
);
3752 screen_set_desktop(self
->desktop
, FALSE
);
3753 } else if (!self
->frame
->visible
)
3754 /* if its not visible for other reasons, then don't mess
3757 if (self
->shaded
&& unshade
)
3758 client_shade(self
, FALSE
);
3760 stacking_raise(CLIENT_AS_WINDOW(self
));
3765 void client_activate(ObClient
*self
, gboolean here
, gboolean raise
,
3766 gboolean unshade
, gboolean user
)
3768 client_present(self
, here
, raise
, unshade
);
3771 static void client_bring_windows_recursive(ObClient
*self
,
3779 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3780 client_bring_windows_recursive(it
->data
, desktop
,
3781 helpers
, modals
, iconic
);
3783 if (((helpers
&& client_helper(self
)) ||
3784 (modals
&& self
->modal
)) &&
3785 ((self
->desktop
!= desktop
&& self
->desktop
!= DESKTOP_ALL
) ||
3786 (iconic
&& self
->iconic
)))
3788 if (iconic
&& self
->iconic
)
3789 client_iconify(self
, FALSE
, TRUE
, FALSE
);
3791 client_set_desktop(self
, desktop
, FALSE
, FALSE
);
3795 void client_bring_helper_windows(ObClient
*self
)
3797 client_bring_windows_recursive(self
, self
->desktop
, TRUE
, FALSE
, FALSE
);
3800 void client_bring_modal_windows(ObClient
*self
)
3802 client_bring_windows_recursive(self
, self
->desktop
, FALSE
, TRUE
, TRUE
);
3805 gboolean
client_focused(ObClient
*self
)
3807 return self
== focus_client
;
3810 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
3813 gulong min_diff
, min_i
;
3815 if (!self
->nicons
) {
3816 ObClientIcon
*parent
= NULL
;
3819 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
3820 ObClient
*c
= it
->data
;
3821 if ((parent
= client_icon_recursive(c
, w
, h
)))
3828 /* some kind of crappy approximation to find the icon closest in size to
3829 what we requested, but icons are generally all the same ratio as
3830 eachother so it's good enough. */
3832 min_diff
= ABS(self
->icons
[0].width
- w
) + ABS(self
->icons
[0].height
- h
);
3835 for (i
= 1; i
< self
->nicons
; ++i
) {
3838 diff
= ABS(self
->icons
[i
].width
- w
) + ABS(self
->icons
[i
].height
- h
);
3839 if (diff
< min_diff
) {
3844 return &self
->icons
[min_i
];
3847 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
3850 static ObClientIcon deficon
;
3852 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
3853 deficon
.width
= deficon
.height
= 48;
3854 deficon
.data
= ob_rr_theme
->def_win_icon
;
3860 void client_set_layer(ObClient
*self
, gint layer
)
3864 self
->above
= FALSE
;
3865 } else if (layer
== 0) {
3866 self
->below
= self
->above
= FALSE
;
3868 self
->below
= FALSE
;
3871 client_calc_layer(self
);
3872 client_change_state(self
); /* reflect this in the state hints */
3875 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
3877 if (self
->undecorated
!= undecorated
&&
3878 /* don't let it undecorate if the function is missing, but let
3880 (self
->functions
& OB_CLIENT_FUNC_UNDECORATE
|| !undecorated
))
3882 self
->undecorated
= undecorated
;
3883 client_setup_decor_and_functions(self
, TRUE
);
3884 client_change_state(self
); /* reflect this in the state hints */
3888 guint
client_monitor(ObClient
*self
)
3890 return screen_find_monitor(&self
->frame
->area
);
3893 ObClient
*client_direct_parent(ObClient
*self
)
3895 if (!self
->parents
) return NULL
;
3896 if (self
->transient_for_group
) return NULL
;
3897 return self
->parents
->data
;
3900 ObClient
*client_search_top_direct_parent(ObClient
*self
)
3903 while ((p
= client_direct_parent(self
))) self
= p
;
3907 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
3909 ObStackingLayer layer
)
3914 /* move up the direct transient chain as far as possible */
3915 while ((p
= client_direct_parent(self
)) &&
3916 (!bylayer
|| p
->layer
== layer
))
3920 ret
= g_slist_prepend(NULL
, self
);
3922 ret
= g_slist_copy(self
->parents
);
3927 GSList
*client_search_all_top_parents(ObClient
*self
)
3929 return client_search_all_top_parents_internal(self
, FALSE
, 0);
3932 GSList
*client_search_all_top_parents_layer(ObClient
*self
)
3934 return client_search_all_top_parents_internal(self
, TRUE
, self
->layer
);
3937 ObClient
*client_search_focus_parent(ObClient
*self
)
3941 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
3942 if (client_focused(it
->data
)) return it
->data
;
3947 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3951 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
3952 if (it
->data
== search
) return search
;
3957 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3961 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3962 if (sit
->data
== search
)
3964 if (client_search_transient(sit
->data
, search
))
3970 static void detect_edge(Rect area
, ObDirection dir
,
3971 gint my_head
, gint my_size
,
3972 gint my_edge_start
, gint my_edge_size
,
3973 gint
*dest
, gboolean
*near_edge
)
3975 gint edge_start
, edge_size
, head
, tail
;
3976 gboolean skip_head
= FALSE
, skip_tail
= FALSE
;
3979 case OB_DIRECTION_NORTH
:
3980 case OB_DIRECTION_SOUTH
:
3981 edge_start
= area
.x
;
3982 edge_size
= area
.width
;
3984 case OB_DIRECTION_EAST
:
3985 case OB_DIRECTION_WEST
:
3986 edge_start
= area
.y
;
3987 edge_size
= area
.height
;
3990 g_assert_not_reached();
3993 /* do we collide with this window? */
3994 if (!RANGES_INTERSECT(my_edge_start
, my_edge_size
,
3995 edge_start
, edge_size
))
3999 case OB_DIRECTION_NORTH
:
4000 head
= RECT_BOTTOM(area
);
4001 tail
= RECT_TOP(area
);
4003 case OB_DIRECTION_SOUTH
:
4004 head
= RECT_TOP(area
);
4005 tail
= RECT_BOTTOM(area
);
4007 case OB_DIRECTION_WEST
:
4008 head
= RECT_RIGHT(area
);
4009 tail
= RECT_LEFT(area
);
4011 case OB_DIRECTION_EAST
:
4012 head
= RECT_LEFT(area
);
4013 tail
= RECT_RIGHT(area
);
4016 g_assert_not_reached();
4019 case OB_DIRECTION_NORTH
:
4020 case OB_DIRECTION_WEST
:
4021 /* check if our window is past the head of this window */
4022 if (my_head
<= head
+ 1)
4024 /* check if our window's tail is past the tail of this window */
4025 if (my_head
+ my_size
- 1 <= tail
)
4027 /* check if the head of this window is closer than the previously
4028 chosen edge (take into account that the previously chosen
4029 edge might have been a tail, not a head) */
4030 if (head
+ (*near_edge
? 0 : my_size
) < *dest
)
4032 /* check if the tail of this window is closer than the previously
4033 chosen edge (take into account that the previously chosen
4034 edge might have been a head, not a tail) */
4035 if (tail
- (!*near_edge
? 0 : my_size
) < *dest
)
4038 case OB_DIRECTION_SOUTH
:
4039 case OB_DIRECTION_EAST
:
4040 /* check if our window is past the head of this window */
4041 if (my_head
>= head
- 1)
4043 /* check if our window's tail is past the tail of this window */
4044 if (my_head
- my_size
+ 1 >= tail
)
4046 /* check if the head of this window is closer than the previously
4047 chosen edge (take into account that the previously chosen
4048 edge might have been a tail, not a head) */
4049 if (head
- (*near_edge
? 0 : my_size
) > *dest
)
4051 /* check if the tail of this window is closer than the previously
4052 chosen edge (take into account that the previously chosen
4053 edge might have been a head, not a tail) */
4054 if (tail
+ (!*near_edge
? 0 : my_size
) > *dest
)
4058 g_assert_not_reached();
4061 ob_debug("my head %d size %d", my_head
, my_size
);
4062 ob_debug("head %d tail %d deest %d", head
, tail
, *dest
);
4064 ob_debug("using near edge %d", head
);
4068 else if (!skip_tail
) {
4069 ob_debug("using far edge %d", tail
);
4075 void client_find_edge_directional(ObClient
*self
, ObDirection dir
,
4076 gint my_head
, gint my_size
,
4077 gint my_edge_start
, gint my_edge_size
,
4078 gint
*dest
, gboolean
*near_edge
)
4085 a
= screen_area(self
->desktop
, SCREEN_AREA_ALL_MONITORS
,
4086 &self
->frame
->area
);
4087 mon
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
,
4088 &self
->frame
->area
);
4091 case OB_DIRECTION_NORTH
:
4092 if (my_head
>= RECT_TOP(*mon
) + 1)
4093 edge
= RECT_TOP(*mon
) - 1;
4095 edge
= RECT_TOP(*a
) - 1;
4097 case OB_DIRECTION_SOUTH
:
4098 if (my_head
<= RECT_BOTTOM(*mon
) - 1)
4099 edge
= RECT_BOTTOM(*mon
) + 1;
4101 edge
= RECT_BOTTOM(*a
) + 1;
4103 case OB_DIRECTION_EAST
:
4104 if (my_head
<= RECT_RIGHT(*mon
) - 1)
4105 edge
= RECT_RIGHT(*mon
) + 1;
4107 edge
= RECT_RIGHT(*a
) + 1;
4109 case OB_DIRECTION_WEST
:
4110 if (my_head
>= RECT_LEFT(*mon
) + 1)
4111 edge
= RECT_LEFT(*mon
) - 1;
4113 edge
= RECT_LEFT(*a
) - 1;
4116 g_assert_not_reached();
4118 /* default to the far edge, then narrow it down */
4122 for (it
= client_list
; it
; it
= g_list_next(it
)) {
4123 ObClient
*cur
= it
->data
;
4125 /* skip windows to not bump into */
4130 if (self
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
&&
4131 cur
->desktop
!= screen_desktop
)
4134 ob_debug("trying window %s", cur
->title
);
4136 detect_edge(cur
->frame
->area
, dir
, my_head
, my_size
, my_edge_start
,
4137 my_edge_size
, dest
, near_edge
);
4139 dock_get_area(&dock_area
);
4140 detect_edge(dock_area
, dir
, my_head
, my_size
, my_edge_start
,
4141 my_edge_size
, dest
, near_edge
);
4146 void client_find_move_directional(ObClient
*self
, ObDirection dir
,
4150 gint e
, e_start
, e_size
;
4154 case OB_DIRECTION_EAST
:
4155 head
= RECT_RIGHT(self
->frame
->area
);
4156 size
= self
->frame
->area
.width
;
4157 e_start
= RECT_TOP(self
->frame
->area
);
4158 e_size
= self
->frame
->area
.height
;
4160 case OB_DIRECTION_WEST
:
4161 head
= RECT_LEFT(self
->frame
->area
);
4162 size
= self
->frame
->area
.width
;
4163 e_start
= RECT_TOP(self
->frame
->area
);
4164 e_size
= self
->frame
->area
.height
;
4166 case OB_DIRECTION_NORTH
:
4167 head
= RECT_TOP(self
->frame
->area
);
4168 size
= self
->frame
->area
.height
;
4169 e_start
= RECT_LEFT(self
->frame
->area
);
4170 e_size
= self
->frame
->area
.width
;
4172 case OB_DIRECTION_SOUTH
:
4173 head
= RECT_BOTTOM(self
->frame
->area
);
4174 size
= self
->frame
->area
.height
;
4175 e_start
= RECT_LEFT(self
->frame
->area
);
4176 e_size
= self
->frame
->area
.width
;
4179 g_assert_not_reached();
4182 client_find_edge_directional(self
, dir
, head
, size
,
4183 e_start
, e_size
, &e
, &near
);
4184 *x
= self
->frame
->area
.x
;
4185 *y
= self
->frame
->area
.y
;
4187 case OB_DIRECTION_EAST
:
4188 if (near
) e
-= self
->frame
->area
.width
;
4192 case OB_DIRECTION_WEST
:
4194 else e
-= self
->frame
->area
.width
;
4197 case OB_DIRECTION_NORTH
:
4199 else e
-= self
->frame
->area
.height
;
4202 case OB_DIRECTION_SOUTH
:
4203 if (near
) e
-= self
->frame
->area
.height
;
4208 g_assert_not_reached();
4210 frame_frame_gravity(self
->frame
, x
, y
);
4213 void client_find_resize_directional(ObClient
*self
, ObDirection side
,
4215 gint
*x
, gint
*y
, gint
*w
, gint
*h
)
4218 gint e
, e_start
, e_size
, delta
;
4223 case OB_DIRECTION_EAST
:
4224 head
= RECT_RIGHT(self
->frame
->area
) +
4225 (self
->size_inc
.width
- 1) * (grow
? 1 : -1);
4226 e_start
= RECT_TOP(self
->frame
->area
);
4227 e_size
= self
->frame
->area
.height
;
4228 dir
= grow
? OB_DIRECTION_EAST
: OB_DIRECTION_WEST
;
4230 case OB_DIRECTION_WEST
:
4231 head
= RECT_LEFT(self
->frame
->area
) -
4232 (self
->size_inc
.width
- 1) * (grow
? 1 : -1);
4233 e_start
= RECT_TOP(self
->frame
->area
);
4234 e_size
= self
->frame
->area
.height
;
4235 dir
= grow
? OB_DIRECTION_WEST
: OB_DIRECTION_EAST
;
4237 case OB_DIRECTION_NORTH
:
4238 head
= RECT_TOP(self
->frame
->area
) -
4239 (self
->size_inc
.height
- 1) * (grow
? 1 : -1);
4240 e_start
= RECT_LEFT(self
->frame
->area
);
4241 e_size
= self
->frame
->area
.width
;
4242 dir
= grow
? OB_DIRECTION_NORTH
: OB_DIRECTION_SOUTH
;
4244 case OB_DIRECTION_SOUTH
:
4245 head
= RECT_BOTTOM(self
->frame
->area
) +
4246 (self
->size_inc
.height
- 1) * (grow
? 1 : -1);
4247 e_start
= RECT_LEFT(self
->frame
->area
);
4248 e_size
= self
->frame
->area
.width
;
4249 dir
= grow
? OB_DIRECTION_SOUTH
: OB_DIRECTION_NORTH
;
4252 g_assert_not_reached();
4255 ob_debug("head %d dir %d", head
, dir
);
4256 client_find_edge_directional(self
, dir
, head
, 1,
4257 e_start
, e_size
, &e
, &near
);
4258 ob_debug("edge %d", e
);
4259 *x
= self
->frame
->area
.x
;
4260 *y
= self
->frame
->area
.y
;
4261 *w
= self
->frame
->area
.width
;
4262 *h
= self
->frame
->area
.height
;
4264 case OB_DIRECTION_EAST
:
4265 if (grow
== near
) --e
;
4266 delta
= e
- RECT_RIGHT(self
->frame
->area
);
4269 case OB_DIRECTION_WEST
:
4270 if (grow
== near
) ++e
;
4271 delta
= RECT_LEFT(self
->frame
->area
) - e
;
4275 case OB_DIRECTION_NORTH
:
4276 if (grow
== near
) ++e
;
4277 delta
= RECT_TOP(self
->frame
->area
) - e
;
4281 case OB_DIRECTION_SOUTH
:
4282 if (grow
== near
) --e
;
4283 delta
= e
- RECT_BOTTOM(self
->frame
->area
);
4287 g_assert_not_reached();
4289 frame_frame_gravity(self
->frame
, x
, y
);
4290 *w
-= self
->frame
->size
.left
+ self
->frame
->size
.right
;
4291 *h
-= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
4294 ObClient
* client_under_pointer(void)
4298 ObClient
*ret
= NULL
;
4300 if (screen_pointer_pos(&x
, &y
)) {
4301 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
4302 if (WINDOW_IS_CLIENT(it
->data
)) {
4303 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
4304 if (c
->frame
->visible
&&
4305 /* check the desktop, this is done during desktop
4306 switching and windows are shown/hidden status is not
4308 (c
->desktop
== screen_desktop
||
4309 c
->desktop
== DESKTOP_ALL
) &&
4310 /* ignore all animating windows */
4311 !frame_iconify_animating(c
->frame
) &&
4312 RECT_CONTAINS(c
->frame
->area
, x
, y
))
4323 gboolean
client_has_group_siblings(ObClient
*self
)
4325 return self
->group
&& self
->group
->members
->next
;