+#undef I3__FILE__
+#define I3__FILE__ "randr.c"
/*
* vim:ts=4:sw=4:expandtab
*
static Output *get_output_by_id(xcb_randr_output_t id) {
Output *output;
TAILQ_FOREACH(output, &outputs, outputs)
- if (output->id == id)
- return output;
+ if (output->id == id)
+ return output;
return NULL;
}
Output *get_output_by_name(const char *name) {
Output *output;
TAILQ_FOREACH(output, &outputs, outputs)
- if (output->active &&
- strcasecmp(output->name, name) == 0)
- return output;
+ if (output->active &&
+ strcasecmp(output->name, name) == 0)
+ return output;
return NULL;
}
* Returns the first output which is active.
*
*/
-Output *get_first_output() {
+Output *get_first_output(void) {
Output *output;
TAILQ_FOREACH(output, &outputs, outputs)
- if (output->active)
- return output;
+ if (output->active)
+ return output;
- return NULL;
+ die("No usable outputs available.\n");
}
/*
* if there is no output which contains these coordinates.
*
*/
-Output *get_output_containing(int x, int y) {
+Output *get_output_containing(unsigned int x, unsigned int y) {
Output *output;
TAILQ_FOREACH(output, &outputs, outputs) {
if (!output->active)
continue;
DLOG("comparing x=%d y=%d with x=%d and y=%d width %d height %d\n",
- x, y, output->rect.x, output->rect.y, output->rect.width, output->rect.height);
+ x, y, output->rect.x, output->rect.y, output->rect.width, output->rect.height);
if (x >= output->rect.x && x < (output->rect.x + output->rect.width) &&
y >= output->rect.y && y < (output->rect.y + output->rect.height))
return output;
}
/*
- * Gets the output which is the last one in the given direction, for example
- * the output on the most bottom when direction == D_DOWN, the output most
- * right when direction == D_RIGHT and so on.
- *
- * This function always returns a output.
+ * In contained_by_output, we check if any active output contains part of the container.
+ * We do this by checking if the output rect is intersected by the Rect.
+ * This is the 2-dimensional counterpart of get_output_containing.
+ * Since we don't actually need the outputs intersected by the given Rect (There could
+ * be many), we just return true or false for convenience.
*
*/
-Output *get_output_most(direction_t direction, Output *current) {
- Output *output, *candidate = NULL;
- int position = 0;
+bool contained_by_output(Rect rect) {
+ Output *output;
+ int lx = rect.x, uy = rect.y;
+ int rx = rect.x + rect.width, by = rect.y + rect.height;
TAILQ_FOREACH(output, &outputs, outputs) {
if (!output->active)
continue;
-
- /* Repeated calls of WIN determine the winner of the comparison */
- #define WIN(variable, condition) \
- if (variable condition) { \
- candidate = output; \
- position = variable; \
- } \
- break;
-
- if (((direction == D_UP) || (direction == D_DOWN)) &&
- (current->rect.x != output->rect.x))
- continue;
-
- if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
- (current->rect.y != output->rect.y))
- continue;
-
- switch (direction) {
- case D_UP:
- WIN(output->rect.y, <= position);
- case D_DOWN:
- WIN(output->rect.y, >= position);
- case D_LEFT:
- WIN(output->rect.x, <= position);
- case D_RIGHT:
- WIN(output->rect.x, >= position);
- }
+ DLOG("comparing x=%d y=%d with x=%d and y=%d width %d height %d\n",
+ rect.x, rect.y, output->rect.x, output->rect.y, output->rect.width, output->rect.height);
+ if (rx >= (int)output->rect.x && lx <= (int)(output->rect.x + output->rect.width) &&
+ by >= (int)output->rect.y && uy <= (int)(output->rect.y + output->rect.height))
+ return true;
}
+ return false;
+}
- assert(candidate != NULL);
-
- return candidate;
+/*
+ * Like get_output_next with close_far == CLOSEST_OUTPUT, but wraps.
+ *
+ * For example if get_output_next(D_DOWN, x, FARTHEST_OUTPUT) = NULL, then
+ * get_output_next_wrap(D_DOWN, x) will return the topmost output.
+ *
+ * This function always returns a output: if no active outputs can be found,
+ * current itself is returned.
+ *
+ */
+Output *get_output_next_wrap(direction_t direction, Output *current) {
+ Output *best = get_output_next(direction, current, CLOSEST_OUTPUT);
+ /* If no output can be found, wrap */
+ if (!best) {
+ direction_t opposite;
+ if (direction == D_RIGHT)
+ opposite = D_LEFT;
+ else if (direction == D_LEFT)
+ opposite = D_RIGHT;
+ else if (direction == D_DOWN)
+ opposite = D_UP;
+ else
+ opposite = D_DOWN;
+ best = get_output_next(opposite, current, FARTHEST_OUTPUT);
+ }
+ if (!best)
+ best = current;
+ DLOG("current = %s, best = %s\n", current->name, best->name);
+ return best;
}
/*
* Gets the output which is the next one in the given direction.
*
+ * If close_far == CLOSEST_OUTPUT, then the output next to the current one will
+ * selected. If close_far == FARTHEST_OUTPUT, the output which is the last one
+ * in the given direction will be selected.
+ *
+ * NULL will be returned when no active outputs are present in the direction
+ * specified (note that “current” counts as such an output).
+ *
*/
-Output *get_output_next(direction_t direction, Output *current) {
- Output *output, *candidate = NULL;
-
+Output *get_output_next(direction_t direction, Output *current, output_close_far_t close_far) {
+ Rect *cur = &(current->rect),
+ *other;
+ Output *output,
+ *best = NULL;
TAILQ_FOREACH(output, &outputs, outputs) {
if (!output->active)
continue;
- if (((direction == D_UP) || (direction == D_DOWN)) &&
- (current->rect.x != output->rect.x))
+ other = &(output->rect);
+
+ if ((direction == D_RIGHT && other->x > cur->x) ||
+ (direction == D_LEFT && other->x < cur->x)) {
+ /* Skip the output when it doesn’t overlap the other one’s y
+ * coordinate at all. */
+ if ((other->y + other->height) <= cur->y ||
+ (cur->y + cur->height) <= other->y)
+ continue;
+ } else if ((direction == D_DOWN && other->y > cur->y) ||
+ (direction == D_UP && other->y < cur->y)) {
+ /* Skip the output when it doesn’t overlap the other one’s x
+ * coordinate at all. */
+ if ((other->x + other->width) <= cur->x ||
+ (cur->x + cur->width) <= other->x)
+ continue;
+ } else
continue;
- if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
- (current->rect.y != output->rect.y))
+ /* No candidate yet? Start with this one. */
+ if (!best) {
+ best = output;
continue;
+ }
- switch (direction) {
- case D_UP:
- if (output->rect.y < current->rect.y &&
- (!candidate || output->rect.y < candidate->rect.y))
- candidate = output;
- break;
- case D_DOWN:
- if (output->rect.y > current->rect.y &&
- (!candidate || output->rect.y > candidate->rect.y))
- candidate = output;
- break;
- case D_LEFT:
- if (output->rect.x < current->rect.x &&
- (!candidate || output->rect.x > candidate->rect.x))
- candidate = output;
- break;
- case D_RIGHT:
- if (output->rect.x > current->rect.x &&
- (!candidate || output->rect.x < candidate->rect.x))
- candidate = output;
- break;
+ if (close_far == CLOSEST_OUTPUT) {
+ /* Is this output better (closer to the current output) than our
+ * current best bet? */
+ if ((direction == D_RIGHT && other->x < best->rect.x) ||
+ (direction == D_LEFT && other->x > best->rect.x) ||
+ (direction == D_DOWN && other->y < best->rect.y) ||
+ (direction == D_UP && other->y > best->rect.y)) {
+ best = output;
+ continue;
+ }
+ } else {
+ /* Is this output better (farther to the current output) than our
+ * current best bet? */
+ if ((direction == D_RIGHT && other->x > best->rect.x) ||
+ (direction == D_LEFT && other->x < best->rect.x) ||
+ (direction == D_DOWN && other->y > best->rect.y) ||
+ (direction == D_UP && other->y < best->rect.y)) {
+ best = output;
+ continue;
+ }
}
}
- return candidate;
+ DLOG("current = %s, best = %s\n", current->name, (best ? best->name : "NULL"));
+ return best;
}
/*
Con *topdock = con_new(NULL, NULL);
topdock->type = CT_DOCKAREA;
topdock->layout = L_DOCKAREA;
- topdock->orientation = VERT;
/* this container swallows dock clients */
Match *match = scalloc(sizeof(Match));
match_init(match);
DLOG("adding main content container\n");
Con *content = con_new(NULL, NULL);
content->type = CT_CON;
+ content->layout = L_SPLITH;
FREE(content->name);
content->name = sstrdup("content");
Con *bottomdock = con_new(NULL, NULL);
bottomdock->type = CT_DOCKAREA;
bottomdock->layout = L_DOCKAREA;
- bottomdock->orientation = VERT;
/* this container swallows dock clients */
match = scalloc(sizeof(Match));
match_init(match);
*
*/
void init_ws_for_output(Output *output, Con *content) {
- char *name;
-
/* go through all assignments and move the existing workspaces to this output */
struct Workspace_Assignment *assignment;
TAILQ_FOREACH(assignment, &ws_assignments, ws_assignments) {
/* check if this workspace actually exists */
Con *workspace = NULL, *out;
TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
- GREP_FIRST(workspace, output_get_content(out),
- !strcasecmp(child->name, assignment->name));
+ GREP_FIRST(workspace, output_get_content(out),
+ !strcasecmp(child->name, assignment->name));
if (workspace == NULL)
continue;
workspace_show(previous);
}
+ /* Render the output on which the workspace was to get correct Rects.
+ * Then, we need to work with the "content" container, since we cannot
+ * be sure that the workspace itself was rendered at all (in case it’s
+ * invisible, it won’t be rendered). */
+ render_con(workspace_out, false);
+ Con *ws_out_content = output_get_content(workspace_out);
+
+ Con *floating_con;
+ TAILQ_FOREACH(floating_con, &(workspace->floating_head), floating_windows)
+ /* NB: We use output->con here because content is not yet rendered,
+ * so it has a rect of {0, 0, 0, 0}. */
+ floating_fix_coordinates(floating_con, &(ws_out_content->rect), &(output->con->rect));
+
con_detach(workspace);
con_attach(workspace, content, false);
/* if there is still no workspace, we create the first free workspace */
DLOG("Now adding a workspace\n");
-
- /* add a workspace to this output */
- Con *out, *current;
- bool exists = true;
- Con *ws = con_new(NULL, NULL);
- ws->type = CT_WORKSPACE;
-
- /* try the configured workspace bindings first to find a free name */
- Binding *bind;
- TAILQ_FOREACH(bind, bindings, bindings) {
- DLOG("binding with command %s\n", bind->command);
- if (strlen(bind->command) < strlen("workspace ") ||
- strncasecmp(bind->command, "workspace", strlen("workspace")) != 0)
- continue;
- DLOG("relevant command = %s\n", bind->command);
- char *target = bind->command + strlen("workspace ");
- /* We check if this is the workspace
- * next/prev/next_on_output/prev_on_output/back_and_forth command.
- * Beware: The workspace names "next", "prev", "next_on_output",
- * "prev_on_output" and "back_and_forth" are OK, so we check before
- * stripping the double quotes */
- if (strncasecmp(target, "next", strlen("next")) == 0 ||
- strncasecmp(target, "prev", strlen("prev")) == 0 ||
- strncasecmp(target, "next_on_output", strlen("next_on_output")) == 0 ||
- strncasecmp(target, "prev_on_output", strlen("prev_on_output")) == 0 ||
- strncasecmp(target, "back_and_forth", strlen("back_and_forth")) == 0)
- continue;
- if (*target == '"')
- target++;
- FREE(ws->name);
- ws->name = strdup(target);
- if (ws->name[strlen(ws->name)-1] == '"')
- ws->name[strlen(ws->name)-1] = '\0';
- DLOG("trying name *%s*\n", ws->name);
-
- current = NULL;
- TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
- GREP_FIRST(current, output_get_content(out), !strcasecmp(child->name, ws->name));
-
- exists = (current != NULL);
- if (!exists) {
- /* Set ->num to the number of the workspace, if the name actually
- * is a number or starts with a number */
- char *endptr = NULL;
- long parsed_num = strtol(ws->name, &endptr, 10);
- if (parsed_num == LONG_MIN ||
- parsed_num == LONG_MAX ||
- parsed_num < 0 ||
- endptr == ws->name)
- ws->num = -1;
- else ws->num = parsed_num;
- LOG("Used number %d for workspace with name %s\n", ws->num, ws->name);
-
- break;
- }
- }
-
- if (exists) {
- /* get the next unused workspace number */
- DLOG("Getting next unused workspace by number\n");
- int c = 0;
- while (exists) {
- c++;
-
- FREE(ws->name);
- sasprintf(&(ws->name), "%d", c);
-
- current = NULL;
- TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
- GREP_FIRST(current, output_get_content(out), !strcasecmp(child->name, ws->name));
- exists = (current != NULL);
-
- DLOG("result for ws %s / %d: exists = %d\n", ws->name, c, exists);
- }
- ws->num = c;
- }
- con_attach(ws, content, false);
-
- sasprintf(&name, "[i3 con] workspace %s", ws->name);
- x_set_name(ws, name);
- free(name);
-
- ws->fullscreen_mode = CF_OUTPUT;
-
- /* If default_orientation is set to NO_ORIENTATION we determine
- * orientation depending on output resolution. */
- if (config.default_orientation == NO_ORIENTATION) {
- ws->orientation = (output->rect.height > output->rect.width) ? VERT : HORIZ;
- DLOG("Auto orientation. Workspace size set to (%d,%d), setting orientation to %d.\n",
- output->rect.width, output->rect.height, ws->orientation);
- } else {
- ws->orientation = config.default_orientation;
- }
-
+ Con *ws = create_workspace_on_output(output, content);
/* TODO: Set focus in main.c */
con_focus(ws);
if (con_num_children(workspace) > 1)
continue;
- workspace->orientation = (output->rect.height > output->rect.width) ? VERT : HORIZ;
- DLOG("Setting workspace [%d,%s]'s orientation to %d.\n", workspace->num, workspace->name, workspace->orientation);
+ workspace->layout = (output->rect.height > output->rect.width) ? L_SPLITV : L_SPLITH;
+ DLOG("Setting workspace [%d,%s]'s layout to %d.\n", workspace->num, workspace->name, workspace->layout);
if ((child = TAILQ_FIRST(&(workspace->nodes_head)))) {
- child->orientation = workspace->orientation;
- DLOG("Setting child [%d,%s]'s orientation to %d.\n", child->num, child->name, child->orientation);
+ if (child->layout == L_SPLITV || child->layout == L_SPLITH)
+ child->layout = workspace->layout;
+ DLOG("Setting child [%d,%s]'s layout to %d.\n", child->num, child->name, child->layout);
}
}
}
new->primary = (primary && primary->output == id);
FREE(new->name);
sasprintf(&new->name, "%.*s",
- xcb_randr_get_output_info_name_length(output),
- xcb_randr_get_output_info_name(output));
+ xcb_randr_get_output_info_name_length(output),
+ xcb_randr_get_output_info_name(output));
DLOG("found output with name %s\n", new->name);
if (!existing) {
if (new->primary)
TAILQ_INSERT_HEAD(&outputs, new, outputs);
- else TAILQ_INSERT_TAIL(&outputs, new, outputs);
+ else
+ TAILQ_INSERT_TAIL(&outputs, new, outputs);
} else if (new->active)
new->to_be_disabled = true;
return;
return;
}
+ if (output->connection == XCB_RANDR_CONNECTION_DISCONNECTED) {
+ DLOG("Disabling output %s: it is disconnected\n", new->name);
+ new->to_be_disabled = true;
+ return;
+ }
+
bool updated = update_if_necessary(&(new->rect.x), crtc->x) |
update_if_necessary(&(new->rect.y), crtc->y) |
update_if_necessary(&(new->rect.width), crtc->width) |
}
DLOG("mode: %dx%d+%d+%d\n", new->rect.width, new->rect.height,
- new->rect.x, new->rect.y);
+ new->rect.x, new->rect.y);
/* If we don’t need to change an existing output or if the output
* does not exist in the first place, the case is simple: we either
if (!existing) {
if (new->primary)
TAILQ_INSERT_HEAD(&outputs, new, outputs);
- else TAILQ_INSERT_TAIL(&outputs, new, outputs);
+ else
+ TAILQ_INSERT_TAIL(&outputs, new, outputs);
}
return;
}
* (Re-)queries the outputs via RandR and stores them in the list of outputs.
*
*/
-void randr_query_outputs() {
+void randr_query_outputs(void) {
Output *output, *other, *first;
xcb_randr_get_output_primary_cookie_t pcookie;
xcb_randr_get_screen_resources_current_cookie_t rcookie;
if ((primary = xcb_randr_get_output_primary_reply(conn, pcookie, NULL)) == NULL)
ELOG("Could not get RandR primary output\n");
- else DLOG("primary output is %08x\n", primary->output);
+ else
+ DLOG("primary output is %08x\n", primary->output);
if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL) {
disable_randr(conn);
return;
if (!output->active || output->to_be_disabled)
continue;
DLOG("output %p / %s, position (%d, %d), checking for clones\n",
- output, output->name, output->rect.x, output->rect.y);
+ output, output->name, output->rect.x, output->rect.y);
for (other = output;
other != TAILQ_END(&outputs);
continue;
DLOG("output %p has the same position, his mode = %d x %d\n",
- other, other->rect.width, other->rect.height);
+ other, other->rect.width, other->rect.height);
uint32_t width = min(other->rect.width, output->rect.width);
uint32_t height = min(other->rect.height, output->rect.height);
other->to_be_disabled = true;
DLOG("new output mode %d x %d, other mode %d x %d\n",
- output->rect.width, output->rect.height,
- other->rect.width, other->rect.height);
+ output->rect.width, output->rect.height,
+ other->rect.width, other->rect.height);
}
}
output->active = false;
DLOG("Output %s disabled, re-assigning workspaces/docks\n", output->name);
- if ((first = get_first_output()) == NULL)
- die("No usable outputs available\n");
+ first = get_first_output();
/* TODO: refactor the following code into a nice function. maybe
* use an on_destroy callback which is implement differently for
Con *old_content = output_get_content(output->con);
while (!TAILQ_EMPTY(&(old_content->nodes_head))) {
current = TAILQ_FIRST(&(old_content->nodes_head));
+ if (current != next && TAILQ_EMPTY(&(current->focus_head))) {
+ /* the workspace is empty and not focused, get rid of it */
+ DLOG("Getting rid of current = %p / %s (empty, unfocused)\n", current, current->name);
+ tree_close(current, DONT_KILL_WINDOW, false, false);
+ continue;
+ }
DLOG("Detaching current = %p / %s\n", current, current->name);
con_detach(current);
DLOG("Re-attaching current = %p / %s\n", current, current->name);
DLOG("Fixing the coordinates of floating containers\n");
Con *floating_con;
TAILQ_FOREACH(floating_con, &(current->floating_head), floating_windows)
- floating_fix_coordinates(floating_con, &(old_content->rect), &(first_content->rect));
+ floating_fix_coordinates(floating_con, &(output->con->rect), &(first->con->rect));
DLOG("Done, next\n");
}
DLOG("re-attached all workspaces\n");
disable_randr(conn);
}
+ /* Verifies that there is at least one active output as a side-effect. */
+ get_first_output();
+
/* Just go through each active output and assign one workspace */
TAILQ_FOREACH(output, &outputs, outputs) {
if (!output->active)
if (!extreply->present) {
disable_randr(conn);
return;
- } else randr_query_outputs();
+ } else
+ randr_query_outputs();
if (event_base != NULL)
*event_base = extreply->first_event;
xcb_randr_select_input(conn, root,
- XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE |
- XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
- XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE |
- XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);
+ XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE |
+ XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
+ XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE |
+ XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);
xcb_flush(conn);
}
projects / i3 / i3 / blobdiff