i3
handlers.c
Go to the documentation of this file.
1 #undef I3__FILE__
2 #define I3__FILE__ "handlers.c"
3 /*
4  * vim:ts=4:sw=4:expandtab
5  *
6  * i3 - an improved dynamic tiling window manager
7  * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
8  *
9  * handlers.c: Small handlers for various events (keypresses, focus changes,
10  * …).
11  *
12  */
13 #include "all.h"
14 
15 #include <time.h>
16 #include <float.h>
17 #include <sys/time.h>
18 #include <xcb/randr.h>
19 #include <X11/XKBlib.h>
20 #define SN_API_NOT_YET_FROZEN 1
21 #include <libsn/sn-monitor.h>
22 
23 int randr_base = -1;
24 
25 /* After mapping/unmapping windows, a notify event is generated. However, we don’t want it,
26  since it’d trigger an infinite loop of switching between the different windows when
27  changing workspaces */
28 static SLIST_HEAD(ignore_head, Ignore_Event) ignore_events;
29 
30 /*
31  * Adds the given sequence to the list of events which are ignored.
32  * If this ignore should only affect a specific response_type, pass
33  * response_type, otherwise, pass -1.
34  *
35  * Every ignored sequence number gets garbage collected after 5 seconds.
36  *
37  */
38 void add_ignore_event(const int sequence, const int response_type) {
39  struct Ignore_Event *event = smalloc(sizeof(struct Ignore_Event));
40 
41  event->sequence = sequence;
42  event->response_type = response_type;
43  event->added = time(NULL);
44 
45  SLIST_INSERT_HEAD(&ignore_events, event, ignore_events);
46 }
47 
48 /*
49  * Checks if the given sequence is ignored and returns true if so.
50  *
51  */
52 bool event_is_ignored(const int sequence, const int response_type) {
53  struct Ignore_Event *event;
54  time_t now = time(NULL);
55  for (event = SLIST_FIRST(&ignore_events); event != SLIST_END(&ignore_events);) {
56  if ((now - event->added) > 5) {
57  struct Ignore_Event *save = event;
58  event = SLIST_NEXT(event, ignore_events);
59  SLIST_REMOVE(&ignore_events, save, Ignore_Event, ignore_events);
60  free(save);
61  } else
62  event = SLIST_NEXT(event, ignore_events);
63  }
64 
65  SLIST_FOREACH (event, &ignore_events, ignore_events) {
66  if (event->sequence != sequence)
67  continue;
68 
69  if (event->response_type != -1 &&
70  event->response_type != response_type)
71  continue;
72 
73  /* instead of removing a sequence number we better wait until it gets
74  * garbage collected. it may generate multiple events (there are multiple
75  * enter_notifies for one configure_request, for example). */
76  //SLIST_REMOVE(&ignore_events, event, Ignore_Event, ignore_events);
77  //free(event);
78  return true;
79  }
80 
81  return false;
82 }
83 
84 /*
85  * Called with coordinates of an enter_notify event or motion_notify event
86  * to check if the user crossed virtual screen boundaries and adjust the
87  * current workspace, if so.
88  *
89  */
90 static void check_crossing_screen_boundary(uint32_t x, uint32_t y) {
91  Output *output;
92 
93  /* If the user disable focus follows mouse, we have nothing to do here */
95  return;
96 
97  if ((output = get_output_containing(x, y)) == NULL) {
98  ELOG("ERROR: No such screen\n");
99  return;
100  }
101 
102  if (output->con == NULL) {
103  ELOG("ERROR: The screen is not recognized by i3 (no container associated)\n");
104  return;
105  }
106 
107  /* Focus the output on which the user moved his cursor */
108  Con *old_focused = focused;
109  Con *next = con_descend_focused(output_get_content(output->con));
110  /* Since we are switching outputs, this *must* be a different workspace, so
111  * call workspace_show() */
113  con_focus(next);
114 
115  /* If the focus changed, we re-render to get updated decorations */
116  if (old_focused != focused)
117  tree_render();
118 }
119 
120 /*
121  * When the user moves the mouse pointer onto a window, this callback gets called.
122  *
123  */
124 static void handle_enter_notify(xcb_enter_notify_event_t *event) {
125  Con *con;
126 
127  last_timestamp = event->time;
128 
129  DLOG("enter_notify for %08x, mode = %d, detail %d, serial %d\n",
130  event->event, event->mode, event->detail, event->sequence);
131  DLOG("coordinates %d, %d\n", event->event_x, event->event_y);
132  if (event->mode != XCB_NOTIFY_MODE_NORMAL) {
133  DLOG("This was not a normal notify, ignoring\n");
134  return;
135  }
136  /* Some events are not interesting, because they were not generated
137  * actively by the user, but by reconfiguration of windows */
138  if (event_is_ignored(event->sequence, XCB_ENTER_NOTIFY)) {
139  DLOG("Event ignored\n");
140  return;
141  }
142 
143  bool enter_child = false;
144  /* Get container by frame or by child window */
145  if ((con = con_by_frame_id(event->event)) == NULL) {
146  con = con_by_window_id(event->event);
147  enter_child = true;
148  }
149 
150  /* If not, then the user moved his cursor to the root window. In that case, we adjust c_ws */
151  if (con == NULL) {
152  DLOG("Getting screen at %d x %d\n", event->root_x, event->root_y);
153  check_crossing_screen_boundary(event->root_x, event->root_y);
154  return;
155  }
156 
157  if (con->parent->type == CT_DOCKAREA) {
158  DLOG("Ignoring, this is a dock client\n");
159  return;
160  }
161 
162  /* see if the user entered the window on a certain window decoration */
163  layout_t layout = (enter_child ? con->parent->layout : con->layout);
164  if (layout == L_DEFAULT) {
165  Con *child;
166  TAILQ_FOREACH (child, &(con->nodes_head), nodes)
167  if (rect_contains(child->deco_rect, event->event_x, event->event_y)) {
168  LOG("using child %p / %s instead!\n", child, child->name);
169  con = child;
170  break;
171  }
172  }
173 
174 #if 0
175  if (client->workspace != c_ws && client->workspace->output == c_ws->output) {
176  /* This can happen when a client gets assigned to a different workspace than
177  * the current one (see src/mainx.c:reparent_window). Shortly after it was created,
178  * an enter_notify will follow. */
179  DLOG("enter_notify for a client on a different workspace but the same screen, ignoring\n");
180  return 1;
181  }
182 #endif
183 
185  return;
186 
187  /* if this container is already focused, there is nothing to do. */
188  if (con == focused)
189  return;
190 
191  /* Get the currently focused workspace to check if the focus change also
192  * involves changing workspaces. If so, we need to call workspace_show() to
193  * correctly update state and send the IPC event. */
194  Con *ws = con_get_workspace(con);
195  if (ws != con_get_workspace(focused))
196  workspace_show(ws);
197 
198  focused_id = XCB_NONE;
200  tree_render();
201 
202  return;
203 }
204 
205 /*
206  * When the user moves the mouse but does not change the active window
207  * (e.g. when having no windows opened but moving mouse on the root screen
208  * and crossing virtual screen boundaries), this callback gets called.
209  *
210  */
211 static void handle_motion_notify(xcb_motion_notify_event_t *event) {
212  last_timestamp = event->time;
213 
214  /* Skip events where the pointer was over a child window, we are only
215  * interested in events on the root window. */
216  if (event->child != 0)
217  return;
218 
219  Con *con;
220  if ((con = con_by_frame_id(event->event)) == NULL) {
221  DLOG("MotionNotify for an unknown container, checking if it crosses screen boundaries.\n");
222  check_crossing_screen_boundary(event->root_x, event->root_y);
223  return;
224  }
225 
227  return;
228 
229  if (con->layout != L_DEFAULT)
230  return;
231 
232  /* see over which rect the user is */
233  Con *current;
234  TAILQ_FOREACH (current, &(con->nodes_head), nodes) {
235  if (!rect_contains(current->deco_rect, event->event_x, event->event_y))
236  continue;
237 
238  /* We found the rect, let’s see if this window is focused */
239  if (TAILQ_FIRST(&(con->focus_head)) == current)
240  return;
241 
242  con_focus(current);
244  return;
245  }
246 
247  return;
248 }
249 
250 /*
251  * Called when the keyboard mapping changes (for example by using Xmodmap),
252  * we need to update our key bindings then (re-translate symbols).
253  *
254  */
255 static void handle_mapping_notify(xcb_mapping_notify_event_t *event) {
256  if (event->request != XCB_MAPPING_KEYBOARD &&
257  event->request != XCB_MAPPING_MODIFIER)
258  return;
259 
260  DLOG("Received mapping_notify for keyboard or modifier mapping, re-grabbing keys\n");
261  xcb_refresh_keyboard_mapping(keysyms, event);
262 
264 
267  grab_all_keys(conn, false);
268 
269  return;
270 }
271 
272 /*
273  * A new window appeared on the screen (=was mapped), so let’s manage it.
274  *
275  */
276 static void handle_map_request(xcb_map_request_event_t *event) {
277  xcb_get_window_attributes_cookie_t cookie;
278 
279  cookie = xcb_get_window_attributes_unchecked(conn, event->window);
280 
281  DLOG("window = 0x%08x, serial is %d.\n", event->window, event->sequence);
282  add_ignore_event(event->sequence, -1);
283 
284  manage_window(event->window, cookie, false);
286  return;
287 }
288 
289 /*
290  * Configure requests are received when the application wants to resize windows
291  * on their own.
292  *
293  * We generate a synthethic configure notify event to signalize the client its
294  * "new" position.
295  *
296  */
297 static void handle_configure_request(xcb_configure_request_event_t *event) {
298  Con *con;
299 
300  DLOG("window 0x%08x wants to be at %dx%d with %dx%d\n",
301  event->window, event->x, event->y, event->width, event->height);
302 
303  /* For unmanaged windows, we just execute the configure request. As soon as
304  * it gets mapped, we will take over anyways. */
305  if ((con = con_by_window_id(event->window)) == NULL) {
306  DLOG("Configure request for unmanaged window, can do that.\n");
307 
308  uint32_t mask = 0;
309  uint32_t values[7];
310  int c = 0;
311 #define COPY_MASK_MEMBER(mask_member, event_member) \
312  do { \
313  if (event->value_mask & mask_member) { \
314  mask |= mask_member; \
315  values[c++] = event->event_member; \
316  } \
317  } while (0)
318 
319  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_X, x);
320  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_Y, y);
321  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_WIDTH, width);
322  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_HEIGHT, height);
323  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_BORDER_WIDTH, border_width);
324  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_SIBLING, sibling);
325  COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_STACK_MODE, stack_mode);
326 
327  xcb_configure_window(conn, event->window, mask, values);
328  xcb_flush(conn);
329 
330  return;
331  }
332 
333  DLOG("Configure request!\n");
334 
335  Con *workspace = con_get_workspace(con),
336  *fullscreen = NULL;
337 
338  /* There might not be a corresponding workspace for dock cons, therefore we
339  * have to be careful here. */
340  if (workspace) {
341  fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
342  if (!fullscreen)
343  fullscreen = con_get_fullscreen_con(workspace, CF_GLOBAL);
344  }
345 
346  if (fullscreen != con && con_is_floating(con) && con_is_leaf(con)) {
347  /* find the height for the decorations */
348  int deco_height = con->deco_rect.height;
349  /* we actually need to apply the size/position changes to the *parent*
350  * container */
351  Rect bsr = con_border_style_rect(con);
352  if (con->border_style == BS_NORMAL) {
353  bsr.y += deco_height;
354  bsr.height -= deco_height;
355  }
356  Con *floatingcon = con->parent;
357 
358  if (strcmp(con_get_workspace(floatingcon)->name, "__i3_scratch") == 0) {
359  DLOG("This is a scratchpad container, ignoring ConfigureRequest\n");
360  return;
361  }
362 
363  Rect newrect = floatingcon->rect;
364 
365  if (event->value_mask & XCB_CONFIG_WINDOW_X) {
366  newrect.x = event->x + (-1) * bsr.x;
367  DLOG("proposed x = %d, new x is %d\n", event->x, newrect.x);
368  }
369  if (event->value_mask & XCB_CONFIG_WINDOW_Y) {
370  newrect.y = event->y + (-1) * bsr.y;
371  DLOG("proposed y = %d, new y is %d\n", event->y, newrect.y);
372  }
373  if (event->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
374  newrect.width = event->width + (-1) * bsr.width;
375  newrect.width += con->border_width * 2;
376  DLOG("proposed width = %d, new width is %d (x11 border %d)\n",
377  event->width, newrect.width, con->border_width);
378  }
379  if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
380  newrect.height = event->height + (-1) * bsr.height;
381  newrect.height += con->border_width * 2;
382  DLOG("proposed height = %d, new height is %d (x11 border %d)\n",
383  event->height, newrect.height, con->border_width);
384  }
385 
386  DLOG("Container is a floating leaf node, will do that.\n");
387  floating_reposition(floatingcon, newrect);
388  return;
389  }
390 
391  /* Dock windows can be reconfigured in their height */
392  if (con->parent && con->parent->type == CT_DOCKAREA) {
393  DLOG("Dock window, only height reconfiguration allowed\n");
394  if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
395  DLOG("Height given, changing\n");
396 
397  con->geometry.height = event->height;
398  tree_render();
399  }
400  }
401 
403 
404  return;
405 }
406 #if 0
407 
408 /*
409  * Configuration notifies are only handled because we need to set up ignore for
410  * the following enter notify events.
411  *
412  */
413 int handle_configure_event(void *prophs, xcb_connection_t *conn, xcb_configure_notify_event_t *event) {
414  DLOG("configure_event, sequence %d\n", event->sequence);
415  /* We ignore this sequence twice because events for child and frame should be ignored */
416  add_ignore_event(event->sequence);
417  add_ignore_event(event->sequence);
418 
419  return 1;
420 }
421 #endif
422 
423 /*
424  * Gets triggered upon a RandR screen change event, that is when the user
425  * changes the screen configuration in any way (mode, position, …)
426  *
427  */
428 static void handle_screen_change(xcb_generic_event_t *e) {
429  DLOG("RandR screen change\n");
430 
431  /* The geometry of the root window is used for “fullscreen global” and
432  * changes when new outputs are added. */
433  xcb_get_geometry_cookie_t cookie = xcb_get_geometry(conn, root);
434  xcb_get_geometry_reply_t *reply = xcb_get_geometry_reply(conn, cookie, NULL);
435  if (reply == NULL) {
436  ELOG("Could not get geometry of the root window, exiting\n");
437  exit(1);
438  }
439  DLOG("root geometry reply: (%d, %d) %d x %d\n", reply->x, reply->y, reply->width, reply->height);
440 
441  croot->rect.width = reply->width;
442  croot->rect.height = reply->height;
443 
445 
447 
448  ipc_send_event("output", I3_IPC_EVENT_OUTPUT, "{\"change\":\"unspecified\"}");
449 
450  return;
451 }
452 
453 /*
454  * Our window decorations were unmapped. That means, the window will be killed
455  * now, so we better clean up before.
456  *
457  */
458 static void handle_unmap_notify_event(xcb_unmap_notify_event_t *event) {
459  DLOG("UnmapNotify for 0x%08x (received from 0x%08x), serial %d\n", event->window, event->event, event->sequence);
460  xcb_get_input_focus_cookie_t cookie;
461  Con *con = con_by_window_id(event->window);
462  if (con == NULL) {
463  /* This could also be an UnmapNotify for the frame. We need to
464  * decrement the ignore_unmap counter. */
465  con = con_by_frame_id(event->window);
466  if (con == NULL) {
467  LOG("Not a managed window, ignoring UnmapNotify event\n");
468  return;
469  }
470 
471  if (con->ignore_unmap > 0)
472  con->ignore_unmap--;
473  /* See the end of this function. */
474  cookie = xcb_get_input_focus(conn);
475  DLOG("ignore_unmap = %d for frame of container %p\n", con->ignore_unmap, con);
476  goto ignore_end;
477  }
478 
479  /* See the end of this function. */
480  cookie = xcb_get_input_focus(conn);
481 
482  if (con->ignore_unmap > 0) {
483  DLOG("ignore_unmap = %d, dec\n", con->ignore_unmap);
484  con->ignore_unmap--;
485  goto ignore_end;
486  }
487 
488  tree_close(con, DONT_KILL_WINDOW, false, false);
489  tree_render();
491 
492 ignore_end:
493  /* If the client (as opposed to i3) destroyed or unmapped a window, an
494  * EnterNotify event will follow (indistinguishable from an EnterNotify
495  * event caused by moving your mouse), causing i3 to set focus to whichever
496  * window is now visible.
497  *
498  * In a complex stacked or tabbed layout (take two v-split containers in a
499  * tabbed container), when the bottom window in tab2 is closed, the bottom
500  * window of tab1 is visible instead. X11 will thus send an EnterNotify
501  * event for the bottom window of tab1, while the focus should be set to
502  * the remaining window of tab2.
503  *
504  * Therefore, we ignore all EnterNotify events which have the same sequence
505  * as an UnmapNotify event. */
506  add_ignore_event(event->sequence, XCB_ENTER_NOTIFY);
507 
508  /* Since we just ignored the sequence of this UnmapNotify, we want to make
509  * sure that following events use a different sequence. When putting xterm
510  * into fullscreen and moving the pointer to a different window, without
511  * using GetInputFocus, subsequent (legitimate) EnterNotify events arrived
512  * with the same sequence and thus were ignored (see ticket #609). */
513  free(xcb_get_input_focus_reply(conn, cookie, NULL));
514 }
515 
516 /*
517  * A destroy notify event is sent when the window is not unmapped, but
518  * immediately destroyed (for example when starting a window and immediately
519  * killing the program which started it).
520  *
521  * We just pass on the event to the unmap notify handler (by copying the
522  * important fields in the event data structure).
523  *
524  */
525 static void handle_destroy_notify_event(xcb_destroy_notify_event_t *event) {
526  DLOG("destroy notify for 0x%08x, 0x%08x\n", event->event, event->window);
527 
528  xcb_unmap_notify_event_t unmap;
529  unmap.sequence = event->sequence;
530  unmap.event = event->event;
531  unmap.window = event->window;
532 
534 }
535 
536 static bool window_name_changed(i3Window *window, char *old_name) {
537  if ((old_name == NULL) && (window->name == NULL))
538  return false;
539 
540  /* Either the old or the new one is NULL, but not both. */
541  if ((old_name == NULL) ^ (window->name == NULL))
542  return true;
543 
544  return (strcmp(old_name, i3string_as_utf8(window->name)) != 0);
545 }
546 
547 /*
548  * Called when a window changes its title
549  *
550  */
551 static bool handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
552  xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
553  Con *con;
554  if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
555  return false;
556 
557  char *old_name = (con->window->name != NULL ? sstrdup(i3string_as_utf8(con->window->name)) : NULL);
558 
559  window_update_name(con->window, prop, false);
560 
562 
563  if (window_name_changed(con->window, old_name))
564  ipc_send_window_event("title", con);
565 
566  FREE(old_name);
567 
568  return true;
569 }
570 
571 /*
572  * Handles legacy window name updates (WM_NAME), see also src/window.c,
573  * window_update_name_legacy().
574  *
575  */
576 static bool handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t state,
577  xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
578  Con *con;
579  if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
580  return false;
581 
582  char *old_name = (con->window->name != NULL ? sstrdup(i3string_as_utf8(con->window->name)) : NULL);
583 
584  window_update_name_legacy(con->window, prop, false);
585 
587 
588  if (window_name_changed(con->window, old_name))
589  ipc_send_window_event("title", con);
590 
591  FREE(old_name);
592 
593  return true;
594 }
595 
596 /*
597  * Called when a window changes its WM_WINDOW_ROLE.
598  *
599  */
600 static bool handle_windowrole_change(void *data, xcb_connection_t *conn, uint8_t state,
601  xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
602  Con *con;
603  if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
604  return false;
605 
606  window_update_role(con->window, prop, false);
607 
608  return true;
609 }
610 
611 #if 0
612 /*
613  * Updates the client’s WM_CLASS property
614  *
615  */
616 static int handle_windowclass_change(void *data, xcb_connection_t *conn, uint8_t state,
617  xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
618  Con *con;
619  if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
620  return 1;
621 
622  window_update_class(con->window, prop, false);
623 
624  return 0;
625 }
626 #endif
627 
628 /*
629  * Expose event means we should redraw our windows (= title bar)
630  *
631  */
632 static void handle_expose_event(xcb_expose_event_t *event) {
633  Con *parent;
634 
635  DLOG("window = %08x\n", event->window);
636 
637  if ((parent = con_by_frame_id(event->window)) == NULL) {
638  LOG("expose event for unknown window, ignoring\n");
639  return;
640  }
641 
642  /* Since we render to our pixmap on every change anyways, expose events
643  * only tell us that the X server lost (parts of) the window contents. We
644  * can handle that by copying the appropriate part from our pixmap to the
645  * window. */
646  xcb_copy_area(conn, parent->pixmap, parent->frame, parent->pm_gc,
647  event->x, event->y, event->x, event->y,
648  event->width, event->height);
649  xcb_flush(conn);
650 
651  return;
652 }
653 
654 /*
655  * Handle client messages (EWMH)
656  *
657  */
658 static void handle_client_message(xcb_client_message_event_t *event) {
659  /* If this is a startup notification ClientMessage, the library will handle
660  * it and call our monitor_event() callback. */
661  if (sn_xcb_display_process_event(sndisplay, (xcb_generic_event_t *)event))
662  return;
663 
664  LOG("ClientMessage for window 0x%08x\n", event->window);
665  if (event->type == A__NET_WM_STATE) {
666  if (event->format != 32 ||
667  (event->data.data32[1] != A__NET_WM_STATE_FULLSCREEN &&
668  event->data.data32[1] != A__NET_WM_STATE_DEMANDS_ATTENTION)) {
669  DLOG("Unknown atom in clientmessage of type %d\n", event->data.data32[1]);
670  return;
671  }
672 
673  Con *con = con_by_window_id(event->window);
674  if (con == NULL) {
675  DLOG("Could not get window for client message\n");
676  return;
677  }
678 
679  if (event->data.data32[1] == A__NET_WM_STATE_FULLSCREEN) {
680  /* Check if the fullscreen state should be toggled */
681  if ((con->fullscreen_mode != CF_NONE &&
682  (event->data.data32[0] == _NET_WM_STATE_REMOVE ||
683  event->data.data32[0] == _NET_WM_STATE_TOGGLE)) ||
684  (con->fullscreen_mode == CF_NONE &&
685  (event->data.data32[0] == _NET_WM_STATE_ADD ||
686  event->data.data32[0] == _NET_WM_STATE_TOGGLE))) {
687  DLOG("toggling fullscreen\n");
689  }
690  } else if (event->data.data32[1] == A__NET_WM_STATE_DEMANDS_ATTENTION) {
691  /* Check if the urgent flag must be set or not */
692  if (event->data.data32[0] == _NET_WM_STATE_ADD)
693  con_set_urgency(con, true);
694  else if (event->data.data32[0] == _NET_WM_STATE_REMOVE)
695  con_set_urgency(con, false);
696  else if (event->data.data32[0] == _NET_WM_STATE_TOGGLE)
697  con_set_urgency(con, !con->urgent);
698  }
699 
700  tree_render();
701  } else if (event->type == A__NET_ACTIVE_WINDOW) {
702  if (event->format != 32)
703  return;
704 
705  DLOG("_NET_ACTIVE_WINDOW: Window 0x%08x should be activated\n", event->window);
706 
707  Con *con = con_by_window_id(event->window);
708  if (con == NULL) {
709  DLOG("Could not get window for client message\n");
710  return;
711  }
712 
713  Con *ws = con_get_workspace(con);
714 
715  if (ws == NULL) {
716  DLOG("Window is not being managed, ignoring _NET_ACTIVE_WINDOW\n");
717  return;
718  }
719 
720  if (con_is_internal(ws)) {
721  DLOG("Workspace is internal, ignoring _NET_ACTIVE_WINDOW\n");
722  return;
723  }
724 
725  /* data32[0] indicates the source of the request (application or pager) */
726  if (event->data.data32[0] == 2) {
727  /* Always focus the con if it is from a pager, because this is most
728  * likely from some user action */
729  DLOG("This request came from a pager. Focusing con = %p\n", con);
730  workspace_show(ws);
731  con_focus(con);
732  } else {
733  /* If the request is from an application, only focus if the
734  * workspace is visible. Otherwise set the urgency hint. */
735  if (workspace_is_visible(ws)) {
736  DLOG("Request to focus con on a visible workspace. Focusing con = %p\n", con);
737  workspace_show(ws);
738  con_focus(con);
739  } else {
740  DLOG("Request to focus con on a hidden workspace. Setting urgent con = %p\n", con);
741  con_set_urgency(con, true);
742  }
743  }
744 
745  tree_render();
746  } else if (event->type == A_I3_SYNC) {
747  xcb_window_t window = event->data.data32[0];
748  uint32_t rnd = event->data.data32[1];
749  DLOG("[i3 sync protocol] Sending random value %d back to X11 window 0x%08x\n", rnd, window);
750 
751  void *reply = scalloc(32);
752  xcb_client_message_event_t *ev = reply;
753 
754  ev->response_type = XCB_CLIENT_MESSAGE;
755  ev->window = window;
756  ev->type = A_I3_SYNC;
757  ev->format = 32;
758  ev->data.data32[0] = window;
759  ev->data.data32[1] = rnd;
760 
761  xcb_send_event(conn, false, window, XCB_EVENT_MASK_NO_EVENT, (char *)ev);
762  xcb_flush(conn);
763  free(reply);
764  } else if (event->type == A__NET_REQUEST_FRAME_EXTENTS) {
765  /*
766  * A client can request an estimate for the frame size which the window
767  * manager will put around it before actually mapping its window. Java
768  * does this (as of openjdk-7).
769  *
770  * Note that the calculation below is not entirely accurate — once you
771  * set a different border type, it’s off. We _could_ request all the
772  * window properties (which have to be set up at this point according
773  * to EWMH), but that seems rather elaborate. The standard explicitly
774  * says the application must cope with an estimate that is not entirely
775  * accurate.
776  */
777  DLOG("_NET_REQUEST_FRAME_EXTENTS for window 0x%08x\n", event->window);
778 
779  /* The reply data: approximate frame size */
780  Rect r = {
781  config.default_border_width, /* left */
782  config.default_border_width, /* right */
783  config.font.height + 5, /* top */
784  config.default_border_width /* bottom */
785  };
786  xcb_change_property(
787  conn,
788  XCB_PROP_MODE_REPLACE,
789  event->window,
790  A__NET_FRAME_EXTENTS,
791  XCB_ATOM_CARDINAL, 32, 4,
792  &r);
793  xcb_flush(conn);
794  } else {
795  DLOG("unhandled clientmessage\n");
796  return;
797  }
798 }
799 
800 #if 0
801 int handle_window_type(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
802  xcb_atom_t atom, xcb_get_property_reply_t *property) {
803  /* TODO: Implement this one. To do this, implement a little test program which sleep(1)s
804  before changing this property. */
805  ELOG("_NET_WM_WINDOW_TYPE changed, this is not yet implemented.\n");
806  return 0;
807 }
808 #endif
809 
810 /*
811  * Handles the size hints set by a window, but currently only the part necessary for displaying
812  * clients proportionally inside their frames (mplayer for example)
813  *
814  * See ICCCM 4.1.2.3 for more details
815  *
816  */
817 static bool handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
818  xcb_atom_t name, xcb_get_property_reply_t *reply) {
819  Con *con = con_by_window_id(window);
820  if (con == NULL) {
821  DLOG("Received WM_NORMAL_HINTS for unknown client\n");
822  return false;
823  }
824 
825  xcb_size_hints_t size_hints;
826 
827  //CLIENT_LOG(client);
828 
829  /* If the hints were already in this event, use them, if not, request them */
830  if (reply != NULL)
831  xcb_icccm_get_wm_size_hints_from_reply(&size_hints, reply);
832  else
834 
835  if ((size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)) {
836  // TODO: Minimum size is not yet implemented
837  DLOG("Minimum size: %d (width) x %d (height)\n", size_hints.min_width, size_hints.min_height);
838  }
839 
840  bool changed = false;
841  if ((size_hints.flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC)) {
842  if (size_hints.width_inc > 0 && size_hints.width_inc < 0xFFFF)
843  if (con->width_increment != size_hints.width_inc) {
844  con->width_increment = size_hints.width_inc;
845  changed = true;
846  }
847  if (size_hints.height_inc > 0 && size_hints.height_inc < 0xFFFF)
848  if (con->height_increment != size_hints.height_inc) {
849  con->height_increment = size_hints.height_inc;
850  changed = true;
851  }
852 
853  if (changed)
854  DLOG("resize increments changed\n");
855  }
856 
857  int base_width = 0, base_height = 0;
858 
859  /* base_width/height are the desired size of the window.
860  We check if either the program-specified size or the program-specified
861  min-size is available */
862  if (size_hints.flags & XCB_ICCCM_SIZE_HINT_BASE_SIZE) {
863  base_width = size_hints.base_width;
864  base_height = size_hints.base_height;
865  } else if (size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE) {
866  /* TODO: is this right? icccm says not */
867  base_width = size_hints.min_width;
868  base_height = size_hints.min_height;
869  }
870 
871  if (base_width != con->base_width ||
872  base_height != con->base_height) {
873  con->base_width = base_width;
874  con->base_height = base_height;
875  DLOG("client's base_height changed to %d\n", base_height);
876  DLOG("client's base_width changed to %d\n", base_width);
877  changed = true;
878  }
879 
880  /* If no aspect ratio was set or if it was invalid, we ignore the hints */
881  if (!(size_hints.flags & XCB_ICCCM_SIZE_HINT_P_ASPECT) ||
882  (size_hints.min_aspect_num <= 0) ||
883  (size_hints.min_aspect_den <= 0)) {
884  goto render_and_return;
885  }
886 
887  /* XXX: do we really use rect here, not window_rect? */
888  double width = con->rect.width - base_width;
889  double height = con->rect.height - base_height;
890  /* Convert numerator/denominator to a double */
891  double min_aspect = (double)size_hints.min_aspect_num / size_hints.min_aspect_den;
892  double max_aspect = (double)size_hints.max_aspect_num / size_hints.min_aspect_den;
893 
894  DLOG("Aspect ratio set: minimum %f, maximum %f\n", min_aspect, max_aspect);
895  DLOG("width = %f, height = %f\n", width, height);
896 
897  /* Sanity checks, this is user-input, in a way */
898  if (max_aspect <= 0 || min_aspect <= 0 || height == 0 || (width / height) <= 0)
899  goto render_and_return;
900 
901  /* Check if we need to set proportional_* variables using the correct ratio */
902  double aspect_ratio = 0.0;
903  if ((width / height) < min_aspect) {
904  aspect_ratio = min_aspect;
905  } else if ((width / height) > max_aspect) {
906  aspect_ratio = max_aspect;
907  } else
908  goto render_and_return;
909 
910  if (fabs(con->aspect_ratio - aspect_ratio) > DBL_EPSILON) {
911  con->aspect_ratio = aspect_ratio;
912  changed = true;
913  }
914 
915 render_and_return:
916  if (changed)
917  tree_render();
918  FREE(reply);
919  return true;
920 }
921 
922 /*
923  * Handles the WM_HINTS property for extracting the urgency state of the window.
924  *
925  */
926 static bool handle_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
927  xcb_atom_t name, xcb_get_property_reply_t *reply) {
928  Con *con = con_by_window_id(window);
929  if (con == NULL) {
930  DLOG("Received WM_HINTS for unknown client\n");
931  return false;
932  }
933 
934  bool urgency_hint;
935  if (reply == NULL)
936  reply = xcb_get_property_reply(conn, xcb_icccm_get_wm_hints(conn, window), NULL);
937  window_update_hints(con->window, reply, &urgency_hint);
938  con_set_urgency(con, urgency_hint);
939  tree_render();
940 
941  return true;
942 }
943 
944 /*
945  * Handles the transient for hints set by a window, signalizing that this window is a popup window
946  * for some other window.
947  *
948  * See ICCCM 4.1.2.6 for more details
949  *
950  */
951 static bool handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
952  xcb_atom_t name, xcb_get_property_reply_t *prop) {
953  Con *con;
954 
955  if ((con = con_by_window_id(window)) == NULL || con->window == NULL) {
956  DLOG("No such window\n");
957  return false;
958  }
959 
960  if (prop == NULL) {
961  prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
962  false, window, XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 0, 32),
963  NULL);
964  if (prop == NULL)
965  return false;
966  }
967 
969 
970  return true;
971 }
972 
973 /*
974  * Handles changes of the WM_CLIENT_LEADER atom which specifies if this is a
975  * toolwindow (or similar) and to which window it belongs (logical parent).
976  *
977  */
978 static bool handle_clientleader_change(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
979  xcb_atom_t name, xcb_get_property_reply_t *prop) {
980  Con *con;
981  if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
982  return false;
983 
984  if (prop == NULL) {
985  prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
986  false, window, A_WM_CLIENT_LEADER, XCB_ATOM_WINDOW, 0, 32),
987  NULL);
988  if (prop == NULL)
989  return false;
990  }
991 
992  window_update_leader(con->window, prop);
993 
994  return true;
995 }
996 
997 /*
998  * Handles FocusIn events which are generated by clients (i3’s focus changes
999  * don’t generate FocusIn events due to a different EventMask) and updates the
1000  * decorations accordingly.
1001  *
1002  */
1003 static void handle_focus_in(xcb_focus_in_event_t *event) {
1004  DLOG("focus change in, for window 0x%08x\n", event->event);
1005  Con *con;
1006  if ((con = con_by_window_id(event->event)) == NULL || con->window == NULL)
1007  return;
1008  DLOG("That is con %p / %s\n", con, con->name);
1009 
1010  if (event->mode == XCB_NOTIFY_MODE_GRAB ||
1011  event->mode == XCB_NOTIFY_MODE_UNGRAB) {
1012  DLOG("FocusIn event for grab/ungrab, ignoring\n");
1013  return;
1014  }
1015 
1016  if (event->detail == XCB_NOTIFY_DETAIL_POINTER) {
1017  DLOG("notify detail is pointer, ignoring this event\n");
1018  return;
1019  }
1020 
1021  if (focused_id == event->event) {
1022  DLOG("focus matches the currently focused window, not doing anything\n");
1023  return;
1024  }
1025 
1026  /* Skip dock clients, they cannot get the i3 focus. */
1027  if (con->parent->type == CT_DOCKAREA) {
1028  DLOG("This is a dock client, not focusing.\n");
1029  return;
1030  }
1031 
1032  DLOG("focus is different, updating decorations\n");
1033 
1034  /* Get the currently focused workspace to check if the focus change also
1035  * involves changing workspaces. If so, we need to call workspace_show() to
1036  * correctly update state and send the IPC event. */
1037  Con *ws = con_get_workspace(con);
1038  if (ws != con_get_workspace(focused))
1039  workspace_show(ws);
1040 
1041  con_focus(con);
1042  /* We update focused_id because we don’t need to set focus again */
1043  focused_id = event->event;
1045  return;
1046 }
1047 
1048 /* Returns false if the event could not be processed (e.g. the window could not
1049  * be found), true otherwise */
1050 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);
1051 
1053  xcb_atom_t atom;
1054  uint32_t long_len;
1056 };
1057 
1059  {0, 128, handle_windowname_change},
1060  {0, UINT_MAX, handle_hints},
1062  {0, UINT_MAX, handle_normal_hints},
1063  {0, UINT_MAX, handle_clientleader_change},
1064  {0, UINT_MAX, handle_transient_for},
1065  {0, 128, handle_windowrole_change}};
1066 #define NUM_HANDLERS (sizeof(property_handlers) / sizeof(struct property_handler_t))
1067 
1068 /*
1069  * Sets the appropriate atoms for the property handlers after the atoms were
1070  * received from X11
1071  *
1072  */
1074  sn_monitor_context_new(sndisplay, conn_screen, startup_monitor_event, NULL, NULL);
1075 
1076  property_handlers[0].atom = A__NET_WM_NAME;
1077  property_handlers[1].atom = XCB_ATOM_WM_HINTS;
1078  property_handlers[2].atom = XCB_ATOM_WM_NAME;
1079  property_handlers[3].atom = XCB_ATOM_WM_NORMAL_HINTS;
1080  property_handlers[4].atom = A_WM_CLIENT_LEADER;
1081  property_handlers[5].atom = XCB_ATOM_WM_TRANSIENT_FOR;
1082  property_handlers[6].atom = A_WM_WINDOW_ROLE;
1083 }
1084 
1085 static void property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom) {
1086  struct property_handler_t *handler = NULL;
1087  xcb_get_property_reply_t *propr = NULL;
1088 
1089  for (size_t c = 0; c < sizeof(property_handlers) / sizeof(struct property_handler_t); c++) {
1090  if (property_handlers[c].atom != atom)
1091  continue;
1092 
1093  handler = &property_handlers[c];
1094  break;
1095  }
1096 
1097  if (handler == NULL) {
1098  //DLOG("Unhandled property notify for atom %d (0x%08x)\n", atom, atom);
1099  return;
1100  }
1101 
1102  if (state != XCB_PROPERTY_DELETE) {
1103  xcb_get_property_cookie_t cookie = xcb_get_property(conn, 0, window, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, handler->long_len);
1104  propr = xcb_get_property_reply(conn, cookie, 0);
1105  }
1106 
1107  /* the handler will free() the reply unless it returns false */
1108  if (!handler->cb(NULL, conn, state, window, atom, propr))
1109  FREE(propr);
1110 }
1111 
1112 /*
1113  * Takes an xcb_generic_event_t and calls the appropriate handler, based on the
1114  * event type.
1115  *
1116  */
1117 void handle_event(int type, xcb_generic_event_t *event) {
1118  if (randr_base > -1 &&
1119  type == randr_base + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
1120  handle_screen_change(event);
1121  return;
1122  }
1123 
1124  switch (type) {
1125  case XCB_KEY_PRESS:
1126  case XCB_KEY_RELEASE:
1127  handle_key_press((xcb_key_press_event_t *)event);
1128  break;
1129 
1130  case XCB_BUTTON_PRESS:
1131  handle_button_press((xcb_button_press_event_t *)event);
1132  break;
1133 
1134  case XCB_MAP_REQUEST:
1135  handle_map_request((xcb_map_request_event_t *)event);
1136  break;
1137 
1138  case XCB_UNMAP_NOTIFY:
1139  handle_unmap_notify_event((xcb_unmap_notify_event_t *)event);
1140  break;
1141 
1142  case XCB_DESTROY_NOTIFY:
1143  handle_destroy_notify_event((xcb_destroy_notify_event_t *)event);
1144  break;
1145 
1146  case XCB_EXPOSE:
1147  handle_expose_event((xcb_expose_event_t *)event);
1148  break;
1149 
1150  case XCB_MOTION_NOTIFY:
1151  handle_motion_notify((xcb_motion_notify_event_t *)event);
1152  break;
1153 
1154  /* Enter window = user moved his mouse over the window */
1155  case XCB_ENTER_NOTIFY:
1156  handle_enter_notify((xcb_enter_notify_event_t *)event);
1157  break;
1158 
1159  /* Client message are sent to the root window. The only interesting
1160  * client message for us is _NET_WM_STATE, we honour
1161  * _NET_WM_STATE_FULLSCREEN and _NET_WM_STATE_DEMANDS_ATTENTION */
1162  case XCB_CLIENT_MESSAGE:
1163  handle_client_message((xcb_client_message_event_t *)event);
1164  break;
1165 
1166  /* Configure request = window tried to change size on its own */
1167  case XCB_CONFIGURE_REQUEST:
1168  handle_configure_request((xcb_configure_request_event_t *)event);
1169  break;
1170 
1171  /* Mapping notify = keyboard mapping changed (Xmodmap), re-grab bindings */
1172  case XCB_MAPPING_NOTIFY:
1173  handle_mapping_notify((xcb_mapping_notify_event_t *)event);
1174  break;
1175 
1176  case XCB_FOCUS_IN:
1177  handle_focus_in((xcb_focus_in_event_t *)event);
1178  break;
1179 
1180  case XCB_PROPERTY_NOTIFY: {
1181  xcb_property_notify_event_t *e = (xcb_property_notify_event_t *)event;
1182  last_timestamp = e->time;
1183  property_notify(e->state, e->window, e->atom);
1184  break;
1185  }
1186 
1187  default:
1188  //DLOG("Unhandled event of type %d\n", type);
1189  break;
1190  }
1191 }
uint32_t long_len
Definition: handlers.c:1054
struct Con * parent
Definition: data.h:512
const char * i3string_as_utf8(i3String *str)
Returns the UTF-8 encoded version of the i3String.
char * sstrdup(const char *str)
Safe-wrapper around strdup which exits if malloc returns NULL (meaning that there is no more memory a...
#define XCB_ATOM_WM_HINTS
Definition: xcb_compat.h:44
void handle_key_press(xcb_key_press_event_t *event)
There was a key press.
Definition: key_press.c:20
#define SLIST_FOREACH(var, head, field)
Definition: queue.h:114
bool urgent
Definition: data.h:484
#define XCB_NUM_LOCK
Definition: xcb.h:27
bool con_is_floating(Con *con)
Returns true if the node is floating.
Definition: con.c:419
void tree_render(void)
Renders the tree, that is rendering all outputs using render_con() and pushing the changes to X11 usi...
Definition: tree.c:507
int height_increment
Definition: data.h:545
uint8_t ignore_unmap
This counter contains the number of UnmapNotify events for this container (or, more precisely...
Definition: data.h:491
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.
Definition: manage.c:82
uint32_t y
Definition: data.h:124
uint32_t height
Definition: data.h:33
Config config
Definition: config.c:19
xcb_connection_t * conn
Definition: main.c:47
SnDisplay * sndisplay
Definition: main.c:52
xcb_gcontext_t pm_gc
Definition: data.h:497
Con * con_get_workspace(Con *con)
Gets the workspace container this node is on.
Definition: con.c:317
bool disable_focus_follows_mouse
By default, focus follows mouse.
Definition: config.h:110
i3Font font
Definition: config.h:92
static bool window_name_changed(i3Window *window, char *old_name)
Definition: handlers.c:536
#define xcb_icccm_get_wm_hints
Definition: xcb_compat.h:32
Stores a rectangle, for example the size of a window, the child window etc.
Definition: data.h:122
#define LOG(fmt,...)
Definition: libi3.h:76
bool workspace_is_visible(Con *ws)
Returns true if the workspace is currently visible.
Definition: workspace.c:232
static struct property_handler_t property_handlers[]
Definition: handlers.c:1058
static void handle_map_request(xcb_map_request_event_t *event)
Definition: handlers.c:276
#define SLIST_NEXT(elm, field)
Definition: queue.h:112
int handle_button_press(xcb_button_press_event_t *event)
The button press X callback.
Definition: click.c:314
static void handle_expose_event(xcb_expose_event_t *event)
Definition: handlers.c:632
void translate_keysyms(void)
Translates keysymbols to keycodes for all bindings which use keysyms.
Definition: bindings.c:242
#define SLIST_END(head)
Definition: queue.h:110
void workspace_show(Con *workspace)
Switches to the given workspace.
Definition: workspace.c:447
Con * con_descend_focused(Con *con)
Returns the focused con inside this client, descending the tree as far as possible.
Definition: con.c:983
struct Rect rect
Definition: data.h:514
void window_update_transient_for(i3Window *win, xcb_get_property_reply_t *prop)
Updates the TRANSIENT_FOR (logical parent window).
Definition: window.c:150
#define _NET_WM_STATE_ADD
Definition: xcb.h:16
static void handle_mapping_notify(xcb_mapping_notify_event_t *event)
Definition: handlers.c:255
#define SLIST_INSERT_HEAD(head, elm, field)
Definition: queue.h:136
#define TAILQ_FIRST(head)
Definition: queue.h:323
static void handle_client_message(xcb_client_message_event_t *event)
Definition: handlers.c:658
struct Window * window
Definition: data.h:547
void window_update_leader(i3Window *win, xcb_get_property_reply_t *prop)
Updates the CLIENT_LEADER (logical parent window).
Definition: window.c:126
uint32_t width
Definition: data.h:32
xcb_timestamp_t last_timestamp
The last timestamp we got from X11 (timestamps are included in some events and are used for some thin...
Definition: main.c:57
#define XCB_ICCCM_SIZE_HINT_BASE_SIZE
Definition: xcb_compat.h:29
#define COPY_MASK_MEMBER(mask_member, event_member)
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)
Definition: handlers.c:551
int border_width
Definition: data.h:540
An Output is a physical output on your graphics driver.
Definition: data.h:301
layout_t
Container layouts.
Definition: data.h:84
void floating_reposition(Con *con, Rect newrect)
Repositions the CT_FLOATING_CON to have the coordinates specified by newrect, but only if the coordin...
Definition: floating.c:759
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)
Definition: handlers.c:978
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)
Definition: bindings.c:105
border_style_t border_style
Definition: data.h:579
bool con_is_internal(Con *con)
Returns true if the container is internal, such as __i3_scratch.
Definition: con.c:411
A &#39;Window&#39; is a type which contains an xcb_window_t and all the related information (hints like _NET_...
Definition: data.h:332
#define xcb_icccm_get_wm_size_hints_from_reply
Definition: xcb_compat.h:21
#define XCB_ATOM_WM_NORMAL_HINTS
Definition: xcb_compat.h:46
bool rect_contains(Rect rect, uint32_t x, uint32_t y)
Definition: util.c:37
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...
Definition: ipc.c:75
int base_width
Definition: data.h:536
enum Con::@18 type
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...
Definition: con.c:461
Definition: data.h:85
#define DLOG(fmt,...)
Definition: libi3.h:86
static cmdp_state state
int response_type
Definition: data.h:181
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)
Definition: handlers.c:576
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)
Definition: handlers.c:817
double aspect_ratio
Definition: data.h:533
#define xcb_icccm_get_wm_normal_hints_reply
Definition: xcb_compat.h:24
int sequence
Definition: data.h:180
void randr_query_outputs(void)
Initializes the specified output, assigning the specified workspace to it.
Definition: randr.c:592
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).
Definition: window.c:89
struct Rect deco_rect
Definition: data.h:516
Con * con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode)
Returns the first fullscreen node below this node.
Definition: con.c:365
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.
Definition: tree.c:190
Rect con_border_style_rect(Con *con)
Returns a &quot;relative&quot; Rect which contains the amount of pixels that need to be added to the original R...
Definition: con.c:1090
Definition: data.h:473
bool con_is_leaf(Con *con)
Returns true when this node is a leaf node (has no children)
Definition: con.c:241
#define XCB_ICCCM_SIZE_HINT_P_MIN_SIZE
Definition: xcb_compat.h:26
uint32_t height
Definition: data.h:126
Con * focused
Definition: tree.c:15
Con * con
Pointer to the Con which represents this output.
Definition: data.h:319
struct Rect geometry
the geometry this window requested when getting mapped
Definition: data.h:518
void x_push_changes(Con *con)
Pushes all changes (state of each node, see x_push_node() and the window stack) to X11...
Definition: x.c:883
char * name
Definition: data.h:520
bool event_is_ignored(const int sequence, const int response_type)
Checks if the given sequence is ignored and returns true if so.
Definition: handlers.c:52
fullscreen_mode_t fullscreen_mode
Definition: data.h:563
int randr_base
Definition: handlers.c:23
int height
The height of the font, built from font_ascent + font_descent.
Definition: libi3.h:47
void con_focus(Con *con)
Sets input focus to the given container.
Definition: con.c:213
Con * con_by_frame_id(xcb_window_t frame)
Returns the container with the given frame ID or NULL if no such container exists.
Definition: con.c:474
void add_ignore_event(const int sequence, const int response_type)
Adds the given sequence to the list of events which are ignored.
int base_height
Definition: data.h:537
#define xcb_icccm_get_wm_normal_hints_unchecked
Definition: xcb_compat.h:25
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)
Definition: handlers.c:951
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)
Definition: handlers.c:926
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...
Definition: config.c:28
static void handle_focus_in(xcb_focus_in_event_t *event)
Definition: handlers.c:1003
xcb_atom_t atom
Definition: handlers.c:1053
static void handle_motion_notify(xcb_motion_notify_event_t *event)
Definition: handlers.c:211
#define ELOG(fmt,...)
Definition: libi3.h:81
unsigned int xcb_numlock_mask
Definition: xcb.c:14
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. ...
Definition: window.c:19
static void check_crossing_screen_boundary(uint32_t x, uint32_t y)
Definition: handlers.c:90
static void handle_screen_change(xcb_generic_event_t *e)
Definition: handlers.c:428
layout_t layout
Definition: data.h:578
static void handle_configure_request(xcb_configure_request_event_t *event)
Definition: handlers.c:297
A &#39;Con&#39; represents everything from the X11 root window down to a single X11 window.
Definition: data.h:479
uint32_t x
Definition: data.h:123
time_t added
Definition: data.h:182
void * scalloc(size_t size)
Safe-wrapper around calloc which exits if malloc returns NULL (meaning that there is no more memory a...
void window_update_hints(i3Window *win, xcb_get_property_reply_t *prop, bool *urgency_hint)
Updates the WM_HINTS (we only care about the input focus handling part).
Definition: window.c:232
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 scratchpad_fix_resolution(void)
When starting i3 initially (and after each change to the connected outputs), this function fixes the ...
Definition: scratchpad.c:251
int default_border_width
Definition: config.h:100
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)
Definition: handlers.c:1050
#define XCB_ICCCM_SIZE_HINT_P_ASPECT
Definition: xcb_compat.h:30
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.
Definition: window.c:57
xcb_window_t frame
Definition: data.h:495
static void property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom)
Definition: handlers.c:1085
#define SLIST_REMOVE(head, elm, type, field)
Definition: queue.h:149
Output * get_output_containing(unsigned int x, unsigned int y)
Returns the active (!) output which contains the coordinates x, y or NULL if there is no output which...
Definition: randr.c:80
void fake_absolute_configure_notify(Con *con)
Generates a configure_notify_event with absolute coordinates (relative to the X root window...
Definition: xcb.c:94
struct Con * croot
Definition: tree.c:14
xcb_window_t root
Definition: main.c:60
static void handle_enter_notify(xcb_enter_notify_event_t *event)
Definition: handlers.c:124
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)
Definition: handlers.c:600
void startup_monitor_event(SnMonitorEvent *event, void *userdata)
Called by libstartup-notification when something happens.
Definition: startup.c:214
#define _NET_WM_STATE_TOGGLE
Definition: xcb.h:17
#define SLIST_HEAD(name, type)
Definition: queue.h:93
Con * output_get_content(Con *output)
Returns the output container below the given output container.
Definition: output.c:18
uint32_t y
Definition: data.h:31
i3String * name
The name of the window.
Definition: data.h:349
static void handle_destroy_notify_event(xcb_destroy_notify_event_t *event)
Definition: handlers.c:525
xcb_window_t id
Definition: data.h:333
cb_property_handler_t cb
Definition: handlers.c:1055
void * smalloc(size_t size)
Safe-wrapper around malloc which exits if malloc returns NULL (meaning that there is no more memory a...
xcb_key_symbols_t * keysyms
Definition: main.c:71
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:334
#define XCB_ATOM_WM_NAME
Definition: xcb_compat.h:42
void window_update_role(i3Window *win, xcb_get_property_reply_t *prop, bool before_mgmt)
Updates the WM_WINDOW_ROLE.
Definition: window.c:199
xcb_pixmap_t pixmap
Definition: data.h:496
#define _NET_WM_STATE_REMOVE
Definition: xcb.h:15
uint32_t x
Definition: data.h:30
#define FREE(pointer)
Definition: util.h:46
static void handle_unmap_notify_event(xcb_unmap_notify_event_t *event)
Definition: handlers.c:458
#define XCB_ATOM_WINDOW
Definition: xcb_compat.h:40
void property_handlers_init(void)
Sets the appropriate atoms for the property handlers after the atoms were received from X11...
Definition: handlers.c:1073
void ipc_send_window_event(const char *property, Con *con)
For the window events we send, along the usual &quot;change&quot; field, also the window container, in &quot;container&quot;.
Definition: ipc.c:1091
#define XCB_ICCCM_SIZE_HINT_P_RESIZE_INC
Definition: xcb_compat.h:28
Definition: data.h:56
void con_set_urgency(Con *con, bool urgent)
Set urgency flag to the container, all the parent containers and the workspace.
Definition: con.c:1575
void con_toggle_fullscreen(Con *con, int fullscreen_mode)
Toggles fullscreen mode for the given container.
Definition: con.c:587
#define SLIST_FIRST(head)
Definition: queue.h:109
int width_increment
Definition: data.h:544
xcb_window_t focused_id
Stores the X11 window ID of the currently focused window.
Definition: x.c:16
#define XCB_ATOM_CARDINAL
Definition: xcb_compat.h:39
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...
Definition: handlers.c:1117
uint32_t width
Definition: data.h:125
int conn_screen
Definition: main.c:49
#define XCB_ATOM_WM_TRANSIENT_FOR
Definition: xcb_compat.h:41