* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
*
* move.c: Moving containers into some direction.
*
*/
#include "all.h"
-typedef enum { BEFORE, AFTER } position_t;
+/*
+ * Returns the lowest container in the tree that has both a and b as descendants.
+ *
+ */
+static Con *lowest_common_ancestor(Con *a, Con *b) {
+ Con *parent_a = a;
+ while (parent_a) {
+ Con *parent_b = b;
+ while (parent_b) {
+ if (parent_a == parent_b) {
+ return parent_a;
+ }
+ parent_b = parent_b->parent;
+ }
+ parent_a = parent_a->parent;
+ }
+ assert(false);
+}
+
+/*
+ * Returns the direct child of ancestor that contains con.
+ *
+ */
+static Con *child_containing_con_recursively(Con *ancestor, Con *con) {
+ Con *child = con;
+ while (child && child->parent != ancestor) {
+ child = child->parent;
+ assert(child->parent);
+ }
+ return child;
+}
+
+/*
+ * Returns true if the given container is the focused descendant of ancestor, recursively.
+ *
+ */
+static bool is_focused_descendant(Con *con, Con *ancestor) {
+ Con *current = con;
+ while (current != ancestor) {
+ if (TAILQ_FIRST(&(current->parent->focus_head)) != current) {
+ return false;
+ }
+ current = current->parent;
+ assert(current->parent);
+ }
+ return true;
+}
/*
* This function detaches 'con' from its parent and inserts it either before or
* after 'target'.
*
*/
-static void insert_con_into(Con *con, Con *target, position_t position) {
+void insert_con_into(Con *con, Con *target, position_t position) {
Con *parent = target->parent;
/* We need to preserve the old con->parent. While it might still be used to
* insert the entry before/after it, we call the on_remove_child callback
* afterwards which might then close the con if it is empty. */
Con *old_parent = con->parent;
+ /* We compare the focus order of the children of the lowest common ancestor. If con or
+ * its ancestor is before target's ancestor then con should be placed before the target
+ * in the focus stack. */
+ Con *lca = lowest_common_ancestor(con, parent);
+ if (lca == con) {
+ ELOG("Container is being inserted into one of its descendants.\n");
+ return;
+ }
+
+ Con *con_ancestor = child_containing_con_recursively(lca, con);
+ Con *target_ancestor = child_containing_con_recursively(lca, target);
+ bool moves_focus_from_ancestor = is_focused_descendant(con, con_ancestor);
+ bool focus_before;
+
+ /* Determine if con is going to be placed before or after target in the parent's focus stack. */
+ if (con_ancestor == target_ancestor) {
+ /* Happens when the target is con's old parent. Eg with layout V [ A H [ B C ] ],
+ * if we move C up. Target will be H. */
+ focus_before = moves_focus_from_ancestor;
+ } else {
+ /* Look at the focus stack order of the children of the lowest common ancestor. */
+ Con *current;
+ TAILQ_FOREACH(current, &(lca->focus_head), focused) {
+ if (current == con_ancestor || current == target_ancestor) {
+ break;
+ }
+ }
+ focus_before = (current == con_ancestor);
+ }
+
+ /* If con is the focused container in our old ancestor we place the new ancestor
+ * before the old ancestor in the focus stack. Example:
+ * Consider the layout [ H [ V1 [ A* B ] V2 [ C ] ] ] where A is focused. We move to
+ * a second workspace and from there we move A to the right and switch back to the
+ * original workspace. Without the change focus would move to B instead of staying
+ * with A. */
+ if (moves_focus_from_ancestor && focus_before) {
+ Con *place = TAILQ_PREV(con_ancestor, focus_head, focused);
+ TAILQ_REMOVE(&(lca->focus_head), target_ancestor, focused);
+ if (place) {
+ TAILQ_INSERT_AFTER(&(lca->focus_head), place, target_ancestor, focused);
+ } else {
+ TAILQ_INSERT_HEAD(&(lca->focus_head), target_ancestor, focused);
+ }
+ }
+
con_detach(con);
con_fix_percent(con->parent);
con->parent = parent;
+ if (parent == lca) {
+ if (focus_before) {
+ /* Example layout: H [ A B* ], we move A up/down. 'target' will be H. */
+ TAILQ_INSERT_BEFORE(target, con, focused);
+ } else {
+ /* Example layout: H [ A B* ], we move A up/down. 'target' will be H. */
+ TAILQ_INSERT_AFTER(&(parent->focus_head), target, con, focused);
+ }
+ } else {
+ if (focus_before) {
+ /* Example layout: V [ H [ A B ] C* ], we move C up. 'target' will be A. */
+ TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
+ } else {
+ /* Example layout: V [ H [ A* B ] C ], we move C up. 'target' will be A. */
+ TAILQ_INSERT_TAIL(&(parent->focus_head), con, focused);
+ }
+ }
+
if (position == BEFORE) {
TAILQ_INSERT_BEFORE(target, con, nodes);
- TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
} else if (position == AFTER) {
TAILQ_INSERT_AFTER(&(parent->nodes_head), target, con, nodes);
- TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
}
/* Pretend the con was just opened with regards to size percent values.
}
/*
- * This function detaches 'con' from its parent and inserts it at the given
- * workspace.
+ * This function detaches 'con' from its parent and puts it in the given
+ * workspace. Position is determined by the direction of movement into the
+ * workspace container.
*
*/
-static void attach_to_workspace(Con *con, Con *ws) {
+static void attach_to_workspace(Con *con, Con *ws, direction_t direction) {
con_detach(con);
con_fix_percent(con->parent);
con->parent = ws;
- TAILQ_INSERT_TAIL(&(ws->nodes_head), con, nodes);
- TAILQ_INSERT_TAIL(&(ws->focus_head), con, focused);
+ if (direction == D_RIGHT || direction == D_DOWN) {
+ TAILQ_INSERT_HEAD(&(ws->nodes_head), con, nodes);
+ TAILQ_INSERT_HEAD(&(ws->focus_head), con, focused);
+ } else {
+ TAILQ_INSERT_TAIL(&(ws->nodes_head), con, nodes);
+ TAILQ_INSERT_TAIL(&(ws->focus_head), con, focused);
+ }
/* Pretend the con was just opened with regards to size percent values.
* Since the con is moved to a completely different con, the old value
}
/*
- * Moves the current container in the given direction (D_LEFT, D_RIGHT,
+ * Moves the given container to the closest output in the given direction if
+ * such an output exists.
+ *
+ */
+static void move_to_output_directed(Con *con, direction_t direction) {
+ Con *old_ws = con_get_workspace(con);
+ Output *current_output = get_output_for_con(con);
+ Output *output = get_output_next(direction, current_output, CLOSEST_OUTPUT);
+
+ if (!output) {
+ DLOG("No output in this direction found. Not moving.\n");
+ return;
+ }
+
+ Con *ws = NULL;
+ GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
+
+ if (!ws) {
+ DLOG("No workspace on output in this direction found. Not moving.\n");
+ return;
+ }
+
+ attach_to_workspace(con, ws, direction);
+
+ /* fix the focus stack */
+ con_activate(con);
+
+ /* force re-painting the indicators */
+ FREE(con->deco_render_params);
+
+ tree_flatten(croot);
+
+ ipc_send_workspace_event("focus", ws, old_ws);
+}
+
+/*
+ * Moves the given container in the given direction (D_LEFT, D_RIGHT,
* D_UP, D_DOWN).
*
*/
-void tree_move(int direction) {
+void tree_move(Con *con, int direction) {
+ position_t position;
+ Con *target;
+
DLOG("Moving in direction %d\n", direction);
+
/* 1: get the first parent with the same orientation */
- Con *con = focused;
if (con->type == CT_WORKSPACE) {
DLOG("Not moving workspace\n");
return;
}
- if (con->parent->type == CT_WORKSPACE && con_num_children(con->parent) == 1) {
- DLOG("This is the only con on this workspace, not doing anything\n");
+ if (con->fullscreen_mode == CF_GLOBAL) {
+ DLOG("Not moving fullscreen global container\n");
+ return;
+ }
+
+ if ((con->fullscreen_mode == CF_OUTPUT) ||
+ (con->parent->type == CT_WORKSPACE && con_num_children(con->parent) == 1)) {
+ /* This is the only con on this workspace */
+ move_to_output_directed(con, direction);
return;
}
if (con_inside_floating(con)) {
/* 'con' should be moved out of a floating container */
DLOG("Inside floating, moving to workspace\n");
- attach_to_workspace(con, con_get_workspace(con));
+ attach_to_workspace(con, con_get_workspace(con), direction);
goto end;
}
DLOG("Force-changing orientation\n");
if (same_orientation == con->parent) {
DLOG("We are in the same container\n");
Con *swap;
- if ((swap = (direction == D_LEFT || direction == D_UP ?
- TAILQ_PREV(con, nodes_head, nodes) :
- TAILQ_NEXT(con, nodes)))) {
+ if ((swap = (direction == D_LEFT || direction == D_UP ? TAILQ_PREV(con, nodes_head, nodes) : TAILQ_NEXT(con, nodes)))) {
if (!con_is_leaf(swap)) {
- insert_con_into(con, con_descend_focused(swap), AFTER);
+ DLOG("Moving into our bordering branch\n");
+ target = con_descend_direction(swap, direction);
+ position = (con_orientation(target->parent) != o ||
+ direction == D_UP ||
+ direction == D_LEFT
+ ? AFTER
+ : BEFORE);
+ insert_con_into(con, target, position);
goto end;
}
if (direction == D_LEFT || direction == D_UP)
TAILQ_SWAP(swap, con, &(swap->parent->nodes_head), nodes);
- else TAILQ_SWAP(con, swap, &(swap->parent->nodes_head), nodes);
+ else
+ TAILQ_SWAP(con, swap, &(swap->parent->nodes_head), nodes);
TAILQ_REMOVE(&(con->parent->focus_head), con, focused);
TAILQ_INSERT_HEAD(&(swap->parent->focus_head), con, focused);
DLOG("Swapped.\n");
+ ipc_send_window_event("move", con);
+ ewmh_update_wm_desktop();
return;
}
- /* If there was no con with which we could swap the current one, search
- * again, but starting one level higher. If we are on the workspace
- * level, don’t do that. The result would be a force change of
- * workspace orientation, which is not necessary. */
- if (con->parent == con_get_workspace(con))
+ if (con->parent == con_get_workspace(con)) {
+ /* If we couldn't find a place to move it on this workspace,
+ * try to move it to a workspace on a different output */
+ move_to_output_directed(con, direction);
+ ipc_send_window_event("move", con);
+ ewmh_update_wm_desktop();
return;
+ }
+
+ /* If there was no con with which we could swap the current one,
+ * search again, but starting one level higher. */
same_orientation = con_parent_with_orientation(con->parent, o);
}
} while (same_orientation == NULL);
}
DLOG("above = %p\n", above);
- Con *next;
- position_t position;
- if (direction == D_UP || direction == D_LEFT) {
- position = BEFORE;
- next = TAILQ_PREV(above, nodes_head, nodes);
- } else {
- position = AFTER;
- next = TAILQ_NEXT(above, nodes);
- }
- /* special case: there is a split container in the direction we are moving
- * to, so descend and append */
- if (next && !con_is_leaf(next))
- insert_con_into(con, con_descend_focused(next), AFTER);
- else
+ Con *next = (direction == D_UP || direction == D_LEFT ? TAILQ_PREV(above, nodes_head, nodes) : TAILQ_NEXT(above, nodes));
+
+ if (next && !con_is_leaf(next)) {
+ DLOG("Moving into the bordering branch of our adjacent container\n");
+ target = con_descend_direction(next, direction);
+ position = (con_orientation(target->parent) != o ||
+ direction == D_UP ||
+ direction == D_LEFT
+ ? AFTER
+ : BEFORE);
+ insert_con_into(con, target, position);
+ } else if (!next &&
+ con->parent->parent->type == CT_WORKSPACE &&
+ con->parent->layout != L_DEFAULT &&
+ con_num_children(con->parent) == 1) {
+ /* Con is the lone child of a non-default layout container at the edge
+ * of the workspace. Treat it as though the workspace is its parent
+ * and move it to the next output. */
+ DLOG("Grandparent is workspace\n");
+ move_to_output_directed(con, direction);
+ } else {
+ DLOG("Moving into container above\n");
+ position = (direction == D_UP || direction == D_LEFT ? BEFORE : AFTER);
insert_con_into(con, above, position);
+ }
end:
- /* We need to call con_focus() to fix the focus stack "above" the container
- * we just inserted the focused container into (otherwise, the parent
- * container(s) would still point to the old container(s)). */
- con_focus(con);
-
/* force re-painting the indicators */
FREE(con->deco_render_params);
tree_flatten(croot);
+ ipc_send_window_event("move", con);
+ ewmh_update_wm_desktop();
}