i3
render.c
Go to the documentation of this file.
1 #undef I3__FILE__
2 #define I3__FILE__ "render.c"
3 /*
4  * vim:ts=4:sw=4:expandtab
5  *
6  * i3 - an improved dynamic tiling window manager
7  * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
8  *
9  * render.c: Renders (determines position/sizes) the layout tree, updating the
10  * various rects. Needs to be pushed to X11 (see x.c) to be visible.
11  *
12  */
13 #include "all.h"
14 
15 /* change this to 'true' if you want to have additional borders around every
16  * container (for debugging purposes) */
17 static bool show_debug_borders = false;
18 
19 /*
20  * Renders a container with layout L_OUTPUT. In this layout, all CT_DOCKAREAs
21  * get the height of their content and the remaining CT_CON gets the rest.
22  *
23  */
24 static void render_l_output(Con *con) {
25  Con *child, *dockchild;
26 
27  int x = con->rect.x;
28  int y = con->rect.y;
29  int height = con->rect.height;
30 
31  /* Find the content container and ensure that there is exactly one. Also
32  * check for any non-CT_DOCKAREA clients. */
33  Con *content = NULL;
34  TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
35  if (child->type == CT_CON) {
36  if (content != NULL) {
37  DLOG("More than one CT_CON on output container\n");
38  assert(false);
39  }
40  content = child;
41  } else if (child->type != CT_DOCKAREA) {
42  DLOG("Child %p of type %d is inside the OUTPUT con\n", child, child->type);
43  assert(false);
44  }
45  }
46 
47  assert(content != NULL);
48 
49  /* We need to find out if there is a fullscreen con on the current workspace
50  * and take the short-cut to render it directly (the user does not want to
51  * see the dockareas in that case) */
52  Con *ws = con_get_fullscreen_con(content, CF_OUTPUT);
53  Con *fullscreen = con_get_fullscreen_con(ws, CF_OUTPUT);
54  if (fullscreen) {
55  fullscreen->rect = con->rect;
56  x_raise_con(fullscreen);
57  render_con(fullscreen, true);
58  return;
59  }
60 
61  /* First pass: determine the height of all CT_DOCKAREAs (the sum of their
62  * children) and figure out how many pixels we have left for the rest */
63  TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
64  if (child->type != CT_DOCKAREA)
65  continue;
66 
67  child->rect.height = 0;
68  TAILQ_FOREACH(dockchild, &(child->nodes_head), nodes)
69  child->rect.height += dockchild->geometry.height;
70 
71  height -= child->rect.height;
72  }
73 
74  /* Second pass: Set the widths/heights */
75  TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
76  if (child->type == CT_CON) {
77  child->rect.x = x;
78  child->rect.y = y;
79  child->rect.width = con->rect.width;
80  child->rect.height = height;
81  }
82 
83  child->rect.x = x;
84  child->rect.y = y;
85  child->rect.width = con->rect.width;
86 
87  child->deco_rect.x = 0;
88  child->deco_rect.y = 0;
89  child->deco_rect.width = 0;
90  child->deco_rect.height = 0;
91 
92  y += child->rect.height;
93 
94  DLOG("child at (%d, %d) with (%d x %d)\n",
95  child->rect.x, child->rect.y, child->rect.width, child->rect.height);
96  x_raise_con(child);
97  render_con(child, false);
98  }
99 }
100 
101 /*
102  * "Renders" the given container (and its children), meaning that all rects are
103  * updated correctly. Note that this function does not call any xcb_*
104  * functions, so the changes are completely done in memory only (and
105  * side-effect free). As soon as you call x_push_changes(), the changes will be
106  * updated in X11.
107  *
108  */
109 void render_con(Con *con, bool render_fullscreen) {
110  int children = con_num_children(con);
111  DLOG("Rendering %snode %p / %s / layout %d / children %d\n",
112  (render_fullscreen ? "fullscreen " : ""), con, con->name, con->layout,
113  children);
114 
115  /* Copy container rect, subtract container border */
116  /* This is the actually usable space inside this container for clients */
117  Rect rect = con->rect;
118 
119  /* Display a border if this is a leaf node. For container nodes, we don’t
120  * draw borders (except when in debug mode) */
121  if (show_debug_borders) {
122  rect.x += 2;
123  rect.y += 2;
124  rect.width -= 2 * 2;
125  rect.height -= 2 * 2;
126  }
127 
128  int x = rect.x;
129  int y = rect.y;
130 
131  int i = 0;
132 
133  con->mapped = true;
134 
135  /* if this container contains a window, set the coordinates */
136  if (con->window) {
137  /* depending on the border style, the rect of the child window
138  * needs to be smaller */
139  Rect *inset = &(con->window_rect);
140  *inset = (Rect){0, 0, con->rect.width, con->rect.height};
141  if (!render_fullscreen)
142  *inset = rect_add(*inset, con_border_style_rect(con));
143 
144  /* Obey x11 border */
145  inset->width -= (2 * con->border_width);
146  inset->height -= (2 * con->border_width);
147 
148  /* Obey the aspect ratio, if any, unless we are in fullscreen mode.
149  *
150  * The spec isn’t explicit on whether the aspect ratio hints should be
151  * respected during fullscreen mode. Other WMs such as Openbox don’t do
152  * that, and this post suggests that this is the correct way to do it:
153  * http://mail.gnome.org/archives/wm-spec-list/2003-May/msg00007.html
154  *
155  * Ignoring aspect ratio during fullscreen was necessary to fix MPlayer
156  * subtitle rendering, see http://bugs.i3wm.org/594 */
157  if (!render_fullscreen &&
158  con->proportional_height != 0 &&
159  con->proportional_width != 0) {
160  double new_height = inset->height + 1;
161  int new_width = inset->width;
162 
163  while (new_height > inset->height) {
164  new_height = ((double)con->proportional_height / con->proportional_width) * new_width;
165 
166  if (new_height > inset->height)
167  new_width--;
168  }
169  /* Center the window */
170  inset->y += ceil(inset->height / 2) - floor(new_height / 2);
171  inset->x += ceil(inset->width / 2) - floor(new_width / 2);
172 
173  inset->height = new_height;
174  inset->width = new_width;
175  }
176 
177  /* NB: We used to respect resize increment size hints for tiling
178  * windows up until commit 0db93d9 here. However, since all terminal
179  * emulators cope with ignoring the size hints in a better way than we
180  * can (by providing their fake-transparency or background color), this
181  * code was removed. See also http://bugs.i3wm.org/540 */
182 
183  DLOG("child will be at %dx%d with size %dx%d\n", inset->x, inset->y, inset->width, inset->height);
184  }
185 
186  /* Check for fullscreen nodes */
187  Con *fullscreen = NULL;
188  if (con->type != CT_OUTPUT) {
189  fullscreen = con_get_fullscreen_con(con, (con->type == CT_ROOT ? CF_GLOBAL : CF_OUTPUT));
190  }
191  if (fullscreen) {
192  fullscreen->rect = rect;
193  x_raise_con(fullscreen);
194  render_con(fullscreen, true);
195  return;
196  }
197 
198  /* find the height for the decorations */
199  int deco_height = config.font.height + 4;
200  if (config.font.height & 0x01)
201  ++deco_height;
202 
203  /* precalculate the sizes to be able to correct rounding errors */
204  int sizes[children];
205  if ((con->layout == L_SPLITH || con->layout == L_SPLITV) && children > 0) {
206  assert(!TAILQ_EMPTY(&con->nodes_head));
207  Con *child;
208  int i = 0, assigned = 0;
209  int total = con_orientation(con) == HORIZ ? rect.width : rect.height;
210  TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
211  double percentage = child->percent > 0.0 ? child->percent : 1.0 / children;
212  assigned += sizes[i++] = percentage * total;
213  }
214  assert(assigned == total ||
215  (assigned > total && assigned - total <= children * 2) ||
216  (assigned < total && total - assigned <= children * 2));
217  int signal = assigned < total ? 1 : -1;
218  while (assigned != total) {
219  for (i = 0; i < children && assigned != total; ++i) {
220  sizes[i] += signal;
221  assigned += signal;
222  }
223  }
224  }
225 
226  if (con->layout == L_OUTPUT) {
227  /* Skip i3-internal outputs */
228  if (con_is_internal(con))
229  return;
230  render_l_output(con);
231  } else if (con->type == CT_ROOT) {
232  Con *output;
233  TAILQ_FOREACH(output, &(con->nodes_head), nodes) {
234  render_con(output, false);
235  }
236 
237  /* We need to render floating windows after rendering all outputs’
238  * tiling windows because they need to be on top of *every* output at
239  * all times. This is important when the user places floating
240  * windows/containers so that they overlap on another output. */
241  DLOG("Rendering floating windows:\n");
242  TAILQ_FOREACH(output, &(con->nodes_head), nodes) {
243  if (con_is_internal(output))
244  continue;
245  /* Get the active workspace of that output */
246  Con *content = output_get_content(output);
247  Con *workspace = TAILQ_FIRST(&(content->focus_head));
248  Con *fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
249  Con *child;
250  TAILQ_FOREACH(child, &(workspace->floating_head), floating_windows) {
251  /* Don’t render floating windows when there is a fullscreen window
252  * on that workspace. Necessary to make floating fullscreen work
253  * correctly (ticket #564). */
254  if (fullscreen != NULL) {
255  Con *floating_child = con_descend_focused(child);
256  /* Exception to the above rule: smart
257  * popup_during_fullscreen handling (popups belonging to
258  * the fullscreen app will be rendered). */
259  if (floating_child->window == NULL ||
260  fullscreen->window == NULL ||
261  floating_child->window->transient_for != fullscreen->window->id)
262  continue;
263  else {
264  DLOG("Rendering floating child even though in fullscreen mode: "
265  "floating->transient_for (0x%08x) == fullscreen->id (0x%08x)\n",
266  floating_child->window->transient_for, fullscreen->window->id);
267  }
268  }
269  DLOG("floating child at (%d,%d) with %d x %d\n",
270  child->rect.x, child->rect.y, child->rect.width, child->rect.height);
271  x_raise_con(child);
272  render_con(child, false);
273  }
274  }
275 
276  } else {
277 
278  /* FIXME: refactor this into separate functions: */
279  Con *child;
280  TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
281  assert(children > 0);
282 
283  /* default layout */
284  if (con->layout == L_SPLITH || con->layout == L_SPLITV) {
285  if (con->layout == L_SPLITH) {
286  child->rect.x = x;
287  child->rect.y = y;
288  child->rect.width = sizes[i];
289  child->rect.height = rect.height;
290  x += child->rect.width;
291  } else {
292  child->rect.x = x;
293  child->rect.y = y;
294  child->rect.width = rect.width;
295  child->rect.height = sizes[i];
296  y += child->rect.height;
297  }
298 
299  /* first we have the decoration, if this is a leaf node */
300  if (con_is_leaf(child) && child->border_style == BS_NORMAL) {
301  /* TODO: make a function for relative coords? */
302  child->deco_rect.x = child->rect.x - con->rect.x;
303  child->deco_rect.y = child->rect.y - con->rect.y;
304 
305  child->rect.y += deco_height;
306  child->rect.height -= deco_height;
307 
308  child->deco_rect.width = child->rect.width;
309  child->deco_rect.height = deco_height;
310  }
311  }
312 
313  /* stacked layout */
314  else if (con->layout == L_STACKED) {
315  child->rect.x = x;
316  child->rect.y = y;
317  child->rect.width = rect.width;
318  child->rect.height = rect.height;
319 
320  child->deco_rect.x = x - con->rect.x;
321  child->deco_rect.y = y - con->rect.y + (i * deco_height);
322  child->deco_rect.width = child->rect.width;
323  child->deco_rect.height = deco_height;
324 
325  if (children > 1 || (child->border_style != BS_PIXEL && child->border_style != BS_NONE)) {
326  child->rect.y += (deco_height * children);
327  child->rect.height -= (deco_height * children);
328  }
329  }
330 
331  /* tabbed layout */
332  else if (con->layout == L_TABBED) {
333  child->rect.x = x;
334  child->rect.y = y;
335  child->rect.width = rect.width;
336  child->rect.height = rect.height;
337 
338  child->deco_rect.width = ceil((float)child->rect.width / children);
339  child->deco_rect.x = x - con->rect.x + i * child->deco_rect.width;
340  child->deco_rect.y = y - con->rect.y;
341 
342  if (children > 1 || (child->border_style != BS_PIXEL && child->border_style != BS_NONE)) {
343  child->rect.y += deco_height;
344  child->rect.height -= deco_height;
345  child->deco_rect.height = deco_height;
346  } else {
347  child->deco_rect.height = (child->border_style == BS_PIXEL ? 1 : 0);
348  }
349  }
350 
351  /* dockarea layout */
352  else if (con->layout == L_DOCKAREA) {
353  child->rect.x = x;
354  child->rect.y = y;
355  child->rect.width = rect.width;
356  child->rect.height = child->geometry.height;
357 
358  child->deco_rect.x = 0;
359  child->deco_rect.y = 0;
360  child->deco_rect.width = 0;
361  child->deco_rect.height = 0;
362  y += child->rect.height;
363  }
364 
365  DLOG("child at (%d, %d) with (%d x %d)\n",
366  child->rect.x, child->rect.y, child->rect.width, child->rect.height);
367  x_raise_con(child);
368  render_con(child, false);
369  i++;
370  }
371 
372  /* in a stacking or tabbed container, we ensure the focused client is raised */
373  if (con->layout == L_STACKED || con->layout == L_TABBED) {
374  TAILQ_FOREACH_REVERSE(child, &(con->focus_head), focus_head, focused)
375  x_raise_con(child);
376  if ((child = TAILQ_FIRST(&(con->focus_head)))) {
377  /* By rendering the stacked container again, we handle the case
378  * that we have a non-leaf-container inside the stack. In that
379  * case, the children of the non-leaf-container need to be raised
380  * aswell. */
381  render_con(child, false);
382  }
383 
384  if (children != 1)
385  /* Raise the stack con itself. This will put the stack decoration on
386  * top of every stack window. That way, when a new window is opened in
387  * the stack, the old window will not obscure part of the decoration
388  * (it’s unmapped afterwards). */
389  x_raise_con(con);
390  }
391  }
392 }