struct desktop_shell
{
- pepper_object_t *compositor;
+ pepper_compositor_t *compositor;
struct wl_list shell_client_list;
struct wl_list shell_surface_list;
struct wl_resource *resource;
/* Hierarchy */
- pepper_object_t *parent;
+ pepper_surface_t *parent;
struct wl_list child_list; /* children surfaces of this */
struct wl_list parent_link;
/* Contents */
- pepper_object_t *surface;
- pepper_object_t *view;
+ pepper_surface_t *surface;
+ pepper_view_t *view;
char *title, *class_;
uint32_t version, uint32_t id);
shell_surface_t *
-shell_surface_create(shell_client_t *shell, pepper_object_t *surface, struct wl_client *client,
+shell_surface_create(shell_client_t *shell, pepper_surface_t *surface, struct wl_client *client,
const struct wl_interface *interface,
const void *implemenetation, uint32_t version, uint32_t id);
shell_surface_set_type(shell_surface_t *shsurf, shell_surface_type_t type);
void
-shell_surface_set_parent(shell_surface_t *shsurf, pepper_object_t *parent_surface);
+shell_surface_set_parent(shell_surface_t *shsurf, pepper_surface_t *parent);
/* */
shell_surface_t *
-get_shsurf_from_surface(pepper_object_t *surface, desktop_shell_t *shell);
+get_shsurf_from_surface(pepper_surface_t *surface, desktop_shell_t *shell);
void
-set_shsurf_to_surface(pepper_object_t *surface, shell_surface_t *shsurf);
+set_shsurf_to_surface(pepper_surface_t *surface, shell_surface_t *shsurf);
void
shell_surface_set_toplevel(shell_surface_t *shsurf);
#endif
PEPPER_API pepper_bool_t
-pepper_desktop_shell_init(pepper_object_t *compositor);
+pepper_desktop_shell_init(pepper_compositor_t *compositor);
#ifdef __cplusplus
}
}
shell_surface_t *
-shell_surface_create(shell_client_t *shell_client, pepper_object_t *surface,
+shell_surface_create(shell_client_t *shell_client, pepper_surface_t *surface,
struct wl_client *client, const struct wl_interface *interface,
const void *implementation, uint32_t version, uint32_t id)
{
wl_client_add_destroy_listener(client, &shsurf->client_destroy_listener);
shsurf->surface_destroy_listener.notify = handle_surface_destroy;
- pepper_object_add_destroy_listener(surface, &shsurf->surface_destroy_listener);
+ pepper_object_add_destroy_listener((pepper_object_t *)surface, &shsurf->surface_destroy_listener);
shell_surface_set_type(shsurf, SHELL_SURFACE_TYPE_NONE);
shsurf_start_listen_commit_event(shsurf);
}
shell_surface_t *
-get_shsurf_from_surface(pepper_object_t *surface, desktop_shell_t *shell)
+get_shsurf_from_surface(pepper_surface_t *surface, desktop_shell_t *shell)
{
- return pepper_object_get_user_data(surface, shell);
+ return pepper_object_get_user_data((pepper_object_t *)surface, shell);
}
void
-set_shsurf_to_surface(pepper_object_t *surface, shell_surface_t *shsurf)
+set_shsurf_to_surface(pepper_surface_t *surface, shell_surface_t *shsurf)
{
- pepper_object_set_user_data(surface, shsurf->shell, shsurf, NULL);
+ pepper_object_set_user_data((pepper_object_t *)surface, shsurf->shell, shsurf, NULL);
}
void
-shell_surface_set_parent(shell_surface_t *shsurf, pepper_object_t *parent)
+shell_surface_set_parent(shell_surface_t *shsurf, pepper_surface_t *parent)
{
shell_surface_t *parent_shsurf;
}
PEPPER_API pepper_bool_t
-pepper_desktop_shell_init(pepper_object_t *compositor)
+pepper_desktop_shell_init(pepper_compositor_t *compositor)
{
desktop_shell_t *shell;
uint32_t id, struct wl_resource *surface_resource)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
- pepper_object_t *surface = wl_resource_get_user_data(surface_resource);
+ pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
shell_surface_t *shsurf;
/* Only one shell surface can be associated with a given surface.*/
struct wl_resource *surface_resource)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
- pepper_object_t *surface = wl_resource_get_user_data(surface_resource);
+ pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
shell_surface_t *shsurf;
if (!pepper_surface_set_role(surface, "xdg_surface"))
int32_t y)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
- pepper_object_t *surface = wl_resource_get_user_data(surface_resource);
+ pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
shell_surface_t *shsurf;
if (!pepper_surface_set_role(surface, "xdg_popup"))
#include "drm-internal.h"
PEPPER_API pepper_drm_t *
-pepper_drm_create(pepper_object_t *compositor, const char *device, const char *renderer)
+pepper_drm_create(pepper_compositor_t *compositor, const char *device, const char *renderer)
{
pepper_drm_t *drm;
#include <xf86drm.h>
#include <xf86drmMode.h>
+#include <pepper-output-backend.h>
#include <pepper-libinput.h>
#include <pepper-render.h>
struct pepper_drm
{
- pepper_object_t *compositor;
+ pepper_compositor_t *compositor;
pepper_libinput_t *input;
struct wl_list output_list;
struct drm_output
{
pepper_drm_t *drm;
- pepper_object_t *base;
+ pepper_output_t *base;
struct wl_list link;
pepper_bool_t vblank_pending;
pepper_bool_t page_flip_pending;
- pepper_object_t *primary_plane;
+ pepper_plane_t *primary_plane;
/* TODO */
};
#include "drm-internal.h"
-#include <pepper-output-backend.h>
#include <pepper-pixman-renderer.h>
#include <pepper-gl-renderer.h>
pepper_list_t *l;
PEPPER_LIST_FOR_EACH(view_list, l)
- {
- pepper_object_t *view = l->item;
- pepper_view_assign_plane(view, output->base, output->primary_plane);
- }
+ pepper_view_assign_plane((pepper_view_t *)l->item, output->base, output->primary_plane);
}
static void
PEPPER_LIST_FOR_EACH(plane_list, l)
{
- pepper_object_t *plane = l->item;
+ pepper_plane_t *plane = l->item;
if (plane == output->primary_plane)
{
}
static void
-drm_output_attach_surface(void *o, pepper_object_t *surface, int *w, int *h)
+drm_output_attach_surface(void *o, pepper_surface_t *surface, int *w, int *h)
{
pepper_renderer_attach_surface(((drm_output_t *)o)->renderer, surface, w, h);
}
typedef struct pepper_drm pepper_drm_t;
PEPPER_API pepper_drm_t *
-pepper_drm_create(pepper_object_t *compositor, const char *device, const char *renderer);
+pepper_drm_create(pepper_compositor_t *compositor, const char *device, const char *renderer);
PEPPER_API void
pepper_drm_destroy(pepper_drm_t *drm);
#include "fbdev-internal.h"
PEPPER_API pepper_fbdev_t *
-pepper_fbdev_create(pepper_object_t *compositor, const char *device, const char *renderer)
+pepper_fbdev_create(pepper_compositor_t *compositor, const char *device, const char *renderer)
{
pepper_fbdev_t *fbdev;
#include <pixman.h>
+#include <pepper-output-backend.h>
#include <pepper-libinput.h>
#include <pepper-render.h>
#include <pepper-pixman-renderer.h>
struct pepper_fbdev
{
- pepper_object_t *compositor;
+ pepper_compositor_t *compositor;
pepper_libinput_t *input;
struct wl_list output_list;
struct fbdev_output
{
pepper_fbdev_t *fbdev;
- pepper_object_t *base;
+ pepper_output_t *base;
struct wl_list link;
struct wl_signal mode_change_signal;
struct wl_signal frame_signal;
- pepper_object_t *primary_plane;
+ pepper_plane_t *primary_plane;
/* TODO */
};
#include <sys/stat.h>
#include <unistd.h>
-#include <pepper-output-backend.h>
#include <pepper-pixman-renderer.h>
#include <pepper-gl-renderer.h>
PEPPER_LIST_FOR_EACH(view_list, l)
{
- pepper_object_t *view = l->item;
+ pepper_view_t *view = l->item;
pepper_view_assign_plane(view, output->base, output->primary_plane);
}
}
PEPPER_LIST_FOR_EACH(plane_list, l)
{
- pepper_object_t *plane = l->item;
+ pepper_plane_t *plane = l->item;
if (plane == output->primary_plane)
{
}
static void
-fbdev_output_attach_surface(void *o, pepper_object_t *surface, int *w, int *h)
+fbdev_output_attach_surface(void *o, pepper_surface_t *surface, int *w, int *h)
{
pepper_renderer_attach_surface(((fbdev_output_t *)o)->renderer, surface, w, h);
}
typedef struct pepper_fbdev pepper_fbdev_t;
PEPPER_API pepper_fbdev_t *
-pepper_fbdev_create(pepper_object_t *compositor, const char *device, const char *renderer);
+pepper_fbdev_create(pepper_compositor_t *compositor, const char *device, const char *renderer);
PEPPER_API void
pepper_fbdev_destroy(pepper_fbdev_t *fbdev);
struct pepper_libinput
{
- pepper_object_t *compositor;
+ pepper_compositor_t *compositor;
struct udev *udev;
struct libinput *libinput;
struct wl_event_source *libinput_event_source;
struct li_seat
{
- pepper_object_t *base;
+ pepper_seat_t *base;
pepper_libinput_t *input;
uint32_t id;
}
PEPPER_API pepper_libinput_t *
-pepper_libinput_create(pepper_object_t *compositor, struct udev *udev)
+pepper_libinput_create(pepper_compositor_t *compositor, struct udev *udev)
{
struct wl_display *display;
struct wl_event_loop *loop;
typedef struct pepper_libinput pepper_libinput_t;
PEPPER_API pepper_libinput_t *
-pepper_libinput_create(pepper_object_t *compositor, struct udev *udev);
+pepper_libinput_create(pepper_compositor_t *compositor, struct udev *udev);
PEPPER_API void
pepper_libinput_destroy(pepper_libinput_t *input);
if (listener)
return pepper_container_of(listener, pepper_buffer_t, resource_destroy_listener);
- buffer = (pepper_buffer_t *)pepper_object_alloc(sizeof(pepper_buffer_t), PEPPER_BUFFER);
+ buffer = (pepper_buffer_t *)pepper_object_alloc(sizeof(pepper_buffer_t));
if (!buffer)
return NULL;
}
PEPPER_API void
-pepper_buffer_reference(pepper_object_t *buf)
+pepper_buffer_reference(pepper_buffer_t *buffer)
{
- pepper_buffer_t *buffer = (pepper_buffer_t *)buf;
-
- CHECK_MAGIC_AND_NON_NULL(buf, PEPPER_BUFFER);
PEPPER_ASSERT(buffer->ref_count >= 0);
buffer->ref_count++;
}
PEPPER_API void
-pepper_buffer_unreference(pepper_object_t *buf)
+pepper_buffer_unreference(pepper_buffer_t *buffer)
{
- pepper_buffer_t *buffer = (pepper_buffer_t *)buf;
-
- CHECK_MAGIC_AND_NON_NULL(buf, PEPPER_BUFFER);
PEPPER_ASSERT(buffer->ref_count > 0);
if (--buffer->ref_count == 0)
}
PEPPER_API struct wl_resource *
-pepper_buffer_get_resource(pepper_object_t *buf)
+pepper_buffer_get_resource(pepper_buffer_t *buffer)
{
- pepper_buffer_t *buffer = (pepper_buffer_t *)buf;
- CHECK_MAGIC_AND_NON_NULL(buf, PEPPER_BUFFER);
return buffer->resource;
}
wl_resource_set_implementation(resource, &compositor_interface, compositor, NULL);
}
-PEPPER_API pepper_object_t *
+PEPPER_API pepper_compositor_t *
pepper_compositor_create(const char *socket_name)
{
- pepper_compositor_t *compositor = NULL;
+ pepper_compositor_t *compositor =
+ (pepper_compositor_t *)pepper_object_alloc(sizeof(pepper_compositor_t));
- compositor = (pepper_compositor_t *)pepper_object_alloc(sizeof(pepper_compositor_t),
- PEPPER_COMPOSITOR);
if (!compositor)
return NULL;
goto error;
}
- wl_global_create(compositor->display, &wl_compositor_interface, 3, compositor,
- compositor_bind);
+ wl_global_create(compositor->display, &wl_compositor_interface, 3, compositor, compositor_bind);
wl_list_init(&compositor->surfaces);
wl_list_init(&compositor->seat_list);
pepper_list_init(&compositor->output_list);
pepper_list_init(&compositor->view_list);
/* Install default input event handler */
- if( NULL == pepper_compositor_add_event_hook(&compositor->base,
+ if( NULL == pepper_compositor_add_event_hook(compositor,
pepper_compositor_event_handler,
compositor))
{
goto error;
}
- return &compositor->base;
+ return compositor;
error:
if (compositor)
- pepper_compositor_destroy(&compositor->base);
+ pepper_compositor_destroy(compositor);
return NULL;
}
PEPPER_API void
-pepper_compositor_destroy(pepper_object_t *cmp)
+pepper_compositor_destroy(pepper_compositor_t *compositor)
{
- pepper_compositor_t *compositor = (pepper_compositor_t *)cmp;
- CHECK_MAGIC_AND_NON_NULL(cmp, PEPPER_COMPOSITOR);
-
pepper_object_fini(&compositor->base);
if (compositor->display)
}
PEPPER_API struct wl_display *
-pepper_compositor_get_display(pepper_object_t *cmp)
+pepper_compositor_get_display(pepper_compositor_t *compositor)
{
- pepper_compositor_t *compositor = (pepper_compositor_t *)cmp;
- CHECK_MAGIC_AND_NON_NULL(cmp, PEPPER_COMPOSITOR);
return compositor->display;
}
{
pepper_pointer_t *pointer;
- pointer = (pepper_pointer_t *)pepper_object_alloc(sizeof(pepper_pointer_t), PEPPER_POINTER);
+ pointer = (pepper_pointer_t *)pepper_object_alloc(sizeof(pepper_pointer_t));
if (!pointer)
{
PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__);
{
pepper_keyboard_t *keyboard;
- keyboard = (pepper_keyboard_t *)pepper_object_alloc(sizeof(pepper_keyboard_t), PEPPER_KEYBOARD);
+ keyboard = (pepper_keyboard_t *)pepper_object_alloc(sizeof(pepper_keyboard_t));
if (!keyboard)
{
PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__);
{
pepper_touch_t *touch;
- touch = (pepper_touch_t *)pepper_object_alloc(sizeof(pepper_touch_t), PEPPER_TOUCH);
+ touch = (pepper_touch_t *)pepper_object_alloc(sizeof(pepper_touch_t));
if (!touch)
{
PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__);
seat_set_name(seat, name);
}
-PEPPER_API pepper_object_t *
-pepper_compositor_add_seat(pepper_object_t *c,
+PEPPER_API pepper_seat_t *
+pepper_compositor_add_seat(pepper_compositor_t *compositor,
const pepper_seat_backend_t *backend,
void *data)
{
- pepper_seat_t *seat;
- pepper_compositor_t *compositor = (pepper_compositor_t *)c;
-
- CHECK_MAGIC_AND_NON_NULL(c, PEPPER_COMPOSITOR);
-
- seat = (pepper_seat_t *)pepper_object_alloc(sizeof(pepper_seat_t), PEPPER_SEAT);
+ pepper_seat_t *seat = (pepper_seat_t *)pepper_object_alloc(sizeof(pepper_seat_t));
if (!seat)
{
PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__);
seat->global = wl_global_create(compositor->display, &wl_seat_interface, 4, seat,
bind_seat);
- return &seat->base;
+ return seat;
}
void
}
pepper_bool_t
-pepper_compositor_event_handler(pepper_object_t *s,
- pepper_input_event_t *event,
- void *data)
+pepper_compositor_event_handler(pepper_seat_t *seat, pepper_input_event_t *event, void *data)
{
/* TODO: */
/* pepper_compositor_t *compositor = data; */
- pepper_seat_t *seat = (pepper_seat_t *)s;
- CHECK_MAGIC_AND_NON_NULL(s, PEPPER_SEAT);
-
switch(event->type)
{
case PEPPER_INPUT_EVENT_KEYBOARD_KEY:
case PEPPER_INPUT_EVENT_POINTER_BUTTON:
{
/* FIXME: Send focused client only */
- struct wl_display *display = pepper_compositor_get_display(&seat->compositor->base);
+ struct wl_display *display = pepper_compositor_get_display(seat->compositor);
uint32_t serial = wl_display_next_serial(display);
struct wl_resource *pointer;
}
PEPPER_API pepper_event_hook_t *
-pepper_compositor_add_event_hook(pepper_object_t *c,
+pepper_compositor_add_event_hook(pepper_compositor_t *compositor,
pepper_event_handler_t handler,
void *data)
{
pepper_event_hook_t *hook;
- pepper_compositor_t *compositor = (pepper_compositor_t *)c;
-
- CHECK_MAGIC_AND_NON_NULL(c, PEPPER_COMPOSITOR);
if( !handler )
return NULL;
}
PEPPER_API void
-pepper_event_hook_destroy(pepper_event_hook_t *hook)
+pepper_event_hook_destroy(pepper_event_hook_t *hook)
{
wl_list_remove(&hook->link);
pepper_free(hook);
}
PEPPER_API pepper_bool_t
-pepper_seat_handle_event(pepper_object_t *s, pepper_input_event_t *event)
+pepper_seat_handle_event(pepper_seat_t *seat, pepper_input_event_t *event)
{
- pepper_seat_t *seat = (pepper_seat_t *)s;
- pepper_compositor_t *compositor = seat->compositor;
pepper_event_hook_t *hook, *tmp;
pepper_bool_t ret = PEPPER_FALSE;
- CHECK_MAGIC_AND_NON_NULL(s, PEPPER_SEAT);
-
/* Iterate installed hook chain. */
/* XXX: this code is not thread-safe */
- wl_list_for_each_safe(hook, tmp, &compositor->event_hook_chain, link)
+ wl_list_for_each_safe(hook, tmp, &seat->compositor->event_hook_chain, link)
{
- ret = hook->handler(&seat->base, event, hook->data);
+ ret = hook->handler(seat, event, hook->data);
/* Event consumed, do not delegate to next element */
if( PEPPER_TRUE == ret)
}
pepper_object_t *
-pepper_object_alloc(size_t size, uint32_t magic)
+pepper_object_alloc(size_t size)
{
pepper_object_t *object = pepper_calloc(1, size);
if (!object)
return NULL;
- if (!pepper_object_init(object, magic))
- {
- pepper_free(object);
- return NULL;
- }
-
- return object;
-}
-
-pepper_bool_t
-pepper_object_init(pepper_object_t *object, uint32_t magic)
-{
- object->magic = magic;
-
wl_signal_init(&object->destroy_signal);
-
- /* Create a hash table for user data. */
object->user_data_map = pepper_map_create(5, user_data_hash, user_data_key_length,
user_data_key_compare);
if (!object->user_data_map)
- return PEPPER_FALSE;
+ {
+ pepper_free(object);
+ return NULL;
+ }
- return PEPPER_TRUE;
+ return object;
}
void
output->modes = pepper_calloc(output->mode_count, sizeof(pepper_output_mode_t));
if (!output->modes)
{
- pepper_output_destroy(&output->base);
+ pepper_output_destroy(output);
return;
}
pepper_output_t *output = pepper_container_of(listener, pepper_output_t, data_destroy_listener);
output->data = NULL;
output->backend = NULL;
- pepper_output_destroy(&output->base);
+ pepper_output_destroy(output);
}
static void
if (!view->visibility || !(view->output_overlap & (1 << output->id)))
{
/* Detach from the previously assigned plane. */
- pepper_view_assign_plane(&view->base, &output->base, NULL);
+ pepper_view_assign_plane(view, output, NULL);
continue;
}
}
PEPPER_API void
-pepper_output_add_damage_region(pepper_object_t *out, pixman_region32_t *region)
+pepper_output_add_damage_region(pepper_output_t *output, pixman_region32_t *region)
{
pepper_list_t *l;
- pepper_output_t *output = (pepper_output_t *)out;
-
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
-
PEPPER_LIST_FOR_EACH(&output->plane_list, l)
pepper_plane_add_damage_region((pepper_plane_t *)l->item, region);
}
-PEPPER_API pepper_object_t *
-pepper_compositor_add_output(pepper_object_t *cmp,
+PEPPER_API pepper_output_t *
+pepper_compositor_add_output(pepper_compositor_t *compositor,
const pepper_output_backend_t *backend, void *data)
{
pepper_output_t *output;
- pepper_compositor_t *compositor = (pepper_compositor_t *)cmp;
uint32_t id;
- CHECK_MAGIC_AND_NON_NULL(cmp, PEPPER_COMPOSITOR);
-
id = ffs(~compositor->output_id_allocator);
if (id == 0)
id = id - 1;
- output = (pepper_output_t *)pepper_object_alloc(sizeof(pepper_output_t), PEPPER_OUTPUT);
+ output = (pepper_output_t *)pepper_object_alloc(sizeof(pepper_output_t));
if (!output)
return NULL;
backend->add_frame_listener(data, &output->frame.frame_listener);
pepper_list_init(&output->plane_list);
- return &output->base;
+ return output;
}
-PEPPER_API pepper_object_t *
-pepper_output_get_compositor(pepper_object_t *out)
+PEPPER_API pepper_compositor_t *
+pepper_output_get_compositor(pepper_output_t *output)
{
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
- return &(((pepper_output_t *)out)->compositor->base);
+ return output->compositor;
}
PEPPER_API void
-pepper_output_destroy(pepper_object_t *out)
+pepper_output_destroy(pepper_output_t *output)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
-
pepper_object_fini(&output->base);
output->compositor->output_id_allocator &= ~(1 << output->id);
}
PEPPER_API void
-pepper_output_move(pepper_object_t *out, int32_t x, int32_t y)
+pepper_output_move(pepper_output_t *output, int32_t x, int32_t y)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
-
if ((output->geometry.x != x) || (output->geometry.y != y))
{
output->geometry.x = x;
}
PEPPER_API const pepper_output_geometry_t *
-pepper_output_get_geometry(pepper_object_t *out)
+pepper_output_get_geometry(pepper_output_t *output)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
return &output->geometry;
}
PEPPER_API uint32_t
-pepper_output_get_scale(pepper_object_t *out)
+pepper_output_get_scale(pepper_output_t *output)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
return output->scale;
}
PEPPER_API int
-pepper_output_get_mode_count(pepper_object_t *out)
+pepper_output_get_mode_count(pepper_output_t *output)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
return output->mode_count;
}
PEPPER_API const pepper_output_mode_t *
-pepper_output_get_mode(pepper_object_t *out, int index)
+pepper_output_get_mode(pepper_output_t *output, int index)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
-
if (index < 0 || index >= output->mode_count)
return NULL;
}
PEPPER_API pepper_bool_t
-pepper_output_set_mode(pepper_object_t *out, const pepper_output_mode_t *mode)
+pepper_output_set_mode(pepper_output_t *output, const pepper_output_mode_t *mode)
{
- pepper_output_t *output = (pepper_output_t *)out;
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
-
if (output->current_mode == mode)
return PEPPER_TRUE;
#include <pixman.h>
#include <pepper-output-backend.h>
-typedef struct pepper_compositor pepper_compositor_t;
-typedef struct pepper_output pepper_output_t;
-typedef struct pepper_surface pepper_surface_t;
-typedef struct pepper_buffer pepper_buffer_t;
-typedef struct pepper_view pepper_view_t;
-typedef struct pepper_seat pepper_seat_t;
-typedef struct pepper_pointer pepper_pointer_t;
-typedef struct pepper_keyboard pepper_keyboard_t;
-typedef struct pepper_touch pepper_touch_t;
-typedef struct pepper_plane pepper_plane_t;
-
-#define CHECK_NON_NULL(ptr) \
- do { \
- if ((ptr) == NULL) { \
- PEPPER_ERROR("NULL check failed.\n"); \
- } \
- } while (0)
-
-#define CHECK_MAGIC(obj, val) \
- do { \
- if (((obj)->magic) != val) \
- { \
- PEPPER_ERROR("magic check failed : %p is not an %s\n", obj, #val); \
- } \
- } while (0)
-
-#define CHECK_MAGIC_AND_NON_NULL(obj, val) \
- do { \
- CHECK_NON_NULL(obj); \
- CHECK_MAGIC(obj, val); \
- } while (0)
-
-#define CHECK_MAGIC_IF_NON_NULL(obj, val) \
- do { \
- if (obj) \
- CHECK_MAGIC(obj, val); \
- } while (0)
-
#define PEPPER_MAX_OUTPUT_COUNT 32
typedef struct pepper_region pepper_region_t;
typedef struct pepper_data_device pepper_data_device_t;
typedef struct pepper_data_offer pepper_data_offer_t;
-enum pepper_magic
-{
- PEPPER_COMPOSITOR = 0x00000001,
- PEPPER_OUTPUT = 0x00000002,
- PEPPER_SURFACE = 0x00000003,
- PEPPER_BUFFER = 0x00000004,
- PEPPER_VIEW = 0x00000005,
- PEPPER_SEAT = 0x00000006,
- PEPPER_POINTER = 0x00000007,
- PEPPER_KEYBOARD = 0x00000008,
- PEPPER_TOUCH = 0x00000009,
- PEPPER_PLANE = 0x0000000a,
-};
-
struct pepper_object
{
- uint32_t magic;
struct wl_signal destroy_signal;
pepper_map_t *user_data_map;
};
pepper_object_t *
-pepper_object_alloc(size_t size, uint32_t magic);
-
-pepper_bool_t
-pepper_object_init(pepper_object_t *object, uint32_t magic);
+pepper_object_alloc(size_t size);
void
pepper_object_fini(pepper_object_t *object);
};
void
-pepper_view_assign_plane(pepper_object_t *view, pepper_object_t *output, pepper_object_t *plane);
-
-void
pepper_view_damage_below(pepper_view_t *view);
void
pepper_plane_create(pepper_object_t *output, pepper_object_t *above_plane);
void
-pepper_plane_destroy(pepper_object_t *plane);
-
-pixman_region32_t *
-pepper_plane_get_damage_region(pepper_object_t *plane);
-
-pixman_region32_t *
-pepper_plane_get_clip_region(pepper_object_t *plane);
-
-const pepper_list_t *
-pepper_plane_get_render_node_list(pepper_object_t *plane);
-
-void
-pepper_plane_subtract_damage_region(pepper_object_t *plane, pixman_region32_t *region);
-
-void
pepper_plane_add_damage_region(pepper_plane_t *plane, pixman_region32_t *region);
void
};
pepper_bool_t
-pepper_compositor_event_handler(pepper_object_t *seat,
- pepper_input_event_t *event,
- void *data);
+pepper_compositor_event_handler(pepper_seat_t *seat, pepper_input_event_t *event, void *data);
void
pepper_surface_flush_damage(pepper_surface_t *surface);
extern "C" {
#endif
+typedef struct pepper_plane pepper_plane_t;
typedef struct pepper_output_backend pepper_output_backend_t;
typedef struct pepper_render_item pepper_render_item_t;
void (*assign_planes)(void *output, const pepper_list_t *view_list);
void (*repaint)(void *output, const pepper_list_t *plane_list);
- void (*attach_surface)(void *output, pepper_object_t *surface, int *w, int *h);
+ void (*attach_surface)(void *output, pepper_surface_t *surface, int *w, int *h);
void (*add_frame_listener)(void *output, struct wl_listener *listener);
};
-PEPPER_API pepper_object_t *
-pepper_compositor_add_output(pepper_object_t *compositor,
+PEPPER_API pepper_output_t *
+pepper_compositor_add_output(pepper_compositor_t *compositor,
const pepper_output_backend_t *backend, void *data);
struct pepper_render_item
{
- pepper_object_t *view;
+ pepper_view_t *view;
pepper_mat4_t transform;
pixman_region32_t visible_region;
};
-PEPPER_API pepper_object_t *
-pepper_output_add_plane(pepper_object_t *output, pepper_object_t *above_plane);
+PEPPER_API pepper_plane_t *
+pepper_output_add_plane(pepper_output_t *output, pepper_plane_t *above_plane);
PEPPER_API void
-pepper_plane_destroy(pepper_object_t *plane);
+pepper_plane_destroy(pepper_plane_t *plane);
PEPPER_API pixman_region32_t *
-pepper_plane_get_damage_region(pepper_object_t *plane);
+pepper_plane_get_damage_region(pepper_plane_t *plane);
PEPPER_API pixman_region32_t *
-pepper_plane_get_clip_region(pepper_object_t *plane);
+pepper_plane_get_clip_region(pepper_plane_t *plane);
PEPPER_API const pepper_list_t *
-pepper_plane_get_render_list(pepper_object_t *plane);
+pepper_plane_get_render_list(pepper_plane_t *plane);
PEPPER_API void
-pepper_plane_subtract_damage_region(pepper_object_t *plane, pixman_region32_t *damage);
+pepper_plane_subtract_damage_region(pepper_plane_t *plane, pixman_region32_t *damage);
PEPPER_API void
-pepper_view_assign_plane(pepper_object_t *view, pepper_object_t *output, pepper_object_t *plane);
+pepper_view_assign_plane(pepper_view_t *view, pepper_output_t *output, pepper_plane_t *plane);
PEPPER_API void
-pepper_output_add_damage_region(pepper_object_t *output, pixman_region32_t *region);
+pepper_output_add_damage_region(pepper_output_t *output, pixman_region32_t *region);
#ifdef __cplusplus
}
#endif
typedef struct pepper_object pepper_object_t;
+
+typedef struct pepper_compositor pepper_compositor_t;
+typedef struct pepper_output pepper_output_t;
+typedef struct pepper_surface pepper_surface_t;
+typedef struct pepper_buffer pepper_buffer_t;
+typedef struct pepper_view pepper_view_t;
+typedef struct pepper_seat pepper_seat_t;
+typedef struct pepper_pointer pepper_pointer_t;
+typedef struct pepper_keyboard pepper_keyboard_t;
+typedef struct pepper_touch pepper_touch_t;
+
typedef struct pepper_output_geometry pepper_output_geometry_t;
typedef struct pepper_output_mode pepper_output_mode_t;
typedef struct pepper_seat_backend pepper_seat_backend_t;
pepper_object_add_destroy_listener(pepper_object_t *object, struct wl_listener *listener);
/* Compositor functions. */
-PEPPER_API pepper_object_t *
+PEPPER_API pepper_compositor_t *
pepper_compositor_create(const char *socket_name);
PEPPER_API void
-pepper_compositor_destroy(pepper_object_t *compositor);
+pepper_compositor_destroy(pepper_compositor_t *compositor);
PEPPER_API struct wl_display *
-pepper_compositor_get_display(pepper_object_t *compositor);
+pepper_compositor_get_display(pepper_compositor_t *compositor);
-PEPPER_API pepper_object_t *
-pepper_compositor_add_seat(pepper_object_t *compositor,
+PEPPER_API pepper_seat_t *
+pepper_compositor_add_seat(pepper_compositor_t *compositor,
const pepper_seat_backend_t *backend,
void *data);
-PEPPER_API pepper_object_t *
-pepper_output_get_compositor(pepper_object_t *output);
+PEPPER_API pepper_compositor_t *
+pepper_output_get_compositor(pepper_output_t *output);
PEPPER_API void
-pepper_output_destroy(pepper_object_t *output);
+pepper_output_destroy(pepper_output_t *output);
PEPPER_API void
-pepper_output_move(pepper_object_t *output, int32_t x, int32_t y);
+pepper_output_move(pepper_output_t *output, int32_t x, int32_t y);
PEPPER_API const pepper_output_geometry_t *
-pepper_output_get_geometry(pepper_object_t *output);
+pepper_output_get_geometry(pepper_output_t *output);
PEPPER_API unsigned int
-pepper_output_get_scale(pepper_object_t *output);
+pepper_output_get_scale(pepper_output_t *output);
PEPPER_API int
-pepper_output_get_mode_count(pepper_object_t *output);
+pepper_output_get_mode_count(pepper_output_t *output);
PEPPER_API const pepper_output_mode_t *
-pepper_output_get_mode(pepper_object_t *output, int index);
+pepper_output_get_mode(pepper_output_t *output, int index);
PEPPER_API pepper_bool_t
-pepper_output_set_mode(pepper_object_t *output, const pepper_output_mode_t *mode);
+pepper_output_set_mode(pepper_output_t *output, const pepper_output_mode_t *mode);
/* Input. */
struct pepper_seat_backend
};
PEPPER_API pepper_bool_t
-pepper_seat_handle_event(pepper_object_t *seat, pepper_input_event_t *event);
+pepper_seat_handle_event(pepper_seat_t *seat, pepper_input_event_t *event);
/* Event hook */
-typedef pepper_bool_t (*pepper_event_handler_t)(pepper_object_t *, pepper_input_event_t *, void *);
+typedef pepper_bool_t (*pepper_event_handler_t)(pepper_seat_t *, pepper_input_event_t *, void *);
PEPPER_API pepper_event_hook_t *
-pepper_compositor_add_event_hook(pepper_object_t *compositor,
+pepper_compositor_add_event_hook(pepper_compositor_t *compositor,
pepper_event_handler_t handler,
void *data);
PEPPER_API void
-pepper_event_hook_destroy(pepper_event_hook_t *hook);
+pepper_event_hook_destroy(pepper_event_hook_t *hook);
/* Surface. */
PEPPER_API const char *
-pepper_surface_get_role(pepper_object_t *surface);
+pepper_surface_get_role(pepper_surface_t *surface);
PEPPER_API pepper_bool_t
-pepper_surface_set_role(pepper_object_t *surface, const char *role);
+pepper_surface_set_role(pepper_surface_t *surface, const char *role);
-PEPPER_API pepper_object_t *
-pepper_surface_get_buffer(pepper_object_t *surface);
+PEPPER_API pepper_buffer_t *
+pepper_surface_get_buffer(pepper_surface_t *surface);
PEPPER_API void
-pepper_surface_get_buffer_offset(pepper_object_t *surface, int32_t *x, int32_t *y);
+pepper_surface_get_buffer_offset(pepper_surface_t *surface, int32_t *x, int32_t *y);
PEPPER_API int32_t
-pepper_surface_get_buffer_scale(pepper_object_t *surface);
+pepper_surface_get_buffer_scale(pepper_surface_t *surface);
PEPPER_API int32_t
-pepper_surface_get_buffer_transform(pepper_object_t *surface);
+pepper_surface_get_buffer_transform(pepper_surface_t *surface);
PEPPER_API const pixman_region32_t *
-pepper_surface_get_damage_region(pepper_object_t *surface);
+pepper_surface_get_damage_region(pepper_surface_t *surface);
PEPPER_API const pixman_region32_t *
-pepper_surface_get_opaque_region(pepper_object_t *surface);
+pepper_surface_get_opaque_region(pepper_surface_t *surface);
PEPPER_API const pixman_region32_t *
-pepper_surface_get_input_region(pepper_object_t *surface);
+pepper_surface_get_input_region(pepper_surface_t *surface);
/* Buffer. */
PEPPER_API void
-pepper_buffer_reference(pepper_object_t *buffer);
+pepper_buffer_reference(pepper_buffer_t *buffer);
PEPPER_API void
-pepper_buffer_unreference(pepper_object_t *buffer);
+pepper_buffer_unreference(pepper_buffer_t *buffer);
PEPPER_API struct wl_resource *
-pepper_buffer_get_resource(pepper_object_t *buffer);
+pepper_buffer_get_resource(pepper_buffer_t *buffer);
/* View. */
-PEPPER_API pepper_object_t *
-pepper_compositor_add_surface_view(pepper_object_t *compositor, pepper_object_t *surface);
+PEPPER_API pepper_view_t *
+pepper_compositor_add_surface_view(pepper_compositor_t *compositor, pepper_surface_t *surface);
PEPPER_API void
-pepper_view_destroy(pepper_object_t *view);
+pepper_view_destroy(pepper_view_t *view);
-PEPPER_API pepper_object_t *
-pepper_view_get_compositor(pepper_object_t *view);
+PEPPER_API pepper_compositor_t *
+pepper_view_get_compositor(pepper_view_t *view);
-PEPPER_API pepper_object_t *
-pepper_view_get_surface(pepper_object_t *view);
+PEPPER_API pepper_surface_t *
+pepper_view_get_surface(pepper_view_t *view);
PEPPER_API void
-pepper_view_set_parent(pepper_object_t *view, pepper_object_t *parent);
+pepper_view_set_parent(pepper_view_t *view, pepper_view_t *parent);
-PEPPER_API pepper_object_t *
-pepper_view_get_parent(pepper_object_t *view);
+PEPPER_API pepper_view_t *
+pepper_view_get_parent(pepper_view_t *view);
PEPPER_API pepper_bool_t
-pepper_view_stack_above(pepper_object_t *view, pepper_object_t *below, pepper_bool_t subtree);
+pepper_view_stack_above(pepper_view_t *view, pepper_view_t *below, pepper_bool_t subtree);
PEPPER_API pepper_bool_t
-pepper_view_stack_below(pepper_object_t *view, pepper_object_t *above, pepper_bool_t subtree);
+pepper_view_stack_below(pepper_view_t *view, pepper_view_t *above, pepper_bool_t subtree);
PEPPER_API void
-pepper_view_stack_top(pepper_object_t *view, pepper_bool_t subtree);
+pepper_view_stack_top(pepper_view_t *view, pepper_bool_t subtree);
PEPPER_API void
-pepper_view_stack_bottom(pepper_object_t *view, pepper_bool_t subtree);
+pepper_view_stack_bottom(pepper_view_t *view, pepper_bool_t subtree);
-PEPPER_API pepper_object_t *
-pepper_view_get_above(pepper_object_t *view);
+PEPPER_API pepper_view_t *
+pepper_view_get_above(pepper_view_t *view);
-PEPPER_API pepper_object_t *
-pepper_view_get_below(pepper_object_t *view);
+PEPPER_API pepper_view_t *
+pepper_view_get_below(pepper_view_t *view);
PEPPER_API const pepper_list_t *
-pepper_view_get_children_list(pepper_object_t *view);
+pepper_view_get_children_list(pepper_view_t *view);
PEPPER_API void
-pepper_view_resize(pepper_object_t *view, int w, int h);
+pepper_view_resize(pepper_view_t *view, int w, int h);
PEPPER_API void
-pepper_view_get_size(pepper_object_t *view, int *w, int *h);
+pepper_view_get_size(pepper_view_t *view, int *w, int *h);
PEPPER_API void
-pepper_view_set_position(pepper_object_t *view, double x, double y);
+pepper_view_set_position(pepper_view_t *view, double x, double y);
PEPPER_API void
-pepper_view_get_position(pepper_object_t *view, double *x, double *y);
+pepper_view_get_position(pepper_view_t *view, double *x, double *y);
PEPPER_API void
-pepper_view_set_transform(pepper_object_t *view, const pepper_mat4_t *matrix);
+pepper_view_set_transform(pepper_view_t *view, const pepper_mat4_t *matrix);
PEPPER_API const pepper_mat4_t *
-pepper_view_get_transform(pepper_object_t *view);
+pepper_view_get_transform(pepper_view_t *view);
PEPPER_API void
-pepper_view_map(pepper_object_t *view);
+pepper_view_map(pepper_view_t *view);
PEPPER_API void
-pepper_view_unmap(pepper_object_t *view);
+pepper_view_unmap(pepper_view_t *view);
PEPPER_API pepper_bool_t
-pepper_view_is_mapped(pepper_object_t *view);
+pepper_view_is_mapped(pepper_view_t *view);
PEPPER_API pepper_bool_t
-pepper_view_is_visible(pepper_object_t *view);
+pepper_view_is_visible(pepper_view_t *view);
#ifdef __cplusplus
}
pixman_region32_intersect_rect(clip, clip, 0, 0, w, h);
}
-PEPPER_API pepper_object_t *
-pepper_output_add_plane(pepper_object_t *out, pepper_object_t *above_plane)
+PEPPER_API pepper_plane_t *
+pepper_output_add_plane(pepper_output_t *output, pepper_plane_t *above)
{
- pepper_plane_t *plane;
- pepper_output_t *output = (pepper_output_t *)out;
- pepper_plane_t *above = (pepper_plane_t *)above_plane;
-
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
- CHECK_MAGIC_IF_NON_NULL(above_plane, PEPPER_PLANE);
+ pepper_plane_t *plane;
if (above && above->output != output)
return NULL;
- plane = (pepper_plane_t *)pepper_object_alloc(sizeof(pepper_plane_t), PEPPER_PLANE);
+ plane = (pepper_plane_t *)pepper_object_alloc(sizeof(pepper_plane_t));
if (!plane)
return NULL;
pixman_region32_init(&plane->damage_region);
pixman_region32_init(&plane->clip_region);
- return &plane->base;
+ return plane;
}
-void
-pepper_plane_destroy(pepper_object_t *pln)
+PEPPER_API void
+pepper_plane_destroy(pepper_plane_t *plane)
{
- pepper_plane_t *plane = (pepper_plane_t *)pln;
pepper_list_t *l;
- CHECK_MAGIC_AND_NON_NULL(pln, PEPPER_PLANE);
-
- pepper_object_fini(pln);
+ pepper_object_fini(&plane->base);
PEPPER_LIST_FOR_EACH(&plane->entry_list, l)
{
pepper_plane_entry_t *entry = l->item;
- pepper_view_assign_plane(entry->base.view, &plane->output->base, NULL);
+ pepper_view_assign_plane(entry->base.view, plane->output, NULL);
}
pepper_list_remove(&plane->link, NULL);
}
PEPPER_API pixman_region32_t *
-pepper_plane_get_damage_region(pepper_object_t *pln)
+pepper_plane_get_damage_region(pepper_plane_t *plane)
{
- pepper_plane_t *plane = (pepper_plane_t *)pln;
- CHECK_MAGIC_AND_NON_NULL(pln, PEPPER_PLANE);
return &plane->damage_region;
}
-pixman_region32_t *
-pepper_plane_get_clip_region(pepper_object_t *pln)
+PEPPER_API pixman_region32_t *
+pepper_plane_get_clip_region(pepper_plane_t *plane)
{
- pepper_plane_t *plane = (pepper_plane_t *)pln;
- CHECK_MAGIC_AND_NON_NULL(pln, PEPPER_PLANE);
return &plane->clip_region;
}
-const pepper_list_t *
-pepper_plane_get_render_list(pepper_object_t *pln)
+PEPPER_API const pepper_list_t *
+pepper_plane_get_render_list(pepper_plane_t *plane)
{
- pepper_plane_t *plane = (pepper_plane_t *)pln;
- CHECK_MAGIC_AND_NON_NULL(pln, PEPPER_PLANE);
return &plane->entry_list;
}
-void
-pepper_plane_subtract_damage_region(pepper_object_t *pln, pixman_region32_t *damage)
+PEPPER_API void
+pepper_plane_subtract_damage_region(pepper_plane_t *plane, pixman_region32_t *damage)
{
- pepper_plane_t *plane = (pepper_plane_t *)pln;
- CHECK_MAGIC_AND_NON_NULL(pln, PEPPER_PLANE);
pixman_region32_subtract(&plane->damage_region, &plane->damage_region, damage);
}
struct wl_resource *resource,
uint32_t id)
{
- pepper_surface_t *surface = (pepper_surface_t *)pepper_object_alloc(sizeof(pepper_surface_t),
- PEPPER_SURFACE);
+ pepper_surface_t *surface = (pepper_surface_t *)pepper_object_alloc(sizeof(pepper_surface_t));
if (!surface)
{
PEPPER_ERROR("Surface memory allocation failed\n");
pepper_surface_state_fini(&surface->pending);
if (surface->buffer.buffer)
- pepper_buffer_unreference(&surface->buffer.buffer->base);
+ pepper_buffer_unreference(surface->buffer.buffer);
pixman_region32_fini(&surface->damage_region);
pixman_region32_fini(&surface->opaque_region);
wl_list_for_each(output, &surface->compositor->output_list, link)
{
- output->backend->attach_surface(output->data, &surface->base, &w, &h);
+ output->backend->attach_surface(output->data, surface, &w, &h);
surface->buffer.buffer->w = w;
surface->buffer.buffer->h = h;
if (surface->pending.buffer)
{
wl_list_remove(&surface->pending.buffer_destroy_listener.link);
- pepper_buffer_reference(&surface->pending.buffer->base);
+ pepper_buffer_reference(surface->pending.buffer);
}
if (surface->buffer.buffer)
- pepper_buffer_unreference(&surface->buffer.buffer->base);
+ pepper_buffer_unreference(surface->buffer.buffer);
surface->buffer.buffer = surface->pending.buffer;
surface->buffer.x += surface->pending.x;
}
PEPPER_API const char *
-pepper_surface_get_role(pepper_object_t *sfc)
+pepper_surface_get_role(pepper_surface_t *surface)
{
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
- return ((pepper_surface_t *)sfc)->role;
+ return surface->role;
}
PEPPER_API pepper_bool_t
-pepper_surface_set_role(pepper_object_t *sfc, const char *role)
+pepper_surface_set_role(pepper_surface_t *surface, const char *role)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
-
if (surface->role)
return PEPPER_FALSE;
return PEPPER_TRUE;
}
-PEPPER_API pepper_object_t *
-pepper_surface_get_buffer(pepper_object_t *sfc)
+PEPPER_API pepper_buffer_t *
+pepper_surface_get_buffer(pepper_surface_t *surface)
{
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
- return &(((pepper_surface_t *)sfc)->buffer.buffer->base);
+ return surface->buffer.buffer;
}
PEPPER_API void
-pepper_surface_get_buffer_offset(pepper_object_t *sfc, int32_t *x, int32_t *y)
+pepper_surface_get_buffer_offset(pepper_surface_t *surface, int32_t *x, int32_t *y)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
-
if (x)
*x = surface->buffer.x;
}
PEPPER_API int32_t
-pepper_surface_get_buffer_scale(pepper_object_t *sfc)
+pepper_surface_get_buffer_scale(pepper_surface_t *surface)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
return surface->buffer.scale;
}
PEPPER_API int32_t
-pepper_surface_get_buffer_transform(pepper_object_t *sfc)
+pepper_surface_get_buffer_transform(pepper_surface_t *surface)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
return surface->buffer.transform;
}
PEPPER_API const pixman_region32_t *
-pepper_surface_get_damage_region(pepper_object_t *sfc)
+pepper_surface_get_damage_region(pepper_surface_t *surface)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
return &surface->damage_region;
}
PEPPER_API const pixman_region32_t *
-pepper_surface_get_opaque_region(pepper_object_t *sfc)
+pepper_surface_get_opaque_region(pepper_surface_t *surface)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
return &surface->opaque_region;
}
PEPPER_API const pixman_region32_t *
-pepper_surface_get_input_region(pepper_object_t *sfc)
+pepper_surface_get_input_region(pepper_surface_t *surface)
{
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
return &surface->input_region;
}
{
pepper_view_t *view = pepper_container_of(listener, pepper_view_t, surface_destroy_listener);
PEPPER_ASSERT(view->surface != NULL);
- pepper_view_destroy(&view->base);
+ pepper_view_destroy(view);
}
static void
}
void
-pepper_view_assign_plane(pepper_object_t *v, pepper_object_t *out, pepper_object_t *pln)
+pepper_view_assign_plane(pepper_view_t *view, pepper_output_t *output, pepper_plane_t *plane)
{
- pepper_view_t *view = (pepper_view_t *)v;
- pepper_output_t *output = (pepper_output_t *)out;
- pepper_plane_t *plane = (pepper_plane_t *)pln;
-
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
- CHECK_MAGIC_AND_NON_NULL(out, PEPPER_OUTPUT);
- CHECK_MAGIC_IF_NON_NULL(pln, PEPPER_PLANE);
-
if (plane && plane->output != output)
{
PEPPER_ERROR("Output mismatch.\n");
for (i = 0; i < PEPPER_MAX_OUTPUT_COUNT; i++)
{
- view->plane_entries[i].base.view = &view->base;
+ view->plane_entries[i].base.view = view;
view->plane_entries[i].link.item = &view->plane_entries[i];
}
}
-PEPPER_API pepper_object_t *
-pepper_compositor_add_surface_view(pepper_object_t *comp, pepper_object_t *sfc)
+PEPPER_API pepper_view_t *
+pepper_compositor_add_surface_view(pepper_compositor_t *compositor, pepper_surface_t *surface)
{
- pepper_view_t *view;
- pepper_compositor_t *compositor = (pepper_compositor_t *)comp;
- pepper_surface_t *surface = (pepper_surface_t *)sfc;
-
- CHECK_MAGIC_AND_NON_NULL(comp, PEPPER_COMPOSITOR);
- CHECK_MAGIC_AND_NON_NULL(sfc, PEPPER_SURFACE);
-
- view = (pepper_view_t *)pepper_object_alloc(sizeof(pepper_view_t), PEPPER_VIEW);
+ pepper_view_t *view = (pepper_view_t *)pepper_object_alloc(sizeof(pepper_view_t));
if (!view)
{
PEPPER_ERROR("Failed to allocate a pepper object.\n");
view->surface_destroy_listener.notify = view_handle_surface_destroy;
pepper_object_add_destroy_listener(&surface->base, &view->surface_destroy_listener);
- return &view->base;
+ return view;
}
PEPPER_API void
-pepper_view_destroy(pepper_object_t *v)
+pepper_view_destroy(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
pepper_list_t *l, *next;
int i;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
/* Destroy signal is emitted in here so that any children that are willing to survive this
* destruction can detach from their parent.
*/
plane_entry_set_plane(&view->plane_entries[i], NULL);
PEPPER_LIST_FOR_EACH_SAFE(&view->children_list, l, next)
- pepper_view_destroy((pepper_object_t *)(l->item));
+ pepper_view_destroy((pepper_view_t *)(l->item));
PEPPER_ASSERT(pepper_list_empty(&view->children_list));
pepper_free(view);
}
-PEPPER_API pepper_object_t *
-pepper_view_get_compositor(pepper_object_t *v)
+PEPPER_API pepper_compositor_t *
+pepper_view_get_compositor(pepper_view_t *view)
{
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
- return &((pepper_view_t *)v)->compositor->base;
+ return view->compositor;
}
-PEPPER_API pepper_object_t *
-pepper_view_get_surface(pepper_object_t *v)
+PEPPER_API pepper_surface_t *
+pepper_view_get_surface(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
- if (view->surface)
- return &((pepper_view_t *)view)->surface->base;
-
- return NULL;
+ return view->surface;
}
PEPPER_API void
-pepper_view_set_parent(pepper_object_t *v, pepper_object_t *p)
+pepper_view_set_parent(pepper_view_t *view, pepper_view_t *parent)
{
- pepper_view_t *view = (pepper_view_t *)v;
- pepper_view_t *parent = (pepper_view_t *)p;
-
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
- CHECK_MAGIC_IF_NON_NULL(p, PEPPER_VIEW);
-
if (view->parent == parent)
return;
view_geometry_dirty(view);
}
-PEPPER_API pepper_object_t *
-pepper_view_get_parent(pepper_object_t *v)
+PEPPER_API pepper_view_t *
+pepper_view_get_parent(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
- return &view->parent->base;
+ return view->parent;
}
PEPPER_API pepper_bool_t
-pepper_view_stack_above(pepper_object_t *v, pepper_object_t *b, pepper_bool_t subtree)
+pepper_view_stack_above(pepper_view_t *view, pepper_view_t *below, pepper_bool_t subtree)
{
- pepper_view_t *view = (pepper_view_t *)v;
- pepper_view_t *below = (pepper_view_t *)b;
-
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
- CHECK_MAGIC_AND_NON_NULL(b, PEPPER_VIEW);
-
view_insert(view, &below->compositor_link, subtree);
return PEPPER_TRUE;
}
PEPPER_API pepper_bool_t
-pepper_view_stack_below(pepper_object_t *v, pepper_object_t *a, pepper_bool_t subtree)
+pepper_view_stack_below(pepper_view_t *view, pepper_view_t *above, pepper_bool_t subtree)
{
- pepper_view_t *view = (pepper_view_t *)v;
- pepper_view_t *above = (pepper_view_t *)a;
-
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
- CHECK_MAGIC_AND_NON_NULL(a, PEPPER_VIEW);
-
view_insert(view, above->compositor_link.prev, subtree);
return PEPPER_TRUE;
}
PEPPER_API void
-pepper_view_stack_top(pepper_object_t *v, pepper_bool_t subtree)
+pepper_view_stack_top(pepper_view_t *view, pepper_bool_t subtree)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
view_insert(view, view->compositor->view_list.prev, subtree);
}
PEPPER_API void
-pepper_view_stack_bottom(pepper_object_t *v, pepper_bool_t subtree)
+pepper_view_stack_bottom(pepper_view_t *view, pepper_bool_t subtree)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
view_insert(view, &view->compositor->view_list, subtree);
}
-PEPPER_API pepper_object_t *
-pepper_view_get_above(pepper_object_t *v)
+PEPPER_API pepper_view_t *
+pepper_view_get_above(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
return view->compositor_link.next->item;
}
-PEPPER_API pepper_object_t *
-pepper_view_get_below(pepper_object_t *v)
+PEPPER_API pepper_view_t *
+pepper_view_get_below(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
return view->compositor_link.prev->item;
}
PEPPER_API const pepper_list_t *
-pepper_view_get_children_list(pepper_object_t *v)
+pepper_view_get_children_list(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
return &view->children_list;
}
PEPPER_API void
-pepper_view_resize(pepper_object_t *v, int w, int h)
+pepper_view_resize(pepper_view_t *view, int w, int h)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
if (view->w == w && view->h == h)
return;
}
PEPPER_API void
-pepper_view_get_size(pepper_object_t *v, int *w, int *h)
+pepper_view_get_size(pepper_view_t *view, int *w, int *h)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
if (w)
*w = view->w;
}
PEPPER_API void
-pepper_view_set_position(pepper_object_t *v, double x, double y)
+pepper_view_set_position(pepper_view_t *view, double x, double y)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
if (view->x == x && view->y == y)
return;
}
PEPPER_API void
-pepper_view_get_position(pepper_object_t *v, double *x, double *y)
+pepper_view_get_position(pepper_view_t *view, double *x, double *y)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
if (x)
*x = view->x;
}
PEPPER_API void
-pepper_view_set_transform(pepper_object_t *v, const pepper_mat4_t *matrix)
+pepper_view_set_transform(pepper_view_t *view, const pepper_mat4_t *matrix)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
-
pepper_mat4_copy(&view->transform, matrix);
view_geometry_dirty(view);
}
PEPPER_API const pepper_mat4_t *
-pepper_view_get_transform(pepper_object_t *v)
+pepper_view_get_transform(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
return &view->transform;
}
PEPPER_API void
-pepper_view_map(pepper_object_t *v)
+pepper_view_map(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
view_map(view);
}
PEPPER_API void
-pepper_view_unmap(pepper_object_t *v)
+pepper_view_unmap(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
view_unmap(view);
}
PEPPER_API pepper_bool_t
-pepper_view_is_mapped(pepper_object_t *v)
+pepper_view_is_mapped(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
return view->mapped;
}
PEPPER_API pepper_bool_t
-pepper_view_is_visible(pepper_object_t *v)
+pepper_view_is_visible(pepper_view_t *view)
{
- pepper_view_t *view = (pepper_view_t *)v;
- CHECK_MAGIC_AND_NON_NULL(v, PEPPER_VIEW);
return view->visibility;
}
struct gl_surface_state
{
gl_renderer_t *renderer;
- pepper_object_t *surface;
+ pepper_surface_t *surface;
- pepper_object_t *buffer;
+ pepper_buffer_t *buffer;
int buffer_width, buffer_height;
int buffer_type;
surface_state_release_buffer(state);
wl_list_remove(&state->surface_destroy_listener.link);
- pepper_object_set_user_data(state->surface, state->renderer, NULL, NULL);
+ pepper_object_set_user_data((pepper_object_t *)state->surface, state->renderer, NULL, NULL);
free(state);
}
}
static gl_surface_state_t *
-get_surface_state(pepper_renderer_t *renderer, pepper_object_t *surface)
+get_surface_state(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
- gl_surface_state_t *state = pepper_object_get_user_data(surface, renderer);
+ gl_surface_state_t *state = pepper_object_get_user_data((pepper_object_t *)surface, renderer);
if (!state)
{
state->buffer_destroy_listener.notify = surface_state_handle_buffer_destroy;
state->surface_destroy_listener.notify = surface_state_handle_surface_destroy;
- pepper_object_add_destroy_listener(surface, &state->surface_destroy_listener);
- pepper_object_set_user_data(surface, renderer, state, NULL);
+ pepper_object_add_destroy_listener((pepper_object_t *)surface,
+ &state->surface_destroy_listener);
+ pepper_object_set_user_data((pepper_object_t *)surface, renderer, state, NULL);
}
return state;
}
static pepper_bool_t
-surface_state_attach_shm(gl_surface_state_t *state, pepper_object_t *buffer)
+surface_state_attach_shm(gl_surface_state_t *state, pepper_buffer_t *buffer)
{
struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get(pepper_buffer_get_resource(buffer));
int w, h;
}
static pepper_bool_t
-surface_state_attach_egl(gl_surface_state_t *state, pepper_object_t *buffer)
+surface_state_attach_egl(gl_surface_state_t *state, pepper_buffer_t *buffer)
{
gl_renderer_t *gr = state->renderer;
EGLDisplay display = gr->display;
}
static pepper_bool_t
-gl_renderer_attach_surface(pepper_renderer_t *renderer, pepper_object_t *surface, int *w, int *h)
+gl_renderer_attach_surface(pepper_renderer_t *renderer, pepper_surface_t *surface, int *w, int *h)
{
gl_surface_state_t *state = get_surface_state(renderer, surface);
- pepper_object_t *buffer = pepper_surface_get_buffer(surface);
+ pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
if (!buffer)
{
/* Set new buffer. */
state->buffer = buffer;
- pepper_object_add_destroy_listener(buffer, &state->buffer_destroy_listener);
+ pepper_object_add_destroy_listener((pepper_object_t *)buffer, &state->buffer_destroy_listener);
/* Output buffer size info. */
*w = state->buffer_width;
}
static pepper_bool_t
-gl_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_object_t *surface)
+gl_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
gl_surface_state_t *state = get_surface_state(renderer, surface);
}
static void
-gl_renderer_repaint_output(pepper_renderer_t *renderer, pepper_object_t *out,
+gl_renderer_repaint_output(pepper_renderer_t *renderer, pepper_output_t *output,
const pepper_list_t *list, pixman_region32_t *damage)
{
gl_renderer_t *gr = (gl_renderer_t *)renderer;
}
PEPPER_API pepper_renderer_t *
-pepper_gl_renderer_create(pepper_object_t *compositor, void *native_display, const char *platform)
+pepper_gl_renderer_create(pepper_compositor_t *compositor, void *native_display, const char *platform)
{
gl_renderer_t *gr;
EGLint major, minor;
#endif
PEPPER_API pepper_renderer_t *
-pepper_gl_renderer_create(pepper_object_t *compositor, void *display, const char *platform);
+pepper_gl_renderer_create(pepper_compositor_t *compositor, void *display, const char *platform);
PEPPER_API pepper_render_target_t *
pepper_gl_renderer_create_target(pepper_renderer_t *renderer, void *window, pepper_format_t format,
#endif
PEPPER_API pepper_renderer_t *
-pepper_pixman_renderer_create(pepper_object_t *compositor);
+pepper_pixman_renderer_create(pepper_compositor_t *compositor);
PEPPER_API pepper_render_target_t *
pepper_pixman_renderer_create_target(pepper_format_t format, void *pixels,
struct pepper_renderer
{
- pepper_object_t *compositor;
+ pepper_compositor_t *compositor;
pepper_render_target_t *target;
void (*destroy)(pepper_renderer_t *renderer);
pepper_bool_t (*attach_surface)(pepper_renderer_t *renderer,
- pepper_object_t *surface, int *w, int *h);
+ pepper_surface_t *surface, int *w, int *h);
- pepper_bool_t (*flush_surface_damage)(pepper_renderer_t *renderer, pepper_object_t *surface);
+ pepper_bool_t (*flush_surface_damage)(pepper_renderer_t *renderer, pepper_surface_t *surface);
pepper_bool_t (*read_pixels)(pepper_renderer_t *renderer,
int x, int y, int w, int h,
void *pixels, pepper_format_t format);
void (*repaint_output)(pepper_renderer_t *renderer,
- pepper_object_t *output,
+ pepper_output_t *output,
const pepper_list_t *render_list,
pixman_region32_t *damage);
};
PEPPER_API pepper_bool_t
pepper_renderer_attach_surface(pepper_renderer_t *renderer,
- pepper_object_t *surface, int *w, int *h);
+ pepper_surface_t *surface, int *w, int *h);
PEPPER_API pepper_bool_t
-pepper_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_object_t *surface);
+pepper_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_surface_t *surface);
PEPPER_API void
-pepper_renderer_repaint_output(pepper_renderer_t *renderer, pepper_object_t *output,
+pepper_renderer_repaint_output(pepper_renderer_t *renderer, pepper_output_t *output,
const pepper_list_t *view_list, pixman_region32_t *damage);
PEPPER_API pepper_bool_t
{
pixman_renderer_t *renderer;
- pepper_object_t *surface;
- pepper_object_t *buffer;
+ pepper_surface_t *surface;
+ pepper_buffer_t *buffer;
int buffer_width, buffer_height;
pixman_image_t *image;
surface_state_release_buffer(state);
wl_list_remove(&state->surface_destroy_listener.link);
- pepper_object_set_user_data(state->surface, state->renderer, NULL, NULL);
+ pepper_object_set_user_data((pepper_object_t *)state->surface, state->renderer, NULL, NULL);
free(state);
}
}
static pixman_surface_state_t *
-get_surface_state(pepper_renderer_t *renderer, pepper_object_t *surface)
+get_surface_state(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
- pixman_surface_state_t *state = pepper_object_get_user_data(surface, renderer);
+ pixman_surface_state_t *state = pepper_object_get_user_data((pepper_object_t *)surface, renderer);
if (!state)
{
state->buffer_destroy_listener.notify = surface_state_handle_buffer_destroy;
state->surface_destroy_listener.notify = surface_state_handle_surface_destroy;
- pepper_object_add_destroy_listener(surface, &state->surface_destroy_listener);
- pepper_object_set_user_data(surface, renderer, state, NULL);
+ pepper_object_add_destroy_listener((pepper_object_t *)surface,
+ &state->surface_destroy_listener);
+ pepper_object_set_user_data((pepper_object_t *)surface, renderer, state, NULL);
}
return state;
}
static pepper_bool_t
-surface_state_attach_shm(pixman_surface_state_t *state, pepper_object_t *buffer)
+surface_state_attach_shm(pixman_surface_state_t *state, pepper_buffer_t *buffer)
{
struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get(pepper_buffer_get_resource(buffer));
pixman_format_code_t format;
}
static pepper_bool_t
-pixman_renderer_attach_surface(pepper_renderer_t *renderer, pepper_object_t *surface,
+pixman_renderer_attach_surface(pepper_renderer_t *renderer, pepper_surface_t *surface,
int *w, int *h)
{
pixman_surface_state_t *state = get_surface_state(renderer, surface);
- pepper_object_t *buffer = pepper_surface_get_buffer(surface);
+ pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
if (!buffer)
{
/* Set new buffer. */
state->buffer = buffer;
- pepper_object_add_destroy_listener(buffer, &state->buffer_destroy_listener);
+ pepper_object_add_destroy_listener((pepper_object_t *)buffer, &state->buffer_destroy_listener);
/* Output buffer size info. */
*w = state->buffer_width;
}
static pepper_bool_t
-pixman_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_object_t *surface)
+pixman_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
return PEPPER_TRUE;
}
}
static void
-pixman_renderer_repaint_output(pepper_renderer_t *renderer, pepper_object_t *output,
+pixman_renderer_repaint_output(pepper_renderer_t *renderer, pepper_output_t *output,
const pepper_list_t *render_list,
pixman_region32_t *damage)
{
}
PEPPER_API pepper_renderer_t *
-pepper_pixman_renderer_create(pepper_object_t *compositor)
+pepper_pixman_renderer_create(pepper_compositor_t *compositor)
{
pixman_renderer_t *renderer;
PEPPER_API pepper_bool_t
pepper_renderer_attach_surface(pepper_renderer_t *renderer,
- pepper_object_t *surface, int *w, int *h)
+ pepper_surface_t *surface, int *w, int *h)
{
return renderer->attach_surface(renderer, surface, w, h);
}
PEPPER_API pepper_bool_t
-pepper_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_object_t *surface)
+pepper_renderer_flush_surface_damage(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
return renderer->flush_surface_damage(renderer, surface);
}
PEPPER_API void
-pepper_renderer_repaint_output(pepper_renderer_t *renderer, pepper_object_t *output,
+pepper_renderer_repaint_output(pepper_renderer_t *renderer, pepper_output_t *output,
const pepper_list_t *view_list, pixman_region32_t *damage)
{
renderer->repaint_output(renderer, output, view_list, damage);
int
main(int argc, char **argv)
{
- pepper_object_t *compositor = NULL;
+ pepper_compositor_t *compositor = NULL;
pepper_drm_t *drm = NULL;
struct wl_display *display = NULL;
struct wl_event_loop *loop = NULL;
int
main(int argc, char **argv)
{
- pepper_object_t *compositor = NULL;
+ pepper_compositor_t *compositor = NULL;
pepper_fbdev_t *fbdev = NULL;
struct wl_display *display = NULL;
struct wl_event_loop *loop = NULL;
int
main(int argc, char **argv)
{
- pepper_object_t *compositor;
- pepper_wayland_t *conn;
- pepper_object_t *output;
- struct wl_display *display;
+ pepper_compositor_t *compositor;
+ pepper_wayland_t *conn;
+ pepper_output_t *output;
+ struct wl_display *display;
compositor = pepper_compositor_create("wayland-1");
PEPPER_ASSERT(compositor);
int
main(int argc, char **argv)
{
- pepper_object_t *compositor;
- pepper_object_t *output;
+ pepper_compositor_t *compositor;
+ pepper_output_t *output;
pepper_output_mode_t mode;
pepper_x11_connection_t *conn;
typedef struct pepper_wayland pepper_wayland_t;
PEPPER_API pepper_wayland_t *
-pepper_wayland_connect(pepper_object_t *compositor, const char *socket_name);
+pepper_wayland_connect(pepper_compositor_t *compositor, const char *socket_name);
PEPPER_API void
pepper_wayland_destroy(pepper_wayland_t *conn);
-PEPPER_API pepper_object_t *
+PEPPER_API pepper_output_t *
pepper_wayland_output_create(pepper_wayland_t *conn, int32_t w, int32_t h, const char *renderer);
#ifdef __cplusplus
}
PEPPER_API pepper_wayland_t *
-pepper_wayland_connect(pepper_object_t *compositor, const char *socket_name)
+pepper_wayland_connect(pepper_compositor_t *compositor, const char *socket_name)
{
pepper_wayland_t *conn;
struct wl_display *compositor_display;
#include "pepper-wayland.h"
#include <wayland-client.h>
#include <pixman.h>
+#include <pepper-output-backend.h>
#include <pepper-render.h>
#include <pepper-pixman-renderer.h>
#include <pepper-gl-renderer.h>
struct pepper_wayland
{
- pepper_object_t *pepper;
+ pepper_compositor_t *pepper;
char *socket_name;
struct wl_display *display;
struct wayland_output
{
pepper_wayland_t *conn;
- pepper_object_t *base;
+ pepper_output_t *base;
struct wl_signal destroy_signal;
struct wl_signal mode_change_signal;
} egl;
#endif
- pepper_object_t *primary_plane;
+ pepper_plane_t *primary_plane;
};
struct wayland_seat
{
- pepper_object_t *base;
+ pepper_seat_t *base;
uint32_t id;
uint32_t caps;
#include "wayland-internal.h"
#include <string.h>
#include <stdlib.h>
-#include <pepper-output-backend.h>
#include <pepper-pixman-renderer.h>
#if ENABLE_WAYLAND_BACKEND_EGL && ENABLE_GL_RENDERER
PEPPER_LIST_FOR_EACH(view_list, l)
{
- pepper_object_t *view = l->item;
+ pepper_view_t *view = l->item;
pepper_view_assign_plane(view, output->base, output->primary_plane);
}
}
PEPPER_LIST_FOR_EACH(plane_list, l)
{
- pepper_object_t *plane = l->item;
+ pepper_plane_t *plane = l->item;
if (plane == output->primary_plane)
{
}
static void
-wayland_output_attach_surface(void *o, pepper_object_t *surface, int *w, int *h)
+wayland_output_attach_surface(void *o, pepper_surface_t *surface, int *w, int *h)
{
pepper_renderer_attach_surface(((wayland_output_t *)o)->renderer, surface, w, h);
}
return init_pixman_renderer(output);
}
-PEPPER_API pepper_object_t *
+PEPPER_API pepper_output_t *
pepper_wayland_output_create(pepper_wayland_t *conn, int32_t w, int32_t h, const char *renderer)
{
wayland_output_t *output;
typedef struct pepper_x11_connection pepper_x11_connection_t;
PEPPER_API pepper_x11_connection_t *
-pepper_x11_connect(pepper_object_t *compositor, const char *display_name);
+pepper_x11_connect(pepper_compositor_t *compositor, const char *display_name);
PEPPER_API void
pepper_x11_destroy(pepper_x11_connection_t *conn);
-PEPPER_API pepper_object_t *
+PEPPER_API pepper_output_t *
pepper_x11_output_create(pepper_x11_connection_t *connection, int32_t w, int32_t h,
const char *renderer);
}
PEPPER_API pepper_x11_connection_t *
-pepper_x11_connect(pepper_object_t *compositor, const char *display_name)
+pepper_x11_connect(pepper_compositor_t *compositor, const char *display_name)
{
pepper_x11_connection_t *connection = NULL;
struct wl_display *wdisplay;
#include <X11/Xlib-xcb.h>
#include <string.h>
#include <pixman.h>
+#include <pepper-output-backend.h>
#include <pepper-render.h>
#include <stdio.h>
struct x11_output
{
- pepper_object_t *base;
+ pepper_output_t *base;
pepper_x11_connection_t *connection;
int32_t x, y;
struct wl_list link;
- pepper_object_t *primary_plane;
+ pepper_plane_t *primary_plane;
};
struct x11_seat
{
- pepper_object_t *base;
+ pepper_seat_t *base;
uint32_t id;
uint32_t caps;
struct pepper_x11_connection
{
- pepper_object_t *compositor;
+ pepper_compositor_t *compositor;
char *display_name;
Display *display;
#include "x11-internal.h"
-#include <pepper-output-backend.h>
#include "pepper-gl-renderer.h"
#include "pepper-pixman-renderer.h"
PEPPER_LIST_FOR_EACH(view_list, l)
{
- pepper_object_t *view = l->item;
+ pepper_view_t *view = l->item;
pepper_view_assign_plane(view, output->base, output->primary_plane);
}
}
PEPPER_LIST_FOR_EACH(plane_list, l)
{
- pepper_object_t *plane = l->item;
+ pepper_plane_t *plane = l->item;
if (plane == output->primary_plane)
{
}
static void
-x11_output_attach_surface(void *o, pepper_object_t *surface, int *w, int *h)
+x11_output_attach_surface(void *o, pepper_surface_t *surface, int *w, int *h)
{
pepper_renderer_attach_surface(((x11_output_t *)o)->renderer, surface, w, h);
}
x11_output_destroy(output);
}
-PEPPER_API pepper_object_t *
+PEPPER_API pepper_output_t *
pepper_x11_output_create(pepper_x11_connection_t *connection,
int32_t w,
int32_t h,
static const char *window_name = "PePPer Compositor";
static const char *class_name = "pepper-1\0PePPer Compositor";
- pepper_object_t *base;
+ pepper_output_t *base;
x11_output_t *output;
struct wl_display *wldisplay;
projects / platform / core / uifw / pepper.git / commitdiff