#include "mouse.h"
#include "render/render.h"
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
#include <glib.h>
#include <X11/Xutil.h>
/*! The event mask to grab on client windows */
-#define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask)
+#define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
+ ColormapChangeMask)
#define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
ButtonMotionMask)
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);
/* focus the new window? */
if (ob_state() != OB_STATE_STARTING &&
+ !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_parent(self)) &&
self->type == OB_CLIENT_TYPE_DIALOG))
{
activate = TRUE;
-#if 0
- if (self->desktop != screen_desktop) {
- /* activate the window */
- activate = TRUE;
- } else {
- gboolean group_foc = FALSE;
-
- if (self->group) {
- GSList *it;
-
- for (it = self->group->members; it; it = g_slist_next(it))
- {
- if (client_focused(it->data))
- {
- group_foc = TRUE;
- break;
- }
- }
- }
- if ((group_foc ||
- (!self->transient_for && (!self->group ||
- !self->group->members->next))) ||
- client_search_focus_tree_full(self) ||
- !focus_client ||
- !client_normal(focus_client))
- {
- /* activate the window */
- activate = TRUE;
- }
- }
-#endif
}
/* get the current position */
self->window, newx, newy, self->area.width, self->area.height);
client_apply_startup_state(self, newx, newy);
- keyboard_grab_for_client(self, TRUE);
mouse_grab_for_client(self, TRUE);
if (activate) {
ob_debug("Want to focus new window 0x%x with time %u (last time %u)\n",
self->window, self->user_time, last_time);
- /* If a nothing at all, or a parent was focused, then focus this
+ /* if it's on another desktop */
+ if (!(self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
+ && /* the timestamp is from before you changed desktops */
+ self->user_time && screen_desktop_user_time &&
+ !event_time_after(self->user_time, screen_desktop_user_time))
+ {
+ activate = FALSE;
+ }
+ /* If nothing is focused, or a parent was focused, then focus this
always
*/
- if (!focus_client || client_search_focus_parent(self) != NULL)
+ else if (!focus_client || client_search_focus_parent(self) != NULL)
activate = TRUE;
else
{
activate = FALSE;
}
- if (activate)
- {
- /* since focus can change the stacking orders, if we focus the
- window then the standard raise it gets is not enough, we need
- to queue one for after the focus change takes place */
- client_raise(self);
- } else {
+ if (!activate) {
ob_debug("Focus stealing prevention activated for %s with time %u "
"(last time %u)\n",
self->title, self->user_time, last_time);
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) {
- /* if using focus_delay, stop the timer now so that focus doesn't
- go moving on us */
- event_halt_focus_delay();
- client_focus(self);
- }
-
- /* client_activate does this but we aren't using it so we have to do it
- here as well */
- if (screen_showing_desktop)
- screen_show_desktop(FALSE);
+ if (activate)
+ client_activate(self, FALSE, TRUE);
/* add to client list/map */
client_list = g_list_append(client_list, self);
g_assert(self != NULL);
+ /* we dont want events no more. do this before hiding the frame so we
+ don't generate more events */
+ XSelectInput(ob_display, self->window, NoEventMask);
+
frame_hide(self->frame);
- /* sync to send the hide to the server quickly, and to get back the enter
- events */
- XSync(ob_display, FALSE);
+ /* flush to send the hide to the server quickly */
+ XFlush(ob_display);
if (focus_client == self) {
/* ignore enter events from the unmap so it doesnt mess with the focus
event_ignore_queued_enters();
}
-
- keyboard_grab_for_client(self, FALSE);
mouse_grab_for_client(self, FALSE);
/* remove the window from our save set */
XChangeSaveSet(ob_display, self->window, SetModeDelete);
- /* we dont want events no more */
- XSelectInput(ob_display, self->window, NoEventMask);
-
/* update the focus lists */
focus_order_remove(self);
+ /* don't leave an invalid focus_client */
+ if (self == focus_client)
+ focus_client = NULL;
client_list = g_list_remove(client_list, self);
stacking_remove(self);
g_free(self->name);
g_free(self->class);
g_free(self->role);
+ g_free(self->client_machine);
g_free(self->sm_client_id);
g_free(self);
if (settings->max_vert != -1)
self->max_vert = !!settings->max_vert;
if (settings->max_horz != -1)
- self->max_vert = !!settings->max_horz;
+ self->max_horz = !!settings->max_horz;
if (settings->fullscreen != -1)
self->fullscreen = !!settings->fullscreen;
(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);
self->desktop = screen_desktop;
}
}
- if (self->desktop != d) {
- /* set the desktop hint, to make sure that it always exists */
- PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
- }
}
static void client_get_layer(ObClient *self)
if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
for (i = 0; i < num_return; ++i) {
- if (proto[i] == prop_atoms.wm_delete_window) {
+ if (proto[i] == prop_atoms.wm_delete_window)
/* this means we can request the window to close */
self->delete_window = TRUE;
- } else if (proto[i] == prop_atoms.wm_take_focus)
+ else if (proto[i] == prop_atoms.wm_take_focus)
/* if this protocol is requested, then the window will be
notified whenever we want it to receive focus */
self->focus_notify = TRUE;
+#ifdef SYNC
+ else if (proto[i] == prop_atoms.net_wm_sync_request)
+ /* if this protocol is requested, then resizing the
+ window will be synchronized between the frame and the
+ client */
+ self->sync_request = TRUE;
+#endif
}
g_free(proto);
}
}
+#ifdef SYNC
+void client_update_sync_request_counter(ObClient *self)
+{
+ guint32 i;
+
+ if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
+ self->sync_counter = i;
+ } else
+ self->sync_counter = None;
+}
+#endif
+
static void client_get_gravity(ObClient *self)
{
XWindowAttributes wattrib;
self->gravity = wattrib.win_gravity;
}
+void client_get_colormap(ObClient *self)
+{
+ XWindowAttributes wa;
+
+ if (XGetWindowAttributes(ob_display, self->window, &wa))
+ client_update_colormap(self, wa.colormap);
+}
+
+void client_update_colormap(ObClient *self, Colormap colormap)
+{
+ self->colormap = colormap;
+}
+
void client_update_normal_hints(ObClient *self)
{
XSizeHints size;
void client_update_title(ObClient *self)
{
gchar *data = NULL;
+ gchar *visible = NULL;
g_free(self->title);
}
}
- PROP_SETS(self->window, net_wm_visible_name, data);
- self->title = data;
+ if (self->client_machine) {
+ visible = g_strdup_printf("%s (%s)", data, self->client_machine);
+ g_free(data);
+ } else
+ visible = data;
+
+ PROP_SETS(self->window, net_wm_visible_name, visible);
+ self->title = visible;
if (self->frame)
frame_adjust_title(self->frame);
}
}
- if (self->frame)
+ /* set the default icon onto the window
+ in theory, this could be a race, but if a window doesn't set an icon
+ or removes it entirely, it's not very likely it is going to set one
+ right away afterwards */
+ if (self->nicons == 0) {
+ RrPixel32 *icon = ob_rr_theme->def_win_icon;
+ gulong *data;
+
+ data = g_new(guint32, 48*48+2);
+ data[0] = data[1] = 48;
+ for (i = 0; i < 48*48; ++i)
+ data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
+ (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
+ (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
+ (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
+ PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
+ g_free(data);
+ } else if (self->frame)
+ /* don't draw the icon empty if we're just setting one now anyways,
+ we'll get the property change any second */
frame_adjust_icon(self->frame);
}
}
}
+static void client_get_client_machine(ObClient *self)
+{
+ gchar *data = NULL;
+ gchar localhost[128];
+
+ g_free(self->client_machine);
+
+ if (PROP_GETS(self->window, wm_client_machine, locale, &data)) {
+ gethostname(localhost, 127);
+ localhost[127] = '\0';
+ if (strcmp(localhost, data))
+ self->client_machine = data;
+ }
+}
+
static void client_change_wm_state(ObClient *self)
{
gulong state[2];
self->area.x = x;
self->area.y = y;
+ /* set the desktop hint, to make sure that it always exists */
+ PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
+
/* these are in a carefully crafted order.. */
if (self->iconic) {
(resized && config_resize_redraw))));
/* if the client is enlarging, then resize the client before the frame */
- if (send_resize_client && user && (w > oldw || h > oldh))
+ if (send_resize_client && user && (w > oldw || h > oldh)) {
XResizeWindow(ob_display, self->window, MAX(w, oldw), MAX(h, oldh));
+ frame_adjust_client_area(self->frame);
+ }
/* find the frame's dimensions and move/resize it */
if (self->decorations != fdecor || self->max_horz != fhorz)
}
/* if the client is shrinking, then resize the frame before the client */
- if (send_resize_client && (!user || (w <= oldw || h <= oldh)))
+ if (send_resize_client && (!user || (w <= oldw || h <= oldh))) {
+ frame_adjust_client_area(self->frame);
XResizeWindow(ob_display, self->window, w, h);
+ }
XFlush(ob_display);
}
to activate it or not (a parent or group member is currently
active)?
*/
- ob_debug("Want to activate window 0x%x with time %u (last time %u), "
- "source=%s\n",
- self->window, event_curtime, last_time,
- (user ? "user" : "application"));
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Want to activate window 0x%x with time %u (last time %u), "
+ "source=%s\n",
+ self->window, event_curtime, last_time,
+ (user ? "user" : "application"));
if (!user && event_curtime && last_time &&
!event_time_after(event_curtime, last_time))
{
client_hilite(self, TRUE);
} else {
+ 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();
+
if (client_normal(self) && screen_showing_desktop)
screen_show_desktop(FALSE);
if (self->iconic)
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. */
+ /* 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);
}
}
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 &&
- client_can_focus(cur)))
- 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) {
ObClient *client_search_top_parent(ObClient *self)
{
- while (self->transient_for && self->transient_for != OB_TRAN_GROUP)
+ while (self->transient_for && self->transient_for != OB_TRAN_GROUP &&
+ client_normal(self))
self = self->transient_for;
return self;
}