#include "client.h"
#include "dock.h"
+#include "xerror.h"
#include "startup.h"
#include "screen.h"
#include "moveresize.h"
#include "openbox.h"
#include "group.h"
#include "config.h"
+#include "menu.h"
#include "render/render.h"
#include <glib.h>
focus_order_add_new(self);
/* focus the new window? */
- if (ob_state != State_Starting && config_focus_new) {
+ if (ob_state != State_Starting && config_focus_new &&
+ (self->type == Type_Normal || self->type == Type_Dialog)) {
gboolean group_foc = FALSE;
if (self->group) {
GSList *it;
- for (it = self->group->members; it; it = it->next)
+ for (it = self->group->members; it; it = it->next) {
if (client_focused(it->data)) {
group_foc = TRUE;
break;
}
+ }
}
/* note the check against Type_Normal/Dialog, not client_normal(self),
which would also include other types. in this case we want more
strict rules for focus */
- if (((self->type == Type_Normal ||
- (self->type == Type_Dialog &&
- (group_foc ||
- (!self->transient_for && (!self->group ||
- !self->group->members->next)))))) ||
+ if ((group_foc ||
+ (!self->transient_for && (!self->group ||
+ !self->group->members->next))) ||
client_search_focus_tree_full(self) ||
!focus_client ||
!client_normal(focus_client)) {
client_unmanage(client_list->data);
}
+/* called by client_unmanage() to close any menus referencing this client */
+void client_close_menus(gpointer key, gpointer value, gpointer self)
+{
+ if (((Menu *)value)->client == (Client *)self)
+ menu_hide((Menu *)value);
+}
+
void client_unmanage(Client *self)
{
int j;
if (moveresize_client == self)
moveresize_end(TRUE);
+ /* close any windows that are attached to this window */
+ g_hash_table_foreach(menu_hash, client_close_menus, self);
+
+
if (focus_client == self) {
XEvent e;
group_remove(self->group, self);
self->group = NULL;
}
- /* i can only have transients from the group if i am not transient
- myself */
- if (hints->window_group != None && !self->transient_for) {
+ if (hints->window_group != None) {
self->group = group_add(hints->window_group, self);
- /* add other transients of the group that are already
- set up */
- for (it = self->group->members; it; it = it->next)
- if (it->data != self &&
- ((Client*)it->data)->transient_for == TRAN_GROUP)
- self->transients = g_slist_append(self->transients,
- it->data);
+ /* i can only have transients from the group if i am not
+ transient myself */
+ if (!self->transient_for) {
+ /* add other transients of the group that are already
+ set up */
+ for (it = self->group->members; it; it = it->next)
+ if (it->data != self &&
+ ((Client*)it->data)->transient_for == TRAN_GROUP)
+ self->transients = g_slist_append(self->transients,
+ it->data);
+ }
}
/* the WM_HINTS can contain an icon */
w = data[i++];
h = data[i++];
i += w * h;
- if (i > num) break;
+ if (i > num || w*h == 0) break;
++self->nicons;
}
w = self->icons[j].width = data[i++];
h = self->icons[j].height = data[i++];
+ if (w*h == 0) continue;
+
self->icons[j].data = g_new(pixel32, w * h);
for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
if (x >= w) {
if (num == 2) {
self->nicons++;
self->icons = g_new(Icon, self->nicons);
+ xerror_set_ignore(TRUE);
if (!render_pixmap_to_rgba(data[0], data[1],
&self->icons[self->nicons-1].width,
&self->icons[self->nicons-1].height,
g_free(&self->icons[self->nicons-1]);
self->nicons--;
}
+ xerror_set_ignore(FALSE);
}
g_free(data);
} else {
if (hints->flags & IconPixmapHint) {
self->nicons++;
self->icons = g_new(Icon, self->nicons);
+ xerror_set_ignore(TRUE);
if (!render_pixmap_to_rgba(hints->icon_pixmap,
(hints->flags & IconMaskHint ?
hints->icon_mask : None),
g_free(&self->icons[self->nicons-1]);
self->nicons--;
}
+ xerror_set_ignore(FALSE);
}
XFree(hints);
}
if (target == self->desktop) return;
- g_message("Setting desktop %u", target);
+ g_message("Setting desktop %u", target+1);
g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
if (shaded != self->shaded)
client_shade(self, shaded);
client_calc_layer(self);
- client_change_state(self); /* change the hint to relect these changes */
+ client_change_state(self); /* change the hint to reflect these changes */
}
Client *client_focus_target(Client *self)
return self;
}
-gboolean client_focus(Client *self)
+gboolean client_can_focus(Client *self)
{
XEvent ev;
/* choose the correct target */
self = client_focus_target(self);
- if (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop) {
- /* update the focus lists */
- focus_order_to_top(self);
+ if (!self->frame->visible)
return FALSE;
- }
if (!((self->can_focus || self->focus_notify) &&
(self->desktop == screen_desktop ||
}
}
+ return TRUE;
+}
+
+gboolean client_focus(Client *self)
+{
+ /* choose the correct target */
+ self = client_focus_target(self);
+
+ if (!client_can_focus(self)) {
+ if (!self->frame->visible) {
+ /* update the focus lists */
+ focus_order_to_top(self);
+ }
+ return FALSE;
+ }
+
if (self->can_focus)
/* RevertToPointerRoot causes much more headache than RevertToNone, so
I choose to use it always, hopefully to find errors quicker, if any
return &self->icons[si];
return &self->icons[li];
}
+
+/* this be mostly ripped from fvwm */
+Client *client_find_directional(Client *c, Direction dir)
+{
+ int my_cx, my_cy, his_cx, his_cy;
+ int offset = 0;
+ int distance = 0;
+ int score, best_score;
+ Client *best_client, *cur;
+ GList *it;
+
+ if(!client_list)
+ return NULL;
+
+ /* first, find the centre coords of the currently focused window */
+ my_cx = c->frame->area.x + c->frame->area.width / 2;
+ my_cy = c->frame->area.y + c->frame->area.height / 2;
+
+ best_score = -1;
+ best_client = NULL;
+
+ for(it = g_list_first(client_list); it; it = it->next) {
+ cur = it->data;
+
+ /* the currently selected window isn't interesting */
+ if(cur == c)
+ continue;
+ if (!client_normal(cur))
+ continue;
+ if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+ continue;
+ if(cur->iconic)
+ continue;
+ if(client_focus_target(cur) == cur &&
+ !(cur->can_focus || cur->focus_notify))
+ continue;
+
+ /* find the centre coords of this window, from the
+ * currently focused window's point of view */
+ his_cx = (cur->frame->area.x - my_cx)
+ + cur->frame->area.width / 2;
+ his_cy = (cur->frame->area.y - my_cy)
+ + cur->frame->area.height / 2;
+
+ if(dir > 3) {
+ int tx;
+ /* Rotate the diagonals 45 degrees counterclockwise.
+ * To do this, multiply the matrix /+h +h\ with the
+ * vector (x y). \-h +h/
+ * h = sqrt(0.5). We can set h := 1 since absolute
+ * distance doesn't matter here. */
+ tx = his_cx + his_cy;
+ his_cy = -his_cx + his_cy;
+ his_cx = tx;
+ }
+
+ switch(dir) {
+ case Direction_North :
+ case Direction_South :
+ case Direction_NorthEast :
+ case Direction_SouthWest :
+ offset = (his_cx < 0) ? -his_cx : his_cx;
+ distance = (dir == Direction_North || dir == Direction_NorthEast) ?
+ -his_cy : his_cy;
+ break;
+ case Direction_East :
+ case Direction_West :
+ case Direction_SouthEast :
+ case Direction_NorthWest :
+ offset = (his_cy < 0) ? -his_cy : his_cy;
+ distance = (dir == Direction_West || dir == Direction_NorthWest) ?
+ -his_cx : his_cx;
+ break;
+ }
+
+ /* the target must be in the requested direction */
+ if(distance <= 0)
+ continue;
+
+ /* Calculate score for this window. The smaller the better. */
+ score = distance + offset;
+
+ /* windows more than 45 degrees off the direction are
+ * heavily penalized and will only be chosen if nothing
+ * else within a million pixels */
+ if(offset > distance)
+ score += 1000000;
+
+ if(best_score == -1 || score < best_score)
+ best_client = cur,
+ best_score = score;
+ }
+
+ return best_client;
+}
+
+void client_set_layer(Client *self, int layer)
+{
+ if (layer < 0) {
+ self->below = TRUE;
+ self->above = FALSE;
+ } else if (layer == 0) {
+ self->below = self->above = FALSE;
+ } else {
+ self->below = FALSE;
+ self->above = TRUE;
+ }
+ client_calc_layer(self);
+ client_change_state(self); /* reflect this in the state hints */
+}
projects / chaz / openbox / blobdiff