1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
22 #include "startupnotify.h"
26 #include "moveresize.h"
30 #include "extensions.h"
41 #include "menuframe.h"
44 #include "render/render.h"
52 # include <signal.h> /* for kill() */
56 #include <X11/Xutil.h>
58 /*! The event mask to grab on client windows */
59 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
62 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
67 ObClientCallback func
;
71 GList
*client_list
= NULL
;
73 static GSList
*client_destroy_notifies
= NULL
;
74 static RrImage
*client_default_icon
= NULL
;
76 static void client_get_all(ObClient
*self
, gboolean real
);
77 static void client_get_startup_id(ObClient
*self
);
78 static void client_get_session_ids(ObClient
*self
);
79 static void client_get_area(ObClient
*self
);
80 static void client_get_desktop(ObClient
*self
);
81 static void client_get_state(ObClient
*self
);
82 static void client_get_shaped(ObClient
*self
);
83 static void client_get_mwm_hints(ObClient
*self
);
84 static void client_get_colormap(ObClient
*self
);
85 static void client_set_desktop_recursive(ObClient
*self
,
89 static void client_change_allowed_actions(ObClient
*self
);
90 static void client_change_state(ObClient
*self
);
91 static void client_change_wm_state(ObClient
*self
);
92 static void client_apply_startup_state(ObClient
*self
,
93 gint x
, gint y
, gint w
, gint h
);
94 static void client_restore_session_state(ObClient
*self
);
95 static gboolean
client_restore_session_stacking(ObClient
*self
);
96 static ObAppSettings
*client_get_settings_state(ObClient
*self
);
97 static void client_update_transient_tree(ObClient
*self
,
98 ObGroup
*oldgroup
, ObGroup
*newgroup
,
99 gboolean oldgtran
, gboolean newgtran
,
101 ObClient
*newparent
);
102 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
,
104 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
106 ObStackingLayer layer
);
107 static void client_call_notifies(ObClient
*self
, GSList
*list
);
108 static void client_ping_event(ObClient
*self
, gboolean dead
);
109 static void client_prompt_kill(ObClient
*self
);
111 void client_startup(gboolean reconfig
)
113 if ((client_default_icon
= RrImageCacheFind(ob_rr_icons
,
114 ob_rr_theme
->def_win_icon
,
115 ob_rr_theme
->def_win_icon_w
,
116 ob_rr_theme
->def_win_icon_h
)))
117 RrImageRef(client_default_icon
);
119 client_default_icon
= RrImageNew(ob_rr_icons
);
120 RrImageAddPicture(client_default_icon
,
121 ob_rr_theme
->def_win_icon
,
122 ob_rr_theme
->def_win_icon_w
,
123 ob_rr_theme
->def_win_icon_h
);
126 if (reconfig
) return;
131 void client_shutdown(gboolean reconfig
)
133 RrImageUnref(client_default_icon
);
134 client_default_icon
= NULL
;
136 if (reconfig
) return;
139 static void client_call_notifies(ObClient
*self
, GSList
*list
)
143 for (it
= list
; it
; it
= g_slist_next(it
)) {
144 ClientCallback
*d
= it
->data
;
145 d
->func(self
, d
->data
);
149 void client_add_destroy_notify(ObClientCallback func
, gpointer data
)
151 ClientCallback
*d
= g_new(ClientCallback
, 1);
154 client_destroy_notifies
= g_slist_prepend(client_destroy_notifies
, d
);
157 void client_remove_destroy_notify(ObClientCallback func
)
161 for (it
= client_destroy_notifies
; it
; it
= g_slist_next(it
)) {
162 ClientCallback
*d
= it
->data
;
163 if (d
->func
== func
) {
165 client_destroy_notifies
=
166 g_slist_delete_link(client_destroy_notifies
, it
);
172 void client_set_list(void)
174 Window
*windows
, *win_it
;
176 guint size
= g_list_length(client_list
);
178 /* create an array of the window ids */
180 windows
= g_new(Window
, size
);
182 for (it
= client_list
; it
; it
= g_list_next(it
), ++win_it
)
183 *win_it
= ((ObClient
*)it
->data
)->window
;
187 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
188 net_client_list
, window
, (gulong
*)windows
, size
);
196 void client_manage_all(void)
201 XWindowAttributes attrib
;
203 XQueryTree(ob_display
, RootWindow(ob_display
, ob_screen
),
204 &w
, &w
, &children
, &nchild
);
206 /* remove all icon windows from the list */
207 for (i
= 0; i
< nchild
; i
++) {
208 if (children
[i
] == None
) continue;
209 wmhints
= XGetWMHints(ob_display
, children
[i
]);
211 if ((wmhints
->flags
& IconWindowHint
) &&
212 (wmhints
->icon_window
!= children
[i
]))
213 for (j
= 0; j
< nchild
; j
++)
214 if (children
[j
] == wmhints
->icon_window
) {
222 /* manage windows in reverse order from how they were originally mapped.
223 this is an attempt to manage children windows before their parents, so
224 that when the parent is mapped, it can find the child */
225 for (i
= 0; i
< nchild
; ++i
) {
226 if (children
[i
] == None
)
228 if (XGetWindowAttributes(ob_display
, children
[i
], &attrib
)) {
229 if (attrib
.override_redirect
) continue;
231 if (attrib
.map_state
!= IsUnmapped
)
232 client_manage(children
[i
], NULL
);
238 void client_manage(Window window
, ObPrompt
*prompt
)
242 XWindowAttributes attrib
;
243 XSetWindowAttributes attrib_set
;
245 gboolean activate
= FALSE
;
246 ObAppSettings
*settings
;
247 gboolean transient
= FALSE
;
248 Rect place
, *monitor
;
249 Time launch_time
, map_time
;
254 /* check if it has already been unmapped by the time we started
255 mapping. the grab does a sync so we don't have to here */
256 if (XCheckTypedWindowEvent(ob_display
, window
, DestroyNotify
, &e
) ||
257 XCheckTypedWindowEvent(ob_display
, window
, UnmapNotify
, &e
))
259 XPutBackEvent(ob_display
, &e
);
261 ob_debug("Trying to manage unmapped window. Aborting that.\n");
263 return; /* don't manage it */
266 /* make sure it isn't an override-redirect window */
267 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
268 attrib
.override_redirect
)
271 return; /* don't manage it */
274 /* is the window a docking app */
275 if ((wmhint
= XGetWMHints(ob_display
, window
))) {
276 if ((wmhint
->flags
& StateHint
) &&
277 wmhint
->initial_state
== WithdrawnState
)
279 dock_add(window
, wmhint
);
287 ob_debug("Managing window: 0x%lx\n", window
);
289 map_time
= event_get_server_time();
291 /* choose the events we want to receive on the CLIENT window
292 (ObPrompt windows can request events too) */
293 attrib_set
.event_mask
= CLIENT_EVENTMASK
|
294 (prompt
? prompt
->event_mask
: 0);
295 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
296 XChangeWindowAttributes(ob_display
, window
,
297 CWEventMask
|CWDontPropagate
, &attrib_set
);
299 /* create the ObClient struct, and populate it from the hints on the
301 self
= g_new0(ObClient
, 1);
302 self
->obwin
.type
= Window_Client
;
303 self
->window
= window
;
304 self
->prompt
= prompt
;
306 /* non-zero defaults */
307 self
->wmstate
= WithdrawnState
; /* make sure it gets updated first time */
308 self
->gravity
= NorthWestGravity
;
309 self
->desktop
= screen_num_desktops
; /* always an invalid value */
311 /* get all the stuff off the window */
312 client_get_all(self
, TRUE
);
314 ob_debug("Window type: %d\n", self
->type
);
315 ob_debug("Window group: 0x%x\n", self
->group
?self
->group
->leader
:0);
316 ob_debug("Window name: %s class: %s role: %s\n", self
->name
, self
->class, self
->role
);
318 /* per-app settings override stuff from client_get_all, and return the
319 settings for other uses too. the returned settings is a shallow copy,
320 that needs to be freed with g_free(). */
321 settings
= client_get_settings_state(self
);
323 /* now we have all of the window's information so we can set this up.
324 do this before creating the frame, so it can tell that we are still
325 mapping and doesn't go applying things right away */
326 client_setup_decor_and_functions(self
, FALSE
);
328 /* specify that if we exit, the window should not be destroyed and
329 should be reparented back to root automatically, unless we are managing
330 an internal ObPrompt window */
332 XChangeSaveSet(ob_display
, window
, SetModeInsert
);
334 /* create the decoration frame for the client window */
335 self
->frame
= frame_new(self
);
337 frame_grab_client(self
->frame
);
339 /* we've grabbed everything and set everything that we need to at mapping
343 /* the session should get the last say though */
344 client_restore_session_state(self
);
346 /* tell startup notification that this app started */
347 launch_time
= sn_app_started(self
->startup_id
, self
->class, self
->name
);
349 if (!PROP_GET32(self
->window
, net_wm_user_time
, cardinal
, &user_time
))
350 user_time
= map_time
;
352 /* do this after we have a frame.. it uses the frame to help determine the
353 WM_STATE to apply. */
354 client_change_state(self
);
356 /* add ourselves to the focus order */
357 focus_order_add_new(self
);
359 /* do this to add ourselves to the stacking list in a non-intrusive way */
360 client_calc_layer(self
);
362 /* focus the new window? */
363 if (ob_state() != OB_STATE_STARTING
&&
364 (!self
->session
|| self
->session
->focused
) &&
365 /* this means focus=true for window is same as config_focus_new=true */
366 ((config_focus_new
|| (settings
&& settings
->focus
== 1)) ||
367 client_search_focus_tree_full(self
)) &&
368 /* NET_WM_USER_TIME 0 when mapping means don't focus */
370 /* this checks for focus=false for the window */
371 (!settings
|| settings
->focus
!= 0) &&
372 focus_valid_target(self
, FALSE
, FALSE
, TRUE
, FALSE
, FALSE
))
377 /* remove the client's border */
378 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
380 /* adjust the frame to the client's size before showing or placing
382 frame_adjust_area(self
->frame
, FALSE
, TRUE
, FALSE
);
383 frame_adjust_client_area(self
->frame
);
385 /* where the frame was placed is where the window was originally */
387 monitor
= screen_physical_area_monitor(screen_find_monitor(&place
));
389 /* figure out placement for the window if the window is new */
390 if (ob_state() == OB_STATE_RUNNING
) {
391 ob_debug("Positioned: %s @ %d %d\n",
392 (!self
->positioned
? "no" :
393 (self
->positioned
== PPosition
? "program specified" :
394 (self
->positioned
== USPosition
? "user specified" :
395 (self
->positioned
== (PPosition
| USPosition
) ?
396 "program + user specified" :
397 "BADNESS !?")))), place
.x
, place
.y
);
399 ob_debug("Sized: %s @ %d %d\n",
400 (!self
->sized
? "no" :
401 (self
->sized
== PSize
? "program specified" :
402 (self
->sized
== USSize
? "user specified" :
403 (self
->sized
== (PSize
| USSize
) ?
404 "program + user specified" :
405 "BADNESS !?")))), place
.width
, place
.height
);
407 /* splash screens are also returned as TRUE for transient,
408 and so will be forced on screen below */
409 transient
= place_client(self
, &place
.x
, &place
.y
, settings
);
411 /* make sure the window is visible. */
412 client_find_onscreen(self
, &place
.x
, &place
.y
,
413 place
.width
, place
.height
,
414 /* non-normal clients has less rules, and
415 windows that are being restored from a
416 session do also. we can assume you want
417 it back where you saved it. Clients saying
418 they placed themselves are subjected to
419 harder rules, ones that are placed by
420 place.c or by the user are allowed partially
421 off-screen and on xinerama divides (ie,
422 it is up to the placement routines to avoid
423 the xinerama divides)
425 splash screens get "transient" set to TRUE by
426 the place_client call
428 ob_state() == OB_STATE_RUNNING
&&
430 (!((self
->positioned
& USPosition
) ||
431 (settings
&& settings
->pos_given
)) &&
432 client_normal(self
) &&
434 /* don't move oldschool fullscreen windows to
435 fit inside the struts (fixes Acroread, which
436 makes its fullscreen window fit the screen
437 but it is not USSize'd or USPosition'd) */
438 !(self
->decorations
== 0 &&
439 RECT_EQUAL(place
, *monitor
)))));
442 /* if the window isn't user-sized, then make it fit inside
443 the visible screen area on its monitor. Use basically the same rules
444 for forcing the window on screen in the client_find_onscreen call.
446 do this after place_client, it chooses the monitor!
448 splash screens get "transient" set to TRUE by
449 the place_client call
451 if (ob_state() == OB_STATE_RUNNING
&&
453 (!(self
->sized
& USSize
|| self
->positioned
& USPosition
) &&
454 client_normal(self
) &&
456 /* don't shrink oldschool fullscreen windows to fit inside the
457 struts (fixes Acroread, which makes its fullscreen window
458 fit the screen but it is not USSize'd or USPosition'd) */
459 !(self
->decorations
== 0 && RECT_EQUAL(place
, *monitor
)))))
461 Rect
*a
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
, &place
);
463 /* get the size of the frame */
464 place
.width
+= self
->frame
->size
.left
+ self
->frame
->size
.right
;
465 place
.height
+= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
467 /* fit the window inside the area */
468 place
.width
= MIN(place
.width
, a
->width
);
469 place
.height
= MIN(place
.height
, a
->height
);
471 ob_debug("setting window size to %dx%d\n", place
.width
, place
.height
);
473 /* get the size of the client back */
474 place
.width
-= self
->frame
->size
.left
+ self
->frame
->size
.right
;
475 place
.height
-= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
480 ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
481 "some restrictions may apply\n",
482 self
->window
, place
.x
, place
.y
, place
.width
, place
.height
);
484 ob_debug(" but session requested %d, %d %d x %d instead, "
486 self
->session
->x
, self
->session
->y
,
487 self
->session
->w
, self
->session
->h
);
489 /* do this after the window is placed, so the premax/prefullscreen numbers
492 this also places the window
494 client_apply_startup_state(self
, place
.x
, place
.y
,
495 place
.width
, place
.height
);
500 ob_debug_type(OB_DEBUG_FOCUS
, "Going to try activate new window? %s\n",
501 activate
? "yes" : "no");
503 gboolean raise
= FALSE
;
504 gboolean relative_focused
;
505 gboolean parent_focused
;
507 parent_focused
= (focus_client
!= NULL
&&
508 client_search_focus_parent(self
));
509 relative_focused
= (focus_client
!= NULL
&&
510 (client_search_focus_tree_full(self
) != NULL
||
511 client_search_focus_group_full(self
) != NULL
));
513 /* This is focus stealing prevention */
514 ob_debug_type(OB_DEBUG_FOCUS
,
515 "Want to focus new window 0x%x at time %u "
516 "launched at %u (last user interaction time %u)\n",
517 self
->window
, map_time
, launch_time
,
518 event_last_user_time
);
520 if (menu_frame_visible
|| moveresize_in_progress
) {
523 ob_debug_type(OB_DEBUG_FOCUS
,
524 "Not focusing the window because the user is inside "
525 "an Openbox menu or is move/resizing a window and "
526 "we don't want to interrupt them\n");
529 /* if it's on another desktop */
530 else if (!(self
->desktop
== screen_desktop
||
531 self
->desktop
== DESKTOP_ALL
) &&
532 /* the timestamp is from before you changed desktops */
533 launch_time
&& screen_desktop_user_time
&&
534 !event_time_after(launch_time
, screen_desktop_user_time
))
538 ob_debug_type(OB_DEBUG_FOCUS
,
539 "Not focusing the window because its on another "
542 /* If something is focused... */
543 else if (focus_client
) {
544 /* If the user is working in another window right now, then don't
546 if (!parent_focused
&&
547 event_last_user_time
&& launch_time
&&
548 event_time_after(event_last_user_time
, launch_time
) &&
549 event_last_user_time
!= launch_time
&&
550 event_time_after(event_last_user_time
,
551 map_time
- OB_EVENT_USER_TIME_DELAY
))
554 ob_debug_type(OB_DEBUG_FOCUS
,
555 "Not focusing the window because the user is "
556 "working in another window that is not "
559 /* If the new window is a transient (and its relatives aren't
561 else if (client_has_parent(self
) && !relative_focused
) {
563 ob_debug_type(OB_DEBUG_FOCUS
,
564 "Not focusing the window because it is a "
565 "transient, and its relatives aren't focused\n");
567 /* Don't steal focus from globally active clients.
568 I stole this idea from KWin. It seems nice.
570 else if (!(focus_client
->can_focus
||
571 focus_client
->focus_notify
))
574 ob_debug_type(OB_DEBUG_FOCUS
,
575 "Not focusing the window because a globally "
576 "active client has focus\n");
578 /* Don't move focus if it's not going to go to this window
580 else if (client_focus_target(self
) != self
) {
583 ob_debug_type(OB_DEBUG_FOCUS
,
584 "Not focusing the window because another window "
585 "would get the focus anyway\n");
587 /* Don't move focus if the window is not visible on the current
588 desktop and none of its relatives are focused */
589 else if (!(self
->desktop
== screen_desktop
||
590 self
->desktop
== DESKTOP_ALL
) &&
595 ob_debug_type(OB_DEBUG_FOCUS
,
596 "Not focusing the window because it is on "
597 "another desktop and no relatives are focused ");
602 ob_debug_type(OB_DEBUG_FOCUS
,
603 "Focus stealing prevention activated for %s at "
604 "time %u (last user interaction time %u)\n",
605 self
->title
, map_time
, event_last_user_time
);
606 /* if the client isn't focused, then hilite it so the user
608 client_hilite(self
, TRUE
);
609 /* we may want to raise it even tho we're not activating it */
610 if (raise
&& !client_restore_session_stacking(self
))
611 stacking_raise(CLIENT_AS_WINDOW(self
));
615 /* This may look rather odd. Well it's because new windows are added
616 to the stacking order non-intrusively. If we're not going to focus
617 the new window or hilite it, then we raise it to the top. This will
618 take affect for things that don't get focused like splash screens.
619 Also if you don't have focus_new enabled, then it's going to get
620 raised to the top. Legacy begets legacy I guess?
622 if (!client_restore_session_stacking(self
))
623 stacking_raise(CLIENT_AS_WINDOW(self
));
626 mouse_grab_for_client(self
, TRUE
);
628 /* this has to happen before we try focus the window, but we want it to
629 happen after the client's stacking has been determined or it looks bad
633 if (!config_focus_under_mouse
)
634 ignore_start
= event_start_ignore_all_enters();
638 if (!config_focus_under_mouse
)
639 event_end_ignore_all_enters(ignore_start
);
643 gboolean stacked
= client_restore_session_stacking(self
);
644 client_present(self
, FALSE
, !stacked
, TRUE
);
647 /* add to client list/map */
648 client_list
= g_list_append(client_list
, self
);
649 g_hash_table_insert(window_map
, &self
->window
, self
);
651 /* this has to happen after we're in the client_list */
652 if (STRUT_EXISTS(self
->strut
))
653 screen_update_areas();
655 /* update the list hints */
658 /* free the ObAppSettings shallow copy */
661 ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
662 window
, self
->frame
->window
, self
->class);
667 ObClient
*client_fake_manage(Window window
)
670 ObAppSettings
*settings
;
672 ob_debug("Pretend-managing window: %lx\n", window
);
674 /* do this minimal stuff to figure out the client's decorations */
676 self
= g_new0(ObClient
, 1);
677 self
->window
= window
;
679 client_get_all(self
, FALSE
);
680 /* per-app settings override stuff, and return the settings for other
681 uses too. this returns a shallow copy that needs to be freed */
682 settings
= client_get_settings_state(self
);
684 client_setup_decor_and_functions(self
, FALSE
);
686 /* create the decoration frame for the client window and adjust its size */
687 self
->frame
= frame_new(self
);
688 frame_adjust_area(self
->frame
, FALSE
, TRUE
, TRUE
);
690 ob_debug("gave extents left %d right %d top %d bottom %d\n",
691 self
->frame
->size
.left
, self
->frame
->size
.right
,
692 self
->frame
->size
.top
, self
->frame
->size
.bottom
);
694 /* free the ObAppSettings shallow copy */
700 void client_unmanage_all(void)
703 client_unmanage(client_list
->data
);
706 void client_unmanage(ObClient
*self
)
711 ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
712 self
->window
, self
->frame
->window
,
713 self
->class, self
->title
? self
->title
: "");
715 g_assert(self
!= NULL
);
717 /* we dont want events no more. do this before hiding the frame so we
718 don't generate more events */
719 XSelectInput(ob_display
, self
->window
, NoEventMask
);
721 /* ignore enter events from the unmap so it doesnt mess with the focus */
722 if (!config_focus_under_mouse
)
723 ignore_start
= event_start_ignore_all_enters();
725 frame_hide(self
->frame
);
726 /* flush to send the hide to the server quickly */
729 if (!config_focus_under_mouse
)
730 event_end_ignore_all_enters(ignore_start
);
732 mouse_grab_for_client(self
, FALSE
);
734 /* remove the window from our save set, unless we are managing an internal
737 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
739 /* update the focus lists */
740 focus_order_remove(self
);
741 if (client_focused(self
)) {
742 /* don't leave an invalid focus_client */
746 /* if we're prompting to kill the client, close that */
747 prompt_unref(self
->kill_prompt
);
748 self
->kill_prompt
= NULL
;
750 client_list
= g_list_remove(client_list
, self
);
751 stacking_remove(self
);
752 g_hash_table_remove(window_map
, &self
->window
);
754 /* once the client is out of the list, update the struts to remove its
756 if (STRUT_EXISTS(self
->strut
))
757 screen_update_areas();
759 client_call_notifies(self
, client_destroy_notifies
);
761 /* tell our parent(s) that we're gone */
762 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
763 ((ObClient
*)it
->data
)->transients
=
764 g_slist_remove(((ObClient
*)it
->data
)->transients
,self
);
766 /* tell our transients that we're gone */
767 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
768 ((ObClient
*)it
->data
)->parents
=
769 g_slist_remove(((ObClient
*)it
->data
)->parents
, self
);
770 /* we could be keeping our children in a higher layer */
771 client_calc_layer(it
->data
);
774 /* remove from its group */
776 group_remove(self
->group
, self
);
780 /* restore the window's original geometry so it is not lost */
786 if (self
->fullscreen
)
787 a
= self
->pre_fullscreen_area
;
788 else if (self
->max_horz
|| self
->max_vert
) {
789 if (self
->max_horz
) {
790 a
.x
= self
->pre_max_area
.x
;
791 a
.width
= self
->pre_max_area
.width
;
793 if (self
->max_vert
) {
794 a
.y
= self
->pre_max_area
.y
;
795 a
.height
= self
->pre_max_area
.height
;
799 self
->fullscreen
= self
->max_horz
= self
->max_vert
= FALSE
;
800 /* let it be moved and resized no matter what */
801 self
->functions
= OB_CLIENT_FUNC_MOVE
| OB_CLIENT_FUNC_RESIZE
;
802 self
->decorations
= 0; /* unmanaged windows have no decor */
804 /* give the client its border back */
805 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
807 client_move_resize(self
, a
.x
, a
.y
, a
.width
, a
.height
);
810 /* reparent the window out of the frame, and free the frame */
811 frame_release_client(self
->frame
);
812 frame_free(self
->frame
);
815 if (ob_state() != OB_STATE_EXITING
) {
816 /* these values should not be persisted across a window
818 PROP_ERASE(self
->window
, net_wm_desktop
);
819 PROP_ERASE(self
->window
, net_wm_state
);
820 PROP_ERASE(self
->window
, wm_state
);
822 /* if we're left in an unmapped state, the client wont be mapped.
823 this is bad, since we will no longer be managing the window on
825 XMapWindow(ob_display
, self
->window
);
828 /* these should not be left on the window ever. other window managers
829 don't necessarily use them and it will mess them up (like compiz) */
830 PROP_ERASE(self
->window
, net_wm_visible_name
);
831 PROP_ERASE(self
->window
, net_wm_visible_icon_name
);
833 /* update the list hints */
836 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
838 /* free all data allocated in the client struct */
839 RrImageUnref(self
->icon_set
);
840 g_slist_free(self
->transients
);
841 g_free(self
->startup_id
);
842 g_free(self
->wm_command
);
844 g_free(self
->icon_title
);
845 g_free(self
->original_title
);
849 g_free(self
->client_machine
);
850 g_free(self
->sm_client_id
);
854 void client_fake_unmanage(ObClient
*self
)
856 /* this is all that got allocated to get the decorations */
858 frame_free(self
->frame
);
862 /*! Returns a new structure containing the per-app settings for this client.
863 The returned structure needs to be freed with g_free. */
864 static ObAppSettings
*client_get_settings_state(ObClient
*self
)
866 ObAppSettings
*settings
;
869 settings
= config_create_app_settings();
871 for (it
= config_per_app_settings
; it
; it
= g_slist_next(it
)) {
872 ObAppSettings
*app
= it
->data
;
873 gboolean match
= TRUE
;
875 g_assert(app
->name
!= NULL
|| app
->class != NULL
);
877 /* we know that either name or class is not NULL so it will have to
878 match to use the rule */
880 !g_pattern_match(app
->name
, strlen(self
->name
), self
->name
, NULL
))
882 else if (app
->class &&
883 !g_pattern_match(app
->class,
884 strlen(self
->class), self
->class, NULL
))
886 else if (app
->role
&&
887 !g_pattern_match(app
->role
,
888 strlen(self
->role
), self
->role
, NULL
))
890 else if ((signed)app
->type
>= 0 && app
->type
!= self
->type
)
894 ob_debug("Window matching: %s\n", app
->name
);
896 /* copy the settings to our struct, overriding the existing
897 settings if they are not defaults */
898 config_app_settings_copy_non_defaults(app
, settings
);
902 if (settings
->shade
!= -1)
903 self
->shaded
= !!settings
->shade
;
904 if (settings
->decor
!= -1)
905 self
->undecorated
= !settings
->decor
;
906 if (settings
->iconic
!= -1)
907 self
->iconic
= !!settings
->iconic
;
908 if (settings
->skip_pager
!= -1)
909 self
->skip_pager
= !!settings
->skip_pager
;
910 if (settings
->skip_taskbar
!= -1)
911 self
->skip_taskbar
= !!settings
->skip_taskbar
;
913 if (settings
->max_vert
!= -1)
914 self
->max_vert
= !!settings
->max_vert
;
915 if (settings
->max_horz
!= -1)
916 self
->max_horz
= !!settings
->max_horz
;
918 if (settings
->fullscreen
!= -1)
919 self
->fullscreen
= !!settings
->fullscreen
;
921 if (settings
->desktop
) {
922 if (settings
->desktop
== DESKTOP_ALL
)
923 self
->desktop
= settings
->desktop
;
924 else if (settings
->desktop
> 0 &&
925 settings
->desktop
<= screen_num_desktops
)
926 self
->desktop
= settings
->desktop
- 1;
929 if (settings
->layer
== -1) {
933 else if (settings
->layer
== 0) {
937 else if (settings
->layer
== 1) {
944 static void client_restore_session_state(ObClient
*self
)
948 ob_debug_type(OB_DEBUG_SM
,
949 "Restore session for client %s\n", self
->title
);
951 if (!(it
= session_state_find(self
))) {
952 ob_debug_type(OB_DEBUG_SM
,
953 "Session data not found for client %s\n", self
->title
);
957 self
->session
= it
->data
;
959 ob_debug_type(OB_DEBUG_SM
, "Session data loaded for client %s\n",
962 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
963 self
->positioned
= USPosition
;
964 self
->sized
= USSize
;
965 if (self
->session
->w
> 0)
966 self
->area
.width
= self
->session
->w
;
967 if (self
->session
->h
> 0)
968 self
->area
.height
= self
->session
->h
;
969 XResizeWindow(ob_display
, self
->window
,
970 self
->area
.width
, self
->area
.height
);
972 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
973 self
->session
->desktop
:
974 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
975 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
977 self
->shaded
= self
->session
->shaded
;
978 self
->iconic
= self
->session
->iconic
;
979 self
->skip_pager
= self
->session
->skip_pager
;
980 self
->skip_taskbar
= self
->session
->skip_taskbar
;
981 self
->fullscreen
= self
->session
->fullscreen
;
982 self
->above
= self
->session
->above
;
983 self
->below
= self
->session
->below
;
984 self
->max_horz
= self
->session
->max_horz
;
985 self
->max_vert
= self
->session
->max_vert
;
986 self
->undecorated
= self
->session
->undecorated
;
989 static gboolean
client_restore_session_stacking(ObClient
*self
)
993 if (!self
->session
) return FALSE
;
995 mypos
= g_list_find(session_saved_state
, self
->session
);
996 if (!mypos
) return FALSE
;
998 /* start above me and look for the first client */
999 for (it
= g_list_previous(mypos
); it
; it
= g_list_previous(it
)) {
1002 for (cit
= client_list
; cit
; cit
= g_list_next(cit
)) {
1003 ObClient
*c
= cit
->data
;
1004 /* found a client that was in the session, so go below it */
1005 if (c
->session
== it
->data
) {
1006 stacking_below(CLIENT_AS_WINDOW(self
),
1007 CLIENT_AS_WINDOW(cit
->data
));
1015 void client_move_onscreen(ObClient
*self
, gboolean rude
)
1017 gint x
= self
->area
.x
;
1018 gint y
= self
->area
.y
;
1019 if (client_find_onscreen(self
, &x
, &y
,
1021 self
->area
.height
, rude
)) {
1022 client_move(self
, x
, y
);
1026 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
1029 gint ox
= *x
, oy
= *y
;
1030 gboolean rudel
= rude
, ruder
= rude
, rudet
= rude
, rudeb
= rude
;
1036 RECT_SET(desired
, *x
, *y
, w
, h
);
1037 frame_rect_to_frame(self
->frame
, &desired
);
1039 /* get where the frame would be */
1040 frame_client_gravity(self
->frame
, x
, y
);
1042 /* get the requested size of the window with decorations */
1043 fw
= self
->frame
->size
.left
+ w
+ self
->frame
->size
.right
;
1044 fh
= self
->frame
->size
.top
+ h
+ self
->frame
->size
.bottom
;
1046 /* If rudeness wasn't requested, then still be rude in a given direction
1047 if the client is not moving, only resizing in that direction */
1049 Point oldtl
, oldtr
, oldbl
, oldbr
;
1050 Point newtl
, newtr
, newbl
, newbr
;
1051 gboolean stationary_l
, stationary_r
, stationary_t
, stationary_b
;
1053 POINT_SET(oldtl
, self
->frame
->area
.x
, self
->frame
->area
.y
);
1054 POINT_SET(oldbr
, self
->frame
->area
.x
+ self
->frame
->area
.width
- 1,
1055 self
->frame
->area
.y
+ self
->frame
->area
.height
- 1);
1056 POINT_SET(oldtr
, oldbr
.x
, oldtl
.y
);
1057 POINT_SET(oldbl
, oldtl
.x
, oldbr
.y
);
1059 POINT_SET(newtl
, *x
, *y
);
1060 POINT_SET(newbr
, *x
+ fw
- 1, *y
+ fh
- 1);
1061 POINT_SET(newtr
, newbr
.x
, newtl
.y
);
1062 POINT_SET(newbl
, newtl
.x
, newbr
.y
);
1064 /* is it moving or just resizing from some corner? */
1065 stationary_l
= oldtl
.x
== newtl
.x
;
1066 stationary_r
= oldtr
.x
== newtr
.x
;
1067 stationary_t
= oldtl
.y
== newtl
.y
;
1068 stationary_b
= oldbl
.y
== newbl
.y
;
1070 /* if left edge is growing and didnt move right edge */
1071 if (stationary_r
&& newtl
.x
< oldtl
.x
)
1073 /* if right edge is growing and didnt move left edge */
1074 if (stationary_l
&& newtr
.x
> oldtr
.x
)
1076 /* if top edge is growing and didnt move bottom edge */
1077 if (stationary_b
&& newtl
.y
< oldtl
.y
)
1079 /* if bottom edge is growing and didnt move top edge */
1080 if (stationary_t
&& newbl
.y
> oldbl
.y
)
1084 /* we iterate through every monitor that the window is at least partially
1085 on, to make sure it is obeying the rules on them all
1087 if the window does not appear on any monitors, then use the first one
1090 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1093 if (!screen_physical_area_monitor_contains(i
, &desired
)) {
1094 if (i
< screen_num_monitors
- 1 || found_mon
)
1097 /* the window is not inside any monitor! so just use the first
1099 a
= screen_area(self
->desktop
, 0, NULL
);
1102 a
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
, &desired
);
1105 /* This makes sure windows aren't entirely outside of the screen so you
1106 can't see them at all.
1107 It makes sure 10% of the window is on the screen at least. And don't
1108 let it move itself off the top of the screen, which would hide the
1109 titlebar on you. (The user can still do this if they want too, it's
1110 only limiting the application.
1112 if (client_normal(self
)) {
1113 if (!self
->strut
.right
&& *x
+ fw
/10 >= a
->x
+ a
->width
- 1)
1114 *x
= a
->x
+ a
->width
- fw
/10;
1115 if (!self
->strut
.bottom
&& *y
+ fh
/10 >= a
->y
+ a
->height
- 1)
1116 *y
= a
->y
+ a
->height
- fh
/10;
1117 if (!self
->strut
.left
&& *x
+ fw
*9/10 - 1 < a
->x
)
1118 *x
= a
->x
- fw
*9/10;
1119 if (!self
->strut
.top
&& *y
+ fh
*9/10 - 1 < a
->y
)
1120 *y
= a
->y
- fh
*9/10;
1123 /* This here doesn't let windows even a pixel outside the
1124 struts/screen. When called from client_manage, programs placing
1125 themselves are forced completely onscreen, while things like
1126 xterm -geometry resolution-width/2 will work fine. Trying to
1127 place it completely offscreen will be handled in the above code.
1128 Sorry for this confused comment, i am tired. */
1129 if (rudel
&& !self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
1130 if (ruder
&& !self
->strut
.right
&& *x
+ fw
> a
->x
+ a
->width
)
1131 *x
= a
->x
+ MAX(0, a
->width
- fw
);
1133 if (rudet
&& !self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
1134 if (rudeb
&& !self
->strut
.bottom
&& *y
+ fh
> a
->y
+ a
->height
)
1135 *y
= a
->y
+ MAX(0, a
->height
- fh
);
1140 /* get where the client should be */
1141 frame_frame_gravity(self
->frame
, x
, y
);
1143 return ox
!= *x
|| oy
!= *y
;
1146 static void client_get_all(ObClient
*self
, gboolean real
)
1148 /* this is needed for the frame to set itself up */
1149 client_get_area(self
);
1151 /* these things can change the decor and functions of the window */
1153 client_get_mwm_hints(self
);
1154 /* this can change the mwmhints for special cases */
1155 client_get_type_and_transientness(self
);
1156 client_get_state(self
);
1157 client_update_normal_hints(self
);
1159 /* get the session related properties, these can change decorations
1160 from per-app settings */
1161 client_get_session_ids(self
);
1163 /* now we got everything that can affect the decorations */
1167 /* get this early so we have it for debugging */
1168 client_update_title(self
);
1170 client_update_protocols(self
);
1172 client_update_wmhints(self
);
1173 /* this may have already been called from client_update_wmhints */
1174 if (!self
->parents
&& !self
->transient_for_group
)
1175 client_update_transient_for(self
);
1177 client_get_startup_id(self
);
1178 client_get_desktop(self
);/* uses transient data/group/startup id if a
1179 desktop is not specified */
1180 client_get_shaped(self
);
1183 /* a couple type-based defaults for new windows */
1185 /* this makes sure that these windows appear on all desktops */
1186 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
1187 self
->desktop
= DESKTOP_ALL
;
1191 client_update_sync_request_counter(self
);
1194 client_get_colormap(self
);
1195 client_update_strut(self
);
1196 client_update_icons(self
);
1197 client_update_icon_geometry(self
);
1200 static void client_get_startup_id(ObClient
*self
)
1202 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
1204 PROP_GETS(self
->group
->leader
,
1205 net_startup_id
, utf8
, &self
->startup_id
);
1208 static void client_get_area(ObClient
*self
)
1210 XWindowAttributes wattrib
;
1213 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1214 g_assert(ret
!= BadWindow
);
1216 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
1217 POINT_SET(self
->root_pos
, wattrib
.x
, wattrib
.y
);
1218 self
->border_width
= wattrib
.border_width
;
1220 ob_debug("client area: %d %d %d %d bw %d\n", wattrib
.x
, wattrib
.y
,
1221 wattrib
.width
, wattrib
.height
, wattrib
.border_width
);
1224 static void client_get_desktop(ObClient
*self
)
1226 guint32 d
= screen_num_desktops
; /* an always-invalid value */
1228 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
1229 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
1230 self
->desktop
= screen_num_desktops
- 1;
1233 ob_debug("client requested desktop 0x%x\n", self
->desktop
);
1236 gboolean first
= TRUE
;
1237 guint all
= screen_num_desktops
; /* not a valid value */
1239 /* if they are all on one desktop, then open it on the
1241 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
1242 ObClient
*c
= it
->data
;
1244 if (c
->desktop
== DESKTOP_ALL
) continue;
1250 else if (all
!= c
->desktop
)
1251 all
= screen_num_desktops
; /* make it invalid */
1253 if (all
!= screen_num_desktops
) {
1254 self
->desktop
= all
;
1256 ob_debug("client desktop set from parents: 0x%x\n",
1259 /* try get from the startup-notification protocol */
1260 else if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
1261 if (self
->desktop
>= screen_num_desktops
&&
1262 self
->desktop
!= DESKTOP_ALL
)
1263 self
->desktop
= screen_num_desktops
- 1;
1264 ob_debug("client desktop set from startup-notification: 0x%x\n",
1267 /* defaults to the current desktop */
1269 self
->desktop
= screen_desktop
;
1270 ob_debug("client desktop set to the current desktop: %d\n",
1276 static void client_get_state(ObClient
*self
)
1281 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
1283 for (i
= 0; i
< num
; ++i
) {
1284 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
1286 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
1287 self
->shaded
= TRUE
;
1288 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
1289 self
->iconic
= TRUE
;
1290 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
1291 self
->skip_taskbar
= TRUE
;
1292 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
1293 self
->skip_pager
= TRUE
;
1294 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
1295 self
->fullscreen
= TRUE
;
1296 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
1297 self
->max_vert
= TRUE
;
1298 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
1299 self
->max_horz
= TRUE
;
1300 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
1302 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
1304 else if (state
[i
] == prop_atoms
.net_wm_state_demands_attention
)
1305 self
->demands_attention
= TRUE
;
1306 else if (state
[i
] == prop_atoms
.ob_wm_state_undecorated
)
1307 self
->undecorated
= TRUE
;
1314 static void client_get_shaped(ObClient
*self
)
1316 self
->shaped
= FALSE
;
1318 if (extensions_shape
) {
1323 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
1325 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
1326 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
1333 void client_update_transient_for(ObClient
*self
)
1336 ObClient
*target
= NULL
;
1337 gboolean trangroup
= FALSE
;
1339 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
1340 if (t
!= self
->window
) { /* can't be transient to itself! */
1341 target
= g_hash_table_lookup(window_map
, &t
);
1342 /* if this happens then we need to check for it */
1343 g_assert(target
!= self
);
1344 if (target
&& !WINDOW_IS_CLIENT(target
)) {
1345 /* watch out for windows with a parent that is something
1346 different, like a dockapp for example */
1351 /* Setting the transient_for to Root is actually illegal, however
1352 applications from time have done this to specify transient for
1354 if (!target
&& self
->group
&& t
== RootWindow(ob_display
, ob_screen
))
1356 } else if (self
->group
&& self
->transient
)
1359 client_update_transient_tree(self
, self
->group
, self
->group
,
1360 self
->transient_for_group
, trangroup
,
1361 client_direct_parent(self
), target
);
1362 self
->transient_for_group
= trangroup
;
1366 static void client_update_transient_tree(ObClient
*self
,
1367 ObGroup
*oldgroup
, ObGroup
*newgroup
,
1368 gboolean oldgtran
, gboolean newgtran
,
1369 ObClient
* oldparent
,
1370 ObClient
*newparent
)
1375 g_assert(!oldgtran
|| oldgroup
);
1376 g_assert(!newgtran
|| newgroup
);
1377 g_assert((!oldgtran
&& !oldparent
) ||
1378 (oldgtran
&& !oldparent
) ||
1379 (!oldgtran
&& oldparent
));
1380 g_assert((!newgtran
&& !newparent
) ||
1381 (newgtran
&& !newparent
) ||
1382 (!newgtran
&& newparent
));
1385 Group transient windows are not allowed to have other group
1386 transient windows as their children.
1389 /* No change has occured */
1390 if (oldgroup
== newgroup
&&
1391 oldgtran
== newgtran
&&
1392 oldparent
== newparent
) return;
1394 /** Remove the client from the transient tree **/
1396 for (it
= self
->transients
; it
; it
= next
) {
1397 next
= g_slist_next(it
);
1399 self
->transients
= g_slist_delete_link(self
->transients
, it
);
1400 c
->parents
= g_slist_remove(c
->parents
, self
);
1402 for (it
= self
->parents
; it
; it
= next
) {
1403 next
= g_slist_next(it
);
1405 self
->parents
= g_slist_delete_link(self
->parents
, it
);
1406 c
->transients
= g_slist_remove(c
->transients
, self
);
1409 /** Re-add the client to the transient tree **/
1411 /* If we're transient for a group then we need to add ourselves to all our
1414 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1417 !client_search_top_direct_parent(c
)->transient_for_group
&&
1420 c
->transients
= g_slist_prepend(c
->transients
, self
);
1421 self
->parents
= g_slist_prepend(self
->parents
, c
);
1426 /* If we are now transient for a single window we need to add ourselves to
1429 WARNING: Cyclical transient-ness is possible if two windows are
1430 transient for eachother.
1432 else if (newparent
&&
1433 /* don't make ourself its child if it is already our child */
1434 !client_is_direct_child(self
, newparent
) &&
1435 client_normal(newparent
))
1437 newparent
->transients
= g_slist_prepend(newparent
->transients
, self
);
1438 self
->parents
= g_slist_prepend(self
->parents
, newparent
);
1441 /* Add any group transient windows to our children. But if we're transient
1442 for the group, then other group transients are not our children.
1444 WARNING: Cyclical transient-ness is possible. For e.g. if:
1445 A is transient for the group
1446 B is transient for A
1447 C is transient for B
1448 A can't be transient for C or we have a cycle
1450 if (!newgtran
&& newgroup
&&
1452 !client_search_top_direct_parent(newparent
)->transient_for_group
) &&
1453 client_normal(self
))
1455 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1457 if (c
!= self
&& c
->transient_for_group
&&
1458 /* Don't make it our child if it is already our parent */
1459 !client_is_direct_child(c
, self
))
1461 self
->transients
= g_slist_prepend(self
->transients
, c
);
1462 c
->parents
= g_slist_prepend(c
->parents
, self
);
1467 /** If we change our group transient-ness, our children change their
1468 effective group transient-ness, which affects how they relate to other
1471 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
1473 if (!c
->transient_for_group
)
1474 client_update_transient_tree(c
, c
->group
, c
->group
,
1475 c
->transient_for_group
,
1476 c
->transient_for_group
,
1477 client_direct_parent(c
),
1478 client_direct_parent(c
));
1482 static void client_get_mwm_hints(ObClient
*self
)
1487 self
->mwmhints
.flags
= 0; /* default to none */
1489 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
1491 if (num
>= OB_MWM_ELEMENTS
) {
1492 self
->mwmhints
.flags
= hints
[0];
1493 self
->mwmhints
.functions
= hints
[1];
1494 self
->mwmhints
.decorations
= hints
[2];
1500 void client_get_type_and_transientness(ObClient
*self
)
1507 self
->transient
= FALSE
;
1509 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1510 /* use the first value that we know about in the array */
1511 for (i
= 0; i
< num
; ++i
) {
1512 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1513 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1514 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1515 self
->type
= OB_CLIENT_TYPE_DOCK
;
1516 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1517 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1518 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1519 self
->type
= OB_CLIENT_TYPE_MENU
;
1520 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1521 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1522 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1523 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1524 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1525 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1526 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1527 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1528 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1529 /* prevent this window from getting any decor or
1531 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1532 OB_MWM_FLAG_DECORATIONS
);
1533 self
->mwmhints
.decorations
= 0;
1534 self
->mwmhints
.functions
= 0;
1536 if (self
->type
!= (ObClientType
) -1)
1537 break; /* grab the first legit type */
1542 if (XGetTransientForHint(ob_display
, self
->window
, &t
))
1543 self
->transient
= TRUE
;
1545 if (self
->type
== (ObClientType
) -1) {
1546 /*the window type hint was not set, which means we either classify
1547 ourself as a normal window or a dialog, depending on if we are a
1549 if (self
->transient
)
1550 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1552 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1555 /* then, based on our type, we can update our transientness.. */
1556 if (self
->type
== OB_CLIENT_TYPE_DIALOG
||
1557 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
1558 self
->type
== OB_CLIENT_TYPE_MENU
||
1559 self
->type
== OB_CLIENT_TYPE_UTILITY
)
1561 self
->transient
= TRUE
;
1565 void client_update_protocols(ObClient
*self
)
1568 guint num_return
, i
;
1570 self
->focus_notify
= FALSE
;
1571 self
->delete_window
= FALSE
;
1573 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1574 for (i
= 0; i
< num_return
; ++i
) {
1575 if (proto
[i
] == prop_atoms
.wm_delete_window
)
1576 /* this means we can request the window to close */
1577 self
->delete_window
= TRUE
;
1578 else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1579 /* if this protocol is requested, then the window will be
1580 notified whenever we want it to receive focus */
1581 self
->focus_notify
= TRUE
;
1582 else if (proto
[i
] == prop_atoms
.net_wm_ping
)
1583 /* if this protocol is requested, then the window will allow
1584 pings to determine if it is still alive */
1587 else if (proto
[i
] == prop_atoms
.net_wm_sync_request
)
1588 /* if this protocol is requested, then resizing the
1589 window will be synchronized between the frame and the
1591 self
->sync_request
= TRUE
;
1599 void client_update_sync_request_counter(ObClient
*self
)
1603 if (PROP_GET32(self
->window
, net_wm_sync_request_counter
, cardinal
, &i
)) {
1604 self
->sync_counter
= i
;
1606 self
->sync_counter
= None
;
1610 static void client_get_colormap(ObClient
*self
)
1612 XWindowAttributes wa
;
1614 if (XGetWindowAttributes(ob_display
, self
->window
, &wa
))
1615 client_update_colormap(self
, wa
.colormap
);
1618 void client_update_colormap(ObClient
*self
, Colormap colormap
)
1620 if (colormap
== self
->colormap
) return;
1622 ob_debug("Setting client %s colormap: 0x%x\n", self
->title
, colormap
);
1624 if (client_focused(self
)) {
1625 screen_install_colormap(self
, FALSE
); /* uninstall old one */
1626 self
->colormap
= colormap
;
1627 screen_install_colormap(self
, TRUE
); /* install new one */
1629 self
->colormap
= colormap
;
1632 void client_update_normal_hints(ObClient
*self
)
1638 self
->min_ratio
= 0.0f
;
1639 self
->max_ratio
= 0.0f
;
1640 SIZE_SET(self
->size_inc
, 1, 1);
1641 SIZE_SET(self
->base_size
, -1, -1);
1642 SIZE_SET(self
->min_size
, 0, 0);
1643 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1645 /* get the hints from the window */
1646 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1647 /* normal windows can't request placement! har har
1648 if (!client_normal(self))
1650 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1651 self
->sized
= (size
.flags
& (PSize
|USSize
));
1653 if (size
.flags
& PWinGravity
)
1654 self
->gravity
= size
.win_gravity
;
1656 if (size
.flags
& PAspect
) {
1657 if (size
.min_aspect
.y
)
1659 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1660 if (size
.max_aspect
.y
)
1662 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1665 if (size
.flags
& PMinSize
)
1666 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1668 if (size
.flags
& PMaxSize
)
1669 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1671 if (size
.flags
& PBaseSize
)
1672 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1674 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1675 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1677 ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n "
1678 "size inc (%d %d) base size (%d %d)\n",
1679 self
->min_size
.width
, self
->min_size
.height
,
1680 self
->max_size
.width
, self
->max_size
.height
,
1681 self
->size_inc
.width
, self
->size_inc
.height
,
1682 self
->base_size
.width
, self
->base_size
.height
);
1685 ob_debug("Normal hints: not set\n");
1688 void client_setup_decor_and_functions(ObClient
*self
, gboolean reconfig
)
1690 /* start with everything (cept fullscreen) */
1692 (OB_FRAME_DECOR_TITLEBAR
|
1693 OB_FRAME_DECOR_HANDLE
|
1694 OB_FRAME_DECOR_GRIPS
|
1695 OB_FRAME_DECOR_BORDER
|
1696 OB_FRAME_DECOR_ICON
|
1697 OB_FRAME_DECOR_ALLDESKTOPS
|
1698 OB_FRAME_DECOR_ICONIFY
|
1699 OB_FRAME_DECOR_MAXIMIZE
|
1700 OB_FRAME_DECOR_SHADE
|
1701 OB_FRAME_DECOR_CLOSE
);
1703 (OB_CLIENT_FUNC_RESIZE
|
1704 OB_CLIENT_FUNC_MOVE
|
1705 OB_CLIENT_FUNC_ICONIFY
|
1706 OB_CLIENT_FUNC_MAXIMIZE
|
1707 OB_CLIENT_FUNC_SHADE
|
1708 OB_CLIENT_FUNC_CLOSE
|
1709 OB_CLIENT_FUNC_BELOW
|
1710 OB_CLIENT_FUNC_ABOVE
|
1711 OB_CLIENT_FUNC_UNDECORATE
);
1713 if (!(self
->min_size
.width
< self
->max_size
.width
||
1714 self
->min_size
.height
< self
->max_size
.height
))
1715 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1717 switch (self
->type
) {
1718 case OB_CLIENT_TYPE_NORMAL
:
1719 /* normal windows retain all of the possible decorations and
1720 functionality, and can be fullscreen */
1721 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1724 case OB_CLIENT_TYPE_DIALOG
:
1725 /* sometimes apps make dialog windows fullscreen for some reason (for
1726 e.g. kpdf does this..) */
1727 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1730 case OB_CLIENT_TYPE_UTILITY
:
1731 /* these windows don't have anything added or removed by default */
1734 case OB_CLIENT_TYPE_MENU
:
1735 case OB_CLIENT_TYPE_TOOLBAR
:
1736 /* these windows can't iconify or maximize */
1737 self
->decorations
&= ~(OB_FRAME_DECOR_ICONIFY
|
1738 OB_FRAME_DECOR_MAXIMIZE
);
1739 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
|
1740 OB_CLIENT_FUNC_MAXIMIZE
);
1743 case OB_CLIENT_TYPE_SPLASH
:
1744 /* these don't get get any decorations, and the only thing you can
1745 do with them is move them */
1746 self
->decorations
= 0;
1747 self
->functions
= OB_CLIENT_FUNC_MOVE
;
1750 case OB_CLIENT_TYPE_DESKTOP
:
1751 /* these windows are not manipulated by the window manager */
1752 self
->decorations
= 0;
1753 self
->functions
= 0;
1756 case OB_CLIENT_TYPE_DOCK
:
1757 /* these windows are not manipulated by the window manager, but they
1758 can set below layer which has a special meaning */
1759 self
->decorations
= 0;
1760 self
->functions
= OB_CLIENT_FUNC_BELOW
;
1764 /* Mwm Hints are applied subtractively to what has already been chosen for
1765 decor and functionality */
1766 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1767 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1768 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1769 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1771 /* if the mwm hints request no handle or title, then all
1772 decorations are disabled, but keep the border if that's
1774 if (self
->mwmhints
.decorations
& OB_MWM_DECOR_BORDER
)
1775 self
->decorations
= OB_FRAME_DECOR_BORDER
;
1777 self
->decorations
= 0;
1782 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1783 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1784 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1785 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1786 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1787 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1788 /* dont let mwm hints kill any buttons
1789 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1790 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1791 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1792 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1794 /* dont let mwm hints kill the close button
1795 if (! (self->mwmhints.functions & MwmFunc_Close))
1796 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1800 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1801 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1802 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1803 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1804 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1805 self
->decorations
&= ~(OB_FRAME_DECOR_GRIPS
| OB_FRAME_DECOR_HANDLE
);
1807 /* can't maximize without moving/resizing */
1808 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1809 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1810 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1811 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1812 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1815 if (self
->max_horz
&& self
->max_vert
) {
1816 /* you can't resize fully maximized windows */
1817 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1818 /* kill the handle on fully maxed windows */
1819 self
->decorations
&= ~(OB_FRAME_DECOR_HANDLE
| OB_FRAME_DECOR_GRIPS
);
1822 /* If there are no decorations to remove, don't allow the user to try
1824 if (self
->decorations
== 0)
1825 self
->functions
&= ~OB_CLIENT_FUNC_UNDECORATE
;
1827 /* finally, the user can have requested no decorations, which overrides
1828 everything (but doesnt give it a border if it doesnt have one) */
1829 if (self
->undecorated
)
1830 self
->decorations
= 0;
1832 /* if we don't have a titlebar, then we cannot shade! */
1833 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1834 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1836 /* now we need to check against rules for the client's current state */
1837 if (self
->fullscreen
) {
1838 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1839 OB_CLIENT_FUNC_FULLSCREEN
|
1840 OB_CLIENT_FUNC_ICONIFY
);
1841 self
->decorations
= 0;
1844 client_change_allowed_actions(self
);
1847 /* force reconfigure to make sure decorations are updated */
1848 client_reconfigure(self
, TRUE
);
1851 static void client_change_allowed_actions(ObClient
*self
)
1856 /* desktop windows are kept on all desktops */
1857 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1858 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1860 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1861 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1862 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1863 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1864 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1865 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1866 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1867 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1868 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1869 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1870 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1871 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1872 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1873 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1874 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1876 if (self
->functions
& OB_CLIENT_FUNC_ABOVE
)
1877 actions
[num
++] = prop_atoms
.net_wm_action_above
;
1878 if (self
->functions
& OB_CLIENT_FUNC_BELOW
)
1879 actions
[num
++] = prop_atoms
.net_wm_action_below
;
1880 if (self
->functions
& OB_CLIENT_FUNC_UNDECORATE
)
1881 actions
[num
++] = prop_atoms
.ob_wm_action_undecorate
;
1883 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1885 /* make sure the window isn't breaking any rules now
1887 don't check ICONIFY here. just cuz a window can't iconify doesnt mean
1888 it can't be iconified with its parent
1891 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1892 if (self
->frame
) client_shade(self
, FALSE
);
1893 else self
->shaded
= FALSE
;
1895 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1896 if (self
->frame
) client_fullscreen(self
, FALSE
);
1897 else self
->fullscreen
= FALSE
;
1899 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1901 if (self
->frame
) client_maximize(self
, FALSE
, 0);
1902 else self
->max_vert
= self
->max_horz
= FALSE
;
1906 void client_update_wmhints(ObClient
*self
)
1910 /* assume a window takes input if it doesn't specify */
1911 self
->can_focus
= TRUE
;
1913 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1916 if (hints
->flags
& InputHint
)
1917 self
->can_focus
= hints
->input
;
1919 /* only do this when first managing the window *AND* when we aren't
1921 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1922 if (hints
->flags
& StateHint
)
1923 self
->iconic
= hints
->initial_state
== IconicState
;
1926 self
->urgent
= (hints
->flags
& XUrgencyHint
);
1927 if (self
->urgent
&& !ur
)
1928 client_hilite(self
, TRUE
);
1929 else if (!self
->urgent
&& ur
&& self
->demands_attention
)
1930 client_hilite(self
, FALSE
);
1932 if (!(hints
->flags
& WindowGroupHint
))
1933 hints
->window_group
= None
;
1935 /* did the group state change? */
1936 if (hints
->window_group
!=
1937 (self
->group
? self
->group
->leader
: None
))
1939 ObGroup
*oldgroup
= self
->group
;
1941 /* remove from the old group if there was one */
1943 group_remove(self
->group
, self
);
1947 /* add ourself to the group if we have one */
1948 if (hints
->window_group
!= None
) {
1949 self
->group
= group_add(hints
->window_group
, self
);
1952 /* Put ourselves into the new group's transient tree, and remove
1953 ourselves from the old group's */
1954 client_update_transient_tree(self
, oldgroup
, self
->group
,
1955 self
->transient_for_group
,
1956 self
->transient_for_group
,
1957 client_direct_parent(self
),
1958 client_direct_parent(self
));
1960 /* Lastly, being in a group, or not, can change if the window is
1961 transient for anything.
1963 The logic for this is:
1964 self->transient = TRUE always if the window wants to be
1965 transient for something, even if transient_for was NULL because
1966 it wasn't in a group before.
1968 If parents was NULL and oldgroup was NULL we can assume
1969 that when we add the new group, it will become transient for
1972 If transient_for_group is TRUE, then it must have already
1973 had a group. If it is getting a new group, the above call to
1974 client_update_transient_tree has already taken care of
1975 everything ! If it is losing all group status then it will
1976 no longer be transient for anything and that needs to be
1979 if (self
->transient
&&
1980 ((self
->parents
== NULL
&& oldgroup
== NULL
) ||
1981 (self
->transient_for_group
&& !self
->group
)))
1982 client_update_transient_for(self
);
1985 /* the WM_HINTS can contain an icon */
1986 if (hints
->flags
& IconPixmapHint
)
1987 client_update_icons(self
);
1993 void client_update_title(ObClient
*self
)
1996 gchar
*visible
= NULL
;
1998 g_free(self
->title
);
1999 g_free(self
->original_title
);
2002 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
)) {
2003 /* try old x stuff */
2004 if (!(PROP_GETS(self
->window
, wm_name
, locale
, &data
)
2005 || PROP_GETS(self
->window
, wm_name
, utf8
, &data
))) {
2006 if (self
->transient
) {
2008 GNOME alert windows are not given titles:
2009 http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
2011 data
= g_strdup("");
2013 data
= g_strdup(_("Unnamed Window"));
2016 self
->original_title
= g_strdup(data
);
2018 if (self
->client_machine
) {
2019 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
2024 if (self
->not_responding
) {
2026 if (self
->kill_level
> 0)
2027 visible
= g_strdup_printf("%s - [%s]", data
, _("Killing..."));
2029 visible
= g_strdup_printf("%s - [%s]", data
, _("Not Responding"));
2033 PROP_SETS(self
->window
, net_wm_visible_name
, visible
);
2034 self
->title
= visible
;
2037 frame_adjust_title(self
->frame
);
2039 /* update the icon title */
2041 g_free(self
->icon_title
);
2044 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
2045 /* try old x stuff */
2046 if (!(PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
) ||
2047 PROP_GETS(self
->window
, wm_icon_name
, utf8
, &data
)))
2048 data
= g_strdup(self
->title
);
2050 if (self
->client_machine
) {
2051 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
2056 if (self
->not_responding
) {
2058 if (self
->kill_level
> 0)
2059 visible
= g_strdup_printf("%s - [%s]", data
, _("Killing..."));
2061 visible
= g_strdup_printf("%s - [%s]", data
, _("Not Responding"));
2065 PROP_SETS(self
->window
, net_wm_visible_icon_name
, visible
);
2066 self
->icon_title
= visible
;
2069 void client_update_strut(ObClient
*self
)
2073 gboolean got
= FALSE
;
2076 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
2080 STRUT_PARTIAL_SET(strut
,
2081 data
[0], data
[2], data
[1], data
[3],
2082 data
[4], data
[5], data
[8], data
[9],
2083 data
[6], data
[7], data
[10], data
[11]);
2089 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
2095 /* use the screen's width/height */
2096 a
= screen_physical_area_all_monitors();
2098 STRUT_PARTIAL_SET(strut
,
2099 data
[0], data
[2], data
[1], data
[3],
2100 a
->y
, a
->y
+ a
->height
- 1,
2101 a
->x
, a
->x
+ a
->width
- 1,
2102 a
->y
, a
->y
+ a
->height
- 1,
2103 a
->x
, a
->x
+ a
->width
- 1);
2110 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
2111 0, 0, 0, 0, 0, 0, 0, 0);
2113 if (!STRUT_EQUAL(strut
, self
->strut
)) {
2114 self
->strut
= strut
;
2116 /* updating here is pointless while we're being mapped cuz we're not in
2117 the client list yet */
2119 screen_update_areas();
2123 void client_update_icons(ObClient
*self
)
2128 guint num_seen
; /* number of icons present */
2133 /* grab the server, because we might be setting the window's icon and
2134 we don't want them to set it in between and we overwrite their own
2138 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
2139 /* figure out how many valid icons are in here */
2142 while (i
+ 2 < num
) { /* +2 is to make sure there is a w and h */
2145 /* watch for the data being too small for the specified size,
2146 or for zero sized icons. */
2147 if (i
+ w
*h
> num
|| w
== 0 || h
== 0) break;
2149 /* convert it to the right bit order for ObRender */
2150 for (j
= 0; j
< w
*h
; ++j
)
2152 (((data
[i
+j
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
2153 (((data
[i
+j
] >> 16) & 0xff) << RrDefaultRedOffset
) +
2154 (((data
[i
+j
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
2155 (((data
[i
+j
] >> 0) & 0xff) << RrDefaultBlueOffset
);
2157 /* is it in the cache? */
2158 img
= RrImageCacheFind(ob_rr_icons
, &data
[i
], w
, h
);
2159 if (img
) RrImageRef(img
); /* own it */
2164 /* don't bother looping anymore if we already found it in the cache
2165 since we'll just use that! */
2169 /* if it's not in the cache yet, then add it to the cache now.
2170 we have already converted it to the correct bit order above */
2171 if (!img
&& num_seen
> 0) {
2172 img
= RrImageNew(ob_rr_icons
);
2174 for (j
= 0; j
< num_seen
; ++j
) {
2177 RrImageAddPicture(img
, &data
[i
], w
, h
);
2185 /* if we didn't find an image from the NET_WM_ICON stuff, then try the
2190 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
2191 if (hints
->flags
& IconPixmapHint
) {
2193 xerror_set_ignore(TRUE
);
2194 xicon
= RrPixmapToRGBA(ob_rr_inst
,
2196 (hints
->flags
& IconMaskHint
?
2197 hints
->icon_mask
: None
),
2198 (gint
*)&w
, (gint
*)&h
, &data
);
2199 xerror_set_ignore(FALSE
);
2202 if (w
> 0 && h
> 0) {
2203 /* is this icon in the cache yet? */
2204 img
= RrImageCacheFind(ob_rr_icons
, data
, w
, h
);
2205 if (img
) RrImageRef(img
); /* own it */
2207 /* if not, then add it */
2209 img
= RrImageNew(ob_rr_icons
);
2210 RrImageAddPicture(img
, data
, w
, h
);
2221 /* set the client's icons to be whatever we found */
2222 RrImageUnref(self
->icon_set
);
2223 self
->icon_set
= img
;
2225 /* if the client has no icon at all, then we set a default icon onto it.
2226 but, if it has parents, then one of them will have an icon already
2228 if (!self
->icon_set
&& !self
->parents
) {
2229 RrPixel32
*icon
= ob_rr_theme
->def_win_icon
;
2230 gulong
*ldata
; /* use a long here to satisfy OBT_PROP_SETA32 */
2232 w
= ob_rr_theme
->def_win_icon_w
;
2233 h
= ob_rr_theme
->def_win_icon_h
;
2234 ldata
= g_new(gulong
, w
*h
+2);
2237 for (i
= 0; i
< w
*h
; ++i
)
2238 ldata
[i
+2] = (((icon
[i
] >> RrDefaultAlphaOffset
) & 0xff) << 24) +
2239 (((icon
[i
] >> RrDefaultRedOffset
) & 0xff) << 16) +
2240 (((icon
[i
] >> RrDefaultGreenOffset
) & 0xff) << 8) +
2241 (((icon
[i
] >> RrDefaultBlueOffset
) & 0xff) << 0);
2242 PROP_SETA32(self
->window
, net_wm_icon
, cardinal
, ldata
, w
*h
+2);
2244 } else if (self
->frame
)
2245 /* don't draw the icon empty if we're just setting one now anyways,
2246 we'll get the property change any second */
2247 frame_adjust_icon(self
->frame
);
2252 void client_update_icon_geometry(ObClient
*self
)
2257 RECT_SET(self
->icon_geometry
, 0, 0, 0, 0);
2259 if (PROP_GETA32(self
->window
, net_wm_icon_geometry
, cardinal
, &data
, &num
))
2262 /* don't let them set it with an area < 0 */
2263 RECT_SET(self
->icon_geometry
, data
[0], data
[1],
2264 MAX(data
[2],0), MAX(data
[3],0));
2269 static void client_get_session_ids(ObClient
*self
)
2276 if (!PROP_GET32(self
->window
, wm_client_leader
, window
, &leader
))
2279 /* get the SM_CLIENT_ID */
2282 got
= PROP_GETS(leader
, sm_client_id
, locale
, &self
->sm_client_id
);
2284 PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
);
2286 /* get the WM_CLASS (name and class). make them "" if they are not
2290 got
= PROP_GETSS(leader
, wm_class
, locale
, &ss
);
2292 got
= PROP_GETSS(self
->window
, wm_class
, locale
, &ss
);
2296 self
->name
= g_strdup(ss
[0]);
2298 self
->class = g_strdup(ss
[1]);
2303 if (self
->name
== NULL
) self
->name
= g_strdup("");
2304 if (self
->class == NULL
) self
->class = g_strdup("");
2306 /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2309 got
= PROP_GETS(leader
, wm_window_role
, locale
, &s
);
2311 got
= PROP_GETS(self
->window
, wm_window_role
, locale
, &s
);
2316 self
->role
= g_strdup("");
2318 /* get the WM_COMMAND */
2322 got
= PROP_GETSS(leader
, wm_command
, locale
, &ss
);
2324 got
= PROP_GETSS(self
->window
, wm_command
, locale
, &ss
);
2327 /* merge/mash them all together */
2328 gchar
*merge
= NULL
;
2331 for (i
= 0; ss
[i
]; ++i
) {
2334 merge
= g_strconcat(merge
, ss
[i
], NULL
);
2336 merge
= g_strconcat(ss
[i
], NULL
);
2341 self
->wm_command
= merge
;
2344 /* get the WM_CLIENT_MACHINE */
2347 got
= PROP_GETS(leader
, wm_client_machine
, locale
, &s
);
2349 got
= PROP_GETS(self
->window
, wm_client_machine
, locale
, &s
);
2352 gchar localhost
[128];
2355 gethostname(localhost
, 127);
2356 localhost
[127] = '\0';
2357 if (strcmp(localhost
, s
) != 0)
2358 self
->client_machine
= s
;
2362 /* see if it has the PID set too (the PID requires that the
2363 WM_CLIENT_MACHINE be set) */
2364 if (PROP_GET32(self
->window
, net_wm_pid
, cardinal
, &pid
))
2369 static void client_change_wm_state(ObClient
*self
)
2374 old
= self
->wmstate
;
2376 if (self
->shaded
|| self
->iconic
||
2377 (self
->desktop
!= DESKTOP_ALL
&& self
->desktop
!= screen_desktop
))
2379 self
->wmstate
= IconicState
;
2381 self
->wmstate
= NormalState
;
2383 if (old
!= self
->wmstate
) {
2384 PROP_MSG(self
->window
, kde_wm_change_state
,
2385 self
->wmstate
, 1, 0, 0);
2387 state
[0] = self
->wmstate
;
2389 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
2393 static void client_change_state(ObClient
*self
)
2395 gulong netstate
[12];
2400 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
2402 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
2404 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
2405 if (self
->skip_taskbar
)
2406 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
2407 if (self
->skip_pager
)
2408 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
2409 if (self
->fullscreen
)
2410 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
2412 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
2414 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
2416 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
2418 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
2419 if (self
->demands_attention
)
2420 netstate
[num
++] = prop_atoms
.net_wm_state_demands_attention
;
2421 if (self
->undecorated
)
2422 netstate
[num
++] = prop_atoms
.ob_wm_state_undecorated
;
2423 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
2426 frame_adjust_state(self
->frame
);
2429 ObClient
*client_search_focus_tree(ObClient
*self
)
2434 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2435 if (client_focused(it
->data
)) return it
->data
;
2436 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
2441 ObClient
*client_search_focus_tree_full(ObClient
*self
)
2443 if (self
->parents
) {
2446 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
2447 ObClient
*c
= it
->data
;
2448 if ((c
= client_search_focus_tree_full(it
->data
))) return c
;
2454 /* this function checks the whole tree, the client_search_focus_tree
2455 does not, so we need to check this window */
2456 if (client_focused(self
))
2458 return client_search_focus_tree(self
);
2462 ObClient
*client_search_focus_group_full(ObClient
*self
)
2467 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
2468 ObClient
*c
= it
->data
;
2470 if (client_focused(c
)) return c
;
2471 if ((c
= client_search_focus_tree(it
->data
))) return c
;
2474 if (client_focused(self
)) return self
;
2478 gboolean
client_has_parent(ObClient
*self
)
2480 return self
->parents
!= NULL
;
2483 static ObStackingLayer
calc_layer(ObClient
*self
)
2488 monitor
= screen_physical_area_monitor(client_monitor(self
));
2490 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
2491 l
= OB_STACKING_LAYER_DESKTOP
;
2492 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
2493 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
2494 else l
= OB_STACKING_LAYER_ABOVE
;
2496 else if ((self
->fullscreen
||
2497 /* No decorations and fills the monitor = oldskool fullscreen.
2498 But not for maximized windows.
2500 (self
->decorations
== 0 &&
2501 !(self
->max_horz
&& self
->max_vert
) &&
2502 RECT_EQUAL(self
->area
, *monitor
))) &&
2503 /* you are fullscreen while you or your children are focused.. */
2504 (client_focused(self
) || client_search_focus_tree(self
) ||
2505 /* you can be fullscreen if you're on another desktop */
2506 (self
->desktop
!= screen_desktop
&&
2507 self
->desktop
!= DESKTOP_ALL
) ||
2508 /* and you can also be fullscreen if the focused client is on
2509 another monitor, or nothing else is focused */
2511 client_monitor(focus_client
) != client_monitor(self
))))
2512 l
= OB_STACKING_LAYER_FULLSCREEN
;
2513 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
2514 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
2515 else l
= OB_STACKING_LAYER_NORMAL
;
2522 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
2523 ObStackingLayer min
)
2525 ObStackingLayer old
, own
;
2529 own
= calc_layer(self
);
2530 self
->layer
= MAX(own
, min
);
2532 if (self
->layer
!= old
) {
2533 stacking_remove(CLIENT_AS_WINDOW(self
));
2534 stacking_add_nonintrusive(CLIENT_AS_WINDOW(self
));
2537 /* we've been restacked */
2538 self
->visited
= TRUE
;
2540 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2541 client_calc_layer_recursive(it
->data
, orig
,
2545 static void client_calc_layer_internal(ObClient
*self
)
2549 /* transients take on the layer of their parents */
2550 sit
= client_search_all_top_parents(self
);
2552 for (; sit
; sit
= g_slist_next(sit
))
2553 client_calc_layer_recursive(sit
->data
, self
, 0);
2556 void client_calc_layer(ObClient
*self
)
2560 /* skip over stuff above fullscreen layer */
2561 for (it
= stacking_list
; it
; it
= g_list_next(it
))
2562 if (window_layer(it
->data
) <= OB_STACKING_LAYER_FULLSCREEN
) break;
2564 /* find the windows in the fullscreen layer, and mark them not-visited */
2565 for (; it
; it
= g_list_next(it
)) {
2566 if (window_layer(it
->data
) < OB_STACKING_LAYER_FULLSCREEN
) break;
2567 else if (WINDOW_IS_CLIENT(it
->data
))
2568 WINDOW_AS_CLIENT(it
->data
)->visited
= FALSE
;
2571 client_calc_layer_internal(self
);
2573 /* skip over stuff above fullscreen layer */
2574 for (it
= stacking_list
; it
; it
= g_list_next(it
))
2575 if (window_layer(it
->data
) <= OB_STACKING_LAYER_FULLSCREEN
) break;
2577 /* now recalc any windows in the fullscreen layer which have not
2578 had their layer recalced already */
2579 for (; it
; it
= g_list_next(it
)) {
2580 if (window_layer(it
->data
) < OB_STACKING_LAYER_FULLSCREEN
) break;
2581 else if (WINDOW_IS_CLIENT(it
->data
) &&
2582 !WINDOW_AS_CLIENT(it
->data
)->visited
)
2583 client_calc_layer_internal(it
->data
);
2587 gboolean
client_should_show(ObClient
*self
)
2591 if (client_normal(self
) && screen_showing_desktop
)
2593 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
2599 gboolean
client_show(ObClient
*self
)
2601 gboolean show
= FALSE
;
2603 if (client_should_show(self
)) {
2604 /* replay pending pointer event before showing the window, in case it
2605 should be going to something under the window */
2606 mouse_replay_pointer();
2608 frame_show(self
->frame
);
2611 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2612 it needs to be in IconicState. This includes when it is on another
2615 client_change_wm_state(self
);
2620 gboolean
client_hide(ObClient
*self
)
2622 gboolean hide
= FALSE
;
2624 if (!client_should_show(self
)) {
2625 if (self
== focus_client
) {
2626 event_cancel_all_key_grabs();
2629 /* We don't need to ignore enter events here.
2630 The window can hide/iconify in 3 different ways:
2631 1 - through an x message. in this case we ignore all enter events
2632 caused by responding to the x message (unless underMouse)
2633 2 - by a keyboard action. in this case we ignore all enter events
2634 caused by the action
2635 3 - by a mouse action. in this case they are doing stuff with the
2636 mouse and focus _should_ move.
2638 Also in action_end, we simulate an enter event that can't be ignored
2639 so trying to ignore them is futile in case 3 anyways
2642 /* replay pending pointer event before hiding the window, in case it
2643 should be going to the window */
2644 mouse_replay_pointer();
2646 frame_hide(self
->frame
);
2649 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2650 it needs to be in IconicState. This includes when it is on another
2653 client_change_wm_state(self
);
2658 void client_showhide(ObClient
*self
)
2660 if (!client_show(self
))
2664 gboolean
client_normal(ObClient
*self
) {
2665 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
2666 self
->type
== OB_CLIENT_TYPE_DOCK
||
2667 self
->type
== OB_CLIENT_TYPE_SPLASH
);
2670 gboolean
client_helper(ObClient
*self
)
2672 return (self
->type
== OB_CLIENT_TYPE_UTILITY
||
2673 self
->type
== OB_CLIENT_TYPE_MENU
||
2674 self
->type
== OB_CLIENT_TYPE_TOOLBAR
);
2677 gboolean
client_mouse_focusable(ObClient
*self
)
2679 return !(self
->type
== OB_CLIENT_TYPE_MENU
||
2680 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
2681 self
->type
== OB_CLIENT_TYPE_SPLASH
||
2682 self
->type
== OB_CLIENT_TYPE_DOCK
);
2685 gboolean
client_enter_focusable(ObClient
*self
)
2687 /* you can focus desktops but it shouldn't on enter */
2688 return (client_mouse_focusable(self
) &&
2689 self
->type
!= OB_CLIENT_TYPE_DESKTOP
);
2692 static void client_apply_startup_state(ObClient
*self
,
2693 gint x
, gint y
, gint w
, gint h
)
2695 /* save the states that we are going to apply */
2696 gboolean iconic
= self
->iconic
;
2697 gboolean fullscreen
= self
->fullscreen
;
2698 gboolean undecorated
= self
->undecorated
;
2699 gboolean shaded
= self
->shaded
;
2700 gboolean demands_attention
= self
->demands_attention
;
2701 gboolean max_horz
= self
->max_horz
;
2702 gboolean max_vert
= self
->max_vert
;
2706 /* turn them all off in the client, so they won't affect the window
2708 self
->iconic
= self
->fullscreen
= self
->undecorated
= self
->shaded
=
2709 self
->demands_attention
= self
->max_horz
= self
->max_vert
= FALSE
;
2711 /* move the client to its placed position, or it it's already there,
2712 generate a ConfigureNotify telling the client where it is.
2714 do this after adjusting the frame. otherwise it gets all weird and
2715 clients don't work right
2717 do this before applying the states so they have the correct
2718 pre-max/pre-fullscreen values
2720 client_try_configure(self
, &x
, &y
, &w
, &h
, &l
, &l
, FALSE
);
2721 ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2722 self
->window
, x
, y
, w
, h
);
2723 /* save the area, and make it where it should be for the premax stuff */
2724 oldarea
= self
->area
;
2725 RECT_SET(self
->area
, x
, y
, w
, h
);
2727 /* apply the states. these are in a carefully crafted order.. */
2730 client_iconify(self
, TRUE
, FALSE
, TRUE
);
2732 client_fullscreen(self
, TRUE
);
2734 client_set_undecorated(self
, TRUE
);
2736 client_shade(self
, TRUE
);
2737 if (demands_attention
)
2738 client_hilite(self
, TRUE
);
2740 if (max_vert
&& max_horz
)
2741 client_maximize(self
, TRUE
, 0);
2743 client_maximize(self
, TRUE
, 2);
2745 client_maximize(self
, TRUE
, 1);
2747 /* if the window hasn't been configured yet, then do so now, in fact the
2748 x,y,w,h may _not_ be the same as the area rect, which can end up
2749 meaning that the client isn't properly moved/resized by the fullscreen
2751 pho can cause this because it maps at size of the screen but not 0,0
2752 so openbox moves it on screen to 0,0 (thus x,y=0,0 and area.x,y don't).
2753 then fullscreen'ing makes it go to 0,0 which it thinks it already is at
2754 cuz thats where the pre-fullscreen will be. however the actual area is
2755 not, so this needs to be called even if we have fullscreened/maxed
2757 self
->area
= oldarea
;
2758 client_configure(self
, x
, y
, w
, h
, FALSE
, TRUE
, FALSE
);
2760 /* set the desktop hint, to make sure that it always exists */
2761 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
2763 /* nothing to do for the other states:
2772 void client_gravity_resize_w(ObClient
*self
, gint
*x
, gint oldw
, gint neww
)
2774 /* these should be the current values. this is for when you're not moving,
2776 g_assert(*x
== self
->area
.x
);
2777 g_assert(oldw
== self
->area
.width
);
2780 switch (self
->gravity
) {
2782 case NorthWestGravity
:
2784 case SouthWestGravity
:
2791 *x
-= (neww
- oldw
) / 2;
2793 case NorthEastGravity
:
2795 case SouthEastGravity
:
2801 void client_gravity_resize_h(ObClient
*self
, gint
*y
, gint oldh
, gint newh
)
2803 /* these should be the current values. this is for when you're not moving,
2805 g_assert(*y
== self
->area
.y
);
2806 g_assert(oldh
== self
->area
.height
);
2809 switch (self
->gravity
) {
2811 case NorthWestGravity
:
2813 case NorthEastGravity
:
2820 *y
-= (newh
- oldh
) / 2;
2822 case SouthWestGravity
:
2824 case SouthEastGravity
:
2830 void client_try_configure(ObClient
*self
, gint
*x
, gint
*y
, gint
*w
, gint
*h
,
2831 gint
*logicalw
, gint
*logicalh
,
2834 Rect desired
= {*x
, *y
, *w
, *h
};
2835 frame_rect_to_frame(self
->frame
, &desired
);
2837 /* make the frame recalculate its dimensions n shit without changing
2838 anything visible for real, this way the constraints below can work with
2839 the updated frame dimensions. */
2840 frame_adjust_area(self
->frame
, FALSE
, TRUE
, TRUE
);
2842 /* gets the frame's position */
2843 frame_client_gravity(self
->frame
, x
, y
);
2845 /* these positions are frame positions, not client positions */
2847 /* set the size and position if fullscreen */
2848 if (self
->fullscreen
) {
2852 i
= screen_find_monitor(&desired
);
2853 a
= screen_physical_area_monitor(i
);
2860 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2864 } else if (self
->max_horz
|| self
->max_vert
) {
2868 /* use all possible struts when maximizing to the full screen */
2869 i
= screen_find_monitor(&desired
);
2870 a
= screen_area(self
->desktop
, i
,
2871 (self
->max_horz
&& self
->max_vert
? NULL
: &desired
));
2873 /* set the size and position if maximized */
2874 if (self
->max_horz
) {
2876 *w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2878 if (self
->max_vert
) {
2880 *h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2883 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2889 /* gets the client's position */
2890 frame_frame_gravity(self
->frame
, x
, y
);
2892 /* work within the preferred sizes given by the window, these may have
2893 changed rather than it's requested width and height, so always run
2894 through this code */
2896 gint basew
, baseh
, minw
, minh
;
2898 gfloat minratio
, maxratio
;
2900 incw
= self
->fullscreen
|| self
->max_horz
? 1 : self
->size_inc
.width
;
2901 inch
= self
->fullscreen
|| self
->max_vert
? 1 : self
->size_inc
.height
;
2902 minratio
= self
->fullscreen
|| (self
->max_horz
&& self
->max_vert
) ?
2903 0 : self
->min_ratio
;
2904 maxratio
= self
->fullscreen
|| (self
->max_horz
&& self
->max_vert
) ?
2905 0 : self
->max_ratio
;
2907 /* base size is substituted with min size if not specified */
2908 if (self
->base_size
.width
>= 0 || self
->base_size
.height
>= 0) {
2909 basew
= self
->base_size
.width
;
2910 baseh
= self
->base_size
.height
;
2912 basew
= self
->min_size
.width
;
2913 baseh
= self
->min_size
.height
;
2915 /* min size is substituted with base size if not specified */
2916 if (self
->min_size
.width
|| self
->min_size
.height
) {
2917 minw
= self
->min_size
.width
;
2918 minh
= self
->min_size
.height
;
2920 minw
= self
->base_size
.width
;
2921 minh
= self
->base_size
.height
;
2924 /* This comment is no longer true */
2925 /* if this is a user-requested resize, then check against min/max
2928 /* smaller than min size or bigger than max size? */
2929 if (*w
> self
->max_size
.width
) *w
= self
->max_size
.width
;
2930 if (*w
< minw
) *w
= minw
;
2931 if (*h
> self
->max_size
.height
) *h
= self
->max_size
.height
;
2932 if (*h
< minh
) *h
= minh
;
2937 /* keep to the increments */
2941 /* you cannot resize to nothing */
2942 if (basew
+ *w
< 1) *w
= 1 - basew
;
2943 if (baseh
+ *h
< 1) *h
= 1 - baseh
;
2945 /* save the logical size */
2946 *logicalw
= incw
> 1 ? *w
: *w
+ basew
;
2947 *logicalh
= inch
> 1 ? *h
: *h
+ baseh
;
2955 /* adjust the height to match the width for the aspect ratios.
2956 for this, min size is not substituted for base size ever. */
2957 *w
-= self
->base_size
.width
;
2958 *h
-= self
->base_size
.height
;
2961 if (*h
* minratio
> *w
) {
2962 *h
= (gint
)(*w
/ minratio
);
2964 /* you cannot resize to nothing */
2967 *w
= (gint
)(*h
* minratio
);
2971 if (*h
* maxratio
< *w
) {
2972 *h
= (gint
)(*w
/ maxratio
);
2974 /* you cannot resize to nothing */
2977 *w
= (gint
)(*h
* minratio
);
2981 *w
+= self
->base_size
.width
;
2982 *h
+= self
->base_size
.height
;
2985 /* these override the above states! if you cant move you can't move! */
2987 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2991 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2992 *w
= self
->area
.width
;
2993 *h
= self
->area
.height
;
3001 void client_configure(ObClient
*self
, gint x
, gint y
, gint w
, gint h
,
3002 gboolean user
, gboolean final
, gboolean force_reply
)
3006 gboolean send_resize_client
;
3007 gboolean moved
= FALSE
, resized
= FALSE
, rootmoved
= FALSE
;
3008 gboolean fmoved
, fresized
;
3009 guint fdecor
= self
->frame
->decorations
;
3010 gboolean fhorz
= self
->frame
->max_horz
;
3011 gboolean fvert
= self
->frame
->max_vert
;
3012 gint logicalw
, logicalh
;
3014 /* find the new x, y, width, and height (and logical size) */
3015 client_try_configure(self
, &x
, &y
, &w
, &h
, &logicalw
, &logicalh
, user
);
3017 /* set the logical size if things changed */
3018 if (!(w
== self
->area
.width
&& h
== self
->area
.height
))
3019 SIZE_SET(self
->logical_size
, logicalw
, logicalh
);
3021 /* figure out if we moved or resized or what */
3022 moved
= (x
!= self
->area
.x
|| y
!= self
->area
.y
);
3023 resized
= (w
!= self
->area
.width
|| h
!= self
->area
.height
);
3025 oldw
= self
->area
.width
;
3026 oldh
= self
->area
.height
;
3027 oldframe
= self
->frame
->area
;
3028 RECT_SET(self
->area
, x
, y
, w
, h
);
3030 /* for app-requested resizes, always resize if 'resized' is true.
3031 for user-requested ones, only resize if final is true, or when
3032 resizing in redraw mode */
3033 send_resize_client
= ((!user
&& resized
) ||
3035 (resized
&& config_resize_redraw
))));
3037 /* if the client is enlarging, then resize the client before the frame */
3038 if (send_resize_client
&& (w
> oldw
|| h
> oldh
)) {
3039 XMoveResizeWindow(ob_display
, self
->window
,
3040 self
->frame
->size
.left
, self
->frame
->size
.top
,
3041 MAX(w
, oldw
), MAX(h
, oldh
));
3042 frame_adjust_client_area(self
->frame
);
3045 /* find the frame's dimensions and move/resize it */
3049 /* if decorations changed, then readjust everything for the frame */
3050 if (self
->decorations
!= fdecor
||
3051 self
->max_horz
!= fhorz
|| self
->max_vert
!= fvert
)
3053 fmoved
= fresized
= TRUE
;
3056 /* adjust the frame */
3057 if (fmoved
|| fresized
) {
3058 gulong ignore_start
;
3060 ignore_start
= event_start_ignore_all_enters();
3062 /* replay pending pointer event before move the window, in case it
3063 would change what window gets the event */
3064 mouse_replay_pointer();
3066 frame_adjust_area(self
->frame
, fmoved
, fresized
, FALSE
);
3069 event_end_ignore_all_enters(ignore_start
);
3072 if (!user
|| final
) {
3073 gint oldrx
= self
->root_pos
.x
;
3074 gint oldry
= self
->root_pos
.y
;
3075 /* we have reset the client to 0 border width, so don't include
3076 it in these coords */
3077 POINT_SET(self
->root_pos
,
3078 self
->frame
->area
.x
+ self
->frame
->size
.left
-
3080 self
->frame
->area
.y
+ self
->frame
->size
.top
-
3081 self
->border_width
);
3082 if (self
->root_pos
.x
!= oldrx
|| self
->root_pos
.y
!= oldry
)
3086 /* This is kinda tricky and should not be changed.. let me explain!
3088 When user = FALSE, then the request is coming from the application
3089 itself, and we are more strict about when to send a synthetic
3090 ConfigureNotify. We strictly follow the rules of the ICCCM sec 4.1.5
3091 in this case (if force_reply is true)
3093 When user = TRUE, then the request is coming from "us", like when we
3094 maximize a window or something. In this case we are more lenient. We
3095 used to follow the same rules as above, but _Java_ Swing can't handle
3096 this. So just to appease Swing, when user = TRUE, we always send
3097 a synthetic ConfigureNotify to give the window its root coordinates.
3099 if ((!user
&& !resized
&& (rootmoved
|| force_reply
)) ||
3100 (user
&& final
&& rootmoved
))
3104 event
.type
= ConfigureNotify
;
3105 event
.xconfigure
.display
= ob_display
;
3106 event
.xconfigure
.event
= self
->window
;
3107 event
.xconfigure
.window
= self
->window
;
3109 ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
3110 self
->title
, self
->root_pos
.x
, self
->root_pos
.y
, w
, h
);
3112 /* root window real coords */
3113 event
.xconfigure
.x
= self
->root_pos
.x
;
3114 event
.xconfigure
.y
= self
->root_pos
.y
;
3115 event
.xconfigure
.width
= w
;
3116 event
.xconfigure
.height
= h
;
3117 event
.xconfigure
.border_width
= self
->border_width
;
3118 event
.xconfigure
.above
= None
;
3119 event
.xconfigure
.override_redirect
= FALSE
;
3120 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
3121 FALSE
, StructureNotifyMask
, &event
);
3124 /* if the client is shrinking, then resize the frame before the client.
3126 both of these resize sections may run, because the top one only resizes
3127 in the direction that is growing
3129 if (send_resize_client
&& (w
<= oldw
|| h
<= oldh
)) {
3130 frame_adjust_client_area(self
->frame
);
3131 XMoveResizeWindow(ob_display
, self
->window
,
3132 self
->frame
->size
.left
, self
->frame
->size
.top
, w
, h
);
3137 /* if it moved between monitors, then this can affect the stacking
3138 layer of this window or others - for fullscreen windows */
3139 if (screen_find_monitor(&self
->frame
->area
) !=
3140 screen_find_monitor(&oldframe
))
3142 client_calc_layer(self
);
3146 void client_fullscreen(ObClient
*self
, gboolean fs
)
3150 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
3151 self
->fullscreen
== fs
) return; /* already done */
3153 self
->fullscreen
= fs
;
3154 client_change_state(self
); /* change the state hints on the client */
3157 self
->pre_fullscreen_area
= self
->area
;
3158 /* if the window is maximized, its area isn't all that meaningful.
3159 save its premax area instead. */
3160 if (self
->max_horz
) {
3161 self
->pre_fullscreen_area
.x
= self
->pre_max_area
.x
;
3162 self
->pre_fullscreen_area
.width
= self
->pre_max_area
.width
;
3164 if (self
->max_vert
) {
3165 self
->pre_fullscreen_area
.y
= self
->pre_max_area
.y
;
3166 self
->pre_fullscreen_area
.height
= self
->pre_max_area
.height
;
3169 /* these will help configure_full figure out where to fullscreen
3173 w
= self
->area
.width
;
3174 h
= self
->area
.height
;
3176 g_assert(self
->pre_fullscreen_area
.width
> 0 &&
3177 self
->pre_fullscreen_area
.height
> 0);
3179 x
= self
->pre_fullscreen_area
.x
;
3180 y
= self
->pre_fullscreen_area
.y
;
3181 w
= self
->pre_fullscreen_area
.width
;
3182 h
= self
->pre_fullscreen_area
.height
;
3183 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
3186 ob_debug("Window %s going fullscreen (%d)\n",
3187 self
->title
, self
->fullscreen
);
3189 client_setup_decor_and_functions(self
, FALSE
);
3190 client_move_resize(self
, x
, y
, w
, h
);
3192 /* and adjust our layer/stacking. do this after resizing the window,
3193 and applying decorations, because windows which fill the screen are
3194 considered "fullscreen" and it affects their layer */
3195 client_calc_layer(self
);
3198 /* try focus us when we go into fullscreen mode */
3203 static void client_iconify_recursive(ObClient
*self
,
3204 gboolean iconic
, gboolean curdesk
,
3205 gboolean hide_animation
)
3208 gboolean changed
= FALSE
;
3210 if (self
->iconic
!= iconic
) {
3211 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
3215 /* don't let non-normal windows iconify along with their parents
3217 if (client_normal(self
)) {
3218 self
->iconic
= iconic
;
3220 /* update the focus lists.. iconic windows go to the bottom of
3222 focus_order_to_bottom(self
);
3227 self
->iconic
= iconic
;
3229 if (curdesk
&& self
->desktop
!= screen_desktop
&&
3230 self
->desktop
!= DESKTOP_ALL
)
3231 client_set_desktop(self
, screen_desktop
, FALSE
, FALSE
);
3233 /* this puts it after the current focused window */
3234 focus_order_remove(self
);
3235 focus_order_add_new(self
);
3242 client_change_state(self
);
3243 if (config_animate_iconify
&& !hide_animation
)
3244 frame_begin_iconify_animation(self
->frame
, iconic
);
3245 /* do this after starting the animation so it doesn't flash */
3246 client_showhide(self
);
3249 /* iconify all direct transients, and deiconify all transients
3251 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3252 if (it
->data
!= self
)
3253 if (client_is_direct_child(self
, it
->data
) || !iconic
)
3254 client_iconify_recursive(it
->data
, iconic
, curdesk
,
3258 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
,
3259 gboolean hide_animation
)
3261 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
|| !iconic
) {
3262 /* move up the transient chain as far as possible first */
3263 self
= client_search_top_direct_parent(self
);
3264 client_iconify_recursive(self
, iconic
, curdesk
, hide_animation
);
3268 void client_maximize(ObClient
*self
, gboolean max
, gint dir
)
3272 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
3273 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && max
) return;/* can't */
3275 /* check if already done */
3277 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
3278 if (dir
== 1 && self
->max_horz
) return;
3279 if (dir
== 2 && self
->max_vert
) return;
3281 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
3282 if (dir
== 1 && !self
->max_horz
) return;
3283 if (dir
== 2 && !self
->max_vert
) return;
3286 /* these will help configure_full figure out which screen to fill with
3290 w
= self
->area
.width
;
3291 h
= self
->area
.height
;
3294 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
3295 RECT_SET(self
->pre_max_area
,
3296 self
->area
.x
, self
->pre_max_area
.y
,
3297 self
->area
.width
, self
->pre_max_area
.height
);
3299 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
3300 RECT_SET(self
->pre_max_area
,
3301 self
->pre_max_area
.x
, self
->area
.y
,
3302 self
->pre_max_area
.width
, self
->area
.height
);
3305 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
3306 g_assert(self
->pre_max_area
.width
> 0);
3308 x
= self
->pre_max_area
.x
;
3309 w
= self
->pre_max_area
.width
;
3311 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
3312 0, self
->pre_max_area
.height
);
3314 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
3315 g_assert(self
->pre_max_area
.height
> 0);
3317 y
= self
->pre_max_area
.y
;
3318 h
= self
->pre_max_area
.height
;
3320 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
3321 self
->pre_max_area
.width
, 0);
3325 if (dir
== 0 || dir
== 1) /* horz */
3326 self
->max_horz
= max
;
3327 if (dir
== 0 || dir
== 2) /* vert */
3328 self
->max_vert
= max
;
3330 client_change_state(self
); /* change the state hints on the client */
3332 client_setup_decor_and_functions(self
, FALSE
);
3333 client_move_resize(self
, x
, y
, w
, h
);
3336 void client_shade(ObClient
*self
, gboolean shade
)
3338 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
3339 shade
) || /* can't shade */
3340 self
->shaded
== shade
) return; /* already done */
3342 self
->shaded
= shade
;
3343 client_change_state(self
);
3344 client_change_wm_state(self
); /* the window is being hidden/shown */
3345 /* resize the frame to just the titlebar */
3346 frame_adjust_area(self
->frame
, FALSE
, TRUE
, FALSE
);
3349 static void client_ping_event(ObClient
*self
, gboolean dead
)
3351 if (self
->not_responding
!= dead
) {
3352 self
->not_responding
= dead
;
3353 client_update_title(self
);
3356 /* the client isn't responding, so ask to kill it */
3357 client_prompt_kill(self
);
3359 /* it came back to life ! */
3361 if (self
->kill_prompt
) {
3362 prompt_unref(self
->kill_prompt
);
3363 self
->kill_prompt
= NULL
;
3366 self
->kill_level
= 0;
3371 void client_close(ObClient
*self
)
3373 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
3375 /* if closing an internal obprompt, that is just cancelling it */
3377 prompt_cancel(self
->prompt
);
3381 /* in the case that the client provides no means to requesting that it
3382 close, we just kill it */
3383 if (!self
->delete_window
)
3384 /* don't use client_kill(), we should only kill based on PID in
3385 response to a lack of PING replies */
3386 XKillClient(ob_display
, self
->window
);
3388 /* request the client to close with WM_DELETE_WINDOW */
3389 PROP_MSG_TO(self
->window
, self
->window
, wm_protocols
,
3390 prop_atoms
.wm_delete_window
, event_curtime
, 0, 0, 0,
3393 /* we're trying to close the window, so see if it is responding. if it
3394 is not, then we will let them kill the window */
3396 ping_start(self
, client_ping_event
);
3398 /* if we already know the window isn't responding (maybe they clicked
3399 no in the kill dialog but it hasn't come back to life), then show
3401 if (self
->not_responding
)
3402 client_prompt_kill(self
);
3406 #define OB_KILL_RESULT_NO 0
3407 #define OB_KILL_RESULT_YES 1
3409 static gboolean
client_kill_requested(ObPrompt
*p
, gint result
, gpointer data
)
3411 ObClient
*self
= data
;
3413 if (result
== OB_KILL_RESULT_YES
)
3415 return TRUE
; /* call the cleanup func */
3418 static void client_kill_cleanup(ObPrompt
*p
, gpointer data
)
3420 ObClient
*self
= data
;
3422 g_assert(p
== self
->kill_prompt
);
3424 prompt_unref(self
->kill_prompt
);
3425 self
->kill_prompt
= NULL
;
3428 static void client_prompt_kill(ObClient
*self
)
3430 /* check if we're already prompting */
3431 if (!self
->kill_prompt
) {
3432 ObPromptAnswer answers
[] = {
3433 { 0, OB_KILL_RESULT_NO
},
3434 { 0, OB_KILL_RESULT_YES
}
3437 const gchar
*y
, *title
;
3439 title
= self
->original_title
;
3440 if (title
[0] == '\0') {
3441 /* empty string, so use its parent */
3442 ObClient
*p
= client_search_top_direct_parent(self
);
3443 if (p
) title
= p
->original_title
;
3446 if (client_on_localhost(self
)) {
3449 if (self
->kill_level
== 0)
3455 (_("The window \"%s\" does not seem to be responding. Do you want to force it to exit by sending the %s signal?"),
3457 y
= _("End Process");
3461 (_("The window \"%s\" does not seem to be responding. Do you want to disconnect it from the X server?"),
3463 y
= _("Disconnect");
3465 /* set the dialog buttons' text */
3466 answers
[0].text
= _("Cancel"); /* "no" */
3467 answers
[1].text
= y
; /* "yes" */
3469 self
->kill_prompt
= prompt_new(m
, NULL
, answers
,
3470 sizeof(answers
)/sizeof(answers
[0]),
3471 OB_KILL_RESULT_NO
, /* default = no */
3472 OB_KILL_RESULT_NO
, /* cancel = no */
3473 client_kill_requested
,
3474 client_kill_cleanup
,
3479 prompt_show(self
->kill_prompt
, self
, TRUE
);
3482 void client_kill(ObClient
*self
)
3484 /* don't kill our own windows */
3485 if (self
->prompt
) return;
3487 if (client_on_localhost(self
) && self
->pid
) {
3488 /* running on the local host */
3489 if (self
->kill_level
== 0) {
3490 ob_debug("killing window 0x%x with pid %lu, with SIGTERM",
3491 self
->window
, self
->pid
);
3492 kill(self
->pid
, SIGTERM
);
3495 /* show that we're trying to kill it */
3496 client_update_title(self
);
3499 ob_debug("killing window 0x%x with pid %lu, with SIGKILL\n",
3500 self
->window
, self
->pid
);
3501 kill(self
->pid
, SIGKILL
); /* kill -9 */
3505 /* running on a remote host */
3506 XKillClient(ob_display
, self
->window
);
3510 void client_hilite(ObClient
*self
, gboolean hilite
)
3512 if (self
->demands_attention
== hilite
)
3513 return; /* no change */
3515 /* don't allow focused windows to hilite */
3516 self
->demands_attention
= hilite
&& !client_focused(self
);
3517 if (self
->frame
!= NULL
) { /* if we're mapping, just set the state */
3518 if (self
->demands_attention
)
3519 frame_flash_start(self
->frame
);
3521 frame_flash_stop(self
->frame
);
3522 client_change_state(self
);
3526 static void client_set_desktop_recursive(ObClient
*self
,
3534 if (target
!= self
->desktop
&& self
->type
!= OB_CLIENT_TYPE_DESKTOP
) {
3536 ob_debug("Setting desktop %u\n", target
+1);
3538 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
3540 old
= self
->desktop
;
3541 self
->desktop
= target
;
3542 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
3543 /* the frame can display the current desktop state */
3544 frame_adjust_state(self
->frame
);
3545 /* 'move' the window to the new desktop */
3549 /* raise if it was not already on the desktop */
3550 if (old
!= DESKTOP_ALL
&& !dontraise
)
3551 stacking_raise(CLIENT_AS_WINDOW(self
));
3552 if (STRUT_EXISTS(self
->strut
))
3553 screen_update_areas();
3555 /* the new desktop's geometry may be different, so we may need to
3556 resize, for example if we are maximized */
3557 client_reconfigure(self
, FALSE
);
3560 /* move all transients */
3561 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3562 if (it
->data
!= self
)
3563 if (client_is_direct_child(self
, it
->data
))
3564 client_set_desktop_recursive(it
->data
, target
,
3565 donthide
, dontraise
);
3568 void client_set_desktop(ObClient
*self
, guint target
,
3569 gboolean donthide
, gboolean dontraise
)
3571 self
= client_search_top_direct_parent(self
);
3572 client_set_desktop_recursive(self
, target
, donthide
, dontraise
);
3575 gboolean
client_is_direct_child(ObClient
*parent
, ObClient
*child
)
3577 while (child
!= parent
&& (child
= client_direct_parent(child
)));
3578 return child
== parent
;
3581 ObClient
*client_search_modal_child(ObClient
*self
)
3586 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
3587 ObClient
*c
= it
->data
;
3588 if ((ret
= client_search_modal_child(c
))) return ret
;
3589 if (c
->modal
) return c
;
3594 static gboolean
client_validate_unmap(ObClient
*self
, int n
)
3597 gboolean ret
= TRUE
;
3599 if (XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
3600 if (n
< self
->ignore_unmaps
) // ignore this one, but look for more
3601 ret
= client_validate_unmap(self
, n
+1);
3603 ret
= FALSE
; // the window is going to become unmanaged
3605 /* put them back on the event stack so they end up in the same order */
3606 XPutBackEvent(ob_display
, &e
);
3612 gboolean
client_validate(ObClient
*self
)
3616 XSync(ob_display
, FALSE
); /* get all events on the server */
3618 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
)) {
3619 XPutBackEvent(ob_display
, &e
);
3623 if (!client_validate_unmap(self
, 0))
3629 void client_set_wm_state(ObClient
*self
, glong state
)
3631 if (state
== self
->wmstate
) return; /* no change */
3635 client_iconify(self
, TRUE
, TRUE
, FALSE
);
3638 client_iconify(self
, FALSE
, TRUE
, FALSE
);
3643 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
3645 gboolean shaded
= self
->shaded
;
3646 gboolean fullscreen
= self
->fullscreen
;
3647 gboolean undecorated
= self
->undecorated
;
3648 gboolean max_horz
= self
->max_horz
;
3649 gboolean max_vert
= self
->max_vert
;
3650 gboolean modal
= self
->modal
;
3651 gboolean iconic
= self
->iconic
;
3652 gboolean demands_attention
= self
->demands_attention
;
3653 gboolean above
= self
->above
;
3654 gboolean below
= self
->below
;
3657 if (!(action
== prop_atoms
.net_wm_state_add
||
3658 action
== prop_atoms
.net_wm_state_remove
||
3659 action
== prop_atoms
.net_wm_state_toggle
))
3660 /* an invalid action was passed to the client message, ignore it */
3663 for (i
= 0; i
< 2; ++i
) {
3664 Atom state
= i
== 0 ? data1
: data2
;
3666 if (!state
) continue;
3668 /* if toggling, then pick whether we're adding or removing */
3669 if (action
== prop_atoms
.net_wm_state_toggle
) {
3670 if (state
== prop_atoms
.net_wm_state_modal
)
3671 action
= modal
? prop_atoms
.net_wm_state_remove
:
3672 prop_atoms
.net_wm_state_add
;
3673 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
3674 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
3675 prop_atoms
.net_wm_state_add
;
3676 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
3677 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
3678 prop_atoms
.net_wm_state_add
;
3679 else if (state
== prop_atoms
.net_wm_state_shaded
)
3680 action
= shaded
? prop_atoms
.net_wm_state_remove
:
3681 prop_atoms
.net_wm_state_add
;
3682 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
3683 action
= self
->skip_taskbar
?
3684 prop_atoms
.net_wm_state_remove
:
3685 prop_atoms
.net_wm_state_add
;
3686 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
3687 action
= self
->skip_pager
?
3688 prop_atoms
.net_wm_state_remove
:
3689 prop_atoms
.net_wm_state_add
;
3690 else if (state
== prop_atoms
.net_wm_state_hidden
)
3691 action
= self
->iconic
?
3692 prop_atoms
.net_wm_state_remove
:
3693 prop_atoms
.net_wm_state_add
;
3694 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
3695 action
= fullscreen
?
3696 prop_atoms
.net_wm_state_remove
:
3697 prop_atoms
.net_wm_state_add
;
3698 else if (state
== prop_atoms
.net_wm_state_above
)
3699 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
3700 prop_atoms
.net_wm_state_add
;
3701 else if (state
== prop_atoms
.net_wm_state_below
)
3702 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
3703 prop_atoms
.net_wm_state_add
;
3704 else if (state
== prop_atoms
.net_wm_state_demands_attention
)
3705 action
= self
->demands_attention
?
3706 prop_atoms
.net_wm_state_remove
:
3707 prop_atoms
.net_wm_state_add
;
3708 else if (state
== prop_atoms
.ob_wm_state_undecorated
)
3709 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
3710 prop_atoms
.net_wm_state_add
;
3713 if (action
== prop_atoms
.net_wm_state_add
) {
3714 if (state
== prop_atoms
.net_wm_state_modal
) {
3716 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
3718 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
3720 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
3722 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
3723 self
->skip_taskbar
= TRUE
;
3724 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
3725 self
->skip_pager
= TRUE
;
3726 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
3728 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
3730 } else if (state
== prop_atoms
.net_wm_state_above
) {
3733 } else if (state
== prop_atoms
.net_wm_state_below
) {
3736 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
3737 demands_attention
= TRUE
;
3738 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
3742 } else { /* action == prop_atoms.net_wm_state_remove */
3743 if (state
== prop_atoms
.net_wm_state_modal
) {
3745 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
3747 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
3749 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
3751 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
3752 self
->skip_taskbar
= FALSE
;
3753 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
3754 self
->skip_pager
= FALSE
;
3755 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
3757 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
3759 } else if (state
== prop_atoms
.net_wm_state_above
) {
3761 } else if (state
== prop_atoms
.net_wm_state_below
) {
3763 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
3764 demands_attention
= FALSE
;
3765 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
3766 undecorated
= FALSE
;
3771 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
3772 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
3774 if (max_horz
== max_vert
) { /* both going the same way */
3775 client_maximize(self
, max_horz
, 0);
3777 client_maximize(self
, max_horz
, 1);
3778 client_maximize(self
, max_vert
, 2);
3782 if (max_horz
!= self
->max_horz
)
3783 client_maximize(self
, max_horz
, 1);
3785 client_maximize(self
, max_vert
, 2);
3788 /* change fullscreen state before shading, as it will affect if the window
3790 if (fullscreen
!= self
->fullscreen
)
3791 client_fullscreen(self
, fullscreen
);
3792 if (shaded
!= self
->shaded
)
3793 client_shade(self
, shaded
);
3794 if (undecorated
!= self
->undecorated
)
3795 client_set_undecorated(self
, undecorated
);
3796 if (above
!= self
->above
|| below
!= self
->below
) {
3797 self
->above
= above
;
3798 self
->below
= below
;
3799 client_calc_layer(self
);
3802 if (modal
!= self
->modal
) {
3803 self
->modal
= modal
;
3804 /* when a window changes modality, then its stacking order with its
3805 transients needs to change */
3806 stacking_raise(CLIENT_AS_WINDOW(self
));
3808 /* it also may get focused. if something is focused that shouldn't
3809 be focused anymore, then move the focus */
3810 if (focus_client
&& client_focus_target(focus_client
) != focus_client
)
3811 client_focus(focus_client
);
3814 if (iconic
!= self
->iconic
)
3815 client_iconify(self
, iconic
, FALSE
, FALSE
);
3817 if (demands_attention
!= self
->demands_attention
)
3818 client_hilite(self
, demands_attention
);
3820 client_change_state(self
); /* change the hint to reflect these changes */
3823 ObClient
*client_focus_target(ObClient
*self
)
3825 ObClient
*child
= NULL
;
3827 child
= client_search_modal_child(self
);
3828 if (child
) return child
;
3832 gboolean
client_can_focus(ObClient
*self
)
3834 /* choose the correct target */
3835 self
= client_focus_target(self
);
3837 if (!self
->frame
->visible
)
3840 if (!(self
->can_focus
|| self
->focus_notify
))
3846 gboolean
client_focus(ObClient
*self
)
3848 /* we might not focus this window, so if we have modal children which would
3849 be focused instead, bring them to this desktop */
3850 client_bring_modal_windows(self
);
3852 /* choose the correct target */
3853 self
= client_focus_target(self
);
3855 if (!client_can_focus(self
)) {
3856 ob_debug_type(OB_DEBUG_FOCUS
,
3857 "Client %s can't be focused\n", self
->title
);
3861 ob_debug_type(OB_DEBUG_FOCUS
,
3862 "Focusing client \"%s\" (0x%x) at time %u\n",
3863 self
->title
, self
->window
, event_curtime
);
3865 /* if using focus_delay, stop the timer now so that focus doesn't
3867 event_halt_focus_delay();
3869 event_cancel_all_key_grabs();
3871 xerror_set_ignore(TRUE
);
3872 xerror_occured
= FALSE
;
3874 if (self
->can_focus
) {
3875 /* This can cause a BadMatch error with CurrentTime, or if an app
3876 passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3877 XSetInputFocus(ob_display
, self
->window
, RevertToPointerRoot
,
3881 if (self
->focus_notify
) {
3883 ce
.xclient
.type
= ClientMessage
;
3884 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
3885 ce
.xclient
.display
= ob_display
;
3886 ce
.xclient
.window
= self
->window
;
3887 ce
.xclient
.format
= 32;
3888 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
3889 ce
.xclient
.data
.l
[1] = event_curtime
;
3890 ce
.xclient
.data
.l
[2] = 0l;
3891 ce
.xclient
.data
.l
[3] = 0l;
3892 ce
.xclient
.data
.l
[4] = 0l;
3893 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
3896 xerror_set_ignore(FALSE
);
3898 ob_debug_type(OB_DEBUG_FOCUS
, "Error focusing? %d\n", xerror_occured
);
3899 return !xerror_occured
;
3902 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
,
3905 if (client_normal(self
) && screen_showing_desktop
)
3906 screen_show_desktop(FALSE
, self
);
3908 client_iconify(self
, FALSE
, here
, FALSE
);
3909 if (self
->desktop
!= DESKTOP_ALL
&&
3910 self
->desktop
!= screen_desktop
)
3913 client_set_desktop(self
, screen_desktop
, FALSE
, TRUE
);
3915 screen_set_desktop(self
->desktop
, FALSE
);
3916 } else if (!self
->frame
->visible
)
3917 /* if its not visible for other reasons, then don't mess
3920 if (self
->shaded
&& unshade
)
3921 client_shade(self
, FALSE
);
3923 stacking_raise(CLIENT_AS_WINDOW(self
));
3928 /* this function exists to map to the net_active_window message in the ewmh */
3929 void client_activate(ObClient
*self
, gboolean here
, gboolean raise
,
3930 gboolean unshade
, gboolean user
)
3932 if (user
|| (self
->desktop
== DESKTOP_ALL
||
3933 self
->desktop
== screen_desktop
))
3934 client_present(self
, here
, raise
, unshade
);
3936 client_hilite(self
, TRUE
);
3939 static void client_bring_windows_recursive(ObClient
*self
,
3947 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3948 client_bring_windows_recursive(it
->data
, desktop
,
3949 helpers
, modals
, iconic
);
3951 if (((helpers
&& client_helper(self
)) ||
3952 (modals
&& self
->modal
)) &&
3953 ((self
->desktop
!= desktop
&& self
->desktop
!= DESKTOP_ALL
) ||
3954 (iconic
&& self
->iconic
)))
3956 if (iconic
&& self
->iconic
)
3957 client_iconify(self
, FALSE
, TRUE
, FALSE
);
3959 client_set_desktop(self
, desktop
, FALSE
, FALSE
);
3963 void client_bring_helper_windows(ObClient
*self
)
3965 client_bring_windows_recursive(self
, self
->desktop
, TRUE
, FALSE
, FALSE
);
3968 void client_bring_modal_windows(ObClient
*self
)
3970 client_bring_windows_recursive(self
, self
->desktop
, FALSE
, TRUE
, TRUE
);
3973 gboolean
client_focused(ObClient
*self
)
3975 return self
== focus_client
;
3978 RrImage
* client_icon(ObClient
*self
)
3980 RrImage
*ret
= NULL
;
3983 ret
= self
->icon_set
;
3984 else if (self
->parents
) {
3986 for (it
= self
->parents
; it
&& !ret
; it
= g_slist_next(it
))
3987 ret
= client_icon(it
->data
);
3990 ret
= client_default_icon
;
3994 void client_set_layer(ObClient
*self
, gint layer
)
3998 self
->above
= FALSE
;
3999 } else if (layer
== 0) {
4000 self
->below
= self
->above
= FALSE
;
4002 self
->below
= FALSE
;
4005 client_calc_layer(self
);
4006 client_change_state(self
); /* reflect this in the state hints */
4009 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
4011 if (self
->undecorated
!= undecorated
&&
4012 /* don't let it undecorate if the function is missing, but let
4014 (self
->functions
& OB_CLIENT_FUNC_UNDECORATE
|| !undecorated
))
4016 self
->undecorated
= undecorated
;
4017 client_setup_decor_and_functions(self
, TRUE
);
4018 client_change_state(self
); /* reflect this in the state hints */
4022 guint
client_monitor(ObClient
*self
)
4024 return screen_find_monitor(&self
->frame
->area
);
4027 ObClient
*client_direct_parent(ObClient
*self
)
4029 if (!self
->parents
) return NULL
;
4030 if (self
->transient_for_group
) return NULL
;
4031 return self
->parents
->data
;
4034 ObClient
*client_search_top_direct_parent(ObClient
*self
)
4037 while ((p
= client_direct_parent(self
))) self
= p
;
4041 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
4043 ObStackingLayer layer
)
4048 /* move up the direct transient chain as far as possible */
4049 while ((p
= client_direct_parent(self
)) &&
4050 (!bylayer
|| p
->layer
== layer
))
4054 ret
= g_slist_prepend(NULL
, self
);
4056 ret
= g_slist_copy(self
->parents
);
4061 GSList
*client_search_all_top_parents(ObClient
*self
)
4063 return client_search_all_top_parents_internal(self
, FALSE
, 0);
4066 GSList
*client_search_all_top_parents_layer(ObClient
*self
)
4068 return client_search_all_top_parents_internal(self
, TRUE
, self
->layer
);
4071 ObClient
*client_search_focus_parent(ObClient
*self
)
4075 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
4076 if (client_focused(it
->data
)) return it
->data
;
4081 ObClient
*client_search_focus_parent_full(ObClient
*self
)
4084 ObClient
*ret
= NULL
;
4086 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
4087 if (client_focused(it
->data
))
4090 ret
= client_search_focus_parent_full(it
->data
);
4096 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
4100 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
4101 if (it
->data
== search
) return search
;
4106 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
4110 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
4111 if (sit
->data
== search
)
4113 if (client_search_transient(sit
->data
, search
))
4119 static void detect_edge(Rect area
, ObDirection dir
,
4120 gint my_head
, gint my_size
,
4121 gint my_edge_start
, gint my_edge_size
,
4122 gint
*dest
, gboolean
*near_edge
)
4124 gint edge_start
, edge_size
, head
, tail
;
4125 gboolean skip_head
= FALSE
, skip_tail
= FALSE
;
4128 case OB_DIRECTION_NORTH
:
4129 case OB_DIRECTION_SOUTH
:
4130 edge_start
= area
.x
;
4131 edge_size
= area
.width
;
4133 case OB_DIRECTION_EAST
:
4134 case OB_DIRECTION_WEST
:
4135 edge_start
= area
.y
;
4136 edge_size
= area
.height
;
4139 g_assert_not_reached();
4142 /* do we collide with this window? */
4143 if (!RANGES_INTERSECT(my_edge_start
, my_edge_size
,
4144 edge_start
, edge_size
))
4148 case OB_DIRECTION_NORTH
:
4149 head
= RECT_BOTTOM(area
);
4150 tail
= RECT_TOP(area
);
4152 case OB_DIRECTION_SOUTH
:
4153 head
= RECT_TOP(area
);
4154 tail
= RECT_BOTTOM(area
);
4156 case OB_DIRECTION_WEST
:
4157 head
= RECT_RIGHT(area
);
4158 tail
= RECT_LEFT(area
);
4160 case OB_DIRECTION_EAST
:
4161 head
= RECT_LEFT(area
);
4162 tail
= RECT_RIGHT(area
);
4165 g_assert_not_reached();
4168 case OB_DIRECTION_NORTH
:
4169 case OB_DIRECTION_WEST
:
4170 /* check if our window is past the head of this window */
4171 if (my_head
<= head
+ 1)
4173 /* check if our window's tail is past the tail of this window */
4174 if (my_head
+ my_size
- 1 <= tail
)
4176 /* check if the head of this window is closer than the previously
4177 chosen edge (take into account that the previously chosen
4178 edge might have been a tail, not a head) */
4179 if (head
+ (*near_edge
? 0 : my_size
) <= *dest
)
4181 /* check if the tail of this window is closer than the previously
4182 chosen edge (take into account that the previously chosen
4183 edge might have been a head, not a tail) */
4184 if (tail
- (!*near_edge
? 0 : my_size
) <= *dest
)
4187 case OB_DIRECTION_SOUTH
:
4188 case OB_DIRECTION_EAST
:
4189 /* check if our window is past the head of this window */
4190 if (my_head
>= head
- 1)
4192 /* check if our window's tail is past the tail of this window */
4193 if (my_head
- my_size
+ 1 >= tail
)
4195 /* check if the head of this window is closer than the previously
4196 chosen edge (take into account that the previously chosen
4197 edge might have been a tail, not a head) */
4198 if (head
- (*near_edge
? 0 : my_size
) >= *dest
)
4200 /* check if the tail of this window is closer than the previously
4201 chosen edge (take into account that the previously chosen
4202 edge might have been a head, not a tail) */
4203 if (tail
+ (!*near_edge
? 0 : my_size
) >= *dest
)
4207 g_assert_not_reached();
4210 ob_debug("my head %d size %d\n", my_head
, my_size
);
4211 ob_debug("head %d tail %d dest %d\n", head
, tail
, *dest
);
4213 ob_debug("using near edge %d\n", head
);
4217 else if (!skip_tail
) {
4218 ob_debug("using far edge %d\n", tail
);
4224 void client_find_edge_directional(ObClient
*self
, ObDirection dir
,
4225 gint my_head
, gint my_size
,
4226 gint my_edge_start
, gint my_edge_size
,
4227 gint
*dest
, gboolean
*near_edge
)
4234 a
= screen_area(self
->desktop
, SCREEN_AREA_ALL_MONITORS
,
4235 &self
->frame
->area
);
4236 mon
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
,
4237 &self
->frame
->area
);
4240 case OB_DIRECTION_NORTH
:
4241 if (my_head
>= RECT_TOP(*mon
) + 1)
4242 edge
= RECT_TOP(*mon
) - 1;
4244 edge
= RECT_TOP(*a
) - 1;
4246 case OB_DIRECTION_SOUTH
:
4247 if (my_head
<= RECT_BOTTOM(*mon
) - 1)
4248 edge
= RECT_BOTTOM(*mon
) + 1;
4250 edge
= RECT_BOTTOM(*a
) + 1;
4252 case OB_DIRECTION_EAST
:
4253 if (my_head
<= RECT_RIGHT(*mon
) - 1)
4254 edge
= RECT_RIGHT(*mon
) + 1;
4256 edge
= RECT_RIGHT(*a
) + 1;
4258 case OB_DIRECTION_WEST
:
4259 if (my_head
>= RECT_LEFT(*mon
) + 1)
4260 edge
= RECT_LEFT(*mon
) - 1;
4262 edge
= RECT_LEFT(*a
) - 1;
4265 g_assert_not_reached();
4267 /* default to the far edge, then narrow it down */
4271 for (it
= client_list
; it
; it
= g_list_next(it
)) {
4272 ObClient
*cur
= it
->data
;
4274 /* skip windows to not bump into */
4279 if (self
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
&&
4280 cur
->desktop
!= screen_desktop
)
4283 ob_debug("trying window %s\n", cur
->title
);
4285 detect_edge(cur
->frame
->area
, dir
, my_head
, my_size
, my_edge_start
,
4286 my_edge_size
, dest
, near_edge
);
4288 dock_get_area(&dock_area
);
4289 detect_edge(dock_area
, dir
, my_head
, my_size
, my_edge_start
,
4290 my_edge_size
, dest
, near_edge
);
4295 void client_find_move_directional(ObClient
*self
, ObDirection dir
,
4299 gint e
, e_start
, e_size
;
4303 case OB_DIRECTION_EAST
:
4304 head
= RECT_RIGHT(self
->frame
->area
);
4305 size
= self
->frame
->area
.width
;
4306 e_start
= RECT_TOP(self
->frame
->area
);
4307 e_size
= self
->frame
->area
.height
;
4309 case OB_DIRECTION_WEST
:
4310 head
= RECT_LEFT(self
->frame
->area
);
4311 size
= self
->frame
->area
.width
;
4312 e_start
= RECT_TOP(self
->frame
->area
);
4313 e_size
= self
->frame
->area
.height
;
4315 case OB_DIRECTION_NORTH
:
4316 head
= RECT_TOP(self
->frame
->area
);
4317 size
= self
->frame
->area
.height
;
4318 e_start
= RECT_LEFT(self
->frame
->area
);
4319 e_size
= self
->frame
->area
.width
;
4321 case OB_DIRECTION_SOUTH
:
4322 head
= RECT_BOTTOM(self
->frame
->area
);
4323 size
= self
->frame
->area
.height
;
4324 e_start
= RECT_LEFT(self
->frame
->area
);
4325 e_size
= self
->frame
->area
.width
;
4328 g_assert_not_reached();
4331 client_find_edge_directional(self
, dir
, head
, size
,
4332 e_start
, e_size
, &e
, &near
);
4333 *x
= self
->frame
->area
.x
;
4334 *y
= self
->frame
->area
.y
;
4336 case OB_DIRECTION_EAST
:
4337 if (near
) e
-= self
->frame
->area
.width
;
4341 case OB_DIRECTION_WEST
:
4343 else e
-= self
->frame
->area
.width
;
4346 case OB_DIRECTION_NORTH
:
4348 else e
-= self
->frame
->area
.height
;
4351 case OB_DIRECTION_SOUTH
:
4352 if (near
) e
-= self
->frame
->area
.height
;
4357 g_assert_not_reached();
4359 frame_frame_gravity(self
->frame
, x
, y
);
4362 void client_find_resize_directional(ObClient
*self
, ObDirection side
,
4364 gint
*x
, gint
*y
, gint
*w
, gint
*h
)
4367 gint e
, e_start
, e_size
, delta
;
4372 case OB_DIRECTION_EAST
:
4373 head
= RECT_RIGHT(self
->frame
->area
) +
4374 (self
->size_inc
.width
- 1) * (grow
? 1 : 0);
4375 e_start
= RECT_TOP(self
->frame
->area
);
4376 e_size
= self
->frame
->area
.height
;
4377 dir
= grow
? OB_DIRECTION_EAST
: OB_DIRECTION_WEST
;
4379 case OB_DIRECTION_WEST
:
4380 head
= RECT_LEFT(self
->frame
->area
) -
4381 (self
->size_inc
.width
- 1) * (grow
? 1 : 0);
4382 e_start
= RECT_TOP(self
->frame
->area
);
4383 e_size
= self
->frame
->area
.height
;
4384 dir
= grow
? OB_DIRECTION_WEST
: OB_DIRECTION_EAST
;
4386 case OB_DIRECTION_NORTH
:
4387 head
= RECT_TOP(self
->frame
->area
) -
4388 (self
->size_inc
.height
- 1) * (grow
? 1 : 0);
4389 e_start
= RECT_LEFT(self
->frame
->area
);
4390 e_size
= self
->frame
->area
.width
;
4391 dir
= grow
? OB_DIRECTION_NORTH
: OB_DIRECTION_SOUTH
;
4393 case OB_DIRECTION_SOUTH
:
4394 head
= RECT_BOTTOM(self
->frame
->area
) +
4395 (self
->size_inc
.height
- 1) * (grow
? 1 : 0);
4396 e_start
= RECT_LEFT(self
->frame
->area
);
4397 e_size
= self
->frame
->area
.width
;
4398 dir
= grow
? OB_DIRECTION_SOUTH
: OB_DIRECTION_NORTH
;
4401 g_assert_not_reached();
4404 ob_debug("head %d dir %d\n", head
, dir
);
4405 client_find_edge_directional(self
, dir
, head
, 1,
4406 e_start
, e_size
, &e
, &near
);
4407 ob_debug("edge %d\n", e
);
4408 *x
= self
->frame
->area
.x
;
4409 *y
= self
->frame
->area
.y
;
4410 *w
= self
->frame
->area
.width
;
4411 *h
= self
->frame
->area
.height
;
4413 case OB_DIRECTION_EAST
:
4414 if (grow
== near
) --e
;
4415 delta
= e
- RECT_RIGHT(self
->frame
->area
);
4418 case OB_DIRECTION_WEST
:
4419 if (grow
== near
) ++e
;
4420 delta
= RECT_LEFT(self
->frame
->area
) - e
;
4424 case OB_DIRECTION_NORTH
:
4425 if (grow
== near
) ++e
;
4426 delta
= RECT_TOP(self
->frame
->area
) - e
;
4430 case OB_DIRECTION_SOUTH
:
4431 if (grow
== near
) --e
;
4432 delta
= e
- RECT_BOTTOM(self
->frame
->area
);
4436 g_assert_not_reached();
4438 frame_frame_gravity(self
->frame
, x
, y
);
4439 *w
-= self
->frame
->size
.left
+ self
->frame
->size
.right
;
4440 *h
-= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
4443 ObClient
* client_under_pointer(void)
4447 ObClient
*ret
= NULL
;
4449 if (screen_pointer_pos(&x
, &y
)) {
4450 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
4451 if (WINDOW_IS_CLIENT(it
->data
)) {
4452 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
4453 if (c
->frame
->visible
&&
4454 /* check the desktop, this is done during desktop
4455 switching and windows are shown/hidden status is not
4457 (c
->desktop
== screen_desktop
||
4458 c
->desktop
== DESKTOP_ALL
) &&
4459 /* ignore all animating windows */
4460 !frame_iconify_animating(c
->frame
) &&
4461 RECT_CONTAINS(c
->frame
->area
, x
, y
))
4472 gboolean
client_has_group_siblings(ObClient
*self
)
4474 return self
->group
&& self
->group
->members
->next
;
4477 /*! Returns TRUE if the client is running on the same machine as Openbox */
4478 gboolean
client_on_localhost(ObClient
*self
)
4480 return self
->client_machine
== NULL
;