Mirrors/rofi
2
0
Fork 0
mirror of https://github.com/lbonn/rofi synced 2024-11-24 04:43:03 +00:00
Code Issues Projects Releases Packages Wiki Activity
rofi/source/wayland/display.c
waicool20 fd0ef6bc15 Fix for segfault after updating to KDE 5.26
2022-10-19 02:08:29 +02:00

1422 lines
44 KiB
C
Raw Blame History

/**
* 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 <config.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/input-event-codes.h>
#include <locale.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <cairo.h>
#include <glib.h>
#include <glib/gstdio.h>
#include <wayland-client.h>
#include <wayland-cursor.h>
#include <xcb/xkb.h>
#include <xkbcommon/xkbcommon-compose.h>
#include <xkbcommon/xkbcommon.h>
#include <libgwater-wayland.h>
#include <nkutils-bindings.h>
#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 void data_offer_handle_source_actions(void *data,
struct wl_data_offer *wl_data_offer,
uint32_t source_actions) {}
static void data_offer_handle_action(void *data,
struct wl_data_offer *wl_data_offer,
uint32_t dnd_action) {}
static const struct wl_data_offer_listener data_offer_listener = {
.offer = data_offer_handle_offer,
.source_actions = data_offer_handle_source_actions,
.action = data_offer_handle_action,
};
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_;
Reference in a new issue View git blame Copy permalink