static ObAppSettings *client_get_settings_state(ObClient *self);
static void client_update_transient_tree(ObClient *self,
ObGroup *oldgroup, ObGroup *newgroup,
+ gboolean oldgtran, gboolean newgtran,
ObClient* oldparent,
ObClient *newparent);
static void client_present(ObClient *self, gboolean here, gboolean raise);
ObStackingLayer layer);
static void client_call_notifies(ObClient *self, GSList *list);
+
void client_startup(gboolean reconfig)
{
if (reconfig) return;
stacking_set_list();
}
-/*
- void client_foreach_transient(ObClient *self, ObClientForeachFunc func, gpointer data)
- {
- GSList *it;
-
- for (it = self->transients; it; it = g_slist_next(it)) {
- if (!func(it->data, data)) return;
- client_foreach_transient(it->data, func, data);
- }
- }
-
- void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, gpointer data)
- {
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP) {
- if (!func(self->transient_for, data)) return;
- client_foreach_ancestor(self->transient_for, func, data);
- } else {
- GSList *it;
-
- for (it = self->group->members; it; it = g_slist_next(it))
- if (it->data != self &&
- !((ObClient*)it->data)->transient_for) {
- if (!func(it->data, data)) return;
- client_foreach_ancestor(it->data, func, data);
- }
- }
- }
- }
-*/
-
void client_manage_all()
{
guint i, j, nchild;
/* 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)) ||
client_search_focus_tree_full(self)) &&
/* this checks for focus=false for the window */
(!settings || settings->focus != 0) &&
- /* note the check against type Normal/Dialog/Utility,
- not client_normal(self), which would also include other types.
- in this case we want more strict rules for focus */
- (self->type == OB_CLIENT_TYPE_NORMAL ||
- self->type == OB_CLIENT_TYPE_UTILITY ||
- self->type == OB_CLIENT_TYPE_DIALOG))
+ focus_valid_target(self, FALSE, TRUE, FALSE, FALSE))
{
activate = TRUE;
}
splash screens get "transient" set to TRUE by
the place_client call
*/
- transient ||
- (!(self->positioned & USPosition) &&
- client_normal(self) &&
- !self->session));
+ ob_state() == OB_STATE_RUNNING &&
+ (transient ||
+ (!(self->positioned & USPosition) &&
+ client_normal(self) &&
+ !self->session)));
}
/* if the window isn't user-sized, then make it fit inside
splash screens get "transient" set to TRUE by
the place_client call
*/
- if (transient ||
- (!(self->sized & USSize) &&
- client_normal(self) &&
- !self->session))
+ if (ob_state() == OB_STATE_RUNNING &&
+ (transient ||
+ (!(self->sized & USSize) &&
+ client_normal(self) &&
+ !self->session)))
{
- /* make a copy to modify */
- Rect a = *screen_area_monitor(self->desktop, client_monitor(self));
+ Rect placer;
+
+ RECT_SET(placer, placex, placey, placew, placeh);
+ frame_rect_to_frame(self->frame, &placer);
+
+ Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &placer);
/* shrink by the frame's area */
- a.width -= self->frame->size.left + self->frame->size.right;
- a.height -= self->frame->size.top + self->frame->size.bottom;
+ a->width -= self->frame->size.left + self->frame->size.right;
+ a->height -= self->frame->size.top + self->frame->size.bottom;
/* fit the window inside the area */
- if (placew > a.width || self->area.height > a.height) {
- placew = MIN(self->area.width, a.width);
- placeh = MIN(self->area.height, a.height);
+ if (placew > a->width || self->area.height > a->height) {
+ placew = MIN(self->area.width, a->width);
+ placeh = MIN(self->area.height, a->height);
ob_debug("setting window size to %dx%d\n",
self->area.width, self->area.height);
}
+ g_free(a);
}
"desktop\n");
}
/* If something is focused, and it's not our relative... */
- else if (focus_client && client_search_focus_tree_full(self) == NULL)
+ else if (focus_client && client_search_focus_tree_full(self) == NULL &&
+ client_search_focus_group_full(self) == NULL)
{
/* If time stamp is old, don't steal focus */
if (self->user_time && last_time &&
/* this has to happen before we try focus the window, but we want it to
happen after the client's stacking has been determined or it looks bad
*/
- client_show(self);
+ {
+ gulong ignore_start;
+ if (!config_focus_under_mouse)
+ ignore_start = event_start_ignore_all_enters();
+
+ client_show(self);
+
+ if (!config_focus_under_mouse)
+ event_end_ignore_all_enters(ignore_start);
+ }
if (activate) {
gboolean stacked = client_restore_session_stacking(self);
XSelectInput(ob_display, self->window, NoEventMask);
/* ignore enter events from the unmap so it doesnt mess with the focus */
- if (!client_focused(self) || !config_focus_under_mouse)
+ if (!config_focus_under_mouse)
ignore_start = event_start_ignore_all_enters();
frame_hide(self->frame);
/* flush to send the hide to the server quickly */
XFlush(ob_display);
- if (!client_focused(self) || !config_focus_under_mouse)
+ if (!config_focus_under_mouse)
event_end_ignore_all_enters(ignore_start);
mouse_grab_for_client(self, FALSE);
client_call_notifies(self, client_destroy_notifies);
/* tell our parent(s) that we're gone */
- if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
- 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);
- } else if (self->transient_for) { /* transient of window */
- self->transient_for->transients =
- g_slist_remove(self->transient_for->transients, self);
- }
+ for (it = self->parents; it; it = g_slist_next(it))
+ ((ObClient*)it->data)->transients =
+ g_slist_remove(((ObClient*)it->data)->transients,self);
/* tell our transients that we're gone */
for (it = self->transients; it; it = g_slist_next(it)) {
- if (((ObClient*)it->data)->transient_for != OB_TRAN_GROUP) {
- ((ObClient*)it->data)->transient_for = NULL;
- client_calc_layer(it->data);
- }
+ ((ObClient*)it->data)->parents =
+ g_slist_remove(((ObClient*)it->data)->parents, self);
+ /* we could be keeping our children in a higher layer */
+ client_calc_layer(it->data);
}
/* remove from its group */
gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h,
gboolean rude)
{
- Rect *mon_a, *all_a;
gint ox = *x, oy = *y;
gboolean rudel = rude, ruder = rude, rudet = rude, rudeb = rude;
gint fw, fh;
Rect desired;
+ guint i;
RECT_SET(desired, *x, *y, w, h);
- all_a = screen_area(self->desktop);
- mon_a = screen_area_monitor(self->desktop, screen_find_monitor(&desired));
+ frame_rect_to_frame(self->frame, &desired);
/* get where the frame would be */
frame_client_gravity(self->frame, x, y, w, h);
fw = self->frame->size.left + w + self->frame->size.right;
fh = self->frame->size.top + h + self->frame->size.bottom;
- /* This makes sure windows aren't entirely outside of the screen so you
- can't see them at all.
- It makes sure 10% of the window is on the screen at least. At don't let
- it move itself off the top of the screen, which would hide the titlebar
- on you. (The user can still do this if they want too, it's only limiting
- the application.
-
- XXX watch for xinerama dead areas...
- */
- if (client_normal(self)) {
- if (!self->strut.right && *x + fw/10 >= all_a->x + all_a->width - 1)
- *x = all_a->x + all_a->width - fw/10;
- if (!self->strut.bottom && *y + fh/10 >= all_a->y + all_a->height - 1)
- *y = all_a->y + all_a->height - fh/10;
- if (!self->strut.left && *x + fw*9/10 - 1 < all_a->x)
- *x = all_a->x - fw*9/10;
- if (!self->strut.top && *y + fh*9/10 - 1 < all_a->y)
- *y = all_a->y - fw*9/10;
- }
-
- /* If rudeness wasn't requested, then figure out of the client is currently
- entirely on the screen. If it is, and the position isn't changing by
- request, and it is enlarging, then be rude even though it wasn't
- requested */
+ /* If rudeness wasn't requested, then still be rude in a given direction
+ if the client is not moving, only resizing in that direction */
if (!rude) {
Point oldtl, oldtr, oldbl, oldbr;
Point newtl, newtr, newbl, newbr;
rudeb = TRUE;
}
- /* This here doesn't let windows even a pixel outside the struts/screen.
- * When called from client_manage, programs placing themselves are
- * forced completely onscreen, while things like
- * xterm -geometry resolution-width/2 will work fine. Trying to
- * place it completely offscreen will be handled in the above code.
- * Sorry for this confused comment, i am tired. */
- if (rudel && !self->strut.left && *x < mon_a->x) *x = mon_a->x;
- if (ruder && !self->strut.right && *x + fw > mon_a->x + mon_a->width)
- *x = mon_a->x + MAX(0, mon_a->width - fw);
+ for (i = 0; i < screen_num_monitors; ++i) {
+ Rect *a;
+
+ if (!screen_physical_area_monitor_contains(i, &desired))
+ continue;
+
+ a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &desired);
- if (rudet && !self->strut.top && *y < mon_a->y) *y = mon_a->y;
- if (rudeb && !self->strut.bottom && *y + fh > mon_a->y + mon_a->height)
- *y = mon_a->y + MAX(0, mon_a->height - fh);
+ /* This makes sure windows aren't entirely outside of the screen so you
+ can't see them at all.
+ It makes sure 10% of the window is on the screen at least. At don't
+ let it move itself off the top of the screen, which would hide the
+ titlebar on you. (The user can still do this if they want too, it's
+ only limiting the application.
+ */
+ if (client_normal(self)) {
+ if (!self->strut.right && *x + fw/10 >= a->x + a->width - 1)
+ *x = a->x + a->width - fw/10;
+ if (!self->strut.bottom && *y + fh/10 >= a->y + a->height - 1)
+ *y = a->y + a->height - fh/10;
+ if (!self->strut.left && *x + fw*9/10 - 1 < a->x)
+ *x = a->x - fw*9/10;
+ if (!self->strut.top && *y + fh*9/10 - 1 < a->y)
+ *y = a->y - fw*9/10;
+ }
+
+ /* This here doesn't let windows even a pixel outside the
+ struts/screen. When called from client_manage, programs placing
+ themselves are forced completely onscreen, while things like
+ xterm -geometry resolution-width/2 will work fine. Trying to
+ place it completely offscreen will be handled in the above code.
+ Sorry for this confused comment, i am tired. */
+ if (rudel && !self->strut.left && *x < a->x) *x = a->x;
+ if (ruder && !self->strut.right && *x + fw > a->x + a->width)
+ *x = a->x + MAX(0, a->width - fw);
+
+ if (rudet && !self->strut.top && *y < a->y) *y = a->y;
+ if (rudeb && !self->strut.bottom && *y + fh > a->y + a->height)
+ *y = a->y + MAX(0, a->height - fh);
+
+ g_free(a);
+ }
/* get where the client should be */
frame_frame_gravity(self->frame, x, y, w, h);
client_update_wmhints(self);
/* this may have already been called from client_update_wmhints */
- if (self->transient_for == NULL)
+ if (!self->parents && !self->transient_for_group)
client_update_transient_for(self);
client_get_startup_id(self);
self->desktop = d;
ob_debug("client requested desktop 0x%x\n", self->desktop);
} else {
- gboolean trdesk = FALSE;
+ GSList *it;
+ gboolean first = TRUE;
+ guint all = screen_num_desktops; /* not a valid value */
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP) {
- if (self->transient_for->desktop != DESKTOP_ALL) {
- self->desktop = self->transient_for->desktop;
- trdesk = TRUE;
- }
- } else {
- /* if all the group is on one desktop, then open it on the
- same desktop */
- GSList *it;
- gboolean first = TRUE;
- guint all = screen_num_desktops; /* not a valid value */
-
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if (c != self) {
- if (first) {
- all = c->desktop;
- first = FALSE;
- }
- else if (all != c->desktop)
- all = screen_num_desktops; /* make it invalid */
- }
- }
- if (all != screen_num_desktops) {
- self->desktop = all;
- trdesk = TRUE;
- }
+ /* if they are all on one desktop, then open it on the
+ same desktop */
+ for (it = self->parents; it; it = g_slist_next(it)) {
+ ObClient *c = it->data;
+
+ if (c->desktop == DESKTOP_ALL) continue;
+
+ if (first) {
+ all = c->desktop;
+ first = FALSE;
}
+ else if (all != c->desktop)
+ all = screen_num_desktops; /* make it invalid */
}
- if (!trdesk) {
- /* try get from the startup-notification protocol */
- if (sn_get_desktop(self->startup_id, &self->desktop)) {
- if (self->desktop >= screen_num_desktops &&
- self->desktop != DESKTOP_ALL)
- self->desktop = screen_num_desktops - 1;
- } else
- /* defaults to the current desktop */
- self->desktop = screen_desktop;
+ if (all != screen_num_desktops) {
+ self->desktop = all;
+
+ ob_debug("client desktop set from parents: 0x%x\n",
+ self->desktop);
+ }
+ /* try get from the startup-notification protocol */
+ else if (sn_get_desktop(self->startup_id, &self->desktop)) {
+ if (self->desktop >= screen_num_desktops &&
+ self->desktop != DESKTOP_ALL)
+ self->desktop = screen_num_desktops - 1;
+ ob_debug("client desktop set from startup-notification: 0x%x\n",
+ self->desktop);
+ }
+ /* defaults to the current desktop */
+ else {
+ self->desktop = screen_desktop;
+ ob_debug("client desktop set to the current desktop: %d\n",
+ self->desktop);
}
}
}
{
Window t = None;
ObClient *target = NULL;
+ gboolean trangroup = FALSE;
if (XGetTransientForHint(ob_display, self->window, &t)) {
if (t != self->window) { /* cant be transient to itself! */
a dockapp, for example */
target = NULL;
}
-
- /* THIS IS SO ANNOYING ! ! ! ! Let me explain.... have a seat..
-
- Setting the transient_for to Root is actually illegal, however
- applications from time have done this to specify transient for
- their group.
-
- Now you can do that by being a TYPE_DIALOG and not setting
- the transient_for hint at all on your window. But people still
- use Root, and Kwin is very strange in this regard.
-
- KWin 3.0 will not consider windows with transient_for set to
- Root as transient for their group *UNLESS* they are also modal.
- In that case, it will make them transient for the group. This
- leads to all sorts of weird behavior from KDE apps which are
- only tested in KWin. I'd like to follow their behavior just to
- make this work right with KDE stuff, but that seems wrong.
- */
- if (!target && self->group) {
- /* not transient to a client, see if it is transient for a
- group */
- if (t == RootWindow(ob_display, ob_screen)) {
- /* window is a transient for its group! */
- target = OB_TRAN_GROUP;
- }
- }
}
- } else if (self->transient && self->group)
- target = OB_TRAN_GROUP;
+
+ /* Setting the transient_for to Root is actually illegal, however
+ applications from time have done this to specify transient for
+ their group */
+ if (!target && self->group && t == RootWindow(ob_display, ob_screen))
+ trangroup = TRUE;
+ } else if (self->group && self->transient)
+ trangroup = TRUE;
client_update_transient_tree(self, self->group, self->group,
- self->transient_for, target);
- self->transient_for = target;
+ self->transient_for_group, trangroup,
+ client_direct_parent(self), target);
+ self->transient_for_group = trangroup;
}
static void client_update_transient_tree(ObClient *self,
ObGroup *oldgroup, ObGroup *newgroup,
+ gboolean oldgtran, gboolean newgtran,
ObClient* oldparent,
ObClient *newparent)
{
GSList *it, *next;
ObClient *c;
+ g_assert(!oldgtran || oldgroup);
+ g_assert(!newgtran || newgroup);
+ g_assert((!oldgtran && !oldparent) ||
+ (oldgtran && !oldparent) ||
+ (!oldgtran && oldparent));
+ g_assert((!newgtran && !newparent) ||
+ (newgtran && !newparent) ||
+ (!newgtran && newparent));
+
/* * *
Group transient windows are not allowed to have other group
transient windows as their children.
/* No change has occured */
- if (oldgroup == newgroup && oldparent == newparent) return;
+ if (oldgroup == newgroup &&
+ oldgtran == newgtran &&
+ oldparent == newparent) return;
/** Remove the client from the transient tree wherever it has changed **/
we could have any number of direct parents above up, any of which could
be transient for the group, and we need to remove it from our children.
*/
- if (oldparent != newparent &&
- newparent != NULL && newparent != OB_TRAN_GROUP &&
- newgroup != NULL && newgroup == oldgroup)
+ if (!oldgtran && oldparent != newparent && newparent != NULL &&
+ newgroup != NULL && newgroup == oldgroup &&
+ client_normal(newparent))
{
- ObClient *look = newparent;
- do {
- self->transients = g_slist_remove(self->transients, look);
- look = look->transient_for;
- } while (look != NULL && look != OB_TRAN_GROUP);
+ ObClient *look = client_search_top_direct_parent(newparent);
+ self->transients = g_slist_remove(self->transients, look);
+ look->parents = g_slist_remove(look->parents, self);
}
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)
+ if ((oldgroup != newgroup || (newgtran && oldgtran != newgtran)) &&
+ oldgroup != NULL && !oldgtran)
{
for (it = self->transients; it; it = next) {
next = g_slist_next(it);
c = it->data;
- if (c->group == oldgroup)
+ if (c->group == oldgroup && client_normal(self)) {
self->transients = g_slist_delete_link(self->transients, it);
+ c->parents = g_slist_remove(c->parents, self);
+ }
}
}
/* 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))
+ if (oldgtran && (oldgroup != newgroup || oldgtran != newgtran))
{
- for (it = oldgroup->members; it; it = g_slist_next(it)) {
+ for (it = self->parents; it; it = next) {
+ next = g_slist_next(it);
c = it->data;
- if (c != self && (!c->transient_for ||
- c->transient_for != OB_TRAN_GROUP))
+ if (!c->transient_for_group && client_normal(c)) {
c->transients = g_slist_remove(c->transients, self);
+ self->parents = g_slist_delete_link(self->parents, it);
+ }
}
}
/* 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)
+ else if (oldparent && oldparent != newparent &&
+ client_normal(oldparent))
+ {
oldparent->transients = g_slist_remove(oldparent->transients, self);
-
+ self->parents = g_slist_remove(self->parents, oldparent);
+ }
/** 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))
+ if (newgtran && (oldgroup != newgroup || oldgtran != newgtran))
{
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))
+ if (c != self && !c->transient_for_group && client_normal(c))
+ {
c->transients = g_slist_prepend(c->transients, self);
+ self->parents = g_slist_prepend(self->parents, c);
+ }
}
}
/* If we are now transient for a single window which we weren't before,
WARNING: Cyclical transient ness is possible if two windows are
transient for eachother.
*/
- else if (newparent != NULL && newparent != OB_TRAN_GROUP &&
- newparent != oldparent &&
+ else if (newparent && newparent != oldparent &&
/* don't make ourself its child if it is already our child */
- !client_is_direct_child(self, newparent))
+ !client_is_direct_child(self, newparent) &&
+ client_normal(newparent))
+ {
newparent->transients = g_slist_prepend(newparent->transients, self);
+ self->parents = g_slist_prepend(self->parents, newparent);
+ }
/* 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
C is transient for B
A can't be transient for C or we have a cycle
*/
- if (oldgroup != newgroup && newgroup != NULL &&
- newparent != OB_TRAN_GROUP)
+ if (oldgroup != newgroup && newgroup != NULL && !newgtran &&
+ client_normal(self))
{
for (it = newgroup->members; it; it = g_slist_next(it)) {
c = it->data;
- if (c != self && c->transient_for == OB_TRAN_GROUP &&
+ if (c != self && c->transient_for_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);
+ c->parents = g_slist_prepend(c->parents, self);
}
}
}
if (size.flags & PResizeInc && size.width_inc && size.height_inc)
SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
+
+ ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n "
+ "size inc (%d %d) base size (%d %d)\n",
+ self->min_size.width, self->min_size.height,
+ self->max_size.width, self->max_size.height,
+ self->size_inc.width, self->size_inc.height,
+ self->base_size.width, self->base_size.height);
}
+ else
+ ob_debug("Normal hints: not set\n");
}
void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
/* finally, the user can have requested no decorations, which overrides
everything (but doesnt give it a border if it doesnt have one) */
- if (self->undecorated) {
- if (config_theme_keepborder)
- self->decorations &= OB_FRAME_DECOR_BORDER;
- else
- self->decorations = 0;
- }
+ if (self->undecorated)
+ self->decorations = 0;
/* if we don't have a titlebar, then we cannot shade! */
if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
client_change_allowed_actions(self);
if (reconfig)
- client_reconfigure(self);
+ /* force reconfigure to make sure decorations are updated */
+ client_reconfigure(self, TRUE);
}
static void client_change_allowed_actions(ObClient *self)
}
}
-void client_reconfigure(ObClient *self)
-{
- client_configure(self, self->area.x, self->area.y,
- self->area.width, self->area.height,
- FALSE, TRUE);
-}
-
void client_update_wmhints(ObClient *self)
{
XWMHints *hints;
/* 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);
+ self->transient_for_group,
+ self->transient_for_group,
+ client_direct_parent(self),
+ client_direct_parent(self));
/* Lastly, being in a group, or not, can change if the window is
transient for anything.
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
+ If parents 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
+ If transient_for_group is TRUE, 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
updated.
*/
if (self->transient &&
- ((self->transient_for == NULL && oldgroup == NULL) ||
- (self->transient_for == OB_TRAN_GROUP && !self->group)))
+ ((self->parents == NULL && oldgroup == NULL) ||
+ (self->transient_for_group && !self->group)))
client_update_transient_for(self);
}
if (!got &&
PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
if (num == 4) {
- const Rect *a;
+ Rect *a;
got = TRUE;
/* use the screen's width/height */
- a = screen_physical_area();
+ a = screen_physical_area_all_monitors();
STRUT_PARTIAL_SET(strut,
data[0], data[2], data[1], data[3],
a->x, a->x + a->width - 1,
a->y, a->y + a->height - 1,
a->x, a->x + a->width - 1);
+ g_free(a);
}
g_free(data);
}
if ((hints = XGetWMHints(ob_display, self->window))) {
if (hints->flags & IconPixmapHint) {
- self->nicons++;
+ self->nicons = 1;
self->icons = g_new(ObClientIcon, self->nicons);
xerror_set_ignore(TRUE);
if (!RrPixmapToRGBA(ob_rr_inst,
hints->icon_pixmap,
(hints->flags & IconMaskHint ?
hints->icon_mask : None),
- &self->icons[self->nicons-1].width,
- &self->icons[self->nicons-1].height,
- &self->icons[self->nicons-1].data)){
- g_free(&self->icons[self->nicons-1]);
- self->nicons--;
+ &self->icons[0].width,
+ &self->icons[0].height,
+ &self->icons[0].data))
+ {
+ g_free(self->icons);
+ self->nicons = 0;
}
xerror_set_ignore(FALSE);
}
ObClient *client_search_focus_tree_full(ObClient *self)
{
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP) {
- return client_search_focus_tree_full(self->transient_for);
- } else {
- GSList *it;
-
- for (it = self->group->members; it; it = g_slist_next(it)) {
- if (it->data != self) {
- ObClient *c = it->data;
+ if (self->parents) {
+ GSList *it;
- if (client_focused(c)) return c;
- if ((c = client_search_focus_tree(it->data))) return c;
- }
- }
+ for (it = self->parents; it; it = g_slist_next(it)) {
+ ObClient *c = it->data;
+ if ((c = client_search_focus_tree_full(it->data))) return c;
}
- }
- /* this function checks the whole tree, the client_search_focus_tree
- does not, so we need to check this window */
- if (client_focused(self))
- return self;
- return client_search_focus_tree(self);
+ return NULL;
+ }
+ else {
+ /* this function checks the whole tree, the client_search_focus_tree
+ does not, so we need to check this window */
+ if (client_focused(self))
+ return self;
+ return client_search_focus_tree(self);
+ }
}
-gboolean client_has_parent(ObClient *self)
+ObClient *client_search_focus_group_full(ObClient *self)
{
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP) {
- if (client_normal(self->transient_for))
- return TRUE;
- }
- else if (self->group) {
- GSList *it;
+ GSList *it;
- for (it = self->group->members; it; it = g_slist_next(it)) {
- if (it->data != self && client_normal(it->data))
- return TRUE;
- }
+ if (self->group) {
+ for (it = self->group->members; it; it = g_slist_next(it)) {
+ ObClient *c = it->data;
+
+ if (client_focused(c)) return c;
+ if ((c = client_search_focus_tree(it->data))) return c;
}
- }
- return FALSE;
+ } else
+ if (client_focused(self)) return self;
+ return NULL;
+}
+
+gboolean client_has_parent(ObClient *self)
+{
+ return self->parents != NULL;
}
static ObStackingLayer calc_layer(ObClient *self)
{
ObStackingLayer l;
+ Rect *monitor;
+
+ monitor = screen_physical_area_monitor(client_monitor(self));
if (self->type == OB_CLIENT_TYPE_DESKTOP)
l = OB_STACKING_LAYER_DESKTOP;
*/
(self->decorations == 0 &&
!(self->max_horz && self->max_vert) &&
- RECT_EQUAL(self->area,
- *screen_physical_area_monitor
- (client_monitor(self))))) &&
+ RECT_EQUAL(self->area, *monitor))) &&
(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;
+ g_free(monitor);
+
return l;
}
event_cancel_all_key_grabs();
}
+ /* We don't need to ignore enter events here.
+ The window can hide/iconify in 3 different ways:
+ 1 - through an x message. in this case we ignore all enter events
+ caused by responding to the x message (unless underMouse)
+ 2 - by a keyboard action. in this case we ignore all enter events
+ caused by the action
+ 3 - by a mouse action. in this case they are doing stuff with the
+ mouse and focus _should_ move.
+
+ Also in action_end, we simulate an enter event that can't be ignored
+ so trying to ignore them is futile in case 3 anyways
+ */
+
frame_hide(self->frame);
hide = TRUE;
*/
client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
- self->window, self->area.x, self->area.y,
- self->area.width, self->area.height);
- oldarea = self->area; /* save the area */
- RECT_SET(self->area, x, y, w, h); /* put where it should be for the premax stuff */
+ self->window, x, y, w, h);
+ /* save the area, and make it where it should be for the premax stuff */
+ oldarea = self->area;
+ RECT_SET(self->area, x, y, w, h);
/* apply the states. these are in a carefully crafted order.. */
/* if the window hasn't been configured yet, then do so now */
if (!fullscreen && !max_vert && !max_horz) {
self->area = oldarea;
- client_configure(self, x, y, w, h, FALSE, TRUE);
+ client_configure(self, x, y, w, h, FALSE, TRUE, FALSE);
}
/* set the desktop hint, to make sure that it always exists */
gint *logicalw, gint *logicalh,
gboolean user)
{
- Rect desired_area = {*x, *y, *w, *h};
+ Rect desired = {*x, *y, *w, *h};
+ frame_rect_to_frame(self->frame, &desired);
/* make the frame recalculate its dimentions n shit without changing
anything visible for real, this way the constraints below can work with
the updated frame dimensions. */
frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
+ /* gets the frame's position */
+ frame_client_gravity(self->frame, x, y, *w, *h);
+
+ /* these positions are frame positions, not client positions */
+
+ /* set the size and position if fullscreen */
+ if (self->fullscreen) {
+ Rect *a;
+ guint i;
+
+ i = screen_find_monitor(&desired);
+ a = screen_physical_area_monitor(i);
+
+ *x = a->x;
+ *y = a->y;
+ *w = a->width;
+ *h = a->height;
+
+ user = FALSE; /* ignore if the client can't be moved/resized when it
+ is fullscreening */
+
+ g_free(a);
+ } else if (self->max_horz || self->max_vert) {
+ Rect *a;
+ guint i;
+
+ /* use all possible struts when maximizing to the full screen */
+ i = screen_find_monitor(&desired);
+ a = screen_area(self->desktop, i,
+ (self->max_horz && self->max_vert ? NULL : &desired));
+
+ /* set the size and position if maximized */
+ if (self->max_horz) {
+ *x = a->x;
+ *w = a->width - self->frame->size.left - self->frame->size.right;
+ }
+ if (self->max_vert) {
+ *y = a->y;
+ *h = a->height - self->frame->size.top - self->frame->size.bottom;
+ }
+
+ user = FALSE; /* ignore if the client can't be moved/resized when it
+ is maximizing */
+
+ g_free(a);
+ }
+
+ /* gets the client's position */
+ frame_frame_gravity(self->frame, x, y, *w, *h);
+
/* work within the prefered sizes given by the window */
if (!(*w == self->area.width && *h == self->area.height)) {
gint basew, baseh, minw, minh;
+ gint incw, inch;
+ gfloat minratio, maxratio;
+
+ incw = self->fullscreen || self->max_horz ? 1 : self->size_inc.width;
+ inch = self->fullscreen || self->max_vert ? 1 : self->size_inc.height;
+ minratio = self->fullscreen || (self->max_horz && self->max_vert) ?
+ 0 : self->min_ratio;
+ maxratio = self->fullscreen || (self->max_horz && self->max_vert) ?
+ 0 : self->max_ratio;
/* base size is substituted with min size if not specified */
if (self->base_size.width || self->base_size.height) {
*h -= baseh;
/* keep to the increments */
- *w /= self->size_inc.width;
- *h /= self->size_inc.height;
+ *w /= incw;
+ *h /= inch;
/* you cannot resize to nothing */
if (basew + *w < 1) *w = 1 - basew;
if (baseh + *h < 1) *h = 1 - baseh;
/* save the logical size */
- *logicalw = self->size_inc.width > 1 ? *w : *w + basew;
- *logicalh = self->size_inc.height > 1 ? *h : *h + baseh;
+ *logicalw = incw > 1 ? *w : *w + basew;
+ *logicalh = inch > 1 ? *h : *h + baseh;
- *w *= self->size_inc.width;
- *h *= self->size_inc.height;
+ *w *= incw;
+ *h *= inch;
*w += basew;
*h += baseh;
*w -= self->base_size.width;
*h -= self->base_size.height;
- if (!self->fullscreen) {
- if (self->min_ratio)
- if (*h * self->min_ratio > *w) {
- *h = (gint)(*w / self->min_ratio);
+ if (minratio)
+ if (*h * minratio > *w) {
+ *h = (gint)(*w / minratio);
- /* you cannot resize to nothing */
- if (*h < 1) {
- *h = 1;
- *w = (gint)(*h * self->min_ratio);
- }
+ /* you cannot resize to nothing */
+ if (*h < 1) {
+ *h = 1;
+ *w = (gint)(*h * minratio);
}
- if (self->max_ratio)
- if (*h * self->max_ratio < *w) {
- *h = (gint)(*w / self->max_ratio);
-
- /* you cannot resize to nothing */
- if (*h < 1) {
- *h = 1;
- *w = (gint)(*h * self->min_ratio);
- }
+ }
+ if (maxratio)
+ if (*h * maxratio < *w) {
+ *h = (gint)(*w / maxratio);
+
+ /* you cannot resize to nothing */
+ if (*h < 1) {
+ *h = 1;
+ *w = (gint)(*h * minratio);
}
- }
+ }
*w += self->base_size.width;
*h += self->base_size.height;
}
- /* gets the frame's position */
- frame_client_gravity(self->frame, x, y, *w, *h);
-
- /* these positions are frame positions, not client positions */
-
- /* set the size and position if fullscreen */
- if (self->fullscreen) {
- Rect *a;
- guint i;
-
- i = screen_find_monitor(&desired_area);
- a = screen_physical_area_monitor(i);
-
- *x = a->x;
- *y = a->y;
- *w = a->width;
- *h = a->height;
-
- user = FALSE; /* ignore if the client can't be moved/resized when it
- is fullscreening */
- } else if (self->max_horz || self->max_vert) {
- Rect *a;
- guint i;
-
- i = screen_find_monitor(&desired_area);
- a = screen_area_monitor(self->desktop, i);
-
- /* set the size and position if maximized */
- if (self->max_horz) {
- *x = a->x;
- *w = a->width - self->frame->size.left - self->frame->size.right;
- }
- if (self->max_vert) {
- *y = a->y;
- *h = a->height - self->frame->size.top - self->frame->size.bottom;
- }
-
- user = FALSE; /* ignore if the client can't be moved/resized when it
- is maximizing */
- }
-
- /* gets the client's position */
- frame_frame_gravity(self->frame, x, y, *w, *h);
-
/* these override the above states! if you cant move you can't move! */
if (user) {
if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
- gboolean user, gboolean final)
+ gboolean user, gboolean final, gboolean force_reply)
{
gint oldw, oldh;
gboolean send_resize_client;
- gboolean moved = FALSE, resized = FALSE;
+ gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE;
gboolean fmoved, fresized;
guint fdecor = self->frame->decorations;
gboolean fhorz = self->frame->max_horz;
}
/* adjust the frame */
- if (fmoved || fresized)
+ if (fmoved || fresized) {
+ gulong ignore_start;
+ if (!user)
+ ignore_start = event_start_ignore_all_enters();
+
frame_adjust_area(self->frame, fmoved, fresized, FALSE);
+ if (!user)
+ event_end_ignore_all_enters(ignore_start);
+ }
+
+ if (!user || final) {
+ gint oldrx = self->root_pos.x;
+ gint oldry = self->root_pos.y;
+ /* we have reset the client to 0 border width, so don't include
+ it in these coords */
+ POINT_SET(self->root_pos,
+ self->frame->area.x + self->frame->size.left -
+ self->border_width,
+ self->frame->area.y + self->frame->size.top -
+ self->border_width);
+ if (self->root_pos.x != oldrx || self->root_pos.y != oldry)
+ rootmoved = TRUE;
+ }
+
/* This is kinda tricky and should not be changed.. let me explain!
When user = FALSE, then the request is coming from the application
itself, and we are more strict about when to send a synthetic
ConfigureNotify. We strictly follow the rules of the ICCCM sec 4.1.5
- in this case.
+ in this case (if force_reply is true)
When user = TRUE, then the request is coming from "us", like when we
- maximize a window or sometihng. In this case we are more lenient. We
+ maximize a window or something. In this case we are more lenient. We
used to follow the same rules as above, but _Java_ Swing can't handle
this. So just to appease Swing, when user = TRUE, we always send
a synthetic ConfigureNotify to give the window its root coordinates.
*/
- if ((!user && !resized) || (user && final))
+ if ((!user && !resized && (rootmoved || force_reply)) ||
+ (user && final && rootmoved))
{
XEvent event;
- /* we have reset the client to 0 border width, so don't include
- it in these coords */
- POINT_SET(self->root_pos,
- self->frame->area.x + self->frame->size.left -
- self->border_width,
- self->frame->area.y + self->frame->size.top -
- self->border_width);
-
event.type = ConfigureNotify;
event.xconfigure.display = ob_display;
event.xconfigure.event = self->window;
if (curdesk && self->desktop != screen_desktop &&
self->desktop != DESKTOP_ALL)
- client_set_desktop(self, screen_desktop, FALSE);
+ client_set_desktop(self, screen_desktop, FALSE, FALSE);
/* this puts it after the current focused window */
focus_order_remove(self);
{
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);
+ self = client_search_top_direct_parent(self);
client_iconify_recursive(self, iconic, curdesk, hide_animation);
}
}
client_change_state(self);
client_change_wm_state(self); /* the window is being hidden/shown */
/* resize the frame to just the titlebar */
- frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
+ frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
}
void client_close(ObClient *self)
void client_set_desktop_recursive(ObClient *self,
guint target,
- gboolean donthide)
+ gboolean donthide,
+ gboolean dontraise)
{
guint old;
GSList *it;
frame_adjust_state(self->frame);
/* 'move' the window to the new desktop */
if (!donthide)
- client_showhide(self);
+ client_hide(self);
+ client_show(self);
/* raise if it was not already on the desktop */
- if (old != DESKTOP_ALL)
+ if (old != DESKTOP_ALL && !dontraise)
stacking_raise(CLIENT_AS_WINDOW(self));
if (STRUT_EXISTS(self->strut))
screen_update_areas();
+ else
+ /* the new desktop's geometry may be different, so we may need to
+ resize, for example if we are maximized */
+ client_reconfigure(self, FALSE);
}
/* 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);
+ client_set_desktop_recursive(it->data, target,
+ donthide, dontraise);
}
-void client_set_desktop(ObClient *self, guint target, gboolean donthide)
+void client_set_desktop(ObClient *self, guint target,
+ gboolean donthide, gboolean dontraise)
{
- self = client_search_top_normal_parent(self);
- client_set_desktop_recursive(self, target, donthide);
+ self = client_search_top_direct_parent(self);
+ client_set_desktop_recursive(self, target, donthide, dontraise);
}
gboolean client_is_direct_child(ObClient *parent, ObClient *child)
{
- while (child != parent &&
- child->transient_for && child->transient_for != OB_TRAN_GROUP)
- child = child->transient_for;
+ while (child != parent && (child = client_direct_parent(child)));
return child == parent;
}
self->desktop != screen_desktop)
{
if (here)
- client_set_desktop(self, screen_desktop, FALSE);
+ client_set_desktop(self, screen_desktop, FALSE, TRUE);
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;
- /* 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
+ /* if the currently focused app doesn't set a user_time, then it can't
benefit from any focus stealing prevention.
+
+ if the timestamp is missing in the request then let it go through
+ even if it is source=app, because EVERY APPLICATION DOES THIS because
+ GTK IS VERY BUGGY AND HARDCODES source=application... WHY!?
*/
- if (user || !focus_client || !last_time)
+ if (!last_time || !event_curtime)
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);
+ allow = 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 (iconic && self->iconic)
client_iconify(self, FALSE, TRUE, FALSE);
else
- client_set_desktop(self, desktop, FALSE);
+ client_set_desktop(self, desktop, FALSE, FALSE);
}
}
if (!self->nicons) {
ObClientIcon *parent = NULL;
+ GSList *it;
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP)
- parent = client_icon_recursive(self->transient_for, w, h);
- 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 ((parent = client_icon_recursive(c, w, h)))
- break;
- }
- }
- }
+ for (it = self->parents; it; it = g_slist_next(it)) {
+ ObClient *c = it->data;
+ if ((parent = client_icon_recursive(c, w, h)))
+ break;
}
return parent;
return screen_find_monitor(&self->frame->area);
}
-ObClient *client_search_top_normal_parent(ObClient *self)
+ObClient *client_direct_parent(ObClient *self)
+{
+ if (!self->parents) return NULL;
+ if (self->transient_for_group) return NULL;
+ return self->parents->data;
+}
+
+ObClient *client_search_top_direct_parent(ObClient *self)
{
- while (self->transient_for && self->transient_for != OB_TRAN_GROUP &&
- client_normal(self->transient_for))
- self = self->transient_for;
+ ObClient *p;
+ while ((p = client_direct_parent(self))) self = p;
return self;
}
gboolean bylayer,
ObStackingLayer layer)
{
- GSList *ret = NULL;
+ GSList *ret;
+ ObClient *p;
/* move up the direct transient chain as far as possible */
- 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)
- ret = g_slist_prepend(ret, self);
- else {
- GSList *it;
-
- g_assert(self->group);
+ while ((p = client_direct_parent(self)) &&
+ (!bylayer || p->layer == layer))
+ self = p;
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
-
- if (!c->transient_for && client_normal(c) &&
- (!bylayer || c->layer == layer))
- {
- ret = g_slist_prepend(ret, c);
- }
- }
-
- if (ret == NULL) /* no group parents */
- ret = g_slist_prepend(ret, self);
- }
+ if (!self->parents)
+ ret = g_slist_prepend(NULL, self);
+ else
+ ret = g_slist_copy(self->parents);
return ret;
}
ObClient *client_search_focus_parent(ObClient *self)
{
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP) {
- if (client_focused(self->transient_for))
- return self->transient_for;
- } else {
- GSList *it;
-
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
+ GSList *it;
- /* checking transient_for prevents infinate loops! */
- if (c != self && !c->transient_for)
- if (client_focused(c))
- return c;
- }
- }
- }
+ for (it = self->parents; it; it = g_slist_next(it))
+ if (client_focused(it->data)) return it->data;
return NULL;
}
ObClient *client_search_parent(ObClient *self, ObClient *search)
{
- if (self->transient_for) {
- if (self->transient_for != OB_TRAN_GROUP) {
- if (self->transient_for == search)
- return search;
- } else {
- GSList *it;
+ GSList *it;
- for (it = self->group->members; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
-
- /* checking transient_for prevents infinate loops! */
- if (c != self && !c->transient_for)
- if (c == search)
- return search;
- }
- }
- }
+ for (it = self->parents; it; it = g_slist_next(it))
+ if (it->data == search) return search;
return NULL;
}
gint dest, monitor_dest;
gint my_edge_start, my_edge_end, my_offset;
GList *it;
- Rect *a, *monitor;
+ Rect *a, *mon;
if(!client_list)
return -1;
- a = screen_area(c->desktop);
- monitor = screen_area_monitor(c->desktop, client_monitor(c));
+ a = screen_area(c->desktop, SCREEN_AREA_ALL_MONITORS, &c->frame->area);
+ mon = screen_area(c->desktop, SCREEN_AREA_ONE_MONITOR, &c->frame->area);
switch(dir) {
case OB_DIRECTION_NORTH:
/* default: top of screen */
dest = a->y + (hang ? c->frame->area.height : 0);
- monitor_dest = monitor->y + (hang ? c->frame->area.height : 0);
+ monitor_dest = mon->y + (hang ? c->frame->area.height : 0);
/* if the monitor edge comes before the screen edge, */
/* use that as the destination instead. (For xinerama) */
if (monitor_dest != dest && my_offset > monitor_dest)
/* default: bottom of screen */
dest = a->y + a->height - (hang ? c->frame->area.height : 0);
- monitor_dest = monitor->y + monitor->height -
+ monitor_dest = mon->y + mon->height -
(hang ? c->frame->area.height : 0);
/* if the monitor edge comes before the screen edge, */
/* use that as the destination instead. (For xinerama) */
/* default: leftmost egde of screen */
dest = a->x + (hang ? c->frame->area.width : 0);
- monitor_dest = monitor->x + (hang ? c->frame->area.width : 0);
+ monitor_dest = mon->x + (hang ? c->frame->area.width : 0);
/* if the monitor edge comes before the screen edge, */
/* use that as the destination instead. (For xinerama) */
if (monitor_dest != dest && my_offset > monitor_dest)
/* default: rightmost edge of screen */
dest = a->x + a->width - (hang ? c->frame->area.width : 0);
- monitor_dest = monitor->x + monitor->width -
+ monitor_dest = mon->x + mon->width -
(hang ? c->frame->area.width : 0);
/* if the monitor edge comes before the screen edge, */
/* use that as the destination instead. (For xinerama) */
g_assert_not_reached();
dest = 0; /* suppress warning */
}
+
+ g_free(a);
+ g_free(mon);
return dest;
}
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = WINDOW_AS_CLIENT(it->data);
if (c->frame->visible &&
+ /* check the desktop, this is done during desktop
+ switching and windows are shown/hidden status is not
+ reliable */
+ (c->desktop == screen_desktop ||
+ c->desktop == DESKTOP_ALL) &&
/* ignore all animating windows */
!frame_iconify_animating(c->frame) &&
RECT_CONTAINS(c->frame->area, x, y))