hyprwm
/
wlroots-hyprland
mirror of https://github.com/hyprwm/wlroots-hyprland.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #85 from martinetd/refactor_states 

Refactor states
This commit is contained in:
Drew DeVault 2017-08-14 10:33:46 -04:00 committed by GitHub
parent 1e1e9887fb e922e62924
commit 53052b3f6e
34 changed files with 183 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
backend/backend.c
View File

@ -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);
}
}

5
backend/libinput/backend.c
View File

@ -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;
}

19
backend/libinput/events.c
View File

@ -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;
}

25
backend/libinput/keyboard.c
View File

@ -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,

8
backend/libinput/pointer.c
View File

@ -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,

8
backend/libinput/tablet_pad.c
View File

@ -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,

8
backend/libinput/tablet_tool.c
View File

@ -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,

8
backend/libinput/touch.c
View File

@ -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,

2
backend/wayland/output.c
View File

@ -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);

94
backend/wayland/wl_seat.c
View File

@ -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);
}
}

5
include/backend/libinput.h
View File

@ -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;
};

8
include/backend/wayland.h
View File

@ -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;
};

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

@ -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);

7
include/wlr/interfaces/wlr_keyboard.h
View File

@ -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

6
include/wlr/interfaces/wlr_pointer.h
View File

@ -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

6
include/wlr/interfaces/wlr_tablet_pad.h
View File

@ -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

6
include/wlr/interfaces/wlr_tablet_tool.h
View File

@ -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

6
include/wlr/interfaces/wlr_touch.h
View File

@ -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

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_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;

2
include/wlr/types/wlr_keyboard.h
View File

@ -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 {

2
include/wlr/types/wlr_pointer.h
View File

@ -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 {

2
include/wlr/types/wlr_tablet_pad.h
View File

@ -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;

2
include/wlr/types/wlr_tablet_tool.h
View File

@ -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;

2
include/wlr/types/wlr_touch.h
View File

@ -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 {

5
render/gles2/renderer.c
View File

@ -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) {

4
render/wlr_renderer.c
View File

@ -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);
}
}

4
render/wlr_texture.c
View File

@ -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);
}
}

15
types/wlr_input_device.c
View File

@ -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);
}
}

18
types/wlr_keyboard.c
View File

@ -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);
}
}

2
types/wlr_output.c
View File

@ -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);

14
types/wlr_pointer.c
View File

@ -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);
}

14
types/wlr_tablet_pad.c
View File

@ -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);
}

14
types/wlr_tablet_tool.c
View File

@ -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);
}

14
types/wlr_touch.c
View File

@ -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);
}