bool resize_find_tiling_participants(Con **current, Con **other, direction_t direction) {
DLOG("Find two participants for resizing container=%p in direction=%i\n", other, direction);
Con *first = *current;
Con *second = NULL;
if (first == NULL) {
DLOG("Current container is NULL, aborting.\n");
return false;
}
/* Go up in the tree and search for a container to resize */
const orientation_t search_orientation = ((direction == D_LEFT || direction == D_RIGHT) ? HORIZ : VERT);
const bool dir_backwards = (direction == D_UP || direction == D_LEFT);
while (first->type != CT_WORKSPACE &&
first->type != CT_FLOATING_CON &&
second == NULL) {
/* get the appropriate first container with the matching
* orientation (skip stacked/tabbed cons) */
if ((con_orientation(first->parent) != search_orientation) ||
(first->parent->layout == L_STACKED) ||
(first->parent->layout == L_TABBED)) {
first = first->parent;
continue;
}
/* get the counterpart for this resizement */
if (dir_backwards) {
second = TAILQ_PREV(first, nodes_head, nodes);
} else {
second = TAILQ_NEXT(first, nodes);
}
if (second == NULL) {
DLOG("No second container in this direction found, trying to look further up in the tree...\n");
first = first->parent;
}
}
DLOG("Found participants: first=%p and second=%p.", first, second);
*current = first;
*other = second;
if (first == NULL || second == NULL) {
DLOG("Could not find two participants for this resize request.\n");
return false;
}
return true;
}
/*
* 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();
}