1 files changed, 45 insertions, 65 deletions

diff --git a/sway/commands.c b/sway/commands.c
index fe1e98b5..8d003dfa 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809
 #include <ctype.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -42,15 +41,17 @@ struct cmd_results *checkarg(int argc, const char *name, enum expected_args type
 }
 
 /* Keep alphabetized */
-static struct cmd_handler handlers[] = {
+static const struct cmd_handler handlers[] = {
         { "assign", cmd_assign },
         { "bar", cmd_bar },
         { "bindcode", cmd_bindcode },
+        { "bindgesture", cmd_bindgesture },
         { "bindswitch", cmd_bindswitch },
         { "bindsym", cmd_bindsym },
         { "client.background", cmd_client_noop },
         { "client.focused", cmd_client_focused },
         { "client.focused_inactive", cmd_client_focused_inactive },
+        { "client.focused_tab_title", cmd_client_focused_tab_title },
         { "client.placeholder", cmd_client_noop },
         { "client.unfocused", cmd_client_unfocused },
         { "client.urgent", cmd_client_urgent },
@@ -91,6 +92,7 @@ static struct cmd_handler handlers[] = {
         { "titlebar_border_thickness", cmd_titlebar_border_thickness },
         { "titlebar_padding", cmd_titlebar_padding },
         { "unbindcode", cmd_unbindcode },
+        { "unbindgesture", cmd_unbindgesture },
         { "unbindswitch", cmd_unbindswitch },
         { "unbindsym", cmd_unbindsym },
         { "workspace", cmd_workspace },
@@ -98,9 +100,10 @@ static struct cmd_handler handlers[] = {
 };
 
 /* Config-time only commands. Keep alphabetized */
-static struct cmd_handler config_handlers[] = {
+static const struct cmd_handler config_handlers[] = {
         { "default_orientation", cmd_default_orientation },
         { "include", cmd_include },
+        { "primary_selection", cmd_primary_selection },
         { "swaybg_command", cmd_swaybg_command },
         { "swaynag_command", cmd_swaynag_command },
         { "workspace_layout", cmd_workspace_layout },
@@ -108,7 +111,7 @@ static struct cmd_handler config_handlers[] = {
 };
 
 /* Runtime-only commands. Keep alphabetized */
-static struct cmd_handler command_handlers[] = {
+static const struct cmd_handler command_handlers[] = {
         { "border", cmd_border },
         { "create_output", cmd_create_output },
         { "exit", cmd_exit },
@@ -144,22 +147,22 @@ static int handler_compare(const void *_a, const void *_b) {
         return strcasecmp(a->command, b->command);
 }
 
-struct cmd_handler *find_handler(char *line, struct cmd_handler *handlers,
-                size_t handlers_size) {
+const struct cmd_handler *find_handler(const char *line,
+                const struct cmd_handler *handlers, size_t handlers_size) {
         if (!handlers || !handlers_size) {
                 return NULL;
         }
-        struct cmd_handler query = { .command = line };
+        const struct cmd_handler query = { .command = line };
         return bsearch(&query, handlers,
                         handlers_size / sizeof(struct cmd_handler),
                         sizeof(struct cmd_handler), handler_compare);
 }
 
-static struct cmd_handler *find_handler_ex(char *line,
-                struct cmd_handler *config_handlers, size_t config_handlers_size,
-                struct cmd_handler *command_handlers, size_t command_handlers_size,
-                struct cmd_handler *handlers, size_t handlers_size) {
-        struct cmd_handler *handler = NULL;
+static const struct cmd_handler *find_handler_ex(char *line,
+                const struct cmd_handler *config_handlers, size_t config_handlers_size,
+                const struct cmd_handler *command_handlers, size_t command_handlers_size,
+                const struct cmd_handler *handlers, size_t handlers_size) {
+        const struct cmd_handler *handler = NULL;
         if (config->reading) {
                 handler = find_handler(line, config_handlers, config_handlers_size);
         } else if (config->active) {
@@ -168,16 +171,17 @@ static struct cmd_handler *find_handler_ex(char *line,
         return handler ? handler : find_handler(line, handlers, handlers_size);
 }
 
-static struct cmd_handler *find_core_handler(char *line) {
+static const struct cmd_handler *find_core_handler(char *line) {
         return find_handler_ex(line, config_handlers, sizeof(config_handlers),
                         command_handlers, sizeof(command_handlers),
                         handlers, sizeof(handlers));
 }
 
-static void set_config_node(struct sway_node *node) {
+static void set_config_node(struct sway_node *node, bool node_overridden) {
         config->handler_context.node = node;
         config->handler_context.container = NULL;
         config->handler_context.workspace = NULL;
+        config->handler_context.node_overridden = node_overridden;
 
         if (node == NULL) {
                 return;
@@ -186,7 +190,7 @@ static void set_config_node(struct sway_node *node) {
         switch (node->type) {
         case N_CONTAINER:
                 config->handler_context.container = node->sway_container;
-                config->handler_context.workspace = node->sway_container->workspace;
+                config->handler_context.workspace = node->sway_container->pending.workspace;
                 break;
         case N_WORKSPACE:
                 config->handler_context.workspace = node->sway_workspace;
@@ -202,6 +206,7 @@ list_t *execute_command(char *_exec, struct sway_seat *seat,
         char *cmd;
         char matched_delim = ';';
         list_t *containers = NULL;
+        bool using_criteria = false;
 
         if (seat == NULL) {
                 // passing a NULL seat means we just pick the default seat
@@ -225,7 +230,7 @@ list_t *execute_command(char *_exec, struct sway_seat *seat,
                 for (; isspace(*head); ++head) {}
                 // Extract criteria (valid for this command list only).
                 if (matched_delim == ';') {
-                        config->handler_context.using_criteria = false;
+                        using_criteria = false;
                         if (*head == '[') {
                                 char *error = NULL;
                                 struct criteria *criteria = criteria_parse(head, &error);
@@ -239,7 +244,7 @@ list_t *execute_command(char *_exec, struct sway_seat *seat,
                                 containers = criteria_get_containers(criteria);
                                 head += strlen(criteria->raw);
                                 criteria_destroy(criteria);
-                                config->handler_context.using_criteria = true;
+                                using_criteria = true;
                                 // Skip leading whitespace
                                 for (; isspace(*head); ++head) {}
                         }
@@ -265,7 +270,7 @@ list_t *execute_command(char *_exec, struct sway_seat *seat,
                                 }
                         }
                 }
-                struct cmd_handler *handler = find_core_handler(argv[0]);
+                const struct cmd_handler *handler = find_core_handler(argv[0]);
                 if (!handler) {
                         list_add(res_list, cmd_results_new(CMD_INVALID,
                                         "Unknown/invalid command '%s'", argv[0]));
@@ -278,11 +283,14 @@ list_t *execute_command(char *_exec, struct sway_seat *seat,
                         argv[i] = do_var_replacement(argv[i]);
                 }
 
-                if (!config->handler_context.using_criteria) {
-                        // The container or workspace which this command will run on.
-                        struct sway_node *node = con ? &con->node :
-                                        seat_get_focus_inactive(seat, &root->node);
-                        set_config_node(node);
+
+                if (!using_criteria) {
+                        if (con) {
+                                set_config_node(&con->node, true);
+                        } else {
+                                set_config_node(seat_get_focus_inactive(seat, &root->node),
+                                                false);
+                        }
                         struct cmd_results *res = handler->handle(argc-1, argv+1);
                         list_add(res_list, res);
                         if (res->status == CMD_INVALID) {
@@ -296,7 +304,7 @@ list_t *execute_command(char *_exec, struct sway_seat *seat,
                         struct cmd_results *fail_res = NULL;
                         for (int i = 0; i < containers->length; ++i) {
                                 struct sway_container *container = containers->items[i];
-                                set_config_node(&container->node);
+                                set_config_node(&container->node, true);
                                 struct cmd_results *res = handler->handle(argc-1, argv+1);
                                 if (res->status == CMD_SUCCESS) {
                                         free_cmd_results(res);
@@ -370,12 +378,15 @@ struct cmd_results *config_command(char *exec, char **new_block) {
 
         // Determine the command handler
         sway_log(SWAY_INFO, "Config command: %s", exec);
-        struct cmd_handler *handler = find_core_handler(argv[0]);
+        const struct cmd_handler *handler = find_core_handler(argv[0]);
         if (!handler || !handler->handle) {
-                const char *error = handler
-                        ? "Command '%s' is shimmed, but unimplemented"
-                        : "Unknown/invalid command '%s'";
-                results = cmd_results_new(CMD_INVALID, error, argv[0]);
+                if (handler) {
+                        results = cmd_results_new(CMD_INVALID,
+                                "Command '%s' is shimmed, but unimplemented", argv[0]);
+                } else {
+                        results = cmd_results_new(CMD_INVALID,
+                                "Unknown/invalid command '%s'", argv[0]);
+                }
                 goto cleanup;
         }
 
@@ -401,6 +412,7 @@ struct cmd_results *config_command(char *exec, char **new_block) {
                                 && handler->handle != cmd_bindsym
                                 && handler->handle != cmd_bindcode
                                 && handler->handle != cmd_bindswitch
+                                && handler->handle != cmd_bindgesture
                                 && handler->handle != cmd_set
                                 && handler->handle != cmd_for_window
                                 && (*argv[i] == '\"' || *argv[i] == '\'')) {
@@ -418,12 +430,12 @@ cleanup:
 }
 
 struct cmd_results *config_subcommand(char **argv, int argc,
-                struct cmd_handler *handlers, size_t handlers_size) {
+                const struct cmd_handler *handlers, size_t handlers_size) {
         char *command = join_args(argv, argc);
         sway_log(SWAY_DEBUG, "Subcommand: %s", command);
         free(command);
 
-        struct cmd_handler *handler = find_handler(argv[0], handlers,
+        const struct cmd_handler *handler = find_handler(argv[0], handlers,
                         handlers_size);
         if (!handler) {
                 return cmd_results_new(CMD_INVALID,
@@ -453,41 +465,13 @@ struct cmd_results *config_commands_command(char *exec) {
                 goto cleanup;
         }
 
-        struct cmd_handler *handler = find_handler(cmd, NULL, 0);
+        const struct cmd_handler *handler = find_handler(cmd, NULL, 0);
         if (!handler && strcmp(cmd, "*") != 0) {
                 results = cmd_results_new(CMD_INVALID,
                         "Unknown/invalid command '%s'", cmd);
                 goto cleanup;
         }
 
-        enum command_context context = 0;
-
-        struct {
-                char *name;
-                enum command_context context;
-        } context_names[] = {
-                { "config", CONTEXT_CONFIG },
-                { "binding", CONTEXT_BINDING },
-                { "ipc", CONTEXT_IPC },
-                { "criteria", CONTEXT_CRITERIA },
-                { "all", CONTEXT_ALL },
-        };
-
-        for (int i = 1; i < argc; ++i) {
-                size_t j;
-                for (j = 0; j < sizeof(context_names) / sizeof(context_names[0]); ++j) {
-                        if (strcmp(context_names[j].name, argv[i]) == 0) {
-                                break;
-                        }
-                }
-                if (j == sizeof(context_names) / sizeof(context_names[0])) {
-                        results = cmd_results_new(CMD_INVALID,
-                                        "Invalid command context %s", argv[i]);
-                        goto cleanup;
-                }
-                context |= context_names[j].context;
-        }
-
         results = cmd_results_new(CMD_SUCCESS, NULL);
 
 cleanup:
@@ -504,14 +488,10 @@ struct cmd_results *cmd_results_new(enum cmd_status status,
         }
         results->status = status;
         if (format) {
-                char *error = malloc(256);
                 va_list args;
                 va_start(args, format);
-                if (error) {
-                        vsnprintf(error, 256, format, args);
-                }
+                results->error = vformat_str(format, args);
                 va_end(args);
-                results->error = error;
         } else {
                 results->error = NULL;
         }