From 6222ab108465c8f3f033acc1db5276b28af27b27 Mon Sep 17 00:00:00 2001 From: Orestis Floros Date: Sat, 23 Sep 2017 19:23:49 +0300 Subject: [PATCH 1/2] Correct insert_con_into's focus handling Change from always putting con on the head of the new parent. Important for moving unfocused containers. --- src/move.c | 114 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 112 insertions(+), 2 deletions(-) diff --git a/src/move.c b/src/move.c index 97ca6d40..72cf9d61 100644 --- a/src/move.c +++ b/src/move.c @@ -12,6 +12,54 @@ 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'. @@ -24,6 +72,52 @@ static void insert_con_into(Con *con, Con *target, position_t position) { * 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); @@ -46,12 +140,28 @@ static void insert_con_into(Con *con, Con *target, position_t position) { 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. From d66fa51f336378c55e266c8aa2ba5fbec64d6a73 Mon Sep 17 00:00:00 2001 From: Orestis Floros Date: Fri, 22 Sep 2017 04:48:32 +0300 Subject: [PATCH 2/2] Don't call con_focus in tree_move Fixes: - Issue where moving an urgent (unfocused) window resets it's urgency hint. - Moving an unfocused container to a new parent should not move it to the top of the focus stack. --- src/move.c | 5 ----- testcases/t/113-urgent.t | 28 ++++++++++++++++++++++++++++ testcases/t/294-focus-order.t | 16 ++++++++++++++++ 3 files changed, 44 insertions(+), 5 deletions(-) diff --git a/src/move.c b/src/move.c index 72cf9d61..a60a27ca 100644 --- a/src/move.c +++ b/src/move.c @@ -374,11 +374,6 @@ void tree_move(Con *con, int direction) { } 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); diff --git a/testcases/t/113-urgent.t b/testcases/t/113-urgent.t index 1e2644ad..0de90193 100644 --- a/testcases/t/113-urgent.t +++ b/testcases/t/113-urgent.t @@ -332,6 +332,34 @@ for ($type = 1; $type <= 2; $type++) { ok(!$source_ws->{urgent}, 'Source workspace is no longer marked urgent'); is($target_ws->{urgent}, 1, 'Target workspace is now marked urgent'); +############################################################################## +# Test that moving an unfocused container doesn't reset its urgency hint. +############################################################################## + $tmp = fresh_workspace; + $win1 = open_window; + $win2 = open_window; + cmd 'split v'; + $win3 = open_window; + set_urgency($win1, 1, $type); + sync_with_i3; + + my $win1_info; + + @content = @{get_ws_content($tmp)}; + $win1_info = first { $_->{window} == $win1->id } @content; + ok($win1_info->{urgent}, 'win1 window is marked urgent'); + + cmd '[id="' . $win1->id . '"] move right'; + cmd '[id="' . $win1->id . '"] move right'; + @content = @{get_ws_content($tmp)}; + $win1_info = first { $_->{window} == $win1->id } @content; + ok($win1_info->{urgent}, 'win1 window is still marked urgent after moving'); + + cmd '[id="' . $win1->id . '"] focus'; + @content = @{get_ws_content($tmp)}; + $win1_info = first { $_->{window} == $win1->id } @content; + ok(!$win1_info->{urgent}, 'win1 window is not marked urgent after focusing'); + ############################################################################## exit_gracefully($pid); diff --git a/testcases/t/294-focus-order.t b/testcases/t/294-focus-order.t index 41c0bf07..0f116241 100644 --- a/testcases/t/294-focus-order.t +++ b/testcases/t/294-focus-order.t @@ -106,4 +106,20 @@ $windows[0] = open_window; cmd 'move left'; confirm_focus('split-v + move'); +###################################################################### +# Test that moving an unfocused container maintains the correct focus +# order. +# Layout: H [ A V1 [ B C D ] ] +###################################################################### + +fresh_workspace; +$windows[3] = open_window; +$windows[2] = open_window; +cmd 'split v'; +$windows[1] = open_window; +$windows[0] = open_window; + +cmd '[id=' . $windows[3]->id . '] move right'; +confirm_focus('split-v + unfocused move'); + done_testing;