From 50edf495aa3971bfb67471c3aaf2eb72e7abd443 Mon Sep 17 00:00:00 2001 From: Vladimir Panteleev Date: Fri, 22 Sep 2017 23:41:38 +0000 Subject: [PATCH] Merge "force_focus_wrapping" option into "focus_wrapping force" Allow enabling forced focus wrapping by specifying "focus_wrapping force" in i3's configuration. This syntax supersedes the previous "force_focus_wrapping yes" one, which remains available for backwards compatibility. --- docs/userguide | 44 ++++++++++++++++++---------------------- include/configuration.h | 25 ++++++++++++----------- include/data.h | 9 ++++++++ parser-specs/config.spec | 2 +- src/config.c | 2 +- src/config_directives.c | 19 +++++++++++++++-- src/tree.c | 5 +++-- 7 files changed, 64 insertions(+), 42 deletions(-) diff --git a/docs/userguide b/docs/userguide index fdfb121b..bfb3da66 100644 --- a/docs/userguide +++ b/docs/userguide @@ -1044,38 +1044,34 @@ opposite window will be focused when trying to move the focus over the edge of a container (and there are no other containers in that direction) -- the focus wraps. -If desired, you can disable this behavior using the +focus_wrapping+ -configuration directive: +If desired, you can disable this behavior by setting the +focus_wrapping+ +configuration directive to the value +no+. -*Syntax*: ---------------------- -focus_wrapping yes|no ---------------------- - -*Example*: ------------------ -focus_wrapping no ------------------ - -By default, focus wrapping does not occur if there is another window or -container in the specified direction, and focus will instead be set on that -window or container. This is the default behavior so you can navigate to all -your windows without having to use +focus parent+. +When enabled, focus wrapping does not occur by default if there is another +window or container in the specified direction, and focus will instead be set +on that window or container. This is the default behavior so you can navigate +to all your windows without having to use +focus parent+. If you want the focus to *always* wrap and you are aware of using +focus -parent+ to switch to different containers, you can use the -+force_focus_wrapping+ configuration directive. After enabling it, the focus -will always wrap. +parent+ to switch to different containers, you can instead set +focus_wrapping+ +to the value +force+. *Syntax*: --------------------------- -force_focus_wrapping yes|no +focus_wrapping yes|no|force + +# Legacy syntax, equivalent to "focus_wrapping force" +force_focus_wrapping yes --------------------------- -*Example*: ------------------------- -force_focus_wrapping yes ------------------------- +*Examples*: +----------------- +# Disable focus wrapping +focus_wrapping no + +# Force focus wrapping +focus_wrapping force +----------------- === Forcing Xinerama diff --git a/include/configuration.h b/include/configuration.h index 33df2c2d..8f1ce332 100644 --- a/include/configuration.h +++ b/include/configuration.h @@ -142,18 +142,19 @@ struct Config { * direction in which there are no more containers to focus) will * cause the focus to wrap to the opposite edge of the current * container. When it is disabled, nothing happens; the current - * focus is preserved. */ - bool focus_wrapping; - - /** Think of the following layout: Horizontal workspace with a tabbed - * con on the left of the screen and a terminal on the right of the - * screen. You are in the second container in the tabbed container and - * focus to the right. By default, i3 will set focus to the terminal on - * the right. If you are in the first container in the tabbed container - * however, focusing to the left will wrap. This option forces i3 to - * always wrap, which will result in you having to use "focus parent" - * more often. */ - bool force_focus_wrapping; + * focus is preserved. + * + * Additionally, focus wrapping may be forced. Think of the + * following layout: Horizontal workspace with a tabbed con on the + * left of the screen and a terminal on the right of the + * screen. You are in the second container in the tabbed container + * and focus to the right. By default, i3 will set focus to the + * terminal on the right. If you are in the first container in the + * tabbed container however, focusing to the left will + * wrap. Setting focus_wrapping to FOCUS_WRAPPING_FORCE forces i3 + * to always wrap, which will result in you having to use "focus + * parent" more often. */ + focus_wrapping_t focus_wrapping; /** By default, use the RandR API for multi-monitor setups. * Unfortunately, the nVidia binary graphics driver doesn't support diff --git a/include/data.h b/include/data.h index 7411ac20..258ea94f 100644 --- a/include/data.h +++ b/include/data.h @@ -133,6 +133,15 @@ typedef enum { POINTER_WARPING_NONE = 1 } warping_t; +/** + * Focus wrapping modes. + */ +typedef enum { + FOCUS_WRAPPING_OFF = 0, + FOCUS_WRAPPING_ON = 1, + FOCUS_WRAPPING_FORCE = 2 +} focus_wrapping_t; + /** * Stores a rectangle, for example the size of a window, the child window etc. * It needs to be packed so that the compiler will not add any padding bytes. diff --git a/parser-specs/config.spec b/parser-specs/config.spec index 3a10bbc1..6b826543 100644 --- a/parser-specs/config.spec +++ b/parser-specs/config.spec @@ -206,7 +206,7 @@ state MOUSE_WARPING: # focus_wrapping state FOCUS_WRAPPING: - value = word + value = '1', 'yes', 'true', 'on', 'enable', 'active', '0', 'no', 'false', 'off', 'disable', 'inactive', 'force' -> call cfg_focus_wrapping($value) # force_focus_wrapping diff --git a/src/config.c b/src/config.c index c8e9bd6b..24c7b541 100644 --- a/src/config.c +++ b/src/config.c @@ -227,7 +227,7 @@ void load_configuration(xcb_connection_t *conn, const char *override_configpath, if (config.workspace_urgency_timer == 0) config.workspace_urgency_timer = 0.5; - config.focus_wrapping = true; + config.focus_wrapping = FOCUS_WRAPPING_ON; parse_configuration(override_configpath, true); diff --git a/src/config_directives.c b/src/config_directives.c index 41d21dec..8d5cf1f0 100644 --- a/src/config_directives.c +++ b/src/config_directives.c @@ -265,11 +265,26 @@ CFGFUN(disable_randr15, const char *value) { } CFGFUN(focus_wrapping, const char *value) { - config.focus_wrapping = eval_boolstr(value); + if (strcmp(value, "force") == 0) { + config.focus_wrapping = FOCUS_WRAPPING_FORCE; + } else if (eval_boolstr(value)) { + config.focus_wrapping = FOCUS_WRAPPING_ON; + } else { + config.focus_wrapping = FOCUS_WRAPPING_OFF; + } } CFGFUN(force_focus_wrapping, const char *value) { - config.force_focus_wrapping = eval_boolstr(value); + /* Legacy syntax. */ + if (eval_boolstr(value)) { + config.focus_wrapping = FOCUS_WRAPPING_FORCE; + } else { + /* For "force_focus_wrapping off", don't enable or disable + * focus wrapping, just ensure it's not forced. */ + if (config.focus_wrapping == FOCUS_WRAPPING_FORCE) { + config.focus_wrapping = FOCUS_WRAPPING_ON; + } + } } CFGFUN(workspace_back_and_forth, const char *value) { diff --git a/src/tree.c b/src/tree.c index 97c02798..fc9526e6 100644 --- a/src/tree.c +++ b/src/tree.c @@ -641,7 +641,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) next = TAILQ_PREV(current, nodes_head, nodes); if (!next) { - if (!config.force_focus_wrapping) { + if (config.focus_wrapping != FOCUS_WRAPPING_FORCE) { /* If there is no next/previous container, we check if we can focus one * when going higher (without wrapping, though). If so, we are done, if * not, we wrap */ @@ -675,7 +675,8 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) * */ void tree_next(char way, orientation_t orientation) { - _tree_next(focused, way, orientation, config.focus_wrapping); + _tree_next(focused, way, orientation, + config.focus_wrapping != FOCUS_WRAPPING_OFF); } /*