2018-11-25 22:12:48 +11:00
|
|
|
#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>
|
2022-08-15 14:54:07 +10:00
|
|
|
#include <pcre.h>
|
2018-01-21 08:21:45 +11:00
|
|
|
#include "sway/criteria.h"
|
2018-03-30 14:41:33 +11:00
|
|
|
#include "sway/tree/container.h"
|
2018-01-21 08:21:45 +11:00
|
|
|
#include "sway/config.h"
|
2018-08-26 12:05:16 +10:00
|
|
|
#include "sway/tree/root.h"
|
2018-03-30 14:41:33 +11:00
|
|
|
#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"
|
2018-07-25 20:17:10 +10:00
|
|
|
#include "config.h"
|
2018-01-21 08:21:45 +11:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
bool criteria_is_empty(struct criteria *criteria) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return !criteria->title
|
2018-05-27 14:14:46 +10:00
|
|
|
&& !criteria->shell
|
2018-05-13 08:16:36 +10:00
|
|
|
&& !criteria->app_id
|
|
|
|
&& !criteria->con_mark
|
|
|
|
&& !criteria->con_id
|
2018-11-18 10:33:06 +11:00
|
|
|
#if HAVE_XWAYLAND
|
2018-09-03 22:25:48 +10:00
|
|
|
&& !criteria->class
|
2018-05-13 08:16:36 +10:00
|
|
|
&& !criteria->id
|
2018-09-03 22:25:48 +10:00
|
|
|
&& !criteria->instance
|
|
|
|
&& !criteria->window_role
|
2018-09-03 19:13:50 +10:00
|
|
|
&& criteria->window_type == ATOM_LAST
|
2018-07-25 20:17:10 +10:00
|
|
|
#endif
|
2018-05-13 08:16:36 +10:00
|
|
|
&& !criteria->floating
|
|
|
|
&& !criteria->tiling
|
|
|
|
&& !criteria->urgent
|
2019-10-02 17:36:52 +10:00
|
|
|
&& !criteria->workspace
|
|
|
|
&& !criteria->pid;
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
2018-01-21 08:21:45 +11:00
|
|
|
|
2019-10-11 13:44:56 +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.
|
2022-08-15 14:54:07 +10:00
|
|
|
static bool generate_regex(pcre **regex, char *value) {
|
|
|
|
const char *reg_err;
|
|
|
|
int offset;
|
2019-10-11 13:44:56 +11:00
|
|
|
|
2022-08-15 14:54:07 +10:00
|
|
|
*regex = pcre_compile(value, PCRE_UTF8 | PCRE_UCP, ®_err, &offset, NULL);
|
2022-04-28 07:33:23 +10:00
|
|
|
|
2022-08-15 14:54:07 +10:00
|
|
|
if (!*regex) {
|
2019-10-11 13:44:56 +11:00
|
|
|
const char *fmt = "Regex compilation for '%s' failed: %s";
|
2022-08-15 14:54:07 +10:00
|
|
|
int len = strlen(fmt) + strlen(value) + strlen(reg_err) - 3;
|
2019-10-11 13:44:56 +11:00
|
|
|
error = malloc(len);
|
2022-08-15 14:54:07 +10:00
|
|
|
snprintf(error, len, fmt, value, reg_err);
|
2019-10-11 13:44:56 +11:00
|
|
|
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 {
|
2022-08-15 14:54:07 +10:00
|
|
|
(*pattern)->match_type = PATTERN_PCRE;
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!generate_regex(&(*pattern)->regex, value)) {
|
|
|
|
return false;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pattern_destroy(struct pattern *pattern) {
|
|
|
|
if (pattern) {
|
|
|
|
if (pattern->regex) {
|
2022-08-15 14:54:07 +10:00
|
|
|
pcre_free(pattern->regex);
|
2019-10-11 13:44:56 +11:00
|
|
|
}
|
|
|
|
free(pattern);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
void criteria_destroy(struct criteria *criteria) {
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_destroy(criteria->title);
|
|
|
|
pattern_destroy(criteria->shell);
|
|
|
|
pattern_destroy(criteria->app_id);
|
2018-11-18 10:33:06 +11:00
|
|
|
#if HAVE_XWAYLAND
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_destroy(criteria->class);
|
|
|
|
pattern_destroy(criteria->instance);
|
|
|
|
pattern_destroy(criteria->window_role);
|
2018-09-03 22:25:48 +10:00
|
|
|
#endif
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_destroy(criteria->con_mark);
|
2018-05-13 08:16:36 +10:00
|
|
|
free(criteria->workspace);
|
2019-02-01 22:51:03 +11:00
|
|
|
free(criteria->cmdlist);
|
|
|
|
free(criteria->raw);
|
2018-05-13 08:16:36 +10:00
|
|
|
free(criteria);
|
|
|
|
}
|
2018-01-21 08:21:45 +11:00
|
|
|
|
2022-08-15 14:54:07 +10:00
|
|
|
static int regex_cmp(const char *item, const pcre *regex) {
|
|
|
|
return pcre_exec(regex, NULL, item, strlen(item), 0, 0, NULL, 0);
|
2018-05-12 22:52:54 +10:00
|
|
|
}
|
2018-01-21 08:21:45 +11:00
|
|
|
|
2018-11-18 10:33:06 +11:00
|
|
|
#if HAVE_XWAYLAND
|
2018-09-03 19:13:50 +10:00
|
|
|
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;
|
|
|
|
}
|
2018-09-03 19:13:50 +10:00
|
|
|
#endif
|
2018-09-01 23:04:49 +10:00
|
|
|
|
2018-07-15 22:43:33 +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)) {
|
2018-07-15 22:43:33 +10:00
|
|
|
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);
|
2018-07-15 22:43:33 +10:00
|
|
|
}
|
|
|
|
|
2020-01-26 20:27:52 +11:00
|
|
|
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) {
|
2022-08-15 14:54:07 +10:00
|
|
|
if (regex_cmp(con->marks->items[i], criteria->con_mark->regex) == 0) {
|
2020-01-26 20:27:52 +11:00
|
|
|
exists = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!exists) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (criteria->con_id) { // Internal ID
|
|
|
|
if (container->node.id != criteria->con_id) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
static bool criteria_matches_view(struct criteria *criteria,
|
|
|
|
struct sway_view *view) {
|
2019-10-11 13:44:56 +11:00
|
|
|
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;
|
2019-03-23 18:49:29 +11:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
if (criteria->title) {
|
|
|
|
const char *title = view_get_title(view);
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!title) {
|
2018-05-13 08:16:36 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->title->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
2020-11-17 11:26:38 +11:00
|
|
|
if (focused && lenient_strcmp(title, view_get_title(focused))) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(title, criteria->title->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
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);
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!shell) {
|
2018-05-27 14:14:46 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->shell->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
|
|
|
if (focused && strcmp(shell, view_get_shell(focused))) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(shell, criteria->shell->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-05-27 14:14:46 +10:00
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
if (criteria->app_id) {
|
|
|
|
const char *app_id = view_get_app_id(view);
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!app_id) {
|
2018-05-13 08:16:36 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->app_id->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
2020-11-17 11:26:38 +11:00
|
|
|
if (focused && lenient_strcmp(app_id, view_get_app_id(focused))) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(app_id, criteria->app_id->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-05-09 14:23:20 +10:00
|
|
|
}
|
2018-09-05 17:37:04 +10:00
|
|
|
|
2020-01-26 20:27:52 +11:00
|
|
|
if (!criteria_matches_container(criteria, view->container)) {
|
|
|
|
return false;
|
2018-05-09 14:23:20 +10:00
|
|
|
}
|
|
|
|
|
2018-11-18 10:33:06 +11:00
|
|
|
#if HAVE_XWAYLAND
|
2018-05-13 08:16:36 +10:00
|
|
|
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;
|
|
|
|
}
|
2018-05-09 14:23:20 +10:00
|
|
|
}
|
2018-09-03 22:25:48 +10:00
|
|
|
|
|
|
|
if (criteria->class) {
|
|
|
|
const char *class = view_get_class(view);
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!class) {
|
2018-09-03 22:25:48 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->class->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
2020-11-17 11:26:38 +11:00
|
|
|
if (focused && lenient_strcmp(class, view_get_class(focused))) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(class, criteria->class->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-09-03 22:25:48 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
if (criteria->instance) {
|
|
|
|
const char *instance = view_get_instance(view);
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!instance) {
|
2018-09-03 22:25:48 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->instance->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
|
|
|
if (focused && strcmp(instance, view_get_instance(focused))) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(instance, criteria->instance->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-09-03 22:25:48 +10:00
|
|
|
}
|
2018-05-09 14:23:20 +10:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
if (criteria->window_role) {
|
2019-10-11 13:44:56 +11:00
|
|
|
const char *window_role = view_get_window_role(view);
|
|
|
|
if (!window_role) {
|
2018-09-02 20:06:25 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->window_role->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
|
|
|
if (focused && strcmp(window_role, view_get_window_role(focused))) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(window_role, criteria->window_role->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
|
|
|
|
2018-09-01 23:04:49 +10:00
|
|
|
if (criteria->window_type != ATOM_LAST) {
|
|
|
|
if (!view_has_window_type(view, criteria->window_type)) {
|
2018-05-13 08:16:36 +10:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2018-09-03 19:13:50 +10:00
|
|
|
#endif
|
2018-05-13 08:16:36 +10:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
if (criteria->urgent) {
|
2018-07-15 22:43:33 +10:00
|
|
|
if (!view_is_urgent(view)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
list_t *urgent_views = create_list();
|
2018-08-17 19:48:34 +10:00
|
|
|
root_for_each_container(find_urgent_iterator, urgent_views);
|
2018-07-15 22:43:33 +10:00
|
|
|
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;
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
if (criteria->workspace) {
|
2021-02-13 09:22:51 +11:00
|
|
|
struct sway_workspace *ws = view->container->pending.workspace;
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!ws) {
|
2018-05-13 08:16:36 +10:00
|
|
|
return false;
|
|
|
|
}
|
2019-10-11 13:44:56 +11:00
|
|
|
|
|
|
|
switch (criteria->workspace->match_type) {
|
|
|
|
case PATTERN_FOCUSED:
|
|
|
|
if (focused &&
|
2021-02-13 09:22:51 +11:00
|
|
|
strcmp(ws->name, focused->container->pending.workspace->name)) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-15 14:54:07 +10:00
|
|
|
case PATTERN_PCRE:
|
|
|
|
if (regex_cmp(ws->name, criteria->workspace->regex) != 0) {
|
2019-10-11 13:44:56 +11:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
|
|
|
|
2019-10-02 17:36:52 +10:00
|
|
|
if (criteria->pid) {
|
|
|
|
if (criteria->pid != view->pid) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
return true;
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10: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
|
|
|
}
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
return matches;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct match_data {
|
|
|
|
struct criteria *criteria;
|
|
|
|
list_t *matches;
|
|
|
|
};
|
|
|
|
|
2020-01-26 20:27:52 +11:00
|
|
|
static void criteria_get_containers_iterator(struct sway_container *container,
|
2018-05-13 08:16:36 +10:00
|
|
|
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)) {
|
2020-01-26 20:27:52 +11:00
|
|
|
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-05-13 08:16:36 +10:00
|
|
|
}
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-26 20:27:52 +11:00
|
|
|
list_t *criteria_get_containers(struct criteria *criteria) {
|
2018-05-13 08:16:36 +10:00
|
|
|
list_t *matches = create_list();
|
|
|
|
struct match_data data = {
|
|
|
|
.criteria = criteria,
|
|
|
|
.matches = matches,
|
|
|
|
};
|
2020-01-26 20:27:52 +11:00
|
|
|
root_for_each_container(criteria_get_containers_iterator, &data);
|
2018-05-13 08:16:36 +10:00
|
|
|
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;
|
2018-10-22 00:51:35 +11:00
|
|
|
} 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
|
|
|
|
}
|
2018-09-03 19:13:50 +10:00
|
|
|
#endif
|
2018-09-01 23:04:49 +10:00
|
|
|
|
2018-05-13 08:17:46 +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
|
2018-09-03 22:25:48 +10:00
|
|
|
T_CLASS,
|
2018-05-13 08:17:46 +10:00
|
|
|
T_ID,
|
2018-09-03 22:25:48 +10:00
|
|
|
T_INSTANCE,
|
|
|
|
T_WINDOW_ROLE,
|
2018-09-03 19:13:50 +10:00
|
|
|
T_WINDOW_TYPE,
|
2018-07-25 21:43:21 +10:00
|
|
|
#endif
|
2018-05-27 14:14:46 +10:00
|
|
|
T_SHELL,
|
2018-05-13 08:17:46 +10:00
|
|
|
T_TILING,
|
|
|
|
T_TITLE,
|
|
|
|
T_URGENT,
|
|
|
|
T_WORKSPACE,
|
2019-10-02 17:36:52 +10:00
|
|
|
T_PID,
|
2018-05-13 08:17:46 +10:00
|
|
|
|
|
|
|
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
|
2018-09-03 22:25:48 +10:00
|
|
|
} else if (strcmp(name, "class") == 0) {
|
|
|
|
return T_CLASS;
|
2018-05-13 08:17:46 +10:00
|
|
|
} else if (strcmp(name, "id") == 0) {
|
|
|
|
return T_ID;
|
2018-09-03 22:25:48 +10:00
|
|
|
} else if (strcmp(name, "instance") == 0) {
|
|
|
|
return T_INSTANCE;
|
|
|
|
} else if (strcmp(name, "window_role") == 0) {
|
|
|
|
return T_WINDOW_ROLE;
|
2018-09-03 19:13:50 +10:00
|
|
|
} else if (strcmp(name, "window_type") == 0) {
|
|
|
|
return T_WINDOW_TYPE;
|
2018-07-25 20:17:10 +10:00
|
|
|
#endif
|
2018-05-27 14:14:46 +10:00
|
|
|
} else if (strcmp(name, "shell") == 0) {
|
|
|
|
return T_SHELL;
|
2018-05-13 08:17:46 +10:00
|
|
|
} 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;
|
2019-10-02 17:36:52 +10:00
|
|
|
} else if (strcmp(name, "pid") == 0) {
|
|
|
|
return T_PID;
|
2018-05-13 08:17:46 +10:00
|
|
|
}
|
|
|
|
return T_INVALID;
|
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
static bool parse_token(struct criteria *criteria, char *name, char *value) {
|
2018-05-13 08:17:46 +10:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
// Require value, unless token is floating or tiled
|
2019-10-11 13:44:56 +11:00
|
|
|
if (!value && token != T_FLOATING && token != T_TILING) {
|
2018-05-13 08:16:36 +10:00
|
|
|
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
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
|
2018-05-13 08:17:46 +10:00
|
|
|
char *endptr = NULL;
|
|
|
|
switch (token) {
|
|
|
|
case T_TITLE:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->title, value);
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
2018-05-27 14:14:46 +10:00
|
|
|
case T_SHELL:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->shell, value);
|
2018-05-27 14:14:46 +10:00
|
|
|
break;
|
2018-05-13 08:17:46 +10:00
|
|
|
case T_APP_ID:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->app_id, value);
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
|
|
|
case T_CON_ID:
|
2019-10-11 13:44:56 +11:00
|
|
|
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");
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
|
|
|
case T_CON_MARK:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->con_mark, value);
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
2018-11-18 10:33:06 +11:00
|
|
|
#if HAVE_XWAYLAND
|
2018-09-03 22:25:48 +10:00
|
|
|
case T_CLASS:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->class, value);
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
|
|
|
case T_ID:
|
2019-10-11 13:44:56 +11:00
|
|
|
criteria->id = strtoul(value, &endptr, 10);
|
2018-05-13 08:16:36 +10:00
|
|
|
if (*endptr != 0) {
|
|
|
|
error = strdup("The value for 'id' should be numeric");
|
|
|
|
}
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
2018-09-03 22:25:48 +10:00
|
|
|
case T_INSTANCE:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->instance, value);
|
2018-09-03 22:25:48 +10:00
|
|
|
break;
|
|
|
|
case T_WINDOW_ROLE:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->window_role, value);
|
2018-09-03 22:25:48 +10:00
|
|
|
break;
|
|
|
|
case T_WINDOW_TYPE:
|
2019-10-11 13:44:56 +11:00
|
|
|
criteria->window_type = parse_window_type(value);
|
2018-09-03 22:25:48 +10:00
|
|
|
break;
|
2018-07-25 20:17:10 +10:00
|
|
|
#endif
|
2018-05-13 08:17:46 +10:00
|
|
|
case T_FLOATING:
|
2018-05-13 08:16:36 +10:00
|
|
|
criteria->floating = true;
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
|
|
|
case T_TILING:
|
2018-05-13 08:16:36 +10:00
|
|
|
criteria->tiling = true;
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
|
|
|
case T_URGENT:
|
2019-10-11 13:44:56 +11:00
|
|
|
if (strcmp(value, "latest") == 0 ||
|
|
|
|
strcmp(value, "newest") == 0 ||
|
|
|
|
strcmp(value, "last") == 0 ||
|
|
|
|
strcmp(value, "recent") == 0) {
|
2018-05-13 08:16:36 +10:00
|
|
|
criteria->urgent = 'l';
|
2019-10-11 13:44:56 +11:00
|
|
|
} else if (strcmp(value, "oldest") == 0 ||
|
|
|
|
strcmp(value, "first") == 0) {
|
2018-05-13 08:16:36 +10:00
|
|
|
criteria->urgent = 'o';
|
2018-01-21 08:21:45 +11:00
|
|
|
} else {
|
2018-05-13 08:16:36 +10:00
|
|
|
error =
|
2018-07-29 19:33:21 +10:00
|
|
|
strdup("The value for 'urgent' must be 'first', 'last', "
|
|
|
|
"'latest', 'newest', 'oldest' or 'recent'");
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
|
|
|
case T_WORKSPACE:
|
2019-10-11 13:44:56 +11:00
|
|
|
pattern_create(&criteria->workspace, value);
|
2018-05-13 08:17:46 +10:00
|
|
|
break;
|
2019-10-02 17:36:52 +10:00
|
|
|
case T_PID:
|
|
|
|
criteria->pid = strtoul(value, &endptr, 10);
|
|
|
|
if (*endptr != 0) {
|
|
|
|
error = strdup("The value for 'pid' should be numeric");
|
|
|
|
}
|
|
|
|
break;
|
2018-05-13 08:17:46 +10:00
|
|
|
case T_INVALID:
|
|
|
|
break;
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
if (error) {
|
2018-05-12 22:52:54 +10:00
|
|
|
return false;
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
2018-05-12 22:52:54 +10:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
return true;
|
2018-05-12 22:52:54 +10:00
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
static void skip_spaces(char **head) {
|
|
|
|
while (**head == ' ') {
|
|
|
|
++*head;
|
2018-05-12 22:52:54 +10:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
// Remove escaping slashes from value
|
|
|
|
static void unescape(char *value) {
|
|
|
|
if (!strchr(value, '\\')) {
|
|
|
|
return;
|
2018-05-12 22:52:54 +10:00
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
char *copy = calloc(strlen(value) + 1, 1);
|
|
|
|
char *readhead = value;
|
|
|
|
char *writehead = copy;
|
|
|
|
while (*readhead) {
|
|
|
|
if (*readhead == '\\' && *(readhead + 1) == '"') {
|
|
|
|
// skip the slash
|
|
|
|
++readhead;
|
2018-05-09 14:23:20 +10:00
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
*writehead = *readhead;
|
|
|
|
++writehead;
|
|
|
|
++readhead;
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
strcpy(value, copy);
|
|
|
|
free(copy);
|
2018-05-12 22:52:54 +10:00
|
|
|
}
|
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
/**
|
|
|
|
* 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.
|
2018-05-13 08:16:36 +10:00
|
|
|
*/
|
|
|
|
struct criteria *criteria_parse(char *raw, char **error_arg) {
|
2018-05-13 11:40:05 +10:00
|
|
|
*error_arg = NULL;
|
2018-05-13 08:16:36 +10:00
|
|
|
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
|
2018-09-03 19:13:50 +10:00
|
|
|
#endif
|
2018-05-13 08:16:36 +10:00
|
|
|
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;
|
2018-05-12 22:52:54 +10:00
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
name = calloc(head - namestart + 1, 1);
|
2018-06-08 22:58:40 +10:00
|
|
|
if (head != namestart) {
|
|
|
|
strncpy(name, namestart, head - namestart);
|
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
// 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);
|
2019-03-09 14:06:38 +11:00
|
|
|
sway_log(SWAY_DEBUG, "Found pair: %s=%s", name, value);
|
2018-05-13 08:16:36 +10:00
|
|
|
}
|
|
|
|
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
|
|
|
}
|
2018-05-13 08:16:36 +10:00
|
|
|
if (*head != ']') {
|
|
|
|
*error_arg = strdup("No closing brace found in criteria");
|
|
|
|
goto cleanup;
|
2018-05-09 14:23:20 +10:00
|
|
|
}
|
2018-01-21 08:21:45 +11:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
if (criteria_is_empty(criteria)) {
|
|
|
|
*error_arg = strdup("Criteria is empty");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2018-01-21 08:21:45 +11:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
++head;
|
|
|
|
int len = head - raw;
|
|
|
|
criteria->raw = calloc(len + 1, 1);
|
|
|
|
strncpy(criteria->raw, raw, len);
|
|
|
|
return criteria;
|
2018-05-12 22:52:54 +10:00
|
|
|
|
2018-05-13 08:16:36 +10:00
|
|
|
cleanup:
|
|
|
|
free(name);
|
|
|
|
free(value);
|
|
|
|
criteria_destroy(criteria);
|
|
|
|
return NULL;
|
2018-01-21 08:21:45 +11:00
|
|
|
}
|
2019-07-27 05:30:04 +10: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;
|
|
|
|
}
|