Merge pull request #1574 from acrisci/config-refactor

Command criteria

35 files changed, 765 insertions, 49 deletions

diff --git a/sway/commands.c b/sway/commands.c
index 1005cf68..a77ff791 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -8,8 +8,10 @@
 #include <json-c/json.h>
 #include "sway/commands.h"
 #include "sway/config.h"
+#include "sway/criteria.h"
 #include "sway/security.h"
 #include "sway/input/input-manager.h"
+#include "sway/input/seat.h"
 #include "stringop.h"
 #include "log.h"
 
@@ -70,10 +72,7 @@ void apply_input_config(struct input_config *input) {
                 list_add(config->input_configs, input);
         }
 
-        struct input_config *old_input_config = current_input_config;
-        current_input_config = input;
         sway_input_manager_apply_input_config(input_manager, input);
-        current_input_config = old_input_config;
 }
 
 void apply_seat_config(struct seat_config *seat) {
@@ -89,7 +88,6 @@ void apply_seat_config(struct seat_config *seat) {
                 list_add(config->seat_configs, seat);
         }
 
-        current_seat_config = seat;
         sway_input_manager_apply_seat_config(input_manager, seat);
 }
 
@@ -136,6 +134,7 @@ static struct cmd_handler handlers[] = {
         { "exit", cmd_exit },
         { "include", cmd_include },
         { "input", cmd_input },
+        { "kill", cmd_kill },
         { "output", cmd_output },
         { "seat", cmd_seat },
         { "set", cmd_set },
@@ -204,9 +203,41 @@ struct cmd_results *handle_command(char *_exec) {
         char *head = exec;
         char *cmdlist;
         char *cmd;
+        list_t *containers = NULL;
 
         head = exec;
         do {
+                // Extract criteria (valid for this command list only).
+                bool has_criteria = false;
+                if (*head == '[') {
+                        has_criteria = true;
+                        ++head;
+                        char *criteria_string = argsep(&head, "]");
+                        if (head) {
+                                ++head;
+                                list_t *tokens = create_list();
+                                char *error;
+
+                                if ((error = extract_crit_tokens(tokens, criteria_string))) {
+                                        wlr_log(L_DEBUG, "criteria string parse error: %s", error);
+                                        results = cmd_results_new(CMD_INVALID, criteria_string,
+                                                "Can't parse criteria string: %s", error);
+                                        free(error);
+                                        free(tokens);
+                                        goto cleanup;
+                                }
+                                containers = container_for_crit_tokens(tokens);
+
+                                free(tokens);
+                        } else {
+                                if (!results) {
+                                        results = cmd_results_new(CMD_INVALID, criteria_string, "Unmatched [");
+                                }
+                                goto cleanup;
+                        }
+                        // Skip leading whitespace
+                        head += strspn(head, whitespace);
+                }
                 // Split command list
                 cmdlist = argsep(&head, ";");
                 cmdlist += strspn(cmdlist, whitespace);
@@ -239,16 +270,42 @@ struct cmd_results *handle_command(char *_exec) {
                                 free_argv(argc, argv);
                                 goto cleanup;
                         }
-                        struct cmd_results *res = handler->handle(argc-1, argv+1);
-                        if (res->status != CMD_SUCCESS) {
-                                free_argv(argc, argv);
-                                if (results) {
-                                        free_cmd_results(results);
+
+                        if (!has_criteria) {
+                                // without criteria, the command acts upon the focused
+                                // container
+                                struct sway_seat *seat = config->handler_context.seat;
+                                if (!seat) {
+                                        seat = sway_input_manager_get_default_seat(input_manager);
+                                }
+                                if (seat) {
+                                        config->handler_context.current_container = seat->focus;
+                                        struct cmd_results *res = handler->handle(argc-1, argv+1);
+                                        if (res->status != CMD_SUCCESS) {
+                                                free_argv(argc, argv);
+                                                if (results) {
+                                                        free_cmd_results(results);
+                                                }
+                                                results = res;
+                                                goto cleanup;
+                                        }
+                                        free_cmd_results(res);
+                                }
+                        } else {
+                                for (int i = 0; i < containers->length; ++i) {
+                                        config->handler_context.current_container = containers->items[i];
+                                        struct cmd_results *res = handler->handle(argc-1, argv+1);
+                                        if (res->status != CMD_SUCCESS) {
+                                                free_argv(argc, argv);
+                                                if (results) {
+                                                        free_cmd_results(results);
+                                                }
+                                                results = res;
+                                                goto cleanup;
+                                        }
+                                        free_cmd_results(res);
                                 }
-                                results = res;
-                                goto cleanup;
                         }
-                        free_cmd_results(res);
                         free_argv(argc, argv);
                 } while(cmdlist);
         } while(head);
diff --git a/sway/commands/input.c b/sway/commands/input.c
index 5ea39f62..fa9cf05a 100644
--- a/sway/commands/input.c
+++ b/sway/commands/input.c
@@ -11,8 +11,12 @@ struct cmd_results *cmd_input(int argc, char **argv) {
         }
 
         if (config->reading && strcmp("{", argv[1]) == 0) {
-                current_input_config = new_input_config(argv[0]);
-                wlr_log(L_DEBUG, "entering input block: %s", current_input_config->identifier);
+                free_input_config(config->handler_context.input_config);
+                config->handler_context.input_config = new_input_config(argv[0]);
+                if (!config->handler_context.input_config) {
+                        return cmd_results_new(CMD_FAILURE, NULL, "Couldn't allocate config");
+                }
+                wlr_log(L_DEBUG, "entering input block: %s", argv[0]);
                 return cmd_results_new(CMD_BLOCK_INPUT, NULL, NULL);
         }
 
@@ -20,15 +24,19 @@ struct cmd_results *cmd_input(int argc, char **argv) {
                 return error;
         }
 
+        bool has_context = (config->handler_context.input_config != NULL);
+        if (!has_context) {
+                // caller did not give a context so create one just for this command
+                config->handler_context.input_config = new_input_config(argv[0]);
+                if (!config->handler_context.input_config) {
+                        return cmd_results_new(CMD_FAILURE, NULL, "Couldn't allocate config");
+                }
+        }
+
         int argc_new = argc-2;
         char **argv_new = argv+2;
 
         struct cmd_results *res;
-        struct input_config *old_input_config = current_input_config;
-        current_input_config = new_input_config(argv[0]);
-        if (!current_input_config) {
-                return cmd_results_new(CMD_FAILURE, NULL, "Couldn't allocate config");
-        }
         if (strcasecmp("accel_profile", argv[1]) == 0) {
                 res = input_cmd_accel_profile(argc_new, argv_new);
         } else if (strcasecmp("click_method", argv[1]) == 0) {
@@ -64,7 +72,12 @@ struct cmd_results *cmd_input(int argc, char **argv) {
         } else {
                 res = cmd_results_new(CMD_INVALID, "input <device>", "Unknown command %s", argv[1]);
         }
-        free_input_config(current_input_config);
-        current_input_config = old_input_config;
+
+        if (!has_context) {
+                // clean up the context we created earlier
+                free_input_config(config->handler_context.input_config);
+                config->handler_context.input_config = NULL;
+        }
+
         return res;
 }
diff --git a/sway/commands/input/accel_profile.c b/sway/commands/input/accel_profile.c
index f72b7d48..37d6e133 100644
--- a/sway/commands/input/accel_profile.c
+++ b/sway/commands/input/accel_profile.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_accel_profile(int argc, char **argv) {
         if ((error = checkarg(argc, "accel_profile", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "accel_profile",
                                 "No input device defined.");
diff --git a/sway/commands/input/click_method.c b/sway/commands/input/click_method.c
index 22eb15f7..8f1f0aa7 100644
--- a/sway/commands/input/click_method.c
+++ b/sway/commands/input/click_method.c
@@ -6,12 +6,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_click_method(int argc, char **argv) {
-        wlr_log(L_DEBUG, "click_method for device:  %d %s",
-                current_input_config==NULL, current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "click_method", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "click_method",
                         "No input device defined.");
diff --git a/sway/commands/input/drag_lock.c b/sway/commands/input/drag_lock.c
index 1783978a..8273a7d4 100644
--- a/sway/commands/input/drag_lock.c
+++ b/sway/commands/input/drag_lock.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
         if ((error = checkarg(argc, "drag_lock", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE,
                         "drag_lock", "No input device defined.");
diff --git a/sway/commands/input/dwt.c b/sway/commands/input/dwt.c
index 8108a110..995a2f47 100644
--- a/sway/commands/input/dwt.c
+++ b/sway/commands/input/dwt.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_dwt(int argc, char **argv) {
         if ((error = checkarg(argc, "dwt", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "dwt", "No input device defined.");
         }
diff --git a/sway/commands/input/events.c b/sway/commands/input/events.c
index a1bfbacd..2217f5ce 100644
--- a/sway/commands/input/events.c
+++ b/sway/commands/input/events.c
@@ -6,16 +6,18 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_events(int argc, char **argv) {
-        wlr_log(L_DEBUG, "events for device: %s",
-                current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "events", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "events",
                         "No input device defined.");
         }
+        wlr_log(L_DEBUG, "events for device: %s",
+                current_input_config->identifier);
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
diff --git a/sway/commands/input/left_handed.c b/sway/commands/input/left_handed.c
index 35740df3..94b8e03e 100644
--- a/sway/commands/input/left_handed.c
+++ b/sway/commands/input/left_handed.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_left_handed(int argc, char **argv) {
         if ((error = checkarg(argc, "left_handed", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "left_handed",
                         "No input device defined.");
diff --git a/sway/commands/input/middle_emulation.c b/sway/commands/input/middle_emulation.c
index 7bc08ae6..a551fd51 100644
--- a/sway/commands/input/middle_emulation.c
+++ b/sway/commands/input/middle_emulation.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
         if ((error = checkarg(argc, "middle_emulation", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "middle_emulation",
                         "No input device defined.");
diff --git a/sway/commands/input/natural_scroll.c b/sway/commands/input/natural_scroll.c
index a7dcdc2c..c4e19b78 100644
--- a/sway/commands/input/natural_scroll.c
+++ b/sway/commands/input/natural_scroll.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_natural_scroll(int argc, char **argv) {
         if ((error = checkarg(argc, "natural_scroll", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "natural_scoll",
                         "No input device defined.");
diff --git a/sway/commands/input/pointer_accel.c b/sway/commands/input/pointer_accel.c
index d2261a63..171063aa 100644
--- a/sway/commands/input/pointer_accel.c
+++ b/sway/commands/input/pointer_accel.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_pointer_accel(int argc, char **argv) {
         if ((error = checkarg(argc, "pointer_accel", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE,
                         "pointer_accel", "No input device defined.");
diff --git a/sway/commands/input/scroll_method.c b/sway/commands/input/scroll_method.c
index 035262cf..0a1c57ac 100644
--- a/sway/commands/input/scroll_method.c
+++ b/sway/commands/input/scroll_method.c
@@ -9,6 +9,8 @@ struct cmd_results *input_cmd_scroll_method(int argc, char **argv) {
         if ((error = checkarg(argc, "scroll_method", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "scroll_method",
                         "No input device defined.");
diff --git a/sway/commands/input/tap.c b/sway/commands/input/tap.c
index ecab9a5b..e7f03058 100644
--- a/sway/commands/input/tap.c
+++ b/sway/commands/input/tap.c
@@ -6,11 +6,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_tap(int argc, char **argv) {
-        wlr_log(L_DEBUG, "tap for device: %s", current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "tap", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "tap", "No input device defined.");
         }
diff --git a/sway/commands/input/xkb_layout.c b/sway/commands/input/xkb_layout.c
index 25db1a33..867e65d3 100644
--- a/sway/commands/input/xkb_layout.c
+++ b/sway/commands/input/xkb_layout.c
@@ -5,11 +5,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_xkb_layout(int argc, char **argv) {
-        wlr_log(L_DEBUG, "xkb layout for device: %s", current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "xkb_layout", EXPECTED_EQUAL_TO, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "xkb_layout", "No input device defined.");
         }
diff --git a/sway/commands/input/xkb_model.c b/sway/commands/input/xkb_model.c
index 819b796b..e8c8e04e 100644
--- a/sway/commands/input/xkb_model.c
+++ b/sway/commands/input/xkb_model.c
@@ -5,11 +5,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_xkb_model(int argc, char **argv) {
-        wlr_log(L_DEBUG, "xkb model for device: %s", current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "xkb_model", EXPECTED_EQUAL_TO, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "xkb_model", "No input device defined.");
         }
diff --git a/sway/commands/input/xkb_options.c b/sway/commands/input/xkb_options.c
index ff5f83ec..e9ddd6e3 100644
--- a/sway/commands/input/xkb_options.c
+++ b/sway/commands/input/xkb_options.c
@@ -5,11 +5,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_xkb_options(int argc, char **argv) {
-        wlr_log(L_DEBUG, "xkb options for device: %s", current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "xkb_options", EXPECTED_EQUAL_TO, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "xkb_options", "No input device defined.");
         }
diff --git a/sway/commands/input/xkb_rules.c b/sway/commands/input/xkb_rules.c
index aafe0003..926d0ac1 100644
--- a/sway/commands/input/xkb_rules.c
+++ b/sway/commands/input/xkb_rules.c
@@ -5,11 +5,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_xkb_rules(int argc, char **argv) {
-        wlr_log(L_DEBUG, "xkb rules for device: %s", current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "xkb_rules", EXPECTED_EQUAL_TO, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "xkb_rules", "No input device defined.");
         }
diff --git a/sway/commands/input/xkb_variant.c b/sway/commands/input/xkb_variant.c
index 89a61fdc..0e3ffd41 100644
--- a/sway/commands/input/xkb_variant.c
+++ b/sway/commands/input/xkb_variant.c
@@ -5,11 +5,12 @@
 #include "log.h"
 
 struct cmd_results *input_cmd_xkb_variant(int argc, char **argv) {
-        wlr_log(L_DEBUG, "xkb variant for device: %s", current_input_config->identifier);
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "xkb_variant", EXPECTED_EQUAL_TO, 1))) {
                 return error;
         }
+        struct input_config *current_input_config =
+                config->handler_context.input_config;
         if (!current_input_config) {
                 return cmd_results_new(CMD_FAILURE, "xkb_variant", "No input device defined.");
         }
diff --git a/sway/commands/kill.c b/sway/commands/kill.c
new file mode 100644
index 00000000..3804f0b0
--- /dev/null
+++ b/sway/commands/kill.c
@@ -0,0 +1,28 @@
+#include <wlr/util/log.h>
+#include "log.h"
+#include "sway/input/input-manager.h"
+#include "sway/input/seat.h"
+#include "sway/view.h"
+#include "sway/commands.h"
+
+struct cmd_results *cmd_kill(int argc, char **argv) {
+        if (config->reading) {
+                return cmd_results_new(CMD_FAILURE, "kill",
+                        "Command 'kill' cannot be used in the config file");
+        }
+        if (!sway_assert(config->handler_context.current_container,
+                                "cmd_kill called without container context")) {
+                return cmd_results_new(CMD_INVALID, NULL,
+                                "cmd_kill called without container context "
+                                "(this is a bug in sway)");
+        }
+        // TODO close arbitrary containers without a view
+        struct sway_view *view =
+                config->handler_context.current_container->sway_view;
+
+        if (view) {
+                view_close(view);
+        }
+
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/seat.c b/sway/commands/seat.c
index 6284002b..45079616 100644
--- a/sway/commands/seat.c
+++ b/sway/commands/seat.c
@@ -11,8 +11,12 @@ struct cmd_results *cmd_seat(int argc, char **argv) {
         }
 
         if (config->reading && strcmp("{", argv[1]) == 0) {
-                current_seat_config = new_seat_config(argv[0]);
-                wlr_log(L_DEBUG, "entering seat block: %s", current_seat_config->name);
+                free_seat_config(config->handler_context.seat_config);
+                config->handler_context.seat_config = new_seat_config(argv[0]);
+                if (!config->handler_context.seat_config) {
+                        return cmd_results_new(CMD_FAILURE, NULL, "Couldn't allocate config");
+                }
+                wlr_log(L_DEBUG, "entering seat block: %s", argv[0]);
                 return cmd_results_new(CMD_BLOCK_SEAT, NULL, NULL);
         }
 
@@ -20,11 +24,18 @@ struct cmd_results *cmd_seat(int argc, char **argv) {
                 return error;
         }
 
+        bool has_context = (config->handler_context.seat_config != NULL);
+        if (!has_context) {
+                config->handler_context.seat_config = new_seat_config(argv[0]);
+                if (!config->handler_context.seat_config) {
+                        return cmd_results_new(CMD_FAILURE, NULL, "Couldn't allocate config");
+                }
+        }
+
         int argc_new = argc-2;
         char **argv_new = argv+2;
 
         struct cmd_results *res;
-        current_seat_config = new_seat_config(argv[0]);
         if (strcasecmp("attach", argv[1]) == 0) {
                 res = seat_cmd_attach(argc_new, argv_new);
         } else if (strcasecmp("fallback", argv[1]) == 0) {
@@ -32,6 +43,12 @@ struct cmd_results *cmd_seat(int argc, char **argv) {
         } else {
                 res = cmd_results_new(CMD_INVALID, "seat <name>", "Unknown command %s", argv[1]);
         }
-        current_seat_config = NULL;
+
+        if (!has_context) {
+                // clean up the context we created earlier
+                free_seat_config(config->handler_context.seat_config);
+                config->handler_context.seat_config = NULL;
+        }
+
         return res;
 }
diff --git a/sway/commands/seat/attach.c b/sway/commands/seat/attach.c
index 80ec63ce..3e771c00 100644
--- a/sway/commands/seat/attach.c
+++ b/sway/commands/seat/attach.c
@@ -12,6 +12,8 @@ struct cmd_results *seat_cmd_attach(int argc, char **argv) {
         if ((error = checkarg(argc, "attach", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct seat_config *current_seat_config =
+                config->handler_context.seat_config;
         if (!current_seat_config) {
                 return cmd_results_new(CMD_FAILURE, "attach", "No seat defined");
         }
diff --git a/sway/commands/seat/fallback.c b/sway/commands/seat/fallback.c
index 7c129aae..56feaab5 100644
--- a/sway/commands/seat/fallback.c
+++ b/sway/commands/seat/fallback.c
@@ -9,6 +9,8 @@ struct cmd_results *seat_cmd_fallback(int argc, char **argv) {
         if ((error = checkarg(argc, "fallback", EXPECTED_AT_LEAST, 1))) {
                 return error;
         }
+        struct seat_config *current_seat_config =
+                config->handler_context.seat_config;
         if (!current_seat_config) {
                 return cmd_results_new(CMD_FAILURE, "fallback", "No seat defined");
         }
@@ -20,6 +22,7 @@ struct cmd_results *seat_cmd_fallback(int argc, char **argv) {
         } else if (strcasecmp(argv[0], "false") == 0) {
                 new_config->fallback = 0;
         } else {
+                free_seat_config(new_config);
                 return cmd_results_new(CMD_INVALID, "fallback",
                         "Expected 'fallback <true|false>'");
         }
diff --git a/sway/config.c b/sway/config.c
index cbd9a8b2..1fd123b7 100644
--- a/sway/config.c
+++ b/sway/config.c
@@ -54,6 +54,8 @@ static void free_mode(struct sway_mode *mode) {
 }
 
 void free_config(struct sway_config *config) {
+        config_clear_handler_context(config);
+
         int i;
 
         if (!config) {
@@ -485,6 +487,12 @@ bool load_include_configs(const char *path, struct sway_config *config) {
         return true;
 }
 
+void config_clear_handler_context(struct sway_config *config) {
+        free_input_config(config->handler_context.input_config);
+        free_seat_config(config->handler_context.seat_config);
+
+        memset(&config->handler_context, 0, sizeof(config->handler_context));
+}
 
 bool read_config(FILE *file, struct sway_config *config) {
         bool success = true;
@@ -597,14 +605,11 @@ bool read_config(FILE *file, struct sway_config *config) {
 
                         case CMD_BLOCK_INPUT:
                                 wlr_log(L_DEBUG, "End of input block");
-                                free_input_config(current_input_config);
-                                current_input_config = NULL;
                                 block = CMD_BLOCK_END;
                                 break;
 
                         case CMD_BLOCK_SEAT:
                                 wlr_log(L_DEBUG, "End of seat block");
-                                current_seat_config = NULL;
                                 block = CMD_BLOCK_END;
                                 break;
 
@@ -640,6 +645,7 @@ bool read_config(FILE *file, struct sway_config *config) {
 
                         default:;
                         }
+                        config_clear_handler_context(config);
                 default:;
                 }
                 free(line);
diff --git a/sway/criteria.c b/sway/criteria.c
new file mode 100644
index 00000000..2eee331c
--- /dev/null
+++ b/sway/criteria.c
@@ -0,0 +1,445 @@
+#define _XOPEN_SOURCE 700
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <pcre.h>
+#include "sway/criteria.h"
+#include "sway/container.h"
+#include "sway/config.h"
+#include "sway/view.h"
+#include "stringop.h"
+#include "list.h"
+#include "log.h"
+
+enum criteria_type { // *must* keep in sync with criteria_strings[]
+        CRIT_APP_ID,
+        CRIT_CLASS,
+        CRIT_CON_ID,
+        CRIT_CON_MARK,
+        CRIT_FLOATING,
+        CRIT_ID,
+        CRIT_INSTANCE,
+        CRIT_TILING,
+        CRIT_TITLE,
+        CRIT_URGENT,
+        CRIT_WINDOW_ROLE,
+        CRIT_WINDOW_TYPE,
+        CRIT_WORKSPACE,
+        CRIT_LAST
+};
+
+static const char * const criteria_strings[CRIT_LAST] = {
+        [CRIT_APP_ID] = "app_id",
+        [CRIT_CLASS] = "class",
+        [CRIT_CON_ID] = "con_id",
+        [CRIT_CON_MARK] = "con_mark",
+        [CRIT_FLOATING] = "floating",
+        [CRIT_ID] = "id",
+        [CRIT_INSTANCE] = "instance",
+        [CRIT_TILING] = "tiling",
+        [CRIT_TITLE] = "title",
+        [CRIT_URGENT] = "urgent", // either "latest" or "oldest" ...
+        [CRIT_WINDOW_ROLE] = "window_role",
+        [CRIT_WINDOW_TYPE] = "window_type",
+        [CRIT_WORKSPACE] = "workspace"
+};
+
+/**
+ * A single criteria token (ie. value/regex pair),
+ * e.g. 'class="some class regex"'.
+ */
+struct crit_token {
+        enum criteria_type type;
+        pcre *regex;
+        char *raw;
+};
+
+static void free_crit_token(struct crit_token *crit) {
+        pcre_free(crit->regex);
+        free(crit->raw);
+        free(crit);
+}
+
+static void free_crit_tokens(list_t *crit_tokens) {
+        for (int i = 0; i < crit_tokens->length; i++) {
+                free_crit_token(crit_tokens->items[i]);
+        }
+        list_free(crit_tokens);
+}
+
+// Extracts criteria string from its brackets. Returns new (duplicate)
+// substring.
+static char *criteria_from(const char *arg) {
+        char *criteria = NULL;
+        if (*arg == '[') {
+                criteria = strdup(arg + 1);
+        } else {
+                criteria = strdup(arg);
+        }
+
+        int last = strlen(criteria) - 1;
+        if (criteria[last] == ']') {
+                criteria[last] = '\0';
+        }
+        return criteria;
+}
+
+// Return instances of c found in str.
+static int countchr(char *str, char c) {
+        int found = 0;
+        for (int i = 0; str[i]; i++) {
+                if (str[i] == c) {
+                        ++found;
+                }
+        }
+        return found;
+}
+
+// criteria_str is e.g. '[class="some class regex" instance="instance name"]'.
+//
+// Will create array of pointers in buf, where first is duplicate of given
+// string (must be freed) and the rest are pointers to names and values in the
+// base string (every other, naturally). argc will be populated with the length
+// of buf.
+//
+// Returns error string or NULL if successful.
+static char *crit_tokens(int *argc, char ***buf,
+                const char * const criteria_str) {
+        wlr_log(L_DEBUG, "Parsing criteria: '%s'", criteria_str);
+        char *base = criteria_from(criteria_str);
+        char *head = base;
+        char *namep = head; // start of criteria name
+        char *valp = NULL; // start of value
+
+        // We're going to place EOS markers where we need to and fill up an array
+        // of pointers to the start of each token (either name or value).
+        int pairs = countchr(base, '=');
+        int max_tokens = pairs * 2 + 1; // this gives us at least enough slots
+
+        char **argv = *buf = calloc(max_tokens, sizeof(char*));
+        argv[0] = base; // this needs to be freed by caller
+        bool quoted = true;
+
+        *argc = 1; // uneven = name, even = value
+        while (*head && *argc < max_tokens) {
+                if (namep != head && *(head - 1) == '\\') {
+                        // escaped character: don't try to parse this
+                } else if (*head == '=' && namep != head) {
+                        if (*argc % 2 != 1) {
+                                // we're not expecting a name
+                                return strdup("Unable to parse criteria: "
+                                        "Found out of place equal sign");
+                        } else {
+                                // name ends here
+                                char *end = head; // don't want to rewind the head
+                                while (*(end - 1) == ' ') {
+                                        --end;
+                                }
+                                *end = '\0';
+                                if (*(namep) == ' ') {
+                                        namep = strrchr(namep, ' ') + 1;
+                                }
+                                argv[*argc] = namep;
+                                *argc += 1;
+                        }
+                } else if (*head == '"') {
+                        if (*argc % 2 != 0) {
+                                // we're not expecting a value
+                                return strdup("Unable to parse criteria: "
+                                        "Found quoted value where it was not expected");
+                        } else if (!valp) { // value starts here
+                                valp = head + 1;
+                                quoted = true;
+                        } else {
+                                // value ends here
+                                argv[*argc] = valp;
+                                *argc += 1;
+                                *head = '\0';
+                                valp = NULL;
+                                namep = head + 1;
+                        }
+                } else if (*argc % 2 == 0 && *head != ' ') {
+                        // parse unquoted values
+                        if (!valp) {
+                                quoted = false;
+                                valp = head;  // value starts here
+                        }
+                } else if (valp && !quoted && *head == ' ') {
+                        // value ends here
+                        argv[*argc] = valp;
+                        *argc += 1;
+                        *head = '\0';
+                        valp = NULL;
+                        namep = head + 1;
+                }
+                head++;
+        }
+
+        // catch last unquoted value if needed
+        if (valp && !quoted && !*head) {
+                argv[*argc] = valp;
+                *argc += 1;
+        }
+
+        return NULL;
+}
+
+// Returns error string on failure or NULL otherwise.
+static char *parse_criteria_name(enum criteria_type *type, char *name) {
+        *type = CRIT_LAST;
+        for (int i = 0; i < CRIT_LAST; i++) {
+                if (strcmp(criteria_strings[i], name) == 0) {
+                        *type = (enum criteria_type) i;
+                        break;
+                }
+        }
+        if (*type == CRIT_LAST) {
+                const char *fmt = "Criteria type '%s' is invalid or unsupported.";
+                int len = strlen(name) + strlen(fmt) - 1;
+                char *error = malloc(len);
+                snprintf(error, len, fmt, name);
+                return error;
+        } else if (*type == CRIT_URGENT || *type == CRIT_WINDOW_ROLE ||
+                        *type == CRIT_WINDOW_TYPE) {
+                // (we're just being helpful here)
+                const char *fmt = "\"%s\" criteria currently unsupported, "
+                        "no window will match this";
+                int len = strlen(fmt) + strlen(name) - 1;
+                char *error = malloc(len);
+                snprintf(error, len, fmt, name);
+                return error;
+        }
+        return NULL;
+}
+
+// Returns error string on failure or NULL otherwise.
+static char *generate_regex(pcre **regex, char *value) {
+        const char *reg_err;
+        int offset;
+
+        *regex = pcre_compile(value, PCRE_UTF8 | PCRE_UCP, &reg_err, &offset, NULL);
+
+        if (!*regex) {
+                const char *fmt = "Regex compilation (for '%s') failed: %s";
+                int len = strlen(fmt) + strlen(value) + strlen(reg_err) - 3;
+                char *error = malloc(len);
+                snprintf(error, len, fmt, value, reg_err);
+                return error;
+        }
+        return NULL;
+}
+
+// Test whether the criterion corresponds to the currently focused window
+static bool crit_is_focused(const char *value) {
+        return !strcmp(value, "focused") || !strcmp(value, "__focused__");
+}
+
+// Populate list with crit_tokens extracted from criteria string, returns error
+// string or NULL if successful.
+char *extract_crit_tokens(list_t *tokens, const char * const criteria) {
+        int argc;
+        char **argv = NULL, *error = NULL;
+        if ((error = crit_tokens(&argc, &argv, criteria))) {
+                goto ect_cleanup;
+        }
+        for (int i = 1; i + 1 < argc; i += 2) {
+                char* name = argv[i], *value = argv[i + 1];
+                struct crit_token *token = calloc(1, sizeof(struct crit_token));
+                token->raw = strdup(value);
+
+                if ((error = parse_criteria_name(&token->type, name))) {
+                        free_crit_token(token);
+                        goto ect_cleanup;
+                } else if (token->type == CRIT_URGENT || crit_is_focused(value)) {
+                        wlr_log(L_DEBUG, "%s -> \"%s\"", name, value);
+                        list_add(tokens, token);
+                } else if((error = generate_regex(&token->regex, value))) {
+                        free_crit_token(token);
+                        goto ect_cleanup;
+                } else {
+                        wlr_log(L_DEBUG, "%s -> /%s/", name, value);
+                        list_add(tokens, token);
+                }
+        }
+ect_cleanup:
+        free(argv[0]); // base string
+        free(argv);
+        return error;
+}
+
+static int regex_cmp(const char *item, const pcre *regex) {
+        return pcre_exec(regex, NULL, item, strlen(item), 0, 0, NULL, 0);
+}
+
+// test a single view if it matches list of criteria tokens (all of them).
+static bool criteria_test(swayc_t *cont, list_t *tokens) {
+        if (cont->type != C_VIEW) {
+                return false;
+        }
+        int matches = 0;
+        for (int i = 0; i < tokens->length; i++) {
+                struct crit_token *crit = tokens->items[i];
+                switch (crit->type) {
+                case CRIT_CLASS:
+                        {
+                                const char *class = view_get_class(cont->sway_view);
+                                if (!class) {
+                                        break;
+                                }
+                                if (crit->regex && regex_cmp(class, crit->regex) == 0) {
+                                        matches++;
+                                }
+                                break;
+                        }
+                case CRIT_CON_ID:
+                        {
+                                char *endptr;
+                                size_t crit_id = strtoul(crit->raw, &endptr, 10);
+
+                                if (*endptr == 0 && cont->id == crit_id) {
+                                        ++matches;
+                                }
+                                break;
+                        }
+                case CRIT_CON_MARK:
+                        // TODO
+                        break;
+                case CRIT_FLOATING:
+                        // TODO
+                        break;
+                case CRIT_ID:
+                        // TODO
+                        break;
+                case CRIT_APP_ID:
+                        {
+                                const char *app_id = view_get_app_id(cont->sway_view);
+                                if (!app_id) {
+                                        break;
+                                }
+
+                                if (crit->regex && regex_cmp(app_id, crit->regex) == 0) {
+                                        matches++;
+                                }
+                                break;
+                        }
+                case CRIT_INSTANCE:
+                        {
+                                const char *instance = view_get_instance(cont->sway_view);
+                                if (!instance) {
+                                        break;
+                                }
+
+                                if (crit->regex && regex_cmp(instance, crit->regex) == 0) {
+                                        matches++;
+                                }
+                                break;
+                        }
+                case CRIT_TILING:
+                        // TODO
+                        break;
+                case CRIT_TITLE:
+                        {
+                                const char *title = view_get_title(cont->sway_view);
+                                if (!title) {
+                                        break;
+                                }
+
+                                if (crit->regex && regex_cmp(title, crit->regex) == 0) {
+                                        matches++;
+                                }
+                                break;
+                        }
+                case CRIT_URGENT:
+                        // TODO "latest" or "oldest"
+                        break;
+                case CRIT_WINDOW_ROLE:
+                        // TODO
+                        break;
+                case CRIT_WINDOW_TYPE:
+                        // TODO
+                        break;
+                case CRIT_WORKSPACE:
+                        // TODO
+                        break;
+                default:
+                        sway_abort("Invalid criteria type (%i)", crit->type);
+                        break;
+                }
+        }
+        return matches == tokens->length;
+}
+
+int criteria_cmp(const void *a, const void *b) {
+        if (a == b) {
+                return 0;
+        } else if (!a) {
+                return -1;
+        } else if (!b) {
+                return 1;
+        }
+        const struct criteria *crit_a = a, *crit_b = b;
+        int cmp = lenient_strcmp(crit_a->cmdlist, crit_b->cmdlist);
+        if (cmp != 0) {
+                return cmp;
+        }
+        return lenient_strcmp(crit_a->crit_raw, crit_b->crit_raw);
+}
+
+void free_criteria(struct criteria *crit) {
+        if (crit->tokens) {
+                free_crit_tokens(crit->tokens);
+        }
+        if (crit->cmdlist) {
+                free(crit->cmdlist);
+        }
+        if (crit->crit_raw) {
+                free(crit->crit_raw);
+        }
+        free(crit);
+}
+
+bool criteria_any(swayc_t *cont, list_t *criteria) {
+        for (int i = 0; i < criteria->length; i++) {
+                struct criteria *bc = criteria->items[i];
+                if (criteria_test(cont, bc->tokens)) {
+                        return true;
+                }
+        }
+        return false;
+}
+
+list_t *criteria_for(swayc_t *cont) {
+        list_t *criteria = config->criteria, *matches = create_list();
+        for (int i = 0; i < criteria->length; i++) {
+                struct criteria *bc = criteria->items[i];
+                if (criteria_test(cont, bc->tokens)) {
+                        list_add(matches, bc);
+                }
+        }
+        return matches;
+}
+
+struct list_tokens {
+        list_t *list;
+        list_t *tokens;
+};
+
+static void container_match_add(swayc_t *container,
+                struct list_tokens *list_tokens) {
+        if (criteria_test(container, list_tokens->tokens)) {
+                list_add(list_tokens->list, container);
+        }
+}
+
+list_t *container_for_crit_tokens(list_t *tokens) {
+        struct list_tokens list_tokens =
+                (struct list_tokens){create_list(), tokens};
+
+        container_map(&root_container,
+                (void (*)(swayc_t *, void *))container_match_add,
+                &list_tokens);
+
+        // TODO look in the scratchpad
+        
+        return list_tokens.list;
+}
diff --git a/sway/desktop/wl_shell.c b/sway/desktop/wl_shell.c
index e34f5160..0cde6583 100644
--- a/sway/desktop/wl_shell.c
+++ b/sway/desktop/wl_shell.c
@@ -51,6 +51,14 @@ static void set_activated(struct sway_view *view, bool activated) {
         // no way to activate wl_shell
 }
 
+static void close(struct sway_view *view) {
+        if (!assert_wl_shell(view)) {
+                return;
+        }
+
+        wl_client_destroy(view->wlr_wl_shell_surface->client);
+}
+
 static void handle_commit(struct wl_listener *listener, void *data) {
         struct sway_wl_shell_surface *sway_surface =
                 wl_container_of(listener, sway_surface, commit);
@@ -103,6 +111,7 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
         sway_view->iface.set_size = set_size;
         sway_view->iface.set_position = set_position;
         sway_view->iface.set_activated = set_activated;
+        sway_view->iface.close = close;
         sway_view->wlr_wl_shell_surface = shell_surface;
         sway_view->sway_wl_shell_surface = sway_surface;
         sway_view->surface = shell_surface->surface;
diff --git a/sway/desktop/xdg_shell_v6.c b/sway/desktop/xdg_shell_v6.c
index df48345c..4b50093f 100644
--- a/sway/desktop/xdg_shell_v6.c
+++ b/sway/desktop/xdg_shell_v6.c
@@ -57,6 +57,16 @@ static void set_activated(struct sway_view *view, bool activated) {
         }
 }
 
+static void close(struct sway_view *view) {
+        if (!assert_xdg(view)) {
+                return;
+        }
+        struct wlr_xdg_surface_v6 *surface = view->wlr_xdg_surface_v6;
+        if (surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
+                wlr_xdg_toplevel_v6_send_close(surface);
+        }
+}
+
 static void handle_commit(struct wl_listener *listener, void *data) {
         struct sway_xdg_surface_v6 *sway_surface =
                 wl_container_of(listener, sway_surface, commit);
@@ -107,6 +117,7 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
         sway_view->iface.set_size = set_size;
         sway_view->iface.set_position = set_position;
         sway_view->iface.set_activated = set_activated;
+        sway_view->iface.close = close;
         sway_view->wlr_xdg_surface_v6 = xdg_surface;
         sway_view->sway_xdg_surface_v6 = sway_surface;
         sway_view->surface = xdg_surface->surface;
diff --git a/sway/desktop/xwayland.c b/sway/desktop/xwayland.c
index a4d9687d..7603d3ca 100644
--- a/sway/desktop/xwayland.c
+++ b/sway/desktop/xwayland.c
@@ -80,6 +80,13 @@ static void set_activated(struct sway_view *view, bool activated) {
         wlr_xwayland_surface_activate(surface, activated);
 }
 
+static void close(struct sway_view *view) {
+        if (!assert_xwayland(view)) {
+                return;
+        }
+        wlr_xwayland_surface_close(view->wlr_xwayland_surface);
+}
+
 static void handle_commit(struct wl_listener *listener, void *data) {
         struct sway_xwayland_surface *sway_surface =
                 wl_container_of(listener, sway_surface, commit);
@@ -192,6 +199,7 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
         sway_view->iface.set_size = set_size;
         sway_view->iface.set_position = set_position;
         sway_view->iface.set_activated = set_activated;
+        sway_view->iface.close = close;
         sway_view->wlr_xwayland_surface = xsurface;
         sway_view->sway_xwayland_surface = sway_surface;
         sway_view->surface = xsurface->surface;
diff --git a/sway/input/input-manager.c b/sway/input/input-manager.c
index bfe9d9c4..2d119cf2 100644
--- a/sway/input/input-manager.c
+++ b/sway/input/input-manager.c
@@ -372,3 +372,14 @@ void sway_input_manager_configure_xcursor(struct sway_input_manager *input) {
                 sway_seat_configure_xcursor(seat);
         }
 }
+
+struct sway_seat *sway_input_manager_get_default_seat(
+                struct sway_input_manager *input) {
+        struct sway_seat *seat = NULL;
+        wl_list_for_each(seat, &input->seats, link) {
+                if (strcmp(seat->wlr_seat->name, "seat0") == 0) {
+                        return seat;
+                }
+        }
+        return seat;
+}
diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c
index 5827a1ca..6dc57d46 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -89,9 +89,12 @@ static bool binding_matches_key_state(struct sway_binding *binding,
         return false;
 }
 
-static void binding_execute_command(struct sway_binding *binding) {
+static void keyboard_execute_command(struct sway_keyboard *keyboard,
+                struct sway_binding *binding) {
         wlr_log(L_DEBUG, "running command for binding: %s",
                 binding->command);
+        config_clear_handler_context(config);
+        config->handler_context.seat = keyboard->seat_device->sway_seat;
         struct cmd_results *results = handle_command(binding->command);
         if (results->status != CMD_SUCCESS) {
                 wlr_log(L_DEBUG, "could not run command for binding: %s",
@@ -160,7 +163,7 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard,
                 }
 
                 if (match) {
-                        binding_execute_command(binding);
+                        keyboard_execute_command(keyboard, binding);
                         return true;
                 }
         }
@@ -267,7 +270,7 @@ static bool keyboard_execute_bindcode(struct sway_keyboard *keyboard,
         for (int i = 0; i < keycode_bindings->length; ++i) {
                 struct sway_binding *binding = keycode_bindings->items[i];
                 if (binding_matches_keycodes(wlr_keyboard, binding, event)) {
-                        binding_execute_command(binding);
+                        keyboard_execute_command(keyboard, binding);
                         return true;
                 }
         }
diff --git a/sway/input/seat.c b/sway/input/seat.c
index 22fee3c3..e9b375e0 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -214,7 +214,7 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
 
         if (container) {
                 struct sway_view *view = container->sway_view;
-                view->iface.set_activated(view, true);
+                view_set_activated(view, true);
                 wl_signal_add(&container->events.destroy, &seat->focus_destroy);
                 seat->focus_destroy.notify = handle_focus_destroy;
 
@@ -234,8 +234,7 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
         if (last_focus &&
                         !sway_input_manager_has_focus(seat->input, last_focus)) {
                 struct sway_view *view = last_focus->sway_view;
-                view->iface.set_activated(view, false);
-
+                view_set_activated(view, false);
         }
 }
 
diff --git a/sway/ipc-server.c b/sway/ipc-server.c
index d2dd881f..a16a2b80 100644
--- a/sway/ipc-server.c
+++ b/sway/ipc-server.c
@@ -335,6 +335,7 @@ void ipc_client_handle_command(struct ipc_client *client) {
         switch (client->current_command) {
         case IPC_COMMAND:
         {
+                config_clear_handler_context(config);
                 struct cmd_results *results = handle_command(buf);
                 const char *json = cmd_results_to_json(results);
                 char reply[256];
diff --git a/sway/meson.build b/sway/meson.build
index 30ec166b..80ccc01d 100644
--- a/sway/meson.build
+++ b/sway/meson.build
@@ -10,6 +10,7 @@ sway_sources = files(
         'commands/exit.c',
         'commands/exec.c',
         'commands/exec_always.c',
+        'commands/kill.c',
         'commands/include.c',
         'commands/input.c',
         'commands/seat.c',
@@ -37,6 +38,7 @@ sway_sources = files(
         'config/output.c',
         'config/seat.c',
         'config/input.c',
+        'criteria.c',
         'ipc-json.c',
         'ipc-server.c',
         'desktop/output.c',
@@ -46,10 +48,12 @@ sway_sources = files(
         'security.c',
         'tree/container.c',
         'tree/layout.c',
+        'tree/view.c',
         'tree/workspace.c',
 )
 
 sway_deps = [
+        pcre,
         pixman,
         wayland_server,
         jsonc,
diff --git a/sway/tree/container.c b/sway/tree/container.c
index d241f69a..b7b9bc68 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -157,7 +157,7 @@ swayc_t *new_view(swayc_t *sibling, struct sway_view *sway_view) {
         if (!sway_assert(sibling, "new_view called with NULL sibling/parent")) {
                 return NULL;
         }
-        const char *title = sway_view->iface.get_prop(sway_view, VIEW_PROP_TITLE);
+        const char *title = view_get_title(sway_view);
         swayc_t *swayc = new_swayc(C_VIEW);
         wlr_log(L_DEBUG, "Adding new view %p:%s to container %p %d",
                 swayc, title, sibling, sibling ? sibling->type : 0);
@@ -321,3 +321,25 @@ swayc_t *swayc_at(swayc_t *parent, double lx, double ly,
 
         return NULL;
 }
+
+void container_map(swayc_t *container, void (*f)(swayc_t *view, void *data), void *data) {
+        if (container) {
+                int i;
+                if (container->children)  {
+                        for (i = 0; i < container->children->length; ++i) {
+                                swayc_t *child = container->children->items[i];
+                                container_map(child, f, data);
+                        }
+                }
+                // TODO
+                /*
+                if (container->floating) {
+                        for (i = 0; i < container->floating->length; ++i) {
+                                swayc_t *child = container->floating->items[i];
+                                container_map(child, f, data);
+                        }
+                }
+                */
+                f(container, data);
+        }
+}
diff --git a/sway/tree/layout.c b/sway/tree/layout.c
index 01535f2d..41ff81b2 100644
--- a/sway/tree/layout.c
+++ b/sway/tree/layout.c
@@ -191,8 +191,8 @@ void arrange_windows(swayc_t *container, double width, double height) {
                 {
                         container->width = width;
                         container->height = height;
-                        container->sway_view->iface.set_size(container->sway_view,
-                                        container->width, container->height);
+                        view_set_size(container->sway_view,
+                                container->width, container->height);
                         wlr_log(L_DEBUG, "Set view to %.f x %.f @ %.f, %.f",
                                         container->width, container->height,
                                         container->x, container->y);
@@ -251,7 +251,7 @@ static void apply_horiz_layout(swayc_t *container,
                         wlr_log(L_DEBUG,
                                  "Calculating arrangement for %p:%d (will scale %f by %f)",
                                  child, child->type, width, scale);
-                        child->sway_view->iface.set_position(child->sway_view, child_x, y);
+                        view_set_position(child->sway_view, child_x, y);
 
                         if (i == end - 1) {
                                 double remaining_width = x + width - child_x;
@@ -301,7 +301,7 @@ void apply_vert_layout(swayc_t *container,
                         wlr_log(L_DEBUG,
                                  "Calculating arrangement for %p:%d (will scale %f by %f)",
                                  child, child->type, height, scale);
-                        child->sway_view->iface.set_position(child->sway_view, x, child_y);
+                        view_set_position(child->sway_view, x, child_y);
 
                         if (i == end - 1) {
                                 double remaining_height = y + height - child_y;
diff --git a/sway/tree/view.c b/sway/tree/view.c
new file mode 100644
index 00000000..b46c3b17
--- /dev/null
+++ b/sway/tree/view.c
@@ -0,0 +1,53 @@
+#include "sway/view.h"
+
+const char *view_get_title(struct sway_view *view) {
+        if (view->iface.get_prop) {
+                return view->iface.get_prop(view, VIEW_PROP_TITLE);
+        }
+        return NULL;
+}
+
+const char *view_get_app_id(struct sway_view *view) {
+        if (view->iface.get_prop) {
+                return view->iface.get_prop(view, VIEW_PROP_APP_ID);
+        }
+        return NULL;
+}
+
+const char *view_get_class(struct sway_view *view) {
+        if (view->iface.get_prop) {
+                return view->iface.get_prop(view, VIEW_PROP_CLASS);
+        }
+        return NULL;
+}
+
+const char *view_get_instance(struct sway_view *view) {
+        if (view->iface.get_prop) {
+                return view->iface.get_prop(view, VIEW_PROP_INSTANCE);
+        }
+        return NULL;
+}
+
+void view_set_size(struct sway_view *view, int width, int height) {
+        if (view->iface.set_size) {
+                view->iface.set_size(view, width, height);
+        }
+}
+
+void view_set_position(struct sway_view *view, double ox, double oy) {
+        if (view->iface.set_position) {
+                view->iface.set_position(view, ox, oy);
+        }
+}
+
+void view_set_activated(struct sway_view *view, bool activated) {
+        if (view->iface.set_activated) {
+                view->iface.set_activated(view, activated);
+        }
+}
+
+void view_close(struct sway_view *view) {
+        if (view->iface.close) {
+                view->iface.close(view);
+        }
+}