swayfx/sway/criteria.c

779 lines
18 KiB
C
Raw Normal View History

#define _POSIX_C_SOURCE 200809L
2018-01-21 08:21:45 +11:00
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
2018-09-01 23:04:49 +10:00
#include <strings.h>
2018-01-21 08:21:45 +11:00
#include <pcre.h>
#include "sway/criteria.h"
#include "sway/tree/container.h"
2018-01-21 08:21:45 +11:00
#include "sway/config.h"
#include "sway/tree/root.h"
#include "sway/tree/view.h"
Implement type safe arguments and demote sway_container This commit changes the meaning of sway_container so that it only refers to layout containers and view containers. Workspaces, outputs and the root are no longer known as containers. Instead, root, outputs, workspaces and containers are all a type of node, and containers come in two types: layout containers and view containers. In addition to the above, this implements type safe variables. This means we use specific types such as sway_output and sway_workspace instead of generic containers or nodes. However, it's worth noting that in a few places places (eg. seat focus and transactions) referring to them in a generic way is unavoidable which is why we still use nodes in some places. If you want a TL;DR, look at node.h, as well as the struct definitions for root, output, workspace and container. Note that sway_output now contains a workspaces list, and workspaces now contain a tiling and floating list, and containers now contain a pointer back to the workspace. There are now functions for seat_get_focused_workspace and seat_get_focused_container. The latter will return NULL if a workspace itself is focused. Most other seat functions like seat_get_focus and seat_set_focus now accept and return nodes. In the config->handler_context struct, current_container has been replaced with three pointers: node, container and workspace. node is the same as what current_container was, while workspace is the workspace that the node resides on and container is the actual container, which may be NULL if a workspace itself is focused. The global root_container variable has been replaced with one simply called root, which is a pointer to the sway_root instance. The way outputs are created, enabled, disabled and destroyed has changed. Previously we'd wrap the sway_output in a container when it is enabled, but as we don't have containers any more it needs a different approach. The output_create and output_destroy functions previously created/destroyed the container, but now they create/destroy the sway_output. There is a new function output_disable to disable an output without destroying it. Containers have a new view property. If this is populated then the container is a view container, otherwise it's a layout container. Like before, this property is immutable for the life of the container. Containers have both a `sway_container *parent` and `sway_workspace *workspace`. As we use specific types now, parent cannot point to a workspace so it'll be NULL for containers which are direct children of the workspace. The workspace property is set for all containers, except those which are hidden in the scratchpad as they have no workspace. In some cases we need to refer to workspaces in a container-like way. For example, workspaces have layout and children, but when using specific types this makes it difficult. Likewise, it's difficult for a container to get its parent's layout when the parent could be another container or a workspace. To make it easier, some helper functions have been created: container_parent_layout and container_get_siblings. container_remove_child has been renamed to container_detach and container_replace_child has been renamed to container_replace. `container_handle_fullscreen_reparent(con, old_parent)` has had the old_parent removed. We now unfullscreen the workspace when detaching the container, so this function is simplified and only needs one argument now. container_notify_subtree_changed has been renamed to container_update_representation. This is more descriptive of its purpose. I also wanted to be able to call it with whatever container was changed rather than the container's parent, which makes bubbling up to the workspace easier. There are now state structs per node thing. ie. sway_output_state, sway_workspace_state and sway_container_state. The focus, move and layout commands have been completely refactored to work with the specific types. I considered making these a separate PR, but I'd be backporting my changes only to replace them again, and it's easier just to test everything at once.
2018-08-30 21:00:10 +10:00
#include "sway/tree/workspace.h"
2018-01-21 08:21:45 +11:00
#include "stringop.h"
#include "list.h"
#include "log.h"
#include "config.h"
2018-01-21 08:21:45 +11:00
bool criteria_is_empty(struct criteria *criteria) {
return !criteria->title
2018-05-27 14:14:46 +10:00
&& !criteria->shell
&& !criteria->app_id
&& !criteria->con_mark
&& !criteria->con_id
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
&& !criteria->class
&& !criteria->id
&& !criteria->instance
&& !criteria->window_role
&& criteria->window_type == ATOM_LAST
#endif
&& !criteria->floating
&& !criteria->tiling
&& !criteria->urgent
&& !criteria->workspace
&& !criteria->pid;
}
2018-01-21 08:21:45 +11:00
// The error pointer is used for parsing functions, and saves having to pass it
// as an argument in several places.
char *error = NULL;
// Returns error string on failure or NULL otherwise.
static bool 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;
error = malloc(len);
snprintf(error, len, fmt, value, reg_err);
return false;
}
return true;
}
static bool pattern_create(struct pattern **pattern, char *value) {
*pattern = calloc(1, sizeof(struct pattern));
if (!*pattern) {
sway_log(SWAY_ERROR, "Failed to allocate pattern");
}
if (strcmp(value, "__focused__") == 0) {
(*pattern)->match_type = PATTERN_FOCUSED;
} else {
(*pattern)->match_type = PATTERN_PCRE;
if (!generate_regex(&(*pattern)->regex, value)) {
return false;
};
}
return true;
}
static void pattern_destroy(struct pattern *pattern) {
if (pattern) {
if (pattern->regex) {
pcre_free(pattern->regex);
}
free(pattern);
}
}
void criteria_destroy(struct criteria *criteria) {
pattern_destroy(criteria->title);
pattern_destroy(criteria->shell);
pattern_destroy(criteria->app_id);
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
pattern_destroy(criteria->class);
pattern_destroy(criteria->instance);
pattern_destroy(criteria->window_role);
#endif
pattern_destroy(criteria->con_mark);
free(criteria->workspace);
free(criteria->cmdlist);
free(criteria->raw);
free(criteria);
}
2018-01-21 08:21:45 +11:00
static int regex_cmp(const char *item, const pcre *regex) {
return pcre_exec(regex, NULL, item, strlen(item), 0, 0, NULL, 0);
}
2018-01-21 08:21:45 +11:00
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
static bool view_has_window_type(struct sway_view *view, enum atom_name name) {
2018-09-01 23:04:49 +10:00
if (view->type != SWAY_VIEW_XWAYLAND) {
return false;
}
struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
struct sway_xwayland *xwayland = &server.xwayland;
xcb_atom_t desired_atom = xwayland->atoms[name];
for (size_t i = 0; i < surface->window_type_len; ++i) {
if (surface->window_type[i] == desired_atom) {
return true;
}
}
return false;
}
#endif
2018-09-01 23:04:49 +10:00
static int cmp_urgent(const void *_a, const void *_b) {
struct sway_view *a = *(void **)_a;
struct sway_view *b = *(void **)_b;
if (a->urgent.tv_sec < b->urgent.tv_sec) {
return -1;
} else if (a->urgent.tv_sec > b->urgent.tv_sec) {
return 1;
}
if (a->urgent.tv_nsec < b->urgent.tv_nsec) {
return -1;
} else if (a->urgent.tv_nsec > b->urgent.tv_nsec) {
return 1;
}
return 0;
}
Implement type safe arguments and demote sway_container This commit changes the meaning of sway_container so that it only refers to layout containers and view containers. Workspaces, outputs and the root are no longer known as containers. Instead, root, outputs, workspaces and containers are all a type of node, and containers come in two types: layout containers and view containers. In addition to the above, this implements type safe variables. This means we use specific types such as sway_output and sway_workspace instead of generic containers or nodes. However, it's worth noting that in a few places places (eg. seat focus and transactions) referring to them in a generic way is unavoidable which is why we still use nodes in some places. If you want a TL;DR, look at node.h, as well as the struct definitions for root, output, workspace and container. Note that sway_output now contains a workspaces list, and workspaces now contain a tiling and floating list, and containers now contain a pointer back to the workspace. There are now functions for seat_get_focused_workspace and seat_get_focused_container. The latter will return NULL if a workspace itself is focused. Most other seat functions like seat_get_focus and seat_set_focus now accept and return nodes. In the config->handler_context struct, current_container has been replaced with three pointers: node, container and workspace. node is the same as what current_container was, while workspace is the workspace that the node resides on and container is the actual container, which may be NULL if a workspace itself is focused. The global root_container variable has been replaced with one simply called root, which is a pointer to the sway_root instance. The way outputs are created, enabled, disabled and destroyed has changed. Previously we'd wrap the sway_output in a container when it is enabled, but as we don't have containers any more it needs a different approach. The output_create and output_destroy functions previously created/destroyed the container, but now they create/destroy the sway_output. There is a new function output_disable to disable an output without destroying it. Containers have a new view property. If this is populated then the container is a view container, otherwise it's a layout container. Like before, this property is immutable for the life of the container. Containers have both a `sway_container *parent` and `sway_workspace *workspace`. As we use specific types now, parent cannot point to a workspace so it'll be NULL for containers which are direct children of the workspace. The workspace property is set for all containers, except those which are hidden in the scratchpad as they have no workspace. In some cases we need to refer to workspaces in a container-like way. For example, workspaces have layout and children, but when using specific types this makes it difficult. Likewise, it's difficult for a container to get its parent's layout when the parent could be another container or a workspace. To make it easier, some helper functions have been created: container_parent_layout and container_get_siblings. container_remove_child has been renamed to container_detach and container_replace_child has been renamed to container_replace. `container_handle_fullscreen_reparent(con, old_parent)` has had the old_parent removed. We now unfullscreen the workspace when detaching the container, so this function is simplified and only needs one argument now. container_notify_subtree_changed has been renamed to container_update_representation. This is more descriptive of its purpose. I also wanted to be able to call it with whatever container was changed rather than the container's parent, which makes bubbling up to the workspace easier. There are now state structs per node thing. ie. sway_output_state, sway_workspace_state and sway_container_state. The focus, move and layout commands have been completely refactored to work with the specific types. I considered making these a separate PR, but I'd be backporting my changes only to replace them again, and it's easier just to test everything at once.
2018-08-30 21:00:10 +10:00
static void find_urgent_iterator(struct sway_container *con, void *data) {
if (!con->view || !view_is_urgent(con->view)) {
return;
}
list_t *urgent_views = data;
Implement type safe arguments and demote sway_container This commit changes the meaning of sway_container so that it only refers to layout containers and view containers. Workspaces, outputs and the root are no longer known as containers. Instead, root, outputs, workspaces and containers are all a type of node, and containers come in two types: layout containers and view containers. In addition to the above, this implements type safe variables. This means we use specific types such as sway_output and sway_workspace instead of generic containers or nodes. However, it's worth noting that in a few places places (eg. seat focus and transactions) referring to them in a generic way is unavoidable which is why we still use nodes in some places. If you want a TL;DR, look at node.h, as well as the struct definitions for root, output, workspace and container. Note that sway_output now contains a workspaces list, and workspaces now contain a tiling and floating list, and containers now contain a pointer back to the workspace. There are now functions for seat_get_focused_workspace and seat_get_focused_container. The latter will return NULL if a workspace itself is focused. Most other seat functions like seat_get_focus and seat_set_focus now accept and return nodes. In the config->handler_context struct, current_container has been replaced with three pointers: node, container and workspace. node is the same as what current_container was, while workspace is the workspace that the node resides on and container is the actual container, which may be NULL if a workspace itself is focused. The global root_container variable has been replaced with one simply called root, which is a pointer to the sway_root instance. The way outputs are created, enabled, disabled and destroyed has changed. Previously we'd wrap the sway_output in a container when it is enabled, but as we don't have containers any more it needs a different approach. The output_create and output_destroy functions previously created/destroyed the container, but now they create/destroy the sway_output. There is a new function output_disable to disable an output without destroying it. Containers have a new view property. If this is populated then the container is a view container, otherwise it's a layout container. Like before, this property is immutable for the life of the container. Containers have both a `sway_container *parent` and `sway_workspace *workspace`. As we use specific types now, parent cannot point to a workspace so it'll be NULL for containers which are direct children of the workspace. The workspace property is set for all containers, except those which are hidden in the scratchpad as they have no workspace. In some cases we need to refer to workspaces in a container-like way. For example, workspaces have layout and children, but when using specific types this makes it difficult. Likewise, it's difficult for a container to get its parent's layout when the parent could be another container or a workspace. To make it easier, some helper functions have been created: container_parent_layout and container_get_siblings. container_remove_child has been renamed to container_detach and container_replace_child has been renamed to container_replace. `container_handle_fullscreen_reparent(con, old_parent)` has had the old_parent removed. We now unfullscreen the workspace when detaching the container, so this function is simplified and only needs one argument now. container_notify_subtree_changed has been renamed to container_update_representation. This is more descriptive of its purpose. I also wanted to be able to call it with whatever container was changed rather than the container's parent, which makes bubbling up to the workspace easier. There are now state structs per node thing. ie. sway_output_state, sway_workspace_state and sway_container_state. The focus, move and layout commands have been completely refactored to work with the specific types. I considered making these a separate PR, but I'd be backporting my changes only to replace them again, and it's easier just to test everything at once.
2018-08-30 21:00:10 +10:00
list_add(urgent_views, con->view);
}
static bool has_container_criteria(struct criteria *criteria) {
return criteria->con_mark || criteria->con_id;
}
static bool criteria_matches_container(struct criteria *criteria,
struct sway_container *container) {
if (criteria->con_mark) {
bool exists = false;
struct sway_container *con = container;
for (int i = 0; i < con->marks->length; ++i) {
if (regex_cmp(con->marks->items[i], criteria->con_mark->regex) == 0) {
exists = true;
break;
}
}
if (!exists) {
return false;
}
}
if (criteria->con_id) { // Internal ID
if (container->node.id != criteria->con_id) {
return false;
}
}
return true;
}
static bool criteria_matches_view(struct criteria *criteria,
struct sway_view *view) {
struct sway_seat *seat = input_manager_current_seat();
struct sway_container *focus = seat_get_focused_container(seat);
struct sway_view *focused = focus ? focus->view : NULL;
if (criteria->title) {
const char *title = view_get_title(view);
if (!title) {
return false;
}
switch (criteria->title->match_type) {
case PATTERN_FOCUSED:
if (focused && lenient_strcmp(title, view_get_title(focused))) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(title, criteria->title->regex) != 0) {
return false;
}
break;
}
2018-01-21 08:21:45 +11:00
}
2018-05-27 14:14:46 +10:00
if (criteria->shell) {
2018-05-27 21:59:38 +10:00
const char *shell = view_get_shell(view);
if (!shell) {
2018-05-27 14:14:46 +10:00
return false;
}
switch (criteria->shell->match_type) {
case PATTERN_FOCUSED:
if (focused && strcmp(shell, view_get_shell(focused))) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(shell, criteria->shell->regex) != 0) {
return false;
}
break;
}
2018-05-27 14:14:46 +10:00
}
if (criteria->app_id) {
const char *app_id = view_get_app_id(view);
if (!app_id) {
return false;
}
switch (criteria->app_id->match_type) {
case PATTERN_FOCUSED:
if (focused && lenient_strcmp(app_id, view_get_app_id(focused))) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(app_id, criteria->app_id->regex) != 0) {
return false;
}
break;
}
Overhaul criteria implementation The criteria struct now uses properties for each token type rather than the list_t list of tokens. The reason for this is that different token types have different data types: pcre, string and number to name a few. This solution should be more flexible moving forward. A bonus of this is that criteria is now easier to understand when looking at the struct definition. The criteria parser has been rewritten because the previous one didn't support valueless pairs (eg. [class="foo" floating]). Criteria now has types. Types at the moment are CT_COMMAND, CT_ASSIGN_WORKSPACE and CT_ASSIGN_OUTPUT. i3 uses types as well. Previously the assign command was creating a criteria with 'move to workspace <name>' as its command, but this caused the window to appear briefly on the focused workspace before being moved to the assigned workspace. It now creates the view directly in the assigned workspace. Each view will only execute a given criteria once. This is achieved by storing a list of executed criteria in the view. This is the same strategy used by i3. Escaping now works properly. Previously you could do things like [class="Fire\"fox"] and the stored value would be 'Fire\"fox', but it should be (and now is) 'Fire"fox'. The public functions in criteria.c are now all prefixed with criteria_. Xwayland views now listen to the set_title, set_class and set_window_type events and criteria will be run when these happen. XDG shell has none of these events so it continues to update the title in handle_commit. Each view type's get_prop function has been split into get_string_prop and get_int_prop because some properties like the X11 window ID and window type are numeric. The following new criteria tokens are now supported: * id (X11 window ID) * instance * tiling * workspace
2018-05-09 14:23:20 +10:00
}
2018-09-05 17:37:04 +10:00
if (!criteria_matches_container(criteria, view->container)) {
return false;
Overhaul criteria implementation The criteria struct now uses properties for each token type rather than the list_t list of tokens. The reason for this is that different token types have different data types: pcre, string and number to name a few. This solution should be more flexible moving forward. A bonus of this is that criteria is now easier to understand when looking at the struct definition. The criteria parser has been rewritten because the previous one didn't support valueless pairs (eg. [class="foo" floating]). Criteria now has types. Types at the moment are CT_COMMAND, CT_ASSIGN_WORKSPACE and CT_ASSIGN_OUTPUT. i3 uses types as well. Previously the assign command was creating a criteria with 'move to workspace <name>' as its command, but this caused the window to appear briefly on the focused workspace before being moved to the assigned workspace. It now creates the view directly in the assigned workspace. Each view will only execute a given criteria once. This is achieved by storing a list of executed criteria in the view. This is the same strategy used by i3. Escaping now works properly. Previously you could do things like [class="Fire\"fox"] and the stored value would be 'Fire\"fox', but it should be (and now is) 'Fire"fox'. The public functions in criteria.c are now all prefixed with criteria_. Xwayland views now listen to the set_title, set_class and set_window_type events and criteria will be run when these happen. XDG shell has none of these events so it continues to update the title in handle_commit. Each view type's get_prop function has been split into get_string_prop and get_int_prop because some properties like the X11 window ID and window type are numeric. The following new criteria tokens are now supported: * id (X11 window ID) * instance * tiling * workspace
2018-05-09 14:23:20 +10:00
}
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
if (criteria->id) { // X11 window ID
uint32_t x11_window_id = view_get_x11_window_id(view);
if (!x11_window_id || x11_window_id != criteria->id) {
return false;
}
Overhaul criteria implementation The criteria struct now uses properties for each token type rather than the list_t list of tokens. The reason for this is that different token types have different data types: pcre, string and number to name a few. This solution should be more flexible moving forward. A bonus of this is that criteria is now easier to understand when looking at the struct definition. The criteria parser has been rewritten because the previous one didn't support valueless pairs (eg. [class="foo" floating]). Criteria now has types. Types at the moment are CT_COMMAND, CT_ASSIGN_WORKSPACE and CT_ASSIGN_OUTPUT. i3 uses types as well. Previously the assign command was creating a criteria with 'move to workspace <name>' as its command, but this caused the window to appear briefly on the focused workspace before being moved to the assigned workspace. It now creates the view directly in the assigned workspace. Each view will only execute a given criteria once. This is achieved by storing a list of executed criteria in the view. This is the same strategy used by i3. Escaping now works properly. Previously you could do things like [class="Fire\"fox"] and the stored value would be 'Fire\"fox', but it should be (and now is) 'Fire"fox'. The public functions in criteria.c are now all prefixed with criteria_. Xwayland views now listen to the set_title, set_class and set_window_type events and criteria will be run when these happen. XDG shell has none of these events so it continues to update the title in handle_commit. Each view type's get_prop function has been split into get_string_prop and get_int_prop because some properties like the X11 window ID and window type are numeric. The following new criteria tokens are now supported: * id (X11 window ID) * instance * tiling * workspace
2018-05-09 14:23:20 +10:00
}
if (criteria->class) {
const char *class = view_get_class(view);
if (!class) {
return false;
}
switch (criteria->class->match_type) {
case PATTERN_FOCUSED:
if (focused && lenient_strcmp(class, view_get_class(focused))) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(class, criteria->class->regex) != 0) {
return false;
}
break;
}
}
if (criteria->instance) {
const char *instance = view_get_instance(view);
if (!instance) {
return false;
}
switch (criteria->instance->match_type) {
case PATTERN_FOCUSED:
if (focused && strcmp(instance, view_get_instance(focused))) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(instance, criteria->instance->regex) != 0) {
return false;
}
break;
}
}
Overhaul criteria implementation The criteria struct now uses properties for each token type rather than the list_t list of tokens. The reason for this is that different token types have different data types: pcre, string and number to name a few. This solution should be more flexible moving forward. A bonus of this is that criteria is now easier to understand when looking at the struct definition. The criteria parser has been rewritten because the previous one didn't support valueless pairs (eg. [class="foo" floating]). Criteria now has types. Types at the moment are CT_COMMAND, CT_ASSIGN_WORKSPACE and CT_ASSIGN_OUTPUT. i3 uses types as well. Previously the assign command was creating a criteria with 'move to workspace <name>' as its command, but this caused the window to appear briefly on the focused workspace before being moved to the assigned workspace. It now creates the view directly in the assigned workspace. Each view will only execute a given criteria once. This is achieved by storing a list of executed criteria in the view. This is the same strategy used by i3. Escaping now works properly. Previously you could do things like [class="Fire\"fox"] and the stored value would be 'Fire\"fox', but it should be (and now is) 'Fire"fox'. The public functions in criteria.c are now all prefixed with criteria_. Xwayland views now listen to the set_title, set_class and set_window_type events and criteria will be run when these happen. XDG shell has none of these events so it continues to update the title in handle_commit. Each view type's get_prop function has been split into get_string_prop and get_int_prop because some properties like the X11 window ID and window type are numeric. The following new criteria tokens are now supported: * id (X11 window ID) * instance * tiling * workspace
2018-05-09 14:23:20 +10:00
if (criteria->window_role) {
const char *window_role = view_get_window_role(view);
if (!window_role) {
return false;
}
switch (criteria->window_role->match_type) {
case PATTERN_FOCUSED:
if (focused && strcmp(window_role, view_get_window_role(focused))) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(window_role, criteria->window_role->regex) != 0) {
return false;
}
break;
}
}
2018-09-01 23:04:49 +10:00
if (criteria->window_type != ATOM_LAST) {
if (!view_has_window_type(view, criteria->window_type)) {
return false;
}
}
#endif
if (criteria->floating) {
Implement type safe arguments and demote sway_container This commit changes the meaning of sway_container so that it only refers to layout containers and view containers. Workspaces, outputs and the root are no longer known as containers. Instead, root, outputs, workspaces and containers are all a type of node, and containers come in two types: layout containers and view containers. In addition to the above, this implements type safe variables. This means we use specific types such as sway_output and sway_workspace instead of generic containers or nodes. However, it's worth noting that in a few places places (eg. seat focus and transactions) referring to them in a generic way is unavoidable which is why we still use nodes in some places. If you want a TL;DR, look at node.h, as well as the struct definitions for root, output, workspace and container. Note that sway_output now contains a workspaces list, and workspaces now contain a tiling and floating list, and containers now contain a pointer back to the workspace. There are now functions for seat_get_focused_workspace and seat_get_focused_container. The latter will return NULL if a workspace itself is focused. Most other seat functions like seat_get_focus and seat_set_focus now accept and return nodes. In the config->handler_context struct, current_container has been replaced with three pointers: node, container and workspace. node is the same as what current_container was, while workspace is the workspace that the node resides on and container is the actual container, which may be NULL if a workspace itself is focused. The global root_container variable has been replaced with one simply called root, which is a pointer to the sway_root instance. The way outputs are created, enabled, disabled and destroyed has changed. Previously we'd wrap the sway_output in a container when it is enabled, but as we don't have containers any more it needs a different approach. The output_create and output_destroy functions previously created/destroyed the container, but now they create/destroy the sway_output. There is a new function output_disable to disable an output without destroying it. Containers have a new view property. If this is populated then the container is a view container, otherwise it's a layout container. Like before, this property is immutable for the life of the container. Containers have both a `sway_container *parent` and `sway_workspace *workspace`. As we use specific types now, parent cannot point to a workspace so it'll be NULL for containers which are direct children of the workspace. The workspace property is set for all containers, except those which are hidden in the scratchpad as they have no workspace. In some cases we need to refer to workspaces in a container-like way. For example, workspaces have layout and children, but when using specific types this makes it difficult. Likewise, it's difficult for a container to get its parent's layout when the parent could be another container or a workspace. To make it easier, some helper functions have been created: container_parent_layout and container_get_siblings. container_remove_child has been renamed to container_detach and container_replace_child has been renamed to container_replace. `container_handle_fullscreen_reparent(con, old_parent)` has had the old_parent removed. We now unfullscreen the workspace when detaching the container, so this function is simplified and only needs one argument now. container_notify_subtree_changed has been renamed to container_update_representation. This is more descriptive of its purpose. I also wanted to be able to call it with whatever container was changed rather than the container's parent, which makes bubbling up to the workspace easier. There are now state structs per node thing. ie. sway_output_state, sway_workspace_state and sway_container_state. The focus, move and layout commands have been completely refactored to work with the specific types. I considered making these a separate PR, but I'd be backporting my changes only to replace them again, and it's easier just to test everything at once.
2018-08-30 21:00:10 +10:00
if (!container_is_floating(view->container)) {
2018-05-24 22:30:44 +10:00
return false;
}
}
if (criteria->tiling) {
Implement type safe arguments and demote sway_container This commit changes the meaning of sway_container so that it only refers to layout containers and view containers. Workspaces, outputs and the root are no longer known as containers. Instead, root, outputs, workspaces and containers are all a type of node, and containers come in two types: layout containers and view containers. In addition to the above, this implements type safe variables. This means we use specific types such as sway_output and sway_workspace instead of generic containers or nodes. However, it's worth noting that in a few places places (eg. seat focus and transactions) referring to them in a generic way is unavoidable which is why we still use nodes in some places. If you want a TL;DR, look at node.h, as well as the struct definitions for root, output, workspace and container. Note that sway_output now contains a workspaces list, and workspaces now contain a tiling and floating list, and containers now contain a pointer back to the workspace. There are now functions for seat_get_focused_workspace and seat_get_focused_container. The latter will return NULL if a workspace itself is focused. Most other seat functions like seat_get_focus and seat_set_focus now accept and return nodes. In the config->handler_context struct, current_container has been replaced with three pointers: node, container and workspace. node is the same as what current_container was, while workspace is the workspace that the node resides on and container is the actual container, which may be NULL if a workspace itself is focused. The global root_container variable has been replaced with one simply called root, which is a pointer to the sway_root instance. The way outputs are created, enabled, disabled and destroyed has changed. Previously we'd wrap the sway_output in a container when it is enabled, but as we don't have containers any more it needs a different approach. The output_create and output_destroy functions previously created/destroyed the container, but now they create/destroy the sway_output. There is a new function output_disable to disable an output without destroying it. Containers have a new view property. If this is populated then the container is a view container, otherwise it's a layout container. Like before, this property is immutable for the life of the container. Containers have both a `sway_container *parent` and `sway_workspace *workspace`. As we use specific types now, parent cannot point to a workspace so it'll be NULL for containers which are direct children of the workspace. The workspace property is set for all containers, except those which are hidden in the scratchpad as they have no workspace. In some cases we need to refer to workspaces in a container-like way. For example, workspaces have layout and children, but when using specific types this makes it difficult. Likewise, it's difficult for a container to get its parent's layout when the parent could be another container or a workspace. To make it easier, some helper functions have been created: container_parent_layout and container_get_siblings. container_remove_child has been renamed to container_detach and container_replace_child has been renamed to container_replace. `container_handle_fullscreen_reparent(con, old_parent)` has had the old_parent removed. We now unfullscreen the workspace when detaching the container, so this function is simplified and only needs one argument now. container_notify_subtree_changed has been renamed to container_update_representation. This is more descriptive of its purpose. I also wanted to be able to call it with whatever container was changed rather than the container's parent, which makes bubbling up to the workspace easier. There are now state structs per node thing. ie. sway_output_state, sway_workspace_state and sway_container_state. The focus, move and layout commands have been completely refactored to work with the specific types. I considered making these a separate PR, but I'd be backporting my changes only to replace them again, and it's easier just to test everything at once.
2018-08-30 21:00:10 +10:00
if (container_is_floating(view->container)) {
2018-05-24 22:30:44 +10:00
return false;
}
}
if (criteria->urgent) {
if (!view_is_urgent(view)) {
return false;
}
list_t *urgent_views = create_list();
root_for_each_container(find_urgent_iterator, urgent_views);
list_stable_sort(urgent_views, cmp_urgent);
struct sway_view *target;
if (criteria->urgent == 'o') { // oldest
target = urgent_views->items[0];
} else { // latest
target = urgent_views->items[urgent_views->length - 1];
}
list_free(urgent_views);
if (view != target) {
return false;
}
}
if (criteria->workspace) {
struct sway_workspace *ws = view->container->pending.workspace;
if (!ws) {
return false;
}
switch (criteria->workspace->match_type) {
case PATTERN_FOCUSED:
if (focused &&
strcmp(ws->name, focused->container->pending.workspace->name)) {
return false;
}
break;
case PATTERN_PCRE:
if (regex_cmp(ws->name, criteria->workspace->regex) != 0) {
return false;
}
break;
}
}
if (criteria->pid) {
if (criteria->pid != view->pid) {
return false;
}
}
return true;
2018-01-21 08:21:45 +11:00
}
list_t *criteria_for_view(struct sway_view *view, enum criteria_type types) {
list_t *criterias = config->criteria;
list_t *matches = create_list();
for (int i = 0; i < criterias->length; ++i) {
struct criteria *criteria = criterias->items[i];
if ((criteria->type & types) && criteria_matches_view(criteria, view)) {
list_add(matches, criteria);
2018-01-21 08:21:45 +11:00
}
}
return matches;
}
struct match_data {
struct criteria *criteria;
list_t *matches;
};
static void criteria_get_containers_iterator(struct sway_container *container,
void *data) {
struct match_data *match_data = data;
2018-09-05 17:37:04 +10:00
if (container->view) {
Implement type safe arguments and demote sway_container This commit changes the meaning of sway_container so that it only refers to layout containers and view containers. Workspaces, outputs and the root are no longer known as containers. Instead, root, outputs, workspaces and containers are all a type of node, and containers come in two types: layout containers and view containers. In addition to the above, this implements type safe variables. This means we use specific types such as sway_output and sway_workspace instead of generic containers or nodes. However, it's worth noting that in a few places places (eg. seat focus and transactions) referring to them in a generic way is unavoidable which is why we still use nodes in some places. If you want a TL;DR, look at node.h, as well as the struct definitions for root, output, workspace and container. Note that sway_output now contains a workspaces list, and workspaces now contain a tiling and floating list, and containers now contain a pointer back to the workspace. There are now functions for seat_get_focused_workspace and seat_get_focused_container. The latter will return NULL if a workspace itself is focused. Most other seat functions like seat_get_focus and seat_set_focus now accept and return nodes. In the config->handler_context struct, current_container has been replaced with three pointers: node, container and workspace. node is the same as what current_container was, while workspace is the workspace that the node resides on and container is the actual container, which may be NULL if a workspace itself is focused. The global root_container variable has been replaced with one simply called root, which is a pointer to the sway_root instance. The way outputs are created, enabled, disabled and destroyed has changed. Previously we'd wrap the sway_output in a container when it is enabled, but as we don't have containers any more it needs a different approach. The output_create and output_destroy functions previously created/destroyed the container, but now they create/destroy the sway_output. There is a new function output_disable to disable an output without destroying it. Containers have a new view property. If this is populated then the container is a view container, otherwise it's a layout container. Like before, this property is immutable for the life of the container. Containers have both a `sway_container *parent` and `sway_workspace *workspace`. As we use specific types now, parent cannot point to a workspace so it'll be NULL for containers which are direct children of the workspace. The workspace property is set for all containers, except those which are hidden in the scratchpad as they have no workspace. In some cases we need to refer to workspaces in a container-like way. For example, workspaces have layout and children, but when using specific types this makes it difficult. Likewise, it's difficult for a container to get its parent's layout when the parent could be another container or a workspace. To make it easier, some helper functions have been created: container_parent_layout and container_get_siblings. container_remove_child has been renamed to container_detach and container_replace_child has been renamed to container_replace. `container_handle_fullscreen_reparent(con, old_parent)` has had the old_parent removed. We now unfullscreen the workspace when detaching the container, so this function is simplified and only needs one argument now. container_notify_subtree_changed has been renamed to container_update_representation. This is more descriptive of its purpose. I also wanted to be able to call it with whatever container was changed rather than the container's parent, which makes bubbling up to the workspace easier. There are now state structs per node thing. ie. sway_output_state, sway_workspace_state and sway_container_state. The focus, move and layout commands have been completely refactored to work with the specific types. I considered making these a separate PR, but I'd be backporting my changes only to replace them again, and it's easier just to test everything at once.
2018-08-30 21:00:10 +10:00
if (criteria_matches_view(match_data->criteria, container->view)) {
list_add(match_data->matches, container);
}
} else if (has_container_criteria(match_data->criteria)) {
if (criteria_matches_container(match_data->criteria, container)) {
list_add(match_data->matches, container);
}
2018-01-21 08:21:45 +11:00
}
}
list_t *criteria_get_containers(struct criteria *criteria) {
list_t *matches = create_list();
struct match_data data = {
.criteria = criteria,
.matches = matches,
};
root_for_each_container(criteria_get_containers_iterator, &data);
return matches;
}
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
2018-09-01 23:04:49 +10:00
static enum atom_name parse_window_type(const char *type) {
if (strcasecmp(type, "normal") == 0) {
return NET_WM_WINDOW_TYPE_NORMAL;
} else if (strcasecmp(type, "dialog") == 0) {
return NET_WM_WINDOW_TYPE_DIALOG;
} else if (strcasecmp(type, "utility") == 0) {
return NET_WM_WINDOW_TYPE_UTILITY;
} else if (strcasecmp(type, "toolbar") == 0) {
return NET_WM_WINDOW_TYPE_TOOLBAR;
} else if (strcasecmp(type, "splash") == 0) {
return NET_WM_WINDOW_TYPE_SPLASH;
} else if (strcasecmp(type, "menu") == 0) {
return NET_WM_WINDOW_TYPE_MENU;
} else if (strcasecmp(type, "dropdown_menu") == 0) {
return NET_WM_WINDOW_TYPE_DROPDOWN_MENU;
} else if (strcasecmp(type, "popup_menu") == 0) {
return NET_WM_WINDOW_TYPE_POPUP_MENU;
} else if (strcasecmp(type, "tooltip") == 0) {
return NET_WM_WINDOW_TYPE_TOOLTIP;
} else if (strcasecmp(type, "notification") == 0) {
return NET_WM_WINDOW_TYPE_NOTIFICATION;
2018-09-01 23:04:49 +10:00
}
return ATOM_LAST; // ie. invalid
}
#endif
2018-09-01 23:04:49 +10:00
enum criteria_token {
T_APP_ID,
T_CON_ID,
T_CON_MARK,
T_FLOATING,
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
T_CLASS,
T_ID,
T_INSTANCE,
T_WINDOW_ROLE,
T_WINDOW_TYPE,
#endif
2018-05-27 14:14:46 +10:00
T_SHELL,
T_TILING,
T_TITLE,
T_URGENT,
T_WORKSPACE,
T_PID,
T_INVALID,
};
static enum criteria_token token_from_name(char *name) {
if (strcmp(name, "app_id") == 0) {
return T_APP_ID;
} else if (strcmp(name, "con_id") == 0) {
return T_CON_ID;
} else if (strcmp(name, "con_mark") == 0) {
return T_CON_MARK;
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
} else if (strcmp(name, "class") == 0) {
return T_CLASS;
} else if (strcmp(name, "id") == 0) {
return T_ID;
} else if (strcmp(name, "instance") == 0) {
return T_INSTANCE;
} else if (strcmp(name, "window_role") == 0) {
return T_WINDOW_ROLE;
} else if (strcmp(name, "window_type") == 0) {
return T_WINDOW_TYPE;
#endif
2018-05-27 14:14:46 +10:00
} else if (strcmp(name, "shell") == 0) {
return T_SHELL;
} else if (strcmp(name, "title") == 0) {
return T_TITLE;
} else if (strcmp(name, "urgent") == 0) {
return T_URGENT;
} else if (strcmp(name, "workspace") == 0) {
return T_WORKSPACE;
2018-10-03 20:33:32 +10:00
} else if (strcmp(name, "tiling") == 0) {
return T_TILING;
2018-10-01 02:59:32 +10:00
} else if (strcmp(name, "floating") == 0) {
return T_FLOATING;
} else if (strcmp(name, "pid") == 0) {
return T_PID;
}
return T_INVALID;
}
static bool parse_token(struct criteria *criteria, char *name, char *value) {
enum criteria_token token = token_from_name(name);
if (token == T_INVALID) {
const char *fmt = "Token '%s' is not recognized";
int len = strlen(fmt) + strlen(name) - 1;
error = malloc(len);
snprintf(error, len, fmt, name);
return false;
}
// Require value, unless token is floating or tiled
if (!value && token != T_FLOATING && token != T_TILING) {
const char *fmt = "Token '%s' requires a value";
int len = strlen(fmt) + strlen(name) - 1;
error = malloc(len);
snprintf(error, len, fmt, name);
return false;
2018-01-21 08:21:45 +11:00
}
char *endptr = NULL;
switch (token) {
case T_TITLE:
pattern_create(&criteria->title, value);
break;
2018-05-27 14:14:46 +10:00
case T_SHELL:
pattern_create(&criteria->shell, value);
2018-05-27 14:14:46 +10:00
break;
case T_APP_ID:
pattern_create(&criteria->app_id, value);
break;
case T_CON_ID:
if (strcmp(value, "__focused__") == 0) {
struct sway_seat *seat = input_manager_current_seat();
struct sway_container *focus = seat_get_focused_container(seat);
struct sway_view *view = focus ? focus->view : NULL;
criteria->con_id = view ? view->container->node.id : 0;
} else {
criteria->con_id = strtoul(value, &endptr, 10);
if (*endptr != 0) {
error = strdup("The value for 'con_id' should be '__focused__' or numeric");
}
}
break;
case T_CON_MARK:
pattern_create(&criteria->con_mark, value);
break;
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
case T_CLASS:
pattern_create(&criteria->class, value);
break;
case T_ID:
criteria->id = strtoul(value, &endptr, 10);
if (*endptr != 0) {
error = strdup("The value for 'id' should be numeric");
}
break;
case T_INSTANCE:
pattern_create(&criteria->instance, value);
break;
case T_WINDOW_ROLE:
pattern_create(&criteria->window_role, value);
break;
case T_WINDOW_TYPE:
criteria->window_type = parse_window_type(value);
break;
#endif
case T_FLOATING:
criteria->floating = true;
break;
case T_TILING:
criteria->tiling = true;
break;
case T_URGENT:
if (strcmp(value, "latest") == 0 ||
strcmp(value, "newest") == 0 ||
strcmp(value, "last") == 0 ||
strcmp(value, "recent") == 0) {
criteria->urgent = 'l';
} else if (strcmp(value, "oldest") == 0 ||
strcmp(value, "first") == 0) {
criteria->urgent = 'o';
2018-01-21 08:21:45 +11:00
} else {
error =
strdup("The value for 'urgent' must be 'first', 'last', "
"'latest', 'newest', 'oldest' or 'recent'");
2018-01-21 08:21:45 +11:00
}
break;
case T_WORKSPACE:
pattern_create(&criteria->workspace, value);
break;
case T_PID:
criteria->pid = strtoul(value, &endptr, 10);
if (*endptr != 0) {
error = strdup("The value for 'pid' should be numeric");
}
break;
case T_INVALID:
break;
2018-01-21 08:21:45 +11:00
}
if (error) {
return false;
2018-01-21 08:21:45 +11:00
}
return true;
}
static void skip_spaces(char **head) {
while (**head == ' ') {
++*head;
}
}
// Remove escaping slashes from value
static void unescape(char *value) {
if (!strchr(value, '\\')) {
return;
}
char *copy = calloc(strlen(value) + 1, 1);
char *readhead = value;
char *writehead = copy;
while (*readhead) {
if (*readhead == '\\' && *(readhead + 1) == '"') {
// skip the slash
++readhead;
Overhaul criteria implementation The criteria struct now uses properties for each token type rather than the list_t list of tokens. The reason for this is that different token types have different data types: pcre, string and number to name a few. This solution should be more flexible moving forward. A bonus of this is that criteria is now easier to understand when looking at the struct definition. The criteria parser has been rewritten because the previous one didn't support valueless pairs (eg. [class="foo" floating]). Criteria now has types. Types at the moment are CT_COMMAND, CT_ASSIGN_WORKSPACE and CT_ASSIGN_OUTPUT. i3 uses types as well. Previously the assign command was creating a criteria with 'move to workspace <name>' as its command, but this caused the window to appear briefly on the focused workspace before being moved to the assigned workspace. It now creates the view directly in the assigned workspace. Each view will only execute a given criteria once. This is achieved by storing a list of executed criteria in the view. This is the same strategy used by i3. Escaping now works properly. Previously you could do things like [class="Fire\"fox"] and the stored value would be 'Fire\"fox', but it should be (and now is) 'Fire"fox'. The public functions in criteria.c are now all prefixed with criteria_. Xwayland views now listen to the set_title, set_class and set_window_type events and criteria will be run when these happen. XDG shell has none of these events so it continues to update the title in handle_commit. Each view type's get_prop function has been split into get_string_prop and get_int_prop because some properties like the X11 window ID and window type are numeric. The following new criteria tokens are now supported: * id (X11 window ID) * instance * tiling * workspace
2018-05-09 14:23:20 +10:00
}
*writehead = *readhead;
++writehead;
++readhead;
2018-01-21 08:21:45 +11:00
}
strcpy(value, copy);
free(copy);
}
/**
* Parse a raw criteria string such as [class="foo" instance="bar"] into a
* criteria struct.
*
* If errors are found, NULL will be returned and the error argument will be
2018-05-13 08:47:22 +10:00
* populated with an error string. It is up to the caller to free the error.
*/
struct criteria *criteria_parse(char *raw, char **error_arg) {
*error_arg = NULL;
error = NULL;
char *head = raw;
skip_spaces(&head);
if (*head != '[') {
*error_arg = strdup("No criteria");
return NULL;
}
++head;
2018-09-01 23:04:49 +10:00
struct criteria *criteria = calloc(1, sizeof(struct criteria));
2018-11-18 10:33:06 +11:00
#if HAVE_XWAYLAND
2018-09-01 23:04:49 +10:00
criteria->window_type = ATOM_LAST; // default value
#endif
char *name = NULL, *value = NULL;
bool in_quotes = false;
while (*head && *head != ']') {
skip_spaces(&head);
// Parse token name
char *namestart = head;
while ((*head >= 'a' && *head <= 'z') || *head == '_') {
++head;
}
name = calloc(head - namestart + 1, 1);
if (head != namestart) {
strncpy(name, namestart, head - namestart);
}
// Parse token value
skip_spaces(&head);
value = NULL;
if (*head == '=') {
++head;
skip_spaces(&head);
if (*head == '"') {
in_quotes = true;
++head;
}
char *valuestart = head;
if (in_quotes) {
while (*head && (*head != '"' || *(head - 1) == '\\')) {
++head;
}
if (!*head) {
*error_arg = strdup("Quote mismatch in criteria");
goto cleanup;
}
} else {
while (*head && *head != ' ' && *head != ']') {
++head;
}
}
value = calloc(head - valuestart + 1, 1);
strncpy(value, valuestart, head - valuestart);
if (in_quotes) {
++head;
in_quotes = false;
}
unescape(value);
sway_log(SWAY_DEBUG, "Found pair: %s=%s", name, value);
}
if (!parse_token(criteria, name, value)) {
*error_arg = error;
goto cleanup;
}
skip_spaces(&head);
free(name);
free(value);
name = NULL;
value = NULL;
2018-01-21 08:21:45 +11:00
}
if (*head != ']') {
*error_arg = strdup("No closing brace found in criteria");
goto cleanup;
Overhaul criteria implementation The criteria struct now uses properties for each token type rather than the list_t list of tokens. The reason for this is that different token types have different data types: pcre, string and number to name a few. This solution should be more flexible moving forward. A bonus of this is that criteria is now easier to understand when looking at the struct definition. The criteria parser has been rewritten because the previous one didn't support valueless pairs (eg. [class="foo" floating]). Criteria now has types. Types at the moment are CT_COMMAND, CT_ASSIGN_WORKSPACE and CT_ASSIGN_OUTPUT. i3 uses types as well. Previously the assign command was creating a criteria with 'move to workspace <name>' as its command, but this caused the window to appear briefly on the focused workspace before being moved to the assigned workspace. It now creates the view directly in the assigned workspace. Each view will only execute a given criteria once. This is achieved by storing a list of executed criteria in the view. This is the same strategy used by i3. Escaping now works properly. Previously you could do things like [class="Fire\"fox"] and the stored value would be 'Fire\"fox', but it should be (and now is) 'Fire"fox'. The public functions in criteria.c are now all prefixed with criteria_. Xwayland views now listen to the set_title, set_class and set_window_type events and criteria will be run when these happen. XDG shell has none of these events so it continues to update the title in handle_commit. Each view type's get_prop function has been split into get_string_prop and get_int_prop because some properties like the X11 window ID and window type are numeric. The following new criteria tokens are now supported: * id (X11 window ID) * instance * tiling * workspace
2018-05-09 14:23:20 +10:00
}
2018-01-21 08:21:45 +11:00
if (criteria_is_empty(criteria)) {
*error_arg = strdup("Criteria is empty");
goto cleanup;
}
2018-01-21 08:21:45 +11:00
++head;
int len = head - raw;
criteria->raw = calloc(len + 1, 1);
strncpy(criteria->raw, raw, len);
return criteria;
cleanup:
free(name);
free(value);
criteria_destroy(criteria);
return NULL;
2018-01-21 08:21:45 +11:00
}
bool criteria_is_equal(struct criteria *left, struct criteria *right) {
if (left->type != right->type) {
return false;
}
// XXX Only implemented for CT_NO_FOCUS for now.
if (left->type == CT_NO_FOCUS) {
return strcmp(left->raw, right->raw) == 0;
}
if (left->type == CT_COMMAND) {
return strcmp(left->raw, right->raw) == 0
&& strcmp(left->cmdlist, right->cmdlist) == 0;
}
return false;
}
bool criteria_already_exists(struct criteria *criteria) {
// XXX Only implemented for CT_NO_FOCUS and CT_COMMAND for now.
// While criteria_is_equal also obeys this limitation, this is a shortcut
// to avoid processing the list.
if (criteria->type != CT_NO_FOCUS && criteria->type != CT_COMMAND) {
return false;
}
list_t *criterias = config->criteria;
for (int i = 0; i < criterias->length; ++i) {
struct criteria *existing = criterias->items[i];
if (criteria_is_equal(criteria, existing)) {
return true;
}
}
return false;
}