From 86269052eb7be715eba274dffc30c77c11b8309c Mon Sep 17 00:00:00 2001 From: Scott Anderson Date: Mon, 19 Feb 2018 14:26:40 +1300 Subject: [PATCH] Explicitly export EFL symbols --- backend/backend.c | 7 +++++ backend/drm/backend.c | 3 +++ backend/drm/drm.c | 2 ++ backend/headless/backend.c | 3 +++ backend/headless/input_device.c | 3 +++ backend/headless/output.c | 3 +++ backend/libinput/backend.c | 4 +++ backend/libinput/events.c | 2 ++ backend/multi/backend.c | 7 +++++ backend/session/session.c | 8 ++++++ backend/wayland/backend.c | 3 +++ backend/wayland/output.c | 3 +++ backend/wayland/wl_seat.c | 2 ++ backend/x11/backend.c | 5 ++++ include/util/defs.h | 10 +++++++ meson.build | 1 + render/egl.c | 11 ++++++++ render/gles2/renderer.c | 2 ++ render/matrix.c | 9 +++++++ render/wlr_renderer.c | 15 +++++++++++ render/wlr_texture.c | 12 +++++++++ types/wlr_box.c | 7 +++++ types/wlr_compositor.c | 3 +++ types/wlr_cursor.c | 16 ++++++++++++ types/wlr_data_device.c | 7 +++++ types/wlr_gamma_control.c | 3 +++ types/wlr_idle.c | 4 +++ types/wlr_input_device.c | 3 +++ types/wlr_keyboard.c | 9 +++++++ types/wlr_list.c | 12 +++++++++ types/wlr_output.c | 32 +++++++++++++++++++++++ types/wlr_output_damage.c | 8 ++++++ types/wlr_output_layout.c | 15 +++++++++++ types/wlr_pointer.c | 3 +++ types/wlr_primary_selection.c | 8 +++++- types/wlr_region.c | 3 +++ types/wlr_screenshooter.c | 3 +++ types/wlr_seat.c | 46 +++++++++++++++++++++++++++++++++ types/wlr_server_decoration.c | 4 +++ types/wlr_surface.c | 14 +++++++++- types/wlr_tablet_pad.c | 3 +++ types/wlr_tablet_tool.c | 3 +++ types/wlr_touch.c | 3 +++ types/wlr_wl_shell.c | 6 +++++ types/wlr_xcursor_manager.c | 6 +++++ types/wlr_xdg_shell.c | 12 +++++++++ types/wlr_xdg_shell_v6.c | 12 +++++++++ util/log.c | 5 ++++ util/os-compatibility.c | 6 +++++ util/region.c | 4 +++ xcursor/wlr_xcursor.c | 6 +++++ xwayland/selection.c | 4 +++ xwayland/xwayland.c | 5 ++++ xwayland/xwm.c | 9 +++++++ 54 files changed, 397 insertions(+), 2 deletions(-) create mode 100644 include/util/defs.h diff --git a/backend/backend.c b/backend/backend.c index bd8d04d1..c2a487e7 100644 --- a/backend/backend.c +++ b/backend/backend.c @@ -13,7 +13,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_backend_init(struct wlr_backend *backend, const struct wlr_backend_impl *impl) { assert(backend); @@ -23,6 +25,7 @@ void wlr_backend_init(struct wlr_backend *backend, wl_signal_init(&backend->events.new_output); } +WLR_API bool wlr_backend_start(struct wlr_backend *backend) { if (backend->impl->start) { return backend->impl->start(backend); @@ -30,6 +33,7 @@ bool wlr_backend_start(struct wlr_backend *backend) { return true; } +WLR_API void wlr_backend_destroy(struct wlr_backend *backend) { if (!backend) { return; @@ -42,6 +46,7 @@ void wlr_backend_destroy(struct wlr_backend *backend) { } } +WLR_API struct wlr_egl *wlr_backend_get_egl(struct wlr_backend *backend) { if (backend->impl->get_egl) { return backend->impl->get_egl(backend); @@ -49,6 +54,7 @@ struct wlr_egl *wlr_backend_get_egl(struct wlr_backend *backend) { return NULL; } +WLR_API struct wlr_renderer *wlr_backend_get_renderer(struct wlr_backend *backend) { if (backend->impl->get_renderer) { return backend->impl->get_renderer(backend); @@ -79,6 +85,7 @@ static struct wlr_backend *attempt_wl_backend(struct wl_display *display) { return backend; } +WLR_API struct wlr_backend *wlr_backend_autocreate(struct wl_display *display) { struct wlr_backend *backend = wlr_multi_backend_create(display); if (!backend) { diff --git a/backend/drm/backend.c b/backend/drm/backend.c index 47dff227..571c5c9d 100644 --- a/backend/drm/backend.c +++ b/backend/drm/backend.c @@ -13,6 +13,7 @@ #include #include #include "backend/drm/drm.h" +#include "util/defs.h" #include "util/signal.h" static bool wlr_drm_backend_start(struct wlr_backend *backend) { @@ -66,6 +67,7 @@ static struct wlr_backend_impl backend_impl = { .get_renderer = wlr_drm_backend_get_renderer, }; +WLR_API bool wlr_backend_is_drm(struct wlr_backend *b) { return b->impl == &backend_impl; } @@ -117,6 +119,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_drm_backend_destroy(&drm->backend); } +WLR_API struct wlr_backend *wlr_drm_backend_create(struct wl_display *display, struct wlr_session *session, int gpu_fd, struct wlr_backend *parent) { assert(display && session && gpu_fd >= 0); diff --git a/backend/drm/drm.c b/backend/drm/drm.c index e60b7e1c..493ef1f5 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -24,6 +24,7 @@ #include "backend/drm/drm.h" #include "backend/drm/iface.h" #include "backend/drm/util.h" +#include "util/defs.h" #include "util/signal.h" bool wlr_drm_check_features(struct wlr_drm_backend *drm) { @@ -728,6 +729,7 @@ static struct wlr_output_impl output_impl = { .get_gamma_size = wlr_drm_connector_get_gamma_size, }; +WLR_API bool wlr_output_is_drm(struct wlr_output *output) { return output->impl == &output_impl; } diff --git a/backend/headless/backend.c b/backend/headless/backend.c index 663bc13b..49201192 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -7,6 +7,7 @@ #include #include "backend/headless.h" #include "glapi.h" +#include "util/defs.h" static bool backend_start(struct wlr_backend *wlr_backend) { struct wlr_headless_backend *backend = @@ -84,6 +85,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { backend_destroy(&backend->backend); } +WLR_API struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { wlr_log(L_INFO, "Creating headless backend"); @@ -125,6 +127,7 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { return &backend->backend; } +WLR_API bool wlr_backend_is_headless(struct wlr_backend *backend) { return backend->impl == &backend_impl; } diff --git a/backend/headless/input_device.c b/backend/headless/input_device.c index ea335aff..66946f77 100644 --- a/backend/headless/input_device.c +++ b/backend/headless/input_device.c @@ -7,6 +7,7 @@ #include #include #include "backend/headless.h" +#include "util/defs.h" #include "util/signal.h" static void input_device_destroy(struct wlr_input_device *wlr_dev) { @@ -19,10 +20,12 @@ static struct wlr_input_device_impl input_device_impl = { .destroy = input_device_destroy, }; +WLR_API bool wlr_input_device_is_headless(struct wlr_input_device *wlr_dev) { return wlr_dev->impl == &input_device_impl; } +WLR_API struct wlr_input_device *wlr_headless_add_input_device( struct wlr_backend *wlr_backend, enum wlr_input_device_type type) { struct wlr_headless_backend *backend = diff --git a/backend/headless/output.c b/backend/headless/output.c index ba4a094e..70182ea0 100644 --- a/backend/headless/output.c +++ b/backend/headless/output.c @@ -5,6 +5,7 @@ #include #include #include "backend/headless.h" +#include "util/defs.h" #include "util/signal.h" static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, @@ -79,6 +80,7 @@ static const struct wlr_output_impl output_impl = { .swap_buffers = output_swap_buffers, }; +WLR_API bool wlr_output_is_headless(struct wlr_output *wlr_output) { return wlr_output->impl == &output_impl; } @@ -90,6 +92,7 @@ static int signal_frame(void *data) { return 0; } +WLR_API struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, unsigned int width, unsigned int height) { struct wlr_headless_backend *backend = diff --git a/backend/libinput/backend.c b/backend/libinput/backend.c index e2a1165f..41a04a27 100644 --- a/backend/libinput/backend.c +++ b/backend/libinput/backend.c @@ -5,6 +5,7 @@ #include #include #include "backend/libinput.h" +#include "util/defs.h" #include "util/signal.h" static int wlr_libinput_open_restricted(const char *path, @@ -128,6 +129,7 @@ static struct wlr_backend_impl backend_impl = { .destroy = wlr_libinput_backend_destroy }; +WLR_API bool wlr_backend_is_libinput(struct wlr_backend *b) { return b->impl == &backend_impl; } @@ -154,6 +156,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_libinput_backend_destroy(&backend->backend); } +WLR_API struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display, struct wlr_session *session) { assert(display && session); @@ -185,6 +188,7 @@ error_backend: return NULL; } +WLR_API 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; diff --git a/backend/libinput/events.c b/backend/libinput/events.c index 603eed07..7faff92f 100644 --- a/backend/libinput/events.c +++ b/backend/libinput/events.c @@ -6,6 +6,7 @@ #include #include #include "backend/libinput.h" +#include "util/defs.h" #include "util/signal.h" struct wlr_input_device *get_appropriate_device( @@ -54,6 +55,7 @@ static struct wlr_input_device *allocate_device( return wlr_dev; } +WLR_API bool wlr_input_device_is_libinput(struct wlr_input_device *wlr_dev) { return wlr_dev->impl == &input_device_impl; } diff --git a/backend/multi/backend.c b/backend/multi/backend.c index 5cb3fbc5..a1ff288b 100644 --- a/backend/multi/backend.c +++ b/backend/multi/backend.c @@ -6,6 +6,7 @@ #include #include "backend/drm/drm.h" #include "backend/multi.h" +#include "util/defs.h" #include "util/signal.h" struct subbackend_state { @@ -90,6 +91,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { multi_backend_destroy((struct wlr_backend*)backend); } +WLR_API struct wlr_backend *wlr_multi_backend_create(struct wl_display *display) { struct wlr_multi_backend *backend = calloc(1, sizeof(struct wlr_multi_backend)); @@ -110,6 +112,7 @@ struct wlr_backend *wlr_multi_backend_create(struct wl_display *display) { return &backend->backend; } +WLR_API bool wlr_backend_is_multi(struct wlr_backend *b) { return b->impl == &backend_impl; } @@ -143,6 +146,7 @@ static struct subbackend_state *multi_backend_get_subbackend(struct wlr_multi_ba return NULL; } +WLR_API void wlr_multi_backend_add(struct wlr_backend *_multi, struct wlr_backend *backend) { assert(wlr_backend_is_multi(_multi)); @@ -175,6 +179,7 @@ void wlr_multi_backend_add(struct wlr_backend *_multi, wlr_signal_emit_safe(&multi->events.backend_add, backend); } +WLR_API void wlr_multi_backend_remove(struct wlr_backend *_multi, struct wlr_backend *backend) { assert(wlr_backend_is_multi(_multi)); @@ -189,6 +194,7 @@ void wlr_multi_backend_remove(struct wlr_backend *_multi, } } +WLR_API struct wlr_session *wlr_multi_get_session(struct wlr_backend *_backend) { assert(wlr_backend_is_multi(_backend)); @@ -202,6 +208,7 @@ struct wlr_session *wlr_multi_get_session(struct wlr_backend *_backend) { return NULL; } +WLR_API bool wlr_multi_is_empty(struct wlr_backend *_backend) { assert(wlr_backend_is_multi(_backend)); struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend; diff --git a/backend/session/session.c b/backend/session/session.c index 2d5d9776..5e6fd4ea 100644 --- a/backend/session/session.c +++ b/backend/session/session.c @@ -13,6 +13,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" extern const struct session_impl session_logind; @@ -66,6 +67,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_session_destroy(session); } +WLR_API struct wlr_session *wlr_session_create(struct wl_display *disp) { struct wlr_session *session = NULL; const struct session_impl **iter; @@ -122,6 +124,7 @@ error_session: return NULL; } +WLR_API void wlr_session_destroy(struct wlr_session *session) { if (!session) { return; @@ -136,6 +139,7 @@ void wlr_session_destroy(struct wlr_session *session) { session->impl->destroy(session); } +WLR_API int wlr_session_open_file(struct wlr_session *session, const char *path) { int fd = session->impl->open(session, path); if (fd < 0) { @@ -179,6 +183,7 @@ static struct wlr_device *find_device(struct wlr_session *session, int fd) { assert(0); } +WLR_API void wlr_session_close_file(struct wlr_session *session, int fd) { struct wlr_device *dev = find_device(session, fd); @@ -187,6 +192,7 @@ void wlr_session_close_file(struct wlr_session *session, int fd) { free(dev); } +WLR_API void wlr_session_signal_add(struct wlr_session *session, int fd, struct wl_listener *listener) { struct wlr_device *dev = find_device(session, fd); @@ -194,6 +200,7 @@ void wlr_session_signal_add(struct wlr_session *session, int fd, wl_signal_add(&dev->signal, listener); } +WLR_API bool wlr_session_change_vt(struct wlr_session *session, unsigned vt) { if (!session) { return false; @@ -269,6 +276,7 @@ static size_t explicit_find_gpus(struct wlr_session *session, /* Tries to find the primary GPU by checking for the "boot_vga" attribute. * If it's not found, it returns the first valid GPU it finds. */ +WLR_API size_t wlr_session_find_gpus(struct wlr_session *session, size_t ret_len, int *ret) { const char *explicit = getenv("WLR_DRM_DEVICES"); diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c index abb25df5..2289d013 100644 --- a/backend/wayland/backend.c +++ b/backend/wayland/backend.c @@ -12,6 +12,7 @@ #include #include #include "backend/wayland.h" +#include "util/defs.h" #include "util/signal.h" #include "xdg-shell-unstable-v6-client-protocol.h" @@ -128,6 +129,7 @@ static struct wlr_backend_impl backend_impl = { .get_renderer = wlr_wl_backend_get_renderer, }; +WLR_API bool wlr_backend_is_wl(struct wlr_backend *b) { return b->impl == &backend_impl; } @@ -181,6 +183,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_wl_backend_destroy(&backend->backend); } +WLR_API struct wlr_backend *wlr_wl_backend_create(struct wl_display *display, const char *remote) { wlr_log(L_INFO, "Creating wayland backend"); diff --git a/backend/wayland/output.c b/backend/wayland/output.c index fc40dea0..5d0aaece 100644 --- a/backend/wayland/output.c +++ b/backend/wayland/output.c @@ -11,6 +11,7 @@ #include #include #include "backend/wayland.h" +#include "util/defs.h" #include "util/signal.h" #include "xdg-shell-unstable-v6-client-protocol.h" @@ -217,6 +218,7 @@ static struct wlr_output_impl output_impl = { .move_cursor = wlr_wl_output_move_cursor, }; +WLR_API bool wlr_output_is_wl(struct wlr_output *wlr_output) { return wlr_output->impl == &output_impl; } @@ -260,6 +262,7 @@ static struct zxdg_toplevel_v6_listener xdg_toplevel_listener = { .close = xdg_toplevel_handle_close, }; +WLR_API struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) { assert(wlr_backend_is_wl(_backend)); struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend; diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c index b1f7cff6..d6c9926b 100644 --- a/backend/wayland/wl_seat.c +++ b/backend/wayland/wl_seat.c @@ -11,6 +11,7 @@ #include #include #include "backend/wayland.h" +#include "util/defs.h" #include "util/signal.h" static void pointer_handle_enter(void *data, struct wl_pointer *wl_pointer, @@ -205,6 +206,7 @@ static struct wlr_input_device_impl input_device_impl = { .destroy = input_device_destroy }; +WLR_API bool wlr_input_device_is_wl(struct wlr_input_device *dev) { return dev->impl == &input_device_impl; } diff --git a/backend/x11/backend.c b/backend/x11/backend.c index 28a4fcac..72b4b69d 100644 --- a/backend/x11/backend.c +++ b/backend/x11/backend.c @@ -23,6 +23,7 @@ #include #endif #include "backend/x11.h" +#include "util/defs.h" #include "util/signal.h" static struct wlr_backend_impl backend_impl; @@ -289,6 +290,7 @@ static struct wlr_backend_impl backend_impl = { .get_renderer = wlr_x11_backend_get_renderer, }; +WLR_API bool wlr_backend_is_x11(struct wlr_backend *backend) { return backend->impl == &backend_impl; } @@ -299,6 +301,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_x11_backend_destroy(&x11->backend); } +WLR_API struct wlr_backend *wlr_x11_backend_create(struct wl_display *display, const char *x11_display) { struct wlr_x11_backend *x11 = calloc(1, sizeof(*x11)); @@ -418,10 +421,12 @@ static struct wlr_output_impl output_impl = { .swap_buffers = output_swap_buffers, }; +WLR_API bool wlr_output_is_x11(struct wlr_output *wlr_output) { return wlr_output->impl == &output_impl; } +WLR_API bool wlr_input_device_is_x11(struct wlr_input_device *wlr_dev) { return wlr_dev->impl == &input_device_impl; } diff --git a/include/util/defs.h b/include/util/defs.h new file mode 100644 index 00000000..55a21f6b --- /dev/null +++ b/include/util/defs.h @@ -0,0 +1,10 @@ +#ifndef UTIL_DEFS_H +#define UTIL_DEFS_H + +#ifdef __GNUC__ +#define WLR_API __attribute__((visibility("default"))) +#else +#define WLR_API +#endif + +#endif diff --git a/meson.build b/meson.build index 2fc78d33..3ab0b31e 100644 --- a/meson.build +++ b/meson.build @@ -17,6 +17,7 @@ project( so_version = ['0', '0', '0'] add_project_arguments('-Wno-unused-parameter', language: 'c') +add_project_arguments('-fvisibility=hidden', language: 'c') add_project_arguments( '-DWLR_SRC_DIR="@0@"'.format(meson.source_root()), language: 'c', diff --git a/render/egl.c b/render/egl.c index 21c446f1..046eeb36 100644 --- a/render/egl.c +++ b/render/egl.c @@ -6,11 +6,13 @@ #include #include #include "glapi.h" +#include "util/defs.h" // Extension documentation // https://www.khronos.org/registry/EGL/extensions/KHR/EGL_KHR_image_base.txt. // https://cgit.freedesktop.org/mesa/mesa/tree/docs/specs/WL_bind_wayland_display.spec +WLR_API const char *egl_error(void) { switch (eglGetError()) { case EGL_SUCCESS: @@ -83,6 +85,7 @@ static bool egl_get_config(EGLDisplay disp, EGLint *attribs, EGLConfig *out, return false; } +WLR_API bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display, EGLint *config_attribs, EGLint visual_id) { if (!load_glapi()) { @@ -158,6 +161,7 @@ error: return false; } +WLR_API void wlr_egl_finish(struct wlr_egl *egl) { eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (egl->wl_display && eglUnbindWaylandDisplayWL) { @@ -169,6 +173,7 @@ void wlr_egl_finish(struct wlr_egl *egl) { eglReleaseThread(); } +WLR_API bool wlr_egl_bind_display(struct wlr_egl *egl, struct wl_display *local_display) { if (!eglBindWaylandDisplayWL) { return false; @@ -182,6 +187,7 @@ bool wlr_egl_bind_display(struct wlr_egl *egl, struct wl_display *local_display) return false; } +WLR_API bool wlr_egl_query_buffer(struct wlr_egl *egl, struct wl_resource *buf, int attrib, int *value) { if (!eglQueryWaylandBufferWL) { @@ -190,6 +196,7 @@ bool wlr_egl_query_buffer(struct wlr_egl *egl, struct wl_resource *buf, return eglQueryWaylandBufferWL(egl->display, buf, attrib, value); } +WLR_API EGLImage wlr_egl_create_image(struct wlr_egl *egl, EGLenum target, EGLClientBuffer buffer, const EGLint *attribs) { if (!eglCreateImageKHR) { @@ -200,6 +207,7 @@ EGLImage wlr_egl_create_image(struct wlr_egl *egl, EGLenum target, buffer, attribs); } +WLR_API bool wlr_egl_destroy_image(struct wlr_egl *egl, EGLImage image) { if (!eglDestroyImageKHR) { return false; @@ -209,6 +217,7 @@ bool wlr_egl_destroy_image(struct wlr_egl *egl, EGLImage image) { return true; } +WLR_API EGLSurface wlr_egl_create_surface(struct wlr_egl *egl, void *window) { EGLSurface surf = eglCreatePlatformWindowSurfaceEXT(egl->display, egl->config, window, NULL); @@ -235,6 +244,7 @@ int wlr_egl_get_buffer_age(struct wlr_egl *egl, EGLSurface surface) { return buffer_age; } +WLR_API bool wlr_egl_make_current(struct wlr_egl *egl, EGLSurface surface, int *buffer_age) { if (!eglMakeCurrent(egl->display, surface, surface, egl->context)) { @@ -248,6 +258,7 @@ bool wlr_egl_make_current(struct wlr_egl *egl, EGLSurface surface, return true; } +WLR_API bool wlr_egl_swap_buffers(struct wlr_egl *egl, EGLSurface surface, pixman_region32_t *damage) { EGLBoolean ret; diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c index 81a932e6..36486232 100644 --- a/render/gles2/renderer.c +++ b/render/gles2/renderer.c @@ -13,6 +13,7 @@ #include #include "render/gles2.h" #include "glapi.h" +#include "util/defs.h" struct shaders shaders; @@ -266,6 +267,7 @@ static struct wlr_renderer_impl wlr_renderer_impl = { .format_supported = wlr_gles2_format_supported, }; +WLR_API struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_backend *backend) { init_globals(); struct wlr_gles2_renderer *renderer; diff --git a/render/matrix.c b/render/matrix.c index d5d7f49d..ca6b995b 100644 --- a/render/matrix.c +++ b/render/matrix.c @@ -4,12 +4,14 @@ #include #include #include +#include "util/defs.h" /* Obtains the index for the given row/column */ static inline int mind(int row, int col) { return (row - 1) * 4 + col - 1; } +WLR_API void wlr_matrix_identity(float (*output)[16]) { static const float identity[16] = { 1.0f, 0.0f, 0.0f, 0.0f, @@ -20,6 +22,7 @@ void wlr_matrix_identity(float (*output)[16]) { memcpy(*output, identity, sizeof(identity)); } +WLR_API void wlr_matrix_translate(float (*output)[16], float x, float y, float z) { wlr_matrix_identity(output); (*output)[mind(1, 4)] = x; @@ -27,6 +30,7 @@ void wlr_matrix_translate(float (*output)[16], float x, float y, float z) { (*output)[mind(3, 4)] = z; } +WLR_API void wlr_matrix_scale(float (*output)[16], float x, float y, float z) { wlr_matrix_identity(output); (*output)[mind(1, 1)] = x; @@ -34,6 +38,7 @@ void wlr_matrix_scale(float (*output)[16], float x, float y, float z) { (*output)[mind(3, 3)] = z; } +WLR_API void wlr_matrix_rotate(float (*output)[16], float radians) { wlr_matrix_identity(output); float _cos = cosf(radians); @@ -44,6 +49,7 @@ void wlr_matrix_rotate(float (*output)[16], float radians) { (*output)[mind(2, 2)] = _cos; } +WLR_API void wlr_matrix_mul(const float (*x)[16], const float (*y)[16], float (*product)[16]) { float _product[16] = { (*x)[mind(1, 1)] * (*y)[mind(1, 1)] + (*x)[mind(1, 2)] * (*y)[mind(2, 1)] + @@ -120,6 +126,7 @@ static const float transforms[][4] = { }, }; +WLR_API void wlr_matrix_transform(float mat[static 16], enum wl_output_transform transform) { memset(mat, 0, sizeof(*mat) * 16); @@ -138,6 +145,7 @@ void wlr_matrix_transform(float mat[static 16], } // Equivilent to glOrtho(0, width, 0, height, 1, -1) with the transform applied +WLR_API void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height, enum wl_output_transform transform) { memset(mat, 0, sizeof(*mat) * 16); @@ -161,6 +169,7 @@ void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height, mat[15] = 1.0f; } +WLR_API void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box, enum wl_output_transform transform, float rotation, float (*projection)[16]) { diff --git a/render/wlr_renderer.c b/render/wlr_renderer.c index fa6c6fc3..83513452 100644 --- a/render/wlr_renderer.c +++ b/render/wlr_renderer.c @@ -1,12 +1,15 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_renderer_init(struct wlr_renderer *renderer, struct wlr_renderer_impl *impl) { renderer->impl = impl; } +WLR_API void wlr_renderer_destroy(struct wlr_renderer *r) { if (r && r->impl && r->impl->destroy) { r->impl->destroy(r); @@ -15,51 +18,62 @@ void wlr_renderer_destroy(struct wlr_renderer *r) { } } +WLR_API void wlr_renderer_begin(struct wlr_renderer *r, struct wlr_output *o) { r->impl->begin(r, o); } +WLR_API void wlr_renderer_end(struct wlr_renderer *r) { r->impl->end(r); } +WLR_API void wlr_renderer_clear(struct wlr_renderer *r, const float (*color)[4]) { r->impl->clear(r, color); } +WLR_API void wlr_renderer_scissor(struct wlr_renderer *r, struct wlr_box *box) { r->impl->scissor(r, box); } +WLR_API struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r) { return r->impl->texture_create(r); } +WLR_API bool wlr_render_with_matrix(struct wlr_renderer *r, struct wlr_texture *texture, const float (*matrix)[16]) { return r->impl->render_with_matrix(r, texture, matrix); } +WLR_API void wlr_render_colored_quad(struct wlr_renderer *r, const float (*color)[4], const float (*matrix)[16]) { r->impl->render_quad(r, color, matrix); } +WLR_API void wlr_render_colored_ellipse(struct wlr_renderer *r, const float (*color)[4], const float (*matrix)[16]) { r->impl->render_ellipse(r, color, matrix); } +WLR_API const enum wl_shm_format *wlr_renderer_get_formats( struct wlr_renderer *r, size_t *len) { return r->impl->formats(r, len); } +WLR_API bool wlr_renderer_buffer_is_drm(struct wlr_renderer *r, struct wl_resource *buffer) { return r->impl->buffer_is_drm(r, buffer); } +WLR_API bool wlr_renderer_read_pixels(struct wlr_renderer *r, enum wl_shm_format fmt, uint32_t stride, uint32_t width, uint32_t height, uint32_t src_x, uint32_t src_y, uint32_t dst_x, uint32_t dst_y, @@ -68,6 +82,7 @@ bool wlr_renderer_read_pixels(struct wlr_renderer *r, enum wl_shm_format fmt, dst_x, dst_y, data); } +WLR_API bool wlr_renderer_format_supported(struct wlr_renderer *r, enum wl_shm_format fmt) { return r->impl->format_supported(r, fmt); diff --git a/render/wlr_texture.c b/render/wlr_texture.c index a82a16b2..f74ebc66 100644 --- a/render/wlr_texture.c +++ b/render/wlr_texture.c @@ -1,13 +1,16 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_texture_init(struct wlr_texture *texture, struct wlr_texture_impl *impl) { texture->impl = impl; wl_signal_init(&texture->destroy_signal); } +WLR_API void wlr_texture_destroy(struct wlr_texture *texture) { if (texture && texture->impl && texture->impl->destroy) { texture->impl->destroy(texture); @@ -16,16 +19,19 @@ void wlr_texture_destroy(struct wlr_texture *texture) { } } +WLR_API void wlr_texture_bind(struct wlr_texture *texture) { texture->impl->bind(texture); } +WLR_API bool wlr_texture_upload_pixels(struct wlr_texture *texture, uint32_t format, int stride, int width, int height, const unsigned char *pixels) { return texture->impl->upload_pixels(texture, format, stride, width, height, pixels); } +WLR_API bool wlr_texture_update_pixels(struct wlr_texture *texture, enum wl_shm_format format, int stride, int x, int y, int width, int height, const unsigned char *pixels) { @@ -33,31 +39,37 @@ bool wlr_texture_update_pixels(struct wlr_texture *texture, width, height, pixels); } +WLR_API bool wlr_texture_upload_shm(struct wlr_texture *texture, uint32_t format, struct wl_shm_buffer *shm) { return texture->impl->upload_shm(texture, format, shm); } +WLR_API bool wlr_texture_update_shm(struct wlr_texture *texture, uint32_t format, int x, int y, int width, int height, struct wl_shm_buffer *shm) { return texture->impl->update_shm(texture, format, x, y, width, height, shm); } +WLR_API bool wlr_texture_upload_drm(struct wlr_texture *texture, struct wl_resource *drm_buffer) { return texture->impl->upload_drm(texture, drm_buffer); } +WLR_API bool wlr_texture_upload_eglimage(struct wlr_texture *texture, EGLImageKHR image, uint32_t width, uint32_t height) { return texture->impl->upload_eglimage(texture, image, width, height); } +WLR_API void wlr_texture_get_matrix(struct wlr_texture *texture, float (*matrix)[16], const float (*projection)[16], int x, int y) { texture->impl->get_matrix(texture, matrix, projection, x, y); } +WLR_API void wlr_texture_get_buffer_size(struct wlr_texture *texture, struct wl_resource *resource, int *width, int *height) { texture->impl->get_buffer_size(texture, resource, width, height); diff --git a/types/wlr_box.c b/types/wlr_box.c index 2ea743d0..be6ab231 100644 --- a/types/wlr_box.c +++ b/types/wlr_box.c @@ -5,7 +5,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_box_closest_point(const struct wlr_box *box, double x, double y, double *dest_x, double *dest_y) { // find the closest x point @@ -27,10 +29,12 @@ void wlr_box_closest_point(const struct wlr_box *box, double x, double y, } } +WLR_API bool wlr_box_empty(const struct wlr_box *box) { return box == NULL || box->width <= 0 || box->height <= 0; } +WLR_API bool wlr_box_intersection(const struct wlr_box *box_a, const struct wlr_box *box_b, struct wlr_box *dest) { bool a_empty = wlr_box_empty(box_a); @@ -57,6 +61,7 @@ bool wlr_box_intersection(const struct wlr_box *box_a, return !wlr_box_empty(dest); } +WLR_API bool wlr_box_contains_point(const struct wlr_box *box, double x, double y) { if (wlr_box_empty(box)) { return false; @@ -66,6 +71,7 @@ bool wlr_box_contains_point(const struct wlr_box *box, double x, double y) { } } +WLR_API void wlr_box_transform(const struct wlr_box *box, enum wl_output_transform transform, int width, int height, struct wlr_box *dest) { @@ -115,6 +121,7 @@ void wlr_box_transform(const struct wlr_box *box, } } +WLR_API void wlr_box_rotated_bounds(const struct wlr_box *box, float rotation, struct wlr_box *dest) { if (rotation == 0) { diff --git a/types/wlr_compositor.c b/types/wlr_compositor.c index 008f2e51..a8df2c13 100644 --- a/types/wlr_compositor.c +++ b/types/wlr_compositor.c @@ -5,6 +5,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" static const struct wl_compositor_interface wl_compositor_impl; @@ -86,6 +87,7 @@ static void wl_compositor_bind(struct wl_client *wl_client, void *data, wl_resource_get_link(wl_resource)); } +WLR_API void wlr_compositor_destroy(struct wlr_compositor *compositor) { if (compositor == NULL) { return; @@ -170,6 +172,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_compositor_destroy(compositor); } +WLR_API struct wlr_compositor *wlr_compositor_create(struct wl_display *display, struct wlr_renderer *renderer) { struct wlr_compositor *compositor = diff --git a/types/wlr_cursor.c b/types/wlr_cursor.c index 20acebf1..6ebd1ddd 100644 --- a/types/wlr_cursor.c +++ b/types/wlr_cursor.c @@ -7,6 +7,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" struct wlr_cursor_device { @@ -55,6 +56,7 @@ struct wlr_cursor_state { struct wl_listener layout_destroy; }; +WLR_API struct wlr_cursor *wlr_cursor_create() { struct wlr_cursor *cur = calloc(1, sizeof(struct wlr_cursor)); if (!cur) { @@ -149,6 +151,7 @@ static void wlr_cursor_device_destroy(struct wlr_cursor_device *c_device) { free(c_device); } +WLR_API void wlr_cursor_destroy(struct wlr_cursor *cur) { wlr_cursor_detach_output_layout(cur); @@ -232,6 +235,7 @@ static struct wlr_box *get_mapping(struct wlr_cursor *cur, return NULL; } +WLR_API bool wlr_cursor_warp(struct wlr_cursor *cur, struct wlr_input_device *dev, double x, double y) { assert(cur->state->layout); @@ -253,6 +257,7 @@ bool wlr_cursor_warp(struct wlr_cursor *cur, struct wlr_input_device *dev, return result; } +WLR_API void wlr_cursor_warp_absolute(struct wlr_cursor *cur, struct wlr_input_device *dev, double x_mm, double y_mm) { assert(cur->state->layout); @@ -268,6 +273,7 @@ void wlr_cursor_warp_absolute(struct wlr_cursor *cur, wlr_cursor_warp_unchecked(cur, x, y); } +WLR_API void wlr_cursor_move(struct wlr_cursor *cur, struct wlr_input_device *dev, double delta_x, double delta_y) { assert(cur->state->layout); @@ -298,6 +304,7 @@ void wlr_cursor_move(struct wlr_cursor *cur, struct wlr_input_device *dev, wlr_cursor_warp_unchecked(cur, x, y); } +WLR_API void wlr_cursor_set_image(struct wlr_cursor *cur, const uint8_t *pixels, int32_t stride, uint32_t width, uint32_t height, int32_t hotspot_x, int32_t hotspot_y, float scale) { @@ -313,6 +320,7 @@ void wlr_cursor_set_image(struct wlr_cursor *cur, const uint8_t *pixels, } } +WLR_API void wlr_cursor_set_surface(struct wlr_cursor *cur, struct wlr_surface *surface, int32_t hotspot_x, int32_t hotspot_y) { struct wlr_cursor_output_cursor *output_cursor; @@ -478,6 +486,7 @@ static struct wlr_cursor_device *wlr_cursor_device_create( return c_device; } +WLR_API void wlr_cursor_attach_input_device(struct wlr_cursor *cur, struct wlr_input_device *dev) { if (dev->type != WLR_INPUT_DEVICE_POINTER && @@ -499,6 +508,7 @@ void wlr_cursor_attach_input_device(struct wlr_cursor *cur, wlr_cursor_device_create(cur, dev); } +WLR_API void wlr_cursor_detach_input_device(struct wlr_cursor *cur, struct wlr_input_device *dev) { struct wlr_cursor_device *c_device, *tmp = NULL; @@ -571,6 +581,7 @@ static void handle_layout_change(struct wl_listener *listener, void *data) { } } +WLR_API void wlr_cursor_attach_output_layout(struct wlr_cursor *cur, struct wlr_output_layout *l) { wlr_cursor_detach_output_layout(cur); @@ -594,11 +605,13 @@ void wlr_cursor_attach_output_layout(struct wlr_cursor *cur, } } +WLR_API void wlr_cursor_map_to_output(struct wlr_cursor *cur, struct wlr_output *output) { cur->state->mapped_output = output; } +WLR_API void wlr_cursor_map_input_to_output(struct wlr_cursor *cur, struct wlr_input_device *dev, struct wlr_output *output) { struct wlr_cursor_device *c_device = get_cursor_device(cur, dev); @@ -611,6 +624,7 @@ void wlr_cursor_map_input_to_output(struct wlr_cursor *cur, c_device->mapped_output = output; } +WLR_API void wlr_cursor_map_to_region(struct wlr_cursor *cur, struct wlr_box *box) { if (box && wlr_box_empty(box)) { @@ -621,6 +635,7 @@ void wlr_cursor_map_to_region(struct wlr_cursor *cur, cur->state->mapped_box = box; } +WLR_API void wlr_cursor_map_input_to_region(struct wlr_cursor *cur, struct wlr_input_device *dev, struct wlr_box *box) { if (box && wlr_box_empty(box)) { @@ -639,6 +654,7 @@ void wlr_cursor_map_input_to_region(struct wlr_cursor *cur, c_device->mapped_box = box; } +WLR_API bool wlr_cursor_absolute_to_layout_coords(struct wlr_cursor *cur, struct wlr_input_device *device, double x_mm, double y_mm, double width_mm, double height_mm, double *lx, double *ly) { diff --git a/types/wlr_data_device.c b/types/wlr_data_device.c index 50c94bc5..b718df37 100644 --- a/types/wlr_data_device.c +++ b/types/wlr_data_device.c @@ -8,6 +8,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" #define ALL_ACTIONS (WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY | \ @@ -270,6 +271,7 @@ static struct wlr_data_offer *wlr_data_source_send_offer( return offer; } +WLR_API void wlr_seat_client_send_selection(struct wlr_seat_client *seat_client) { if (wl_list_empty(&seat_client->data_devices)) { return; @@ -312,6 +314,7 @@ static void seat_client_selection_data_source_destroy( wlr_signal_emit_safe(&seat->events.selection, seat); } +WLR_API void wlr_seat_set_selection(struct wlr_seat *seat, struct wlr_data_source *source, uint32_t serial) { if (source) { @@ -962,12 +965,14 @@ static void data_source_resource_handle_destroy(struct wl_resource *resource) { free(source); } +WLR_API void wlr_data_source_init(struct wlr_data_source *source) { wl_array_init(&source->mime_types); wl_signal_init(&source->events.destroy); source->actions = -1; } +WLR_API void wlr_data_source_finish(struct wlr_data_source *source) { if (source == NULL) { return; @@ -1059,6 +1064,7 @@ static void data_device_manager_bind(struct wl_client *client, NULL, NULL); } +WLR_API void wlr_data_device_manager_destroy(struct wlr_data_device_manager *manager) { if (!manager) { return; @@ -1075,6 +1081,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_data_device_manager_destroy(manager); } +WLR_API struct wlr_data_device_manager *wlr_data_device_manager_create( struct wl_display *display) { struct wlr_data_device_manager *manager = diff --git a/types/wlr_gamma_control.c b/types/wlr_gamma_control.c index 61c058c4..f3e7bd81 100644 --- a/types/wlr_gamma_control.c +++ b/types/wlr_gamma_control.c @@ -5,6 +5,7 @@ #include #include #include "gamma-control-protocol.h" +#include "util/defs.h" #include "util/signal.h" static void resource_destroy(struct wl_client *client, @@ -146,6 +147,7 @@ static void gamma_control_manager_bind(struct wl_client *client, void *data, manager, NULL); } +WLR_API void wlr_gamma_control_manager_destroy( struct wlr_gamma_control_manager *manager) { if (!manager) { @@ -166,6 +168,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_gamma_control_manager_destroy(manager); } +WLR_API struct wlr_gamma_control_manager *wlr_gamma_control_manager_create( struct wl_display *display) { struct wlr_gamma_control_manager *manager = diff --git a/types/wlr_idle.c b/types/wlr_idle.c index 51963aea..4ced8d65 100644 --- a/types/wlr_idle.c +++ b/types/wlr_idle.c @@ -5,6 +5,7 @@ #include #include #include "idle-protocol.h" +#include "util/defs.h" #include "util/signal.h" static const struct org_kde_kwin_idle_timeout_interface idle_timeout_impl; @@ -157,6 +158,7 @@ static void idle_bind(struct wl_client *wl_client, void *data, wl_resource_set_implementation(wl_resource, &idle_impl, idle, NULL); } +WLR_API void wlr_idle_destroy(struct wlr_idle *idle) { if (!idle) { return; @@ -175,6 +177,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_idle_destroy(idle); } +WLR_API struct wlr_idle *wlr_idle_create(struct wl_display *display) { struct wlr_idle *idle = calloc(1, sizeof(struct wlr_idle)); if (!idle) { @@ -203,6 +206,7 @@ struct wlr_idle *wlr_idle_create(struct wl_display *display) { return idle; } +WLR_API void wlr_idle_notify_activity(struct wlr_idle *idle, struct wlr_seat *seat) { wlr_signal_emit_safe(&idle->activity_notify, seat); } diff --git a/types/wlr_input_device.c b/types/wlr_input_device.c index 65d4b1d6..6e851288 100644 --- a/types/wlr_input_device.c +++ b/types/wlr_input_device.c @@ -10,8 +10,10 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" +WLR_API void wlr_input_device_init(struct wlr_input_device *dev, enum wlr_input_device_type type, struct wlr_input_device_impl *impl, @@ -25,6 +27,7 @@ void wlr_input_device_init(struct wlr_input_device *dev, wl_signal_init(&dev->events.destroy); } +WLR_API void wlr_input_device_destroy(struct wlr_input_device *dev) { if (!dev) { return; diff --git a/types/wlr_keyboard.c b/types/wlr_keyboard.c index 5c0699ff..5bf2e824 100644 --- a/types/wlr_keyboard.c +++ b/types/wlr_keyboard.c @@ -7,6 +7,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" int os_create_anonymous_file(off_t size); @@ -100,6 +101,7 @@ static void keyboard_key_update(struct wlr_keyboard *keyboard, assert(keyboard->num_keycodes <= WLR_KEYBOARD_KEYS_CAP); } +WLR_API void wlr_keyboard_notify_modifiers(struct wlr_keyboard *keyboard, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) { @@ -115,6 +117,7 @@ void wlr_keyboard_notify_modifiers(struct wlr_keyboard *keyboard, } } +WLR_API void wlr_keyboard_notify_key(struct wlr_keyboard *keyboard, struct wlr_event_keyboard_key *event) { if (keyboard->xkb_state == NULL) { @@ -136,6 +139,7 @@ void wlr_keyboard_notify_key(struct wlr_keyboard *keyboard, wlr_signal_emit_safe(&keyboard->events.key, event); } +WLR_API void wlr_keyboard_init(struct wlr_keyboard *kb, struct wlr_keyboard_impl *impl) { kb->impl = impl; @@ -149,6 +153,7 @@ void wlr_keyboard_init(struct wlr_keyboard *kb, kb->repeat_info.delay = 600; } +WLR_API void wlr_keyboard_destroy(struct wlr_keyboard *kb) { if (kb == NULL) { return; @@ -164,12 +169,14 @@ void wlr_keyboard_destroy(struct wlr_keyboard *kb) { free(kb); } +WLR_API void wlr_keyboard_led_update(struct wlr_keyboard *kb, uint32_t leds) { if (kb->impl && kb->impl->led_update) { kb->impl->led_update(kb, leds); } } +WLR_API void wlr_keyboard_set_keymap(struct wlr_keyboard *kb, struct xkb_keymap *keymap) { char *keymap_str = NULL; @@ -247,6 +254,7 @@ err: free(keymap_str); } +WLR_API void wlr_keyboard_set_repeat_info(struct wlr_keyboard *kb, int32_t rate, int32_t delay) { if (kb->repeat_info.rate == rate && kb->repeat_info.delay == delay) { @@ -257,6 +265,7 @@ void wlr_keyboard_set_repeat_info(struct wlr_keyboard *kb, int32_t rate, wlr_signal_emit_safe(&kb->events.repeat_info, kb); } +WLR_API uint32_t wlr_keyboard_get_modifiers(struct wlr_keyboard *kb) { xkb_mod_mask_t mask = kb->modifiers.depressed | kb->modifiers.latched; uint32_t modifiers = 0; diff --git a/types/wlr_list.c b/types/wlr_list.c index 2be0912a..ad8ef095 100644 --- a/types/wlr_list.c +++ b/types/wlr_list.c @@ -5,7 +5,9 @@ #include #include #include +#include "util/defs.h" +WLR_API bool wlr_list_init(struct wlr_list *list) { list->capacity = 10; list->length = 0; @@ -29,16 +31,19 @@ static bool list_resize(struct wlr_list *list) { return true; } +WLR_API void wlr_list_finish(struct wlr_list *list) { free(list->items); } +WLR_API void wlr_list_for_each(struct wlr_list *list, void (*callback)(void *item)) { for (size_t i = 0; i < list->length; i++) { callback(list->items[i]); } } +WLR_API ssize_t wlr_list_push(struct wlr_list *list, void *item) { if (!list_resize(list)) { return -1; @@ -47,6 +52,7 @@ ssize_t wlr_list_push(struct wlr_list *list, void *item) { return list->length; } +WLR_API ssize_t wlr_list_insert(struct wlr_list *list, size_t index, void *item) { if (!list_resize(list)) { return -1; @@ -58,12 +64,14 @@ ssize_t wlr_list_insert(struct wlr_list *list, size_t index, void *item) { return list->length; } +WLR_API void wlr_list_del(struct wlr_list *list, size_t index) { list->length--; memmove(&list->items[index], &list->items[index + 1], sizeof(void *) * (list->length - index)); } +WLR_API void *wlr_list_pop(struct wlr_list *list) { if (list->length == 0) { return NULL; @@ -73,6 +81,7 @@ void *wlr_list_pop(struct wlr_list *list) { return last; } +WLR_API void *wlr_list_peek(struct wlr_list *list) { if (list->length == 0) { return NULL; @@ -80,6 +89,7 @@ void *wlr_list_peek(struct wlr_list *list) { return list->items[list->length - 1]; } +WLR_API ssize_t wlr_list_cat(struct wlr_list *list, const struct wlr_list *source) { size_t old_len = list->length; size_t i; @@ -92,11 +102,13 @@ ssize_t wlr_list_cat(struct wlr_list *list, const struct wlr_list *source) { return list->length; } +WLR_API void wlr_list_qsort(struct wlr_list *list, int compare(const void *left, const void *right)) { qsort(list->items, list->length, sizeof(void *), compare); } +WLR_API ssize_t wlr_list_find(struct wlr_list *list, int compare(const void *item, const void *data), const void *data) { for (size_t i = 0; i < list->length; i++) { diff --git a/types/wlr_output.c b/types/wlr_output.c index 809b1959..b9912520 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -13,6 +13,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" static void wl_output_send_to_resource(struct wl_resource *resource) { @@ -113,6 +114,7 @@ static void wl_output_bind(struct wl_client *wl_client, void *data, wl_output_send_to_resource(wl_resource); } +WLR_API void wlr_output_create_global(struct wlr_output *output) { if (output->wl_global != NULL) { return; @@ -122,6 +124,7 @@ void wlr_output_create_global(struct wlr_output *output) { output->wl_global = wl_global; } +WLR_API void wlr_output_destroy_global(struct wlr_output *output) { if (output->wl_global == NULL) { return; @@ -134,6 +137,7 @@ void wlr_output_destroy_global(struct wlr_output *output) { output->wl_global = NULL; } +WLR_API void wlr_output_update_enabled(struct wlr_output *output, bool enabled) { if (output->enabled == enabled) { return; @@ -148,6 +152,7 @@ static void wlr_output_update_matrix(struct wlr_output *output) { output->transform); } +WLR_API void wlr_output_enable(struct wlr_output *output, bool enable) { if (output->enabled == enable) { return; @@ -158,6 +163,7 @@ void wlr_output_enable(struct wlr_output *output, bool enable) { } } +WLR_API bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode) { if (!output->impl || !output->impl->set_mode) { @@ -166,6 +172,7 @@ bool wlr_output_set_mode(struct wlr_output *output, return output->impl->set_mode(output, mode); } +WLR_API bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width, int32_t height, int32_t refresh) { if (!output->impl || !output->impl->set_custom_mode) { @@ -174,6 +181,7 @@ bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width, return output->impl->set_custom_mode(output, width, height, refresh); } +WLR_API void wlr_output_update_mode(struct wlr_output *output, struct wlr_output_mode *mode) { output->current_mode = mode; @@ -181,6 +189,7 @@ void wlr_output_update_mode(struct wlr_output *output, mode->refresh); } +WLR_API void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, int32_t height, int32_t refresh) { output->width = width; @@ -197,6 +206,7 @@ void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, wlr_signal_emit_safe(&output->events.mode, output); } +WLR_API void wlr_output_set_transform(struct wlr_output *output, enum wl_output_transform transform) { output->impl->transform(output, transform); @@ -211,6 +221,7 @@ void wlr_output_set_transform(struct wlr_output *output, wlr_signal_emit_safe(&output->events.transform, output); } +WLR_API void wlr_output_set_position(struct wlr_output *output, int32_t lx, int32_t ly) { if (lx == output->lx && ly == output->ly) { @@ -227,6 +238,7 @@ void wlr_output_set_position(struct wlr_output *output, int32_t lx, } } +WLR_API void wlr_output_set_scale(struct wlr_output *output, float scale) { if (output->scale == scale) { return; @@ -249,6 +261,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_output_destroy_global(output); } +WLR_API void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend, const struct wlr_output_impl *impl, struct wl_display *display) { assert(impl->make_current && impl->swap_buffers && impl->transform); @@ -276,6 +289,7 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend, output->frame_pending = true; } +WLR_API void wlr_output_destroy(struct wlr_output *output) { if (!output) { return; @@ -307,6 +321,7 @@ void wlr_output_destroy(struct wlr_output *output) { } } +WLR_API void wlr_output_transformed_resolution(struct wlr_output *output, int *width, int *height) { if (output->transform % 2 == 0) { @@ -318,6 +333,7 @@ void wlr_output_transformed_resolution(struct wlr_output *output, } } +WLR_API void wlr_output_effective_resolution(struct wlr_output *output, int *width, int *height) { wlr_output_transformed_resolution(output, width, height); @@ -325,6 +341,7 @@ void wlr_output_effective_resolution(struct wlr_output *output, *height /= output->scale; } +WLR_API bool wlr_output_make_current(struct wlr_output *output, int *buffer_age) { return output->impl->make_current(output, buffer_age); } @@ -460,6 +477,7 @@ surface_damage_finish: pixman_region32_fini(&surface_damage); } +WLR_API bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, pixman_region32_t *damage) { if (output->frame_pending) { @@ -526,6 +544,7 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, return true; } +WLR_API void wlr_output_send_frame(struct wlr_output *output) { output->frame_pending = false; wlr_signal_emit_safe(&output->events.frame, output); @@ -539,6 +558,7 @@ static void schedule_frame_handle_idle_timer(void *data) { } } +WLR_API void wlr_output_schedule_frame(struct wlr_output *output) { if (output->frame_pending || output->idle_frame != NULL) { return; @@ -550,6 +570,7 @@ void wlr_output_schedule_frame(struct wlr_output *output) { wl_event_loop_add_idle(ev, schedule_frame_handle_idle_timer, output); } +WLR_API void wlr_output_set_gamma(struct wlr_output *output, uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b) { if (output->impl->set_gamma) { @@ -557,6 +578,7 @@ void wlr_output_set_gamma(struct wlr_output *output, } } +WLR_API uint32_t wlr_output_get_gamma_size(struct wlr_output *output) { if (!output->impl->get_gamma_size) { return 0; @@ -564,6 +586,7 @@ uint32_t wlr_output_get_gamma_size(struct wlr_output *output) { return output->impl->get_gamma_size(output); } +WLR_API void wlr_output_update_needs_swap(struct wlr_output *output) { output->needs_swap = true; wlr_signal_emit_safe(&output->events.needs_swap, output); @@ -622,6 +645,7 @@ static void output_fullscreen_surface_handle_destroy( output_fullscreen_surface_reset(output); } +WLR_API void wlr_output_set_fullscreen_surface(struct wlr_output *output, struct wlr_surface *surface) { // TODO: hardware fullscreen @@ -648,6 +672,7 @@ void wlr_output_set_fullscreen_surface(struct wlr_output *output, &output->fullscreen_surface_destroy); } +WLR_API struct wlr_output *wlr_output_from_resource(struct wl_resource *resource) { assert(wl_resource_instance_of(resource, &wl_output_interface, &wl_output_impl)); @@ -674,6 +699,7 @@ static void output_cursor_reset(struct wlr_output_cursor *cursor) { } } +WLR_API bool wlr_output_cursor_set_image(struct wlr_output_cursor *cursor, const uint8_t *pixels, int32_t stride, uint32_t width, uint32_t height, int32_t hotspot_x, int32_t hotspot_y) { @@ -781,6 +807,7 @@ static void output_cursor_handle_destroy(struct wl_listener *listener, output_cursor_reset(cursor); } +WLR_API void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor, struct wlr_surface *surface, int32_t hotspot_x, int32_t hotspot_y) { if (surface && strcmp(surface->role, "wl_pointer-cursor") != 0) { @@ -841,6 +868,7 @@ void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor, } } +WLR_API bool wlr_output_cursor_move(struct wlr_output_cursor *cursor, double x, double y) { if (cursor->x == x && cursor->y == y) { @@ -868,6 +896,7 @@ bool wlr_output_cursor_move(struct wlr_output_cursor *cursor, return cursor->output->impl->move_cursor(cursor->output, (int)x, (int)y); } +WLR_API struct wlr_output_cursor *wlr_output_cursor_create(struct wlr_output *output) { struct wlr_output_cursor *cursor = calloc(1, sizeof(struct wlr_output_cursor)); @@ -884,6 +913,7 @@ struct wlr_output_cursor *wlr_output_cursor_create(struct wlr_output *output) { return cursor; } +WLR_API void wlr_output_cursor_destroy(struct wlr_output_cursor *cursor) { if (cursor == NULL) { return; @@ -906,6 +936,7 @@ void wlr_output_cursor_destroy(struct wlr_output_cursor *cursor) { } +WLR_API enum wl_output_transform wlr_output_transform_invert( enum wl_output_transform tr) { if ((tr & WL_OUTPUT_TRANSFORM_90) && !(tr & WL_OUTPUT_TRANSFORM_FLIPPED)) { @@ -914,6 +945,7 @@ enum wl_output_transform wlr_output_transform_invert( return tr; } +WLR_API enum wl_output_transform wlr_output_transform_compose( enum wl_output_transform tr_a, enum wl_output_transform tr_b) { uint32_t flipped = (tr_a ^ tr_b) & WL_OUTPUT_TRANSFORM_FLIPPED; diff --git a/types/wlr_output_damage.c b/types/wlr_output_damage.c index b3636c37..d5455b40 100644 --- a/types/wlr_output_damage.c +++ b/types/wlr_output_damage.c @@ -5,6 +5,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" static void output_handle_destroy(struct wl_listener *listener, void *data) { @@ -50,6 +51,7 @@ static void output_handle_frame(struct wl_listener *listener, void *data) { wlr_signal_emit_safe(&output_damage->events.frame, output_damage); } +WLR_API struct wlr_output_damage *wlr_output_damage_create(struct wlr_output *output) { struct wlr_output_damage *output_damage = calloc(1, sizeof(struct wlr_output_damage)); @@ -82,6 +84,7 @@ struct wlr_output_damage *wlr_output_damage_create(struct wlr_output *output) { return output_damage; } +WLR_API void wlr_output_damage_destroy(struct wlr_output_damage *output_damage) { if (output_damage == NULL) { return; @@ -100,6 +103,7 @@ void wlr_output_damage_destroy(struct wlr_output_damage *output_damage) { free(output_damage); } +WLR_API bool wlr_output_damage_make_current(struct wlr_output_damage *output_damage, bool *needs_swap, pixman_region32_t *damage) { struct wlr_output *output = output_damage->output; @@ -131,6 +135,7 @@ bool wlr_output_damage_make_current(struct wlr_output_damage *output_damage, return true; } +WLR_API bool wlr_output_damage_swap_buffers(struct wlr_output_damage *output_damage, struct timespec *when, pixman_region32_t *damage) { if (!wlr_output_swap_buffers(output_damage->output, when, damage)) { @@ -148,6 +153,7 @@ bool wlr_output_damage_swap_buffers(struct wlr_output_damage *output_damage, return true; } +WLR_API void wlr_output_damage_add(struct wlr_output_damage *output_damage, pixman_region32_t *damage) { int width, height; @@ -160,6 +166,7 @@ void wlr_output_damage_add(struct wlr_output_damage *output_damage, wlr_output_schedule_frame(output_damage->output); } +WLR_API void wlr_output_damage_add_whole(struct wlr_output_damage *output_damage) { int width, height; wlr_output_transformed_resolution(output_damage->output, &width, &height); @@ -170,6 +177,7 @@ void wlr_output_damage_add_whole(struct wlr_output_damage *output_damage) { wlr_output_schedule_frame(output_damage->output); } +WLR_API void wlr_output_damage_add_box(struct wlr_output_damage *output_damage, struct wlr_box *box) { int width, height; diff --git a/types/wlr_output_layout.c b/types/wlr_output_layout.c index db0389bd..048051c0 100644 --- a/types/wlr_output_layout.c +++ b/types/wlr_output_layout.c @@ -6,6 +6,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" struct wlr_output_layout_state { @@ -25,6 +26,7 @@ struct wlr_output_layout_output_state { struct wl_listener output_destroy; }; +WLR_API struct wlr_output_layout *wlr_output_layout_create() { struct wlr_output_layout *layout = calloc(1, sizeof(struct wlr_output_layout)); @@ -57,6 +59,7 @@ static void wlr_output_layout_output_destroy( free(l_output); } +WLR_API void wlr_output_layout_destroy(struct wlr_output_layout *layout) { if (!layout) { return; @@ -189,6 +192,7 @@ static struct wlr_output_layout_output *wlr_output_layout_output_create( return l_output; } +WLR_API void wlr_output_layout_add(struct wlr_output_layout *layout, struct wlr_output *output, int x, int y) { struct wlr_output_layout_output *l_output = @@ -208,6 +212,7 @@ void wlr_output_layout_add(struct wlr_output_layout *layout, wlr_signal_emit_safe(&layout->events.add, l_output); } +WLR_API struct wlr_output_layout_output *wlr_output_layout_get( struct wlr_output_layout *layout, struct wlr_output *reference) { struct wlr_output_layout_output *l_output; @@ -219,6 +224,7 @@ struct wlr_output_layout_output *wlr_output_layout_get( return NULL; } +WLR_API bool wlr_output_layout_contains_point(struct wlr_output_layout *layout, struct wlr_output *reference, int x, int y) { if (reference) { @@ -231,6 +237,7 @@ bool wlr_output_layout_contains_point(struct wlr_output_layout *layout, } } +WLR_API bool wlr_output_layout_intersects(struct wlr_output_layout *layout, struct wlr_output *reference, const struct wlr_box *target_box) { struct wlr_box out_box; @@ -257,6 +264,7 @@ bool wlr_output_layout_intersects(struct wlr_output_layout *layout, } } +WLR_API struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout, double x, double y) { struct wlr_output_layout_output *l_output; @@ -269,6 +277,7 @@ struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout, return NULL; } +WLR_API void wlr_output_layout_move(struct wlr_output_layout *layout, struct wlr_output *output, int x, int y) { struct wlr_output_layout_output *l_output = @@ -283,6 +292,7 @@ void wlr_output_layout_move(struct wlr_output_layout *layout, } } +WLR_API void wlr_output_layout_remove(struct wlr_output_layout *layout, struct wlr_output *output) { struct wlr_output_layout_output *l_output = @@ -294,6 +304,7 @@ void wlr_output_layout_remove(struct wlr_output_layout *layout, wlr_output_destroy_global(output); } +WLR_API void wlr_output_layout_output_coords(struct wlr_output_layout *layout, struct wlr_output *reference, double *x, double *y) { assert(layout && reference); @@ -310,6 +321,7 @@ void wlr_output_layout_output_coords(struct wlr_output_layout *layout, } } +WLR_API void wlr_output_layout_closest_point(struct wlr_output_layout *layout, struct wlr_output *reference, double x, double y, double *dest_x, double *dest_y) { @@ -343,6 +355,7 @@ void wlr_output_layout_closest_point(struct wlr_output_layout *layout, *dest_y = min_y; } +WLR_API struct wlr_box *wlr_output_layout_get_box( struct wlr_output_layout *layout, struct wlr_output *reference) { struct wlr_output_layout_output *l_output; @@ -387,6 +400,7 @@ struct wlr_box *wlr_output_layout_get_box( // not reached } +WLR_API void wlr_output_layout_add_auto(struct wlr_output_layout *layout, struct wlr_output *output) { struct wlr_output_layout_output *l_output = @@ -405,6 +419,7 @@ void wlr_output_layout_add_auto(struct wlr_output_layout *layout, wlr_signal_emit_safe(&layout->events.add, l_output); } +WLR_API struct wlr_output *wlr_output_layout_get_center_output( struct wlr_output_layout *layout) { if (wl_list_empty(&layout->outputs)) { diff --git a/types/wlr_pointer.c b/types/wlr_pointer.c index bc9efd8c..705805d5 100644 --- a/types/wlr_pointer.c +++ b/types/wlr_pointer.c @@ -3,7 +3,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_pointer_init(struct wlr_pointer *pointer, struct wlr_pointer_impl *impl) { pointer->impl = impl; @@ -13,6 +15,7 @@ void wlr_pointer_init(struct wlr_pointer *pointer, wl_signal_init(&pointer->events.axis); } +WLR_API void wlr_pointer_destroy(struct wlr_pointer *pointer) { if (pointer && pointer->impl && pointer->impl->destroy) { pointer->impl->destroy(pointer); diff --git a/types/wlr_primary_selection.c b/types/wlr_primary_selection.c index 9c267405..de1b129a 100644 --- a/types/wlr_primary_selection.c +++ b/types/wlr_primary_selection.c @@ -7,6 +7,7 @@ #include #include #include "gtk-primary-selection-protocol.h" +#include "util/defs.h" #include "util/signal.h" static const struct gtk_primary_selection_offer_interface offer_impl; @@ -173,6 +174,7 @@ static void source_resource_handle_destroy(struct wl_resource *resource) { } +WLR_API void wlr_seat_client_send_primary_selection( struct wlr_seat_client *seat_client) { if (wl_list_empty(&seat_client->primary_selection_devices)) { @@ -216,6 +218,7 @@ static void seat_client_primary_selection_source_destroy( wlr_signal_emit_safe(&seat->events.primary_selection, seat); } +WLR_API void wlr_seat_set_primary_selection(struct wlr_seat *seat, struct wlr_primary_selection_source *source, uint32_t serial) { if (source) { @@ -283,13 +286,14 @@ static void device_resource_handle_destroy(struct wl_resource *resource) { wl_list_remove(wl_resource_get_link(resource)); } - +WLR_API void wlr_primary_selection_source_init( struct wlr_primary_selection_source *source) { wl_array_init(&source->mime_types); wl_signal_init(&source->events.destroy); } +WLR_API void wlr_primary_selection_source_finish( struct wlr_primary_selection_source *source) { if (source == NULL) { @@ -382,6 +386,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_primary_selection_device_manager_destroy(manager); } +WLR_API struct wlr_primary_selection_device_manager * wlr_primary_selection_device_manager_create( struct wl_display *display) { @@ -404,6 +409,7 @@ struct wlr_primary_selection_device_manager * return manager; } +WLR_API void wlr_primary_selection_device_manager_destroy( struct wlr_primary_selection_device_manager *manager) { if (manager == NULL) { diff --git a/types/wlr_region.c b/types/wlr_region.c index 6309c1a9..2d34a6a2 100644 --- a/types/wlr_region.c +++ b/types/wlr_region.c @@ -4,6 +4,7 @@ #include #include #include +#include "util/defs.h" static void region_add(struct wl_client *client, struct wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height) { @@ -38,6 +39,7 @@ static void destroy_region(struct wl_resource *resource) { free(reg); } +WLR_API void wlr_region_create(struct wl_client *client, struct wl_resource *res, uint32_t id) { pixman_region32_t *region = calloc(1, sizeof(pixman_region32_t)); @@ -59,6 +61,7 @@ void wlr_region_create(struct wl_client *client, struct wl_resource *res, destroy_region); } +WLR_API pixman_region32_t *wlr_region_from_resource(struct wl_resource *resource) { assert(wl_resource_instance_of(resource, &wl_region_interface, ®ion_impl)); diff --git a/types/wlr_screenshooter.c b/types/wlr_screenshooter.c index e756b6aa..e4407135 100644 --- a/types/wlr_screenshooter.c +++ b/types/wlr_screenshooter.c @@ -8,6 +8,7 @@ #include #include #include "screenshooter-protocol.h" +#include "util/defs.h" static struct wlr_screenshot *screenshot_from_resource( struct wl_resource *resource) { @@ -168,6 +169,7 @@ static void screenshooter_bind(struct wl_client *wl_client, void *data, screenshooter, NULL); } +WLR_API void wlr_screenshooter_destroy(struct wlr_screenshooter *screenshooter) { if (!screenshooter) { return; @@ -187,6 +189,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_screenshooter_destroy(screenshooter); } +WLR_API struct wlr_screenshooter *wlr_screenshooter_create(struct wl_display *display) { struct wlr_screenshooter *screenshooter = calloc(1, sizeof(struct wlr_screenshooter)); diff --git a/types/wlr_seat.c b/types/wlr_seat.c index 93f6d872..b424de7b 100644 --- a/types/wlr_seat.c +++ b/types/wlr_seat.c @@ -9,6 +9,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" static void resource_destroy(struct wl_client *client, @@ -356,6 +357,7 @@ static const struct wlr_touch_grab_interface default_touch_grab_impl = { }; +WLR_API void wlr_seat_destroy(struct wlr_seat *seat) { if (!seat) { return; @@ -396,6 +398,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_seat_destroy(seat); } +WLR_API struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name) { struct wlr_seat *wlr_seat = calloc(1, sizeof(struct wlr_seat)); if (!wlr_seat) { @@ -489,6 +492,7 @@ struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name) { return wlr_seat; } +WLR_API struct wlr_seat_client *wlr_seat_client_for_wl_client(struct wlr_seat *wlr_seat, struct wl_client *wl_client) { assert(wlr_seat); @@ -501,6 +505,7 @@ struct wlr_seat_client *wlr_seat_client_for_wl_client(struct wlr_seat *wlr_seat, return NULL; } +WLR_API void wlr_seat_set_capabilities(struct wlr_seat *wlr_seat, uint32_t capabilities) { wlr_seat->capabilities = capabilities; @@ -510,6 +515,7 @@ void wlr_seat_set_capabilities(struct wlr_seat *wlr_seat, } } +WLR_API void wlr_seat_set_name(struct wlr_seat *wlr_seat, const char *name) { free(wlr_seat->name); wlr_seat->name = strdup(name); @@ -519,6 +525,7 @@ void wlr_seat_set_name(struct wlr_seat *wlr_seat, const char *name) { } } +WLR_API bool wlr_seat_pointer_surface_has_focus(struct wlr_seat *wlr_seat, struct wlr_surface *surface) { return surface == wlr_seat->pointer_state.focused_surface; @@ -542,6 +549,7 @@ static void pointer_resource_destroy_notify(struct wl_listener *listener, wlr_seat_pointer_clear_focus(state->seat); } +WLR_API void wlr_seat_pointer_enter(struct wlr_seat *wlr_seat, struct wlr_surface *surface, double sx, double sy) { assert(wlr_seat); @@ -605,10 +613,12 @@ void wlr_seat_pointer_enter(struct wlr_seat *wlr_seat, // TODO: send focus change event } +WLR_API void wlr_seat_pointer_clear_focus(struct wlr_seat *wlr_seat) { wlr_seat_pointer_enter(wlr_seat, NULL, 0, 0); } +WLR_API void wlr_seat_pointer_send_motion(struct wlr_seat *wlr_seat, uint32_t time, double sx, double sy) { struct wlr_seat_client *client = wlr_seat->pointer_state.focused_client; @@ -624,6 +634,7 @@ void wlr_seat_pointer_send_motion(struct wlr_seat *wlr_seat, uint32_t time, } } +WLR_API uint32_t wlr_seat_pointer_send_button(struct wlr_seat *wlr_seat, uint32_t time, uint32_t button, uint32_t state) { struct wlr_seat_client *client = wlr_seat->pointer_state.focused_client; @@ -640,6 +651,7 @@ uint32_t wlr_seat_pointer_send_button(struct wlr_seat *wlr_seat, uint32_t time, return serial; } +WLR_API void wlr_seat_pointer_send_axis(struct wlr_seat *wlr_seat, uint32_t time, enum wlr_axis_orientation orientation, double value) { struct wlr_seat_client *client = wlr_seat->pointer_state.focused_client; @@ -660,6 +672,7 @@ void wlr_seat_pointer_send_axis(struct wlr_seat *wlr_seat, uint32_t time, } } +WLR_API void wlr_seat_pointer_start_grab(struct wlr_seat *wlr_seat, struct wlr_seat_pointer_grab *grab) { assert(wlr_seat); @@ -670,6 +683,7 @@ void wlr_seat_pointer_start_grab(struct wlr_seat *wlr_seat, wlr_signal_emit_safe(&wlr_seat->events.pointer_grab_begin, grab); } +WLR_API void wlr_seat_pointer_end_grab(struct wlr_seat *wlr_seat) { struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab; if (grab != wlr_seat->pointer_state.default_grab) { @@ -681,12 +695,14 @@ void wlr_seat_pointer_end_grab(struct wlr_seat *wlr_seat) { } } +WLR_API void wlr_seat_pointer_notify_enter(struct wlr_seat *wlr_seat, struct wlr_surface *surface, double sx, double sy) { struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab; grab->interface->enter(grab, surface, sx, sy); } +WLR_API void wlr_seat_pointer_notify_motion(struct wlr_seat *wlr_seat, uint32_t time, double sx, double sy) { clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event); @@ -694,6 +710,7 @@ void wlr_seat_pointer_notify_motion(struct wlr_seat *wlr_seat, uint32_t time, grab->interface->motion(grab, time, sx, sy); } +WLR_API uint32_t wlr_seat_pointer_notify_button(struct wlr_seat *wlr_seat, uint32_t time, uint32_t button, uint32_t state) { clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event); @@ -717,6 +734,7 @@ uint32_t wlr_seat_pointer_notify_button(struct wlr_seat *wlr_seat, return serial; } +WLR_API void wlr_seat_pointer_notify_axis(struct wlr_seat *wlr_seat, uint32_t time, enum wlr_axis_orientation orientation, double value) { clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event); @@ -724,10 +742,12 @@ void wlr_seat_pointer_notify_axis(struct wlr_seat *wlr_seat, uint32_t time, grab->interface->axis(grab, time, orientation, value); } +WLR_API bool wlr_seat_pointer_has_grab(struct wlr_seat *seat) { return seat->pointer_state.grab->interface != &default_pointer_grab_impl; } +WLR_API void wlr_seat_keyboard_send_key(struct wlr_seat *wlr_seat, uint32_t time, uint32_t key, uint32_t state) { struct wlr_seat_client *client = wlr_seat->keyboard_state.focused_client; @@ -770,6 +790,7 @@ static void handle_keyboard_destroy(struct wl_listener *listener, void *data) { state->keyboard = NULL; } +WLR_API void wlr_seat_set_keyboard(struct wlr_seat *seat, struct wlr_input_device *device) { // TODO call this on device key event before the event reaches the @@ -814,10 +835,12 @@ void wlr_seat_set_keyboard(struct wlr_seat *seat, } } +WLR_API struct wlr_keyboard *wlr_seat_get_keyboard(struct wlr_seat *seat) { return seat->keyboard_state.keyboard; } +WLR_API void wlr_seat_keyboard_start_grab(struct wlr_seat *wlr_seat, struct wlr_seat_keyboard_grab *grab) { grab->seat = wlr_seat; @@ -826,6 +849,7 @@ void wlr_seat_keyboard_start_grab(struct wlr_seat *wlr_seat, wlr_signal_emit_safe(&wlr_seat->events.keyboard_grab_begin, grab); } +WLR_API void wlr_seat_keyboard_end_grab(struct wlr_seat *wlr_seat) { struct wlr_seat_keyboard_grab *grab = wlr_seat->keyboard_state.grab; @@ -856,6 +880,7 @@ static void keyboard_resource_destroy_notify(struct wl_listener *listener, wlr_seat_keyboard_clear_focus(state->seat); } +WLR_API void wlr_seat_keyboard_send_modifiers(struct wlr_seat *seat, struct wlr_keyboard_modifiers *modifiers) { struct wlr_seat_client *client = seat->keyboard_state.focused_client; @@ -876,6 +901,7 @@ void wlr_seat_keyboard_send_modifiers(struct wlr_seat *seat, } } +WLR_API void wlr_seat_keyboard_enter(struct wlr_seat *seat, struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes, struct wlr_keyboard_modifiers *modifiers) { @@ -955,6 +981,7 @@ void wlr_seat_keyboard_enter(struct wlr_seat *seat, } } +WLR_API void wlr_seat_keyboard_notify_enter(struct wlr_seat *seat, struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes, struct wlr_keyboard_modifiers *modifiers) { @@ -962,15 +989,18 @@ void wlr_seat_keyboard_notify_enter(struct wlr_seat *seat, grab->interface->enter(grab, surface, keycodes, num_keycodes, modifiers); } +WLR_API void wlr_seat_keyboard_clear_focus(struct wlr_seat *seat) { // TODO respect grabs here? wlr_seat_keyboard_enter(seat, NULL, NULL, 0, NULL); } +WLR_API bool wlr_seat_keyboard_has_grab(struct wlr_seat *seat) { return seat->keyboard_state.grab->interface != &default_keyboard_grab_impl; } +WLR_API void wlr_seat_keyboard_notify_modifiers(struct wlr_seat *seat, struct wlr_keyboard_modifiers *modifiers) { clock_gettime(CLOCK_MONOTONIC, &seat->last_event); @@ -978,6 +1008,7 @@ void wlr_seat_keyboard_notify_modifiers(struct wlr_seat *seat, grab->interface->modifiers(grab, modifiers); } +WLR_API void wlr_seat_keyboard_notify_key(struct wlr_seat *seat, uint32_t time, uint32_t key, uint32_t state) { clock_gettime(CLOCK_MONOTONIC, &seat->last_event); @@ -985,6 +1016,7 @@ void wlr_seat_keyboard_notify_key(struct wlr_seat *seat, uint32_t time, grab->interface->key(grab, time, key, state); } +WLR_API void wlr_seat_touch_start_grab(struct wlr_seat *wlr_seat, struct wlr_seat_touch_grab *grab) { grab->seat = wlr_seat; @@ -993,6 +1025,7 @@ void wlr_seat_touch_start_grab(struct wlr_seat *wlr_seat, wlr_signal_emit_safe(&wlr_seat->events.touch_grab_begin, grab); } +WLR_API void wlr_seat_touch_end_grab(struct wlr_seat *wlr_seat) { struct wlr_seat_touch_grab *grab = wlr_seat->touch_state.grab; @@ -1072,6 +1105,7 @@ static struct wlr_touch_point *touch_point_create( return point; } +WLR_API struct wlr_touch_point *wlr_seat_touch_get_point( struct wlr_seat *seat, int32_t touch_id) { struct wlr_touch_point *point = NULL; @@ -1084,6 +1118,7 @@ struct wlr_touch_point *wlr_seat_touch_get_point( return NULL; } +WLR_API uint32_t wlr_seat_touch_notify_down(struct wlr_seat *seat, struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx, double sy) { @@ -1106,6 +1141,7 @@ uint32_t wlr_seat_touch_notify_down(struct wlr_seat *seat, return serial; } +WLR_API void wlr_seat_touch_notify_up(struct wlr_seat *seat, uint32_t time, int32_t touch_id) { clock_gettime(CLOCK_MONOTONIC, &seat->last_event); @@ -1121,6 +1157,7 @@ void wlr_seat_touch_notify_up(struct wlr_seat *seat, uint32_t time, touch_point_destroy(point); } +WLR_API void wlr_seat_touch_notify_motion(struct wlr_seat *seat, uint32_t time, int32_t touch_id, double sx, double sy) { clock_gettime(CLOCK_MONOTONIC, &seat->last_event); @@ -1168,6 +1205,7 @@ static void touch_point_set_focus(struct wlr_touch_point *point, } } +WLR_API void wlr_seat_touch_point_focus(struct wlr_seat *seat, struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx, double sy) { @@ -1186,6 +1224,7 @@ void wlr_seat_touch_point_focus(struct wlr_seat *seat, } } +WLR_API void wlr_seat_touch_point_clear_focus(struct wlr_seat *seat, uint32_t time, int32_t touch_id) { struct wlr_touch_point *point = wlr_seat_touch_get_point(seat, touch_id); @@ -1197,6 +1236,7 @@ void wlr_seat_touch_point_clear_focus(struct wlr_seat *seat, uint32_t time, touch_point_clear_focus(point); } +WLR_API uint32_t wlr_seat_touch_send_down(struct wlr_seat *seat, struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx, double sy) { @@ -1217,6 +1257,7 @@ uint32_t wlr_seat_touch_send_down(struct wlr_seat *seat, return serial; } +WLR_API void wlr_seat_touch_send_up(struct wlr_seat *seat, uint32_t time, int32_t touch_id) { struct wlr_touch_point *point = wlr_seat_touch_get_point(seat, touch_id); if (!point) { @@ -1232,6 +1273,7 @@ void wlr_seat_touch_send_up(struct wlr_seat *seat, uint32_t time, int32_t touch_ } } +WLR_API void wlr_seat_touch_send_motion(struct wlr_seat *seat, uint32_t time, int32_t touch_id, double sx, double sy) { struct wlr_touch_point *point = wlr_seat_touch_get_point(seat, touch_id); @@ -1248,19 +1290,23 @@ void wlr_seat_touch_send_motion(struct wlr_seat *seat, uint32_t time, int32_t to } } +WLR_API int wlr_seat_touch_num_points(struct wlr_seat *seat) { return wl_list_length(&seat->touch_state.touch_points); } +WLR_API bool wlr_seat_touch_has_grab(struct wlr_seat *seat) { return seat->touch_state.grab->interface != &default_touch_grab_impl; } +WLR_API bool wlr_seat_validate_grab_serial(struct wlr_seat *seat, uint32_t serial) { return serial == seat->pointer_state.grab_serial || serial == seat->touch_state.grab_serial; } +WLR_API struct wlr_seat_client *wlr_seat_client_from_resource( struct wl_resource *resource) { assert(wl_resource_instance_of(resource, &wl_seat_interface, diff --git a/types/wlr_server_decoration.c b/types/wlr_server_decoration.c index 6d332033..e04e5267 100644 --- a/types/wlr_server_decoration.c +++ b/types/wlr_server_decoration.c @@ -4,6 +4,7 @@ #include #include #include "server-decoration-protocol.h" +#include "util/defs.h" #include "util/signal.h" static const struct org_kde_kwin_server_decoration_interface @@ -127,6 +128,7 @@ static const struct org_kde_kwin_server_decoration_manager_interface .create = server_decoration_manager_handle_create, }; +WLR_API void wlr_server_decoration_manager_set_default_mode( struct wlr_server_decoration_manager *manager, uint32_t default_mode) { manager->default_mode = default_mode; @@ -162,6 +164,7 @@ static void server_decoration_manager_bind(struct wl_client *client, void *data, manager->default_mode); } +WLR_API void wlr_server_decoration_manager_destroy( struct wlr_server_decoration_manager *manager) { if (manager == NULL) { @@ -187,6 +190,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_server_decoration_manager_destroy(manager); } +WLR_API struct wlr_server_decoration_manager *wlr_server_decoration_manager_create( struct wl_display *display) { struct wlr_server_decoration_manager *manager = diff --git a/types/wlr_surface.c b/types/wlr_surface.c index e2588167..93904245 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -8,6 +8,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" static void wlr_surface_state_reset_buffer(struct wlr_surface_state *state) { @@ -530,6 +531,7 @@ const struct wl_surface_interface surface_interface = { .damage_buffer = surface_damage_buffer }; +WLR_API struct wlr_surface *wlr_surface_from_resource(struct wl_resource *resource) { assert(wl_resource_instance_of(resource, &wl_surface_interface, &surface_interface)); @@ -605,6 +607,7 @@ static void destroy_surface(struct wl_resource *resource) { free(surface); } +WLR_API struct wlr_surface *wlr_surface_create(struct wl_resource *res, struct wlr_renderer *renderer) { struct wlr_surface *surface = calloc(1, sizeof(struct wlr_surface)); @@ -630,6 +633,7 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res, return surface; } +WLR_API void wlr_surface_get_matrix(struct wlr_surface *surface, float (*matrix)[16], const float (*projection)[16], @@ -646,10 +650,12 @@ void wlr_surface_get_matrix(struct wlr_surface *surface, wlr_matrix_mul(projection, matrix, matrix); } +WLR_API bool wlr_surface_has_buffer(struct wlr_surface *surface) { return surface->texture && surface->texture->valid; } +WLR_API int wlr_surface_set_role(struct wlr_surface *surface, const char *role, struct wl_resource *error_resource, uint32_t error_code) { assert(role); @@ -808,6 +814,7 @@ static void subsurface_handle_parent_destroy(struct wl_listener *listener, subsurface->parent = NULL; } +WLR_API void wlr_surface_make_subsurface(struct wlr_surface *surface, struct wlr_surface *parent, uint32_t id) { struct wl_client *client = wl_resource_get_client(surface->resource); @@ -857,7 +864,7 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface, wlr_signal_emit_safe(&parent->events.new_subsurface, subsurface); } - +WLR_API struct wlr_surface *wlr_surface_get_main_surface(struct wlr_surface *surface) { struct wlr_subsurface *sub; @@ -868,6 +875,7 @@ struct wlr_surface *wlr_surface_get_main_surface(struct wlr_surface *surface) { return surface; } +WLR_API struct wlr_subsurface *wlr_surface_subsurface_at(struct wlr_surface *surface, double sx, double sy, double *sub_x, double *sub_y) { struct wlr_subsurface *subsurface; @@ -900,6 +908,7 @@ struct wlr_subsurface *wlr_surface_subsurface_at(struct wlr_surface *surface, return NULL; } +WLR_API void wlr_surface_send_enter(struct wlr_surface *surface, struct wlr_output *output) { struct wl_client *client = wl_resource_get_client(surface->resource); @@ -912,6 +921,7 @@ void wlr_surface_send_enter(struct wlr_surface *surface, } } +WLR_API void wlr_surface_send_leave(struct wlr_surface *surface, struct wlr_output *output) { struct wl_client *client = wl_resource_get_client(surface->resource); @@ -928,6 +938,7 @@ static inline int64_t timespec_to_msec(const struct timespec *a) { return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000; } +WLR_API void wlr_surface_send_frame_done(struct wlr_surface *surface, const struct timespec *when) { struct wlr_frame_callback *cb, *cnext; @@ -938,6 +949,7 @@ void wlr_surface_send_frame_done(struct wlr_surface *surface, } } +WLR_API void wlr_surface_set_role_committed(struct wlr_surface *surface, void (*role_committed)(struct wlr_surface *surface, void *role_data), void *role_data) { diff --git a/types/wlr_tablet_pad.c b/types/wlr_tablet_pad.c index 3d25d685..3f4979b8 100644 --- a/types/wlr_tablet_pad.c +++ b/types/wlr_tablet_pad.c @@ -3,7 +3,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_tablet_pad_init(struct wlr_tablet_pad *pad, struct wlr_tablet_pad_impl *impl) { pad->impl = impl; @@ -12,6 +14,7 @@ void wlr_tablet_pad_init(struct wlr_tablet_pad *pad, wl_signal_init(&pad->events.strip); } +WLR_API void wlr_tablet_pad_destroy(struct wlr_tablet_pad *pad) { if (pad && pad->impl && pad->impl->destroy) { pad->impl->destroy(pad); diff --git a/types/wlr_tablet_tool.c b/types/wlr_tablet_tool.c index f46a5434..8cce799f 100644 --- a/types/wlr_tablet_tool.c +++ b/types/wlr_tablet_tool.c @@ -3,7 +3,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_tablet_tool_init(struct wlr_tablet_tool *tool, struct wlr_tablet_tool_impl *impl) { tool->impl = impl; @@ -13,6 +15,7 @@ void wlr_tablet_tool_init(struct wlr_tablet_tool *tool, wl_signal_init(&tool->events.button); } +WLR_API void wlr_tablet_tool_destroy(struct wlr_tablet_tool *tool) { if (!tool) { return; diff --git a/types/wlr_touch.c b/types/wlr_touch.c index ba7ffac7..22eb77f9 100644 --- a/types/wlr_touch.c +++ b/types/wlr_touch.c @@ -3,7 +3,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_touch_init(struct wlr_touch *touch, struct wlr_touch_impl *impl) { touch->impl = impl; @@ -13,6 +15,7 @@ void wlr_touch_init(struct wlr_touch *touch, wl_signal_init(&touch->events.cancel); } +WLR_API void wlr_touch_destroy(struct wlr_touch *touch) { if (touch && touch->impl && touch->impl->destroy) { touch->impl->destroy(touch); diff --git a/types/wlr_wl_shell.c b/types/wlr_wl_shell.c index cac64c44..14b079f7 100644 --- a/types/wlr_wl_shell.c +++ b/types/wlr_wl_shell.c @@ -8,6 +8,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" static const char *wlr_wl_shell_surface_role = "wl-shell-surface"; @@ -591,6 +592,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_wl_shell_destroy(wl_shell); } +WLR_API struct wlr_wl_shell *wlr_wl_shell_create(struct wl_display *display) { struct wlr_wl_shell *wl_shell = calloc(1, sizeof(struct wlr_wl_shell)); if (!wl_shell) { @@ -615,6 +617,7 @@ struct wlr_wl_shell *wlr_wl_shell_create(struct wl_display *display) { return wl_shell; } +WLR_API void wlr_wl_shell_destroy(struct wlr_wl_shell *wlr_wl_shell) { if (!wlr_wl_shell) { return; @@ -630,6 +633,7 @@ void wlr_wl_shell_destroy(struct wlr_wl_shell *wlr_wl_shell) { free(wlr_wl_shell); } +WLR_API void wlr_wl_shell_surface_ping(struct wlr_wl_shell_surface *surface) { if (surface->ping_serial != 0) { // already pinged @@ -643,11 +647,13 @@ void wlr_wl_shell_surface_ping(struct wlr_wl_shell_surface *surface) { wl_shell_surface_send_ping(surface->resource, surface->ping_serial); } +WLR_API void wlr_wl_shell_surface_configure(struct wlr_wl_shell_surface *surface, uint32_t edges, int32_t width, int32_t height) { wl_shell_surface_send_configure(surface->resource, edges, width, height); } +WLR_API struct wlr_wl_shell_surface *wlr_wl_shell_surface_popup_at( struct wlr_wl_shell_surface *surface, double sx, double sy, double *popup_sx, double *popup_sy) { diff --git a/types/wlr_xcursor_manager.c b/types/wlr_xcursor_manager.c index d81b639d..04c78b90 100644 --- a/types/wlr_xcursor_manager.c +++ b/types/wlr_xcursor_manager.c @@ -2,7 +2,9 @@ #include #include #include +#include "util/defs.h" +WLR_API struct wlr_xcursor_manager *wlr_xcursor_manager_create(const char *name, uint32_t size) { struct wlr_xcursor_manager *manager = @@ -18,6 +20,7 @@ struct wlr_xcursor_manager *wlr_xcursor_manager_create(const char *name, return manager; } +WLR_API void wlr_xcursor_manager_destroy(struct wlr_xcursor_manager *manager) { if (manager == NULL) { return; @@ -32,6 +35,7 @@ void wlr_xcursor_manager_destroy(struct wlr_xcursor_manager *manager) { free(manager); } +WLR_API int wlr_xcursor_manager_load(struct wlr_xcursor_manager *manager, float scale) { struct wlr_xcursor_manager_theme *theme; @@ -55,6 +59,7 @@ int wlr_xcursor_manager_load(struct wlr_xcursor_manager *manager, return 0; } +WLR_API struct wlr_xcursor *wlr_xcursor_manager_get_xcursor( struct wlr_xcursor_manager *manager, const char *name, float scale) { struct wlr_xcursor_manager_theme *theme; @@ -66,6 +71,7 @@ struct wlr_xcursor *wlr_xcursor_manager_get_xcursor( return NULL; } +WLR_API void wlr_xcursor_manager_set_cursor_image(struct wlr_xcursor_manager *manager, const char *name, struct wlr_cursor *cursor) { struct wlr_xcursor_manager_theme *theme; diff --git a/types/wlr_xdg_shell.c b/types/wlr_xdg_shell.c index 990926cf..74758084 100644 --- a/types/wlr_xdg_shell.c +++ b/types/wlr_xdg_shell.c @@ -10,6 +10,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" #include "xdg-shell-protocol.h" @@ -1383,6 +1384,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_xdg_shell_destroy(xdg_shell); } +WLR_API struct wlr_xdg_shell *wlr_xdg_shell_create(struct wl_display *display) { struct wlr_xdg_shell *xdg_shell = calloc(1, sizeof(struct wlr_xdg_shell)); @@ -1411,6 +1413,7 @@ struct wlr_xdg_shell *wlr_xdg_shell_create(struct wl_display *display) { return xdg_shell; } +WLR_API void wlr_xdg_shell_destroy(struct wlr_xdg_shell *xdg_shell) { if (!xdg_shell) { return; @@ -1420,6 +1423,7 @@ void wlr_xdg_shell_destroy(struct wlr_xdg_shell *xdg_shell) { free(xdg_shell); } +WLR_API void wlr_xdg_surface_ping(struct wlr_xdg_surface *surface) { if (surface->client->ping_serial != 0) { // already pinged @@ -1434,6 +1438,7 @@ void wlr_xdg_surface_ping(struct wlr_xdg_surface *surface) { surface->client->ping_serial); } +WLR_API uint32_t wlr_xdg_toplevel_set_size(struct wlr_xdg_surface *surface, uint32_t width, uint32_t height) { assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); @@ -1443,6 +1448,7 @@ uint32_t wlr_xdg_toplevel_set_size(struct wlr_xdg_surface *surface, return wlr_xdg_surface_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_set_activated(struct wlr_xdg_surface *surface, bool activated) { assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); @@ -1451,6 +1457,7 @@ uint32_t wlr_xdg_toplevel_set_activated(struct wlr_xdg_surface *surface, return wlr_xdg_surface_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_set_maximized(struct wlr_xdg_surface *surface, bool maximized) { assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); @@ -1459,6 +1466,7 @@ uint32_t wlr_xdg_toplevel_set_maximized(struct wlr_xdg_surface *surface, return wlr_xdg_surface_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_set_fullscreen(struct wlr_xdg_surface *surface, bool fullscreen) { assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); @@ -1467,6 +1475,7 @@ uint32_t wlr_xdg_toplevel_set_fullscreen(struct wlr_xdg_surface *surface, return wlr_xdg_surface_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_set_resizing(struct wlr_xdg_surface *surface, bool resizing) { assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); @@ -1475,11 +1484,13 @@ uint32_t wlr_xdg_toplevel_set_resizing(struct wlr_xdg_surface *surface, return wlr_xdg_surface_schedule_configure(surface); } +WLR_API void wlr_xdg_toplevel_send_close(struct wlr_xdg_surface *surface) { assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); xdg_toplevel_send_close(surface->toplevel_state->resource); } +WLR_API void wlr_xdg_surface_popup_get_position(struct wlr_xdg_surface *surface, double *popup_sx, double *popup_sy) { assert(surface->role == WLR_XDG_SURFACE_ROLE_POPUP); @@ -1490,6 +1501,7 @@ void wlr_xdg_surface_popup_get_position(struct wlr_xdg_surface *surface, surface->geometry->y; } +WLR_API struct wlr_xdg_surface *wlr_xdg_surface_popup_at( struct wlr_xdg_surface *surface, double sx, double sy, double *popup_sx, double *popup_sy) { diff --git a/types/wlr_xdg_shell_v6.c b/types/wlr_xdg_shell_v6.c index e07d78a1..a77feb42 100644 --- a/types/wlr_xdg_shell_v6.c +++ b/types/wlr_xdg_shell_v6.c @@ -10,6 +10,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" #include "xdg-shell-unstable-v6-protocol.h" @@ -1353,6 +1354,7 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { wlr_xdg_shell_v6_destroy(xdg_shell); } +WLR_API struct wlr_xdg_shell_v6 *wlr_xdg_shell_v6_create(struct wl_display *display) { struct wlr_xdg_shell_v6 *xdg_shell = calloc(1, sizeof(struct wlr_xdg_shell_v6)); @@ -1381,6 +1383,7 @@ struct wlr_xdg_shell_v6 *wlr_xdg_shell_v6_create(struct wl_display *display) { return xdg_shell; } +WLR_API void wlr_xdg_shell_v6_destroy(struct wlr_xdg_shell_v6 *xdg_shell) { if (!xdg_shell) { return; @@ -1390,6 +1393,7 @@ void wlr_xdg_shell_v6_destroy(struct wlr_xdg_shell_v6 *xdg_shell) { free(xdg_shell); } +WLR_API void wlr_xdg_surface_v6_ping(struct wlr_xdg_surface_v6 *surface) { if (surface->client->ping_serial != 0) { // already pinged @@ -1404,6 +1408,7 @@ void wlr_xdg_surface_v6_ping(struct wlr_xdg_surface_v6 *surface) { surface->client->ping_serial); } +WLR_API uint32_t wlr_xdg_toplevel_v6_set_size(struct wlr_xdg_surface_v6 *surface, uint32_t width, uint32_t height) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); @@ -1413,6 +1418,7 @@ uint32_t wlr_xdg_toplevel_v6_set_size(struct wlr_xdg_surface_v6 *surface, return wlr_xdg_surface_v6_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_v6_set_activated(struct wlr_xdg_surface_v6 *surface, bool activated) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); @@ -1421,6 +1427,7 @@ uint32_t wlr_xdg_toplevel_v6_set_activated(struct wlr_xdg_surface_v6 *surface, return wlr_xdg_surface_v6_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_v6_set_maximized(struct wlr_xdg_surface_v6 *surface, bool maximized) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); @@ -1429,6 +1436,7 @@ uint32_t wlr_xdg_toplevel_v6_set_maximized(struct wlr_xdg_surface_v6 *surface, return wlr_xdg_surface_v6_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_v6_set_fullscreen(struct wlr_xdg_surface_v6 *surface, bool fullscreen) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); @@ -1437,6 +1445,7 @@ uint32_t wlr_xdg_toplevel_v6_set_fullscreen(struct wlr_xdg_surface_v6 *surface, return wlr_xdg_surface_v6_schedule_configure(surface); } +WLR_API uint32_t wlr_xdg_toplevel_v6_set_resizing(struct wlr_xdg_surface_v6 *surface, bool resizing) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); @@ -1445,11 +1454,13 @@ uint32_t wlr_xdg_toplevel_v6_set_resizing(struct wlr_xdg_surface_v6 *surface, return wlr_xdg_surface_v6_schedule_configure(surface); } +WLR_API void wlr_xdg_toplevel_v6_send_close(struct wlr_xdg_surface_v6 *surface) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL); zxdg_toplevel_v6_send_close(surface->toplevel_state->resource); } +WLR_API void wlr_xdg_surface_v6_popup_get_position(struct wlr_xdg_surface_v6 *surface, double *popup_sx, double *popup_sy) { assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_POPUP); @@ -1460,6 +1471,7 @@ void wlr_xdg_surface_v6_popup_get_position(struct wlr_xdg_surface_v6 *surface, surface->geometry->y; } +WLR_API struct wlr_xdg_surface_v6 *wlr_xdg_surface_v6_popup_at( struct wlr_xdg_surface_v6 *surface, double sx, double sy, double *popup_sx, double *popup_sy) { diff --git a/util/log.c b/util/log.c index 327402e6..bf5f848c 100644 --- a/util/log.c +++ b/util/log.c @@ -7,6 +7,7 @@ #include #include #include +#include "util/defs.h" static bool colored = true; static log_importance_t log_importance = L_ERROR; @@ -48,6 +49,7 @@ void wlr_log_stderr(log_importance_t verbosity, const char *fmt, va_list args) { static log_callback_t log_callback = wlr_log_stderr; +WLR_API void wlr_log_init(log_importance_t verbosity, log_callback_t callback) { if (verbosity < L_LAST) { log_importance = verbosity; @@ -57,10 +59,12 @@ void wlr_log_init(log_importance_t verbosity, log_callback_t callback) { } } +WLR_API void _wlr_vlog(log_importance_t verbosity, const char *fmt, va_list args) { log_callback(verbosity, fmt, args); } +WLR_API void _wlr_log(log_importance_t verbosity, const char *fmt, ...) { va_list args; va_start(args, fmt); @@ -73,6 +77,7 @@ void _wlr_log(log_importance_t verbosity, const char *fmt, ...) { // e.g. '/src/build/wlroots/backend/wayland/backend.c' and // '../backend/wayland/backend.c' will both be stripped to // 'backend/wayland/backend.c' +WLR_API const char *_strip_path(const char *filepath) { static int srclen = sizeof(WLR_SRC_DIR); if (strstr(filepath, WLR_SRC_DIR) == filepath) { diff --git a/util/os-compatibility.c b/util/os-compatibility.c index bd3067d2..0e95fdee 100644 --- a/util/os-compatibility.c +++ b/util/os-compatibility.c @@ -31,6 +31,7 @@ #include #include #include +#include "util/defs.h" #include "util/os-compatibility.h" int os_fd_set_cloexec(int fd) { @@ -97,6 +98,11 @@ int create_tmpfile_cloexec(char *tmpname) * If posix_fallocate() is not supported, program may receive * SIGBUS on accessing mmap()'ed file contents instead. */ +/* + * XXX: This is not part of our public headers, but one of the examples uses it. + * We really should not export this. + */ +WLR_API int os_create_anonymous_file(off_t size) { static const char template[] = "/wlroots-shared-XXXXXX"; const char *path; diff --git a/util/region.c b/util/region.c index 88e38fd2..2639ac04 100644 --- a/util/region.c +++ b/util/region.c @@ -1,7 +1,9 @@ #include #include #include +#include "util/defs.h" +WLR_API void wlr_region_scale(pixman_region32_t *dst, pixman_region32_t *src, float scale) { if (scale == 1) { @@ -29,6 +31,7 @@ void wlr_region_scale(pixman_region32_t *dst, pixman_region32_t *src, free(dst_rects); } +WLR_API void wlr_region_transform(pixman_region32_t *dst, pixman_region32_t *src, enum wl_output_transform transform, int width, int height) { if (transform == WL_OUTPUT_TRANSFORM_NORMAL) { @@ -102,6 +105,7 @@ void wlr_region_transform(pixman_region32_t *dst, pixman_region32_t *src, free(dst_rects); } +WLR_API void wlr_region_expand(pixman_region32_t *dst, pixman_region32_t *src, int distance) { if (distance == 0) { diff --git a/xcursor/wlr_xcursor.c b/xcursor/wlr_xcursor.c index 7fcdbb6f..2366ba24 100644 --- a/xcursor/wlr_xcursor.c +++ b/xcursor/wlr_xcursor.c @@ -30,6 +30,7 @@ #include #include #include +#include "util/defs.h" #include "xcursor/xcursor.h" static void wlr_xcursor_destroy(struct wlr_xcursor *cursor) { @@ -212,6 +213,7 @@ static void load_callback(XcursorImages *images, void *data) { XcursorImagesDestroy(images); } +WLR_API struct wlr_xcursor_theme *wlr_xcursor_theme_load(const char *name, int size) { struct wlr_xcursor_theme *theme; @@ -255,6 +257,7 @@ out_error_name: return NULL; } +WLR_API void wlr_xcursor_theme_destroy(struct wlr_xcursor_theme *theme) { unsigned int i; @@ -267,6 +270,7 @@ void wlr_xcursor_theme_destroy(struct wlr_xcursor_theme *theme) { free(theme); } +WLR_API struct wlr_xcursor *wlr_xcursor_theme_get_cursor(struct wlr_xcursor_theme *theme, const char *name) { unsigned int i; @@ -322,10 +326,12 @@ static int wlr_xcursor_frame_and_duration(struct wlr_xcursor *cursor, return i; } +WLR_API int wlr_xcursor_frame(struct wlr_xcursor *_cursor, uint32_t time) { return wlr_xcursor_frame_and_duration(_cursor, time, NULL); } +WLR_API const char *wlr_xcursor_get_resize_name(enum wlr_edges edges) { if (edges & WLR_EDGE_TOP) { if (edges & WLR_EDGE_RIGHT) { diff --git a/xwayland/selection.c b/xwayland/selection.c index ffcde4d0..b16b8731 100644 --- a/xwayland/selection.c +++ b/xwayland/selection.c @@ -9,6 +9,7 @@ #include #include #include +#include "util/defs.h" static const size_t incr_chunk_size = 64 * 1024; @@ -805,6 +806,7 @@ static void selection_init(struct wlr_xwm *xwm, selection->atom, mask); } +WLR_API void xwm_selection_init(struct wlr_xwm *xwm) { uint32_t values[] = { XCB_EVENT_MASK_PROPERTY_CHANGE }; xwm->selection_window = xcb_generate_id(xwm->xcb_conn); @@ -828,6 +830,7 @@ void xwm_selection_init(struct wlr_xwm *xwm) { selection_init(xwm, &xwm->primary_selection, xwm->atoms[PRIMARY]); } +WLR_API void xwm_selection_finish(struct wlr_xwm *xwm) { if (!xwm) { return; @@ -896,6 +899,7 @@ static void seat_handle_primary_selection(struct wl_listener *listener, xwm_selection_set_owner(&xwm->primary_selection, source != NULL); } +WLR_API void xwm_set_seat(struct wlr_xwm *xwm, struct wlr_seat *seat) { if (xwm->seat != NULL) { wl_list_remove(&xwm->seat_selection.link); diff --git a/xwayland/xwayland.c b/xwayland/xwayland.c index 1d935180..3ef4d41c 100644 --- a/xwayland/xwayland.c +++ b/xwayland/xwayland.c @@ -20,6 +20,7 @@ #include #include #include "sockets.h" +#include "util/defs.h" #include "util/signal.h" #ifdef __FreeBSD__ @@ -336,12 +337,14 @@ static bool wlr_xwayland_start(struct wlr_xwayland *wlr_xwayland, return true; } +WLR_API void wlr_xwayland_destroy(struct wlr_xwayland *wlr_xwayland) { wlr_xwayland_set_seat(wlr_xwayland, NULL); wlr_xwayland_finish(wlr_xwayland); free(wlr_xwayland); } +WLR_API struct wlr_xwayland *wlr_xwayland_create(struct wl_display *wl_display, struct wlr_compositor *compositor) { struct wlr_xwayland *wlr_xwayland = calloc(1, sizeof(struct wlr_xwayland)); @@ -355,6 +358,7 @@ struct wlr_xwayland *wlr_xwayland_create(struct wl_display *wl_display, return NULL; } +WLR_API void wlr_xwayland_set_cursor(struct wlr_xwayland *wlr_xwayland, uint8_t *pixels, uint32_t stride, uint32_t width, uint32_t height, int32_t hotspot_x, int32_t hotspot_y) { @@ -386,6 +390,7 @@ static void wlr_xwayland_handle_seat_destroy(struct wl_listener *listener, wlr_xwayland_set_seat(xwayland, NULL); } +WLR_API void wlr_xwayland_set_seat(struct wlr_xwayland *xwayland, struct wlr_seat *seat) { if (xwayland->seat) { diff --git a/xwayland/xwm.c b/xwayland/xwm.c index 94dfdaab..72b7a8a4 100644 --- a/xwayland/xwm.c +++ b/xwayland/xwm.c @@ -14,6 +14,7 @@ #include #include #include +#include "util/defs.h" #include "util/signal.h" #ifdef WLR_HAS_XCB_ICCCM @@ -1043,6 +1044,7 @@ static void handle_compositor_surface_create(struct wl_listener *listener, } } +WLR_API void wlr_xwayland_surface_activate(struct wlr_xwayland_surface *xsurface, bool activated) { struct wlr_xwayland_surface *focused = xsurface->xwm->focus_surface; @@ -1053,6 +1055,7 @@ void wlr_xwayland_surface_activate(struct wlr_xwayland_surface *xsurface, } } +WLR_API void wlr_xwayland_surface_configure(struct wlr_xwayland_surface *xsurface, int16_t x, int16_t y, uint16_t width, uint16_t height) { xsurface->x = x; @@ -1069,6 +1072,7 @@ void wlr_xwayland_surface_configure(struct wlr_xwayland_surface *xsurface, xcb_flush(xwm->xcb_conn); } +WLR_API void wlr_xwayland_surface_close(struct wlr_xwayland_surface *xsurface) { struct wlr_xwm *xwm = xsurface->xwm; @@ -1100,6 +1104,7 @@ void wlr_xwayland_surface_close(struct wlr_xwayland_surface *xsurface) { xcb_flush(xwm->xcb_conn); } +WLR_API void xwm_destroy(struct wlr_xwm *xwm) { if (!xwm) { return; @@ -1292,6 +1297,7 @@ static void xwm_get_render_format(struct wlr_xwm *xwm) { free(reply); } +WLR_API void xwm_set_cursor(struct wlr_xwm *xwm, const uint8_t *pixels, uint32_t stride, uint32_t width, uint32_t height, int32_t hotspot_x, int32_t hotspot_y) { if (!xwm->render_format_id) { @@ -1332,6 +1338,7 @@ void xwm_set_cursor(struct wlr_xwm *xwm, const uint8_t *pixels, uint32_t stride, xcb_flush(xwm->xcb_conn); } +WLR_API struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) { struct wlr_xwm *xwm = calloc(1, sizeof(struct wlr_xwm)); if (xwm == NULL) { @@ -1418,6 +1425,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) { return xwm; } +WLR_API void wlr_xwayland_surface_set_maximized(struct wlr_xwayland_surface *surface, bool maximized) { surface->maximized_horz = maximized; @@ -1426,6 +1434,7 @@ void wlr_xwayland_surface_set_maximized(struct wlr_xwayland_surface *surface, xcb_flush(surface->xwm->xcb_conn); } +WLR_API void wlr_xwayland_surface_set_fullscreen(struct wlr_xwayland_surface *surface, bool fullscreen) { surface->fullscreen = fullscreen;