1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
22 #include "startupnotify.h"
26 #include "moveresize.h"
29 #include "extensions.h"
39 #include "menuframe.h"
42 #include "render/render.h"
49 #include <X11/Xutil.h>
51 /*! The event mask to grab on client windows */
52 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
55 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
60 ObClientCallback func
;
64 GList
*client_list
= NULL
;
66 static GSList
*client_destroy_notifies
= NULL
;
68 static void client_get_all(ObClient
*self
, gboolean real
);
69 static void client_get_startup_id(ObClient
*self
);
70 static void client_get_session_ids(ObClient
*self
);
71 static void client_get_area(ObClient
*self
);
72 static void client_get_desktop(ObClient
*self
);
73 static void client_get_state(ObClient
*self
);
74 static void client_get_shaped(ObClient
*self
);
75 static void client_get_mwm_hints(ObClient
*self
);
76 static void client_get_colormap(ObClient
*self
);
77 static void client_change_allowed_actions(ObClient
*self
);
78 static void client_change_state(ObClient
*self
);
79 static void client_change_wm_state(ObClient
*self
);
80 static void client_apply_startup_state(ObClient
*self
,
81 gint x
, gint y
, gint w
, gint h
);
82 static void client_restore_session_state(ObClient
*self
);
83 static gboolean
client_restore_session_stacking(ObClient
*self
);
84 static ObAppSettings
*client_get_settings_state(ObClient
*self
);
85 static void client_update_transient_tree(ObClient
*self
,
86 ObGroup
*oldgroup
, ObGroup
*newgroup
,
87 gboolean oldgtran
, gboolean newgtran
,
90 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
,
92 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
94 ObStackingLayer layer
);
95 static void client_call_notifies(ObClient
*self
, GSList
*list
);
98 void client_startup(gboolean reconfig
)
100 if (reconfig
) return;
105 void client_shutdown(gboolean reconfig
)
107 if (reconfig
) return;
110 static void client_call_notifies(ObClient
*self
, GSList
*list
)
114 for (it
= list
; it
; it
= g_slist_next(it
)) {
115 ClientCallback
*d
= it
->data
;
116 d
->func(self
, d
->data
);
120 void client_add_destroy_notify(ObClientCallback func
, gpointer data
)
122 ClientCallback
*d
= g_new(ClientCallback
, 1);
125 client_destroy_notifies
= g_slist_prepend(client_destroy_notifies
, d
);
128 void client_remove_destroy_notify(ObClientCallback func
)
132 for (it
= client_destroy_notifies
; it
; it
= g_slist_next(it
)) {
133 ClientCallback
*d
= it
->data
;
134 if (d
->func
== func
) {
136 client_destroy_notifies
=
137 g_slist_delete_link(client_destroy_notifies
, it
);
143 void client_set_list(void)
145 Window
*windows
, *win_it
;
147 guint size
= g_list_length(client_list
);
149 /* create an array of the window ids */
151 windows
= g_new(Window
, size
);
153 for (it
= client_list
; it
; it
= g_list_next(it
), ++win_it
)
154 *win_it
= ((ObClient
*)it
->data
)->window
;
158 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
159 net_client_list
, window
, (gulong
*)windows
, size
);
167 void client_manage_all(void)
172 XWindowAttributes attrib
;
174 XQueryTree(ob_display
, RootWindow(ob_display
, ob_screen
),
175 &w
, &w
, &children
, &nchild
);
177 /* remove all icon windows from the list */
178 for (i
= 0; i
< nchild
; i
++) {
179 if (children
[i
] == None
) continue;
180 wmhints
= XGetWMHints(ob_display
, children
[i
]);
182 if ((wmhints
->flags
& IconWindowHint
) &&
183 (wmhints
->icon_window
!= children
[i
]))
184 for (j
= 0; j
< nchild
; j
++)
185 if (children
[j
] == wmhints
->icon_window
) {
193 for (i
= 0; i
< nchild
; ++i
) {
194 if (children
[i
] == None
)
196 if (XGetWindowAttributes(ob_display
, children
[i
], &attrib
)) {
197 if (attrib
.override_redirect
) continue;
199 if (attrib
.map_state
!= IsUnmapped
)
200 client_manage(children
[i
]);
206 void client_manage(Window window
)
210 XWindowAttributes attrib
;
211 XSetWindowAttributes attrib_set
;
213 gboolean activate
= FALSE
;
214 ObAppSettings
*settings
;
215 gboolean transient
= FALSE
;
216 Rect place
, *monitor
;
217 Time launch_time
, map_time
;
221 /* check if it has already been unmapped by the time we started
222 mapping. the grab does a sync so we don't have to here */
223 if (XCheckTypedWindowEvent(ob_display
, window
, DestroyNotify
, &e
) ||
224 XCheckTypedWindowEvent(ob_display
, window
, UnmapNotify
, &e
))
226 XPutBackEvent(ob_display
, &e
);
228 ob_debug("Trying to manage unmapped window. Aborting that.\n");
230 return; /* don't manage it */
233 /* make sure it isn't an override-redirect window */
234 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
235 attrib
.override_redirect
)
238 return; /* don't manage it */
241 /* is the window a docking app */
242 if ((wmhint
= XGetWMHints(ob_display
, window
))) {
243 if ((wmhint
->flags
& StateHint
) &&
244 wmhint
->initial_state
== WithdrawnState
)
246 dock_add(window
, wmhint
);
254 ob_debug("Managing window: 0x%lx\n", window
);
256 map_time
= event_get_server_time();
258 /* choose the events we want to receive on the CLIENT window */
259 attrib_set
.event_mask
= CLIENT_EVENTMASK
;
260 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
261 XChangeWindowAttributes(ob_display
, window
,
262 CWEventMask
|CWDontPropagate
, &attrib_set
);
264 /* create the ObClient struct, and populate it from the hints on the
266 self
= g_new0(ObClient
, 1);
267 self
->obwin
.type
= Window_Client
;
268 self
->window
= window
;
270 /* non-zero defaults */
271 self
->wmstate
= WithdrawnState
; /* make sure it gets updated first time */
272 self
->gravity
= NorthWestGravity
;
273 self
->desktop
= screen_num_desktops
; /* always an invalid value */
275 /* get all the stuff off the window */
276 client_get_all(self
, TRUE
);
278 ob_debug("Window type: %d\n", self
->type
);
279 ob_debug("Window group: 0x%x\n", self
->group
?self
->group
->leader
:0);
281 /* specify that if we exit, the window should not be destroyed and
282 should be reparented back to root automatically */
283 XChangeSaveSet(ob_display
, window
, SetModeInsert
);
285 /* create the decoration frame for the client window */
286 self
->frame
= frame_new(self
);
288 frame_grab_client(self
->frame
);
290 /* we've grabbed everything and set everything that we need to at mapping
294 /* per-app settings override stuff from client_get_all, and return the
295 settings for other uses too. the returned settings is a shallow copy,
296 that needs to be freed with g_free(). */
297 settings
= client_get_settings_state(self
);
298 /* the session should get the last say though */
299 client_restore_session_state(self
);
301 /* now we have all of the window's information so we can set this up */
302 client_setup_decor_and_functions(self
, FALSE
);
304 /* tell startup notification that this app started */
305 launch_time
= sn_app_started(self
->startup_id
, self
->class);
307 /* do this after we have a frame.. it uses the frame to help determine the
308 WM_STATE to apply. */
309 client_change_state(self
);
311 /* add ourselves to the focus order */
312 focus_order_add_new(self
);
314 /* do this to add ourselves to the stacking list in a non-intrusive way */
315 client_calc_layer(self
);
317 /* focus the new window? */
318 if (ob_state() != OB_STATE_STARTING
&&
319 (!self
->session
|| self
->session
->focused
) &&
320 /* this means focus=true for window is same as config_focus_new=true */
321 ((config_focus_new
|| (settings
&& settings
->focus
== 1)) ||
322 client_search_focus_tree_full(self
)) &&
323 /* this checks for focus=false for the window */
324 (!settings
|| settings
->focus
!= 0) &&
325 focus_valid_target(self
, FALSE
, FALSE
, TRUE
, FALSE
, FALSE
))
330 /* remove the client's border */
331 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
333 /* adjust the frame to the client's size before showing or placing
335 frame_adjust_area(self
->frame
, FALSE
, TRUE
, FALSE
);
336 frame_adjust_client_area(self
->frame
);
338 /* where the frame was placed is where the window was originally */
340 monitor
= screen_physical_area_monitor(screen_find_monitor(&place
));
342 /* figure out placement for the window if the window is new */
343 if (ob_state() == OB_STATE_RUNNING
) {
344 ob_debug("Positioned: %s @ %d %d\n",
345 (!self
->positioned
? "no" :
346 (self
->positioned
== PPosition
? "program specified" :
347 (self
->positioned
== USPosition
? "user specified" :
348 (self
->positioned
== (PPosition
| USPosition
) ?
349 "program + user specified" :
350 "BADNESS !?")))), place
.x
, place
.y
);
352 ob_debug("Sized: %s @ %d %d\n",
353 (!self
->sized
? "no" :
354 (self
->sized
== PSize
? "program specified" :
355 (self
->sized
== USSize
? "user specified" :
356 (self
->sized
== (PSize
| USSize
) ?
357 "program + user specified" :
358 "BADNESS !?")))), place
.width
, place
.height
);
360 /* splash screens are also returned as TRUE for transient,
361 and so will be forced on screen below */
362 transient
= place_client(self
, &place
.x
, &place
.y
, settings
);
364 /* make sure the window is visible. */
365 client_find_onscreen(self
, &place
.x
, &place
.y
,
366 place
.width
, place
.height
,
367 /* non-normal clients has less rules, and
368 windows that are being restored from a
369 session do also. we can assume you want
370 it back where you saved it. Clients saying
371 they placed themselves are subjected to
372 harder rules, ones that are placed by
373 place.c or by the user are allowed partially
374 off-screen and on xinerama divides (ie,
375 it is up to the placement routines to avoid
376 the xinerama divides)
378 splash screens get "transient" set to TRUE by
379 the place_client call
381 ob_state() == OB_STATE_RUNNING
&&
383 (!((self
->positioned
& USPosition
) ||
384 (settings
&& settings
->pos_given
)) &&
385 client_normal(self
) &&
387 /* don't move oldschool fullscreen windows to
388 fit inside the struts (fixes Acroread, which
389 makes its fullscreen window fit the screen
390 but it is not USSize'd or USPosition'd) */
391 !(self
->decorations
== 0 &&
392 RECT_EQUAL(place
, *monitor
)))));
395 /* if the window isn't user-sized, then make it fit inside
396 the visible screen area on its monitor. Use basically the same rules
397 for forcing the window on screen in the client_find_onscreen call.
399 do this after place_client, it chooses the monitor!
401 splash screens get "transient" set to TRUE by
402 the place_client call
404 if (ob_state() == OB_STATE_RUNNING
&&
406 (!(self
->sized
& USSize
|| self
->positioned
& USPosition
) &&
407 client_normal(self
) &&
409 /* don't shrink oldschool fullscreen windows to fit inside the
410 struts (fixes Acroread, which makes its fullscreen window
411 fit the screen but it is not USSize'd or USPosition'd) */
412 !(self
->decorations
== 0 && RECT_EQUAL(place
, *monitor
)))))
414 Rect
*a
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
, &place
);
416 /* get the size of the frame */
417 place
.width
+= self
->frame
->size
.left
+ self
->frame
->size
.right
;
418 place
.height
+= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
420 /* fit the window inside the area */
421 place
.width
= MIN(place
.width
, a
->width
);
422 place
.height
= MIN(place
.height
, a
->height
);
424 ob_debug("setting window size to %dx%d\n", place
.width
, place
.height
);
426 /* get the size of the client back */
427 place
.width
-= self
->frame
->size
.left
+ self
->frame
->size
.right
;
428 place
.height
-= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
433 ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
434 "some restrictions may apply\n",
435 self
->window
, place
.x
, place
.y
, place
.width
, place
.height
);
437 ob_debug(" but session requested %d, %d %d x %d instead, "
439 self
->session
->x
, self
->session
->y
,
440 self
->session
->w
, self
->session
->h
);
442 /* do this after the window is placed, so the premax/prefullscreen numbers
445 this also places the window
447 client_apply_startup_state(self
, place
.x
, place
.y
,
448 place
.width
, place
.height
);
454 gboolean raise
= FALSE
;
456 /* This is focus stealing prevention */
457 ob_debug_type(OB_DEBUG_FOCUS
,
458 "Want to focus new window 0x%x at time %u "
459 "launched at %u (last user interaction time %u)\n",
460 self
->window
, map_time
, launch_time
,
461 event_last_user_time
);
463 if (menu_frame_visible
|| moveresize_in_progress
) {
466 ob_debug_type(OB_DEBUG_FOCUS
,
467 "Not focusing the window because the user is inside "
468 "an Openbox menu or is move/resizing a window and "
469 "we don't want to interrupt them\n");
472 /* if it's on another desktop */
473 else if (!(self
->desktop
== screen_desktop
||
474 self
->desktop
== DESKTOP_ALL
) &&
475 /* the timestamp is from before you changed desktops */
476 launch_time
&& screen_desktop_user_time
&&
477 !event_time_after(launch_time
, screen_desktop_user_time
))
481 ob_debug_type(OB_DEBUG_FOCUS
,
482 "Not focusing the window because its on another "
485 /* If something is focused, and it's not our relative... */
486 else if (focus_client
&& client_search_focus_tree_full(self
) == NULL
&&
487 client_search_focus_group_full(self
) == NULL
)
489 /* If the user is working in another window right now, then don't
491 if (event_last_user_time
&& launch_time
&&
492 event_time_after(event_last_user_time
, launch_time
) &&
493 event_last_user_time
!= launch_time
&&
494 event_time_after(event_last_user_time
,
495 map_time
- OB_EVENT_USER_TIME_DELAY
))
498 ob_debug_type(OB_DEBUG_FOCUS
,
499 "Not focusing the window because the user is "
500 "working in another window\n");
502 /* If its a transient (and its parents aren't focused) */
503 else if (client_has_parent(self
)) {
505 ob_debug_type(OB_DEBUG_FOCUS
,
506 "Not focusing the window because it is a "
507 "transient, and its relatives aren't focused\n");
509 /* Don't steal focus from globally active clients.
510 I stole this idea from KWin. It seems nice.
512 else if (!(focus_client
->can_focus
||
513 focus_client
->focus_notify
))
516 ob_debug_type(OB_DEBUG_FOCUS
,
517 "Not focusing the window because a globally "
518 "active client has focus\n");
520 /* Don't move focus if it's not going to go to this window
522 else if (client_focus_target(self
) != self
) {
525 ob_debug_type(OB_DEBUG_FOCUS
,
526 "Not focusing the window because another window "
527 "would get the focus anyway\n");
529 else if (!(self
->desktop
== screen_desktop
||
530 self
->desktop
== DESKTOP_ALL
))
534 ob_debug_type(OB_DEBUG_FOCUS
,
535 "Not focusing the window because it is on "
536 "another desktop and no relatives are focused ");
541 ob_debug_type(OB_DEBUG_FOCUS
,
542 "Focus stealing prevention activated for %s at "
543 "time %u (last user interactioon time %u)\n",
544 self
->title
, map_time
, event_last_user_time
);
545 /* if the client isn't focused, then hilite it so the user
547 client_hilite(self
, TRUE
);
548 /* we may want to raise it even tho we're not activating it */
549 if (raise
&& !client_restore_session_stacking(self
))
550 stacking_raise(CLIENT_AS_WINDOW(self
));
554 /* This may look rather odd. Well it's because new windows are added
555 to the stacking order non-intrusively. If we're not going to focus
556 the new window or hilite it, then we raise it to the top. This will
557 take affect for things that don't get focused like splash screens.
558 Also if you don't have focus_new enabled, then it's going to get
559 raised to the top. Legacy begets legacy I guess?
561 if (!client_restore_session_stacking(self
))
562 stacking_raise(CLIENT_AS_WINDOW(self
));
565 mouse_grab_for_client(self
, TRUE
);
567 /* this has to happen before we try focus the window, but we want it to
568 happen after the client's stacking has been determined or it looks bad
572 if (!config_focus_under_mouse
)
573 ignore_start
= event_start_ignore_all_enters();
577 if (!config_focus_under_mouse
)
578 event_end_ignore_all_enters(ignore_start
);
582 gboolean stacked
= client_restore_session_stacking(self
);
583 client_present(self
, FALSE
, !stacked
, TRUE
);
586 /* add to client list/map */
587 client_list
= g_list_append(client_list
, self
);
588 g_hash_table_insert(window_map
, &self
->window
, self
);
590 /* this has to happen after we're in the client_list */
591 if (STRUT_EXISTS(self
->strut
))
592 screen_update_areas();
594 /* update the list hints */
597 /* free the ObAppSettings shallow copy */
600 ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
601 window
, self
->frame
->window
, self
->class);
607 ObClient
*client_fake_manage(Window window
)
610 ObAppSettings
*settings
;
612 ob_debug("Pretend-managing window: %lx\n", window
);
614 /* do this minimal stuff to figure out the client's decorations */
616 self
= g_new0(ObClient
, 1);
617 self
->window
= window
;
619 client_get_all(self
, FALSE
);
620 /* per-app settings override stuff, and return the settings for other
621 uses too. this returns a shallow copy that needs to be freed */
622 settings
= client_get_settings_state(self
);
624 client_setup_decor_and_functions(self
, FALSE
);
626 /* create the decoration frame for the client window and adjust its size */
627 self
->frame
= frame_new(self
);
628 frame_adjust_area(self
->frame
, FALSE
, TRUE
, TRUE
);
630 ob_debug("gave extents left %d right %d top %d bottom %d\n",
631 self
->frame
->size
.left
, self
->frame
->size
.right
,
632 self
->frame
->size
.top
, self
->frame
->size
.bottom
);
634 /* free the ObAppSettings shallow copy */
640 void client_unmanage_all(void)
642 while (client_list
!= NULL
)
643 client_unmanage(client_list
->data
);
646 void client_unmanage(ObClient
*self
)
652 ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
653 self
->window
, self
->frame
->window
,
654 self
->class, self
->title
? self
->title
: "");
656 g_assert(self
!= NULL
);
658 /* we dont want events no more. do this before hiding the frame so we
659 don't generate more events */
660 XSelectInput(ob_display
, self
->window
, NoEventMask
);
662 /* ignore enter events from the unmap so it doesnt mess with the focus */
663 if (!config_focus_under_mouse
)
664 ignore_start
= event_start_ignore_all_enters();
666 frame_hide(self
->frame
);
667 /* flush to send the hide to the server quickly */
670 if (!config_focus_under_mouse
)
671 event_end_ignore_all_enters(ignore_start
);
673 mouse_grab_for_client(self
, FALSE
);
675 /* remove the window from our save set */
676 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
678 /* update the focus lists */
679 focus_order_remove(self
);
680 if (client_focused(self
)) {
681 /* don't leave an invalid focus_client */
685 client_list
= g_list_remove(client_list
, self
);
686 stacking_remove(self
);
687 g_hash_table_remove(window_map
, &self
->window
);
689 /* once the client is out of the list, update the struts to remove its
691 if (STRUT_EXISTS(self
->strut
))
692 screen_update_areas();
694 client_call_notifies(self
, client_destroy_notifies
);
696 /* tell our parent(s) that we're gone */
697 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
698 ((ObClient
*)it
->data
)->transients
=
699 g_slist_remove(((ObClient
*)it
->data
)->transients
,self
);
701 /* tell our transients that we're gone */
702 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
703 ((ObClient
*)it
->data
)->parents
=
704 g_slist_remove(((ObClient
*)it
->data
)->parents
, self
);
705 /* we could be keeping our children in a higher layer */
706 client_calc_layer(it
->data
);
709 /* remove from its group */
711 group_remove(self
->group
, self
);
715 /* restore the window's original geometry so it is not lost */
721 if (self
->fullscreen
)
722 a
= self
->pre_fullscreen_area
;
723 else if (self
->max_horz
|| self
->max_vert
) {
724 if (self
->max_horz
) {
725 a
.x
= self
->pre_max_area
.x
;
726 a
.width
= self
->pre_max_area
.width
;
728 if (self
->max_vert
) {
729 a
.y
= self
->pre_max_area
.y
;
730 a
.height
= self
->pre_max_area
.height
;
734 self
->fullscreen
= self
->max_horz
= self
->max_vert
= FALSE
;
735 /* let it be moved and resized no matter what */
736 self
->functions
= OB_CLIENT_FUNC_MOVE
| OB_CLIENT_FUNC_RESIZE
;
737 self
->decorations
= 0; /* unmanaged windows have no decor */
739 /* give the client its border back */
740 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
742 client_move_resize(self
, a
.x
, a
.y
, a
.width
, a
.height
);
745 /* reparent the window out of the frame, and free the frame */
746 frame_release_client(self
->frame
);
747 frame_free(self
->frame
);
750 if (ob_state() != OB_STATE_EXITING
) {
751 /* these values should not be persisted across a window
753 PROP_ERASE(self
->window
, net_wm_desktop
);
754 PROP_ERASE(self
->window
, net_wm_state
);
755 PROP_ERASE(self
->window
, wm_state
);
757 /* if we're left in an unmapped state, the client wont be mapped.
758 this is bad, since we will no longer be managing the window on
760 XMapWindow(ob_display
, self
->window
);
763 /* update the list hints */
766 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
768 /* free all data allocated in the client struct */
769 g_slist_free(self
->transients
);
770 for (j
= 0; j
< self
->nicons
; ++j
)
771 g_free(self
->icons
[j
].data
);
772 if (self
->nicons
> 0)
774 g_free(self
->wm_command
);
776 g_free(self
->icon_title
);
780 g_free(self
->client_machine
);
781 g_free(self
->sm_client_id
);
785 void client_fake_unmanage(ObClient
*self
)
787 /* this is all that got allocated to get the decorations */
789 frame_free(self
->frame
);
793 /*! Returns a new structure containing the per-app settings for this client.
794 The returned structure needs to be freed with g_free. */
795 static ObAppSettings
*client_get_settings_state(ObClient
*self
)
797 ObAppSettings
*settings
;
800 settings
= config_create_app_settings();
802 for (it
= config_per_app_settings
; it
; it
= g_slist_next(it
)) {
803 ObAppSettings
*app
= it
->data
;
804 gboolean match
= TRUE
;
806 g_assert(app
->name
!= NULL
|| app
->class != NULL
);
808 /* we know that either name or class is not NULL so it will have to
809 match to use the rule */
811 !g_pattern_match(app
->name
, strlen(self
->name
), self
->name
, NULL
))
813 else if (app
->class &&
814 !g_pattern_match(app
->class,
815 strlen(self
->class), self
->class, NULL
))
817 else if (app
->role
&&
818 !g_pattern_match(app
->role
,
819 strlen(self
->role
), self
->role
, NULL
))
823 ob_debug("Window matching: %s\n", app
->name
);
825 /* copy the settings to our struct, overriding the existing
826 settings if they are not defaults */
827 config_app_settings_copy_non_defaults(app
, settings
);
831 if (settings
->shade
!= -1)
832 self
->shaded
= !!settings
->shade
;
833 if (settings
->decor
!= -1)
834 self
->undecorated
= !settings
->decor
;
835 if (settings
->iconic
!= -1)
836 self
->iconic
= !!settings
->iconic
;
837 if (settings
->skip_pager
!= -1)
838 self
->skip_pager
= !!settings
->skip_pager
;
839 if (settings
->skip_taskbar
!= -1)
840 self
->skip_taskbar
= !!settings
->skip_taskbar
;
842 if (settings
->max_vert
!= -1)
843 self
->max_vert
= !!settings
->max_vert
;
844 if (settings
->max_horz
!= -1)
845 self
->max_horz
= !!settings
->max_horz
;
847 if (settings
->fullscreen
!= -1)
848 self
->fullscreen
= !!settings
->fullscreen
;
850 if (settings
->desktop
) {
851 if (settings
->desktop
== DESKTOP_ALL
)
852 self
->desktop
= settings
->desktop
;
853 else if (settings
->desktop
> 0 &&
854 settings
->desktop
<= screen_num_desktops
)
855 self
->desktop
= settings
->desktop
- 1;
858 if (settings
->layer
== -1) {
862 else if (settings
->layer
== 0) {
866 else if (settings
->layer
== 1) {
873 static void client_restore_session_state(ObClient
*self
)
877 ob_debug_type(OB_DEBUG_SM
,
878 "Restore session for client %s\n", self
->title
);
880 if (!(it
= session_state_find(self
))) {
881 ob_debug_type(OB_DEBUG_SM
,
882 "Session data not found for client %s\n", self
->title
);
886 self
->session
= it
->data
;
888 ob_debug_type(OB_DEBUG_SM
, "Session data loaded for client %s\n",
891 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
892 self
->positioned
= USPosition
;
893 self
->sized
= USSize
;
894 if (self
->session
->w
> 0)
895 self
->area
.width
= self
->session
->w
;
896 if (self
->session
->h
> 0)
897 self
->area
.height
= self
->session
->h
;
898 XResizeWindow(ob_display
, self
->window
,
899 self
->area
.width
, self
->area
.height
);
901 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
902 self
->session
->desktop
:
903 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
904 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
906 self
->shaded
= self
->session
->shaded
;
907 self
->iconic
= self
->session
->iconic
;
908 self
->skip_pager
= self
->session
->skip_pager
;
909 self
->skip_taskbar
= self
->session
->skip_taskbar
;
910 self
->fullscreen
= self
->session
->fullscreen
;
911 self
->above
= self
->session
->above
;
912 self
->below
= self
->session
->below
;
913 self
->max_horz
= self
->session
->max_horz
;
914 self
->max_vert
= self
->session
->max_vert
;
915 self
->undecorated
= self
->session
->undecorated
;
918 static gboolean
client_restore_session_stacking(ObClient
*self
)
922 if (!self
->session
) return FALSE
;
924 mypos
= g_list_find(session_saved_state
, self
->session
);
925 if (!mypos
) return FALSE
;
927 /* start above me and look for the first client */
928 for (it
= g_list_previous(mypos
); it
; it
= g_list_previous(it
)) {
931 for (cit
= client_list
; cit
; cit
= g_list_next(cit
)) {
932 ObClient
*c
= cit
->data
;
933 /* found a client that was in the session, so go below it */
934 if (c
->session
== it
->data
) {
935 stacking_below(CLIENT_AS_WINDOW(self
),
936 CLIENT_AS_WINDOW(cit
->data
));
944 void client_move_onscreen(ObClient
*self
, gboolean rude
)
946 gint x
= self
->area
.x
;
947 gint y
= self
->area
.y
;
948 if (client_find_onscreen(self
, &x
, &y
,
950 self
->area
.height
, rude
)) {
951 client_move(self
, x
, y
);
955 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
958 gint ox
= *x
, oy
= *y
;
959 gboolean rudel
= rude
, ruder
= rude
, rudet
= rude
, rudeb
= rude
;
964 RECT_SET(desired
, *x
, *y
, w
, h
);
965 frame_rect_to_frame(self
->frame
, &desired
);
967 /* get where the frame would be */
968 frame_client_gravity(self
->frame
, x
, y
);
970 /* get the requested size of the window with decorations */
971 fw
= self
->frame
->size
.left
+ w
+ self
->frame
->size
.right
;
972 fh
= self
->frame
->size
.top
+ h
+ self
->frame
->size
.bottom
;
974 /* If rudeness wasn't requested, then still be rude in a given direction
975 if the client is not moving, only resizing in that direction */
977 Point oldtl
, oldtr
, oldbl
, oldbr
;
978 Point newtl
, newtr
, newbl
, newbr
;
979 gboolean stationary_l
, stationary_r
, stationary_t
, stationary_b
;
981 POINT_SET(oldtl
, self
->frame
->area
.x
, self
->frame
->area
.y
);
982 POINT_SET(oldbr
, self
->frame
->area
.x
+ self
->frame
->area
.width
- 1,
983 self
->frame
->area
.y
+ self
->frame
->area
.height
- 1);
984 POINT_SET(oldtr
, oldbr
.x
, oldtl
.y
);
985 POINT_SET(oldbl
, oldtl
.x
, oldbr
.y
);
987 POINT_SET(newtl
, *x
, *y
);
988 POINT_SET(newbr
, *x
+ fw
- 1, *y
+ fh
- 1);
989 POINT_SET(newtr
, newbr
.x
, newtl
.y
);
990 POINT_SET(newbl
, newtl
.x
, newbr
.y
);
992 /* is it moving or just resizing from some corner? */
993 stationary_l
= oldtl
.x
== newtl
.x
;
994 stationary_r
= oldtr
.x
== newtr
.x
;
995 stationary_t
= oldtl
.y
== newtl
.y
;
996 stationary_b
= oldbl
.y
== newbl
.y
;
998 /* if left edge is growing and didnt move right edge */
999 if (stationary_r
&& newtl
.x
< oldtl
.x
)
1001 /* if right edge is growing and didnt move left edge */
1002 if (stationary_l
&& newtr
.x
> oldtr
.x
)
1004 /* if top edge is growing and didnt move bottom edge */
1005 if (stationary_b
&& newtl
.y
< oldtl
.y
)
1007 /* if bottom edge is growing and didnt move top edge */
1008 if (stationary_t
&& newbl
.y
> oldbl
.y
)
1012 for (i
= 0; i
< screen_num_monitors
; ++i
) {
1015 if (!screen_physical_area_monitor_contains(i
, &desired
)) {
1016 if (i
< screen_num_monitors
- 1)
1019 /* the window is not inside any monitor! so just use the first
1021 a
= screen_area(self
->desktop
, 0, NULL
);
1023 a
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
, &desired
);
1025 /* This makes sure windows aren't entirely outside of the screen so you
1026 can't see them at all.
1027 It makes sure 10% of the window is on the screen at least. At don't
1028 let it move itself off the top of the screen, which would hide the
1029 titlebar on you. (The user can still do this if they want too, it's
1030 only limiting the application.
1032 if (client_normal(self
)) {
1033 if (!self
->strut
.right
&& *x
+ fw
/10 >= a
->x
+ a
->width
- 1)
1034 *x
= a
->x
+ a
->width
- fw
/10;
1035 if (!self
->strut
.bottom
&& *y
+ fh
/10 >= a
->y
+ a
->height
- 1)
1036 *y
= a
->y
+ a
->height
- fh
/10;
1037 if (!self
->strut
.left
&& *x
+ fw
*9/10 - 1 < a
->x
)
1038 *x
= a
->x
- fw
*9/10;
1039 if (!self
->strut
.top
&& *y
+ fh
*9/10 - 1 < a
->y
)
1040 *y
= a
->y
- fh
*9/10;
1043 /* This here doesn't let windows even a pixel outside the
1044 struts/screen. When called from client_manage, programs placing
1045 themselves are forced completely onscreen, while things like
1046 xterm -geometry resolution-width/2 will work fine. Trying to
1047 place it completely offscreen will be handled in the above code.
1048 Sorry for this confused comment, i am tired. */
1049 if (rudel
&& !self
->strut
.left
&& *x
< a
->x
) *x
= a
->x
;
1050 if (ruder
&& !self
->strut
.right
&& *x
+ fw
> a
->x
+ a
->width
)
1051 *x
= a
->x
+ MAX(0, a
->width
- fw
);
1053 if (rudet
&& !self
->strut
.top
&& *y
< a
->y
) *y
= a
->y
;
1054 if (rudeb
&& !self
->strut
.bottom
&& *y
+ fh
> a
->y
+ a
->height
)
1055 *y
= a
->y
+ MAX(0, a
->height
- fh
);
1060 /* get where the client should be */
1061 frame_frame_gravity(self
->frame
, x
, y
);
1063 return ox
!= *x
|| oy
!= *y
;
1066 static void client_get_all(ObClient
*self
, gboolean real
)
1068 /* this is needed for the frame to set itself up */
1069 client_get_area(self
);
1071 /* these things can change the decor and functions of the window */
1073 client_get_mwm_hints(self
);
1074 /* this can change the mwmhints for special cases */
1075 client_get_type_and_transientness(self
);
1076 client_get_state(self
);
1077 client_update_normal_hints(self
);
1079 /* get the session related properties, these can change decorations
1080 from per-app settings */
1081 client_get_session_ids(self
);
1083 /* now we got everything that can affect the decorations */
1087 /* get this early so we have it for debugging */
1088 client_update_title(self
);
1090 client_update_protocols(self
);
1092 client_update_wmhints(self
);
1093 /* this may have already been called from client_update_wmhints */
1094 if (!self
->parents
&& !self
->transient_for_group
)
1095 client_update_transient_for(self
);
1097 client_get_startup_id(self
);
1098 client_get_desktop(self
);/* uses transient data/group/startup id if a
1099 desktop is not specified */
1100 client_get_shaped(self
);
1103 /* a couple type-based defaults for new windows */
1105 /* this makes sure that these windows appear on all desktops */
1106 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
1107 self
->desktop
= DESKTOP_ALL
;
1111 client_update_sync_request_counter(self
);
1114 client_get_colormap(self
);
1115 client_update_strut(self
);
1116 client_update_icons(self
);
1117 client_update_icon_geometry(self
);
1120 static void client_get_startup_id(ObClient
*self
)
1122 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
1124 PROP_GETS(self
->group
->leader
,
1125 net_startup_id
, utf8
, &self
->startup_id
);
1128 static void client_get_area(ObClient
*self
)
1130 XWindowAttributes wattrib
;
1133 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1134 g_assert(ret
!= BadWindow
);
1136 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
1137 POINT_SET(self
->root_pos
, wattrib
.x
, wattrib
.y
);
1138 self
->border_width
= wattrib
.border_width
;
1140 ob_debug("client area: %d %d %d %d bw %d\n", wattrib
.x
, wattrib
.y
,
1141 wattrib
.width
, wattrib
.height
, wattrib
.border_width
);
1144 static void client_get_desktop(ObClient
*self
)
1146 guint32 d
= screen_num_desktops
; /* an always-invalid value */
1148 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
1149 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
1150 self
->desktop
= screen_num_desktops
- 1;
1153 ob_debug("client requested desktop 0x%x\n", self
->desktop
);
1156 gboolean first
= TRUE
;
1157 guint all
= screen_num_desktops
; /* not a valid value */
1159 /* if they are all on one desktop, then open it on the
1161 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
1162 ObClient
*c
= it
->data
;
1164 if (c
->desktop
== DESKTOP_ALL
) continue;
1170 else if (all
!= c
->desktop
)
1171 all
= screen_num_desktops
; /* make it invalid */
1173 if (all
!= screen_num_desktops
) {
1174 self
->desktop
= all
;
1176 ob_debug("client desktop set from parents: 0x%x\n",
1179 /* try get from the startup-notification protocol */
1180 else if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
1181 if (self
->desktop
>= screen_num_desktops
&&
1182 self
->desktop
!= DESKTOP_ALL
)
1183 self
->desktop
= screen_num_desktops
- 1;
1184 ob_debug("client desktop set from startup-notification: 0x%x\n",
1187 /* defaults to the current desktop */
1189 self
->desktop
= screen_desktop
;
1190 ob_debug("client desktop set to the current desktop: %d\n",
1196 static void client_get_state(ObClient
*self
)
1201 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
1203 for (i
= 0; i
< num
; ++i
) {
1204 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
1206 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
1207 self
->shaded
= TRUE
;
1208 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
1209 self
->iconic
= TRUE
;
1210 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
1211 self
->skip_taskbar
= TRUE
;
1212 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
1213 self
->skip_pager
= TRUE
;
1214 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
1215 self
->fullscreen
= TRUE
;
1216 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
1217 self
->max_vert
= TRUE
;
1218 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
1219 self
->max_horz
= TRUE
;
1220 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
1222 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
1224 else if (state
[i
] == prop_atoms
.net_wm_state_demands_attention
)
1225 self
->demands_attention
= TRUE
;
1226 else if (state
[i
] == prop_atoms
.ob_wm_state_undecorated
)
1227 self
->undecorated
= TRUE
;
1234 static void client_get_shaped(ObClient
*self
)
1236 self
->shaped
= FALSE
;
1238 if (extensions_shape
) {
1243 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
1245 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
1246 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
1248 self
->shaped
= (s
!= 0);
1253 void client_update_transient_for(ObClient
*self
)
1256 ObClient
*target
= NULL
;
1257 gboolean trangroup
= FALSE
;
1259 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
1260 if (t
!= self
->window
) { /* cant be transient to itself! */
1261 target
= g_hash_table_lookup(window_map
, &t
);
1262 /* if this happens then we need to check for it*/
1263 g_assert(target
!= self
);
1264 if (target
&& !WINDOW_IS_CLIENT(target
)) {
1265 /* this can happen when a dialog is a child of
1266 a dockapp, for example */
1271 /* Setting the transient_for to Root is actually illegal, however
1272 applications from time have done this to specify transient for
1274 if (!target
&& self
->group
&& t
== RootWindow(ob_display
, ob_screen
))
1276 } else if (self
->group
&& self
->transient
)
1279 client_update_transient_tree(self
, self
->group
, self
->group
,
1280 self
->transient_for_group
, trangroup
,
1281 client_direct_parent(self
), target
);
1282 self
->transient_for_group
= trangroup
;
1286 static void client_update_transient_tree(ObClient
*self
,
1287 ObGroup
*oldgroup
, ObGroup
*newgroup
,
1288 gboolean oldgtran
, gboolean newgtran
,
1289 ObClient
* oldparent
,
1290 ObClient
*newparent
)
1295 g_assert(!oldgtran
|| oldgroup
);
1296 g_assert(!newgtran
|| newgroup
);
1297 g_assert((!oldgtran
&& !oldparent
) ||
1298 (oldgtran
&& !oldparent
) ||
1299 (!oldgtran
&& oldparent
));
1300 g_assert((!newgtran
&& !newparent
) ||
1301 (newgtran
&& !newparent
) ||
1302 (!newgtran
&& newparent
));
1305 Group transient windows are not allowed to have other group
1306 transient windows as their children.
1310 /* No change has occured */
1311 if (oldgroup
== newgroup
&&
1312 oldgtran
== newgtran
&&
1313 oldparent
== newparent
) return;
1315 /** Remove the client from the transient tree **/
1317 for (it
= self
->transients
; it
; it
= next
) {
1318 next
= g_slist_next(it
);
1320 self
->transients
= g_slist_delete_link(self
->transients
, it
);
1321 c
->parents
= g_slist_remove(c
->parents
, self
);
1323 for (it
= self
->parents
; it
; it
= next
) {
1324 next
= g_slist_next(it
);
1326 self
->parents
= g_slist_delete_link(self
->parents
, it
);
1327 c
->transients
= g_slist_remove(c
->transients
, self
);
1330 /** Re-add the client to the transient tree **/
1332 /* If we're transient for a group then we need to add ourselves to all our
1335 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1338 !client_search_top_direct_parent(c
)->transient_for_group
&&
1341 c
->transients
= g_slist_prepend(c
->transients
, self
);
1342 self
->parents
= g_slist_prepend(self
->parents
, c
);
1347 /* If we are now transient for a single window we need to add ourselves to
1350 WARNING: Cyclical transient ness is possible if two windows are
1351 transient for eachother.
1353 else if (newparent
&&
1354 /* don't make ourself its child if it is already our child */
1355 !client_is_direct_child(self
, newparent
) &&
1356 client_normal(newparent
))
1358 newparent
->transients
= g_slist_prepend(newparent
->transients
, self
);
1359 self
->parents
= g_slist_prepend(self
->parents
, newparent
);
1362 /* Add any group transient windows to our children. But if we're transient
1363 for the group, then other group transients are not our children.
1365 WARNING: Cyclical transient-ness is possible. For e.g. if:
1366 A is transient for the group
1367 B is transient for A
1368 C is transient for B
1369 A can't be transient for C or we have a cycle
1371 if (!newgtran
&& newgroup
&&
1373 !client_search_top_direct_parent(newparent
)->transient_for_group
) &&
1374 client_normal(self
))
1376 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1378 if (c
!= self
&& c
->transient_for_group
&&
1379 /* Don't make it our child if it is already our parent */
1380 !client_is_direct_child(c
, self
))
1382 self
->transients
= g_slist_prepend(self
->transients
, c
);
1383 c
->parents
= g_slist_prepend(c
->parents
, self
);
1388 /** If we change our group transient-ness, our children change their
1389 effect group transient-ness, which affects how they relate to other
1392 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
1394 if (!c
->transient_for_group
)
1395 client_update_transient_tree(c
, c
->group
, c
->group
,
1396 c
->transient_for_group
,
1397 c
->transient_for_group
,
1398 client_direct_parent(c
),
1399 client_direct_parent(c
));
1403 static void client_get_mwm_hints(ObClient
*self
)
1408 self
->mwmhints
.flags
= 0; /* default to none */
1410 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
1412 if (num
>= OB_MWM_ELEMENTS
) {
1413 self
->mwmhints
.flags
= hints
[0];
1414 self
->mwmhints
.functions
= hints
[1];
1415 self
->mwmhints
.decorations
= hints
[2];
1421 void client_get_type_and_transientness(ObClient
*self
)
1428 self
->transient
= FALSE
;
1430 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1431 /* use the first value that we know about in the array */
1432 for (i
= 0; i
< num
; ++i
) {
1433 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1434 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1435 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1436 self
->type
= OB_CLIENT_TYPE_DOCK
;
1437 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1438 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1439 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1440 self
->type
= OB_CLIENT_TYPE_MENU
;
1441 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1442 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1443 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1444 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1445 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1446 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1447 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1448 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1449 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1450 /* prevent this window from getting any decor or
1452 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1453 OB_MWM_FLAG_DECORATIONS
);
1454 self
->mwmhints
.decorations
= 0;
1455 self
->mwmhints
.functions
= 0;
1457 if (self
->type
!= (ObClientType
) -1)
1458 break; /* grab the first legit type */
1463 if (XGetTransientForHint(ob_display
, self
->window
, &t
))
1464 self
->transient
= TRUE
;
1466 if (self
->type
== (ObClientType
) -1) {
1467 /*the window type hint was not set, which means we either classify
1468 ourself as a normal window or a dialog, depending on if we are a
1470 if (self
->transient
)
1471 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1473 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1476 /* then, based on our type, we can update our transientness.. */
1477 if (self
->type
== OB_CLIENT_TYPE_DIALOG
||
1478 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
1479 self
->type
== OB_CLIENT_TYPE_MENU
||
1480 self
->type
== OB_CLIENT_TYPE_UTILITY
)
1482 self
->transient
= TRUE
;
1486 void client_update_protocols(ObClient
*self
)
1489 guint num_return
, i
;
1491 self
->focus_notify
= FALSE
;
1492 self
->delete_window
= FALSE
;
1494 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1495 for (i
= 0; i
< num_return
; ++i
) {
1496 if (proto
[i
] == prop_atoms
.wm_delete_window
)
1497 /* this means we can request the window to close */
1498 self
->delete_window
= TRUE
;
1499 else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1500 /* if this protocol is requested, then the window will be
1501 notified whenever we want it to receive focus */
1502 self
->focus_notify
= TRUE
;
1504 else if (proto
[i
] == prop_atoms
.net_wm_sync_request
)
1505 /* if this protocol is requested, then resizing the
1506 window will be synchronized between the frame and the
1508 self
->sync_request
= TRUE
;
1516 void client_update_sync_request_counter(ObClient
*self
)
1520 if (PROP_GET32(self
->window
, net_wm_sync_request_counter
, cardinal
, &i
)) {
1521 self
->sync_counter
= i
;
1523 self
->sync_counter
= None
;
1527 void client_get_colormap(ObClient
*self
)
1529 XWindowAttributes wa
;
1531 if (XGetWindowAttributes(ob_display
, self
->window
, &wa
))
1532 client_update_colormap(self
, wa
.colormap
);
1535 void client_update_colormap(ObClient
*self
, Colormap colormap
)
1537 if (colormap
== self
->colormap
) return;
1539 ob_debug("Setting client %s colormap: 0x%x\n", self
->title
, colormap
);
1541 if (client_focused(self
)) {
1542 screen_install_colormap(self
, FALSE
); /* uninstall old one */
1543 self
->colormap
= colormap
;
1544 screen_install_colormap(self
, FALSE
); /* install new one */
1546 self
->colormap
= colormap
;
1549 void client_update_normal_hints(ObClient
*self
)
1555 self
->min_ratio
= 0.0f
;
1556 self
->max_ratio
= 0.0f
;
1557 SIZE_SET(self
->size_inc
, 1, 1);
1558 SIZE_SET(self
->base_size
, 0, 0);
1559 SIZE_SET(self
->min_size
, 0, 0);
1560 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1562 /* get the hints from the window */
1563 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1564 /* normal windows can't request placement! har har
1565 if (!client_normal(self))
1567 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1568 self
->sized
= (size
.flags
& (PSize
|USSize
));
1570 if (size
.flags
& PWinGravity
)
1571 self
->gravity
= size
.win_gravity
;
1573 if (size
.flags
& PAspect
) {
1574 if (size
.min_aspect
.y
)
1576 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1577 if (size
.max_aspect
.y
)
1579 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1582 if (size
.flags
& PMinSize
)
1583 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1585 if (size
.flags
& PMaxSize
)
1586 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1588 if (size
.flags
& PBaseSize
)
1589 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1591 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1592 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1594 ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n "
1595 "size inc (%d %d) base size (%d %d)\n",
1596 self
->min_size
.width
, self
->min_size
.height
,
1597 self
->max_size
.width
, self
->max_size
.height
,
1598 self
->size_inc
.width
, self
->size_inc
.height
,
1599 self
->base_size
.width
, self
->base_size
.height
);
1602 ob_debug("Normal hints: not set\n");
1605 void client_setup_decor_and_functions(ObClient
*self
, gboolean reconfig
)
1607 /* start with everything (cept fullscreen) */
1609 (OB_FRAME_DECOR_TITLEBAR
|
1610 OB_FRAME_DECOR_HANDLE
|
1611 OB_FRAME_DECOR_GRIPS
|
1612 OB_FRAME_DECOR_BORDER
|
1613 OB_FRAME_DECOR_ICON
|
1614 OB_FRAME_DECOR_ALLDESKTOPS
|
1615 OB_FRAME_DECOR_ICONIFY
|
1616 OB_FRAME_DECOR_MAXIMIZE
|
1617 OB_FRAME_DECOR_SHADE
|
1618 OB_FRAME_DECOR_CLOSE
);
1620 (OB_CLIENT_FUNC_RESIZE
|
1621 OB_CLIENT_FUNC_MOVE
|
1622 OB_CLIENT_FUNC_ICONIFY
|
1623 OB_CLIENT_FUNC_MAXIMIZE
|
1624 OB_CLIENT_FUNC_SHADE
|
1625 OB_CLIENT_FUNC_CLOSE
|
1626 OB_CLIENT_FUNC_BELOW
|
1627 OB_CLIENT_FUNC_ABOVE
|
1628 OB_CLIENT_FUNC_UNDECORATE
);
1630 if (!(self
->min_size
.width
< self
->max_size
.width
||
1631 self
->min_size
.height
< self
->max_size
.height
))
1632 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1634 switch (self
->type
) {
1635 case OB_CLIENT_TYPE_NORMAL
:
1636 /* normal windows retain all of the possible decorations and
1637 functionality, and can be fullscreen */
1638 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1641 case OB_CLIENT_TYPE_DIALOG
:
1642 /* sometimes apps make dialog windows fullscreen for some reason (for
1643 e.g. kpdf does this..) */
1644 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1647 case OB_CLIENT_TYPE_UTILITY
:
1648 /* these windows don't have anything added or removed by default */
1651 case OB_CLIENT_TYPE_MENU
:
1652 case OB_CLIENT_TYPE_TOOLBAR
:
1653 /* these windows can't iconify or maximize */
1654 self
->decorations
&= ~(OB_FRAME_DECOR_ICONIFY
|
1655 OB_FRAME_DECOR_MAXIMIZE
);
1656 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
|
1657 OB_CLIENT_FUNC_MAXIMIZE
);
1660 case OB_CLIENT_TYPE_SPLASH
:
1661 /* these don't get get any decorations, and the only thing you can
1662 do with them is move them */
1663 self
->decorations
= 0;
1664 self
->functions
= OB_CLIENT_FUNC_MOVE
;
1667 case OB_CLIENT_TYPE_DESKTOP
:
1668 /* these windows are not manipulated by the window manager */
1669 self
->decorations
= 0;
1670 self
->functions
= 0;
1673 case OB_CLIENT_TYPE_DOCK
:
1674 /* these windows are not manipulated by the window manager, but they
1675 can set below layer which has a special meaning */
1676 self
->decorations
= 0;
1677 self
->functions
= OB_CLIENT_FUNC_BELOW
;
1681 /* Mwm Hints are applied subtractively to what has already been chosen for
1682 decor and functionality */
1683 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1684 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1685 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1686 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1688 /* if the mwm hints request no handle or title, then all
1689 decorations are disabled, but keep the border if that's
1691 if (self
->mwmhints
.decorations
& OB_MWM_DECOR_BORDER
)
1692 self
->decorations
= OB_FRAME_DECOR_BORDER
;
1694 self
->decorations
= 0;
1699 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1700 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1701 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1702 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1703 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1704 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1705 /* dont let mwm hints kill any buttons
1706 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1707 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1708 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1709 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1711 /* dont let mwm hints kill the close button
1712 if (! (self->mwmhints.functions & MwmFunc_Close))
1713 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1717 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1718 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1719 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1720 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1721 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1722 self
->decorations
&= ~(OB_FRAME_DECOR_GRIPS
| OB_FRAME_DECOR_HANDLE
);
1724 /* can't maximize without moving/resizing */
1725 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1726 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1727 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1728 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1729 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1732 if (self
->max_horz
&& self
->max_vert
) {
1733 /* you can't resize fully maximized windows */
1734 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1735 /* kill the handle on fully maxed windows */
1736 self
->decorations
&= ~(OB_FRAME_DECOR_HANDLE
| OB_FRAME_DECOR_GRIPS
);
1739 /* If there are no decorations to remove, don't allow the user to try
1741 if (self
->decorations
== 0)
1742 self
->functions
&= ~OB_CLIENT_FUNC_UNDECORATE
;
1744 /* finally, the user can have requested no decorations, which overrides
1745 everything (but doesnt give it a border if it doesnt have one) */
1746 if (self
->undecorated
)
1747 self
->decorations
= 0;
1749 /* if we don't have a titlebar, then we cannot shade! */
1750 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1751 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1753 /* now we need to check against rules for the client's current state */
1754 if (self
->fullscreen
) {
1755 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1756 OB_CLIENT_FUNC_FULLSCREEN
|
1757 OB_CLIENT_FUNC_ICONIFY
);
1758 self
->decorations
= 0;
1761 client_change_allowed_actions(self
);
1764 /* force reconfigure to make sure decorations are updated */
1765 client_reconfigure(self
, TRUE
);
1768 static void client_change_allowed_actions(ObClient
*self
)
1773 /* desktop windows are kept on all desktops */
1774 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1775 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1777 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1778 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1779 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1780 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1781 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1782 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1783 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1784 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1785 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1786 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1787 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1788 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1789 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1790 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1791 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1793 if (self
->functions
& OB_CLIENT_FUNC_ABOVE
)
1794 actions
[num
++] = prop_atoms
.net_wm_action_above
;
1795 if (self
->functions
& OB_CLIENT_FUNC_BELOW
)
1796 actions
[num
++] = prop_atoms
.net_wm_action_below
;
1797 if (self
->functions
& OB_CLIENT_FUNC_UNDECORATE
)
1798 actions
[num
++] = prop_atoms
.ob_wm_action_undecorate
;
1800 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1802 /* make sure the window isn't breaking any rules now */
1804 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1805 if (self
->frame
) client_shade(self
, FALSE
);
1806 else self
->shaded
= FALSE
;
1808 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
) && self
->iconic
) {
1809 if (self
->frame
) client_iconify(self
, FALSE
, TRUE
, FALSE
);
1810 else self
->iconic
= FALSE
;
1812 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1813 if (self
->frame
) client_fullscreen(self
, FALSE
);
1814 else self
->fullscreen
= FALSE
;
1816 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1818 if (self
->frame
) client_maximize(self
, FALSE
, 0);
1819 else self
->max_vert
= self
->max_horz
= FALSE
;
1823 void client_update_wmhints(ObClient
*self
)
1827 /* assume a window takes input if it doesnt specify */
1828 self
->can_focus
= TRUE
;
1830 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1833 if (hints
->flags
& InputHint
)
1834 self
->can_focus
= hints
->input
;
1836 /* only do this when first managing the window *AND* when we aren't
1838 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1839 if (hints
->flags
& StateHint
)
1840 self
->iconic
= hints
->initial_state
== IconicState
;
1843 self
->urgent
= (hints
->flags
& XUrgencyHint
);
1844 if (self
->urgent
&& !ur
)
1845 client_hilite(self
, TRUE
);
1846 else if (!self
->urgent
&& ur
&& self
->demands_attention
)
1847 client_hilite(self
, FALSE
);
1849 if (!(hints
->flags
& WindowGroupHint
))
1850 hints
->window_group
= None
;
1852 /* did the group state change? */
1853 if (hints
->window_group
!=
1854 (self
->group
? self
->group
->leader
: None
))
1856 ObGroup
*oldgroup
= self
->group
;
1858 /* remove from the old group if there was one */
1859 if (self
->group
!= NULL
) {
1860 group_remove(self
->group
, self
);
1864 /* add ourself to the group if we have one */
1865 if (hints
->window_group
!= None
) {
1866 self
->group
= group_add(hints
->window_group
, self
);
1869 /* Put ourselves into the new group's transient tree, and remove
1870 ourselves from the old group's */
1871 client_update_transient_tree(self
, oldgroup
, self
->group
,
1872 self
->transient_for_group
,
1873 self
->transient_for_group
,
1874 client_direct_parent(self
),
1875 client_direct_parent(self
));
1877 /* Lastly, being in a group, or not, can change if the window is
1878 transient for anything.
1880 The logic for this is:
1881 self->transient = TRUE always if the window wants to be
1882 transient for something, even if transient_for was NULL because
1883 it wasn't in a group before.
1885 If parents was NULL and oldgroup was NULL we can assume
1886 that when we add the new group, it will become transient for
1889 If transient_for_group is TRUE, then it must have already
1890 had a group. If it is getting a new group, the above call to
1891 client_update_transient_tree has already taken care of
1892 everything ! If it is losing all group status then it will
1893 no longer be transient for anything and that needs to be
1896 if (self
->transient
&&
1897 ((self
->parents
== NULL
&& oldgroup
== NULL
) ||
1898 (self
->transient_for_group
&& !self
->group
)))
1899 client_update_transient_for(self
);
1902 /* the WM_HINTS can contain an icon */
1903 if (hints
->flags
& IconPixmapHint
)
1904 client_update_icons(self
);
1910 void client_update_title(ObClient
*self
)
1913 gchar
*visible
= NULL
;
1915 g_free(self
->title
);
1918 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
)) {
1919 /* try old x stuff */
1920 if (!(PROP_GETS(self
->window
, wm_name
, locale
, &data
)
1921 || PROP_GETS(self
->window
, wm_name
, utf8
, &data
))) {
1922 if (self
->transient
) {
1924 GNOME alert windows are not given titles:
1925 http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1927 data
= g_strdup("");
1929 data
= g_strdup("Unnamed Window");
1933 if (self
->client_machine
) {
1934 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
1939 PROP_SETS(self
->window
, net_wm_visible_name
, visible
);
1940 self
->title
= visible
;
1943 frame_adjust_title(self
->frame
);
1945 /* update the icon title */
1947 g_free(self
->icon_title
);
1950 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
1951 /* try old x stuff */
1952 if (!(PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
) ||
1953 PROP_GETS(self
->window
, wm_icon_name
, utf8
, &data
)))
1954 data
= g_strdup(self
->title
);
1956 if (self
->client_machine
) {
1957 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
1962 PROP_SETS(self
->window
, net_wm_visible_icon_name
, visible
);
1963 self
->icon_title
= visible
;
1966 void client_update_strut(ObClient
*self
)
1970 gboolean got
= FALSE
;
1973 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
1977 STRUT_PARTIAL_SET(strut
,
1978 data
[0], data
[2], data
[1], data
[3],
1979 data
[4], data
[5], data
[8], data
[9],
1980 data
[6], data
[7], data
[10], data
[11]);
1986 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
1992 /* use the screen's width/height */
1993 a
= screen_physical_area_all_monitors();
1995 STRUT_PARTIAL_SET(strut
,
1996 data
[0], data
[2], data
[1], data
[3],
1997 a
->y
, a
->y
+ a
->height
- 1,
1998 a
->x
, a
->x
+ a
->width
- 1,
1999 a
->y
, a
->y
+ a
->height
- 1,
2000 a
->x
, a
->x
+ a
->width
- 1);
2007 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
2008 0, 0, 0, 0, 0, 0, 0, 0);
2010 if (!STRUT_EQUAL(strut
, self
->strut
)) {
2011 self
->strut
= strut
;
2013 /* updating here is pointless while we're being mapped cuz we're not in
2014 the client list yet */
2016 screen_update_areas();
2020 void client_update_icons(ObClient
*self
)
2026 for (i
= 0; i
< self
->nicons
; ++i
)
2027 g_free(self
->icons
[i
].data
);
2028 if (self
->nicons
> 0)
2029 g_free(self
->icons
);
2032 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
2033 /* figure out how many valid icons are in here */
2035 while (num
- i
> 2) {
2039 if (i
> num
|| w
*h
== 0) break;
2043 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
2045 /* store the icons */
2047 for (j
= 0; j
< self
->nicons
; ++j
) {
2050 w
= self
->icons
[j
].width
= data
[i
++];
2051 h
= self
->icons
[j
].height
= data
[i
++];
2053 if (w
*h
== 0) continue;
2055 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
2056 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
2061 self
->icons
[j
].data
[t
] =
2062 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
2063 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
2064 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
2065 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
2074 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
2075 if (hints
->flags
& IconPixmapHint
) {
2077 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
2078 xerror_set_ignore(TRUE
);
2079 if (!RrPixmapToRGBA(ob_rr_inst
,
2081 (hints
->flags
& IconMaskHint
?
2082 hints
->icon_mask
: None
),
2083 &self
->icons
[0].width
,
2084 &self
->icons
[0].height
,
2085 &self
->icons
[0].data
))
2087 g_free(self
->icons
);
2090 xerror_set_ignore(FALSE
);
2096 /* set the default icon onto the window
2097 in theory, this could be a race, but if a window doesn't set an icon
2098 or removes it entirely, it's not very likely it is going to set one
2099 right away afterwards
2101 if it has parents, then one of them will have an icon already
2103 if (self
->nicons
== 0 && !self
->parents
) {
2104 RrPixel32
*icon
= ob_rr_theme
->def_win_icon
;
2107 data
= g_new(gulong
, 48*48+2);
2108 data
[0] = data
[1] = 48;
2109 for (i
= 0; i
< 48*48; ++i
)
2110 data
[i
+2] = (((icon
[i
] >> RrDefaultAlphaOffset
) & 0xff) << 24) +
2111 (((icon
[i
] >> RrDefaultRedOffset
) & 0xff) << 16) +
2112 (((icon
[i
] >> RrDefaultGreenOffset
) & 0xff) << 8) +
2113 (((icon
[i
] >> RrDefaultBlueOffset
) & 0xff) << 0);
2114 PROP_SETA32(self
->window
, net_wm_icon
, cardinal
, data
, 48*48+2);
2116 } else if (self
->frame
)
2117 /* don't draw the icon empty if we're just setting one now anyways,
2118 we'll get the property change any second */
2119 frame_adjust_icon(self
->frame
);
2122 void client_update_icon_geometry(ObClient
*self
)
2127 RECT_SET(self
->icon_geometry
, 0, 0, 0, 0);
2129 if (PROP_GETA32(self
->window
, net_wm_icon_geometry
, cardinal
, &data
, &num
)
2132 /* don't let them set it with an area < 0 */
2133 RECT_SET(self
->icon_geometry
, data
[0], data
[1],
2134 MAX(data
[2],0), MAX(data
[3],0));
2138 static void client_get_session_ids(ObClient
*self
)
2145 if (!PROP_GET32(self
->window
, wm_client_leader
, window
, &leader
))
2148 /* get the SM_CLIENT_ID */
2151 got
= PROP_GETS(leader
, sm_client_id
, locale
, &self
->sm_client_id
);
2153 PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
);
2155 /* get the WM_CLASS (name and class). make them "" if they are not
2159 got
= PROP_GETSS(leader
, wm_class
, locale
, &ss
);
2161 got
= PROP_GETSS(self
->window
, wm_class
, locale
, &ss
);
2165 self
->name
= g_strdup(ss
[0]);
2167 self
->class = g_strdup(ss
[1]);
2172 if (self
->name
== NULL
) self
->name
= g_strdup("");
2173 if (self
->class == NULL
) self
->class = g_strdup("");
2175 /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2178 got
= PROP_GETS(leader
, wm_window_role
, locale
, &s
);
2180 got
= PROP_GETS(self
->window
, wm_window_role
, locale
, &s
);
2185 self
->role
= g_strdup("");
2187 /* get the WM_COMMAND */
2191 got
= PROP_GETSS(leader
, wm_command
, locale
, &ss
);
2193 got
= PROP_GETSS(self
->window
, wm_command
, locale
, &ss
);
2196 /* merge/mash them all together */
2197 gchar
*merge
= NULL
;
2200 for (i
= 0; ss
[i
]; ++i
) {
2203 merge
= g_strconcat(merge
, ss
[i
], NULL
);
2205 merge
= g_strconcat(ss
[i
], NULL
);
2210 self
->wm_command
= merge
;
2213 /* get the WM_CLIENT_MACHINE */
2216 got
= PROP_GETS(leader
, wm_client_machine
, locale
, &s
);
2218 got
= PROP_GETS(self
->window
, wm_client_machine
, locale
, &s
);
2221 gchar localhost
[128];
2223 gethostname(localhost
, 127);
2224 localhost
[127] = '\0';
2225 if (strcmp(localhost
, s
) != 0)
2226 self
->client_machine
= s
;
2232 static void client_change_wm_state(ObClient
*self
)
2237 old
= self
->wmstate
;
2239 if (self
->shaded
|| self
->iconic
||
2240 (self
->desktop
!= DESKTOP_ALL
&& self
->desktop
!= screen_desktop
))
2242 self
->wmstate
= IconicState
;
2244 self
->wmstate
= NormalState
;
2246 if (old
!= self
->wmstate
) {
2247 PROP_MSG(self
->window
, kde_wm_change_state
,
2248 self
->wmstate
, 1, 0, 0);
2250 state
[0] = self
->wmstate
;
2252 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
2256 static void client_change_state(ObClient
*self
)
2258 gulong netstate
[12];
2263 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
2265 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
2267 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
2268 if (self
->skip_taskbar
)
2269 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
2270 if (self
->skip_pager
)
2271 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
2272 if (self
->fullscreen
)
2273 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
2275 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
2277 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
2279 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
2281 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
2282 if (self
->demands_attention
)
2283 netstate
[num
++] = prop_atoms
.net_wm_state_demands_attention
;
2284 if (self
->undecorated
)
2285 netstate
[num
++] = prop_atoms
.ob_wm_state_undecorated
;
2286 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
2289 frame_adjust_state(self
->frame
);
2292 ObClient
*client_search_focus_tree(ObClient
*self
)
2297 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2298 if (client_focused(it
->data
)) return it
->data
;
2299 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
2304 ObClient
*client_search_focus_tree_full(ObClient
*self
)
2306 if (self
->parents
) {
2309 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
2310 ObClient
*c
= it
->data
;
2311 if ((c
= client_search_focus_tree_full(it
->data
))) return c
;
2317 /* this function checks the whole tree, the client_search_focus_tree
2318 does not, so we need to check this window */
2319 if (client_focused(self
))
2321 return client_search_focus_tree(self
);
2325 ObClient
*client_search_focus_group_full(ObClient
*self
)
2330 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
2331 ObClient
*c
= it
->data
;
2333 if (client_focused(c
)) return c
;
2334 if ((c
= client_search_focus_tree(it
->data
))) return c
;
2337 if (client_focused(self
)) return self
;
2341 gboolean
client_has_parent(ObClient
*self
)
2343 return self
->parents
!= NULL
;
2346 static ObStackingLayer
calc_layer(ObClient
*self
)
2351 monitor
= screen_physical_area_monitor(client_monitor(self
));
2353 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
2354 l
= OB_STACKING_LAYER_DESKTOP
;
2355 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
2356 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
2357 else l
= OB_STACKING_LAYER_ABOVE
;
2359 else if ((self
->fullscreen
||
2360 /* No decorations and fills the monitor = oldskool fullscreen.
2361 But not for maximized windows.
2363 (self
->decorations
== 0 &&
2364 !(self
->max_horz
&& self
->max_vert
) &&
2365 RECT_EQUAL(self
->area
, *monitor
))) &&
2366 (client_focused(self
) || client_search_focus_tree(self
)))
2367 l
= OB_STACKING_LAYER_FULLSCREEN
;
2368 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
2369 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
2370 else l
= OB_STACKING_LAYER_NORMAL
;
2377 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
2378 ObStackingLayer min
)
2380 ObStackingLayer old
, own
;
2384 own
= calc_layer(self
);
2385 self
->layer
= MAX(own
, min
);
2387 if (self
->layer
!= old
) {
2388 stacking_remove(CLIENT_AS_WINDOW(self
));
2389 stacking_add_nonintrusive(CLIENT_AS_WINDOW(self
));
2392 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2393 client_calc_layer_recursive(it
->data
, orig
,
2397 void client_calc_layer(ObClient
*self
)
2404 /* transients take on the layer of their parents */
2405 it
= client_search_all_top_parents(self
);
2407 for (; it
; it
= g_slist_next(it
))
2408 client_calc_layer_recursive(it
->data
, orig
, 0);
2411 gboolean
client_should_show(ObClient
*self
)
2415 if (client_normal(self
) && screen_showing_desktop
)
2417 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
2423 gboolean
client_show(ObClient
*self
)
2425 gboolean show
= FALSE
;
2427 if (client_should_show(self
)) {
2428 frame_show(self
->frame
);
2431 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2432 it needs to be in IconicState. This includes when it is on another
2435 client_change_wm_state(self
);
2440 gboolean
client_hide(ObClient
*self
)
2442 gboolean hide
= FALSE
;
2444 if (!client_should_show(self
)) {
2445 if (self
== focus_client
) {
2446 /* if there is a grab going on, then we need to cancel it. if we
2447 move focus during the grab, applications will get
2448 NotifyWhileGrabbed events and ignore them !
2450 actions should not rely on being able to move focus during an
2453 event_cancel_all_key_grabs();
2456 /* We don't need to ignore enter events here.
2457 The window can hide/iconify in 3 different ways:
2458 1 - through an x message. in this case we ignore all enter events
2459 caused by responding to the x message (unless underMouse)
2460 2 - by a keyboard action. in this case we ignore all enter events
2461 caused by the action
2462 3 - by a mouse action. in this case they are doing stuff with the
2463 mouse and focus _should_ move.
2465 Also in action_end, we simulate an enter event that can't be ignored
2466 so trying to ignore them is futile in case 3 anyways
2469 frame_hide(self
->frame
);
2472 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2473 it needs to be in IconicState. This includes when it is on another
2476 client_change_wm_state(self
);
2481 void client_showhide(ObClient
*self
)
2483 if (!client_show(self
))
2487 gboolean
client_normal(ObClient
*self
) {
2488 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
2489 self
->type
== OB_CLIENT_TYPE_DOCK
||
2490 self
->type
== OB_CLIENT_TYPE_SPLASH
);
2493 gboolean
client_helper(ObClient
*self
)
2495 return (self
->type
== OB_CLIENT_TYPE_UTILITY
||
2496 self
->type
== OB_CLIENT_TYPE_MENU
||
2497 self
->type
== OB_CLIENT_TYPE_TOOLBAR
);
2500 gboolean
client_mouse_focusable(ObClient
*self
)
2502 return !(self
->type
== OB_CLIENT_TYPE_MENU
||
2503 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
2504 self
->type
== OB_CLIENT_TYPE_SPLASH
||
2505 self
->type
== OB_CLIENT_TYPE_DOCK
);
2508 gboolean
client_enter_focusable(ObClient
*self
)
2510 /* you can focus desktops but it shouldn't on enter */
2511 return (client_mouse_focusable(self
) &&
2512 self
->type
!= OB_CLIENT_TYPE_DESKTOP
);
2516 static void client_apply_startup_state(ObClient
*self
,
2517 gint x
, gint y
, gint w
, gint h
)
2519 /* save the states that we are going to apply */
2520 gboolean iconic
= self
->iconic
;
2521 gboolean fullscreen
= self
->fullscreen
;
2522 gboolean undecorated
= self
->undecorated
;
2523 gboolean shaded
= self
->shaded
;
2524 gboolean demands_attention
= self
->demands_attention
;
2525 gboolean max_horz
= self
->max_horz
;
2526 gboolean max_vert
= self
->max_vert
;
2530 /* turn them all off in the client, so they won't affect the window
2532 self
->iconic
= self
->fullscreen
= self
->undecorated
= self
->shaded
=
2533 self
->demands_attention
= self
->max_horz
= self
->max_vert
= FALSE
;
2535 /* move the client to its placed position, or it it's already there,
2536 generate a ConfigureNotify telling the client where it is.
2538 do this after adjusting the frame. otherwise it gets all weird and
2539 clients don't work right
2541 do this before applying the states so they have the correct
2542 pre-max/pre-fullscreen values
2544 client_try_configure(self
, &x
, &y
, &w
, &h
, &l
, &l
, FALSE
);
2545 ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2546 self
->window
, x
, y
, w
, h
);
2547 /* save the area, and make it where it should be for the premax stuff */
2548 oldarea
= self
->area
;
2549 RECT_SET(self
->area
, x
, y
, w
, h
);
2551 /* apply the states. these are in a carefully crafted order.. */
2554 client_iconify(self
, TRUE
, FALSE
, TRUE
);
2556 client_fullscreen(self
, TRUE
);
2558 client_set_undecorated(self
, TRUE
);
2560 client_shade(self
, TRUE
);
2561 if (demands_attention
)
2562 client_hilite(self
, TRUE
);
2564 if (max_vert
&& max_horz
)
2565 client_maximize(self
, TRUE
, 0);
2567 client_maximize(self
, TRUE
, 2);
2569 client_maximize(self
, TRUE
, 1);
2571 /* if the window hasn't been configured yet, then do so now, in fact the
2572 x,y,w,h may _not_ be the same as the area rect, which can end up
2573 meaning that the client isn't properly moved/resized by the fullscreen
2575 pho can cause this because it maps at size of the screen but not 0,0
2576 so openbox moves it on screen to 0,0 (thus x,y=0,0 and area.x,y don't).
2577 then fullscreen'ing makes it go to 0,0 which it thinks it already is at
2578 cuz thats where the pre-fullscreen will be. however the actual area is
2579 not, so this needs to be called even if we have fullscreened/maxed
2581 self
->area
= oldarea
;
2582 client_configure(self
, x
, y
, w
, h
, FALSE
, TRUE
, FALSE
);
2584 /* set the desktop hint, to make sure that it always exists */
2585 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
2587 /* nothing to do for the other states:
2596 void client_gravity_resize_w(ObClient
*self
, gint
*x
, gint oldw
, gint neww
)
2598 /* these should be the current values. this is for when you're not moving,
2600 g_assert(*x
== self
->area
.x
);
2601 g_assert(oldw
== self
->area
.width
);
2604 switch (self
->gravity
) {
2606 case NorthWestGravity
:
2608 case SouthWestGravity
:
2615 *x
-= (neww
- oldw
) / 2;
2617 case NorthEastGravity
:
2619 case SouthEastGravity
:
2625 void client_gravity_resize_h(ObClient
*self
, gint
*y
, gint oldh
, gint newh
)
2627 /* these should be the current values. this is for when you're not moving,
2629 g_assert(*y
== self
->area
.y
);
2630 g_assert(oldh
== self
->area
.height
);
2633 switch (self
->gravity
) {
2635 case NorthWestGravity
:
2637 case NorthEastGravity
:
2644 *y
-= (newh
- oldh
) / 2;
2646 case SouthWestGravity
:
2648 case SouthEastGravity
:
2654 void client_try_configure(ObClient
*self
, gint
*x
, gint
*y
, gint
*w
, gint
*h
,
2655 gint
*logicalw
, gint
*logicalh
,
2658 Rect desired
= {*x
, *y
, *w
, *h
};
2659 frame_rect_to_frame(self
->frame
, &desired
);
2661 /* make the frame recalculate its dimentions n shit without changing
2662 anything visible for real, this way the constraints below can work with
2663 the updated frame dimensions. */
2664 frame_adjust_area(self
->frame
, FALSE
, TRUE
, TRUE
);
2666 /* gets the frame's position */
2667 frame_client_gravity(self
->frame
, x
, y
);
2669 /* these positions are frame positions, not client positions */
2671 /* set the size and position if fullscreen */
2672 if (self
->fullscreen
) {
2676 i
= screen_find_monitor(&desired
);
2677 a
= screen_physical_area_monitor(i
);
2684 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2688 } else if (self
->max_horz
|| self
->max_vert
) {
2692 /* use all possible struts when maximizing to the full screen */
2693 i
= screen_find_monitor(&desired
);
2694 a
= screen_area(self
->desktop
, i
,
2695 (self
->max_horz
&& self
->max_vert
? NULL
: &desired
));
2697 /* set the size and position if maximized */
2698 if (self
->max_horz
) {
2700 *w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2702 if (self
->max_vert
) {
2704 *h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2707 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2713 /* gets the client's position */
2714 frame_frame_gravity(self
->frame
, x
, y
);
2716 /* work within the prefered sizes given by the window */
2717 if (!(*w
== self
->area
.width
&& *h
== self
->area
.height
)) {
2718 gint basew
, baseh
, minw
, minh
;
2720 gfloat minratio
, maxratio
;
2722 incw
= self
->fullscreen
|| self
->max_horz
? 1 : self
->size_inc
.width
;
2723 inch
= self
->fullscreen
|| self
->max_vert
? 1 : self
->size_inc
.height
;
2724 minratio
= self
->fullscreen
|| (self
->max_horz
&& self
->max_vert
) ?
2725 0 : self
->min_ratio
;
2726 maxratio
= self
->fullscreen
|| (self
->max_horz
&& self
->max_vert
) ?
2727 0 : self
->max_ratio
;
2729 /* base size is substituted with min size if not specified */
2730 if (self
->base_size
.width
|| self
->base_size
.height
) {
2731 basew
= self
->base_size
.width
;
2732 baseh
= self
->base_size
.height
;
2734 basew
= self
->min_size
.width
;
2735 baseh
= self
->min_size
.height
;
2737 /* min size is substituted with base size if not specified */
2738 if (self
->min_size
.width
|| self
->min_size
.height
) {
2739 minw
= self
->min_size
.width
;
2740 minh
= self
->min_size
.height
;
2742 minw
= self
->base_size
.width
;
2743 minh
= self
->base_size
.height
;
2746 /* if this is a user-requested resize, then check against min/max
2749 /* smaller than min size or bigger than max size? */
2750 if (*w
> self
->max_size
.width
) *w
= self
->max_size
.width
;
2751 if (*w
< minw
) *w
= minw
;
2752 if (*h
> self
->max_size
.height
) *h
= self
->max_size
.height
;
2753 if (*h
< minh
) *h
= minh
;
2758 /* keep to the increments */
2762 /* you cannot resize to nothing */
2763 if (basew
+ *w
< 1) *w
= 1 - basew
;
2764 if (baseh
+ *h
< 1) *h
= 1 - baseh
;
2766 /* save the logical size */
2767 *logicalw
= incw
> 1 ? *w
: *w
+ basew
;
2768 *logicalh
= inch
> 1 ? *h
: *h
+ baseh
;
2776 /* adjust the height to match the width for the aspect ratios.
2777 for this, min size is not substituted for base size ever. */
2778 *w
-= self
->base_size
.width
;
2779 *h
-= self
->base_size
.height
;
2782 if (*h
* minratio
> *w
) {
2783 *h
= (gint
)(*w
/ minratio
);
2785 /* you cannot resize to nothing */
2788 *w
= (gint
)(*h
* minratio
);
2792 if (*h
* maxratio
< *w
) {
2793 *h
= (gint
)(*w
/ maxratio
);
2795 /* you cannot resize to nothing */
2798 *w
= (gint
)(*h
* minratio
);
2802 *w
+= self
->base_size
.width
;
2803 *h
+= self
->base_size
.height
;
2806 /* these override the above states! if you cant move you can't move! */
2808 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2812 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2813 *w
= self
->area
.width
;
2814 *h
= self
->area
.height
;
2823 void client_configure(ObClient
*self
, gint x
, gint y
, gint w
, gint h
,
2824 gboolean user
, gboolean final
, gboolean force_reply
)
2827 gboolean send_resize_client
;
2828 gboolean moved
= FALSE
, resized
= FALSE
, rootmoved
= FALSE
;
2829 gboolean fmoved
, fresized
;
2830 guint fdecor
= self
->frame
->decorations
;
2831 gboolean fhorz
= self
->frame
->max_horz
;
2832 gboolean fvert
= self
->frame
->max_vert
;
2833 gint logicalw
, logicalh
;
2835 /* find the new x, y, width, and height (and logical size) */
2836 client_try_configure(self
, &x
, &y
, &w
, &h
, &logicalw
, &logicalh
, user
);
2838 /* set the logical size if things changed */
2839 if (!(w
== self
->area
.width
&& h
== self
->area
.height
))
2840 SIZE_SET(self
->logical_size
, logicalw
, logicalh
);
2842 /* figure out if we moved or resized or what */
2843 moved
= (x
!= self
->area
.x
|| y
!= self
->area
.y
);
2844 resized
= (w
!= self
->area
.width
|| h
!= self
->area
.height
);
2846 oldw
= self
->area
.width
;
2847 oldh
= self
->area
.height
;
2848 RECT_SET(self
->area
, x
, y
, w
, h
);
2850 /* for app-requested resizes, always resize if 'resized' is true.
2851 for user-requested ones, only resize if final is true, or when
2852 resizing in redraw mode */
2853 send_resize_client
= ((!user
&& resized
) ||
2855 (resized
&& config_resize_redraw
))));
2857 /* if the client is enlarging, then resize the client before the frame */
2858 if (send_resize_client
&& (w
> oldw
|| h
> oldh
)) {
2859 XMoveResizeWindow(ob_display
, self
->window
,
2860 self
->frame
->size
.left
, self
->frame
->size
.top
,
2861 MAX(w
, oldw
), MAX(h
, oldh
));
2862 frame_adjust_client_area(self
->frame
);
2865 /* find the frame's dimensions and move/resize it */
2869 /* if decorations changed, then readjust everything for the frame */
2870 if (self
->decorations
!= fdecor
||
2871 self
->max_horz
!= fhorz
|| self
->max_vert
!= fvert
)
2873 fmoved
= fresized
= TRUE
;
2876 /* adjust the frame */
2877 if (fmoved
|| fresized
) {
2878 gulong ignore_start
;
2880 ignore_start
= event_start_ignore_all_enters();
2882 frame_adjust_area(self
->frame
, fmoved
, fresized
, FALSE
);
2885 event_end_ignore_all_enters(ignore_start
);
2888 if (!user
|| final
) {
2889 gint oldrx
= self
->root_pos
.x
;
2890 gint oldry
= self
->root_pos
.y
;
2891 /* we have reset the client to 0 border width, so don't include
2892 it in these coords */
2893 POINT_SET(self
->root_pos
,
2894 self
->frame
->area
.x
+ self
->frame
->size
.left
-
2896 self
->frame
->area
.y
+ self
->frame
->size
.top
-
2897 self
->border_width
);
2898 if (self
->root_pos
.x
!= oldrx
|| self
->root_pos
.y
!= oldry
)
2902 /* This is kinda tricky and should not be changed.. let me explain!
2904 When user = FALSE, then the request is coming from the application
2905 itself, and we are more strict about when to send a synthetic
2906 ConfigureNotify. We strictly follow the rules of the ICCCM sec 4.1.5
2907 in this case (if force_reply is true)
2909 When user = TRUE, then the request is coming from "us", like when we
2910 maximize a window or something. In this case we are more lenient. We
2911 used to follow the same rules as above, but _Java_ Swing can't handle
2912 this. So just to appease Swing, when user = TRUE, we always send
2913 a synthetic ConfigureNotify to give the window its root coordinates.
2915 if ((!user
&& !resized
&& (rootmoved
|| force_reply
)) ||
2916 (user
&& final
&& rootmoved
))
2920 event
.type
= ConfigureNotify
;
2921 event
.xconfigure
.display
= ob_display
;
2922 event
.xconfigure
.event
= self
->window
;
2923 event
.xconfigure
.window
= self
->window
;
2925 ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
2926 self
->title
, self
->root_pos
.x
, self
->root_pos
.y
, w
, h
);
2928 /* root window real coords */
2929 event
.xconfigure
.x
= self
->root_pos
.x
;
2930 event
.xconfigure
.y
= self
->root_pos
.y
;
2931 event
.xconfigure
.width
= w
;
2932 event
.xconfigure
.height
= h
;
2933 event
.xconfigure
.border_width
= self
->border_width
;
2934 event
.xconfigure
.above
= None
;
2935 event
.xconfigure
.override_redirect
= FALSE
;
2936 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
2937 FALSE
, StructureNotifyMask
, &event
);
2940 /* if the client is shrinking, then resize the frame before the client.
2942 both of these resize sections may run, because the top one only resizes
2943 in the direction that is growing
2945 if (send_resize_client
&& (w
<= oldw
|| h
<= oldh
)) {
2946 frame_adjust_client_area(self
->frame
);
2947 XMoveResizeWindow(ob_display
, self
->window
,
2948 self
->frame
->size
.left
, self
->frame
->size
.top
, w
, h
);
2954 void client_fullscreen(ObClient
*self
, gboolean fs
)
2958 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
2959 self
->fullscreen
== fs
) return; /* already done */
2961 self
->fullscreen
= fs
;
2962 client_change_state(self
); /* change the state hints on the client */
2965 self
->pre_fullscreen_area
= self
->area
;
2966 /* if the window is maximized, its area isn't all that meaningful.
2967 save it's premax area instead. */
2968 if (self
->max_horz
) {
2969 self
->pre_fullscreen_area
.x
= self
->pre_max_area
.x
;
2970 self
->pre_fullscreen_area
.width
= self
->pre_max_area
.width
;
2972 if (self
->max_vert
) {
2973 self
->pre_fullscreen_area
.y
= self
->pre_max_area
.y
;
2974 self
->pre_fullscreen_area
.height
= self
->pre_max_area
.height
;
2977 /* these will help configure_full figure out where to fullscreen
2981 w
= self
->area
.width
;
2982 h
= self
->area
.height
;
2984 g_assert(self
->pre_fullscreen_area
.width
> 0 &&
2985 self
->pre_fullscreen_area
.height
> 0);
2987 x
= self
->pre_fullscreen_area
.x
;
2988 y
= self
->pre_fullscreen_area
.y
;
2989 w
= self
->pre_fullscreen_area
.width
;
2990 h
= self
->pre_fullscreen_area
.height
;
2991 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
2994 ob_debug("Window %s going fullscreen (%d)\n",
2995 self
->title
, self
->fullscreen
);
2997 client_setup_decor_and_functions(self
, FALSE
);
2998 client_move_resize(self
, x
, y
, w
, h
);
3000 /* and adjust our layer/stacking. do this after resizing the window,
3001 and applying decorations, because windows which fill the screen are
3002 considered "fullscreen" and it affects their layer */
3003 client_calc_layer(self
);
3006 /* try focus us when we go into fullscreen mode */
3011 static void client_iconify_recursive(ObClient
*self
,
3012 gboolean iconic
, gboolean curdesk
,
3013 gboolean hide_animation
)
3016 gboolean changed
= FALSE
;
3019 if (self
->iconic
!= iconic
) {
3020 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
3024 /* don't let non-normal windows iconify along with their parents
3026 if (client_normal(self
)) {
3027 self
->iconic
= iconic
;
3029 /* update the focus lists.. iconic windows go to the bottom of
3031 focus_order_to_bottom(self
);
3036 self
->iconic
= iconic
;
3038 if (curdesk
&& self
->desktop
!= screen_desktop
&&
3039 self
->desktop
!= DESKTOP_ALL
)
3040 client_set_desktop(self
, screen_desktop
, FALSE
, FALSE
);
3042 /* this puts it after the current focused window */
3043 focus_order_remove(self
);
3044 focus_order_add_new(self
);
3051 client_change_state(self
);
3052 if (config_animate_iconify
&& !hide_animation
)
3053 frame_begin_iconify_animation(self
->frame
, iconic
);
3054 /* do this after starting the animation so it doesn't flash */
3055 client_showhide(self
);
3058 /* iconify all direct transients, and deiconify all transients
3060 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3061 if (it
->data
!= self
)
3062 if (client_is_direct_child(self
, it
->data
) || !iconic
)
3063 client_iconify_recursive(it
->data
, iconic
, curdesk
,
3067 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
,
3068 gboolean hide_animation
)
3070 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
|| !iconic
) {
3071 /* move up the transient chain as far as possible first */
3072 self
= client_search_top_direct_parent(self
);
3073 client_iconify_recursive(self
, iconic
, curdesk
, hide_animation
);
3077 void client_maximize(ObClient
*self
, gboolean max
, gint dir
)
3081 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
3082 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
3084 /* check if already done */
3086 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
3087 if (dir
== 1 && self
->max_horz
) return;
3088 if (dir
== 2 && self
->max_vert
) return;
3090 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
3091 if (dir
== 1 && !self
->max_horz
) return;
3092 if (dir
== 2 && !self
->max_vert
) return;
3095 /* these will help configure_full figure out which screen to fill with
3099 w
= self
->area
.width
;
3100 h
= self
->area
.height
;
3103 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
3104 RECT_SET(self
->pre_max_area
,
3105 self
->area
.x
, self
->pre_max_area
.y
,
3106 self
->area
.width
, self
->pre_max_area
.height
);
3108 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
3109 RECT_SET(self
->pre_max_area
,
3110 self
->pre_max_area
.x
, self
->area
.y
,
3111 self
->pre_max_area
.width
, self
->area
.height
);
3114 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
3115 g_assert(self
->pre_max_area
.width
> 0);
3117 x
= self
->pre_max_area
.x
;
3118 w
= self
->pre_max_area
.width
;
3120 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
3121 0, self
->pre_max_area
.height
);
3123 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
3124 g_assert(self
->pre_max_area
.height
> 0);
3126 y
= self
->pre_max_area
.y
;
3127 h
= self
->pre_max_area
.height
;
3129 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
3130 self
->pre_max_area
.width
, 0);
3134 if (dir
== 0 || dir
== 1) /* horz */
3135 self
->max_horz
= max
;
3136 if (dir
== 0 || dir
== 2) /* vert */
3137 self
->max_vert
= max
;
3139 client_change_state(self
); /* change the state hints on the client */
3141 client_setup_decor_and_functions(self
, FALSE
);
3142 client_move_resize(self
, x
, y
, w
, h
);
3145 void client_shade(ObClient
*self
, gboolean shade
)
3147 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
3148 shade
) || /* can't shade */
3149 self
->shaded
== shade
) return; /* already done */
3151 self
->shaded
= shade
;
3152 client_change_state(self
);
3153 client_change_wm_state(self
); /* the window is being hidden/shown */
3154 /* resize the frame to just the titlebar */
3155 frame_adjust_area(self
->frame
, FALSE
, TRUE
, FALSE
);
3158 void client_close(ObClient
*self
)
3162 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
3164 /* in the case that the client provides no means to requesting that it
3165 close, we just kill it */
3166 if (!self
->delete_window
)
3170 XXX: itd be cool to do timeouts and shit here for killing the client's
3172 like... if the window is around after 5 seconds, then the close button
3173 turns a nice red, and if this function is called again, the client is
3177 ce
.xclient
.type
= ClientMessage
;
3178 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
3179 ce
.xclient
.display
= ob_display
;
3180 ce
.xclient
.window
= self
->window
;
3181 ce
.xclient
.format
= 32;
3182 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_delete_window
;
3183 ce
.xclient
.data
.l
[1] = event_curtime
;
3184 ce
.xclient
.data
.l
[2] = 0l;
3185 ce
.xclient
.data
.l
[3] = 0l;
3186 ce
.xclient
.data
.l
[4] = 0l;
3187 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
3190 void client_kill(ObClient
*self
)
3192 XKillClient(ob_display
, self
->window
);
3195 void client_hilite(ObClient
*self
, gboolean hilite
)
3197 if (self
->demands_attention
== hilite
)
3198 return; /* no change */
3200 /* don't allow focused windows to hilite */
3201 self
->demands_attention
= hilite
&& !client_focused(self
);
3202 if (self
->frame
!= NULL
) { /* if we're mapping, just set the state */
3203 if (self
->demands_attention
)
3204 frame_flash_start(self
->frame
);
3206 frame_flash_stop(self
->frame
);
3207 client_change_state(self
);
3211 void client_set_desktop_recursive(ObClient
*self
,
3219 if (target
!= self
->desktop
&& self
->type
!= OB_CLIENT_TYPE_DESKTOP
) {
3221 ob_debug("Setting desktop %u\n", target
+1);
3223 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
3225 old
= self
->desktop
;
3226 self
->desktop
= target
;
3227 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
3228 /* the frame can display the current desktop state */
3229 frame_adjust_state(self
->frame
);
3230 /* 'move' the window to the new desktop */
3234 /* raise if it was not already on the desktop */
3235 if (old
!= DESKTOP_ALL
&& !dontraise
)
3236 stacking_raise(CLIENT_AS_WINDOW(self
));
3237 if (STRUT_EXISTS(self
->strut
))
3238 screen_update_areas();
3240 /* the new desktop's geometry may be different, so we may need to
3241 resize, for example if we are maximized */
3242 client_reconfigure(self
, FALSE
);
3245 /* move all transients */
3246 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3247 if (it
->data
!= self
)
3248 if (client_is_direct_child(self
, it
->data
))
3249 client_set_desktop_recursive(it
->data
, target
,
3250 donthide
, dontraise
);
3253 void client_set_desktop(ObClient
*self
, guint target
,
3254 gboolean donthide
, gboolean dontraise
)
3256 self
= client_search_top_direct_parent(self
);
3257 client_set_desktop_recursive(self
, target
, donthide
, dontraise
);
3260 gboolean
client_is_direct_child(ObClient
*parent
, ObClient
*child
)
3262 while (child
!= parent
&& (child
= client_direct_parent(child
)));
3263 return child
== parent
;
3266 ObClient
*client_search_modal_child(ObClient
*self
)
3271 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
3272 ObClient
*c
= it
->data
;
3273 if ((ret
= client_search_modal_child(c
))) return ret
;
3274 if (c
->modal
) return c
;
3279 gboolean
client_validate(ObClient
*self
)
3283 XSync(ob_display
, FALSE
); /* get all events on the server */
3285 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
) ||
3286 XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
3287 XPutBackEvent(ob_display
, &e
);
3294 void client_set_wm_state(ObClient
*self
, glong state
)
3296 if (state
== self
->wmstate
) return; /* no change */
3300 client_iconify(self
, TRUE
, TRUE
, FALSE
);
3303 client_iconify(self
, FALSE
, TRUE
, FALSE
);
3308 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
3310 gboolean shaded
= self
->shaded
;
3311 gboolean fullscreen
= self
->fullscreen
;
3312 gboolean undecorated
= self
->undecorated
;
3313 gboolean max_horz
= self
->max_horz
;
3314 gboolean max_vert
= self
->max_vert
;
3315 gboolean modal
= self
->modal
;
3316 gboolean iconic
= self
->iconic
;
3317 gboolean demands_attention
= self
->demands_attention
;
3318 gboolean above
= self
->above
;
3319 gboolean below
= self
->below
;
3322 if (!(action
== prop_atoms
.net_wm_state_add
||
3323 action
== prop_atoms
.net_wm_state_remove
||
3324 action
== prop_atoms
.net_wm_state_toggle
))
3325 /* an invalid action was passed to the client message, ignore it */
3328 for (i
= 0; i
< 2; ++i
) {
3329 Atom state
= i
== 0 ? data1
: data2
;
3331 if (!state
) continue;
3333 /* if toggling, then pick whether we're adding or removing */
3334 if (action
== prop_atoms
.net_wm_state_toggle
) {
3335 if (state
== prop_atoms
.net_wm_state_modal
)
3336 action
= modal
? prop_atoms
.net_wm_state_remove
:
3337 prop_atoms
.net_wm_state_add
;
3338 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
3339 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
3340 prop_atoms
.net_wm_state_add
;
3341 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
3342 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
3343 prop_atoms
.net_wm_state_add
;
3344 else if (state
== prop_atoms
.net_wm_state_shaded
)
3345 action
= shaded
? prop_atoms
.net_wm_state_remove
:
3346 prop_atoms
.net_wm_state_add
;
3347 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
3348 action
= self
->skip_taskbar
?
3349 prop_atoms
.net_wm_state_remove
:
3350 prop_atoms
.net_wm_state_add
;
3351 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
3352 action
= self
->skip_pager
?
3353 prop_atoms
.net_wm_state_remove
:
3354 prop_atoms
.net_wm_state_add
;
3355 else if (state
== prop_atoms
.net_wm_state_hidden
)
3356 action
= self
->iconic
?
3357 prop_atoms
.net_wm_state_remove
:
3358 prop_atoms
.net_wm_state_add
;
3359 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
3360 action
= fullscreen
?
3361 prop_atoms
.net_wm_state_remove
:
3362 prop_atoms
.net_wm_state_add
;
3363 else if (state
== prop_atoms
.net_wm_state_above
)
3364 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
3365 prop_atoms
.net_wm_state_add
;
3366 else if (state
== prop_atoms
.net_wm_state_below
)
3367 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
3368 prop_atoms
.net_wm_state_add
;
3369 else if (state
== prop_atoms
.net_wm_state_demands_attention
)
3370 action
= self
->demands_attention
?
3371 prop_atoms
.net_wm_state_remove
:
3372 prop_atoms
.net_wm_state_add
;
3373 else if (state
== prop_atoms
.ob_wm_state_undecorated
)
3374 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
3375 prop_atoms
.net_wm_state_add
;
3378 if (action
== prop_atoms
.net_wm_state_add
) {
3379 if (state
== prop_atoms
.net_wm_state_modal
) {
3381 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
3383 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
3385 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
3387 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
3388 self
->skip_taskbar
= TRUE
;
3389 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
3390 self
->skip_pager
= TRUE
;
3391 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
3393 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
3395 } else if (state
== prop_atoms
.net_wm_state_above
) {
3398 } else if (state
== prop_atoms
.net_wm_state_below
) {
3401 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
3402 demands_attention
= TRUE
;
3403 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
3407 } else { /* action == prop_atoms.net_wm_state_remove */
3408 if (state
== prop_atoms
.net_wm_state_modal
) {
3410 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
3412 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
3414 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
3416 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
3417 self
->skip_taskbar
= FALSE
;
3418 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
3419 self
->skip_pager
= FALSE
;
3420 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
3422 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
3424 } else if (state
== prop_atoms
.net_wm_state_above
) {
3426 } else if (state
== prop_atoms
.net_wm_state_below
) {
3428 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
3429 demands_attention
= FALSE
;
3430 } else if (state
== prop_atoms
.ob_wm_state_undecorated
) {
3431 undecorated
= FALSE
;
3436 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
3437 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
3439 if (max_horz
== max_vert
) { /* both going the same way */
3440 client_maximize(self
, max_horz
, 0);
3442 client_maximize(self
, max_horz
, 1);
3443 client_maximize(self
, max_vert
, 2);
3447 if (max_horz
!= self
->max_horz
)
3448 client_maximize(self
, max_horz
, 1);
3450 client_maximize(self
, max_vert
, 2);
3453 /* change fullscreen state before shading, as it will affect if the window
3455 if (fullscreen
!= self
->fullscreen
)
3456 client_fullscreen(self
, fullscreen
);
3457 if (shaded
!= self
->shaded
)
3458 client_shade(self
, shaded
);
3459 if (undecorated
!= self
->undecorated
)
3460 client_set_undecorated(self
, undecorated
);
3461 if (above
!= self
->above
|| below
!= self
->below
) {
3462 self
->above
= above
;
3463 self
->below
= below
;
3464 client_calc_layer(self
);
3467 if (modal
!= self
->modal
) {
3468 self
->modal
= modal
;
3469 /* when a window changes modality, then its stacking order with its
3470 transients needs to change */
3471 stacking_raise(CLIENT_AS_WINDOW(self
));
3473 /* it also may get focused. if something is focused that shouldn't
3474 be focused anymore, then move the focus */
3475 if (focus_client
&& client_focus_target(focus_client
) != focus_client
)
3476 client_focus(focus_client
);
3479 if (iconic
!= self
->iconic
)
3480 client_iconify(self
, iconic
, FALSE
, FALSE
);
3482 if (demands_attention
!= self
->demands_attention
)
3483 client_hilite(self
, demands_attention
);
3485 client_change_state(self
); /* change the hint to reflect these changes */
3488 ObClient
*client_focus_target(ObClient
*self
)
3490 ObClient
*child
= NULL
;
3492 child
= client_search_modal_child(self
);
3493 if (child
) return child
;
3497 gboolean
client_can_focus(ObClient
*self
)
3499 /* choose the correct target */
3500 self
= client_focus_target(self
);
3502 if (!self
->frame
->visible
)
3505 if (!(self
->can_focus
|| self
->focus_notify
))
3511 gboolean
client_focus(ObClient
*self
)
3513 /* we might not focus this window, so if we have modal children which would
3514 be focused instead, bring them to this desktop */
3515 client_bring_modal_windows(self
);
3517 /* choose the correct target */
3518 self
= client_focus_target(self
);
3520 if (!client_can_focus(self
)) {
3521 ob_debug_type(OB_DEBUG_FOCUS
,
3522 "Client %s can't be focused\n", self
->title
);
3526 ob_debug_type(OB_DEBUG_FOCUS
,
3527 "Focusing client \"%s\" (0x%x) at time %u\n",
3528 self
->title
, self
->window
, event_curtime
);
3530 /* if using focus_delay, stop the timer now so that focus doesn't
3532 event_halt_focus_delay();
3534 /* if there is a grab going on, then we need to cancel it. if we move
3535 focus during the grab, applications will get NotifyWhileGrabbed events
3538 actions should not rely on being able to move focus during an
3541 event_cancel_all_key_grabs();
3543 xerror_set_ignore(TRUE
);
3544 xerror_occured
= FALSE
;
3546 if (self
->can_focus
) {
3547 /* This can cause a BadMatch error with CurrentTime, or if an app
3548 passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3549 XSetInputFocus(ob_display
, self
->window
, RevertToPointerRoot
,
3553 if (self
->focus_notify
) {
3555 ce
.xclient
.type
= ClientMessage
;
3556 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
3557 ce
.xclient
.display
= ob_display
;
3558 ce
.xclient
.window
= self
->window
;
3559 ce
.xclient
.format
= 32;
3560 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
3561 ce
.xclient
.data
.l
[1] = event_curtime
;
3562 ce
.xclient
.data
.l
[2] = 0l;
3563 ce
.xclient
.data
.l
[3] = 0l;
3564 ce
.xclient
.data
.l
[4] = 0l;
3565 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
3568 xerror_set_ignore(FALSE
);
3570 ob_debug_type(OB_DEBUG_FOCUS
, "Error focusing? %d\n", xerror_occured
);
3571 return !xerror_occured
;
3574 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
,
3577 if (client_normal(self
) && screen_showing_desktop
)
3578 screen_show_desktop(FALSE
, self
);
3580 client_iconify(self
, FALSE
, here
, FALSE
);
3581 if (self
->desktop
!= DESKTOP_ALL
&&
3582 self
->desktop
!= screen_desktop
)
3585 client_set_desktop(self
, screen_desktop
, FALSE
, TRUE
);
3587 screen_set_desktop(self
->desktop
, FALSE
);
3588 } else if (!self
->frame
->visible
)
3589 /* if its not visible for other reasons, then don't mess
3592 if (self
->shaded
&& unshade
)
3593 client_shade(self
, FALSE
);
3595 stacking_raise(CLIENT_AS_WINDOW(self
));
3600 void client_activate(ObClient
*self
, gboolean here
, gboolean raise
,
3601 gboolean unshade
, gboolean user
)
3603 client_present(self
, here
, raise
, unshade
);
3606 static void client_bring_windows_recursive(ObClient
*self
,
3614 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
3615 client_bring_windows_recursive(it
->data
, desktop
,
3616 helpers
, modals
, iconic
);
3618 if (((helpers
&& client_helper(self
)) ||
3619 (modals
&& self
->modal
)) &&
3620 ((self
->desktop
!= desktop
&& self
->desktop
!= DESKTOP_ALL
) ||
3621 (iconic
&& self
->iconic
)))
3623 if (iconic
&& self
->iconic
)
3624 client_iconify(self
, FALSE
, TRUE
, FALSE
);
3626 client_set_desktop(self
, desktop
, FALSE
, FALSE
);
3630 void client_bring_helper_windows(ObClient
*self
)
3632 client_bring_windows_recursive(self
, self
->desktop
, TRUE
, FALSE
, FALSE
);
3635 void client_bring_modal_windows(ObClient
*self
)
3637 client_bring_windows_recursive(self
, self
->desktop
, FALSE
, TRUE
, TRUE
);
3640 gboolean
client_focused(ObClient
*self
)
3642 return self
== focus_client
;
3645 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
3648 gulong min_diff
, min_i
;
3650 if (!self
->nicons
) {
3651 ObClientIcon
*parent
= NULL
;
3654 for (it
= self
->parents
; it
; it
= g_slist_next(it
)) {
3655 ObClient
*c
= it
->data
;
3656 if ((parent
= client_icon_recursive(c
, w
, h
)))
3663 /* some kind of crappy approximation to find the icon closest in size to
3664 what we requested, but icons are generally all the same ratio as
3665 eachother so it's good enough. */
3667 min_diff
= ABS(self
->icons
[0].width
- w
) + ABS(self
->icons
[0].height
- h
);
3670 for (i
= 1; i
< self
->nicons
; ++i
) {
3673 diff
= ABS(self
->icons
[i
].width
- w
) + ABS(self
->icons
[i
].height
- h
);
3674 if (diff
< min_diff
) {
3679 return &self
->icons
[min_i
];
3682 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
3685 static ObClientIcon deficon
;
3687 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
3688 deficon
.width
= deficon
.height
= 48;
3689 deficon
.data
= ob_rr_theme
->def_win_icon
;
3695 void client_set_layer(ObClient
*self
, gint layer
)
3699 self
->above
= FALSE
;
3700 } else if (layer
== 0) {
3701 self
->below
= self
->above
= FALSE
;
3703 self
->below
= FALSE
;
3706 client_calc_layer(self
);
3707 client_change_state(self
); /* reflect this in the state hints */
3710 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
3712 if (self
->undecorated
!= undecorated
&&
3713 /* don't let it undecorate if the function is missing, but let
3715 (self
->functions
& OB_CLIENT_FUNC_UNDECORATE
|| !undecorated
))
3717 self
->undecorated
= undecorated
;
3718 client_setup_decor_and_functions(self
, TRUE
);
3719 client_change_state(self
); /* reflect this in the state hints */
3723 guint
client_monitor(ObClient
*self
)
3725 return screen_find_monitor(&self
->frame
->area
);
3728 ObClient
*client_direct_parent(ObClient
*self
)
3730 if (!self
->parents
) return NULL
;
3731 if (self
->transient_for_group
) return NULL
;
3732 return self
->parents
->data
;
3735 ObClient
*client_search_top_direct_parent(ObClient
*self
)
3738 while ((p
= client_direct_parent(self
))) self
= p
;
3742 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
3744 ObStackingLayer layer
)
3749 /* move up the direct transient chain as far as possible */
3750 while ((p
= client_direct_parent(self
)) &&
3751 (!bylayer
|| p
->layer
== layer
))
3755 ret
= g_slist_prepend(NULL
, self
);
3757 ret
= g_slist_copy(self
->parents
);
3762 GSList
*client_search_all_top_parents(ObClient
*self
)
3764 return client_search_all_top_parents_internal(self
, FALSE
, 0);
3767 GSList
*client_search_all_top_parents_layer(ObClient
*self
)
3769 return client_search_all_top_parents_internal(self
, TRUE
, self
->layer
);
3772 ObClient
*client_search_focus_parent(ObClient
*self
)
3776 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
3777 if (client_focused(it
->data
)) return it
->data
;
3782 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3786 for (it
= self
->parents
; it
; it
= g_slist_next(it
))
3787 if (it
->data
== search
) return search
;
3792 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3796 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3797 if (sit
->data
== search
)
3799 if (client_search_transient(sit
->data
, search
))
3805 static void detect_edge(Rect area
, ObDirection dir
,
3806 gint my_head
, gint my_size
,
3807 gint my_edge_start
, gint my_edge_size
,
3808 gint
*dest
, gboolean
*near_edge
)
3810 gint edge_start
, edge_size
, head
, tail
;
3811 gboolean skip_head
= FALSE
, skip_tail
= FALSE
;
3814 case OB_DIRECTION_NORTH
:
3815 case OB_DIRECTION_SOUTH
:
3816 edge_start
= area
.x
;
3817 edge_size
= area
.width
;
3819 case OB_DIRECTION_EAST
:
3820 case OB_DIRECTION_WEST
:
3821 edge_start
= area
.y
;
3822 edge_size
= area
.height
;
3825 g_assert_not_reached();
3828 /* do we collide with this window? */
3829 if (!RANGES_INTERSECT(my_edge_start
, my_edge_size
,
3830 edge_start
, edge_size
))
3834 case OB_DIRECTION_NORTH
:
3835 head
= RECT_BOTTOM(area
);
3836 tail
= RECT_TOP(area
);
3838 case OB_DIRECTION_SOUTH
:
3839 head
= RECT_TOP(area
);
3840 tail
= RECT_BOTTOM(area
);
3842 case OB_DIRECTION_WEST
:
3843 head
= RECT_RIGHT(area
);
3844 tail
= RECT_LEFT(area
);
3846 case OB_DIRECTION_EAST
:
3847 head
= RECT_LEFT(area
);
3848 tail
= RECT_RIGHT(area
);
3851 g_assert_not_reached();
3854 case OB_DIRECTION_NORTH
:
3855 case OB_DIRECTION_WEST
:
3856 /* check if our window is past the head of this window */
3857 if (my_head
<= head
+ 1)
3859 /* check if our window's tail is past the tail of this window */
3860 if (my_head
+ my_size
- 1 <= tail
)
3862 /* check if the head of this window is closer than the previously
3863 chosen edge (take into account that the previously chosen
3864 edge might have been a tail, not a head) */
3865 if (head
+ (*near_edge
? 0 : my_size
) < *dest
)
3867 /* check if the tail of this window is closer than the previously
3868 chosen edge (take into account that the previously chosen
3869 edge might have been a head, not a tail) */
3870 if (tail
- (!*near_edge
? 0 : my_size
) < *dest
)
3873 case OB_DIRECTION_SOUTH
:
3874 case OB_DIRECTION_EAST
:
3875 /* check if our window is past the head of this window */
3876 if (my_head
>= head
- 1)
3878 /* check if our window's tail is past the tail of this window */
3879 if (my_head
- my_size
+ 1 >= tail
)
3881 /* check if the head of this window is closer than the previously
3882 chosen edge (take into account that the previously chosen
3883 edge might have been a tail, not a head) */
3884 if (head
- (*near_edge
? 0 : my_size
) > *dest
)
3886 /* check if the tail of this window is closer than the previously
3887 chosen edge (take into account that the previously chosen
3888 edge might have been a head, not a tail) */
3889 if (tail
+ (!*near_edge
? 0 : my_size
) > *dest
)
3893 g_assert_not_reached();
3896 ob_debug("my head %d size %d\n", my_head
, my_size
);
3897 ob_debug("head %d tail %d deest %d\n", head
, tail
, *dest
);
3899 ob_debug("using near edge %d\n", head
);
3903 else if (!skip_tail
) {
3904 ob_debug("using far edge %d\n", tail
);
3910 void client_find_edge_directional(ObClient
*self
, ObDirection dir
,
3911 gint my_head
, gint my_size
,
3912 gint my_edge_start
, gint my_edge_size
,
3913 gint
*dest
, gboolean
*near_edge
)
3920 a
= screen_area(self
->desktop
, SCREEN_AREA_ALL_MONITORS
,
3921 &self
->frame
->area
);
3922 mon
= screen_area(self
->desktop
, SCREEN_AREA_ONE_MONITOR
,
3923 &self
->frame
->area
);
3926 case OB_DIRECTION_NORTH
:
3927 if (my_head
>= RECT_TOP(*mon
) + 1)
3928 edge
= RECT_TOP(*mon
) - 1;
3930 edge
= RECT_TOP(*a
) - 1;
3932 case OB_DIRECTION_SOUTH
:
3933 if (my_head
<= RECT_BOTTOM(*mon
) - 1)
3934 edge
= RECT_BOTTOM(*mon
) + 1;
3936 edge
= RECT_BOTTOM(*a
) + 1;
3938 case OB_DIRECTION_EAST
:
3939 if (my_head
<= RECT_RIGHT(*mon
) - 1)
3940 edge
= RECT_RIGHT(*mon
) + 1;
3942 edge
= RECT_RIGHT(*a
) + 1;
3944 case OB_DIRECTION_WEST
:
3945 if (my_head
>= RECT_LEFT(*mon
) + 1)
3946 edge
= RECT_LEFT(*mon
) - 1;
3948 edge
= RECT_LEFT(*a
) - 1;
3951 g_assert_not_reached();
3953 /* default to the far edge, then narrow it down */
3957 for (it
= client_list
; it
; it
= g_list_next(it
)) {
3958 ObClient
*cur
= it
->data
;
3960 /* skip windows to not bump into */
3965 if (self
->desktop
!= cur
->desktop
&& cur
->desktop
!= DESKTOP_ALL
&&
3966 cur
->desktop
!= screen_desktop
)
3969 ob_debug("trying window %s\n", cur
->title
);
3971 detect_edge(cur
->frame
->area
, dir
, my_head
, my_size
, my_edge_start
,
3972 my_edge_size
, dest
, near_edge
);
3974 dock_get_area(&dock_area
);
3975 detect_edge(dock_area
, dir
, my_head
, my_size
, my_edge_start
,
3976 my_edge_size
, dest
, near_edge
);
3981 void client_find_move_directional(ObClient
*self
, ObDirection dir
,
3985 gint e
, e_start
, e_size
;
3989 case OB_DIRECTION_EAST
:
3990 head
= RECT_RIGHT(self
->frame
->area
);
3991 size
= self
->frame
->area
.width
;
3992 e_start
= RECT_TOP(self
->frame
->area
);
3993 e_size
= self
->frame
->area
.height
;
3995 case OB_DIRECTION_WEST
:
3996 head
= RECT_LEFT(self
->frame
->area
);
3997 size
= self
->frame
->area
.width
;
3998 e_start
= RECT_TOP(self
->frame
->area
);
3999 e_size
= self
->frame
->area
.height
;
4001 case OB_DIRECTION_NORTH
:
4002 head
= RECT_TOP(self
->frame
->area
);
4003 size
= self
->frame
->area
.height
;
4004 e_start
= RECT_LEFT(self
->frame
->area
);
4005 e_size
= self
->frame
->area
.width
;
4007 case OB_DIRECTION_SOUTH
:
4008 head
= RECT_BOTTOM(self
->frame
->area
);
4009 size
= self
->frame
->area
.height
;
4010 e_start
= RECT_LEFT(self
->frame
->area
);
4011 e_size
= self
->frame
->area
.width
;
4014 g_assert_not_reached();
4017 client_find_edge_directional(self
, dir
, head
, size
,
4018 e_start
, e_size
, &e
, &near
);
4019 *x
= self
->frame
->area
.x
;
4020 *y
= self
->frame
->area
.y
;
4022 case OB_DIRECTION_EAST
:
4023 if (near
) e
-= self
->frame
->area
.width
;
4027 case OB_DIRECTION_WEST
:
4029 else e
-= self
->frame
->area
.width
;
4032 case OB_DIRECTION_NORTH
:
4034 else e
-= self
->frame
->area
.height
;
4037 case OB_DIRECTION_SOUTH
:
4038 if (near
) e
-= self
->frame
->area
.height
;
4043 g_assert_not_reached();
4045 frame_frame_gravity(self
->frame
, x
, y
);
4048 void client_find_resize_directional(ObClient
*self
, ObDirection side
,
4050 gint
*x
, gint
*y
, gint
*w
, gint
*h
)
4053 gint e
, e_start
, e_size
, delta
;
4058 case OB_DIRECTION_EAST
:
4059 head
= RECT_RIGHT(self
->frame
->area
) +
4060 (self
->size_inc
.width
- 1) * (grow
? 1 : -1);
4061 e_start
= RECT_TOP(self
->frame
->area
);
4062 e_size
= self
->frame
->area
.height
;
4063 dir
= grow
? OB_DIRECTION_EAST
: OB_DIRECTION_WEST
;
4065 case OB_DIRECTION_WEST
:
4066 head
= RECT_LEFT(self
->frame
->area
) -
4067 (self
->size_inc
.width
- 1) * (grow
? 1 : -1);
4068 e_start
= RECT_TOP(self
->frame
->area
);
4069 e_size
= self
->frame
->area
.height
;
4070 dir
= grow
? OB_DIRECTION_WEST
: OB_DIRECTION_EAST
;
4072 case OB_DIRECTION_NORTH
:
4073 head
= RECT_TOP(self
->frame
->area
) -
4074 (self
->size_inc
.height
- 1) * (grow
? 1 : -1);
4075 e_start
= RECT_LEFT(self
->frame
->area
);
4076 e_size
= self
->frame
->area
.width
;
4077 dir
= grow
? OB_DIRECTION_NORTH
: OB_DIRECTION_SOUTH
;
4079 case OB_DIRECTION_SOUTH
:
4080 head
= RECT_BOTTOM(self
->frame
->area
) +
4081 (self
->size_inc
.height
- 1) * (grow
? 1 : -1);
4082 e_start
= RECT_LEFT(self
->frame
->area
);
4083 e_size
= self
->frame
->area
.width
;
4084 dir
= grow
? OB_DIRECTION_SOUTH
: OB_DIRECTION_NORTH
;
4087 g_assert_not_reached();
4090 ob_debug("head %d dir %d\n", head
, dir
);
4091 client_find_edge_directional(self
, dir
, head
, 1,
4092 e_start
, e_size
, &e
, &near
);
4093 ob_debug("edge %d\n", e
);
4094 *x
= self
->frame
->area
.x
;
4095 *y
= self
->frame
->area
.y
;
4096 *w
= self
->frame
->area
.width
;
4097 *h
= self
->frame
->area
.height
;
4099 case OB_DIRECTION_EAST
:
4100 if (grow
== near
) --e
;
4101 delta
= e
- RECT_RIGHT(self
->frame
->area
);
4104 case OB_DIRECTION_WEST
:
4105 if (grow
== near
) ++e
;
4106 delta
= RECT_LEFT(self
->frame
->area
) - e
;
4110 case OB_DIRECTION_NORTH
:
4111 if (grow
== near
) ++e
;
4112 delta
= RECT_TOP(self
->frame
->area
) - e
;
4116 case OB_DIRECTION_SOUTH
:
4117 if (grow
== near
) --e
;
4118 delta
= e
- RECT_BOTTOM(self
->frame
->area
);
4122 g_assert_not_reached();
4124 frame_frame_gravity(self
->frame
, x
, y
);
4125 *w
-= self
->frame
->size
.left
+ self
->frame
->size
.right
;
4126 *h
-= self
->frame
->size
.top
+ self
->frame
->size
.bottom
;
4129 ObClient
* client_under_pointer(void)
4133 ObClient
*ret
= NULL
;
4135 if (screen_pointer_pos(&x
, &y
)) {
4136 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
4137 if (WINDOW_IS_CLIENT(it
->data
)) {
4138 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
4139 if (c
->frame
->visible
&&
4140 /* check the desktop, this is done during desktop
4141 switching and windows are shown/hidden status is not
4143 (c
->desktop
== screen_desktop
||
4144 c
->desktop
== DESKTOP_ALL
) &&
4145 /* ignore all animating windows */
4146 !frame_iconify_animating(c
->frame
) &&
4147 RECT_CONTAINS(c
->frame
->area
, x
, y
))
4158 gboolean
client_has_group_siblings(ObClient
*self
)
4160 return self
->group
&& self
->group
->members
->next
;