/** * MIT/X11 License * Modified (c) 2017 Quentin “Sardem FF7” Glidic * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #define G_LOG_DOMAIN "Wayland" #pragma GCC diagnostic ignored "-Wunused-variable" #pragma GCC diagnostic ignored "-Wunused-parameter" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "keyb.h" #include "view.h" #include "display-internal.h" #include "display.h" #include "wayland-internal.h" #include "primary-selection-unstable-v1-protocol.h" #include "wlr-layer-shell-unstable-v1-protocol.h" typedef struct _display_buffer_pool wayland_buffer_pool; typedef struct { wayland_stuff *context; uint32_t global_name; struct wl_output *output; int32_t scale; } wayland_output; typedef struct { wayland_buffer_pool *pool; struct wl_buffer *buffer; uint8_t *data; gboolean released; } wayland_buffer; struct _display_buffer_pool { wayland_stuff *context; uint8_t *data; size_t size; int32_t width; int32_t height; gboolean to_free; wayland_buffer *buffers; }; static wayland_stuff wayland_; wayland_stuff *wayland = &wayland_; static const cairo_user_data_key_t wayland_cairo_surface_user_data; static void wayland_buffer_cleanup(wayland_buffer_pool *self) { if (!self->to_free) { return; } size_t i, count = 0; for (i = 0; i < wayland->buffer_count; ++i) { if ((self->buffers[i].released) && (self->buffers[i].buffer != NULL)) { wl_buffer_destroy(self->buffers[i].buffer); self->buffers[i].buffer = NULL; } if (self->buffers[i].buffer == NULL) { ++count; } } if (count < wayland->buffer_count) { return; } munmap(self->data, self->size); g_free(self); } static void wayland_buffer_release(void *data, struct wl_buffer *buffer) { wayland_buffer_pool *self = data; size_t i; for (i = 0; i < wayland->buffer_count; ++i) { if (self->buffers[i].buffer == buffer) { self->buffers[i].released = TRUE; } } wayland_buffer_cleanup(self); } static const struct wl_buffer_listener wayland_buffer_listener = { wayland_buffer_release}; wayland_buffer_pool *display_buffer_pool_new(gint width, gint height) { struct wl_shm_pool *wl_pool; struct wl_buffer *buffer; int fd; uint8_t *data; width *= wayland->scale; height *= wayland->scale; int32_t stride; size_t size; size_t pool_size; stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); size = stride * height; pool_size = size * wayland->buffer_count; gchar filename[PATH_MAX]; g_snprintf(filename, PATH_MAX, "%s/rofi-wayland-surface", g_get_user_runtime_dir()); fd = g_open(filename, O_CREAT | O_RDWR, 0); g_unlink(filename); if (fd < 0) { g_warning("creating a buffer file for %zu B failed: %s", pool_size, g_strerror(errno)); return NULL; } if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) { g_close(fd, NULL); return NULL; } if (ftruncate(fd, pool_size) < 0) { g_close(fd, NULL); return NULL; } data = mmap(NULL, pool_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (data == MAP_FAILED) { g_warning("mmap of size %zu failed: %s", pool_size, g_strerror(errno)); close(fd); return NULL; } wayland_buffer_pool *pool; pool = g_new0(wayland_buffer_pool, 1); pool->width = width; pool->height = height; pool->buffers = g_new0(wayland_buffer, wayland->buffer_count); wl_pool = wl_shm_create_pool(wayland->shm, fd, pool_size); size_t i; for (i = 0; i < wayland->buffer_count; ++i) { pool->buffers[i].pool = pool; pool->buffers[i].buffer = wl_shm_pool_create_buffer( wl_pool, size * i, width, height, stride, WL_SHM_FORMAT_ARGB8888); pool->buffers[i].data = data + size * i; pool->buffers[i].released = TRUE; wl_buffer_add_listener(pool->buffers[i].buffer, &wayland_buffer_listener, pool); } wl_shm_pool_destroy(wl_pool); close(fd); return pool; } void display_buffer_pool_free(wayland_buffer_pool *self) { self->to_free = TRUE; wayland_buffer_cleanup(self); } static void wayland_surface_protocol_enter(void *data, struct wl_surface *wl_surface, struct wl_output *wl_output) { wayland_output *output; output = g_hash_table_lookup(wayland->outputs, wl_output); if (output == NULL) { return; } wl_surface_set_buffer_scale(wl_surface, output->scale); if (wayland->scale != output->scale) { wayland->scale = output->scale; // create new buffers with the correct scaled size rofi_view_pool_refresh(); RofiViewState *state = rofi_view_get_active(); if (state != NULL) { rofi_view_set_size(state, -1, -1); } } } static void wayland_surface_protocol_leave(void *data, struct wl_surface *wl_surface, struct wl_output *wl_output) {} static const struct wl_surface_listener wayland_surface_interface = { .enter = wayland_surface_protocol_enter, .leave = wayland_surface_protocol_leave, }; static void wayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time); static const struct wl_callback_listener wayland_frame_wl_callback_listener = { .done = wayland_frame_callback, }; cairo_surface_t * display_buffer_pool_get_next_buffer(wayland_buffer_pool *pool) { wayland_buffer *buffer = NULL; size_t i; for (i = 0; (buffer == NULL) && (i < wayland->buffer_count); ++i) { buffer = pool->buffers + i; if (!buffer->released) { buffer = NULL; } } if (buffer == NULL) { return NULL; } cairo_surface_t *surface; surface = cairo_image_surface_create_for_data( buffer->data, CAIRO_FORMAT_ARGB32, pool->width, pool->height, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, pool->width)); cairo_surface_set_user_data(surface, &wayland_cairo_surface_user_data, buffer, NULL); return surface; } void display_surface_commit(cairo_surface_t *surface) { if (surface == NULL) { return; } wayland_buffer *buffer = cairo_surface_get_user_data(surface, &wayland_cairo_surface_user_data); wayland_buffer_pool *pool = buffer->pool; cairo_surface_destroy(surface); wl_surface_damage(wayland->surface, 0, 0, pool->width, pool->height); wl_surface_attach(wayland->surface, buffer->buffer, 0, 0); // FIXME: hidpi wl_surface_set_buffer_scale(wayland->surface, wayland->scale); buffer->released = FALSE; wl_surface_commit(wayland->surface); } static void wayland_frame_callback(void *data, struct wl_callback *callback, uint32_t timestamp) { if (wayland->frame_cb != NULL) { wl_callback_destroy(wayland->frame_cb); rofi_view_frame_callback(); } wayland->frame_cb = wl_surface_frame(wayland->surface); wl_callback_add_listener(wayland->frame_cb, &wayland_frame_wl_callback_listener, wayland); } static void wayland_keyboard_keymap(void *data, struct wl_keyboard *keyboard, enum wl_keyboard_keymap_format format, int32_t fd, uint32_t size) { wayland_seat *self = data; if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) { close(fd); return; } char *str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0); if (str == MAP_FAILED) { close(fd); return; } struct xkb_keymap *keymap = xkb_keymap_new_from_string( nk_bindings_seat_get_context(wayland->bindings_seat), str, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS); if (keymap == NULL) { fprintf(stderr, "Failed to get Keymap for current keyboard device.\n"); return; } struct xkb_state *state = xkb_state_new(keymap); if (state == NULL) { fprintf(stderr, "Failed to get state object for current keyboard device.\n"); return; } nk_bindings_seat_update_keymap(wayland->bindings_seat, keymap, state); } static void wayland_keyboard_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface, struct wl_array *keys) { wayland_seat *self = data; wayland->last_seat = self; self->serial = serial; uint32_t *key, *kend; for (key = keys->data, kend = key + keys->size / sizeof(*key); key < kend; ++key) { nk_bindings_seat_handle_key(wayland->bindings_seat, NULL, *key + 8, NK_BINDINGS_KEY_STATE_PRESSED); } } static void wayland_keyboard_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) { wayland_seat *self = data; // TODO? } static gboolean wayland_key_repeat(void *data) { wayland_seat *self = data; if (self->repeat.key == 0) { self->repeat.source = NULL; return G_SOURCE_REMOVE; } char *text = nk_bindings_seat_handle_key(wayland->bindings_seat, NULL, self->repeat.key, NK_BINDINGS_KEY_STATE_PRESS); RofiViewState *state = rofi_view_get_active(); if (state == NULL) { return G_SOURCE_REMOVE; } if (text != NULL) { rofi_view_handle_text(state, text); } rofi_view_maybe_update(state); return G_SOURCE_CONTINUE; } static gboolean wayland_key_repeat_delay(void *data) { wayland_seat *self = data; if (self->repeat.key == 0) { return FALSE; } char *text = nk_bindings_seat_handle_key(wayland->bindings_seat, NULL, self->repeat.key, NK_BINDINGS_KEY_STATE_PRESS); RofiViewState *state = rofi_view_get_active(); if (state == NULL) { return G_SOURCE_REMOVE; } if (text != NULL) { rofi_view_handle_text(state, text); } guint source_id = g_timeout_add(self->repeat.rate, wayland_key_repeat, data); self->repeat.source = g_main_context_find_source_by_id(NULL, source_id); rofi_view_maybe_update(state); return G_SOURCE_REMOVE; } static void wayland_keyboard_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, enum wl_keyboard_key_state kstate) { RofiViewState *state = rofi_view_get_active(); wayland_seat *self = data; gchar *text; wayland->last_seat = self; self->serial = serial; xkb_keycode_t keycode = key + 8; if (kstate == WL_KEYBOARD_KEY_STATE_RELEASED) { if (keycode == self->repeat.key) { self->repeat.key = 0; if (self->repeat.source != NULL) { g_source_destroy(self->repeat.source); self->repeat.source = NULL; } } nk_bindings_seat_handle_key(wayland->bindings_seat, NULL, keycode, NK_BINDINGS_KEY_STATE_RELEASE); } else if (kstate == WL_KEYBOARD_KEY_STATE_PRESSED) { char *text = nk_bindings_seat_handle_key( wayland->bindings_seat, NULL, keycode, NK_BINDINGS_KEY_STATE_PRESS); if (self->repeat.source != NULL) { g_source_destroy(self->repeat.source); self->repeat.source = NULL; } if (state != NULL) { if (text != NULL) { rofi_view_handle_text(state, text); } self->repeat.key = keycode; guint source_id = g_timeout_add(self->repeat.delay, wayland_key_repeat_delay, data); self->repeat.source = g_main_context_find_source_by_id(NULL, source_id); } } if (state != NULL) { rofi_view_maybe_update(state); } } static void wayland_keyboard_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) { wayland_seat *self = data; nk_bindings_seat_update_mask(wayland->bindings_seat, NULL, mods_depressed, mods_latched, mods_locked, 0, 0, 0); RofiViewState *state = rofi_view_get_active(); if (state != NULL) { rofi_view_maybe_update(state); } } static void wayland_keyboard_repeat_info(void *data, struct wl_keyboard *keyboard, int32_t rate, int32_t delay) { wayland_seat *self = data; self->repeat.key = 0; self->repeat.rate = rate; self->repeat.delay = delay; if (self->repeat.source != NULL) { g_source_destroy(self->repeat.source); self->repeat.source = NULL; } } static const struct wl_keyboard_listener wayland_keyboard_listener = { .keymap = wayland_keyboard_keymap, .enter = wayland_keyboard_enter, .leave = wayland_keyboard_leave, .key = wayland_keyboard_key, .modifiers = wayland_keyboard_modifiers, .repeat_info = wayland_keyboard_repeat_info, }; static void wayland_cursor_set_image(int i) { struct wl_buffer *buffer; struct wl_cursor_image *image; image = wayland->cursor.cursor->images[i]; wayland->cursor.image = image; buffer = wl_cursor_image_get_buffer(wayland->cursor.image); wl_surface_attach(wayland->cursor.surface, buffer, 0, 0); wl_surface_damage(wayland->cursor.surface, 0, 0, wayland->cursor.image->width, wayland->cursor.image->height); wl_surface_commit(wayland->cursor.surface); } static void wayland_cursor_frame_callback(void *data, struct wl_callback *callback, uint32_t time); static const struct wl_callback_listener wayland_cursor_frame_wl_callback_listener = { .done = wayland_cursor_frame_callback, }; static void wayland_cursor_frame_callback(void *data, struct wl_callback *callback, uint32_t time) { int i; if (wayland->cursor.frame_cb != NULL) { wl_callback_destroy(wayland->cursor.frame_cb); } wayland->cursor.frame_cb = wl_surface_frame(wayland->cursor.surface); wl_callback_add_listener(wayland->cursor.frame_cb, &wayland_cursor_frame_wl_callback_listener, wayland); i = wl_cursor_frame(wayland->cursor.cursor, time); wayland_cursor_set_image(i); } static void wayland_pointer_send_events(wayland_seat *self) { RofiViewState *state = rofi_view_get_active(); if (state == NULL) { return; } if (self->motion.x > -1 || self->motion.y > -1) { // TODO: hover select rofi_view_handle_mouse_motion(state, self->motion.x, self->motion.y, FALSE); self->motion.x = -1; self->motion.y = -1; } NkBindingsMouseButton button = -1; switch (self->button.button) { case BTN_LEFT: button = NK_BINDINGS_MOUSE_BUTTON_PRIMARY; break; case BTN_RIGHT: button = NK_BINDINGS_MOUSE_BUTTON_SECONDARY; break; case BTN_MIDDLE: button = NK_BINDINGS_MOUSE_BUTTON_MIDDLE; break; } if (self->button.button > 0) { if (self->button.pressed) { rofi_view_handle_mouse_motion(state, self->button.x, self->button.y, FALSE); nk_bindings_seat_handle_button(wayland->bindings_seat, NULL, button, NK_BINDINGS_BUTTON_STATE_PRESS, self->button.time); } else { nk_bindings_seat_handle_button(wayland->bindings_seat, NULL, button, NK_BINDINGS_BUTTON_STATE_RELEASE, self->button.time); } self->button.button = 0; } if (self->wheel.vertical != 0) { nk_bindings_seat_handle_scroll(wayland->bindings_seat, NULL, NK_BINDINGS_SCROLL_AXIS_VERTICAL, self->wheel.vertical); self->wheel.vertical = 0; } if (self->wheel.horizontal != 0) { nk_bindings_seat_handle_scroll(wayland->bindings_seat, NULL, NK_BINDINGS_SCROLL_AXIS_HORIZONTAL, self->wheel.horizontal); self->wheel.horizontal = 0; } rofi_view_maybe_update(state); } static void wayland_pointer_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t x, wl_fixed_t y) { wayland_seat *self = data; if (wayland->cursor.surface == NULL) { return; } if (wayland->cursor.cursor->image_count < 2) { wayland_cursor_set_image(0); } else { wayland_cursor_frame_callback(wayland, wayland->cursor.frame_cb, 0); } wl_pointer_set_cursor(self->pointer, serial, wayland->cursor.surface, wayland->cursor.image->hotspot_x, wayland->cursor.image->hotspot_y); } static void wayland_pointer_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) { wayland_seat *self = data; if (wayland->cursor.frame_cb != NULL) { wl_callback_destroy(wayland->cursor.frame_cb); } } static void wayland_pointer_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t x, wl_fixed_t y) { wayland_seat *self = data; self->button.x = wl_fixed_to_int(x); self->button.y = wl_fixed_to_int(y); self->motion.x = wl_fixed_to_int(x); self->motion.y = wl_fixed_to_int(y); self->motion.time = time; if (wl_pointer_get_version(self->pointer) >= WL_POINTER_FRAME_SINCE_VERSION) { return; } wayland_pointer_send_events(self); } static void wayland_pointer_button(void *data, struct wl_pointer *pointer, uint32_t serial, uint32_t time, uint32_t button, enum wl_pointer_button_state state) { wayland_seat *self = data; wayland->last_seat = self; self->serial = serial; self->button.time = time; self->button.pressed = (state == WL_POINTER_BUTTON_STATE_PRESSED); self->button.button = button; wayland_pointer_send_events(self); } static void wayland_pointer_axis(void *data, struct wl_pointer *pointer, uint32_t time, enum wl_pointer_axis axis, wl_fixed_t value) { wayland_seat *self = data; switch (axis) { case WL_POINTER_AXIS_VERTICAL_SCROLL: self->wheel.vertical += (gint)(wl_fixed_to_double(value) / 10.); break; case WL_POINTER_AXIS_HORIZONTAL_SCROLL: self->wheel.horizontal += (gint)(wl_fixed_to_double(value) / 10.); break; } wayland_pointer_send_events(self); } static void wayland_pointer_frame(void *data, struct wl_pointer *pointer) { wayland_seat *self = data; wayland_pointer_send_events(self); } static void wayland_pointer_axis_source(void *data, struct wl_pointer *pointer, enum wl_pointer_axis_source axis_source) {} static void wayland_pointer_axis_stop(void *data, struct wl_pointer *pointer, uint32_t time, enum wl_pointer_axis axis) {} static void wayland_pointer_axis_discrete(void *data, struct wl_pointer *pointer, enum wl_pointer_axis axis, int32_t discrete) { wayland_seat *self = data; switch (axis) { case WL_POINTER_AXIS_VERTICAL_SCROLL: self->wheel.vertical += discrete; break; case WL_POINTER_AXIS_HORIZONTAL_SCROLL: self->wheel.horizontal += discrete; break; } } static const struct wl_pointer_listener wayland_pointer_listener = { .enter = wayland_pointer_enter, .leave = wayland_pointer_leave, .motion = wayland_pointer_motion, .button = wayland_pointer_button, .axis = wayland_pointer_axis, .frame = wayland_pointer_frame, .axis_source = wayland_pointer_axis_source, .axis_stop = wayland_pointer_axis_stop, .axis_discrete = wayland_pointer_axis_discrete, }; static void wayland_keyboard_release(wayland_seat *self) { if (self->keyboard == NULL) { return; } if (wl_keyboard_get_version(self->keyboard) >= WL_KEYBOARD_RELEASE_SINCE_VERSION) { wl_keyboard_release(self->keyboard); } else { wl_keyboard_destroy(self->keyboard); } self->repeat.key = 0; if (self->repeat.source != NULL) { g_source_destroy(self->repeat.source); self->repeat.source = NULL; } self->keyboard = NULL; } #define CLIPBOARD_READ_INCREMENT 1024 typedef void (*clipboard_read_callback)(char *data); struct clipboard_read_info { char *buffer; size_t size; int fd; clipboard_read_callback callback; }; static gboolean clipboard_read_glib_callback(GIOChannel *channel, GIOCondition condition, gpointer opaque) { struct clipboard_read_info *info = opaque; gsize read; switch (g_io_channel_read_chars(channel, info->buffer + info->size, CLIPBOARD_READ_INCREMENT, &read, NULL)) { case G_IO_STATUS_AGAIN: return TRUE; case G_IO_STATUS_NORMAL: { info->size += read; info->buffer = g_realloc(info->buffer, info->size + CLIPBOARD_READ_INCREMENT); if (!info->buffer) { g_io_channel_shutdown(channel, FALSE, NULL); g_io_channel_unref(channel); close(info->fd); g_free(info); return FALSE; } return TRUE; } default: info->buffer[info->size] = '\0'; info->callback(info->buffer); g_io_channel_shutdown(channel, FALSE, NULL); g_io_channel_unref(channel); close(info->fd); g_free(info); return FALSE; } } static gboolean clipboard_read_data(int fd, clipboard_read_callback callback) { GIOChannel *channel = g_io_channel_unix_new(fd); struct clipboard_read_info *info = g_malloc(sizeof *info); if (info == NULL) { g_io_channel_unref(channel); close(fd); return FALSE; } info->fd = fd; info->size = 0; info->callback = callback; info->buffer = g_malloc(CLIPBOARD_READ_INCREMENT); if (info->buffer == NULL) { g_io_channel_unref(channel); close(info->fd); g_free(info); return FALSE; } g_io_add_watch(channel, G_IO_IN | G_IO_HUP | G_IO_ERR, clipboard_read_glib_callback, info); return TRUE; } static void data_offer_handle_offer(void *data, struct wl_data_offer *offer, const char *mime_type) {} static const struct wl_data_offer_listener data_offer_listener = { .offer = data_offer_handle_offer, }; static void data_device_handle_data_offer(void *data, struct wl_data_device *data_device, struct wl_data_offer *offer) { wl_data_offer_add_listener(offer, &data_offer_listener, NULL); } static void clipboard_default_callback(char *data) { if (wayland->clipboard_default_data != NULL) { g_free(wayland->clipboard_default_data); } wayland->clipboard_default_data = data; } static void data_device_handle_selection(void *data, struct wl_data_device *data_device, struct wl_data_offer *offer) { if (offer == NULL) { // clipboard is empty return; } int fds[2]; if (pipe(fds) < 0) { return; } wl_data_offer_receive(offer, "text/plain", fds[1]); close(fds[1]); wl_display_roundtrip(wayland->display); clipboard_read_data(fds[0], clipboard_default_callback); wl_data_offer_destroy(offer); } static const struct wl_data_device_listener data_device_listener = { .data_offer = data_device_handle_data_offer, .selection = data_device_handle_selection, }; static void primary_selection_handle_offer(void *data, struct zwp_primary_selection_offer_v1 *offer, const char *mime_type) {} static const struct zwp_primary_selection_offer_v1_listener primary_selection_offer_listener = { .offer = primary_selection_handle_offer, }; static void primary_selection_device_handle_data_offer( void *data, struct zwp_primary_selection_device_v1 *data_device, struct zwp_primary_selection_offer_v1 *offer) { zwp_primary_selection_offer_v1_add_listener( offer, &primary_selection_offer_listener, NULL); } static void clipboard_primary_callback(char *data) { if (wayland->clipboard_primary_data != NULL) { g_free(wayland->clipboard_primary_data); } wayland->clipboard_primary_data = data; } static void primary_selection_device_handle_selection( void *data, struct zwp_primary_selection_device_v1 *data_device, struct zwp_primary_selection_offer_v1 *offer) { if (offer == NULL) { // clipboard is empty return; } int fds[2]; if (pipe(fds) < 0) { return; } zwp_primary_selection_offer_v1_receive(offer, "text/plain", fds[1]); close(fds[1]); wl_display_roundtrip(wayland->display); clipboard_read_data(fds[0], clipboard_primary_callback); zwp_primary_selection_offer_v1_destroy(offer); } static const struct zwp_primary_selection_device_v1_listener primary_selection_device_listener = { .data_offer = primary_selection_device_handle_data_offer, .selection = primary_selection_device_handle_selection, }; static void wayland_pointer_release(wayland_seat *self) { if (self->pointer == NULL) { return; } if (wl_pointer_get_version(self->pointer) >= WL_POINTER_RELEASE_SINCE_VERSION) { wl_pointer_release(self->pointer); } else { wl_pointer_destroy(self->pointer); } self->pointer = NULL; } static void wayland_seat_release(wayland_seat *self) { wayland_keyboard_release(self); wayland_pointer_release(self); if (wl_seat_get_version(self->seat) >= WL_SEAT_RELEASE_SINCE_VERSION) { wl_seat_release(self->seat); } else { wl_seat_destroy(self->seat); } g_hash_table_remove(wayland->seats, self->seat); g_free(self); } static void wayland_seat_capabilities(void *data, struct wl_seat *seat, uint32_t capabilities) { wayland_seat *self = data; if ((capabilities & WL_SEAT_CAPABILITY_KEYBOARD) && (self->keyboard == NULL)) { self->keyboard = wl_seat_get_keyboard(self->seat); wl_keyboard_add_listener(self->keyboard, &wayland_keyboard_listener, self); } else if ((!(capabilities & WL_SEAT_CAPABILITY_POINTER)) && (self->keyboard != NULL)) { wayland_keyboard_release(self); } if ((capabilities & WL_SEAT_CAPABILITY_POINTER) && (self->pointer == NULL)) { self->pointer = wl_seat_get_pointer(self->seat); wl_pointer_add_listener(self->pointer, &wayland_pointer_listener, self); } else if ((!(capabilities & WL_SEAT_CAPABILITY_POINTER)) && (self->pointer != NULL)) { wayland_pointer_release(self); } if (wayland->data_device_manager != NULL) { self->data_device = wl_data_device_manager_get_data_device( wayland->data_device_manager, seat); wl_data_device_add_listener(self->data_device, &data_device_listener, NULL); } if (wayland->primary_selection_device_manager != NULL) { self->primary_selection_device = zwp_primary_selection_device_manager_v1_get_device( wayland->primary_selection_device_manager, seat); zwp_primary_selection_device_v1_add_listener( self->primary_selection_device, &primary_selection_device_listener, NULL); } } static void wayland_seat_name(void *data, struct wl_seat *seat, const char *name) { wayland_seat *self = data; if (self->name != NULL) { g_hash_table_remove(wayland->seats_by_name, self->name); } self->name = g_strdup(name); g_hash_table_insert(wayland->seats_by_name, self->name, self); } static const struct wl_seat_listener wayland_seat_listener = { .capabilities = wayland_seat_capabilities, .name = wayland_seat_name, }; static void wayland_output_release(wayland_output *self) { if (wl_output_get_version(self->output) >= WL_OUTPUT_RELEASE_SINCE_VERSION) { wl_output_release(self->output); } else { wl_output_destroy(self->output); } g_hash_table_remove(wayland->outputs, self->output); g_free(self); } static void wayland_output_done(void *data, struct wl_output *output) {} static void wayland_output_geometry(void *data, struct wl_output *output, int32_t x, int32_t y, int32_t width, int32_t height, int32_t subpixel, const char *make, const char *model, int32_t transform) {} static void wayland_output_mode(void *data, struct wl_output *output, enum wl_output_mode flags, int32_t width, int32_t height, int32_t refresh) {} static void wayland_output_scale(void *data, struct wl_output *output, int32_t scale) { wayland_output *self = data; self->scale = scale; } static const struct wl_output_listener wayland_output_listener = { .geometry = wayland_output_geometry, .mode = wayland_output_mode, .scale = wayland_output_scale, .done = wayland_output_done, }; static const char *const wayland_cursor_names[] = { "left_ptr", "default", "top_left_arrow", "left-arrow", NULL}; static void wayland_registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { if (g_strcmp0(interface, wl_compositor_interface.name) == 0) { wayland->global_names[WAYLAND_GLOBAL_COMPOSITOR] = name; wayland->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, MIN(version, WL_COMPOSITOR_INTERFACE_VERSION)); } else if (g_strcmp0(interface, zwlr_layer_shell_v1_interface.name) == 0) { wayland->global_names[WAYLAND_GLOBAL_LAYER_SHELL] = name; wayland->layer_shell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, MIN(version, WL_LAYER_SHELL_INTERFACE_VERSION)); } else if (g_strcmp0(interface, wl_shm_interface.name) == 0) { wayland->global_names[WAYLAND_GLOBAL_SHM] = name; wayland->shm = wl_registry_bind(registry, name, &wl_shm_interface, MIN(version, WL_SHM_INTERFACE_VERSION)); } else if (g_strcmp0(interface, wl_seat_interface.name) == 0) { wayland_seat *seat = g_new0(wayland_seat, 1); seat->context = wayland; seat->global_name = name; seat->seat = wl_registry_bind(registry, name, &wl_seat_interface, MIN(version, WL_SEAT_INTERFACE_VERSION)); g_hash_table_insert(wayland->seats, seat->seat, seat); wl_seat_add_listener(seat->seat, &wayland_seat_listener, seat); } else if (g_strcmp0(interface, wl_output_interface.name) == 0) { wayland_output *output = g_new0(wayland_output, 1); output->context = wayland; output->global_name = name; output->output = wl_registry_bind(registry, name, &wl_output_interface, MIN(version, WL_OUTPUT_INTERFACE_VERSION)); output->scale = 1; g_hash_table_insert(wayland->outputs, output->output, output); wl_output_add_listener(output->output, &wayland_output_listener, output); } else if (strcmp(interface, wl_data_device_manager_interface.name) == 0) { wayland->data_device_manager = wl_registry_bind(registry, name, &wl_data_device_manager_interface, 3); } else if (strcmp(interface, zwp_primary_selection_device_manager_v1_interface.name) == 0) { wayland->primary_selection_device_manager = wl_registry_bind( registry, name, &zwp_primary_selection_device_manager_v1_interface, 1); } } static void wayland_registry_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) { wayland_global_name i; for (i = 0; i < _WAYLAND_GLOBAL_SIZE; ++i) { if (wayland->global_names[i] != name) { continue; } wayland->global_names[i] = 0; switch (i) { case WAYLAND_GLOBAL_COMPOSITOR: wl_compositor_destroy(wayland->compositor); wayland->compositor = NULL; break; case WAYLAND_GLOBAL_LAYER_SHELL: zwlr_layer_shell_v1_destroy(wayland->layer_shell); wayland->layer_shell = NULL; break; case WAYLAND_GLOBAL_SHM: wl_shm_destroy(wayland->shm); wayland->shm = NULL; break; case _WAYLAND_GLOBAL_SIZE: g_assert_not_reached(); } return; } if ((wayland->cursor.theme != NULL) && ((wayland->compositor == NULL) || (wayland->shm == NULL))) { if (wayland->cursor.frame_cb != NULL) { wl_callback_destroy(wayland->cursor.frame_cb); } wayland->cursor.frame_cb = NULL; wl_surface_destroy(wayland->cursor.surface); wl_cursor_theme_destroy(wayland->cursor.theme); wayland->cursor.surface = NULL; wayland->cursor.image = NULL; wayland->cursor.cursor = NULL; wayland->cursor.theme = NULL; } GHashTableIter iter; wayland_seat *seat; g_hash_table_iter_init(&iter, wayland->seats); while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&seat)) { if (seat->global_name != name) { continue; } g_hash_table_iter_remove(&iter); wayland_seat_release(seat); return; } wayland_output *output; g_hash_table_iter_init(&iter, wayland->outputs); while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&output)) { if (output->global_name != name) { continue; } g_hash_table_iter_remove(&iter); wayland_output_release(output); return; } } static const struct wl_registry_listener wayland_registry_listener = { .global = wayland_registry_handle_global, .global_remove = wayland_registry_handle_global_remove, }; static void wayland_layer_shell_surface_configure( void *data, struct zwlr_layer_surface_v1 *surface, uint32_t serial, uint32_t width, uint32_t height) { wayland->layer_width = width; wayland->layer_height = height; zwlr_layer_surface_v1_ack_configure(surface, serial); } static void wayland_layer_shell_surface_closed(void *data, struct zwlr_layer_surface_v1 *surface) { zwlr_layer_surface_v1_destroy(surface); wl_surface_destroy(wayland->surface); wayland->surface = NULL; } static const struct zwlr_layer_surface_v1_listener wayland_layer_shell_surface_listener = { .configure = wayland_layer_shell_surface_configure, .closed = wayland_layer_shell_surface_closed, }; static gboolean wayland_error(gpointer user_data) { g_main_loop_quit(wayland->main_loop); return G_SOURCE_REMOVE; } static gboolean wayland_display_setup(GMainLoop *main_loop, NkBindings *bindings) { wayland->main_loop = main_loop; char *display = (char *)g_getenv("WAYLAND_DISPLAY"); wayland->main_loop_source = g_water_wayland_source_new(NULL, display); if (wayland->main_loop_source == NULL) { g_warning("Could not connect to the Wayland compositor"); return FALSE; } g_water_wayland_source_set_error_callback(wayland->main_loop_source, wayland_error, NULL, NULL); wayland->buffer_count = 3; wayland->scale = 1; wayland->outputs = g_hash_table_new(g_direct_hash, g_direct_equal); wayland->seats = g_hash_table_new(g_direct_hash, g_direct_equal); wayland->seats_by_name = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); wayland->display = g_water_wayland_source_get_display(wayland->main_loop_source); wayland->registry = wl_display_get_registry(wayland->display); wl_registry_add_listener(wayland->registry, &wayland_registry_listener, NULL); wl_display_roundtrip(wayland->display); if (wayland->compositor == NULL || wayland->shm == NULL || g_hash_table_size(wayland->outputs) == 0 || g_hash_table_size(wayland->seats) == 0) { g_error("Could not connect to wayland compositor"); return FALSE; } if (wayland->layer_shell == NULL) { g_error("Rofi on wayland requires support for the layer shell protocol"); return FALSE; } guint64 cursor_size = 24; char *env_cursor_size = (char *)g_getenv("XCURSOR_SIZE"); if (env_cursor_size && strlen(env_cursor_size) > 0) { guint64 size = g_ascii_strtoull(env_cursor_size, NULL, 10); if (0 < size && size < G_MAXUINT64) { cursor_size = size; } } wayland->cursor.theme = wl_cursor_theme_load(wayland->cursor.theme_name, cursor_size, wayland->shm); if (wayland->cursor.theme != NULL) { const char *const *cname = (const char *const *)wayland->cursor.name; for (cname = (cname != NULL) ? cname : wayland_cursor_names; (wayland->cursor.cursor == NULL) && (*cname != NULL); ++cname) { wayland->cursor.cursor = wl_cursor_theme_get_cursor(wayland->cursor.theme, *cname); } if (wayland->cursor.cursor == NULL) { wl_cursor_theme_destroy(wayland->cursor.theme); wayland->cursor.theme = NULL; } else { wayland->cursor.surface = wl_compositor_create_surface(wayland->compositor); } } wayland->surface = wl_compositor_create_surface(wayland->compositor); wayland->bindings_seat = nk_bindings_seat_new(bindings, XKB_CONTEXT_NO_FLAGS); wayland->wlr_surface = zwlr_layer_shell_v1_get_layer_surface( wayland->layer_shell, wayland->surface, NULL, ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, "rofi"); // Set size zero and anchor on all corners to get the usable screen size // see https://github.com/swaywm/wlroots/pull/2422 zwlr_layer_surface_v1_set_anchor(wayland->wlr_surface, ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT); zwlr_layer_surface_v1_set_size(wayland->wlr_surface, 0, 0); zwlr_layer_surface_v1_set_keyboard_interactivity(wayland->wlr_surface, 1); zwlr_layer_surface_v1_add_listener( wayland->wlr_surface, &wayland_layer_shell_surface_listener, NULL); wl_surface_add_listener(wayland->surface, &wayland_surface_interface, wayland); wl_surface_commit(wayland->surface); wl_display_roundtrip(wayland->display); wayland_frame_callback(wayland, wayland->frame_cb, 0); return TRUE; } static gboolean wayland_display_late_setup(void) { return TRUE; } gboolean display_get_surface_dimensions(int *width, int *height) { if (wayland->layer_width != 0) { if (width != NULL) { *width = wayland->layer_width; } if (height != NULL) { *height = wayland->layer_height; } return TRUE; } return FALSE; } void display_set_surface_dimensions( int width, int height, int x_margin, int y_margin, int loc) { wayland->layer_width = width; wayland->layer_height = height; zwlr_layer_surface_v1_set_size(wayland->wlr_surface, width, height); uint32_t wlr_anchor = 0; switch (loc) { case WL_NORTH_WEST: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; break; case WL_NORTH: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; break; case WL_NORTH_EAST: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; break; case WL_EAST: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; break; case WL_SOUTH_EAST: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; break; case WL_SOUTH: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; break; case WL_SOUTH_WEST: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; break; case WL_WEST: wlr_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT; break; case WL_CENTER: default: break; } if (height == 0) { wlr_anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; } if (width == 0) { wlr_anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; } zwlr_layer_surface_v1_set_anchor(wayland->wlr_surface, wlr_anchor); // NOTE: Setting margin for edges we are not anchored to has no effect, so we // can safely set contradictory margins (e.g. top vs bottom) - at most one of // the margins on a given axis will have effect. // This also means that margin has no effect if the window is centered. :( zwlr_layer_surface_v1_set_margin(wayland->wlr_surface, y_margin, -x_margin, -y_margin, x_margin); } static void wayland_display_early_cleanup(void) {} static void wayland_display_cleanup(void) { if (wayland->main_loop_source == NULL) { return; } if (wayland->surface != NULL) { wl_surface_destroy(wayland->surface); } nk_bindings_seat_free(wayland->bindings_seat); g_hash_table_unref(wayland->seats_by_name); g_hash_table_unref(wayland->seats); g_hash_table_unref(wayland->outputs); wl_registry_destroy(wayland->registry); wl_display_flush(wayland->display); g_water_wayland_source_free(wayland->main_loop_source); } static void wayland_display_dump_monitor_layout(void) {} static void wayland_display_startup_notification(RofiHelperExecuteContext *context, GSpawnChildSetupFunc *child_setup, gpointer *user_data) {} static int wayland_display_monitor_active(workarea *mon) { // TODO: do something? return FALSE; } static void wayland_display_set_input_focus(guint w) {} static void wayland_display_revert_input_focus(void) {} static const struct _view_proxy *wayland_display_view_proxy(void) { return wayland_view_proxy; } static guint wayland_display_scale(void) { return wayland->scale; } static char *wayland_get_clipboard_data(int type) { switch (type) { case CLIPBOARD_DEFAULT: return wayland->clipboard_default_data; case CLIPBOARD_PRIMARY: return wayland->clipboard_primary_data; } return NULL; } static display_proxy display_ = { .setup = wayland_display_setup, .late_setup = wayland_display_late_setup, .early_cleanup = wayland_display_early_cleanup, .cleanup = wayland_display_cleanup, .dump_monitor_layout = wayland_display_dump_monitor_layout, .startup_notification = wayland_display_startup_notification, .monitor_active = wayland_display_monitor_active, .set_input_focus = wayland_display_set_input_focus, .revert_input_focus = wayland_display_revert_input_focus, .scale = wayland_display_scale, .get_clipboard_data = wayland_get_clipboard_data, .view = wayland_display_view_proxy, }; display_proxy *const wayland_proxy = &display_;