int
ds_backend_get_drm_fd(struct ds_backend *backend);
-ds_buffer_caps_t
+enum ds_buffer_caps
ds_backend_get_buffer_caps(struct ds_backend *backend);
void
struct ds_buffer;
-typedef enum
+enum ds_buffer_caps
{
DS_BUFFER_CAP_DATA_PTR = 1 << 0,
DS_BUFFER_CAP_DMABUF = 1 << 1,
DS_BUFFER_CAP_SHM = 1 << 2,
-} ds_buffer_caps_t;
+};
enum ds_buffer_data_ptr_access_flag
{
}
void
-ds_addon_set_finish(ds_addon_set_t *set)
+ds_addon_set_finish(struct ds_addon_set *set)
{
- ds_addon_t *addon, *tmp;
+ struct ds_addon *addon, *tmp;
wl_list_for_each_safe(addon, tmp, &set->addons, link) {
ds_addon_finish(addon);
}
void
-ds_addon_init(ds_addon_t *addon, ds_addon_set_t *set,
- const void *owner, const ds_addon_interface_t *impl)
+ds_addon_init(struct ds_addon *addon, struct ds_addon_set *set,
+ const void *owner, const struct ds_addon_interface *impl)
{
- ds_addon_t *iter;
+ struct ds_addon *iter;
assert(owner && impl);
}
void
-ds_addon_finish(ds_addon_t *addon)
+ds_addon_finish(struct ds_addon *addon)
{
wl_list_remove(&addon->link);
wl_list_init(&addon->link);
}
-ds_addon_t *
-ds_addon_find(ds_addon_set_t *set, const void *owner,
- const ds_addon_interface_t *impl)
+struct ds_addon *
+ds_addon_find(struct ds_addon_set *set, const void *owner,
+ const struct ds_addon_interface *impl)
{
struct ds_addon *addon;
#include <wayland-util.h>
-typedef struct ds_addon_set ds_addon_set_t;
-typedef struct ds_addon_interface ds_addon_interface_t;
-typedef struct ds_addon ds_addon_t;
-
struct ds_addon_set {
struct wl_list addons;
};
-struct ds_addon_interface {
- const char *name;
- void (*destroy)(struct ds_addon *addon);
-};
-
struct ds_addon {
- const ds_addon_interface_t *impl;
+ const struct ds_addon_interface *impl;
const void *owner;
struct wl_list link;
};
+struct ds_addon_interface {
+ const char *name;
+ void (*destroy)(struct ds_addon *addon);
+};
+
void
-ds_addon_set_init(ds_addon_set_t *set);
+ds_addon_set_init(struct ds_addon_set *set);
void
-ds_addon_set_finish(ds_addon_set_t *set);
+ds_addon_set_finish(struct ds_addon_set *set);
void
-ds_addon_init(ds_addon_t *addon, ds_addon_set_t *set,
- const void *owner, const ds_addon_interface_t *impl);
+ds_addon_init(struct ds_addon *addon, struct ds_addon_set *set,
+ const void *owner, const struct ds_addon_interface *impl);
void
-ds_addon_finish(ds_addon_t *addon);
+ds_addon_finish(struct ds_addon *addon);
-ds_addon_t *
-ds_addon_find(ds_addon_set_t *set, const void *owner,
- const ds_addon_interface_t *impl);
+struct ds_addon *
+ds_addon_find(struct ds_addon_set *set, const void *owner,
+ const struct ds_addon_interface *impl);
#endif
#include "libds/log.h"
#include "util.h"
-typedef struct ds_shm_allocator ds_shm_allocator_t;
-
-typedef struct ds_shm_buffer ds_shm_buffer_t;
-
struct ds_shm_allocator
{
struct ds_allocator base;
WL_EXPORT struct ds_allocator *
ds_shm_allocator_create(void)
{
- ds_shm_allocator_t *alloc;
+ struct ds_shm_allocator *alloc;
alloc = calloc(1, sizeof *alloc);
if (!alloc)
return &alloc->base;
}
-static ds_shm_allocator_t *
+static struct ds_shm_allocator *
shm_allocator_from_allocator(struct ds_allocator *ds_allocator)
{
assert(ds_allocator->iface == &shm_allocator_iface);
- return (ds_shm_allocator_t *)ds_allocator;
+ return (struct ds_shm_allocator *)ds_allocator;
}
static void
shm_allocator_destroy(struct ds_allocator *ds_allocator)
{
- ds_shm_allocator_t *alloc;
+ struct ds_shm_allocator *alloc;
alloc = shm_allocator_from_allocator(ds_allocator);
ds_dbg("Destroy Shm allocator(%p)", alloc);
static const struct ds_buffer_interface shm_buffer_interface;
-static ds_shm_buffer_t *
+static struct ds_shm_buffer *
shm_buffer_from_buffer(struct ds_buffer *buffer)
{
assert(buffer->iface == &shm_buffer_interface);
- return (ds_shm_buffer_t *)buffer;
+ return (struct ds_shm_buffer *)buffer;
}
static void
shm_buffer_destroy(struct ds_buffer *ds_buffer)
{
- ds_shm_buffer_t *buffer;
+ struct ds_shm_buffer *buffer;
buffer = shm_buffer_from_buffer(ds_buffer);
static bool
shm_buffer_get_shm(struct ds_buffer *ds_buffer, struct ds_shm_attributes *shm)
{
- ds_shm_buffer_t *buffer;
+ struct ds_shm_buffer *buffer;
buffer = shm_buffer_from_buffer(ds_buffer);
memcpy(shm, &buffer->shm, sizeof *shm);
shm_buffer_begin_data_ptr_access(struct ds_buffer *ds_buffer, uint32_t flags,
void **data, uint32_t *format, size_t *stride)
{
- ds_shm_buffer_t *buffer;
+ struct ds_shm_buffer *buffer;
buffer = shm_buffer_from_buffer(ds_buffer);
*data = buffer->data;
shm_allocator_create_buffer(struct ds_allocator *ds_allocator,
int width, int height, uint32_t format)
{
- ds_shm_buffer_t *buffer;
+ struct ds_shm_buffer *buffer;
buffer = calloc(1, sizeof *buffer);
if (!buffer)
static const struct ds_backend_interface wl_backend_interface;
static void wl_backend_handle_display_destroy(struct wl_listener *listener,
void *data);
-static bool wl_backend_server_init(ds_wl_backend_server_t *server,
+static bool wl_backend_server_init(struct ds_wl_backend_server *server,
const char *name);
-static void wl_backend_server_finish(ds_wl_backend_server_t *server);
+static void wl_backend_server_finish(struct ds_wl_backend_server *server);
static int wl_backend_handle_dispatch_events(int fd, uint32_t mask,
void *data);
WL_EXPORT struct ds_backend *
ds_wl_backend_create(struct wl_display *display, const char *server_name)
{
- ds_wl_backend_t *wl_backend;
+ struct ds_wl_backend *wl_backend;
struct wl_event_loop *loop;
int fd;
return NULL;
}
-ds_wl_backend_t *
+struct ds_wl_backend *
wl_backend_from_backend(struct ds_backend *backend)
{
assert(backend->iface == &wl_backend_interface);
- return (ds_wl_backend_t *)backend;
+ return (struct ds_wl_backend *)backend;
}
static void
-wl_backend_destroy(ds_wl_backend_t *backend)
+wl_backend_destroy(struct ds_wl_backend *backend)
{
- ds_wl_output_t *output, *tmp_output;
- ds_wl_buffer_t *buffer, *tmp_buffer;
+ struct ds_wl_output *output, *tmp_output;
+ struct ds_wl_buffer *buffer, *tmp_buffer;
ds_dbg("Destroy wayland backend(%p)", backend);
static void
wl_backend_iface_destroy(struct ds_backend *backend)
{
- ds_wl_backend_t *wl_backend;
+ struct ds_wl_backend *wl_backend;
if (!backend)
return;
static void
wl_backend_handle_display_destroy(struct wl_listener *listener, void *data)
{
- ds_wl_backend_t *wl_backend;
+ struct ds_wl_backend *wl_backend;
wl_backend = wl_container_of(listener, wl_backend, display_destroy);
wl_backend_destroy(wl_backend);
registry_handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *iface, uint32_t version)
{
- ds_wl_backend_server_t *server = data;
+ struct ds_wl_backend_server *server = data;
ds_log(DS_DBG, "Wayland global: %s v%d", iface, version);
};
static bool
-wl_backend_server_init(ds_wl_backend_server_t *server, const char *name)
+wl_backend_server_init(struct ds_wl_backend_server *server, const char *name)
{
server->display = wl_display_connect(name);
if (!server->display) {
}
static void
-wl_backend_server_finish(ds_wl_backend_server_t *server)
+wl_backend_server_finish(struct ds_wl_backend_server *server)
{
xdg_wm_base_destroy(server->xdg_wm_base);
wl_compositor_destroy(server->compositor);
static int
wl_backend_handle_dispatch_events(int fd, uint32_t mask, void *data)
{
- ds_wl_backend_t *wl_backend = data;
- ds_wl_backend_server_t *server = &wl_backend->server;
+ struct ds_wl_backend *wl_backend = data;
+ struct ds_wl_backend_server *server = &wl_backend->server;
int count = 0;
if ((mask & WL_EVENT_HANGUP) || (mask & WL_EVENT_ERROR)) {
#include "libds/interfaces/backend.h"
#include "libds/interfaces/output.h"
-typedef struct ds_wl_backend_server ds_wl_backend_server_t;
-
-typedef struct ds_wl_backend ds_wl_backend_t;
-
-typedef struct ds_wl_buffer ds_wl_buffer_t;
-
-typedef struct ds_wl_output ds_wl_output_t;
-
struct ds_wl_backend_server
{
struct wl_display *display;
struct wl_list buffers; // ds_wl_buffer.link
struct wl_event_source *server_event_source;
- ds_wl_backend_server_t server;
+ struct ds_wl_backend_server server;
};
struct ds_wl_buffer
{
struct ds_output base;
- ds_wl_backend_t *backend;
+ struct ds_wl_backend *backend;
struct wl_surface *surface;
struct xdg_surface *xdg_surface;
struct wl_list link;
};
-ds_wl_backend_t *
+struct ds_wl_backend *
wl_backend_from_backend(struct ds_backend *backend);
void
-destroy_wl_buffer(ds_wl_buffer_t *buffer);
+destroy_wl_buffer(struct ds_wl_buffer *buffer);
#endif
struct ds_output *
ds_wl_backend_create_output(struct ds_backend *ds_backend)
{
- ds_wl_backend_t *backend;
- ds_wl_output_t *output;
+ struct ds_wl_backend *backend;
+ struct ds_wl_output *output;
backend = wl_backend_from_backend(ds_backend);
}
void
-destroy_wl_buffer(ds_wl_buffer_t *buffer)
+destroy_wl_buffer(struct ds_wl_buffer *buffer)
{
if (buffer == NULL)
return;
free(buffer);
}
-static ds_wl_output_t *
+static struct ds_wl_output *
wl_output_from_output(struct ds_output *ds_output)
{
assert(ds_output->iface == &wl_output_iface);
- return (ds_wl_output_t *)ds_output;
+ return (struct ds_wl_output *)ds_output;
}
static void
wl_output_iface_destroy(struct ds_output *ds_output)
{
- ds_wl_output_t *output;
+ struct ds_wl_output *output;
output = wl_output_from_output(ds_output);
}
static struct wl_buffer *
-import_shm(ds_wl_backend_t *backend, struct ds_shm_attributes *shm)
+import_shm(struct ds_wl_backend *backend, struct ds_shm_attributes *shm)
{
enum wl_shm_format wl_shm_format = WL_SHM_FORMAT_XRGB8888;
struct wl_shm_pool *pool;
static void
buffer_handle_release(void *data, struct wl_buffer *wl_buffer)
{
- ds_wl_buffer_t *buffer = data;
+ struct ds_wl_buffer *buffer = data;
ds_dbg("Wayland output: Buffer(%p) released.", buffer->buffer);
buffer->released = true;
static void
buffer_handle_buffer_destroy(struct wl_listener *listener, void *data)
{
- ds_wl_buffer_t *buffer;
+ struct ds_wl_buffer *buffer;
buffer = wl_container_of(listener, buffer, buffer_destroy);
destroy_wl_buffer(buffer);
}
-static ds_wl_buffer_t *
-create_wl_buffer(ds_wl_backend_t *backend, struct ds_buffer *ds_buffer)
+static struct ds_wl_buffer *
+create_wl_buffer(struct ds_wl_backend *backend, struct ds_buffer *ds_buffer)
{
struct ds_shm_attributes shm;
- ds_wl_buffer_t *buffer;
+ struct ds_wl_buffer *buffer;
struct wl_buffer *wl_buffer;
if (ds_buffer_get_shm(ds_buffer, &shm)) {
return buffer;
}
-static ds_wl_buffer_t *
-get_or_create_wl_buffer(ds_wl_backend_t *backend, struct ds_buffer *ds_buffer)
+static struct ds_wl_buffer *
+get_or_create_wl_buffer(struct ds_wl_backend *backend, struct ds_buffer *ds_buffer)
{
- ds_wl_buffer_t *buffer;
+ struct ds_wl_buffer *buffer;
wl_list_for_each(buffer, &backend->buffers, link) {
if (buffer->buffer == ds_buffer && buffer->released) {
static void
surface_frame_callback(void *data, struct wl_callback *cb, uint32_t time)
{
- ds_wl_output_t *output = data;
+ struct ds_wl_output *output = data;
wl_callback_destroy(cb);
output->frame_callback = NULL;
static bool
wl_output_iface_commit(struct ds_output *ds_output)
{
- ds_wl_output_t *output;
- ds_wl_buffer_t *buffer;
+ struct ds_wl_output *output;
+ struct ds_wl_buffer *buffer;
struct ds_buffer *ds_buffer;
output = wl_output_from_output(ds_output);
int32_t width, int32_t height, struct wl_array *states)
{
// TODO
- // ds_wl_output_t *output = data;
+ // struct ds_wl_output *output = data;
if (width == 0 || height == 0)
return;
wl_output_xdg_toplevel_handle_close(void *data,
struct xdg_toplevel *xdg_toplevel)
{
- ds_wl_output_t *output = data;
+ struct ds_wl_output *output = data;
ds_output_destroy(&output->base);
}
assert(resource && ds_resource_is_buffer(resource));
if (wl_shm_buffer_get(resource) != NULL) {
- ds_shm_client_buffer_t *shm_client_buffer =
+ struct ds_shm_client_buffer *shm_client_buffer =
ds_shm_client_buffer_get_or_create(resource);
if (!shm_client_buffer) {
ds_err("Failed to create shm client buffer");
#include "libds/buffer.h"
#include "libds/interfaces/buffer.h"
-typedef struct ds_shm_client_buffer ds_shm_client_buffer_t;
-
struct ds_shm_client_buffer
{
struct ds_buffer base;
} listener;
};
-ds_shm_client_buffer_t *
+struct ds_shm_client_buffer *
ds_shm_client_buffer_get_or_create(struct wl_resource *resource);
#endif
static void
shm_client_buffer_resource_handle_destroy(struct wl_listener *listener,
void *data);
-static ds_shm_client_buffer_t *
+static struct ds_shm_client_buffer *
shm_client_buffer_create(struct wl_resource *resource);
-ds_shm_client_buffer_t *
+struct ds_shm_client_buffer *
ds_shm_client_buffer_get_or_create(struct wl_resource *resource)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
struct wl_listener *resource_destroy_listener;
resource_destroy_listener = wl_resource_get_destroy_listener(resource,
shm_client_buffer_resource_handle_destroy(struct wl_listener *listener,
void *data)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
buffer = wl_container_of(listener, buffer, listener.resource_destroy);
static const struct ds_buffer_interface shm_client_buffer_iface;
-static ds_shm_client_buffer_t *
+static struct ds_shm_client_buffer *
shm_client_buffer_from_buffer(struct ds_buffer *buffer)
{
assert(buffer->iface == &shm_client_buffer_iface);
- return (ds_shm_client_buffer_t *)buffer;
+ return (struct ds_shm_client_buffer *)buffer;
}
static void
shm_client_buffer_destroy(struct ds_buffer *ds_buffer)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
buffer = shm_client_buffer_from_buffer(ds_buffer);
enum ds_buffer_data_ptr_access_flag flags, void **data,
uint32_t *format, size_t *stride)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
buffer = shm_client_buffer_from_buffer(ds_buffer);
*format = buffer->format;
static void
shm_client_buffer_end_data_ptr_access(struct ds_buffer *ds_buffer)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
buffer = shm_client_buffer_from_buffer(ds_buffer);
if (buffer->shm_buffer)
static void
shm_client_buffer_handle_release(struct wl_listener *listener, void *data)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
buffer = wl_container_of(listener, buffer, listener.buffer_release);
if (buffer->resource)
wl_buffer_send_release(buffer->resource);
}
-static ds_shm_client_buffer_t *
+static struct ds_shm_client_buffer *
shm_client_buffer_create(struct wl_resource *resource)
{
- ds_shm_client_buffer_t *buffer;
+ struct ds_shm_client_buffer *buffer;
struct wl_shm_buffer *shm_buffer;
enum wl_shm_format wl_shm_format;
int32_t width;
struct ds_compositor
{
struct wl_global *global;
- ds_subcompositor_t subcompositor;
+ struct ds_subcompositor subcompositor;
struct {
struct wl_signal new_surface;
uint32_t version, uint32_t id);
bool
-ds_subcompositor_init(ds_subcompositor_t *subcomp,
+ds_subcompositor_init(struct ds_subcompositor *subcomp,
struct wl_display *display)
{
subcomp->global = wl_global_create(display, &wl_subcompositor_interface,
}
void
-ds_subcompositor_finish(ds_subcompositor_t *subcomp)
+ds_subcompositor_finish(struct ds_subcompositor *subcomp)
{
wl_global_destroy(subcomp->global);
}
subcompositor_bind(struct wl_client *client, void *data,
uint32_t version, uint32_t id)
{
- ds_subcompositor_t *subcomp = data;
+ struct ds_subcompositor *subcomp = data;
struct wl_resource *resource;
resource = wl_resource_create(client, &wl_subcompositor_interface, 1, id);
#include <wayland-server.h>
-typedef struct ds_subcompositor ds_subcompositor_t;
-
struct ds_subcompositor
{
struct wl_global *global;
};
bool
-ds_subcompositor_init(ds_subcompositor_t *subcomp,
+ds_subcompositor_init(struct ds_subcompositor *subcomp,
struct wl_display *display);
void
-ds_subcompositor_finish(ds_subcompositor_t *subcomp);
+ds_subcompositor_finish(struct ds_subcompositor *subcomp);
#endif
#include "buffer.h"
#include "surface.h"
-typedef enum
+enum ds_surface_state_field
{
DS_SURFACE_STATE_BUFFER = 1 << 0,
DS_SURFACE_STATE_SURFACE_DAMAGE = 1 << 1,
DS_SURFACE_STATE_SCALE = 1 << 6,
DS_SURFACE_STATE_FRAME_CALLBACK_LIST = 1 << 7,
DS_SURFACE_STATE_VIEWPORT = 1 << 8,
-} ds_surface_state_field_t;
+};
struct ds_surface_state
{
- ds_surface_state_field_t committed;
+ enum ds_surface_state_field committed;
struct ds_buffer *buffer;
int32_t dx, dy;
#include "surface.h"
#include "libds/output.h"
-typedef enum
+enum ds_xdg_surface_role
{
DS_XDG_SURFACE_ROLE_NONE,
DS_XDG_SURFACE_ROLE_TOPLEVEL,
DS_XDG_SURFACE_ROLE_POPUP,
-} ds_xdg_surface_role_t;
+};
struct ds_xdg_shell
{
struct ds_xdg_client *client;
struct ds_surface *ds_surface;
- ds_xdg_surface_role_t role;
+ enum ds_xdg_surface_role role;
union {
struct ds_xdg_toplevel *toplevel;