1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
22 #include "startupnotify.h"
26 #include "moveresize.h"
29 #include "extensions.h"
39 #include "menuframe.h"
42 #include "render/render.h"
49 #include <X11/Xutil.h>
51 /*! The event mask to grab on client windows */
52 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
55 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
60 ObClientDestructor func
;
64 GList
*client_list
= NULL
;
66 static GSList
*client_destructors
= NULL
;
68 static void client_get_all(ObClient
*self
);
69 static void client_toggle_border(ObClient
*self
, gboolean show
);
70 static void client_get_startup_id(ObClient
*self
);
71 static void client_get_area(ObClient
*self
);
72 static void client_get_desktop(ObClient
*self
);
73 static void client_get_state(ObClient
*self
);
74 static void client_get_layer(ObClient
*self
);
75 static void client_get_shaped(ObClient
*self
);
76 static void client_get_mwm_hints(ObClient
*self
);
77 static void client_get_gravity(ObClient
*self
);
78 static void client_get_client_machine(ObClient
*self
);
79 static void client_get_colormap(ObClient
*self
);
80 static void client_get_transientness(ObClient
*self
);
81 static void client_change_allowed_actions(ObClient
*self
);
82 static void client_change_state(ObClient
*self
);
83 static void client_change_wm_state(ObClient
*self
);
84 static void client_apply_startup_state(ObClient
*self
, gint x
, gint y
);
85 static void client_restore_session_state(ObClient
*self
);
86 static gboolean
client_restore_session_stacking(ObClient
*self
);
87 static ObAppSettings
*client_get_settings_state(ObClient
*self
);
88 static void client_update_transient_tree(ObClient
*self
,
89 ObGroup
*oldgroup
, ObGroup
*newgroup
,
92 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
);
93 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
95 ObStackingLayer layer
);
97 void client_startup(gboolean reconfig
)
104 void client_shutdown(gboolean reconfig
)
108 void client_add_destructor(ObClientDestructor func
, gpointer data
)
110 Destructor
*d
= g_new(Destructor
, 1);
113 client_destructors
= g_slist_prepend(client_destructors
, d
);
116 void client_remove_destructor(ObClientDestructor func
)
120 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
121 Destructor
*d
= it
->data
;
122 if (d
->func
== func
) {
124 client_destructors
= g_slist_delete_link(client_destructors
, it
);
130 void client_set_list()
132 Window
*windows
, *win_it
;
134 guint size
= g_list_length(client_list
);
136 /* create an array of the window ids */
138 windows
= g_new(Window
, size
);
140 for (it
= client_list
; it
; it
= g_list_next(it
), ++win_it
)
141 *win_it
= ((ObClient
*)it
->data
)->window
;
145 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
146 net_client_list
, window
, (gulong
*)windows
, size
);
155 void client_foreach_transient(ObClient *self, ObClientForeachFunc func, gpointer data)
159 for (it = self->transients; it; it = g_slist_next(it)) {
160 if (!func(it->data, data)) return;
161 client_foreach_transient(it->data, func, data);
165 void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, gpointer data)
167 if (self->transient_for) {
168 if (self->transient_for != OB_TRAN_GROUP) {
169 if (!func(self->transient_for, data)) return;
170 client_foreach_ancestor(self->transient_for, func, data);
174 for (it = self->group->members; it; it = g_slist_next(it))
175 if (it->data != self &&
176 !((ObClient*)it->data)->transient_for) {
177 if (!func(it->data, data)) return;
178 client_foreach_ancestor(it->data, func, data);
185 void client_manage_all()
190 XWindowAttributes attrib
;
192 XQueryTree(ob_display
, RootWindow(ob_display
, ob_screen
),
193 &w
, &w
, &children
, &nchild
);
195 /* remove all icon windows from the list */
196 for (i
= 0; i
< nchild
; i
++) {
197 if (children
[i
] == None
) continue;
198 wmhints
= XGetWMHints(ob_display
, children
[i
]);
200 if ((wmhints
->flags
& IconWindowHint
) &&
201 (wmhints
->icon_window
!= children
[i
]))
202 for (j
= 0; j
< nchild
; j
++)
203 if (children
[j
] == wmhints
->icon_window
) {
211 for (i
= 0; i
< nchild
; ++i
) {
212 if (children
[i
] == None
)
214 if (XGetWindowAttributes(ob_display
, children
[i
], &attrib
)) {
215 if (attrib
.override_redirect
) continue;
217 if (attrib
.map_state
!= IsUnmapped
)
218 client_manage(children
[i
]);
224 void client_manage(Window window
)
228 XWindowAttributes attrib
;
229 XSetWindowAttributes attrib_set
;
231 gboolean activate
= FALSE
;
232 ObAppSettings
*settings
;
237 /* check if it has already been unmapped by the time we started mapping.
238 the grab does a sync so we don't have to here */
239 if (XCheckTypedWindowEvent(ob_display
, window
, DestroyNotify
, &e
) ||
240 XCheckTypedWindowEvent(ob_display
, window
, UnmapNotify
, &e
))
242 XPutBackEvent(ob_display
, &e
);
244 ob_debug("Trying to manage unmapped window. Aborting that.\n");
246 return; /* don't manage it */
249 /* make sure it isn't an override-redirect window */
250 if (!XGetWindowAttributes(ob_display
, window
, &attrib
) ||
251 attrib
.override_redirect
)
254 return; /* don't manage it */
257 /* is the window a docking app */
258 if ((wmhint
= XGetWMHints(ob_display
, window
))) {
259 if ((wmhint
->flags
& StateHint
) &&
260 wmhint
->initial_state
== WithdrawnState
)
262 dock_add(window
, wmhint
);
270 ob_debug("Managing window: %lx\n", window
);
272 /* choose the events we want to receive on the CLIENT window */
273 attrib_set
.event_mask
= CLIENT_EVENTMASK
;
274 attrib_set
.do_not_propagate_mask
= CLIENT_NOPROPAGATEMASK
;
275 XChangeWindowAttributes(ob_display
, window
,
276 CWEventMask
|CWDontPropagate
, &attrib_set
);
279 /* create the ObClient struct, and populate it from the hints on the
281 self
= g_new0(ObClient
, 1);
282 self
->obwin
.type
= Window_Client
;
283 self
->window
= window
;
285 /* non-zero defaults */
286 self
->wmstate
= WithdrawnState
; /* make sure it gets updated first time */
288 self
->desktop
= screen_num_desktops
; /* always an invalid value */
289 self
->user_time
= focus_client
? focus_client
->user_time
: CurrentTime
;
291 client_get_all(self
);
292 /* per-app settings override stuff, and return the settings for other
294 settings
= client_get_settings_state(self
);
295 /* the session should get the last say */
296 client_restore_session_state(self
);
298 client_calc_layer(self
);
301 Time t
= sn_app_started(self
->startup_id
, self
->class);
302 if (t
) self
->user_time
= t
;
305 /* update the focus lists, do this before the call to change_state or
306 it can end up in the list twice! */
307 focus_order_add_new(self
);
309 /* remove the client's border (and adjust re gravity) */
310 client_toggle_border(self
, FALSE
);
312 /* specify that if we exit, the window should not be destroyed and should
313 be reparented back to root automatically */
314 XChangeSaveSet(ob_display
, window
, SetModeInsert
);
316 /* create the decoration frame for the client window */
317 self
->frame
= frame_new(self
);
319 frame_grab_client(self
->frame
, self
);
321 /* do this after we have a frame.. it uses the frame to help determine the
322 WM_STATE to apply. */
323 client_change_state(self
);
327 stacking_add_nonintrusive(CLIENT_AS_WINDOW(self
));
329 /* focus the new window? */
330 if (ob_state() != OB_STATE_STARTING
&&
331 (!self
->session
|| self
->session
->focused
) &&
333 /* this means focus=true for window is same as config_focus_new=true */
334 ((config_focus_new
|| (settings
&& settings
->focus
== 1)) ||
335 client_search_focus_parent(self
)) &&
336 /* this checks for focus=false for the window */
337 (!settings
|| settings
->focus
!= 0) &&
338 /* note the check against Type_Normal/Dialog, not client_normal(self),
339 which would also include other types. in this case we want more
340 strict rules for focus */
341 (self
->type
== OB_CLIENT_TYPE_NORMAL
||
342 self
->type
== OB_CLIENT_TYPE_DIALOG
))
347 /* get the current position */
351 /* figure out placement for the window */
352 if (ob_state() == OB_STATE_RUNNING
) {
355 transient
= place_client(self
, &newx
, &newy
, settings
);
357 /* make sure the window is visible. */
358 client_find_onscreen(self
, &newx
, &newy
,
361 /* non-normal clients has less rules, and
362 windows that are being restored from a
363 session do also. we can assume you want
364 it back where you saved it. Clients saying
365 they placed themselves are subjected to
366 harder rules, ones that are placed by
367 place.c or by the user are allowed partially
368 off-screen and on xinerama divides (ie,
369 it is up to the placement routines to avoid
370 the xinerama divides) */
372 (((self
->positioned
& PPosition
) &&
373 !(self
->positioned
& USPosition
)) &&
374 client_normal(self
) &&
378 /* do this after the window is placed, so the premax/prefullscreen numbers
380 also, this moves the window to the position where it has been placed
382 ob_debug("placing window 0x%x at %d, %d with size %d x %d\n",
383 self
->window
, newx
, newy
, self
->area
.width
, self
->area
.height
);
385 ob_debug("session requested %d %d\n",
386 self
->session
->x
, self
->session
->y
);
388 client_apply_startup_state(self
, newx
, newy
);
390 mouse_grab_for_client(self
, TRUE
);
393 guint32 last_time
= focus_client
?
394 focus_client
->user_time
: CurrentTime
;
396 /* This is focus stealing prevention */
397 ob_debug_type(OB_DEBUG_FOCUS
,
398 "Want to focus new window 0x%x with time %u "
400 self
->window
, self
->user_time
, last_time
);
402 /* if it's on another desktop */
403 if (!(self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
404 && /* the timestamp is from before you changed desktops */
405 self
->user_time
&& screen_desktop_user_time
&&
406 !event_time_after(self
->user_time
, screen_desktop_user_time
))
409 ob_debug_type(OB_DEBUG_FOCUS
,
410 "Not focusing the window because its on another "
413 /* If something is focused, and it's not our parent... */
414 else if (focus_client
&& client_search_focus_parent(self
) == NULL
)
416 /* If time stamp is old, don't steal focus */
417 if (self
->user_time
&& last_time
&&
418 !event_time_after(self
->user_time
, last_time
))
421 ob_debug_type(OB_DEBUG_FOCUS
,
422 "Not focusing the window because the time is "
425 /* Don't steal focus from globally active clients.
426 I stole this idea from KWin. It seems nice.
428 if (!(focus_client
->can_focus
|| focus_client
->focus_notify
)) {
430 ob_debug_type(OB_DEBUG_FOCUS
,
431 "Not focusing the window because a globally "
432 "active client has focus\n");
437 ob_debug_type(OB_DEBUG_FOCUS
,
438 "Focus stealing prevention activated for %s with "
439 "time %u (last time %u)\n",
440 self
->title
, self
->user_time
, last_time
);
441 /* if the client isn't focused, then hilite it so the user
443 client_hilite(self
, TRUE
);
447 /* This may look rather odd. Well it's because new windows are added
448 to the stacking order non-intrusively. If we're not going to focus
449 the new window or hilite it, then we raise it to the top. This will
450 take affect for things that don't get focused like splash screens.
451 Also if you don't have focus_new enabled, then it's going to get
452 raised to the top. Legacy begets legacy I guess?
454 if (!client_restore_session_stacking(self
))
458 /* this has to happen before we try focus the window, but we want it to
459 happen after the client's stacking has been determined or it looks bad
463 /* use client_focus instead of client_activate cuz client_activate does
464 stuff like switch desktops etc and I'm not interested in all that when
465 a window maps since its not based on an action from the user like
466 clicking a window to activate it. so keep the new window out of the way
469 gboolean stacked
= client_restore_session_stacking(self
);
470 client_present(self
, FALSE
, !stacked
);
473 /* add to client list/map */
474 client_list
= g_list_append(client_list
, self
);
475 g_hash_table_insert(window_map
, &self
->window
, self
);
477 /* this has to happen after we're in the client_list */
478 if (STRUT_EXISTS(self
->strut
))
479 screen_update_areas();
481 /* update the list hints */
484 ob_debug("Managed window 0x%lx (%s)\n", window
, self
->class);
487 void client_unmanage_all()
489 while (client_list
!= NULL
)
490 client_unmanage(client_list
->data
);
493 void client_unmanage(ObClient
*self
)
498 ob_debug("Unmanaging window: %lx (%s) (%s)\n", self
->window
, self
->class,
499 self
->title
? self
->title
: "");
501 g_assert(self
!= NULL
);
503 /* we dont want events no more. do this before hiding the frame so we
504 don't generate more events */
505 XSelectInput(ob_display
, self
->window
, NoEventMask
);
507 frame_hide(self
->frame
);
508 /* flush to send the hide to the server quickly */
511 /* ignore enter events from the unmap so it doesnt mess with the focus */
512 event_ignore_queued_enters();
514 mouse_grab_for_client(self
, FALSE
);
516 /* remove the window from our save set */
517 XChangeSaveSet(ob_display
, self
->window
, SetModeDelete
);
519 /* update the focus lists */
520 focus_order_remove(self
);
521 if (client_focused(self
)) {
522 /* don't leave an invalid focus_client */
526 client_list
= g_list_remove(client_list
, self
);
527 stacking_remove(self
);
528 g_hash_table_remove(window_map
, &self
->window
);
530 /* once the client is out of the list, update the struts to remove its
532 if (STRUT_EXISTS(self
->strut
))
533 screen_update_areas();
535 for (it
= client_destructors
; it
; it
= g_slist_next(it
)) {
536 Destructor
*d
= it
->data
;
537 d
->func(self
, d
->data
);
540 /* tell our parent(s) that we're gone */
541 if (self
->transient_for
== OB_TRAN_GROUP
) { /* transient of group */
542 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
543 if (it
->data
!= self
)
544 ((ObClient
*)it
->data
)->transients
=
545 g_slist_remove(((ObClient
*)it
->data
)->transients
, self
);
546 } else if (self
->transient_for
) { /* transient of window */
547 self
->transient_for
->transients
=
548 g_slist_remove(self
->transient_for
->transients
, self
);
551 /* tell our transients that we're gone */
552 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
553 if (((ObClient
*)it
->data
)->transient_for
!= OB_TRAN_GROUP
) {
554 ((ObClient
*)it
->data
)->transient_for
= NULL
;
555 client_calc_layer(it
->data
);
559 /* remove from its group */
561 group_remove(self
->group
, self
);
565 /* restore the window's original geometry so it is not lost */
569 if (self
->fullscreen
)
570 a
= self
->pre_fullscreen_area
;
571 else if (self
->max_horz
|| self
->max_vert
) {
572 if (self
->max_horz
) {
573 a
.x
= self
->pre_max_area
.x
;
574 a
.width
= self
->pre_max_area
.width
;
576 if (self
->max_vert
) {
577 a
.y
= self
->pre_max_area
.y
;
578 a
.height
= self
->pre_max_area
.height
;
582 /* give the client its border back */
583 client_toggle_border(self
, TRUE
);
585 self
->fullscreen
= self
->max_horz
= self
->max_vert
= FALSE
;
586 self
->decorations
= 0; /* unmanaged windows have no decor */
588 client_move_resize(self
, a
.x
, a
.y
, a
.width
, a
.height
);
591 /* reparent the window out of the frame, and free the frame */
592 frame_release_client(self
->frame
, self
);
595 if (ob_state() != OB_STATE_EXITING
) {
596 /* these values should not be persisted across a window
598 PROP_ERASE(self
->window
, net_wm_desktop
);
599 PROP_ERASE(self
->window
, net_wm_state
);
600 PROP_ERASE(self
->window
, wm_state
);
602 /* if we're left in an unmapped state, the client wont be mapped. this
603 is bad, since we will no longer be managing the window on restart */
604 XMapWindow(ob_display
, self
->window
);
607 ob_debug("Unmanaged window 0x%lx\n", self
->window
);
609 /* free all data allocated in the client struct */
610 g_slist_free(self
->transients
);
611 for (j
= 0; j
< self
->nicons
; ++j
)
612 g_free(self
->icons
[j
].data
);
613 if (self
->nicons
> 0)
615 g_free(self
->wm_command
);
617 g_free(self
->icon_title
);
621 g_free(self
->client_machine
);
622 g_free(self
->sm_client_id
);
625 /* update the list hints */
629 static ObAppSettings
*client_get_settings_state(ObClient
*self
)
631 ObAppSettings
*settings
= NULL
;
634 for (it
= config_per_app_settings
; it
; it
= g_slist_next(it
)) {
635 ObAppSettings
*app
= it
->data
;
637 if ((app
->name
&& !app
->class && !strcmp(app
->name
, self
->name
))
638 || (app
->class && !app
->name
&& !strcmp(app
->class, self
->class))
639 || (app
->class && app
->name
&& !strcmp(app
->class, self
->class)
640 && !strcmp(app
->name
, self
->name
)))
642 /* Match if no role was specified in the per app setting, or if the
643 * string matches the beginning of the role, since apps like to set
644 * the role to things like browser-window-23c4b2f */
646 || !strncmp(app
->role
, self
->role
, strlen(app
->role
)))
648 ob_debug("Window matching: %s\n", app
->name
);
657 if (settings
->shade
!= -1)
658 self
->shaded
= !!settings
->shade
;
659 if (settings
->decor
!= -1)
660 self
->undecorated
= !settings
->decor
;
661 if (settings
->iconic
!= -1)
662 self
->iconic
= !!settings
->iconic
;
663 if (settings
->skip_pager
!= -1)
664 self
->skip_pager
= !!settings
->skip_pager
;
665 if (settings
->skip_taskbar
!= -1)
666 self
->skip_taskbar
= !!settings
->skip_taskbar
;
668 if (settings
->max_vert
!= -1)
669 self
->max_vert
= !!settings
->max_vert
;
670 if (settings
->max_horz
!= -1)
671 self
->max_horz
= !!settings
->max_horz
;
673 if (settings
->fullscreen
!= -1)
674 self
->fullscreen
= !!settings
->fullscreen
;
676 if (settings
->desktop
) {
677 if (settings
->desktop
== DESKTOP_ALL
)
678 self
->desktop
= settings
->desktop
;
679 else if (settings
->desktop
> 0 &&
680 settings
->desktop
<= screen_num_desktops
)
681 self
->desktop
= settings
->desktop
- 1;
684 if (settings
->layer
== -1) {
688 else if (settings
->layer
== 0) {
692 else if (settings
->layer
== 1) {
700 static void client_restore_session_state(ObClient
*self
)
704 ob_debug_type(OB_DEBUG_SM
,
705 "Restore session for client %s\n", self
->title
);
707 if (!(it
= session_state_find(self
))) {
708 ob_debug_type(OB_DEBUG_SM
,
709 "Session data not found for client %s\n", self
->title
);
713 self
->session
= it
->data
;
715 ob_debug_type(OB_DEBUG_SM
, "Session data loaded for client %s\n",
718 RECT_SET_POINT(self
->area
, self
->session
->x
, self
->session
->y
);
719 self
->positioned
= USPosition
;
720 if (self
->session
->w
> 0)
721 self
->area
.width
= self
->session
->w
;
722 if (self
->session
->h
> 0)
723 self
->area
.height
= self
->session
->h
;
724 XResizeWindow(ob_display
, self
->window
,
725 self
->area
.width
, self
->area
.height
);
727 self
->desktop
= (self
->session
->desktop
== DESKTOP_ALL
?
728 self
->session
->desktop
:
729 MIN(screen_num_desktops
- 1, self
->session
->desktop
));
730 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
732 self
->shaded
= self
->session
->shaded
;
733 self
->iconic
= self
->session
->iconic
;
734 self
->skip_pager
= self
->session
->skip_pager
;
735 self
->skip_taskbar
= self
->session
->skip_taskbar
;
736 self
->fullscreen
= self
->session
->fullscreen
;
737 self
->above
= self
->session
->above
;
738 self
->below
= self
->session
->below
;
739 self
->max_horz
= self
->session
->max_horz
;
740 self
->max_vert
= self
->session
->max_vert
;
741 self
->undecorated
= self
->session
->undecorated
;
744 static gboolean
client_restore_session_stacking(ObClient
*self
)
748 if (!self
->session
) return FALSE
;
750 mypos
= g_list_find(session_saved_state
, self
->session
);
751 if (!mypos
) return FALSE
;
753 /* start above me and look for the first client */
754 for (it
= g_list_previous(mypos
); it
; it
= g_list_previous(it
)) {
757 for (cit
= client_list
; cit
; cit
= g_list_next(cit
)) {
758 ObClient
*c
= cit
->data
;
759 /* found a client that was in the session, so go below it */
760 if (c
->session
== it
->data
) {
761 stacking_below(CLIENT_AS_WINDOW(self
),
762 CLIENT_AS_WINDOW(cit
->data
));
770 void client_move_onscreen(ObClient
*self
, gboolean rude
)
772 gint x
= self
->area
.x
;
773 gint y
= self
->area
.y
;
774 if (client_find_onscreen(self
, &x
, &y
,
776 self
->area
.height
, rude
)) {
777 client_move(self
, x
, y
);
781 gboolean
client_find_onscreen(ObClient
*self
, gint
*x
, gint
*y
, gint w
, gint h
,
785 gint ox
= *x
, oy
= *y
;
786 gboolean rudel
= rude
, ruder
= rude
, rudet
= rude
, rudeb
= rude
;
789 all_a
= screen_area(self
->desktop
);
790 mon_a
= screen_area_monitor(self
->desktop
, client_monitor(self
));
792 /* get where the frame would be */
793 frame_client_gravity(self
->frame
, x
, y
, w
, h
);
795 /* get the requested size of the window with decorations */
796 fw
= self
->frame
->size
.left
+ w
+ self
->frame
->size
.right
;
797 fh
= self
->frame
->size
.top
+ h
+ self
->frame
->size
.bottom
;
799 /* This makes sure windows aren't entirely outside of the screen so you
800 can't see them at all.
801 It makes sure 10% of the window is on the screen at least. At don't let
802 it move itself off the top of the screen, which would hide the titlebar
803 on you. (The user can still do this if they want too, it's only limiting
806 XXX watch for xinerama dead areas...
808 if (client_normal(self
)) {
809 if (!self
->strut
.right
&& *x
+ fw
/10 >= all_a
->x
+ all_a
->width
- 1)
810 *x
= all_a
->x
+ all_a
->width
- fw
/10;
811 if (!self
->strut
.bottom
&& *y
+ fh
/10 >= all_a
->y
+ all_a
->height
- 1)
812 *y
= all_a
->y
+ all_a
->height
- fh
/10;
813 if (!self
->strut
.left
&& *x
+ fw
*9/10 - 1 < all_a
->x
)
814 *x
= all_a
->x
- fw
*9/10;
815 if (!self
->strut
.top
&& *y
+ fh
*9/10 - 1 < all_a
->y
)
816 *y
= all_a
->y
- fw
*9/10;
819 /* If rudeness wasn't requested, then figure out of the client is currently
820 entirely on the screen. If it is, and the position isn't changing by
821 request, and it is enlarging, then be rude even though it wasn't
824 Point oldtl
, oldtr
, oldbl
, oldbr
;
825 Point newtl
, newtr
, newbl
, newbr
;
826 gboolean stationary_l
, stationary_r
, stationary_t
, stationary_b
;
828 POINT_SET(oldtl
, self
->frame
->area
.x
, self
->frame
->area
.y
);
829 POINT_SET(oldbr
, self
->frame
->area
.x
+ self
->frame
->area
.width
- 1,
830 self
->frame
->area
.y
+ self
->frame
->area
.height
- 1);
831 POINT_SET(oldtr
, oldbr
.x
, oldtl
.y
);
832 POINT_SET(oldbl
, oldtl
.x
, oldbr
.y
);
834 POINT_SET(newtl
, *x
, *y
);
835 POINT_SET(newbr
, *x
+ fw
- 1, *y
+ fh
- 1);
836 POINT_SET(newtr
, newbr
.x
, newtl
.y
);
837 POINT_SET(newbl
, newtl
.x
, newbr
.y
);
839 /* is it moving or just resizing from some corner? */
840 stationary_l
= oldtl
.x
== oldtl
.x
;
841 stationary_r
= oldtr
.x
== oldtr
.x
;
842 stationary_t
= oldtl
.y
== oldtl
.y
;
843 stationary_b
= oldbl
.y
== oldbl
.y
;
845 /* if left edge is growing and didnt move right edge */
846 if (stationary_r
&& newtl
.x
< oldtl
.x
)
848 /* if right edge is growing and didnt move left edge */
849 if (stationary_l
&& newtr
.x
> oldtr
.x
)
851 /* if top edge is growing and didnt move bottom edge */
852 if (stationary_b
&& newtl
.y
< oldtl
.y
)
854 /* if bottom edge is growing and didnt move top edge */
855 if (stationary_t
&& newbl
.y
> oldbl
.y
)
859 /* This here doesn't let windows even a pixel outside the struts/screen.
860 * When called from client_manage, programs placing themselves are
861 * forced completely onscreen, while things like
862 * xterm -geometry resolution-width/2 will work fine. Trying to
863 * place it completely offscreen will be handled in the above code.
864 * Sorry for this confused comment, i am tired. */
865 if (fw
<= mon_a
->width
) {
866 if (rudel
&& !self
->strut
.left
&& *x
< mon_a
->x
) *x
= mon_a
->x
;
867 if (ruder
&& !self
->strut
.right
&& *x
+ fw
> mon_a
->x
+ mon_a
->width
)
868 *x
= mon_a
->x
+ mon_a
->width
- fw
;
870 if (fh
<= mon_a
->height
) {
871 if (rudet
&& !self
->strut
.top
&& *y
< mon_a
->y
) *y
= mon_a
->y
;
872 if (rudeb
&& !self
->strut
.bottom
&& *y
+ fh
> mon_a
->y
+ mon_a
->height
)
873 *y
= mon_a
->y
+ mon_a
->height
- fh
;
876 /* get where the client should be */
877 frame_frame_gravity(self
->frame
, x
, y
, w
, h
);
879 return ox
!= *x
|| oy
!= *y
;
882 static void client_toggle_border(ObClient
*self
, gboolean show
)
884 /* adjust our idea of where the client is, based on its border. When the
885 border is removed, the client should now be considered to be in a
887 when re-adding the border to the client, the same operation needs to be
889 gint oldx
= self
->area
.x
, oldy
= self
->area
.y
;
890 gint x
= oldx
, y
= oldy
;
891 switch(self
->gravity
) {
893 case NorthWestGravity
:
895 case SouthWestGravity
:
897 case NorthEastGravity
:
899 case SouthEastGravity
:
900 if (show
) x
-= self
->border_width
* 2;
901 else x
+= self
->border_width
* 2;
908 if (show
) x
-= self
->border_width
;
909 else x
+= self
->border_width
;
912 switch(self
->gravity
) {
914 case NorthWestGravity
:
916 case NorthEastGravity
:
918 case SouthWestGravity
:
920 case SouthEastGravity
:
921 if (show
) y
-= self
->border_width
* 2;
922 else y
+= self
->border_width
* 2;
929 if (show
) y
-= self
->border_width
;
930 else y
+= self
->border_width
;
937 XSetWindowBorderWidth(ob_display
, self
->window
, self
->border_width
);
939 /* set border_width to 0 because there is no border to add into
940 calculations anymore */
941 self
->border_width
= 0;
943 XSetWindowBorderWidth(ob_display
, self
->window
, 0);
947 static void client_get_all(ObClient
*self
)
949 client_get_area(self
);
950 client_get_mwm_hints(self
);
952 /* The transient-ness of a window is used to pick a type, but the type can
953 also affect transiency.
955 Dialogs are always made transients for their group if they have one.
957 I also have made non-application type windows be transients for their
958 group (eg utility windows).
960 client_get_transientness(self
);
961 client_get_type(self
);/* this can change the mwmhints for special cases */
962 client_get_state(self
);
964 client_update_wmhints(self
);
965 /* this may have already been called from client_update_wmhints */
966 if (self
->transient_for
== NULL
)
967 client_update_transient_for(self
);
968 client_get_startup_id(self
);
969 client_get_desktop(self
);/* uses transient data/group/startup id if a
970 desktop is not specified */
971 client_get_shaped(self
);
973 client_get_layer(self
); /* if layer hasn't been specified, get it from
974 other sources if possible */
977 /* a couple type-based defaults for new windows */
979 /* this makes sure that these windows appear on all desktops */
980 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
981 self
->desktop
= DESKTOP_ALL
;
984 client_update_protocols(self
);
986 client_get_gravity(self
); /* get the attribute gravity */
987 client_update_normal_hints(self
); /* this may override the attribute
990 /* got the type, the mwmhints, the protocols, and the normal hints
991 (min/max sizes), so we're ready to set up the decorations/functions */
992 client_setup_decor_and_functions(self
);
995 client_update_sync_request_counter(self
);
997 client_get_client_machine(self
);
998 client_get_colormap(self
);
999 client_update_title(self
);
1000 client_update_class(self
);
1001 client_update_sm_client_id(self
);
1002 client_update_command(self
);
1003 client_update_strut(self
);
1004 client_update_icons(self
);
1005 client_update_user_time(self
);
1006 client_update_icon_geometry(self
);
1009 static void client_get_startup_id(ObClient
*self
)
1011 if (!(PROP_GETS(self
->window
, net_startup_id
, utf8
, &self
->startup_id
)))
1013 PROP_GETS(self
->group
->leader
,
1014 net_startup_id
, utf8
, &self
->startup_id
);
1017 static void client_get_area(ObClient
*self
)
1019 XWindowAttributes wattrib
;
1022 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1023 g_assert(ret
!= BadWindow
);
1025 RECT_SET(self
->area
, wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
1026 POINT_SET(self
->root_pos
, wattrib
.x
, wattrib
.y
);
1027 self
->border_width
= wattrib
.border_width
;
1029 ob_debug("client area: %d %d %d %d\n", wattrib
.x
, wattrib
.y
,
1030 wattrib
.width
, wattrib
.height
);
1033 static void client_get_desktop(ObClient
*self
)
1035 guint32 d
= screen_num_desktops
; /* an always-invalid value */
1037 if (PROP_GET32(self
->window
, net_wm_desktop
, cardinal
, &d
)) {
1038 if (d
>= screen_num_desktops
&& d
!= DESKTOP_ALL
)
1039 self
->desktop
= screen_num_desktops
- 1;
1043 gboolean trdesk
= FALSE
;
1045 if (self
->transient_for
) {
1046 if (self
->transient_for
!= OB_TRAN_GROUP
) {
1047 self
->desktop
= self
->transient_for
->desktop
;
1052 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
1053 if (it
->data
!= self
&&
1054 !((ObClient
*)it
->data
)->transient_for
) {
1055 self
->desktop
= ((ObClient
*)it
->data
)->desktop
;
1062 /* try get from the startup-notification protocol */
1063 if (sn_get_desktop(self
->startup_id
, &self
->desktop
)) {
1064 if (self
->desktop
>= screen_num_desktops
&&
1065 self
->desktop
!= DESKTOP_ALL
)
1066 self
->desktop
= screen_num_desktops
- 1;
1068 /* defaults to the current desktop */
1069 self
->desktop
= screen_desktop
;
1074 static void client_get_layer(ObClient
*self
)
1076 if (!(self
->above
|| self
->below
)) {
1078 /* apply stuff from the group */
1082 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
1083 ObClient
*c
= it
->data
;
1084 if (c
!= self
&& !client_search_transient(self
, c
) &&
1085 client_normal(self
) && client_normal(c
))
1088 (c
->above
? 1 : (c
->below
? -1 : 0)));
1102 g_assert_not_reached();
1109 static void client_get_state(ObClient
*self
)
1114 if (PROP_GETA32(self
->window
, net_wm_state
, atom
, &state
, &num
)) {
1116 for (i
= 0; i
< num
; ++i
) {
1117 if (state
[i
] == prop_atoms
.net_wm_state_modal
)
1119 else if (state
[i
] == prop_atoms
.net_wm_state_shaded
)
1120 self
->shaded
= TRUE
;
1121 else if (state
[i
] == prop_atoms
.net_wm_state_hidden
)
1122 self
->iconic
= TRUE
;
1123 else if (state
[i
] == prop_atoms
.net_wm_state_skip_taskbar
)
1124 self
->skip_taskbar
= TRUE
;
1125 else if (state
[i
] == prop_atoms
.net_wm_state_skip_pager
)
1126 self
->skip_pager
= TRUE
;
1127 else if (state
[i
] == prop_atoms
.net_wm_state_fullscreen
)
1128 self
->fullscreen
= TRUE
;
1129 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_vert
)
1130 self
->max_vert
= TRUE
;
1131 else if (state
[i
] == prop_atoms
.net_wm_state_maximized_horz
)
1132 self
->max_horz
= TRUE
;
1133 else if (state
[i
] == prop_atoms
.net_wm_state_above
)
1135 else if (state
[i
] == prop_atoms
.net_wm_state_below
)
1137 else if (state
[i
] == prop_atoms
.net_wm_state_demands_attention
)
1138 self
->demands_attention
= TRUE
;
1139 else if (state
[i
] == prop_atoms
.openbox_wm_state_undecorated
)
1140 self
->undecorated
= TRUE
;
1147 static void client_get_shaped(ObClient
*self
)
1149 self
->shaped
= FALSE
;
1151 if (extensions_shape
) {
1156 XShapeSelectInput(ob_display
, self
->window
, ShapeNotifyMask
);
1158 XShapeQueryExtents(ob_display
, self
->window
, &s
, &foo
,
1159 &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
, &ufoo
,
1161 self
->shaped
= (s
!= 0);
1166 void client_get_transientness(ObClient
*self
)
1169 if (XGetTransientForHint(ob_display
, self
->window
, &t
))
1170 self
->transient
= TRUE
;
1173 void client_update_transient_for(ObClient
*self
)
1176 ObClient
*target
= NULL
;
1178 if (XGetTransientForHint(ob_display
, self
->window
, &t
)) {
1179 self
->transient
= TRUE
;
1180 if (t
!= self
->window
) { /* cant be transient to itself! */
1181 target
= g_hash_table_lookup(window_map
, &t
);
1182 /* if this happens then we need to check for it*/
1183 g_assert(target
!= self
);
1184 if (target
&& !WINDOW_IS_CLIENT(target
)) {
1185 /* this can happen when a dialog is a child of
1186 a dockapp, for example */
1190 /* THIS IS SO ANNOYING ! ! ! ! Let me explain.... have a seat..
1192 Setting the transient_for to Root is actually illegal, however
1193 applications from time have done this to specify transient for
1196 Now you can do that by being a TYPE_DIALOG and not setting
1197 the transient_for hint at all on your window. But people still
1198 use Root, and Kwin is very strange in this regard.
1200 KWin 3.0 will not consider windows with transient_for set to
1201 Root as transient for their group *UNLESS* they are also modal.
1202 In that case, it will make them transient for the group. This
1203 leads to all sorts of weird behavior from KDE apps which are
1204 only tested in KWin. I'd like to follow their behavior just to
1205 make this work right with KDE stuff, but that seems wrong.
1207 if (!target
&& self
->group
) {
1208 /* not transient to a client, see if it is transient for a
1210 if (t
== RootWindow(ob_display
, ob_screen
)) {
1211 /* window is a transient for its group! */
1212 target
= OB_TRAN_GROUP
;
1216 } else if (self
->type
== OB_CLIENT_TYPE_DIALOG
||
1217 self
->type
== OB_CLIENT_TYPE_TOOLBAR
||
1218 self
->type
== OB_CLIENT_TYPE_MENU
||
1219 self
->type
== OB_CLIENT_TYPE_UTILITY
)
1221 self
->transient
= TRUE
;
1223 target
= OB_TRAN_GROUP
;
1225 self
->transient
= FALSE
;
1227 client_update_transient_tree(self
, self
->group
, self
->group
,
1228 self
->transient_for
, target
);
1229 self
->transient_for
= target
;
1233 static void client_update_transient_tree(ObClient
*self
,
1234 ObGroup
*oldgroup
, ObGroup
*newgroup
,
1235 ObClient
* oldparent
,
1236 ObClient
*newparent
)
1241 /* No change has occured */
1242 if (oldgroup
== newgroup
&& oldparent
== newparent
) return;
1244 /** Remove the client from the transient tree wherever it has changed **/
1246 /* If the window is becoming a direct transient for a window in its group
1247 then that window can't be a child of this window anymore */
1248 if (oldparent
!= newparent
&&
1249 newparent
!= NULL
&& newparent
!= OB_TRAN_GROUP
&&
1250 newparent
->transient_for
== OB_TRAN_GROUP
&&
1251 newgroup
!= NULL
&& newgroup
== oldgroup
)
1253 self
->transients
= g_slist_remove(self
->transients
, newparent
);
1257 /* If the group changed then we need to remove any old group transient
1258 windows from our children. But if we're transient for the group, then
1259 other group transients are not our children. */
1260 if (oldgroup
!= newgroup
&& oldgroup
!= NULL
&&
1261 oldparent
!= OB_TRAN_GROUP
)
1263 for (it
= self
->transients
; it
; it
= next
) {
1264 next
= g_slist_next(it
);
1266 if (c
->group
== oldgroup
)
1267 self
->transients
= g_slist_delete_link(self
->transients
, it
);
1271 /* If we used to be transient for a group and now we are not, or we're
1272 transient for a new group, then we need to remove ourselves from all
1274 if (oldparent
== OB_TRAN_GROUP
&& (oldgroup
!= newgroup
||
1275 oldparent
!= newparent
))
1277 for (it
= oldgroup
->members
; it
; it
= g_slist_next(it
)) {
1279 if (c
!= self
&& (!c
->transient_for
||
1280 c
->transient_for
!= OB_TRAN_GROUP
))
1281 c
->transients
= g_slist_remove(c
->transients
, self
);
1284 /* If we used to be transient for a single window and we are no longer
1285 transient for it, then we need to remove ourself from its children */
1286 else if (oldparent
!= NULL
&& oldparent
!= OB_TRAN_GROUP
&&
1287 oldparent
!= newparent
)
1288 oldparent
->transients
= g_slist_remove(oldparent
->transients
, self
);
1291 /** Re-add the client to the transient tree wherever it has changed **/
1293 /* If we're now transient for a group and we weren't transient for it
1294 before then we need to add ourselves to all our new parents */
1295 if (newparent
== OB_TRAN_GROUP
&& (oldgroup
!= newgroup
||
1296 oldparent
!= newparent
))
1298 for (it
= oldgroup
->members
; it
; it
= g_slist_next(it
)) {
1300 if (c
!= self
&& (!c
->transient_for
||
1301 c
->transient_for
!= OB_TRAN_GROUP
))
1302 c
->transients
= g_slist_prepend(c
->transients
, self
);
1305 /* If we are now transient for a single window which we weren't before,
1306 we need to add ourselves to its children
1308 WARNING: Cyclical transient ness is possible if two windows are
1309 transient for eachother.
1311 else if (newparent
!= NULL
&& newparent
!= OB_TRAN_GROUP
&&
1312 newparent
!= oldparent
&&
1313 /* don't make ourself its child if it is already our child */
1314 !client_is_direct_child(self
, newparent
))
1315 newparent
->transients
= g_slist_prepend(newparent
->transients
, self
);
1317 /* If the group changed then we need to add any new group transient
1318 windows to our children. But if we're transient for the group, then
1319 other group transients are not our children.
1321 WARNING: Cyclical transient-ness is possible. For e.g. if:
1322 A is transient for the group
1323 B is a member of the group and transient for A
1325 if (oldgroup
!= newgroup
&& newgroup
!= NULL
&&
1326 newparent
!= OB_TRAN_GROUP
)
1328 for (it
= newgroup
->members
; it
; it
= g_slist_next(it
)) {
1330 if (c
!= self
&& c
->transient_for
== OB_TRAN_GROUP
&&
1331 /* Don't make it our child if it is already our parent */
1332 !client_is_direct_child(c
, self
))
1334 self
->transients
= g_slist_prepend(self
->transients
, c
);
1340 static void client_get_mwm_hints(ObClient
*self
)
1345 self
->mwmhints
.flags
= 0; /* default to none */
1347 if (PROP_GETA32(self
->window
, motif_wm_hints
, motif_wm_hints
,
1349 if (num
>= OB_MWM_ELEMENTS
) {
1350 self
->mwmhints
.flags
= hints
[0];
1351 self
->mwmhints
.functions
= hints
[1];
1352 self
->mwmhints
.decorations
= hints
[2];
1358 void client_get_type(ObClient
*self
)
1365 if (PROP_GETA32(self
->window
, net_wm_window_type
, atom
, &val
, &num
)) {
1366 /* use the first value that we know about in the array */
1367 for (i
= 0; i
< num
; ++i
) {
1368 if (val
[i
] == prop_atoms
.net_wm_window_type_desktop
)
1369 self
->type
= OB_CLIENT_TYPE_DESKTOP
;
1370 else if (val
[i
] == prop_atoms
.net_wm_window_type_dock
)
1371 self
->type
= OB_CLIENT_TYPE_DOCK
;
1372 else if (val
[i
] == prop_atoms
.net_wm_window_type_toolbar
)
1373 self
->type
= OB_CLIENT_TYPE_TOOLBAR
;
1374 else if (val
[i
] == prop_atoms
.net_wm_window_type_menu
)
1375 self
->type
= OB_CLIENT_TYPE_MENU
;
1376 else if (val
[i
] == prop_atoms
.net_wm_window_type_utility
)
1377 self
->type
= OB_CLIENT_TYPE_UTILITY
;
1378 else if (val
[i
] == prop_atoms
.net_wm_window_type_splash
)
1379 self
->type
= OB_CLIENT_TYPE_SPLASH
;
1380 else if (val
[i
] == prop_atoms
.net_wm_window_type_dialog
)
1381 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1382 else if (val
[i
] == prop_atoms
.net_wm_window_type_normal
)
1383 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1384 else if (val
[i
] == prop_atoms
.kde_net_wm_window_type_override
) {
1385 /* prevent this window from getting any decor or
1387 self
->mwmhints
.flags
&= (OB_MWM_FLAG_FUNCTIONS
|
1388 OB_MWM_FLAG_DECORATIONS
);
1389 self
->mwmhints
.decorations
= 0;
1390 self
->mwmhints
.functions
= 0;
1392 if (self
->type
!= (ObClientType
) -1)
1393 break; /* grab the first legit type */
1398 if (self
->type
== (ObClientType
) -1) {
1399 /*the window type hint was not set, which means we either classify
1400 ourself as a normal window or a dialog, depending on if we are a
1402 if (self
->transient
)
1403 self
->type
= OB_CLIENT_TYPE_DIALOG
;
1405 self
->type
= OB_CLIENT_TYPE_NORMAL
;
1409 void client_update_protocols(ObClient
*self
)
1412 guint num_return
, i
;
1414 self
->focus_notify
= FALSE
;
1415 self
->delete_window
= FALSE
;
1417 if (PROP_GETA32(self
->window
, wm_protocols
, atom
, &proto
, &num_return
)) {
1418 for (i
= 0; i
< num_return
; ++i
) {
1419 if (proto
[i
] == prop_atoms
.wm_delete_window
)
1420 /* this means we can request the window to close */
1421 self
->delete_window
= TRUE
;
1422 else if (proto
[i
] == prop_atoms
.wm_take_focus
)
1423 /* if this protocol is requested, then the window will be
1424 notified whenever we want it to receive focus */
1425 self
->focus_notify
= TRUE
;
1427 else if (proto
[i
] == prop_atoms
.net_wm_sync_request
)
1428 /* if this protocol is requested, then resizing the
1429 window will be synchronized between the frame and the
1431 self
->sync_request
= TRUE
;
1439 void client_update_sync_request_counter(ObClient
*self
)
1443 if (PROP_GET32(self
->window
, net_wm_sync_request_counter
, cardinal
, &i
)) {
1444 self
->sync_counter
= i
;
1446 self
->sync_counter
= None
;
1450 static void client_get_gravity(ObClient
*self
)
1452 XWindowAttributes wattrib
;
1455 ret
= XGetWindowAttributes(ob_display
, self
->window
, &wattrib
);
1456 g_assert(ret
!= BadWindow
);
1457 self
->gravity
= wattrib
.win_gravity
;
1460 void client_get_colormap(ObClient
*self
)
1462 XWindowAttributes wa
;
1464 if (XGetWindowAttributes(ob_display
, self
->window
, &wa
))
1465 client_update_colormap(self
, wa
.colormap
);
1468 void client_update_colormap(ObClient
*self
, Colormap colormap
)
1470 self
->colormap
= colormap
;
1473 void client_update_normal_hints(ObClient
*self
)
1477 gint oldgravity
= self
->gravity
;
1480 self
->min_ratio
= 0.0f
;
1481 self
->max_ratio
= 0.0f
;
1482 SIZE_SET(self
->size_inc
, 1, 1);
1483 SIZE_SET(self
->base_size
, 0, 0);
1484 SIZE_SET(self
->min_size
, 0, 0);
1485 SIZE_SET(self
->max_size
, G_MAXINT
, G_MAXINT
);
1487 /* get the hints from the window */
1488 if (XGetWMNormalHints(ob_display
, self
->window
, &size
, &ret
)) {
1489 /* normal windows can't request placement! har har
1490 if (!client_normal(self))
1492 self
->positioned
= (size
.flags
& (PPosition
|USPosition
));
1494 if (size
.flags
& PWinGravity
) {
1495 self
->gravity
= size
.win_gravity
;
1497 /* if the client has a frame, i.e. has already been mapped and
1498 is changing its gravity */
1499 if (self
->frame
&& self
->gravity
!= oldgravity
) {
1500 /* move our idea of the client's position based on its new
1502 client_convert_gravity(self
, oldgravity
,
1503 &self
->area
.x
, &self
->area
.y
,
1504 self
->area
.width
, self
->area
.height
);
1508 if (size
.flags
& PAspect
) {
1509 if (size
.min_aspect
.y
)
1511 (gfloat
) size
.min_aspect
.x
/ size
.min_aspect
.y
;
1512 if (size
.max_aspect
.y
)
1514 (gfloat
) size
.max_aspect
.x
/ size
.max_aspect
.y
;
1517 if (size
.flags
& PMinSize
)
1518 SIZE_SET(self
->min_size
, size
.min_width
, size
.min_height
);
1520 if (size
.flags
& PMaxSize
)
1521 SIZE_SET(self
->max_size
, size
.max_width
, size
.max_height
);
1523 if (size
.flags
& PBaseSize
)
1524 SIZE_SET(self
->base_size
, size
.base_width
, size
.base_height
);
1526 if (size
.flags
& PResizeInc
&& size
.width_inc
&& size
.height_inc
)
1527 SIZE_SET(self
->size_inc
, size
.width_inc
, size
.height_inc
);
1531 void client_setup_decor_and_functions(ObClient
*self
)
1533 /* start with everything (cept fullscreen) */
1535 (OB_FRAME_DECOR_TITLEBAR
|
1536 OB_FRAME_DECOR_HANDLE
|
1537 OB_FRAME_DECOR_GRIPS
|
1538 OB_FRAME_DECOR_BORDER
|
1539 OB_FRAME_DECOR_ICON
|
1540 OB_FRAME_DECOR_ALLDESKTOPS
|
1541 OB_FRAME_DECOR_ICONIFY
|
1542 OB_FRAME_DECOR_MAXIMIZE
|
1543 OB_FRAME_DECOR_SHADE
|
1544 OB_FRAME_DECOR_CLOSE
);
1546 (OB_CLIENT_FUNC_RESIZE
|
1547 OB_CLIENT_FUNC_MOVE
|
1548 OB_CLIENT_FUNC_ICONIFY
|
1549 OB_CLIENT_FUNC_MAXIMIZE
|
1550 OB_CLIENT_FUNC_SHADE
|
1551 OB_CLIENT_FUNC_CLOSE
);
1553 if (!(self
->min_size
.width
< self
->max_size
.width
||
1554 self
->min_size
.height
< self
->max_size
.height
))
1555 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1557 switch (self
->type
) {
1558 case OB_CLIENT_TYPE_NORMAL
:
1559 /* normal windows retain all of the possible decorations and
1560 functionality, and are the only windows that you can fullscreen */
1561 self
->functions
|= OB_CLIENT_FUNC_FULLSCREEN
;
1564 case OB_CLIENT_TYPE_DIALOG
:
1565 case OB_CLIENT_TYPE_UTILITY
:
1566 /* these windows cannot be maximized */
1567 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1570 case OB_CLIENT_TYPE_MENU
:
1571 case OB_CLIENT_TYPE_TOOLBAR
:
1572 /* these windows get less functionality */
1573 self
->functions
&= ~(OB_CLIENT_FUNC_ICONIFY
| OB_CLIENT_FUNC_RESIZE
);
1576 case OB_CLIENT_TYPE_DESKTOP
:
1577 case OB_CLIENT_TYPE_DOCK
:
1578 case OB_CLIENT_TYPE_SPLASH
:
1579 /* none of these windows are manipulated by the window manager */
1580 self
->decorations
= 0;
1581 self
->functions
= 0;
1585 /* Mwm Hints are applied subtractively to what has already been chosen for
1586 decor and functionality */
1587 if (self
->mwmhints
.flags
& OB_MWM_FLAG_DECORATIONS
) {
1588 if (! (self
->mwmhints
.decorations
& OB_MWM_DECOR_ALL
)) {
1589 if (! ((self
->mwmhints
.decorations
& OB_MWM_DECOR_HANDLE
) ||
1590 (self
->mwmhints
.decorations
& OB_MWM_DECOR_TITLE
)))
1592 /* if the mwm hints request no handle or title, then all
1593 decorations are disabled, but keep the border if that's
1595 if (self
->mwmhints
.decorations
& OB_MWM_DECOR_BORDER
)
1596 self
->decorations
= OB_FRAME_DECOR_BORDER
;
1598 self
->decorations
= 0;
1603 if (self
->mwmhints
.flags
& OB_MWM_FLAG_FUNCTIONS
) {
1604 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_ALL
)) {
1605 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_RESIZE
))
1606 self
->functions
&= ~OB_CLIENT_FUNC_RESIZE
;
1607 if (! (self
->mwmhints
.functions
& OB_MWM_FUNC_MOVE
))
1608 self
->functions
&= ~OB_CLIENT_FUNC_MOVE
;
1609 /* dont let mwm hints kill any buttons
1610 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1611 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1612 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1613 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1615 /* dont let mwm hints kill the close button
1616 if (! (self->mwmhints.functions & MwmFunc_Close))
1617 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1621 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
))
1622 self
->decorations
&= ~OB_FRAME_DECOR_SHADE
;
1623 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
))
1624 self
->decorations
&= ~OB_FRAME_DECOR_ICONIFY
;
1625 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
))
1626 self
->decorations
&= ~OB_FRAME_DECOR_GRIPS
;
1628 /* can't maximize without moving/resizing */
1629 if (!((self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) &&
1630 (self
->functions
& OB_CLIENT_FUNC_MOVE
) &&
1631 (self
->functions
& OB_CLIENT_FUNC_RESIZE
))) {
1632 self
->functions
&= ~OB_CLIENT_FUNC_MAXIMIZE
;
1633 self
->decorations
&= ~OB_FRAME_DECOR_MAXIMIZE
;
1636 /* kill the handle on fully maxed windows */
1637 if (self
->max_vert
&& self
->max_horz
)
1638 self
->decorations
&= ~OB_FRAME_DECOR_HANDLE
;
1640 /* finally, the user can have requested no decorations, which overrides
1641 everything (but doesnt give it a border if it doesnt have one) */
1642 if (self
->undecorated
) {
1643 if (config_theme_keepborder
)
1644 self
->decorations
&= OB_FRAME_DECOR_BORDER
;
1646 self
->decorations
= 0;
1649 /* if we don't have a titlebar, then we cannot shade! */
1650 if (!(self
->decorations
& OB_FRAME_DECOR_TITLEBAR
))
1651 self
->functions
&= ~OB_CLIENT_FUNC_SHADE
;
1653 /* now we need to check against rules for the client's current state */
1654 if (self
->fullscreen
) {
1655 self
->functions
&= (OB_CLIENT_FUNC_CLOSE
|
1656 OB_CLIENT_FUNC_FULLSCREEN
|
1657 OB_CLIENT_FUNC_ICONIFY
);
1658 self
->decorations
= 0;
1661 client_change_allowed_actions(self
);
1664 /* adjust the client's decorations, etc. */
1665 client_reconfigure(self
);
1669 static void client_change_allowed_actions(ObClient
*self
)
1674 /* desktop windows are kept on all desktops */
1675 if (self
->type
!= OB_CLIENT_TYPE_DESKTOP
)
1676 actions
[num
++] = prop_atoms
.net_wm_action_change_desktop
;
1678 if (self
->functions
& OB_CLIENT_FUNC_SHADE
)
1679 actions
[num
++] = prop_atoms
.net_wm_action_shade
;
1680 if (self
->functions
& OB_CLIENT_FUNC_CLOSE
)
1681 actions
[num
++] = prop_atoms
.net_wm_action_close
;
1682 if (self
->functions
& OB_CLIENT_FUNC_MOVE
)
1683 actions
[num
++] = prop_atoms
.net_wm_action_move
;
1684 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
)
1685 actions
[num
++] = prop_atoms
.net_wm_action_minimize
;
1686 if (self
->functions
& OB_CLIENT_FUNC_RESIZE
)
1687 actions
[num
++] = prop_atoms
.net_wm_action_resize
;
1688 if (self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
)
1689 actions
[num
++] = prop_atoms
.net_wm_action_fullscreen
;
1690 if (self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) {
1691 actions
[num
++] = prop_atoms
.net_wm_action_maximize_horz
;
1692 actions
[num
++] = prop_atoms
.net_wm_action_maximize_vert
;
1695 PROP_SETA32(self
->window
, net_wm_allowed_actions
, atom
, actions
, num
);
1697 /* make sure the window isn't breaking any rules now */
1699 if (!(self
->functions
& OB_CLIENT_FUNC_SHADE
) && self
->shaded
) {
1700 if (self
->frame
) client_shade(self
, FALSE
);
1701 else self
->shaded
= FALSE
;
1703 if (!(self
->functions
& OB_CLIENT_FUNC_ICONIFY
) && self
->iconic
) {
1704 if (self
->frame
) client_iconify(self
, FALSE
, TRUE
);
1705 else self
->iconic
= FALSE
;
1707 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) && self
->fullscreen
) {
1708 if (self
->frame
) client_fullscreen(self
, FALSE
);
1709 else self
->fullscreen
= FALSE
;
1711 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
) && (self
->max_horz
||
1713 if (self
->frame
) client_maximize(self
, FALSE
, 0);
1714 else self
->max_vert
= self
->max_horz
= FALSE
;
1718 void client_reconfigure(ObClient
*self
)
1720 /* by making this pass FALSE for user, we avoid the emacs event storm where
1721 every configurenotify causes an update in its normal hints, i think this
1722 is generally what we want anyways... */
1723 client_configure(self
, self
->area
.x
, self
->area
.y
,
1724 self
->area
.width
, self
->area
.height
, FALSE
, TRUE
);
1727 void client_update_wmhints(ObClient
*self
)
1731 /* assume a window takes input if it doesnt specify */
1732 self
->can_focus
= TRUE
;
1734 if ((hints
= XGetWMHints(ob_display
, self
->window
)) != NULL
) {
1737 if (hints
->flags
& InputHint
)
1738 self
->can_focus
= hints
->input
;
1740 /* only do this when first managing the window *AND* when we aren't
1742 if (ob_state() != OB_STATE_STARTING
&& self
->frame
== NULL
)
1743 if (hints
->flags
& StateHint
)
1744 self
->iconic
= hints
->initial_state
== IconicState
;
1747 self
->urgent
= (hints
->flags
& XUrgencyHint
);
1748 if (self
->urgent
&& !ur
)
1749 client_hilite(self
, TRUE
);
1750 else if (!self
->urgent
&& ur
&& self
->demands_attention
)
1751 client_hilite(self
, FALSE
);
1753 if (!(hints
->flags
& WindowGroupHint
))
1754 hints
->window_group
= None
;
1756 /* did the group state change? */
1757 if (hints
->window_group
!=
1758 (self
->group
? self
->group
->leader
: None
))
1760 ObGroup
*oldgroup
= self
->group
;
1762 /* remove from the old group if there was one */
1763 if (self
->group
!= NULL
) {
1764 group_remove(self
->group
, self
);
1768 /* add ourself to the group if we have one */
1769 if (hints
->window_group
!= None
) {
1770 self
->group
= group_add(hints
->window_group
, self
);
1773 /* Put ourselves into the new group's transient tree, and remove
1774 ourselves from the old group's */
1775 client_update_transient_tree(self
, oldgroup
, self
->group
,
1776 self
->transient_for
,
1777 self
->transient_for
);
1779 /* Lastly, being in a group, or not, can change if the window is
1780 transient for anything.
1782 The logic for this is:
1783 self->transient = TRUE always if the window wants to be
1784 transient for something, even if transient_for was NULL because
1785 it wasn't in a group before.
1787 If transient_for was NULL and oldgroup was NULL we can assume
1788 that when we add the new group, it will become transient for
1791 If transient_for was OB_TRAN_GROUP, then it must have already
1792 had a group. If it is getting a new group, the above call to
1793 client_update_transient_tree has already taken care of
1794 everything ! If it is losing all group status then it will
1795 no longer be transient for anything and that needs to be
1798 if (self
->transient
&&
1799 ((self
->transient_for
== NULL
&& oldgroup
== NULL
) ||
1800 (self
->transient_for
== OB_TRAN_GROUP
&& !self
->group
)))
1801 client_update_transient_for(self
);
1804 /* the WM_HINTS can contain an icon */
1805 client_update_icons(self
);
1811 void client_update_title(ObClient
*self
)
1814 gchar
*visible
= NULL
;
1816 g_free(self
->title
);
1819 if (!PROP_GETS(self
->window
, net_wm_name
, utf8
, &data
)) {
1820 /* try old x stuff */
1821 if (!(PROP_GETS(self
->window
, wm_name
, locale
, &data
)
1822 || PROP_GETS(self
->window
, wm_name
, utf8
, &data
))) {
1823 if (self
->transient
) {
1825 GNOME alert windows are not given titles:
1826 http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1828 data
= g_strdup("");
1830 data
= g_strdup("Unnamed Window");
1834 if (self
->client_machine
) {
1835 visible
= g_strdup_printf("%s (%s)", data
, self
->client_machine
);
1840 PROP_SETS(self
->window
, net_wm_visible_name
, visible
);
1841 self
->title
= visible
;
1844 frame_adjust_title(self
->frame
);
1846 /* update the icon title */
1848 g_free(self
->icon_title
);
1851 if (!PROP_GETS(self
->window
, net_wm_icon_name
, utf8
, &data
))
1852 /* try old x stuff */
1853 if (!(PROP_GETS(self
->window
, wm_icon_name
, locale
, &data
) ||
1854 PROP_GETS(self
->window
, wm_icon_name
, utf8
, &data
)))
1855 data
= g_strdup(self
->title
);
1857 PROP_SETS(self
->window
, net_wm_visible_icon_name
, data
);
1858 self
->icon_title
= data
;
1861 void client_update_class(ObClient
*self
)
1866 if (self
->name
) g_free(self
->name
);
1867 if (self
->class) g_free(self
->class);
1868 if (self
->role
) g_free(self
->role
);
1870 self
->name
= self
->class = self
->role
= NULL
;
1872 if (PROP_GETSS(self
->window
, wm_class
, locale
, &data
)) {
1874 self
->name
= g_strdup(data
[0]);
1876 self
->class = g_strdup(data
[1]);
1881 if (PROP_GETS(self
->window
, wm_window_role
, locale
, &s
))
1884 if (self
->name
== NULL
) self
->name
= g_strdup("");
1885 if (self
->class == NULL
) self
->class = g_strdup("");
1886 if (self
->role
== NULL
) self
->role
= g_strdup("");
1889 void client_update_strut(ObClient
*self
)
1893 gboolean got
= FALSE
;
1896 if (PROP_GETA32(self
->window
, net_wm_strut_partial
, cardinal
,
1900 STRUT_PARTIAL_SET(strut
,
1901 data
[0], data
[2], data
[1], data
[3],
1902 data
[4], data
[5], data
[8], data
[9],
1903 data
[6], data
[7], data
[10], data
[11]);
1909 PROP_GETA32(self
->window
, net_wm_strut
, cardinal
, &data
, &num
)) {
1915 /* use the screen's width/height */
1916 a
= screen_physical_area();
1918 STRUT_PARTIAL_SET(strut
,
1919 data
[0], data
[2], data
[1], data
[3],
1920 a
->y
, a
->y
+ a
->height
- 1,
1921 a
->x
, a
->x
+ a
->width
- 1,
1922 a
->y
, a
->y
+ a
->height
- 1,
1923 a
->x
, a
->x
+ a
->width
- 1);
1929 STRUT_PARTIAL_SET(strut
, 0, 0, 0, 0,
1930 0, 0, 0, 0, 0, 0, 0, 0);
1932 if (!STRUT_EQUAL(strut
, self
->strut
)) {
1933 self
->strut
= strut
;
1935 /* updating here is pointless while we're being mapped cuz we're not in
1936 the client list yet */
1938 screen_update_areas();
1942 void client_update_icons(ObClient
*self
)
1948 for (i
= 0; i
< self
->nicons
; ++i
)
1949 g_free(self
->icons
[i
].data
);
1950 if (self
->nicons
> 0)
1951 g_free(self
->icons
);
1954 if (PROP_GETA32(self
->window
, net_wm_icon
, cardinal
, &data
, &num
)) {
1955 /* figure out how many valid icons are in here */
1957 while (num
- i
> 2) {
1961 if (i
> num
|| w
*h
== 0) break;
1965 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
1967 /* store the icons */
1969 for (j
= 0; j
< self
->nicons
; ++j
) {
1972 w
= self
->icons
[j
].width
= data
[i
++];
1973 h
= self
->icons
[j
].height
= data
[i
++];
1975 if (w
*h
== 0) continue;
1977 self
->icons
[j
].data
= g_new(RrPixel32
, w
* h
);
1978 for (x
= 0, y
= 0, t
= 0; t
< w
* h
; ++t
, ++x
, ++i
) {
1983 self
->icons
[j
].data
[t
] =
1984 (((data
[i
] >> 24) & 0xff) << RrDefaultAlphaOffset
) +
1985 (((data
[i
] >> 16) & 0xff) << RrDefaultRedOffset
) +
1986 (((data
[i
] >> 8) & 0xff) << RrDefaultGreenOffset
) +
1987 (((data
[i
] >> 0) & 0xff) << RrDefaultBlueOffset
);
1996 if ((hints
= XGetWMHints(ob_display
, self
->window
))) {
1997 if (hints
->flags
& IconPixmapHint
) {
1999 self
->icons
= g_new(ObClientIcon
, self
->nicons
);
2000 xerror_set_ignore(TRUE
);
2001 if (!RrPixmapToRGBA(ob_rr_inst
,
2003 (hints
->flags
& IconMaskHint
?
2004 hints
->icon_mask
: None
),
2005 &self
->icons
[self
->nicons
-1].width
,
2006 &self
->icons
[self
->nicons
-1].height
,
2007 &self
->icons
[self
->nicons
-1].data
)){
2008 g_free(&self
->icons
[self
->nicons
-1]);
2011 xerror_set_ignore(FALSE
);
2017 /* set the default icon onto the window
2018 in theory, this could be a race, but if a window doesn't set an icon
2019 or removes it entirely, it's not very likely it is going to set one
2020 right away afterwards */
2021 if (self
->nicons
== 0) {
2022 RrPixel32
*icon
= ob_rr_theme
->def_win_icon
;
2025 data
= g_new(gulong
, 48*48+2);
2026 data
[0] = data
[1] = 48;
2027 for (i
= 0; i
< 48*48; ++i
)
2028 data
[i
+2] = (((icon
[i
] >> RrDefaultAlphaOffset
) & 0xff) << 24) +
2029 (((icon
[i
] >> RrDefaultRedOffset
) & 0xff) << 16) +
2030 (((icon
[i
] >> RrDefaultGreenOffset
) & 0xff) << 8) +
2031 (((icon
[i
] >> RrDefaultBlueOffset
) & 0xff) << 0);
2032 PROP_SETA32(self
->window
, net_wm_icon
, cardinal
, data
, 48*48+2);
2034 } else if (self
->frame
)
2035 /* don't draw the icon empty if we're just setting one now anyways,
2036 we'll get the property change any second */
2037 frame_adjust_icon(self
->frame
);
2040 void client_update_user_time(ObClient
*self
)
2044 if (PROP_GET32(self
->window
, net_wm_user_time
, cardinal
, &time
)) {
2045 /* we set this every time, not just when it grows, because in practice
2046 sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
2047 backward we don't want all windows to stop focusing. we'll just
2048 assume noone is setting times older than the last one, cuz that
2049 would be pretty stupid anyways
2051 self
->user_time
= time
;
2054 ob_debug("window %s user time %u\n", self->title, time);
2059 void client_update_icon_geometry(ObClient
*self
)
2064 RECT_SET(self
->icon_geometry
, 0, 0, 0, 0);
2066 if (PROP_GETA32(self
->window
, net_wm_icon_geometry
, cardinal
, &data
, &num
)
2069 /* don't let them set it with an area < 0 */
2070 RECT_SET(self
->icon_geometry
, data
[0], data
[1],
2071 MAX(data
[2],0), MAX(data
[3],0));
2075 static void client_get_client_machine(ObClient
*self
)
2078 gchar localhost
[128];
2080 g_free(self
->client_machine
);
2082 if (PROP_GETS(self
->window
, wm_client_machine
, locale
, &data
) ||
2084 PROP_GETS(self
->group
->leader
, wm_client_machine
, locale
, &data
)))
2086 gethostname(localhost
, 127);
2087 localhost
[127] = '\0';
2088 if (strcmp(localhost
, data
))
2089 self
->client_machine
= data
;
2093 static void client_change_wm_state(ObClient
*self
)
2098 old
= self
->wmstate
;
2100 if (self
->shaded
|| !self
->frame
->visible
)
2101 self
->wmstate
= IconicState
;
2103 self
->wmstate
= NormalState
;
2105 if (old
!= self
->wmstate
) {
2106 PROP_MSG(self
->window
, kde_wm_change_state
,
2107 self
->wmstate
, 1, 0, 0);
2109 state
[0] = self
->wmstate
;
2111 PROP_SETA32(self
->window
, wm_state
, wm_state
, state
, 2);
2115 static void client_change_state(ObClient
*self
)
2117 gulong netstate
[11];
2122 netstate
[num
++] = prop_atoms
.net_wm_state_modal
;
2124 netstate
[num
++] = prop_atoms
.net_wm_state_shaded
;
2126 netstate
[num
++] = prop_atoms
.net_wm_state_hidden
;
2127 if (self
->skip_taskbar
)
2128 netstate
[num
++] = prop_atoms
.net_wm_state_skip_taskbar
;
2129 if (self
->skip_pager
)
2130 netstate
[num
++] = prop_atoms
.net_wm_state_skip_pager
;
2131 if (self
->fullscreen
)
2132 netstate
[num
++] = prop_atoms
.net_wm_state_fullscreen
;
2134 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_vert
;
2136 netstate
[num
++] = prop_atoms
.net_wm_state_maximized_horz
;
2138 netstate
[num
++] = prop_atoms
.net_wm_state_above
;
2140 netstate
[num
++] = prop_atoms
.net_wm_state_below
;
2141 if (self
->demands_attention
)
2142 netstate
[num
++] = prop_atoms
.net_wm_state_demands_attention
;
2143 if (self
->undecorated
)
2144 netstate
[num
++] = prop_atoms
.openbox_wm_state_undecorated
;
2145 PROP_SETA32(self
->window
, net_wm_state
, atom
, netstate
, num
);
2148 frame_adjust_state(self
->frame
);
2151 ObClient
*client_search_focus_tree(ObClient
*self
)
2156 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
2157 if (client_focused(it
->data
)) return it
->data
;
2158 if ((ret
= client_search_focus_tree(it
->data
))) return ret
;
2163 ObClient
*client_search_focus_tree_full(ObClient
*self
)
2165 if (self
->transient_for
) {
2166 if (self
->transient_for
!= OB_TRAN_GROUP
) {
2167 return client_search_focus_tree_full(self
->transient_for
);
2170 gboolean recursed
= FALSE
;
2172 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
))
2173 if (!((ObClient
*)it
->data
)->transient_for
) {
2175 if ((c
= client_search_focus_tree_full(it
->data
)))
2184 /* this function checks the whole tree, the client_search_focus_tree~
2185 does not, so we need to check this window */
2186 if (client_focused(self
))
2188 return client_search_focus_tree(self
);
2191 static ObStackingLayer
calc_layer(ObClient
*self
)
2195 if (self
->type
== OB_CLIENT_TYPE_DESKTOP
)
2196 l
= OB_STACKING_LAYER_DESKTOP
;
2197 else if (self
->type
== OB_CLIENT_TYPE_DOCK
) {
2198 if (self
->below
) l
= OB_STACKING_LAYER_NORMAL
;
2199 else l
= OB_STACKING_LAYER_ABOVE
;
2201 else if ((self
->fullscreen
||
2202 /* no decorations and fills the monitor = oldskool fullscreen */
2203 (self
->frame
!= NULL
&&
2204 (self
->frame
->size
.right
== 0 && self
->frame
->size
.left
== 0 &&
2205 self
->frame
->size
.bottom
== 0 && self
->frame
->size
.top
== 0 &&
2206 RECT_EQUAL(self
->area
,
2207 *screen_physical_area_monitor
2208 (client_monitor(self
)))))) &&
2209 (client_focused(self
) || client_search_focus_tree(self
)))
2210 l
= OB_STACKING_LAYER_FULLSCREEN
;
2211 else if (self
->above
) l
= OB_STACKING_LAYER_ABOVE
;
2212 else if (self
->below
) l
= OB_STACKING_LAYER_BELOW
;
2213 else l
= OB_STACKING_LAYER_NORMAL
;
2218 static void client_calc_layer_recursive(ObClient
*self
, ObClient
*orig
,
2219 ObStackingLayer min
, gboolean raised
)
2221 ObStackingLayer old
, own
;
2225 own
= calc_layer(self
);
2226 self
->layer
= MAX(own
, min
);
2228 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2229 client_calc_layer_recursive(it
->data
, orig
,
2231 raised
? raised
: self
->layer
!= old
);
2233 if (!raised
&& self
->layer
!= old
)
2234 if (orig
->frame
) { /* only restack if the original window is managed */
2235 stacking_remove(CLIENT_AS_WINDOW(self
));
2236 stacking_add(CLIENT_AS_WINDOW(self
));
2240 void client_calc_layer(ObClient
*self
)
2247 /* transients take on the layer of their parents */
2248 it
= client_search_all_top_parents(self
);
2250 for (; it
; it
= g_slist_next(it
))
2251 client_calc_layer_recursive(it
->data
, orig
, 0, FALSE
);
2254 gboolean
client_should_show(ObClient
*self
)
2258 if (client_normal(self
) && screen_showing_desktop
)
2261 if (self->transient_for) {
2262 if (self->transient_for != OB_TRAN_GROUP)
2263 return client_should_show(self->transient_for);
2267 for (it = self->group->members; it; it = g_slist_next(it)) {
2268 ObClient *c = it->data;
2269 if (c != self && !c->transient_for) {
2270 if (client_should_show(c))
2277 if (self
->desktop
== screen_desktop
|| self
->desktop
== DESKTOP_ALL
)
2283 void client_show(ObClient
*self
)
2286 if (client_should_show(self
)) {
2287 frame_show(self
->frame
);
2290 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2291 needs to be in IconicState. This includes when it is on another
2294 client_change_wm_state(self
);
2297 void client_hide(ObClient
*self
)
2299 if (!client_should_show(self
)) {
2300 frame_hide(self
->frame
);
2303 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2304 needs to be in IconicState. This includes when it is on another
2307 client_change_wm_state(self
);
2310 void client_showhide(ObClient
*self
)
2313 if (client_should_show(self
)) {
2314 frame_show(self
->frame
);
2317 frame_hide(self
->frame
);
2320 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2321 needs to be in IconicState. This includes when it is on another
2324 client_change_wm_state(self
);
2327 gboolean
client_normal(ObClient
*self
) {
2328 return ! (self
->type
== OB_CLIENT_TYPE_DESKTOP
||
2329 self
->type
== OB_CLIENT_TYPE_DOCK
||
2330 self
->type
== OB_CLIENT_TYPE_SPLASH
);
2333 gboolean
client_application(ObClient
*self
)
2335 return (self
->type
== OB_CLIENT_TYPE_NORMAL
||
2336 self
->type
== OB_CLIENT_TYPE_DIALOG
);
2339 static void client_apply_startup_state(ObClient
*self
, gint x
, gint y
)
2341 gboolean pos
= FALSE
; /* has the window's position been configured? */
2344 /* save the position, and set self->area for these to use */
2350 /* set the desktop hint, to make sure that it always exists */
2351 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, self
->desktop
);
2353 /* these are in a carefully crafted order.. */
2356 self
->iconic
= FALSE
;
2357 client_iconify(self
, TRUE
, FALSE
);
2359 if (self
->fullscreen
) {
2360 self
->fullscreen
= FALSE
;
2361 client_fullscreen(self
, TRUE
);
2364 if (self
->undecorated
) {
2365 self
->undecorated
= FALSE
;
2366 client_set_undecorated(self
, TRUE
);
2369 self
->shaded
= FALSE
;
2370 client_shade(self
, TRUE
);
2372 if (self
->demands_attention
) {
2373 self
->demands_attention
= FALSE
;
2374 client_hilite(self
, TRUE
);
2377 if (self
->max_vert
&& self
->max_horz
) {
2378 self
->max_vert
= self
->max_horz
= FALSE
;
2379 client_maximize(self
, TRUE
, 0);
2381 } else if (self
->max_vert
) {
2382 self
->max_vert
= FALSE
;
2383 client_maximize(self
, TRUE
, 2);
2385 } else if (self
->max_horz
) {
2386 self
->max_horz
= FALSE
;
2387 client_maximize(self
, TRUE
, 1);
2391 /* if the client didn't get positioned yet, then do so now
2392 call client_move even if the window is not being moved anywhere, because
2393 when we reparent it and decorate it, it is getting moved and we need to
2394 be telling it so with a ConfigureNotify event.
2397 /* use the saved position */
2400 client_move(self
, x
, y
);
2403 /* nothing to do for the other states:
2412 void client_convert_gravity(ObClient
*self
, gint gravity
, gint
*x
, gint
*y
,
2415 gint oldg
= self
->gravity
;
2417 /* get the frame's position from the requested stuff */
2418 self
->gravity
= gravity
;
2419 frame_client_gravity(self
->frame
, x
, y
, w
, h
);
2420 self
->gravity
= oldg
;
2422 /* get the client's position in its true gravity from that */
2423 frame_frame_gravity(self
->frame
, x
, y
, w
, h
);
2426 void client_try_configure(ObClient
*self
, gint
*x
, gint
*y
, gint
*w
, gint
*h
,
2427 gint
*logicalw
, gint
*logicalh
,
2430 Rect desired_area
= {*x
, *y
, *w
, *h
};
2432 /* make the frame recalculate its dimentions n shit without changing
2433 anything visible for real, this way the constraints below can work with
2434 the updated frame dimensions. */
2435 frame_adjust_area(self
->frame
, TRUE
, TRUE
, TRUE
);
2437 /* work within the prefered sizes given by the window */
2438 if (!(*w
== self
->area
.width
&& *h
== self
->area
.height
)) {
2439 gint basew
, baseh
, minw
, minh
;
2441 /* base size is substituted with min size if not specified */
2442 if (self
->base_size
.width
|| self
->base_size
.height
) {
2443 basew
= self
->base_size
.width
;
2444 baseh
= self
->base_size
.height
;
2446 basew
= self
->min_size
.width
;
2447 baseh
= self
->min_size
.height
;
2449 /* min size is substituted with base size if not specified */
2450 if (self
->min_size
.width
|| self
->min_size
.height
) {
2451 minw
= self
->min_size
.width
;
2452 minh
= self
->min_size
.height
;
2454 minw
= self
->base_size
.width
;
2455 minh
= self
->base_size
.height
;
2458 /* if this is a user-requested resize, then check against min/max
2461 /* smaller than min size or bigger than max size? */
2462 if (*w
> self
->max_size
.width
) *w
= self
->max_size
.width
;
2463 if (*w
< minw
) *w
= minw
;
2464 if (*h
> self
->max_size
.height
) *h
= self
->max_size
.height
;
2465 if (*h
< minh
) *h
= minh
;
2470 /* keep to the increments */
2471 *w
/= self
->size_inc
.width
;
2472 *h
/= self
->size_inc
.height
;
2474 /* you cannot resize to nothing */
2475 if (basew
+ *w
< 1) *w
= 1 - basew
;
2476 if (baseh
+ *h
< 1) *h
= 1 - baseh
;
2478 /* save the logical size */
2479 *logicalw
= self
->size_inc
.width
> 1 ? *w
: *w
+ basew
;
2480 *logicalh
= self
->size_inc
.height
> 1 ? *h
: *h
+ baseh
;
2482 *w
*= self
->size_inc
.width
;
2483 *h
*= self
->size_inc
.height
;
2488 /* adjust the height to match the width for the aspect ratios.
2489 for this, min size is not substituted for base size ever. */
2490 *w
-= self
->base_size
.width
;
2491 *h
-= self
->base_size
.height
;
2493 if (!self
->fullscreen
) {
2494 if (self
->min_ratio
)
2495 if (*h
* self
->min_ratio
> *w
) {
2496 *h
= (gint
)(*w
/ self
->min_ratio
);
2498 /* you cannot resize to nothing */
2501 *w
= (gint
)(*h
* self
->min_ratio
);
2504 if (self
->max_ratio
)
2505 if (*h
* self
->max_ratio
< *w
) {
2506 *h
= (gint
)(*w
/ self
->max_ratio
);
2508 /* you cannot resize to nothing */
2511 *w
= (gint
)(*h
* self
->min_ratio
);
2516 *w
+= self
->base_size
.width
;
2517 *h
+= self
->base_size
.height
;
2520 /* gets the frame's position */
2521 frame_client_gravity(self
->frame
, x
, y
, *w
, *h
);
2523 /* these positions are frame positions, not client positions */
2525 /* set the size and position if fullscreen */
2526 if (self
->fullscreen
) {
2530 i
= screen_find_monitor(&desired_area
);
2531 a
= screen_physical_area_monitor(i
);
2538 user
= FALSE
; /* ignore if the client can't be moved/resized when it
2539 is entering fullscreen */
2540 } else if (self
->max_horz
|| self
->max_vert
) {
2544 i
= screen_find_monitor(&desired_area
);
2545 a
= screen_area_monitor(self
->desktop
, i
);
2547 /* set the size and position if maximized */
2548 if (self
->max_horz
) {
2550 *w
= a
->width
- self
->frame
->size
.left
- self
->frame
->size
.right
;
2552 if (self
->max_vert
) {
2554 *h
= a
->height
- self
->frame
->size
.top
- self
->frame
->size
.bottom
;
2557 /* maximizing is not allowed if the user can't move+resize the window
2561 /* gets the client's position */
2562 frame_frame_gravity(self
->frame
, x
, y
, *w
, *h
);
2564 /* these override the above states! if you cant move you can't move! */
2566 if (!(self
->functions
& OB_CLIENT_FUNC_MOVE
)) {
2570 if (!(self
->functions
& OB_CLIENT_FUNC_RESIZE
)) {
2571 *w
= self
->area
.width
;
2572 *h
= self
->area
.height
;
2581 void client_configure_full(ObClient
*self
, gint x
, gint y
, gint w
, gint h
,
2582 gboolean user
, gboolean final
,
2583 gboolean force_reply
)
2585 gint oldw
, oldh
, oldrx
, oldry
;
2586 gboolean send_resize_client
;
2587 gboolean moved
= FALSE
, resized
= FALSE
, rootmoved
= FALSE
;
2588 guint fdecor
= self
->frame
->decorations
;
2589 gboolean fhorz
= self
->frame
->max_horz
;
2590 gint logicalw
, logicalh
;
2592 /* find the new x, y, width, and height (and logical size) */
2593 client_try_configure(self
, &x
, &y
, &w
, &h
, &logicalw
, &logicalh
, user
);
2595 /* set the logical size if things changed */
2596 if (!(w
== self
->area
.width
&& h
== self
->area
.height
))
2597 SIZE_SET(self
->logical_size
, logicalw
, logicalh
);
2599 /* figure out if we moved or resized or what */
2600 moved
= x
!= self
->area
.x
|| y
!= self
->area
.y
;
2601 resized
= w
!= self
->area
.width
|| h
!= self
->area
.height
;
2603 oldw
= self
->area
.width
;
2604 oldh
= self
->area
.height
;
2605 RECT_SET(self
->area
, x
, y
, w
, h
);
2607 /* for app-requested resizes, always resize if 'resized' is true.
2608 for user-requested ones, only resize if final is true, or when
2609 resizing in redraw mode */
2610 send_resize_client
= ((!user
&& resized
) ||
2612 (resized
&& config_resize_redraw
))));
2614 /* if the client is enlarging, then resize the client before the frame */
2615 if (send_resize_client
&& user
&& (w
> oldw
|| h
> oldh
)) {
2616 XResizeWindow(ob_display
, self
->window
, MAX(w
, oldw
), MAX(h
, oldh
));
2617 /* resize the plate to show the client padding color underneath */
2618 frame_adjust_client_area(self
->frame
);
2621 /* find the frame's dimensions and move/resize it */
2622 if (self
->decorations
!= fdecor
|| self
->max_horz
!= fhorz
)
2623 moved
= resized
= TRUE
;
2624 if (moved
|| resized
)
2625 frame_adjust_area(self
->frame
, moved
, resized
, FALSE
);
2627 /* find the client's position relative to the root window */
2628 oldrx
= self
->root_pos
.x
;
2629 oldry
= self
->root_pos
.y
;
2630 rootmoved
= (oldrx
!= (signed)(self
->frame
->area
.x
+
2631 self
->frame
->size
.left
-
2632 self
->border_width
) ||
2633 oldry
!= (signed)(self
->frame
->area
.y
+
2634 self
->frame
->size
.top
-
2635 self
->border_width
));
2637 if (force_reply
|| ((!user
|| (user
&& final
)) && rootmoved
))
2641 POINT_SET(self
->root_pos
,
2642 self
->frame
->area
.x
+ self
->frame
->size
.left
-
2644 self
->frame
->area
.y
+ self
->frame
->size
.top
-
2645 self
->border_width
);
2647 event
.type
= ConfigureNotify
;
2648 event
.xconfigure
.display
= ob_display
;
2649 event
.xconfigure
.event
= self
->window
;
2650 event
.xconfigure
.window
= self
->window
;
2652 /* root window real coords */
2653 event
.xconfigure
.x
= self
->root_pos
.x
;
2654 event
.xconfigure
.y
= self
->root_pos
.y
;
2655 event
.xconfigure
.width
= w
;
2656 event
.xconfigure
.height
= h
;
2657 event
.xconfigure
.border_width
= 0;
2658 event
.xconfigure
.above
= self
->frame
->plate
;
2659 event
.xconfigure
.override_redirect
= FALSE
;
2660 XSendEvent(event
.xconfigure
.display
, event
.xconfigure
.window
,
2661 FALSE
, StructureNotifyMask
, &event
);
2664 /* if the client is shrinking, then resize the frame before the client */
2665 if (send_resize_client
&& (!user
|| (w
<= oldw
|| h
<= oldh
))) {
2666 /* resize the plate to show the client padding color underneath */
2667 frame_adjust_client_area(self
->frame
);
2669 XResizeWindow(ob_display
, self
->window
, w
, h
);
2675 void client_fullscreen(ObClient
*self
, gboolean fs
)
2679 if (!(self
->functions
& OB_CLIENT_FUNC_FULLSCREEN
) || /* can't */
2680 self
->fullscreen
== fs
) return; /* already done */
2682 self
->fullscreen
= fs
;
2683 client_change_state(self
); /* change the state hints on the client */
2684 client_calc_layer(self
); /* and adjust out layer/stacking */
2687 self
->pre_fullscreen_area
= self
->area
;
2688 /* if the window is maximized, its area isn't all that meaningful.
2689 save it's premax area instead. */
2690 if (self
->max_horz
) {
2691 self
->pre_fullscreen_area
.x
= self
->pre_max_area
.x
;
2692 self
->pre_fullscreen_area
.width
= self
->pre_max_area
.width
;
2694 if (self
->max_vert
) {
2695 self
->pre_fullscreen_area
.y
= self
->pre_max_area
.y
;
2696 self
->pre_fullscreen_area
.height
= self
->pre_max_area
.height
;
2699 /* these are not actually used cuz client_configure will set them
2700 as appropriate when the window is fullscreened */
2705 if (self
->pre_fullscreen_area
.width
> 0 &&
2706 self
->pre_fullscreen_area
.height
> 0)
2708 x
= self
->pre_fullscreen_area
.x
;
2709 y
= self
->pre_fullscreen_area
.y
;
2710 w
= self
->pre_fullscreen_area
.width
;
2711 h
= self
->pre_fullscreen_area
.height
;
2712 RECT_SET(self
->pre_fullscreen_area
, 0, 0, 0, 0);
2714 /* pick some fallbacks... */
2715 a
= screen_area_monitor(self
->desktop
, 0);
2716 x
= a
->x
+ a
->width
/ 4;
2717 y
= a
->y
+ a
->height
/ 4;
2723 client_setup_decor_and_functions(self
);
2725 client_move_resize(self
, x
, y
, w
, h
);
2727 /* try focus us when we go into fullscreen mode */
2731 static void client_iconify_recursive(ObClient
*self
,
2732 gboolean iconic
, gboolean curdesk
)
2735 gboolean changed
= FALSE
;
2738 if (self
->iconic
!= iconic
) {
2739 ob_debug("%sconifying window: 0x%lx\n", (iconic
? "I" : "Uni"),
2743 if (self
->functions
& OB_CLIENT_FUNC_ICONIFY
) {
2744 self
->iconic
= iconic
;
2746 /* update the focus lists.. iconic windows go to the bottom of
2747 the list, put the new iconic window at the 'top of the
2749 focus_order_to_top(self
);
2754 self
->iconic
= iconic
;
2756 if (curdesk
&& self
->desktop
!= screen_desktop
&&
2757 self
->desktop
!= DESKTOP_ALL
)
2758 client_set_desktop(self
, screen_desktop
, FALSE
);
2760 /* this puts it after the current focused window */
2761 focus_order_remove(self
);
2762 focus_order_add_new(self
);
2769 client_change_state(self
);
2770 if (ob_state() != OB_STATE_STARTING
&& config_animate_iconify
)
2771 frame_begin_iconify_animation(self
->frame
, iconic
);
2772 /* do this after starting the animation so it doesn't flash */
2773 client_showhide(self
);
2776 /* iconify all direct transients, and deiconify all transients
2778 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2779 if (it
->data
!= self
)
2780 if (client_is_direct_child(self
, it
->data
) || !iconic
)
2781 client_iconify_recursive(it
->data
, iconic
, curdesk
);
2784 void client_iconify(ObClient
*self
, gboolean iconic
, gboolean curdesk
)
2786 /* move up the transient chain as far as possible first */
2787 self
= client_search_top_normal_parent(self
);
2788 client_iconify_recursive(self
, iconic
, curdesk
);
2791 void client_maximize(ObClient
*self
, gboolean max
, gint dir
)
2795 g_assert(dir
== 0 || dir
== 1 || dir
== 2);
2796 if (!(self
->functions
& OB_CLIENT_FUNC_MAXIMIZE
)) return; /* can't */
2798 /* check if already done */
2800 if (dir
== 0 && self
->max_horz
&& self
->max_vert
) return;
2801 if (dir
== 1 && self
->max_horz
) return;
2802 if (dir
== 2 && self
->max_vert
) return;
2804 if (dir
== 0 && !self
->max_horz
&& !self
->max_vert
) return;
2805 if (dir
== 1 && !self
->max_horz
) return;
2806 if (dir
== 2 && !self
->max_vert
) return;
2809 /* we just tell it to configure in the same place and client_configure
2810 worries about filling the screen with the window */
2813 w
= self
->area
.width
;
2814 h
= self
->area
.height
;
2817 if ((dir
== 0 || dir
== 1) && !self
->max_horz
) { /* horz */
2818 RECT_SET(self
->pre_max_area
,
2819 self
->area
.x
, self
->pre_max_area
.y
,
2820 self
->area
.width
, self
->pre_max_area
.height
);
2822 if ((dir
== 0 || dir
== 2) && !self
->max_vert
) { /* vert */
2823 RECT_SET(self
->pre_max_area
,
2824 self
->pre_max_area
.x
, self
->area
.y
,
2825 self
->pre_max_area
.width
, self
->area
.height
);
2830 a
= screen_area_monitor(self
->desktop
, 0);
2831 if ((dir
== 0 || dir
== 1) && self
->max_horz
) { /* horz */
2832 if (self
->pre_max_area
.width
> 0) {
2833 x
= self
->pre_max_area
.x
;
2834 w
= self
->pre_max_area
.width
;
2836 RECT_SET(self
->pre_max_area
, 0, self
->pre_max_area
.y
,
2837 0, self
->pre_max_area
.height
);
2839 /* pick some fallbacks... */
2840 x
= a
->x
+ a
->width
/ 4;
2844 if ((dir
== 0 || dir
== 2) && self
->max_vert
) { /* vert */
2845 if (self
->pre_max_area
.height
> 0) {
2846 y
= self
->pre_max_area
.y
;
2847 h
= self
->pre_max_area
.height
;
2849 RECT_SET(self
->pre_max_area
, self
->pre_max_area
.x
, 0,
2850 self
->pre_max_area
.width
, 0);
2852 /* pick some fallbacks... */
2853 y
= a
->y
+ a
->height
/ 4;
2859 if (dir
== 0 || dir
== 1) /* horz */
2860 self
->max_horz
= max
;
2861 if (dir
== 0 || dir
== 2) /* vert */
2862 self
->max_vert
= max
;
2864 client_change_state(self
); /* change the state hints on the client */
2866 client_setup_decor_and_functions(self
);
2868 client_move_resize(self
, x
, y
, w
, h
);
2871 void client_shade(ObClient
*self
, gboolean shade
)
2873 if ((!(self
->functions
& OB_CLIENT_FUNC_SHADE
) &&
2874 shade
) || /* can't shade */
2875 self
->shaded
== shade
) return; /* already done */
2877 self
->shaded
= shade
;
2878 client_change_state(self
);
2879 client_change_wm_state(self
); /* the window is being hidden/shown */
2880 /* resize the frame to just the titlebar */
2881 frame_adjust_area(self
->frame
, FALSE
, FALSE
, FALSE
);
2884 void client_close(ObClient
*self
)
2888 if (!(self
->functions
& OB_CLIENT_FUNC_CLOSE
)) return;
2890 /* in the case that the client provides no means to requesting that it
2891 close, we just kill it */
2892 if (!self
->delete_window
)
2896 XXX: itd be cool to do timeouts and shit here for killing the client's
2898 like... if the window is around after 5 seconds, then the close button
2899 turns a nice red, and if this function is called again, the client is
2903 ce
.xclient
.type
= ClientMessage
;
2904 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
2905 ce
.xclient
.display
= ob_display
;
2906 ce
.xclient
.window
= self
->window
;
2907 ce
.xclient
.format
= 32;
2908 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_delete_window
;
2909 ce
.xclient
.data
.l
[1] = event_curtime
;
2910 ce
.xclient
.data
.l
[2] = 0l;
2911 ce
.xclient
.data
.l
[3] = 0l;
2912 ce
.xclient
.data
.l
[4] = 0l;
2913 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
2916 void client_kill(ObClient
*self
)
2918 XKillClient(ob_display
, self
->window
);
2921 void client_hilite(ObClient
*self
, gboolean hilite
)
2923 if (self
->demands_attention
== hilite
)
2924 return; /* no change */
2926 /* don't allow focused windows to hilite */
2927 self
->demands_attention
= hilite
&& !client_focused(self
);
2928 if (self
->frame
!= NULL
) { /* if we're mapping, just set the state */
2929 if (self
->demands_attention
)
2930 frame_flash_start(self
->frame
);
2932 frame_flash_stop(self
->frame
);
2933 client_change_state(self
);
2937 void client_set_desktop_recursive(ObClient
*self
,
2938 guint target
, gboolean donthide
)
2943 if (target
!= self
->desktop
) {
2945 ob_debug("Setting desktop %u\n", target
+1);
2947 g_assert(target
< screen_num_desktops
|| target
== DESKTOP_ALL
);
2949 /* remove from the old desktop(s) */
2950 focus_order_remove(self
);
2952 old
= self
->desktop
;
2953 self
->desktop
= target
;
2954 PROP_SET32(self
->window
, net_wm_desktop
, cardinal
, target
);
2955 /* the frame can display the current desktop state */
2956 frame_adjust_state(self
->frame
);
2957 /* 'move' the window to the new desktop */
2959 client_showhide(self
);
2960 /* raise if it was not already on the desktop */
2961 if (old
!= DESKTOP_ALL
)
2963 if (STRUT_EXISTS(self
->strut
))
2964 screen_update_areas();
2966 /* add to the new desktop(s) */
2967 if (config_focus_new
)
2968 focus_order_to_top(self
);
2970 focus_order_to_bottom(self
);
2973 /* move all transients */
2974 for (it
= self
->transients
; it
; it
= g_slist_next(it
))
2975 if (it
->data
!= self
)
2976 if (client_is_direct_child(self
, it
->data
))
2977 client_set_desktop_recursive(it
->data
, target
, donthide
);
2980 void client_set_desktop(ObClient
*self
, guint target
, gboolean donthide
)
2982 self
= client_search_top_normal_parent(self
);
2983 client_set_desktop_recursive(self
, target
, donthide
);
2986 gboolean
client_is_direct_child(ObClient
*parent
, ObClient
*child
)
2988 while (child
!= parent
&&
2989 child
->transient_for
&& child
->transient_for
!= OB_TRAN_GROUP
)
2990 child
= child
->transient_for
;
2991 return child
== parent
;
2994 ObClient
*client_search_modal_child(ObClient
*self
)
2999 for (it
= self
->transients
; it
; it
= g_slist_next(it
)) {
3000 ObClient
*c
= it
->data
;
3001 if ((ret
= client_search_modal_child(c
))) return ret
;
3002 if (c
->modal
) return c
;
3007 gboolean
client_validate(ObClient
*self
)
3011 XSync(ob_display
, FALSE
); /* get all events on the server */
3013 if (XCheckTypedWindowEvent(ob_display
, self
->window
, DestroyNotify
, &e
) ||
3014 XCheckTypedWindowEvent(ob_display
, self
->window
, UnmapNotify
, &e
)) {
3015 XPutBackEvent(ob_display
, &e
);
3022 void client_set_wm_state(ObClient
*self
, glong state
)
3024 if (state
== self
->wmstate
) return; /* no change */
3028 client_iconify(self
, TRUE
, TRUE
);
3031 client_iconify(self
, FALSE
, TRUE
);
3036 void client_set_state(ObClient
*self
, Atom action
, glong data1
, glong data2
)
3038 gboolean shaded
= self
->shaded
;
3039 gboolean fullscreen
= self
->fullscreen
;
3040 gboolean undecorated
= self
->undecorated
;
3041 gboolean max_horz
= self
->max_horz
;
3042 gboolean max_vert
= self
->max_vert
;
3043 gboolean modal
= self
->modal
;
3044 gboolean iconic
= self
->iconic
;
3045 gboolean demands_attention
= self
->demands_attention
;
3048 if (!(action
== prop_atoms
.net_wm_state_add
||
3049 action
== prop_atoms
.net_wm_state_remove
||
3050 action
== prop_atoms
.net_wm_state_toggle
))
3051 /* an invalid action was passed to the client message, ignore it */
3054 for (i
= 0; i
< 2; ++i
) {
3055 Atom state
= i
== 0 ? data1
: data2
;
3057 if (!state
) continue;
3059 /* if toggling, then pick whether we're adding or removing */
3060 if (action
== prop_atoms
.net_wm_state_toggle
) {
3061 if (state
== prop_atoms
.net_wm_state_modal
)
3062 action
= modal
? prop_atoms
.net_wm_state_remove
:
3063 prop_atoms
.net_wm_state_add
;
3064 else if (state
== prop_atoms
.net_wm_state_maximized_vert
)
3065 action
= self
->max_vert
? prop_atoms
.net_wm_state_remove
:
3066 prop_atoms
.net_wm_state_add
;
3067 else if (state
== prop_atoms
.net_wm_state_maximized_horz
)
3068 action
= self
->max_horz
? prop_atoms
.net_wm_state_remove
:
3069 prop_atoms
.net_wm_state_add
;
3070 else if (state
== prop_atoms
.net_wm_state_shaded
)
3071 action
= shaded
? prop_atoms
.net_wm_state_remove
:
3072 prop_atoms
.net_wm_state_add
;
3073 else if (state
== prop_atoms
.net_wm_state_skip_taskbar
)
3074 action
= self
->skip_taskbar
?
3075 prop_atoms
.net_wm_state_remove
:
3076 prop_atoms
.net_wm_state_add
;
3077 else if (state
== prop_atoms
.net_wm_state_skip_pager
)
3078 action
= self
->skip_pager
?
3079 prop_atoms
.net_wm_state_remove
:
3080 prop_atoms
.net_wm_state_add
;
3081 else if (state
== prop_atoms
.net_wm_state_hidden
)
3082 action
= self
->iconic
?
3083 prop_atoms
.net_wm_state_remove
:
3084 prop_atoms
.net_wm_state_add
;
3085 else if (state
== prop_atoms
.net_wm_state_fullscreen
)
3086 action
= fullscreen
?
3087 prop_atoms
.net_wm_state_remove
:
3088 prop_atoms
.net_wm_state_add
;
3089 else if (state
== prop_atoms
.net_wm_state_above
)
3090 action
= self
->above
? prop_atoms
.net_wm_state_remove
:
3091 prop_atoms
.net_wm_state_add
;
3092 else if (state
== prop_atoms
.net_wm_state_below
)
3093 action
= self
->below
? prop_atoms
.net_wm_state_remove
:
3094 prop_atoms
.net_wm_state_add
;
3095 else if (state
== prop_atoms
.net_wm_state_demands_attention
)
3096 action
= self
->demands_attention
?
3097 prop_atoms
.net_wm_state_remove
:
3098 prop_atoms
.net_wm_state_add
;
3099 else if (state
== prop_atoms
.openbox_wm_state_undecorated
)
3100 action
= undecorated
? prop_atoms
.net_wm_state_remove
:
3101 prop_atoms
.net_wm_state_add
;
3104 if (action
== prop_atoms
.net_wm_state_add
) {
3105 if (state
== prop_atoms
.net_wm_state_modal
) {
3107 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
3109 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
3111 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
3113 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
3114 self
->skip_taskbar
= TRUE
;
3115 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
3116 self
->skip_pager
= TRUE
;
3117 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
3119 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
3121 } else if (state
== prop_atoms
.net_wm_state_above
) {
3123 self
->below
= FALSE
;
3124 } else if (state
== prop_atoms
.net_wm_state_below
) {
3125 self
->above
= FALSE
;
3127 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
3128 demands_attention
= TRUE
;
3129 } else if (state
== prop_atoms
.openbox_wm_state_undecorated
) {
3133 } else { /* action == prop_atoms.net_wm_state_remove */
3134 if (state
== prop_atoms
.net_wm_state_modal
) {
3136 } else if (state
== prop_atoms
.net_wm_state_maximized_vert
) {
3138 } else if (state
== prop_atoms
.net_wm_state_maximized_horz
) {
3140 } else if (state
== prop_atoms
.net_wm_state_shaded
) {
3142 } else if (state
== prop_atoms
.net_wm_state_skip_taskbar
) {
3143 self
->skip_taskbar
= FALSE
;
3144 } else if (state
== prop_atoms
.net_wm_state_skip_pager
) {
3145 self
->skip_pager
= FALSE
;
3146 } else if (state
== prop_atoms
.net_wm_state_hidden
) {
3148 } else if (state
== prop_atoms
.net_wm_state_fullscreen
) {
3150 } else if (state
== prop_atoms
.net_wm_state_above
) {
3151 self
->above
= FALSE
;
3152 } else if (state
== prop_atoms
.net_wm_state_below
) {
3153 self
->below
= FALSE
;
3154 } else if (state
== prop_atoms
.net_wm_state_demands_attention
) {
3155 demands_attention
= FALSE
;
3156 } else if (state
== prop_atoms
.openbox_wm_state_undecorated
) {
3157 undecorated
= FALSE
;
3161 if (max_horz
!= self
->max_horz
|| max_vert
!= self
->max_vert
) {
3162 if (max_horz
!= self
->max_horz
&& max_vert
!= self
->max_vert
) {
3164 if (max_horz
== max_vert
) { /* both going the same way */
3165 client_maximize(self
, max_horz
, 0);
3167 client_maximize(self
, max_horz
, 1);
3168 client_maximize(self
, max_vert
, 2);
3172 if (max_horz
!= self
->max_horz
)
3173 client_maximize(self
, max_horz
, 1);
3175 client_maximize(self
, max_vert
, 2);
3178 /* change fullscreen state before shading, as it will affect if the window
3180 if (fullscreen
!= self
->fullscreen
)
3181 client_fullscreen(self
, fullscreen
);
3182 if (shaded
!= self
->shaded
)
3183 client_shade(self
, shaded
);
3184 if (undecorated
!= self
->undecorated
)
3185 client_set_undecorated(self
, undecorated
);
3186 if (modal
!= self
->modal
) {
3187 self
->modal
= modal
;
3188 /* when a window changes modality, then its stacking order with its
3189 transients needs to change */
3192 if (iconic
!= self
->iconic
)
3193 client_iconify(self
, iconic
, FALSE
);
3195 if (demands_attention
!= self
->demands_attention
)
3196 client_hilite(self
, demands_attention
);
3198 client_change_state(self
); /* change the hint to reflect these changes */
3201 ObClient
*client_focus_target(ObClient
*self
)
3203 ObClient
*child
= NULL
;
3205 child
= client_search_modal_child(self
);
3206 if (child
) return child
;
3210 gboolean
client_can_focus(ObClient
*self
)
3214 /* choose the correct target */
3215 self
= client_focus_target(self
);
3217 if (!self
->frame
->visible
)
3220 if (!(self
->can_focus
|| self
->focus_notify
))
3223 /* do a check to see if the window has already been unmapped or destroyed
3224 do this intelligently while watching out for unmaps we've generated
3225 (ignore_unmaps > 0) */
3226 if (XCheckTypedWindowEvent(ob_display
, self
->window
,
3227 DestroyNotify
, &ev
)) {
3228 XPutBackEvent(ob_display
, &ev
);
3231 while (XCheckTypedWindowEvent(ob_display
, self
->window
,
3232 UnmapNotify
, &ev
)) {
3233 if (self
->ignore_unmaps
) {
3234 self
->ignore_unmaps
--;
3236 XPutBackEvent(ob_display
, &ev
);
3244 gboolean
client_focus(ObClient
*self
)
3246 /* choose the correct target */
3247 self
= client_focus_target(self
);
3249 if (!client_can_focus(self
)) {
3250 if (!self
->frame
->visible
) {
3251 /* update the focus lists */
3252 focus_order_to_top(self
);
3257 ob_debug_type(OB_DEBUG_FOCUS
,
3258 "Focusing client \"%s\" at time %u\n",
3259 self
->title
, event_curtime
);
3261 if (self
->can_focus
) {
3262 /* This can cause a BadMatch error with CurrentTime, or if an app
3263 passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3264 xerror_set_ignore(TRUE
);
3265 XSetInputFocus(ob_display
, self
->window
, RevertToPointerRoot
,
3267 xerror_set_ignore(FALSE
);
3270 if (self
->focus_notify
) {
3272 ce
.xclient
.type
= ClientMessage
;
3273 ce
.xclient
.message_type
= prop_atoms
.wm_protocols
;
3274 ce
.xclient
.display
= ob_display
;
3275 ce
.xclient
.window
= self
->window
;
3276 ce
.xclient
.format
= 32;
3277 ce
.xclient
.data
.l
[0] = prop_atoms
.wm_take_focus
;
3278 ce
.xclient
.data
.l
[1] = event_curtime
;
3279 ce
.xclient
.data
.l
[2] = 0l;
3280 ce
.xclient
.data
.l
[3] = 0l;
3281 ce
.xclient
.data
.l
[4] = 0l;
3282 XSendEvent(ob_display
, self
->window
, FALSE
, NoEventMask
, &ce
);
3286 ob_debug("%sively focusing %lx at %d\n",
3287 (self
->can_focus
? "act" : "pass"),
3288 self
->window
, (gint
) event_curtime
);
3291 /* Cause the FocusIn to come back to us. Important for desktop switches,
3292 since otherwise we'll have no FocusIn on the queue and send it off to
3293 the focus_backup. */
3294 XSync(ob_display
, FALSE
);
3298 /*! Present the client to the user.
3299 @param raise If the client should be raised or not. You should only set
3300 raise to false if you don't care if the window is completely
3303 static void client_present(ObClient
*self
, gboolean here
, gboolean raise
)
3305 /* if using focus_delay, stop the timer now so that focus doesn't
3307 event_halt_focus_delay();
3309 if (client_normal(self
) && screen_showing_desktop
)
3310 screen_show_desktop(FALSE
, FALSE
);
3312 client_iconify(self
, FALSE
, here
);
3313 if (self
->desktop
!= DESKTOP_ALL
&&
3314 self
->desktop
!= screen_desktop
)
3317 client_set_desktop(self
, screen_desktop
, FALSE
);
3319 screen_set_desktop(self
->desktop
, FALSE
);
3320 } else if (!self
->frame
->visible
)
3321 /* if its not visible for other reasons, then don't mess
3325 client_shade(self
, FALSE
);
3330 /* we do this as an action here. this is rather important. this is
3331 because we want the results from the focus change to take place
3332 BEFORE we go about raising the window. when a fullscreen window
3333 loses focus, we need this or else the raise wont be able to raise
3334 above the to-lose-focus fullscreen window. */
3339 void client_activate(ObClient
*self
, gboolean here
, gboolean user
)
3341 guint32 last_time
= focus_client
? focus_client
->user_time
: CurrentTime
;
3343 /* XXX do some stuff here if user is false to determine if we really want
3344 to activate it or not (a parent or group member is currently
3347 ob_debug_type(OB_DEBUG_FOCUS
,
3348 "Want to activate window 0x%x with time %u (last time %u), "
3350 self
->window
, event_curtime
, last_time
,
3351 (user
? "user" : "application"));
3353 if (!user
&& event_curtime
&& last_time
&&
3354 !event_time_after(event_curtime
, last_time
))
3356 client_hilite(self
, TRUE
);
3358 if (event_curtime
!= CurrentTime
)
3359 self
->user_time
= event_curtime
;
3361 client_present(self
, here
, TRUE
);
3365 void client_raise(ObClient
*self
)
3367 action_run_string("Raise", self
, CurrentTime
);
3370 void client_lower(ObClient
*self
)
3372 action_run_string("Lower", self
, CurrentTime
);
3375 gboolean
client_focused(ObClient
*self
)
3377 return self
== focus_client
;
3380 static ObClientIcon
* client_icon_recursive(ObClient
*self
, gint w
, gint h
)
3383 /* si is the smallest image >= req */
3384 /* li is the largest image < req */
3385 gulong size
, smallest
= 0xffffffff, largest
= 0, si
= 0, li
= 0;
3387 if (!self
->nicons
) {
3388 ObClientIcon
*parent
= NULL
;
3390 if (self
->transient_for
) {
3391 if (self
->transient_for
!= OB_TRAN_GROUP
)
3392 parent
= client_icon_recursive(self
->transient_for
, w
, h
);
3395 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3396 ObClient
*c
= it
->data
;
3397 if (c
!= self
&& !c
->transient_for
) {
3398 if ((parent
= client_icon_recursive(c
, w
, h
)))
3408 for (i
= 0; i
< self
->nicons
; ++i
) {
3409 size
= self
->icons
[i
].width
* self
->icons
[i
].height
;
3410 if (size
< smallest
&& size
>= (unsigned)(w
* h
)) {
3414 if (size
> largest
&& size
<= (unsigned)(w
* h
)) {
3419 if (largest
== 0) /* didnt find one smaller than the requested size */
3420 return &self
->icons
[si
];
3421 return &self
->icons
[li
];
3424 const ObClientIcon
* client_icon(ObClient
*self
, gint w
, gint h
)
3427 static ObClientIcon deficon
;
3429 if (!(ret
= client_icon_recursive(self
, w
, h
))) {
3430 deficon
.width
= deficon
.height
= 48;
3431 deficon
.data
= ob_rr_theme
->def_win_icon
;
3437 void client_set_layer(ObClient
*self
, gint layer
)
3441 self
->above
= FALSE
;
3442 } else if (layer
== 0) {
3443 self
->below
= self
->above
= FALSE
;
3445 self
->below
= FALSE
;
3448 client_calc_layer(self
);
3449 client_change_state(self
); /* reflect this in the state hints */
3452 void client_set_undecorated(ObClient
*self
, gboolean undecorated
)
3454 if (self
->undecorated
!= undecorated
) {
3455 self
->undecorated
= undecorated
;
3456 client_setup_decor_and_functions(self
);
3457 /* Make sure the client knows it might have moved. Maybe there is a
3458 * better way of doing this so only one client_configure is sent, but
3459 * since 125 of these are sent per second when moving the window (with
3460 * user = FALSE) i doubt it matters much.
3462 client_configure(self
, self
->area
.x
, self
->area
.y
,
3463 self
->area
.width
, self
->area
.height
, TRUE
, TRUE
);
3464 client_change_state(self
); /* reflect this in the state hints */
3468 guint
client_monitor(ObClient
*self
)
3470 return screen_find_monitor(&self
->frame
->area
);
3473 ObClient
*client_search_top_normal_parent(ObClient
*self
)
3475 while (self
->transient_for
&& self
->transient_for
!= OB_TRAN_GROUP
&&
3476 client_normal(self
->transient_for
))
3477 self
= self
->transient_for
;
3481 static GSList
*client_search_all_top_parents_internal(ObClient
*self
,
3483 ObStackingLayer layer
)
3487 /* move up the direct transient chain as far as possible */
3488 while (self
->transient_for
&& self
->transient_for
!= OB_TRAN_GROUP
&&
3489 (!bylayer
|| self
->transient_for
->layer
== layer
) &&
3490 client_normal(self
->transient_for
))
3491 self
= self
->transient_for
;
3493 if (!self
->transient_for
)
3494 ret
= g_slist_prepend(ret
, self
);
3498 g_assert(self
->group
);
3500 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3501 ObClient
*c
= it
->data
;
3503 if (!c
->transient_for
&& client_normal(c
) &&
3504 (!bylayer
|| c
->layer
== layer
))
3506 ret
= g_slist_prepend(ret
, c
);
3510 if (ret
== NULL
) /* no group parents */
3511 ret
= g_slist_prepend(ret
, self
);
3517 GSList
*client_search_all_top_parents(ObClient
*self
)
3519 return client_search_all_top_parents_internal(self
, FALSE
, 0);
3522 GSList
*client_search_all_top_parents_layer(ObClient
*self
)
3524 return client_search_all_top_parents_internal(self
, TRUE
, self
->layer
);
3527 ObClient
*client_search_focus_parent(ObClient
*self
)
3529 if (self
->transient_for
) {
3530 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3531 if (client_focused(self
->transient_for
))
3532 return self
->transient_for
;
3536 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3537 ObClient
*c
= it
->data
;
3539 /* checking transient_for prevents infinate loops! */
3540 if (c
!= self
&& !c
->transient_for
)
3541 if (client_focused(c
))
3550 ObClient
*client_search_parent(ObClient
*self
, ObClient
*search
)
3552 if (self
->transient_for
) {
3553 if (self
->transient_for
!= OB_TRAN_GROUP
) {
3554 if (self
->transient_for
== search
)
3559 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3560 ObClient
*c
= it
->data
;
3562 /* checking transient_for prevents infinate loops! */
3563 if (c
!= self
&& !c
->transient_for
)
3573 ObClient
*client_search_transient(ObClient
*self
, ObClient
*search
)
3577 for (sit
= self
->transients
; sit
; sit
= g_slist_next(sit
)) {
3578 if (sit
->data
== search
)
3580 if (client_search_transient(sit
->data
, search
))
3586 void client_update_sm_client_id(ObClient
*self
)
3588 g_free(self
->sm_client_id
);
3589 self
->sm_client_id
= NULL
;
3591 if (!PROP_GETS(self
->window
, sm_client_id
, locale
, &self
->sm_client_id
))
3593 PROP_GETS(self
->group
->leader
, sm_client_id
, locale
,
3594 &self
->sm_client_id
);
3597 void client_update_command(ObClient
*self
)
3601 g_free(self
->wm_command
);
3602 self
->wm_command
= NULL
;
3604 if (PROP_GETSS(self
->window
, wm_command
, locale
, &data
) ||
3606 PROP_GETSS(self
->group
->leader
, wm_command
, locale
, &data
)))
3608 /* merge/mash them all together */
3609 gchar
*merge
= NULL
;
3612 for (i
= 0; data
[i
]; ++i
) {
3615 merge
= g_strconcat(merge
, data
[i
], NULL
);
3617 merge
= g_strconcat(data
[i
], NULL
);
3622 self
->wm_command
= merge
;
3626 #define WANT_EDGE(cur, c) \
3629 if(!client_normal(cur)) \
3631 if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL) \
3635 if(cur->layer < c->layer && !config_resist_layers_below) \
3638 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3639 if ((his_edge_start >= my_edge_start && \
3640 his_edge_start <= my_edge_end) || \
3641 (my_edge_start >= his_edge_start && \
3642 my_edge_start <= his_edge_end)) \
3645 /* finds the nearest edge in the given direction from the current client
3646 * note to self: the edge is the -frame- edge (the actual one), not the
3649 gint
client_directional_edge_search(ObClient
*c
, ObDirection dir
, gboolean hang
)
3651 gint dest
, monitor_dest
;
3652 gint my_edge_start
, my_edge_end
, my_offset
;
3659 a
= screen_area(c
->desktop
);
3660 monitor
= screen_area_monitor(c
->desktop
, client_monitor(c
));
3663 case OB_DIRECTION_NORTH
:
3664 my_edge_start
= c
->frame
->area
.x
;
3665 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3666 my_offset
= c
->frame
->area
.y
+ (hang
? c
->frame
->area
.height
: 0);
3668 /* default: top of screen */
3669 dest
= a
->y
+ (hang
? c
->frame
->area
.height
: 0);
3670 monitor_dest
= monitor
->y
+ (hang
? c
->frame
->area
.height
: 0);
3671 /* if the monitor edge comes before the screen edge, */
3672 /* use that as the destination instead. (For xinerama) */
3673 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3674 dest
= monitor_dest
;
3676 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3677 gint his_edge_start
, his_edge_end
, his_offset
;
3678 ObClient
*cur
= it
->data
;
3682 his_edge_start
= cur
->frame
->area
.x
;
3683 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3684 his_offset
= cur
->frame
->area
.y
+
3685 (hang
? 0 : cur
->frame
->area
.height
);
3687 if(his_offset
+ 1 > my_offset
)
3690 if(his_offset
< dest
)
3693 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3696 case OB_DIRECTION_SOUTH
:
3697 my_edge_start
= c
->frame
->area
.x
;
3698 my_edge_end
= c
->frame
->area
.x
+ c
->frame
->area
.width
;
3699 my_offset
= c
->frame
->area
.y
+ (hang
? 0 : c
->frame
->area
.height
);
3701 /* default: bottom of screen */
3702 dest
= a
->y
+ a
->height
- (hang
? c
->frame
->area
.height
: 0);
3703 monitor_dest
= monitor
->y
+ monitor
->height
-
3704 (hang
? c
->frame
->area
.height
: 0);
3705 /* if the monitor edge comes before the screen edge, */
3706 /* use that as the destination instead. (For xinerama) */
3707 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3708 dest
= monitor_dest
;
3710 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3711 gint his_edge_start
, his_edge_end
, his_offset
;
3712 ObClient
*cur
= it
->data
;
3716 his_edge_start
= cur
->frame
->area
.x
;
3717 his_edge_end
= cur
->frame
->area
.x
+ cur
->frame
->area
.width
;
3718 his_offset
= cur
->frame
->area
.y
+
3719 (hang
? cur
->frame
->area
.height
: 0);
3722 if(his_offset
- 1 < my_offset
)
3725 if(his_offset
> dest
)
3728 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3731 case OB_DIRECTION_WEST
:
3732 my_edge_start
= c
->frame
->area
.y
;
3733 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3734 my_offset
= c
->frame
->area
.x
+ (hang
? c
->frame
->area
.width
: 0);
3736 /* default: leftmost egde of screen */
3737 dest
= a
->x
+ (hang
? c
->frame
->area
.width
: 0);
3738 monitor_dest
= monitor
->x
+ (hang
? c
->frame
->area
.width
: 0);
3739 /* if the monitor edge comes before the screen edge, */
3740 /* use that as the destination instead. (For xinerama) */
3741 if (monitor_dest
!= dest
&& my_offset
> monitor_dest
)
3742 dest
= monitor_dest
;
3744 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3745 gint his_edge_start
, his_edge_end
, his_offset
;
3746 ObClient
*cur
= it
->data
;
3750 his_edge_start
= cur
->frame
->area
.y
;
3751 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3752 his_offset
= cur
->frame
->area
.x
+
3753 (hang
? 0 : cur
->frame
->area
.width
);
3755 if(his_offset
+ 1 > my_offset
)
3758 if(his_offset
< dest
)
3761 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3764 case OB_DIRECTION_EAST
:
3765 my_edge_start
= c
->frame
->area
.y
;
3766 my_edge_end
= c
->frame
->area
.y
+ c
->frame
->area
.height
;
3767 my_offset
= c
->frame
->area
.x
+ (hang
? 0 : c
->frame
->area
.width
);
3769 /* default: rightmost edge of screen */
3770 dest
= a
->x
+ a
->width
- (hang
? c
->frame
->area
.width
: 0);
3771 monitor_dest
= monitor
->x
+ monitor
->width
-
3772 (hang
? c
->frame
->area
.width
: 0);
3773 /* if the monitor edge comes before the screen edge, */
3774 /* use that as the destination instead. (For xinerama) */
3775 if (monitor_dest
!= dest
&& my_offset
< monitor_dest
)
3776 dest
= monitor_dest
;
3778 for(it
= client_list
; it
&& my_offset
!= dest
; it
= g_list_next(it
)) {
3779 gint his_edge_start
, his_edge_end
, his_offset
;
3780 ObClient
*cur
= it
->data
;
3784 his_edge_start
= cur
->frame
->area
.y
;
3785 his_edge_end
= cur
->frame
->area
.y
+ cur
->frame
->area
.height
;
3786 his_offset
= cur
->frame
->area
.x
+
3787 (hang
? cur
->frame
->area
.width
: 0);
3789 if(his_offset
- 1 < my_offset
)
3792 if(his_offset
> dest
)
3795 HIT_EDGE(my_edge_start
, my_edge_end
, his_edge_start
, his_edge_end
)
3798 case OB_DIRECTION_NORTHEAST
:
3799 case OB_DIRECTION_SOUTHEAST
:
3800 case OB_DIRECTION_NORTHWEST
:
3801 case OB_DIRECTION_SOUTHWEST
:
3802 /* not implemented */
3804 g_assert_not_reached();
3805 dest
= 0; /* suppress warning */
3810 ObClient
* client_under_pointer()
3814 ObClient
*ret
= NULL
;
3816 if (screen_pointer_pos(&x
, &y
)) {
3817 for (it
= stacking_list
; it
; it
= g_list_next(it
)) {
3818 if (WINDOW_IS_CLIENT(it
->data
)) {
3819 ObClient
*c
= WINDOW_AS_CLIENT(it
->data
);
3820 if (c
->frame
->visible
&&
3821 /* ignore all animating windows */
3822 !frame_iconify_animating(c
->frame
) &&
3823 RECT_CONTAINS(c
->frame
->area
, x
, y
))
3834 gboolean
client_has_group_siblings(ObClient
*self
)
3836 return self
->group
&& self
->group
->members
->next
;
3839 gboolean
client_has_application_group_siblings(ObClient
*self
)
3843 if (!self
->group
) return FALSE
;
3845 for (it
= self
->group
->members
; it
; it
= g_slist_next(it
)) {
3846 ObClient
*c
= it
->data
;
3847 if (c
!= self
&& client_application(c
))