/*
* 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);
Con *current_output_con = con_get_output(con);
Output *current_output = get_output_by_name(current_output_con->name);
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_focus(con);
/* force re-painting the indicators */
FREE(con->deco_render_params);
tree_flatten(croot);
ipc_send_workspace_event("focus", ws, old_ws);
}
void test_flatten(void) {
Cell *c, *t;
char *s;
c = cell_nil;
check(cell_nullp(tree_flatten(c)));
c = cell_cons_string("one", cell_nil);
t = tree_flatten(c);
s = cell_asprint(t);
fprintf(stderr, "tree_flatten %s ==> %s\n", cell_asprint(c), s);
check(streq(s, "(one)"));
c = cell_cons_string("two", c);
t = tree_flatten(c);
s = cell_asprint(t);
fprintf(stderr, "tree_flatten %s ==> %s\n", cell_asprint(c), s);
check(streq(s, "(two one)"));
c = cell_cons(c, cell_nil);
t = tree_flatten(c);
s = cell_asprint(t);
fprintf(stderr, "tree_flatten %s ==> %s\n", cell_asprint(c), s);
check(streq(s, "(two one)"));
c = cell_cons_string("three", c);
t = tree_flatten(c);
s = cell_asprint(t);
fprintf(stderr, "tree_flatten %s ==> %s\n", cell_asprint(c), s);
check(streq(s, "(three two one)"));
c = cell_cons(c, c);
t = tree_flatten(c);
s = cell_asprint(t);
fprintf(stderr, "tree_flatten %s ==> %s\n", cell_asprint(c), s);
check(streq(s, "(three two one three two one)"));
c = fbbq();
c = cell_cons(cell_nil, c);
t = tree_flatten(c);
s = cell_asprint(t);
fprintf(stderr, "tree_flatten %s ==> %s\n", cell_asprint(c), s);
check(streq(s, "(foo bar baz qux)"));
}
/*
* Moves the given container in the given direction (D_LEFT, D_RIGHT,
* D_UP, D_DOWN).
*
*/
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 */
if (con->type == CT_WORKSPACE) {
DLOG("Not moving workspace\n");
return;
}
if (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;
}
orientation_t o = (direction == D_LEFT || direction == D_RIGHT ? HORIZ : VERT);
Con *same_orientation = con_parent_with_orientation(con, o);
/* The do {} while is used to 'restart' at this point with a different
* same_orientation, see the very last lines before the end of this block
* */
do {
/* There is no parent container with the same orientation */
if (!same_orientation) {
if (con_is_floating(con)) {
/* this is a floating con, we just disable floating */
floating_disable(con, true);
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), direction);
goto end;
}
DLOG("Force-changing orientation\n");
ws_force_orientation(con_get_workspace(con), o);
same_orientation = con_parent_with_orientation(con, o);
}
/* easy case: the move is within this container */
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 (!con_is_leaf(swap)) {
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);
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 (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);
/* this time, we have to move to another container */
/* This is the container *above* 'con' (an ancestor of con) which is inside
* 'same_orientation' */
Con *above = con;
while (above->parent != same_orientation)
above = above->parent;
/* Enforce the fullscreen focus restrictions. */
if (!con_fullscreen_permits_focusing(above->parent)) {
LOG("Cannot move out of fullscreen container\n");
return;
}
DLOG("above = %p\n", above);
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 (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();
}