diff options
Diffstat (limited to 'rt')
| -rw-r--r-- | rt/CMakeLists.txt | 84 | ||||
| -rw-r--r-- | rt/include/foreign_intf.h | 33 | ||||
| -rw-r--r-- | rt/include/plugin.h | 190 | ||||
| -rw-r--r-- | rt/include/plugin_types.h | 9 | ||||
| -rw-r--r-- | rt/include/wl.h | 116 | ||||
| -rw-r--r-- | rt/src/plugin.c | 266 | ||||
| -rw-r--r-- | rt/src/wl.c | 1066 | ||||
| -rw-r--r-- | rt/tools/genbuild.pl | 48 | ||||
| -rw-r--r-- | rt/tools/genintf.pl | 42 |
9 files changed, 1854 insertions, 0 deletions
diff --git a/rt/CMakeLists.txt b/rt/CMakeLists.txt new file mode 100644 index 0000000..a7a0a77 --- /dev/null +++ b/rt/CMakeLists.txt @@ -0,0 +1,84 @@ +cmake_minimum_required(VERSION 3.10) +project ( + wtr_harness + VERSION 0.1 + LANGUAGES C) + +set(CMAKE_VERBOSE_MAKEFILE ON) +set(CMAKE_BUILD_TYPE Debug) + +include_directories(include/ ../wlroots/include /usr/include/pixman-1 + ${CMAKE_CURRENT_BINARY_DIR}/ + ${CMAKE_CURRENT_BINARY_DIR}/../wlroots/include + ${CMAKE_CURRENT_BINARY_DIR}/../wlroots/protocol +) + +add_definitions(-DWLR_USE_UNSTABLE) + +execute_process( + COMMAND pkg-config --variable=pkgdatadir wayland-protocols + OUTPUT_VARIABLE WAYLAND_PROTOCOLS + RESULT_VARIABLE ec + OUTPUT_STRIP_TRAILING_WHITESPACE +) +if(${ec} EQUAL 0) +else() + message(FATAL_ERROR "Failed to execute pkg-config") +endif() + +execute_process( + COMMAND pkg-config --variable=wayland_scanner wayland-scanner + OUTPUT_VARIABLE WAYLAND_SCANNER + RESULT_VARIABLE ec + OUTPUT_STRIP_TRAILING_WHITESPACE +) +if(${ec} EQUAL 0) +else() + message(FATAL_ERROR "Failed to execute pkg-config") +endif() + +set(PLUGIN_INTF ${CMAKE_BINARY_DIR}/plugin_interface.h) +add_custom_command( + OUTPUT ${PLUGIN_INTF} + COMMAND perl ${PROJECT_SOURCE_DIR}/tools/genintf.pl < + ${PROJECT_SOURCE_DIR}/include/plugin.h > ${PLUGIN_INTF} + DEPENDS ${PROJECT_SOURCE_DIR}/include/plugin.h + DEPENDS ${PROJECT_SOURCE_DIR}/tools/genintf.pl +) + +set(PLUGIN_LOAD ${CMAKE_BINARY_DIR}/gen_plugin_load.c) +add_custom_command( + OUTPUT ${PLUGIN_LOAD} + COMMAND perl ${PROJECT_SOURCE_DIR}/tools/genbuild.pl < + ${PROJECT_SOURCE_DIR}/include/plugin.h > ${PLUGIN_LOAD} + DEPENDS ${PROJECT_SOURCE_DIR}/include/plugin.h + DEPENDS ${PROJECT_SOURCE_DIR}/tools/genbuild.pl +) + +add_custom_command( + OUTPUT xdg-shell-protocol.h + COMMAND ${WAYLAND_SCANNER} server-header + ${WAYLAND_PROTOCOLS}/stable/xdg-shell/xdg-shell.xml + xdg-shell-protocol.h +) + +add_custom_command( + OUTPUT xdg-shell-protocol.c + COMMAND ${WAYLAND_SCANNER} private-code + ${WAYLAND_PROTOCOLS}/stable/xdg-shell/xdg-shell.xml + xdg-shell-protocol.c + DEPENDS xdg-shell-protocol.h +) + +file (GLOB_RECURSE SOURCES src/*.c) + +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +add_executable (wtr_harness ${SOURCES} ${PLUGIN_LOAD} ${PLUGIN_INTF} + xdg-shell-protocol.c) + +target_link_libraries(wtr_harness dl) +target_link_directories(wtr_harness PUBLIC + "${CMAKE_CURRENT_BINARY_DIR}/../wlroots") +target_link_libraries(wtr_harness wlroots-0.18 wayland-server xkbcommon pthread) +target_link_options(wtr_harness PRIVATE -Wl,--wrap=pthread_create) diff --git a/rt/include/foreign_intf.h b/rt/include/foreign_intf.h new file mode 100644 index 0000000..6558fab --- /dev/null +++ b/rt/include/foreign_intf.h @@ -0,0 +1,33 @@ +/* Contains a structure, which contains functions to back-call into + * the harness code. */ + +#ifndef __FOREIGN_INTERFACE +#define __FOREIGN_INTERFACE + +#define EXPORT(a) a + +typedef void *ctx_t; + +typedef struct FOREIGN_INTERFACE { + /* DO NOT ADD ANY UNEXPORTED VARIABLES HERE */ + + /* The context, which needs to be passed to each function. This context is + * opaque to the plugin and should not be changed. */ + EXPORT(ctx_t ctx); + + /* Requests the harness hot reload the current plugin. */ + EXPORT(void (*request_hot_reload)(ctx_t ctx)); + + /* Requests the harness hot reload the current plugin. */ + EXPORT(void (*do_log)(ctx_t ctx, const char *str)); + + /* Requestes that the whole system exit. Exits with the given return code. */ + EXPORT(void (*request_exit)(ctx_t ctx, int rc)); + + /* Returns the seat associated with the server. */ + EXPORT(void *(*get_seat)(ctx_t ctx)); +} foreign_interface_t; + +#undef EXPORT + +#endif /* __FOREIGN_INTERFACE */ diff --git a/rt/include/plugin.h b/rt/include/plugin.h new file mode 100644 index 0000000..4d69d76 --- /dev/null +++ b/rt/include/plugin.h @@ -0,0 +1,190 @@ +#ifndef _PLUGIN_H_ +#define _PLUGIN_H_ + +#include <dlfcn.h> +#include <linux/limits.h> +#include <pthread.h> +#include <stdint.h> +#include <stdlib.h> +#include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_keyboard.h> +#include <wlr/types/wlr_pointer.h> + +#include "plugin_types.h" +#include <foreign_intf.h> + +/* + * Marker macro to define what functions should be exported. This generates the + * interface which the plugin needs to implement. + */ +#define EXPORT(a) a + +#define EXPORT_INCLUDE(a) + +// clang-format off +EXPORT_INCLUDE(<foreign_intf.h>) +EXPORT_INCLUDE(<wlr/types/wlr_keyboard.h>) +EXPORT_INCLUDE(<wlr/types/wlr_input_device.h>) +EXPORT_INCLUDE(<wlr/types/wlr_pointer.h>) +// clang-format on + +#define MAX_QUEUED_ACTIONS 8 + +typedef void *dlhandle_t; + +/* Opaque state for a plugin. Not to be touched by the harness (not that it + * really can be.) */ + +struct PLUGIN; +/* This structure represents an action requested by the plugin for the harness. + */ +typedef struct { + int (*action)(struct PLUGIN *requester, void *arg); + void (*arg_dtor)(void *arg); + union { + void *ptr_arg; + int int_arg; + char *str_arg; + }; +} requested_action_t; + +/* + * Structure for the plugin. + */ +typedef struct PLUGIN { + /* The argc this plugin is loaded with. Typically the argc from main(). */ + int argc; + + /* The argv this plugin is loaded with. Typically the argv from main(). */ + char **argv; + + /* Filename the plugin is loaded from. */ + char filename[PATH_MAX]; + + /* Interface to the harness that this plugin can use. */ + foreign_interface_t foreign_intf; + + /* Opaque state of this plugin. The state is usually some kind of pointer to + * the plugin state, but all the harness knows is the opaque state is a + * pointer-sized piece of data. + * + * This opaque state is used in a linear pattern where the handlers take the + * opaque state, maybe operate on it, and return a new opaque state, which is + * then passed to the next handler, etc. It is on the plugin to properly + * manager the memory for this state and to destroy it upon teardown. + * + * It's guaranteed that this state is used linearly, meaning the harness gives + * up all ownership to it once passed into a handler. */ + opqst_t state; + + /* This plugin's lock. This avoids potential issues with multiple threads + * trying to change the opaque state at once which can lead to undesireable + * outcomes. */ + pthread_mutex_t lock; + + /** Set to not-zero if this plugin is initialized, otherwise set to zero. */ + int initialized; + + /* The handle to the shared library. */ + dlhandle_t library_handle; + + /* Pointer to the plugin name. This is in the shared library and a + * null-terminated string. If the library does not have a plugin name, this + * will be NULL. */ + const char *plugin_name; + + /** + * Initializes the plugin on the first time, and only the first time, it is + * loaded. This is used to do things like setup a runtime that cannot be + * reliably torn down. It is up to the plugin to ensure this won't interfere + * with hot-reloading. + */ + EXPORT(void (*plugin_metaload)(int argc, char **argv)); + + /** Intializes the plugin with the given argc/argv. This is the first thing + * called on the plugin and is called immediately after the library is loaded. + */ + EXPORT(void (*plugin_load)(int argc, char **argv, foreign_interface_t *intf)); + + /* Start the plugin with the marshalled state from the previous plugin. + * + * This should return the opaque state from the mashalled_state. + * + * This function should not fail if the state cannot be demarshalled, rather a + * default state should be returned. This is because changing the plugin and + * hot-reloading can produce incompatibilities between the old state and the + * new state, and this should not cause a failure. + */ + EXPORT(opqst_t (*plugin_hot_start)(uint8_t *mashalled_state, uint32_t n)); + + /* + * Starts the plugin without a marshalled state. Happens during the first boot + * when there is not state. + */ + EXPORT(opqst_t (*plugin_cold_start)()); + + /* + * Marshals the state to a bytestring. The returned pointer should be malloc'd + * on the heap. The harness takes ownership of the malloc'd pointer. + * + * This is usually called in preparation for a teardown followed by a + * hot-start. + */ + EXPORT(uint8_t *(*plugin_marshal_state)(opqst_t st, uint32_t *szout)); + + /* + * Teardown the plugin in preperation for the library's imminent unloading. + */ + EXPORT(void (*plugin_teardown)(opqst_t)); + + /* + * Handles a keybinding. + */ + EXPORT(opqst_t (*plugin_handle_keybinding)( + struct wlr_keyboard *keyboard, struct wlr_keyboard_key_event *event, + uint32_t modifiers, uint32_t keysym, uint32_t codepoint, int *out_handled, + opqst_t state)); + + EXPORT(opqst_t (*plugin_handle_button)(struct wlr_pointer_button_event *event, + uint32_t modifiers, opqst_t state)); + + /* + * Handles a surface being mapped, unmapped or destroyed. + */ + EXPORT(opqst_t (*plugin_handle_surface)(void *surface, surface_event_t event, + opqst_t)); + + /* List of requested actions by the plugin. Right now there is a maximum of 8 + * allowed at one time. That should be plenty. The actions should be flushed + * after each call to a handler anyway. */ + size_t n_requested_actions; + requested_action_t requested_actions[MAX_QUEUED_ACTIONS]; +} plugin_t; + +#undef EXPORT +#undef EXPORT_INCLUDE + +/* Reloads the plugin. This tears down the existing plugin, marshals the state + * for it and reloads it. + * + * This function will call dlclose on the plugin's library handle. + */ +int plugin_hot_reload(int argc, char **argv, const char *filepath, + plugin_t *plugin); + +/* + * Like hot-reload, but uses the same parameters the plugin was originally + * loaded with. + */ +int plugin_hot_reload_same_state(plugin_t *plugin); + +/* Starts a plugin in a cold state. Called after load_plugin_from_file. */ +void plugin_cold_start(plugin_t *plugin); + +/* Reads a plugin from a filename. */ +int load_plugin_from_file(int argc, char **argv, const char *filename, + plugin_t *plugin); + +void plugin_run_requested_actions(plugin_t *plugin); + +#endif /* _PLUGIN_H_ */ diff --git a/rt/include/plugin_types.h b/rt/include/plugin_types.h new file mode 100644 index 0000000..df1eab5 --- /dev/null +++ b/rt/include/plugin_types.h @@ -0,0 +1,9 @@ +#pragma once + +typedef void *opqst_t; + +typedef enum { + SURFACE_MAP = 0, + SURFACE_UNMAP, + SURFACE_DELETE, +} surface_event_t; diff --git a/rt/include/wl.h b/rt/include/wl.h new file mode 100644 index 0000000..dc7fe9f --- /dev/null +++ b/rt/include/wl.h @@ -0,0 +1,116 @@ +#pragma once + +#include <assert.h> +#include <getopt.h> +#include <stdbool.h> +#include <unistd.h> +#include <wayland-server-core.h> +#include <wlr/backend.h> +#include <wlr/backend/session.h> +#include <wlr/render/allocator.h> +#include <wlr/render/wlr_renderer.h> +#include <wlr/types/wlr_compositor.h> +#include <wlr/types/wlr_cursor.h> +#include <wlr/types/wlr_data_device.h> +#include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_keyboard.h> +#include <wlr/types/wlr_output.h> +#include <wlr/types/wlr_output_layout.h> +#include <wlr/types/wlr_pointer.h> +#include <wlr/types/wlr_scene.h> +#include <wlr/types/wlr_seat.h> +#include <wlr/types/wlr_subcompositor.h> +#include <wlr/types/wlr_xcursor_manager.h> +#include <wlr/types/wlr_xdg_shell.h> +#include <wlr/util/log.h> +#include <xkbcommon/xkbcommon.h> + +#include <plugin.h> + +/* For brevity's sake, struct members are annotated where they are used. */ +enum montis_cursor_mode { + TINYWL_CURSOR_PASSTHROUGH, + TINYWL_CURSOR_MOVE, + TINYWL_CURSOR_RESIZE, +}; + +struct montis_server { + struct wl_display *wl_display; + struct wlr_backend *backend; + struct wlr_renderer *renderer; + struct wlr_allocator *allocator; + struct wlr_scene *scene; + struct wlr_scene_output_layout *scene_layout; + + struct wlr_xdg_shell *xdg_shell; + struct wl_listener new_xdg_toplevel; + struct wl_listener new_xdg_popup; + struct wl_list toplevels; + + struct wlr_cursor *cursor; + struct wlr_xcursor_manager *cursor_mgr; + struct wl_listener cursor_motion; + struct wl_listener cursor_motion_absolute; + struct wl_listener cursor_button; + struct wl_listener cursor_axis; + struct wl_listener cursor_frame; + + struct wlr_seat *seat; + struct wl_listener new_input; + struct wl_listener request_cursor; + struct wl_listener request_set_selection; + struct wl_list keyboards; + enum montis_cursor_mode cursor_mode; + struct montis_toplevel *grabbed_toplevel; + double grab_x, grab_y; + struct wlr_box grab_geobox; + uint32_t resize_edges; + + struct wlr_output_layout *output_layout; + struct wl_list outputs; + struct wl_listener new_output; + + struct wlr_session *session; + plugin_t plugin; +}; + +struct montis_output { + struct wl_list link; + struct montis_server *server; + struct wlr_output *wlr_output; + struct wl_listener frame; + struct wl_listener request_state; + struct wl_listener destroy; +}; + +struct montis_toplevel { + struct wl_list link; + struct montis_server *server; + struct wlr_xdg_toplevel *xdg_toplevel; + struct wlr_scene_tree *scene_tree; + struct wl_listener map; + struct wl_listener unmap; + struct wl_listener destroy; + struct wl_listener commit; + struct wl_listener request_move; + struct wl_listener request_resize; + struct wl_listener request_maximize; + struct wl_listener request_fullscreen; +}; + +struct montis_keyboard { + struct wl_list link; + struct montis_server *server; + struct wlr_keyboard *wlr_keyboard; + + struct wl_listener modifiers; + struct wl_listener key; + struct wl_listener destroy; +}; + +struct montis_popup { + struct wlr_xdg_popup *xdg_popup; + struct wl_listener commit; + struct wl_listener destroy; +}; + diff --git a/rt/src/plugin.c b/rt/src/plugin.c new file mode 100644 index 0000000..37a6dd3 --- /dev/null +++ b/rt/src/plugin.c @@ -0,0 +1,266 @@ +#include "plugin.h" +#include "foreign_intf.h" +#include "wl.h" + +#include <sys/stat.h> +#include <unistd.h> +#include <ctype.h> +#include <dlfcn.h> +#include <pthread.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +/* Utility function for showing the marshalled states as hex code */ +static void shx(uint8_t *state, uint32_t sz) +{ + uint32_t i = 0; + while (i < sz) { + for (int j = 0; j < 16; ++j) { + if (i < sz) { + printf("%02x ", (unsigned int)state[i]); + } + else { + printf(" "); + } + ++i; + } + + i -= 16; + + printf(" "); + + for (int j = 0; j < 16; ++j) { + if (i < sz) { + if (isprint(state[i]) && !isspace(state[i])) { + printf("%c", state[i]); + } + else { + printf("."); + } + } + else { + printf(" "); + } + ++i; + } + printf("\n"); + } +} + +int load_plugin_from_dl_(dlhandle_t dl, plugin_t *plug); + +static void lock(plugin_t *plugin) { pthread_mutex_lock(&plugin->lock); }; + +static void unlock(plugin_t *plugin) { pthread_mutex_unlock(&plugin->lock); }; + +static int plugin_hot_reload_same_state_action_(plugin_t *plugin, void *ignore) +{ + return plugin_hot_reload_same_state(plugin); +} + +void do_request_hot_reload(void *plugv) +{ + plugin_t *plugin = plugv; + + size_t n = plugin->n_requested_actions++; + if (n < 8) { + plugin->requested_actions[n].action = plugin_hot_reload_same_state_action_; + plugin->requested_actions[n].arg_dtor = NULL; + } +} + +static int plugin_do_log(plugin_t *plugin, void *chrs) +{ + char *str = chrs; + puts(str); + return 0; +} + +void do_request_log(void *plugv, const char *str) +{ + plugin_t *plugin = plugv; + + size_t n = plugin->n_requested_actions++; + if (n < 8) { + plugin->requested_actions[n].action = plugin_do_log; + plugin->requested_actions[n].str_arg = strdup(str); + plugin->requested_actions[n].arg_dtor = free; + } +} + +static int plugin_do_exit(void *plugv, int ec) +{ + exit(ec); + return 0; +} + +void do_request_exit(void *plugv, int ec) +{ + plugin_t *plugin = plugv; + + size_t n = plugin->n_requested_actions++; + if (n < 8) { + plugin->requested_actions[n].action = + (int (*)(plugin_t *, void *))plugin_do_exit; + plugin->requested_actions[n].int_arg = ec; + plugin->requested_actions[n].arg_dtor = NULL; + } +} + +static void* plugin_get_seat(void* ctx) { + struct montis_server* server = wl_container_of(ctx, server, plugin); + return server->seat; +} + +static int load_plugin_from_file_(int argc, char **argv, const char *filename, + plugin_t *plugin) +{ + dlhandle_t lib = dlopen(filename, RTLD_LAZY); + int ec = 0; + + if (!lib) { + fprintf(stderr, "Failed to open library: %s: %s\n", filename, dlerror()); + ec = 1; + goto end; + } + + printf("Loading file.\n"); + ec = load_plugin_from_dl_(lib, plugin); + + if (ec) { + goto end; + } + + strncpy(plugin->filename, filename, sizeof(plugin->filename)); + plugin->argc = argc; + plugin->argv = argv; + + plugin->foreign_intf.ctx = plugin; + plugin->foreign_intf.request_hot_reload = do_request_hot_reload; + plugin->foreign_intf.do_log = do_request_log; + plugin->foreign_intf.request_exit = do_request_exit; + plugin->foreign_intf.get_seat = plugin_get_seat; + + plugin->plugin_load(plugin->argc, plugin->argv, &plugin->foreign_intf); +end: + return ec; +} + +static void maybe_run_metaload(int argc, char **argv, plugin_t *plugin) +{ + static char *loaded_plugins[12]; + int i; + for (i = 0; i < 12 && loaded_plugins[i]; ++i) { + if (strcmp(loaded_plugins[i], plugin->plugin_name) == 0) { + return; // Plugin is already loaded + } + } + loaded_plugins[i] = strdup(plugin->plugin_name); + + printf("First time loading %s, running metaload.\n", plugin->plugin_name); + if (plugin->plugin_metaload) { + plugin->plugin_metaload(argc, argv); + } +} + +int load_plugin_from_file(int argc, char **argv, const char *filename, + plugin_t *plugin) +{ + memset(plugin, 0, sizeof(*plugin)); + + pthread_mutexattr_t attr; + if (pthread_mutexattr_init(&attr)) { + perror("pthread_mutexattr_init"); + return 1; + } + + if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) { + perror("pthread_mutexattr_settype"); + return 1; + } + + if (pthread_mutex_init(&plugin->lock, &attr)) { + pthread_mutexattr_destroy(&attr); + perror("pthread_mutexattr_init"); + return 1; + } + pthread_mutexattr_destroy(&attr); + int rc = load_plugin_from_file_(argc, argv, filename, plugin); + + if (rc == 0) { + maybe_run_metaload(argc, argv, plugin); + } + + return rc; +} + +int plugin_hot_reload_same_state(plugin_t *plugin) +{ + char filename_cpy[PATH_MAX]; + strncpy(filename_cpy, plugin->filename, sizeof(filename_cpy)); + return plugin_hot_reload(plugin->argc, plugin->argv, filename_cpy, plugin); +} + +int plugin_hot_reload(int argc, char **argv, const char *filepath, + plugin_t *plugin) +{ + int ec = 0; + uint32_t sz = 0; + uint8_t *marshalled_state = NULL; + + printf("Hot Reloading %s\n", plugin->plugin_name); + lock(plugin); + + printf("Marshalling state ...\n"); + marshalled_state = plugin->plugin_marshal_state(plugin->state, &sz); + + printf("Calling teardown ...\n"); + plugin->plugin_teardown(plugin->state); + + printf("State Marshalled:\n"); + shx(marshalled_state, sz); + + printf("Unloading old library handle.\n"); + if (dlclose(plugin->library_handle)) { + printf("Could not close library handle: %s\n", dlerror()); + } + + if ((ec = load_plugin_from_file_(argc, argv, filepath, plugin))) { + goto fail; + } + + printf("Hot starting plugin ...\n"); + plugin->state = plugin->plugin_hot_start(marshalled_state, sz); + +fail: + free(marshalled_state); + unlock(plugin); + return ec; +} + +void plugin_run_requested_actions(plugin_t *plugin) +{ + lock(plugin); + requested_action_t requested_actions[MAX_QUEUED_ACTIONS]; + size_t n_requested_actions = plugin->n_requested_actions; + memcpy(&requested_actions, plugin->requested_actions, + sizeof(requested_actions)); + plugin->n_requested_actions = 0; + unlock(plugin); + + size_t i; + for (i = 0; i < n_requested_actions; ++i) { + requested_actions[i].action(plugin, requested_actions[i].str_arg); + if (requested_actions[i].arg_dtor) { + requested_actions[i].arg_dtor(requested_actions[i].ptr_arg); + } + } +} + +void plugin_cold_start(plugin_t *plugin) +{ + lock(plugin); + plugin->state = plugin->plugin_cold_start(); + unlock(plugin); +} diff --git a/rt/src/wl.c b/rt/src/wl.c new file mode 100644 index 0000000..261e082 --- /dev/null +++ b/rt/src/wl.c @@ -0,0 +1,1066 @@ +#define _POSIX_C_SOURCE 200112L + +#include <stdio.h> +#include <stdlib.h> +#include <sys/time.h> +#include <time.h> + +#include <wl.h> + +#include "xdg-decoration-unstable-v1-client-protocol.h" + +// This macro is responsible for calling a handler on a plugin. This macro will +// acquire the plugin's lock, call the member with the arguments and update the +// state. +// +// This only works on function which have the format: +// +// opqst_t function(args ..., opqst_t state); +// +// Note that the state parameter is omitted from this macro. +#define plugin_call_update_state(plugin, member, ...) \ + do { \ + plugin_t *pl__ = &(plugin); \ + pthread_mutex_lock(&pl__->lock); \ + pl__->state = pl__->member(__VA_ARGS__, pl__->state); \ + pthread_mutex_unlock(&pl__->lock); \ + plugin_run_requested_actions(pl__); \ + } while (0) + +static void focus_toplevel(struct montis_toplevel *toplevel, + struct wlr_surface *surface) +{ + /* Note: this function only deals with keyboard focus. */ + if (toplevel == NULL) { + return; + } + struct montis_server *server = toplevel->server; + struct wlr_seat *seat = server->seat; + struct wlr_surface *prev_surface = seat->keyboard_state.focused_surface; + if (prev_surface == surface) { + /* Don't re-focus an already focused surface. */ + return; + } + if (prev_surface) { + /* + * Deactivate the previously focused surface. This lets the client know + * it no longer has focus and the client will repaint accordingly, e.g. + * stop displaying a caret. + */ + struct wlr_xdg_toplevel *prev_toplevel = + wlr_xdg_toplevel_try_from_wlr_surface(prev_surface); + if (prev_toplevel != NULL) { + wlr_xdg_toplevel_set_activated(prev_toplevel, false); + } + } + struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat); + /* Move the toplevel to the front */ + wlr_scene_node_raise_to_top(&toplevel->scene_tree->node); + wl_list_remove(&toplevel->link); + wl_list_insert(&server->toplevels, &toplevel->link); + /* Activate the new surface */ + wlr_xdg_toplevel_set_activated(toplevel->xdg_toplevel, true); + /* + * Tell the seat to have the keyboard enter this surface. wlroots will keep + * track of this and automatically send key events to the appropriate + * clients without additional work on your part. + */ + if (keyboard != NULL) { + wlr_seat_keyboard_notify_enter(seat, toplevel->xdg_toplevel->base->surface, + keyboard->keycodes, keyboard->num_keycodes, + &keyboard->modifiers); + } +} + +static void keyboard_handle_modifiers(struct wl_listener *listener, void *data) +{ + /* This event is raised when a modifier key, such as shift or alt, is + * pressed. We simply communicate this to the client. */ + struct montis_keyboard *keyboard = + wl_container_of(listener, keyboard, modifiers); + /* + * A seat can only have one keyboard, but this is a limitation of the + * Wayland protocol - not wlroots. We assign all connected keyboards to the + * same seat. You can swap out the underlying wlr_keyboard like this and + * wlr_seat handles this transparently. + */ + wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr_keyboard); + /* Send modifiers to the client. */ + wlr_seat_keyboard_notify_modifiers(keyboard->server->seat, + &keyboard->wlr_keyboard->modifiers); +} + +static void keyboard_handle_key(struct wl_listener *listener, void *data) +{ + /* This event is raised when a key is pressed or released. */ + struct montis_keyboard *keyboard = wl_container_of(listener, keyboard, key); + struct montis_server *server = keyboard->server; + struct wlr_keyboard_key_event *event = data; + struct wlr_seat *seat = server->seat; + + /* Translate libinput keycode -> xkbcommon */ + uint32_t keycode = event->keycode + 8; + /* Get a list of keysyms based on the keymap for this keyboard */ + const xkb_keysym_t *syms; + int nsyms = + xkb_state_key_get_syms(keyboard->wlr_keyboard->xkb_state, keycode, &syms); + + int handled = false; + uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->wlr_keyboard); + uint32_t codepoint; + int ec; + + if (nsyms > 0 && syms[0] >= XKB_KEY_XF86Switch_VT_1 && + syms[0] <= XKB_KEY_XF86Switch_VT_12) { + /* Escape-hatch to change sessions. These should always be available key + * bindings regardless of what the plugin dictates. This allows an escape + * hatch to edit the plugin in a different vterm and then use the escape + * hatch below to hot-restart the plugin if things get borked. */ + if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) { + wlr_session_change_vt(server->session, + syms[0] - XKB_KEY_XF86Switch_VT_1 + 1); + } + } + else if (modifiers == + (WLR_MODIFIER_SHIFT | WLR_MODIFIER_CTRL | WLR_MODIFIER_ALT) && + nsyms > 0 && syms[0] == XKB_KEY_Escape) { + /* Escape-hatch to hot-reload the plugin in case the plugin got borked and + * stops accepting keybindings. Ctrl+Shift+Alt+Escape will always reload the + * plugin.*/ + if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) { + if ((ec = plugin_hot_reload_same_state(&server->plugin)) != 0) { + fprintf(stderr, "Failed to hot reload plugin"); + exit(1); + } + } + } + else { + /* Pass the information along to the plugin for the plugin to handle. The + * plugin will return via 'handled' whether or not the key event was handled + * or not. */ + if (nsyms > 0) { + codepoint = + xkb_state_key_get_utf32(keyboard->wlr_keyboard->xkb_state, keycode); + plugin_call_update_state(server->plugin, plugin_handle_keybinding, + keyboard->wlr_keyboard, event, modifiers, + syms[0], codepoint, &handled); + } + } +} + +static void keyboard_handle_destroy(struct wl_listener *listener, void *data) +{ + /* This event is raised by the keyboard base wlr_input_device to signal + * the destruction of the wlr_keyboard. It will no longer receive events + * and should be destroyed. + */ + struct montis_keyboard *keyboard = + wl_container_of(listener, keyboard, destroy); + wl_list_remove(&keyboard->modifiers.link); + wl_list_remove(&keyboard->key.link); + wl_list_remove(&keyboard->destroy.link); + wl_list_remove(&keyboard->link); + free(keyboard); +} + +static void server_new_keyboard(struct montis_server *server, + struct wlr_input_device *device) +{ + struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device); + + struct montis_keyboard *keyboard = calloc(1, sizeof(*keyboard)); + keyboard->server = server; + keyboard->wlr_keyboard = wlr_keyboard; + + struct xkb_rule_names names = (struct xkb_rule_names){0}; + names.layout = "jr"; + names.variant = "jdvprk"; + names.options = "numpad:mac"; + + /* We need to prepare an XKB keymap and assign it to the keyboard. This + * assumes the defaults (e.g. layout = "us"). */ + struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); + struct xkb_keymap *keymap = + xkb_keymap_new_from_names(context, &names, XKB_KEYMAP_COMPILE_NO_FLAGS); + + if (!keymap) { + fprintf(stderr, "Unable to read keymap.\n"); + exit(1); + } + + wlr_keyboard_set_keymap(wlr_keyboard, keymap); + xkb_keymap_unref(keymap); + xkb_context_unref(context); + wlr_keyboard_set_repeat_info(wlr_keyboard, 25, 600); + + /* Here we set up listeners for keyboard events. */ + keyboard->modifiers.notify = keyboard_handle_modifiers; + wl_signal_add(&wlr_keyboard->events.modifiers, &keyboard->modifiers); + keyboard->key.notify = keyboard_handle_key; + wl_signal_add(&wlr_keyboard->events.key, &keyboard->key); + keyboard->destroy.notify = keyboard_handle_destroy; + wl_signal_add(&device->events.destroy, &keyboard->destroy); + + wlr_seat_set_keyboard(server->seat, keyboard->wlr_keyboard); + + /* And add the keyboard to our list of keyboards */ + wl_list_insert(&server->keyboards, &keyboard->link); +} + +static void server_new_pointer(struct montis_server *server, + struct wlr_input_device *device) +{ + /* We don't do anything special with pointers. All of our pointer handling + * is proxied through wlr_cursor. On another compositor, you might take this + * opportunity to do libinput configuration on the device to set + * acceleration, etc. */ + wlr_cursor_attach_input_device(server->cursor, device); +} + +static void server_new_input(struct wl_listener *listener, void *data) +{ + /* This event is raised by the backend when a new input device becomes + * available. */ + struct montis_server *server = wl_container_of(listener, server, new_input); + struct wlr_input_device *device = data; + switch (device->type) { + case WLR_INPUT_DEVICE_KEYBOARD: + server_new_keyboard(server, device); + break; + case WLR_INPUT_DEVICE_POINTER: + server_new_pointer(server, device); + break; + default: + break; + } + /* We need to let the wlr_seat know what our capabilities are, which is + * communiciated to the client. In TinyWL we always have a cursor, even if + * there are no pointer devices, so we always include that capability. */ + uint32_t caps = WL_SEAT_CAPABILITY_POINTER; + if (!wl_list_empty(&server->keyboards)) { + caps |= WL_SEAT_CAPABILITY_KEYBOARD; + } + wlr_seat_set_capabilities(server->seat, caps); +} + +static void seat_request_cursor(struct wl_listener *listener, void *data) +{ + struct montis_server *server = + wl_container_of(listener, server, request_cursor); + /* This event is raised by the seat when a client provides a cursor image */ + struct wlr_seat_pointer_request_set_cursor_event *event = data; + struct wlr_seat_client *focused_client = + server->seat->pointer_state.focused_client; + /* This can be sent by any client, so we check to make sure this one is + * actually has pointer focus first. */ + if (focused_client == event->seat_client) { + /* Once we've vetted the client, we can tell the cursor to use the + * provided surface as the cursor image. It will set the hardware cursor + * on the output that it's currently on and continue to do so as the + * cursor moves between outputs. */ + wlr_cursor_set_surface(server->cursor, event->surface, event->hotspot_x, + event->hotspot_y); + } +} + +static void seat_request_set_selection(struct wl_listener *listener, void *data) +{ + /* This event is raised by the seat when a client wants to set the selection, + * usually when the user copies something. wlroots allows compositors to + * ignore such requests if they so choose, but in montis we always honor + */ + struct montis_server *server = + wl_container_of(listener, server, request_set_selection); + struct wlr_seat_request_set_selection_event *event = data; + wlr_seat_set_selection(server->seat, event->source, event->serial); +} + +static struct montis_toplevel *desktop_toplevel_at(struct montis_server *server, + double lx, double ly, + struct wlr_surface **surface, + double *sx, double *sy) +{ + /* This returns the topmost node in the scene at the given layout coords. + * We only care about surface nodes as we are specifically looking for a + * surface in the surface tree of a montis_toplevel. */ + struct wlr_scene_node *node = + wlr_scene_node_at(&server->scene->tree.node, lx, ly, sx, sy); + if (node == NULL || node->type != WLR_SCENE_NODE_BUFFER) { + return NULL; + } + struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node); + struct wlr_scene_surface *scene_surface = + wlr_scene_surface_try_from_buffer(scene_buffer); + if (!scene_surface) { + return NULL; + } + + *surface = scene_surface->surface; + /* Find the node corresponding to the montis_toplevel at the root of this + * surface tree, it is the only one for which we set the data field. */ + struct wlr_scene_tree *tree = node->pare |