itycodes
/
convince
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make gaps implementation consistent with i3-gaps

Browse Source 
This changes our gaps implementation to behave like i3-gaps.

Our previous implementation allowed you to set gaps on a per container
basis. This isn't supported by i3-gaps and doesn't seem to have a
practical use case. The gaps_outer and gaps_inner properties on
containers are now removed as they just read the gaps_inner from the
workspace.

`gaps inner|outer <px>` no longer changes the gaps for all workspaces.
It only sets defaults for new workspaces.

`gaps inner|outer current|workspace|all set|plus|minus <px>` is now
runtime only, and the workspace option is now removed. `current` now
sets gaps for the current workspace as opposed to the current container.

`workspace <ws> gaps inner|outer <px>` is now implemented. This sets
defaults for a workspace.

This also fixes a bug where changing the layout of a split container
from linear to tabbed would cause gaps to not be applied to it until you
switch to another workspace and back.
master
Ryan Dwyer 6 years ago
parent dc01e884f7
commit 415a48ac63
8 changed files with 209 additions and 164 deletions
Show Stats Download Patch File Download Diff File

2
include/sway/config.h
Unescape View File

@ -173,6 +173,8 @@ struct output_config {
struct workspace_config { struct workspace_config {
char *workspace; char *workspace;
char *output; char *output;
int gaps_inner;
int gaps_outer;
}; };
struct bar_config { struct bar_config {

3
include/sway/tree/container.h
Unescape View File

@ -94,9 +94,6 @@ struct sway_container {
// The gaps currently applied to the container. // The gaps currently applied to the container.
double current_gaps; double current_gaps;
bool has_gaps;
double gaps_inner;
double gaps_outer;
struct sway_workspace *workspace; // NULL when hidden in the scratchpad struct sway_workspace *workspace; // NULL when hidden in the scratchpad
struct sway_container *parent; // NULL if container in root of workspace struct sway_container *parent; // NULL if container in root of workspace

7
include/sway/tree/workspace.h
Unescape View File

@ -32,10 +32,9 @@ struct sway_workspace {
enum sway_container_layout layout; enum sway_container_layout layout;
enum sway_container_layout prev_split_layout; enum sway_container_layout prev_split_layout;
double current_gaps; int current_gaps;
bool has_gaps; int gaps_inner;
double gaps_inner; int gaps_outer;
double gaps_outer;
struct sway_output *output; // NULL if no outputs are connected struct sway_output *output; // NULL if no outputs are connected
list_t *floating; // struct sway_container list_t *floating; // struct sway_container

230
sway/commands/gaps.c
Unescape View File

@ -1,4 +1,5 @@
#include <string.h> #include <string.h>
#include <strings.h>
#include "sway/commands.h" #include "sway/commands.h"
#include "sway/config.h" #include "sway/config.h"
#include "sway/tree/arrange.h" #include "sway/tree/arrange.h"
@ -13,19 +14,15 @@ enum gaps_op {
GAPS_OP_SUBTRACT GAPS_OP_SUBTRACT
}; };
enum gaps_scope { struct gaps_data {
GAPS_SCOPE_ALL, bool inner;
GAPS_SCOPE_WORKSPACE, enum gaps_op operation;
GAPS_SCOPE_CURRENT int amount;
}; };
struct cmd_results *cmd_gaps(int argc, char **argv) { // gaps edge_gaps on|off|toggle
struct cmd_results *error = checkarg(argc, "gaps", EXPECTED_AT_LEAST, 1); static struct cmd_results *gaps_edge_gaps(int argc, char **argv) {
if (error) { struct cmd_results *error;
return error;
}
if (strcmp(argv[0], "edge_gaps") == 0) {
if ((error = checkarg(argc, "gaps", EXPECTED_AT_LEAST, 2))) { if ((error = checkarg(argc, "gaps", EXPECTED_AT_LEAST, 2))) {
return error; return error;
} }
@ -45,140 +42,139 @@ struct cmd_results *cmd_gaps(int argc, char **argv) {
"gaps edge_gaps on|off|toggle"); "gaps edge_gaps on|off|toggle");
} }
arrange_root(); arrange_root();
} else { return cmd_results_new(CMD_SUCCESS, NULL, NULL);
int amount_idx = 0; // the current index in argv }
enum gaps_op op = GAPS_OP_SET;
enum gaps_scope scope = GAPS_SCOPE_ALL;
bool inner = true;
if (strcmp(argv[0], "inner") == 0) { // gaps inner|outer <px>
amount_idx++; static struct cmd_results *gaps_set_defaults(int argc, char **argv) {
struct cmd_results *error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 2);
if (error) {
return error;
}
bool inner;
if (strcasecmp(argv[0], "inner") == 0) {
inner = true; inner = true;
} else if (strcmp(argv[0], "outer") == 0) { } else if (strcasecmp(argv[0], "outer") == 0) {
amount_idx++;
inner = false; inner = false;
} else {
return cmd_results_new(CMD_INVALID, "gaps",
"Expected 'gaps inner|outer <px>'");
} }
// If one of the long variants of the gaps command is used char *end;
// (which starts with inner|outer) check the number of args int amount = strtol(argv[1], &end, 10);
if (amount_idx > 0) { // if we've seen inner|outer if (strlen(end) && strcasecmp(end, "px") != 0) {
if (argc > 2) { // check the longest variant return cmd_results_new(CMD_INVALID, "gaps",
error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 4); "Expected 'gaps inner|outer <px>'");
if (error) {
return error;
} }
} else { // check the next longest format
error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 2); if (inner) {
if (error) { config->gaps_inner = amount;
return error; } else {
config->gaps_outer = amount;
} }
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
static void configure_gaps(struct sway_workspace *ws, void *_data) {
struct gaps_data *data = _data;
int *prop = data->inner ? &ws->gaps_inner : &ws->gaps_outer;
switch (data->operation) {
case GAPS_OP_SET:
*prop = data->amount;
break;
case GAPS_OP_ADD:
*prop += data->amount;
break;
case GAPS_OP_SUBTRACT:
*prop -= data->amount;
break;
} }
} else { arrange_workspace(ws);
error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 1); }
// gaps inner|outer current|all set|plus|minus <px>
static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
struct cmd_results *error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 4);
if (error) { if (error) {
return error; return error;
} }
struct gaps_data data;
if (strcasecmp(argv[0], "inner") == 0) {
data.inner = true;
} else if (strcasecmp(argv[0], "outer") == 0) {
data.inner = false;
} else {
return cmd_results_new(CMD_INVALID, "gaps",
"Expected 'gaps inner|outer current|all set|plus|minus <px>'");
} }
if (argc == 4) { bool all;
// Long format: all|workspace|current. if (strcasecmp(argv[1], "current") == 0) {
if (strcmp(argv[amount_idx], "all") == 0) { all = false;
amount_idx++; } else if (strcasecmp(argv[1], "all") == 0) {
scope = GAPS_SCOPE_ALL; all = true;
} else if (strcmp(argv[amount_idx], "workspace") == 0) { } else {
amount_idx++; return cmd_results_new(CMD_INVALID, "gaps",
scope = GAPS_SCOPE_WORKSPACE; "Expected 'gaps inner|outer current|all set|plus|minus <px>'");
} else if (strcmp(argv[amount_idx], "current") == 0) {
amount_idx++;
scope = GAPS_SCOPE_CURRENT;
}
// Long format: set|plus|minus
if (strcmp(argv[amount_idx], "set") == 0) {
amount_idx++;
op = GAPS_OP_SET;
} else if (strcmp(argv[amount_idx], "plus") == 0) {
amount_idx++;
op = GAPS_OP_ADD;
} else if (strcmp(argv[amount_idx], "minus") == 0) {
amount_idx++;
op = GAPS_OP_SUBTRACT;
} }
if (strcasecmp(argv[2], "set") == 0) {
data.operation = GAPS_OP_SET;
} else if (strcasecmp(argv[2], "plus") == 0) {
data.operation = GAPS_OP_ADD;
} else if (strcasecmp(argv[2], "minus") == 0) {
data.operation = GAPS_OP_SUBTRACT;
} else {
return cmd_results_new(CMD_INVALID, "gaps",
"Expected 'gaps inner|outer current|all set|plus|minus <px>'");
} }
char *end; char *end;
double val = strtod(argv[amount_idx], &end); data.amount = strtol(argv[3], &end, 10);
if (strlen(end) && strcasecmp(end, "px") != 0) {
if (strlen(end) && val == 0.0) { // invalid <amount>
// guess which variant of the command was attempted
if (argc == 1) {
return cmd_results_new(CMD_INVALID, "gaps", "gaps <amount>");
}
if (argc == 2) {
return cmd_results_new(CMD_INVALID, "gaps", return cmd_results_new(CMD_INVALID, "gaps",
"gaps inner|outer <amount>"); "Expected 'gaps inner|outer current|all set|plus|minus <px>'");
} }
return cmd_results_new(CMD_INVALID, "gaps",
"gaps inner|outer all|workspace|current set|plus|minus <amount>"); if (all) {
root_for_each_workspace(configure_gaps, &data);
} else {
configure_gaps(config->handler_context.workspace, &data);
} }
if (amount_idx == 0) { // gaps <amount>
config->gaps_inner = val;
config->gaps_outer = val;
arrange_root();
return cmd_results_new(CMD_SUCCESS, NULL, NULL); return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} }
// Other variants. The middle-length variant (gaps inner|outer <amount>)
// just defaults the scope to "all" and defaults the op to "set".
double total; // gaps edge_gaps on|off|toggle
switch (op) { // gaps inner|outer <px> - sets defaults for workspaces
case GAPS_OP_SUBTRACT: { // gaps inner|outer current|all set|plus|minus <px> - runtime only
total = (inner ? config->gaps_inner : config->gaps_outer) - val; struct cmd_results *cmd_gaps(int argc, char **argv) {
if (total < 0) { struct cmd_results *error = checkarg(argc, "gaps", EXPECTED_AT_LEAST, 2);
total = 0; if (error) {
} return error;
break;
}
case GAPS_OP_ADD: {
total = (inner ? config->gaps_inner : config->gaps_outer) + val;
break;
}
case GAPS_OP_SET: {
total = val;
break;
}
} }
if (scope == GAPS_SCOPE_ALL) { if (strcmp(argv[0], "edge_gaps") == 0) {
if (inner) { return gaps_edge_gaps(argc, argv);
config->gaps_inner = total;
} else {
config->gaps_outer = total;
} }
arrange_root();
} else { if (argc == 2) {
if (scope == GAPS_SCOPE_WORKSPACE) { return gaps_set_defaults(argc, argv);
struct sway_workspace *ws = config->handler_context.workspace;
ws->has_gaps = true;
if (inner) {
ws->gaps_inner = total;
} else {
ws->gaps_outer = total;
} }
arrange_workspace(ws); if (argc == 4) {
} else { if (config->active) {
struct sway_container *c = config->handler_context.container; return gaps_set_runtime(argc, argv);
c->has_gaps = true;
if (inner) {
c->gaps_inner = total;
} else { } else {
c->gaps_outer = total; return cmd_results_new(CMD_INVALID, "gaps",
} "This syntax can only be used when sway is running");
arrange_workspace(c->workspace);
}
} }
} }
return cmd_results_new(CMD_INVALID, "gaps",
return cmd_results_new(CMD_SUCCESS, NULL, NULL); "Expected 'gaps inner|outer <px>' or "
"'gaps inner|outer current|all set|plus|minus <px>'");
} }

3
sway/commands/layout.c
Unescape View File

@ -138,15 +138,14 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
} }
container->layout = new_layout; container->layout = new_layout;
container_update_representation(container); container_update_representation(container);
arrange_container(container);
} else { } else {
if (old_layout != L_TABBED && old_layout != L_STACKED) { if (old_layout != L_TABBED && old_layout != L_STACKED) {
workspace->prev_split_layout = old_layout; workspace->prev_split_layout = old_layout;
} }
workspace->layout = new_layout; workspace->layout = new_layout;
workspace_update_representation(workspace); workspace_update_representation(workspace);
arrange_workspace(workspace);
} }
arrange_workspace(workspace);
} }
return cmd_results_new(CMD_SUCCESS, NULL, NULL); return cmd_results_new(CMD_SUCCESS, NULL, NULL);

38
sway/commands/workspace.c
Unescape View File

@ -20,6 +20,8 @@ static struct workspace_config *workspace_config_find_or_create(char *ws_name) {
return NULL; return NULL;
} }
wsc->workspace = strdup(ws_name); wsc->workspace = strdup(ws_name);
wsc->gaps_inner = -1;
wsc->gaps_outer = -1;
list_add(config->workspace_configs, wsc); list_add(config->workspace_configs, wsc);
return wsc; return wsc;
} }
@ -37,6 +39,7 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
} }
int output_location = -1; int output_location = -1;
int gaps_location = -1;
for (int i = 0; i < argc; ++i) { for (int i = 0; i < argc; ++i) {
if (strcasecmp(argv[i], "output") == 0) { if (strcasecmp(argv[i], "output") == 0) {
@ -44,6 +47,12 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
break; break;
} }
} }
for (int i = 0; i < argc; ++i) {
if (strcasecmp(argv[i], "gaps") == 0) {
gaps_location = i;
break;
}
}
if (output_location >= 0) { if (output_location >= 0) {
if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO, output_location + 2))) { if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO, output_location + 2))) {
return error; return error;
@ -57,6 +66,35 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
} }
free(wsc->output); free(wsc->output);
wsc->output = strdup(argv[output_location + 1]); wsc->output = strdup(argv[output_location + 1]);
} else if (gaps_location >= 0) {
if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO, gaps_location + 3))) {
return error;
}
char *ws_name = join_args(argv, argc - 3);
struct workspace_config *wsc = workspace_config_find_or_create(ws_name);
free(ws_name);
if (!wsc) {
return cmd_results_new(CMD_FAILURE, "workspace gaps",
"Unable to allocate workspace output");
}
int *prop = NULL;
if (strcasecmp(argv[gaps_location + 1], "inner") == 0) {
prop = &wsc->gaps_inner;
} else if (strcasecmp(argv[gaps_location + 1], "outer") == 0) {
prop = &wsc->gaps_outer;
} else {
return cmd_results_new(CMD_FAILURE, "workspace gaps",
"Expected 'workspace <ws> gaps inner|outer <px>'");
}
char *end;
int val = strtol(argv[gaps_location + 2], &end, 10);
if (strlen(end)) {
free(end);
return cmd_results_new(CMD_FAILURE, "workspace gaps",
"Expected 'workspace <ws> gaps inner|outer <px>'");
}
*prop = val >= 0 ? val : 0;
} else { } else {
if (config->reading || !config->active) { if (config->reading || !config->active) {
return cmd_results_new(CMD_DEFER, "workspace", NULL); return cmd_results_new(CMD_DEFER, "workspace", NULL);

2
sway/tree/container.c
Unescape View File

@ -1022,7 +1022,7 @@ void container_add_gaps(struct sway_container *c) {
struct sway_workspace *ws = c->workspace; struct sway_workspace *ws = c->workspace;
c->current_gaps = ws->has_gaps ? ws->gaps_inner : config->gaps_inner; c->current_gaps = ws->gaps_inner;
c->x += c->current_gaps; c->x += c->current_gaps;
c->y += c->current_gaps; c->y += c->current_gaps;
c->width -= 2 * c->current_gaps; c->width -= 2 * c->current_gaps;

18
sway/tree/workspace.c
Unescape View File

@ -68,6 +68,20 @@ struct sway_workspace *workspace_create(struct sway_output *output,
ws->output_priority = create_list(); ws->output_priority = create_list();
workspace_output_add_priority(ws, output); workspace_output_add_priority(ws, output);
ws->gaps_outer = config->gaps_outer;
ws->gaps_inner = config->gaps_inner;
if (name) {
struct workspace_config *wsc = workspace_find_config(name);
if (wsc) {
if (wsc->gaps_outer != -1) {
ws->gaps_outer = wsc->gaps_outer;
}
if (wsc->gaps_inner != -1) {
ws->gaps_inner = wsc->gaps_inner;
}
}
}
output_add_workspace(output, ws); output_add_workspace(output, ws);
output_sort_workspaces(output); output_sort_workspaces(output);
@ -632,13 +646,13 @@ void workspace_add_gaps(struct sway_workspace *ws) {
return; return;
} }
ws->current_gaps = ws->has_gaps ? ws->gaps_outer : config->gaps_outer; ws->current_gaps = ws->gaps_outer;
if (ws->layout == L_TABBED || ws->layout == L_STACKED) { if (ws->layout == L_TABBED || ws->layout == L_STACKED) {
// We have to add inner gaps for this, because children of tabbed and // We have to add inner gaps for this, because children of tabbed and
// stacked containers don't apply their own gaps - they assume the // stacked containers don't apply their own gaps - they assume the
// tabbed/stacked container is using gaps. // tabbed/stacked container is using gaps.
ws->current_gaps += ws->has_gaps ? ws->gaps_inner : config->gaps_inner; ws->current_gaps += ws->gaps_inner;
} }
ws->x += ws->current_gaps; ws->x += ws->current_gaps;

Write Preview
Loading…
Cancel
Save