mirrors/sway
1
0
Fork 0
mirror of https://github.com/swaywm/sway.git synced 2026-05-03 06:46:26 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename subbackend to backend

Browse source
This commit is contained in:
Tony Crisci 2018-03-01 06:19:35 -05:00
parent 1c84c3b9b9
commit ed8923bc1b
3 changed files with 156 additions and 156 deletions
Download patch file Download diff file Expand all files Collapse all files

44
include/sway/server.h
View file

@ -12,16 +12,16 @@
// TODO WLR: make Xwayland optional // TODO WLR: make Xwayland optional
#include <wlr/xwayland.h> #include <wlr/xwayland.h>
enum sway_subbackend_type { enum sway_backend_type {
SWAY_SUBBACKEND_WAYLAND, SWAY_BACKEND_WAYLAND,
SWAY_SUBBACKEND_X11, SWAY_BACKEND_X11,
SWAY_SUBBACKEND_DRM, SWAY_BACKEND_DRM,
SWAY_SUBBACKEND_HEADLESS, SWAY_BACKEND_HEADLESS,
}; };
struct sway_subbackend { struct sway_backend {
char *name; char *name;
enum sway_subbackend_type type; enum sway_backend_type type;
struct wlr_backend *backend; struct wlr_backend *backend;
struct wl_list outputs; struct wl_list outputs;
@ -29,7 +29,7 @@ struct sway_subbackend {
struct wl_listener backend_destroy; struct wl_listener backend_destroy;
struct wl_list link; // sway_server::subbackends struct wl_list link; // sway_server::backends
}; };
@ -39,7 +39,7 @@ struct sway_server {
const char *socket; const char *socket;
struct wlr_backend *backend; struct wlr_backend *backend;
struct wl_list subbackends; // sway_server_subbackend::link struct wl_list backends; // sway_server_backend::link
struct wlr_renderer *renderer; struct wlr_renderer *renderer;
struct wlr_compositor *compositor; struct wlr_compositor *compositor;
@ -73,23 +73,23 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data);
void handle_xwayland_surface(struct wl_listener *listener, void *data); void handle_xwayland_surface(struct wl_listener *listener, void *data);
void handle_wl_shell_surface(struct wl_listener *listener, void *data); void handle_wl_shell_surface(struct wl_listener *listener, void *data);
struct sway_subbackend *sway_subbackend_create(enum sway_subbackend_type type, struct sway_backend *sway_backend_create(enum sway_backend_type type,
char *name); char *name);
void sway_server_add_subbackend(struct sway_server *server, void sway_server_add_backend(struct sway_server *server,
struct sway_subbackend *subbackend); struct sway_backend *backend);
void sway_server_remove_subbackend(struct sway_server *server, char *name); void sway_server_remove_backend(struct sway_server *server, char *name);
struct sway_subbackend *sway_server_get_subbackend(struct sway_server *server, struct sway_backend *sway_server_get_backend(struct sway_server *server,
char *name); char *name);
void sway_subbackend_add_output(struct sway_server *server, void sway_backend_add_output(struct sway_server *server,
struct sway_subbackend *subbackend, char *name); struct sway_backend *backend, char *name);
void sway_subbackend_remove_output(struct sway_server *server, void sway_backend_remove_output(struct sway_server *server,
struct sway_subbackend *subbackend, char *name); struct sway_backend *backend, char *name);
void sway_subbackend_add_input(struct sway_server *server, void sway_backend_add_input(struct sway_server *server,
struct sway_subbackend *subbackend, enum wlr_input_device_type type, struct sway_backend *backend, enum wlr_input_device_type type,
char *name); char *name);
void sway_subbackend_remove_input(struct sway_server *server, void sway_backend_remove_input(struct sway_server *server,
struct sway_subbackend *subbackend, char *name); struct sway_backend *backend, char *name);
#endif #endif

48
sway/commands/backend.c
View file

@ -10,7 +10,7 @@ static struct cmd_results *backend_cmd_del(int argc, char **argv) {
return error; return error;
} }
sway_server_remove_subbackend(&server, argv[0]); sway_server_remove_backend(&server, argv[0]);
return cmd_results_new(CMD_SUCCESS, NULL, NULL); return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} }
@ -22,15 +22,15 @@ static struct cmd_results *backend_cmd_add(int argc, char **argv) {
} }
const char *type_name = argv[0]; const char *type_name = argv[0];
enum sway_subbackend_type type; enum sway_backend_type type;
if (strcasecmp(type_name, "wayland") == 0) { if (strcasecmp(type_name, "wayland") == 0) {
type = SWAY_SUBBACKEND_WAYLAND; type = SWAY_BACKEND_WAYLAND;
} else if (strcasecmp(type_name, "x11") == 0) { } else if (strcasecmp(type_name, "x11") == 0) {
type = SWAY_SUBBACKEND_X11; type = SWAY_BACKEND_X11;
} else if (strcasecmp(type_name, "drm") == 0) { } else if (strcasecmp(type_name, "drm") == 0) {
type = SWAY_SUBBACKEND_DRM; type = SWAY_BACKEND_DRM;
} else if (strcasecmp(type_name, "headless") == 0) { } else if (strcasecmp(type_name, "headless") == 0) {
type = SWAY_SUBBACKEND_HEADLESS; type = SWAY_BACKEND_HEADLESS;
} else { } else {
error = error =
cmd_results_new(CMD_INVALID, cmd_results_new(CMD_INVALID,
@ -38,15 +38,15 @@ static struct cmd_results *backend_cmd_add(int argc, char **argv) {
return error; return error;
} }
struct sway_subbackend *subbackend = struct sway_backend *backend =
sway_subbackend_create(type, NULL); sway_backend_create(type, NULL);
sway_server_add_subbackend(&server, subbackend); sway_server_add_backend(&server, backend);
return cmd_results_new(CMD_SUCCESS, NULL, NULL); return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} }
static struct cmd_results *backend_cmd_add_output(int argc, char **argv, static struct cmd_results *backend_cmd_add_output(int argc, char **argv,
struct sway_subbackend *backend) { struct sway_backend *backend) {
// TODO allow to name the output // TODO allow to name the output
char *name = NULL; char *name = NULL;
if (argc > 0) { if (argc > 0) {
@ -57,31 +57,31 @@ static struct cmd_results *backend_cmd_add_output(int argc, char **argv,
} }
} }
sway_subbackend_add_output(&server, backend, name); sway_backend_add_output(&server, backend, name);
return cmd_results_new(CMD_SUCCESS, NULL, NULL); return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} }
static struct cmd_results *backend_cmd_del_output(int argc, char **argv, static struct cmd_results *backend_cmd_del_output(int argc, char **argv,
struct sway_subbackend *backend) { struct sway_backend *backend) {
struct cmd_results *error = NULL; struct cmd_results *error = NULL;
if ((error = checkarg(argc, "backend", EXPECTED_AT_LEAST, 1))) { if ((error = checkarg(argc, "backend", EXPECTED_AT_LEAST, 1))) {
return error; return error;
} }
sway_subbackend_remove_output(&server, backend, argv[0]); sway_backend_remove_output(&server, backend, argv[0]);
return cmd_results_new(CMD_SUCCESS, NULL, NULL); return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} }
static struct cmd_results *backend_cmd_add_input(int argc, char **argv, static struct cmd_results *backend_cmd_add_input(int argc, char **argv,
struct sway_subbackend *backend) { struct sway_backend *backend) {
return cmd_results_new(CMD_INVALID, "backend <cmd> [args]", return cmd_results_new(CMD_INVALID, "backend <cmd> [args]",
"add_output is not implemented"); "add_input is not implemented");
} }
static struct cmd_results *backend_cmd_del_input(int argc, char **argv, static struct cmd_results *backend_cmd_del_input(int argc, char **argv,
struct sway_subbackend *backend) { struct sway_backend *backend) {
return cmd_results_new(CMD_INVALID, "backend <cmd> [args]", return cmd_results_new(CMD_INVALID, "backend <cmd> [args]",
"del_output is not implemented"); "del_input is not implemented");
} }
struct cmd_results *cmd_backend(int argc, char **argv) { struct cmd_results *cmd_backend(int argc, char **argv) {
@ -99,22 +99,22 @@ struct cmd_results *cmd_backend(int argc, char **argv) {
return backend_cmd_del(argc_new, argv_new); return backend_cmd_del(argc_new, argv_new);
} }
struct sway_subbackend *subbackend = struct sway_backend *backend =
sway_server_get_subbackend(&server, argv[0]); sway_server_get_backend(&server, argv[0]);
if (subbackend == NULL) { if (backend == NULL) {
return cmd_results_new(CMD_INVALID, "backend <cmd> [args]", return cmd_results_new(CMD_INVALID, "backend <cmd> [args]",
"Cannot find backend: %s", argv[0]); "Cannot find backend: %s", argv[0]);
} }
if (strcasecmp("add-output", argv[1]) == 0) { if (strcasecmp("add-output", argv[1]) == 0) {
return backend_cmd_add_output(argc_new, argv_new, subbackend); return backend_cmd_add_output(argc_new, argv_new, backend);
} else if (strcasecmp("del-output", argv[1]) == 0) { } else if (strcasecmp("del-output", argv[1]) == 0) {
return backend_cmd_del_output(argc_new, argv_new, subbackend); return backend_cmd_del_output(argc_new, argv_new, backend);
} else if (strcasecmp("add-input", argv[1]) == 0) { } else if (strcasecmp("add-input", argv[1]) == 0) {
return backend_cmd_add_input(argc_new, argv_new, subbackend); return backend_cmd_add_input(argc_new, argv_new, backend);
} else if (strcasecmp("del-input", argv[1]) == 0) { } else if (strcasecmp("del-input", argv[1]) == 0) {
return backend_cmd_del_input(argc_new, argv_new, subbackend); return backend_cmd_del_input(argc_new, argv_new, backend);
} }
return cmd_results_new(CMD_INVALID, "backend <cmd> [args]", "Unknown command %s", argv[1]); return cmd_results_new(CMD_INVALID, "backend <cmd> [args]", "Unknown command %s", argv[1]);

220
sway/server.c
View file

@ -48,16 +48,16 @@ bool server_init(struct sway_server *server, bool headless) {
server->wl_display = wl_display_create(); server->wl_display = wl_display_create();
server->wl_event_loop = wl_display_get_event_loop(server->wl_display); server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
wl_list_init(&server->subbackends); wl_list_init(&server->backends);
if (headless) { if (headless) {
server->backend = wlr_multi_backend_create(server->wl_display); server->backend = wlr_multi_backend_create(server->wl_display);
struct sway_subbackend *subbackend = struct sway_backend *backend =
sway_subbackend_create(SWAY_SUBBACKEND_HEADLESS, "headless"); sway_backend_create(SWAY_BACKEND_HEADLESS, "headless");
sway_server_add_subbackend(server, subbackend); sway_server_add_backend(server, backend);
sway_subbackend_add_output(server, subbackend, "headless"); sway_backend_add_output(server, backend, "headless");
} else { } else {
// TODO add whatever this function creates to the subbackends // TODO add whatever this function creates to the backends
server->backend = wlr_backend_autocreate(server->wl_display); server->backend = wlr_backend_autocreate(server->wl_display);
} }
@ -125,33 +125,33 @@ void server_run(struct sway_server *server) {
wl_display_run(server->wl_display); wl_display_run(server->wl_display);
} }
static void sway_subbackend_destroy(struct sway_subbackend *subbackend) { static void sway_backend_destroy(struct sway_backend *backend) {
if (subbackend->backend) { if (backend->backend) {
wl_list_remove(&subbackend->backend_destroy.link); wl_list_remove(&backend->backend_destroy.link);
} }
wl_list_remove(&subbackend->link); wl_list_remove(&backend->link);
// free(name)? // free(name)?
free(subbackend); free(backend);
} }
struct sway_subbackend *sway_server_get_subbackend(struct sway_server *server, struct sway_backend *sway_server_get_backend(struct sway_server *server,
char *name) { char *name) {
struct sway_subbackend *subbackend = NULL; struct sway_backend *backend = NULL;
wl_list_for_each(subbackend, &server->subbackends, link) { wl_list_for_each(backend, &server->backends, link) {
if (strcasecmp(subbackend->name, name) == 0) { if (strcasecmp(backend->name, name) == 0) {
return subbackend; return backend;
} }
} }
return NULL; return NULL;
} }
struct sway_subbackend *sway_subbackend_create(enum sway_subbackend_type type, struct sway_backend *sway_backend_create(enum sway_backend_type type,
char *name) { char *name) {
struct sway_subbackend *subbackend = struct sway_backend *backend =
calloc(1, sizeof(struct sway_subbackend)); calloc(1, sizeof(struct sway_backend));
if (subbackend == NULL) { if (backend == NULL) {
wlr_log(L_ERROR, "could not allocate subbackend"); wlr_log(L_ERROR, "could not allocate backend");
return NULL; return NULL;
} }
@ -160,22 +160,22 @@ struct sway_subbackend *sway_subbackend_create(enum sway_subbackend_type type,
// type is and how many other backends are configured of that type // type is and how many other backends are configured of that type
// (<type>-<num>). // (<type>-<num>).
} else { } else {
subbackend->name = name; backend->name = name;
} }
subbackend->type = type; backend->type = type;
wl_list_init(&subbackend->outputs); wl_list_init(&backend->outputs);
wl_list_init(&subbackend->inputs); wl_list_init(&backend->inputs);
wl_list_init(&subbackend->link); wl_list_init(&backend->link);
return subbackend; return backend;
} }
static void handle_subbackend_backend_destroy(struct wl_listener *listener, static void handle_backend_backend_destroy(struct wl_listener *listener,
void *data) { void *data) {
struct sway_subbackend *subbackend = struct sway_backend *backend =
wl_container_of(listener, subbackend, backend_destroy); wl_container_of(listener, backend, backend_destroy);
sway_subbackend_destroy(subbackend); sway_backend_destroy(backend);
} }
static struct wlr_backend *wayland_backend_create(struct sway_server *server) { static struct wlr_backend *wayland_backend_create(struct sway_server *server) {
@ -206,114 +206,114 @@ static struct wlr_backend *drm_backend_create(struct sway_server *server) {
return NULL; return NULL;
} }
void sway_server_add_subbackend(struct sway_server *server, void sway_server_add_backend(struct sway_server *server,
struct sway_subbackend *subbackend) { struct sway_backend *backend) {
if (sway_server_get_subbackend(server, subbackend->name)) { if (sway_server_get_backend(server, backend->name)) {
wlr_log(L_ERROR, "cannot add subbackend '%s': already exists", wlr_log(L_ERROR, "cannot add backend '%s': already exists",
subbackend->name); backend->name);
sway_subbackend_destroy(subbackend); sway_backend_destroy(backend);
return; return;
} }
struct wlr_backend *backend = NULL; struct wlr_backend *wlr_backend = NULL;
switch (subbackend->type) { switch (backend->type) {
case SWAY_SUBBACKEND_WAYLAND: case SWAY_BACKEND_WAYLAND:
backend = wayland_backend_create(server); wlr_backend = wayland_backend_create(server);
break; break;
case SWAY_SUBBACKEND_X11: case SWAY_BACKEND_X11:
backend = x11_backend_create(server); wlr_backend = x11_backend_create(server);
break; break;
case SWAY_SUBBACKEND_DRM: case SWAY_BACKEND_DRM:
backend = drm_backend_create(server); wlr_backend = drm_backend_create(server);
break; break;
case SWAY_SUBBACKEND_HEADLESS: case SWAY_BACKEND_HEADLESS:
backend = headless_backend_create(server); wlr_backend = headless_backend_create(server);
break; break;
} }
if (backend == NULL) { if (backend == NULL) {
wlr_log(L_ERROR, "could not create subbackend '%s'", subbackend->name); wlr_log(L_ERROR, "could not create backend '%s'", backend->name);
sway_subbackend_destroy(subbackend); sway_backend_destroy(backend);
return; return;
} }
subbackend->backend = backend; backend->backend = wlr_backend;
wl_list_remove(&subbackend->link); wl_list_remove(&backend->link);
wl_list_insert(&server->subbackends, &subbackend->link); wl_list_insert(&server->backends, &backend->link);
wl_signal_add(&backend->events.destroy, &subbackend->backend_destroy); wl_signal_add(&wlr_backend->events.destroy, &backend->backend_destroy);
subbackend->backend_destroy.notify = handle_subbackend_backend_destroy; backend->backend_destroy.notify = handle_backend_backend_destroy;
wlr_multi_backend_add(server->backend, backend); wlr_multi_backend_add(server->backend, wlr_backend);
wlr_backend_start(backend); wlr_backend_start(wlr_backend);
} }
void sway_server_remove_subbackend(struct sway_server *server, char *name) { void sway_server_remove_backend(struct sway_server *server, char *name) {
struct sway_subbackend *subbackend = struct sway_backend *backend =
sway_server_get_subbackend(server, name); sway_server_get_backend(server, name);
if (!subbackend) { if (!backend) {
wlr_log(L_DEBUG, "could not find subbackend named '%s'", name); wlr_log(L_DEBUG, "could not find backend named '%s'", name);
return; return;
} }
wlr_backend_destroy(subbackend->backend); wlr_backend_destroy(backend->backend);
} }
struct subbackend_output { struct backend_output {
struct sway_subbackend *backend; struct sway_backend *backend;
struct wlr_output *wlr_output; struct wlr_output *wlr_output;
struct wl_listener output_destroy; struct wl_listener output_destroy;
struct wl_list link; // sway_subbackend::outputs struct wl_list link; // sway_backend::outputs
}; };
static void subbackend_output_destroy(struct subbackend_output *output) { static void backend_output_destroy(struct backend_output *output) {
wl_list_remove(&output->link); wl_list_remove(&output->link);
wl_list_remove(&output->output_destroy.link); wl_list_remove(&output->output_destroy.link);
free(output); free(output);
} }
static void handle_subbackend_output_destroy(struct wl_listener *listener, static void handle_backend_output_destroy(struct wl_listener *listener,
void *data) { void *data) {
struct subbackend_output *output = struct backend_output *output =
wl_container_of(listener, output, output_destroy); wl_container_of(listener, output, output_destroy);
subbackend_output_destroy(output); backend_output_destroy(output);
} }
void sway_subbackend_add_output(struct sway_server *server, void sway_backend_add_output(struct sway_server *server,
struct sway_subbackend *subbackend, char *name) { struct sway_backend *backend, char *name) {
struct wlr_output *wlr_output = NULL; struct wlr_output *wlr_output = NULL;
switch(subbackend->type) { switch(backend->type) {
case SWAY_SUBBACKEND_WAYLAND: case SWAY_BACKEND_WAYLAND:
wlr_log(L_DEBUG, "TODO: create wayland subbackend output"); wlr_log(L_DEBUG, "TODO: create wayland backend output");
break; break;
case SWAY_SUBBACKEND_X11: case SWAY_BACKEND_X11:
wlr_log(L_DEBUG, "TODO: create x11 subbackend output"); wlr_log(L_DEBUG, "TODO: create x11 backend output");
break; break;
case SWAY_SUBBACKEND_DRM: case SWAY_BACKEND_DRM:
wlr_log(L_DEBUG, "creating DRM subbackend outputs is not supported"); wlr_log(L_DEBUG, "creating DRM backend outputs is not supported");
break; break;
case SWAY_SUBBACKEND_HEADLESS: case SWAY_BACKEND_HEADLESS:
wlr_output = wlr_output =
wlr_headless_add_output(subbackend->backend, 1280, 960); wlr_headless_add_output(backend->backend, 1280, 960);
break; break;
} }
if (wlr_output == NULL) { if (wlr_output == NULL) {
wlr_log(L_ERROR, "could not create subbackend output '%s'", name); wlr_log(L_ERROR, "could not create backend output '%s'", name);
return; return;
} }
struct subbackend_output *output = struct backend_output *output =
calloc(1, sizeof(struct subbackend_output)); calloc(1, sizeof(struct backend_output));
if (output == NULL) { if (output == NULL) {
wlr_output_destroy(wlr_output); wlr_output_destroy(wlr_output);
wlr_log(L_ERROR, "could not allocate subbackend output"); wlr_log(L_ERROR, "could not allocate backend output");
return; return;
} }
@ -334,77 +334,77 @@ void sway_subbackend_add_output(struct sway_server *server,
output->wlr_output = wlr_output; output->wlr_output = wlr_output;
wl_signal_add(&wlr_output->events.destroy, &output->output_destroy); wl_signal_add(&wlr_output->events.destroy, &output->output_destroy);
output->output_destroy.notify = handle_subbackend_output_destroy; output->output_destroy.notify = handle_backend_output_destroy;
wl_list_insert(&subbackend->outputs, &output->link); wl_list_insert(&backend->outputs, &output->link);
} }
void sway_subbackend_remove_output(struct sway_server *server, void sway_backend_remove_output(struct sway_server *server,
struct sway_subbackend *subbackend, char *name) { struct sway_backend *backend, char *name) {
struct subbackend_output *output = NULL, *tmp = NULL; struct backend_output *output = NULL, *tmp = NULL;
wl_list_for_each_safe(output, tmp, &subbackend->outputs, link) { wl_list_for_each_safe(output, tmp, &backend->outputs, link) {
if (strcasecmp(output->wlr_output->name, name) == 0) { if (strcasecmp(output->wlr_output->name, name) == 0) {
wlr_output_destroy(output->wlr_output); wlr_output_destroy(output->wlr_output);
} }
} }
} }
struct subbackend_input { struct backend_input {
struct sway_subbackend *backend; struct sway_backend *backend;
struct wlr_input_device *device; struct wlr_input_device *device;
struct wl_listener input_destroy; struct wl_listener input_destroy;
struct wl_list link; // sway_subbackend::inputs struct wl_list link; // sway_backend::inputs
}; };
static void subbackend_input_destroy(struct subbackend_input *input) { static void backend_input_destroy(struct backend_input *input) {
wl_list_remove(&input->link); wl_list_remove(&input->link);
wl_list_remove(&input->input_destroy.link); wl_list_remove(&input->input_destroy.link);
free(input); free(input);
} }
static void handle_subbackend_device_destroy(struct wl_listener *listener, static void handle_backend_device_destroy(struct wl_listener *listener,
void *data) { void *data) {
struct subbackend_input *input = struct backend_input *input =
wl_container_of(listener, input, input_destroy); wl_container_of(listener, input, input_destroy);
subbackend_input_destroy(input); backend_input_destroy(input);
} }
void sway_subbackend_add_input(struct sway_server *server, void sway_backend_add_input(struct sway_server *server,
struct sway_subbackend *subbackend, enum wlr_input_device_type type, struct sway_backend *backend, enum wlr_input_device_type type,
char *name) { char *name) {
if (subbackend->type != SWAY_SUBBACKEND_HEADLESS) { if (backend->type != SWAY_BACKEND_HEADLESS) {
wlr_log(L_DEBUG, "adding inputs is only supported for the headless backend"); wlr_log(L_DEBUG, "adding inputs is only supported for the headless backend");
return; return;
} }
// TODO allow naming the input device // TODO allow naming the input device
struct wlr_input_device *device = struct wlr_input_device *device =
wlr_headless_add_input_device(subbackend->backend, type); wlr_headless_add_input_device(backend->backend, type);
if (device == NULL) { if (device == NULL) {
return; return;
} }
struct subbackend_input *input = struct backend_input *input =
calloc(1, sizeof(struct subbackend_input)); calloc(1, sizeof(struct backend_input));
if (input == NULL) { if (input == NULL) {
wlr_log(L_ERROR, "could not allocate subbackend input device"); wlr_log(L_ERROR, "could not allocate backend input device");
return; return;
} }
input->device = device; input->device = device;
wl_signal_add(&device->events.destroy, &input->input_destroy); wl_signal_add(&device->events.destroy, &input->input_destroy);
input->input_destroy.notify = handle_subbackend_device_destroy; input->input_destroy.notify = handle_backend_device_destroy;
wl_list_insert(&subbackend->inputs, &input->link); wl_list_insert(&backend->inputs, &input->link);
} }
void sway_subbackend_remove_input(struct sway_server *server, void sway_backend_remove_input(struct sway_server *server,
struct sway_subbackend *subbackend, char *name) { struct sway_backend *backend, char *name) {
struct subbackend_input *input = NULL, *tmp = NULL; struct backend_input *input = NULL, *tmp = NULL;
wl_list_for_each_safe(input, tmp, &subbackend->inputs, link) { wl_list_for_each_safe(input, tmp, &backend->inputs, link) {
if (strcasecmp(input->device->name, name) == 0) { if (strcasecmp(input->device->name, name) == 0) {
wlr_input_device_destroy(input->device); wlr_input_device_destroy(input->device);
} }