commit
53052b3f6e
|
@ -32,8 +32,10 @@ bool wlr_backend_start(struct wlr_backend *backend) {
|
|||
}
|
||||
|
||||
void wlr_backend_destroy(struct wlr_backend *backend) {
|
||||
if (backend->impl->destroy) {
|
||||
if (backend->impl && backend->impl->destroy) {
|
||||
backend->impl->destroy(backend);
|
||||
} else {
|
||||
free(backend);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -151,6 +151,7 @@ error_backend:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev) {
|
||||
return dev->state->handle;
|
||||
struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *_dev) {
|
||||
struct wlr_libinput_input_device *dev = (struct wlr_libinput_input_device *)_dev;
|
||||
return dev->handle;
|
||||
}
|
||||
|
|
|
@ -23,9 +23,10 @@ struct wlr_input_device *get_appropriate_device(
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static void wlr_libinput_device_destroy(struct wlr_input_device_state *state) {
|
||||
libinput_device_unref(state->handle);
|
||||
free(state);
|
||||
static void wlr_libinput_device_destroy(struct wlr_input_device *_dev) {
|
||||
struct wlr_libinput_input_device *dev = (struct wlr_libinput_input_device *)_dev;
|
||||
libinput_device_unref(dev->handle);
|
||||
free(dev);
|
||||
}
|
||||
|
||||
static struct wlr_input_device_impl input_device_impl = {
|
||||
|
@ -38,13 +39,13 @@ static struct wlr_input_device *allocate_device(
|
|||
int vendor = libinput_device_get_id_vendor(libinput_dev);
|
||||
int product = libinput_device_get_id_product(libinput_dev);
|
||||
const char *name = libinput_device_get_name(libinput_dev);
|
||||
struct wlr_input_device_state *devstate =
|
||||
calloc(1, sizeof(struct wlr_input_device_state));
|
||||
devstate->handle = libinput_dev;
|
||||
struct wlr_libinput_input_device *wlr_libinput_dev =
|
||||
calloc(1, sizeof(struct wlr_libinput_input_device));
|
||||
struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device;
|
||||
wlr_libinput_dev->handle = libinput_dev;
|
||||
libinput_device_ref(libinput_dev);
|
||||
struct wlr_input_device *wlr_dev = wlr_input_device_create(
|
||||
type, &input_device_impl, devstate,
|
||||
name, vendor, product);
|
||||
wlr_input_device_init(wlr_dev, type, &input_device_impl,
|
||||
name, vendor, product);
|
||||
list_add(wlr_devices, wlr_dev);
|
||||
return wlr_dev;
|
||||
}
|
||||
|
|
|
@ -7,17 +7,21 @@
|
|||
#include <wlr/util/log.h>
|
||||
#include "backend/libinput.h"
|
||||
|
||||
struct wlr_keyboard_state {
|
||||
struct wlr_libinput_keyboard {
|
||||
struct wlr_keyboard wlr_keyboard;
|
||||
struct libinput_device *libinput_dev;
|
||||
};
|
||||
|
||||
static void wlr_libinput_keyboard_set_leds(struct wlr_keyboard_state *kbstate, uint32_t leds) {
|
||||
libinput_device_led_update(kbstate->libinput_dev, leds);
|
||||
static void wlr_libinput_keyboard_set_leds(struct wlr_keyboard *wlr_kb, uint32_t leds) {
|
||||
struct wlr_libinput_keyboard *wlr_libinput_kb = (struct wlr_libinput_keyboard *)wlr_kb;
|
||||
libinput_device_led_update(wlr_libinput_kb->libinput_dev, leds);
|
||||
}
|
||||
|
||||
static void wlr_libinput_keyboard_destroy(struct wlr_keyboard_state *kbstate) {
|
||||
libinput_device_unref(kbstate->libinput_dev);
|
||||
free(kbstate);
|
||||
static void wlr_libinput_keyboard_destroy(struct wlr_keyboard *wlr_kb) {
|
||||
struct wlr_libinput_keyboard *wlr_libinput_kb =
|
||||
(struct wlr_libinput_keyboard *)wlr_kb;
|
||||
libinput_device_unref(wlr_libinput_kb->libinput_dev);
|
||||
free(wlr_libinput_kb);
|
||||
}
|
||||
|
||||
struct wlr_keyboard_impl impl = {
|
||||
|
@ -28,11 +32,14 @@ struct wlr_keyboard_impl impl = {
|
|||
struct wlr_keyboard *wlr_libinput_keyboard_create(
|
||||
struct libinput_device *libinput_dev) {
|
||||
assert(libinput_dev);
|
||||
struct wlr_keyboard_state *kbstate = calloc(1, sizeof(struct wlr_keyboard_state));
|
||||
kbstate->libinput_dev = libinput_dev;
|
||||
struct wlr_libinput_keyboard *wlr_libinput_kb =
|
||||
calloc(1, sizeof(struct wlr_libinput_keyboard));
|
||||
wlr_libinput_kb->libinput_dev = libinput_dev;
|
||||
libinput_device_ref(libinput_dev);
|
||||
libinput_device_led_update(libinput_dev, 0);
|
||||
return wlr_keyboard_create(&impl, kbstate);
|
||||
struct wlr_keyboard *wlr_kb = &wlr_libinput_kb->wlr_keyboard;
|
||||
wlr_keyboard_init(wlr_kb, &impl);
|
||||
return wlr_kb;
|
||||
}
|
||||
|
||||
void handle_keyboard_key(struct libinput_event *event,
|
||||
|
|
|
@ -10,7 +10,13 @@
|
|||
struct wlr_pointer *wlr_libinput_pointer_create(
|
||||
struct libinput_device *libinput_dev) {
|
||||
assert(libinput_dev);
|
||||
return wlr_pointer_create(NULL, NULL);
|
||||
struct wlr_pointer *wlr_pointer = calloc(1, sizeof(struct wlr_pointer));
|
||||
if (!wlr_pointer) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_pointer");
|
||||
return NULL;
|
||||
}
|
||||
wlr_pointer_init(wlr_pointer, NULL);
|
||||
return wlr_pointer;
|
||||
}
|
||||
|
||||
void handle_pointer_motion(struct libinput_event *event,
|
||||
|
|
|
@ -10,7 +10,13 @@
|
|||
struct wlr_tablet_pad *wlr_libinput_tablet_pad_create(
|
||||
struct libinput_device *libinput_dev) {
|
||||
assert(libinput_dev);
|
||||
return wlr_tablet_pad_create(NULL, NULL);
|
||||
struct wlr_tablet_pad *wlr_tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad));
|
||||
if (!wlr_tablet_pad) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_tablet_pad");
|
||||
return NULL;
|
||||
}
|
||||
wlr_tablet_pad_init(wlr_tablet_pad, NULL);
|
||||
return wlr_tablet_pad;
|
||||
}
|
||||
|
||||
void handle_tablet_pad_button(struct libinput_event *event,
|
||||
|
|
|
@ -10,7 +10,13 @@
|
|||
struct wlr_tablet_tool *wlr_libinput_tablet_tool_create(
|
||||
struct libinput_device *libinput_dev) {
|
||||
assert(libinput_dev);
|
||||
return wlr_tablet_tool_create(NULL, NULL);
|
||||
struct wlr_tablet_tool *wlr_tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool));
|
||||
if (!wlr_tablet_tool) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_tablet_tool");
|
||||
return NULL;
|
||||
}
|
||||
wlr_tablet_tool_init(wlr_tablet_tool, NULL);
|
||||
return wlr_tablet_tool;
|
||||
}
|
||||
|
||||
void handle_tablet_tool_axis(struct libinput_event *event,
|
||||
|
|
|
@ -10,7 +10,13 @@
|
|||
struct wlr_touch *wlr_libinput_touch_create(
|
||||
struct libinput_device *libinput_dev) {
|
||||
assert(libinput_dev);
|
||||
return wlr_touch_create(NULL, NULL);
|
||||
struct wlr_touch *wlr_touch = calloc(1, sizeof(struct wlr_touch));
|
||||
if (!wlr_touch) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_touch");
|
||||
return NULL;
|
||||
}
|
||||
wlr_touch_init(wlr_touch, NULL);
|
||||
return wlr_touch;
|
||||
}
|
||||
|
||||
void handle_touch_down(struct libinput_event *event,
|
||||
|
|
|
@ -103,7 +103,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
|
|||
|
||||
struct wlr_wl_backend_output *output;
|
||||
if (!(output = calloc(sizeof(struct wlr_wl_backend_output), 1))) {
|
||||
wlr_log(L_ERROR, "Failed to allocate wlr_output_state");
|
||||
wlr_log(L_ERROR, "Failed to allocate wlr_wl_backend_output");
|
||||
return NULL;
|
||||
}
|
||||
wlr_output_init(&output->wlr_output, &output_impl);
|
||||
|
|
|
@ -16,31 +16,34 @@ static void pointer_handle_enter(void *data, struct wl_pointer *wl_pointer,
|
|||
uint32_t serial, struct wl_surface *surface, wl_fixed_t surface_x,
|
||||
wl_fixed_t surface_y) {
|
||||
struct wlr_input_device *dev = data;
|
||||
assert(dev && dev->pointer && dev->pointer->state);
|
||||
struct wlr_wl_input_device *wlr_wl_dev = (struct wlr_wl_input_device *)dev;
|
||||
assert(dev && dev->pointer);
|
||||
struct wlr_wl_pointer *wlr_wl_pointer = (struct wlr_wl_pointer *)dev->pointer;
|
||||
struct wlr_wl_backend_output* output =
|
||||
wlr_wl_output_for_surface(dev->state->backend, surface);
|
||||
wlr_wl_output_for_surface(wlr_wl_dev->backend, surface);
|
||||
assert(output);
|
||||
dev->pointer->state->current_output = output;
|
||||
wlr_wl_pointer->current_output = output;
|
||||
}
|
||||
|
||||
static void pointer_handle_leave(void *data, struct wl_pointer *wl_pointer,
|
||||
uint32_t serial, struct wl_surface *surface) {
|
||||
struct wlr_input_device *dev = data;
|
||||
assert(dev && dev->pointer && dev->pointer->state);
|
||||
dev->pointer->state->current_output = NULL;
|
||||
assert(dev && dev->pointer);
|
||||
struct wlr_wl_pointer *wlr_wl_pointer = (struct wlr_wl_pointer *)dev->pointer;
|
||||
wlr_wl_pointer->current_output = NULL;
|
||||
}
|
||||
|
||||
static void pointer_handle_motion(void *data, struct wl_pointer *wl_pointer,
|
||||
uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
|
||||
struct wlr_input_device *dev = data;
|
||||
assert(dev && dev->pointer && dev->pointer->state);
|
||||
struct wlr_pointer_state *state = dev->pointer->state;
|
||||
if (!state->current_output) {
|
||||
assert(dev && dev->pointer);
|
||||
struct wlr_wl_pointer *wlr_wl_pointer = (struct wlr_wl_pointer *)dev->pointer;
|
||||
if (!wlr_wl_pointer->current_output) {
|
||||
wlr_log(L_ERROR, "pointer motion event without current output");
|
||||
return;
|
||||
}
|
||||
int width, height;
|
||||
wl_egl_window_get_attached_size(state->current_output->egl_window,
|
||||
wl_egl_window_get_attached_size(wlr_wl_pointer->current_output->egl_window,
|
||||
&width, &height);
|
||||
struct wlr_event_pointer_motion_absolute wlr_event;
|
||||
wlr_event.time_sec = time / 1000;
|
||||
|
@ -69,13 +72,14 @@ static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
|
|||
uint32_t time, uint32_t axis, wl_fixed_t value) {
|
||||
struct wlr_input_device *dev = data;
|
||||
assert(dev && dev->pointer);
|
||||
struct wlr_wl_pointer *wlr_wl_pointer = (struct wlr_wl_pointer *)dev->pointer;
|
||||
|
||||
struct wlr_event_pointer_axis wlr_event;
|
||||
wlr_event.delta = value;
|
||||
wlr_event.orientation = axis;
|
||||
wlr_event.time_sec = time / 1000;
|
||||
wlr_event.time_usec = time * 1000;
|
||||
wlr_event.source = dev->pointer->state->axis_source;
|
||||
wlr_event.source = wlr_wl_pointer->axis_source;
|
||||
wl_signal_emit(&dev->pointer->events.axis, &wlr_event);
|
||||
}
|
||||
|
||||
|
@ -86,8 +90,10 @@ static void pointer_handle_frame(void *data, struct wl_pointer *wl_pointer) {
|
|||
static void pointer_handle_axis_source(void *data, struct wl_pointer *wl_pointer,
|
||||
uint32_t axis_source) {
|
||||
struct wlr_input_device *dev = data;
|
||||
assert(dev && dev->pointer && dev->pointer->state);
|
||||
dev->pointer->state->axis_source = axis_source;
|
||||
assert(dev && dev->pointer);
|
||||
struct wlr_wl_pointer *wlr_wl_pointer = (struct wlr_wl_pointer *)dev->pointer;
|
||||
|
||||
wlr_wl_pointer->axis_source = axis_source;
|
||||
}
|
||||
|
||||
static void pointer_handle_axis_stop(void *data, struct wl_pointer *wl_pointer,
|
||||
|
@ -160,46 +166,35 @@ static struct wl_keyboard_listener keyboard_listener = {
|
|||
.repeat_info = keyboard_handle_repeat_info
|
||||
};
|
||||
|
||||
static void input_device_destroy(struct wlr_input_device_state *state) {
|
||||
wl_signal_emit(&state->backend->backend.events.input_remove, state->wlr_device);
|
||||
if (state->resource)
|
||||
wl_proxy_destroy(state->resource);
|
||||
free(state);
|
||||
static void input_device_destroy(struct wlr_input_device *_dev) {
|
||||
struct wlr_wl_input_device *dev = (struct wlr_wl_input_device *)_dev;
|
||||
wl_signal_emit(&dev->backend->backend.events.input_remove, &dev->wlr_input_device);
|
||||
if (dev->resource) {
|
||||
wl_proxy_destroy(dev->resource);
|
||||
}
|
||||
free(dev);
|
||||
}
|
||||
|
||||
static struct wlr_input_device_impl input_device_impl = {
|
||||
.destroy = input_device_destroy
|
||||
};
|
||||
|
||||
static void pointer_destroy(struct wlr_pointer_state *state) {
|
||||
free(state);
|
||||
}
|
||||
|
||||
static struct wlr_pointer_impl pointer_impl = {
|
||||
.destroy = pointer_destroy
|
||||
};
|
||||
|
||||
static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
|
||||
enum wlr_input_device_type type) {
|
||||
struct wlr_input_device_state *devstate;
|
||||
if (!(devstate = calloc(1, sizeof(struct wlr_input_device_state)))) {
|
||||
struct wlr_wl_input_device *wlr_wl_dev;
|
||||
if (!(wlr_wl_dev = calloc(1, sizeof(struct wlr_wl_input_device)))) {
|
||||
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
devstate->backend = backend;
|
||||
wlr_wl_dev->backend = backend;
|
||||
|
||||
int vendor = 0;
|
||||
int product = 0;
|
||||
const char *name = "wayland";
|
||||
struct wlr_input_device *wlr_device = wlr_input_device_create(
|
||||
type, &input_device_impl, devstate,
|
||||
name, vendor, product);
|
||||
if (!wlr_device) {
|
||||
free(devstate);
|
||||
return NULL;
|
||||
}
|
||||
devstate->wlr_device = wlr_device;
|
||||
struct wlr_input_device *wlr_device = &wlr_wl_dev->wlr_input_device;
|
||||
wlr_input_device_init(wlr_device, type, &input_device_impl,
|
||||
name, vendor, product);
|
||||
list_add(backend->devices, wlr_device);
|
||||
return wlr_device;
|
||||
}
|
||||
|
@ -211,23 +206,26 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
|
|||
|
||||
if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
|
||||
wlr_log(L_DEBUG, "seat %p offered pointer", (void*) wl_seat);
|
||||
struct wlr_pointer_state *pointer_state;
|
||||
if (!(pointer_state = calloc(1, sizeof(struct wlr_pointer_state)))) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_pointer_state");
|
||||
struct wlr_wl_pointer *wlr_wl_pointer;
|
||||
if (!(wlr_wl_pointer = calloc(1, sizeof(struct wlr_wl_pointer)))) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_wl_pointer");
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_input_device *wlr_device;
|
||||
if (!(wlr_device = allocate_device(backend, WLR_INPUT_DEVICE_POINTER))) {
|
||||
free(pointer_state);
|
||||
free(wlr_wl_pointer);
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer");
|
||||
return;
|
||||
}
|
||||
struct wlr_wl_input_device *wlr_wl_device =
|
||||
(struct wlr_wl_input_device *)wlr_device;
|
||||
|
||||
struct wl_pointer *wl_pointer = wl_seat_get_pointer(wl_seat);
|
||||
wl_pointer_add_listener(wl_pointer, &pointer_listener, wlr_device);
|
||||
wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state);
|
||||
wlr_device->state->resource = wl_pointer;
|
||||
wlr_device->pointer = &wlr_wl_pointer->wlr_pointer;
|
||||
wlr_pointer_init(wlr_device->pointer, NULL);
|
||||
wlr_wl_device->resource = wl_pointer;
|
||||
wl_signal_emit(&backend->backend.events.input_add, wlr_device);
|
||||
}
|
||||
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
|
||||
|
@ -238,11 +236,19 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
|
|||
wlr_log(L_ERROR, "Unable to allocate wl_pointer device");
|
||||
return;
|
||||
}
|
||||
wlr_device->keyboard = calloc(1, sizeof(struct wlr_keyboard));
|
||||
if (!wlr_device->keyboard) {
|
||||
free(wlr_device);
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr keyboard");
|
||||
return;
|
||||
}
|
||||
wlr_keyboard_init(wlr_device->keyboard, NULL);
|
||||
struct wlr_wl_input_device *wlr_wl_device =
|
||||
(struct wlr_wl_input_device *)wlr_device;
|
||||
|
||||
struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat);
|
||||
wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device);
|
||||
wlr_device->keyboard = wlr_keyboard_create(NULL, NULL);
|
||||
wlr_device->state->resource = wl_keyboard;
|
||||
wlr_wl_device->resource = wl_keyboard;
|
||||
wl_signal_emit(&backend->backend.events.input_add, wlr_device);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define _WLR_BACKEND_LIBINPUT_INTERNAL_H
|
||||
#include <libinput.h>
|
||||
#include <wayland-server-core.h>
|
||||
#include <wlr/types/wlr_input_device.h>
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/interfaces/wlr_input_device.h>
|
||||
#include <wlr/util/list.h>
|
||||
|
@ -22,7 +23,9 @@ struct wlr_libinput_backend {
|
|||
list_t *wlr_device_lists;
|
||||
};
|
||||
|
||||
struct wlr_input_device_state {
|
||||
struct wlr_libinput_input_device {
|
||||
struct wlr_input_device wlr_input_device;
|
||||
|
||||
struct libinput_device *handle;
|
||||
};
|
||||
|
||||
|
|
|
@ -41,13 +41,15 @@ struct wlr_wl_backend_output {
|
|||
void *egl_surface;
|
||||
};
|
||||
|
||||
struct wlr_input_device_state {
|
||||
struct wlr_wl_input_device {
|
||||
struct wlr_input_device wlr_input_device;
|
||||
|
||||
struct wlr_wl_backend *backend;
|
||||
struct wlr_input_device *wlr_device;
|
||||
void *resource;
|
||||
};
|
||||
|
||||
struct wlr_pointer_state {
|
||||
struct wlr_wl_pointer {
|
||||
struct wlr_pointer wlr_pointer;
|
||||
enum wlr_axis_source axis_source;
|
||||
struct wlr_wl_backend_output *current_output;
|
||||
};
|
||||
|
|
|
@ -3,13 +3,13 @@
|
|||
#include <wlr/types/wlr_input_device.h>
|
||||
|
||||
struct wlr_input_device_impl {
|
||||
void (*destroy)(struct wlr_input_device_state *state);
|
||||
void (*destroy)(struct wlr_input_device *wlr_device);
|
||||
};
|
||||
|
||||
struct wlr_input_device *wlr_input_device_create(
|
||||
void wlr_input_device_init(
|
||||
struct wlr_input_device *wlr_device,
|
||||
enum wlr_input_device_type type,
|
||||
struct wlr_input_device_impl *impl,
|
||||
struct wlr_input_device_state *state,
|
||||
const char *name, int vendor, int product);
|
||||
void wlr_input_device_destroy(struct wlr_input_device *dev);
|
||||
|
||||
|
|
|
@ -4,12 +4,11 @@
|
|||
#include <stdint.h>
|
||||
|
||||
struct wlr_keyboard_impl {
|
||||
void (*destroy)(struct wlr_keyboard_state *state);
|
||||
void (*led_update)(struct wlr_keyboard_state *state, uint32_t leds);
|
||||
void (*destroy)(struct wlr_keyboard *keyboard);
|
||||
void (*led_update)(struct wlr_keyboard *keyboard, uint32_t leds);
|
||||
};
|
||||
|
||||
struct wlr_keyboard *wlr_keyboard_create(struct wlr_keyboard_impl *impl,
|
||||
struct wlr_keyboard_state *state);
|
||||
void wlr_keyboard_init(struct wlr_keyboard *keyboard, struct wlr_keyboard_impl *impl);
|
||||
void wlr_keyboard_destroy(struct wlr_keyboard *keyboard);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
#include <wlr/types/wlr_pointer.h>
|
||||
|
||||
struct wlr_pointer_impl {
|
||||
void (*destroy)(struct wlr_pointer_state *state);
|
||||
void (*destroy)(struct wlr_pointer *pointer);
|
||||
};
|
||||
|
||||
struct wlr_pointer *wlr_pointer_create(struct wlr_pointer_impl *impl,
|
||||
struct wlr_pointer_state *state);
|
||||
void wlr_pointer_init(struct wlr_pointer *pointer,
|
||||
struct wlr_pointer_impl *impl);
|
||||
void wlr_pointer_destroy(struct wlr_pointer *pointer);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
#include <wlr/types/wlr_tablet_pad.h>
|
||||
|
||||
struct wlr_tablet_pad_impl {
|
||||
void (*destroy)(struct wlr_tablet_pad_state *pad);
|
||||
void (*destroy)(struct wlr_tablet_pad *pad);
|
||||
};
|
||||
|
||||
struct wlr_tablet_pad *wlr_tablet_pad_create(struct wlr_tablet_pad_impl *impl,
|
||||
struct wlr_tablet_pad_state *state);
|
||||
void wlr_tablet_pad_init(struct wlr_tablet_pad *pad,
|
||||
struct wlr_tablet_pad_impl *impl);
|
||||
void wlr_tablet_pad_destroy(struct wlr_tablet_pad *pad);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
#include <wlr/types/wlr_tablet_tool.h>
|
||||
|
||||
struct wlr_tablet_tool_impl {
|
||||
void (*destroy)(struct wlr_tablet_tool_state *tool);
|
||||
void (*destroy)(struct wlr_tablet_tool *tool);
|
||||
};
|
||||
|
||||
struct wlr_tablet_tool *wlr_tablet_tool_create(struct wlr_tablet_tool_impl *impl,
|
||||
struct wlr_tablet_tool_state *state);
|
||||
void wlr_tablet_tool_init(struct wlr_tablet_tool *tool,
|
||||
struct wlr_tablet_tool_impl *impl);
|
||||
void wlr_tablet_tool_destroy(struct wlr_tablet_tool *tool);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
#include <wlr/types/wlr_touch.h>
|
||||
|
||||
struct wlr_touch_impl {
|
||||
void (*destroy)(struct wlr_touch_state *state);
|
||||
void (*destroy)(struct wlr_touch *touch);
|
||||
};
|
||||
|
||||
struct wlr_touch *wlr_touch_create(struct wlr_touch_impl *impl,
|
||||
struct wlr_touch_state *state);
|
||||
void wlr_touch_init(struct wlr_touch *touch,
|
||||
struct wlr_touch_impl *impl);
|
||||
void wlr_touch_destroy(struct wlr_touch *touch);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -21,11 +21,9 @@ enum wlr_input_device_type {
|
|||
#include <wlr/types/wlr_tablet_tool.h>
|
||||
#include <wlr/types/wlr_tablet_pad.h>
|
||||
|
||||
struct wlr_input_device_state;
|
||||
struct wlr_input_device_impl;
|
||||
|
||||
struct wlr_input_device {
|
||||
struct wlr_input_device_state *state;
|
||||
struct wlr_input_device_impl *impl;
|
||||
|
||||
enum wlr_input_device_type type;
|
||||
|
|
|
@ -10,11 +10,9 @@ enum WLR_KEYBOARD_LED {
|
|||
WLR_LED_LAST
|
||||
};
|
||||
|
||||
struct wlr_keyboard_state;
|
||||
struct wlr_keyboard_impl;
|
||||
|
||||
struct wlr_keyboard {
|
||||
struct wlr_keyboard_state *state;
|
||||
struct wlr_keyboard_impl *impl;
|
||||
|
||||
struct {
|
||||
|
|
|
@ -4,11 +4,9 @@
|
|||
#include <wayland-server.h>
|
||||
#include <stdint.h>
|
||||
|
||||
struct wlr_pointer_state;
|
||||
struct wlr_pointer_impl;
|
||||
|
||||
struct wlr_pointer {
|
||||
struct wlr_pointer_state *state;
|
||||
struct wlr_pointer_impl *impl;
|
||||
|
||||
struct {
|
||||
|
|
|
@ -11,11 +11,9 @@
|
|||
*/
|
||||
|
||||
struct wlr_tablet_pad_impl;
|
||||
struct wlr_tablet_pad_state;
|
||||
|
||||
struct wlr_tablet_pad {
|
||||
struct wlr_tablet_pad_impl *impl;
|
||||
struct wlr_tablet_pad_state *state;
|
||||
|
||||
struct {
|
||||
struct wl_signal button;
|
||||
|
|
|
@ -5,11 +5,9 @@
|
|||
#include <stdint.h>
|
||||
|
||||
struct wlr_tablet_tool_impl;
|
||||
struct wlr_tablet_tool_state;
|
||||
|
||||
struct wlr_tablet_tool {
|
||||
struct wlr_tablet_tool_impl *impl;
|
||||
struct wlr_tablet_tool_state *state;
|
||||
|
||||
struct {
|
||||
struct wl_signal axis;
|
||||
|
|
|
@ -3,11 +3,9 @@
|
|||
#include <wayland-server.h>
|
||||
#include <stdint.h>
|
||||
|
||||
struct wlr_touch_state;
|
||||
struct wlr_touch_impl;
|
||||
|
||||
struct wlr_touch {
|
||||
struct wlr_touch_state *state;
|
||||
struct wlr_touch_impl *impl;
|
||||
|
||||
struct {
|
||||
|
|
|
@ -227,10 +227,6 @@ static bool wlr_gles2_buffer_is_drm(struct wlr_renderer *_renderer,
|
|||
EGL_TEXTURE_FORMAT, &format);
|
||||
}
|
||||
|
||||
static void wlr_gles2_destroy(struct wlr_renderer *renderer) {
|
||||
free(renderer);
|
||||
}
|
||||
|
||||
static struct wlr_renderer_impl wlr_renderer_impl = {
|
||||
.begin = wlr_gles2_begin,
|
||||
.end = wlr_gles2_end,
|
||||
|
@ -240,7 +236,6 @@ static struct wlr_renderer_impl wlr_renderer_impl = {
|
|||
.render_ellipse = wlr_gles2_render_ellipse,
|
||||
.formats = wlr_gles2_formats,
|
||||
.buffer_is_drm = wlr_gles2_buffer_is_drm,
|
||||
.destroy = wlr_gles2_destroy
|
||||
};
|
||||
|
||||
struct wlr_renderer *wlr_gles2_renderer_init(struct wlr_backend *backend) {
|
||||
|
|
|
@ -8,8 +8,10 @@ void wlr_renderer_init(struct wlr_renderer *renderer,
|
|||
}
|
||||
|
||||
void wlr_renderer_destroy(struct wlr_renderer *r) {
|
||||
if (r && r->impl->destroy) {
|
||||
if (r && r->impl && r->impl->destroy) {
|
||||
r->impl->destroy(r);
|
||||
} else {
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -9,8 +9,10 @@ void wlr_texture_init(struct wlr_texture *texture,
|
|||
}
|
||||
|
||||
void wlr_texture_destroy(struct wlr_texture *texture) {
|
||||
if (texture && texture->impl->destroy) {
|
||||
if (texture && texture->impl && texture->impl->destroy) {
|
||||
texture->impl->destroy(texture);
|
||||
} else {
|
||||
free(texture);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -11,26 +11,19 @@
|
|||
#include <wlr/interfaces/wlr_tablet_pad.h>
|
||||
#include <wlr/util/log.h>
|
||||
|
||||
struct wlr_input_device *wlr_input_device_create(
|
||||
void wlr_input_device_init(struct wlr_input_device *dev,
|
||||
enum wlr_input_device_type type,
|
||||
struct wlr_input_device_impl *impl,
|
||||
struct wlr_input_device_state *state,
|
||||
const char *name, int vendor, int product) {
|
||||
struct wlr_input_device *dev = calloc(1, sizeof(struct wlr_input_device));
|
||||
dev->type = type;
|
||||
dev->impl = impl;
|
||||
dev->state = state;
|
||||
dev->name = strdup(name);
|
||||
dev->vendor = vendor;
|
||||
dev->product = product;
|
||||
return dev;
|
||||
}
|
||||
|
||||
void wlr_input_device_destroy(struct wlr_input_device *dev) {
|
||||
if (!dev) return;
|
||||
if (dev->impl && dev->impl->destroy && dev->state) {
|
||||
dev->impl->destroy(dev->state);
|
||||
}
|
||||
if (dev->_device) {
|
||||
switch (dev->type) {
|
||||
case WLR_INPUT_DEVICE_KEYBOARD:
|
||||
|
@ -55,5 +48,9 @@ void wlr_input_device_destroy(struct wlr_input_device *dev) {
|
|||
}
|
||||
}
|
||||
free(dev->name);
|
||||
free(dev);
|
||||
if (dev->impl && dev->impl->destroy) {
|
||||
dev->impl->destroy(dev);
|
||||
} else {
|
||||
free(dev);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -4,25 +4,23 @@
|
|||
#include <wlr/types/wlr_keyboard.h>
|
||||
#include <wlr/interfaces/wlr_keyboard.h>
|
||||
|
||||
struct wlr_keyboard *wlr_keyboard_create(struct wlr_keyboard_impl *impl,
|
||||
struct wlr_keyboard_state *state) {
|
||||
struct wlr_keyboard *kb = calloc(1, sizeof(struct wlr_keyboard));
|
||||
void wlr_keyboard_init(struct wlr_keyboard *kb,
|
||||
struct wlr_keyboard_impl *impl) {
|
||||
kb->impl = impl;
|
||||
kb->state = state;
|
||||
wl_signal_init(&kb->events.key);
|
||||
return kb;
|
||||
}
|
||||
|
||||
void wlr_keyboard_destroy(struct wlr_keyboard *kb) {
|
||||
if (!kb) return;
|
||||
if (kb->impl) {
|
||||
kb->impl->destroy(kb->state);
|
||||
if (kb->impl && kb->impl->destroy) {
|
||||
kb->impl->destroy(kb);
|
||||
} else {
|
||||
free(kb);
|
||||
}
|
||||
free(kb);
|
||||
}
|
||||
|
||||
void wlr_keyboard_led_update(struct wlr_keyboard *kb, uint32_t leds) {
|
||||
if (kb->impl) {
|
||||
kb->impl->led_update(kb->state, leds);
|
||||
if (kb->impl && kb->impl->led_update) {
|
||||
kb->impl->led_update(kb, leds);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -183,7 +183,7 @@ void wlr_output_destroy(struct wlr_output *output) {
|
|||
free(mode);
|
||||
}
|
||||
list_free(output->modes);
|
||||
if (output->impl->destroy) {
|
||||
if (output->impl && output->impl->destroy) {
|
||||
output->impl->destroy(output);
|
||||
} else {
|
||||
free(output);
|
||||
|
|
|
@ -4,22 +4,20 @@
|
|||
#include <wlr/types/wlr_pointer.h>
|
||||
#include <wlr/interfaces/wlr_pointer.h>
|
||||
|
||||
struct wlr_pointer *wlr_pointer_create(struct wlr_pointer_impl *impl,
|
||||
struct wlr_pointer_state *state) {
|
||||
struct wlr_pointer *pointer = calloc(1, sizeof(struct wlr_pointer));
|
||||
void wlr_pointer_init(struct wlr_pointer *pointer,
|
||||
struct wlr_pointer_impl *impl) {
|
||||
pointer->impl = impl;
|
||||
pointer->state = state;
|
||||
wl_signal_init(&pointer->events.motion);
|
||||
wl_signal_init(&pointer->events.motion_absolute);
|
||||
wl_signal_init(&pointer->events.button);
|
||||
wl_signal_init(&pointer->events.axis);
|
||||
return pointer;
|
||||
}
|
||||
|
||||
void wlr_pointer_destroy(struct wlr_pointer *pointer) {
|
||||
if (!pointer) return;
|
||||
if (pointer->impl) {
|
||||
pointer->impl->destroy(pointer->state);
|
||||
if (pointer->impl && pointer->impl->destroy) {
|
||||
pointer->impl->destroy(pointer);
|
||||
} else {
|
||||
free(pointer);
|
||||
}
|
||||
free(pointer);
|
||||
}
|
||||
|
|
|
@ -4,21 +4,19 @@
|
|||
#include <wlr/types/wlr_tablet_pad.h>
|
||||
#include <wlr/interfaces/wlr_tablet_pad.h>
|
||||
|
||||
struct wlr_tablet_pad *wlr_tablet_pad_create(struct wlr_tablet_pad_impl *impl,
|
||||
struct wlr_tablet_pad_state *state) {
|
||||
struct wlr_tablet_pad *pad = calloc(1, sizeof(struct wlr_tablet_pad));
|
||||
void wlr_tablet_pad_init(struct wlr_tablet_pad *pad,
|
||||
struct wlr_tablet_pad_impl *impl) {
|
||||
pad->impl = impl;
|
||||
pad->state = state;
|
||||
wl_signal_init(&pad->events.button);
|
||||
wl_signal_init(&pad->events.ring);
|
||||
wl_signal_init(&pad->events.strip);
|
||||
return pad;
|
||||
}
|
||||
|
||||
void wlr_tablet_pad_destroy(struct wlr_tablet_pad *pad) {
|
||||
if (!pad) return;
|
||||
if (pad->impl) {
|
||||
pad->impl->destroy(pad->state);
|
||||
if (pad->impl && pad->impl->destroy) {
|
||||
pad->impl->destroy(pad);
|
||||
} else {
|
||||
free(pad);
|
||||
}
|
||||
free(pad);
|
||||
}
|
||||
|
|
|
@ -4,22 +4,20 @@
|
|||
#include <wlr/types/wlr_tablet_tool.h>
|
||||
#include <wlr/interfaces/wlr_tablet_tool.h>
|
||||
|
||||
struct wlr_tablet_tool *wlr_tablet_tool_create(struct wlr_tablet_tool_impl *impl,
|
||||
struct wlr_tablet_tool_state *state) {
|
||||
struct wlr_tablet_tool *tool = calloc(1, sizeof(struct wlr_tablet_tool));
|
||||
void wlr_tablet_tool_init(struct wlr_tablet_tool *tool,
|
||||
struct wlr_tablet_tool_impl *impl) {
|
||||
tool->impl = impl;
|
||||
tool->state = state;
|
||||
wl_signal_init(&tool->events.axis);
|
||||
wl_signal_init(&tool->events.proximity);
|
||||
wl_signal_init(&tool->events.tip);
|
||||
wl_signal_init(&tool->events.button);
|
||||
return tool;
|
||||
}
|
||||
|
||||
void wlr_tablet_tool_destroy(struct wlr_tablet_tool *tool) {
|
||||
if (!tool) return;
|
||||
if (tool->impl) {
|
||||
tool->impl->destroy(tool->state);
|
||||
if (tool->impl && tool->impl->destroy) {
|
||||
tool->impl->destroy(tool);
|
||||
} else {
|
||||
free(tool);
|
||||
}
|
||||
free(tool);
|
||||
}
|
||||
|
|
|
@ -4,22 +4,20 @@
|
|||
#include <wlr/types/wlr_touch.h>
|
||||
#include <wlr/interfaces/wlr_touch.h>
|
||||
|
||||
struct wlr_touch *wlr_touch_create(struct wlr_touch_impl *impl,
|
||||
struct wlr_touch_state *state) {
|
||||
struct wlr_touch *touch = calloc(1, sizeof(struct wlr_touch));
|
||||
void wlr_touch_init(struct wlr_touch *touch,
|
||||
struct wlr_touch_impl *impl) {
|
||||
touch->impl = impl;
|
||||
touch->state = state;
|
||||
wl_signal_init(&touch->events.down);
|
||||
wl_signal_init(&touch->events.up);
|
||||
wl_signal_init(&touch->events.motion);
|
||||
wl_signal_init(&touch->events.cancel);
|
||||
return touch;
|
||||
}
|
||||
|
||||
void wlr_touch_destroy(struct wlr_touch *touch) {
|
||||
if (!touch) return;
|
||||
if (touch->impl) {
|
||||
touch->impl->destroy(touch->state);
|
||||
if (touch->impl && touch->impl->destroy) {
|
||||
touch->impl->destroy(touch);
|
||||
} else {
|
||||
free(touch);
|
||||
}
|
||||
free(touch);
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue