* 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 "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;
*
*/
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 */
/* 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);
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();
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) {
- // XXX: this is commented out because in src/x.c we disable EnterNotify events
- /* we need to ignore EnterNotify events which will be generated because a
- * different window is visible now */
- //add_ignore_event(event->sequence, XCB_ENTER_NOTIFY);
+ /* 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);
Con *con = con_by_window_id(event->window);
return 1;
}
- tree_close(con, DONT_KILL_WINDOW, false);
+ tree_close(con, DONT_KILL_WINDOW, false, false);
tree_render();
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
static int handle_expose_event(xcb_expose_event_t *event) {
Con *parent;
- /* 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;
-
DLOG("window = %08x\n", event->window);
if ((parent = con_by_frame_id(event->window)) == NULL) {
return 1;
}
- /* re-render the parent (recursively, if it’s a split con) */
- x_deco_recurse(parent);
+ /* 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 */
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
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;
{ 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 = 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 = XCB_ATOM_WM_TRANSIENT_FOR;
+ property_handlers[6].atom = A_WM_WINDOW_ROLE;
}
static void property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom) {
}
if (handler == NULL) {
- DLOG("Unhandled property notify for atom %d (0x%08x)\n", atom, atom);
+ //DLOG("Unhandled property notify for atom %d (0x%08x)\n", atom, atom);
return;
}
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