+void client_unfocus(ObClient *self)
+{
+ if (focus_client == self) {
+#ifdef DEBUG_FOCUS
+ ob_debug("client_unfocus for %lx\n", self->window);
+#endif
+ focus_fallback(OB_FOCUS_FALLBACK_UNFOCUSING);
+ }
+}
+
+void client_activate(ObClient *self, gboolean here)
+{
+ /* This check is for the client_list_menu trying to activate
+ * a closed client. */
+ if (!g_list_find(client_list, self)) return;
+ 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);
+
+ client_focus(self);
+
+ /* we do this an action here. this is rather important. this is because
+ we want the results from the focus change to take place BEFORE we go
+ about raising the window. when a fullscreen window loses focus, we need
+ this or else the raise wont be able to raise above the to-lose-focus
+ fullscreen window. */
+ client_raise(self);
+}
+
+void client_raise(ObClient *self)
+{
+ action_run_string("Raise", self);
+}
+
+void client_lower(ObClient *self)
+{
+ action_run_string("Lower", self);
+}
+
+gboolean client_focused(ObClient *self)
+{
+ return self == focus_client;
+}
+
+static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
+{
+ guint i;
+ /* si is the smallest image >= req */
+ /* li is the largest image < req */
+ gulong size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;
+
+ if (!self->nicons) {
+ ObClientIcon *parent = NULL;
+
+ 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;
+ }
+ }
+ }
+ }
+
+ return parent;
+ }
+
+ for (i = 0; i < self->nicons; ++i) {
+ size = self->icons[i].width * self->icons[i].height;
+ if (size < smallest && size >= (unsigned)(w * h)) {
+ smallest = size;
+ si = i;
+ }
+ if (size > largest && size <= (unsigned)(w * h)) {
+ largest = size;
+ li = i;
+ }
+ }
+ if (largest == 0) /* didnt find one smaller than the requested size */
+ return &self->icons[si];
+ return &self->icons[li];
+}
+
+const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
+{
+ ObClientIcon *ret;
+ static ObClientIcon deficon;
+
+ if (!(ret = client_icon_recursive(self, w, h))) {
+ deficon.width = deficon.height = 48;
+ deficon.data = ob_rr_theme->def_win_icon;
+ ret = &deficon;
+ }
+ return ret;
+}
+
+/* this be mostly ripped from fvwm */
+ObClient *client_find_directional(ObClient *c, ObDirection dir)
+{
+ gint my_cx, my_cy, his_cx, his_cy;
+ gint offset = 0;
+ gint distance = 0;
+ gint score, best_score;
+ ObClient *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 = g_list_next(it)) {
+ cur = it->data;
+
+ /* the currently selected window isn't interesting */
+ if(cur == c)
+ continue;
+ if (!client_normal(cur))
+ continue;
+ /* using c->desktop instead of screen_desktop doesn't work if the
+ * current window was omnipresent, hope this doesn't have any other
+ * side effects */
+ if(screen_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 == OB_DIRECTION_NORTHEAST || dir == OB_DIRECTION_SOUTHEAST ||
+ dir == OB_DIRECTION_SOUTHWEST || dir == OB_DIRECTION_NORTHWEST) {
+ gint 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 OB_DIRECTION_NORTH:
+ case OB_DIRECTION_SOUTH:
+ case OB_DIRECTION_NORTHEAST:
+ case OB_DIRECTION_SOUTHWEST:
+ offset = (his_cx < 0) ? -his_cx : his_cx;
+ distance = ((dir == OB_DIRECTION_NORTH ||
+ dir == OB_DIRECTION_NORTHEAST) ?
+ -his_cy : his_cy);
+ break;
+ case OB_DIRECTION_EAST:
+ case OB_DIRECTION_WEST:
+ case OB_DIRECTION_SOUTHEAST:
+ case OB_DIRECTION_NORTHWEST:
+ offset = (his_cy < 0) ? -his_cy : his_cy;
+ distance = ((dir == OB_DIRECTION_WEST ||
+ dir == OB_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(ObClient *self, gint 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 */
+}
+
+void client_set_undecorated(ObClient *self, gboolean undecorated)
+{
+ if (self->undecorated != undecorated) {
+ self->undecorated = undecorated;
+ client_setup_decor_and_functions(self);
+ /* Make sure the client knows it might have moved. Maybe there is a
+ * better way of doing this so only one client_configure is sent, but
+ * since 125 of these are sent per second when moving the window (with
+ * user = FALSE) i doubt it matters much.
+ */
+ client_configure(self, OB_CORNER_TOPLEFT, self->area.x, self->area.y,
+ self->area.width, self->area.height, TRUE, TRUE);
+ client_change_state(self); /* reflect this in the state hints */
+ }
+}
+
+/* Determines which physical monitor a client is on by calculating the
+ area of the part of the client on each monitor. The number of the
+ monitor containing the greatest area of the client is returned.*/
+guint client_monitor(ObClient *self)
+{
+ guint i;
+ guint most = 0;
+ guint mostv = 0;
+
+ for (i = 0; i < screen_num_monitors; ++i) {
+ Rect *area = screen_physical_area_monitor(i);
+ if (RECT_INTERSECTS_RECT(*area, self->frame->area)) {
+ Rect r;
+ guint v;
+
+ RECT_SET_INTERSECTION(r, *area, self->frame->area);
+ v = r.width * r.height;
+
+ if (v > mostv) {
+ mostv = v;
+ most = i;
+ }
+ }
+ }
+ return most;
+}
+
+ObClient *client_search_top_transient(ObClient *self)
+{
+ /* move up the transient chain as far as possible */
+ if (self->transient_for) {
+ if (self->transient_for != OB_TRAN_GROUP) {
+ return client_search_top_transient(self->transient_for);
+ } else {
+ GSList *it;
+
+ g_assert(self->group);
+
+ 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)
+ break;
+ }
+ if (it)
+ return it->data;
+ }
+ }
+
+ return self;
+}
+
+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;
+
+ /* checking transient_for prevents infinate loops! */
+ if (c != self && !c->transient_for)
+ if (client_focused(c))
+ return c;
+ }
+ }
+ }
+
+ 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;
+
+ 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;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+ObClient *client_search_transient(ObClient *self, ObClient *search)
+{
+ GSList *sit;
+
+ for (sit = self->transients; sit; sit = g_slist_next(sit)) {
+ if (sit->data == search)
+ return search;
+ if (client_search_transient(sit->data, search))
+ return search;
+ }
+ 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);
+}
+
+/* finds the nearest edge in the given direction from the current client
+ * note to self: the edge is the -frame- edge (the actual one), not the
+ * client edge.
+ */
+gint client_directional_edge_search(ObClient *c, ObDirection dir)
+{
+ gint dest, monitor_dest;
+ gint my_edge_start, my_edge_end, my_offset;
+ GList *it;
+ Rect *a, *monitor;
+
+ if(!client_list)
+ return -1;
+
+ a = screen_area(c->desktop);
+ monitor = screen_area_monitor(c->desktop, client_monitor(c));
+
+ switch(dir) {
+ case OB_DIRECTION_NORTH:
+ my_edge_start = c->frame->area.x;
+ my_edge_end = c->frame->area.x + c->frame->area.width;
+ my_offset = c->frame->area.y;
+
+ /* default: top of screen */
+ dest = a->y;
+ monitor_dest = monitor->y;
+ /* 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)
+ dest = monitor_dest;
+
+ for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
+ gint his_edge_start, his_edge_end, his_offset;
+ ObClient *cur = it->data;
+
+ if(cur == c)
+ continue;
+ if(!client_normal(cur))
+ continue;
+ if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+ continue;
+ if(cur->iconic)
+ continue;
+ if(cur->layer < c->layer && !config_resist_layers_below)
+ continue;
+
+ his_edge_start = cur->frame->area.x;
+ his_edge_end = cur->frame->area.x + cur->frame->area.width;
+ his_offset = cur->frame->area.y + cur->frame->area.height;
+
+ if(his_offset + 1 > my_offset)
+ continue;
+
+ if(his_offset < dest)
+ continue;
+
+ if(his_edge_start >= my_edge_start &&
+ his_edge_start <= my_edge_end)
+ dest = his_offset;
+
+ if(my_edge_start >= his_edge_start &&
+ my_edge_start <= his_edge_end)
+ dest = his_offset;
+
+ }
+ break;
+ case OB_DIRECTION_SOUTH:
+ my_edge_start = c->frame->area.x;
+ my_edge_end = c->frame->area.x + c->frame->area.width;
+ my_offset = c->frame->area.y + c->frame->area.height;
+
+ /* default: bottom of screen */
+ dest = a->y + a->height;
+ monitor_dest = monitor->y + monitor->height;
+ /* 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)
+ dest = monitor_dest;
+
+ for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
+ gint his_edge_start, his_edge_end, his_offset;
+ ObClient *cur = it->data;
+
+ if(cur == c)
+ continue;
+ if(!client_normal(cur))
+ continue;
+ if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+ continue;
+ if(cur->iconic)
+ continue;
+ if(cur->layer < c->layer && !config_resist_layers_below)
+ continue;
+
+ his_edge_start = cur->frame->area.x;
+ his_edge_end = cur->frame->area.x + cur->frame->area.width;
+ his_offset = cur->frame->area.y;
+
+
+ if(his_offset - 1 < my_offset)
+ continue;
+
+ if(his_offset > dest)
+ continue;
+
+ if(his_edge_start >= my_edge_start &&
+ his_edge_start <= my_edge_end)
+ dest = his_offset;
+
+ if(my_edge_start >= his_edge_start &&
+ my_edge_start <= his_edge_end)
+ dest = his_offset;
+
+ }
+ break;
+ case OB_DIRECTION_WEST:
+ my_edge_start = c->frame->area.y;
+ my_edge_end = c->frame->area.y + c->frame->area.height;
+ my_offset = c->frame->area.x;
+
+ /* default: leftmost egde of screen */
+ dest = a->x;
+ monitor_dest = monitor->x;
+ /* 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)
+ dest = monitor_dest;
+
+ for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
+ gint his_edge_start, his_edge_end, his_offset;
+ ObClient *cur = it->data;
+
+ if(cur == c)
+ continue;
+ if(!client_normal(cur))
+ continue;
+ if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+ continue;
+ if(cur->iconic)
+ continue;
+ if(cur->layer < c->layer && !config_resist_layers_below)
+ continue;
+
+ his_edge_start = cur->frame->area.y;
+ his_edge_end = cur->frame->area.y + cur->frame->area.height;
+ his_offset = cur->frame->area.x + cur->frame->area.width;
+
+ if(his_offset + 1 > my_offset)
+ continue;
+
+ if(his_offset < dest)
+ continue;
+
+ if(his_edge_start >= my_edge_start &&
+ his_edge_start <= my_edge_end)
+ dest = his_offset;
+
+ if(my_edge_start >= his_edge_start &&
+ my_edge_start <= his_edge_end)
+ dest = his_offset;
+
+
+ }
+ break;
+ case OB_DIRECTION_EAST:
+ my_edge_start = c->frame->area.y;
+ my_edge_end = c->frame->area.y + c->frame->area.height;
+ my_offset = c->frame->area.x + c->frame->area.width;
+
+ /* default: rightmost edge of screen */
+ dest = a->x + a->width;
+ monitor_dest = monitor->x + monitor->width;
+ /* 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)
+ dest = monitor_dest;
+
+ for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
+ gint his_edge_start, his_edge_end, his_offset;
+ ObClient *cur = it->data;
+
+ if(cur == c)
+ continue;
+ if(!client_normal(cur))
+ continue;
+ if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+ continue;
+ if(cur->iconic)
+ continue;
+ if(cur->layer < c->layer && !config_resist_layers_below)
+ continue;
+
+ his_edge_start = cur->frame->area.y;
+ his_edge_end = cur->frame->area.y + cur->frame->area.height;
+ his_offset = cur->frame->area.x;
+
+ if(his_offset - 1 < my_offset)
+ continue;
+
+ if(his_offset > dest)
+ continue;
+
+ if(his_edge_start >= my_edge_start &&
+ his_edge_start <= my_edge_end)
+ dest = his_offset;
+
+ if(my_edge_start >= his_edge_start &&
+ my_edge_start <= his_edge_end)
+ dest = his_offset;
+
+ }
+ break;
+ case OB_DIRECTION_NORTHEAST:
+ case OB_DIRECTION_SOUTHEAST:
+ case OB_DIRECTION_NORTHWEST:
+ case OB_DIRECTION_SOUTHWEST:
+ /* not implemented */
+ default:
+ g_assert_not_reached();
+ dest = 0; /* suppress warning */
+ }
+ return dest;
+}
+
+ObClient* client_under_pointer()
+{
+ gint x, y;
+ GList *it;
+ ObClient *ret = NULL;
+
+ if (screen_pointer_pos(&x, &y)) {
+ for (it = stacking_list; it; it = g_list_next(it)) {
+ if (WINDOW_IS_CLIENT(it->data)) {
+ ObClient *c = WINDOW_AS_CLIENT(it->data);
+ if (c->frame->visible &&
+ RECT_CONTAINS(c->frame->area, x, y)) {
+ ret = c;
+ break;
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+gboolean client_has_group_siblings(ObClient *self)