i3
randr.c
Go to the documentation of this file.
1 #undef I3__FILE__
2 #define I3__FILE__ "randr.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  * For more information on RandR, please see the X.org RandR specification at
10  * http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt
11  * (take your time to read it completely, it answers all questions).
12  *
13  */
14 #include "all.h"
15 
16 #include <time.h>
17 #include <xcb/randr.h>
18 
19 /* While a clean namespace is usually a pretty good thing, we really need
20  * to use shorter names than the whole xcb_randr_* default names. */
21 typedef xcb_randr_get_crtc_info_reply_t crtc_info;
22 typedef xcb_randr_get_screen_resources_current_reply_t resources_reply;
23 
24 /* Pointer to the result of the query for primary output */
25 xcb_randr_get_output_primary_reply_t *primary;
26 
27 /* Stores all outputs available in your current session. */
28 struct outputs_head outputs = TAILQ_HEAD_INITIALIZER(outputs);
29 
30 static bool randr_disabled = false;
31 
32 /*
33  * Get a specific output by its internal X11 id. Used by randr_query_outputs
34  * to check if the output is new (only in the first scan) or if we are
35  * re-scanning.
36  *
37  */
38 static Output *get_output_by_id(xcb_randr_output_t id) {
39  Output *output;
40  TAILQ_FOREACH(output, &outputs, outputs)
41  if (output->id == id)
42  return output;
43 
44  return NULL;
45 }
46 
47 /*
48  * Returns the output with the given name if it is active (!) or NULL.
49  *
50  */
51 Output *get_output_by_name(const char *name) {
52  Output *output;
53  TAILQ_FOREACH(output, &outputs, outputs)
54  if (output->active &&
55  strcasecmp(output->name, name) == 0)
56  return output;
57 
58  return NULL;
59 }
60 
61 /*
62  * Returns the first output which is active.
63  *
64  */
66  Output *output;
67 
68  TAILQ_FOREACH(output, &outputs, outputs)
69  if (output->active)
70  return output;
71 
72  return NULL;
73 }
74 
75 /*
76  * Returns the active (!) output which contains the coordinates x, y or NULL
77  * if there is no output which contains these coordinates.
78  *
79  */
81  Output *output;
82  TAILQ_FOREACH(output, &outputs, outputs) {
83  if (!output->active)
84  continue;
85  DLOG("comparing x=%d y=%d with x=%d and y=%d width %d height %d\n",
86  x, y, output->rect.x, output->rect.y, output->rect.width, output->rect.height);
87  if (x >= output->rect.x && x < (output->rect.x + output->rect.width) &&
88  y >= output->rect.y && y < (output->rect.y + output->rect.height))
89  return output;
90  }
91 
92  return NULL;
93 }
94 
95 /*
96  * Gets the output which is the last one in the given direction, for example
97  * the output on the most bottom when direction == D_DOWN, the output most
98  * right when direction == D_RIGHT and so on.
99  *
100  * This function always returns a output.
101  *
102  */
103 Output *get_output_most(direction_t direction, Output *current) {
104  Output *output, *candidate = NULL;
105  int position = 0;
106  TAILQ_FOREACH(output, &outputs, outputs) {
107  if (!output->active)
108  continue;
109 
110  /* Repeated calls of WIN determine the winner of the comparison */
111  #define WIN(variable, condition) \
112  if (variable condition) { \
113  candidate = output; \
114  position = variable; \
115  } \
116  break;
117 
118  if (((direction == D_UP) || (direction == D_DOWN)) &&
119  (current->rect.x != output->rect.x))
120  continue;
121 
122  if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
123  (current->rect.y != output->rect.y))
124  continue;
125 
126  switch (direction) {
127  case D_UP:
128  WIN(output->rect.y, <= position);
129  case D_DOWN:
130  WIN(output->rect.y, >= position);
131  case D_LEFT:
132  WIN(output->rect.x, <= position);
133  case D_RIGHT:
134  WIN(output->rect.x, >= position);
135  }
136  }
137 
138  assert(candidate != NULL);
139 
140  return candidate;
141 }
142 
143 /*
144  * Gets the output which is the next one in the given direction.
145  *
146  */
147 Output *get_output_next(direction_t direction, Output *current) {
148  Output *output, *candidate = NULL;
149 
150  TAILQ_FOREACH(output, &outputs, outputs) {
151  if (!output->active)
152  continue;
153 
154  if (((direction == D_UP) || (direction == D_DOWN)) &&
155  (current->rect.x != output->rect.x))
156  continue;
157 
158  if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
159  (current->rect.y != output->rect.y))
160  continue;
161 
162  switch (direction) {
163  case D_UP:
164  if (output->rect.y < current->rect.y &&
165  (!candidate || output->rect.y < candidate->rect.y))
166  candidate = output;
167  break;
168  case D_DOWN:
169  if (output->rect.y > current->rect.y &&
170  (!candidate || output->rect.y > candidate->rect.y))
171  candidate = output;
172  break;
173  case D_LEFT:
174  if (output->rect.x < current->rect.x &&
175  (!candidate || output->rect.x > candidate->rect.x))
176  candidate = output;
177  break;
178  case D_RIGHT:
179  if (output->rect.x > current->rect.x &&
180  (!candidate || output->rect.x < candidate->rect.x))
181  candidate = output;
182  break;
183  }
184  }
185 
186  return candidate;
187 }
188 
189 /*
190  * Disables RandR support by creating exactly one output with the size of the
191  * X11 screen.
192  *
193  */
194 void disable_randr(xcb_connection_t *conn) {
195  DLOG("RandR extension unusable, disabling.\n");
196 
197  Output *s = scalloc(sizeof(Output));
198 
199  s->active = true;
200  s->rect.x = 0;
201  s->rect.y = 0;
202  s->rect.width = root_screen->width_in_pixels;
203  s->rect.height = root_screen->height_in_pixels;
204  s->name = "xroot-0";
205  output_init_con(s);
207 
209 
210  randr_disabled = true;
211 }
212 
213 /*
214  * Initializes a CT_OUTPUT Con (searches existing ones from inplace restart
215  * before) to use for the given Output.
216  *
217  */
218 void output_init_con(Output *output) {
219  Con *con = NULL, *current;
220  bool reused = false;
221 
222  DLOG("init_con for output %s\n", output->name);
223 
224  /* Search for a Con with that name directly below the root node. There
225  * might be one from a restored layout. */
226  TAILQ_FOREACH(current, &(croot->nodes_head), nodes) {
227  if (strcmp(current->name, output->name) != 0)
228  continue;
229 
230  con = current;
231  reused = true;
232  DLOG("Using existing con %p / %s\n", con, con->name);
233  break;
234  }
235 
236  if (con == NULL) {
237  con = con_new(croot, NULL);
238  FREE(con->name);
239  con->name = sstrdup(output->name);
240  con->type = CT_OUTPUT;
241  con->layout = L_OUTPUT;
243  }
244  con->rect = output->rect;
245  output->con = con;
246 
247  char *name;
248  sasprintf(&name, "[i3 con] output %s", con->name);
249  x_set_name(con, name);
250  FREE(name);
251 
252  if (reused) {
253  DLOG("Not adding workspace, this was a reused con\n");
254  return;
255  }
256 
257  DLOG("Changing layout, adding top/bottom dockarea\n");
258  Con *topdock = con_new(NULL, NULL);
259  topdock->type = CT_DOCKAREA;
260  topdock->layout = L_DOCKAREA;
261  /* this container swallows dock clients */
262  Match *match = scalloc(sizeof(Match));
263  match_init(match);
264  match->dock = M_DOCK_TOP;
265  match->insert_where = M_BELOW;
266  TAILQ_INSERT_TAIL(&(topdock->swallow_head), match, matches);
267 
268  FREE(topdock->name);
269  topdock->name = sstrdup("topdock");
270 
271  sasprintf(&name, "[i3 con] top dockarea %s", con->name);
272  x_set_name(topdock, name);
273  FREE(name);
274  DLOG("attaching\n");
275  con_attach(topdock, con, false);
276 
277  /* content container */
278 
279  DLOG("adding main content container\n");
280  Con *content = con_new(NULL, NULL);
281  content->type = CT_CON;
282  content->layout = L_SPLITH;
283  FREE(content->name);
284  content->name = sstrdup("content");
285 
286  sasprintf(&name, "[i3 con] content %s", con->name);
287  x_set_name(content, name);
288  FREE(name);
289  con_attach(content, con, false);
290 
291  /* bottom dock container */
292  Con *bottomdock = con_new(NULL, NULL);
293  bottomdock->type = CT_DOCKAREA;
294  bottomdock->layout = L_DOCKAREA;
295  /* this container swallows dock clients */
296  match = scalloc(sizeof(Match));
297  match_init(match);
298  match->dock = M_DOCK_BOTTOM;
299  match->insert_where = M_BELOW;
300  TAILQ_INSERT_TAIL(&(bottomdock->swallow_head), match, matches);
301 
302  FREE(bottomdock->name);
303  bottomdock->name = sstrdup("bottomdock");
304 
305  sasprintf(&name, "[i3 con] bottom dockarea %s", con->name);
306  x_set_name(bottomdock, name);
307  FREE(name);
308  DLOG("attaching\n");
309  con_attach(bottomdock, con, false);
310 }
311 
312 /*
313  * Initializes at least one workspace for this output, trying the following
314  * steps until there is at least one workspace:
315  *
316  * • Move existing workspaces, which are assigned to be on the given output, to
317  * the output.
318  * • Create the first assigned workspace for this output.
319  * • Create the first unused workspace.
320  *
321  */
322 void init_ws_for_output(Output *output, Con *content) {
323  /* go through all assignments and move the existing workspaces to this output */
324  struct Workspace_Assignment *assignment;
326  if (strcmp(assignment->output, output->name) != 0)
327  continue;
328 
329  /* check if this workspace actually exists */
330  Con *workspace = NULL, *out;
331  TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
332  GREP_FIRST(workspace, output_get_content(out),
333  !strcasecmp(child->name, assignment->name));
334  if (workspace == NULL)
335  continue;
336 
337  /* check that this workspace is not already attached (that means the
338  * user configured this assignment twice) */
339  Con *workspace_out = con_get_output(workspace);
340  if (workspace_out == output->con) {
341  LOG("Workspace \"%s\" assigned to output \"%s\", but it is already "
342  "there. Do you have two assignment directives for the same "
343  "workspace in your configuration file?\n",
344  workspace->name, output->name);
345  continue;
346  }
347 
348  /* if so, move it over */
349  LOG("Moving workspace \"%s\" from output \"%s\" to \"%s\" due to assignment\n",
350  workspace->name, workspace_out->name, output->name);
351 
352  /* if the workspace is currently visible on that output, we need to
353  * switch to a different workspace - otherwise the output would end up
354  * with no active workspace */
355  bool visible = workspace_is_visible(workspace);
356  Con *previous = NULL;
357  if (visible && (previous = TAILQ_NEXT(workspace, focused))) {
358  LOG("Switching to previously used workspace \"%s\" on output \"%s\"\n",
359  previous->name, workspace_out->name);
360  workspace_show(previous);
361  }
362 
363  /* Render the output on which the workspace was to get correct Rects.
364  * Then, we need to work with the "content" container, since we cannot
365  * be sure that the workspace itself was rendered at all (in case it’s
366  * invisible, it won’t be rendered). */
367  render_con(workspace_out, false);
368  Con *ws_out_content = output_get_content(workspace_out);
369 
370  Con *floating_con;
371  TAILQ_FOREACH(floating_con, &(workspace->floating_head), floating_windows)
372  /* NB: We use output->con here because content is not yet rendered,
373  * so it has a rect of {0, 0, 0, 0}. */
374  floating_fix_coordinates(floating_con, &(ws_out_content->rect), &(output->con->rect));
375 
376  con_detach(workspace);
377  con_attach(workspace, content, false);
378 
379  /* In case the workspace we just moved was visible but there was no
380  * other workspace to switch to, we need to initialize the source
381  * output aswell */
382  if (visible && previous == NULL) {
383  LOG("There is no workspace left on \"%s\", re-initializing\n",
384  workspace_out->name);
386  output_get_content(workspace_out));
387  DLOG("Done re-initializing, continuing with \"%s\"\n", output->name);
388  }
389  }
390 
391  /* if a workspace exists, we are done now */
392  if (!TAILQ_EMPTY(&(content->nodes_head))) {
393  /* ensure that one of the workspaces is actually visible (in fullscreen
394  * mode), if they were invisible before, this might not be the case. */
395  Con *visible = NULL;
396  GREP_FIRST(visible, content, child->fullscreen_mode == CF_OUTPUT);
397  if (!visible) {
398  visible = TAILQ_FIRST(&(content->nodes_head));
399  focused = content;
400  workspace_show(visible);
401  }
402  return;
403  }
404 
405  /* otherwise, we create the first assigned ws for this output */
407  if (strcmp(assignment->output, output->name) != 0)
408  continue;
409 
410  LOG("Initializing first assigned workspace \"%s\" for output \"%s\"\n",
411  assignment->name, assignment->output);
412  focused = content;
413  workspace_show_by_name(assignment->name);
414  return;
415  }
416 
417  /* if there is still no workspace, we create the first free workspace */
418  DLOG("Now adding a workspace\n");
419  Con *ws = create_workspace_on_output(output, content);
420 
421  /* TODO: Set focus in main.c */
422  con_focus(ws);
423 }
424 
425 /*
426  * This function needs to be called when changing the mode of an output when
427  * it already has some workspaces (or a bar window) assigned.
428  *
429  * It reconfigures the bar window for the new mode, copies the new rect into
430  * each workspace on this output and forces all windows on the affected
431  * workspaces to be reconfigured.
432  *
433  * It is necessary to call render_layout() afterwards.
434  *
435  */
436 static void output_change_mode(xcb_connection_t *conn, Output *output) {
437  DLOG("Output mode changed, updating rect\n");
438  assert(output->con != NULL);
439  output->con->rect = output->rect;
440 
441  Con *content, *workspace, *child;
442 
443  /* Point content to the container of the workspaces */
444  content = output_get_content(output->con);
445 
446  /* Fix the position of all floating windows on this output.
447  * The 'rect' of each workspace will be updated in src/render.c. */
448  TAILQ_FOREACH(workspace, &(content->nodes_head), nodes) {
449  TAILQ_FOREACH(child, &(workspace->floating_head), floating_windows) {
450  floating_fix_coordinates(child, &(workspace->rect), &(output->con->rect));
451  }
452  }
453 
454  /* If default_orientation is NO_ORIENTATION, we change the orientation of
455  * the workspaces and their childs depending on output resolution. This is
456  * only done for workspaces with maximum one child. */
458  TAILQ_FOREACH(workspace, &(content->nodes_head), nodes) {
459  /* Workspaces with more than one child are left untouched because
460  * we do not want to change an existing layout. */
461  if (con_num_children(workspace) > 1)
462  continue;
463 
464  workspace->layout = (output->rect.height > output->rect.width) ? L_SPLITV : L_SPLITH;
465  DLOG("Setting workspace [%d,%s]'s layout to %d.\n", workspace->num, workspace->name, workspace->layout);
466  if ((child = TAILQ_FIRST(&(workspace->nodes_head)))) {
467  if (child->layout == L_SPLITV || child->layout == L_SPLITH)
468  child->layout = workspace->layout;
469  DLOG("Setting child [%d,%s]'s layout to %d.\n", child->num, child->name, child->layout);
470  }
471  }
472  }
473 }
474 
475 /*
476  * Gets called by randr_query_outputs() for each output. The function adds new
477  * outputs to the list of outputs, checks if the mode of existing outputs has
478  * been changed or if an existing output has been disabled. It will then change
479  * either the "changed" or the "to_be_deleted" flag of the output, if
480  * appropriate.
481  *
482  */
483 static void handle_output(xcb_connection_t *conn, xcb_randr_output_t id,
484  xcb_randr_get_output_info_reply_t *output,
485  xcb_timestamp_t cts, resources_reply *res) {
486  /* each CRT controller has a position in which we are interested in */
487  crtc_info *crtc;
488 
489  Output *new = get_output_by_id(id);
490  bool existing = (new != NULL);
491  if (!existing)
492  new = scalloc(sizeof(Output));
493  new->id = id;
494  new->primary = (primary && primary->output == id);
495  FREE(new->name);
496  sasprintf(&new->name, "%.*s",
497  xcb_randr_get_output_info_name_length(output),
498  xcb_randr_get_output_info_name(output));
499 
500  DLOG("found output with name %s\n", new->name);
501 
502  /* Even if no CRTC is used at the moment, we store the output so that
503  * we do not need to change the list ever again (we only update the
504  * position/size) */
505  if (output->crtc == XCB_NONE) {
506  if (!existing) {
507  if (new->primary)
509  else TAILQ_INSERT_TAIL(&outputs, new, outputs);
510  } else if (new->active)
511  new->to_be_disabled = true;
512  return;
513  }
514 
515  xcb_randr_get_crtc_info_cookie_t icookie;
516  icookie = xcb_randr_get_crtc_info(conn, output->crtc, cts);
517  if ((crtc = xcb_randr_get_crtc_info_reply(conn, icookie, NULL)) == NULL) {
518  DLOG("Skipping output %s: could not get CRTC (%p)\n",
519  new->name, crtc);
520  free(new);
521  return;
522  }
523 
524  bool updated = update_if_necessary(&(new->rect.x), crtc->x) |
525  update_if_necessary(&(new->rect.y), crtc->y) |
526  update_if_necessary(&(new->rect.width), crtc->width) |
527  update_if_necessary(&(new->rect.height), crtc->height);
528  free(crtc);
529  new->active = (new->rect.width != 0 && new->rect.height != 0);
530  if (!new->active) {
531  DLOG("width/height 0/0, disabling output\n");
532  return;
533  }
534 
535  DLOG("mode: %dx%d+%d+%d\n", new->rect.width, new->rect.height,
536  new->rect.x, new->rect.y);
537 
538  /* If we don’t need to change an existing output or if the output
539  * does not exist in the first place, the case is simple: we either
540  * need to insert the new output or we are done. */
541  if (!updated || !existing) {
542  if (!existing) {
543  if (new->primary)
545  else TAILQ_INSERT_TAIL(&outputs, new, outputs);
546  }
547  return;
548  }
549 
550  new->changed = true;
551 }
552 
553 /*
554  * (Re-)queries the outputs via RandR and stores them in the list of outputs.
555  *
556  */
558  Output *output, *other, *first;
559  xcb_randr_get_output_primary_cookie_t pcookie;
560  xcb_randr_get_screen_resources_current_cookie_t rcookie;
561  resources_reply *res;
562 
563  /* timestamp of the configuration so that we get consistent replies to all
564  * requests (if the configuration changes between our different calls) */
565  xcb_timestamp_t cts;
566 
567  /* an output is VGA-1, LVDS-1, etc. (usually physical video outputs) */
568  xcb_randr_output_t *randr_outputs;
569 
570  if (randr_disabled)
571  return;
572 
573  /* Get screen resources (primary output, crtcs, outputs, modes) */
574  rcookie = xcb_randr_get_screen_resources_current(conn, root);
575  pcookie = xcb_randr_get_output_primary(conn, root);
576 
577  if ((primary = xcb_randr_get_output_primary_reply(conn, pcookie, NULL)) == NULL)
578  ELOG("Could not get RandR primary output\n");
579  else DLOG("primary output is %08x\n", primary->output);
580  if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL) {
582  return;
583  }
584  cts = res->config_timestamp;
585 
586  int len = xcb_randr_get_screen_resources_current_outputs_length(res);
587  randr_outputs = xcb_randr_get_screen_resources_current_outputs(res);
588 
589  /* Request information for each output */
590  xcb_randr_get_output_info_cookie_t ocookie[len];
591  for (int i = 0; i < len; i++)
592  ocookie[i] = xcb_randr_get_output_info(conn, randr_outputs[i], cts);
593 
594  /* Loop through all outputs available for this X11 screen */
595  for (int i = 0; i < len; i++) {
596  xcb_randr_get_output_info_reply_t *output;
597 
598  if ((output = xcb_randr_get_output_info_reply(conn, ocookie[i], NULL)) == NULL)
599  continue;
600 
601  handle_output(conn, randr_outputs[i], output, cts, res);
602  free(output);
603  }
604 
605  /* Check for clones, disable the clones and reduce the mode to the
606  * lowest common mode */
607  TAILQ_FOREACH(output, &outputs, outputs) {
608  if (!output->active || output->to_be_disabled)
609  continue;
610  DLOG("output %p / %s, position (%d, %d), checking for clones\n",
611  output, output->name, output->rect.x, output->rect.y);
612 
613  for (other = output;
614  other != TAILQ_END(&outputs);
615  other = TAILQ_NEXT(other, outputs)) {
616  if (other == output || !other->active || other->to_be_disabled)
617  continue;
618 
619  if (other->rect.x != output->rect.x ||
620  other->rect.y != output->rect.y)
621  continue;
622 
623  DLOG("output %p has the same position, his mode = %d x %d\n",
624  other, other->rect.width, other->rect.height);
625  uint32_t width = min(other->rect.width, output->rect.width);
626  uint32_t height = min(other->rect.height, output->rect.height);
627 
628  if (update_if_necessary(&(output->rect.width), width) |
629  update_if_necessary(&(output->rect.height), height))
630  output->changed = true;
631 
632  update_if_necessary(&(other->rect.width), width);
633  update_if_necessary(&(other->rect.height), height);
634 
635  DLOG("disabling output %p (%s)\n", other, other->name);
636  other->to_be_disabled = true;
637 
638  DLOG("new output mode %d x %d, other mode %d x %d\n",
639  output->rect.width, output->rect.height,
640  other->rect.width, other->rect.height);
641  }
642  }
643 
644  /* Ensure that all outputs which are active also have a con. This is
645  * necessary because in the next step, a clone might get disabled. Example:
646  * LVDS1 active, VGA1 gets activated as a clone of LVDS1 (has no con).
647  * LVDS1 gets disabled. */
648  TAILQ_FOREACH(output, &outputs, outputs) {
649  if (output->active && output->con == NULL) {
650  DLOG("Need to initialize a Con for output %s\n", output->name);
651  output_init_con(output);
652  output->changed = false;
653  }
654  }
655 
656  /* Handle outputs which have a new mode or are disabled now (either
657  * because the user disabled them or because they are clones) */
658  TAILQ_FOREACH(output, &outputs, outputs) {
659  if (output->to_be_disabled) {
660  output->active = false;
661  DLOG("Output %s disabled, re-assigning workspaces/docks\n", output->name);
662 
663  if ((first = get_first_output()) == NULL)
664  die("No usable outputs available\n");
665 
666  /* TODO: refactor the following code into a nice function. maybe
667  * use an on_destroy callback which is implement differently for
668  * different container types (CT_CONTENT vs. CT_DOCKAREA)? */
669  Con *first_content = output_get_content(first->con);
670 
671  if (output->con != NULL) {
672  /* We need to move the workspaces from the disappearing output to the first output */
673  /* 1: Get the con to focus next, if the disappearing ws is focused */
674  Con *next = NULL;
675  if (TAILQ_FIRST(&(croot->focus_head)) == output->con) {
676  DLOG("This output (%p) was focused! Getting next\n", output->con);
677  next = focused;
678  DLOG("next = %p\n", next);
679  }
680 
681  /* 2: iterate through workspaces and re-assign them, fixing the coordinates
682  * of floating containers as we go */
683  Con *current;
684  Con *old_content = output_get_content(output->con);
685  while (!TAILQ_EMPTY(&(old_content->nodes_head))) {
686  current = TAILQ_FIRST(&(old_content->nodes_head));
687  if (current != next && TAILQ_EMPTY(&(current->focus_head))) {
688  /* the workspace is empty and not focused, get rid of it */
689  DLOG("Getting rid of current = %p / %s (empty, unfocused)\n", current, current->name);
690  tree_close(current, DONT_KILL_WINDOW, false, false);
691  continue;
692  }
693  DLOG("Detaching current = %p / %s\n", current, current->name);
694  con_detach(current);
695  DLOG("Re-attaching current = %p / %s\n", current, current->name);
696  con_attach(current, first_content, false);
697  DLOG("Fixing the coordinates of floating containers\n");
698  Con *floating_con;
699  TAILQ_FOREACH(floating_con, &(current->floating_head), floating_windows)
700  floating_fix_coordinates(floating_con, &(output->con->rect), &(first->con->rect));
701  DLOG("Done, next\n");
702  }
703  DLOG("re-attached all workspaces\n");
704 
705  if (next) {
706  DLOG("now focusing next = %p\n", next);
707  con_focus(next);
709  }
710 
711  /* 3: move the dock clients to the first output */
712  Con *child;
713  TAILQ_FOREACH(child, &(output->con->nodes_head), nodes) {
714  if (child->type != CT_DOCKAREA)
715  continue;
716  DLOG("Handling dock con %p\n", child);
717  Con *dock;
718  while (!TAILQ_EMPTY(&(child->nodes_head))) {
719  dock = TAILQ_FIRST(&(child->nodes_head));
720  Con *nc;
721  Match *match;
722  nc = con_for_window(first->con, dock->window, &match);
723  DLOG("Moving dock client %p to nc %p\n", dock, nc);
724  con_detach(dock);
725  DLOG("Re-attaching\n");
726  con_attach(dock, nc, false);
727  DLOG("Done\n");
728  }
729  }
730 
731  DLOG("destroying disappearing con %p\n", output->con);
732  tree_close(output->con, DONT_KILL_WINDOW, true, false);
733  DLOG("Done. Should be fine now\n");
734  output->con = NULL;
735  }
736 
737  output->to_be_disabled = false;
738  output->changed = false;
739  }
740 
741  if (output->changed) {
742  output_change_mode(conn, output);
743  output->changed = false;
744  }
745  }
746 
747  if (TAILQ_EMPTY(&outputs)) {
748  ELOG("No outputs found via RandR, disabling\n");
750  }
751 
752  /* Just go through each active output and assign one workspace */
753  TAILQ_FOREACH(output, &outputs, outputs) {
754  if (!output->active)
755  continue;
756  Con *content = output_get_content(output->con);
757  if (!TAILQ_EMPTY(&(content->nodes_head)))
758  continue;
759  DLOG("Should add ws for output %s\n", output->name);
760  init_ws_for_output(output, content);
761  }
762 
763  /* Focus the primary screen, if possible */
764  TAILQ_FOREACH(output, &outputs, outputs) {
765  if (!output->primary || !output->con)
766  continue;
767 
768  DLOG("Focusing primary output %s\n", output->name);
770  }
771 
772  /* render_layout flushes */
773  tree_render();
774 
775  FREE(res);
776  FREE(primary);
777 }
778 
779 /*
780  * We have just established a connection to the X server and need the initial
781  * XRandR information to setup workspaces for each screen.
782  *
783  */
784 void randr_init(int *event_base) {
785  const xcb_query_extension_reply_t *extreply;
786 
787  extreply = xcb_get_extension_data(conn, &xcb_randr_id);
788  if (!extreply->present) {
790  return;
791  } else randr_query_outputs();
792 
793  if (event_base != NULL)
794  *event_base = extreply->first_event;
795 
796  xcb_randr_select_input(conn, root,
797  XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE |
798  XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
799  XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE |
800  XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);
801 
802  xcb_flush(conn);
803 }