koma/i3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2941 from orestisf1993/issue-2938

Browse Source 
Fix focus order in floating_disable & floating_enable for unfocused windows
This commit is contained in:
Ingo Bürk
2018-03-31 20:34:17 +02:00
committed by GitHub
parent 8a805cdd5c 791e407fd3
commit 666aa9e0dd
6 changed files with 286 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/con.c
View File

@ -1436,40 +1436,6 @@ orientation_t con_orientation(Con *con) {
*
*/
Con *con_next_focused(Con *con) {
Con *next;
/* floating containers are attached to a workspace, so we focus either the
* next floating container (if any) or the workspace itself. */
if (con->type == CT_FLOATING_CON) {
DLOG("selecting next for CT_FLOATING_CON\n");
next = TAILQ_NEXT(con, floating_windows);
DLOG("next = %p\n", next);
if (!next) {
next = TAILQ_PREV(con, floating_head, floating_windows);
DLOG("using prev, next = %p\n", next);
}
if (!next) {
Con *ws = con_get_workspace(con);
next = ws;
DLOG("no more floating containers for next = %p, restoring workspace focus\n", next);
while (next != TAILQ_END(&(ws->focus_head)) && !TAILQ_EMPTY(&(next->focus_head))) {
next = TAILQ_FIRST(&(next->focus_head));
if (next == con) {
DLOG("skipping container itself, we want the next client\n");
next = TAILQ_NEXT(next, focused);
}
}
if (next == TAILQ_END(&(ws->focus_head))) {
DLOG("Focus list empty, returning ws\n");
next = ws;
}
} else {
/* Instead of returning the next CT_FLOATING_CON, we descend it to
* get an actual window to focus. */
next = con_descend_focused(next);
}
return next;
}
/* dock clients cannot be focused, so we focus the workspace instead */
if (con->parent->type == CT_DOCKAREA) {
DLOG("selecting workspace for dock client\n");
@ -1478,10 +1444,9 @@ Con *con_next_focused(Con *con) {
/* if 'con' is not the first entry in the focus stack, use the first one as
* it’s currently focused already */
Con *first = TAILQ_FIRST(&(con->parent->focus_head));
if (first != con) {
DLOG("Using first entry %p\n", first);
next = first;
Con *next = TAILQ_FIRST(&(con->parent->focus_head));
if (next != con) {
DLOG("Using first entry %p\n", next);
} else {
/* try to focus the next container on the same level as this one or fall
* back to its parent */
@ -1496,6 +1461,10 @@ Con *con_next_focused(Con *con) {
next = TAILQ_FIRST(&(next->focus_head));
}
if (con->type == CT_FLOATING_CON && next != con->parent) {
next = con_descend_focused(next);
}
return next;
}

97
src/floating.c
View File

@ -176,11 +176,36 @@ void floating_enable(Con *con, bool automatic) {
return;
}
Con *focus_head_placeholder = NULL;
bool focus_before_parent = true;
if (!set_focus) {
/* Find recursively the ancestor container which is a child of our workspace.
* We need to reuse its focus position later. */
Con *ancestor = con;
while (ancestor->parent->type != CT_WORKSPACE) {
focus_before_parent &= TAILQ_FIRST(&(ancestor->parent->focus_head)) == ancestor;
ancestor = ancestor->parent;
}
/* Consider the part of the focus stack of our current workspace:
* [ ... S_{i-1} S_{i} S_{i+1} ... ]
* Where S_{x} is a container tree and the container 'con' that is beeing switched to
* floating belongs in S_{i}. The new floating container, 'nc', will have the
* workspace as its parent so it needs to be placed in this stack. If C was focused
* we just need to call con_focus(). Otherwise, nc must be placed before or after S_{i}.
* We should avoid using the S_{i} container for our operations since it might get
* killed if it has no other children. So, the two possible positions are after S_{i-1}
* or before S_{i+1}.
*/
if (focus_before_parent) {
focus_head_placeholder = TAILQ_PREV(ancestor, focus_head, focused);
} else {
focus_head_placeholder = TAILQ_NEXT(ancestor, focused);
}
}
/* 1: detach the container from its parent */
/* TODO: refactor this with tree_close_internal() */
TAILQ_REMOVE(&(con->parent->nodes_head), con, nodes);
TAILQ_REMOVE(&(con->parent->focus_head), con, focused);
con_detach(con);
con_fix_percent(con->parent);
/* 2: create a new container to render the decoration on, add
@ -196,12 +221,23 @@ void floating_enable(Con *con, bool automatic) {
/* We insert nc already, even though its rect is not yet calculated. This
* is necessary because otherwise the workspace might be empty (and get
* closed in tree_close_internal()) even though it’s not. */
if (set_focus) {
TAILQ_INSERT_TAIL(&(ws->floating_head), nc, floating_windows);
TAILQ_INSERT_HEAD(&(ws->floating_head), nc, floating_windows);
struct focus_head *fh = &(ws->focus_head);
if (focus_before_parent) {
if (focus_head_placeholder) {
TAILQ_INSERT_AFTER(fh, focus_head_placeholder, nc, focused);
} else {
TAILQ_INSERT_HEAD(fh, nc, focused);
}
} else {
TAILQ_INSERT_HEAD(&(ws->floating_head), nc, floating_windows);
if (focus_head_placeholder) {
TAILQ_INSERT_BEFORE(focus_head_placeholder, nc, focused);
} else {
/* Also used for the set_focus case */
TAILQ_INSERT_TAIL(fh, nc, focused);
}
}
TAILQ_INSERT_TAIL(&(ws->focus_head), nc, focused);
/* check if the parent container is empty and close it if so */
if ((con->parent->type == CT_CON || con->parent->type == CT_FLOATING_CON) &&
@ -329,45 +365,22 @@ void floating_disable(Con *con, bool automatic) {
return;
}
const bool set_focus = (con == focused);
Con *ws = con_get_workspace(con);
Con *parent = con->parent;
Con *tiling_focused = con_descend_tiling_focused(ws);
/* 1: detach from parent container */
TAILQ_REMOVE(&(con->parent->nodes_head), con, nodes);
TAILQ_REMOVE(&(con->parent->focus_head), con, focused);
/* 2: kill parent container */
TAILQ_REMOVE(&(con->parent->parent->floating_head), con->parent, floating_windows);
TAILQ_REMOVE(&(con->parent->parent->focus_head), con->parent, focused);
/* clear the pointer before calling tree_close_internal in which the memory is freed */
con->parent = NULL;
tree_close_internal(parent, DONT_KILL_WINDOW, true, false);
/* 3: re-attach to the parent of the currently focused con on the workspace
* this floating con was on */
Con *focused = con_descend_tiling_focused(ws);
/* if there is no other container on this workspace, focused will be the
* workspace itself */
if (focused->type == CT_WORKSPACE)
con->parent = focused;
else
con->parent = focused->parent;
/* con_fix_percent will adjust the percent value */
con->percent = 0.0;
if (tiling_focused->type == CT_WORKSPACE) {
Con *parent = con->parent;
con_detach(con);
con->parent = NULL;
tree_close_internal(parent, DONT_KILL_WINDOW, true, false);
con_attach(con, tiling_focused, false);
con->percent = 0.0;
con_fix_percent(con->parent);
} else {
insert_con_into(con, tiling_focused, AFTER);
}
con->floating = FLOATING_USER_OFF;
con_attach(con, con->parent, false);
con_fix_percent(con->parent);
if (set_focus)
con_activate(con);
floating_set_hint_atom(con, false);
ipc_send_window_event("floating", con);
}

5
src/move.c
View File

@ -9,9 +9,6 @@
*/
#include "all.h"
typedef enum { BEFORE,
AFTER } position_t;
/*
* Returns the lowest container in the tree that has both a and b as descendants.
*
@ -65,7 +62,7 @@ static bool is_focused_descendant(Con *con, Con *ancestor) {
* 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