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->name[0] == '_' && con->name[1] == '_')
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 (output->name[0] == '_' && output->name[1] == '_')
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 
249  /* Check for (floating!) fullscreen nodes */
250  /* XXX: This code duplication is unfortunate. Keep in mind to fix
251  * this when we clean up the whole render.c */
252  Con *fullscreen = NULL;
253  fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
254  if (fullscreen) {
255  /* Either the fullscreen window is inside the floating
256  * container, then we need to render and raise it now… */
257  if (con_inside_floating(fullscreen)) {
258  fullscreen->rect = output->rect;
259  x_raise_con(fullscreen);
260  render_con(fullscreen, true);
261  continue;
262  } else {
263  /* …or it’s a tiling window, in which case the floating
264  * windows should not overlap it, so we skip rendering this
265  * output. */
266  continue;
267  }
268  }
269 
270  Con *child;
271  TAILQ_FOREACH(child, &(workspace->floating_head), floating_windows) {
272  DLOG("floating child at (%d,%d) with %d x %d\n", child->rect.x, child->rect.y, child->rect.width, child->rect.height);
273  x_raise_con(child);
274  render_con(child, false);
275  }
276  }
277 
278  } else {
279 
280  /* FIXME: refactor this into separate functions: */
281  Con *child;
282  TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
283  assert(children > 0);
284 
285  /* default layout */
286  if (con->layout == L_SPLITH || con->layout == L_SPLITV) {
287  if (con->layout == L_SPLITH) {
288  child->rect.x = x;
289  child->rect.y = y;
290  child->rect.width = sizes[i];
291  child->rect.height = rect.height;
292  x += child->rect.width;
293  } else {
294  child->rect.x = x;
295  child->rect.y = y;
296  child->rect.width = rect.width;
297  child->rect.height = sizes[i];
298  y += child->rect.height;
299  }
300 
301  /* first we have the decoration, if this is a leaf node */
302  if (con_is_leaf(child) && child->border_style == BS_NORMAL) {
303  /* TODO: make a function for relative coords? */
304  child->deco_rect.x = child->rect.x - con->rect.x;
305  child->deco_rect.y = child->rect.y - con->rect.y;
306 
307  child->rect.y += deco_height;
308  child->rect.height -= deco_height;
309 
310  child->deco_rect.width = child->rect.width;
311  child->deco_rect.height = deco_height;
312  }
313  }
314 
315  /* stacked layout */
316  else if (con->layout == L_STACKED) {
317  child->rect.x = x;
318  child->rect.y = y;
319  child->rect.width = rect.width;
320  child->rect.height = rect.height;
321 
322  child->deco_rect.x = x - con->rect.x;
323  child->deco_rect.y = y - con->rect.y + (i * deco_height);
324  child->deco_rect.width = child->rect.width;
325  child->deco_rect.height = deco_height;
326 
327  if (children > 1 || (child->border_style != BS_1PIXEL && child->border_style != BS_NONE)) {
328  child->rect.y += (deco_height * children);
329  child->rect.height -= (deco_height * children);
330  }
331  }
332 
333  /* tabbed layout */
334  else if (con->layout == L_TABBED) {
335  child->rect.x = x;
336  child->rect.y = y;
337  child->rect.width = rect.width;
338  child->rect.height = rect.height;
339 
340  child->deco_rect.width = ceil((float)child->rect.width / children);
341  child->deco_rect.x = x - con->rect.x + i * child->deco_rect.width;
342  child->deco_rect.y = y - con->rect.y;
343 
344  if (children > 1 || (child->border_style != BS_1PIXEL && child->border_style != BS_NONE)) {
345  child->rect.y += deco_height;
346  child->rect.height -= deco_height;
347  child->deco_rect.height = deco_height;
348  } else {
349  child->deco_rect.height = (child->border_style == BS_1PIXEL ? 1 : 0);
350  }
351  }
352 
353  /* dockarea layout */
354  else if (con->layout == L_DOCKAREA) {
355  child->rect.x = x;
356  child->rect.y = y;
357  child->rect.width = rect.width;
358  child->rect.height = child->geometry.height;
359 
360  child->deco_rect.x = 0;
361  child->deco_rect.y = 0;
362  child->deco_rect.width = 0;
363  child->deco_rect.height = 0;
364  y += child->rect.height;
365  }
366 
367  DLOG("child at (%d, %d) with (%d x %d)\n",
368  child->rect.x, child->rect.y, child->rect.width, child->rect.height);
369  x_raise_con(child);
370  render_con(child, false);
371  i++;
372  }
373 
374  /* in a stacking or tabbed container, we ensure the focused client is raised */
375  if (con->layout == L_STACKED || con->layout == L_TABBED) {
376  TAILQ_FOREACH_REVERSE(child, &(con->focus_head), focus_head, focused)
377  x_raise_con(child);
378  if ((child = TAILQ_FIRST(&(con->focus_head)))) {
379  /* By rendering the stacked container again, we handle the case
380  * that we have a non-leaf-container inside the stack. In that
381  * case, the children of the non-leaf-container need to be raised
382  * aswell. */
383  render_con(child, false);
384  }
385 
386  if (children != 1)
387  /* Raise the stack con itself. This will put the stack decoration on
388  * top of every stack window. That way, when a new window is opened in
389  * the stack, the old window will not obscure part of the decoration
390  * (it’s unmapped afterwards). */
391  x_raise_con(con);
392  }
393  }
394 }