2 #define I3__FILE__ "handlers.c"
17 #include <xcb/randr.h>
18 #include <X11/XKBlib.h>
19 #define SN_API_NOT_YET_FROZEN 1
20 #include <libsn/sn-monitor.h>
42 event->added = time(NULL);
53 time_t now = time(NULL);
55 if ((now - event->
added) > 5) {
60 }
else event =
SLIST_NEXT(event, ignore_events);
96 ELOG(
"ERROR: No such screen\n");
100 if (output->
con == NULL) {
101 ELOG(
"ERROR: The screen is not recognized by i3 (no container associated)\n");
127 DLOG(
"enter_notify for %08x, mode = %d, detail %d, serial %d\n",
128 event->event, event->mode, event->detail, event->sequence);
129 DLOG(
"coordinates %d, %d\n", event->event_x, event->event_y);
130 if (event->mode != XCB_NOTIFY_MODE_NORMAL) {
131 DLOG(
"This was not a normal notify, ignoring\n");
137 DLOG(
"Event ignored\n");
141 bool enter_child =
false;
150 DLOG(
"Getting screen at %d x %d\n", event->root_x, event->root_y);
156 DLOG(
"Ignoring, this is a dock client\n");
166 LOG(
"using child %p / %s instead!\n", child, child->
name);
173 if (client->workspace != c_ws && client->workspace->output == c_ws->output) {
177 DLOG(
"enter_notify for a client on a different workspace but the same screen, ignoring\n");
211 if (event->child != 0)
216 DLOG(
"MotionNotify for an unknown container, checking if it crosses screen boundaries.\n");
251 if (event->request != XCB_MAPPING_KEYBOARD &&
252 event->request != XCB_MAPPING_MODIFIER)
255 DLOG(
"Received mapping_notify for keyboard or modifier mapping, re-grabbing keys\n");
256 xcb_refresh_keyboard_mapping(
keysyms, event);
272 xcb_get_window_attributes_cookie_t cookie;
274 cookie = xcb_get_window_attributes_unchecked(
conn, event->window);
276 DLOG(
"window = 0x%08x, serial is %d.\n", event->window, event->sequence);
295 DLOG(
"window 0x%08x wants to be at %dx%d with %dx%d\n",
296 event->window, event->x, event->y, event->width, event->height);
301 DLOG(
"Configure request for unmanaged window, can do that.\n");
306 #define COPY_MASK_MEMBER(mask_member, event_member) do { \
307 if (event->value_mask & mask_member) { \
308 mask |= mask_member; \
309 values[c++] = event->event_member; \
321 xcb_configure_window(
conn, event->window, mask, values);
327 DLOG(
"Configure request!\n");
347 bsr.
y += deco_height;
348 bsr.
height -= deco_height;
353 DLOG(
"This is a scratchpad container, ignoring ConfigureRequest\n");
359 if (event->value_mask & XCB_CONFIG_WINDOW_X) {
360 newrect.
x =
event->x + (-1) * bsr.
x;
361 DLOG(
"proposed x = %d, new x is %d\n", event->x, newrect.
x);
363 if (event->value_mask & XCB_CONFIG_WINDOW_Y) {
364 newrect.
y =
event->y + (-1) * bsr.
y;
365 DLOG(
"proposed y = %d, new y is %d\n", event->y, newrect.
y);
367 if (event->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
368 newrect.
width =
event->width + (-1) * bsr.
width;
370 DLOG(
"proposed width = %d, new width is %d (x11 border %d)\n",
373 if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
376 DLOG(
"proposed height = %d, new height is %d (x11 border %d)\n",
380 DLOG(
"Container is a floating leaf node, will do that.\n");
387 DLOG(
"Dock window, only height reconfiguration allowed\n");
388 if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
389 DLOG(
"Height given, changing\n");
407 int handle_configure_event(
void *prophs, xcb_connection_t *
conn, xcb_configure_notify_event_t *event) {
408 DLOG(
"configure_event, sequence %d\n", event->sequence);
423 DLOG(
"RandR screen change\n");
429 ipc_send_event(
"output", I3_IPC_EVENT_OUTPUT,
"{\"change\":\"unspecified\"}");
440 DLOG(
"UnmapNotify for 0x%08x (received from 0x%08x), serial %d\n", event->window, event->event, event->sequence);
441 xcb_get_input_focus_cookie_t cookie;
448 LOG(
"Not a managed window, ignoring UnmapNotify event\n");
455 cookie = xcb_get_input_focus(
conn);
456 DLOG(
"ignore_unmap = %d for frame of container %p\n", con->
ignore_unmap, con);
461 cookie = xcb_get_input_focus(
conn);
494 free(xcb_get_input_focus_reply(
conn, cookie, NULL));
507 DLOG(
"destroy notify for 0x%08x, 0x%08x\n", event->event, event->window);
509 xcb_unmap_notify_event_t unmap;
510 unmap.sequence =
event->sequence;
511 unmap.event =
event->event;
512 unmap.window =
event->window;
522 xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
540 xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
557 xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
572 static int handle_windowclass_change(
void *data, xcb_connection_t *
conn, uint8_t
state,
573 xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
591 DLOG(
"window = %08x\n", event->window);
594 LOG(
"expose event for unknown window, ignoring\n");
603 event->x, event->y, event->x, event->y,
604 event->width, event->height);
617 if (sn_xcb_display_process_event(
sndisplay, (xcb_generic_event_t*)event))
620 LOG(
"ClientMessage for window 0x%08x\n", event->window);
621 if (event->type == A__NET_WM_STATE) {
622 if (event->format != 32 ||
623 (event->data.data32[1] != A__NET_WM_STATE_FULLSCREEN &&
624 event->data.data32[1] != A__NET_WM_STATE_DEMANDS_ATTENTION)) {
625 DLOG(
"Unknown atom in clientmessage of type %d\n", event->data.data32[1]);
631 DLOG(
"Could not get window for client message\n");
635 if (event->data.data32[1] == A__NET_WM_STATE_FULLSCREEN) {
643 DLOG(
"toggling fullscreen\n");
646 }
else if (event->data.data32[1] == A__NET_WM_STATE_DEMANDS_ATTENTION) {
657 }
else if (event->type == A__NET_ACTIVE_WINDOW) {
658 DLOG(
"_NET_ACTIVE_WINDOW: Window 0x%08x should be activated\n", event->window);
661 DLOG(
"Could not get window for client message\n");
667 DLOG(
"Workspace not visible, ignoring _NET_ACTIVE_WINDOW\n");
676 }
else if (event->type == A_I3_SYNC) {
677 xcb_window_t window =
event->data.data32[0];
678 uint32_t rnd =
event->data.data32[1];
679 DLOG(
"[i3 sync protocol] Sending random value %d back to X11 window 0x%08x\n", rnd, window);
682 xcb_client_message_event_t *ev = reply;
684 ev->response_type = XCB_CLIENT_MESSAGE;
686 ev->type = A_I3_SYNC;
688 ev->data.data32[0] = window;
689 ev->data.data32[1] = rnd;
691 xcb_send_event(conn,
false, window, XCB_EVENT_MASK_NO_EVENT, (
char*)ev);
694 }
else if (event->type == A__NET_REQUEST_FRAME_EXTENTS) {
705 DLOG(
"_NET_REQUEST_FRAME_EXTENTS for window 0x%08x\n", event->window);
706 xcb_get_geometry_reply_t *geometry;
707 xcb_get_geometry_cookie_t cookie = xcb_get_geometry(conn, event->window);
709 if (!(geometry = xcb_get_geometry_reply(conn, cookie, NULL))) {
710 ELOG(
"Could not get geometry of X11 window 0x%08x while handling "
711 "the _NET_REQUEST_FRAME_EXTENTS ClientMessage\n",
716 DLOG(
"Current geometry = x=%d, y=%d, width=%d, height=%d\n",
717 geometry->x, geometry->y, geometry->width, geometry->height);
727 XCB_PROP_MODE_REPLACE,
729 A__NET_FRAME_EXTENTS,
734 DLOG(
"unhandled clientmessage\n");
740 int handle_window_type(
void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
741 xcb_atom_t atom, xcb_get_property_reply_t *property) {
744 ELOG(
"_NET_WM_WINDOW_TYPE changed, this is not yet implemented.\n");
757 xcb_atom_t name, xcb_get_property_reply_t *reply) {
760 DLOG(
"Received WM_NORMAL_HINTS for unknown client\n");
764 xcb_size_hints_t size_hints;
776 DLOG(
"Minimum size: %d (width) x %d (height)\n", size_hints.min_width, size_hints.min_height);
779 bool changed =
false;
781 if (size_hints.width_inc > 0 && size_hints.width_inc < 0xFFFF)
786 if (size_hints.height_inc > 0 && size_hints.height_inc < 0xFFFF)
793 DLOG(
"resize increments changed\n");
796 int base_width = 0, base_height = 0;
802 base_width = size_hints.base_width;
803 base_height = size_hints.base_height;
806 base_width = size_hints.min_width;
807 base_height = size_hints.min_height;
814 DLOG(
"client's base_height changed to %d\n", base_height);
815 DLOG(
"client's base_width changed to %d\n", base_width);
821 (size_hints.min_aspect_num <= 0) ||
822 (size_hints.min_aspect_den <= 0)) {
823 goto render_and_return;
830 double min_aspect = (double)size_hints.min_aspect_num / size_hints.min_aspect_den;
831 double max_aspect = (
double)size_hints.max_aspect_num / size_hints.min_aspect_den;
833 DLOG(
"Aspect ratio set: minimum %f, maximum %f\n", min_aspect, max_aspect);
834 DLOG(
"width = %f, height = %f\n", width, height);
837 if (max_aspect <= 0 || min_aspect <= 0 || height == 0 || (width / height) <= 0)
838 goto render_and_return;
841 double aspect_ratio = 0.0;
842 if ((width / height) < min_aspect) {
843 aspect_ratio = min_aspect;
844 }
else if ((width / height) > max_aspect) {
845 aspect_ratio = max_aspect;
846 }
else goto render_and_return;
848 if (fabs(con->
aspect_ratio - aspect_ratio) > DBL_EPSILON) {
864 static bool handle_hints(
void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
865 xcb_atom_t name, xcb_get_property_reply_t *reply) {
868 DLOG(
"Received WM_HINTS for unknown client\n");
901 xcb_atom_t name, xcb_get_property_reply_t *prop) {
905 DLOG(
"No such window\n");
910 prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
927 xcb_atom_t name, xcb_get_property_reply_t *prop) {
933 prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
951 DLOG(
"focus change in, for window 0x%08x\n", event->event);
955 DLOG(
"That is con %p / %s\n", con, con->
name);
957 if (event->mode == XCB_NOTIFY_MODE_GRAB ||
958 event->mode == XCB_NOTIFY_MODE_UNGRAB) {
959 DLOG(
"FocusIn event for grab/ungrab, ignoring\n");
963 if (event->detail == XCB_NOTIFY_DETAIL_POINTER) {
964 DLOG(
"notify detail is pointer, ignoring this event\n");
969 DLOG(
"focus matches the currently focused window, not doing anything\n");
975 DLOG(
"This is a dock client, not focusing.\n");
979 DLOG(
"focus is different, updating decorations\n");
997 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);
1014 #define NUM_HANDLERS (sizeof(property_handlers) / sizeof(struct property_handler_t))
1025 property_handlers[0].
atom = A__NET_WM_NAME;
1029 property_handlers[4].
atom = A_WM_CLIENT_LEADER;
1031 property_handlers[6].
atom = A_WM_WINDOW_ROLE;
1036 xcb_get_property_reply_t *propr = NULL;
1039 if (property_handlers[c].atom != atom)
1042 handler = &property_handlers[c];
1046 if (handler == NULL) {
1051 if (state != XCB_PROPERTY_DELETE) {
1052 xcb_get_property_cookie_t cookie = xcb_get_property(conn, 0, window, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, handler->
long_len);
1053 propr = xcb_get_property_reply(conn, cookie, 0);
1057 if (!handler->
cb(NULL, conn, state, window, atom, propr))
1068 type ==
randr_base + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
1075 case XCB_KEY_RELEASE:
1079 case XCB_BUTTON_PRESS:
1083 case XCB_MAP_REQUEST:
1087 case XCB_UNMAP_NOTIFY:
1091 case XCB_DESTROY_NOTIFY:
1099 case XCB_MOTION_NOTIFY:
1104 case XCB_ENTER_NOTIFY:
1111 case XCB_CLIENT_MESSAGE:
1116 case XCB_CONFIGURE_REQUEST:
1121 case XCB_MAPPING_NOTIFY:
1129 case XCB_PROPERTY_NOTIFY: {
1130 xcb_property_notify_event_t *e = (xcb_property_notify_event_t*)event;
static void handle_enter_notify(xcb_enter_notify_event_t *event)
static void handle_map_request(xcb_map_request_event_t *event)
uint8_t ignore_unmap
This counter contains the number of UnmapNotify events for this container (or, more precisely...
#define XCB_ICCCM_SIZE_HINT_P_MIN_SIZE
static void handle_expose_event(xcb_expose_event_t *event)
A 'Con' represents everything from the X11 root window down to a single X11 window.
static void handle_client_message(xcb_client_message_event_t *event)
#define SLIST_HEAD(name, type)
void window_update_leader(i3Window *win, xcb_get_property_reply_t *prop)
Updates the CLIENT_LEADER (logical parent window).
void con_toggle_fullscreen(Con *con, int fullscreen_mode)
Toggles fullscreen mode for the given container.
void workspace_show(Con *workspace)
Switches to the given workspace.
static void handle_destroy_notify_event(xcb_destroy_notify_event_t *event)
uint32_t aio_get_mod_mask_for(uint32_t keysym, xcb_key_symbols_t *symbols)
All-in-one function which returns the modifier mask (XCB_MOD_MASK_*) for the given keysymbol...
void x_push_changes(Con *con)
Pushes all changes (state of each node, see x_push_node() and the window stack) to X11...
#define xcb_icccm_get_wm_normal_hints_unchecked
static void handle_screen_change(xcb_generic_event_t *e)
Stores a rectangle, for example the size of a window, the child window etc.
bool workspace_is_visible(Con *ws)
Returns true if the workspace is currently visible.
border_style_t border_style
#define xcb_icccm_wm_hints_get_urgency
Con * con_by_frame_id(xcb_window_t frame)
Returns the container with the given frame ID or NULL if no such container exists.
xcb_timestamp_t last_timestamp
The last timestamp we got from X11 (timestamps are included in some events and are used for some thin...
#define SLIST_NEXT(elm, field)
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)
bool disable_focus_follows_mouse
By default, focus follows mouse.
void con_set_urgency(Con *con, bool urgent)
Set urgency flag to the container, all the parent containers and the workspace.
void randr_query_outputs(void)
Initializes the specified output, assigning the specified workspace to it.
#define XCB_ICCCM_SIZE_HINT_P_ASPECT
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)
Rect con_border_style_rect(Con *con)
Returns a "relative" Rect which contains the amount of pixels that need to be added to the original R...
#define _NET_WM_STATE_ADD
layout_t
Container layouts.
#define xcb_icccm_get_wm_hints
#define xcb_icccm_get_wm_hints_from_reply
#define xcb_icccm_get_wm_size_hints_from_reply
void * scalloc(size_t size)
Safe-wrapper around calloc which exits if malloc returns NULL (meaning that there is no more memory a...
Con * con_get_workspace(Con *con)
Gets the workspace container this node is on.
static void handle_mapping_notify(xcb_mapping_notify_event_t *event)
void window_update_role(i3Window *win, xcb_get_property_reply_t *prop, bool before_mgmt)
Updates the WM_WINDOW_ROLE.
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)
void handle_key_press(xcb_key_press_event_t *event)
There was a key press.
static struct property_handler_t property_handlers[]
void floating_reposition(Con *con, Rect newrect)
Repositions the CT_FLOATING_CON to have the coordinates specified by newrect, but only if the coordin...
#define XCB_ICCCM_SIZE_HINT_P_RESIZE_INC
static void handle_focus_in(xcb_focus_in_event_t *event)
struct Rect geometry
the geometry this window requested when getting mapped
#define xcb_icccm_wm_hints_t
void manage_window(xcb_window_t window, xcb_get_window_attributes_cookie_t cookie, bool needs_to_be_mapped)
Do some sanity checks and then reparent the window.
void fake_absolute_configure_notify(Con *con)
Generates a configure_notify_event with absolute coordinates (relative to the X root window...
Con * con_by_window_id(xcb_window_t window)
Returns the container with the given client window ID or NULL if no such container exists...
bool rect_contains(Rect rect, uint32_t x, uint32_t y)
void ipc_send_event(const char *event, uint32_t message_type, const char *payload)
Sends the specified event to all IPC clients which are currently connected and subscribed to this kin...
static void handle_unmap_notify_event(xcb_unmap_notify_event_t *event)
#define _NET_WM_STATE_REMOVE
Con * con_descend_focused(Con *con)
Returns the focused con inside this client, descending the tree as far as possible.
bool event_is_ignored(const int sequence, const int response_type)
Checks if the given sequence is ignored and returns true if so.
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)
#define XCB_ATOM_WM_TRANSIENT_FOR
#define xcb_icccm_get_wm_normal_hints_reply
bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool force_set_focus)
Closes the given container including all children.
void window_update_name(i3Window *win, xcb_get_property_reply_t *prop, bool before_mgmt)
Updates the name by using _NET_WM_NAME (encoded in UTF-8) for the given window.
void * smalloc(size_t size)
Safe-wrapper around malloc which exits if malloc returns NULL (meaning that there is no more memory a...
bool con_is_leaf(Con *con)
Returns true when this node is a leaf node (has no children)
static void property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom)
void startup_monitor_event(SnMonitorEvent *event, void *userdata)
Called by libstartup-notification when something happens.
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)
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)
void con_focus(Con *con)
Sets input focus to the given container.
#define TAILQ_FIRST(head)
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)
An Output is a physical output on your graphics driver.
Output * get_output_containing(int x, int y)
Returns the active (!) output which contains the coordinates x, y or NULL if there is no output which...
static void handle_configure_request(xcb_configure_request_event_t *event)
#define SLIST_FOREACH(var, head, field)
#define TAILQ_FOREACH(var, head, field)
void window_update_hints(i3Window *win, xcb_get_property_reply_t *prop)
Updates the WM_HINTS (we only care about the input focus handling part).
void window_update_transient_for(i3Window *win, xcb_get_property_reply_t *prop)
Updates the TRANSIENT_FOR (logical parent window).
void translate_keysyms(void)
Translates keysymbols to keycodes for all bindings which use keysyms.
void window_update_name_legacy(i3Window *win, xcb_get_property_reply_t *prop, bool before_mgmt)
Updates the name by using WM_NAME (encoded in COMPOUND_TEXT).
void handle_event(int type, xcb_generic_event_t *event)
Takes an xcb_generic_event_t and calls the appropriate handler, based on the event type...
Con * output_get_content(Con *output)
Returns the output container below the given output container.
#define XCB_ATOM_WM_NORMAL_HINTS
#define SLIST_INSERT_HEAD(head, elm, field)
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)
xcb_window_t focused_id
Stores the X11 window ID of the currently focused window.
void window_update_class(i3Window *win, xcb_get_property_reply_t *prop, bool before_mgmt)
Updates the WM_CLASS (consisting of the class and instance) for the given window. ...
static void check_crossing_screen_boundary(uint32_t x, uint32_t y)
#define XCB_ICCCM_SIZE_HINT_BASE_SIZE
#define SLIST_FIRST(head)
#define _NET_WM_STATE_TOGGLE
void tree_render(void)
Renders the tree, that is rendering all outputs using render_con() and pushing the changes to X11 usi...
Con * con
Pointer to the Con which represents this output.
bool con_is_floating(Con *con)
Returns true if the node is floating.
#define XCB_ATOM_CARDINAL
#define COPY_MASK_MEMBER(mask_member, event_member)
static void handle_motion_notify(xcb_motion_notify_event_t *event)
#define SLIST_REMOVE(head, elm, type, field)
void ungrab_all_keys(xcb_connection_t *conn)
Ungrabs all keys, to be called before re-grabbing the keys because of a mapping_notify event or a con...
Con * con_get_fullscreen_con(Con *con, int fullscreen_mode)
Returns the first fullscreen node below this node.
void property_handlers_init(void)
Sets the appropriate atoms for the property handlers after the atoms were received from X11...
xcb_key_symbols_t * keysyms
void grab_all_keys(xcb_connection_t *conn, bool bind_mode_switch)
Grab the bound keys (tell X to send us keypress events for those keycodes)
#define XCB_ATOM_WM_HINTS
int height
The height of the font, built from font_ascent + font_descent.
unsigned int xcb_numlock_mask
void add_ignore_event(const int sequence, const int response_type)
Adds the given sequence to the list of events which are ignored.
enum Con::@19 fullscreen_mode
int handle_button_press(xcb_button_press_event_t *event)
The button press X callback.
void scratchpad_fix_resolution(void)
When starting i3 initially (and after each change to the connected outputs), this function fixes the ...