hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-22 21:05:58 +01:00
Code Issues Projects Releases Packages Wiki Activity

Refactor out wlr_input_device_state

Browse source
This commit is contained in:
Dominique Martinet 2017-08-14 14:54:53 +02:00
parent 1e1e9887fb
commit e6ad67911b
8 changed files with 49 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
backend/libinput/backend.c
View file

@ -151,6 +151,7 @@ error_backend:
return NULL; return NULL;
} }
struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev) { struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *_dev) {
return dev->state->handle; struct wlr_libinput_input_device *dev = (struct wlr_libinput_input_device *)_dev;
return dev->handle;
} }

17
backend/libinput/events.c
View file

@ -23,9 +23,10 @@ struct wlr_input_device *get_appropriate_device(
return NULL; return NULL;
} }
static void wlr_libinput_device_destroy(struct wlr_input_device_state *state) { static void wlr_libinput_device_destroy(struct wlr_input_device *_dev) {
libinput_device_unref(state->handle); struct wlr_libinput_input_device *dev = (struct wlr_libinput_input_device *)_dev;
free(state); libinput_device_unref(dev->handle);
free(dev);
} }
static struct wlr_input_device_impl input_device_impl = { static struct wlr_input_device_impl input_device_impl = {
@ -38,12 +39,12 @@ static struct wlr_input_device *allocate_device(
int vendor = libinput_device_get_id_vendor(libinput_dev); int vendor = libinput_device_get_id_vendor(libinput_dev);
int product = libinput_device_get_id_product(libinput_dev); int product = libinput_device_get_id_product(libinput_dev);
const char *name = libinput_device_get_name(libinput_dev); const char *name = libinput_device_get_name(libinput_dev);
struct wlr_input_device_state *devstate = struct wlr_libinput_input_device *wlr_libinput_dev =
calloc(1, sizeof(struct wlr_input_device_state)); calloc(1, sizeof(struct wlr_libinput_input_device));
devstate->handle = libinput_dev; struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device;
wlr_libinput_dev->handle = libinput_dev;
libinput_device_ref(libinput_dev); libinput_device_ref(libinput_dev);
struct wlr_input_device *wlr_dev = wlr_input_device_create( wlr_input_device_init(wlr_dev, type, &input_device_impl,
type, &input_device_impl, devstate,
name, vendor, product); name, vendor, product);
list_add(wlr_devices, wlr_dev); list_add(wlr_devices, wlr_dev);
return wlr_dev; return wlr_dev;

37
backend/wayland/wl_seat.c
View file

@ -16,9 +16,10 @@ static void pointer_handle_enter(void *data, struct wl_pointer *wl_pointer,
uint32_t serial, struct wl_surface *surface, wl_fixed_t surface_x, uint32_t serial, struct wl_surface *surface, wl_fixed_t surface_x,
wl_fixed_t surface_y) { wl_fixed_t surface_y) {
struct wlr_input_device *dev = data; struct wlr_input_device *dev = data;
struct wlr_wl_input_device *wlr_wl_dev = (struct wlr_wl_input_device *)dev;
assert(dev && dev->pointer && dev->pointer->state); assert(dev && dev->pointer && dev->pointer->state);
struct wlr_wl_backend_output* output = 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); assert(output);
dev->pointer->state->current_output = output; dev->pointer->state->current_output = output;
} }
@ -160,11 +161,12 @@ static struct wl_keyboard_listener keyboard_listener = {
.repeat_info = keyboard_handle_repeat_info .repeat_info = keyboard_handle_repeat_info
}; };
static void input_device_destroy(struct wlr_input_device_state *state) { static void input_device_destroy(struct wlr_input_device *_dev) {
wl_signal_emit(&state->backend->backend.events.input_remove, state->wlr_device); struct wlr_wl_input_device *dev = (struct wlr_wl_input_device *)_dev;
if (state->resource) wl_signal_emit(&dev->backend->backend.events.input_remove, &dev->wlr_input_device);
wl_proxy_destroy(state->resource); if (dev->resource)
free(state); wl_proxy_destroy(dev->resource);
free(dev);
} }
static struct wlr_input_device_impl input_device_impl = { static struct wlr_input_device_impl input_device_impl = {
@ -181,25 +183,20 @@ static struct wlr_pointer_impl pointer_impl = {
static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend, static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
enum wlr_input_device_type type) { enum wlr_input_device_type type) {
struct wlr_input_device_state *devstate; struct wlr_wl_input_device *wlr_wl_dev;
if (!(devstate = calloc(1, sizeof(struct wlr_input_device_state)))) { if (!(wlr_wl_dev = calloc(1, sizeof(struct wlr_wl_input_device)))) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno)); wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return NULL; return NULL;
} }
devstate->backend = backend; wlr_wl_dev->backend = backend;
int vendor = 0; int vendor = 0;
int product = 0; int product = 0;
const char *name = "wayland"; const char *name = "wayland";
struct wlr_input_device *wlr_device = wlr_input_device_create( struct wlr_input_device *wlr_device = &wlr_wl_dev->wlr_input_device;
type, &input_device_impl, devstate, wlr_input_device_init(wlr_device, type, &input_device_impl,
name, vendor, product); name, vendor, product);
if (!wlr_device) {
free(devstate);
return NULL;
}
devstate->wlr_device = wlr_device;
list_add(backend->devices, wlr_device); list_add(backend->devices, wlr_device);
return wlr_device; return wlr_device;
} }
@ -223,11 +220,13 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer"); wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer");
return; 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); struct wl_pointer *wl_pointer = wl_seat_get_pointer(wl_seat);
wl_pointer_add_listener(wl_pointer, &pointer_listener, wlr_device); wl_pointer_add_listener(wl_pointer, &pointer_listener, wlr_device);
wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state); wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state);
wlr_device->state->resource = wl_pointer; wlr_wl_device->resource = wl_pointer;
wl_signal_emit(&backend->backend.events.input_add, wlr_device); wl_signal_emit(&backend->backend.events.input_add, wlr_device);
} }
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) { if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
@ -238,11 +237,13 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
wlr_log(L_ERROR, "Unable to allocate wl_pointer device"); wlr_log(L_ERROR, "Unable to allocate wl_pointer device");
return; return;
} }
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); struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat);
wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device); wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device);
wlr_device->keyboard = wlr_keyboard_create(NULL, NULL); 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); wl_signal_emit(&backend->backend.events.input_add, wlr_device);
} }
} }

5
include/backend/libinput.h
View file

@ -2,6 +2,7 @@
#define _WLR_BACKEND_LIBINPUT_INTERNAL_H #define _WLR_BACKEND_LIBINPUT_INTERNAL_H
#include <libinput.h> #include <libinput.h>
#include <wayland-server-core.h> #include <wayland-server-core.h>
#include <wlr/types/wlr_input_device.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
@ -22,7 +23,9 @@ struct wlr_libinput_backend {
list_t *wlr_device_lists; 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; struct libinput_device *handle;
}; };

5
include/backend/wayland.h
View file

@ -41,9 +41,10 @@ struct wlr_wl_backend_output {
void *egl_surface; 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_wl_backend *backend;
struct wlr_input_device *wlr_device;
void *resource; void *resource;
}; };

6
include/wlr/interfaces/wlr_input_device.h
View file

@ -3,13 +3,13 @@
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
struct wlr_input_device_impl { 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, enum wlr_input_device_type type,
struct wlr_input_device_impl *impl, struct wlr_input_device_impl *impl,
struct wlr_input_device_state *state,
const char *name, int vendor, int product); const char *name, int vendor, int product);
void wlr_input_device_destroy(struct wlr_input_device *dev); void wlr_input_device_destroy(struct wlr_input_device *dev);

2
include/wlr/types/wlr_input_device.h
View file

@ -21,11 +21,9 @@ enum wlr_input_device_type {
#include <wlr/types/wlr_tablet_tool.h> #include <wlr/types/wlr_tablet_tool.h>
#include <wlr/types/wlr_tablet_pad.h> #include <wlr/types/wlr_tablet_pad.h>
struct wlr_input_device_state;
struct wlr_input_device_impl; struct wlr_input_device_impl;
struct wlr_input_device { struct wlr_input_device {
struct wlr_input_device_state *state;
struct wlr_input_device_impl *impl; struct wlr_input_device_impl *impl;
enum wlr_input_device_type type; enum wlr_input_device_type type;

13
types/wlr_input_device.c
View file

@ -11,26 +11,19 @@
#include <wlr/interfaces/wlr_tablet_pad.h> #include <wlr/interfaces/wlr_tablet_pad.h>
#include <wlr/util/log.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, enum wlr_input_device_type type,
struct wlr_input_device_impl *impl, struct wlr_input_device_impl *impl,
struct wlr_input_device_state *state,
const char *name, int vendor, int product) { const char *name, int vendor, int product) {
struct wlr_input_device *dev = calloc(1, sizeof(struct wlr_input_device));
dev->type = type; dev->type = type;
dev->impl = impl; dev->impl = impl;
dev->state = state;
dev->name = strdup(name); dev->name = strdup(name);
dev->vendor = vendor; dev->vendor = vendor;
dev->product = product; dev->product = product;
return dev;
} }
void wlr_input_device_destroy(struct wlr_input_device *dev) { void wlr_input_device_destroy(struct wlr_input_device *dev) {
if (!dev) return; if (!dev) return;
if (dev->impl && dev->impl->destroy && dev->state) {
dev->impl->destroy(dev->state);
}
if (dev->_device) { if (dev->_device) {
switch (dev->type) { switch (dev->type) {
case WLR_INPUT_DEVICE_KEYBOARD: case WLR_INPUT_DEVICE_KEYBOARD:
@ -55,5 +48,9 @@ void wlr_input_device_destroy(struct wlr_input_device *dev) {
} }
} }
free(dev->name); free(dev->name);
if (dev->impl && dev->impl->destroy) {
dev->impl->destroy(dev);
} else {
free(dev); free(dev);
} }
}