#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_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);
/* non-zero defaults */
self->wmstate = WithdrawnState; /* make sure it gets updated first time */
- self->layer = -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);
/* the session should get the last say */
client_restore_session_state(self);
- client_calc_layer(self);
+ client_setup_decor_and_functions(self);
{
Time t = sn_app_started(self->startup_id, self->class);
/* 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);
+ /* do this to add ourselves to the stacking list in a non-intrusive way */
+ client_calc_layer(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))
+ stacking_raise(CLIENT_AS_WINDOW(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);
+
+ client_setup_decor_and_functions(self);
+
+ /* create the decoration frame for the client window and adjust its size */
+ self->frame = frame_new(self);
+ frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
+ 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 hint is used to pick a type, but the type can also affect
- transiency (dialogs are always made transients of their group if they
- have one). This is Havoc's idea, but it is needed to make some apps
- work right (eg tsclient).
- I also have made non-application type windows be transients based on
- their type, like dialogs.
- */
- client_update_transient_for(self);
- client_get_type(self);/* this can change the mwmhints for special cases */
+ /* these things can change the decor and functions of the window */
+
+ 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_transient_for(self);
+ client_update_normal_hints(self);
+
+ /* get the session related properties, these can change decorations
+ from per-app settings */
+ client_get_session_ids(self);
+
+ /* now we got everything that can affect the decorations */
+ if (!real)
+ return;
+
+ client_update_protocols(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 */
-
{
/* a couple type-based defaults for new windows */
if (self->type == OB_CLIENT_TYPE_DESKTOP)
self->desktop = DESKTOP_ALL;
}
-
- client_update_protocols(self);
-
- client_get_gravity(self); /* get the attribute gravity */
- client_update_normal_hints(self); /* this may override the attribute
- gravity */
-
- /* 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);
#ifdef SYNC
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);
+ 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)
}
}
-static void client_get_layer(ObClient *self)
-{
- if (!(self->above || self->below)) {
- if (self->group) {
- /* apply stuff from the group */
- GSList *it;
- gint layer = -2;
-
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if (c != self && !client_search_transient(self, c) &&
- client_normal(self) && client_normal(c))
- {
- layer = MAX(layer,
- (c->above ? 1 : (c->below ? -1 : 0)));
- }
- }
- switch (layer) {
- case -1:
- self->below = TRUE;
- break;
- case -2:
- case 0:
- break;
- case 1:
- self->above = TRUE;
- break;
- default:
- g_assert_not_reached();
- break;
- }
- }
- }
-}
-
static void client_get_state(ObClient *self)
{
guint32 *state;
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;
}
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 if (self->transient && self->group)
+ target = OB_TRAN_GROUP;
+
+ client_update_transient_tree(self, self->group, self->group,
+ self->transient_for, target);
+ self->transient_for = target;
+
+}
+
+static void client_update_transient_tree(ObClient *self,
+ ObGroup *oldgroup, ObGroup *newgroup,
+ ObClient* oldparent,
+ ObClient *newparent)
+{
+ GSList *it, *next;
+ ObClient *c;
+
+ /* No change has occured */
+ if (oldgroup == newgroup && oldparent == newparent) return;
+
+ /** Remove the client from the transient tree wherever it has changed **/
+
+ /* 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 ||
+ (newparent == OB_TRAN_GROUP && oldparent != newparent)) &&
+ oldgroup != NULL && oldparent != OB_TRAN_GROUP)
+ {
+ for (it = self->transients; it; it = next) {
+ next = g_slist_next(it);
+ c = it->data;
+ if (c->group == oldgroup)
+ self->transients = g_slist_delete_link(self->transients, it);
}
- } else
- self->transient = FALSE;
+ }
- /* if anything has changed... */
- if (target != self->transient_for) {
- if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
- GSList *it;
+ /* If we used to be transient for a group and now we are not, or we're
+ transient for a new group, then we need to remove ourselves from all
+ our ex-parents */
+ if (oldparent == OB_TRAN_GROUP && (oldgroup != newgroup ||
+ oldparent != newparent))
+ {
+ for (it = oldgroup->members; it; it = g_slist_next(it)) {
+ c = it->data;
+ if (c != self && (!c->transient_for ||
+ c->transient_for != OB_TRAN_GROUP))
+ c->transients = g_slist_remove(c->transients, self);
+ }
+ }
+ /* If we used to be transient for a single window and we are no longer
+ transient for it, then we need to remove ourself from its children */
+ else if (oldparent != NULL && oldparent != OB_TRAN_GROUP &&
+ oldparent != newparent)
+ oldparent->transients = g_slist_remove(oldparent->transients, self);
- /* remove from old parents */
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if (c != self && (!c->transient_for ||
- c->transient_for != OB_TRAN_GROUP))
- c->transients = g_slist_remove(c->transients, self);
- }
- } else if (self->transient_for != NULL) { /* transient of window */
- /* remove from old parent */
- self->transient_for->transients =
- g_slist_remove(self->transient_for->transients, self);
+
+ /** Re-add the client to the transient tree wherever it has changed **/
+
+ /* If we're now transient for a group and we weren't transient for it
+ before then we need to add ourselves to all our new parents */
+ if (newparent == OB_TRAN_GROUP && (oldgroup != newgroup ||
+ oldparent != newparent))
+ {
+ for (it = oldgroup->members; it; it = g_slist_next(it)) {
+ c = it->data;
+ if (c != self && (!c->transient_for ||
+ c->transient_for != OB_TRAN_GROUP))
+ c->transients = g_slist_prepend(c->transients, self);
}
- self->transient_for = target;
- if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
- GSList *it;
+ }
+ /* If we are now transient for a single window which we weren't before,
+ we need to add ourselves to its children
- /* add to new parents */
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if (c != self && (!c->transient_for ||
- c->transient_for != OB_TRAN_GROUP))
- c->transients = g_slist_append(c->transients, self);
+ WARNING: Cyclical transient ness is possible if two windows are
+ transient for eachother.
+ */
+ else if (newparent != NULL && newparent != OB_TRAN_GROUP &&
+ 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 new group transient
+ windows to our children. But if we're transient for the group, then
+ other group transients are not our children.
+
+ WARNING: Cyclical transient-ness is possible. For e.g. if:
+ A is transient for the group
+ B is a member of the group and transient for A
+ */
+ if (oldgroup != newgroup && newgroup != NULL &&
+ newparent != OB_TRAN_GROUP)
+ {
+ for (it = newgroup->members; it; it = g_slist_next(it)) {
+ c = it->data;
+ if (c != self && c->transient_for == OB_TRAN_GROUP &&
+ /* Don't make it our child if it is already our parent */
+ !client_is_direct_child(c, self))
+ {
+ self->transients = g_slist_prepend(self->transients, c);
}
- } else if (self->transient_for != NULL) { /* transient of window */
- /* add to new parent */
- self->transient_for->transients =
- g_slist_append(self->transient_for->transients, self);
}
}
}
}
}
-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;
/* kill the handle on fully maxed windows */
if (self->max_vert && self->max_horz)
- self->decorations &= ~OB_FRAME_DECOR_HANDLE;
+ self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
/* finally, the user can have requested no decorations, which overrides
everything (but doesnt give it a border if it doesnt have one) */
void client_update_wmhints(ObClient *self)
{
XWMHints *hints;
- GSList *it;
/* assume a window takes input if it doesnt specify */
self->can_focus = TRUE;
/* did the group state change? */
if (hints->window_group !=
- (self->group ? self->group->leader : None)) {
+ (self->group ? self->group->leader : None))
+ {
+ ObGroup *oldgroup = self->group;
+
/* remove from the old group if there was one */
if (self->group != NULL) {
- /* remove transients of the group */
- for (it = self->group->members; it; it = g_slist_next(it))
- self->transients = g_slist_remove(self->transients,
- it->data);
-
- /* remove myself from parents in the group */
- if (self->transient_for == OB_TRAN_GROUP) {
- for (it = self->group->members; it;
- it = g_slist_next(it))
- {
- ObClient *c = it->data;
-
- if (c != self && (!c->transient_for ||
- c->transient_for != OB_TRAN_GROUP))
- c->transients = g_slist_remove(c->transients,
- self);
- }
- }
-
group_remove(self->group, self);
self->group = NULL;
}
- /* add ourself to the group */
- if (hints->window_group != None)
+ /* add ourself to the group if we have one */
+ if (hints->window_group != None) {
self->group = group_add(hints->window_group, self);
+ }
-
- /* because the self->transient flag wont change from this call,
- we don't need to update the window's type and such, only its
- transient_for
-
- do this before adding transients from the group so we know if
- we are actually transient for the group or not.
+ /* Put ourselves into the new group's transient tree, and remove
+ ourselves from the old group's */
+ client_update_transient_tree(self, oldgroup, self->group,
+ self->transient_for,
+ self->transient_for);
+
+ /* Lastly, being in a group, or not, can change if the window is
+ transient for anything.
+
+ The logic for this is:
+ self->transient = TRUE always if the window wants to be
+ transient for something, even if transient_for was NULL because
+ it wasn't in a group before.
+
+ If transient_for was NULL and oldgroup was NULL we can assume
+ that when we add the new group, it will become transient for
+ something.
+
+ If transient_for was OB_TRAN_GROUP, then it must have already
+ had a group. If it is getting a new group, the above call to
+ client_update_transient_tree has already taken care of
+ everything ! If it is losing all group status then it will
+ no longer be transient for anything and that needs to be
+ updated.
*/
- client_update_transient_for(self);
-
- /* i can only have transients from the group if i am not
- transient for the group myself */
- if (self->group && (self->transient_for == NULL ||
- self->transient_for != OB_TRAN_GROUP))
- {
- /* add other transients of the group that are already
- set up */
- for (it = self->group->members; it; it = g_slist_next(it))
- {
- ObClient *c = it->data;
- if (c != self && c->transient_for == OB_TRAN_GROUP)
- self->transients = g_slist_append(self->transients, c);
- }
- }
+ if (self->transient &&
+ ((self->transient_for == NULL && oldgroup == NULL) ||
+ (self->transient_for == OB_TRAN_GROUP && !self->group)))
+ client_update_transient_for(self);
}
/* the WM_HINTS can contain an icon */
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 (PROP_GET32(self->window, net_wm_user_time, cardinal, &time)) {
+ 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 (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;
+ else
+ g_free(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;
}
static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
- ObStackingLayer min, gboolean raised)
+ ObStackingLayer min)
{
ObStackingLayer old, own;
GSList *it;
own = calc_layer(self);
self->layer = MAX(own, min);
+ if (self->layer != old) {
+ stacking_remove(CLIENT_AS_WINDOW(self));
+ stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
+ }
+
for (it = self->transients; it; it = g_slist_next(it))
client_calc_layer_recursive(it->data, orig,
- self->layer,
- raised ? raised : self->layer != old);
-
- if (!raised && self->layer != old)
- if (orig->frame) { /* only restack if the original window is managed */
- stacking_remove(CLIENT_AS_WINDOW(self));
- stacking_add(CLIENT_AS_WINDOW(self));
- }
+ self->layer);
}
void client_calc_layer(ObClient *self)
it = client_search_all_top_parents(self);
for (; it; it = g_slist_next(it))
- client_calc_layer_recursive(it->data, orig, 0, FALSE);
+ client_calc_layer_recursive(it->data, orig, 0);
}
gboolean client_should_show(ObClient *self)
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_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_NORMAL ||
- self->type == OB_CLIENT_TYPE_DIALOG);
+ 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_showhide(self);
/* raise if it was not already on the desktop */
if (old != DESKTOP_ALL)
- client_raise(self);
+ stacking_raise(CLIENT_AS_WINDOW(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;
}
}
self->modal = modal;
/* when a window changes modality, then its stacking order with its
transients needs to change */
- client_raise(self);
+ stacking_raise(CLIENT_AS_WINDOW(self));
}
if (iconic != self->iconic)
client_iconify(self, iconic, 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);
+ if (raise)
+ stacking_raise(CLIENT_AS_WINDOW(self));
+
+ client_focus(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_raise(ObClient *self)
-{
- action_run_string("Raise", self, CurrentTime);
-}
-
-void client_lower(ObClient *self)
+void client_bring_helper_windows(ObClient *self)
{
- action_run_string("Lower", self, CurrentTime);
+ client_bring_helper_windows_recursive(self, self->desktop);
}
gboolean client_focused(ObClient *self)
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;
-}