X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fmove.c;h=42510d520823ec98e4dfcbb0edd116bb282ca444;hb=92000942039fa99d7334ca5099b467b0d3d17792;hp=d110312aa57ab9b916b9cfe3073b96943b73a6ea;hpb=f28afc8f6b43ad6ee9ff8cbd4ffaa70d5ae343ca;p=i3%2Fi3 diff --git a/src/move.c b/src/move.c index d110312a..42510d52 100644 --- a/src/move.c +++ b/src/move.c @@ -1,3 +1,5 @@ +#undef I3__FILE__ +#define I3__FILE__ "move.c" /* * vim:ts=4:sw=4:expandtab * @@ -9,7 +11,8 @@ */ #include "all.h" -typedef enum { BEFORE, AFTER } position_t; +typedef enum { BEFORE, + AFTER } position_t; /* * This function detaches 'con' from its parent and inserts it either before or @@ -63,11 +66,12 @@ static void insert_con_into(Con *con, Con *target, position_t position) { } /* - * 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); @@ -75,8 +79,13 @@ static void attach_to_workspace(Con *con, Con *ws) { 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 @@ -85,13 +94,54 @@ static void attach_to_workspace(Con *con, Con *ws) { con_fix_percent(ws); } +/* + * 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_focus_event(ws, old_ws); +} + /* * Moves the current container in the given direction (D_LEFT, D_RIGHT, * D_UP, D_DOWN). * */ void tree_move(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; @@ -101,7 +151,8 @@ void tree_move(int direction) { } 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"); + /* This is the only con on this workspace */ + move_to_output_directed(con, direction); return; } @@ -122,7 +173,7 @@ void tree_move(int direction) { 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"); @@ -134,16 +185,22 @@ void tree_move(int direction) { 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); @@ -152,12 +209,15 @@ void tree_move(int direction) { 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); 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); @@ -176,22 +236,23 @@ void tree_move(int direction) { } 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 { + 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