* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2010 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ *
+ * handlers.c: Small handlers for various events (keypresses, focus changes,
+ * …).
*
*/
-#include <time.h>
-#include <limits.h>
+#include "all.h"
+#include <time.h>
#include <xcb/randr.h>
-
#include <X11/XKBlib.h>
-
-#include "all.h"
+#define SN_API_NOT_YET_FROZEN 1
+#include <libsn/sn-monitor.h>
int randr_base = -1;
changing workspaces */
static SLIST_HEAD(ignore_head, Ignore_Event) ignore_events;
+/*
+ * Adds the given sequence to the list of events which are ignored.
+ * If this ignore should only affect a specific response_type, pass
+ * response_type, otherwise, pass -1.
+ *
+ * Every ignored sequence number gets garbage collected after 5 seconds.
+ *
+ */
void add_ignore_event(const int sequence, const int response_type) {
struct Ignore_Event *event = smalloc(sizeof(struct Ignore_Event));
* Checks if the given sequence is ignored and returns true if so.
*
*/
-static bool event_is_ignored(const int sequence, const int response_type) {
+bool event_is_ignored(const int sequence, const int response_type) {
struct Ignore_Event *event;
time_t now = time(NULL);
for (event = SLIST_FIRST(&ignore_events); event != SLIST_END(&ignore_events);) {
if (event->sequence != sequence)
continue;
- if (event->response_type != 0 &&
+ if (event->response_type != -1 &&
event->response_type != response_type)
continue;
*
*/
static int handle_key_press(xcb_key_press_event_t *event) {
+
+ last_timestamp = event->time;
+
DLOG("Keypress %d, state raw = %d\n", event->detail, event->state);
/* Remove the numlock bit, all other bits are modifiers we can bind to */
}
}
- parse_cmd(bind->command);
- tree_render();
+ char *json_result = parse_cmd(bind->command);
+ FREE(json_result);
return 1;
}
/* Focus the output on which the user moved his cursor */
Con *old_focused = focused;
- con_focus(con_descend_focused(output_get_content(output->con)));
+ Con *next = con_descend_focused(output_get_content(output->con));
+ /* Since we are switching outputs, this *must* be a different workspace, so
+ * call workspace_show() */
+ workspace_show(con_get_workspace(next));
+ con_focus(next);
/* If the focus changed, we re-render to get updated decorations */
if (old_focused != focused)
static int handle_enter_notify(xcb_enter_notify_event_t *event) {
Con *con;
+ last_timestamp = event->time;
+
DLOG("enter_notify for %08x, mode = %d, detail %d, serial %d\n",
event->event, event->mode, event->detail, event->sequence);
DLOG("coordinates %d, %d\n", event->event_x, event->event_y);
/* see if the user entered the window on a certain window decoration */
int layout = (enter_child ? con->parent->layout : con->layout);
- Con *child;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes)
- if (rect_contains(child->deco_rect, event->event_x, event->event_y)) {
- LOG("using child %p / %s instead!\n", child, child->name);
- con = child;
- break;
- }
-
- /* for stacked/tabbed layout we do not want to change focus when the user
- * enters the window at the decoration of any child window. */
- if (layout == L_STACKED || layout == L_TABBED) {
- con = TAILQ_FIRST(&(con->parent->focus_head));
- LOG("using focused %p / %s instead\n", con, con->name);
+ if (layout == L_DEFAULT) {
+ Con *child;
+ TAILQ_FOREACH(child, &(con->nodes_head), nodes)
+ if (rect_contains(child->deco_rect, event->event_x, event->event_y)) {
+ LOG("using child %p / %s instead!\n", child, child->name);
+ con = child;
+ break;
+ }
}
#if 0
if (config.disable_focus_follows_mouse)
return 1;
+ /* Get the currently focused workspace to check if the focus change also
+ * involves changing workspaces. If so, we need to call workspace_show() to
+ * correctly update state and send the IPC event. */
+ Con *ws = con_get_workspace(con);
+ if (ws != con_get_workspace(focused))
+ workspace_show(ws);
+
con_focus(con_descend_focused(con));
tree_render();
*
*/
static int handle_motion_notify(xcb_motion_notify_event_t *event) {
+
+ last_timestamp = event->time;
+
/* Skip events where the pointer was over a child window, we are only
* interested in events on the root window. */
if (event->child != 0)
DLOG("Received mapping_notify for keyboard or modifier mapping, re-grabbing keys\n");
xcb_refresh_keyboard_mapping(keysyms, event);
- xcb_get_numlock_mask(conn);
+ xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
ungrab_all_keys(conn);
translate_keysyms();
cookie = xcb_get_window_attributes_unchecked(conn, event->window);
DLOG("window = 0x%08x, serial is %d.\n", event->window, event->sequence);
- add_ignore_event(event->sequence, 0);
+ add_ignore_event(event->sequence, -1);
manage_window(event->window, cookie, false);
x_push_changes(croot);
bsr.y += deco_height;
bsr.height -= deco_height;
}
- con = con->parent;
- DLOG("Container is a floating leaf node, will do that.\n");
+ Con *floatingcon = con->parent;
+
+ Rect newrect = floatingcon->rect;
+
if (event->value_mask & XCB_CONFIG_WINDOW_X) {
- con->rect.x = event->x + (-1) * bsr.x;
- DLOG("proposed x = %d, new x is %d\n", event->x, con->rect.x);
+ newrect.x = event->x + (-1) * bsr.x;
+ DLOG("proposed x = %d, new x is %d\n", event->x, newrect.x);
}
if (event->value_mask & XCB_CONFIG_WINDOW_Y) {
- con->rect.y = event->y + (-1) * bsr.y;
- DLOG("proposed y = %d, new y is %d\n", event->y, con->rect.y);
+ newrect.y = event->y + (-1) * bsr.y;
+ DLOG("proposed y = %d, new y is %d\n", event->y, newrect.y);
}
if (event->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
- con->rect.width = event->width + (-1) * bsr.width;
- DLOG("proposed width = %d, new width is %d\n", event->width, con->rect.width);
+ newrect.width = event->width + (-1) * bsr.width;
+ newrect.width += con->border_width * 2;
+ DLOG("proposed width = %d, new width is %d (x11 border %d)\n",
+ event->width, newrect.width, con->border_width);
}
if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
- con->rect.height = event->height + (-1) * bsr.height;
- DLOG("proposed height = %d, new height is %d\n", event->height, con->rect.height);
+ newrect.height = event->height + (-1) * bsr.height;
+ newrect.height += con->border_width * 2;
+ DLOG("proposed height = %d, new height is %d (x11 border %d)\n",
+ event->height, newrect.height, con->border_width);
}
- tree_render();
- }
-
- fake_absolute_configure_notify(con);
-
- return 1;
-#if 0
- /* Dock clients can be reconfigured in their height */
- if (client->dock) {
- DLOG("Reconfiguring height of this dock client\n");
-
- if (!(event->value_mask & XCB_CONFIG_WINDOW_HEIGHT)) {
- DLOG("Ignoring configure request, no height given\n");
- return 1;
- }
- client->desired_height = event->height;
- render_workspace(conn, c_ws->output, c_ws);
- xcb_flush(conn);
-
- return 1;
- }
-
- if (client->fullscreen) {
- DLOG("Client is in fullscreen mode\n");
+ DLOG("Container is a floating leaf node, will do that.\n");
+ floating_reposition(floatingcon, newrect);
+ return 1;
+ }
- Rect child_rect = client->container->workspace->rect;
- child_rect.x = child_rect.y = 0;
- fake_configure_notify(conn, child_rect, client->child);
+ /* Dock windows can be reconfigured in their height */
+ if (con->parent && con->parent->type == CT_DOCKAREA) {
+ DLOG("Dock window, only height reconfiguration allowed\n");
+ if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+ DLOG("Height given, changing\n");
- return 1;
+ con->geometry.height = event->height;
+ tree_render();
}
+ }
- fake_absolute_configure_notify(conn, client);
+ fake_absolute_configure_notify(con);
- return 1;
-#endif
+ return 1;
}
#if 0
*
*/
static int handle_unmap_notify_event(xcb_unmap_notify_event_t *event) {
- /* we need to ignore EnterNotify events which will be generated because a
- * different window is visible now */
+ /* If the client (as opposed to i3) destroyed or unmapped a window, an
+ * EnterNotify event will follow (indistinguishable from an EnterNotify
+ * event caused by moving your mouse), causing i3 to set focus to whichever
+ * window is now visible.
+ *
+ * In a complex stacked or tabbed layout (take two v-split containers in a
+ * tabbed container), when the bottom window in tab2 is closed, the bottom
+ * window of tab1 is visible instead. X11 will thus send an EnterNotify
+ * event for the bottom window of tab1, while the focus should be set to
+ * the remaining window of tab2.
+ *
+ * Therefore, we ignore all EnterNotify events which have the same sequence
+ * as an UnmapNotify event. */
add_ignore_event(event->sequence, XCB_ENTER_NOTIFY);
DLOG("UnmapNotify for 0x%08x (received from 0x%08x), serial %d\n", event->window, event->event, event->sequence);
return 1;
}
- tree_close(con, false, false);
+ tree_close(con, DONT_KILL_WINDOW, false, false);
tree_render();
x_push_changes(croot);
return 1;
* Called when a window changes its title
*
*/
-static int handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
+static bool handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
Con *con;
if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
- return 1;
+ return false;
- window_update_name(con->window, prop);
+ window_update_name(con->window, prop, false);
x_push_changes(croot);
- return 1;
+ return true;
}
/*
* window_update_name_legacy().
*
*/
-static int handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t state,
+static bool handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t state,
xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
Con *con;
if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
- return 1;
+ return false;
- window_update_name_legacy(con->window, prop);
+ window_update_name_legacy(con->window, prop, false);
x_push_changes(croot);
- return 1;
+ return true;
+}
+
+/*
+ * Called when a window changes its WM_WINDOW_ROLE.
+ *
+ */
+static bool handle_windowrole_change(void *data, xcb_connection_t *conn, uint8_t state,
+ xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
+ Con *con;
+ if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
+ return false;
+
+ window_update_role(con->window, prop, false);
+
+ return true;
}
+#if 0
/*
* Updates the client’s WM_CLASS property
*
if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
return 1;
- window_update_class(con->window, prop);
+ window_update_class(con->window, prop, false);
return 0;
}
+#endif
/*
* Expose event means we should redraw our windows (= title bar)
*
*/
static int handle_expose_event(xcb_expose_event_t *event) {
- Con *parent, *con;
-
- /* event->count is the number of minimum remaining expose events for this
- * window, so we skip all events but the last one */
- if (event->count != 0)
- return 1;
+ Con *parent;
DLOG("window = %08x\n", event->window);
return 1;
}
- if (parent->window)
- x_draw_decoration(parent);
-
- TAILQ_FOREACH(con, &(parent->nodes_head), nodes) {
- DLOG("expose for con %p / %s\n", con, con->name);
- if (con->window)
- x_draw_decoration(con);
- }
-
- /* We also need to render the decorations of other Cons nearby the Con
- * itself to not get overlapping decorations */
- TAILQ_FOREACH(con, &(parent->parent->nodes_head), nodes) {
- DLOG("expose for con %p / %s\n", con, con->name);
- if (con->window)
- x_draw_decoration(con);
- }
+ /* Since we render to our pixmap on every change anyways, expose events
+ * only tell us that the X server lost (parts of) the window contents. We
+ * can handle that by copying the appropriate part from our pixmap to the
+ * window. */
+ xcb_copy_area(conn, parent->pixmap, parent->frame, parent->pm_gc,
+ event->x, event->y, event->x, event->y,
+ event->width, event->height);
xcb_flush(conn);
return 1;
* Handle client messages (EWMH)
*
*/
-static int handle_client_message(xcb_client_message_event_t *event) {
+static void handle_client_message(xcb_client_message_event_t *event) {
+ /* If this is a startup notification ClientMessage, the library will handle
+ * it and call our monitor_event() callback. */
+ if (sn_xcb_display_process_event(sndisplay, (xcb_generic_event_t*)event))
+ return;
+
LOG("ClientMessage for window 0x%08x\n", event->window);
if (event->type == A__NET_WM_STATE) {
if (event->format != 32 || event->data.data32[1] != A__NET_WM_STATE_FULLSCREEN) {
DLOG("atom in clientmessage is %d, fullscreen is %d\n",
event->data.data32[1], A__NET_WM_STATE_FULLSCREEN);
DLOG("not about fullscreen atom\n");
- return 0;
+ return;
}
Con *con = con_by_window_id(event->window);
if (con == NULL) {
DLOG("Could not get window for client message\n");
- return 0;
+ return;
}
/* Check if the fullscreen state should be toggled */
(event->data.data32[0] == _NET_WM_STATE_ADD ||
event->data.data32[0] == _NET_WM_STATE_TOGGLE))) {
DLOG("toggling fullscreen\n");
- con_toggle_fullscreen(con);
+ con_toggle_fullscreen(con, CF_OUTPUT);
}
tree_render();
x_push_changes(croot);
+ } else if (event->type == A_I3_SYNC) {
+ DLOG("i3 sync, yay\n");
+ xcb_window_t window = event->data.data32[0];
+ uint32_t rnd = event->data.data32[1];
+ DLOG("Sending random value %d back to X11 window 0x%08x\n", rnd, window);
+
+ void *reply = scalloc(32);
+ xcb_client_message_event_t *ev = reply;
+
+ ev->response_type = XCB_CLIENT_MESSAGE;
+ ev->window = window;
+ ev->type = A_I3_SYNC;
+ ev->format = 32;
+ ev->data.data32[0] = window;
+ ev->data.data32[1] = rnd;
+
+ xcb_send_event(conn, false, window, XCB_EVENT_MASK_NO_EVENT, (char*)ev);
+ xcb_flush(conn);
+ free(reply);
} else {
- ELOG("unhandled clientmessage\n");
- return 0;
+ DLOG("unhandled clientmessage\n");
+ return;
}
-
- return 1;
}
#if 0
* See ICCCM 4.1.2.3 for more details
*
*/
-static int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+static bool handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
xcb_atom_t name, xcb_get_property_reply_t *reply) {
Con *con = con_by_window_id(window);
if (con == NULL) {
DLOG("Received WM_NORMAL_HINTS for unknown client\n");
- return 1;
+ return false;
}
xcb_size_hints_t size_hints;
con->base_height = base_height;
DLOG("client's base_height changed to %d\n", base_height);
DLOG("client's base_width changed to %d\n", base_width);
+ changed = true;
}
/* If no aspect ratio was set or if it was invalid, we ignore the hints */
/* Check if we need to set proportional_* variables using the correct ratio */
if ((width / height) < min_aspect) {
- con->proportional_width = width;
- con->proportional_height = width / min_aspect;
+ if (con->proportional_width != width ||
+ con->proportional_height != (width / min_aspect)) {
+ con->proportional_width = width;
+ con->proportional_height = width / min_aspect;
+ changed = true;
+ }
} else if ((width / height) > max_aspect) {
- con->proportional_width = width;
- con->proportional_height = width / max_aspect;
+ if (con->proportional_width != width ||
+ con->proportional_height != (width / max_aspect)) {
+ con->proportional_width = width;
+ con->proportional_height = width / max_aspect;
+ changed = true;
+ }
} else goto render_and_return;
render_and_return:
- tree_render();
- return 1;
+ if (changed)
+ tree_render();
+ FREE(reply);
+ return true;
}
/*
* Handles the WM_HINTS property for extracting the urgency state of the window.
*
*/
-static int handle_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+static bool handle_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
xcb_atom_t name, xcb_get_property_reply_t *reply) {
Con *con = con_by_window_id(window);
if (con == NULL) {
DLOG("Received WM_HINTS for unknown client\n");
- return 1;
+ return false;
}
xcb_icccm_wm_hints_t hints;
if (reply != NULL) {
if (!xcb_icccm_get_wm_hints_from_reply(&hints, reply))
- return 1;
+ return false;
} else {
if (!xcb_icccm_get_wm_hints_reply(conn, xcb_icccm_get_wm_hints_unchecked(conn, con->window->id), &hints, NULL))
- return 1;
+ return false;
}
if (!con->urgent && focused == con) {
DLOG("Ignoring urgency flag for current client\n");
- return 1;
+ FREE(reply);
+ return true;
}
/* Update the flag on the client directly */
}
#endif
- return 1;
+ FREE(reply);
+ return true;
}
/*
* See ICCCM 4.1.2.6 for more details
*
*/
-static int handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+static bool handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
xcb_atom_t name, xcb_get_property_reply_t *prop) {
Con *con;
if ((con = con_by_window_id(window)) == NULL || con->window == NULL) {
DLOG("No such window\n");
- return 1;
+ return false;
}
if (prop == NULL) {
prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
- false, window, A_WM_TRANSIENT_FOR, A_WINDOW, 0, 32), NULL);
+ false, window, XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 0, 32), NULL);
if (prop == NULL)
- return 1;
+ return false;
}
window_update_transient_for(con->window, prop);
}
#endif
- return 1;
+ return true;
}
/*
* toolwindow (or similar) and to which window it belongs (logical parent).
*
*/
-static int handle_clientleader_change(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+static bool handle_clientleader_change(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
xcb_atom_t name, xcb_get_property_reply_t *prop) {
Con *con;
if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
- return 1;
+ return false;
if (prop == NULL) {
prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
- false, window, A_WM_CLIENT_LEADER, A_WINDOW, 0, 32), NULL);
+ false, window, A_WM_CLIENT_LEADER, XCB_ATOM_WINDOW, 0, 32), NULL);
if (prop == NULL)
- return 1;
+ return false;
}
window_update_leader(con->window, prop);
- return 1;
+ return true;
}
/*
return 1;
}
+ /* Skip dock clients, they cannot get the i3 focus. */
+ if (con->parent->type == CT_DOCKAREA) {
+ DLOG("This is a dock client, not focusing.\n");
+ return 1;
+ }
+
DLOG("focus is different, updating decorations\n");
+
+ /* Get the currently focused workspace to check if the focus change also
+ * involves changing workspaces. If so, we need to call workspace_show() to
+ * correctly update state and send the IPC event. */
+ Con *ws = con_get_workspace(con);
+ if (ws != con_get_workspace(focused))
+ workspace_show(ws);
+
con_focus(con);
/* We update focused_id because we don’t need to set focus again */
focused_id = event->event;
return 1;
}
-typedef int (*cb_property_handler_t)(void *data, xcb_connection_t *c, uint8_t state, xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *property);
+/* Returns false if the event could not be processed (e.g. the window could not
+ * be found), true otherwise */
+typedef bool (*cb_property_handler_t)(void *data, xcb_connection_t *c, uint8_t state, xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *property);
struct property_handler_t {
xcb_atom_t atom;
{ 0, 128, handle_windowname_change_legacy },
{ 0, UINT_MAX, handle_normal_hints },
{ 0, UINT_MAX, handle_clientleader_change },
- { 0, UINT_MAX, handle_transient_for }
+ { 0, UINT_MAX, handle_transient_for },
+ { 0, 128, handle_windowrole_change }
};
#define NUM_HANDLERS (sizeof(property_handlers) / sizeof(struct property_handler_t))
*
*/
void property_handlers_init() {
+
+ sn_monitor_context_new(sndisplay, conn_screen, startup_monitor_event, NULL, NULL);
+
property_handlers[0].atom = A__NET_WM_NAME;
- property_handlers[1].atom = A_WM_HINTS;
- property_handlers[2].atom = A_WM_NAME;
- property_handlers[3].atom = A_WM_NORMAL_HINTS;
+ property_handlers[1].atom = XCB_ATOM_WM_HINTS;
+ property_handlers[2].atom = XCB_ATOM_WM_NAME;
+ property_handlers[3].atom = XCB_ATOM_WM_NORMAL_HINTS;
property_handlers[4].atom = A_WM_CLIENT_LEADER;
- property_handlers[5].atom = A_WM_TRANSIENT_FOR;
+ property_handlers[5].atom = XCB_ATOM_WM_TRANSIENT_FOR;
+ property_handlers[6].atom = A_WM_WINDOW_ROLE;
}
-static int property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom) {
+static void property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom) {
struct property_handler_t *handler = NULL;
xcb_get_property_reply_t *propr = NULL;
- int ret;
for (int c = 0; c < sizeof(property_handlers) / sizeof(struct property_handler_t); c++) {
if (property_handlers[c].atom != atom)
}
if (handler == NULL) {
- DLOG("Unhandled property notify for atom %d (0x%08x)\n", atom, atom);
- return 0;
+ //DLOG("Unhandled property notify for atom %d (0x%08x)\n", atom, atom);
+ return;
}
if (state != XCB_PROPERTY_DELETE) {
propr = xcb_get_property_reply(conn, cookie, 0);
}
- ret = handler->cb(NULL, conn, state, window, atom, propr);
- FREE(propr);
- return ret;
+ /* the handler will free() the reply unless it returns false */
+ if (!handler->cb(NULL, conn, state, window, atom, propr))
+ FREE(propr);
}
/*
handle_focus_in((xcb_focus_in_event_t*)event);
break;
- case XCB_PROPERTY_NOTIFY:
- DLOG("Property notify\n");
+ case XCB_PROPERTY_NOTIFY: {
xcb_property_notify_event_t *e = (xcb_property_notify_event_t*)event;
+ last_timestamp = e->time;
property_notify(e->state, e->window, e->atom);
break;
+ }
default:
- DLOG("Unhandled event of type %d\n", type);
+ //DLOG("Unhandled event of type %d\n", type);
break;
}
}
projects / i3 / i3 / blobdiff