+#undef I3__FILE__
+#define I3__FILE__ "con.c"
/*
* vim:ts=4:sw=4:expandtab
*
if (con->type == CT_WORKSPACE)
return false;
- if (con->orientation != NO_ORIENTATION) {
- DLOG("container %p does not accepts windows, orientation != NO_ORIENTATION\n", con);
+ if (con->split) {
+ DLOG("container %p does not accept windows, it is a split container.\n", con);
return false;
}
while (con_orientation(parent) != orientation) {
DLOG("Need to go one level further up\n");
parent = parent->parent;
- /* Abort when we reach a floating con */
- if (parent && parent->type == CT_FLOATING_CON)
+ /* Abort when we reach a floating con, or an output con */
+ if (parent &&
+ (parent->type == CT_FLOATING_CON ||
+ parent->type == CT_OUTPUT ||
+ (parent->parent && parent->parent->type == CT_OUTPUT)))
parent = NULL;
if (parent == NULL)
break;
* con focused. Otherwise, we leave the focus on the current workspace as we
* don’t want to focus invisible workspaces */
if (source_output != dest_output &&
- workspace_is_visible(workspace)) {
+ workspace_is_visible(workspace) &&
+ workspace->name[0] != '_' &&
+ workspace->name[1] != '_') {
DLOG("Moved to a different output, focusing target\n");
} else {
/* Descend focus stack in case focus_next is a workspace which can
*
*/
int con_orientation(Con *con) {
- /* stacking containers behave like they are in vertical orientation */
- if (con->layout == L_STACKED)
- return VERT;
-
- if (con->layout == L_TABBED)
- return HORIZ;
-
- return con->orientation;
+ switch (con->layout) {
+ case L_SPLITV:
+ /* stacking containers behave like they are in vertical orientation */
+ case L_STACKED:
+ return VERT;
+
+ case L_SPLITH:
+ /* tabbed containers behave like they are in vertical orientation */
+ case L_TABBED:
+ return HORIZ;
+
+ case L_DEFAULT:
+ DLOG("Someone called con_orientation() on a con with L_DEFAULT, this is a bug in the code.\n");
+ assert(false);
+ return HORIZ;
+
+ case L_DOCKAREA:
+ case L_OUTPUT:
+ DLOG("con_orientation() called on dockarea/output (%d) container %p\n", con->layout, con);
+ assert(false);
+ return HORIZ;
+
+ default:
+ DLOG("con_orientation() ran into default\n");
+ assert(false);
+ }
}
/*
*
*/
Rect con_border_style_rect(Con *con) {
- switch (con_border_style(con)) {
+ adjacent_t borders_to_hide = ADJ_NONE;
+ Rect result;
+ /* Shortcut to avoid calling con_adjacent_borders() on dock containers. */
+ int border_style = con_border_style(con);
+ if (border_style == BS_NONE)
+ return (Rect){ 0, 0, 0, 0 };
+ borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders;
+ switch (border_style) {
case BS_NORMAL:
- return (Rect){2, 0, -(2 * 2), -2};
+ result = (Rect){2, 0, -(2 * 2), -2};
+ if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) {
+ result.x -= 2;
+ result.width += 2;
+ }
+ if (borders_to_hide & ADJ_RIGHT_SCREEN_EDGE) {
+ result.width += 2;
+ }
+ /* With normal borders we never hide the upper border */
+ if (borders_to_hide & ADJ_LOWER_SCREEN_EDGE) {
+ result.height += 2;
+ }
+ return result;
case BS_1PIXEL:
- return (Rect){1, 1, -2, -2};
+ result = (Rect){1, 1, -2, -2};
+ if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) {
+ result.x -= 1;
+ result.width += 1;
+ }
+ if (borders_to_hide & ADJ_RIGHT_SCREEN_EDGE) {
+ result.width += 1;
+ }
+ if (borders_to_hide & ADJ_UPPER_SCREEN_EDGE) {
+ result.y -= 1;
+ result.height += 1;
+ }
+ if (borders_to_hide & ADJ_LOWER_SCREEN_EDGE) {
+ result.height += 1;
+ }
+ return result;
case BS_NONE:
return (Rect){0, 0, 0, 0};
}
}
+/*
+ * Returns adjacent borders of the window. We need this if hide_edge_borders is
+ * enabled.
+ */
+adjacent_t con_adjacent_borders(Con *con) {
+ adjacent_t result = ADJ_NONE;
+ Con *workspace = con_get_workspace(con);
+ if (con->rect.x == workspace->rect.x)
+ result |= ADJ_LEFT_SCREEN_EDGE;
+ if (con->rect.x + con->rect.width == workspace->rect.x + workspace->rect.width)
+ result |= ADJ_RIGHT_SCREEN_EDGE;
+ if (con->rect.y == workspace->rect.y)
+ result |= ADJ_UPPER_SCREEN_EDGE;
+ if (con->rect.y + con->rect.height == workspace->rect.y + workspace->rect.height)
+ result |= ADJ_LOWER_SCREEN_EDGE;
+ return result;
+}
+
/*
* Use this function to get a container’s border style. This is important
* because when inside a stack, the border style is always BS_NORMAL.
*
*/
void con_set_layout(Con *con, int layout) {
+ DLOG("con_set_layout(%p, %d), con->type = %d\n",
+ con, layout, con->type);
+
+ /* Users can focus workspaces, but not any higher in the hierarchy.
+ * Focus on the workspace is a special case, since in every other case, the
+ * user means "change the layout of the parent split container". */
+ if (con->type != CT_WORKSPACE)
+ con = con->parent;
+
+ /* We fill in last_split_layout when switching to a different layout
+ * since there are many places in the code that don’t use
+ * con_set_layout(). */
+ if (con->layout == L_SPLITH || con->layout == L_SPLITV)
+ con->last_split_layout = con->layout;
+
/* When the container type is CT_WORKSPACE, the user wants to change the
* whole workspace into stacked/tabbed mode. To do this and still allow
* intuitive operations (like level-up and then opening a new window), we
* need to create a new split container. */
- if (con->type == CT_WORKSPACE) {
+ if (con->type == CT_WORKSPACE &&
+ (layout == L_STACKED || layout == L_TABBED)) {
DLOG("Creating new split container\n");
/* 1: create a new split container */
Con *new = con_new(NULL, NULL);
new->parent = con;
- /* 2: set the requested layout on the split con */
+ /* 2: Set the requested layout on the split container and mark it as
+ * split. */
new->layout = layout;
-
- /* 3: While the layout is irrelevant in stacked/tabbed mode, it needs
- * to be set. Otherwise, this con will not be interpreted as a split
- * container. */
- if (config.default_orientation == NO_ORIENTATION) {
- new->orientation = (con->rect.height > con->rect.width) ? VERT : HORIZ;
- } else {
- new->orientation = config.default_orientation;
- }
+ new->last_split_layout = con->last_split_layout;
+ new->split = true;
Con *old_focused = TAILQ_FIRST(&(con->focus_head));
if (old_focused == TAILQ_END(&(con->focus_head)))
old_focused = NULL;
- /* 4: move the existing cons of this workspace below the new con */
+ /* 3: move the existing cons of this workspace below the new con */
DLOG("Moving cons\n");
Con *child;
while (!TAILQ_EMPTY(&(con->nodes_head))) {
return;
}
- con->layout = layout;
+ if (layout == L_DEFAULT) {
+ /* Special case: the layout formerly known as "default" (in combination
+ * with an orientation). Since we switched to splith/splitv layouts,
+ * using the "default" layout (which "only" should happen when using
+ * legacy configs) is using the last split layout (either splith or
+ * splitv) in order to still do the same thing.
+ *
+ * Starting from v4.6 though, we will nag users about using "layout
+ * default", and in v4.9 we will remove it entirely (with an
+ * appropriate i3-migrate-config mechanism). */
+ con->layout = con->last_split_layout;
+ /* In case last_split_layout was not initialized… */
+ if (con->layout == L_DEFAULT)
+ con->layout = L_SPLITH;
+ } else {
+ con->layout = layout;
+ }
+}
+
+/*
+ * This function toggles the layout of a given container. toggle_mode can be
+ * either 'default' (toggle only between stacked/tabbed/last_split_layout),
+ * 'split' (toggle only between splitv/splith) or 'all' (toggle between all
+ * layouts).
+ *
+ */
+void con_toggle_layout(Con *con, const char *toggle_mode) {
+ Con *parent = con;
+ /* Users can focus workspaces, but not any higher in the hierarchy.
+ * Focus on the workspace is a special case, since in every other case, the
+ * user means "change the layout of the parent split container". */
+ if (con->type != CT_WORKSPACE)
+ parent = con->parent;
+ DLOG("con_toggle_layout(%p, %s), parent = %p\n", con, toggle_mode, parent);
+
+ if (strcmp(toggle_mode, "split") == 0) {
+ /* Toggle between splits. When the current layout is not a split
+ * layout, we just switch back to last_split_layout. Otherwise, we
+ * change to the opposite split layout. */
+ if (parent->layout != L_SPLITH && parent->layout != L_SPLITV)
+ con_set_layout(con, parent->last_split_layout);
+ else {
+ if (parent->layout == L_SPLITH)
+ con_set_layout(con, L_SPLITV);
+ else con_set_layout(con, L_SPLITH);
+ }
+ } else {
+ if (parent->layout == L_STACKED)
+ con_set_layout(con, L_TABBED);
+ else if (parent->layout == L_TABBED) {
+ if (strcmp(toggle_mode, "all") == 0)
+ con_set_layout(con, L_SPLITH);
+ else con_set_layout(con, parent->last_split_layout);
+ } else if (parent->layout == L_SPLITH || parent->layout == L_SPLITV) {
+ if (strcmp(toggle_mode, "all") == 0) {
+ /* When toggling through all modes, we toggle between
+ * splith/splitv, whereas normally we just directly jump to
+ * stacked. */
+ if (parent->layout == L_SPLITH)
+ con_set_layout(con, L_SPLITV);
+ else con_set_layout(con, L_STACKED);
+ } else {
+ con_set_layout(con, L_STACKED);
+ }
+ }
+ }
}
/*
/* For horizontal/vertical split containers we sum up the width (h-split)
* or height (v-split) and use the maximum of the height (h-split) or width
* (v-split) as minimum size. */
- if (con->orientation == HORIZ || con->orientation == VERT) {
+ if (con->split) {
uint32_t width = 0, height = 0;
Con *child;
TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
Rect min = con_minimum_size(child);
- if (con->orientation == HORIZ) {
+ if (con->layout == L_SPLITH) {
width += min.width;
height = max(height, min.height);
} else {
return (Rect){ 0, 0, width, height };
}
- ELOG("Unhandled case, type = %d, layout = %d, orientation = %d\n",
- con->type, con->layout, con->orientation);
+ ELOG("Unhandled case, type = %d, layout = %d, split = %d\n",
+ con->type, con->layout, con->split);
assert(false);
}
while (fs && fs->fullscreen_mode == CF_NONE)
fs = fs->parent;
+ /* fs must be non-NULL since the workspace con doesn’t have CF_NONE and
+ * there always has to be a workspace con in the hierarchy. */
+ assert(fs != NULL);
/* The most common case is we hit the workspace level. In this
* situation, changing focus is also harmless. */
assert(fs->fullscreen_mode != CF_NONE);
projects / i3 / i3 / blobdiff