#include "mouse.h"
#include "render/render.h"
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
#include <glib.h>
#include <X11/Xutil.h>
gpointer data;
} Destructor;
-GList *client_list = NULL;
+GList *client_list = NULL;
static GSList *client_destructors = NULL;
-static Time client_last_user_time = CurrentTime;
static void client_get_all(ObClient *self);
static void client_toggle_border(ObClient *self, gboolean show);
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_change_allowed_actions(ObClient *self);
static void client_change_state(ObClient *self);
static void client_change_wm_state(ObClient *self);
static void client_restore_session_state(ObClient *self);
static void client_restore_session_stacking(ObClient *self);
static ObAppSettings *client_get_settings_state(ObClient *self);
-static void client_unfocus(ObClient *self);
void client_startup(gboolean reconfig)
{
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 = client_last_user_time;
+ self->user_time = CurrentTime;
client_get_all(self);
- client_restore_session_state(self);
/* 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);
mouse_grab_for_client(self, TRUE);
if (activate) {
+ guint32 last_time = focus_client ?
+ focus_client->user_time : CurrentTime;
+
/* This is focus stealing prevention */
ob_debug("Want to focus new window 0x%x with time %u (last time %u)\n",
- self->window, self->user_time, client_last_user_time);
+ self->window, self->user_time, last_time);
/* If a nothing at all, or a parent was focused, then focus this
always
else
{
/* If time stamp is old, don't steal focus */
- if (self->user_time &&
- !event_time_after(self->user_time, client_last_user_time))
+ if (self->user_time && last_time &&
+ !event_time_after(self->user_time, last_time))
{
activate = FALSE;
}
} else {
ob_debug("Focus stealing prevention activated for %s with time %u "
"(last time %u)\n",
- self->title, self->user_time, client_last_user_time);
+ self->title, self->user_time, last_time);
/* if the client isn't focused, then hilite it so the user
knows it is there */
client_hilite(self, TRUE);
client_focus(self);
}
- /* client_activate does this but we aret using it so we have to do it
+ /* 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);
g_assert(self != NULL);
- /* update the focus lists */
- focus_order_remove(self);
+ /* 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);
- if (focus_client == self) {
- XEvent e;
+ frame_hide(self->frame);
+ /* flush to send the hide to the server quickly */
+ XFlush(ob_display);
- /* focus the last focused window on the desktop, and ignore enter
- events from the unmap so it doesnt mess with the focus */
- while (XCheckTypedEvent(ob_display, EnterNotify, &e));
- /* remove these flags so we don't end up getting focused in the
- fallback! */
- self->can_focus = FALSE;
- self->focus_notify = FALSE;
- self->modal = FALSE;
- client_unfocus(self);
+ if (focus_client == self) {
+ /* ignore enter events from the unmap so it doesnt mess with the focus
+ */
+ event_ignore_queued_enters();
}
- /* potentially fix focusLast */
- if (config_focus_last)
- grab_pointer(TRUE, OB_CURSOR_NONE);
-
- frame_hide(self->frame);
- XFlush(ob_display);
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);
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);
/* update the list hints */
client_set_list();
-
- if (config_focus_last)
- grab_pointer(FALSE, OB_CURSOR_NONE);
}
static ObAppSettings *client_get_settings_state(ObClient *self)
(min/max sizes), so we're ready to set up the decorations/functions */
client_setup_decor_and_functions(self);
+ client_get_client_machine(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, FALSE);
+ client_update_user_time(self);
}
static void client_get_startup_id(ObClient *self)
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);
frame_adjust_icon(self->frame);
}
-void client_update_user_time(ObClient *self, gboolean new_event)
+void client_update_user_time(ObClient *self)
{
guint32 time;
if (PROP_GET32(self->window, net_wm_user_time, cardinal, &time)) {
- self->user_time = time;
/* 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
assume noone is setting times older than the last one, cuz that
would be pretty stupid anyways
- However! This is called when a window is mapped to get its user time
- but it's an old number, it's not changing it from new user
- interaction, so in that case, don't change the last user time.
*/
- if (new_event)
- client_last_user_time = time;
+ self->user_time = time;
/*
ob_debug("window %s user time %u\n", self->title, time);
- ob_debug("last user time %u\n", client_last_user_time);
*/
}
}
+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];
return FALSE;
}
- ob_debug("Focusing client \"%s\" at time %u\n", self->title, event_curtime);
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focusing client \"%s\" at time %u\n",
+ self->title, event_curtime);
if (self->can_focus) {
+ /* This can cause a BadMatch error with CurrentTime, or if an app
+ passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
+ xerror_set_ignore(TRUE);
XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
event_curtime);
+ xerror_set_ignore(FALSE);
}
if (self->focus_notify) {
return TRUE;
}
-/* Used when the current client is closed or otherwise hidden, focus_last will
- then prevent focus from going to the mouse pointer
-*/
-static void client_unfocus(ObClient *self)
-{
- if (focus_client == self) {
-#ifdef DEBUG_FOCUS
- ob_debug("client_unfocus for %lx\n", self->window);
-#endif
- focus_fallback(FALSE);
- }
-}
-
void client_activate(ObClient *self, gboolean here, gboolean user)
{
+ guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
+
/* 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)?
*/
ob_debug("Want to activate window 0x%x with time %u (last time %u), "
"source=%s\n",
- self->window, event_curtime, client_last_user_time,
+ self->window, event_curtime, last_time,
(user ? "user" : "application"));
- if (!user && event_curtime &&
- !event_time_after(event_curtime, client_last_user_time))
+
+ if (!user && event_curtime && last_time &&
+ !event_time_after(event_curtime, last_time))
{
client_hilite(self, TRUE);
} else {
for (it = self->group->members; it; it = g_slist_next(it)) {
ObClient *c = it->data;
- if (!c->transient_for)
+ if (!c->transient_for && client_normal(c))
ret = g_slist_prepend(ret, c);
}