#include "event.h"
#include "grab.h"
#include "focus.h"
+#include "propwin.h"
#include "stacking.h"
#include "openbox.h"
#include "group.h"
GList *client_list = NULL;
static GSList *client_destructors = NULL;
-static GSList *client_desktop_notifies = NULL;
-static void client_get_all(ObClient *self);
+static void client_get_all(ObClient *self, gboolean real);
static void client_toggle_border(ObClient *self, gboolean show);
static void client_get_startup_id(ObClient *self);
static void client_get_session_ids(ObClient *self);
static void client_get_layer(ObClient *self);
static void client_get_shaped(ObClient *self);
static void client_get_mwm_hints(ObClient *self);
-static void client_get_gravity(ObClient *self);
static void client_get_colormap(ObClient *self);
-static void client_get_transientness(ObClient *self);
static void client_change_allowed_actions(ObClient *self);
static void client_change_state(ObClient *self);
static void client_change_wm_state(ObClient *self);
void client_shutdown(gboolean reconfig)
{
+ if (reconfig) return;
}
void client_add_destructor(ObClientCallback func, gpointer data)
}
}
-void client_add_desktop_notify(ObClientCallback func, gpointer data)
-{
- ClientCallback *d = g_new(ClientCallback, 1);
- d->func = func;
- d->data = data;
- client_desktop_notifies = g_slist_prepend(client_desktop_notifies, d);
-}
-
-void client_remove_desktop_notify(ObClientCallback func)
-{
- GSList *it;
-
- for (it = client_desktop_notifies; it; it = g_slist_next(it)) {
- ClientCallback *d = it->data;
- if (d->func == func) {
- g_free(d);
- client_desktop_notifies =
- g_slist_delete_link(client_desktop_notifies, it);
- break;
- }
- }
-}
-
void client_set_list()
{
Window *windows, *win_it;
grab_server(TRUE);
- /* check if it has already been unmapped by the time we started mapping.
- the grab does a sync so we don't have to here */
+ /* check if it has already been unmapped by the time we started
+ mapping. the grab does a sync so we don't have to here */
if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
{
XChangeWindowAttributes(ob_display, window,
CWEventMask|CWDontPropagate, &attrib_set);
-
/* create the ObClient struct, and populate it from the hints on the
window */
self = g_new0(ObClient, 1);
self->desktop = screen_num_desktops; /* always an invalid value */
self->user_time = focus_client ? focus_client->user_time : CurrentTime;
- client_get_all(self);
+ client_get_all(self, TRUE);
/* per-app settings override stuff, and return the settings for other
uses too */
settings = client_get_settings_state(self);
/* remove the client's border (and adjust re gravity) */
client_toggle_border(self, FALSE);
- /* specify that if we exit, the window should not be destroyed and should
- be reparented back to root automatically */
+ /* specify that if we exit, the window should not be destroyed and
+ should be reparented back to root automatically */
XChangeSaveSet(ob_display, window, SetModeInsert);
/* create the decoration frame for the client window */
self->frame = frame_new(self);
- frame_grab_client(self->frame, self);
+ frame_grab_client(self->frame);
/* do this after we have a frame.. it uses the frame to help determine the
WM_STATE to apply. */
client_set_list();
ob_debug("Managed window 0x%lx (%s)\n", window, self->class);
+
+ return;
+}
+
+
+ObClient *client_fake_manage(Window window)
+{
+ ObClient *self;
+ ObAppSettings *settings;
+
+ ob_debug("Pretend-managing window: %lx\n", window);
+
+ /* do this minimal stuff to figure out the client's decorations */
+
+ self = g_new0(ObClient, 1);
+ self->window = window;
+
+ client_get_all(self, FALSE);
+ /* per-app settings override stuff, and return the settings for other
+ uses too */
+ settings = client_get_settings_state(self);
+
+ /* create the decoration frame for the client window */
+ self->frame = frame_new(self);
+ return self;
}
void client_unmanage_all()
guint j;
GSList *it;
- ob_debug("Unmanaging window: %lx (%s) (%s)\n", self->window, self->class,
- self->title ? self->title : "");
+ ob_debug("Unmanaging window: %lx (%s) (%s)\n", self->window,
+ self->class, self->title ? self->title : "");
g_assert(self != NULL);
/* flush to send the hide to the server quickly */
XFlush(ob_display);
- /* ignore enter events from the unmap so it doesnt mess with the focus */
+ /* ignore enter events from the unmap so it doesnt mess with the
+ focus */
event_ignore_queued_enters();
mouse_grab_for_client(self, FALSE);
/* remove the window from our save set */
XChangeSaveSet(ob_display, self->window, SetModeDelete);
+ /* kill the property windows */
+ propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
+
/* update the focus lists */
focus_order_remove(self);
if (client_focused(self)) {
for (it = self->group->members; it; it = g_slist_next(it))
if (it->data != self)
((ObClient*)it->data)->transients =
- g_slist_remove(((ObClient*)it->data)->transients, self);
+ g_slist_remove(((ObClient*)it->data)->transients,self);
} else if (self->transient_for) { /* transient of window */
self->transient_for->transients =
g_slist_remove(self->transient_for->transients, self);
}
/* reparent the window out of the frame, and free the frame */
- frame_release_client(self->frame, self);
+ frame_release_client(self->frame);
+ frame_free(self->frame);
self->frame = NULL;
if (ob_state() != OB_STATE_EXITING) {
PROP_ERASE(self->window, net_wm_state);
PROP_ERASE(self->window, wm_state);
} else {
- /* if we're left in an unmapped state, the client wont be mapped. this
- is bad, since we will no longer be managing the window on restart */
+ /* if we're left in an unmapped state, the client wont be mapped.
+ this is bad, since we will no longer be managing the window on
+ restart */
XMapWindow(ob_display, self->window);
}
+ /* update the list hints */
+ client_set_list();
+
ob_debug("Unmanaged window 0x%lx\n", self->window);
/* free all data allocated in the client struct */
g_free(self->client_machine);
g_free(self->sm_client_id);
g_free(self);
-
- /* update the list hints */
- client_set_list();
+}
+
+void client_fake_unmanage(ObClient *self)
+{
+ /* this is all that got allocated to get the decorations */
+
+ frame_free(self->frame);
+ g_free(self);
}
static ObAppSettings *client_get_settings_state(ObClient *self)
}
-static void client_get_all(ObClient *self)
+static void client_get_all(ObClient *self, gboolean real)
{
+ /* this is needed for the frame to set itself up */
client_get_area(self);
- client_get_mwm_hints(self);
-
- /* The transient-ness of a window is used to pick a type, but the type can
- also affect transiency.
- Dialogs are always made transients for their group if they have one.
+ /* these things can change the decor and functions of the window */
- I also have made non-application type windows be transients for their
- group (eg utility windows).
- */
- client_get_transientness(self);
- client_get_type(self);/* this can change the mwmhints for special cases */
+ client_get_mwm_hints(self);
+ /* this can change the mwmhints for special cases */
+ client_get_type_and_transientness(self);
client_get_state(self);
+ client_update_protocols(self);
+ client_update_normal_hints(self);
- client_update_wmhints(self);
- /* this may have already been called from client_update_wmhints */
- if (self->transient_for == NULL)
- client_update_transient_for(self);
- client_get_startup_id(self);
- client_get_desktop(self);/* uses transient data/group/startup id if a
- desktop is not specified */
- client_get_shaped(self);
-
- client_get_layer(self); /* if layer hasn't been specified, get it from
- other sources if possible */
+ /* got the type, the mwmhints, the protocols, and the normal hints
+ (min/max sizes), so we're ready to set up the decorations/functions */
+ client_setup_decor_and_functions(self);
- {
- /* a couple type-based defaults for new windows */
+ if (real) {
+ client_update_wmhints(self);
+ /* this may have already been called from client_update_wmhints */
+ if (self->transient_for == NULL)
+ client_update_transient_for(self);
- /* this makes sure that these windows appear on all desktops */
- if (self->type == OB_CLIENT_TYPE_DESKTOP)
- self->desktop = DESKTOP_ALL;
- }
+ client_get_startup_id(self);
+ client_get_desktop(self);/* uses transient data/group/startup id if a
+ desktop is not specified */
+ client_get_shaped(self);
- client_update_protocols(self);
+ client_get_layer(self); /* if layer hasn't been specified, get it from
+ other sources if possible */
- client_get_gravity(self); /* get the attribute gravity */
- client_update_normal_hints(self); /* this may override the attribute
- gravity */
+ {
+ /* a couple type-based defaults for new windows */
- /* got the type, the mwmhints, the protocols, and the normal hints
- (min/max sizes), so we're ready to set up the decorations/functions */
- client_setup_decor_and_functions(self);
+ /* this makes sure that these windows appear on all desktops */
+ if (self->type == OB_CLIENT_TYPE_DESKTOP)
+ self->desktop = DESKTOP_ALL;
+ }
#ifdef SYNC
- client_update_sync_request_counter(self);
+ client_update_sync_request_counter(self);
#endif
- /* get the session related properties */
- client_get_session_ids(self);
+ /* get the session related properties */
+ client_get_session_ids(self);
- client_get_colormap(self);
- client_update_title(self);
- client_update_strut(self);
- client_update_icons(self);
- client_update_user_time(self);
- client_update_icon_geometry(self);
+ client_get_colormap(self);
+ client_update_title(self);
+ client_update_strut(self);
+ client_update_icons(self);
+ client_update_user_time_window(self);
+ if (!self->user_time_window) /* check if this would have been called */
+ client_update_user_time(self);
+ client_update_icon_geometry(self);
+ }
}
static void client_get_startup_id(ObClient *self)
#endif
}
-void client_get_transientness(ObClient *self)
-{
- Window t;
- if (XGetTransientForHint(ob_display, self->window, &t))
- self->transient = TRUE;
-}
-
void client_update_transient_for(ObClient *self)
{
Window t = None;
ObClient *target = NULL;
if (XGetTransientForHint(ob_display, self->window, &t)) {
- self->transient = TRUE;
if (t != self->window) { /* cant be transient to itself! */
target = g_hash_table_lookup(window_map, &t);
/* if this happens then we need to check for it*/
}
}
}
- } else if (self->type == OB_CLIENT_TYPE_DIALOG ||
- self->type == OB_CLIENT_TYPE_TOOLBAR ||
- self->type == OB_CLIENT_TYPE_MENU ||
- self->type == OB_CLIENT_TYPE_UTILITY)
- {
- self->transient = TRUE;
- if (self->group)
- target = OB_TRAN_GROUP;
- } else
- self->transient = FALSE;
+ } else if (self->transient && self->group)
+ target = OB_TRAN_GROUP;
client_update_transient_tree(self, self->group, self->group,
self->transient_for, target);
}
}
-void client_get_type(ObClient *self)
+void client_get_type_and_transientness(ObClient *self)
{
guint num, i;
guint32 *val;
+ Window t;
self->type = -1;
+ self->transient = FALSE;
if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
/* use the first value that we know about in the array */
}
g_free(val);
}
-
+
+ if (XGetTransientForHint(ob_display, self->window, &t))
+ self->transient = TRUE;
+
if (self->type == (ObClientType) -1) {
/*the window type hint was not set, which means we either classify
ourself as a normal window or a dialog, depending on if we are a
else
self->type = OB_CLIENT_TYPE_NORMAL;
}
+
+ /* then, based on our type, we can update our transientness.. */
+ if (self->type == OB_CLIENT_TYPE_DIALOG ||
+ self->type == OB_CLIENT_TYPE_TOOLBAR ||
+ self->type == OB_CLIENT_TYPE_MENU ||
+ self->type == OB_CLIENT_TYPE_UTILITY)
+ {
+ self->transient = TRUE;
+ }
}
void client_update_protocols(ObClient *self)
}
#endif
-static void client_get_gravity(ObClient *self)
-{
- XWindowAttributes wattrib;
- Status ret;
-
- ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
- g_assert(ret != BadWindow);
- self->gravity = wattrib.win_gravity;
-}
-
void client_get_colormap(ObClient *self)
{
XWindowAttributes wa;
self->functions &= ~(OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_RESIZE);
break;
+ case OB_CLIENT_TYPE_SPLASH:
+ /* these don't get get any decorations, and the only thing you can
+ do with them is move them */
+ self->decorations = 0;
+ self->functions = OB_CLIENT_FUNC_MOVE;
+
case OB_CLIENT_TYPE_DESKTOP:
case OB_CLIENT_TYPE_DOCK:
- case OB_CLIENT_TYPE_SPLASH:
- /* none of these windows are manipulated by the window manager */
+ /* these windows are not manipulated by the window manager */
self->decorations = 0;
self->functions = 0;
break;
void client_update_user_time(ObClient *self)
{
guint32 time;
+ gboolean got = FALSE;
+
+ if (self->user_time_window)
+ got = PROP_GET32(self->user_time_window,
+ net_wm_user_time, cardinal, &time);
+ if (!got)
+ got = PROP_GET32(self->window, net_wm_user_time, cardinal, &time);
- if (PROP_GET32(self->window, net_wm_user_time, cardinal, &time)) {
+ if (got) {
/* we set this every time, not just when it grows, because in practice
sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
backward we don't want all windows to stop focusing. we'll just
*/
self->user_time = time;
- /*
- ob_debug("window %s user time %u\n", self->title, time);
- */
+ /*ob_debug("window %s user time %u\n", self->title, time);*/
+ }
+}
+
+void client_update_user_time_window(ObClient *self)
+{
+ guint32 w;
+
+ if (!PROP_GET32(self->window, net_wm_user_time_window, window, &w))
+ w = None;
+
+ if (w != self->user_time_window) {
+ /* remove the old window */
+ propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
+ self->user_time_window = None;
+
+ if (self->group && self->group->leader == w) {
+ ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
+ "_NET_WM_USER_TYPE_WINDOW to its group leader\n");
+ /* do it anyways..? */
+ }
+ else if (w == self->window) {
+ ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
+ "_NET_WM_USER_TIME_WINDOW to itself\n");
+ w = None; /* don't do it */
+ }
+
+ /* add the new window */
+ propwin_add(w, OB_PROPWIN_USER_TIME, self);
+ self->user_time_window = w;
+
+ /* and update from it */
+ client_update_user_time(self);
}
}
self->type == OB_CLIENT_TYPE_TOOLBAR);
}
+gboolean client_mouse_focusable(ObClient *self)
+{
+ return !(self->type == OB_CLIENT_TYPE_MENU ||
+ self->type == OB_CLIENT_TYPE_TOOLBAR ||
+ self->type == OB_CLIENT_TYPE_SPLASH ||
+ self->type == OB_CLIENT_TYPE_DOCK);
+}
+
+gboolean client_enter_focusable(ObClient *self)
+{
+ /* you can focus desktops but it shouldn't on enter */
+ return (client_mouse_focusable(self) &&
+ self->type != OB_CLIENT_TYPE_DESKTOP);
+}
+
+
static void client_apply_startup_state(ObClient *self, gint x, gint y)
{
gboolean pos = FALSE; /* has the window's position been configured? */
pos = TRUE;
}
- /* if the client didn't get positioned yet, then do so now
+ /* if the client didn't get positioned yet, then do so now.
call client_move even if the window is not being moved anywhere, because
when we reparent it and decorate it, it is getting moved and we need to
be telling it so with a ConfigureNotify event.
self->window);
if (iconic) {
- if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
+ /* don't let non-normal windows iconify along with their parents
+ or whatever */
+ if (client_normal(self)) {
self->iconic = iconic;
/* update the focus lists.. iconic windows go to the bottom of
if (curdesk && self->desktop != screen_desktop &&
self->desktop != DESKTOP_ALL)
- client_set_desktop(self, screen_desktop, FALSE, FALSE);
+ client_set_desktop(self, screen_desktop, FALSE);
/* this puts it after the current focused window */
focus_order_remove(self);
void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk)
{
- /* move up the transient chain as far as possible first */
- self = client_search_top_normal_parent(self);
- client_iconify_recursive(self, iconic, curdesk);
+ if (self->functions & OB_CLIENT_FUNC_ICONIFY || !iconic) {
+ /* move up the transient chain as far as possible first */
+ self = client_search_top_normal_parent(self);
+ client_iconify_recursive(self, iconic, curdesk);
+ }
}
void client_maximize(ObClient *self, gboolean max, gint dir)
void client_set_desktop_recursive(ObClient *self,
guint target,
- gboolean donthide,
- gboolean focus_nonintrusive)
+ gboolean donthide)
{
guint old;
GSList *it;
g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
- /* remove from the old desktop(s) */
- if (!focus_nonintrusive)
- focus_order_remove(self);
-
old = self->desktop;
self->desktop = target;
PROP_SET32(self->window, net_wm_desktop, cardinal, target);
client_raise(self);
if (STRUT_EXISTS(self->strut))
screen_update_areas();
-
- /* add to the new desktop(s) */
- if (!focus_nonintrusive) {
- if (config_focus_new)
- focus_order_to_top(self);
- else
- focus_order_to_bottom(self);
- }
-
- /* call the notifies */
- GSList *it;
- for (it = client_desktop_notifies; it; it = g_slist_next(it)) {
- ClientCallback *d = it->data;
- d->func(self, d->data);
- }
}
/* move all transients */
for (it = self->transients; it; it = g_slist_next(it))
if (it->data != self)
if (client_is_direct_child(self, it->data))
- client_set_desktop_recursive(it->data, target,
- donthide, focus_nonintrusive);
+ client_set_desktop_recursive(it->data, target, donthide);
}
void client_set_desktop(ObClient *self, guint target,
- gboolean donthide, gboolean focus_nonintrusive)
+ gboolean donthide)
{
self = client_search_top_normal_parent(self);
- client_set_desktop_recursive(self, target, donthide, focus_nonintrusive);
+ client_set_desktop_recursive(self, target, donthide);
}
gboolean client_is_direct_child(ObClient *parent, ObClient *child)
gboolean modal = self->modal;
gboolean iconic = self->iconic;
gboolean demands_attention = self->demands_attention;
+ gboolean above = self->above;
+ gboolean below = self->below;
gint i;
if (!(action == prop_atoms.net_wm_state_add ||
} else if (state == prop_atoms.net_wm_state_fullscreen) {
fullscreen = TRUE;
} else if (state == prop_atoms.net_wm_state_above) {
- self->above = TRUE;
- self->below = FALSE;
+ above = TRUE;
+ below = FALSE;
} else if (state == prop_atoms.net_wm_state_below) {
- self->above = FALSE;
- self->below = TRUE;
+ above = FALSE;
+ below = TRUE;
} else if (state == prop_atoms.net_wm_state_demands_attention) {
demands_attention = TRUE;
} else if (state == prop_atoms.openbox_wm_state_undecorated) {
} else if (state == prop_atoms.net_wm_state_fullscreen) {
fullscreen = FALSE;
} else if (state == prop_atoms.net_wm_state_above) {
- self->above = FALSE;
+ above = FALSE;
} else if (state == prop_atoms.net_wm_state_below) {
- self->below = FALSE;
+ below = FALSE;
} else if (state == prop_atoms.net_wm_state_demands_attention) {
demands_attention = FALSE;
} else if (state == prop_atoms.openbox_wm_state_undecorated) {
if (demands_attention != self->demands_attention)
client_hilite(self, demands_attention);
+ if (above != self->above || below != self->below) {
+ self->above = above;
+ self->below = below;
+ client_calc_layer(self);
+ }
+
client_change_state(self); /* change the hint to reflect these changes */
}
self->desktop != screen_desktop)
{
if (here)
- client_set_desktop(self, screen_desktop, FALSE, FALSE);
+ client_set_desktop(self, screen_desktop, FALSE);
else
screen_set_desktop(self->desktop, FALSE);
} else if (!self->frame->visible)
{
guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
gboolean allow = FALSE;
- gboolean relative = FALSE;
- if (user || !focus_client)
+ /* if the request came from the user, or if nothing is focused, then grant
+ the request.
+ if the currently focused app doesn't set a user_time, then it can't
+ benefit from any focus stealing prevention.
+ */
+ if (user || !focus_client || !last_time)
allow = TRUE;
- /* if the request came from an application and something already has focus
- then do some checks; */
- else {
- GSList *it;
-
- /* search if someone related to us by transience already has focus */
- for (it = client_search_all_top_parents(self); it && !relative;
- it = g_slist_next(it))
- {
- if (client_search_transient(it->data, focus_client))
- relative = TRUE;
- }
-
- /* search if someone in the group already has focus */
- for (it = client_search_all_top_parents(self); it && !relative;
- it = g_slist_next(it))
- {
- if (client_search_transient(it->data, focus_client))
- relative = TRUE;
- }
-
- /* if a relative has focus, then if the time is newer (or we can't
- check the time - very lenient), allow focus to move */
- allow = relative && (!event_curtime || !last_time ||
- event_time_after(event_curtime, last_time));
- }
-
+ /* otherwise, if they didn't give a time stamp or if it is too old, they
+ don't get focus */
+ else
+ allow = event_curtime && event_time_after(event_curtime, last_time);
ob_debug_type(OB_DEBUG_FOCUS,
"Want to activate window 0x%x with time %u (last time %u), "
if (client_helper(self) &&
self->desktop != desktop && self->desktop != DESKTOP_ALL)
{
- client_set_desktop(self, desktop, FALSE, TRUE);
+ client_set_desktop(self, desktop, FALSE);
}
}
{
return self->group && self->group->members->next;
}
-
-gboolean client_has_non_helper_group_siblings(ObClient *self)
-{
- GSList *it;
-
- if (!self->group) return FALSE;
-
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if (c != self && client_normal(c) && !client_helper(c))
- return TRUE;
- }
- return FALSE;
-}
projects / chaz / openbox / blobdiff