i3
x.c
Go to the documentation of this file.
1 #undef I3__FILE__
2 #define I3__FILE__ "x.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  * x.c: Interface to X11, transfers our in-memory state to X11 (see also
10  * render.c). Basically a big state machine.
11  *
12  */
13 #include "all.h"
14 
15 /* Stores the X11 window ID of the currently focused window */
16 xcb_window_t focused_id = XCB_NONE;
17 
18 /* Because 'focused_id' might be reset to force input focus (after click to
19  * raise), we separately keep track of the X11 window ID to be able to always
20  * tell whether the focused window actually changed. */
21 static xcb_window_t last_focused = XCB_NONE;
22 
23 /* Stores coordinates to warp mouse pointer to if set */
24 static Rect *warp_to;
25 
26 /*
27  * Describes the X11 state we may modify (map state, position, window stack).
28  * There is one entry per container. The state represents the current situation
29  * as X11 sees it (with the exception of the order in the state_head CIRCLEQ,
30  * which represents the order that will be pushed to X11, while old_state_head
31  * represents the current order). It will be updated in x_push_changes().
32  *
33  */
34 typedef struct con_state {
35  xcb_window_t id;
36  bool mapped;
37  bool unmap_now;
39 
41  Con *con;
42 
43  /* For reparenting, we have a flag (need_reparent) and the X ID of the old
44  * frame this window was in. The latter is necessary because we need to
45  * ignore UnmapNotify events (by changing the window event mask). */
47  xcb_window_t old_frame;
48 
51 
52  bool initial;
53 
54  char *name;
55 
57  CIRCLEQ_ENTRY(con_state) old_state;
58  TAILQ_ENTRY(con_state) initial_mapping_order;
59 } con_state;
60 
61 CIRCLEQ_HEAD(state_head, con_state) state_head =
62  CIRCLEQ_HEAD_INITIALIZER(state_head);
63 
64 CIRCLEQ_HEAD(old_state_head, con_state) old_state_head =
65  CIRCLEQ_HEAD_INITIALIZER(old_state_head);
66 
67 TAILQ_HEAD(initial_mapping_head, con_state) initial_mapping_head =
68  TAILQ_HEAD_INITIALIZER(initial_mapping_head);
69 
70 /*
71  * Returns the container state for the given frame. This function always
72  * returns a container state (otherwise, there is a bug in the code and the
73  * container state of a container for which x_con_init() was not called was
74  * requested).
75  *
76  */
77 static con_state *state_for_frame(xcb_window_t window) {
79  CIRCLEQ_FOREACH (state, &state_head, state)
80  if (state->id == window)
81  return state;
82 
83  /* TODO: better error handling? */
84  ELOG("No state found\n");
85  assert(false);
86  return NULL;
87 }
88 
89 /*
90  * Initializes the X11 part for the given container. Called exactly once for
91  * every container from con_new().
92  *
93  */
94 void x_con_init(Con *con, uint16_t depth) {
95  /* TODO: maybe create the window when rendering first? we could then even
96  * get the initial geometry right */
97 
98  uint32_t mask = 0;
99  uint32_t values[5];
100 
101  xcb_visualid_t visual = XCB_COPY_FROM_PARENT;
102  xcb_colormap_t win_colormap = XCB_NONE;
103  if (depth != root_depth && depth != XCB_COPY_FROM_PARENT) {
104  /* For custom visuals, we need to create a colormap before creating
105  * this window. It will be freed directly after creating the window. */
106  visual = get_visualid_by_depth(depth);
107  win_colormap = xcb_generate_id(conn);
108  xcb_create_colormap_checked(conn, XCB_COLORMAP_ALLOC_NONE, win_colormap, root, visual);
109 
110  /* We explicitly set a background color and border color (even though we
111  * don’t even have a border) because the X11 server requires us to when
112  * using 32 bit color depths, see
113  * http://stackoverflow.com/questions/3645632 */
114  mask |= XCB_CW_BACK_PIXEL;
115  values[0] = root_screen->black_pixel;
116 
117  mask |= XCB_CW_BORDER_PIXEL;
118  values[1] = root_screen->black_pixel;
119 
120  /* our own frames should not be managed */
121  mask |= XCB_CW_OVERRIDE_REDIRECT;
122  values[2] = 1;
123 
124  /* see include/xcb.h for the FRAME_EVENT_MASK */
125  mask |= XCB_CW_EVENT_MASK;
126  values[3] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW;
127 
128  mask |= XCB_CW_COLORMAP;
129  values[4] = win_colormap;
130  } else {
131  /* our own frames should not be managed */
132  mask = XCB_CW_OVERRIDE_REDIRECT;
133  values[0] = 1;
134 
135  /* see include/xcb.h for the FRAME_EVENT_MASK */
136  mask |= XCB_CW_EVENT_MASK;
137  values[1] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW;
138 
139  mask |= XCB_CW_COLORMAP;
140  values[2] = colormap;
141  }
142 
143  Rect dims = {-15, -15, 10, 10};
144  con->frame = create_window(conn, dims, depth, visual, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCURSOR_CURSOR_POINTER, false, mask, values);
145 
146  if (win_colormap != XCB_NONE)
147  xcb_free_colormap(conn, win_colormap);
148 
149  struct con_state *state = scalloc(sizeof(struct con_state));
150  state->id = con->frame;
151  state->mapped = false;
152  state->initial = true;
153  DLOG("Adding window 0x%08x to lists\n", state->id);
154  CIRCLEQ_INSERT_HEAD(&state_head, state, state);
155  CIRCLEQ_INSERT_HEAD(&old_state_head, state, old_state);
156  TAILQ_INSERT_TAIL(&initial_mapping_head, state, initial_mapping_order);
157  DLOG("adding new state for window id 0x%08x\n", state->id);
158 }
159 
160 /*
161  * Re-initializes the associated X window state for this container. You have
162  * to call this when you assign a client to an empty container to ensure that
163  * its state gets updated correctly.
164  *
165  */
166 void x_reinit(Con *con) {
167  struct con_state *state;
168 
169  if ((state = state_for_frame(con->frame)) == NULL) {
170  ELOG("window state not found\n");
171  return;
172  }
173 
174  DLOG("resetting state %p to initial\n", state);
175  state->initial = true;
176  state->child_mapped = false;
177  state->con = con;
178  memset(&(state->window_rect), 0, sizeof(Rect));
179 }
180 
181 /*
182  * Reparents the child window of the given container (necessary for sticky
183  * containers). The reparenting happens in the next call of x_push_changes().
184  *
185  */
186 void x_reparent_child(Con *con, Con *old) {
187  struct con_state *state;
188  if ((state = state_for_frame(con->frame)) == NULL) {
189  ELOG("window state for con not found\n");
190  return;
191  }
192 
193  state->need_reparent = true;
194  state->old_frame = old->frame;
195 }
196 
197 /*
198  * Moves a child window from Container src to Container dest.
199  *
200  */
201 void x_move_win(Con *src, Con *dest) {
202  struct con_state *state_src, *state_dest;
203 
204  if ((state_src = state_for_frame(src->frame)) == NULL) {
205  ELOG("window state for src not found\n");
206  return;
207  }
208 
209  if ((state_dest = state_for_frame(dest->frame)) == NULL) {
210  ELOG("window state for dest not found\n");
211  return;
212  }
213 
214  state_dest->con = state_src->con;
215  state_src->con = NULL;
216 
217  Rect zero = {0, 0, 0, 0};
218  if (memcmp(&(state_dest->window_rect), &(zero), sizeof(Rect)) == 0) {
219  memcpy(&(state_dest->window_rect), &(state_src->window_rect), sizeof(Rect));
220  DLOG("COPYING RECT\n");
221  }
222 }
223 
224 /*
225  * Kills the window decoration associated with the given container.
226  *
227  */
229  con_state *state;
230 
231  xcb_destroy_window(conn, con->frame);
232  xcb_free_pixmap(conn, con->pixmap);
233  xcb_free_gc(conn, con->pm_gc);
234  state = state_for_frame(con->frame);
235  CIRCLEQ_REMOVE(&state_head, state, state);
236  CIRCLEQ_REMOVE(&old_state_head, state, old_state);
237  TAILQ_REMOVE(&initial_mapping_head, state, initial_mapping_order);
238  FREE(state->name);
239  free(state);
240 
241  /* Invalidate focused_id to correctly focus new windows with the same ID */
242  focused_id = last_focused = XCB_NONE;
243 }
244 
245 /*
246  * Returns true if the client supports the given protocol atom (like WM_DELETE_WINDOW)
247  *
248  */
249 bool window_supports_protocol(xcb_window_t window, xcb_atom_t atom) {
250  xcb_get_property_cookie_t cookie;
252  bool result = false;
253 
254  cookie = xcb_icccm_get_wm_protocols(conn, window, A_WM_PROTOCOLS);
255  if (xcb_icccm_get_wm_protocols_reply(conn, cookie, &protocols, NULL) != 1)
256  return false;
257 
258  /* Check if the client’s protocols have the requested atom set */
259  for (uint32_t i = 0; i < protocols.atoms_len; i++)
260  if (protocols.atoms[i] == atom)
261  result = true;
262 
264 
265  return result;
266 }
267 
268 /*
269  * Kills the given X11 window using WM_DELETE_WINDOW (if supported).
270  *
271  */
272 void x_window_kill(xcb_window_t window, kill_window_t kill_window) {
273  /* if this window does not support WM_DELETE_WINDOW, we kill it the hard way */
274  if (!window_supports_protocol(window, A_WM_DELETE_WINDOW)) {
275  if (kill_window == KILL_WINDOW) {
276  LOG("Killing specific window 0x%08x\n", window);
277  xcb_destroy_window(conn, window);
278  } else {
279  LOG("Killing the X11 client which owns window 0x%08x\n", window);
280  xcb_kill_client(conn, window);
281  }
282  return;
283  }
284 
285  /* Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes.
286  * In order to properly initialize these bytes, we allocate 32 bytes even
287  * though we only need less for an xcb_configure_notify_event_t */
288  void *event = scalloc(32);
289  xcb_client_message_event_t *ev = event;
290 
291  ev->response_type = XCB_CLIENT_MESSAGE;
292  ev->window = window;
293  ev->type = A_WM_PROTOCOLS;
294  ev->format = 32;
295  ev->data.data32[0] = A_WM_DELETE_WINDOW;
296  ev->data.data32[1] = XCB_CURRENT_TIME;
297 
298  LOG("Sending WM_DELETE to the client\n");
299  xcb_send_event(conn, false, window, XCB_EVENT_MASK_NO_EVENT, (char *)ev);
300  xcb_flush(conn);
301  free(event);
302 }
303 
304 /*
305  * Draws the decoration of the given container onto its parent.
306  *
307  */
309  Con *parent = con->parent;
310  bool leaf = con_is_leaf(con);
311 
312  /* This code needs to run for:
313  * • leaf containers
314  * • non-leaf containers which are in a stacked/tabbed container
315  *
316  * It does not need to run for:
317  * • direct children of outputs or dockareas
318  * • floating containers (they don’t have a decoration)
319  */
320  if ((!leaf &&
321  parent->layout != L_STACKED &&
322  parent->layout != L_TABBED) ||
323  parent->type == CT_OUTPUT ||
324  parent->type == CT_DOCKAREA ||
325  con->type == CT_FLOATING_CON)
326  return;
327 
328  /* Skip containers whose height is 0 (for example empty dockareas) */
329  if (con->rect.height == 0)
330  return;
331 
332  /* Skip containers whose pixmap has not yet been created (can happen when
333  * decoration rendering happens recursively for a window for which
334  * x_push_node() was not yet called) */
335  if (leaf && con->pixmap == XCB_NONE)
336  return;
337 
338  /* 1: build deco_params and compare with cache */
339  struct deco_render_params *p = scalloc(sizeof(struct deco_render_params));
340 
341  /* find out which colors to use */
342  if (con->urgent)
343  p->color = &config.client.urgent;
344  else if (con == focused || con_inside_focused(con))
345  p->color = &config.client.focused;
346  else if (con == TAILQ_FIRST(&(parent->focus_head)))
348  else
350 
351  p->border_style = con_border_style(con);
352 
353  Rect *r = &(con->rect);
354  Rect *w = &(con->window_rect);
355  p->con_rect = (struct width_height) {r->width, r->height};
356  p->con_window_rect = (struct width_height) {w->width, w->height};
357  p->con_deco_rect = con->deco_rect;
359  p->con_is_leaf = con_is_leaf(con);
360  p->parent_layout = con->parent->layout;
361 
362  if (con->deco_render_params != NULL &&
363  (con->window == NULL || !con->window->name_x_changed) &&
364  !parent->pixmap_recreated &&
365  !con->pixmap_recreated &&
366  memcmp(p, con->deco_render_params, sizeof(struct deco_render_params)) == 0) {
367  free(p);
368  goto copy_pixmaps;
369  }
370 
371  Con *next = con;
372  while ((next = TAILQ_NEXT(next, nodes))) {
373  FREE(next->deco_render_params);
374  }
375 
376  FREE(con->deco_render_params);
377  con->deco_render_params = p;
378 
379  if (con->window != NULL && con->window->name_x_changed)
380  con->window->name_x_changed = false;
381 
382  parent->pixmap_recreated = false;
383  con->pixmap_recreated = false;
384 
385  /* 2: draw the client.background, but only for the parts around the client_rect */
386  if (con->window != NULL) {
387  xcb_rectangle_t background[] = {
388  /* top area */
389  {0, 0, r->width, w->y},
390  /* bottom area */
391  {0, (w->y + w->height), r->width, r->height - (w->y + w->height)},
392  /* left area */
393  {0, 0, w->x, r->height},
394  /* right area */
395  {w->x + w->width, 0, r->width - (w->x + w->width), r->height}};
396 #if 0
397  for (int i = 0; i < 4; i++)
398  DLOG("rect is (%d, %d) with %d x %d\n",
399  background[i].x,
400  background[i].y,
401  background[i].width,
402  background[i].height
403  );
404 #endif
405 
406  xcb_change_gc(conn, con->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {config.client.background});
407  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, sizeof(background) / sizeof(xcb_rectangle_t), background);
408  }
409 
410  /* 3: draw a rectangle in border color around the client */
411  if (p->border_style != BS_NONE && p->con_is_leaf) {
412  /* We might hide some borders adjacent to the screen-edge */
413  adjacent_t borders_to_hide = ADJ_NONE;
414  borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders;
415 
417 #if 0
418  DLOG("con->rect spans %d x %d\n", con->rect.width, con->rect.height);
419  DLOG("border_rect spans (%d, %d) with %d x %d\n", br.x, br.y, br.width, br.height);
420  DLOG("window_rect spans (%d, %d) with %d x %d\n", con->window_rect.x, con->window_rect.y, con->window_rect.width, con->window_rect.height);
421 #endif
422 
423  /* These rectangles represents the border around the child window
424  * (left, bottom and right part). We don’t just fill the whole
425  * rectangle because some childs are not freely resizable and we want
426  * their background color to "shine through". */
427  xcb_change_gc(conn, con->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->background});
428  if (!(borders_to_hide & ADJ_LEFT_SCREEN_EDGE)) {
429  xcb_rectangle_t leftline = {0, 0, br.x, r->height};
430  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &leftline);
431  }
432  if (!(borders_to_hide & ADJ_RIGHT_SCREEN_EDGE)) {
433  xcb_rectangle_t rightline = {r->width + br.width + br.x, 0, r->width, r->height};
434  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &rightline);
435  }
436  if (!(borders_to_hide & ADJ_LOWER_SCREEN_EDGE)) {
437  xcb_rectangle_t bottomline = {0, r->height + br.height + br.y, r->width, r->height};
438  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &bottomline);
439  }
440  /* 1pixel border needs an additional line at the top */
441  if (p->border_style == BS_PIXEL && !(borders_to_hide & ADJ_UPPER_SCREEN_EDGE)) {
442  xcb_rectangle_t topline = {br.x, 0, con->rect.width + br.width + br.x, br.y};
443  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &topline);
444  }
445 
446  /* Highlight the side of the border at which the next window will be
447  * opened if we are rendering a single window within a split container
448  * (which is undistinguishable from a single window outside a split
449  * container otherwise. */
450  if (TAILQ_NEXT(con, nodes) == NULL &&
451  TAILQ_PREV(con, nodes_head, nodes) == NULL &&
452  con->parent->type != CT_FLOATING_CON) {
453  xcb_change_gc(conn, con->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->indicator});
454  if (p->parent_layout == L_SPLITH)
455  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, (xcb_rectangle_t[]) {
456  {r->width + br.width + br.x, br.y, r->width, r->height + br.height}});
457  else if (p->parent_layout == L_SPLITV)
458  xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, (xcb_rectangle_t[]) {
459  {br.x, r->height + br.height + br.y, r->width - (2 * br.x), r->height}});
460  }
461  }
462 
463  /* if this is a borderless/1pixel window, we don’t need to render the
464  * decoration. */
465  if (p->border_style != BS_NORMAL)
466  goto copy_pixmaps;
467 
468  /* 4: paint the bar */
469  xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->background});
470  xcb_rectangle_t drect = {con->deco_rect.x, con->deco_rect.y, con->deco_rect.width, con->deco_rect.height};
471  xcb_poly_fill_rectangle(conn, parent->pixmap, parent->pm_gc, 1, &drect);
472 
473  /* 5: draw two unconnected horizontal lines in border color */
474  xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->border});
475  Rect *dr = &(con->deco_rect);
476  int deco_diff_l = 2;
477  int deco_diff_r = 2;
478  if (parent->layout == L_TABBED) {
479  if (TAILQ_PREV(con, nodes_head, nodes) != NULL)
480  deco_diff_l = 0;
481  if (TAILQ_NEXT(con, nodes) != NULL)
482  deco_diff_r = 0;
483  }
484  xcb_segment_t segments[] = {
485  {dr->x, dr->y,
486  dr->x + dr->width - 1, dr->y},
487  {dr->x + deco_diff_l, dr->y + dr->height - 1,
488  dr->x - deco_diff_r + dr->width - 1, dr->y + dr->height - 1}};
489  xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments);
490 
491  /* 6: draw the title */
492  set_font_colors(parent->pm_gc, p->color->text, p->color->background);
493  int text_offset_y = (con->deco_rect.height - config.font.height) / 2;
494 
495  struct Window *win = con->window;
496  if (win == NULL) {
497  /* we have a split container which gets a representation
498  * of its children as title
499  */
500  char *title;
501  char *tree = con_get_tree_representation(con);
502  sasprintf(&title, "i3: %s", tree);
503  free(tree);
504 
505  draw_text_ascii(title,
506  parent->pixmap, parent->pm_gc,
507  con->deco_rect.x + 2, con->deco_rect.y + text_offset_y,
508  con->deco_rect.width - 2);
509  free(title);
510 
511  goto after_title;
512  }
513 
514  if (win->name == NULL)
515  goto copy_pixmaps;
516 
517  int indent_level = 0,
518  indent_mult = 0;
519  Con *il_parent = parent;
520  if (il_parent->layout != L_STACKED) {
521  while (1) {
522  //DLOG("il_parent = %p, layout = %d\n", il_parent, il_parent->layout);
523  if (il_parent->layout == L_STACKED)
524  indent_level++;
525  if (il_parent->type == CT_WORKSPACE || il_parent->type == CT_DOCKAREA || il_parent->type == CT_OUTPUT)
526  break;
527  il_parent = il_parent->parent;
528  indent_mult++;
529  }
530  }
531  //DLOG("indent_level = %d, indent_mult = %d\n", indent_level, indent_mult);
532  int indent_px = (indent_level * 5) * indent_mult;
533 
534  draw_text(win->name,
535  parent->pixmap, parent->pm_gc,
536  con->deco_rect.x + 2 + indent_px, con->deco_rect.y + text_offset_y,
537  con->deco_rect.width - 2 - indent_px);
538 
539 after_title:
540  /* Since we don’t clip the text at all, it might in some cases be painted
541  * on the border pixels on the right side of a window. Therefore, we draw
542  * the right border again after rendering the text (and the unconnected
543  * lines in border color). */
544 
545  /* Draw a 1px separator line before and after every tab, so that tabs can
546  * be easily distinguished. */
547  if (parent->layout == L_TABBED) {
548  xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->border});
549  } else {
550  xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->background});
551  }
552  xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, parent->pixmap, parent->pm_gc, 6,
553  (xcb_point_t[]) {
554  {dr->x + dr->width, dr->y},
555  {dr->x + dr->width, dr->y + dr->height},
556  {dr->x + dr->width - 1, dr->y},
557  {dr->x + dr->width - 1, dr->y + dr->height},
558  {dr->x, dr->y + dr->height},
559  {dr->x, dr->y},
560  });
561 
562  xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) {p->color->border});
563  xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments);
564 
565 copy_pixmaps:
566  xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);
567 }
568 
569 /*
570  * Recursively calls x_draw_decoration. This cannot be done in x_push_node
571  * because x_push_node uses focus order to recurse (see the comment above)
572  * while drawing the decoration needs to happen in the actual order.
573  *
574  */
575 void x_deco_recurse(Con *con) {
576  Con *current;
577  bool leaf = TAILQ_EMPTY(&(con->nodes_head)) &&
578  TAILQ_EMPTY(&(con->floating_head));
579  con_state *state = state_for_frame(con->frame);
580 
581  if (!leaf) {
582  TAILQ_FOREACH (current, &(con->nodes_head), nodes)
583  x_deco_recurse(current);
584 
585  TAILQ_FOREACH (current, &(con->floating_head), floating_windows)
586  x_deco_recurse(current);
587 
588  if (state->mapped)
589  xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);
590  }
591 
592  if ((con->type != CT_ROOT && con->type != CT_OUTPUT) &&
593  (!leaf || con->mapped))
594  x_draw_decoration(con);
595 }
596 
597 /*
598  * This function pushes the properties of each node of the layout tree to
599  * X11 if they have changed (like the map state, position of the window, …).
600  * It recursively traverses all children of the given node.
601  *
602  */
603 void x_push_node(Con *con) {
604  Con *current;
605  con_state *state;
606  Rect rect = con->rect;
607 
608  //DLOG("Pushing changes for node %p / %s\n", con, con->name);
609  state = state_for_frame(con->frame);
610 
611  if (state->name != NULL) {
612  DLOG("pushing name %s for con %p\n", state->name, con);
613 
614  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->frame,
615  XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, strlen(state->name), state->name);
616  FREE(state->name);
617  }
618 
619  if (con->window == NULL) {
620  /* Calculate the height of all window decorations which will be drawn on to
621  * this frame. */
622  uint32_t max_y = 0, max_height = 0;
623  TAILQ_FOREACH (current, &(con->nodes_head), nodes) {
624  Rect *dr = &(current->deco_rect);
625  if (dr->y >= max_y && dr->height >= max_height) {
626  max_y = dr->y;
627  max_height = dr->height;
628  }
629  }
630  rect.height = max_y + max_height;
631  if (rect.height == 0)
632  con->mapped = false;
633  }
634 
635  /* reparent the child window (when the window was moved due to a sticky
636  * container) */
637  if (state->need_reparent && con->window != NULL) {
638  DLOG("Reparenting child window\n");
639 
640  /* Temporarily set the event masks to XCB_NONE so that we won’t get
641  * UnmapNotify events (otherwise the handler would close the container).
642  * These events are generated automatically when reparenting. */
643  uint32_t values[] = {XCB_NONE};
644  xcb_change_window_attributes(conn, state->old_frame, XCB_CW_EVENT_MASK, values);
645  xcb_change_window_attributes(conn, con->window->id, XCB_CW_EVENT_MASK, values);
646 
647  xcb_reparent_window(conn, con->window->id, con->frame, 0, 0);
648 
649  values[0] = FRAME_EVENT_MASK;
650  xcb_change_window_attributes(conn, state->old_frame, XCB_CW_EVENT_MASK, values);
651  values[0] = CHILD_EVENT_MASK;
652  xcb_change_window_attributes(conn, con->window->id, XCB_CW_EVENT_MASK, values);
653 
654  state->old_frame = XCB_NONE;
655  state->need_reparent = false;
656 
657  con->ignore_unmap++;
658  DLOG("ignore_unmap for reparenting of con %p (win 0x%08x) is now %d\n",
659  con, con->window->id, con->ignore_unmap);
660  }
661 
662  bool fake_notify = false;
663  /* Set new position if rect changed (and if height > 0) */
664  if (memcmp(&(state->rect), &rect, sizeof(Rect)) != 0 &&
665  rect.height > 0) {
666  /* We first create the new pixmap, then render to it, set it as the
667  * background and only afterwards change the window size. This reduces
668  * flickering. */
669 
670  /* As the pixmap only depends on the size and not on the position, it
671  * is enough to check if width/height have changed. Also, we don’t
672  * create a pixmap at all when the window is actually not visible
673  * (height == 0) or when it is not needed. */
674  bool has_rect_changed = (state->rect.width != rect.width || state->rect.height != rect.height);
675 
676  /* The pixmap of a borderless leaf container will not be used except
677  * for the titlebar in a stack or tabs (issue #1013). */
678  bool is_pixmap_needed = (con->border_style != BS_NONE ||
679  !con_is_leaf(con) ||
680  con->parent->layout == L_STACKED ||
681  con->parent->layout == L_TABBED);
682 
683  /* Check if the container has an unneeded pixmap left over from
684  * previously having a border or titlebar. */
685  if (!is_pixmap_needed && con->pixmap != XCB_NONE) {
686  xcb_free_pixmap(conn, con->pixmap);
687  con->pixmap = XCB_NONE;
688  }
689 
690  if (has_rect_changed && is_pixmap_needed) {
691  if (con->pixmap == 0) {
692  con->pixmap = xcb_generate_id(conn);
693  con->pm_gc = xcb_generate_id(conn);
694  } else {
695  xcb_free_pixmap(conn, con->pixmap);
696  xcb_free_gc(conn, con->pm_gc);
697  }
698 
699  uint16_t win_depth = root_depth;
700  if (con->window)
701  win_depth = con->window->depth;
702 
703  xcb_create_pixmap(conn, win_depth, con->pixmap, con->frame, rect.width, rect.height);
704 
705  /* For the graphics context, we disable GraphicsExposure events.
706  * Those will be sent when a CopyArea request cannot be fulfilled
707  * properly due to parts of the source being unmapped or otherwise
708  * unavailable. Since we always copy from pixmaps to windows, this
709  * is not a concern for us. */
710  uint32_t values[] = {0};
711  xcb_create_gc(conn, con->pm_gc, con->pixmap, XCB_GC_GRAPHICS_EXPOSURES, values);
712 
713  con->pixmap_recreated = true;
714 
715  /* Don’t render the decoration for windows inside a stack which are
716  * not visible right now */
717  if (!con->parent ||
718  con->parent->layout != L_STACKED ||
719  TAILQ_FIRST(&(con->parent->focus_head)) == con)
720  /* Render the decoration now to make the correct decoration visible
721  * from the very first moment. Later calls will be cached, so this
722  * doesn’t hurt performance. */
723  x_deco_recurse(con);
724  }
725 
726  DLOG("setting rect (%d, %d, %d, %d)\n", rect.x, rect.y, rect.width, rect.height);
727  /* flush to ensure that the following commands are sent in a single
728  * buffer and will be processed directly afterwards (the contents of a
729  * window get lost when resizing it, therefore we want to provide it as
730  * fast as possible) */
731  xcb_flush(conn);
732  xcb_set_window_rect(conn, con->frame, rect);
733  if (con->pixmap != XCB_NONE)
734  xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);
735  xcb_flush(conn);
736 
737  memcpy(&(state->rect), &rect, sizeof(Rect));
738  fake_notify = true;
739  }
740 
741  /* dito, but for child windows */
742  if (con->window != NULL &&
743  memcmp(&(state->window_rect), &(con->window_rect), sizeof(Rect)) != 0) {
744  DLOG("setting window rect (%d, %d, %d, %d)\n",
745  con->window_rect.x, con->window_rect.y, con->window_rect.width, con->window_rect.height);
747  memcpy(&(state->window_rect), &(con->window_rect), sizeof(Rect));
748  fake_notify = true;
749  }
750 
751  /* Map if map state changed, also ensure that the child window
752  * is changed if we are mapped and there is a new, unmapped child window.
753  * Unmaps are handled in x_push_node_unmaps(). */
754  if ((state->mapped != con->mapped || (con->window != NULL && !state->child_mapped)) &&
755  con->mapped) {
756  xcb_void_cookie_t cookie;
757 
758  if (con->window != NULL) {
759  /* Set WM_STATE_NORMAL because GTK applications don’t want to
760  * drag & drop if we don’t. Also, xprop(1) needs it. */
761  long data[] = {XCB_ICCCM_WM_STATE_NORMAL, XCB_NONE};
762  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->window->id,
763  A_WM_STATE, A_WM_STATE, 32, 2, data);
764  }
765 
766  uint32_t values[1];
767  if (!state->child_mapped && con->window != NULL) {
768  cookie = xcb_map_window(conn, con->window->id);
769 
770  /* We are interested in EnterNotifys as soon as the window is
771  * mapped */
772  values[0] = CHILD_EVENT_MASK;
773  xcb_change_window_attributes(conn, con->window->id, XCB_CW_EVENT_MASK, values);
774  DLOG("mapping child window (serial %d)\n", cookie.sequence);
775  state->child_mapped = true;
776  }
777 
778  cookie = xcb_map_window(conn, con->frame);
779 
780  values[0] = FRAME_EVENT_MASK;
781  xcb_change_window_attributes(conn, con->frame, XCB_CW_EVENT_MASK, values);
782 
783  /* copy the pixmap contents to the frame window immediately after mapping */
784  if (con->pixmap != XCB_NONE)
785  xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);
786  xcb_flush(conn);
787 
788  DLOG("mapping container %08x (serial %d)\n", con->frame, cookie.sequence);
789  state->mapped = con->mapped;
790  }
791 
792  state->unmap_now = (state->mapped != con->mapped) && !con->mapped;
793 
794  if (fake_notify) {
795  DLOG("Sending fake configure notify\n");
797  }
798 
799  /* Handle all children and floating windows of this node. We recurse
800  * in focus order to display the focused client in a stack first when
801  * switching workspaces (reduces flickering). */
802  TAILQ_FOREACH (current, &(con->focus_head), focused)
803  x_push_node(current);
804 }
805 
806 /*
807  * Same idea as in x_push_node(), but this function only unmaps windows. It is
808  * necessary to split this up to handle new fullscreen clients properly: The
809  * new window needs to be mapped and focus needs to be set *before* the
810  * underlying windows are unmapped. Otherwise, focus will revert to the
811  * PointerRoot and will then be set to the new window, generating unnecessary
812  * FocusIn/FocusOut events.
813  *
814  */
815 static void x_push_node_unmaps(Con *con) {
816  Con *current;
817  con_state *state;
818 
819  //DLOG("Pushing changes (with unmaps) for node %p / %s\n", con, con->name);
820  state = state_for_frame(con->frame);
821 
822  /* map/unmap if map state changed, also ensure that the child window
823  * is changed if we are mapped *and* in initial state (meaning the
824  * container was empty before, but now got a child) */
825  if (state->unmap_now) {
826  xcb_void_cookie_t cookie;
827  if (con->window != NULL) {
828  /* Set WM_STATE_WITHDRAWN, it seems like Java apps need it */
829  long data[] = {XCB_ICCCM_WM_STATE_WITHDRAWN, XCB_NONE};
830  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->window->id,
831  A_WM_STATE, A_WM_STATE, 32, 2, data);
832  }
833 
834  cookie = xcb_unmap_window(conn, con->frame);
835  DLOG("unmapping container %p / %s (serial %d)\n", con, con->name, cookie.sequence);
836  /* we need to increase ignore_unmap for this container (if it
837  * contains a window) and for every window "under" this one which
838  * contains a window */
839  if (con->window != NULL) {
840  con->ignore_unmap++;
841  DLOG("ignore_unmap for con %p (frame 0x%08x) now %d\n", con, con->frame, con->ignore_unmap);
842  }
843  state->mapped = con->mapped;
844  }
845 
846  /* handle all children and floating windows of this node */
847  TAILQ_FOREACH (current, &(con->nodes_head), nodes)
848  x_push_node_unmaps(current);
849 
850  TAILQ_FOREACH (current, &(con->floating_head), floating_windows)
851  x_push_node_unmaps(current);
852 }
853 
854 /*
855  * Returns true if the given container is currently attached to its parent.
856  *
857  * TODO: Remove once #1185 has been fixed
858  */
859 static bool is_con_attached(Con *con) {
860  if (con->parent == NULL)
861  return false;
862 
863  Con *current;
864  TAILQ_FOREACH (current, &(con->parent->nodes_head), nodes) {
865  if (current == con)
866  return true;
867  }
868 
869  return false;
870 }
871 
872 /*
873  * Pushes all changes (state of each node, see x_push_node() and the window
874  * stack) to X11.
875  *
876  * NOTE: We need to push the stack first so that the windows have the correct
877  * stacking order. This is relevant for workspace switching where we map the
878  * windows because mapping may generate EnterNotify events. When they are
879  * generated in the wrong order, this will cause focus problems when switching
880  * workspaces.
881  *
882  */
883 void x_push_changes(Con *con) {
884  con_state *state;
885  xcb_query_pointer_cookie_t pointercookie;
886 
887  /* If we need to warp later, we request the pointer position as soon as possible */
888  if (warp_to) {
889  pointercookie = xcb_query_pointer(conn, root);
890  }
891 
892  DLOG("-- PUSHING WINDOW STACK --\n");
893  //DLOG("Disabling EnterNotify\n");
894  uint32_t values[1] = {XCB_NONE};
895  CIRCLEQ_FOREACH_REVERSE (state, &state_head, state) {
896  if (state->mapped)
897  xcb_change_window_attributes(conn, state->id, XCB_CW_EVENT_MASK, values);
898  }
899  //DLOG("Done, EnterNotify disabled\n");
900  bool order_changed = false;
901  bool stacking_changed = false;
902 
903  /* count first, necessary to (re)allocate memory for the bottom-to-top
904  * stack afterwards */
905  int cnt = 0;
906  CIRCLEQ_FOREACH_REVERSE (state, &state_head, state)
907  if (con_has_managed_window(state->con))
908  cnt++;
909 
910  /* The bottom-to-top window stack of all windows which are managed by i3.
911  * Used for x_get_window_stack(). */
912  static xcb_window_t *client_list_windows = NULL;
913  static int client_list_count = 0;
914 
915  if (cnt != client_list_count) {
916  client_list_windows = srealloc(client_list_windows, sizeof(xcb_window_t) * cnt);
917  client_list_count = cnt;
918  }
919 
920  xcb_window_t *walk = client_list_windows;
921 
922  /* X11 correctly represents the stack if we push it from bottom to top */
923  CIRCLEQ_FOREACH_REVERSE (state, &state_head, state) {
924  if (con_has_managed_window(state->con))
925  memcpy(walk++, &(state->con->window->id), sizeof(xcb_window_t));
926 
927  //DLOG("stack: 0x%08x\n", state->id);
928  con_state *prev = CIRCLEQ_PREV(state, state);
929  con_state *old_prev = CIRCLEQ_PREV(state, old_state);
930  if (prev != old_prev)
931  order_changed = true;
932  if ((state->initial || order_changed) && prev != CIRCLEQ_END(&state_head)) {
933  stacking_changed = true;
934  //DLOG("Stacking 0x%08x above 0x%08x\n", prev->id, state->id);
935  uint32_t mask = 0;
936  mask |= XCB_CONFIG_WINDOW_SIBLING;
937  mask |= XCB_CONFIG_WINDOW_STACK_MODE;
938  uint32_t values[] = {state->id, XCB_STACK_MODE_ABOVE};
939 
940  xcb_configure_window(conn, prev->id, mask, values);
941  }
942  state->initial = false;
943  }
944 
945  /* If we re-stacked something (or a new window appeared), we need to update
946  * the _NET_CLIENT_LIST and _NET_CLIENT_LIST_STACKING hints */
947  if (stacking_changed) {
948  DLOG("Client list changed (%i clients)\n", cnt);
949  ewmh_update_client_list_stacking(client_list_windows, client_list_count);
950 
951  walk = client_list_windows;
952 
953  /* reorder by initial mapping */
954  TAILQ_FOREACH (state, &initial_mapping_head, initial_mapping_order) {
955  if (con_has_managed_window(state->con))
956  *walk++ = state->con->window->id;
957  }
958 
959  ewmh_update_client_list(client_list_windows, client_list_count);
960  }
961 
962  DLOG("PUSHING CHANGES\n");
963  x_push_node(con);
964 
965  if (warp_to) {
966  xcb_query_pointer_reply_t *pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL);
967  if (!pointerreply) {
968  ELOG("Could not query pointer position, not warping pointer\n");
969  } else {
970  int mid_x = warp_to->x + (warp_to->width / 2);
971  int mid_y = warp_to->y + (warp_to->height / 2);
972 
973  Output *current = get_output_containing(pointerreply->root_x, pointerreply->root_y);
974  Output *target = get_output_containing(mid_x, mid_y);
975  if (current != target) {
976  /* Ignore MotionNotify events generated by warping */
977  xcb_change_window_attributes(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]) {XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT});
978  xcb_warp_pointer(conn, XCB_NONE, root, 0, 0, 0, 0, mid_x, mid_y);
979  xcb_change_window_attributes(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]) {ROOT_EVENT_MASK});
980  }
981  }
982  warp_to = NULL;
983  }
984 
985  //DLOG("Re-enabling EnterNotify\n");
986  values[0] = FRAME_EVENT_MASK;
987  CIRCLEQ_FOREACH_REVERSE (state, &state_head, state) {
988  if (state->mapped)
989  xcb_change_window_attributes(conn, state->id, XCB_CW_EVENT_MASK, values);
990  }
991  //DLOG("Done, EnterNotify re-enabled\n");
992 
993  x_deco_recurse(con);
994 
995  xcb_window_t to_focus = focused->frame;
996  if (focused->window != NULL)
997  to_focus = focused->window->id;
998 
999  if (focused_id != to_focus) {
1000  if (!focused->mapped) {
1001  DLOG("Not updating focus (to %p / %s), focused window is not mapped.\n", focused, focused->name);
1002  /* Invalidate focused_id to correctly focus new windows with the same ID */
1003  focused_id = XCB_NONE;
1004  } else {
1005  if (focused->window != NULL &&
1008  DLOG("Updating focus by sending WM_TAKE_FOCUS to window 0x%08x (focused: %p / %s)\n",
1009  to_focus, focused, focused->name);
1010  send_take_focus(to_focus, last_timestamp);
1011 
1013 
1014  if (to_focus != last_focused && is_con_attached(focused))
1015  ipc_send_window_event("focus", focused);
1016  } else {
1017  DLOG("Updating focus (focused: %p / %s) to X11 window 0x%08x\n", focused, focused->name, to_focus);
1018  /* We remove XCB_EVENT_MASK_FOCUS_CHANGE from the event mask to get
1019  * no focus change events for our own focus changes. We only want
1020  * these generated by the clients. */
1021  if (focused->window != NULL) {
1022  values[0] = CHILD_EVENT_MASK & ~(XCB_EVENT_MASK_FOCUS_CHANGE);
1023  xcb_change_window_attributes(conn, focused->window->id, XCB_CW_EVENT_MASK, values);
1024  }
1025  xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, to_focus, last_timestamp);
1026  if (focused->window != NULL) {
1027  values[0] = CHILD_EVENT_MASK;
1028  xcb_change_window_attributes(conn, focused->window->id, XCB_CW_EVENT_MASK, values);
1029  }
1030 
1032 
1033  if (to_focus != XCB_NONE && to_focus != last_focused && focused->window != NULL && is_con_attached(focused))
1034  ipc_send_window_event("focus", focused);
1035  }
1036 
1038  }
1039  }
1040 
1041  if (focused_id == XCB_NONE) {
1042  DLOG("Still no window focused, better set focus to the root window\n");
1043  xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, root, last_timestamp);
1044  ewmh_update_active_window(XCB_WINDOW_NONE);
1045  focused_id = root;
1046  }
1047 
1048  xcb_flush(conn);
1049  DLOG("ENDING CHANGES\n");
1050 
1051  /* Disable EnterWindow events for windows which will be unmapped in
1052  * x_push_node_unmaps() now. Unmapping windows happens when switching
1053  * workspaces. We want to avoid getting EnterNotifies during that phase
1054  * because they would screw up our focus. One of these cases is having a
1055  * stack with two windows. If the first window is focused and gets
1056  * unmapped, the second one appears under the cursor and therefore gets an
1057  * EnterNotify event. */
1058  values[0] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW;
1059  CIRCLEQ_FOREACH_REVERSE (state, &state_head, state) {
1060  if (!state->unmap_now)
1061  continue;
1062  xcb_change_window_attributes(conn, state->id, XCB_CW_EVENT_MASK, values);
1063  }
1064 
1065  /* Push all pending unmaps */
1066  x_push_node_unmaps(con);
1067 
1068  /* save the current stack as old stack */
1069  CIRCLEQ_FOREACH (state, &state_head, state) {
1070  CIRCLEQ_REMOVE(&old_state_head, state, old_state);
1071  CIRCLEQ_INSERT_TAIL(&old_state_head, state, old_state);
1072  }
1073  //CIRCLEQ_FOREACH(state, &old_state_head, old_state) {
1074  // DLOG("old stack: 0x%08x\n", state->id);
1075  //}
1076 
1077  xcb_flush(conn);
1078 }
1079 
1080 /*
1081  * Raises the specified container in the internal stack of X windows. The
1082  * next call to x_push_changes() will make the change visible in X11.
1083  *
1084  */
1085 void x_raise_con(Con *con) {
1086  con_state *state;
1087  state = state_for_frame(con->frame);
1088  //DLOG("raising in new stack: %p / %s / %s / xid %08x\n", con, con->name, con->window ? con->window->name_json : "", state->id);
1089 
1090  CIRCLEQ_REMOVE(&state_head, state, state);
1091  CIRCLEQ_INSERT_HEAD(&state_head, state, state);
1092 }
1093 
1094 /*
1095  * Sets the WM_NAME property (so, no UTF8, but used only for debugging anyways)
1096  * of the given name. Used for properly tagging the windows for easily spotting
1097  * i3 windows in xwininfo -root -all.
1098  *
1099  */
1100 void x_set_name(Con *con, const char *name) {
1101  struct con_state *state;
1102 
1103  if ((state = state_for_frame(con->frame)) == NULL) {
1104  ELOG("window state not found\n");
1105  return;
1106  }
1107 
1108  FREE(state->name);
1109  state->name = sstrdup(name);
1110 }
1111 
1112 /*
1113  * Set up the I3_SHMLOG_PATH atom.
1114  *
1115  */
1117  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root,
1118  A_I3_SHMLOG_PATH, A_UTF8_STRING, 8,
1119  strlen(shmlogname), shmlogname);
1120 }
1121 
1122 /*
1123  * Sets up i3 specific atoms (I3_SOCKET_PATH and I3_CONFIG_PATH)
1124  *
1125  */
1126 void x_set_i3_atoms(void) {
1127  pid_t pid = getpid();
1128  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_SOCKET_PATH, A_UTF8_STRING, 8,
1129  (current_socketpath == NULL ? 0 : strlen(current_socketpath)),
1131  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_PID, XCB_ATOM_CARDINAL, 32, 1, &pid);
1132  xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_CONFIG_PATH, A_UTF8_STRING, 8,
1135 }
1136 
1137 /*
1138  * Set warp_to coordinates. This will trigger on the next call to
1139  * x_push_changes().
1140  *
1141  */
1145  warp_to = rect;
1146 }
1147 
1148 /*
1149  * Applies the given mask to the event mask of every i3 window decoration X11
1150  * window. This is useful to disable EnterNotify while resizing so that focus
1151  * is untouched.
1152  *
1153  */
1154 void x_mask_event_mask(uint32_t mask) {
1155  uint32_t values[] = {FRAME_EVENT_MASK & mask};
1156 
1157  con_state *state;
1158  CIRCLEQ_FOREACH_REVERSE (state, &state_head, state) {
1159  if (state->mapped)
1160  xcb_change_window_attributes(conn, state->id, XCB_CW_EVENT_MASK, values);
1161  }
1162 }
Definition: data.h:87
void ewmh_update_client_list_stacking(xcb_window_t *stack, int num_windows)
Updates the _NET_CLIENT_LIST_STACKING hint.
Definition: ewmh.c:94
struct Con * parent
Definition: data.h:512
void x_mask_event_mask(uint32_t mask)
Applies the given mask to the event mask of every i3 window decoration X11 window.
Definition: x.c:1154
#define CIRCLEQ_INSERT_HEAD(head, elm, field)
Definition: queue.h:489
char * sstrdup(const char *str)
Safe-wrapper around strdup which exits if malloc returns NULL (meaning that there is no more memory a...
bool mapped
Definition: x.c:36
bool mapped
Definition: data.h:480
bool pixmap_recreated
Definition: data.h:494
bool urgent
Definition: data.h:484
Con * con
The con for which this state is.
Definition: x.c:41
Definition: data.h:56
#define CHILD_EVENT_MASK
The XCB_CW_EVENT_MASK for the child (= real window)
Definition: xcb.h:33
uint8_t ignore_unmap
This counter contains the number of UnmapNotify events for this container (or, more precisely...
Definition: data.h:491
uint32_t y
Definition: data.h:124
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:386
uint32_t height
Definition: data.h:33
Config config
Definition: config.c:19
xcb_connection_t * conn
Definition: main.c:47
#define ROOT_EVENT_MASK
Definition: xcb.h:47
xcb_gcontext_t pm_gc
Definition: data.h:497
bool disable_focus_follows_mouse
By default, focus follows mouse.
Definition: config.h:110
i3Font font
Definition: config.h:92
void x_reinit(Con *con)
Re-initializes the associated X window state for this container.
Definition: x.c:166
bool needs_take_focus
Whether the application needs to receive WM_TAKE_FOCUS.
Definition: data.h:363
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
static xcb_window_t last_focused
Definition: x.c:21
#define CIRCLEQ_PREV(elm, field)
Definition: queue.h:447
Definition: data.h:56
bool window_supports_protocol(xcb_window_t window, xcb_atom_t atom)
Returns true if the client supports the given protocol atom (like WM_DELETE_WINDOW) ...
Definition: x.c:249
struct Rect window_rect
Definition: data.h:515
#define xcb_icccm_get_wm_protocols_reply
Definition: xcb_compat.h:17
#define CIRCLEQ_FOREACH(var, head, field)
Definition: queue.h:451
struct Rect rect
Definition: data.h:514
void x_push_node(Con *con)
This function pushes the properties of each node of the layout tree to X11 if they have changed (like...
Definition: x.c:603
xcb_screen_t * root_screen
Definition: main.c:59
struct width_height con_rect
Definition: data.h:160
uint16_t depth
Depth of the window.
Definition: data.h:379
#define TAILQ_FIRST(head)
Definition: queue.h:323
static Con * to_focus
Definition: load_layout.c:24
#define xcb_icccm_get_wm_protocols_reply_wipe
Definition: xcb_compat.h:18
struct Window * window
Definition: data.h:547
void x_reparent_child(Con *con, Con *old)
Reparents the child window of the given container (necessary for sticky containers).
Definition: x.c:186
void x_deco_recurse(Con *con)
Recursively calls x_draw_decoration.
Definition: x.c:575
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
char * shmlogname
Definition: log.c:44
#define FRAME_EVENT_MASK
The XCB_CW_EVENT_MASK for its frame.
Definition: xcb.h:38
struct Config::config_client client
void x_window_kill(xcb_window_t window, kill_window_t kill_window)
Kills the given X11 window using WM_DELETE_WINDOW (if supported).
Definition: x.c:272
bool name_x_changed
Flag to force re-rendering the decoration upon changes.
Definition: data.h:357
struct Colortriple unfocused
Definition: config.h:191
static bool is_con_attached(Con *con)
Definition: x.c:859
An Output is a physical output on your graphics driver.
Definition: data.h:301
void send_take_focus(xcb_window_t window, xcb_timestamp_t timestamp)
Sends the WM_TAKE_FOCUS ClientMessage to the given window.
Definition: xcb.c:113
Stores the parameters for rendering a window decoration.
Definition: data.h:157
#define TAILQ_NEXT(elm, field)
Definition: queue.h:325
border_style_t border_style
Definition: data.h:579
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
void x_set_warp_to(Rect *rect)
Set warp_to coordinates.
Definition: x.c:1142
void ewmh_update_client_list(xcb_window_t *list, int num_windows)
Updates the _NET_CLIENT_LIST hint.
Definition: ewmh.c:78
uint32_t background
Definition: data.h:163
char * con_get_tree_representation(Con *con)
Create a string representing the subtree under con.
Definition: con.c:1614
enum Con::@18 type
#define DLOG(fmt,...)
Definition: libi3.h:86
static Rect * warp_to
Definition: x.c:24
static cmdp_state state
#define xcb_icccm_get_wm_protocols_reply_t
Definition: xcb_compat.h:14
xcb_colormap_t colormap
Definition: main.c:67
#define CIRCLEQ_END(head)
Definition: queue.h:445
Rect rect
Definition: x.c:49
int sasprintf(char **strp, const char *fmt,...)
Safe-wrapper around asprintf which exits if it returns -1 (meaning that there is no more memory avail...
Definition: data.h:86
CIRCLEQ_HEAD(state_head, con_state)
Definition: x.c:61
#define XCB_ICCCM_WM_STATE_WITHDRAWN
Definition: xcb_compat.h:20
struct Rect deco_rect
Definition: data.h:516
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: x.c:34
int border_style
Definition: data.h:159
uint8_t root_depth
Definition: main.c:65
void x_move_win(Con *src, Con *dest)
Moves a child window from Container src to Container dest.
Definition: x.c:201
bool con_is_leaf(Con *con)
Returns true when this node is a leaf node (has no children)
Definition: con.c:241
bool con_has_managed_window(Con *con)
Returns true when this con is a leaf node with a managed X11 window (e.g., excluding dock containers)...
Definition: con.c:249
uint32_t height
Definition: data.h:126
struct deco_render_params * deco_render_params
Cache for the decoration rendering.
Definition: data.h:553
Rect window_rect
Definition: x.c:50
#define CIRCLEQ_ENTRY(type)
Definition: queue.h:434
Con * focused
Definition: tree.c:15
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
uint32_t background
Definition: config.h:188
bool con_is_leaf
Definition: data.h:165
char * name
Definition: data.h:520
warping_t mouse_warping
By default, when switching focus to a window on a different output (e.g.
Definition: config.h:120
Definition: data.h:91
void xcb_set_window_rect(xcb_connection_t *conn, xcb_window_t window, Rect r)
Configures the given window to have the size/position specified by given rect.
Definition: xcb.c:145
int height
The height of the font, built from font_ascent + font_descent.
Definition: libi3.h:47
void draw_text(i3String *text, xcb_drawable_t drawable, xcb_gcontext_t gc, int x, int y, int max_width)
Draws text onto the specified X drawable (normally a pixmap) at the specified coordinates (from the t...
void x_set_name(Con *con, const char *name)
Sets the WM_NAME property (so, no UTF8, but used only for debugging anyways) of the given name...
Definition: x.c:1100
#define TAILQ_EMPTY(head)
Definition: queue.h:331
adjacent_t con_adjacent_borders(Con *con)
Returns adjacent borders of the window.
Definition: con.c:1140
struct width_height con_window_rect
Definition: data.h:161
struct Colortriple focused
Definition: config.h:189
adjacent_t hide_edge_borders
Remove borders if they are adjacent to the screen edge.
Definition: config.h:126
#define TAILQ_PREV(elm, headname, field)
Definition: queue.h:329
#define TAILQ_ENTRY(type)
Definition: queue.h:314
#define ELOG(fmt,...)
Definition: libi3.h:81
char * current_configpath
Definition: config.c:18
void draw_text_ascii(const char *text, xcb_drawable_t drawable, xcb_gcontext_t gc, int x, int y, int max_width)
ASCII version of draw_text to print static strings.
xcb_visualid_t get_visualid_by_depth(uint16_t depth)
Get visualid with specified depth.
Definition: xcb.c:231
xcb_window_t create_window(xcb_connection_t *conn, Rect dims, uint16_t depth, xcb_visualid_t visual, uint16_t window_class, enum xcursor_cursor_t cursor, bool map, uint32_t mask, uint32_t *values)
Convenience wrapper around xcb_create_window which takes care of depth, generating an ID and checking...
Definition: xcb.c:21
void x_draw_decoration(Con *con)
Draws the decoration of the given container onto its parent.
Definition: x.c:308
layout_t layout
Definition: data.h:578
Stores a width/height pair, used as part of deco_render_params to check whether the rects width/heigh...
Definition: data.h:146
struct Colortriple urgent
Definition: config.h:192
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
bool need_reparent
Definition: x.c:46
void * scalloc(size_t size)
Safe-wrapper around calloc which exits if malloc returns NULL (meaning that there is no more memory a...
#define CIRCLEQ_FOREACH_REVERSE(var, head, field)
Definition: queue.h:456
char * current_socketpath
Definition: ipc.c:23
static void x_push_node_unmaps(Con *con)
Definition: x.c:815
#define CIRCLEQ_REMOVE(head, elm, field)
Definition: queue.h:509
xcb_window_t frame
Definition: data.h:495
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
bool con_inside_focused(Con *con)
Checks if the given container is inside a focused container.
Definition: con.c:448
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
void set_font_colors(xcb_gcontext_t gc, uint32_t foreground, uint32_t background)
Defines the colors to be used for the forthcoming draw_text calls.
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:362
int con_border_style(Con *con)
Use this function to get a container’s border style.
Definition: con.c:1164
xcb_window_t root
Definition: main.c:60
adjacent_t
describes if the window is adjacent to the output (physical screen) edges.
Definition: data.h:63
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:311
Definition: data.h:63
struct Colortriple focused_inactive
Definition: config.h:190
uint32_t y
Definition: data.h:31
bool child_mapped
Definition: x.c:38
i3String * name
The name of the window.
Definition: data.h:349
#define xcb_icccm_get_wm_protocols
Definition: xcb_compat.h:15
xcb_window_t id
Definition: data.h:333
#define CIRCLEQ_HEAD_INITIALIZER(head)
Definition: queue.h:431
bool unmap_now
Definition: x.c:37
void x_set_i3_atoms(void)
Sets up i3 specific atoms (I3_SOCKET_PATH and I3_CONFIG_PATH)
Definition: x.c:1126
void update_shmlog_atom()
Set up the SHMLOG_PATH atom.
Definition: x.c:1116
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:334
#define XCB_ATOM_WM_NAME
Definition: xcb_compat.h:42
bool doesnt_accept_focus
Whether this window accepts focus.
Definition: data.h:367
char * name
Definition: x.c:54
Rect con_deco_rect
Definition: data.h:162
xcb_pixmap_t pixmap
Definition: data.h:496
void * srealloc(void *ptr, size_t size)
Safe-wrapper around realloc which exits if realloc returns NULL (meaning that there is no more memory...
void ewmh_update_active_window(xcb_window_t window)
Updates _NET_ACTIVE_WINDOW with the currently focused window.
Definition: ewmh.c:50
xcb_window_t id
Definition: x.c:35
struct Colortriple * color
Definition: data.h:158
xcb_window_t old_frame
Definition: x.c:47
uint32_t x
Definition: data.h:30
bool initial
Definition: x.c:52
#define FREE(pointer)
Definition: util.h:46
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 CIRCLEQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:499
layout_t parent_layout
Definition: data.h:164
Definition: data.h:56
#define TAILQ_HEAD(name, type)
Definition: queue.h:305
#define XCB_ICCCM_WM_STATE_NORMAL
Definition: xcb_compat.h:19
void x_con_kill(Con *con)
Kills the window decoration associated with the given container.
Definition: x.c:228
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
#define XCB_ATOM_STRING
Definition: xcb_compat.h:47
kill_window_t
parameter to specify whether tree_close() and x_window_kill() should kill only this specific window o...
Definition: data.h:60
uint32_t width
Definition: data.h:125
Definition: data.h:90
void x_raise_con(Con *con)
Raises the specified container in the internal stack of X windows.
Definition: x.c:1085
void x_con_init(Con *con, uint16_t depth)
Initializes the X11 part for the given container.
Definition: x.c:94