#include "event.h"
#include "grab.h"
#include "focus.h"
+#include "propwin.h"
#include "stacking.h"
#include "openbox.h"
#include "group.h"
typedef struct
{
- ObClientDestructor func;
+ ObClientCallback func;
gpointer data;
-} Destructor;
+} ClientCallback;
-GList *client_list = NULL;
+GList *client_list = NULL;
-static GSList *client_destructors = NULL;
+static GSList *client_destructors = 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_area(ObClient *self);
static void client_get_desktop(ObClient *self);
static void client_get_state(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_client_machine(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);
static void client_apply_startup_state(ObClient *self, gint x, gint y);
static void client_restore_session_state(ObClient *self);
-static void client_restore_session_stacking(ObClient *self);
+static gboolean client_restore_session_stacking(ObClient *self);
static ObAppSettings *client_get_settings_state(ObClient *self);
static void client_update_transient_tree(ObClient *self,
ObGroup *oldgroup, ObGroup *newgroup,
ObClient* oldparent,
ObClient *newparent);
+static void client_present(ObClient *self, gboolean here, gboolean raise);
+static GSList *client_search_all_top_parents_internal(ObClient *self,
+ gboolean bylayer,
+ ObStackingLayer layer);
void client_startup(gboolean reconfig)
{
void client_shutdown(gboolean reconfig)
{
+ if (reconfig) return;
}
-void client_add_destructor(ObClientDestructor func, gpointer data)
+void client_add_destructor(ObClientCallback func, gpointer data)
{
- Destructor *d = g_new(Destructor, 1);
+ ClientCallback *d = g_new(ClientCallback, 1);
d->func = func;
d->data = data;
client_destructors = g_slist_prepend(client_destructors, d);
}
-void client_remove_destructor(ObClientDestructor func)
+void client_remove_destructor(ObClientCallback func)
{
GSList *it;
for (it = client_destructors; it; it = g_slist_next(it)) {
- Destructor *d = it->data;
+ ClientCallback *d = it->data;
if (d->func == func) {
g_free(d);
client_destructors = g_slist_delete_link(client_destructors, 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. */
grab_server(FALSE);
stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
- client_restore_session_stacking(self);
/* focus the new window? */
if (ob_state() != OB_STATE_STARTING &&
+ (!self->session || self->session->focused) &&
!self->iconic &&
/* this means focus=true for window is same as config_focus_new=true */
((config_focus_new || (settings && settings->focus == 1)) ||
*/
ob_debug("placing window 0x%x at %d, %d with size %d x %d\n",
self->window, newx, newy, self->area.width, self->area.height);
+ if (self->session)
+ ob_debug("session requested %d %d\n",
+ self->session->x, self->session->y);
+
client_apply_startup_state(self, newx, newy);
mouse_grab_for_client(self, TRUE);
Also if you don't have focus_new enabled, then it's going to get
raised to the top. Legacy begets legacy I guess?
*/
- client_raise(self);
+ if (!client_restore_session_stacking(self))
+ client_raise(self);
}
/* this has to happen before we try focus the window, but we want it to
a window maps since its not based on an action from the user like
clicking a window to activate it. so keep the new window out of the way
but do focus it. */
- if (activate)
- client_activate(self, FALSE, TRUE);
+ if (activate) {
+ gboolean stacked = client_restore_session_stacking(self);
+ client_present(self, FALSE, !stacked);
+ }
/* add to client list/map */
client_list = g_list_append(client_list, self);
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)) {
screen_update_areas();
for (it = client_destructors; it; it = g_slist_next(it)) {
- Destructor *d = it->data;
+ ClientCallback *d = it->data;
d->func(self, d->data);
}
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->icons[j].data);
if (self->nicons > 0)
g_free(self->icons);
+ g_free(self->wm_command);
g_free(self->title);
g_free(self->icon_title);
g_free(self->name);
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)
|| (app->class && app->name && !strcmp(app->class, self->class)
&& !strcmp(app->name, self->name)))
{
- ob_debug("Window matching: %s\n", app->name);
/* Match if no role was specified in the per app setting, or if the
* string matches the beginning of the role, since apps like to set
* the role to things like browser-window-23c4b2f */
if (!app->role
|| !strncmp(app->role, self->role, strlen(app->role)))
{
+ ob_debug("Window matching: %s\n", app->name);
/* use this one */
settings = app;
break;
if (settings->fullscreen != -1)
self->fullscreen = !!settings->fullscreen;
- if (settings->desktop < screen_num_desktops
- || settings->desktop == DESKTOP_ALL)
- self->desktop = settings->desktop;
+ if (settings->desktop) {
+ if (settings->desktop == DESKTOP_ALL)
+ self->desktop = settings->desktop;
+ else if (settings->desktop > 0 &&
+ settings->desktop <= screen_num_desktops)
+ self->desktop = settings->desktop - 1;
+ }
if (settings->layer == -1) {
self->below = TRUE;
{
GList *it;
- if (!(it = session_state_find(self)))
+ ob_debug_type(OB_DEBUG_SM,
+ "Restore session for client %s\n", self->title);
+
+ if (!(it = session_state_find(self))) {
+ ob_debug_type(OB_DEBUG_SM,
+ "Session data not found for client %s\n", self->title);
return;
+ }
self->session = it->data;
+ ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n",
+ self->title);
+
RECT_SET_POINT(self->area, self->session->x, self->session->y);
- self->positioned = PPosition;
+ self->positioned = USPosition;
if (self->session->w > 0)
self->area.width = self->session->w;
if (self->session->h > 0)
self->below = self->session->below;
self->max_horz = self->session->max_horz;
self->max_vert = self->session->max_vert;
+ self->undecorated = self->session->undecorated;
}
-static void client_restore_session_stacking(ObClient *self)
+static gboolean client_restore_session_stacking(ObClient *self)
{
- GList *it;
+ GList *it, *mypos;
+
+ if (!self->session) return FALSE;
- if (!self->session) return;
+ mypos = g_list_find(session_saved_state, self->session);
+ if (!mypos) return FALSE;
- it = g_list_find(session_saved_state, self->session);
- for (it = g_list_previous(it); it; it = g_list_previous(it)) {
+ /* start above me and look for the first client */
+ for (it = g_list_previous(mypos); it; it = g_list_previous(it)) {
GList *cit;
- for (cit = client_list; cit; cit = g_list_next(cit))
- if (session_state_cmp(it->data, cit->data))
- break;
- if (cit) {
- client_calc_layer(self);
- stacking_below(CLIENT_AS_WINDOW(self),
- CLIENT_AS_WINDOW(cit->data));
- break;
+ for (cit = client_list; cit; cit = g_list_next(cit)) {
+ ObClient *c = cit->data;
+ /* found a client that was in the session, so go below it */
+ if (c->session == it->data) {
+ stacking_below(CLIENT_AS_WINDOW(self),
+ CLIENT_AS_WINDOW(cit->data));
+ return TRUE;
+ }
}
}
+ return FALSE;
}
void client_move_onscreen(ObClient *self, gboolean rude)
if (!rude) {
Point oldtl, oldtr, oldbl, oldbr;
Point newtl, newtr, newbl, newbr;
- gboolean stationary;
+ gboolean stationary_l, stationary_r, stationary_t, stationary_b;
POINT_SET(oldtl, self->frame->area.x, self->frame->area.y);
POINT_SET(oldbr, self->frame->area.x + self->frame->area.width - 1,
POINT_SET(newbl, newtl.x, newbr.y);
/* is it moving or just resizing from some corner? */
- stationary = (POINT_EQUAL(oldtl, newtl) || POINT_EQUAL(oldtr, newtr) ||
- POINT_EQUAL(oldbl, newbl) || POINT_EQUAL(oldbr, newbr));
+ stationary_l = oldtl.x == oldtl.x;
+ stationary_r = oldtr.x == oldtr.x;
+ stationary_t = oldtl.y == oldtl.y;
+ stationary_b = oldbl.y == oldbl.y;
- /* if left edge is growing */
- if (stationary && newtl.x < oldtl.x)
+ /* if left edge is growing and didnt move right edge */
+ if (stationary_r && newtl.x < oldtl.x)
rudel = TRUE;
- /* if right edge is growing */
- if (stationary && newtr.x > oldtr.x)
+ /* if right edge is growing and didnt move left edge */
+ if (stationary_l && newtr.x > oldtr.x)
ruder = TRUE;
- /* if top edge is growing */
- if (stationary && newtl.y < oldtl.y)
+ /* if top edge is growing and didnt move bottom edge */
+ if (stationary_b && newtl.y < oldtl.y)
rudet = TRUE;
- /* if bottom edge is growing */
- if (stationary && newbl.y > oldbl.y)
+ /* if bottom edge is growing and didnt move top edge */
+ if (stationary_t && newbl.y > oldbl.y)
rudeb = TRUE;
}
}
-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.
+ /* these things can change the decor and functions of the window */
- Dialogs are always made transients for their group if they have one.
-
- 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);
- 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
- client_get_client_machine(self);
- client_get_colormap(self);
- client_update_title(self);
- client_update_class(self);
- client_update_sm_client_id(self);
- client_update_strut(self);
- client_update_icons(self);
- client_update_user_time(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_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)
self->below = TRUE;
else if (state[i] == prop_atoms.net_wm_state_demands_attention)
self->demands_attention = TRUE;
- else if (state[i] == prop_atoms.ob_wm_state_undecorated)
+ else if (state[i] == prop_atoms.openbox_wm_state_undecorated)
self->undecorated = TRUE;
}
#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->group) {
- 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;
- 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);
/** Remove the client from the transient tree wherever it has changed **/
- /* If the group changed then we need to remove any old group transient
- windows from our children. But if we're transient for the group, then
+ /* If the window is becoming a direct transient for a window in its group
+ then that window can't be a child of this window anymore */
+ if (oldparent != newparent &&
+ newparent != NULL && newparent != OB_TRAN_GROUP &&
+ newparent->transient_for == OB_TRAN_GROUP &&
+ newgroup != NULL && newgroup == oldgroup)
+ {
+ self->transients = g_slist_remove(self->transients, newparent);
+ }
+
+
+ /* If the group changed, or if we are just becoming transient for the
+ group, then we need to remove any old group transient windows
+ from our children. But if we were already transient for the group, then
other group transients are not our children. */
- if (oldgroup != newgroup && oldgroup != NULL &&
- oldparent != OB_TRAN_GROUP)
+ if ((oldgroup != newgroup ||
+ (newparent == OB_TRAN_GROUP && oldparent != newparent)) &&
+ oldgroup != NULL && oldparent != OB_TRAN_GROUP)
{
for (it = self->transients; it; it = next) {
next = g_slist_next(it);
transient for eachother.
*/
else if (newparent != NULL && newparent != OB_TRAN_GROUP &&
- newparent != newparent &&
+ newparent != oldparent &&
/* don't make ourself its child if it is already our child */
!client_is_direct_child(self, newparent))
newparent->transients = g_slist_prepend(newparent->transients, self);
- /* If the group changed then we need to add any old group transient
+ /* If the group changed then we need to add any new group transient
windows to our children. But if we're transient for the group, then
other group transients are not our children.
}
}
-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_wmhints(ObClient *self)
{
XWMHints *hints;
- GSList *it;
/* assume a window takes input if it doesnt specify */
self->can_focus = TRUE;
*/
if (self->transient &&
((self->transient_for == NULL && oldgroup == NULL) ||
- self->transient_for == OB_TRAN_GROUP && self->group == NULL))
+ (self->transient_for == OB_TRAN_GROUP && !self->group)))
client_update_transient_for(self);
}
self->icon_title = data;
}
-void client_update_class(ObClient *self)
-{
- gchar **data;
- gchar *s;
-
- if (self->name) g_free(self->name);
- if (self->class) g_free(self->class);
- if (self->role) g_free(self->role);
-
- self->name = self->class = self->role = NULL;
-
- if (PROP_GETSS(self->window, wm_class, locale, &data)) {
- if (data[0]) {
- self->name = g_strdup(data[0]);
- if (data[1])
- self->class = g_strdup(data[1]);
- }
- g_strfreev(data);
- }
-
- if (PROP_GETS(self->window, wm_window_role, locale, &s))
- self->role = s;
-
- if (self->name == NULL) self->name = g_strdup("");
- if (self->class == NULL) self->class = g_strdup("");
- if (self->role == NULL) self->role = g_strdup("");
-}
-
void client_update_strut(ObClient *self)
{
guint num;
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);*/
}
}
-static void client_get_client_machine(ObClient *self)
+void client_update_user_time_window(ObClient *self)
{
- gchar *data = NULL;
- gchar localhost[128];
+ guint32 w;
- g_free(self->client_machine);
+ 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);
+ }
+}
+
+void client_update_icon_geometry(ObClient *self)
+{
+ guint num;
+ guint32 *data;
+
+ RECT_SET(self->icon_geometry, 0, 0, 0, 0);
+
+ if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num)
+ && num == 4)
+ {
+ /* don't let them set it with an area < 0 */
+ RECT_SET(self->icon_geometry, data[0], data[1],
+ MAX(data[2],0), MAX(data[3],0));
+ }
+}
+
+static void client_get_session_ids(ObClient *self)
+{
+ guint32 leader;
+ gboolean got;
+ gchar *s;
+ gchar **ss;
+
+ if (!PROP_GET32(self->window, wm_client_leader, window, &leader))
+ leader = None;
+
+ /* get the SM_CLIENT_ID */
+ got = FALSE;
+ if (leader)
+ got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id);
+ if (!got)
+ PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id);
+
+ /* get the WM_CLASS (name and class). make them "" if they are not
+ provided */
+ got = FALSE;
+ if (leader)
+ got = PROP_GETSS(leader, wm_class, locale, &ss);
+ if (!got)
+ got = PROP_GETSS(self->window, wm_class, locale, &ss);
+
+ if (got) {
+ if (ss[0]) {
+ self->name = g_strdup(ss[0]);
+ if (ss[1])
+ self->class = g_strdup(ss[1]);
+ }
+ g_strfreev(ss);
+ }
+
+ if (self->name == NULL) self->name = g_strdup("");
+ if (self->class == NULL) self->class = g_strdup("");
+
+ /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
+ got = FALSE;
+ if (leader)
+ got = PROP_GETS(leader, wm_window_role, locale, &s);
+ if (!got)
+ got = PROP_GETS(self->window, wm_window_role, locale, &s);
+
+ if (got)
+ self->role = s;
+ else
+ self->role = g_strdup("");
+
+ /* get the WM_COMMAND */
+ got = FALSE;
+
+ if (leader)
+ got = PROP_GETSS(leader, wm_command, locale, &ss);
+ if (!got)
+ got = PROP_GETSS(self->window, wm_command, locale, &ss);
+
+ if (got) {
+ /* merge/mash them all together */
+ gchar *merge = NULL;
+ gint i;
+
+ for (i = 0; ss[i]; ++i) {
+ gchar *tmp = merge;
+ if (merge)
+ merge = g_strconcat(merge, ss[i], NULL);
+ else
+ merge = g_strconcat(ss[i], NULL);
+ g_free(tmp);
+ }
+ g_strfreev(ss);
+
+ self->wm_command = merge;
+ }
+
+ /* get the WM_CLIENT_MACHINE */
+ got = FALSE;
+ if (leader)
+ got = PROP_GETS(leader, wm_client_machine, locale, &s);
+ if (!got)
+ got = PROP_GETS(self->window, wm_client_machine, locale, &s);
+
+ if (got) {
+ gchar localhost[128];
- if (PROP_GETS(self->window, wm_client_machine, locale, &data)) {
gethostname(localhost, 127);
localhost[127] = '\0';
- if (strcmp(localhost, data))
- self->client_machine = data;
+ if (strcmp(localhost, s) != 0)
+ self->client_machine = s;
}
}
old = self->wmstate;
- if (self->shaded || self->iconic || !self->frame->visible)
+ if (self->shaded || self->iconic ||
+ (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop))
+ {
self->wmstate = IconicState;
- else
+ } else
self->wmstate = NormalState;
if (old != self->wmstate) {
if (self->demands_attention)
netstate[num++] = prop_atoms.net_wm_state_demands_attention;
if (self->undecorated)
- netstate[num++] = prop_atoms.ob_wm_state_undecorated;
+ netstate[num++] = prop_atoms.openbox_wm_state_undecorated;
PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
if (self->frame)
{
ObStackingLayer l;
- if (self->fullscreen &&
- (client_focused(self) || client_search_focus_tree(self)))
- l = OB_STACKING_LAYER_FULLSCREEN;
- else if (self->type == OB_CLIENT_TYPE_DESKTOP)
+ if (self->type == OB_CLIENT_TYPE_DESKTOP)
l = OB_STACKING_LAYER_DESKTOP;
else if (self->type == OB_CLIENT_TYPE_DOCK) {
if (self->below) l = OB_STACKING_LAYER_NORMAL;
else l = OB_STACKING_LAYER_ABOVE;
}
+ else if ((self->fullscreen ||
+ /* no decorations and fills the monitor = oldskool fullscreen */
+ (self->frame != NULL &&
+ (self->frame->size.right == 0 && self->frame->size.left == 0 &&
+ self->frame->size.bottom == 0 && self->frame->size.top == 0 &&
+ RECT_EQUAL(self->area,
+ *screen_physical_area_monitor
+ (client_monitor(self)))))) &&
+ (client_focused(self) || client_search_focus_tree(self)))
+ l = OB_STACKING_LAYER_FULLSCREEN;
else if (self->above) l = OB_STACKING_LAYER_ABOVE;
else if (self->below) l = OB_STACKING_LAYER_BELOW;
else l = OB_STACKING_LAYER_NORMAL;
return FALSE;
if (client_normal(self) && screen_showing_desktop)
return FALSE;
- /*
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP)
- return client_should_show(self->transient_for);
- else {
- GSList *it;
-
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if (c != self && !c->transient_for) {
- if (client_should_show(c))
- return TRUE;
- }
- }
- }
- }
- */
if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
return TRUE;
self->type == OB_CLIENT_TYPE_SPLASH);
}
-gboolean client_application(ObClient *self)
+gboolean client_helper(ObClient *self)
{
- return (self->type == OB_CLIENT_TYPE_NORMAL ||
- self->type == OB_CLIENT_TYPE_DIALOG);
+ return (self->type == OB_CLIENT_TYPE_UTILITY ||
+ self->type == OB_CLIENT_TYPE_MENU ||
+ 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 (changed) {
client_change_state(self);
+ if (ob_state() != OB_STATE_STARTING && config_animate_iconify)
+ frame_begin_iconify_animation(self->frame, iconic);
+ /* do this after starting the animation so it doesn't flash */
client_showhide(self);
- if (STRUT_EXISTS(self->strut))
- screen_update_areas();
}
/* iconify all direct transients, and deiconify all transients
void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk)
{
- /* move up the transient chain as far as possible first */
- self = client_search_top_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)
+ guint target,
+ gboolean donthide)
{
guint old;
GSList *it;
g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
- /* remove from the old desktop(s) */
- 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 (config_focus_new)
- focus_order_to_top(self);
- else
- focus_order_to_bottom(self);
}
/* move all transients */
client_set_desktop_recursive(it->data, target, donthide);
}
-void client_set_desktop(ObClient *self, guint target, gboolean donthide)
+void client_set_desktop(ObClient *self, guint target,
+ gboolean donthide)
{
- self = client_search_top_parent(self);
+ self = client_search_top_normal_parent(self);
client_set_desktop_recursive(self, target, donthide);
}
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 ||
action = self->demands_attention ?
prop_atoms.net_wm_state_remove :
prop_atoms.net_wm_state_add;
- else if (state == prop_atoms.ob_wm_state_undecorated)
+ else if (state == prop_atoms.openbox_wm_state_undecorated)
action = undecorated ? prop_atoms.net_wm_state_remove :
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.ob_wm_state_undecorated) {
+ } else if (state == prop_atoms.openbox_wm_state_undecorated) {
undecorated = TRUE;
}
} 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.ob_wm_state_undecorated) {
+ } else if (state == prop_atoms.openbox_wm_state_undecorated) {
undecorated = FALSE;
}
}
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 */
}
return TRUE;
}
+/*! Present the client to the user.
+ @param raise If the client should be raised or not. You should only set
+ raise to false if you don't care if the window is completely
+ hidden.
+*/
+static void client_present(ObClient *self, gboolean here, gboolean raise)
+{
+ /* if using focus_delay, stop the timer now so that focus doesn't
+ go moving on us */
+ event_halt_focus_delay();
+
+ if (client_normal(self) && screen_showing_desktop)
+ screen_show_desktop(FALSE, FALSE);
+ if (self->iconic)
+ client_iconify(self, FALSE, here);
+ if (self->desktop != DESKTOP_ALL &&
+ self->desktop != screen_desktop)
+ {
+ if (here)
+ client_set_desktop(self, screen_desktop, FALSE);
+ else
+ screen_set_desktop(self->desktop, FALSE);
+ } else if (!self->frame->visible)
+ /* if its not visible for other reasons, then don't mess
+ with it */
+ return;
+ if (self->shaded)
+ client_shade(self, FALSE);
+
+ client_focus(self);
+
+ if (raise) {
+ /* we do this as an action here. this is rather important. this is
+ because we want the results from the focus change to take place
+ BEFORE we go about raising the window. when a fullscreen window
+ loses focus, we need this or else the raise wont be able to raise
+ above the to-lose-focus fullscreen window. */
+ client_raise(self);
+ }
+}
+
void client_activate(ObClient *self, gboolean here, gboolean user)
{
guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
+ gboolean allow = FALSE;
- /* XXX do some stuff here if user is false to determine if we really want
- to activate it or not (a parent or group member is currently
- active)?
+ /* 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;
+ /* 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), "
- "source=%s\n",
+ "source=%s allowing? %d\n",
self->window, event_curtime, last_time,
- (user ? "user" : "application"));
+ (user ? "user" : "application"), allow);
- if (!user && event_curtime && last_time &&
- !event_time_after(event_curtime, last_time))
- {
- client_hilite(self, TRUE);
- } else {
+ if (allow) {
if (event_curtime != CurrentTime)
self->user_time = event_curtime;
- /* if using focus_delay, stop the timer now so that focus doesn't
- go moving on us */
- event_halt_focus_delay();
+ client_present(self, here, TRUE);
+ } else
+ /* don't focus it but tell the user it wants attention */
+ client_hilite(self, TRUE);
+}
- if (client_normal(self) && screen_showing_desktop)
- screen_show_desktop(FALSE);
- if (self->iconic)
- client_iconify(self, FALSE, here);
- if (self->desktop != DESKTOP_ALL &&
- self->desktop != screen_desktop)
- {
- if (here)
- client_set_desktop(self, screen_desktop, FALSE);
- else
- screen_set_desktop(self->desktop);
- } else if (!self->frame->visible)
- /* if its not visible for other reasons, then don't mess
- with it */
- return;
- if (self->shaded)
- client_shade(self, FALSE);
+static void client_bring_helper_windows_recursive(ObClient *self,
+ guint desktop)
+{
+ GSList *it;
- client_focus(self);
+ for (it = self->transients; it; it = g_slist_next(it))
+ client_bring_helper_windows_recursive(it->data, desktop);
- /* we do this as an action here. this is rather important. this is
- because we want the results from the focus change to take place
- BEFORE we go about raising the window. when a fullscreen window
- loses focus, we need this or else the raise wont be able to raise
- above the to-lose-focus fullscreen window. */
- client_raise(self);
+ if (client_helper(self) &&
+ self->desktop != desktop && self->desktop != DESKTOP_ALL)
+ {
+ client_set_desktop(self, desktop, FALSE);
}
}
+void client_bring_helper_windows(ObClient *self)
+{
+ client_bring_helper_windows_recursive(self, self->desktop);
+}
+
void client_raise(ObClient *self)
{
action_run_string("Raise", self, CurrentTime);
return screen_find_monitor(&self->frame->area);
}
-ObClient *client_search_top_parent(ObClient *self)
+ObClient *client_search_top_normal_parent(ObClient *self)
{
while (self->transient_for && self->transient_for != OB_TRAN_GROUP &&
- client_normal(self))
+ client_normal(self->transient_for))
self = self->transient_for;
return self;
}
-GSList *client_search_all_top_parents(ObClient *self)
+static GSList *client_search_all_top_parents_internal(ObClient *self,
+ gboolean bylayer,
+ ObStackingLayer layer)
{
GSList *ret = NULL;
-
+
/* move up the direct transient chain as far as possible */
- while (self->transient_for && self->transient_for != OB_TRAN_GROUP)
+ while (self->transient_for && self->transient_for != OB_TRAN_GROUP &&
+ (!bylayer || self->transient_for->layer == layer) &&
+ client_normal(self->transient_for))
self = self->transient_for;
if (!self->transient_for)
for (it = self->group->members; it; it = g_slist_next(it)) {
ObClient *c = it->data;
- if (!c->transient_for && client_normal(c))
+ if (!c->transient_for && client_normal(c) &&
+ (!bylayer || c->layer == layer))
+ {
ret = g_slist_prepend(ret, c);
+ }
}
if (ret == NULL) /* no group parents */
return ret;
}
+GSList *client_search_all_top_parents(ObClient *self)
+{
+ return client_search_all_top_parents_internal(self, FALSE, 0);
+}
+
+GSList *client_search_all_top_parents_layer(ObClient *self)
+{
+ return client_search_all_top_parents_internal(self, TRUE, self->layer);
+}
+
ObClient *client_search_focus_parent(ObClient *self)
{
if (self->transient_for) {
return NULL;
}
-void client_update_sm_client_id(ObClient *self)
-{
- g_free(self->sm_client_id);
- self->sm_client_id = NULL;
-
- if (!PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id) &&
- self->group)
- PROP_GETS(self->group->leader, sm_client_id, locale,
- &self->sm_client_id);
-}
-
#define WANT_EDGE(cur, c) \
if(cur == c) \
continue; \
- if(!client_normal(cur)) \
+ if(!client_normal(cur)) \
continue; \
if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL) \
continue; \
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = WINDOW_AS_CLIENT(it->data);
if (c->frame->visible &&
- RECT_CONTAINS(c->frame->area, x, y)) {
+ /* ignore all animating windows */
+ !frame_iconify_animating(c->frame) &&
+ RECT_CONTAINS(c->frame->area, x, y))
+ {
ret = c;
break;
}
{
return self->group && self->group->members->next;
}
-
-gboolean client_has_application_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_application(c))
- return TRUE;
- }
- return FALSE;
-}
projects / chaz / openbox / blobdiff