2704 lines
82 KiB
C
2704 lines
82 KiB
C
#include <Mw/Milsko.h>
|
|
|
|
#include <sys/poll.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include "../../external/stb_ds.h"
|
|
#include "pixman.h"
|
|
|
|
/* TODO: find out what FreeBSD and such wants us to include */
|
|
#ifdef __FreeBSD__
|
|
/* XXX: Untested (nishi) */
|
|
#include <evdev/input.h>
|
|
#else
|
|
#include <linux/input.h>
|
|
#include <linux/input-event-codes.h>
|
|
#endif
|
|
|
|
wayland_call_table_t wl_call_tbl;
|
|
MwBool MwWaylandAlwaysRender = MwFALSE;
|
|
|
|
/* Standard procedure before most event callbacks in Wayland ("most" because the setup ones don't need this). Wait for the Mutex to be freed, if we're deadlocking for longer then a quarter of a second then do nothing with the event. */
|
|
#define WAYLAND_EVENT_OP_START(self) \
|
|
do { \
|
|
struct timespec t; \
|
|
t.tv_sec = 0; \
|
|
t.tv_nsec = 250; \
|
|
if(pthread_mutex_timedlock(&self->wayland.eventsMutex, &t) != 0) { \
|
|
/*printf("deadlock at line %d\n", __LINE__);*/ \
|
|
return; \
|
|
}; \
|
|
} while(0);
|
|
|
|
/* Footer for WAYLAND_EVENT_OP_START */
|
|
#define WAYLAND_EVENT_OP_END(self) pthread_mutex_unlock(&self->wayland.eventsMutex);
|
|
|
|
/* Setup the framebuffer with the saved width/height */
|
|
static void framebuffer_setup(struct _MwLLWayland* wayland);
|
|
/* Destroy the framebuffer */
|
|
static void framebuffer_destroy(struct _MwLLWayland* handle);
|
|
|
|
/* Setup the framebuffer with the saved width/height */
|
|
static void backbuffer_setup(struct _MwLLWayland* wayland);
|
|
/* Destroy the backbuffer */
|
|
static void backbuffer_destroy(struct _MwLLWayland* handle);
|
|
|
|
static void buffer_destroy(struct _MwLLWaylandShmBuffer* buffer);
|
|
|
|
static void region_setup(MwLL handle);
|
|
static void region_invalidate(MwLL handle);
|
|
static void update_buffer(MwLL self, struct _MwLLWaylandShmBuffer* buffer);
|
|
/* Get the registered interface from r, or NULL if it doesn't currently have it. */
|
|
#define WAYLAND_GET_INTERFACE(handle, inter) shget(handle.wl_protocol_map, inter##_interface.name)
|
|
|
|
/* `wl_registry.global` callback */
|
|
static void new_protocol(void* data, struct wl_registry* registry,
|
|
MwU32 name, const char* interface,
|
|
MwU32 version) {
|
|
MwLL self = data;
|
|
(void)version;
|
|
(void)registry;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
wayland_protocol_callback_table_t* cb = shget(self->wayland.wl_protocol_setup_map, interface);
|
|
if(cb != NULL) {
|
|
char* inter = malloc(strlen(interface) + 1);
|
|
strcpy(inter, interface);
|
|
shput(self->wayland.wl_protocol_map, inter, cb->setup(name, data));
|
|
/* we don't care for adding this protocol, we just use it to know if the compositor will let us have transparent surfaces */
|
|
} else if(strcmp(interface, "wp_alpha_modifier_v1") == 0) {
|
|
self->common.supports_transparency = MwTRUE;
|
|
} else {
|
|
// printf("unknown interface %s\n", interface);
|
|
}
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_registry.global_remove` callback */
|
|
static void protocol_removed(void* data,
|
|
struct wl_registry* registry,
|
|
MwU32 name) {
|
|
(void)data;
|
|
(void)registry;
|
|
(void)name;
|
|
printf("%d destroyed\n", name);
|
|
};
|
|
|
|
/* Flush Wayland events */
|
|
static void wl_flush(MwLL handle) {
|
|
struct pollfd pfd;
|
|
int rc;
|
|
|
|
pfd.fd = wl_display_get_fd(handle->wayland.display);
|
|
pfd.events = POLLIN;
|
|
while(MwTRUE) {
|
|
rc = wl_display_flush(handle->wayland.display);
|
|
if(errno != EAGAIN || rc != -1) {
|
|
break;
|
|
}
|
|
|
|
if(poll(&pfd, 1, -1) == -1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Recursively dispatch a resize event to a widget and its children */
|
|
static void recursive_dispatch_resize(MwLL handle) {
|
|
MwWidget h = (MwWidget)handle->common.user;
|
|
if(h) {
|
|
int i;
|
|
for(i = 0; i < arrlen(h->children); i++) {
|
|
MwDispatch(h->children[i], resize);
|
|
if(arrlen(h->children[i]->children) > 0) {
|
|
recursive_dispatch_resize(h->children[i]->lowlevel);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/* Recursively dispatch a move event to a widget and its children */
|
|
static void recursive_dispatch_move(MwLL handle, MwLLMouse* p) {
|
|
MwWidget h = (MwWidget)handle->common.user;
|
|
if(h) {
|
|
int i;
|
|
for(i = 0; i < arrlen(h->children); i++) {
|
|
MwLLDispatch(h->children[i]->lowlevel, move, p);
|
|
if(arrlen(h->children[i]->children) > 0) {
|
|
recursive_dispatch_move(h->children[i]->lowlevel, p);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/* Recursively dispatch a key event to a widget and its children */
|
|
static void recursive_dispatch_key(MwLL handle, int* k) {
|
|
MwWidget h = (MwWidget)handle->common.user;
|
|
MwLLDispatch(handle, key, k);
|
|
if(h) {
|
|
int i;
|
|
for(i = 0; i < arrlen(h->children); i++) {
|
|
MwLLDispatch(h->children[i]->lowlevel, key, k);
|
|
if(arrlen(h->children[i]->children) > 0) {
|
|
recursive_dispatch_key(h->children[i]->lowlevel, k);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
/* Recursively dispatch a key released event to a widget and its children */
|
|
static void recursive_dispatch_key_released(MwLL handle, int* k) {
|
|
MwWidget h = (MwWidget)handle->common.user;
|
|
MwLLDispatch(handle, key_released, k);
|
|
if(h) {
|
|
int i;
|
|
for(i = 0; i < arrlen(h->children); i++) {
|
|
MwLLDispatch(h->children[i]->lowlevel, key_released, k);
|
|
if(arrlen(h->children[i]->children) > 0) {
|
|
recursive_dispatch_key_released(h->children[i]->lowlevel, k);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
static void wl_offer(void* data,
|
|
struct wl_data_offer* wl_data_offer,
|
|
const char* mime_type) {
|
|
wl_clipboard_device_context_t* self = data;
|
|
wl_data_offer_accept(wl_data_offer, self->ll->wayland.clipboard_serial, mime_type);
|
|
};
|
|
|
|
struct wl_data_offer_listener offer_listener = {
|
|
.offer = wl_offer,
|
|
};
|
|
|
|
static void wl_data_device_data_offer(void* data,
|
|
struct wl_data_device* wl_data_device,
|
|
struct wl_data_offer* offer) {
|
|
wl_clipboard_device_context_t* self = data;
|
|
(void)wl_data_device;
|
|
|
|
wl_data_offer_add_listener(offer, &offer_listener, data);
|
|
|
|
self->offer.wl = offer;
|
|
};
|
|
|
|
static void wl_data_device_enter(void* data,
|
|
struct wl_data_device* wl_data_device,
|
|
uint32_t serial,
|
|
struct wl_surface* surface,
|
|
wl_fixed_t x,
|
|
wl_fixed_t y,
|
|
struct wl_data_offer* id) {
|
|
MwLL self = data;
|
|
(void)wl_data_device;
|
|
(void)surface;
|
|
(void)x;
|
|
(void)y;
|
|
(void)id;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
self->wayland.clipboard_serial = serial;
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
static void wl_data_device_leave(void* data,
|
|
struct wl_data_device* wl_data_device) {
|
|
MwLL self = data;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
wl_data_device_destroy(wl_data_device);
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
static void wl_data_device_motion(void* data,
|
|
struct wl_data_device* wl_data_device,
|
|
uint32_t time,
|
|
wl_fixed_t x,
|
|
wl_fixed_t y) {
|
|
(void)data;
|
|
(void)wl_data_device;
|
|
(void)time;
|
|
(void)x;
|
|
(void)y;
|
|
};
|
|
static void wl_data_device_drop(void* data,
|
|
struct wl_data_device* wl_data_device) {
|
|
(void)data;
|
|
(void)wl_data_device;
|
|
};
|
|
|
|
static void wl_data_device_selection(void* data,
|
|
struct wl_data_device* wl_data_device,
|
|
struct wl_data_offer* id) {
|
|
(void)data;
|
|
(void)wl_data_device;
|
|
(void)id;
|
|
};
|
|
|
|
struct wl_data_device_listener wl_data_device_listener = {
|
|
.data_offer = wl_data_device_data_offer,
|
|
.enter = wl_data_device_enter,
|
|
.leave = wl_data_device_leave,
|
|
.motion = wl_data_device_motion,
|
|
.drop = wl_data_device_drop,
|
|
.selection = wl_data_device_selection,
|
|
};
|
|
|
|
static void zwp_primary_selection_device_v1_data_offer(void* data,
|
|
struct zwp_primary_selection_device_v1* zwp_primary_selection_device_v1,
|
|
struct zwp_primary_selection_offer_v1* offer) {
|
|
wl_clipboard_device_context_t* self = data;
|
|
(void)zwp_primary_selection_device_v1;
|
|
|
|
self->offer.zwp = offer;
|
|
};
|
|
|
|
static void zwp_primary_selection_device_v1_selection(void* data,
|
|
struct zwp_primary_selection_device_v1* zwp_primary_selection_device_v1,
|
|
struct zwp_primary_selection_offer_v1* id) {
|
|
(void)data;
|
|
(void)zwp_primary_selection_device_v1;
|
|
(void)id;
|
|
};
|
|
|
|
struct zwp_primary_selection_device_v1_listener zwp_primary_selection_device_v1_listener = {
|
|
.data_offer = zwp_primary_selection_device_v1_data_offer,
|
|
.selection = zwp_primary_selection_device_v1_selection,
|
|
};
|
|
|
|
static void wl_clipboard_read(wl_clipboard_device_context_t* ctx) {
|
|
int fds[2];
|
|
fd_set set;
|
|
char* buf = NULL;
|
|
struct timeval timeout;
|
|
int rc = 0;
|
|
|
|
if(pipe(fds) != 0) {
|
|
return;
|
|
}
|
|
|
|
FD_ZERO(&set);
|
|
FD_SET(fds[0], &set);
|
|
timeout.tv_sec = 0;
|
|
timeout.tv_usec = 100;
|
|
|
|
if(ctx->ll->wayland.supports_zwp) {
|
|
zwp_primary_selection_offer_v1_receive(ctx->offer.zwp, "text/plain", fds[1]);
|
|
} else if(ctx->offer.wl) {
|
|
wl_data_offer_receive(ctx->offer.wl, "text/plain", fds[1]);
|
|
}
|
|
close(fds[1]);
|
|
|
|
wl_flush(ctx->ll);
|
|
wl_display_roundtrip(ctx->ll->wayland.display);
|
|
|
|
while(MwTRUE) {
|
|
rc = select(fds[0] + 1, &set, NULL, NULL, &timeout);
|
|
if(rc <= 0) {
|
|
break;
|
|
} else {
|
|
char b;
|
|
ssize_t n = read(fds[0], &b, sizeof(b));
|
|
if(n <= 0) {
|
|
break;
|
|
}
|
|
arrpush(buf, b);
|
|
}
|
|
}
|
|
arrpush(buf, 0);
|
|
close(fds[0]);
|
|
|
|
MwLLDispatch(ctx->ll, clipboard, buf);
|
|
arrfree(buf);
|
|
|
|
ctx->ll->wayland.events_pending = 1;
|
|
}
|
|
|
|
static void wl_data_source_listener_target(void* data,
|
|
struct wl_data_source* wl_data_source,
|
|
const char* mime_type) {
|
|
(void)data;
|
|
(void)wl_data_source;
|
|
(void)mime_type;
|
|
};
|
|
static void wl_data_source_listener_send(void* data,
|
|
struct wl_data_source* wl_data_source,
|
|
const char* mime_type,
|
|
int32_t fd) {
|
|
MwLL self = data;
|
|
(void)wl_data_source;
|
|
(void)mime_type;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
if(self->wayland.clipboard_buffer != NULL) {
|
|
write(fd, self->wayland.clipboard_buffer, strlen(self->wayland.clipboard_buffer));
|
|
close(fd);
|
|
}
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
static void wl_data_source_listener_cancelled(void* data,
|
|
struct wl_data_source* wl_data_source);
|
|
|
|
struct wl_data_source_listener wl_data_source_listener = {
|
|
.target = wl_data_source_listener_target,
|
|
.send = wl_data_source_listener_send,
|
|
.cancelled = wl_data_source_listener_cancelled,
|
|
};
|
|
|
|
static void wl_data_source_listener_cancelled(void* data,
|
|
struct wl_data_source* wl_data_source) {
|
|
MwLL self = data;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
wl_data_source_destroy(wl_data_source);
|
|
|
|
self->wayland.clipboard_source.wl = wl_data_device_manager_create_data_source(self->wayland.clipboard_manager.wl);
|
|
|
|
wl_data_source_offer(self->wayland.clipboard_source.wl, "text/plain");
|
|
wl_data_source_offer(self->wayland.clipboard_source.wl, "text/plain;charset=utf-8");
|
|
wl_data_source_offer(self->wayland.clipboard_source.wl, "TEXT");
|
|
wl_data_source_offer(self->wayland.clipboard_source.wl, "STRING");
|
|
wl_data_source_offer(self->wayland.clipboard_source.wl, "UTF8_STRING");
|
|
|
|
wl_data_source_add_listener(self->wayland.clipboard_source.wl, &wl_data_source_listener, self);
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
static void zwp_primary_selection_source_v1_send(void* data,
|
|
struct zwp_primary_selection_source_v1* wl_data_source,
|
|
const char* mime_type,
|
|
int32_t fd) {
|
|
MwLL self = data;
|
|
(void)wl_data_source;
|
|
(void)mime_type;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
if(self->wayland.clipboard_buffer != NULL) {
|
|
write(fd, self->wayland.clipboard_buffer, strlen(self->wayland.clipboard_buffer));
|
|
close(fd);
|
|
}
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
static void zwp_primary_selection_source_v1_cancelled(void* data,
|
|
struct zwp_primary_selection_source_v1* wl_data_source) {
|
|
MwLL self = data;
|
|
(void)wl_data_source;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
zwp_primary_selection_source_v1_destroy(self->wayland.clipboard_source.zwp);
|
|
|
|
self->wayland.clipboard_source.zwp = zwp_primary_selection_device_manager_v1_create_source(self->wayland.clipboard_manager.zwp);
|
|
|
|
zwp_primary_selection_source_v1_offer(self->wayland.clipboard_source.zwp, "text/plain");
|
|
zwp_primary_selection_source_v1_offer(self->wayland.clipboard_source.zwp, "text/plain;charset=utf-8");
|
|
zwp_primary_selection_source_v1_offer(self->wayland.clipboard_source.zwp, "TEXT");
|
|
zwp_primary_selection_source_v1_offer(self->wayland.clipboard_source.zwp, "STRING");
|
|
zwp_primary_selection_source_v1_offer(self->wayland.clipboard_source.zwp, "UTF8_STRING");
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
struct zwp_primary_selection_source_v1_listener zwp_primary_selection_source_v1_listener = {
|
|
.send = zwp_primary_selection_source_v1_send,
|
|
.cancelled = zwp_primary_selection_source_v1_cancelled,
|
|
};
|
|
|
|
/* wl_data_device_manager setup function */
|
|
static wayland_protocol_t* wl_data_device_manager_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland->clipboard_manager.wl = wl_registry_bind(wayland->registry, name, &wl_data_device_manager_interface, 2);
|
|
|
|
wayland->clipboard_source.wl = wl_data_device_manager_create_data_source(wayland->clipboard_manager.wl);
|
|
|
|
wl_data_source_offer(wayland->clipboard_source.wl, "text/plain");
|
|
wl_data_source_offer(wayland->clipboard_source.wl, "text/plain;charset=utf-8");
|
|
wl_data_source_offer(wayland->clipboard_source.wl, "TEXT");
|
|
wl_data_source_offer(wayland->clipboard_source.wl, "STRING");
|
|
wl_data_source_offer(wayland->clipboard_source.wl, "UTF8_STRING");
|
|
|
|
wl_data_source_add_listener(wayland->clipboard_source.wl, &wl_data_source_listener, wayland);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void wl_data_device_manager_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)data;
|
|
if(wayland->clipboard_manager.wl != NULL && !wayland->supports_zwp) {
|
|
wl_data_device_manager_destroy(wayland->clipboard_manager.wl);
|
|
wl_data_source_destroy(wayland->clipboard_source.wl);
|
|
wayland->clipboard_manager.wl = NULL;
|
|
}
|
|
}
|
|
|
|
/* zwp_primary_selection_device_manager_v1 setup function */
|
|
static wayland_protocol_t* zwp_primary_selection_device_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
if(wayland->clipboard_manager.wl != NULL) {
|
|
wl_data_device_manager_interface_destroy(wayland, NULL);
|
|
}
|
|
|
|
wayland->clipboard_manager.zwp = wl_registry_bind(wayland->registry, name, &zwp_primary_selection_device_manager_v1_interface, 1);
|
|
|
|
wayland->clipboard_source.zwp = zwp_primary_selection_device_manager_v1_create_source(wayland->clipboard_manager.zwp);
|
|
|
|
zwp_primary_selection_source_v1_offer(wayland->clipboard_source.zwp, "text/plain");
|
|
zwp_primary_selection_source_v1_offer(wayland->clipboard_source.zwp, "text/plain;charset=utf-8");
|
|
zwp_primary_selection_source_v1_offer(wayland->clipboard_source.zwp, "TEXT");
|
|
zwp_primary_selection_source_v1_offer(wayland->clipboard_source.zwp, "STRING");
|
|
zwp_primary_selection_source_v1_offer(wayland->clipboard_source.zwp, "UTF8_STRING");
|
|
|
|
zwp_primary_selection_source_v1_add_listener(wayland->clipboard_source.zwp, &zwp_primary_selection_source_v1_listener, wayland);
|
|
|
|
wayland->supports_zwp = MwTRUE;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void zwp_primary_selection_device_manager_v1_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
/* zwp_primary_selection_device_manager_v1 setup function */
|
|
static wayland_protocol_t* zwp_pointer_constraints_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland->pointer_constraints = wl_registry_bind(wayland->registry, name, &zwp_pointer_constraints_v1_interface, 1);
|
|
return NULL;
|
|
}
|
|
|
|
static void zwp_pointer_constraints_v1_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
static struct wl_surface* curSurface;
|
|
|
|
/* `wl_pointer.enter` callback */
|
|
static void pointer_enter(void* data, struct wl_pointer* wl_pointer, MwU32 serial,
|
|
struct wl_surface* surface, wl_fixed_t surface_x,
|
|
wl_fixed_t surface_y) {
|
|
MwLL self = data;
|
|
(void)surface_x;
|
|
(void)surface_y;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
curSurface = surface;
|
|
|
|
self->wayland.pointer_serial = serial;
|
|
|
|
wl_pointer_set_cursor(wl_pointer, serial, self->wayland.cursor.surface, 0, 0);
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_pointer.leave` callback */
|
|
static void pointer_leave(void* data, struct wl_pointer* wl_pointer, MwU32 serial,
|
|
struct wl_surface* surface) {
|
|
MwLL self = data;
|
|
(void)wl_pointer;
|
|
(void)serial;
|
|
(void)surface;
|
|
WAYLAND_EVENT_OP_START(self);
|
|
curSurface = NULL;
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
static void xdg_borderless_step(MwLL self, MwLLMouse p, MwU32 serial) {
|
|
if(self->wayland.type == MWLL_WAYLAND_TOPLEVEL && self->wayland.backbuffer.surface == curSurface) {
|
|
if(p.point.y >= (self->wayland.wh + CSD_BORDER_FRAME_TOP + CSD_BORDER_FRAME_BOTTOM) - 5) {
|
|
if(p.point.x >= (self->wayland.ww + CSD_BORDER_FRAME_LEFT + CSD_BORDER_FRAME_RIGHT) - 5) {
|
|
xdg_toplevel_resize(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial, XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT);
|
|
} else {
|
|
xdg_toplevel_resize(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial, XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM);
|
|
}
|
|
} else if(p.point.y <= 5) {
|
|
if(p.point.x >= (self->wayland.ww + CSD_BORDER_FRAME_LEFT + CSD_BORDER_FRAME_RIGHT) - 5) {
|
|
xdg_toplevel_resize(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial, XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT);
|
|
} else {
|
|
xdg_toplevel_resize(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial, XDG_TOPLEVEL_RESIZE_EDGE_TOP);
|
|
}
|
|
} else if(p.point.x >= (self->wayland.ww + CSD_BORDER_FRAME_LEFT + CSD_BORDER_FRAME_RIGHT) - 5) {
|
|
xdg_toplevel_resize(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial, XDG_TOPLEVEL_RESIZE_EDGE_RIGHT);
|
|
} else if(p.point.x <= 5) {
|
|
xdg_toplevel_resize(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial, XDG_TOPLEVEL_RESIZE_EDGE_LEFT);
|
|
} else if(p.point.y <= CSD_BORDER_FRAME_TOP) {
|
|
xdg_toplevel_move(self->wayland.toplevel->xdg_top_level, self->wayland.pointer_seat, serial);
|
|
}
|
|
};
|
|
}
|
|
|
|
static MwLL currentlyHeldWidget = NULL;
|
|
|
|
static void relative_pointer_motion(void* data,
|
|
struct zwp_relative_pointer_v1* pointer,
|
|
uint32_t timeHi,
|
|
uint32_t timeLo,
|
|
wl_fixed_t dx,
|
|
wl_fixed_t dy,
|
|
wl_fixed_t dxUnaccel,
|
|
wl_fixed_t dyUnaccel) {
|
|
MwLL self = data;
|
|
MwLLMouse p;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
p.point.x = wl_fixed_to_int(dxUnaccel);
|
|
p.point.y = wl_fixed_to_int(dyUnaccel);
|
|
|
|
recursive_dispatch_move(self, &p);
|
|
if(self->wayland.locked_pointer) zwp_locked_pointer_v1_set_cursor_position_hint(self->wayland.locked_pointer, 0, CSD_BORDER_FRAME_TOP);
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
}
|
|
|
|
struct zwp_relative_pointer_v1_listener relative_pointer_listener =
|
|
{
|
|
relative_pointer_motion};
|
|
|
|
/* zwp_primary_selection_device_manager_v1 setup function */
|
|
static wayland_protocol_t* zwp_relative_pointer_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland->relative_pointer_manager = wl_registry_bind(wayland->registry, name, &zwp_relative_pointer_manager_v1_interface, 1);
|
|
return NULL;
|
|
}
|
|
|
|
static void zwp_relative_pointer_manager_v1_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
/* `wl_pointer.motion` callback */
|
|
static void pointer_motion(void* data, struct wl_pointer* wl_pointer, MwU32 time,
|
|
wl_fixed_t surface_x, wl_fixed_t surface_y) {
|
|
MwLL self = data;
|
|
MwLL topmost_parent = self;
|
|
MwLLMouse p;
|
|
(void)time;
|
|
(void)wl_pointer;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
while(topmost_parent->wayland.parent) topmost_parent = topmost_parent->wayland.parent;
|
|
|
|
self->wayland.cur_mouse_pos.x = wl_fixed_to_int(surface_x);
|
|
self->wayland.cur_mouse_pos.y = wl_fixed_to_int(surface_y);
|
|
p.point = self->wayland.cur_mouse_pos;
|
|
MwLLDispatch(self, move, &p);
|
|
|
|
if(currentlyHeldWidget) {
|
|
MwLLDispatch(currentlyHeldWidget, down, &p);
|
|
}
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_pointer.button` callback */
|
|
static void pointer_button(void* data, struct wl_pointer* wl_pointer, MwU32 serial, MwU32 time, MwU32 button, MwU32 state) {
|
|
MwLL self = data;
|
|
MwLLMouse p;
|
|
MwBool inArea = MwFALSE;
|
|
|
|
(void)wl_pointer;
|
|
(void)serial;
|
|
(void)time;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
p.point = self->wayland.cur_mouse_pos;
|
|
|
|
if(self->wayland.framebuffer.surface) {
|
|
inArea |= self->wayland.framebuffer.surface == curSurface;
|
|
}
|
|
if(self->wayland.backbuffer.surface) {
|
|
inArea |= self->wayland.backbuffer.surface == curSurface;
|
|
}
|
|
if(inArea) {
|
|
int i;
|
|
|
|
switch(button) {
|
|
case BTN_LEFT:
|
|
p.button = MwLLMouseLeft;
|
|
break;
|
|
case BTN_MIDDLE:
|
|
p.button = MwLLMouseMiddle;
|
|
for(i = 0; i < arrlen(self->wayland.clipboard_devices); i++) {
|
|
wl_clipboard_read(
|
|
self->wayland.clipboard_devices[i]);
|
|
}
|
|
break;
|
|
case BTN_RIGHT:
|
|
p.button = MwLLMouseRight;
|
|
break;
|
|
}
|
|
self->wayland.held_down = state == WL_POINTER_BUTTON_STATE_PRESSED;
|
|
|
|
switch(state) {
|
|
case WL_POINTER_BUTTON_STATE_PRESSED:
|
|
MwLLDispatch(self, down, &p);
|
|
currentlyHeldWidget = self;
|
|
|
|
break;
|
|
case WL_POINTER_BUTTON_STATE_RELEASED:
|
|
if(currentlyHeldWidget != NULL) {
|
|
MwLLDispatch(currentlyHeldWidget, up, &p);
|
|
currentlyHeldWidget = NULL;
|
|
} else {
|
|
MwLLDispatch(self, up, &p);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!self->wayland.has_decorations) {
|
|
xdg_borderless_step(self, p, serial);
|
|
}
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_pointer.axis` callback */
|
|
static void pointer_axis(void* data, struct wl_pointer* wl_pointer, MwU32 time,
|
|
MwU32 axis, wl_fixed_t value) {
|
|
(void)data;
|
|
(void)wl_pointer;
|
|
(void)time;
|
|
(void)axis;
|
|
(void)value;
|
|
};
|
|
|
|
struct wl_pointer_listener pointer_listener = {
|
|
.enter = pointer_enter,
|
|
.leave = pointer_leave,
|
|
.motion = pointer_motion,
|
|
.button = pointer_button,
|
|
.axis = pointer_axis,
|
|
};
|
|
|
|
/* `wl_keyboard.keymap` callback */
|
|
static void keyboard_keymap(void* data,
|
|
struct wl_keyboard* wl_keyboard,
|
|
MwU32 format,
|
|
int32_t fd,
|
|
MwU32 size) {
|
|
MwLL self = data;
|
|
(void)wl_keyboard;
|
|
|
|
if(self->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
assert(format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1);
|
|
|
|
char* map_shm = (char*)mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
|
|
assert(map_shm != MAP_FAILED);
|
|
|
|
struct xkb_keymap* xkb_keymap = xkb_keymap_new_from_string(
|
|
self->wayland.xkb_context, map_shm, XKB_KEYMAP_FORMAT_TEXT_V1,
|
|
XKB_KEYMAP_COMPILE_NO_FLAGS);
|
|
munmap(map_shm, size);
|
|
close(fd);
|
|
|
|
struct xkb_state* xkb_state = xkb_state_new(xkb_keymap);
|
|
|
|
self->wayland.xkb_keymap = xkb_keymap;
|
|
self->wayland.xkb_state = xkb_state;
|
|
} else {
|
|
self->wayland.xkb_keymap = self->wayland.parent->wayland.xkb_keymap;
|
|
self->wayland.xkb_state = self->wayland.parent->wayland.xkb_state;
|
|
}
|
|
};
|
|
|
|
/* `wl_keyboard.enter` callback */
|
|
static void keyboard_enter(void* data,
|
|
struct wl_keyboard* wl_keyboard,
|
|
MwU32 serial,
|
|
struct wl_surface* surface,
|
|
struct wl_array* keys) {
|
|
MwLL self = data;
|
|
(void)wl_keyboard;
|
|
(void)surface;
|
|
(void)keys;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
self->wayland.keyboard_serial = serial;
|
|
|
|
MwLLDispatch(self, focus_in, NULL);
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_keyboard.leave` callback */
|
|
static void keyboard_leave(void* data,
|
|
struct wl_keyboard* wl_keyboard,
|
|
MwU32 serial,
|
|
struct wl_surface* surface) {
|
|
MwLL self = data;
|
|
(void)wl_keyboard;
|
|
(void)serial;
|
|
(void)surface;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
MwLLDispatch(self, focus_out, NULL);
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_keyboard.key` callback */
|
|
static void keyboard_key(void* data,
|
|
struct wl_keyboard* wl_keyboard,
|
|
MwU32 serial,
|
|
MwU32 time,
|
|
MwU32 key,
|
|
MwU32 state) {
|
|
MwLL self = data;
|
|
MwBool inArea;
|
|
|
|
(void)wl_keyboard;
|
|
(void)serial;
|
|
(void)time;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
if(self->wayland.framebuffer.surface) {
|
|
inArea |= self->wayland.framebuffer.surface == curSurface;
|
|
}
|
|
|
|
if(self->wayland.backbuffer.surface) {
|
|
inArea |= self->wayland.backbuffer.surface == curSurface;
|
|
}
|
|
if(inArea) {
|
|
xkb_layout_index_t layout;
|
|
MwU32 levels;
|
|
xkb_level_index_t level;
|
|
const xkb_keysym_t* syms_out;
|
|
MwU32 keycode = key + 8;
|
|
MwU64 syms_num;
|
|
int i;
|
|
|
|
if(!self->wayland.xkb_keymap) {
|
|
return;
|
|
}
|
|
|
|
layout = xkb_state_key_get_layout(self->wayland.xkb_state, keycode);
|
|
levels =
|
|
xkb_keymap_num_levels_for_key(self->wayland.xkb_keymap, keycode, layout);
|
|
|
|
if((((self->wayland.mod_state & 1) == 1) || ((self->wayland.mod_state & 2) == 2)) && levels >= 2) {
|
|
level = 1;
|
|
} else if(levels >= 1) {
|
|
level = 0;
|
|
}
|
|
syms_num = xkb_keymap_key_get_syms_by_level(self->wayland.xkb_keymap, keycode, layout, level, &syms_out);
|
|
if(syms_out == NULL) {
|
|
return;
|
|
}
|
|
|
|
for(i = 0; i < syms_num; i++) {
|
|
int sym = syms_out[i];
|
|
int key = -1;
|
|
const char* name;
|
|
|
|
switch(sym) {
|
|
case XKB_KEY_BackSpace:
|
|
key = MwLLKeyBackSpace;
|
|
break;
|
|
case XKB_KEY_Left:
|
|
key = MwLLKeyLeft;
|
|
break;
|
|
case XKB_KEY_Right:
|
|
key = MwLLKeyRight;
|
|
break;
|
|
case XKB_KEY_Up:
|
|
key = MwLLKeyUp;
|
|
break;
|
|
case XKB_KEY_Down:
|
|
key = MwLLKeyDown;
|
|
break;
|
|
case XKB_KEY_Return:
|
|
key = MwLLKeyEnter;
|
|
break;
|
|
case XKB_KEY_Escape:
|
|
key = MwLLKeyEscape;
|
|
break;
|
|
case XKB_KEY_Shift_L:
|
|
key = MwLLKeyLeftShift;
|
|
break;
|
|
case XKB_KEY_Shift_R:
|
|
key = MwLLKeyRightShift;
|
|
break;
|
|
case XKB_KEY_Alt_L:
|
|
case XKB_KEY_Alt_R:
|
|
key = MwLLKeyAlt;
|
|
break;
|
|
case XKB_KEY_Control_L:
|
|
case XKB_KEY_Control_R:
|
|
key = MwLLKeyControl;
|
|
break;
|
|
default:
|
|
if(MwStringIsKeyUTF8(sym)) {
|
|
key = sym;
|
|
}
|
|
}
|
|
|
|
if((self->wayland.mod_state & 4) == 4) {
|
|
/* clipboard paste */
|
|
if(key == 'V') {
|
|
int i;
|
|
for(i = 0; i < arrlen(self->wayland.clipboard_devices); i++) {
|
|
wl_clipboard_read(
|
|
self->wayland.clipboard_devices[i]);
|
|
}
|
|
}
|
|
key |= MwLLControlMask;
|
|
}
|
|
if((self->wayland.mod_state & 8) == 8) {
|
|
key |= MwLLAltMask;
|
|
}
|
|
|
|
if(key != -1) {
|
|
if(state == WL_KEYBOARD_KEY_STATE_PRESSED) {
|
|
MwLLDispatch(self, key, &key);
|
|
} else {
|
|
MwLLDispatch(self, key_released, &key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!MwWaylandAlwaysRender) {
|
|
MwLLDispatch(self, draw, NULL);
|
|
}
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `wl_keyboard.modifiers` callback */
|
|
static void keyboard_modifiers(void* data,
|
|
struct wl_keyboard* wl_keyboard,
|
|
MwU32 serial,
|
|
MwU32 mods_depressed,
|
|
MwU32 mods_latched,
|
|
MwU32 mods_locked,
|
|
MwU32 group) {
|
|
MwLL self = data;
|
|
(void)wl_keyboard;
|
|
(void)serial;
|
|
(void)group;
|
|
(void)mods_latched;
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
self->wayland.mod_state = 0;
|
|
self->wayland.mod_state |= mods_depressed;
|
|
self->wayland.mod_state |= mods_locked;
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
struct wl_keyboard_listener keyboard_listener = {
|
|
.keymap = keyboard_keymap,
|
|
.enter = keyboard_enter,
|
|
.leave = keyboard_leave,
|
|
.key = keyboard_key,
|
|
.modifiers = keyboard_modifiers,
|
|
};
|
|
|
|
/* `wl_seat.name` callback */
|
|
static void
|
|
wl_seat_name(void* data, struct wl_seat* wl_seat, const char* name) {
|
|
(void)data;
|
|
(void)wl_seat;
|
|
(void)name;
|
|
};
|
|
|
|
/* `wl_seat.capabilities` callback */
|
|
static void wl_seat_capabilities(void* data, struct wl_seat* wl_seat,
|
|
MwU32 capabilities) {
|
|
MwLL self = data;
|
|
wl_clipboard_device_context_t* device_ctx = malloc(sizeof(wl_clipboard_device_context_t));
|
|
|
|
WAYLAND_EVENT_OP_START(self);
|
|
|
|
if(capabilities & WL_SEAT_CAPABILITY_KEYBOARD) {
|
|
self->wayland.keyboard = wl_seat_get_keyboard(wl_seat);
|
|
wl_keyboard_add_listener(self->wayland.keyboard, &keyboard_listener, data);
|
|
}
|
|
if(capabilities & WL_SEAT_CAPABILITY_POINTER) {
|
|
self->wayland.pointer_seat = wl_seat;
|
|
self->wayland.pointer = wl_seat_get_pointer(wl_seat);
|
|
wl_pointer_add_listener(self->wayland.pointer, &pointer_listener, data);
|
|
}
|
|
|
|
if(self->wayland.clipboard_manager.wl != NULL) {
|
|
if(self->wayland.supports_zwp) {
|
|
device_ctx->device.zwp = zwp_primary_selection_device_manager_v1_get_device(self->wayland.clipboard_manager.zwp, wl_seat);
|
|
} else {
|
|
device_ctx->device.wl = wl_data_device_manager_get_data_device(self->wayland.clipboard_manager.wl, wl_seat);
|
|
}
|
|
device_ctx->ll = self;
|
|
device_ctx->seat = wl_seat;
|
|
device_ctx->capabilities = capabilities;
|
|
|
|
if(self->wayland.supports_zwp) {
|
|
zwp_primary_selection_device_v1_add_listener(device_ctx->device.zwp, &zwp_primary_selection_device_v1_listener, device_ctx);
|
|
} else {
|
|
wl_data_device_add_listener(device_ctx->device.wl, &wl_data_device_listener, device_ctx);
|
|
}
|
|
|
|
arrpush(self->wayland.clipboard_devices, device_ctx);
|
|
}
|
|
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
static void output_geometry(void* data,
|
|
struct wl_output* wl_output,
|
|
int32_t x,
|
|
int32_t y,
|
|
int32_t physical_width,
|
|
int32_t physical_height,
|
|
int32_t subpixel,
|
|
const char* make,
|
|
const char* model,
|
|
int32_t transform) {
|
|
(void)data;
|
|
(void)wl_output;
|
|
(void)x;
|
|
(void)y;
|
|
(void)physical_width;
|
|
(void)physical_height;
|
|
(void)subpixel;
|
|
(void)make;
|
|
(void)model;
|
|
(void)transform;
|
|
};
|
|
static void output_mode(void* data,
|
|
struct wl_output* wl_output,
|
|
uint32_t flags,
|
|
int32_t width,
|
|
int32_t height,
|
|
int32_t refresh) {
|
|
MwLL self = data;
|
|
(void)wl_output;
|
|
(void)flags;
|
|
(void)refresh;
|
|
self->wayland.mw = width;
|
|
self->wayland.mh = height;
|
|
};
|
|
|
|
struct wl_output_listener output_listener = {
|
|
.geometry = output_geometry,
|
|
.mode = output_mode,
|
|
};
|
|
|
|
/* `xdg_wm_base.ping` callback */
|
|
void xdg_wm_base_ping(void* data,
|
|
struct xdg_wm_base* xdg_wm_base,
|
|
MwU32 serial) {
|
|
(void)data;
|
|
xdg_wm_base_pong(xdg_wm_base, serial);
|
|
};
|
|
|
|
/* wl_seat setup function */
|
|
static wayland_protocol_t* wl_seat_setup(MwU32 name, MwLL ll) {
|
|
wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
|
|
proto->listener = malloc(sizeof(struct wl_seat_listener));
|
|
|
|
((struct wl_seat_listener*)proto->listener)->name = wl_seat_name;
|
|
((struct wl_seat_listener*)proto->listener)->capabilities = wl_seat_capabilities;
|
|
|
|
wl_seat_add_listener(wl_registry_bind(ll->wayland.registry, name, &wl_seat_interface, 1), proto->listener, ll);
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void wl_seat_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
free(data->listener);
|
|
}
|
|
|
|
/* wl_output setup function */
|
|
static wayland_protocol_t* wl_output_setup(MwU32 name, MwLL ll) {
|
|
ll->wayland.output = wl_registry_bind(ll->wayland.registry, name, &wl_output_interface, 1);
|
|
wl_output_add_listener(ll->wayland.output, &output_listener, ll);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void wl_output_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
/* wl_compositor setup function */
|
|
static wayland_protocol_t* wl_compositor_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland->compositor = wl_registry_bind(wayland->registry, name, &wl_compositor_interface, 1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void wl_compositor_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
/* wl_subcompositor setup function */
|
|
static wayland_protocol_t* wl_subcompositor_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
if(wayland->type == MWLL_WAYLAND_TOPLEVEL) {
|
|
wayland->toplevel->scompositor = wl_registry_bind(wayland->registry, name, &wl_subcompositor_interface, 1);
|
|
} else {
|
|
wayland->sublevel->subcompositor = wl_registry_bind(wayland->registry, name, &wl_subcompositor_interface, 1);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void wl_subcompositor_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)data;
|
|
wl_subcompositor_destroy(wayland->sublevel->subcompositor);
|
|
}
|
|
|
|
/* xdg_wm_base setup function */
|
|
static wayland_protocol_t* xdg_wm_base_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
|
|
proto->listener = malloc(sizeof(struct xdg_wm_base_listener));
|
|
|
|
((struct xdg_wm_base_listener*)proto->listener)->ping = xdg_wm_base_ping;
|
|
|
|
proto->context = wl_registry_bind(wayland->registry, name, &xdg_wm_base_interface, 1);
|
|
xdg_wm_base_add_listener(proto->context, proto->listener, wayland);
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void xdg_wm_base_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
free(data->listener);
|
|
}
|
|
|
|
/* xdg_wm_base setup function */
|
|
static wayland_protocol_t* wp_viewporter_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
|
|
proto->context = wl_registry_bind(wayland->registry, name, &wp_viewporter_interface, 1);
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void wp_viewporter_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
/* the two decoration manager constructs */
|
|
typedef struct zxdg_decoration_manager_v1_context {
|
|
struct zxdg_decoration_manager_v1* manager;
|
|
struct zxdg_toplevel_decoration_v1* decoration;
|
|
} zxdg_decoration_manager_v1_context_t;
|
|
|
|
/* zxdg_decoration_manager_v1 setup function */
|
|
static wayland_protocol_t* zxdg_decoration_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
|
|
zxdg_decoration_manager_v1_context_t* ctx = malloc(sizeof(zxdg_decoration_manager_v1_context_t));
|
|
proto->listener = NULL;
|
|
|
|
ctx->manager = wl_registry_bind(wayland->registry, name, &zxdg_decoration_manager_v1_interface, 1);
|
|
;
|
|
|
|
proto->context = ctx;
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void zxdg_decoration_manager_v1_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
/* Standard Wayland event loop. */
|
|
static int event_loop(MwLL handle) {
|
|
struct pollfd fd;
|
|
struct timespec timeout;
|
|
struct _MwLLWayland* wayland = &handle->wayland;
|
|
|
|
timeout.tv_nsec = 1;
|
|
timeout.tv_sec = 0;
|
|
|
|
if(wayland->display == NULL) {
|
|
return 0;
|
|
}
|
|
fd.fd = wl_display_get_fd(wayland->display);
|
|
fd.events = POLLIN;
|
|
|
|
/* If an error other than EAGAIN happens, we have likely been disconnected from the Wayland session */
|
|
while(wl_display_flush(wayland->display) == -1) {
|
|
if(errno != EAGAIN) {
|
|
return MwFALSE;
|
|
}
|
|
|
|
while(poll(&fd, 1, -1) == -1) {
|
|
if(errno != EINTR && errno != EAGAIN) {
|
|
wl_display_cancel_read(wayland->display);
|
|
|
|
MwLLDispatch(handle, close, NULL);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
wl_display_prepare_read(handle->wayland.display);
|
|
/* Condition where no events are being sent. */
|
|
if(!poll(&fd, 1, timeout.tv_nsec)) {
|
|
wl_display_cancel_read(wayland->display);
|
|
|
|
update_buffer(handle, &wayland->framebuffer);
|
|
if(wayland->type == MWLL_WAYLAND_TOPLEVEL)
|
|
update_buffer(handle, &wayland->backbuffer);
|
|
return 0;
|
|
}
|
|
wl_display_read_events(wayland->display);
|
|
if(wl_display_dispatch_pending(wayland->display) < 0) {
|
|
wl_display_cancel_read(wayland->display);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* make the fuck sure that we're configurd */
|
|
static void hang_until_configured(MwLL handle) {
|
|
while(!handle->wayland.configured) {
|
|
if(wl_display_roundtrip(handle->wayland.display) == -1) {
|
|
printf("roundtrip failed\n");
|
|
raise(SIGTRAP);
|
|
return;
|
|
}
|
|
event_loop(handle);
|
|
}
|
|
}
|
|
|
|
/* `xdg_toplevel.configure` callback */
|
|
static void xdg_toplevel_configure(void* data,
|
|
struct xdg_toplevel* xdg_toplevel,
|
|
MwI32 width, MwI32 height,
|
|
struct wl_array* states) {
|
|
MwLL self = data;
|
|
(void)states;
|
|
(void)xdg_toplevel;
|
|
|
|
/* Yes, somehow this can get called before */
|
|
if(!self->wayland.configured) {
|
|
return;
|
|
}
|
|
|
|
if(width == 0 || height == 0) {
|
|
width = self->wayland.ww;
|
|
height = self->wayland.wh;
|
|
/* if it's still 0 then bail */
|
|
if(width == 0 || height == 0) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
region_invalidate(self);
|
|
self->wayland.ww = width;
|
|
self->wayland.wh = height;
|
|
|
|
xdg_surface_set_window_geometry(self->wayland.toplevel->xdg_surface, 0, 0, self->wayland.ww, self->wayland.wh);
|
|
|
|
backbuffer_destroy(&self->wayland);
|
|
backbuffer_setup(&self->wayland);
|
|
framebuffer_destroy(&self->wayland);
|
|
framebuffer_setup(&self->wayland);
|
|
|
|
region_setup(self);
|
|
MwLLDispatch(self, resize, NULL);
|
|
|
|
recursive_dispatch_resize(self);
|
|
|
|
if(self->wayland.pointer_constrained) {
|
|
zwp_locked_pointer_v1_set_cursor_position_hint(self->wayland.locked_pointer, 0, CSD_BORDER_FRAME_TOP);
|
|
wl_surface_commit(self->wayland.framebuffer.surface);
|
|
}
|
|
};
|
|
|
|
/* `xdg_surface.close` callback */
|
|
static void xdg_toplevel_close(
|
|
void* data, struct xdg_toplevel* xdg_toplevel) {
|
|
MwLL self = data;
|
|
(void)xdg_toplevel;
|
|
WAYLAND_EVENT_OP_START(self);
|
|
MwLLDispatch(self, close, NULL);
|
|
WAYLAND_EVENT_OP_END(self);
|
|
};
|
|
|
|
/* `xdg_surface.configure` callback */
|
|
static void xdg_surface_configure(
|
|
void* data, struct xdg_surface* xdg_surface, MwU32 serial) {
|
|
MwLL self = data;
|
|
|
|
xdg_surface_ack_configure(xdg_surface, serial);
|
|
|
|
MwLLDispatch(self, draw, NULL);
|
|
|
|
if(self->wayland.configured) {
|
|
update_buffer(self, &self->wayland.framebuffer);
|
|
update_buffer(self, &self->wayland.backbuffer);
|
|
}
|
|
|
|
self->wayland.configured = MwTRUE;
|
|
}
|
|
|
|
/* wl_shm setup function */
|
|
static wayland_protocol_t* wl_shm_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland->framebuffer.shm = wl_registry_bind(wayland->registry, name, &wl_shm_interface, 1);
|
|
wayland->backbuffer.shm = wl_registry_bind(wayland->registry, name, &wl_shm_interface, 1);
|
|
wayland->cursor.shm = wl_registry_bind(wayland->registry, name, &wl_shm_interface, 1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void wl_shm_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
(void)data;
|
|
}
|
|
|
|
static void update_buffer(MwLL self, struct _MwLLWaylandShmBuffer* buffer) {
|
|
(void)self;
|
|
memcpy(buffer->buf, buffer->buf_back, buffer->buf_size);
|
|
|
|
// Yes this is needed every time, it's how we fix weston.
|
|
wl_surface_attach(buffer->surface, buffer->shm_buffer, 0, 0);
|
|
|
|
wl_surface_commit(buffer->surface);
|
|
}
|
|
|
|
static void buffer_setup(struct _MwLLWaylandShmBuffer* buffer, MwU32 width, MwU32 height) {
|
|
int stride = width * 4;
|
|
char temp_name[] = "/tmp/milsko-wl-shm-XXXXXX";
|
|
char temp_name_back[] = "/tmp/milsko-wl-shm-back-XXXXXX";
|
|
|
|
buffer->buf_size = (width * height * 4) * sizeof(MwU32);
|
|
|
|
buffer->fd = mkstemp(temp_name);
|
|
|
|
unlink(temp_name);
|
|
unlink(temp_name_back);
|
|
|
|
if(posix_fallocate(buffer->fd, 0, buffer->buf_size) != 0) {
|
|
printf("failure setting up wl_shm: could not fallocate. %s.\n", strerror(errno));
|
|
close(buffer->fd);
|
|
return;
|
|
}
|
|
if(ftruncate(buffer->fd, buffer->buf_size) != 0) {
|
|
printf("failure setting up wl_shm: could not truncate. %s.\n", strerror(errno));
|
|
close(buffer->fd);
|
|
return;
|
|
}
|
|
|
|
buffer->buf = mmap(NULL, buffer->buf_size, PROT_WRITE, MAP_SHARED, buffer->fd, 0);
|
|
buffer->buf_back = malloc(buffer->buf_size);
|
|
|
|
fsync(buffer->fd);
|
|
|
|
if(!(buffer->shm_pool = wl_shm_create_pool(buffer->shm, buffer->fd, buffer->buf_size))) {
|
|
printf("failure setting up wl_shm: could not create pool.\n");
|
|
}
|
|
buffer->shm_buffer = wl_shm_pool_create_buffer(buffer->shm_pool, 0, width, height, stride, WL_SHM_FORMAT_ARGB8888);
|
|
|
|
buffer->pixman_fb = pixman_image_create_bits(PIXMAN_a8r8g8b8,
|
|
width, height, buffer->buf_back, stride);
|
|
|
|
buffer->width = width;
|
|
buffer->height = height;
|
|
|
|
buffer->setup = MwTRUE;
|
|
}
|
|
|
|
static void buffer_destroy(struct _MwLLWaylandShmBuffer* buffer) {
|
|
if(!buffer->setup) {
|
|
return;
|
|
}
|
|
if(buffer->shm_buffer) wl_buffer_destroy(buffer->shm_buffer);
|
|
if(buffer->shm_pool) wl_shm_pool_destroy(buffer->shm_pool);
|
|
munmap(buffer->buf, buffer->buf_size);
|
|
free(buffer->buf_back);
|
|
close(buffer->fd);
|
|
pixman_image_unref(buffer->pixman_fb);
|
|
|
|
buffer->setup = MwFALSE;
|
|
}
|
|
|
|
static void framebuffer_setup(struct _MwLLWayland* wayland) {
|
|
buffer_setup(&wayland->framebuffer, wayland->ww, wayland->wh);
|
|
|
|
memset(wayland->framebuffer.buf_back, 0, wayland->framebuffer.buf_size);
|
|
wl_surface_attach(wayland->framebuffer.surface, wayland->framebuffer.shm_buffer, 0, 0);
|
|
wl_surface_commit(wayland->framebuffer.surface);
|
|
|
|
hang_until_configured((MwLL)wayland);
|
|
update_buffer((MwLL)wayland, &wayland->framebuffer);
|
|
};
|
|
static void framebuffer_destroy(struct _MwLLWayland* wayland) {
|
|
buffer_destroy(&wayland->framebuffer);
|
|
};
|
|
|
|
static void backbuffer_setup(struct _MwLLWayland* wayland) {
|
|
if(wayland->type != MWLL_WAYLAND_TOPLEVEL) {
|
|
return;
|
|
}
|
|
MwU32 w = wayland->ww;
|
|
MwU32 h = wayland->wh;
|
|
if(!wayland->has_decorations) {
|
|
w += (CSD_BORDER_FRAME_LEFT + CSD_BORDER_FRAME_RIGHT);
|
|
h += (CSD_BORDER_FRAME_TOP + CSD_BORDER_FRAME_BOTTOM);
|
|
}
|
|
buffer_setup(&wayland->backbuffer, w, h);
|
|
|
|
memset(wayland->backbuffer.buf_back, 255, wayland->backbuffer.buf_size);
|
|
wl_surface_attach(wayland->backbuffer.surface, wayland->backbuffer.shm_buffer, 0, 0);
|
|
wl_surface_commit(wayland->backbuffer.surface);
|
|
hang_until_configured((MwLL)wayland);
|
|
update_buffer((MwLL)wayland, &wayland->backbuffer);
|
|
};
|
|
static void backbuffer_destroy(struct _MwLLWayland* wayland) {
|
|
buffer_destroy(&wayland->backbuffer);
|
|
};
|
|
|
|
static void region_invalidate(MwLL handle) {
|
|
if(!handle->wayland.configured) {
|
|
return;
|
|
}
|
|
wl_region_subtract(handle->wayland.region, 0, 0, handle->wayland.ww, handle->wayland.wh);
|
|
}
|
|
static void region_setup(MwLL handle) {
|
|
MwLL parent = handle->wayland.parent;
|
|
int width = handle->wayland.ww;
|
|
int height = handle->wayland.wh;
|
|
|
|
if(!handle->wayland.configured) {
|
|
return;
|
|
}
|
|
|
|
wl_region_add(handle->wayland.o_region, 0, 0, width, height);
|
|
|
|
if(handle->wayland.type == MWLL_WAYLAND_POPUP) {
|
|
wl_region_add(handle->wayland.region, 0, 0, width + abs(handle->wayland.x), height + abs(handle->wayland.y));
|
|
} else {
|
|
if(parent) {
|
|
if(width - handle->wayland.x > parent->wayland.ww) {
|
|
width = parent->wayland.ww - handle->wayland.x;
|
|
}
|
|
if(height - handle->wayland.y > parent->wayland.wh) {
|
|
height = parent->wayland.wh - handle->wayland.y;
|
|
}
|
|
} else {
|
|
if(!handle->wayland.has_decorations) {
|
|
width += CSD_BORDER_FRAME_LEFT + CSD_BORDER_FRAME_RIGHT;
|
|
height += CSD_BORDER_FRAME_TOP + CSD_BORDER_FRAME_BOTTOM;
|
|
}
|
|
}
|
|
wl_region_add(handle->wayland.region, 0, 0, width, height);
|
|
}
|
|
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
wl_surface_set_opaque_region(handle->wayland.backbuffer.surface, handle->wayland.o_region);
|
|
wl_surface_set_input_region(handle->wayland.backbuffer.surface, handle->wayland.region);
|
|
}
|
|
wl_surface_set_opaque_region(handle->wayland.framebuffer.surface, handle->wayland.o_region);
|
|
wl_surface_set_input_region(handle->wayland.framebuffer.surface, handle->wayland.region);
|
|
}
|
|
|
|
static wayland_protocol_t* xdg_toplevel_icon_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
|
|
wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
|
|
|
|
proto->context = wl_registry_bind(wayland->registry, name, &xdg_toplevel_icon_manager_v1_interface, 1);
|
|
proto->listener = NULL;
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void xdg_toplevel_icon_manager_v1_interface_destroy(struct _MwLLWayland* wayland, wayland_protocol_t* data) {
|
|
(void)wayland;
|
|
free(data->listener);
|
|
}
|
|
|
|
/* Function for setting up the callbacks/structs that will be registered upon the relevant interfaces being found. */
|
|
static void setup_callbacks(struct _MwLLWayland* wayland) {
|
|
/* Convience macro for adding the interface functions to the setup map */
|
|
#define WL_INTERFACE(interface) \
|
|
do { \
|
|
wayland_protocol_callback_table_t* cb = malloc(sizeof(wayland_protocol_callback_table_t)); \
|
|
cb->setup = (wl_setup_func*)interface##_setup; \
|
|
cb->destroy = (wl_destroy_func*)interface##_interface_destroy; \
|
|
shput(wayland->wl_protocol_setup_map, interface##_interface.name, cb); \
|
|
} while(0);
|
|
|
|
wayland->registry_listener.global = new_protocol;
|
|
wayland->registry_listener.global_remove = protocol_removed;
|
|
wayland->wl_protocol_setup_map = NULL;
|
|
wayland->wl_protocol_map = NULL;
|
|
|
|
WL_INTERFACE(wl_shm);
|
|
WL_INTERFACE(wl_compositor);
|
|
WL_INTERFACE(wl_seat);
|
|
WL_INTERFACE(wl_output);
|
|
WL_INTERFACE(wl_data_device_manager);
|
|
WL_INTERFACE(zwp_primary_selection_device_manager_v1);
|
|
WL_INTERFACE(zwp_pointer_constraints_v1);
|
|
WL_INTERFACE(zwp_relative_pointer_manager_v1);
|
|
WL_INTERFACE(xdg_wm_base);
|
|
if(wayland->type == MWLL_WAYLAND_TOPLEVEL) {
|
|
WL_INTERFACE(wp_viewporter);
|
|
WL_INTERFACE(zxdg_decoration_manager_v1);
|
|
WL_INTERFACE(xdg_toplevel_icon_manager_v1);
|
|
WL_INTERFACE(wl_subcompositor);
|
|
} else if(wayland->type == MWLL_WAYLAND_POPUP) {
|
|
} else {
|
|
WL_INTERFACE(wl_subcompositor);
|
|
}
|
|
#undef WL_INTERFACE
|
|
}
|
|
|
|
/* Toplevel setup function */
|
|
static void setup_toplevel(MwLL r, int x, int y) {
|
|
r->wayland.type = MWLL_WAYLAND_TOPLEVEL;
|
|
r->wayland.toplevel = malloc(sizeof(struct _MwLLWaylandTopLevel));
|
|
r->wayland.x = x;
|
|
r->wayland.y = y;
|
|
|
|
setup_callbacks(&r->wayland);
|
|
|
|
/* Connect to the Wayland compositor */
|
|
r->wayland.display = wl_display_connect(NULL);
|
|
if(r->wayland.display == NULL) {
|
|
printf("wayland: failed to create display\n");
|
|
raise(SIGTRAP);
|
|
return;
|
|
}
|
|
|
|
/* Do a roundtrip to ensure all interfaces are setup. */
|
|
r->wayland.registry = wl_display_get_registry(r->wayland.display);
|
|
wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
|
|
if(wl_display_roundtrip(r->wayland.display) == -1) {
|
|
printf("roundtrip failed\n");
|
|
raise(SIGTRAP);
|
|
return;
|
|
}
|
|
|
|
/* check now if we have decorations so that everything else can act accordingly */
|
|
if(shget(r->wayland.wl_protocol_map, zxdg_decoration_manager_v1_interface.name) != NULL) {
|
|
r->wayland.has_decorations = MwTRUE;
|
|
}
|
|
|
|
r->wayland.xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
|
|
|
|
/* Create a wl_surface, a xdg_surface and a xdg_toplevel */
|
|
r->wayland.framebuffer.surface = wl_compositor_create_surface(r->wayland.compositor);
|
|
r->wayland.backbuffer.surface = wl_compositor_create_surface(r->wayland.compositor);
|
|
r->wayland.toplevel->ssurface = wl_subcompositor_get_subsurface(r->wayland.toplevel->scompositor, r->wayland.framebuffer.surface, r->wayland.backbuffer.surface);
|
|
wl_subsurface_set_desync(r->wayland.toplevel->ssurface);
|
|
|
|
r->wayland.toplevel->xdg_surface =
|
|
xdg_wm_base_get_xdg_surface(WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context, r->wayland.backbuffer.surface);
|
|
r->wayland.toplevel->xdg_top_level = xdg_surface_get_toplevel(r->wayland.toplevel->xdg_surface);
|
|
|
|
/* setup mandatory listeners */
|
|
r->wayland.toplevel->xdg_surface_listener.configure = xdg_surface_configure;
|
|
|
|
r->wayland.toplevel->xdg_toplevel_listener.configure = xdg_toplevel_configure;
|
|
r->wayland.toplevel->xdg_toplevel_listener.close = xdg_toplevel_close;
|
|
|
|
xdg_surface_add_listener(r->wayland.toplevel->xdg_surface, &r->wayland.toplevel->xdg_surface_listener, r);
|
|
xdg_toplevel_add_listener(r->wayland.toplevel->xdg_top_level, &r->wayland.toplevel->xdg_toplevel_listener,
|
|
r);
|
|
|
|
xdg_toplevel_set_title(r->wayland.toplevel->xdg_top_level, "Milsko App");
|
|
xdg_toplevel_set_app_id(r->wayland.toplevel->xdg_top_level, "MilskoWaylandApp");
|
|
|
|
/* Perform the initial commit and wait for the first configure event */
|
|
wl_surface_commit(r->wayland.backbuffer.surface);
|
|
wl_surface_commit(r->wayland.framebuffer.surface);
|
|
while(!r->wayland.configured) {
|
|
event_loop(r);
|
|
}
|
|
|
|
/* setup decorations if we can */
|
|
if(r->wayland.has_decorations) {
|
|
zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(r->wayland, zxdg_decoration_manager_v1)->context;
|
|
|
|
dec->decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
|
|
dec->manager, r->wayland.toplevel->xdg_top_level);
|
|
|
|
zxdg_toplevel_decoration_v1_set_mode(
|
|
dec->decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
|
|
} else {
|
|
wl_subsurface_set_position(r->wayland.toplevel->ssurface, CSD_BORDER_FRAME_LEFT, CSD_BORDER_FRAME_TOP);
|
|
}
|
|
}
|
|
|
|
/* Toplevel destroy function */
|
|
static void destroy_toplevel(MwLL r) {
|
|
if(shget(r->wayland.wl_protocol_map, zxdg_decoration_manager_v1_interface.name) != NULL) {
|
|
zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(r->wayland, zxdg_decoration_manager_v1)->context;
|
|
zxdg_decoration_manager_v1_destroy(dec->manager);
|
|
}
|
|
|
|
wl_surface_destroy(r->wayland.framebuffer.surface);
|
|
|
|
wl_compositor_destroy(r->wayland.compositor);
|
|
|
|
xdg_surface_destroy(r->wayland.toplevel->xdg_surface);
|
|
|
|
xdg_toplevel_destroy(r->wayland.toplevel->xdg_top_level);
|
|
|
|
xkb_keymap_unref(r->wayland.xkb_keymap);
|
|
|
|
xkb_state_unref(r->wayland.xkb_state);
|
|
|
|
xkb_context_unref(r->wayland.xkb_context);
|
|
|
|
free(r->wayland.toplevel);
|
|
|
|
wl_registry_destroy(r->wayland.registry);
|
|
|
|
wl_display_disconnect(r->wayland.display);
|
|
|
|
r->wayland.configured = MwFALSE;
|
|
}
|
|
|
|
/* Sublevel setup function */
|
|
static void setup_sublevel(MwLL parent, MwLL r, int x, int y) {
|
|
struct wl_compositor* compositor = parent->wayland.compositor;
|
|
struct wl_surface* parent_surface = parent->wayland.framebuffer.surface;
|
|
|
|
r->wayland.sublevel = malloc(sizeof(struct _MwLLWaylandSublevel));
|
|
r->wayland.sublevel->parent = parent;
|
|
|
|
r->wayland.type = MWLL_WAYLAND_SUBLEVEL;
|
|
|
|
r->wayland.display = parent->wayland.display;
|
|
|
|
setup_callbacks(&r->wayland);
|
|
|
|
r->wayland.registry = wl_display_get_registry(parent->wayland.display);
|
|
r->wayland.display = parent->wayland.display;
|
|
|
|
if(parent->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
r->wayland.sublevel->xdg_surface = parent->wayland.toplevel->xdg_surface;
|
|
} else {
|
|
r->wayland.sublevel->xdg_surface = parent->wayland.sublevel->xdg_surface;
|
|
}
|
|
|
|
wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
|
|
if(wl_display_roundtrip(r->wayland.display) == -1) {
|
|
printf("roundtrip failed\n");
|
|
raise(SIGTRAP);
|
|
return;
|
|
}
|
|
|
|
r->wayland.framebuffer.surface = wl_compositor_create_surface(compositor);
|
|
|
|
r->wayland.sublevel->subsurface = wl_subcompositor_get_subsurface(r->wayland.sublevel->subcompositor, r->wayland.framebuffer.surface, parent_surface);
|
|
|
|
wl_subsurface_set_desync(r->wayland.sublevel->subsurface);
|
|
wl_subsurface_set_position(r->wayland.sublevel->subsurface, x, y);
|
|
|
|
if(parent) {
|
|
wl_subsurface_place_above(r->wayland.sublevel->subsurface, parent->wayland.framebuffer.surface);
|
|
}
|
|
|
|
r->wayland.xkb_keymap = parent->wayland.xkb_keymap;
|
|
r->wayland.xkb_state = parent->wayland.xkb_state;
|
|
|
|
r->wayland.configured = MwTRUE;
|
|
}
|
|
|
|
/* Sublevel setup function */
|
|
static void destroy_sublevel(MwLL r) {
|
|
backbuffer_destroy(&r->wayland);
|
|
framebuffer_destroy(&r->wayland);
|
|
|
|
wl_subsurface_destroy(r->wayland.sublevel->subsurface);
|
|
|
|
free(r->wayland.sublevel);
|
|
|
|
r->wayland.configured = MwFALSE;
|
|
}
|
|
|
|
static void popup_configure(void* data,
|
|
struct xdg_popup* xdg_popup,
|
|
int32_t x,
|
|
int32_t y,
|
|
int32_t width,
|
|
int32_t height) {
|
|
MwLL self = data;
|
|
(void)xdg_popup;
|
|
|
|
self->wayland.x = x;
|
|
self->wayland.y = y;
|
|
self->wayland.ww = width;
|
|
self->wayland.wh = height;
|
|
};
|
|
|
|
static void popup_done(void* data,
|
|
struct xdg_popup* xdg_popup) {
|
|
(void)data;
|
|
(void)xdg_popup;
|
|
};
|
|
|
|
struct xdg_popup_listener popup_listener = {
|
|
.configure = popup_configure,
|
|
.popup_done = popup_done,
|
|
};
|
|
|
|
/* Popup setup function */
|
|
static void setup_popup(MwLL r, int x, int y, MwLL parent) {
|
|
struct xdg_surface* xdg_surface;
|
|
MwLL topmost_parent = r->wayland.parent;
|
|
|
|
r->wayland.type = MWLL_WAYLAND_POPUP;
|
|
r->wayland.x = x;
|
|
r->wayland.y = y;
|
|
r->wayland.popup = malloc(sizeof(struct _MwLLWaylandPopup));
|
|
|
|
while(topmost_parent->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
|
|
topmost_parent = topmost_parent->wayland.parent;
|
|
}
|
|
if(!topmost_parent->wayland.has_decorations) {
|
|
r->wayland.x += ceil((float)CSD_BORDER_FRAME_LEFT / 2.);
|
|
r->wayland.y += ceil((float)CSD_BORDER_FRAME_TOP / 2.);
|
|
}
|
|
|
|
setup_callbacks(&r->wayland);
|
|
|
|
/* Connect to the Wayland compositor */
|
|
r->wayland.display = parent->wayland.display;
|
|
|
|
/* Do a roundtrip to ensure all interfaces are setup. */
|
|
r->wayland.registry = wl_display_get_registry(r->wayland.display);
|
|
wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
|
|
if(wl_display_roundtrip(r->wayland.display) == -1) {
|
|
printf("roundtrip failed\n");
|
|
raise(SIGTRAP);
|
|
return;
|
|
}
|
|
|
|
/* check now if we have decorations so that everything else can act accordingly */
|
|
if(shget(r->wayland.wl_protocol_map, zxdg_decoration_manager_v1_interface.name) != NULL) {
|
|
r->wayland.has_decorations = MwTRUE;
|
|
}
|
|
|
|
r->wayland.popup->xdg_wm_base = WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context;
|
|
|
|
r->wayland.popup->xdg_positioner = xdg_wm_base_create_positioner(r->wayland.popup->xdg_wm_base);
|
|
|
|
xdg_positioner_set_size(r->wayland.popup->xdg_positioner, r->wayland.ww, r->wayland.wh);
|
|
xdg_positioner_set_anchor_rect(
|
|
r->wayland.popup->xdg_positioner,
|
|
r->wayland.x, r->wayland.y, r->wayland.ww, r->wayland.wh);
|
|
|
|
xdg_surface = topmost_parent->wayland.toplevel->xdg_surface;
|
|
r->wayland.xkb_keymap = topmost_parent->wayland.xkb_keymap;
|
|
r->wayland.xkb_state = topmost_parent->wayland.xkb_state;
|
|
|
|
r->wayland.framebuffer.surface = wl_compositor_create_surface(r->wayland.compositor);
|
|
|
|
r->wayland.popup->xdg_surface =
|
|
xdg_wm_base_get_xdg_surface(WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context, r->wayland.framebuffer.surface);
|
|
|
|
r->wayland.popup->xdg_popup = xdg_surface_get_popup(
|
|
r->wayland.popup->xdg_surface,
|
|
xdg_surface,
|
|
r->wayland.popup->xdg_positioner);
|
|
|
|
xdg_popup_add_listener(r->wayland.popup->xdg_popup, &popup_listener, r);
|
|
|
|
r->wayland.popup->xdg_surface_listener.configure = xdg_surface_configure;
|
|
xdg_surface_add_listener(r->wayland.popup->xdg_surface, &r->wayland.popup->xdg_surface_listener, r);
|
|
|
|
/* Perform the initial commit and wait for the first configure event */
|
|
wl_surface_commit(r->wayland.framebuffer.surface);
|
|
while(!r->wayland.configured) {
|
|
event_loop(r);
|
|
}
|
|
}
|
|
|
|
/* Popup destroy function */
|
|
static void destroy_popup(MwLL r) {
|
|
xdg_popup_destroy(r->wayland.popup->xdg_popup);
|
|
|
|
xdg_surface_destroy(r->wayland.popup->xdg_surface);
|
|
|
|
xdg_positioner_destroy(r->wayland.popup->xdg_positioner);
|
|
|
|
wl_surface_destroy(r->wayland.framebuffer.surface);
|
|
|
|
wl_registry_destroy(r->wayland.registry);
|
|
|
|
r->wayland.configured = MwFALSE;
|
|
}
|
|
|
|
static void wl_logger(const char* fmt, va_list args) {
|
|
vprintf(fmt, args);
|
|
raise(SIGTRAP);
|
|
}
|
|
|
|
static void widget_setup(MwLL r, MwLL parent, int x, int y, int width, int height, enum _MwLLWaylandType ty) {
|
|
/* Wayland does not report global coordinates ever. Compositors are not even expected to have knowledge of this.
|
|
*/
|
|
r->common.coordinate_type = MwCoordinatesLocal;
|
|
|
|
r->common.type = MwLLBackendWayland;
|
|
|
|
if(width < 2) width = 2;
|
|
if(height < 2) height = 2;
|
|
|
|
if(x == MwDEFAULT) {
|
|
x = 0;
|
|
}
|
|
if(y == MwDEFAULT) {
|
|
y = 0;
|
|
}
|
|
|
|
r->wayland.ww = width;
|
|
r->wayland.wh = height;
|
|
r->wayland.x = x;
|
|
r->wayland.y = y;
|
|
r->wayland.parent = parent;
|
|
|
|
if(ty == MWLL_WAYLAND_UNKNOWN) {
|
|
if(parent == NULL) {
|
|
setup_toplevel(r, x, y);
|
|
} else {
|
|
setup_sublevel(parent, r, x, y);
|
|
}
|
|
} else {
|
|
switch(ty) {
|
|
case MWLL_WAYLAND_UNKNOWN:
|
|
break;
|
|
case MWLL_WAYLAND_TOPLEVEL:
|
|
setup_toplevel(r, x, y);
|
|
break;
|
|
case MWLL_WAYLAND_SUBLEVEL:
|
|
setup_sublevel(parent, r, x, y);
|
|
break;
|
|
case MWLL_WAYLAND_POPUP:
|
|
setup_popup(r, x, y, parent);
|
|
break;
|
|
}
|
|
}
|
|
|
|
framebuffer_setup(&r->wayland);
|
|
backbuffer_setup(&r->wayland);
|
|
|
|
r->wayland.region = wl_compositor_create_region(r->wayland.compositor);
|
|
r->wayland.o_region = wl_compositor_create_region(r->wayland.compositor);
|
|
region_setup(r);
|
|
|
|
MwLLForceRender(r);
|
|
if(parent != NULL) {
|
|
MwLLForceRender(parent);
|
|
}
|
|
|
|
if(!r->wayland.has_decorations) {
|
|
MwLLBeginDraw(r);
|
|
MwLLEndDraw(r);
|
|
}
|
|
}
|
|
static MwLL MwLLCreateImpl(MwLL parent, int x, int y, int width, int height) {
|
|
MwLL r;
|
|
r = malloc(sizeof(*r));
|
|
memset(r, 0, sizeof(*r));
|
|
MwLLCreateCommon(r);
|
|
|
|
widget_setup(r, parent, x, y, width, height, MWLL_WAYLAND_UNKNOWN);
|
|
|
|
return r;
|
|
}
|
|
|
|
static void MwLLDestroyImpl(MwLL handle) {
|
|
int i;
|
|
struct timeval tv;
|
|
struct timespec t = {
|
|
.tv_sec = 0,
|
|
.tv_nsec = 0,
|
|
};
|
|
int select_ret;
|
|
|
|
if(pthread_mutex_timedlock(&handle->wayland.eventsMutex, &t) != 0) {
|
|
printf("WARNING: Couldn't call MwLLDestroyImpl due to deadlock.\n");
|
|
return;
|
|
};
|
|
|
|
MwLLDestroyCommon(handle);
|
|
|
|
event_loop(handle);
|
|
|
|
/* sleep long enough that any active attempts to wait for the mutex will have given up and we can safely unlock/destroy it */
|
|
tv.tv_sec = 0;
|
|
tv.tv_usec = 1000;
|
|
do {
|
|
select_ret = select(1, NULL, NULL, NULL, &tv);
|
|
} while((select_ret == -1) && (errno == EINTR));
|
|
|
|
pthread_mutex_unlock(&handle->wayland.eventsMutex);
|
|
pthread_mutex_destroy(&handle->wayland.eventsMutex);
|
|
|
|
// framebuffer_destroy(&handle->wayland);
|
|
buffer_destroy(&handle->wayland.cursor);
|
|
wl_region_destroy(handle->wayland.region);
|
|
|
|
if(handle->wayland.supports_zwp) {
|
|
zwp_primary_selection_source_v1_destroy(handle->wayland.clipboard_source.zwp);
|
|
} else {
|
|
wl_data_source_destroy(handle->wayland.clipboard_source.wl);
|
|
}
|
|
if(handle->wayland.icon != NULL) {
|
|
buffer_destroy(handle->wayland.icon);
|
|
wl_surface_destroy(handle->wayland.icon->surface);
|
|
}
|
|
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
destroy_toplevel(handle);
|
|
} else if(handle->wayland.type == MWLL_WAYLAND_SUBLEVEL) {
|
|
destroy_sublevel(handle);
|
|
} else if(handle->wayland.type == MWLL_WAYLAND_POPUP) {
|
|
destroy_popup(handle);
|
|
}
|
|
|
|
for(i = 0; i < shlen(handle->wayland.wl_protocol_setup_map); i++) {
|
|
void* ctx = shget(handle->wayland.wl_protocol_map, handle->wayland.wl_protocol_setup_map[i].key);
|
|
|
|
if(ctx != NULL) {
|
|
handle->wayland.wl_protocol_setup_map[i].value->destroy(&handle->wayland, ctx);
|
|
}
|
|
shdel(handle->wayland.wl_protocol_map, handle->wayland.wl_protocol_setup_map[i].value);
|
|
}
|
|
shfree(handle->wayland.wl_protocol_map);
|
|
shfree(handle->wayland.wl_protocol_setup_map);
|
|
|
|
free(handle);
|
|
|
|
if(currentlyHeldWidget == handle) {
|
|
currentlyHeldWidget = NULL;
|
|
}
|
|
}
|
|
|
|
static void MwLLGetXYWHImpl(MwLL handle, int* x, int* y, unsigned int* w, unsigned int* h) {
|
|
*x = handle->wayland.x;
|
|
*y = handle->wayland.y;
|
|
*w = handle->wayland.ww;
|
|
*h = handle->wayland.wh;
|
|
}
|
|
|
|
static void MwLLSetXYImpl(MwLL handle, int x, int y) {
|
|
region_invalidate(handle);
|
|
handle->wayland.x = x;
|
|
handle->wayland.y = y;
|
|
if(handle->wayland.type == MWLL_WAYLAND_SUBLEVEL) {
|
|
wl_subsurface_set_position(handle->wayland.sublevel->subsurface, x, y);
|
|
}
|
|
region_setup(handle);
|
|
|
|
MwLLDispatch(handle, draw, NULL);
|
|
}
|
|
|
|
static void MwLLSetWHImpl(MwLL handle, int w, int h) {
|
|
region_invalidate(handle);
|
|
|
|
/* Prevent an integer underflow when the w/h is too low */
|
|
if((w < 2 || h < 2)) {
|
|
handle->wayland.ww = 2;
|
|
handle->wayland.wh = 2;
|
|
} else {
|
|
handle->wayland.ww = w;
|
|
handle->wayland.wh = h;
|
|
}
|
|
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL && handle->wayland.configured) {
|
|
xdg_surface_set_window_geometry(handle->wayland.toplevel->xdg_surface, 0, 0, handle->wayland.ww, handle->wayland.wh);
|
|
}
|
|
|
|
if(handle->wayland.type == MWLL_WAYLAND_SUBLEVEL && handle->wayland.configured && !handle->wayland.dispatching_resize) {
|
|
handle->wayland.dispatching_resize = MwTRUE;
|
|
MwLLDispatch(handle, resize, NULL);
|
|
handle->wayland.dispatching_resize = MwFALSE;
|
|
}
|
|
|
|
if(handle->wayland.type == MWLL_WAYLAND_POPUP) {
|
|
destroy_popup(handle);
|
|
wl_flush(handle);
|
|
setup_popup(handle, handle->wayland.x, handle->wayland.y, handle->wayland.parent);
|
|
}
|
|
|
|
refresh:
|
|
region_setup(handle);
|
|
|
|
framebuffer_destroy(&handle->wayland);
|
|
framebuffer_setup(&handle->wayland);
|
|
backbuffer_destroy(&handle->wayland);
|
|
backbuffer_setup(&handle->wayland);
|
|
MwLLDispatch(handle, draw, NULL);
|
|
handle->wayland.events_pending = 1;
|
|
}
|
|
|
|
static void MwLLBeginDrawImpl(MwLL handle) {
|
|
if(handle->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
|
|
// handle->wayland.selected_cairo = handle->wayland.front_cairo;
|
|
return;
|
|
}
|
|
|
|
if(!handle->wayland.has_decorations) {
|
|
int x;
|
|
MwU32 w = handle->wayland.ww + CSD_BORDER_FRAME_LEFT + CSD_BORDER_FRAME_RIGHT;
|
|
MwU32 h = handle->wayland.wh + CSD_BORDER_FRAME_TOP + CSD_BORDER_FRAME_BOTTOM;
|
|
// cairo_set_line_width(handle->wayland.back_cairo, 4.0);
|
|
// for(x = 0; x < w; x++) {
|
|
// float placeholder = (float)x / (float)w;
|
|
// cairo_set_source_rgb(handle->wayland.back_cairo, placeholder, 0.25, 0.25);
|
|
|
|
// cairo_move_to(handle->wayland.back_cairo, w - x, 0);
|
|
// cairo_line_to(handle->wayland.back_cairo, w - x, CSD_BORDER_FRAME_TOP);
|
|
// cairo_stroke(handle->wayland.back_cairo);
|
|
|
|
// cairo_move_to(handle->wayland.back_cairo, x, CSD_BORDER_FRAME_TOP);
|
|
// cairo_line_to(handle->wayland.back_cairo, x, h);
|
|
// cairo_stroke(handle->wayland.back_cairo);
|
|
// }
|
|
// cairo_set_source_rgba(handle->wayland.back_cairo, 1, 1, 1, 0.5);
|
|
// cairo_move_to(handle->wayland.back_cairo, 0, 0);
|
|
// cairo_line_to(handle->wayland.back_cairo, 0, h);
|
|
// cairo_stroke(handle->wayland.back_cairo);
|
|
// cairo_move_to(handle->wayland.back_cairo, 0, 0);
|
|
// cairo_line_to(handle->wayland.back_cairo, w, 0);
|
|
// cairo_stroke(handle->wayland.back_cairo);
|
|
|
|
// cairo_set_source_rgba(handle->wayland.back_cairo, 0, 0, 0, 0.5);
|
|
// cairo_move_to(handle->wayland.back_cairo, 0, h);
|
|
// cairo_line_to(handle->wayland.back_cairo, w, h);
|
|
// cairo_stroke(handle->wayland.back_cairo);
|
|
// cairo_move_to(handle->wayland.back_cairo, w, 0);
|
|
// cairo_line_to(handle->wayland.back_cairo, w, h);
|
|
// cairo_stroke(handle->wayland.back_cairo);
|
|
|
|
if(strlen(handle->wayland.title) != 0) {
|
|
int y, x;
|
|
int i = 0, sx = 0, sy = 0;
|
|
int tw, th;
|
|
unsigned char* px;
|
|
MwRect r;
|
|
MwLLPixmap p;
|
|
tw = strlen(handle->wayland.title) * 7;
|
|
th = 14;
|
|
px = malloc(tw * th * 4);
|
|
assert(px);
|
|
|
|
memset(px, 0, tw * th * 4);
|
|
|
|
// handle->wayland.selected_cairo = handle->wayland.back_cairo;
|
|
|
|
while(handle->wayland.title[i]) {
|
|
int out;
|
|
i += MwUTF8ToUTF32(handle->wayland.title + i, &out);
|
|
|
|
if(out > 0xff) {
|
|
out = 0;
|
|
}
|
|
|
|
for(y = 0; y < 14; y++) {
|
|
for(x = 0; x < 7; x++) {
|
|
unsigned char* ppx = &px[((sy + y) * tw + sx + x) * 4];
|
|
int col = MwFontData[out].data[y] & (1 << ((7 - 1) - x)) ? 255 : 0;
|
|
ppx[0] = col;
|
|
ppx[1] = col;
|
|
ppx[2] = col;
|
|
ppx[3] = col;
|
|
}
|
|
}
|
|
sx += 7;
|
|
}
|
|
|
|
p = MwLLCreatePixmap(handle, px, tw, th);
|
|
r.x = 5;
|
|
r.y = 5;
|
|
r.width = tw;
|
|
r.height = th;
|
|
|
|
MwLLDrawPixmap(handle, &r, p);
|
|
MwLLDestroyPixmap(p);
|
|
free(px);
|
|
}
|
|
update_buffer(handle, &handle->wayland.backbuffer);
|
|
}
|
|
// handle->wayland.selected_cairo = handle->wayland.front_cairo;
|
|
}
|
|
|
|
static void MwLLEndDrawImpl(MwLL handle) {
|
|
if(handle->wayland.configured) {
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
update_buffer(handle, &handle->wayland.backbuffer);
|
|
}
|
|
update_buffer(handle, &handle->wayland.framebuffer);
|
|
}
|
|
}
|
|
|
|
#define MAXPTS 512
|
|
#define MAXTRI (MAXPTS * 4)
|
|
#define EPS 1e-7
|
|
|
|
#define PACK(dst, pts, idx) \
|
|
do { \
|
|
(dst).x = pixman_int_to_fixed((pts)[(idx)].x); \
|
|
(dst).y = pixman_int_to_fixed((pts)[(idx)].y); \
|
|
} while(0)
|
|
|
|
typedef struct {
|
|
int a, b, c;
|
|
double cx, cy, r2; /* circumcircle centre + radius^2 */
|
|
} triangle;
|
|
|
|
typedef struct {
|
|
MwPoint pts[MAXPTS + 3];
|
|
int npts;
|
|
triangle tris[MAXTRI];
|
|
int ntris;
|
|
int bad[MAXTRI];
|
|
int nbad;
|
|
MwPoint edges[MAXTRI * 3];
|
|
int nedges;
|
|
} triangulation_state;
|
|
|
|
static void circumcircle(triangulation_state* s, int t) {
|
|
double ax = s->pts[s->tris[t].a].x, ay = s->pts[s->tris[t].a].y;
|
|
double bx = s->pts[s->tris[t].b].x, by = s->pts[s->tris[t].b].y;
|
|
double cx = s->pts[s->tris[t].c].x, cy = s->pts[s->tris[t].c].y;
|
|
double D = 2.0 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
|
|
double ux, uy;
|
|
if(fabs(D) < EPS) {
|
|
s->tris[t].r2 = 1e30;
|
|
return;
|
|
}
|
|
ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / D;
|
|
uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / D;
|
|
s->tris[t].cx = ux;
|
|
s->tris[t].cy = uy;
|
|
s->tris[t].r2 = (ax - ux) * (ax - ux) + (ay - uy) * (ay - uy);
|
|
}
|
|
|
|
static int in_circumcircle(triangulation_state* s, int t, int p) {
|
|
double dx = s->pts[p].x - s->tris[t].cx;
|
|
double dy = s->pts[p].y - s->tris[t].cy;
|
|
return dx * dx + dy * dy < s->tris[t].r2 - EPS;
|
|
}
|
|
|
|
static void add_tri(triangulation_state* s, int a, int b, int c) {
|
|
s->tris[s->ntris].a = a;
|
|
s->tris[s->ntris].b = b;
|
|
s->tris[s->ntris].c = c;
|
|
circumcircle(s, s->ntris);
|
|
s->ntris++;
|
|
}
|
|
|
|
static void remove_tri(triangulation_state* s, int i) {
|
|
s->tris[i] = s->tris[--s->ntris];
|
|
}
|
|
|
|
static int delaunay(MwPoint* src, int npts,
|
|
pixman_triangle_t* out, int out_size) {
|
|
triangulation_state s;
|
|
int si, i, j, k;
|
|
double mnx, mxx, mny, mxy, dx, dy, dmx, mx, my;
|
|
|
|
if(npts < 3 || npts > MAXPTS) return -1;
|
|
|
|
s.npts = npts;
|
|
memcpy(s.pts, src, npts * sizeof(MwPoint));
|
|
|
|
/* super-triangle */
|
|
mnx = mxx = s.pts[0].x;
|
|
mny = mxy = s.pts[0].y;
|
|
for(i = 1; i < npts; i++) {
|
|
if(s.pts[i].x < mnx) mnx = s.pts[i].x;
|
|
if(s.pts[i].x > mxx) mxx = s.pts[i].x;
|
|
if(s.pts[i].y < mny) mny = s.pts[i].y;
|
|
if(s.pts[i].y > mxy) mxy = s.pts[i].y;
|
|
}
|
|
dx = mxx - mnx;
|
|
dy = mxy - mny;
|
|
dmx = (dx > dy) ? dx : dy;
|
|
mx = (mnx + mxx) * 0.5;
|
|
my = (mny + mxy) * 0.5;
|
|
|
|
si = npts;
|
|
s.pts[si].x = mx - 20.0 * dmx;
|
|
s.pts[si].y = my - dmx;
|
|
s.pts[si + 1].x = mx;
|
|
s.pts[si + 1].y = my + 20.0 * dmx;
|
|
s.pts[si + 2].x = mx + 20.0 * dmx;
|
|
s.pts[si + 2].y = my - dmx;
|
|
|
|
s.ntris = 0;
|
|
add_tri(&s, si, si + 1, si + 2);
|
|
|
|
/* insert each point */
|
|
for(i = 0; i < npts; i++) {
|
|
s.nbad = 0;
|
|
for(j = 0; j < s.ntris; j++)
|
|
if(in_circumcircle(&s, j, i))
|
|
s.bad[s.nbad++] = j;
|
|
|
|
s.nedges = 0;
|
|
for(j = 0; j < s.nbad; j++) {
|
|
int ea[3][2];
|
|
ea[0][0] = s.tris[s.bad[j]].a;
|
|
ea[0][1] = s.tris[s.bad[j]].b;
|
|
ea[1][0] = s.tris[s.bad[j]].b;
|
|
ea[1][1] = s.tris[s.bad[j]].c;
|
|
ea[2][0] = s.tris[s.bad[j]].c;
|
|
ea[2][1] = s.tris[s.bad[j]].a;
|
|
for(k = 0; k < 3; k++) {
|
|
int m, shared = 0;
|
|
for(m = 0; m < s.nbad; m++) {
|
|
if(m == j) continue;
|
|
if((s.tris[s.bad[m]].a == ea[k][0] || s.tris[s.bad[m]].b == ea[k][0] || s.tris[s.bad[m]].c == ea[k][0]) &&
|
|
(s.tris[s.bad[m]].a == ea[k][1] || s.tris[s.bad[m]].b == ea[k][1] || s.tris[s.bad[m]].c == ea[k][1])) {
|
|
shared = 1;
|
|
break;
|
|
}
|
|
}
|
|
if(!shared) {
|
|
s.edges[s.nedges].x = ea[k][0];
|
|
s.edges[s.nedges].y = ea[k][1];
|
|
s.nedges++;
|
|
}
|
|
}
|
|
}
|
|
|
|
for(j = s.nbad - 1; j >= 0; j--)
|
|
remove_tri(&s, s.bad[j]);
|
|
|
|
for(j = 0; j < s.nedges; j++)
|
|
add_tri(&s, s.edges[j].x, s.edges[j].y, i);
|
|
}
|
|
|
|
/* remove triangles touching the super-triangle */
|
|
for(i = s.ntris - 1; i >= 0; i--)
|
|
if(s.tris[i].a >= npts || s.tris[i].b >= npts || s.tris[i].c >= npts)
|
|
remove_tri(&s, i);
|
|
|
|
if(s.ntris > out_size) return -1;
|
|
|
|
/* pack into pixman_triangle_t */
|
|
for(i = 0; i < s.ntris; i++) {
|
|
PACK(out[i].p1, s.pts, s.tris[i].a);
|
|
PACK(out[i].p2, s.pts, s.tris[i].b);
|
|
PACK(out[i].p3, s.pts, s.tris[i].c);
|
|
}
|
|
return s.ntris;
|
|
}
|
|
|
|
static void MwLLPolygonImpl(MwLL handle, MwPoint* points, int points_count, MwLLColor color) {
|
|
int n, i;
|
|
pixman_color_t col = {color->common.red * 0xFF, color->common.green * 0xFF, color->common.blue * 0xFF, 0xffff};
|
|
pixman_image_t* image = pixman_image_create_solid_fill(&col);
|
|
pixman_triangle_t out[MAXTRI];
|
|
|
|
n = delaunay(points, points_count, out, MAXTRI);
|
|
|
|
pixman_composite_triangles(PIXMAN_OP_OVER, image, handle->wayland.framebuffer.pixman_fb, PIXMAN_a8, 0, 0, 0, 0, points_count, out);
|
|
|
|
pixman_image_unref(image);
|
|
|
|
handle->wayland.events_pending = 1;
|
|
}
|
|
|
|
static void MwLLLineImpl(MwLL handle, MwPoint* points, MwLLColor color) {
|
|
int i;
|
|
pixman_color_t col = {color->common.red * 0xFF, color->common.green * 0xFF, color->common.blue * 0xFF, 0xffff};
|
|
pixman_image_t* image = pixman_image_create_solid_fill(&col);
|
|
|
|
pixman_image_unref(image);
|
|
|
|
handle->wayland.events_pending = 1;
|
|
}
|
|
|
|
static MwLLColor MwLLAllocColorImpl(MwLL handle, int r, int g, int b) {
|
|
MwLLColor c = malloc(sizeof(*c));
|
|
(void)handle;
|
|
|
|
c->common.red = r;
|
|
c->common.blue = b;
|
|
c->common.green = g;
|
|
|
|
return c;
|
|
}
|
|
|
|
static void MwLLColorUpdateImpl(MwLL handle, MwLLColor c, int r, int g, int b) {
|
|
(void)handle;
|
|
c->common.red = r;
|
|
c->common.blue = b;
|
|
c->common.green = g;
|
|
}
|
|
|
|
static void MwLLFreeColorImpl(MwLLColor color) {
|
|
free(color);
|
|
}
|
|
|
|
static int MwLLPendingImpl(MwLL handle) {
|
|
struct timespec timeout = {
|
|
.tv_nsec = 1,
|
|
.tv_sec = 0,
|
|
};
|
|
struct pollfd fd = {
|
|
.fd = wl_display_get_fd(handle->wayland.display),
|
|
.events = POLLOUT,
|
|
};
|
|
int pending = 0;
|
|
|
|
if(!handle->wayland.did_initial_resize) {
|
|
recursive_dispatch_resize(handle);
|
|
handle->wayland.did_initial_resize = 1;
|
|
}
|
|
|
|
if(!MwWaylandAlwaysRender) {
|
|
wl_display_prepare_read(handle->wayland.display);
|
|
if(!poll(&fd, 1, timeout.tv_nsec)) {
|
|
wl_display_cancel_read(handle->wayland.display);
|
|
} else {
|
|
wl_display_read_events(handle->wayland.display);
|
|
if((pending = wl_display_dispatch_pending(handle->wayland.display)) < 0) {
|
|
wl_display_cancel_read(handle->wayland.display);
|
|
}
|
|
}
|
|
} else {
|
|
if((pending = wl_display_dispatch_pending(handle->wayland.display)) < 0) {
|
|
wl_display_cancel_read(handle->wayland.display);
|
|
}
|
|
}
|
|
|
|
if(MwWaylandAlwaysRender) {
|
|
handle->wayland.did_event_loop_early = MwTRUE;
|
|
event_loop(handle);
|
|
return pending;
|
|
}
|
|
|
|
update_buffer(handle, &handle->wayland.framebuffer);
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
update_buffer(handle, &handle->wayland.backbuffer);
|
|
}
|
|
|
|
return handle->wayland.force_render || handle->wayland.events_pending || pending;
|
|
}
|
|
|
|
static void MwLLNextEventImpl(MwLL handle) {
|
|
if(!MwWaylandAlwaysRender) {
|
|
if(handle->wayland.did_event_loop_early) {
|
|
handle->wayland.did_event_loop_early = MwFALSE;
|
|
} else {
|
|
event_loop(handle);
|
|
}
|
|
}
|
|
|
|
if(handle->wayland.force_render) {
|
|
MwLLDispatch(handle, draw, NULL);
|
|
if(handle->wayland.configured) update_buffer(handle, &handle->wayland.framebuffer);
|
|
handle->wayland.force_render = 0;
|
|
}
|
|
if(handle->wayland.events_pending) {
|
|
handle->wayland.events_pending = 0;
|
|
}
|
|
}
|
|
|
|
static void MwLLSetTitleImpl(MwLL handle, const char* title) {
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
xdg_toplevel_set_title(handle->wayland.toplevel->xdg_top_level, title);
|
|
}
|
|
if(!handle->wayland.has_decorations) {
|
|
strncpy(handle->wayland.title, title, 255);
|
|
MwLLBeginDraw(handle);
|
|
MwLLEndDraw(handle);
|
|
}
|
|
}
|
|
|
|
static MwLLPixmap MwLLCreatePixmapImpl(MwLL handle, unsigned char* data, int width, int height) {
|
|
MwLLPixmap r = malloc(sizeof(*r));
|
|
pixman_transform_t transform;
|
|
|
|
(void)handle;
|
|
int stride = width * 4;
|
|
|
|
r->common.width = width;
|
|
r->common.height = height;
|
|
r->common.raw = malloc(4 * width * height);
|
|
memcpy(r->common.raw, data, 4 * width * height);
|
|
|
|
r->wayland.img = NULL;
|
|
|
|
MwLLPixmapUpdate(r);
|
|
|
|
return r;
|
|
}
|
|
|
|
static void MwLLPixmapUpdateImpl(MwLLPixmap r) {
|
|
int i;
|
|
unsigned char* d;
|
|
if(r->wayland.img) {
|
|
pixman_image_unref(r->wayland.img);
|
|
}
|
|
r->wayland.img = pixman_image_create_bits(PIXMAN_a8b8g8r8, r->common.width, r->common.height, (MwU32*)r->common.raw, r->common.width * 4);
|
|
}
|
|
|
|
static void MwLLDestroyPixmapImpl(MwLLPixmap pixmap) {
|
|
free(pixmap->common.raw);
|
|
free(pixmap);
|
|
}
|
|
|
|
static void MwLLDrawPixmapImpl(MwLL handle, MwRect* rect, MwLLPixmap pixmap) {
|
|
int width, height;
|
|
pixman_transform_t transform;
|
|
pixman_transform_t reverse;
|
|
|
|
pixman_transform_init_identity(&transform);
|
|
|
|
pixman_transform_scale(&transform, &reverse, pixman_double_to_fixed((double)pixmap->common.width / (double)rect->width), pixman_double_to_fixed((double)pixmap->common.height / (double)rect->height));
|
|
|
|
pixman_image_set_transform(pixmap->wayland.img, &transform);
|
|
|
|
width = pixman_image_get_width(pixmap->wayland.img);
|
|
height = pixman_image_get_height(pixmap->wayland.img);
|
|
|
|
pixman_image_composite(PIXMAN_OP_OVER,
|
|
pixmap->wayland.img, /* src */
|
|
NULL /* mask */,
|
|
handle->wayland.framebuffer.pixman_fb, /* dest */
|
|
0, 0, /* src_x, src_y */
|
|
0, 0, /* mask_x, mask_y */
|
|
rect->x, rect->y, /* dest_x, dest_y */
|
|
rect->width, rect->height /* height */);
|
|
}
|
|
static void MwLLSetIconImpl(MwLL handle, MwLLPixmap pixmap) {
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
if(WAYLAND_GET_INTERFACE(handle->wayland, xdg_toplevel_icon_manager_v1) != NULL) {
|
|
struct xdg_toplevel_icon_manager_v1* icon_manager = WAYLAND_GET_INTERFACE(handle->wayland, xdg_toplevel_icon_manager_v1)->context;
|
|
struct xdg_toplevel_icon_v1* icon = xdg_toplevel_icon_manager_v1_create_icon(icon_manager);
|
|
MwU64 size = pixmap->common.width * pixmap->common.height * 4;
|
|
int i = 0;
|
|
|
|
if(handle->wayland.icon == NULL) {
|
|
handle->wayland.icon = malloc(sizeof(struct _MwLLWaylandShmBuffer));
|
|
memset(handle->wayland.icon, 0, sizeof(struct _MwLLWaylandShmBuffer));
|
|
handle->wayland.icon->shm = handle->wayland.framebuffer.shm;
|
|
}
|
|
|
|
if(handle->wayland.icon->setup) {
|
|
buffer_destroy(handle->wayland.icon);
|
|
wl_surface_destroy(handle->wayland.icon->surface);
|
|
}
|
|
handle->wayland.icon->surface = wl_compositor_create_surface(handle->wayland.compositor);
|
|
|
|
wl_surface_attach(handle->wayland.icon->surface, handle->wayland.icon->shm_buffer, 0, 0);
|
|
wl_surface_commit(handle->wayland.icon->surface);
|
|
|
|
buffer_setup(handle->wayland.icon, pixmap->common.width, pixmap->common.height);
|
|
|
|
for(; i < size; i += 2) {
|
|
handle->wayland.icon->buf_back[i] = pixmap->common.raw[i + 2];
|
|
handle->wayland.icon->buf_back[i + 1] = pixmap->common.raw[i + 1];
|
|
handle->wayland.icon->buf_back[i + 2] = pixmap->common.raw[i + 0];
|
|
handle->wayland.icon->buf_back[i + 3] = 255;
|
|
}
|
|
|
|
if(handle->wayland.configured) update_buffer(handle, handle->wayland.icon);
|
|
|
|
xdg_toplevel_icon_v1_add_buffer(icon, handle->wayland.icon->shm_buffer, 1);
|
|
|
|
xdg_toplevel_icon_manager_v1_set_icon(icon_manager, handle->wayland.toplevel->xdg_top_level, icon);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MwLLForceRenderImpl(MwLL handle) {
|
|
wl_surface_damage(handle->wayland.framebuffer.surface, 0, 0, handle->wayland.ww, handle->wayland.wh);
|
|
|
|
handle->wayland.force_render = MwTRUE;
|
|
if(handle->wayland.parent) {
|
|
handle->wayland.parent->wayland.force_render = MwTRUE;
|
|
}
|
|
}
|
|
|
|
static void MwLLSetCursorImpl(MwLL handle, MwCursor* image, MwCursor* mask) {
|
|
int x, y, xs, ys;
|
|
|
|
if(handle->wayland.cursor.setup) {
|
|
buffer_destroy(&handle->wayland.cursor);
|
|
wl_surface_destroy(handle->wayland.cursor.surface);
|
|
}
|
|
buffer_setup(&handle->wayland.cursor, image->width, image->height);
|
|
memset(handle->wayland.cursor.buf_back, 0, handle->wayland.cursor.buf_size);
|
|
|
|
xs = -mask->x + image->x;
|
|
ys = mask->height + mask->y;
|
|
ys = image->height + image->y - ys;
|
|
|
|
for(y = 0; y < mask->height; y++) {
|
|
unsigned int d = mask->data[y];
|
|
for(x = mask->width - 1; x >= 0; x--) {
|
|
int idx = ((y * image->width) + x) * 4;
|
|
|
|
if(d & 1) {
|
|
handle->wayland.cursor.buf_back[idx + 3] = 255;
|
|
};
|
|
d = d >> 1;
|
|
}
|
|
}
|
|
for(y = 0; y < image->height; y++) {
|
|
unsigned int d = image->data[y];
|
|
for(x = image->width - 1; x >= 0; x--) {
|
|
int px = 0;
|
|
int idx = (((y + ys) * image->width) + (x + xs)) * 4;
|
|
|
|
if(d & 1) {
|
|
px = 255;
|
|
};
|
|
|
|
handle->wayland.cursor.buf_back[idx] = px;
|
|
handle->wayland.cursor.buf_back[idx + 1] = px;
|
|
handle->wayland.cursor.buf_back[idx + 2] = px;
|
|
d = d >> 1;
|
|
}
|
|
}
|
|
|
|
handle->wayland.cursor.surface = wl_compositor_create_surface(handle->wayland.compositor);
|
|
wl_surface_attach(handle->wayland.cursor.surface, handle->wayland.cursor.shm_buffer, 0, 0);
|
|
wl_surface_commit(handle->wayland.cursor.surface);
|
|
update_buffer(handle, &handle->wayland.cursor);
|
|
|
|
/* If there's currently a pointer, set it up. (Otherwise, it'll be setup during the pointer enter event) */
|
|
if(handle->wayland.pointer != NULL) {
|
|
// wl_pointer_set_cursor(handle->wayland.pointer, handle->wayland.pointer_serial, handle->wayland.cursor.surface, 0, 0);
|
|
}
|
|
}
|
|
|
|
static void MwLLDetachImpl(MwLL handle, MwPoint* point) {
|
|
MwLL p = handle->wayland.parent;
|
|
int x = 0, y = 0;
|
|
while(p != NULL) {
|
|
x += p->wayland.x;
|
|
y += p->wayland.y;
|
|
p = p->wayland.parent;
|
|
}
|
|
|
|
handle->wayland.detatching = MwTRUE;
|
|
handle->wayland.detach_point = *point;
|
|
handle->wayland.detach_point.x += x;
|
|
handle->wayland.detach_point.y += y;
|
|
}
|
|
|
|
static void MwLLShowImpl(MwLL handle, int show) {
|
|
/* Some guy on a mailing list said that "abusing" wl_surface_attach for this purpose is bad? This is documented behavior so please I beg of you let me know if there's a compositor that actually has a problem with this. */
|
|
if(handle->wayland.framebuffer.surface) {
|
|
wl_surface_attach(handle->wayland.framebuffer.surface, show ? handle->wayland.framebuffer.shm_buffer : NULL, 0, 0);
|
|
wl_surface_commit(handle->wayland.framebuffer.surface);
|
|
}
|
|
if(handle->wayland.backbuffer.surface) {
|
|
wl_surface_attach(handle->wayland.backbuffer.surface, show ? handle->wayland.backbuffer.shm_buffer : NULL, 0, 0);
|
|
wl_surface_commit(handle->wayland.backbuffer.surface);
|
|
}
|
|
}
|
|
|
|
static void MwLLMakePopupImpl(MwLL handle, MwLL parent) {
|
|
(void)handle;
|
|
(void)parent;
|
|
/* Wayland doesn't have "popups" in the Milsko sense persay. xdg_popup is closer to ToolWindow and as such is what we use there. So just like the Mac backend, this is just left alone. */
|
|
}
|
|
|
|
static void MwLLSetSizeHintsImpl(MwLL handle, int minx, int miny, int maxx, int maxy) {
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
xdg_toplevel_set_min_size(handle->wayland.toplevel->xdg_top_level, minx, miny);
|
|
xdg_toplevel_set_max_size(handle->wayland.toplevel->xdg_top_level, maxx, maxy);
|
|
}
|
|
}
|
|
|
|
static void MwLLMakeBorderlessImpl(MwLL handle, int toggle) {
|
|
(void)toggle;
|
|
if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
|
|
if(WAYLAND_GET_INTERFACE(handle->wayland, zxdg_decoration_manager_v1) != NULL) {
|
|
zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(handle->wayland, zxdg_decoration_manager_v1)->context;
|
|
|
|
dec->decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
|
|
dec->manager, handle->wayland.toplevel->xdg_top_level);
|
|
|
|
zxdg_toplevel_decoration_v1_set_mode(
|
|
dec->decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MwLLFocusImpl(MwLL handle) {
|
|
(void)handle;
|
|
printf("[WARNING] MwLLFocus not supported on Wayland\n");
|
|
}
|
|
|
|
static void MwLLGrabPointerImpl(MwLL handle, int toggle) {
|
|
MwLL topmost_parent = handle;
|
|
while(topmost_parent->wayland.parent) topmost_parent = topmost_parent->wayland.parent;
|
|
if(handle->wayland.pointer_constraints && handle->wayland.relative_pointer_manager) {
|
|
if(toggle) {
|
|
topmost_parent->wayland.locked_pointer = zwp_pointer_constraints_v1_lock_pointer(topmost_parent->wayland.pointer_constraints, topmost_parent->wayland.backbuffer.surface, topmost_parent->wayland.pointer, topmost_parent->wayland.region, ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT);
|
|
wl_surface_commit(topmost_parent->wayland.backbuffer.surface);
|
|
zwp_locked_pointer_v1_set_cursor_position_hint(topmost_parent->wayland.locked_pointer, 0, CSD_BORDER_FRAME_TOP);
|
|
handle->wayland.relative_pointer = zwp_relative_pointer_manager_v1_get_relative_pointer(handle->wayland.relative_pointer_manager, handle->wayland.pointer);
|
|
zwp_relative_pointer_v1_add_listener(handle->wayland.relative_pointer, &relative_pointer_listener, topmost_parent);
|
|
} else {
|
|
if(topmost_parent->wayland.locked_pointer) {
|
|
zwp_locked_pointer_v1_destroy(topmost_parent->wayland.locked_pointer);
|
|
topmost_parent->wayland.locked_pointer = NULL;
|
|
}
|
|
if(topmost_parent->wayland.relative_pointer) {
|
|
zwp_relative_pointer_v1_destroy(topmost_parent->wayland.relative_pointer);
|
|
topmost_parent->wayland.relative_pointer = NULL;
|
|
}
|
|
}
|
|
handle->wayland.do_lock_pointer = toggle;
|
|
} else {
|
|
printf("[WARNING] MwLLGrabPointer not supported in Wayland session, zwp_pointer_constraints_v1 and relative_pointer_manager_v1 are required.\n");
|
|
}
|
|
}
|
|
|
|
static void MwLLSetClipboardImpl(MwLL handle, const char* text) {
|
|
if(handle->wayland.clipboard_buffer != NULL) {
|
|
free(handle->wayland.clipboard_buffer);
|
|
}
|
|
handle->wayland.clipboard_buffer = malloc(strlen(text));
|
|
strcpy(handle->wayland.clipboard_buffer, text);
|
|
|
|
if(handle->wayland.supports_zwp) {
|
|
int i;
|
|
for(i = 0; i < arrlen(handle->wayland.clipboard_devices); i++) {
|
|
wl_clipboard_device_context_t* device = handle->wayland.clipboard_devices[i];
|
|
zwp_primary_selection_device_v1_set_selection(device->device.zwp, handle->wayland.clipboard_source.zwp, handle->wayland.keyboard_serial);
|
|
}
|
|
} else {
|
|
int i;
|
|
for(i = 0; i < arrlen(handle->wayland.clipboard_devices); i++) {
|
|
wl_clipboard_device_context_t* device = handle->wayland.clipboard_devices[i];
|
|
wl_data_device_set_selection(device->device.wl, handle->wayland.clipboard_source.wl, handle->wayland.keyboard_serial);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MwLLGetClipboardImpl(MwLL handle) {
|
|
int i;
|
|
for(i = 0; i < arrlen(handle->wayland.clipboard_devices); i++) {
|
|
wl_clipboard_read(
|
|
handle->wayland.clipboard_devices[i]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void MwLLMakeToolWindowImpl(MwLL handle) {
|
|
handle->wayland.type_to_be = MWLL_WAYLAND_POPUP;
|
|
}
|
|
|
|
static void MwLLGetCursorCoordImpl(MwLL handle, MwPoint* point) {
|
|
*point = handle->wayland.cur_mouse_pos;
|
|
}
|
|
|
|
static void MwLLGetScreenSizeImpl(MwLL handle, MwRect* rect) {
|
|
rect->x = 0;
|
|
rect->y = 0;
|
|
rect->width = handle->wayland.mw;
|
|
rect->height = handle->wayland.mh;
|
|
}
|
|
|
|
static void MwLLBeginStateChangeImpl(MwLL handle) {
|
|
(void)handle;
|
|
/* no-op */
|
|
}
|
|
|
|
static void MwLLEndStateChangeImpl(MwLL handle) {
|
|
if(handle->wayland.detatching) {
|
|
MwLL topmost_parent = handle->wayland.parent;
|
|
|
|
while(topmost_parent->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
|
|
topmost_parent = topmost_parent->wayland.parent;
|
|
}
|
|
switch(handle->wayland.type) {
|
|
case MWLL_WAYLAND_UNKNOWN:
|
|
break;
|
|
case MWLL_WAYLAND_TOPLEVEL:
|
|
destroy_toplevel(handle);
|
|
break;
|
|
case MWLL_WAYLAND_SUBLEVEL:
|
|
destroy_sublevel(handle);
|
|
break;
|
|
case MWLL_WAYLAND_POPUP:
|
|
destroy_popup(handle);
|
|
break;
|
|
}
|
|
|
|
wl_flush(handle);
|
|
|
|
widget_setup(handle, handle->wayland.parent, handle->wayland.detach_point.x, handle->wayland.detach_point.y, handle->wayland.ww, handle->wayland.wh, handle->wayland.type_to_be);
|
|
|
|
if(handle->common.user) {
|
|
MwWidget w = handle->common.user;
|
|
int i;
|
|
for(i = 0; i < arrlen(w->children); i++) {
|
|
if(w->children[i]->lowlevel->wayland.type == MWLL_WAYLAND_SUBLEVEL) {
|
|
MwLL child = w->children[i]->lowlevel;
|
|
child->wayland.sublevel->xdg_surface = handle->wayland.popup->xdg_surface;
|
|
wl_subsurface_destroy(child->wayland.sublevel->subsurface);
|
|
wl_flush(handle);
|
|
|
|
child->wayland.sublevel->subsurface = wl_subcompositor_get_subsurface(child->wayland.sublevel->subcompositor, child->wayland.framebuffer.surface, handle->wayland.framebuffer.surface);
|
|
wl_subsurface_set_desync(child->wayland.sublevel->subsurface);
|
|
wl_subsurface_set_position(child->wayland.sublevel->subsurface, child->wayland.x, child->wayland.y);
|
|
|
|
wl_subsurface_place_above(child->wayland.sublevel->subsurface, handle->wayland.framebuffer.surface);
|
|
MwLLEndStateChangeImpl(w->children[i]->lowlevel);
|
|
|
|
currentlyHeldWidget = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
MwLLForceRender(handle);
|
|
if(handle->wayland.parent != NULL) {
|
|
MwLLForceRender(handle->wayland.parent);
|
|
}
|
|
|
|
handle->wayland.events_pending = 1;
|
|
|
|
handle->wayland.detatching = MwFALSE;
|
|
}
|
|
}
|
|
|
|
static int MwLLWaylandCallInitImpl(void) {
|
|
/*
|
|
* Order of precedence:
|
|
* - MILSKO_BACKEND
|
|
* - XDG_SESSION_TYPE
|
|
* - manually checking environment variables
|
|
*/
|
|
#ifdef __linux__
|
|
MwBool loadWayland = MwFALSE;
|
|
if(getenv("MILSKO_BACKEND")) {
|
|
loadWayland =
|
|
(strcmp(getenv("MILSKO_BACKEND"), "wayland") == 0);
|
|
} else if(getenv("WAYLAND_DISPLAY") && !loadWayland) {
|
|
loadWayland = (getenv("WAYLAND_DISPLAY") != NULL);
|
|
}
|
|
|
|
if(loadWayland) {
|
|
if(wayland_load_funcs()) {
|
|
return 1;
|
|
}
|
|
wl_log_set_handler_client(wl_logger);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
#include "call.c"
|
|
CALL(Wayland);
|