* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2010 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
*
- * con.c contains all functions which deal with containers directly (creating
- * containers, searching containers, getting specific properties from
- * containers, …).
+ * con.c: Functions which deal with containers directly (creating containers,
+ * searching containers, getting specific properties from containers,
+ * …).
*
*/
#include "all.h"
cnt++;
if ((cnt % (sizeof(colors) / sizeof(char*))) == 0)
cnt = 0;
-
- x_con_init(new);
+ if (window)
+ x_con_init(new, window->depth);
+ else
+ x_con_init(new, XCB_COPY_FROM_PARENT);
TAILQ_INIT(&(new->floating_head));
TAILQ_INIT(&(new->nodes_head));
* workspace or a new split container with the configured
* workspace_layout).
*/
- if (con->window != NULL && parent->type == CT_WORKSPACE) {
+ if (con->window != NULL &&
+ parent->type == CT_WORKSPACE &&
+ config.default_layout != L_DEFAULT) {
DLOG("Parent is a workspace. Applying default layout...\n");
Con *target = workspace_attach_to(parent);
con->urgent = false;
workspace_update_urgent_flag(con_get_workspace(con));
}
- DLOG("con_focus done = %p\n", con);
}
/*
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 *con_for_window(Con *con, i3Window *window, Match **store_match) {
Con *child;
Match *match;
- DLOG("searching con for window %p starting at con %p\n", window, con);
- DLOG("class == %s\n", window->class_class);
+ //DLOG("searching con for window %p starting at con %p\n", window, con);
+ //DLOG("class == %s\n", window->class_class);
TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
TAILQ_FOREACH(match, &(child->swallow_head), matches) {
fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
}
if (fullscreen != NULL) {
- LOG("Not entering fullscreen mode, container (%p/%s) "
- "already is in fullscreen mode\n",
+ /* Disable fullscreen for the currently fullscreened
+ * container and enable it for the one the user wants
+ * to have in fullscreen mode. */
+ LOG("Disabling fullscreen for (%p/%s) upon user request\n",
fullscreen, fullscreen->name);
- goto update_netwm_state;
+ fullscreen->fullscreen_mode = CF_NONE;
}
/* 2: enable fullscreen */
con->fullscreen_mode = CF_NONE;
}
-update_netwm_state:
DLOG("mode now: %d\n", con->fullscreen_mode);
/* update _NET_WM_STATE if this container has a window */
return;
}
+ /* Prevent moving if this would violate the fullscreen focus restrictions. */
+ if (!con_fullscreen_permits_focusing(workspace)) {
+ LOG("Cannot move out of a fullscreen container");
+ return;
+ }
+
if (con_is_floating(con)) {
DLOG("Using FLOATINGCON instead\n");
con = con->parent;
}
+ Con *source_ws = con_get_workspace(con);
+ if (workspace == source_ws) {
+ DLOG("Not moving, already there\n");
+ return;
+ }
+
+ /* Save the current workspace. So we can call workspace_show() by the end
+ * of this function. */
+ Con *current_ws = con_get_workspace(focused);
+
Con *source_output = con_get_output(con),
*dest_output = con_get_output(workspace);
next = ws;
}
- /* If moving to a visible workspace, call show so it can be considered
- * focused. Must do before attaching because workspace_show checks to see
- * if focused container is in its area. */
- if (source_output != dest_output &&
- workspace_is_visible(workspace)) {
- workspace_show(workspace->name);
-
+ if (source_output != dest_output) {
+ /* Take the relative coordinates of the current output, then add them
+ * to the coordinate space of the correct output */
if (fix_coordinates && con->type == CT_FLOATING_CON) {
- DLOG("Floating window, fixing coordinates\n");
- /* Take the relative coordinates of the current output, then add them
- * to the coordinate space of the correct output */
- uint32_t rel_x = (con->rect.x - source_output->rect.x);
- uint32_t rel_y = (con->rect.y - source_output->rect.y);
- con->rect.x = dest_output->rect.x + rel_x;
- con->rect.y = dest_output->rect.y + rel_y;
+ floating_fix_coordinates(con, &(source_output->rect), &(dest_output->rect));
} else DLOG("Not fixing coordinates, fix_coordinates flag = %d\n", fix_coordinates);
- /* Don’t warp if told so (when dragging floating windows with the
- * mouse for example) */
- if (dont_warp)
- x_set_warp_to(NULL);
- else
- x_set_warp_to(&(con->rect));
+ /* If moving to a visible workspace, call show so it can be considered
+ * focused. Must do before attaching because workspace_show checks to see
+ * if focused container is in its area. */
+ if (workspace_is_visible(workspace)) {
+ workspace_show(workspace);
+
+ /* Don’t warp if told so (when dragging floating windows with the
+ * mouse for example) */
+ if (dont_warp)
+ x_set_warp_to(NULL);
+ else
+ x_set_warp_to(&(con->rect));
+ }
}
DLOG("Re-attaching container to %p / %s\n", next, next->name);
con_fix_percent(next);
/* 7: focus the con on the target workspace (the X focus is only updated by
- * calling tree_render(), so for the "real" focus this is a no-op). */
- con_focus(con_descend_focused(con));
+ * calling tree_render(), so for the "real" focus this is a no-op).
+ * We don’t focus the con for i3 pseudo workspaces like __i3_scratch and
+ * we don’t focus when there is a fullscreen con on that workspace. */
+ if ((workspace->name[0] != '_' || workspace->name[1] != '_') &&
+ con_get_fullscreen_con(workspace, CF_OUTPUT) == NULL)
+ con_focus(con_descend_focused(con));
/* 8: when moving to a visible workspace on a different output, we keep the
* con focused. Otherwise, we leave the focus on the current workspace as we
/* Descend focus stack in case focus_next is a workspace which can
* occur if we move to the same workspace. Also show current workspace
* to ensure it is focused. */
- workspace_show(con_get_workspace(focus_next)->name);
- con_focus(con_descend_focused(focus_next));
+ workspace_show(current_ws);
+
+ /* Set focus only if con was on current workspace before moving.
+ * Otherwise we would give focus to some window on different workspace. */
+ if (source_ws == current_ws)
+ con_focus(con_descend_focused(focus_next));
}
CALL(parent, on_remove_child);
*
*/
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);
+ }
}
/*
*/
Con *con_descend_focused(Con *con) {
Con *next = con;
- while (!TAILQ_EMPTY(&(next->focus_head)))
+ while (next != focused && !TAILQ_EMPTY(&(next->focus_head)))
next = TAILQ_FIRST(&(next->focus_head));
return next;
}
Con *next = con;
Con *before;
Con *child;
+ if (next == focused)
+ return next;
do {
before = next;
TAILQ_FOREACH(child, &(next->focus_head), focused) {
next = child;
break;
}
- } while (before != next);
+ } while (before != next && next != focused);
return next;
}
*/
Con *con_descend_direction(Con *con, direction_t direction) {
Con *most = NULL;
- DLOG("con_descend_direction(%p, %d)\n", con, direction);
+ int orientation = con_orientation(con);
+ DLOG("con_descend_direction(%p, orientation %d, direction %d)\n", con, orientation, direction);
if (direction == D_LEFT || direction == D_RIGHT) {
- if (con->orientation == HORIZ) {
+ if (orientation == HORIZ) {
/* If the direction is horizontal, we can use either the first
* (D_RIGHT) or the last con (D_LEFT) */
if (direction == D_RIGHT)
most = TAILQ_FIRST(&(con->nodes_head));
else most = TAILQ_LAST(&(con->nodes_head), nodes_head);
- } else if (con->orientation == VERT) {
+ } else if (orientation == VERT) {
/* Wrong orientation. We use the last focused con. Within that con,
* we recurse to chose the left/right con or at least the last
* focused one. */
}
if (direction == D_UP || direction == D_DOWN) {
- if (con->orientation == VERT) {
+ if (orientation == VERT) {
/* If the direction is vertical, we can use either the first
* (D_DOWN) or the last con (D_UP) */
if (direction == D_UP)
most = TAILQ_LAST(&(con->nodes_head), nodes_head);
else most = TAILQ_FIRST(&(con->nodes_head));
- } else if (con->orientation == HORIZ) {
+ } else if (orientation == HORIZ) {
/* Wrong orientation. We use the last focused con. Within that con,
* we recurse to chose the top/bottom con or at least the last
* focused one. */
return con->border_style;
}
+/*
+ * Sets the given border style on con, correctly keeping the position/size of a
+ * floating window.
+ *
+ */
+void con_set_border_style(Con *con, int border_style) {
+ /* Handle the simple case: non-floating containerns */
+ if (!con_is_floating(con)) {
+ con->border_style = border_style;
+ return;
+ }
+
+ /* For floating containers, we want to keep the position/size of the
+ * *window* itself. We first add the border pixels to con->rect to make
+ * con->rect represent the absolute position of the window. Then, we change
+ * the border and subtract the new border pixels. Afterwards, we update
+ * parent->rect to contain con. */
+ DLOG("This is a floating container\n");
+
+ Rect bsr = con_border_style_rect(con);
+ con->rect.x += bsr.x;
+ con->rect.y += bsr.y;
+ con->rect.width += bsr.width;
+ con->rect.height += bsr.height;
+
+ /* Change the border style, get new border/decoration values. */
+ con->border_style = border_style;
+ bsr = con_border_style_rect(con);
+ int deco_height =
+ (con->border_style == BS_NORMAL ? config.font.height + 5 : 0);
+
+ con->rect.x -= bsr.x;
+ con->rect.y -= bsr.y;
+ con->rect.width -= bsr.width;
+ con->rect.height -= bsr.height;
+
+ Con *parent = con->parent;
+ parent->rect.x = con->rect.x;
+ parent->rect.y = con->rect.y - deco_height;
+ parent->rect.width = con->rect.width;
+ parent->rect.height = con->rect.height + deco_height;
+}
+
/*
* This function changes the layout of a given container. Use it to handle
* special cases like changing a whole workspace to stacked/tabbed (creates a
Con *new = con_new(NULL, NULL);
new->parent = con;
- /* 2: set the requested layout on the split con */
- 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;
- }
+ /* 2: Set the requested layout on the split container and mark it as
+ * split. */
+ con_set_layout(new, 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 {
+ /* 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;
+ 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) {
+ 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 (con->layout != L_SPLITH && con->layout != L_SPLITV)
+ con_set_layout(con, con->last_split_layout);
+ else {
+ if (con->layout == L_SPLITH)
+ con_set_layout(con, L_SPLITV);
+ else con_set_layout(con, L_SPLITH);
+ }
+ } else {
+ if (con->layout == L_STACKED)
+ con_set_layout(con, L_TABBED);
+ else if (con->layout == L_TABBED) {
+ if (strcmp(toggle_mode, "all") == 0)
+ con_set_layout(con, L_SPLITH);
+ else con_set_layout(con, con->last_split_layout);
+ } else if (con->layout == L_SPLITH || con->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 (con->layout == L_SPLITH)
+ con_set_layout(con, L_SPLITV);
+ else con_set_layout(con, L_STACKED);
+ } else {
+ con_set_layout(con, L_STACKED);
+ }
+ }
+ }
}
/*
/* Every container 'above' (in the hierarchy) the workspace content should
* not be closed when the last child was removed */
- if (con->type == CT_WORKSPACE ||
- con->type == CT_OUTPUT ||
+ if (con->type == CT_OUTPUT ||
con->type == CT_ROOT ||
con->type == CT_DOCKAREA) {
DLOG("not handling, type = %d\n", con->type);
return;
}
+ /* For workspaces, close them only if they're not visible anymore */
+ if (con->type == CT_WORKSPACE) {
+ if (TAILQ_EMPTY(&(con->focus_head)) && !workspace_is_visible(con)) {
+ LOG("Closing old workspace (%p / %s), it is empty\n", con, con->name);
+ tree_close(con, DONT_KILL_WINDOW, false, false);
+ ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"empty\"}");
+ }
+ return;
+ }
+
/* TODO: check if this container would swallow any other client and
* don’t close it automatically. */
int children = con_num_children(con);
if (children == 0) {
DLOG("Container empty, closing\n");
- tree_close(con, DONT_KILL_WINDOW, false);
+ tree_close(con, DONT_KILL_WINDOW, false, false);
return;
}
}
/* 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);
}
+
+/*
+ * Returns true if changing the focus to con would be allowed considering
+ * the fullscreen focus constraints. Specifically, if a fullscreen container or
+ * any of its descendants is focused, this function returns true if and only if
+ * focusing con would mean that focus would still be visible on screen, i.e.,
+ * the newly focused container would not be obscured by a fullscreen container.
+ *
+ * In the simplest case, if a fullscreen container or any of its descendants is
+ * fullscreen, this functions returns true if con is the fullscreen container
+ * itself or any of its descendants, as this means focus wouldn't escape the
+ * boundaries of the fullscreen container.
+ *
+ * In case the fullscreen container is of type CF_OUTPUT, this function returns
+ * true if con is on a different workspace, as focus wouldn't be obscured by
+ * the fullscreen container that is constrained to a different workspace.
+ *
+ * Note that this same logic can be applied to moving containers. If a
+ * container can be focused under the fullscreen focus constraints, it can also
+ * become a parent or sibling to the currently focused container.
+ *
+ */
+bool con_fullscreen_permits_focusing(Con *con) {
+ /* No focus, no problem. */
+ if (!focused)
+ return true;
+
+ /* Find the first fullscreen ascendent. */
+ Con *fs = focused;
+ 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);
+ if (fs->type == CT_WORKSPACE)
+ return true;
+
+ /* Allow it if the container itself is the fullscreen container. */
+ if (con == fs)
+ return true;
+
+ /* If fullscreen is per-output, the focus being in a different workspace is
+ * sufficient to guarantee that change won't leave fullscreen in bad shape. */
+ if (fs->fullscreen_mode == CF_OUTPUT &&
+ con_get_workspace(con) != con_get_workspace(fs)) {
+ return true;
+ }
+
+ /* Allow it only if the container to be focused is contained within the
+ * current fullscreen container. */
+ do {
+ if (con->parent == fs)
+ return true;
+ con = con->parent;
+ } while (con);
+
+ /* Focusing con would hide it behind a fullscreen window, disallow it. */
+ return false;
+}
projects / i3 / i3 / blobdiff