You should follow the style of the file you're editing. In general, we
try to follow the rules below.
-- indent with tabs, and a tab is always 8 characters wide
+- indent with tabs, and a tab is always 4 characters wide
- opening braces are on the same line as the if statement;
- no braces in an if-body with just one statement;
- if one of the branches of an if-else codition has braces, than the
== astyle options ==
#command line
-#astyle -A8 -t8 -p -z2 -H -k3 -W3 -xC80 -xL -n -r "./*.c"
+#astyle -A8 -t4 -p -z2 -H -k3 -W3 -xC80 -xL -n -r "./*.c"
#or
#astyle -A8t8pz2Hk3W3xC80xLnrf "*.c"
struct {
double dx,
- dy; /* difference between pointer position and view position */
+ dy; /* difference between pointer position and view position */
} move;
struct {
shell_client_t *
shell_client_create(desktop_shell_t *shell, struct wl_client *client,
- const struct wl_interface *interface, const void *implementation,
- uint32_t version, uint32_t id);
+ const struct wl_interface *interface, const void *implementation,
+ uint32_t version, uint32_t id);
shell_surface_t *
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);
+ struct wl_client *client,
+ const struct wl_interface *interface,
+ const void *implemenetation, uint32_t version, uint32_t id);
void
shell_surface_ping(shell_surface_t *shsurf);
void
shell_surface_set_next_type(shell_surface_t *shsurf,
- shell_surface_type_t new_type);
+ shell_surface_type_t new_type);
void
shell_surface_set_parent(shell_surface_t *shsurf, pepper_surface_t *parent);
void
shell_surface_set_popup(shell_surface_t *shsurf, pepper_seat_t *seat,
- pepper_surface_t *parent,
- double x, double y, uint32_t flags, uint32_t serial);
+ pepper_surface_t *parent,
+ double x, double y, uint32_t flags, uint32_t serial);
void
shell_surface_set_transient(shell_surface_t *shsurf, pepper_surface_t *parent,
- double x, double y, uint32_t flags);
+ double x, double y, uint32_t flags);
void
shell_surface_ack_configure(shell_surface_t *shsurf, uint32_t serial);
void
shell_surface_set_geometry(shell_surface_t *shsurf, double x, double y,
- int32_t w, int32_t h);
+ int32_t w, int32_t h);
void
shell_surface_set_maximized(shell_surface_t *shsurf, pepper_output_t *output);
void
shell_surface_set_fullscreen(shell_surface_t *shsurf, pepper_output_t *output,
- uint32_t method, uint32_t framerate);
+ uint32_t method, uint32_t framerate);
void
shell_surface_unset_fullscreen(shell_surface_t *shsurf);
void
shell_get_output_workarea(desktop_shell_t *shell, pepper_output_t *output,
- pixman_rectangle32_t *area);
+ pixman_rectangle32_t *area);
pepper_bool_t
void
shell_surface_move(shell_surface_t *shsurf, pepper_seat_t *seat,
- uint32_t serial);
+ uint32_t serial);
void
shell_surface_resize(shell_surface_t *shsurf, pepper_seat_t *seat,
- uint32_t serial, uint32_t edges);
+ uint32_t serial, uint32_t edges);
void
shell_surface_set_position(shell_surface_t *shsurf, double x, double y);
static void
pepper_shell_set_cursor(struct wl_client *client, struct wl_resource *resource,
- struct wl_resource *surface_resource)
+ struct wl_resource *surface_resource)
{
desktop_shell_t *shell = wl_resource_get_user_data(resource);
pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
static void
bind_pepper_shell(struct wl_client *client, void *data, uint32_t version,
- uint32_t id)
+ uint32_t id)
{
desktop_shell_t *shell = data;
struct wl_resource *resource;
wl_list_insert(&shell->pepper_shell_list, wl_resource_get_link(resource));
wl_resource_set_implementation(resource, &pepper_shell_implementation, shell,
- unbind_resource);
+ unbind_resource);
wl_resource_set_user_data(resource, shell);
}
static void
handle_global(void *data, struct wl_registry *registry, uint32_t id,
- const char *interface, uint32_t version)
+ const char *interface, uint32_t version)
{
struct display *display = data;
if (strcmp(interface, "wl_compositor") == 0)
display->compositor = wl_registry_bind(registry, id, &wl_compositor_interface,
- 1);
+ 1);
else if (strcmp(interface, "wl_shm") == 0)
display->shm = wl_registry_bind(registry, id, &wl_shm_interface, 1);
else if (strcmp(interface, "pepper_shell") == 0)
static int
create_shm_buffer(struct display *display, struct buffer *buffer, int w, int h,
- uint32_t format)
+ uint32_t format)
{
struct wl_shm_pool *pool;
int fd, size, stride;
}
if (!create_shm_buffer(display, &cursor->buffers[0],
- CURSOR_WIDTH, CURSOR_HEIGHT, WL_SHM_FORMAT_XRGB8888)) {
+ CURSOR_WIDTH, CURSOR_HEIGHT, WL_SHM_FORMAT_XRGB8888)) {
fprintf(stderr, "create_shm_buffer() failed.\n");
return -1;
}
/* Update the surface with the initial buffer. */
wl_surface_attach(cursor->surface, cursor->buffers[0].buffer, 0, 0);
wl_surface_damage(cursor->surface, 0, 0, cursor->buffers[0].w,
- cursor->buffers[0].h);
+ cursor->buffers[0].h);
cursor->frame_callback = wl_surface_frame(cursor->surface);
wl_callback_add_listener(cursor->frame_callback, &frame_listener, cursor);
wl_surface_commit(cursor->surface);
static void
handle_surface_commit(pepper_event_listener_t *listener,
- pepper_object_t *surface, uint32_t id, void *info, void *data)
+ pepper_object_t *surface, uint32_t id, void *info, void *data)
{
shell_surface_t *shsurf = data;
}
if (shsurf->type_changed && shsurf->ack_configure &&
- shsurf->shell_surface_map) {
+ shsurf->shell_surface_map) {
shsurf->shell_surface_map(shsurf);
shsurf->type_changed = PEPPER_FALSE;
static void
handle_surface_destroy(pepper_event_listener_t *listener,
- pepper_object_t *surface, uint32_t id, void *info, void *data)
+ pepper_object_t *surface, uint32_t id, void *info, void *data)
{
shell_surface_t *shsurf = data;
shell_surface_t *child, *tmp;
static void
shsurf_wl_shell_surface_send_configure(shell_surface_t *shsurf, int32_t width,
- int32_t height)
+ int32_t height)
{
uint32_t edges = 0; /* FIXME */
wl_shell_surface_send_configure(shsurf->resource,
- edges,
- width,
- height);
+ edges,
+ width,
+ height);
/* wl_shell_surface dont need this */
shsurf->ack_configure = PEPPER_TRUE;
static void
shsurf_xdg_surface_send_configure(shell_surface_t *shsurf, int32_t width,
- int32_t height)
+ int32_t height)
{
struct wl_display *display;
struct wl_array states;
serial = wl_display_next_serial(display);
xdg_surface_send_configure(shsurf->resource,
- width,
- height,
- &states,
- serial);
+ width,
+ height,
+ &states,
+ serial);
wl_array_release(&states);
static void
shsurf_xdg_popup_send_configure(shell_surface_t *shsurf, int32_t width,
- int32_t height)
+ int32_t height)
{
/* Do nothing */
}
static void
handle_focus(pepper_event_listener_t *listener,
- pepper_object_t *view, uint32_t id, void *info, void *data)
+ pepper_object_t *view, uint32_t id, void *info, void *data)
{
pepper_object_type_t type = pepper_object_get_type((pepper_object_t *)info);
shell_surface_t *
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)
+ struct wl_client *client, const struct wl_interface *interface,
+ const void *implementation, uint32_t version, uint32_t id)
{
shell_surface_t *shsurf = NULL;
const char *role = NULL;
pepper_list_insert(&shsurf->shell->shell_surface_list, &shsurf->link);
wl_resource_set_implementation(shsurf->resource, implementation, shsurf,
- handle_resource_destroy);
+ handle_resource_destroy);
shsurf->surface_destroy_listener =
pepper_object_add_event_listener((pepper_object_t *)surface,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- handle_surface_destroy, shsurf);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ handle_surface_destroy, shsurf);
shsurf->surface_commit_listener =
pepper_object_add_event_listener((pepper_object_t *)surface,
- PEPPER_EVENT_SURFACE_COMMIT, 0,
- handle_surface_commit, shsurf);
+ PEPPER_EVENT_SURFACE_COMMIT, 0,
+ handle_surface_commit, shsurf);
shsurf->focus_enter_listener =
pepper_object_add_event_listener((pepper_object_t *)shsurf->view,
- PEPPER_EVENT_FOCUS_ENTER, 0,
- handle_focus, shsurf);
+ PEPPER_EVENT_FOCUS_ENTER, 0,
+ handle_focus, shsurf);
shsurf->focus_leave_listener =
pepper_object_add_event_listener((pepper_object_t *)shsurf->view,
- PEPPER_EVENT_FOCUS_LEAVE, 0,
- handle_focus, shsurf);
+ PEPPER_EVENT_FOCUS_LEAVE, 0,
+ handle_focus, shsurf);
shell_surface_set_next_type(shsurf, SHELL_SURFACE_TYPE_NONE);
struct wl_event_loop *loop = wl_display_get_event_loop(display);
shell_client->ping_timer = wl_event_loop_add_timer(loop, handle_ping_timeout,
- shell_client);
+ shell_client);
if (!shell_client->ping_timer) {
PEPPER_ERROR("Failed to add timer event source.\n");
}
wl_event_source_timer_update(shell_client->ping_timer,
- DESKTOP_SHELL_PING_TIMEOUT);
+ DESKTOP_SHELL_PING_TIMEOUT);
shell_client->ping_serial = wl_display_next_serial(display);
shell_client->need_pong = PEPPER_TRUE;
/* Client response right ping_serial */
if (shell_client->need_pong && shell_client->ping_serial == serial) {
wl_event_source_timer_update(shell_client->ping_timer,
- 0); /* disarms the timer */
+ 0); /* disarms the timer */
shell_client->irresponsive = PEPPER_FALSE;
shell_client->need_pong = PEPPER_FALSE;
switch_output_mode(pepper_output_t *output, pepper_output_mode_t *mode)
{
pepper_output_mode_t best_mode = {.w = (uint32_t) - 1, .h = (uint32_t) - 1,},
- tmp_mode;
+ tmp_mode;
int i, mode_count;
/* TODO: Find the output mode to the smallest mode that can fit */
return ;
if (shsurf->type == SHELL_SURFACE_TYPE_FULLSCREEN &&
- shsurf->fullscreen.method == WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER) {
+ shsurf->fullscreen.method == WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER) {
switch_output_mode(shsurf->fullscreen.output, &shsurf->saved.mode);
}
shell_surface_set_next_type(shsurf, SHELL_SURFACE_TYPE_TOPLEVEL);
if (shsurf->type == SHELL_SURFACE_TYPE_FULLSCREEN ||
- shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
- shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
+ shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
+ shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
shsurf->send_configure(shsurf, shsurf->saved.w, shsurf->saved.h);
}
}
void
shell_surface_set_popup(shell_surface_t *shsurf,
- pepper_seat_t *seat,
- pepper_surface_t *parent,
- double x,
- double y,
- uint32_t flags,
- uint32_t serial)
+ pepper_seat_t *seat,
+ pepper_surface_t *parent,
+ double x,
+ double y,
+ uint32_t flags,
+ uint32_t serial)
{
if (shsurf->type == SHELL_SURFACE_TYPE_POPUP)
return ;
void
shell_surface_set_transient(shell_surface_t *shsurf,
- pepper_surface_t *parent,
- double x,
- double y,
- uint32_t flags)
+ pepper_surface_t *parent,
+ double x,
+ double y,
+ uint32_t flags)
{
if (shsurf->type == SHELL_SURFACE_TYPE_TRANSIENT)
return ;
static void
shell_surface_get_geometry(shell_surface_t *shsurf,
- pixman_rectangle32_t *geometry)
+ pixman_rectangle32_t *geometry)
{
double x, y;
int w, h;
shell_surface_save_current_geometry(shell_surface_t *shsurf)
{
if (shsurf->type != SHELL_SURFACE_TYPE_MAXIMIZED &&
- shsurf->type != SHELL_SURFACE_TYPE_FULLSCREEN) {
+ shsurf->type != SHELL_SURFACE_TYPE_FULLSCREEN) {
pepper_view_get_position(shsurf->view, &shsurf->saved.x, &shsurf->saved.y);
shsurf->saved.w = shsurf->geometry.w;
shsurf->saved.h = shsurf->geometry.h;
void
shell_surface_set_maximized(shell_surface_t *shsurf,
- pepper_output_t *output)
+ pepper_output_t *output)
{
pixman_rectangle32_t area;
void
shell_surface_set_fullscreen(shell_surface_t *shsurf,
- pepper_output_t *output,
- uint32_t method,
- uint32_t framerate)
+ pepper_output_t *output,
+ uint32_t method,
+ uint32_t framerate)
{
const pepper_output_geometry_t *geom;
set_shsurf_to_surface(pepper_surface_t *surface, shell_surface_t *shsurf)
{
pepper_object_set_user_data((pepper_object_t *)surface, shsurf->shell, shsurf,
- NULL);
+ NULL);
}
void
void
shell_surface_set_geometry(shell_surface_t *shsurf, double x, double y,
- int32_t w, int32_t h)
+ int32_t w, int32_t h)
{
shsurf->next_geometry.x = x;
shsurf->next_geometry.y = y;
pepper_keyboard_t *keyboard;
if (shsurf->type == SHELL_SURFACE_TYPE_FULLSCREEN ||
- shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
- shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
+ shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
+ shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
pepper_view_set_position(shsurf->view, shsurf->saved.x, shsurf->saved.y);
} else {
shell_surface_set_initial_position(shsurf);
static void
pointer_popup_grab_motion(pepper_pointer_t *pointer, void *data,
- uint32_t time, double x, double y)
+ uint32_t time, double x, double y)
{
double vx, vy;
pepper_compositor_t *compositor = pepper_pointer_get_compositor(pointer);
pepper_view_t *view = pepper_compositor_pick_view(compositor, x, y, &vx,
- &vy);
+ &vy);
pepper_view_t *focus = pepper_pointer_get_focus(pointer);
if (focus != view) {
static void
pointer_popup_grab_button(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t button, uint32_t state)
+ uint32_t time, uint32_t button, uint32_t state)
{
shell_surface_t *shsurf = data;
struct wl_client *client = NULL;
static void
pointer_popup_grab_axis(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t axis, double value)
+ uint32_t time, uint32_t axis, double value)
{
/* TODO */
}
if (shsurf_is_xdg_popup(shsurf))
xdg_popup_send_popup_done(shsurf->resource);
else if (shsurf_is_wl_shell_surface(shsurf) &&
- shsurf->type == SHELL_SURFACE_TYPE_POPUP )
+ shsurf->type == SHELL_SURFACE_TYPE_POPUP )
wl_shell_surface_send_popup_done(shsurf->resource);
}
}
const pepper_pointer_grab_t *grab = pepper_pointer_get_grab(pointer);
if (grab == &pointer_popup_grab )
pepper_pointer_set_grab(pointer,
- shsurf->old_pointer_grab,
- shsurf->old_pointer_grab_data);
+ shsurf->old_pointer_grab,
+ shsurf->old_pointer_grab_data);
}
shell_surface_send_popup_done(shsurf);
shell_surface_map_popup(shell_surface_t *shsurf)
{
shell_surface_t *parent = get_shsurf_from_surface(shsurf->parent,
- shsurf->shell);
+ shsurf->shell);
/* Set position as relatively */
pepper_view_set_parent(shsurf->view, parent->view);
shell_surface_map_transient(shell_surface_t *shsurf)
{
shell_surface_t *parent = get_shsurf_from_surface(shsurf->parent,
- shsurf->shell);
+ shsurf->shell);
double x, y;
pepper_view_get_position(parent->view, &x, &y);
pepper_view_set_parent(shsurf->view, parent->view);
shell_surface_set_position(shsurf,
- x + shsurf->transient.x,
- y + shsurf->transient.y);
+ x + shsurf->transient.x,
+ y + shsurf->transient.y);
if (shsurf->transient.flags != WL_SHELL_SURFACE_TRANSIENT_INACTIVE) {
/* TODO: set keyboard focus to view */
static void
shell_surface_center_on_output_by_scale(shell_surface_t *shsurf,
- const pepper_output_geometry_t *output,
- pixman_rectangle32_t *surface_geom,
- float scale)
+ const pepper_output_geometry_t *output,
+ pixman_rectangle32_t *surface_geom,
+ float scale)
{
double x, y;
switch (shsurf->fullscreen.method) {
case WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE: {
scale = get_scale(output_geom->w, output_geom->h, shsurf_geom.width,
- shsurf_geom.height);
+ shsurf_geom.height);
}
break;
case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER: {
/* Place target view */
shell_surface_center_on_output_by_scale(shsurf, output_geom, &shsurf_geom,
- scale);
+ scale);
}
void
shell_surface_set_next_type(shell_surface_t *shsurf,
- shell_surface_type_t new_type)
+ shell_surface_type_t new_type)
{
if (shsurf->next_type == new_type)
return ;
static void
pointer_move_grab_motion(pepper_pointer_t *pointer, void *data, uint32_t time,
- double x, double y)
+ double x, double y)
{
shell_surface_t *shsurf = data;
pepper_view_set_position(shsurf->view, shsurf->move.dx + x,
- shsurf->move.dy + y);
+ shsurf->move.dy + y);
}
static void
pointer_move_grab_button(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t button, uint32_t state)
+ uint32_t time, uint32_t button, uint32_t state)
{
if (button == BTN_LEFT && state == PEPPER_BUTTON_STATE_RELEASED) {
shell_surface_t *shsurf = data;
pepper_pointer_set_grab(pointer, shsurf->old_pointer_grab,
- shsurf->old_pointer_grab_data);
+ shsurf->old_pointer_grab_data);
}
}
static void
pointer_move_grab_axis(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t axis, double value)
+ uint32_t time, uint32_t axis, double value)
{
/* TODO */
}
void
shell_surface_move(shell_surface_t *shsurf, pepper_seat_t *seat,
- uint32_t serial)
+ uint32_t serial)
{
pepper_pointer_t *pointer = pepper_seat_get_pointer(seat);
double vx, vy;
double px, py;
if (shsurf->type == SHELL_SURFACE_TYPE_FULLSCREEN ||
- shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
- shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
+ shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
+ shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
return ;
}
static void
pointer_resize_grab_motion(pepper_pointer_t *pointer, void *data, uint32_t time,
- double x, double y)
+ double x, double y)
{
shell_surface_t *shsurf = data;
double dx = 0.f, dy = 0.f;
static void
pointer_resize_grab_button(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t button, uint32_t state)
+ uint32_t time, uint32_t button, uint32_t state)
{
if (button == BTN_LEFT && state == PEPPER_BUTTON_STATE_RELEASED) {
shell_surface_t *shsurf = data;
pepper_pointer_set_grab(pointer, shsurf->old_pointer_grab,
- shsurf->old_pointer_grab_data);
+ shsurf->old_pointer_grab_data);
shsurf->resize.resizing = PEPPER_FALSE;
shsurf->resize.edges = 0;
}
static void
pointer_resize_grab_axis(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t axis, double value)
+ uint32_t time, uint32_t axis, double value)
{
/* TODO */
}
void
shell_surface_resize(shell_surface_t *shsurf, pepper_seat_t *seat,
- uint32_t serial, uint32_t edges)
+ uint32_t serial, uint32_t edges)
{
pepper_pointer_t *pointer = pepper_seat_get_pointer(seat);
if (shsurf->type == SHELL_SURFACE_TYPE_FULLSCREEN ||
- shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
- shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
+ shsurf->type == SHELL_SURFACE_TYPE_MAXIMIZED ||
+ shsurf->type == SHELL_SURFACE_TYPE_MINIMIZED) {
return ;
}
void
shell_get_output_workarea(desktop_shell_t *shell,
- pepper_output_t *output,
- pixman_rectangle32_t *area)
+ pepper_output_t *output,
+ pixman_rectangle32_t *area)
{
const pepper_output_geometry_t *geom;
handle_shell_client_destroy(struct wl_listener *listener, void *data)
{
shell_client_t *shell_client = pepper_container_of(listener, shell_client,
- client_destroy_listener);
+ client_destroy_listener);
remove_ping_timer(shell_client);
pepper_list_remove(&shell_client->link);
shell_client_t *
shell_client_create(desktop_shell_t *shell, struct wl_client *client,
- const struct wl_interface *interface, const void *implementation,
- uint32_t version, uint32_t id)
+ const struct wl_interface *interface, const void *implementation,
+ uint32_t version, uint32_t id)
{
shell_client_t *shell_client;
pepper_list_insert(&shell->shell_client_list, &shell_client->link);
wl_resource_set_implementation(shell_client->resource, implementation,
- shell_client, NULL);
+ shell_client, NULL);
return shell_client;
}
static void
default_pointer_grab_motion(pepper_pointer_t *pointer, void *data,
- uint32_t time, double x, double y)
+ uint32_t time, double x, double y)
{
double vx, vy;
pepper_compositor_t *compositor = pepper_pointer_get_compositor(pointer);
pepper_view_t *view = pepper_compositor_pick_view(compositor, x, y, &vx,
- &vy);
+ &vy);
pepper_view_t *focus = pepper_pointer_get_focus(pointer);
if (focus != view) {
static void
default_pointer_grab_button(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t button, uint32_t state)
+ uint32_t time, uint32_t button, uint32_t state)
{
pepper_seat_t *seat = pepper_pointer_get_seat(pointer);
pepper_keyboard_t *keyboard = pepper_seat_get_keyboard(seat);
static void
default_pointer_grab_axis(pepper_pointer_t *pointer, void *data,
- uint32_t time, uint32_t axis, double value)
+ uint32_t time, uint32_t axis, double value)
{
pepper_pointer_send_axis(pointer, pepper_pointer_get_focus(pointer), time, axis,
- value);
+ value);
}
static void
static void
pointer_add_callback(pepper_event_listener_t *listener, pepper_object_t *object,
- uint32_t id,
- void *info, void *data)
+ uint32_t id,
+ void *info, void *data)
{
pepper_pointer_t *pointer = info;
pepper_pointer_set_grab(pointer, &default_pointer_grab, data);
static void
pointer_remove_callback(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id,
- void *info, void *data)
+ pepper_object_t *object, uint32_t id,
+ void *info, void *data)
{
/* Nothing to do. */
}
static void
default_keyboard_grab_key(pepper_keyboard_t *keyboard, void *data,
- uint32_t time, uint32_t key, uint32_t state)
+ uint32_t time, uint32_t key, uint32_t state)
{
pepper_keyboard_send_key(keyboard, pepper_keyboard_get_focus(keyboard), time,
- key, state);
+ key, state);
}
static void
default_keyboard_grab_modifiers(pepper_keyboard_t *keyboard, void *data,
- uint32_t mods_depressed,
- uint32_t mods_latched, uint32_t mods_locked, uint32_t group)
+ uint32_t mods_depressed,
+ uint32_t mods_latched, uint32_t mods_locked, uint32_t group)
{
pepper_keyboard_send_modifiers(keyboard, pepper_keyboard_get_focus(keyboard),
- mods_depressed, mods_latched, mods_locked, group);
+ mods_depressed, mods_latched, mods_locked, group);
}
static void
static void
keyboard_add_callback(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id,
- void *info, void *data)
+ pepper_object_t *object, uint32_t id,
+ void *info, void *data)
{
pepper_keyboard_t *keyboard = info;
pepper_keyboard_set_grab(keyboard, &default_keyboard_grab, NULL);
static void
keyboard_remove_callback(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id,
- void *info, void *data)
+ pepper_object_t *object, uint32_t id,
+ void *info, void *data)
{
/* Nothing to do. */
}
static void
touch_add_callback(pepper_event_listener_t *listener, pepper_object_t *object,
- uint32_t id,
- void *info, void *data)
+ uint32_t id,
+ void *info, void *data)
{
/* TODO: */
}
static void
touch_remove_callback(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id,
- void *info, void *data)
+ pepper_object_t *object, uint32_t id,
+ void *info, void *data)
{
/* TODO: */
}
shseat->pointer_add_listener =
pepper_object_add_event_listener((pepper_object_t *)seat,
- PEPPER_EVENT_SEAT_POINTER_ADD,
- 0, pointer_add_callback, shseat);
+ PEPPER_EVENT_SEAT_POINTER_ADD,
+ 0, pointer_add_callback, shseat);
shseat->pointer_remove_listener =
pepper_object_add_event_listener((pepper_object_t *)seat,
- PEPPER_EVENT_SEAT_POINTER_REMOVE,
- 0, pointer_remove_callback, shseat);
+ PEPPER_EVENT_SEAT_POINTER_REMOVE,
+ 0, pointer_remove_callback, shseat);
shseat->keyboard_add_listener =
pepper_object_add_event_listener((pepper_object_t *)seat,
- PEPPER_EVENT_SEAT_KEYBOARD_ADD,
- 0, keyboard_add_callback, shseat);
+ PEPPER_EVENT_SEAT_KEYBOARD_ADD,
+ 0, keyboard_add_callback, shseat);
shseat->keyboard_remove_listener =
pepper_object_add_event_listener((pepper_object_t *)seat,
- PEPPER_EVENT_SEAT_KEYBOARD_REMOVE,
- 0, keyboard_remove_callback, shseat);
+ PEPPER_EVENT_SEAT_KEYBOARD_REMOVE,
+ 0, keyboard_remove_callback, shseat);
shseat->touch_add_listener =
pepper_object_add_event_listener((pepper_object_t *)seat,
- PEPPER_EVENT_SEAT_TOUCH_ADD,
- 0, touch_add_callback, shseat);
+ PEPPER_EVENT_SEAT_TOUCH_ADD,
+ 0, touch_add_callback, shseat);
shseat->touch_remove_listener =
pepper_object_add_event_listener((pepper_object_t *)seat,
- PEPPER_EVENT_SEAT_TOUCH_REMOVE,
- 0, touch_remove_callback, shseat);
+ PEPPER_EVENT_SEAT_TOUCH_REMOVE,
+ 0, touch_remove_callback, shseat);
}
static void
static void
input_device_add_callback(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
shell_add_input_device(data, info);
}
static void
seat_add_callback(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
shell_add_seat(data, info);
}
static void
seat_remove_callback(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
shell_remove_seat(data, info);
}
/* input_device_add */
shell->input_device_add_listener =
pepper_object_add_event_listener(compositor,
- PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_ADD,
- 0, input_device_add_callback, shell);
+ PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_ADD,
+ 0, input_device_add_callback, shell);
shell->seat_add_listener =
pepper_object_add_event_listener(compositor, PEPPER_EVENT_COMPOSITOR_SEAT_ADD,
- 0, seat_add_callback, shell);
+ 0, seat_add_callback, shell);
shell->seat_remove_listener =
pepper_object_add_event_listener(compositor,
- PEPPER_EVENT_COMPOSITOR_SEAT_REMOVE,
- 0, seat_remove_callback, shell);
+ PEPPER_EVENT_COMPOSITOR_SEAT_REMOVE,
+ 0, seat_remove_callback, shell);
}
static void
static void
wl_shell_surface_pong(struct wl_client *client, struct wl_resource *resource,
- uint32_t serial)
+ uint32_t serial)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
wl_shell_surface_move(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *seat_resource,
- uint32_t serial)
+ struct wl_resource *resource,
+ struct wl_resource *seat_resource,
+ uint32_t serial)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_seat_t *seat = wl_resource_get_user_data(seat_resource);
static void
wl_shell_surface_resize(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *seat_resource,
- uint32_t serial,
- uint32_t edges)
+ struct wl_resource *resource,
+ struct wl_resource *seat_resource,
+ uint32_t serial,
+ uint32_t edges)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_seat_t *seat = wl_resource_get_user_data(seat_resource);
static void
wl_shell_surface_set_toplevel(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
wl_shell_surface_set_transient(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *parent_resource,
- int32_t x,
- int32_t y,
- uint32_t flags)
+ struct wl_resource *resource,
+ struct wl_resource *parent_resource,
+ int32_t x,
+ int32_t y,
+ uint32_t flags)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_surface_t *parent = wl_resource_get_user_data(parent_resource);
static void
wl_shell_surface_set_fullscreen(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t method,
- uint32_t framerate,
- struct wl_resource *output_resource)
+ struct wl_resource *resource,
+ uint32_t method,
+ uint32_t framerate,
+ struct wl_resource *output_resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_output_t *output = NULL;
static void
wl_shell_surface_set_popup(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *seat_res,
- uint32_t serial,
- struct wl_resource *parent_res,
- int32_t x,
- int32_t y,
- uint32_t flags)
+ struct wl_resource *resource,
+ struct wl_resource *seat_res,
+ uint32_t serial,
+ struct wl_resource *parent_res,
+ int32_t x,
+ int32_t y,
+ uint32_t flags)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_seat_t *seat;
if (!seat_res) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid seat");
+ "Invalid seat");
return ;
}
seat = wl_resource_get_user_data(seat_res);
if (!parent_res) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid parent surface");
+ "Invalid parent surface");
return ;
}
parent = wl_resource_get_user_data(parent_res);
static void
wl_shell_surface_set_maximized(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *output_res)
+ struct wl_resource *resource,
+ struct wl_resource *output_res)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_output_t *output = NULL;
static void
wl_shell_surface_set_title(struct wl_client *client,
- struct wl_resource *resource,
- const char *title)
+ struct wl_resource *resource,
+ const char *title)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
wl_shell_surface_set_class(struct wl_client *client,
- struct wl_resource *resource,
- const char *class_)
+ struct wl_resource *resource,
+ const char *class_)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
wl_shell_get_shell_surface(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id, struct wl_resource *surface_resource)
+ struct wl_resource *resource,
+ uint32_t id, struct wl_resource *surface_resource)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
/* Only one shell surface can be associated with a given surface.*/
if (!pepper_surface_set_role(surface, "wl_shell_surface")) {
wl_resource_post_error(resource, WL_SHELL_ERROR_ROLE,
- "Assign \"wl_shell_surface\" to wl_surface failed\n");
+ "Assign \"wl_shell_surface\" to wl_surface failed\n");
return ;
}
shsurf = shell_surface_create(shell_client, surface, client,
- &wl_shell_surface_interface,
- &shell_surface_implementation, 1, id);
+ &wl_shell_surface_interface,
+ &shell_surface_implementation, 1, id);
if (!shsurf)
wl_client_post_no_memory(client);
}
bind_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id)
{
shell_client_create((desktop_shell_t *)data, client,
- &wl_shell_interface, &shell_implementation, version, id);
+ &wl_shell_interface, &shell_implementation, version, id);
}
pepper_bool_t
static void
xdg_surface_destroy(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
wl_resource_destroy(resource);
}
static void
xdg_surface_set_parent(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *parent_resource)
+ struct wl_resource *resource,
+ struct wl_resource *parent_resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
shell_surface_t *parent = NULL;
static void
xdg_surface_set_app_id(struct wl_client *client,
- struct wl_resource *resource,
- const char *app_id)
+ struct wl_resource *resource,
+ const char *app_id)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_show_window_menu(struct wl_client *client,
- struct wl_resource *surface_resource,
- struct wl_resource *seat_resource,
- uint32_t serial,
- int32_t x,
- int32_t y)
+ struct wl_resource *surface_resource,
+ struct wl_resource *seat_resource,
+ uint32_t serial,
+ int32_t x,
+ int32_t y)
{
/* TODO: */
}
static void
xdg_surface_set_title(struct wl_client *client,
- struct wl_resource *resource,
- const char *title)
+ struct wl_resource *resource,
+ const char *title)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_move(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *seat_resource,
- uint32_t serial)
+ struct wl_resource *resource,
+ struct wl_resource *seat_resource,
+ uint32_t serial)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_seat_t *seat;
if (!seat_resource) {
wl_resource_post_error(resource,
- WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid seat");
+ WL_DISPLAY_ERROR_INVALID_OBJECT,
+ "Invalid seat");
return ;
}
seat = wl_resource_get_user_data(seat_resource);
static void
xdg_surface_resize(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *seat_resource,
- uint32_t serial,
- uint32_t edges)
+ struct wl_resource *resource,
+ struct wl_resource *seat_resource,
+ uint32_t serial,
+ uint32_t edges)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_seat_t *seat;
if (!seat_resource) {
wl_resource_post_error(resource,
- WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid seat");
+ WL_DISPLAY_ERROR_INVALID_OBJECT,
+ "Invalid seat");
return ;
}
seat = wl_resource_get_user_data(seat_resource);
static void
xdg_surface_ack_configure(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t serial)
+ struct wl_resource *resource,
+ uint32_t serial)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_set_window_geometry(struct wl_client *client,
- struct wl_resource *resource,
- int32_t x,
- int32_t y,
- int32_t width,
- int32_t height)
+ struct wl_resource *resource,
+ int32_t x,
+ int32_t y,
+ int32_t width,
+ int32_t height)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_set_maximized(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_unset_maximized(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_set_fullscreen(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *output_resource)
+ struct wl_resource *resource,
+ struct wl_resource *output_resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
pepper_output_t *output = NULL;
static void
xdg_surface_unset_fullscreen(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_surface_set_minimized(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
shell_surface_t *shsurf = wl_resource_get_user_data(resource);
static void
xdg_shell_destroy(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
/* TODO: */
}
static void
xdg_shell_use_unstable_version(struct wl_client *client,
- struct wl_resource *resource,
- int32_t version)
+ struct wl_resource *resource,
+ int32_t version)
{
/* TODO: */
if (version != XDG_SHELL_VERSION_CURRENT) {
static void
xdg_shell_get_xdg_surface(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id,
- struct wl_resource *surface_resource)
+ struct wl_resource *resource,
+ uint32_t id,
+ struct wl_resource *surface_resource)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
if (!pepper_surface_set_role(surface, "xdg_surface")) {
wl_resource_post_error(resource, XDG_SHELL_ERROR_ROLE,
- "Assign \"xdg_surface\" to wl_surface failed\n");
+ "Assign \"xdg_surface\" to wl_surface failed\n");
return ;
}
shsurf = shell_surface_create(shell_client, surface, client,
- &xdg_surface_interface,
- &xdg_surface_implementation, 1, id);
+ &xdg_surface_interface,
+ &xdg_surface_implementation, 1, id);
if (!shsurf) {
wl_client_post_no_memory(client);
return ;
static void
xdg_popup_destroy(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
wl_resource_destroy(resource);
}
static void
xdg_shell_get_xdg_popup(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id,
- struct wl_resource *surface_resource,
- struct wl_resource *parent_resource,
- struct wl_resource *seat_resource,
- uint32_t serial,
- int32_t x,
- int32_t y)
+ struct wl_resource *resource,
+ uint32_t id,
+ struct wl_resource *surface_resource,
+ struct wl_resource *parent_resource,
+ struct wl_resource *seat_resource,
+ uint32_t serial,
+ int32_t x,
+ int32_t y)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
pepper_surface_t *surface;
/* Check parameters */
if (!surface_resource) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid surface");
+ "Invalid surface");
return ;
}
surface = wl_resource_get_user_data(surface_resource);
if (!seat_resource) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid seat");
+ "Invalid seat");
return ;
}
seat = wl_resource_get_user_data(seat_resource);
if (!parent_resource) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid parent surface");
+ "Invalid parent surface");
return ;
}
parent = wl_resource_get_user_data(parent_resource);
if (strcmp(role, "xdg_surface") && strcmp(role, "xdg_popup")) {
wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
- "Invalid xdg_popup parent");
+ "Invalid xdg_popup parent");
return ;
}
}
/* Set role */
if (!pepper_surface_set_role(surface, "xdg_popup")) {
wl_resource_post_error(resource, XDG_SHELL_ERROR_ROLE,
- "Assign \"xdg_popup\" to wl_surface failed\n");
+ "Assign \"xdg_popup\" to wl_surface failed\n");
return ;
}
/* TODO: */
shsurf = shell_surface_create(shell_client, surface, client,
- &xdg_popup_interface,
- &xdg_popup_implementation, 1, id);
+ &xdg_popup_interface,
+ &xdg_popup_implementation, 1, id);
if (!shsurf) {
wl_client_post_no_memory(client);
return ;
static void
xdg_shell_pong(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t serial)
+ struct wl_resource *resource,
+ uint32_t serial)
{
shell_client_t *shell_client = wl_resource_get_user_data(resource);
static void
bind_xdg_shell(struct wl_client *client, void *data, uint32_t version,
- uint32_t id)
+ uint32_t id)
{
shell_client_create((desktop_shell_t *)data, client,
- &xdg_shell_interface, &xdg_shell_implementation, version, id);
+ &xdg_shell_interface, &xdg_shell_implementation, version, id);
}
pepper_bool_t
struct wl_global *global;
global = wl_global_create(display, &xdg_shell_interface, 1, shell,
- bind_xdg_shell);
+ bind_xdg_shell);
if (!global)
return PEPPER_FALSE;
buffer->size = create_arg.size;
ret = drmModeAddFB(drm->fd, w, h, 24, 32, buffer->stride, buffer->handle,
- &buffer->id);
+ &buffer->id);
PEPPER_CHECK(ret == 0, goto error, "drmModeAddFB() failed.\n");
memset(&map_arg, 0, sizeof(map_arg));
PEPPER_CHECK(ret == 0, goto error, "drmIoctl() failed.\n");
buffer->map = mmap(0, buffer->size, PROT_WRITE, MAP_SHARED, drm->fd,
- map_arg.offset);
+ map_arg.offset);
PEPPER_CHECK(buffer->map != MAP_FAILED, goto error, "mmap() failed.\n");
buffer->image = pixman_image_create_bits(PIXMAN_x8r8g8b8, w, h, buffer->map,
- buffer->stride);
+ buffer->stride);
PEPPER_CHECK(buffer->image, goto error, "pixman_image_create_bits() failed.\n");
return buffer;
static inline pepper_bool_t
init_buffer_gbm(drm_buffer_t *buffer, pepper_drm_t *drm, struct gbm_bo *bo,
- uint32_t format)
+ uint32_t format)
{
int ret;
uint32_t handles[4], strides[4], offsets[4];
offsets[0] = 0;
ret = drmModeAddFB2(drm->fd, buffer->w, buffer->h,
- format ? format : gbm_bo_get_format(bo),
- handles, strides, offsets, &buffer->id , 0);
+ format ? format : gbm_bo_get_format(bo),
+ handles, strides, offsets, &buffer->id , 0);
if (ret != 0) {
ret = drmModeAddFB(drm->fd, buffer->w, buffer->h, 24, 32,
- buffer->stride, buffer->handle, &buffer->id);
+ buffer->stride, buffer->handle, &buffer->id);
PEPPER_CHECK(ret, return PEPPER_FALSE, "drmModeAddFB() failed.\n");
}
drm_buffer_t *
drm_buffer_create_gbm(pepper_drm_t *drm, struct gbm_surface *surface,
- struct gbm_bo *bo)
+ struct gbm_bo *bo)
{
drm_buffer_t *buffer;
static void
handle_client_buffer_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id, void *info, void *data)
+ pepper_object_t *object,
+ uint32_t id, void *info, void *data)
{
drm_buffer_t *buffer = data;
buffer->client_buffer = NULL;
drm_buffer_t *
drm_buffer_create_client(pepper_drm_t *drm,
- struct gbm_bo *bo, pepper_buffer_t *client_buffer, uint32_t format)
+ struct gbm_bo *bo, pepper_buffer_t *client_buffer, uint32_t format)
{
drm_buffer_t *buffer;
pepper_buffer_reference(client_buffer);
buffer->client_buffer_destroy_listener =
pepper_object_add_event_listener((pepper_object_t *)client_buffer,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- handle_client_buffer_destroy, buffer);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ handle_client_buffer_destroy, buffer);
return buffer;
}
drmFreeVersion(drm_info);
PEPPER_CHECK(!drmCtlInstHandler(fd, drmIRQ), return,
- "drmCtlInstHandler() failed.\n");
+ "drmCtlInstHandler() failed.\n");
sprd_dev = sprd_device_create(fd);
PEPPER_CHECK(sprd_dev, return, "sprd_device_create() failed.\n");
PEPPER_API pepper_drm_t *
pepper_drm_create(pepper_compositor_t *compositor, struct udev *udev,
- const char *device)
+ const char *device)
{
pepper_drm_t *drm = NULL;
struct udev_device *udev_device = NULL;
/* Open DRM device file and check validity. */
drm->fd = open(filepath, O_RDWR | O_CLOEXEC);
PEPPER_CHECK(drm->fd != -1, goto error,
- "open(%s, O_RDWR | O_CLOEXEC) failed.\n", filepath);
+ "open(%s, O_RDWR | O_CLOEXEC) failed.\n", filepath);
#ifdef HAVE_DRM_SPRD
/*If drm is sprd, this fuction MUST call before other drm function*/
/* Create udev event monitor. */
drm->udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
PEPPER_CHECK(drm->udev_monitor, goto error,
- "udev_monitor_new_from_netlink() failed.\n");
+ "udev_monitor_new_from_netlink() failed.\n");
udev_monitor_filter_add_match_subsystem_devtype(drm->udev_monitor, "drm", NULL);
#ifdef HAVE_TBM
/* Create wayland-tbm*/
drm->wl_tbm_server = wayland_tbm_server_init(pepper_compositor_get_display(
- compositor),
- filepath, drm->fd, 0);
+ compositor),
+ filepath, drm->fd, 0);
#endif
/* Add DRM event FDs to the compositor's display. */
loop = wl_display_get_event_loop(pepper_compositor_get_display(compositor));
drm->drm_event_source = wl_event_loop_add_fd(loop, drm->fd, WL_EVENT_READABLE,
- handle_drm_event, drm);
+ handle_drm_event, drm);
PEPPER_CHECK(drm->drm_event_source, goto error,
- "wl_event_loop_add() failed.\n");
+ "wl_event_loop_add() failed.\n");
drm->udev_event_source = wl_event_loop_add_fd(loop,
- udev_monitor_get_fd(drm->udev_monitor),
- WL_EVENT_READABLE, handle_udev_event, drm);
+ udev_monitor_get_fd(drm->udev_monitor),
+ WL_EVENT_READABLE, handle_udev_event, drm);
PEPPER_CHECK(drm->udev_event_source, goto error,
- "wl_event_loop_add() failed.\n");
+ "wl_event_loop_add() failed.\n");
drm->drm_event_context.version = DRM_EVENT_CONTEXT_VERSION;
drm->drm_event_context.vblank_handler = drm_handle_vblank;
conn->connected = PEPPER_FALSE;
}
} else if (!conn->connected &&
- conn->connector->connection == DRM_MODE_CONNECTED) {
+ conn->connector->connection == DRM_MODE_CONNECTED) {
/* Newly connected. */
PEPPER_ASSERT(conn->output == NULL);
drm_output_create(conn);
drm_buffer_t *
drm_buffer_create_gbm(pepper_drm_t *drm, struct gbm_surface *surface,
- struct gbm_bo *bo);
+ struct gbm_bo *bo);
drm_buffer_t *
drm_buffer_create_client(pepper_drm_t *drm,
- struct gbm_bo *bo, pepper_buffer_t *buffer, uint32_t format);
+ struct gbm_bo *bo, pepper_buffer_t *buffer, uint32_t format);
void
drm_buffer_release(drm_buffer_t *buffer);
void
drm_handle_vblank(int fd, unsigned int frame, unsigned int sec,
- unsigned int usec, void *data);
+ unsigned int usec, void *data);
void
drm_handle_page_flip(int fd, unsigned int frame, unsigned int sec,
- unsigned int usec, void *data);
+ unsigned int usec, void *data);
struct drm_plane {
pepper_drm_t *drm;
get_refresh_rate(const drmModeModeInfo *info)
{
return (info->clock * 1000000LL / info->vtotal + info->vtotal / 2) /
- info->vtotal;
+ info->vtotal;
}
static pepper_bool_t
same_mode(const drmModeModeInfo *info, const pepper_output_mode_t *mode)
{
return info->hdisplay == mode->w && info->vdisplay == mode->h &&
- get_refresh_rate(info) == (uint32_t)mode->refresh;
+ get_refresh_rate(info) == (uint32_t)mode->refresh;
}
static void
return NULL;
if (pepper_output_get_scale(output->base) != pepper_surface_get_buffer_scale(
- surface))
+ surface))
return NULL;
buffer = pepper_surface_get_buffer(surface);
return NULL;
bo = gbm_bo_import(output->drm->gbm_device,
- GBM_BO_IMPORT_WL_BUFFER, resource, GBM_BO_USE_SCANOUT);
+ GBM_BO_IMPORT_WL_BUFFER, resource, GBM_BO_USE_SCANOUT);
if (!bo)
return NULL;
/* TODO: Hard-coded XRGB8888 */
output->back = drm_buffer_create_client(output->drm, bo, buffer,
- GBM_FORMAT_XRGB8888);
+ GBM_FORMAT_XRGB8888);
if (!output->back) {
gbm_bo_destroy(bo);
return NULL;
return NULL;
bo = gbm_bo_import(output->drm->gbm_device,
- GBM_BO_IMPORT_WL_BUFFER, resource, GBM_BO_USE_SCANOUT);
+ GBM_BO_IMPORT_WL_BUFFER, resource, GBM_BO_USE_SCANOUT);
if (!bo)
return NULL;
drm_output_render_gl(drm_output_t *output)
{
const pepper_list_t *render_list = pepper_plane_get_render_list(
- output->primary_plane);
+ output->primary_plane);
pixman_region32_t *damage = pepper_plane_get_damage_region(
- output->primary_plane);
+ output->primary_plane);
struct gbm_bo *bo;
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- damage);
+ damage);
bo = gbm_surface_lock_front_buffer(output->gbm_surface);
PEPPER_CHECK(bo, return, "gbm_surface_lock_front_buffer() failed.\n");
drm_output_render_pixman(drm_output_t *output)
{
const pepper_list_t *render_list = pepper_plane_get_render_list(
- output->primary_plane);
+ output->primary_plane);
pixman_region32_t *damage = pepper_plane_get_damage_region(
- output->primary_plane);
+ output->primary_plane);
pixman_region32_t total_damage;
output->back_fb_index ^= 1;
if (output->use_shadow) {
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- damage);
+ damage);
/* Copy shadow image to the back frame buffer. */
pixman_image_set_clip_region32(output->back->image, &total_damage);
pixman_image_composite32(PIXMAN_OP_SRC,
- output->shadow_image, NULL, output->back->image,
- 0, 0, 0, 0, 0, 0,
- output->back->w, output->back->h);
+ output->shadow_image, NULL, output->back->image,
+ 0, 0, 0, 0, 0, 0,
+ output->back->w, output->back->h);
} else {
output->render_target = output->fb_target[output->back_fb_index];
pepper_renderer_set_target(output->renderer,
- output->fb_target[output->back_fb_index]);
+ output->fb_target[output->back_fb_index]);
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- &total_damage);
+ &total_damage);
}
pixman_region32_fini(&total_damage);
struct timespec ts;
if (output->front && drmModePageFlip(output->drm->fd, output->crtc_id,
- output->front->id, DRM_MODE_PAGE_FLIP_EVENT, output) >= 0) {
+ output->front->id, DRM_MODE_PAGE_FLIP_EVENT, output) >= 0) {
return;
}
gbm_bo_write(bo, buf, sizeof(buf));
if (drmModeSetCursor(drm->fd, output->crtc_id, gbm_bo_get_handle(bo).s32,
- drm->cursor_width, drm->cursor_height)) {
+ drm->cursor_width, drm->cursor_height)) {
PEPPER_TRACE("failed to set cursor\n");
drm->cursor_broken = PEPPER_TRUE;
}
if (output->back) {
if (!output->front) {
ret = drmModeSetCrtc(output->drm->fd, output->crtc_id, output->back->id, 0, 0,
- &output->conn->id, 1, output->mode);
+ &output->conn->id, 1, output->mode);
}
ret = drmModePageFlip(output->drm->fd, output->crtc_id, output->back->id,
- DRM_MODE_PAGE_FLIP_EVENT, output);
+ DRM_MODE_PAGE_FLIP_EVENT, output);
PEPPER_CHECK(ret == 0, , "page flip failed.\n");
output->page_flip_pending = PEPPER_TRUE;
vbl.request.type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT;
ret = drmModeSetPlane(output->drm->fd, plane->id,
- output->crtc_id, plane->back->id, 0,
- plane->dx, plane->dy, plane->dw, plane->dh,
- plane->sx, plane->sy, plane->sw, plane->sh);
+ output->crtc_id, plane->back->id, 0,
+ plane->dx, plane->dy, plane->dw, plane->dh,
+ plane->sx, plane->sy, plane->sw, plane->sh);
PEPPER_CHECK(ret == 0, continue, "drmModeSetPlane() failed.\n");
pepper_plane_clear_damage_region(plane->base);
if (output->crtc_index > 1) {
vbl.request.type |= (output->crtc_index << DRM_VBLANK_HIGH_CRTC_SHIFT) &
- DRM_VBLANK_HIGH_CRTC_MASK;
+ DRM_VBLANK_HIGH_CRTC_MASK;
} else if (output->crtc_index > 0) {
vbl.request.type |= DRM_VBLANK_SECONDARY;
}
static void
drm_output_flush_surface_damage(void *o, pepper_surface_t *surface,
- pepper_bool_t *keep_buffer)
+ pepper_bool_t *keep_buffer)
{
drm_output_t *output = o;
pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
for (i = 0; i < conn->connector->count_encoders; i++) {
int32_t possible_crtcs;
drmModeEncoder *encoder = drmModeGetEncoder(conn->drm->fd,
- conn->connector->encoders[i]);
+ conn->connector->encoders[i]);
PEPPER_CHECK(encoder, continue, "drmModeGetEncoder() failed.\n");
if (!drm->pixman_renderer) {
drm->pixman_renderer = pepper_pixman_renderer_create(drm->compositor);
PEPPER_CHECK(drm->pixman_renderer, return,
- "pepper_pixman_renderer_create() failed.\n");
+ "pepper_pixman_renderer_create() failed.\n");
}
output->renderer = drm->pixman_renderer;
if (output->use_shadow) {
output->shadow_image = pixman_image_create_bits(PIXMAN_x8r8g8b8, w, h, NULL, 0);
PEPPER_CHECK(output->shadow_image, goto error,
- "pixman_image_create_bits() failed.\n");
+ "pixman_image_create_bits() failed.\n");
output->render_target = pepper_pixman_renderer_create_target_for_image(
- output->shadow_image);
+ output->shadow_image);
PEPPER_CHECK(output->render_target, goto error,
- "pixman target creation failed.\n");
+ "pixman target creation failed.\n");
pepper_renderer_set_target(output->renderer, output->render_target);
} else {
output->fb_target[i] =
pepper_pixman_renderer_create_target_for_image(output->fb[i]->image);
PEPPER_CHECK(output->fb_target[i], goto error,
- "pixman target creation failed.\n");
+ "pixman target creation failed.\n");
}
}
}
drm->gl_renderer = pepper_gl_renderer_create(drm->compositor, drm->gbm_device,
- "gbm");
+ "gbm");
PEPPER_CHECK(drm->gl_renderer, return, "pepper_gl_renderer_create() failed.\n");
}
output->renderer = drm->gl_renderer;
output->gbm_surface = gbm_surface_create(drm->gbm_device, w, h,
- GBM_FORMAT_XRGB8888,
- GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
+ GBM_FORMAT_XRGB8888,
+ GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
PEPPER_CHECK(output->gbm_surface, goto error, "gbm_surface_create() failed.\n");
output->render_target = pepper_gl_renderer_create_target(drm->gl_renderer,
- output->gbm_surface,
- PEPPER_FORMAT_XRGB8888,
- &native_visual_id, w, h);
+ output->gbm_surface,
+ PEPPER_FORMAT_XRGB8888,
+ &native_visual_id, w, h);
PEPPER_CHECK(output->render_target, goto error,
- "pepper_gl_renderer_create_target() failed.\n");
+ "pepper_gl_renderer_create_target() failed.\n");
output->render_type = DRM_RENDER_TYPE_GL;
pepper_renderer_set_target(output->renderer, output->render_target);
const char *use_overlay_env = getenv("PEPPER_DRM_USE_OVERLAY");
PEPPER_CHECK(conn->output == NULL, return NULL,
- "The connector already has an output.\n");
+ "The connector already has an output.\n");
output = calloc(1, sizeof(drm_output_t));
PEPPER_CHECK(output, return NULL, "calloc() failed.\n");
output->mode = &conn->connector->modes[0];
output->base = pepper_compositor_add_output(drm->compositor,
- &drm_output_backend,
- conn->name, output, WL_OUTPUT_TRANSFORM_NORMAL, 1);
+ &drm_output_backend,
+ conn->name, output, WL_OUTPUT_TRANSFORM_NORMAL, 1);
PEPPER_CHECK(output->base, goto error,
- "pepper_compositor_add_output() failed.\n");
+ "pepper_compositor_add_output() failed.\n");
if (render_env && strcmp(render_env, "gl") == 0)
init_gl_renderer(output);
for (i = 0; i < 2; i++)
output->cursor_bo[i] = gbm_bo_create(drm->gbm_device,
- drm->cursor_width, drm->cursor_height,
- GBM_FORMAT_ARGB8888,
- GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
+ drm->cursor_width, drm->cursor_height,
+ GBM_FORMAT_ARGB8888,
+ GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
if (!output->cursor_bo[0] || !output->cursor_bo[1]) {
PEPPER_TRACE("failed to create cursor bo\n");
drm->cursor_broken = PEPPER_TRUE;
output->primary_plane = pepper_output_add_plane(output->base, NULL);
PEPPER_CHECK(output->primary_plane, goto error,
- "pepper_output_add_plane() failed.\n");
+ "pepper_output_add_plane() failed.\n");
output->cursor_plane = pepper_output_add_plane(output->base,
- output->primary_plane);
+ output->primary_plane);
PEPPER_CHECK(output->cursor_plane, goto error,
- "pepper_output_add_plane() failed.\n");
+ "pepper_output_add_plane() failed.\n");
output->fb_plane = pepper_output_add_plane(output->base, output->primary_plane);
PEPPER_CHECK(output->fb_plane, goto error,
- "pepper_output_add_plane() failed.\n");
+ "pepper_output_add_plane() failed.\n");
pepper_list_for_each_safe(plane, tmp, &output->drm->plane_list, link) {
if (plane->output == NULL &&
- (plane->plane->possible_crtcs & (1 << output->crtc_index))) {
+ (plane->plane->possible_crtcs & (1 << output->crtc_index))) {
plane->base = pepper_output_add_plane(output->base, output->primary_plane);
if (plane->base)
if (output->saved_crtc) {
drmModeSetCrtc(output->conn->drm->fd,
- output->saved_crtc->crtc_id,
- output->saved_crtc->buffer_id,
- output->saved_crtc->x, output->saved_crtc->y,
- &output->conn->connector->connector_id, 1, &output->saved_crtc->mode);
+ output->saved_crtc->crtc_id,
+ output->saved_crtc->buffer_id,
+ output->saved_crtc->x, output->saved_crtc->y,
+ &output->conn->connector->connector_id, 1, &output->saved_crtc->mode);
drmModeFreeCrtc(output->saved_crtc);
}
plane->output = NULL;
pepper_plane_destroy(plane->base);
drmModeSetPlane(output->drm->fd, plane->id, output->crtc_id,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
}
void
drm_handle_vblank(int fd, unsigned int frame, unsigned int sec,
- unsigned int usec, void *data)
+ unsigned int usec, void *data)
{
drm_plane_t *plane = data;
struct timespec ts;
plane->back = NULL;
if (plane->output->vblank_pending_count == 0 &&
- !plane->output->page_flip_pending) {
+ !plane->output->page_flip_pending) {
if (plane->output->destroy_pending) {
drm_output_destroy(plane->output);
} else {
void
drm_handle_page_flip(int fd, unsigned int frame, unsigned int sec,
- unsigned int usec, void *data)
+ unsigned int usec, void *data)
{
drm_output_t *output = data;
struct timespec ts;
PEPPER_API pepper_drm_t *
pepper_drm_create(pepper_compositor_t *compositor, struct udev *udev,
- const char *device);
+ const char *device);
PEPPER_API void
pepper_drm_destroy(pepper_drm_t *drm);
PEPPER_API pepper_fbdev_t *
pepper_fbdev_create(pepper_compositor_t *compositor, struct udev *udev,
- const char *device, const char *renderer)
+ const char *device, const char *renderer)
{
pepper_fbdev_t *fbdev;
{
printf("Bits per pixel: %i\n", info->bits_per_pixel);
printf("Resolution: %ix%i (virtual %ix%i)\n",
- info->xres, info->yres,
- info->xres_virtual, info->yres_virtual);
+ info->xres, info->yres,
+ info->xres_virtual, info->yres_virtual);
printf("Scrolling offset: (%i,%i)\n",
- info->xoffset, info->yoffset);
+ info->xoffset, info->yoffset);
printf("Trans channel: %i bits at offset %i\n",
- info->transp.length, info->transp.offset);
+ info->transp.length, info->transp.offset);
printf("Red channel: %i bits at offset %i\n",
- info->red.length, info->red.offset);
+ info->red.length, info->red.offset);
printf("Green channel: %i bits at offset %i\n",
- info->red.length, info->green.offset);
+ info->red.length, info->green.offset);
printf("Blue channel: %i bits at offset %i\n",
- info->red.length, info->blue.offset);
+ info->red.length, info->blue.offset);
}
static void
pixman_region32_t *damage = pepper_plane_get_damage_region(plane);
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- damage);
+ damage);
pepper_plane_clear_damage_region(plane);
/* FIXME: composite with damage? */
if (output->use_shadow)
pixman_image_composite32(PIXMAN_OP_SRC, output->shadow_image, NULL,
- output->frame_buffer_image, 0, 0, 0, 0, 0, 0,
- output->w, output->h);
+ output->frame_buffer_image, 0, 0, 0, 0, 0, 0,
+ output->w, output->h);
}
}
static void
fbdev_output_flush_surface_damage(void *o, pepper_surface_t *surface,
- pepper_bool_t *keep_buffer)
+ pepper_bool_t *keep_buffer)
{
pepper_renderer_flush_surface_damage(((fbdev_output_t *)o)->renderer, surface);
*keep_buffer = PEPPER_TRUE;
target = pepper_pixman_renderer_create_target_for_image(output->shadow_image);
else
target = pepper_pixman_renderer_create_target(output->format,
- output->frame_buffer_pixels,
- output->stride, output->w, output->h);
+ output->frame_buffer_pixels,
+ output->stride, output->w, output->h);
if (!target)
return PEPPER_FALSE;
output->stride = output->w * (output->bpp / 8);
output->frame_buffer_pixels = mmap(NULL, output->h * output->stride,
- PROT_WRITE, MAP_SHARED, fd, 0);
+ PROT_WRITE, MAP_SHARED, fd, 0);
if (!output->frame_buffer_pixels) {
PEPPER_ERROR("mmap failed.\n");
goto error;
pixman_format_code_t pixman_format = get_pixman_format(output->format);
output->frame_buffer_image = pixman_image_create_bits(pixman_format,
- output->w, output->h,
- output->frame_buffer_pixels,
- output->stride);
+ output->w, output->h,
+ output->frame_buffer_pixels,
+ output->stride);
if (!output->frame_buffer_image) {
PEPPER_ERROR("Failed to create pixman image in %s: pixels_image\n",
- __FUNCTION__);
+ __FUNCTION__);
goto error;
}
output->shadow_image = pixman_image_create_bits(pixman_format, output->w,
- output->h,
- NULL, output->stride);
+ output->h,
+ NULL, output->stride);
if (!output->shadow_image) {
PEPPER_ERROR("Failed to create pixman image in %s: shadow_image\n",
- __FUNCTION__);
+ __FUNCTION__);
goto error;
}
}
}
output->base = pepper_compositor_add_output(output->fbdev->compositor,
- &fbdev_output_backend, "fbdev", output,
- WL_OUTPUT_TRANSFORM_NORMAL, 1);
+ &fbdev_output_backend, "fbdev", output,
+ WL_OUTPUT_TRANSFORM_NORMAL, 1);
if (!output->base) {
PEPPER_ERROR("Failed to add output to compositor in %s\n", __FUNCTION__);
goto error;
display = pepper_compositor_get_display(fbdev->compositor);
loop = wl_display_get_event_loop(display);
output->frame_done_timer = wl_event_loop_add_timer(loop, frame_done_handler,
- output);
+ output);
return PEPPER_TRUE;
PEPPER_API pepper_fbdev_t *
pepper_fbdev_create(pepper_compositor_t *compositor, struct udev *udev,
- const char *device, const char *renderer);
+ const char *device, const char *renderer);
PEPPER_API void
pepper_fbdev_destroy(pepper_fbdev_t *fbdev);
static void
libinput_device_get_properties(struct libinput_device *libinput_device,
- pepper_list_t *property_list)
+ pepper_list_t *property_list)
{
/* get properties */
struct udev_device *udev_device = libinput_device_get_udev_device(
device->caps = caps;
device->base = pepper_input_device_create(input->compositor, caps,
- &li_device_backend, device);
+ &li_device_backend, device);
if (!device->base) {
PEPPER_ERROR("Failed to create pepper input device\n");
/* TODO: error handling */
static void
device_removed(pepper_libinput_t *input,
- struct libinput_device *libinput_device)
+ struct libinput_device *libinput_device)
{
li_device_t *device;
device = (li_device_t *)libinput_device_get_user_data(libinput_device);
static void
pointer_motion(struct libinput_device *libinput_device,
- struct libinput_event_pointer *pointer_event)
+ struct libinput_event_pointer *pointer_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.y = libinput_event_pointer_get_dy(pointer_event);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION, &event);
}
static void
pointer_motion_absolute(struct libinput_device *libinput_device,
- struct libinput_event_pointer *pointer_event)
+ struct libinput_event_pointer *pointer_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.y = libinput_event_pointer_get_absolute_y_transformed(pointer_event, 1);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION_ABSOLUTE, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION_ABSOLUTE, &event);
}
static void
pointer_button(struct libinput_device *libinput_device,
- struct libinput_event_pointer *pointer_event)
+ struct libinput_event_pointer *pointer_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.state = libinput_event_pointer_get_button_state(pointer_event);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON, &event);
}
static void
pointer_axis(struct libinput_device *libinput_device,
- struct libinput_event_pointer *pointer_event)
+ struct libinput_event_pointer *pointer_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.time = libinput_event_pointer_get_time(pointer_event);
if (libinput_event_pointer_has_axis(pointer_event,
- LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) {
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) {
event.axis = PEPPER_POINTER_AXIS_VERTICAL;
event.value = libinput_event_pointer_get_axis_value(pointer_event,
- LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_AXIS, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_AXIS, &event);
} else if (libinput_event_pointer_has_axis(pointer_event,
- LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
event.axis = PEPPER_POINTER_AXIS_HORIZONTAL;
event.value = libinput_event_pointer_get_axis_value(pointer_event,
- LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_AXIS, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_AXIS, &event);
}
}
static void
keyboard_key(struct libinput_device *libinput_device,
- struct libinput_event_keyboard *keyboard_event)
+ struct libinput_event_keyboard *keyboard_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.key = libinput_event_keyboard_get_key(keyboard_event);
if (libinput_event_keyboard_get_key_state(keyboard_event) ==
- LIBINPUT_KEY_STATE_RELEASED)
+ LIBINPUT_KEY_STATE_RELEASED)
event.state = PEPPER_KEY_STATE_RELEASED;
else
event.state = PEPPER_KEY_STATE_PRESSED;
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
+ PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
}
static void
touch_down(struct libinput_device *libinput_device,
- struct libinput_event_touch *touch_event)
+ struct libinput_event_touch *touch_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.y = libinput_event_touch_get_y_transformed(touch_event, 1);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_TOUCH_DOWN, &event);
+ PEPPER_EVENT_INPUT_DEVICE_TOUCH_DOWN, &event);
}
static void
touch_up(struct libinput_device *libinput_device,
- struct libinput_event_touch *touch_event)
+ struct libinput_event_touch *touch_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_input_event_t event;
event.slot = libinput_event_touch_get_seat_slot(touch_event);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_TOUCH_UP, &event);
+ PEPPER_EVENT_INPUT_DEVICE_TOUCH_UP, &event);
}
static void
touch_motion(struct libinput_device *libinput_device,
- struct libinput_event_touch *touch_event)
+ struct libinput_event_touch *touch_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
event.y = libinput_event_touch_get_y_transformed(touch_event, 1);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_TOUCH_MOTION, &event);
+ PEPPER_EVENT_INPUT_DEVICE_TOUCH_MOTION, &event);
}
static void
touch_frame(struct libinput_device *libinput_device,
- struct libinput_event_touch *touch_event)
+ struct libinput_event_touch *touch_event)
{
li_device_t *device = libinput_device_get_user_data(libinput_device);
pepper_object_emit_event((pepper_object_t *)device->base,
- PEPPER_EVENT_INPUT_DEVICE_TOUCH_FRAME, NULL);
+ PEPPER_EVENT_INPUT_DEVICE_TOUCH_FRAME, NULL);
}
static void
switch (libinput_event_get_type(event)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
device_added((pepper_libinput_t *)libinput_get_user_data(libinput),
- libinput_device);
+ libinput_device);
break;
case LIBINPUT_EVENT_DEVICE_REMOVED:
device_removed((pepper_libinput_t *)libinput_get_user_data(libinput),
- libinput_device);
+ libinput_device);
break;
case LIBINPUT_EVENT_POINTER_MOTION:
pointer_motion(libinput_device, libinput_event_get_pointer_event(event));
break;
case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
pointer_motion_absolute(libinput_device,
- libinput_event_get_pointer_event(event));
+ libinput_event_get_pointer_event(event));
break;
case LIBINPUT_EVENT_POINTER_BUTTON:
pointer_button(libinput_device, libinput_event_get_pointer_event(event));
pepper_list_init(&input->device_list);
input->libinput = libinput_udev_create_context(&libinput_interface, input,
- input->udev);
+ input->udev);
if (!input->libinput) {
PEPPER_ERROR("Failed to initialize libinput in %s\n", __FUNCTION__);
goto error;
loop = wl_display_get_event_loop(display);
input->libinput_fd = libinput_get_fd(input->libinput);
input->libinput_event_source = wl_event_loop_add_fd(loop, input->libinput_fd,
- WL_EVENT_READABLE,
- handle_libinput_events, input);
+ WL_EVENT_READABLE,
+ handle_libinput_events, input);
if (!input->libinput_event_source) {
PEPPER_ERROR("Failed to add libinput fd to the main loop in %s\n",
- __FUNCTION__);
+ __FUNCTION__);
goto error;
}
buffer_resource_destroy_handler(struct wl_listener *listener, void *data)
{
pepper_buffer_t *buffer = pepper_container_of(listener, buffer,
- resource_destroy_listener);
+ resource_destroy_listener);
pepper_object_fini(&buffer->base);
free(buffer);
}
struct wl_listener *listener;
listener = wl_resource_get_destroy_listener(resource,
- buffer_resource_destroy_handler);
+ buffer_resource_destroy_handler);
if (listener)
return pepper_container_of(listener, buffer, resource_destroy_listener);
buffer = (pepper_buffer_t *)pepper_object_alloc(PEPPER_OBJECT_BUFFER,
- sizeof(pepper_buffer_t));
+ sizeof(pepper_buffer_t));
PEPPER_CHECK(buffer, return NULL, "pepper_object_alloc() failed.\n");
buffer->resource = resource;
static void
compositor_create_surface(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id)
+ struct wl_resource *resource,
+ uint32_t id)
{
pepper_compositor_t *compositor = wl_resource_get_user_data(resource);
static void
compositor_create_region(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id)
+ struct wl_resource *resource,
+ uint32_t id)
{
pepper_compositor_t *compositor = wl_resource_get_user_data(resource);
static void
compositor_bind(struct wl_client *client,
- void *data,
- uint32_t version,
- uint32_t id)
+ void *data,
+ uint32_t version,
+ uint32_t id)
{
pepper_compositor_t *compositor = (pepper_compositor_t *)data;
struct wl_resource *resource;
wl_list_insert(&compositor->resource_list, wl_resource_get_link(resource));
wl_resource_set_implementation(resource, &compositor_interface, compositor,
- unbind_resource);
+ unbind_resource);
}
static pepper_bool_t
compositor_bind_socket(pepper_compositor_t *compositor, int socket_fd,
- const char *name)
+ const char *name)
{
struct stat buf;
socklen_t size, name_size;
PEPPER_CHECK((-1 != flags), return PEPPER_FALSE, "fcntl(F_GETFD) failed\n");
PEPPER_CHECK((-1 != fcntl(socket_fd, F_SETFD, flags | FD_CLOEXEC)),
- return PEPPER_FALSE,
- "fcntl(F_SETFD) failed\n");
+ return PEPPER_FALSE,
+ "fcntl(F_SETFD) failed\n");
runtime_dir = getenv("XDG_RUNTIME_DIR");
if (!runtime_dir) {
compositor->addr.sun_family = AF_LOCAL;
name_size = snprintf(compositor->addr.sun_path,
- sizeof compositor->addr.sun_path,
- "%s/%s", runtime_dir, name) + 1;
+ sizeof compositor->addr.sun_path,
+ "%s/%s", runtime_dir, name) + 1;
if (name_size > (int)sizeof(compositor->addr.sun_path)) {
PEPPER_ERROR("socket path \"%s/%s\" plus null terminator"
- " exceeds 108 bytes\n", runtime_dir, name);
+ " exceeds 108 bytes\n", runtime_dir, name);
goto err_addr;
}
if (stat(compositor->addr.sun_path, &buf) < 0) {
if (errno != ENOENT) {
PEPPER_ERROR("did not manage to stat file %s\n",
- compositor->addr.sun_path);
+ compositor->addr.sun_path);
goto err_addr;
}
- }
- else if (buf.st_mode & S_IWUSR ||
- buf.st_mode & S_IWGRP)
- {
+ } else if (buf.st_mode & S_IWUSR ||
+ buf.st_mode & S_IWGRP) {
unlink(compositor->addr.sun_path);
}
pepper_compositor_t *compositor;
compositor = (pepper_compositor_t *)pepper_object_alloc(
- PEPPER_OBJECT_COMPOSITOR,
- sizeof(pepper_compositor_t));
+ PEPPER_OBJECT_COMPOSITOR,
+ sizeof(pepper_compositor_t));
PEPPER_CHECK(compositor, goto error, "pepper_object_alloc() failed.\n");
wl_list_init(&compositor->resource_list);
if (socket_name) {
if (fd > 0) {
PEPPER_CHECK(PEPPER_TRUE == compositor_bind_socket(compositor, fd, socket_name),
- goto error,
- "compositor_bind_socket()");
+ goto error,
+ "compositor_bind_socket()");
ret = wl_display_add_socket_fd(compositor->display, fd);
PEPPER_CHECK(ret == 0, goto error,
- "wl_display_add_socket_fd(name = %s, fd = %d) failed.\n", socket_name, fd);
+ "wl_display_add_socket_fd(name = %s, fd = %d) failed.\n", socket_name, fd);
} else {
ret = wl_display_add_socket(compositor->display, socket_name);
PEPPER_CHECK(ret == 0, goto error, "wl_display_add_socket(name = %s) failed.\n",
- socket_name);
+ socket_name);
}
} else {
if (fd > 0) {
ret = wl_display_add_socket_fd(compositor->display, fd);
PEPPER_CHECK(ret == 0, goto error,
- "wl_display_add_socket_fd(name = %s, fd = %d) failed.\n", socket_name, fd);
+ "wl_display_add_socket_fd(name = %s, fd = %d) failed.\n", socket_name, fd);
} else {
socket_name = wl_display_add_socket_auto(compositor->display);
PEPPER_CHECK(socket_name, goto error, "wl_display_add_socket_auto() failed.\n");
PEPPER_CHECK(ret == 0, goto error, "wl_display_init_shm() failed.\n");
compositor->global = wl_global_create(compositor->display,
- &wl_compositor_interface,
- 3, compositor, compositor_bind);
+ &wl_compositor_interface,
+ 3, compositor, compositor_bind);
PEPPER_CHECK(compositor->global, goto error, "wl_global_create() failed.\n");
compositor->subcomp = pepper_subcompositor_create(compositor);
PEPPER_CHECK(compositor->subcomp, goto error,
- "pepper_subcompositor_create() failed.\n");
+ "pepper_subcompositor_create() failed.\n");
compositor->clock_id = CLOCK_MONOTONIC;
return compositor;
pepper_region_t *region, *next_region;
pepper_list_for_each_safe(surface, next_surface, &compositor->surface_list,
- link)
+ link)
pepper_surface_destroy(surface);
pepper_list_for_each_safe(region, next_region, &compositor->region_list, link)
*/
PEPPER_API pepper_view_t *
pepper_compositor_pick_view(pepper_compositor_t *compositor,
- double x, double y, double *vx, double *vy)
+ double x, double y, double *vx, double *vy)
{
pepper_view_t *view;
int ix = (int)x;
continue;
if (!pixman_region32_contains_point(&view->surface->input_region, ilx, ily,
- NULL))
+ NULL))
continue;
if (vx)
wl_list_insert(&seat->resource_list, wl_resource_get_link(resource));
wl_resource_set_implementation(resource, &seat_interface, data,
- unbind_resource);
+ unbind_resource);
wl_seat_send_capabilities(resource, seat->caps);
*/
PEPPER_API pepper_seat_t *
pepper_compositor_add_seat(pepper_compositor_t *compositor,
- const char *seat_name)
+ const char *seat_name)
{
pepper_seat_t *seat;
seat = (pepper_seat_t *)pepper_object_alloc(PEPPER_OBJECT_SEAT,
sizeof(pepper_seat_t));
PEPPER_CHECK(seat, return NULL, "Failed to allocate memory in %s\n",
- __FUNCTION__);
+ __FUNCTION__);
pepper_list_init(&seat->link);
wl_list_init(&seat->resource_list);
PEPPER_CHECK(seat->name, goto error, "strdup() failed.\n");
seat->global = wl_global_create(compositor->display, &wl_seat_interface, 4,
- seat, bind_seat);
+ seat, bind_seat);
PEPPER_CHECK(seat->global, goto error, "wl_global_create() failed.\n");
seat->compositor = compositor;
seat->link.item = seat;
pepper_list_insert(&compositor->seat_list, &seat->link);
pepper_object_emit_event(&seat->compositor->base,
- PEPPER_EVENT_COMPOSITOR_SEAT_ADD, seat);
+ PEPPER_EVENT_COMPOSITOR_SEAT_ADD, seat);
return seat;
if ((seat->caps & WL_SEAT_CAPABILITY_POINTER) && !seat->pointer) {
seat->pointer = pepper_pointer_create(seat);
pepper_object_emit_event(&seat->base, PEPPER_EVENT_SEAT_POINTER_ADD,
- seat->pointer);
+ seat->pointer);
} else if (!(seat->caps & WL_SEAT_CAPABILITY_POINTER) && seat->pointer) {
pepper_object_emit_event(&seat->base, PEPPER_EVENT_SEAT_POINTER_REMOVE,
- seat->pointer);
+ seat->pointer);
pepper_pointer_destroy(seat->pointer);
seat->pointer = NULL;
}
if ((seat->caps & WL_SEAT_CAPABILITY_KEYBOARD) && !seat->keyboard) {
seat->keyboard = pepper_keyboard_create(seat);
pepper_object_emit_event(&seat->base, PEPPER_EVENT_SEAT_KEYBOARD_ADD,
- seat->keyboard);
+ seat->keyboard);
} else if (!(seat->caps & WL_SEAT_CAPABILITY_KEYBOARD) && seat->keyboard) {
pepper_object_emit_event(&seat->base, PEPPER_EVENT_SEAT_KEYBOARD_REMOVE,
- seat->keyboard);
+ seat->keyboard);
pepper_keyboard_destroy(seat->keyboard);
seat->keyboard = NULL;
}
pepper_object_emit_event(&seat->base, PEPPER_EVENT_SEAT_TOUCH_ADD, seat->touch);
} else if (!(seat->caps & WL_SEAT_CAPABILITY_TOUCH) && seat->touch) {
pepper_object_emit_event(&seat->base, PEPPER_EVENT_SEAT_TOUCH_REMOVE,
- seat->touch);
+ seat->touch);
pepper_touch_destroy(seat->touch);
seat->touch = NULL;
}
static void
seat_handle_device_event(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id, void *info, void *data)
+ pepper_object_t *object,
+ uint32_t id, void *info, void *data)
{
pepper_input_device_entry_t *entry = data;
pepper_seat_t *seat = entry->seat;
seat_update_caps(seat);
entry->listener = pepper_object_add_event_listener(&device->base,
- PEPPER_EVENT_ALL, 0,
- seat_handle_device_event, entry);
+ PEPPER_EVENT_ALL, 0,
+ seat_handle_device_event, entry);
}
/**
*/
PEPPER_API void
pepper_seat_remove_input_device(pepper_seat_t *seat,
- pepper_input_device_t *device)
+ pepper_input_device_t *device)
{
pepper_input_device_entry_t *entry;
*/
PEPPER_API pepper_input_device_t *
pepper_input_device_create(pepper_compositor_t *compositor, uint32_t caps,
- const pepper_input_device_backend_t *backend, void *data)
+ const pepper_input_device_backend_t *backend, void *data)
{
pepper_input_device_t *device;
device = (pepper_input_device_t *)pepper_object_alloc(
- PEPPER_OBJECT_INPUT_DEVICE,
- sizeof(pepper_input_device_t));
+ PEPPER_OBJECT_INPUT_DEVICE,
+ sizeof(pepper_input_device_t));
PEPPER_CHECK(device, return NULL, "pepper_object_alloc() failed.\n");
device->compositor = compositor;
pepper_list_insert(&compositor->input_device_list, &device->link);
pepper_object_emit_event(&compositor->base,
- PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_ADD,
- device);
+ PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_ADD,
+ device);
return device;
}
pepper_input_device_destroy(pepper_input_device_t *device)
{
pepper_object_emit_event(&device->compositor->base,
- PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_REMOVE, device);
+ PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_REMOVE, device);
pepper_list_remove(&device->link);
pepper_object_fini(&device->base);
free(device);
uint32_t mods_depressed, mods_latched, mods_locked, group;
mods_depressed = xkb_state_serialize_mods(keyboard->state,
- XKB_STATE_MODS_DEPRESSED);
+ XKB_STATE_MODS_DEPRESSED);
mods_latched = xkb_state_serialize_mods(keyboard->state,
- XKB_STATE_MODS_LATCHED);
+ XKB_STATE_MODS_LATCHED);
mods_locked = xkb_state_serialize_mods(keyboard->state, XKB_STATE_MODS_LOCKED);
group = xkb_state_serialize_mods(keyboard->state, XKB_STATE_LAYOUT_EFFECTIVE);
if ((mods_depressed != keyboard->mods_depressed) ||
- (mods_latched != keyboard->mods_latched) ||
- (mods_locked != keyboard->mods_locked) || (group != keyboard->group)) {
+ (mods_latched != keyboard->mods_latched) ||
+ (mods_locked != keyboard->mods_locked) || (group != keyboard->group)) {
keyboard->mods_depressed = mods_depressed;
keyboard->mods_latched = mods_latched;
keyboard->mods_locked = mods_locked;
keyboard->group = group;
keyboard->grab->modifiers(keyboard, keyboard->data, mods_depressed,
- mods_latched,
- mods_locked, group);
+ mods_latched,
+ mods_locked, group);
}
}
keyboard->pending_keymap = NULL;
keymap_str = xkb_keymap_get_as_string(keyboard->keymap,
- XKB_KEYMAP_FORMAT_TEXT_V1);
+ XKB_KEYMAP_FORMAT_TEXT_V1);
PEPPER_CHECK(keymap_str, goto error, "failed to get keymap string\n");
keyboard->keymap_len = strlen(keymap_str) + 1;
PEPPER_CHECK(keyboard->keymap_fd, goto error, "failed to create keymap file\n");
keymap_map = mmap(NULL, keyboard->keymap_len, PROT_READ | PROT_WRITE,
- MAP_SHARED,
- keyboard->keymap_fd, 0);
+ MAP_SHARED,
+ keyboard->keymap_fd, 0);
PEPPER_CHECK(keymap_map, goto error, "failed to mmap for keymap\n");
strcpy(keymap_map, keymap_str);
if (keyboard->state) {
mods_latched = xkb_state_serialize_mods(keyboard->state,
- XKB_STATE_MODS_LATCHED);
+ XKB_STATE_MODS_LATCHED);
mods_locked = xkb_state_serialize_mods(keyboard->state, XKB_STATE_MODS_LOCKED);
xkb_state_update_mask(state, 0, mods_latched, mods_locked, 0, 0, 0);
xkb_state_unref(keyboard->state);
wl_resource_for_each(resource, &keyboard->resource_list)
wl_keyboard_send_keymap(resource, format, keyboard->keymap_fd,
- keyboard->keymap_len);
+ keyboard->keymap_len);
update_modifiers(keyboard);
wl_resource_for_each(resource, &keyboard->resource_list)
wl_keyboard_send_modifiers(resource,
- wl_display_next_serial(keyboard->seat->compositor->display),
- keyboard->mods_depressed, keyboard->mods_latched,
- keyboard->mods_locked, keyboard->group);
+ wl_display_next_serial(keyboard->seat->compositor->display),
+ keyboard->mods_depressed, keyboard->mods_latched,
+ keyboard->mods_locked, keyboard->group);
goto done;
error:
void
pepper_keyboard_handle_event(pepper_keyboard_t *keyboard, uint32_t id,
- pepper_input_event_t *event)
+ pepper_input_event_t *event)
{
uint32_t *keys = keyboard->keys.data;
unsigned int num_keys = keyboard->keys.size / sizeof(uint32_t);
if (keyboard->grab)
keyboard->grab->key(keyboard, keyboard->data, event->time, event->key,
- event->state);
+ event->state);
if (keyboard->pending_keymap && (keyboard->keys.size == 0))
update_keymap(keyboard);
static void
keyboard_handle_focus_destroy(pepper_event_listener_t *listener,
- pepper_object_t *surface,
- uint32_t id, void *info, void *data)
+ pepper_object_t *surface,
+ uint32_t id, void *info, void *data)
{
pepper_keyboard_t *keyboard = data;
pepper_keyboard_set_focus(keyboard, NULL);
void
pepper_keyboard_bind_resource(struct wl_client *client,
- struct wl_resource *resource, uint32_t id)
+ struct wl_resource *resource, uint32_t id)
{
pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource);
pepper_keyboard_t *keyboard = seat->keyboard;
return;
res = wl_resource_create(client, &wl_keyboard_interface,
- wl_resource_get_version(resource), id);
+ wl_resource_get_version(resource), id);
if (!res) {
wl_client_post_no_memory(client);
return;
if (keyboard->keymap) {
wl_keyboard_send_keymap(res, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
- keyboard->keymap_fd, keyboard->keymap_len);
+ keyboard->keymap_fd, keyboard->keymap_len);
} else {
int fd = open("/dev/null", O_RDONLY);
wl_keyboard_send_keymap(res, WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP, fd, 0);
}
if (!keyboard->focus || !keyboard->focus->surface ||
- !keyboard->focus->surface->resource)
+ !keyboard->focus->surface->resource)
return;
if (wl_resource_get_client(keyboard->focus->surface->resource) == client) {
wl_keyboard_send_enter(res, keyboard->focus_serial,
- keyboard->focus->surface->resource, &keyboard->keys);
+ keyboard->focus->surface->resource, &keyboard->keys);
}
}
if (keyboard->focus) {
pepper_event_listener_remove(keyboard->focus_destroy_listener);
pepper_object_emit_event(&keyboard->base, PEPPER_EVENT_FOCUS_LEAVE,
- keyboard->focus);
+ keyboard->focus);
pepper_object_emit_event(&keyboard->focus->base, PEPPER_EVENT_FOCUS_LEAVE,
- keyboard);
+ keyboard);
}
keyboard->focus = focus;
if (focus) {
keyboard->focus_serial = wl_display_next_serial(
- keyboard->seat->compositor->display);
+ keyboard->seat->compositor->display);
keyboard->focus_destroy_listener =
pepper_object_add_event_listener(&focus->base, PEPPER_EVENT_OBJECT_DESTROY, 0,
- keyboard_handle_focus_destroy, keyboard);
+ keyboard_handle_focus_destroy, keyboard);
pepper_object_emit_event(&keyboard->base, PEPPER_EVENT_FOCUS_ENTER, focus);
pepper_object_emit_event(&focus->base, PEPPER_EVENT_FOCUS_ENTER, keyboard);
wl_resource_for_each(resource, &keyboard->resource_list) {
if (wl_resource_get_client(resource) == client)
wl_keyboard_send_enter(resource, serial, view->surface->resource,
- &keyboard->keys);
+ &keyboard->keys);
}
}
*/
PEPPER_API void
pepper_keyboard_send_key(pepper_keyboard_t *keyboard, pepper_view_t *view,
- uint32_t time, uint32_t key, uint32_t state)
+ uint32_t time, uint32_t key, uint32_t state)
{
struct wl_resource *resource;
struct wl_client *client;
*/
PEPPER_API void
pepper_keyboard_send_modifiers(pepper_keyboard_t *keyboard, pepper_view_t *view,
- uint32_t depressed, uint32_t latched,
- uint32_t locked, uint32_t group)
+ uint32_t depressed, uint32_t latched,
+ uint32_t locked, uint32_t group)
{
struct wl_resource *resource;
struct wl_client *client;
*/
PEPPER_API void
pepper_keyboard_set_grab(pepper_keyboard_t *keyboard,
- const pepper_keyboard_grab_t *grab, void *data)
+ const pepper_keyboard_grab_t *grab, void *data)
{
keyboard->grab = grab;
keyboard->data = data;
*/
PEPPER_API void
pepper_keyboard_set_keymap(pepper_keyboard_t *keyboard,
- struct xkb_keymap *keymap)
+ struct xkb_keymap *keymap)
{
xkb_keymap_unref(keyboard->pending_keymap);
if (keymap)
*/
PEPPER_API void
pepper_pixman_region_global_to_output(pixman_region32_t *region,
- pepper_output_t *output)
+ pepper_output_t *output)
{
pixman_box32_t *box, b;
int num_rects, i;
*/
PEPPER_API void
pepper_coordinates_surface_to_buffer(pepper_surface_t *surface,
- double sx, double sy, double *bx, double *by)
+ double sx, double sy, double *bx, double *by)
{
int32_t scale, w, h;
*/
static inline void
make_output_transform(pepper_mat4_t *mat,
- double s, /* scale */
- double a, double b, double c, double d, double e, double f, /* transform */
- double x, double y /* translate */)
+ double s, /* scale */
+ double a, double b, double c, double d, double e, double f, /* transform */
+ double x, double y /* translate */)
{
double *m = &mat->m[0];
void
pepper_transform_global_to_output(pepper_mat4_t *transform,
- pepper_output_t *output)
+ pepper_output_t *output)
{
pepper_mat4_t mat;
double x = output->geometry.x;
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
make_output_transform(&mat, (double)output->scale, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_FLIPPED:
make_output_transform(&mat, (double)output->scale, -1.0, 0.0, 0.0, 1.0, w, 0.0,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_90:
make_output_transform(&mat, (double)output->scale, 0.0, -1.0, 1.0, 0.0, h, 0.0,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
make_output_transform(&mat, (double)output->scale, 0.0, -1.0, -1.0, 0.0, h, w,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_180:
make_output_transform(&mat, (double)output->scale, -1.0, 0.0, 0.0, -1.0, w, h,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
make_output_transform(&mat, (double)output->scale, 1.0, 0.0, 0.0, -1.0, 0.0, h,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_270:
make_output_transform(&mat, (double)output->scale, 0.0, 1.0, -1.0, 0.0, 0.0, w,
- x, y);
+ x, y);
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
make_output_transform(&mat, (double)output->scale, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0,
- x, y);
+ x, y);
break;
}
pepper_list_init(&object->event_listener_list);
pepper_map_pointer_init(&object->user_data_map, PEPPER_OBJECT_BUCKET_BITS,
- &object->buckets[0]);
+ &object->buckets[0]);
if (!object_map) {
pepper_id_allocator_init(&id_allocator);
*/
PEPPER_API void
pepper_object_set_user_data(pepper_object_t *object, const void *key,
- void *data,
- pepper_free_func_t free_func)
+ void *data,
+ pepper_free_func_t free_func)
{
pepper_map_set(&object->user_data_map, key, data, free_func);
}
*/
PEPPER_API pepper_event_listener_t *
pepper_object_add_event_listener(pepper_object_t *object, uint32_t id,
- int priority,
- pepper_event_callback_t callback, void *data)
+ int priority,
+ pepper_event_callback_t callback, void *data)
{
pepper_event_listener_t *listener;
*/
PEPPER_API void
pepper_event_listener_set_priority(pepper_event_listener_t *listener,
- int priority)
+ int priority)
{
if (!listener->object)
return;
pepper_event_listener_t *listener, *tmp;
PEPPER_CHECK(id != PEPPER_EVENT_ALL, return,
- "Cannot emit the PEPPER_EVENT_ALL event");
+ "Cannot emit the PEPPER_EVENT_ALL event");
pepper_list_for_each_safe(listener, tmp, &object->event_listener_list, link) {
if (listener->id == PEPPER_EVENT_ALL || listener->id == id)
wl_resource_for_each(resource, &output->resource_list) {
wl_output_send_geometry(resource,
- output->geometry.x, output->geometry.y,
- output->geometry.w, output->geometry.h,
- output->geometry.subpixel,
- output->geometry.maker, output->geometry.model,
- output->geometry.transform);
+ output->geometry.x, output->geometry.y,
+ output->geometry.w, output->geometry.h,
+ output->geometry.subpixel,
+ output->geometry.maker, output->geometry.model,
+ output->geometry.transform);
}
}
wl_resource_set_implementation(resource, NULL, NULL, output_destroy);
wl_output_send_geometry(resource,
- output->geometry.x, output->geometry.y,
- output->geometry.w, output->geometry.h,
- output->geometry.subpixel,
- output->geometry.maker, output->geometry.model,
- output->geometry.transform);
+ output->geometry.x, output->geometry.y,
+ output->geometry.w, output->geometry.h,
+ output->geometry.subpixel,
+ output->geometry.maker, output->geometry.model,
+ output->geometry.transform);
wl_output_send_scale(resource, output->scale);
output_send_modes(output, resource);
/* Build a list of views in sorted z-order that are visible on the given output. */
pepper_list_for_each(view, &output->compositor->view_list, compositor_link) {
if (!view->active || !(view->output_overlap & (1 << output->id)) ||
- !view->surface) {
+ !view->surface) {
/* Detach from the previously assigned plane. */
pepper_view_assign_plane(view, output, NULL);
continue;
pepper_list_for_each(view, &output->view_list, link) {
/* TODO: Output time stamp and presentation feedback. */
pepper_surface_send_frame_callback_done(view->surface,
- output->frame.time.tv_sec * 1000 +
- output->frame.time.tv_nsec / 1000000);
+ output->frame.time.tv_sec * 1000 +
+ output->frame.time.tv_nsec / 1000000);
}
}
*/
PEPPER_API void
pepper_output_add_damage_region(pepper_output_t *output,
- pixman_region32_t *region)
+ pixman_region32_t *region)
{
pepper_plane_t *plane;
pepper_list_for_each(plane, &output->plane_list, link)
if (output->frame.print_fps) {
if (output->frame.count > 0) {
uint32_t tick = (time.tv_sec - output->frame.time.tv_sec) * 1000 +
- (time.tv_nsec - output->frame.time.tv_nsec) / 1000000;
+ (time.tv_nsec - output->frame.time.tv_nsec) / 1000000;
uint32_t tick_count;
output->frame.total_time += tick;
tick_count = PEPPER_OUTPUT_MAX_TICK_COUNT;
PEPPER_TRACE("%s FPS : %.2f\n", output->name,
- (double)(tick_count * 1000) / (double)output->frame.total_time);
+ (double)(tick_count * 1000) / (double)output->frame.total_time);
}
}
*/
PEPPER_API pepper_output_t *
pepper_compositor_add_output(pepper_compositor_t *compositor,
- const pepper_output_backend_t *backend, const char *name, void *data,
- int transform, int scale)
+ const pepper_output_backend_t *backend, const char *name, void *data,
+ int transform, int scale)
{
pepper_output_t *output;
uint32_t id;
pepper_list_for_each(output, &compositor->output_list, link) {
PEPPER_CHECK(strcmp(output->name, name) != 0, return NULL,
- "Output with name = %s already exist.\n", name);
+ "Output with name = %s already exist.\n", name);
}
id = ffs(~compositor->output_id_allocator);
id = id - 1;
output = (pepper_output_t *)pepper_object_alloc(PEPPER_OBJECT_OUTPUT,
- sizeof(pepper_output_t));
+ sizeof(pepper_output_t));
PEPPER_CHECK(output, return NULL, "pepper_object_alloc() failed.\n");
output->compositor = compositor;
/* Create global object for this output. */
output->global = wl_global_create(compositor->display, &wl_output_interface, 2,
- output,
- output_bind);
+ output,
+ output_bind);
if (!output->global) {
free(output);
return NULL;
output->frame.print_fps = PEPPER_TRUE;
pepper_object_emit_event(&compositor->base, PEPPER_EVENT_COMPOSITOR_OUTPUT_ADD,
- output);
+ output);
return output;
}
pepper_output_destroy(pepper_output_t *output)
{
pepper_object_emit_event(&output->compositor->base,
- PEPPER_EVENT_COMPOSITOR_OUTPUT_REMOVE, output);
+ PEPPER_EVENT_COMPOSITOR_OUTPUT_REMOVE, output);
pepper_object_fini(&output->base);
output->compositor->output_id_allocator &= ~(1 << output->id);
*/
PEPPER_API void
pepper_output_get_mode(pepper_output_t *output, int index,
- pepper_output_mode_t *mode)
+ pepper_output_mode_t *mode)
{
return output->backend->get_mode(output->data, index, mode);
}
*/
PEPPER_API pepper_bool_t
pepper_output_set_mode(pepper_output_t *output,
- const pepper_output_mode_t *mode)
+ const pepper_output_mode_t *mode)
{
if (output->current_mode.w == mode->w && output->current_mode.h == mode->h &&
- output->current_mode.refresh == mode->refresh)
+ output->current_mode.refresh == mode->refresh)
return PEPPER_TRUE;
if (output->backend->set_mode(output->data, mode)) {
PEPPER_API pepper_input_device_t *
pepper_input_device_create(pepper_compositor_t *compositor, uint32_t caps,
- const pepper_input_device_backend_t *backend, void *data);
+ const pepper_input_device_backend_t *backend, void *data);
PEPPER_API void
pepper_input_device_destroy(pepper_input_device_t *device);
pepper_surface_t *
pepper_surface_create(pepper_compositor_t *compositor,
- struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id);
+ struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id);
void
pepper_surface_destroy(pepper_surface_t *surface);
void
pepper_surface_commit_state(pepper_surface_t *surface,
- pepper_surface_state_t *state);
+ pepper_surface_state_t *state);
void
pepper_surface_send_frame_callback_done(pepper_surface_t *surface,
- uint32_t time);
+ uint32_t time);
struct pepper_region {
pepper_object_t base;
pepper_region_t *
pepper_region_create(pepper_compositor_t *compositor,
- struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id);
+ struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id);
void
pepper_region_destroy(pepper_region_t *region);
void
pepper_transform_pixman_region(pixman_region32_t *region,
- const pepper_mat4_t *matrix);
+ const pepper_mat4_t *matrix);
/* Subcompositor */
struct pepper_subcompositor {
pepper_subsurface_t *
pepper_subsurface_create(pepper_surface_t *surface, pepper_surface_t *parent,
- struct wl_client *client, struct wl_resource *resource, uint32_t id);
+ struct wl_client *client, struct wl_resource *resource, uint32_t id);
pepper_bool_t
pepper_subsurface_commit(pepper_subsurface_t *subsurface);
void
subsurface_destroy_children_views(pepper_subsurface_t *subsurface,
- pepper_view_t *parent_view);
+ pepper_view_t *parent_view);
void
subsurface_create_children_views(pepper_subsurface_t *subsurface,
- pepper_view_t *parent_view);
+ pepper_view_t *parent_view);
/* Input */
struct pepper_pointer {
void
pepper_pointer_bind_resource(struct wl_client *client,
- struct wl_resource *resource, uint32_t id);
+ struct wl_resource *resource, uint32_t id);
void
pepper_pointer_handle_event(pepper_pointer_t *pointer, uint32_t id,
- pepper_input_event_t *event);
+ pepper_input_event_t *event);
struct pepper_keyboard {
pepper_object_t base;
void
pepper_keyboard_bind_resource(struct wl_client *client,
- struct wl_resource *resource, uint32_t id);
+ struct wl_resource *resource, uint32_t id);
void
pepper_keyboard_handle_event(pepper_keyboard_t *keyboard, uint32_t id,
- pepper_input_event_t *event);
+ pepper_input_event_t *event);
struct pepper_touch_point {
pepper_touch_t *touch;
void
pepper_touch_bind_resource(struct wl_client *client,
- struct wl_resource *resource, uint32_t id);
+ struct wl_resource *resource, uint32_t id);
void
pepper_touch_handle_event(pepper_touch_t *touch, uint32_t id,
- pepper_input_event_t *event);
+ pepper_input_event_t *event);
struct pepper_seat {
pepper_object_t base;
void
pepper_plane_add_damage_region(pepper_plane_t *plane,
- pixman_region32_t *region);
+ pixman_region32_t *region);
void
pepper_plane_update(pepper_plane_t *plane, const pepper_list_t *view_list,
- pixman_region32_t *clip);
+ pixman_region32_t *clip);
void
pepper_surface_flush_damage(pepper_surface_t *surface);
/* Misc. */
void
pepper_pixman_region_global_to_output(pixman_region32_t *region,
- pepper_output_t *output);
+ pepper_output_t *output);
void
pepper_transform_global_to_output(pepper_mat4_t *transform,
- pepper_output_t *output);
+ pepper_output_t *output);
#endif /* PEPPER_INTERNAL_H */
* Return mode info for the given mode index.
*/
void (*get_mode)(void *output, int index,
- pepper_output_mode_t *mode);
+ pepper_output_mode_t *mode);
/**
* Change output mode to the given mode. return PEPPER_TRUE on success.
* allocate resources for the surface.
*/
void (*attach_surface)(void *output, pepper_surface_t *surface,
- int *w, int *h);
+ int *w, int *h);
/**
* Update the surface content. Called before repaint. Backend should handle damage region
* of the given surface if it is maintaining a copy of the surface.
*/
void (*flush_surface_damage)(void *output, pepper_surface_t *surface,
- pepper_bool_t *keep_buffer);
+ pepper_bool_t *keep_buffer);
};
PEPPER_API pepper_output_t *
pepper_compositor_add_output(pepper_compositor_t *compositor,
- const pepper_output_backend_t *backend, const char *name, void *data,
- int transform, int scale);
+ const pepper_output_backend_t *backend, const char *name, void *data,
+ int transform, int scale);
struct pepper_render_item {
pepper_view_t *view; /**< view to render */
PEPPER_API void
pepper_plane_subtract_damage_region(pepper_plane_t *plane,
- pixman_region32_t *damage);
+ pixman_region32_t *damage);
PEPPER_API void
pepper_plane_clear_damage_region(pepper_plane_t *plane);
PEPPER_API void
pepper_view_assign_plane(pepper_view_t *view, pepper_output_t *output,
- pepper_plane_t *plane);
+ pepper_plane_t *plane);
PEPPER_API void
pepper_output_add_damage_region(pepper_output_t *output,
- pixman_region32_t *region);
+ pixman_region32_t *region);
PEPPER_API void
pepper_output_finish_frame(pepper_output_t *output, struct timespec *ts);
PEPPER_API void
pepper_map_init(pepper_map_t *map,
- int bucket_bits,
- pepper_hash_func_t hash_func,
- pepper_key_length_func_t key_length_func,
- pepper_key_compare_func_t key_compare_func,
- void *buckets);
+ int bucket_bits,
+ pepper_hash_func_t hash_func,
+ pepper_key_length_func_t key_length_func,
+ pepper_key_compare_func_t key_compare_func,
+ void *buckets);
PEPPER_API void
pepper_map_int32_init(pepper_map_t *map, int bucket_bits, void *buckets);
PEPPER_API pepper_map_t *
pepper_map_create(int bucket_bits,
- pepper_hash_func_t hash_func,
- pepper_key_length_func_t key_length_func,
- pepper_key_compare_func_t key_compare_func);
+ pepper_hash_func_t hash_func,
+ pepper_key_length_func_t key_length_func,
+ pepper_key_compare_func_t key_compare_func);
PEPPER_API pepper_map_t *
pepper_map_int32_create(int bucket_bits);
PEPPER_API void
pepper_map_set(pepper_map_t *map, const void *key, void *data,
- pepper_free_func_t free_func);
+ pepper_free_func_t free_func);
typedef struct pepper_id_allocator pepper_id_allocator_t;
static inline void
pepper_mat4_multiply(pepper_mat4_t *dst, const pepper_mat4_t *ma,
- const pepper_mat4_t *mb)
+ const pepper_mat4_t *mb)
{
pepper_mat4_t tmp;
double *d = tmp.m;
static inline void
pepper_mat4_init_rotate(pepper_mat4_t *matrix, double x, double y, double z,
- double angle)
+ double angle)
{
double c;
double s;
static inline void
pepper_mat4_rotate(pepper_mat4_t *matrix, double x, double y, double z,
- double angle)
+ double angle)
{
pepper_mat4_t rotate;
double det;
if (!(src->flags & PEPPER_MATRIX_COMPLEX) &&
- !(src->flags & PEPPER_MATRIX_ROTATE)) {
+ !(src->flags & PEPPER_MATRIX_ROTATE)) {
pepper_mat4_copy(dst, src);
dst->m[12] = -m[12] / m[ 0];
}
d[ 0] = m[ 5] * m[10] * m[15] -
- m[ 5] * m[11] * m[14] -
- m[ 9] * m[ 6] * m[15] +
- m[ 9] * m[ 7] * m[14] +
- m[13] * m[ 6] * m[11] -
- m[13] * m[ 7] * m[10];
+ m[ 5] * m[11] * m[14] -
+ m[ 9] * m[ 6] * m[15] +
+ m[ 9] * m[ 7] * m[14] +
+ m[13] * m[ 6] * m[11] -
+ m[13] * m[ 7] * m[10];
d[ 4] = -m[ 4] * m[10] * m[15] +
- m[ 4] * m[11] * m[14] +
- m[ 8] * m[ 6] * m[15] -
- m[ 8] * m[ 7] * m[14] -
- m[12] * m[ 6] * m[11] +
- m[12] * m[ 7] * m[10];
+ m[ 4] * m[11] * m[14] +
+ m[ 8] * m[ 6] * m[15] -
+ m[ 8] * m[ 7] * m[14] -
+ m[12] * m[ 6] * m[11] +
+ m[12] * m[ 7] * m[10];
d[ 8] = m[ 4] * m[ 9] * m[15] -
- m[ 4] * m[11] * m[13] -
- m[ 8] * m[ 5] * m[15] +
- m[ 8] * m[ 7] * m[13] +
- m[12] * m[ 5] * m[11] -
- m[12] * m[ 7] * m[ 9];
+ m[ 4] * m[11] * m[13] -
+ m[ 8] * m[ 5] * m[15] +
+ m[ 8] * m[ 7] * m[13] +
+ m[12] * m[ 5] * m[11] -
+ m[12] * m[ 7] * m[ 9];
d[12] = -m[ 4] * m[ 9] * m[14] +
- m[ 4] * m[10] * m[13] +
- m[ 8] * m[ 5] * m[14] -
- m[ 8] * m[ 6] * m[13] -
- m[12] * m[ 5] * m[10] +
- m[12] * m[ 6] * m[ 9];
+ m[ 4] * m[10] * m[13] +
+ m[ 8] * m[ 5] * m[14] -
+ m[ 8] * m[ 6] * m[13] -
+ m[12] * m[ 5] * m[10] +
+ m[12] * m[ 6] * m[ 9];
d[ 1] = -m[ 1] * m[10] * m[15] +
- m[ 1] * m[11] * m[14] +
- m[ 9] * m[ 2] * m[15] -
- m[ 9] * m[ 3] * m[14] -
- m[13] * m[ 2] * m[11] +
- m[13] * m[ 3] * m[10];
+ m[ 1] * m[11] * m[14] +
+ m[ 9] * m[ 2] * m[15] -
+ m[ 9] * m[ 3] * m[14] -
+ m[13] * m[ 2] * m[11] +
+ m[13] * m[ 3] * m[10];
d[ 5] = m[ 0] * m[10] * m[15] -
- m[ 0] * m[11] * m[14] -
- m[ 8] * m[ 2] * m[15] +
- m[ 8] * m[ 3] * m[14] +
- m[12] * m[ 2] * m[11] -
- m[12] * m[ 3] * m[10];
+ m[ 0] * m[11] * m[14] -
+ m[ 8] * m[ 2] * m[15] +
+ m[ 8] * m[ 3] * m[14] +
+ m[12] * m[ 2] * m[11] -
+ m[12] * m[ 3] * m[10];
d[ 9] = -m[ 0] * m[ 9] * m[15] +
- m[ 0] * m[11] * m[13] +
- m[ 8] * m[ 1] * m[15] -
- m[ 8] * m[ 3] * m[13] -
- m[12] * m[ 1] * m[11] +
- m[12] * m[ 3] * m[ 9];
+ m[ 0] * m[11] * m[13] +
+ m[ 8] * m[ 1] * m[15] -
+ m[ 8] * m[ 3] * m[13] -
+ m[12] * m[ 1] * m[11] +
+ m[12] * m[ 3] * m[ 9];
d[13] = m[ 0] * m[ 9] * m[14] -
- m[ 0] * m[10] * m[13] -
- m[ 8] * m[ 1] * m[14] +
- m[ 8] * m[ 2] * m[13] +
- m[12] * m[ 1] * m[10] -
- m[12] * m[ 2] * m[ 9];
+ m[ 0] * m[10] * m[13] -
+ m[ 8] * m[ 1] * m[14] +
+ m[ 8] * m[ 2] * m[13] +
+ m[12] * m[ 1] * m[10] -
+ m[12] * m[ 2] * m[ 9];
d[ 2] = m[ 1] * m[ 6] * m[15] -
- m[ 1] * m[ 7] * m[14] -
- m[ 5] * m[ 2] * m[15] +
- m[ 5] * m[ 3] * m[14] +
- m[13] * m[ 2] * m[ 7] -
- m[13] * m[ 3] * m[ 6];
+ m[ 1] * m[ 7] * m[14] -
+ m[ 5] * m[ 2] * m[15] +
+ m[ 5] * m[ 3] * m[14] +
+ m[13] * m[ 2] * m[ 7] -
+ m[13] * m[ 3] * m[ 6];
d[ 6] = -m[ 0] * m[ 6] * m[15] +
- m[ 0] * m[ 7] * m[14] +
- m[ 4] * m[ 2] * m[15] -
- m[ 4] * m[ 3] * m[14] -
- m[12] * m[ 2] * m[ 7] +
- m[12] * m[ 3] * m[ 6];
+ m[ 0] * m[ 7] * m[14] +
+ m[ 4] * m[ 2] * m[15] -
+ m[ 4] * m[ 3] * m[14] -
+ m[12] * m[ 2] * m[ 7] +
+ m[12] * m[ 3] * m[ 6];
d[10] = m[ 0] * m[ 5] * m[15] -
- m[ 0] * m[ 7] * m[13] -
- m[ 4] * m[ 1] * m[15] +
- m[ 4] * m[ 3] * m[13] +
- m[12] * m[ 1] * m[ 7] -
- m[12] * m[ 3] * m[ 5];
+ m[ 0] * m[ 7] * m[13] -
+ m[ 4] * m[ 1] * m[15] +
+ m[ 4] * m[ 3] * m[13] +
+ m[12] * m[ 1] * m[ 7] -
+ m[12] * m[ 3] * m[ 5];
d[14] = -m[ 0] * m[ 5] * m[14] +
- m[ 0] * m[ 6] * m[13] +
- m[ 4] * m[ 1] * m[14] -
- m[ 4] * m[ 2] * m[13] -
- m[12] * m[ 1] * m[ 6] +
- m[12] * m[ 2] * m[ 5];
+ m[ 0] * m[ 6] * m[13] +
+ m[ 4] * m[ 1] * m[14] -
+ m[ 4] * m[ 2] * m[13] -
+ m[12] * m[ 1] * m[ 6] +
+ m[12] * m[ 2] * m[ 5];
d[ 3] = -m[ 1] * m[ 6] * m[11] +
- m[ 1] * m[ 7] * m[10] +
- m[ 5] * m[ 2] * m[11] -
- m[ 5] * m[ 3] * m[10] -
- m[ 9] * m[ 2] * m[ 7] +
- m[ 9] * m[ 3] * m[ 6];
+ m[ 1] * m[ 7] * m[10] +
+ m[ 5] * m[ 2] * m[11] -
+ m[ 5] * m[ 3] * m[10] -
+ m[ 9] * m[ 2] * m[ 7] +
+ m[ 9] * m[ 3] * m[ 6];
d[ 7] = m[ 0] * m[ 6] * m[11] -
- m[ 0] * m[ 7] * m[10] -
- m[ 4] * m[ 2] * m[11] +
- m[ 4] * m[ 3] * m[10] +
- m[ 8] * m[ 2] * m[ 7] -
- m[ 8] * m[ 3] * m[ 6];
+ m[ 0] * m[ 7] * m[10] -
+ m[ 4] * m[ 2] * m[11] +
+ m[ 4] * m[ 3] * m[10] +
+ m[ 8] * m[ 2] * m[ 7] -
+ m[ 8] * m[ 3] * m[ 6];
d[11] = -m[ 0] * m[ 5] * m[11] +
- m[ 0] * m[ 7] * m[ 9] +
- m[ 4] * m[ 1] * m[11] -
- m[ 4] * m[ 3] * m[ 9] -
- m[ 8] * m[ 1] * m[ 7] +
- m[ 8] * m[ 3] * m[ 5];
+ m[ 0] * m[ 7] * m[ 9] +
+ m[ 4] * m[ 1] * m[11] -
+ m[ 4] * m[ 3] * m[ 9] -
+ m[ 8] * m[ 1] * m[ 7] +
+ m[ 8] * m[ 3] * m[ 5];
d[15] = m[ 0] * m[ 5] * m[10] -
- m[ 0] * m[ 6] * m[ 9] -
- m[ 4] * m[ 1] * m[10] +
- m[ 4] * m[ 2] * m[ 9] +
- m[ 8] * m[ 1] * m[ 6] -
- m[ 8] * m[ 2] * m[ 5];
+ m[ 0] * m[ 6] * m[ 9] -
+ m[ 4] * m[ 1] * m[10] +
+ m[ 4] * m[ 2] * m[ 9] +
+ m[ 8] * m[ 1] * m[ 6] -
+ m[ 8] * m[ 2] * m[ 5];
det = m[0] * d[0] + m[1] * d[4] + m[2] * d[8] + m[3] * d[12];
* @param data data passed when adding the event listener.
*/
typedef void (*pepper_event_callback_t)(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id, void *info, void *data);
+ pepper_object_t *object,
+ uint32_t id, void *info, void *data);
/**
* @typedef pepper_input_event_t
PEPPER_API void
pepper_object_set_user_data(pepper_object_t *object, const void *key,
- void *data,
- pepper_free_func_t free_func);
+ void *data,
+ pepper_free_func_t free_func);
PEPPER_API void *
pepper_object_get_user_data(pepper_object_t *object, const void *key);
PEPPER_API pepper_event_listener_t *
pepper_object_add_event_listener(pepper_object_t *object, uint32_t id,
- int priority,
- pepper_event_callback_t callback, void *data);
+ int priority,
+ pepper_event_callback_t callback, void *data);
PEPPER_API void
pepper_event_listener_remove(pepper_event_listener_t *listener);
PEPPER_API void
pepper_event_listener_set_priority(pepper_event_listener_t *listener,
- int priority);
+ int priority);
PEPPER_API void
pepper_object_emit_event(pepper_object_t *object, uint32_t id, void *info);
PEPPER_API pepper_view_t *
pepper_compositor_pick_view(pepper_compositor_t *compositor,
- double x, double y, double *vx, double *vy);
+ double x, double y, double *vx, double *vy);
PEPPER_API pepper_bool_t
pepper_compositor_set_clock_id(pepper_compositor_t *compositor, clockid_t id);
PEPPER_API pepper_bool_t
pepper_compositor_get_time(pepper_compositor_t *compositor,
- struct timespec *ts);
+ struct timespec *ts);
PEPPER_API void
pepper_output_destroy(pepper_output_t *output);
PEPPER_API void
pepper_output_get_mode(pepper_output_t *output, int index,
- pepper_output_mode_t *mode);
+ pepper_output_mode_t *mode);
PEPPER_API const pepper_output_mode_t *
pepper_output_get_current_mode(pepper_output_t *output);
PEPPER_API pepper_bool_t
pepper_output_set_mode(pepper_output_t *output,
- const pepper_output_mode_t *mode);
+ const pepper_output_mode_t *mode);
PEPPER_API const char *
pepper_output_get_name(pepper_output_t *output);
PEPPER_API pepper_output_t *
pepper_compositor_find_output(pepper_compositor_t *compositor,
- const char *name);
+ const char *name);
PEPPER_API pepper_seat_t *
pepper_compositor_add_seat(pepper_compositor_t *compositor,
- const char *seat_name);
+ const char *seat_name);
PEPPER_API void
pepper_seat_destroy(pepper_seat_t *seat);
PEPPER_API void
pepper_seat_add_input_device(pepper_seat_t *seat,
- pepper_input_device_t *device);
+ pepper_input_device_t *device);
PEPPER_API void
pepper_seat_remove_input_device(pepper_seat_t *seat,
- pepper_input_device_t *device);
+ pepper_input_device_t *device);
PEPPER_API const char *
pepper_input_device_get_property(pepper_input_device_t *device,
- const char *key);
+ const char *key);
PEPPER_API pepper_compositor_t *
pepper_input_device_get_compositor(pepper_input_device_t *device);
* @param x movement in y direction on global space
**/
void (*motion)(pepper_pointer_t *pointer, void *data, uint32_t time, double x,
- double y);
+ double y);
/**
* Handler for pointer button event
* @param state button state (@see pepper_button_state)
**/
void (*button)(pepper_pointer_t *pointer, void *data, uint32_t time,
- uint32_t button,
- uint32_t state);
+ uint32_t button,
+ uint32_t state);
/**
* Handler for pointer axis event
* @param value amount of axis movement
**/
void (*axis)(pepper_pointer_t *pointer, void *data, uint32_t time,
- uint32_t axis, double value);
+ uint32_t axis, double value);
/**
* Handler for the grab cancel
PEPPER_API pepper_bool_t
pepper_pointer_set_clamp(pepper_pointer_t *pointer, double x0, double y0,
- double x1, double y1);
+ double x1, double y1);
PEPPER_API void
pepper_pointer_get_clamp(pepper_pointer_t *pointer, double *x0, double *y0,
- double *x1, double *y1);
+ double *x1, double *y1);
PEPPER_API void
pepper_pointer_set_velocity(pepper_pointer_t *pointer, double vx, double vy);
PEPPER_API void
pepper_pointer_send_enter(pepper_pointer_t *pointer, pepper_view_t *view,
- double x, double y);
+ double x, double y);
PEPPER_API void
pepper_pointer_send_motion(pepper_pointer_t *pointer, pepper_view_t *view,
- uint32_t time, double x, double y);
+ uint32_t time, double x, double y);
PEPPER_API void
pepper_pointer_send_button(pepper_pointer_t *pointer, pepper_view_t *view,
- uint32_t time, uint32_t button, uint32_t state);
+ uint32_t time, uint32_t button, uint32_t state);
PEPPER_API void
pepper_pointer_send_axis(pepper_pointer_t *pointer, pepper_view_t *view,
- uint32_t time, uint32_t axis, double value);
+ uint32_t time, uint32_t axis, double value);
PEPPER_API void
pepper_pointer_set_grab(pepper_pointer_t *pointer,
- const pepper_pointer_grab_t *grab, void *data);
+ const pepper_pointer_grab_t *grab, void *data);
PEPPER_API const pepper_pointer_grab_t *
pepper_pointer_get_grab(pepper_pointer_t *pointer);
* @param state state flag (ex. WL_KEYBOARD_KEY_STATE_PRESSED)
**/
void (*key)(pepper_keyboard_t *keyboard, void *data, uint32_t time,
- uint32_t key,
- uint32_t state);
+ uint32_t key,
+ uint32_t state);
/**
* Handler for keyboard modifier event
* @param group (none)
**/
void (*modifiers)(pepper_keyboard_t *keyboard, void *data,
- uint32_t mods_depressed,
- uint32_t mods_latched, uint32_t mods_locked, uint32_t group);
+ uint32_t mods_depressed,
+ uint32_t mods_latched, uint32_t mods_locked, uint32_t group);
/**
* Handler for grab cancel
PEPPER_API void
pepper_keyboard_send_key(pepper_keyboard_t *keyboard, pepper_view_t *view,
- uint32_t time, uint32_t key, uint32_t state);
+ uint32_t time, uint32_t key, uint32_t state);
PEPPER_API void
pepper_keyboard_send_modifiers(pepper_keyboard_t *keyboard, pepper_view_t *view,
- uint32_t depressed, uint32_t latched,
- uint32_t locked, uint32_t group);
+ uint32_t depressed, uint32_t latched,
+ uint32_t locked, uint32_t group);
PEPPER_API void
pepper_keyboard_set_grab(pepper_keyboard_t *keyboard,
- const pepper_keyboard_grab_t *grab, void *data);
+ const pepper_keyboard_grab_t *grab, void *data);
PEPPER_API const pepper_keyboard_grab_t *
pepper_keyboard_get_grab(pepper_keyboard_t *keyboard);
PEPPER_API void
pepper_keyboard_set_keymap(pepper_keyboard_t *keyboard,
- struct xkb_keymap *keymap);
+ struct xkb_keymap *keymap);
/* Touch. */
struct pepper_touch_grab {
void (*down)(pepper_touch_t *touch, void *data, uint32_t time, int32_t id,
- double x, double y);
+ double x, double y);
void (*up)(pepper_touch_t *touch, void *data, uint32_t time, uint32_t id);
void (*motion)(pepper_touch_t *touch, void *data,
- uint32_t time, uint32_t id, double x, double y);
+ uint32_t time, uint32_t id, double x, double y);
void (*frame)(pepper_touch_t *touch, void *data);
void (*cancel)(pepper_touch_t *touch, void *data);
};
PEPPER_API void
pepper_touch_set_focus(pepper_touch_t *touch, uint32_t id,
- pepper_view_t *focus);
+ pepper_view_t *focus);
PEPPER_API pepper_view_t *
pepper_touch_get_focus(pepper_touch_t *touch, uint32_t id);
PEPPER_API pepper_bool_t
pepper_touch_get_position(pepper_touch_t *touch, uint32_t id, double *x,
- double *y);
+ double *y);
PEPPER_API pepper_bool_t
pepper_touch_set_position(pepper_touch_t *touch, uint32_t id, double x,
- double y);
+ double y);
PEPPER_API void
pepper_touch_send_down(pepper_touch_t *touch, pepper_view_t *view,
- uint32_t time, uint32_t id, double x, double y);
+ uint32_t time, uint32_t id, double x, double y);
PEPPER_API void
pepper_touch_send_up(pepper_touch_t *touch, pepper_view_t *view, uint32_t time,
- uint32_t id);
+ uint32_t id);
PEPPER_API void
pepper_touch_send_motion(pepper_touch_t *touch, pepper_view_t *view,
- uint32_t time, uint32_t id, double x, double y);
+ uint32_t time, uint32_t id, double x, double y);
PEPPER_API void
pepper_touch_send_frame(pepper_touch_t *touch, pepper_view_t *view);
PEPPER_API void
pepper_touch_set_grab(pepper_touch_t *touch, const pepper_touch_grab_t *grab,
- void *data);
+ void *data);
PEPPER_API const pepper_touch_grab_t *
pepper_touch_get_grab(pepper_touch_t *touch);
PEPPER_API void
pepper_surface_get_buffer_offset(pepper_surface_t *surface, int32_t *x,
- int32_t *y);
+ int32_t *y);
PEPPER_API int32_t
pepper_surface_get_buffer_scale(pepper_surface_t *surface);
PEPPER_API pepper_bool_t
pepper_view_stack_above(pepper_view_t *view, pepper_view_t *below,
- pepper_bool_t subtree);
+ pepper_bool_t subtree);
PEPPER_API pepper_bool_t
pepper_view_stack_below(pepper_view_t *view, pepper_view_t *above,
- pepper_bool_t subtree);
+ pepper_bool_t subtree);
PEPPER_API void
pepper_view_stack_top(pepper_view_t *view, pepper_bool_t subtree);
PEPPER_API void
pepper_view_get_local_coordinate(pepper_view_t *view, double gx, double gy,
- double *lx, double *ly);
+ double *lx, double *ly);
PEPPER_API void
pepper_view_get_global_coordinate(pepper_view_t *view, double lx, double ly,
- double *gx, double *gy);
+ double *gx, double *gy);
/* Misc */
PEPPER_API void
pepper_pixman_region_global_to_output(pixman_region32_t *region,
- pepper_output_t *output);
+ pepper_output_t *output);
PEPPER_API void
pepper_coordinates_surface_to_buffer(pepper_surface_t *surface,
- double sx, double sy, double *bx, double *by);
+ double sx, double sy, double *bx, double *by);
#ifdef __cplusplus
}
void
pepper_plane_update(pepper_plane_t *plane, const pepper_list_t *view_list,
- pixman_region32_t *clip)
+ pixman_region32_t *clip)
{
int x = plane->output->geometry.x;
int y = plane->output->geometry.y;
/* Calculate visible region (output space). */
pixman_region32_subtract(&entry->base.visible_region,
- &view->bounding_region, &plane_clip);
+ &view->bounding_region, &plane_clip);
pixman_region32_intersect_rect(&entry->base.visible_region,
- &entry->base.visible_region, x, y, w, h);
+ &entry->base.visible_region, x, y, w, h);
pepper_pixman_region_global_to_output(&entry->base.visible_region,
- plane->output);
+ plane->output);
/* Accumulate opaque region of this view (global space). */
pixman_region32_union(&plane_clip, &plane_clip, &view->opaque_region);
pepper_plane_t *plane;
PEPPER_CHECK(!above ||
- above->output == output, return NULL, "Output mismatch.\n");
+ above->output == output, return NULL, "Output mismatch.\n");
plane = (pepper_plane_t *)pepper_object_alloc(PEPPER_OBJECT_PLANE,
sizeof(pepper_plane_t));
{
if (!damage) {
pixman_region32_union_rect(&plane->damage_region, &plane->damage_region,
- 0, 0, plane->output->geometry.w, plane->output->geometry.h);
+ 0, 0, plane->output->geometry.w, plane->output->geometry.h);
pepper_output_schedule_repaint(plane->output);
} else if (pixman_region32_not_empty(damage)) {
pixman_region32_union(&plane->damage_region, &plane->damage_region, damage);
*/
PEPPER_API void
pepper_plane_subtract_damage_region(pepper_plane_t *plane,
- pixman_region32_t *damage)
+ pixman_region32_t *damage)
{
pixman_region32_subtract(&plane->damage_region, &plane->damage_region, damage);
}
static void
pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
- uint32_t serial,
- struct wl_resource *surface_resource, int32_t x, int32_t y)
+ uint32_t serial,
+ struct wl_resource *surface_resource, int32_t x, int32_t y)
{
pepper_pointer_t *pointer = (pepper_pointer_t *)wl_resource_get_user_data(
- resource);
+ resource);
pepper_surface_t *surface;
pepper_view_t *cursor_view;
static void
pointer_set_position(pepper_pointer_t *pointer, uint32_t time, double x,
- double y)
+ double y)
{
pepper_input_event_t event;
if (pointer->cursor_view)
pepper_view_set_position(pointer->cursor_view,
- x - pointer->hotspot_x, y - pointer->hotspot_y);
+ x - pointer->hotspot_x, y - pointer->hotspot_y);
if (pointer->grab)
pointer->grab->motion(pointer, pointer->data, time, pointer->x, pointer->y);
void
pepper_pointer_handle_event(pepper_pointer_t *pointer, uint32_t id,
- pepper_input_event_t *event)
+ pepper_input_event_t *event)
{
pointer->time = event->time;
break;
case PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION: {
pointer_set_position(pointer, event->time,
- pointer->x + event->x * pointer->x_velocity,
- pointer->y + event->y * pointer->y_velocity);
+ pointer->x + event->x * pointer->x_velocity,
+ pointer->y + event->y * pointer->y_velocity);
}
break;
case PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON: {
if (pointer->grab) {
pointer->grab->button(pointer, pointer->data,
- event->time, event->button, event->state);
+ event->time, event->button, event->state);
}
pepper_object_emit_event(&pointer->base, PEPPER_EVENT_POINTER_BUTTON, event);
case PEPPER_EVENT_INPUT_DEVICE_POINTER_AXIS: {
if (pointer->grab)
pointer->grab->axis(pointer, pointer->data, event->time, event->axis,
- event->value);
+ event->value);
pepper_object_emit_event(&pointer->base, PEPPER_EVENT_POINTER_AXIS, event);
}
static void
pointer_handle_focus_destroy(pepper_event_listener_t *listener,
- pepper_object_t *surface,
- uint32_t id, void *info, void *data)
+ pepper_object_t *surface,
+ uint32_t id, void *info, void *data)
{
pepper_pointer_t *pointer = data;
pepper_pointer_set_focus(pointer, NULL);
void
pepper_pointer_bind_resource(struct wl_client *client,
- struct wl_resource *resource, uint32_t id)
+ struct wl_resource *resource, uint32_t id)
{
pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource);
pepper_pointer_t *pointer = seat->pointer;
return;
res = wl_resource_create(client, &wl_pointer_interface,
- wl_resource_get_version(resource), id);
+ wl_resource_get_version(resource), id);
if (!res) {
wl_client_post_no_memory(client);
return;
wl_resource_set_implementation(res, &pointer_impl, pointer, unbind_resource);
if (!pointer->focus || !pointer->focus->surface ||
- !pointer->focus->surface->resource)
+ !pointer->focus->surface->resource)
return;
if (wl_resource_get_client(pointer->focus->surface->resource) == client) {
wl_pointer_send_enter(res, pointer->focus_serial,
- pointer->focus->surface->resource,
- wl_fixed_from_double(pointer->vx), wl_fixed_from_double(pointer->vy));
+ pointer->focus->surface->resource,
+ wl_fixed_from_double(pointer->vx), wl_fixed_from_double(pointer->vy));
}
}
*/
PEPPER_API pepper_bool_t
pepper_pointer_set_clamp(pepper_pointer_t *pointer, double x0, double y0,
- double x1, double y1)
+ double x1, double y1)
{
if (x1 < x0 || y1 < y0)
return PEPPER_FALSE;
if (pointer->grab)
pointer->grab->motion(pointer, pointer->data, pointer->time, pointer->x,
- pointer->y);
+ pointer->y);
memset(&event, 0x00, sizeof(pepper_input_event_t));
*/
PEPPER_API void
pepper_pointer_get_clamp(pepper_pointer_t *pointer, double *x0, double *y0,
- double *x1, double *y1)
+ double *x1, double *y1)
{
if (x0)
*x0 = pointer->clamp.x0;
if (pointer->focus) {
pepper_event_listener_remove(pointer->focus_destroy_listener);
pepper_object_emit_event(&pointer->base, PEPPER_EVENT_FOCUS_LEAVE,
- pointer->focus);
+ pointer->focus);
pepper_object_emit_event(&pointer->focus->base, PEPPER_EVENT_FOCUS_LEAVE,
- pointer);
+ pointer);
}
pointer->focus = focus;
if (focus) {
pointer->focus_serial = wl_display_next_serial(
- pointer->seat->compositor->display);
+ pointer->seat->compositor->display);
pointer->focus_destroy_listener =
pepper_object_add_event_listener(&focus->base, PEPPER_EVENT_OBJECT_DESTROY, 0,
- pointer_handle_focus_destroy, pointer);
+ pointer_handle_focus_destroy, pointer);
pepper_object_emit_event(&pointer->base, PEPPER_EVENT_FOCUS_ENTER, focus);
pepper_object_emit_event(&focus->base, PEPPER_EVENT_FOCUS_ENTER, pointer);
*/
PEPPER_API void
pepper_pointer_send_enter(pepper_pointer_t *pointer, pepper_view_t *view,
- double x, double y)
+ double x, double y)
{
struct wl_resource *resource;
wl_fixed_t fx = wl_fixed_from_double(x);
*/
PEPPER_API void
pepper_pointer_send_motion(pepper_pointer_t *pointer, pepper_view_t *view,
- uint32_t time, double x, double y)
+ uint32_t time, double x, double y)
{
struct wl_resource *resource;
wl_fixed_t fx = wl_fixed_from_double(x);
*/
PEPPER_API void
pepper_pointer_send_button(pepper_pointer_t *pointer, pepper_view_t *view,
- uint32_t time, uint32_t button, uint32_t state)
+ uint32_t time, uint32_t button, uint32_t state)
{
struct wl_resource *resource;
struct wl_client *client;
*/
PEPPER_API void
pepper_pointer_send_axis(pepper_pointer_t *pointer, pepper_view_t *view,
- uint32_t time, uint32_t axis, double value)
+ uint32_t time, uint32_t axis, double value)
{
struct wl_resource *resource;
wl_fixed_t v = wl_fixed_from_double(value);
*/
PEPPER_API void
pepper_pointer_set_grab(pepper_pointer_t *pointer,
- const pepper_pointer_grab_t *grab, void *data)
+ const pepper_pointer_grab_t *grab, void *data)
{
pointer->grab = grab;
pointer->data = data;
static void
region_add(struct wl_client *client, struct wl_resource *resource,
- int32_t x, int32_t y, int32_t w, int32_t h)
+ int32_t x, int32_t y, int32_t w, int32_t h)
{
pepper_region_t *region = wl_resource_get_user_data(resource);
pixman_region32_union_rect(®ion->pixman_region, ®ion->pixman_region,
- x, y, w, h);
+ x, y, w, h);
}
static void
region_subtract(struct wl_client *client, struct wl_resource *resource,
- int32_t x, int32_t y, int32_t w, int32_t h)
+ int32_t x, int32_t y, int32_t w, int32_t h)
{
pepper_region_t *region = wl_resource_get_user_data(resource);
pixman_region32_t rect;
pepper_region_t *
pepper_region_create(pepper_compositor_t *compositor,
- struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id)
+ struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id)
{
pepper_region_t *region = calloc(1, sizeof(pepper_region_t));
PEPPER_CHECK(region, return NULL, "calloc(0 failed.\n");
region->compositor = compositor;
wl_resource_set_implementation(region->resource, ®ion_implementation,
- region, region_resource_destroy_handler);
+ region, region_resource_destroy_handler);
region->link.item = region;
pepper_list_insert(&compositor->region_list, ®ion->link);
void
pepper_transform_pixman_region(pixman_region32_t *region,
- const pepper_mat4_t *matrix)
+ const pepper_mat4_t *matrix)
{
pixman_region32_t result;
transform_bounding_box(&box, matrix);
pixman_region32_union_rect(&result, &result,
- box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
+ box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
}
pixman_region32_copy(region, &result);
static void
subcompositor_get_subsurface(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id,
- struct wl_resource *surface_resource,
- struct wl_resource *parent_resource)
+ struct wl_resource *resource,
+ uint32_t id,
+ struct wl_resource *surface_resource,
+ struct wl_resource *parent_resource)
{
pepper_surface_t *surface = wl_resource_get_user_data(surface_resource);
pepper_surface_t *parent = wl_resource_get_user_data(parent_resource);
if (surface->sub) {
wl_resource_post_error(resource, WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
- "wl_subcompositor::get_subsurface() already requested");
+ "wl_subcompositor::get_subsurface() already requested");
return ;
}
if (surface == parent) {
wl_resource_post_error(resource, WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
- "wl_subcompositor::get_subsurface() cannot assign parent for its own");
+ "wl_subcompositor::get_subsurface() cannot assign parent for its own");
return ;
}
static void
subcompositor_bind(struct wl_client *client,
- void *data,
- uint32_t version,
- uint32_t id)
+ void *data,
+ uint32_t version,
+ uint32_t id)
{
pepper_subcompositor_t *subcompositor = (pepper_subcompositor_t *)data;
struct wl_resource *resource;
wl_list_insert(&subcompositor->resource_list, wl_resource_get_link(resource));
wl_resource_set_implementation(resource, &subcompositor_interface,
- subcompositor, unbind_resource);
+ subcompositor, unbind_resource);
}
pepper_subcompositor_t *
pepper_subcompositor_t *subcompositor;
subcompositor = (pepper_subcompositor_t *)pepper_object_alloc(
- PEPPER_OBJECT_SUBCOMPOSITOR,
- sizeof(pepper_subcompositor_t));
+ PEPPER_OBJECT_SUBCOMPOSITOR,
+ sizeof(pepper_subcompositor_t));
PEPPER_CHECK(subcompositor, goto error, "pepper_object_alloc() failed.\n");
subcompositor->compositor = compositor;
subcompositor->global = wl_global_create(compositor->display,
- &wl_subcompositor_interface, 1,
- subcompositor, subcompositor_bind);
+ &wl_subcompositor_interface, 1,
+ subcompositor, subcompositor_bind);
PEPPER_CHECK(subcompositor->global, goto error, "wl_global_create() failed.\n");
wl_list_init(&subcompositor->resource_list);
static void
subsurface_destroy(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
wl_resource_destroy(resource);
}
static void
subsurface_set_position(struct wl_client *client,
- struct wl_resource *resource,
- int32_t x,
- int32_t y)
+ struct wl_resource *resource,
+ int32_t x,
+ int32_t y)
{
pepper_subsurface_t *subsurface = wl_resource_get_user_data(resource);
static void
subsurface_stack_above(pepper_subsurface_t *subsurface,
- pepper_subsurface_t *sibling)
+ pepper_subsurface_t *sibling)
{
pepper_subsurface_t *parent;
pepper_list_t *pos;
static void
subsurface_place_above(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *sibling_resource)
+ struct wl_resource *resource,
+ struct wl_resource *sibling_resource)
{
pepper_subsurface_t *sub = wl_resource_get_user_data(resource);
pepper_surface_t *sibling;
if (!sibling_resource) {
wl_resource_post_error(resource, WL_SUBSURFACE_ERROR_BAD_SURFACE,
- "reference surface cannot be null");
+ "reference surface cannot be null");
return ;
}
if (sub->surface == sibling) {
wl_resource_post_error(resource, WL_SUBSURFACE_ERROR_BAD_SURFACE,
- "cannot place above of its own for itself");
+ "cannot place above of its own for itself");
return ;
}
if (!subsurface_is_sibling(sub, sibling)) {
wl_resource_post_error(resource, WL_SUBSURFACE_ERROR_BAD_SURFACE,
- "reference surface is not sibling");
+ "reference surface is not sibling");
return ;
}
static void
subsurface_stack_below(pepper_subsurface_t *subsurface,
- pepper_subsurface_t *sibling)
+ pepper_subsurface_t *sibling)
{
pepper_subsurface_t *parent;
pepper_list_t *pos;
static void
subsurface_place_below(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *sibling_resource)
+ struct wl_resource *resource,
+ struct wl_resource *sibling_resource)
{
pepper_subsurface_t *sub = wl_resource_get_user_data(resource);
pepper_surface_t *sibling;
if (!sibling_resource) {
wl_resource_post_error(resource, WL_SUBSURFACE_ERROR_BAD_SURFACE,
- "reference surface cannot be null");
+ "reference surface cannot be null");
return ;
}
if (sub->surface == sibling) {
wl_resource_post_error(resource, WL_SUBSURFACE_ERROR_BAD_SURFACE,
- "cannot place below of its own for itself");
+ "cannot place below of its own for itself");
return ;
}
if (!subsurface_is_sibling(sub, sibling)) {
wl_resource_post_error(resource, WL_SUBSURFACE_ERROR_BAD_SURFACE,
- "reference surface is not sibling");
+ "reference surface is not sibling");
return ;
}
static void
subsurface_set_sync(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
pepper_subsurface_t *subsurface = wl_resource_get_user_data(resource);
/* Subsurface emit commit event in here */
pepper_object_emit_event(&subsurface->surface->base,
- PEPPER_EVENT_SURFACE_COMMIT, NULL);
+ PEPPER_EVENT_SURFACE_COMMIT, NULL);
}
static pepper_bool_t
}
EACH_LIST_FOR_EACH(view1, &child1->surface->view_list,
- view2, &child2->surface->view_list,
- surface_link) {
+ view2, &child2->surface->view_list,
+ surface_link) {
pepper_view_stack_above(view1, view2, PEPPER_TRUE);
}
static void
subsurface_set_desync(struct wl_client *client,
- struct wl_resource *resource)
+ struct wl_resource *resource)
{
pepper_subsurface_t *subsurface = wl_resource_get_user_data(resource);
static void
handle_parent_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id, void *info, void *data)
+ pepper_object_t *object, uint32_t id, void *info, void *data)
{
pepper_subsurface_t *subsurface = data;
static void
handle_parent_commit(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id, void *info, void *data)
+ pepper_object_t *object, uint32_t id, void *info, void *data)
{
pepper_subsurface_t *subsurface = data;
pepper_list_for_each(parent_view, &parent->view_list, surface_link) {
pepper_view_t *subview = pepper_compositor_add_view(parent->compositor);
PEPPER_CHECK(subview, return PEPPER_FALSE,
- "pepper_compositor_add_view() failed.\n");
+ "pepper_compositor_add_view() failed.\n");
pepper_view_set_surface(subview, subsurface->surface);
pepper_view_set_parent(subview, parent_view);
pepper_list_init(&subsurface->pending.children_list);
pepper_list_insert(&subsurface->pending.children_list,
- &subsurface->pending.self_link);
+ &subsurface->pending.self_link);
return subsurface;
}
pepper_subsurface_t *
pepper_subsurface_create(pepper_surface_t *surface,
- pepper_surface_t *parent,
- struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id)
+ pepper_surface_t *parent,
+ struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id)
{
pepper_subsurface_t *subsurface = NULL;
pepper_bool_t ret;
if (!pepper_surface_set_role(surface, "wl_subsurface")) {
wl_resource_post_error(resource, WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
- "cannot assign wl_subsurface role");
+ "cannot assign wl_subsurface role");
return NULL;
}
PEPPER_CHECK(subsurface, goto error, "calloc() failed.\n");
subsurface->resource = wl_resource_create(client, &wl_subsurface_interface,
- wl_resource_get_version(resource), id);
+ wl_resource_get_version(resource), id);
PEPPER_CHECK(subsurface->resource, goto error, "wl_resource_create() failed\n");
wl_resource_set_implementation(subsurface->resource, &subsurface_implementation,
- subsurface,
- subsurface_resource_destroy_handler);
+ subsurface,
+ subsurface_resource_destroy_handler);
subsurface->surface = surface;
subsurface->parent = parent;
subsurface->parent_destroy_listener =
pepper_object_add_event_listener(&parent->base, PEPPER_EVENT_OBJECT_DESTROY, 0,
- handle_parent_destroy, subsurface);
+ handle_parent_destroy, subsurface);
subsurface->parent_commit_listener =
pepper_object_add_event_listener(&parent->base, PEPPER_EVENT_SURFACE_COMMIT, 0,
- handle_parent_commit, subsurface);
+ handle_parent_commit, subsurface);
pepper_surface_state_init(&subsurface->cache);
if (!parent->sub)
parent->sub = pepper_dummy_subsurface_create_for_parent(parent);
PEPPER_CHECK(parent->sub, goto error,
- "pepper_dummy_subsurface_create_for_parent() failed\n");
+ "pepper_dummy_subsurface_create_for_parent() failed\n");
/* children_list is z-order sorted, youngest child is top-most */
pepper_list_init(&subsurface->children_list);
/* link to myself */
pepper_list_insert(&subsurface->children_list, &subsurface->self_link);
pepper_list_insert(&subsurface->pending.children_list,
- &subsurface->pending.self_link);
+ &subsurface->pending.self_link);
/* link to parent */
pepper_list_insert(&parent->sub->children_list, &subsurface->parent_link);
pepper_list_insert(&parent->sub->pending.children_list,
- &subsurface->pending.parent_link);
+ &subsurface->pending.parent_link);
/* create views that corresponding to parent's views */
ret = pepper_subsurface_create_views(subsurface);
void
subsurface_destroy_children_views(pepper_subsurface_t *subsurface,
- pepper_view_t *parent_view)
+ pepper_view_t *parent_view)
{
pepper_list_t *list;
void
subsurface_create_children_views(pepper_subsurface_t *subsurface,
- pepper_view_t *parent_view)
+ pepper_view_t *parent_view)
{
pepper_list_t *list;
/* Except its own */
if (child && (child != subsurface)) {
pepper_view_t *view = pepper_compositor_add_view(
- subsurface->surface->compositor);
+ subsurface->surface->compositor);
pepper_view_set_surface(view, child->surface);
pepper_view_set_parent(view, parent_view);
pepper_view_set_transform_inherit(view, PEPPER_TRUE);
static void
surface_state_handle_buffer_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id, void *info, void *data)
+ pepper_object_t *object, uint32_t id, void *info, void *data)
{
pepper_surface_state_t *state = data;
state->buffer = NULL;
static void
surface_handle_buffer_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object, uint32_t id, void *info, void *data)
+ pepper_object_t *object, uint32_t id, void *info, void *data)
{
pepper_surface_t *surface = data;
surface->buffer.buffer = NULL;
pixman_region32_init(&state->damage_region);
pixman_region32_init(&state->opaque_region);
pixman_region32_init_rect(&state->input_region, INT32_MIN, INT32_MIN,
- UINT32_MAX, UINT32_MAX);
+ UINT32_MAX, UINT32_MAX);
wl_list_init(&state->frame_callback_list);
}
static void
surface_attach(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *buffer_resource,
- int32_t x,
- int32_t y)
+ struct wl_resource *resource,
+ struct wl_resource *buffer_resource,
+ int32_t x,
+ int32_t y)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
pepper_buffer_t *buffer = NULL;
if (buffer) {
surface->pending.buffer_destroy_listener =
pepper_object_add_event_listener(&buffer->base, PEPPER_EVENT_OBJECT_DESTROY, 0,
- surface_state_handle_buffer_destroy, &surface->pending);
+ surface_state_handle_buffer_destroy, &surface->pending);
}
}
static void
surface_damage(struct wl_client *client,
- struct wl_resource *resource,
- int32_t x,
- int32_t y,
- int32_t w,
- int32_t h)
+ struct wl_resource *resource,
+ int32_t x,
+ int32_t y,
+ int32_t w,
+ int32_t h)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
pixman_region32_union_rect(&surface->pending.damage_region,
- &surface->pending.damage_region, x, y, w, h);
+ &surface->pending.damage_region, x, y, w, h);
}
static void
static void
surface_frame(struct wl_client *client,
- struct wl_resource *resource,
- uint32_t callback_id)
+ struct wl_resource *resource,
+ uint32_t callback_id)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
struct wl_resource *callback;
}
wl_resource_set_implementation(callback, NULL, NULL,
- frame_callback_resource_destroy_handler);
+ frame_callback_resource_destroy_handler);
wl_list_insert(surface->pending.frame_callback_list.prev,
- wl_resource_get_link(callback));
+ wl_resource_get_link(callback));
}
static void
surface_set_opaque_region(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *region_resource)
+ struct wl_resource *resource,
+ struct wl_resource *region_resource)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
static void
surface_set_input_region(struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *region_resource)
+ struct wl_resource *resource,
+ struct wl_resource *region_resource)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
pixman_region32_copy(&surface->pending.input_region, ®ion->pixman_region);
} else {
pixman_region32_init_rect(&surface->pending.input_region,
- INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX);
+ INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX);
}
}
static void
surface_set_buffer_transform(struct wl_client *client,
- struct wl_resource *resource,
- int transform)
+ struct wl_resource *resource,
+ int transform)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
if (transform < 0 || transform > WL_OUTPUT_TRANSFORM_FLIPPED_270) {
wl_resource_post_error(resource, WL_SURFACE_ERROR_INVALID_TRANSFORM,
- "Invalid transform value : %d", transform);
+ "Invalid transform value : %d", transform);
return;
}
static void
surface_set_buffer_scale(struct wl_client *client,
- struct wl_resource *resource,
- int32_t scale)
+ struct wl_resource *resource,
+ int32_t scale)
{
pepper_surface_t *surface = wl_resource_get_user_data(resource);
if (scale < 1) {
wl_resource_post_error(resource, WL_SURFACE_ERROR_INVALID_SCALE,
- "Invalid scale value (should be >= 1): %d", scale);
+ "Invalid scale value (should be >= 1): %d", scale);
return;
}
pepper_surface_t *
pepper_surface_create(pepper_compositor_t *compositor,
- struct wl_client *client,
- struct wl_resource *resource,
- uint32_t id)
+ struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id)
{
pepper_surface_t *surface = (pepper_surface_t *)pepper_object_alloc(
- PEPPER_OBJECT_SURFACE,
- sizeof(pepper_surface_t));
+ PEPPER_OBJECT_SURFACE,
+ sizeof(pepper_surface_t));
PEPPER_CHECK(surface, goto error, "pepper_object_alloc() failed.\n");
surface->compositor = compositor;
surface->resource = wl_resource_create(client, &wl_surface_interface,
- wl_resource_get_version(resource), id);
+ wl_resource_get_version(resource), id);
PEPPER_CHECK(surface->resource, goto error, "wl_resource_create() failed\n");
wl_resource_set_implementation(surface->resource, &surface_implementation,
- surface,
- surface_resource_destroy_handler);
+ surface,
+ surface_resource_destroy_handler);
surface->link.item = surface;
pepper_list_insert(&compositor->surface_list, &surface->link);
pixman_region32_init(&surface->damage_region);
pixman_region32_init(&surface->opaque_region);
pixman_region32_init_rect(&surface->input_region, INT32_MIN, INT32_MIN,
- UINT32_MAX, UINT32_MAX);
+ UINT32_MAX, UINT32_MAX);
surface->pickable = PEPPER_TRUE;
wl_list_init(&surface->frame_callback_list);
pepper_list_init(&surface->view_list);
pepper_object_emit_event(&compositor->base, PEPPER_EVENT_COMPOSITOR_SURFACE_ADD,
- surface);
+ surface);
return surface;
pepper_view_t *view, *nv;
pepper_object_emit_event(&surface->compositor->base,
- PEPPER_EVENT_COMPOSITOR_SURFACE_REMOVE, surface);
+ PEPPER_EVENT_COMPOSITOR_SURFACE_REMOVE, surface);
pepper_surface_state_fini(&surface->pending);
pepper_object_fini(&surface->base);
void
pepper_surface_commit_state(pepper_surface_t *surface,
- pepper_surface_state_t *state)
+ pepper_surface_state_t *state)
{
pepper_view_t *view;
surface->buffer.destroy_listener =
pepper_object_add_event_listener(&state->buffer->base,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- surface_handle_buffer_destroy, surface);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ surface_handle_buffer_destroy, surface);
}
surface->buffer.buffer = state->buffer;
void
pepper_surface_send_frame_callback_done(pepper_surface_t *surface,
- uint32_t time)
+ uint32_t time)
{
struct wl_resource *callback, *next;
*/
PEPPER_API void
pepper_surface_get_buffer_offset(pepper_surface_t *surface, int32_t *x,
- int32_t *y)
+ int32_t *y)
{
if (x)
*x = surface->buffer.x;
static void
touch_point_handle_focus_destroy(pepper_event_listener_t *listener,
- pepper_object_t *surface,
- uint32_t id, void *info, void *data)
+ pepper_object_t *surface,
+ uint32_t id, void *info, void *data)
{
pepper_touch_point_t *point = data;
touch_point_set_focus(point, NULL);
if (point->focus) {
pepper_event_listener_remove(point->focus_destroy_listener);
pepper_object_emit_event(&point->touch->base, PEPPER_EVENT_FOCUS_LEAVE,
- point->focus);
+ point->focus);
pepper_object_emit_event(&point->focus->base, PEPPER_EVENT_FOCUS_LEAVE,
- point->focus);
+ point->focus);
}
point->focus = focus;
if (focus) {
point->focus_serial = wl_display_next_serial(
- point->touch->seat->compositor->display);
+ point->touch->seat->compositor->display);
point->focus_destroy_listener =
pepper_object_add_event_listener(&focus->base, PEPPER_EVENT_OBJECT_DESTROY, 0,
- touch_point_handle_focus_destroy, point);
+ touch_point_handle_focus_destroy, point);
pepper_object_emit_event(&point->touch->base, PEPPER_EVENT_FOCUS_ENTER, focus);
pepper_object_emit_event(&focus->base, PEPPER_EVENT_FOCUS_ENTER, focus);
void
pepper_touch_handle_event(pepper_touch_t *touch, uint32_t id,
- pepper_input_event_t *event)
+ pepper_input_event_t *event)
{
switch (id) {
case PEPPER_EVENT_TOUCH_DOWN: {
if (touch->grab)
touch->grab->down(touch, touch->data, event->time, event->slot, event->x,
- event->y);
+ event->y);
}
break;
case PEPPER_EVENT_TOUCH_UP: {
if (touch->grab)
touch->grab->motion(touch, touch->data, event->time, event->slot, event->x,
- event->y);
+ event->y);
}
break;
case PEPPER_EVENT_TOUCH_FRAME: {
void
pepper_touch_bind_resource(struct wl_client *client,
- struct wl_resource *resource, uint32_t id)
+ struct wl_resource *resource, uint32_t id)
{
pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource);
pepper_touch_t *touch = seat->touch;
return;
res = wl_resource_create(client, &wl_touch_interface,
- wl_resource_get_version(resource), id);
+ wl_resource_get_version(resource), id);
if (!res) {
wl_client_post_no_memory(client);
return;
*/
PEPPER_API pepper_bool_t
pepper_touch_get_position(pepper_touch_t *touch, uint32_t id, double *x,
- double *y)
+ double *y)
{
pepper_touch_point_t *point = get_touch_point(touch, id);
PEPPER_CHECK(point, return PEPPER_FALSE, "Touch point %d does not exist.\n",
- id);
+ id);
if (x)
*x = point->x;
*/
PEPPER_API pepper_bool_t
pepper_touch_set_position(pepper_touch_t *touch, uint32_t id, double x,
- double y)
+ double y)
{
pepper_touch_point_t *point = get_touch_point(touch, id);
PEPPER_CHECK(point, return PEPPER_FALSE, "Touch point %d does not exist.\n",
- id);
+ id);
point->x = x;
point->y = y;
*/
PEPPER_API void
pepper_touch_send_down(pepper_touch_t *touch, pepper_view_t *view,
- uint32_t time, uint32_t id, double x, double y)
+ uint32_t time, uint32_t id, double x, double y)
{
struct wl_resource *resource;
wl_fixed_t fx = wl_fixed_from_double(x);
struct wl_resource *surface_resource = view->surface->resource;
if (wl_resource_get_client(resource) == wl_resource_get_client(
- surface_resource))
+ surface_resource))
wl_touch_send_down(resource, point->focus_serial, time, surface_resource, id,
- fx, fy);
+ fx, fy);
}
event.time = time;
*/
PEPPER_API void
pepper_touch_send_up(pepper_touch_t *touch, pepper_view_t *view, uint32_t time,
- uint32_t id)
+ uint32_t id)
{
struct wl_resource *resource;
uint32_t serial;
struct wl_resource *surface_resource = view->surface->resource;
if (wl_resource_get_client(resource) == wl_resource_get_client(
- surface_resource))
+ surface_resource))
wl_touch_send_up(resource, serial, time, id);
}
*/
PEPPER_API void
pepper_touch_send_motion(pepper_touch_t *touch, pepper_view_t *view,
- uint32_t time, uint32_t id, double x, double y)
+ uint32_t time, uint32_t id, double x, double y)
{
struct wl_resource *resource;
struct wl_resource *surface_resource = view->surface->resource;
if (wl_resource_get_client(resource) == wl_resource_get_client(
- surface_resource))
+ surface_resource))
wl_touch_send_motion(resource, time, id, fx, fy);
}
*/
PEPPER_API void
pepper_touch_set_grab(pepper_touch_t *touch, const pepper_touch_grab_t *grab,
- void *data)
+ void *data)
{
touch->grab = grab;
touch->data = data;
PEPPER_API void
pepper_map_init(pepper_map_t *map,
- int bucket_bits,
- pepper_hash_func_t hash_func,
- pepper_key_length_func_t key_length_func,
- pepper_key_compare_func_t key_compare_func,
- void *buckets)
+ int bucket_bits,
+ pepper_hash_func_t hash_func,
+ pepper_key_length_func_t key_length_func,
+ pepper_key_compare_func_t key_compare_func,
+ void *buckets)
{
map->hash_func = hash_func;
map->key_length_func = key_length_func;
static int
int32_key_compare(const void *key0, int key0_length,
- const void *key1, int key1_length)
+ const void *key1, int key1_length)
{
return (int)(key0 - key1);
}
static int
int64_key_compare(const void *key0, int key0_length,
- const void *key1, int key1_length)
+ const void *key1, int key1_length)
{
return (int)(key0 - key1);
}
PEPPER_API pepper_map_t *
pepper_map_create(int bucket_bits,
- pepper_hash_func_t hash_func,
- pepper_key_length_func_t key_length_func,
- pepper_key_compare_func_t key_compare_func)
+ pepper_hash_func_t hash_func,
+ pepper_key_length_func_t key_length_func,
+ pepper_key_compare_func_t key_compare_func)
{
pepper_map_t *map;
int bucket_size = 1 << bucket_bits;
map = calloc(1, sizeof(pepper_map_t) + bucket_size * sizeof(
- pepper_map_entry_t *));
+ pepper_map_entry_t *));
PEPPER_CHECK(map, return NULL, "calloc() failed.\n");
pepper_map_init(map, bucket_bits, hash_func, key_length_func, key_compare_func,
- map + 1);
+ map + 1);
return map;
}
PEPPER_API void
pepper_map_set(pepper_map_t *map, const void *key, void *data,
- pepper_free_func_t free_func)
+ pepper_free_func_t free_func)
{
pepper_map_entry_t **bucket = get_bucket(map, key);
pepper_map_entry_t *curr = *bucket;
}
if ((vt_data.saved_tty_num > 0) &&
- (ioctl(fd, VT_ACTIVATE, vt_data.saved_tty_num) < 0)) {
+ (ioctl(fd, VT_ACTIVATE, vt_data.saved_tty_num) < 0)) {
PEPPER_ERROR("");
}
pepper_transform_pixman_region(&damage, &view->global_transform);
pixman_region32_translate(&damage,
- -entry->plane->output->geometry.x,
- -entry->plane->output->geometry.y);
+ -entry->plane->output->geometry.x,
+ -entry->plane->output->geometry.y);
pixman_region32_intersect(&damage, &damage, &entry->base.visible_region);
pepper_plane_add_damage_region(entry->plane, &damage);
}
*/
PEPPER_API void
pepper_view_assign_plane(pepper_view_t *view, pepper_output_t *output,
- pepper_plane_t *plane)
+ pepper_plane_t *plane)
{
PEPPER_CHECK(!plane ||
- plane->output == output, return, "Plane output mismatch.\n");
+ plane->output == output, return, "Plane output mismatch.\n");
plane_entry_set_plane(&view->plane_entries[output->id], plane);
}
/* Transform. */
pepper_mat4_init_translate(&view->global_transform, view->x, view->y, 0.0);
pepper_mat4_multiply(&view->global_transform, &view->global_transform,
- &view->transform);
+ &view->transform);
if (view->inherit_transform && view->parent) {
pepper_mat4_multiply(&view->global_transform,
- &view->parent->global_transform, &view->global_transform);
+ &view->parent->global_transform, &view->global_transform);
}
pepper_mat4_inverse(&view->global_transform_inverse, &view->global_transform);
if (view->surface && pepper_mat4_is_translation(&view->global_transform)) {
pixman_region32_copy(&view->opaque_region, &view->surface->opaque_region);
pixman_region32_translate(&view->opaque_region,
- view->global_transform.m[12], view->global_transform.m[13]);
+ view->global_transform.m[12], view->global_transform.m[13]);
} else {
pixman_region32_clear(&view->opaque_region);
}
};
if (pixman_region32_contains_rectangle(&view->bounding_region,
- &box) != PIXMAN_REGION_OUT) {
+ &box) != PIXMAN_REGION_OUT) {
view->output_overlap |= (1 << output->id);
if (!(output_overlap_prev & (1 << output->id)))
pepper_surface_send_enter(view->surface, output);
pepper_compositor_add_view(pepper_compositor_t *compositor)
{
pepper_view_t *view = (pepper_view_t *)pepper_object_alloc(PEPPER_OBJECT_VIEW,
- sizeof(pepper_view_t));
+ sizeof(pepper_view_t));
PEPPER_CHECK(view, return NULL, "pepper_object_alloc() failed.\n");
view_init(view, compositor);
view->h = 0;
pepper_object_emit_event(&compositor->base, PEPPER_EVENT_COMPOSITOR_VIEW_ADD,
- view);
+ view);
return view;
}
pepper_view_t *child, *tmp;
pepper_object_emit_event(&view->compositor->base,
- PEPPER_EVENT_COMPOSITOR_VIEW_REMOVE, view);
+ PEPPER_EVENT_COMPOSITOR_VIEW_REMOVE, view);
pepper_object_fini(&view->base);
for (i = 0; i < PEPPER_MAX_OUTPUT_COUNT; i++)
pepper_list_insert(view->parent->children_list.prev, &view->parent_link);
pepper_view_mark_dirty(view,
- PEPPER_VIEW_ACTIVE_DIRTY | PEPPER_VIEW_GEOMETRY_DIRTY);
+ PEPPER_VIEW_ACTIVE_DIRTY | PEPPER_VIEW_GEOMETRY_DIRTY);
}
/**
/* Get transform matrix on the parent local coordinate space. */
pepper_mat4_inverse(&view->transform, &view->parent->global_transform);
pepper_mat4_multiply(&view->transform, &view->global_transform,
- &view->transform);
+ &view->transform);
/* Set position of the (x, y) translation term of the matrix. */
view->x = view->transform.m[12];
*/
PEPPER_API pepper_bool_t
pepper_view_stack_above(pepper_view_t *view, pepper_view_t *below,
- pepper_bool_t subtree)
+ pepper_bool_t subtree)
{
view_insert(view, below->compositor_link.prev, subtree);
return PEPPER_TRUE;
*/
PEPPER_API pepper_bool_t
pepper_view_stack_below(pepper_view_t *view, pepper_view_t *above,
- pepper_bool_t subtree)
+ pepper_bool_t subtree)
{
view_insert(view, &above->compositor_link, subtree);
return PEPPER_TRUE;
extent.y2 = view->surface->h;
if (pixman_region32_contains_rectangle(&surface->opaque_region,
- &extent) == PIXMAN_REGION_IN)
+ &extent) == PIXMAN_REGION_IN)
return PEPPER_TRUE;
return PEPPER_FALSE;
*/
PEPPER_API void
pepper_view_get_local_coordinate(pepper_view_t *view, double gx, double gy,
- double *lx, double *ly)
+ double *lx, double *ly)
{
pepper_vec4_t pos = { gx, gy, 0.0, 1.0 };
*/
PEPPER_API void
pepper_view_get_global_coordinate(pepper_view_t *view, double lx, double ly,
- double *gx, double *gy)
+ double *gx, double *gy)
{
pepper_vec4_t pos = { lx, ly, 0.0, 1.0 };
static pepper_bool_t
init_gl_shader(gl_renderer_t *gr, gl_shader_t *shader, const char *vs,
- const char *fs)
+ const char *fs)
{
GLint status;
char msg[512];
for (i = 0; i < GL_SHADER_SAMPLER_NONE; i++) {
if (!init_gl_shader(gr, &gr->shaders[i], vertex_shaders[i],
- fragment_shaders[i])) {
+ fragment_shaders[i])) {
fini_gl_shaders(gr);
return PEPPER_FALSE;
}
if (gr->unbind_display)
gr->unbind_display(gr->display,
- pepper_compositor_get_display(gr->base.compositor));
+ pepper_compositor_get_display(gr->base.compositor));
if (gr->display != EGL_NO_DISPLAY)
eglMakeCurrent(gr->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
static void
surface_state_handle_buffer_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
gl_surface_state_t *state = data;
surface_state_release_buffer(state);
static void
surface_state_handle_surface_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
gl_surface_state_t *state = data;
surface_state_release_buffer(state);
pepper_event_listener_remove(state->surface_destroy_listener);
pepper_object_set_user_data((pepper_object_t *)state->surface, state->renderer,
- NULL, NULL);
+ NULL, NULL);
free(state);
}
get_surface_state(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
gl_surface_state_t *state = pepper_object_get_user_data((
- pepper_object_t *)surface, renderer);
+ pepper_object_t *)surface, renderer);
if (!state) {
state = (gl_surface_state_t *)calloc(1, sizeof(gl_surface_state_t));
state->surface = surface;
state->surface_destroy_listener =
pepper_object_add_event_listener((pepper_object_t *)surface,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- surface_state_handle_surface_destroy, state);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ surface_state_handle_surface_destroy, state);
pepper_object_set_user_data((pepper_object_t *)surface, renderer, state, NULL);
}
h = wl_shm_buffer_get_height(shm_buffer);
if (state->buffer_type != BUFFER_TYPE_SHM ||
- w != state->buffer_width || h != state->buffer_height ||
- pitch != state->shm.pitch || format != state->shm.format ||
- pixel_format != state->shm.pixel_format) {
+ w != state->buffer_width || h != state->buffer_height ||
+ pitch != state->shm.pitch || format != state->shm.format ||
+ pixel_format != state->shm.pixel_format) {
/* Don't use glTexSubImage2D() for shm buffers in this case. */
state->shm.need_full_upload = PEPPER_TRUE;
}
surface_state_attach_tbm(gl_surface_state_t *state, pepper_buffer_t *buffer)
{
tbm_surface_h tbm_surface = wayland_tbm_server_get_surface(NULL,
- pepper_buffer_get_resource(buffer));
+ pepper_buffer_get_resource(buffer));
if (!tbm_surface)
return PEPPER_FALSE;
gr->query_buffer(display, resource, EGL_WIDTH, &state->buffer_width);
gr->query_buffer(display, resource, EGL_HEIGHT, &state->buffer_height);
if (!gr->query_buffer(display, resource, EGL_WAYLAND_Y_INVERTED_WL,
- &state->y_inverted))
+ &state->y_inverted))
state->y_inverted = 1;
state->buffer_type = BUFFER_TYPE_EGL;
static pepper_bool_t
gl_renderer_attach_surface(pepper_renderer_t *renderer,
- pepper_surface_t *surface, int *w, int *h)
+ pepper_surface_t *surface, int *w, int *h)
{
gl_surface_state_t *state = get_surface_state(renderer, surface);
pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
if (state->buffer) {
state->buffer_destroy_listener =
pepper_object_add_event_listener((pepper_object_t *)buffer,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- surface_state_handle_buffer_destroy, state);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ surface_state_handle_buffer_destroy, state);
}
*w = state->buffer_width;
for (i = 0; i < num_planes; i++) {
attribs[1] = i;
state->images[i] = gr->create_image(display, NULL, EGL_WAYLAND_BUFFER_WL,
- resource, attribs);
+ resource, attribs);
PEPPER_ASSERT(state->images[i] != EGL_NO_IMAGE_KHR);
gl_renderer_t *gr = (gl_renderer_t *)state->renderer;
EGLDisplay display = gr->display;
tbm_surface_h tbm_surface = wayland_tbm_server_get_surface(NULL,
- pepper_buffer_get_resource(state->buffer));
+ pepper_buffer_get_resource(state->buffer));
int sampler;
const EGLint image_attribs[] = {
surface_state_ensure_textures(state, 1);
state->images[0] = gr->create_image(display, NULL, EGL_NATIVE_SURFACE_TIZEN,
- state->tbm_surface, image_attribs);
+ state->tbm_surface, image_attribs);
PEPPER_ASSERT(state->images[0] != EGL_NO_IMAGE_KHR);
glActiveTexture(GL_TEXTURE0 + 0);
if (!gr->has_unpack_subimage) {
wl_shm_buffer_begin_access(state->shm.buffer);
glTexImage2D(GL_TEXTURE_2D, 0, state->shm.format,
- state->buffer_width, state->buffer_height, 0,
- state->shm.format, state->shm.pixel_format,
- wl_shm_buffer_get_data(state->shm.buffer));
+ state->buffer_width, state->buffer_height, 0,
+ state->shm.format, state->shm.pixel_format,
+ wl_shm_buffer_get_data(state->shm.buffer));
wl_shm_buffer_end_access(state->shm.buffer);
} else if (state->shm.need_full_upload) {
glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, state->shm.pitch);
wl_shm_buffer_begin_access(state->shm.buffer);
glTexImage2D(GL_TEXTURE_2D, 0, state->shm.format,
- state->buffer_width, state->buffer_height, 0,
- state->shm.format, state->shm.pixel_format,
- wl_shm_buffer_get_data(state->shm.buffer));
+ state->buffer_width, state->buffer_height, 0,
+ state->shm.format, state->shm.pixel_format,
+ wl_shm_buffer_get_data(state->shm.buffer));
wl_shm_buffer_end_access(state->shm.buffer);
state->shm.need_full_upload = PEPPER_FALSE;
} else {
glPixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, rects[i].x1);
glPixelStorei(GL_UNPACK_SKIP_ROWS_EXT, rects[i].y1);
glTexSubImage2D(GL_TEXTURE_2D, 0, rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1, rects[i].y2 - rects[i].y1,
- state->shm.format, state->shm.pixel_format,
- wl_shm_buffer_get_data(state->shm.buffer));
+ rects[i].x2 - rects[i].x1, rects[i].y2 - rects[i].y1,
+ state->shm.format, state->shm.pixel_format,
+ wl_shm_buffer_get_data(state->shm.buffer));
}
wl_shm_buffer_end_access(state->shm.buffer);
}
static pepper_bool_t
gl_renderer_flush_surface_damage(pepper_renderer_t *renderer,
- pepper_surface_t *surface)
+ pepper_surface_t *surface)
{
gl_surface_state_t *state = get_surface_state(renderer, surface);
static pepper_bool_t
gl_renderer_read_pixels(pepper_renderer_t *renderer,
- int x, int y, int w, int h,
- void *pixels, pepper_format_t format)
+ int x, int y, int w, int h,
+ void *pixels, pepper_format_t format)
{
gl_renderer_t *gr = (gl_renderer_t *)renderer;
GLenum gl_format;
static pepper_bool_t
inside(pepper_vec2_t *vertex, pepper_vec2_t *clip_start,
- pepper_vec2_t *clip_end)
+ pepper_vec2_t *clip_end)
{
if ((clip_start->y > clip_end->y) && (vertex->x >= clip_start->x)) /* left */
return PEPPER_TRUE;
static void
intersect(pepper_vec2_t *vertex1, pepper_vec2_t *vertex2,
- pepper_vec2_t *clip_start, pepper_vec2_t *clip_end, pepper_vec2_t *out_vertex)
+ pepper_vec2_t *clip_start, pepper_vec2_t *clip_end, pepper_vec2_t *out_vertex)
{
if (clip_start->x == clip_end->x) {
out_vertex->x = clip_start->x;
out_vertex->y = vertex1->y + (clip_start->x - vertex1->x) *
- (vertex2->y - vertex1->y)
- / (vertex2->x - vertex1->x);
+ (vertex2->y - vertex1->y)
+ / (vertex2->x - vertex1->x);
} else {
out_vertex->x = vertex1->x + (clip_start->y - vertex1->y) *
- (vertex2->x - vertex1->x)
- / (vertex2->y - vertex1->y);
+ (vertex2->x - vertex1->x)
+ / (vertex2->y - vertex1->y);
out_vertex->y = clip_start->y;
}
}
static void
clip_line(pepper_vec2_t *in_vertices, pepper_vec2_t *out_vertices, int in_len,
- int *out_len,
- pepper_vec2_t *clip_start, pepper_vec2_t *clip_end)
+ int *out_len,
+ pepper_vec2_t *clip_start, pepper_vec2_t *clip_end)
{
int i;
pepper_vec2_t *vs, *ve;
static void
clip(pepper_vec2_t *vertices, int *len, pixman_box32_t *clip_rect,
- pepper_bool_t is_rect)
+ pepper_bool_t is_rect)
{
if (is_rect) {
int i;
if ((vertices[0].x >= clip_rect->x2) || (vertices[2].x <= clip_rect->x1) ||
- (vertices[0].y >= clip_rect->y2) || (vertices[2].y <= clip_rect->y1)) {
+ (vertices[0].y >= clip_rect->y2) || (vertices[2].y <= clip_rect->y1)) {
*len = 0;
return;
}
static void
calc_vertices(gl_renderer_t *gr, gl_surface_state_t *state,
- pepper_render_item_t *node,
- pixman_region32_t *region, pixman_region32_t *surface_region)
+ pepper_render_item_t *node,
+ pixman_region32_t *region, pixman_region32_t *surface_region)
{
int i, j, k, n;
int len;
surface_rects = pixman_region32_rectangles(surface_region, &surface_nrects);
rects = pixman_region32_rectangles(region, &nrects);
vertex_array = wl_array_add(&gr->vertex_array,
- surface_nrects * nrects * (8 - 2) * 3 * 2 * 2 * sizeof(GLfloat));
+ surface_nrects * nrects * (8 - 2) * 3 * 2 * 2 * sizeof(GLfloat));
gr->triangles = 0;
for (n = 0; n < surface_nrects; n++) {
double x, y;
pepper_mat4_transform_vec2(inverse, &texcoords[j]);
pepper_coordinates_surface_to_buffer(pepper_view_get_surface(node->view),
- texcoords[j].x, texcoords[j].y, &x, &y);
+ texcoords[j].x, texcoords[j].y, &x, &y);
if (!state->y_inverted)
y = state->buffer_height - y;
texcoords[j].x = x / state->buffer_width;
for (j = 1, k = 1; j < len; j++) {
if ((float_difference((float)vertices[j - 1].x,
- (float)vertices[j].x) == 0.0f) &&
- (float_difference((float)vertices[j - 1].y, (float)vertices[j].y) == 0.0f))
+ (float)vertices[j].x) == 0.0f) &&
+ (float_difference((float)vertices[j - 1].y, (float)vertices[j].y) == 0.0f))
continue;
if (j != k) {
}
if ((float_difference((float)vertices[len - 1].x,
- (float)vertices[0].x) == 0.0f) &&
- (float_difference((float)vertices[len - 1].y, (float)vertices[0].y) == 0.0f))
+ (float)vertices[0].x) == 0.0f) &&
+ (float_difference((float)vertices[len - 1].y, (float)vertices[0].y) == 0.0f))
k--;
for (j = 2; j < k; j++) {
static void
repaint_region_clip(gl_renderer_t *gr, gl_surface_state_t *state,
- pepper_render_item_t *node,
- pixman_region32_t *damage, pixman_region32_t *surface_region)
+ pepper_render_item_t *node,
+ pixman_region32_t *damage, pixman_region32_t *surface_region)
{
GLfloat *vertex_array;
vertex_array = gr->vertex_array.data;
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
- &vertex_array[0]);
+ &vertex_array[0]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
- &vertex_array[2]);
+ &vertex_array[2]);
glEnableVertexAttribArray(1);
glDrawArrays(GL_TRIANGLES, 0, gr->triangles * 3);
static void
repaint_view_clip(pepper_renderer_t *renderer, pepper_output_t *output,
- pepper_render_item_t *node, pixman_region32_t *damage)
+ pepper_render_item_t *node, pixman_region32_t *damage)
{
gl_renderer_t *gr = (gl_renderer_t *)renderer;
gl_render_target_t *gt = (gl_render_target_t *)renderer->target;
trans[i] = (float)gt->proj_mat.m[i];
filter = (node->transform.flags <= PEPPER_MATRIX_TRANSLATE) ? GL_NEAREST :
- GL_LINEAR;
+ GL_LINEAR;
for (i = 0; i < state->num_planes; i++) {
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, state->textures[i]);
static void
set_vertex(gl_surface_state_t *state, int32_t sx, int32_t sy,
- GLfloat *vertex_array)
+ GLfloat *vertex_array)
{
double x, y;
static void
repaint_region_scissor(gl_renderer_t *gr, gl_surface_state_t *state,
- pixman_region32_t *damage, pixman_region32_t *surface_region)
+ pixman_region32_t *damage, pixman_region32_t *surface_region)
{
int i, j;
int nrects, surface_nrects;
set_vertex(state, surface_rects[i].x1, surface_rects[i].y2, &vertex_array[12]);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
- &vertex_array[0]);
+ &vertex_array[0]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat),
- &vertex_array[2]);
+ &vertex_array[2]);
glEnableVertexAttribArray(1);
rects = pixman_region32_rectangles(damage, &nrects);
for (j = 0; j < nrects; j++) {
glScissor(rects[j].x1, gt->height - rects[j].y2,
- rects[j].x2 - rects[j].x1, rects[j].y2 - rects[j].y1);
+ rects[j].x2 - rects[j].x1, rects[j].y2 - rects[j].y1);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
}
static void
repaint_view_scissor(pepper_renderer_t *renderer, pepper_output_t *output,
- pepper_render_item_t *node, pixman_region32_t *damage)
+ pepper_render_item_t *node, pixman_region32_t *damage)
{
gl_renderer_t *gr = (gl_renderer_t *)renderer;
gl_render_target_t *gt = (gl_render_target_t *)renderer->target;
}
filter = (node->transform.flags <= PEPPER_MATRIX_TRANSLATE) ? GL_NEAREST :
- GL_LINEAR;
+ GL_LINEAR;
for (i = 0; i < state->num_planes; i++) {
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, state->textures[i]);
static void
gl_renderer_repaint_output(pepper_renderer_t *renderer, pepper_output_t *output,
- const pepper_list_t *list, pixman_region32_t *damage)
+ const pepper_list_t *list, pixman_region32_t *damage)
{
gl_renderer_t *gr = (gl_renderer_t *)renderer;
gl_render_target_t *gt = (gl_render_target_t *)renderer->target;
if (gr->has_buffer_age)
eglQuerySurface(gr->display, ((gl_render_target_t *)renderer->target)->surface,
- EGL_BUFFER_AGE_EXT, &buffer_age);
+ EGL_BUFFER_AGE_EXT, &buffer_age);
if (!buffer_age || buffer_age - 1 > MAX_BUFFER_COUNT) {
pixman_region32_init_rect(&total_damage, geom->x, geom->y, geom->w, geom->h);
for (i = 0; i < buffer_age - 1; i++)
pixman_region32_union(&total_damage, &total_damage,
- >->damages[(first + i) % MAX_BUFFER_COUNT]);
+ >->damages[(first + i) % MAX_BUFFER_COUNT]);
pixman_region32_copy(>->damages[gt->damage_index], damage);
glEnable(GL_SCISSOR_TEST);
for (i = 0; i < nrects; i++) {
glScissor(rects[i].x1, geom->h - rects[i].y2,
- rects[i].x2 - rects[i].x1, rects[i].y2 - rects[i].y1);
+ rects[i].x2 - rects[i].x1, rects[i].y2 - rects[i].y1);
glClear(GL_COLOR_BUFFER_BIT);
}
glDisable(GL_SCISSOR_TEST);
if (gr->use_clipper)
pepper_list_for_each_list_reverse(l, list)
repaint_view_clip(renderer, output, (pepper_render_item_t *)l->item,
- &total_damage);
+ &total_damage);
else
pepper_list_for_each_list_reverse(l, list)
repaint_view_scissor(renderer, output, (pepper_render_item_t *)l->item,
- &total_damage);
+ &total_damage);
}
pixman_region32_fini(&total_damage);
gr->query_buffer = (void *)eglGetProcAddress("eglQueryWaylandBufferWL");
if (!gr->bind_display(gr->display,
- pepper_compositor_get_display(gr->base.compositor))) {
+ pepper_compositor_get_display(gr->base.compositor))) {
gr->bind_display = NULL;
gr->unbind_display = NULL;
gr->query_buffer = NULL;
}
gr->image_target_texture_2d = (void *)
- eglGetProcAddress("glEGLImageTargetTexture2DOES");
+ eglGetProcAddress("glEGLImageTargetTexture2DOES");
if (!gr->image_target_texture_2d) {
PEPPER_ERROR("glEGLImageTargetTexture2DOES not supported.\n");
PEPPER_API pepper_renderer_t *
pepper_gl_renderer_create(pepper_compositor_t *compositor, void *native_display,
- const char *platform)
+ const char *platform)
{
gl_renderer_t *gr;
EGLint major, minor;
PEPPER_API pepper_render_target_t *
pepper_gl_renderer_create_target(pepper_renderer_t *renderer,
- void *native_window,
- pepper_format_t format, const void *visual_id,
- int32_t width, int32_t height)
+ void *native_window,
+ pepper_format_t format, const void *visual_id,
+ int32_t width, int32_t height)
{
gl_renderer_t *gr = (gl_renderer_t *)renderer;
gl_render_target_t *target;
goto error;
if (!eglChooseConfig(gr->display, config_attribs, configs, config_size,
- &num_configs)) {
+ &num_configs)) {
PEPPER_ERROR("eglChooseConfig() failed.\n");
goto error;
}
if (visual_id) {
/* Native visual id have privilege. */
if (eglGetConfigAttrib(gr->display, configs[i], EGL_NATIVE_VISUAL_ID,
- &attrib)) {
+ &attrib)) {
if (attrib == *((EGLint *)visual_id)) {
config = configs[i];
break;
/* Try platform window surface creation first. */
if (gr->create_platform_window_surface)
surface = gr->create_platform_window_surface(gr->display, config, native_window,
- NULL);
+ NULL);
if (target->surface == EGL_NO_SURFACE) {
surface = eglCreateWindowSurface(gr->display, config,
- (EGLNativeWindowType)native_window, NULL);
+ (EGLNativeWindowType)native_window, NULL);
}
if (surface == EGL_NO_SURFACE) {
if (gr->context == EGL_NO_CONTEXT) {
context = eglCreateContext(gr->display, config, EGL_NO_CONTEXT,
- context_attribs);
+ context_attribs);
if (context == EGL_NO_CONTEXT) {
PEPPER_ERROR("eglCreateContext() failed.\n");
goto error;
target->base.destroy = gl_render_target_destroy;
pepper_mat4_init_translate(&target->proj_mat, (double)width / -2,
- (double)height / -2, 0);
+ (double)height / -2, 0);
pepper_mat4_scale(&target->proj_mat, (double)2 / width, (double)(-2) / height,
- 1);
+ 1);
for (i = 0; i < MAX_BUFFER_COUNT; i++)
pixman_region32_init(&target->damages[i]);
PEPPER_API pepper_renderer_t *
pepper_gl_renderer_create(pepper_compositor_t *compositor, void *display,
- const char *platform);
+ const char *platform);
PEPPER_API pepper_render_target_t *
pepper_gl_renderer_create_target(pepper_renderer_t *renderer, void *window,
- pepper_format_t format,
- const void *visual_id, int32_t width, int32_t height);
+ pepper_format_t format,
+ const void *visual_id, int32_t width, int32_t height);
#ifdef __cplusplus
}
PEPPER_API pepper_render_target_t *
pepper_pixman_renderer_create_target(pepper_format_t format, void *pixels,
- int stride, int width, int height);
+ int stride, int width, int height);
PEPPER_API pepper_render_target_t *
pepper_pixman_renderer_create_target_for_image(pixman_image_t *image);
void (*destroy)(pepper_renderer_t *renderer);
pepper_bool_t (*attach_surface)(pepper_renderer_t *renderer,
- pepper_surface_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_surface_t *surface);
+ 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);
+ int x, int y, int w, int h,
+ void *pixels, pepper_format_t format);
void (*repaint_output)(pepper_renderer_t *renderer,
- pepper_output_t *output,
- const pepper_list_t *render_list,
- pixman_region32_t *damage);
+ pepper_output_t *output,
+ const pepper_list_t *render_list,
+ pixman_region32_t *damage);
};
#endif /* PEPPER_RENDER_INTERNAL_H */
PEPPER_API pepper_bool_t
pepper_renderer_set_target(pepper_renderer_t *renderer,
- pepper_render_target_t *target);
+ pepper_render_target_t *target);
PEPPER_API pepper_render_target_t *
pepper_renderer_get_target(pepper_renderer_t *renderer);
PEPPER_API pepper_bool_t
pepper_renderer_attach_surface(pepper_renderer_t *renderer,
- pepper_surface_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_surface_t *surface);
+ pepper_surface_t *surface);
PEPPER_API void
pepper_renderer_repaint_output(pepper_renderer_t *renderer,
- pepper_output_t *output,
- const pepper_list_t *view_list, pixman_region32_t *damage);
+ pepper_output_t *output,
+ const pepper_list_t *view_list, pixman_region32_t *damage);
PEPPER_API pepper_bool_t
pepper_renderer_read_pixels(pepper_renderer_t *renderer, int x, int y, int w,
- int h,
- void *pixels, pepper_format_t format);
+ int h,
+ void *pixels, pepper_format_t format);
#ifdef __cplusplus
}
static void
surface_state_handle_buffer_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
pixman_surface_state_t *state = data;
surface_state_release_buffer(state);
static void
surface_state_handle_surface_destroy(pepper_event_listener_t *listener,
- pepper_object_t *object,
- uint32_t id,
- void *info,
- void *data)
+ pepper_object_t *object,
+ uint32_t id,
+ void *info,
+ void *data)
{
pixman_surface_state_t *state = data;
surface_state_release_buffer(state);
pepper_event_listener_remove(state->surface_destroy_listener);
pepper_object_set_user_data((pepper_object_t *)state->surface, state->renderer,
- NULL, NULL);
+ NULL, NULL);
free(state);
}
}
#ifdef HAVE_TBM
tbm_surface = wayland_tbm_server_get_surface(NULL,
- pepper_buffer_get_resource(state->buffer));
+ pepper_buffer_get_resource(state->buffer));
if (tbm_surface) {
tbm_surface_info_s tmp;
tbm_surface_map(tbm_surface, TBM_SURF_OPTION_READ, &tmp);
}
#ifdef HAVE_TBM
tbm_surface = wayland_tbm_server_get_surface(NULL,
- pepper_buffer_get_resource(state->buffer));
+ pepper_buffer_get_resource(state->buffer));
if (tbm_surface) {
tbm_surface_unmap(tbm_surface);
return;
get_surface_state(pepper_renderer_t *renderer, pepper_surface_t *surface)
{
pixman_surface_state_t *state = pepper_object_get_user_data((
- pepper_object_t *)surface, renderer);
+ pepper_object_t *)surface, renderer);
if (!state) {
state = calloc(1, sizeof(pixman_surface_state_t));
state->surface = surface;
state->surface_destroy_listener =
pepper_object_add_event_listener((pepper_object_t *)surface,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- surface_state_handle_surface_destroy, state);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ surface_state_handle_surface_destroy, state);
pepper_object_set_user_data((pepper_object_t *)surface, renderer, state, NULL);
}
h = wl_shm_buffer_get_height(shm_buffer);
image = pixman_image_create_bits(format, w, h,
- wl_shm_buffer_get_data(shm_buffer),
- wl_shm_buffer_get_stride(shm_buffer));
+ wl_shm_buffer_get_data(shm_buffer),
+ wl_shm_buffer_get_stride(shm_buffer));
if (!image)
return PEPPER_FALSE;
surface_state_attach_tbm(pixman_surface_state_t *state, pepper_buffer_t *buffer)
{
tbm_surface_h tbm_surface = wayland_tbm_server_get_surface(NULL,
- pepper_buffer_get_resource(buffer));
+ pepper_buffer_get_resource(buffer));
tbm_surface_info_s info;
pixman_format_code_t format;
int w, h;
w = info.width;
h = info.height;
image = pixman_image_create_bits(format, w, h,
- (uint32_t *)info.planes[0].ptr,
- info.planes[0].stride);
+ (uint32_t *)info.planes[0].ptr,
+ info.planes[0].stride);
if (!image)
return PEPPER_FALSE;
static pepper_bool_t
pixman_renderer_attach_surface(pepper_renderer_t *renderer,
- pepper_surface_t *surface,
- int *w, int *h)
+ pepper_surface_t *surface,
+ int *w, int *h)
{
pixman_surface_state_t *state = get_surface_state(renderer, surface);
pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
if (state->buffer) {
state->buffer_destroy_listener =
pepper_object_add_event_listener((pepper_object_t *)buffer,
- PEPPER_EVENT_OBJECT_DESTROY, 0,
- surface_state_handle_buffer_destroy, state);
+ PEPPER_EVENT_OBJECT_DESTROY, 0,
+ surface_state_handle_buffer_destroy, state);
}
*w = state->buffer_width;
static pepper_bool_t
pixman_renderer_flush_surface_damage(pepper_renderer_t *renderer,
- pepper_surface_t *surface)
+ pepper_surface_t *surface)
{
return PEPPER_TRUE;
}
static pepper_bool_t
pixman_renderer_read_pixels(pepper_renderer_t *renderer,
- int x, int y, int w, int h,
- void *pixels, pepper_format_t format)
+ int x, int y, int w, int h,
+ void *pixels, pepper_format_t format)
{
pixman_image_t *src = ((pixman_render_target_t *)
- renderer->target)->image;
+ renderer->target)->image;
pixman_image_t *dst;
pixman_format_code_t pixman_format;
int stride;
static void
pixman_transform_from_pepper_mat4(pixman_transform_t *transform,
- pepper_mat4_t *mat)
+ pepper_mat4_t *mat)
{
transform->matrix[0][0] = pixman_double_to_fixed(mat->m[0]);
transform->matrix[0][1] = pixman_double_to_fixed(mat->m[4]);
static void
repaint_view(pepper_renderer_t *renderer, pepper_output_t *output,
- pepper_render_item_t *node, pixman_region32_t *damage)
+ pepper_render_item_t *node, pixman_region32_t *damage)
{
int32_t x, y, w, h, scale;
pepper_surface_t *surface = pepper_view_get_surface(node->view);
pixman_region32_t repaint, repaint_surface;
pixman_region32_t surface_blend, *surface_opaque;
pixman_surface_state_t *ps = get_surface_state(renderer,
- pepper_view_get_surface(node->view));
+ pepper_view_get_surface(node->view));
pixman_region32_init(&repaint);
pixman_region32_intersect(&repaint, &node->visible_region, damage);
if (node->transform.flags <= PEPPER_MATRIX_TRANSLATE) {
pixman_transform_init_translate(&trans,
- -pixman_double_to_fixed(node->transform.m[12]),
- -pixman_double_to_fixed(node->transform.m[13]));
+ -pixman_double_to_fixed(node->transform.m[12]),
+ -pixman_double_to_fixed(node->transform.m[13]));
filter = PIXMAN_FILTER_NEAREST;
} else {
pixman_transform_from_pepper_mat4(&trans, &node->inverse);
pepper_surface_get_buffer_offset(surface, &x, &y);
pepper_surface_get_size(surface, &w, &h);
pixman_transform_translate(&trans, NULL,
- pixman_int_to_fixed(x), pixman_int_to_fixed(y));
+ pixman_int_to_fixed(x), pixman_int_to_fixed(y));
switch (pepper_surface_get_buffer_transform(surface)) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_scale(&trans, NULL, pixman_int_to_fixed(-1),
- pixman_int_to_fixed(1));
+ pixman_int_to_fixed(1));
pixman_transform_translate(&trans, NULL, pixman_int_to_fixed(w), 0);
break;
}
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&trans, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&trans, NULL,
- pixman_int_to_fixed(w),
- pixman_int_to_fixed(h));
+ pixman_int_to_fixed(w),
+ pixman_int_to_fixed(h));
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
scale = pepper_surface_get_buffer_scale(surface);
pixman_transform_scale(&trans, NULL,
- pixman_int_to_fixed(scale),
- pixman_int_to_fixed(scale));
+ pixman_int_to_fixed(scale),
+ pixman_int_to_fixed(scale));
pixman_image_set_transform(ps->image, &trans);
pixman_image_set_filter(ps->image, filter, NULL, 0);
if (pixman_region32_not_empty(surface_opaque)) {
pixman_region32_translate(surface_opaque,
- (int)node->transform.m[12], (int)node->transform.m[13]);
+ (int)node->transform.m[12], (int)node->transform.m[13]);
pepper_pixman_region_global_to_output(surface_opaque, output);
pixman_region32_intersect(&repaint_surface, &repaint, surface_opaque);
pixman_image_set_clip_region32(target->image, &repaint_surface);
surface_state_begin_access(ps);
pixman_image_composite32(PIXMAN_OP_SRC, ps->image, NULL, target->image,
- 0, 0, /* src_x, src_y */
- 0, 0, /* mask_x, mask_y */
- 0, 0, /* dest_x, dest_y */
- pixman_image_get_width(target->image),
- pixman_image_get_height(target->image));
+ 0, 0, /* src_x, src_y */
+ 0, 0, /* mask_x, mask_y */
+ 0, 0, /* dest_x, dest_y */
+ pixman_image_get_width(target->image),
+ pixman_image_get_height(target->image));
surface_state_end_access(ps);
}
if (pixman_region32_not_empty(&surface_blend)) {
pixman_region32_translate(&surface_blend,
- (int)node->transform.m[12], (int)node->transform.m[13]);
+ (int)node->transform.m[12], (int)node->transform.m[13]);
pepper_pixman_region_global_to_output(&surface_blend, output);
pixman_region32_intersect(&repaint_surface, &repaint, &surface_blend);
pixman_image_set_clip_region32(target->image, &repaint_surface);
surface_state_begin_access(ps);
pixman_image_composite32(PIXMAN_OP_OVER, ps->image, NULL, target->image,
- 0, 0, /* src_x, src_y */
- 0, 0, /* mask_x, mask_y */
- 0, 0, /* dest_x, dest_y */
- pixman_image_get_width(target->image),
- pixman_image_get_height(target->image));
+ 0, 0, /* src_x, src_y */
+ 0, 0, /* mask_x, mask_y */
+ 0, 0, /* dest_x, dest_y */
+ pixman_image_get_width(target->image),
+ pixman_image_get_height(target->image));
surface_state_end_access(ps);
}
} else {
pixman_region32_translate(&surface_blend,
- (int)node->transform.m[12], (int)node->transform.m[13]);
+ (int)node->transform.m[12], (int)node->transform.m[13]);
pepper_pixman_region_global_to_output(&surface_blend, output);
pixman_region32_intersect(&repaint_surface, &repaint, &surface_blend);
pixman_image_set_clip_region32(target->image, &repaint_surface);
surface_state_begin_access(ps);
pixman_image_composite32(PIXMAN_OP_OVER, ps->image, NULL, target->image,
- 0, 0, /* src_x, src_y */
- 0, 0, /* mask_x, mask_y */
- 0, 0, /* dest_x, dest_y */
- pixman_image_get_width(target->image),
- pixman_image_get_height(target->image));
+ 0, 0, /* src_x, src_y */
+ 0, 0, /* mask_x, mask_y */
+ 0, 0, /* dest_x, dest_y */
+ pixman_image_get_width(target->image),
+ pixman_image_get_height(target->image));
surface_state_end_access(ps);
}
clear_background(pixman_renderer_t *renderer, pixman_region32_t *damage)
{
pixman_render_target_t *target = (pixman_render_target_t *)
- renderer->base.target;
+ renderer->base.target;
pixman_image_set_clip_region32(target->image, damage);
pixman_image_composite32(PIXMAN_OP_SRC, renderer->background, NULL,
- target->image,
- 0, 0, 0, 0, 0, 0,
- pixman_image_get_width(target->image),
- pixman_image_get_height(target->image));
+ target->image,
+ 0, 0, 0, 0, 0, 0,
+ pixman_image_get_width(target->image),
+ pixman_image_get_height(target->image));
}
static void
pixman_renderer_repaint_output(pepper_renderer_t *renderer,
- pepper_output_t *output,
- const pepper_list_t *render_list,
- pixman_region32_t *damage)
+ pepper_output_t *output,
+ const pepper_list_t *render_list,
+ pixman_region32_t *damage)
{
if (pixman_region32_not_empty(damage)) {
pepper_list_t *l;
PEPPER_API pepper_render_target_t *
pepper_pixman_renderer_create_target(pepper_format_t format, void *pixels,
- int stride, int width, int height)
+ int stride, int width, int height)
{
pixman_render_target_t *target;
pixman_format_code_t pixman_format;
goto error;
target->image = pixman_image_create_bits(pixman_format, width, height, pixels,
- stride);
+ stride);
if (!target->image)
goto error;
PEPPER_API pepper_bool_t
pepper_renderer_set_target(pepper_renderer_t *renderer,
- pepper_render_target_t *target)
+ pepper_render_target_t *target)
{
if (target->renderer != NULL && target->renderer != renderer)
return PEPPER_FALSE;
PEPPER_API pepper_bool_t
pepper_renderer_attach_surface(pepper_renderer_t *renderer,
- pepper_surface_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_surface_t *surface)
+ pepper_surface_t *surface)
{
return renderer->flush_surface_damage(renderer, surface);
}
PEPPER_API void
pepper_renderer_repaint_output(pepper_renderer_t *renderer,
- pepper_output_t *output,
- const pepper_list_t *view_list, pixman_region32_t *damage)
+ pepper_output_t *output,
+ const pepper_list_t *view_list, pixman_region32_t *damage)
{
renderer->repaint_output(renderer, output, view_list, damage);
}
PEPPER_API pepper_bool_t
pepper_renderer_read_pixels(pepper_renderer_t *renderer, int x, int y, int w,
- int h,
- void *pixels, pepper_format_t format)
+ int h,
+ void *pixels, pepper_format_t format)
{
return renderer->read_pixels(renderer, x, y, w, h, pixels, format);
}
tdm->compositor = compositor;
tdm->disp = tdm_display_init(&ret);
PEPPER_CHECK(ret == TDM_ERROR_NONE, goto error,
- "tdm_display_init() failed %d\n", ret);
+ "tdm_display_init() failed %d\n", ret);
ret = tdm_display_get_fd(tdm->disp, &tdm->fd);
PEPPER_CHECK(ret == TDM_ERROR_NONE, goto error,
- "tdm_display_get_fd() failed %d\n", ret);
+ "tdm_display_get_fd() failed %d\n", ret);
tdm->bufmgr = tbm_bufmgr_init(tdm->fd);
PEPPER_CHECK(tdm->bufmgr, goto error, "tbm_bufmgr_init() failed \n");
*/
tdm->wl_tbm_server = wayland_tbm_server_init(pepper_compositor_get_display(
- compositor),
- "/dev/dri/card0", tdm->fd, 0);
+ compositor),
+ "/dev/dri/card0", tdm->fd, 0);
#endif
/*Setup outputs*/
loop = wl_display_get_event_loop(pepper_compositor_get_display(compositor));
tdm->tdm_event_source = wl_event_loop_add_fd(loop, tdm->fd, WL_EVENT_READABLE,
- __tdm_handle_event, tdm);
+ __tdm_handle_event, tdm);
PEPPER_CHECK(tdm->tdm_event_source, goto error,
- "wl_event_loop_add() failed.\n");
+ "wl_event_loop_add() failed.\n");
if (!pepper_compositor_set_clock_id(compositor, CLOCK_MONOTONIC))
goto error;
return NULL;
}
target = pepper_pixman_renderer_create_target(format, info.planes[0].ptr,
- info.planes[0].stride,
- info.width, info.height);
+ info.planes[0].stride,
+ info.width, info.height);
if (!target) {
tbm_bo_delete_user_data(bo, KEY_RENDER_TARGET);
PEPPER_ERROR("pepper_pixman_renderer_create_target() fail\n");
__tdm_renderer_pixman_render(pepper_tdm_output_t *output)
{
const pepper_list_t *render_list = pepper_plane_get_render_list(
- output->primary_plane->base);
+ output->primary_plane->base);
pixman_region32_t *damage = pepper_plane_get_damage_region(
- output->primary_plane->base);
+ output->primary_plane->base);
pixman_region32_t total_damage;
tbm_surface_h back;
pepper_render_target_t *target;
/*Set render target*/
ret = tbm_surface_queue_dequeue(output->tbm_surface_queue, &back);
PEPPER_CHECK(ret == TBM_SURFACE_QUEUE_ERROR_NONE, return,
- "tbm_surface_queue_dequeue() failed\n");
+ "tbm_surface_queue_dequeue() failed\n");
target = __tdm_renderer_pixman_get_target(back);
if (PEPPER_FALSE == pepper_renderer_set_target(output->renderer, target)) {
pixman_region32_copy(&output->previous_damage, damage);
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- &total_damage);
+ &total_damage);
pixman_region32_fini(&total_damage);
pepper_plane_clear_damage_region(output->primary_plane->base);
if (!tdm->pixman_renderer) {
tdm->pixman_renderer = pepper_pixman_renderer_create(tdm->compositor);
PEPPER_CHECK(tdm->pixman_renderer, return,
- "pepper_pixman_renderer_create() failed.\n");
+ "pepper_pixman_renderer_create() failed.\n");
}
output->renderer = tdm->pixman_renderer;
tdm_output_get_mode(output->output, &mode);
output->tbm_surface_queue = tbm_surface_queue_create(3,
- mode->hdisplay, mode->vdisplay,
- TBM_FORMAT_XBGR8888, TBM_BO_SCANOUT);
+ mode->hdisplay, mode->vdisplay,
+ TBM_FORMAT_XBGR8888, TBM_BO_SCANOUT);
PEPPER_CHECK(output->tbm_surface_queue, goto error,
- "tbm_surface_queue_create() failed.\n");
+ "tbm_surface_queue_create() failed.\n");
pixman_region32_init(&output->previous_damage);
output->render_type = TDM_RENDER_TYPE_PIXMAN;
int ret;
const pepper_list_t *render_list = pepper_plane_get_render_list(
- output->primary_plane->base);
+ output->primary_plane->base);
pixman_region32_t *damage = pepper_plane_get_damage_region(
- output->primary_plane->base);
+ output->primary_plane->base);
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- damage);
+ damage);
ret = tbm_surface_queue_can_acquire(output->tbm_surface_queue, 1);
PEPPER_CHECK(ret > 0, return, "tbm_surface_queue_can_acquire() failed.\n");
ret = tbm_surface_queue_acquire(output->tbm_surface_queue, &output->back);
PEPPER_CHECK(ret == TBM_SURFACE_QUEUE_ERROR_NONE, return,
- "tbm_surface_queue_acquire() failed.\n");
+ "tbm_surface_queue_acquire() failed.\n");
pepper_plane_clear_damage_region(output->primary_plane->base);
}
if (!tdm->gl_renderer) {
tdm->gl_renderer = pepper_gl_renderer_create(tdm->compositor, tdm->bufmgr,
- "tbm");
+ "tbm");
PEPPER_CHECK(tdm->gl_renderer, return, "pepper_gl_renderer_create() failed.\n");
}
tdm_output_get_mode(output->output, &mode);
output->tbm_surface_queue = tbm_surface_queue_create(3,
- mode->hdisplay, mode->vdisplay,
- TBM_FORMAT_XRGB8888,
- TBM_BO_SCANOUT);
+ mode->hdisplay, mode->vdisplay,
+ TBM_FORMAT_XRGB8888,
+ TBM_BO_SCANOUT);
PEPPER_CHECK(output->tbm_surface_queue, goto error,
- "tbm_surface_queue_create() failed.\n");
+ "tbm_surface_queue_create() failed.\n");
output->render_target = pepper_gl_renderer_create_target(tdm->gl_renderer,
- output->tbm_surface_queue,
- PEPPER_FORMAT_XRGB8888,
- &native_visual_id,
- mode->hdisplay, mode->vdisplay);
+ output->tbm_surface_queue,
+ PEPPER_FORMAT_XRGB8888,
+ &native_visual_id,
+ mode->hdisplay, mode->vdisplay);
PEPPER_CHECK(output->render_target, goto error,
- "pepper_gl_renderer_create_target() failed.\n");
+ "pepper_gl_renderer_create_target() failed.\n");
output->render_type = TDM_RENDER_TYPE_GL;
pepper_renderer_set_target(output->renderer, output->render_target);
static void
__tdm_plane_destroy(pepper_event_listener_t *listener, pepper_object_t *object,
- uint32_t id, void *info, void *data)
+ uint32_t id, void *info, void *data)
{
free(data);
}
err = tdm_output_get_mode(output->output, &mode);
PEPPER_CHECK(err == TDM_ERROR_NONE, return PEPPER_FALSE,
- "tdm_output_get_mode()\n");
+ "tdm_output_get_mode()\n");
/*TODO : set default layer info*/
info.transform = TDM_TRANSFORM_NORMAL;
plane->layer = (tdm_layer *)tdm_output_get_layer(output->output, i, &err);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "tdm_output_get_layer failed err:%d\n", err);
+ "tdm_output_get_layer failed err:%d\n", err);
plane->base = pepper_output_add_plane(output->base, prev);
PEPPER_CHECK(plane->base, goto error,
- "pepper_output_add_plane() failed\n");
+ "pepper_output_add_plane() failed\n");
pepper_object_add_event_listener((pepper_object_t *)plane->base,
- PEPPER_EVENT_OBJECT_DESTROY,
- 0,
- __tdm_plane_destroy, plane);
+ PEPPER_EVENT_OBJECT_DESTROY,
+ 0,
+ __tdm_plane_destroy, plane);
tdm_layer_get_capabilities(plane->layer, &plane->caps);
if (plane->caps & TDM_LAYER_CAPABILITY_PRIMARY) {
static void
__tdm_output_commit_cb(tdm_output *o, unsigned int sequence,
- unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+ unsigned int tv_sec, unsigned int tv_usec, void *user_data)
{
pepper_tdm_output_t *output = user_data;
struct timespec ts;
tdm_output_get_available_modes(output->output, &modes, &num_mode);
for (i = 0; i < num_mode; i++) {
- if (mode->w == (int32_t)modes[i].hdisplay&&
- mode->h == (int32_t)modes[i].vdisplay&&
- mode->refresh == (int32_t)modes[i].vrefresh) {
+ if (mode->w == (int32_t)modes[i].hdisplay &&
+ mode->h == (int32_t)modes[i].vdisplay &&
+ mode->refresh == (int32_t)modes[i].vrefresh) {
err = tdm_output_set_mode(output->output, &modes[i]);
PEPPER_CHECK(err == TDM_ERROR_NONE, return PEPPER_FALSE,
- "tdm_output_set_mode() failed mode:%s\n", modes[i].name);
+ "tdm_output_set_mode() failed mode:%s\n", modes[i].name);
return PEPPER_TRUE;
}
}
if (output->back) {
err = tdm_layer_set_buffer((tdm_layer *)output->primary_plane->layer,
- output->back);
+ output->back);
PEPPER_CHECK(err == TDM_ERROR_NONE, return, "tdm_layer_set_buffer() failed");
err = tdm_output_commit(output->output, 0, __tdm_output_commit_cb, output);
static void
pepper_tdm_output_attach_surface(void *o, pepper_surface_t *surface, int *w,
- int *h)
+ int *h)
{
pepper_tdm_output_t *output = (pepper_tdm_output_t *)o;
pepper_renderer_attach_surface(output->renderer, surface, w, h);
static void
pepper_tdm_output_flush_surface_damage(void *o, pepper_surface_t *surface,
- pepper_bool_t *keep_buffer)
+ pepper_bool_t *keep_buffer)
{
pepper_tdm_output_t *output = o;
pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
pepper_renderer_flush_surface_damage(output->renderer, surface);
if (output->render_type == TDM_RENDER_TYPE_GL &&
- (buffer && wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
+ (buffer && wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
*keep_buffer = PEPPER_FALSE;
} else {
*keep_buffer = PEPPER_TRUE;
output = (pepper_tdm_output_t *)calloc(1, sizeof(pepper_tdm_output_t));
output->tdm = tdm;
output->output = (tdm_output *)tdm_display_get_output(tdm->disp, num_output,
- &err);
+ &err);
PEPPER_CHECK((output->output && (err == TDM_ERROR_NONE)), goto error,
- "tdm_display_get_output(%d) failed err:%d\n", num_output, err);
+ "tdm_display_get_output(%d) failed err:%d\n", num_output, err);
/*Check connection state*/
err = tdm_output_get_conn_status(output->output, &status);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "tdm_display_get_output(%d) failed err:%d\n", num_output, err);
+ "tdm_display_get_output(%d) failed err:%d\n", num_output, err);
if (status != TDM_OUTPUT_CONN_STATUS_CONNECTED)
continue;
/*Setup default mode*/
err = tdm_output_get_available_modes(output->output, &modes, &num_mode);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "tdm_output_get_available_modes(%d) failed err:%d\n", num_output, err);
+ "tdm_output_get_available_modes(%d) failed err:%d\n", num_output, err);
for (i = 0; i < num_mode; i++) {
if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
preferred_mode = &modes[i];
if (preferred_mode) {
err = tdm_output_set_mode(output->output, preferred_mode);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "tdm_output_set_mode() failed err:%d\n", err);
+ "tdm_output_set_mode() failed err:%d\n", err);
} else if (default_mode) {
err = tdm_output_set_mode(output->output, default_mode);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "tdm_output_set_mode() failed err:%d\n", err);
+ "tdm_output_set_mode() failed err:%d\n", err);
} else {
err = tdm_output_set_mode(output->output, &modes[0]);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "tdm_output_set_mode() failed err:%d\n", err);
+ "tdm_output_set_mode() failed err:%d\n", err);
}
/*Setup renderer*/
if (render_env && !strcmp(render_env, "gl")) {
__tdm_renderer_gl_init(output);
PEPPER_CHECK(output->renderer, goto error,
- "Failed to initialize gl_renderer.\n");
+ "Failed to initialize gl_renderer.\n");
}
if (!output->renderer) {
__tdm_renderer_pixman_init(output);
PEPPER_CHECK(output->renderer, goto error,
- "Failed to initialize pixman_renderer.\n");
+ "Failed to initialize pixman_renderer.\n");
}
/*Add pepper_output to compositor*/
output->base = pepper_compositor_add_output(tdm->compositor,
- &tdm_output_backend,
- "tdm_output",
- output,
- WL_OUTPUT_TRANSFORM_NORMAL, 1);
+ &tdm_output_backend,
+ "tdm_output",
+ output,
+ WL_OUTPUT_TRANSFORM_NORMAL, 1);
PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
- "pepper_compositor_add_output() failed err:%d\n", err);
+ "pepper_compositor_add_output() failed err:%d\n", err);
PEPPER_CHECK(PEPPER_TRUE == __tdm_output_plane_init(output), goto error,
- "pepper_tdm_plane_init() failed\n");
+ "pepper_tdm_plane_init() failed\n");
}
return PEPPER_TRUE;
PEPPER_API pepper_wayland_t *
pepper_wayland_connect(pepper_compositor_t *compositor,
- const char *socket_name);
+ const char *socket_name);
PEPPER_API void
pepper_wayland_destroy(pepper_wayland_t *conn);
PEPPER_API pepper_output_t *
pepper_wayland_output_create(pepper_wayland_t *conn, int32_t w, int32_t h,
- const char *renderer);
+ const char *renderer);
#ifdef __cplusplus
}
static void
handle_global(void *data, struct wl_registry *registry,
- uint32_t name, const char *interface, uint32_t version)
+ uint32_t name, const char *interface, uint32_t version)
{
pepper_wayland_t *conn = data;
if (strcmp(interface, "wl_compositor") == 0) {
conn->compositor = wl_registry_bind(registry, name, &wl_compositor_interface,
- 1);
+ 1);
} else if (strcmp(interface, "wl_seat") == 0) {
wayland_handle_global_seat(conn, registry, name, version);
} else if (strcmp(interface, "wl_shell") == 0) {
conn->fd = wl_display_get_fd(conn->display);
conn->gl_renderer = pepper_gl_renderer_create(compositor, conn->display,
- "wayland");
+ "wayland");
conn->pixman_renderer = pepper_pixman_renderer_create(compositor);
if (!conn->pixman_renderer) {
compositor_display = pepper_compositor_get_display(compositor);
loop = wl_display_get_event_loop(compositor_display);
conn->event_source = wl_event_loop_add_fd(loop, conn->fd, WL_EVENT_READABLE,
- handle_wayland_event, conn);
+ handle_wayland_event, conn);
wl_event_source_check(conn->event_source);
pepper_list_init(&conn->seat_list);
static void
pointer_handle_enter(void *data, struct wl_pointer *pointer,
- uint32_t serial, struct wl_surface *surface,
- wl_fixed_t surface_x, wl_fixed_t surface_y)
+ uint32_t serial, struct wl_surface *surface,
+ wl_fixed_t surface_x, wl_fixed_t surface_y)
{
/* TODO */
}
static void
pointer_handle_leave(void *data, struct wl_pointer *pointer,
- uint32_t serial, struct wl_surface *surface)
+ uint32_t serial, struct wl_surface *surface)
{
/* TODO */
}
static void
pointer_handle_motion(void *data, struct wl_pointer *pointer,
- uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y)
+ uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y)
{
/* TODO */
}
static void
pointer_handle_button(void *data, struct wl_pointer *pointer,
- uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
+ uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
{
/* TODO */
}
static void
pointer_handle_axis(void *data, struct wl_pointer *pointer,
- uint32_t time, uint32_t axis, wl_fixed_t value)
+ uint32_t time, uint32_t axis, wl_fixed_t value)
{
/* TODO */
}
static void
keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
- uint32_t format, int32_t fd, uint32_t size)
+ uint32_t format, int32_t fd, uint32_t size)
{
/* TODO */
}
static void
keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
- uint32_t serial, struct wl_surface *surface,
- struct wl_array *keys)
+ uint32_t serial, struct wl_surface *surface,
+ struct wl_array *keys)
{
/* TODO */
}
static void
keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
- uint32_t serial, struct wl_surface *surface)
+ uint32_t serial, struct wl_surface *surface)
{
/* TODO */
}
static void
keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
- uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
+ uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
{
/* TODO */
}
static void
keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
- uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched,
- uint32_t mods_locked, uint32_t group)
+ uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched,
+ uint32_t mods_locked, uint32_t group)
{
/* TODO */
}
static void
keyboard_handle_repeat_info(void *data, struct wl_keyboard *keyboard,
- int32_t rate, int32_t delay)
+ int32_t rate, int32_t delay)
{
/* TODO */
}
static void
touch_handle_down(void *data, struct wl_touch *touch,
- uint32_t serial, uint32_t time, struct wl_surface *surface,
- int32_t id, wl_fixed_t x, wl_fixed_t y)
+ uint32_t serial, uint32_t time, struct wl_surface *surface,
+ int32_t id, wl_fixed_t x, wl_fixed_t y)
{
/* TODO */
}
static void
touch_handle_up(void *data, struct wl_touch *touch,
- uint32_t serial, uint32_t time, int32_t id)
+ uint32_t serial, uint32_t time, int32_t id)
{
/* TODO */
}
static void
touch_handle_motion(void *data, struct wl_touch *touch,
- uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y)
+ uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y)
{
/* TODO */
}
wl_pointer_add_listener(seat->pointer.wl_pointer, &pointer_listener, seat);
seat->pointer.base = pepper_input_device_create(seat->conn->pepper,
- WL_SEAT_CAPABILITY_POINTER,
- NULL, NULL);
+ WL_SEAT_CAPABILITY_POINTER,
+ NULL, NULL);
} else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && (seat->pointer.wl_pointer)) {
pepper_input_device_destroy(seat->pointer.base);
wl_pointer_release(seat->pointer.wl_pointer);
wl_keyboard_add_listener(seat->keyboard.wl_keyboard, &keyboard_listener, seat);
seat->keyboard.base = pepper_input_device_create(seat->conn->pepper,
- WL_SEAT_CAPABILITY_KEYBOARD,
- NULL, NULL);
+ WL_SEAT_CAPABILITY_KEYBOARD,
+ NULL, NULL);
} else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) &&
- (seat->keyboard.wl_keyboard)) {
+ (seat->keyboard.wl_keyboard)) {
pepper_input_device_destroy(seat->keyboard.base);
wl_keyboard_release(seat->keyboard.wl_keyboard);
seat->keyboard.wl_keyboard = NULL;
wl_touch_add_listener(seat->touch.wl_touch, &touch_listener, seat);
seat->touch.base = pepper_input_device_create(seat->conn->pepper,
- WL_SEAT_CAPABILITY_KEYBOARD,
- NULL, NULL);
+ WL_SEAT_CAPABILITY_KEYBOARD,
+ NULL, NULL);
} else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && (seat->touch.wl_touch)) {
pepper_input_device_destroy(seat->touch.base);
wl_touch_release(seat->touch.wl_touch);
void
wayland_handle_global_seat(pepper_wayland_t *conn, struct wl_registry *registry,
- uint32_t name, uint32_t version)
+ uint32_t name, uint32_t version)
{
wayland_seat_t *seat;
void
wayland_handle_global_seat(pepper_wayland_t *conn, struct wl_registry *registry,
- uint32_t name, uint32_t version);
+ uint32_t name, uint32_t version);
wayland_shm_buffer_t *
wayland_shm_buffer_create(wayland_output_t *output);
static void
shell_surface_ping(void *data, struct wl_shell_surface *shell_surface,
- uint32_t serial)
+ uint32_t serial)
{
wl_shell_surface_pong(shell_surface, serial);
}
static void
shell_surface_configure(void *data, struct wl_shell_surface *shell_surface,
- uint32_t edges,
- int32_t w, int32_t h)
+ uint32_t edges,
+ int32_t w, int32_t h)
{
wayland_output_t *output = data;
wayland_shm_buffer_t *buffer, *tmp;
output->render_pre(output);
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- damage);
+ damage);
pepper_plane_clear_damage_region(plane);
if (output->render_post)
static void
wayland_output_attach_surface(void *o, pepper_surface_t *surface, int *w,
- int *h)
+ int *h)
{
pepper_renderer_attach_surface(((wayland_output_t *)o)->renderer, surface, w,
- h);
+ h);
}
static void
wayland_output_flush_surface_damage(void *o, pepper_surface_t *surface,
- pepper_bool_t *keep_buffer)
+ pepper_bool_t *keep_buffer)
{
wayland_output_t *output = o;
pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
pepper_renderer_flush_surface_damage(output->renderer, surface);
if (output->renderer == output->conn->pixman_renderer ||
- (buffer && !wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
+ (buffer && !wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
*keep_buffer = PEPPER_TRUE;
} else {
*keep_buffer = PEPPER_FALSE;
return PEPPER_FALSE;
output->egl.window = wl_egl_window_create(output->surface, output->w,
- output->h);
+ output->h);
if (!output->egl.window)
return PEPPER_FALSE;
output->gl_render_target = pepper_gl_renderer_create_target(
- output->conn->renderer,
- output->egl.window,
- PEPPER_FORMAT_ARGB8888, NULL,
- output->w, output->h);
+ output->conn->renderer,
+ output->egl.window,
+ PEPPER_FORMAT_ARGB8888, NULL,
+ output->w, output->h);
if (!output->gl_render_target) {
wl_egl_window_destroy(output->egl.window);
PEPPER_API pepper_output_t *
pepper_wayland_output_create(pepper_wayland_t *conn, int32_t w, int32_t h,
- const char *renderer)
+ const char *renderer)
{
wayland_output_t *output;
/* Create wayland resources. */
output->surface = wl_compositor_create_surface(conn->compositor);
output->shell_surface = wl_shell_get_shell_surface(conn->shell,
- output->surface);
+ output->surface);
wl_shell_surface_add_listener(output->shell_surface, &shell_surface_listener,
- output);
+ output);
wl_shell_surface_set_toplevel(output->shell_surface);
snprintf(&output->name[0], 32, "wayland-%p", output);
/* Add compositor base class output object for this output. */
output->base = pepper_compositor_add_output(conn->pepper,
- &wayland_output_backend,
- output->name, output, WL_OUTPUT_TRANSFORM_NORMAL, 1);
+ &wayland_output_backend,
+ output->name, output, WL_OUTPUT_TRANSFORM_NORMAL, 1);
if (!output->base) {
wayland_output_destroy(output);
return NULL;
}
buffer->pixels = mmap(NULL, buffer->size, PROT_READ | PROT_WRITE, MAP_SHARED,
- fd, 0);
+ fd, 0);
if (!buffer->pixels) {
PEPPER_ERROR("mmap() failed for fd=%d\n", fd);
goto error;
pool = wl_shm_create_pool(output->conn->shm, fd, buffer->size);
buffer->buffer = wl_shm_pool_create_buffer(pool, 0, buffer->w, buffer->h,
- buffer->stride, WL_SHM_FORMAT_ARGB8888);
+ buffer->stride, WL_SHM_FORMAT_ARGB8888);
wl_buffer_add_listener(buffer->buffer, &buffer_listener, buffer);
wl_shm_pool_destroy(pool);
close(fd);
buffer->target = pepper_pixman_renderer_create_target(PEPPER_FORMAT_ARGB8888,
- buffer->pixels, buffer->stride,
- buffer->w, buffer->h);
+ buffer->pixels, buffer->stride,
+ buffer->w, buffer->h);
if (!buffer->target)
goto error;
PEPPER_API pepper_output_t *
pepper_x11_output_create(pepper_x11_connection_t *connection,
- int x, int y, int w, int h, int transform, int scale,
- const char *renderer);
+ int x, int y, int w, int h, int transform, int scale,
+ const char *renderer);
PEPPER_API pepper_bool_t
pepper_x11_input_create(pepper_x11_connection_t *conn);
static inline pepper_bool_t
x11_get_next_event(xcb_connection_t *xcb_conn, xcb_generic_event_t **event,
- uint32_t mask)
+ uint32_t mask)
{
*event = xcb_poll_for_event(xcb_conn);
return *event != NULL;
for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
cookies[i] = xcb_intern_atom(conn->xcb_connection, 0,
- strlen(atoms[i].name),
- atoms[i].name);
+ strlen(atoms[i].name),
+ atoms[i].name);
}
for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
}
connection = (pepper_x11_connection_t *)calloc(1,
- sizeof(pepper_x11_connection_t));
+ sizeof(pepper_x11_connection_t));
if (!connection) {
PEPPER_ERROR("Memory allocation failed\n");
return NULL;
connection->compositor = compositor;
connection->gl_renderer = pepper_gl_renderer_create(connection->compositor,
- connection->display, "x11");
+ connection->display, "x11");
connection->pixman_renderer = pepper_pixman_renderer_create(
- connection->compositor);
+ connection->compositor);
if (!connection->pixman_renderer) {
PEPPER_ERROR("Failed to create pixman renderer.\n");
free(connection);
loop = wl_display_get_event_loop(wdisplay);
connection->xcb_event_source = wl_event_loop_add_fd(loop,
- connection->fd,
- WL_EVENT_READABLE,
- x11_handle_event,
- connection);
+ connection->fd,
+ WL_EVENT_READABLE,
+ x11_handle_event,
+ connection);
wl_event_source_check(connection->xcb_event_source);
pepper_list_init(&connection->output_list);
uint32_t mask = XCB_CW_CURSOR;
uint32_t value_list = cursor->xcb_cursor;
xcb_change_window_attributes(conn->xcb_connection,
- output->window,
- mask,
- &value_list);
+ output->window,
+ mask,
+ &value_list);
}
return current_cursor;
}
if (w < 0 || h < 0) {
PEPPER_ERROR("x11:output:cursor:%s: width(%d) or height(%d) is invalid\n",
- __FUNCTION__, w, h);
+ __FUNCTION__, w, h);
return NULL;
}
gc = xcb_generate_id(conn->xcb_connection);
xcb_create_pixmap(conn->xcb_connection, 1/*depth?*/,
- pixmap, conn->screen->root, w, h);
+ pixmap, conn->screen->root, w, h);
xcb_create_gc(conn->xcb_connection, gc, pixmap, 0, NULL);
xcb_put_image(conn->xcb_connection, XCB_IMAGE_FORMAT_XY_PIXMAP, pixmap,
- gc, w, h, 0, 0, 0, 32, w * h * sizeof(uint8_t), cursor->data);
+ gc, w, h, 0, 0, 0, 32, w * h * sizeof(uint8_t), cursor->data);
cursor->xcb_cursor = xcb_generate_id(conn->xcb_connection);
/*
* cb_void_cookie_t xcb_create_cursor(xcb_connection_t *conn,
* uint16_t y);
*/
xcb_create_cursor(conn->xcb_connection, cursor->xcb_cursor,
- pixmap, pixmap, 0, 0, 0, 0, 0, 0, 1, 1);
+ pixmap, pixmap, 0, 0, 0, 0, 0, 0, 1, 1);
xcb_free_gc(conn->xcb_connection, gc);
xcb_free_pixmap(conn->xcb_connection, pixmap);
void
x11_handle_input_event(x11_seat_t *seat, uint32_t type,
- xcb_generic_event_t *xev)
+ xcb_generic_event_t *xev)
{
pepper_input_event_t event;
event.state = PEPPER_KEY_STATE_PRESSED;
pepper_object_emit_event((pepper_object_t *)seat->keyboard,
- PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
+ PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
}
break;
case XCB_KEY_RELEASE: {
event.state = PEPPER_KEY_STATE_RELEASED;
pepper_object_emit_event((pepper_object_t *)seat->keyboard,
- PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
+ PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
}
break;
case XCB_BUTTON_PRESS: {
event.button = get_standard_button(bp->detail);
pepper_object_emit_event((pepper_object_t *)seat->pointer,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON, &event);
}
break;
case XCB_BUTTON_RELEASE: {
event.button = get_standard_button(br->detail);
pepper_object_emit_event((pepper_object_t *)seat->pointer,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_BUTTON, &event);
}
break;
case XCB_MOTION_NOTIFY: {
event.y = motion->event_y;
pepper_object_emit_event((pepper_object_t *)seat->pointer,
- PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION_ABSOLUTE, &event);
+ PEPPER_EVENT_INPUT_DEVICE_POINTER_MOTION_ABSOLUTE, &event);
}
break;
default :
/* Hard-coded: */
seat->pointer = pepper_input_device_create(conn->compositor,
- WL_SEAT_CAPABILITY_POINTER,
- NULL, NULL);
+ WL_SEAT_CAPABILITY_POINTER,
+ NULL, NULL);
if (!seat->pointer) {
PEPPER_ERROR("failed to create pepper pointer device\n");
seat->caps |= WL_SEAT_CAPABILITY_POINTER;
seat->keyboard = pepper_input_device_create(conn->compositor,
- WL_SEAT_CAPABILITY_KEYBOARD,
- NULL, NULL);
+ WL_SEAT_CAPABILITY_KEYBOARD,
+ NULL, NULL);
if (!seat->keyboard) {
PEPPER_ERROR("failed to create pepper keyboard device\n");
void
x11_handle_input_event(x11_seat_t *seat, uint32_t type,
- xcb_generic_event_t *xev);
+ xcb_generic_event_t *xev);
void
x11_output_destroy(void *o);
gl_renderer_init(x11_output_t *output)
{
output->gl_target = pepper_gl_renderer_create_target(
- output->connection->gl_renderer,
- (void *)(intptr_t)output->window,
- PEPPER_FORMAT_ARGB8888,
- &output->connection->screen->root_visual,
- output->w, output->h);
+ output->connection->gl_renderer,
+ (void *)(intptr_t)output->window,
+ PEPPER_FORMAT_ARGB8888,
+ &output->connection->screen->root_visual,
+ output->w, output->h);
if (!output->gl_target) {
PEPPER_ERROR("Failed to create gl render target.\n");
static pepper_bool_t
x11_shm_image_init(x11_shm_image_t *shm, xcb_connection_t *conn, int w, int h,
- int bpp)
+ int bpp)
{
xcb_generic_error_t *err = NULL;
xcb_void_cookie_t cookie;
/* Now create pepper render target */
shm->target = pepper_pixman_renderer_create_target(format, shm->buf,
- w * (bpp / 8), w, h);
+ w * (bpp / 8), w, h);
if (!shm->target) {
PEPPER_ERROR("Failed to create pixman render target\n");
goto err;
/* Find root visual */
scr_iter = xcb_setup_roots_iterator(xcb_get_setup(xcb_conn));
visual_type = xcb_visualtype_get(scr_iter.data,
- scr_iter.data->root_visual);
+ scr_iter.data->root_visual);
if (!visual_type) {
PEPPER_ERROR("Failed to lookup visual for root window\n");
return PEPPER_FALSE;;
}
output->depth = xcb_depth_get(scr_iter.data,
- scr_iter.data->root_visual);
+ scr_iter.data->root_visual);
fmt_iter = xcb_setup_pixmap_formats_iterator(xcb_get_setup(xcb_conn));
for (; fmt_iter.rem; xcb_format_next(&fmt_iter)) {
hints.min_width = hints.max_width = output->w;
hints.min_height = hints.max_height = output->h;
xcb_change_property(conn,
- XCB_PROP_MODE_REPLACE,
- output->window,
- output->connection->atom.wm_normal_hints,
- output->connection->atom.wm_size_hints,
- 32,
- sizeof(hints) / 4,
- (uint8_t *)&hints);
+ XCB_PROP_MODE_REPLACE,
+ output->window,
+ output->connection->atom.wm_normal_hints,
+ output->connection->atom.wm_size_hints,
+ 32,
+ sizeof(hints) / 4,
+ (uint8_t *)&hints);
/* resize window */
xcb_configure_window (conn,
- output->window,
- XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
- values);
+ output->window,
+ XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
+ values);
/* resize image */
if (output->shm.target) {
/* Init x11_shm_image */
if (!x11_shm_image_init(&output->shm, conn, output->w, output->h,
- output->bpp)) {
+ output->bpp)) {
PEPPER_ERROR("x11_shm_image_init failed\n");
return PEPPER_FALSE;
}
pepper_renderer_set_target(output->renderer, output->target);
pepper_renderer_repaint_output(output->renderer, output->base, render_list,
- damage);
+ damage);
pepper_plane_clear_damage_region(plane);
if (output->renderer == output->connection->pixman_renderer) {
xcb_generic_error_t *err;
cookie = xcb_shm_put_image_checked(output->connection->xcb_connection,
- output->window,
- output->gc,
- output->w,
- output->h,
- 0, /* src_x */
- 0, /* src_y */
- output->shm.w, /* src_w */
- output->shm.h, /* src_h */
- 0, /* dst_x */
- 0, /* dst_y */
- output->depth, /* depth */
- XCB_IMAGE_FORMAT_Z_PIXMAP, /* format */
- 0, /* send_event */
- output->shm.segment, /* xcb shm segment */
- 0); /* offset */
+ output->window,
+ output->gc,
+ output->w,
+ output->h,
+ 0, /* src_x */
+ 0, /* src_y */
+ output->shm.w, /* src_w */
+ output->shm.h, /* src_h */
+ 0, /* dst_x */
+ 0, /* dst_y */
+ output->depth, /* depth */
+ XCB_IMAGE_FORMAT_Z_PIXMAP, /* format */
+ 0, /* send_event */
+ output->shm.segment, /* xcb shm segment */
+ 0); /* offset */
err = xcb_request_check(output->connection->xcb_connection, cookie);
if (err) {
static void
x11_output_flush_surface_damage(void *o, pepper_surface_t *surface,
- pepper_bool_t *keep_buffer)
+ pepper_bool_t *keep_buffer)
{
x11_output_t *output = o;
pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
pepper_renderer_flush_surface_damage(output->renderer, surface);
if (output->renderer == output->connection->pixman_renderer ||
- (buffer && !wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
+ (buffer && !wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
*keep_buffer = PEPPER_TRUE;
} else {
*keep_buffer = PEPPER_FALSE;
PEPPER_API pepper_output_t *
pepper_x11_output_create(pepper_x11_connection_t *connection,
- int x, int y, int w, int h, int transform, int scale,
- const char *renderer)
+ int x, int y, int w, int h, int transform, int scale,
+ const char *renderer)
{
static const char *window_name = "PePPer Compositor";
static const char *class_name = "pepper-1\0PePPer Compositor";
output->window = xcb_generate_id(connection->xcb_connection);
xcb_create_window(connection->xcb_connection,
- XCB_COPY_FROM_PARENT,
- output->window,
- connection->screen->root,
- 0, 0, w, h, 0,
- XCB_WINDOW_CLASS_INPUT_OUTPUT,
- connection->screen->root_visual,
- mask,
- values);
+ XCB_COPY_FROM_PARENT,
+ output->window,
+ connection->screen->root,
+ 0, 0, w, h, 0,
+ XCB_WINDOW_CLASS_INPUT_OUTPUT,
+ connection->screen->root_visual,
+ mask,
+ values);
/* cannot resize */
memset(&hints, 0, sizeof(hints));
hints.min_width = hints.max_width = w;
hints.min_height = hints.max_height = h;
xcb_change_property(connection->xcb_connection,
- XCB_PROP_MODE_REPLACE,
- output->window,
- connection->atom.wm_normal_hints,
- connection->atom.wm_size_hints,
- 32,
- sizeof(hints) / 4,
- (uint8_t *)&hints);
+ XCB_PROP_MODE_REPLACE,
+ output->window,
+ connection->atom.wm_normal_hints,
+ connection->atom.wm_size_hints,
+ 32,
+ sizeof(hints) / 4,
+ (uint8_t *)&hints);
/* set window name */
xcb_change_property(connection->xcb_connection, XCB_PROP_MODE_REPLACE,
- output->window,
- connection->atom.net_wm_name,
- connection->atom.utf8_string, 8,
- strlen(window_name), window_name);
+ output->window,
+ connection->atom.net_wm_name,
+ connection->atom.utf8_string, 8,
+ strlen(window_name), window_name);
xcb_change_property(connection->xcb_connection, XCB_PROP_MODE_REPLACE,
- output->window,
- connection->atom.wm_class,
- connection->atom.string, 8,
- strlen(class_name), class_name);
+ output->window,
+ connection->atom.wm_class,
+ connection->atom.string, 8,
+ strlen(class_name), class_name);
/* set property to receive wm_delete_window message */
list[0] = connection->atom.wm_delete_window;
xcb_change_property(connection->xcb_connection, XCB_PROP_MODE_REPLACE,
- output->window,
- connection->atom.wm_protocols,
- XCB_ATOM_ATOM, 32,
- 1, list);
+ output->window,
+ connection->atom.wm_protocols,
+ XCB_ATOM_ATOM, 32,
+ 1, list);
xcb_map_window(connection->xcb_connection, output->window);
if (connection->use_xinput)
x11_window_input_property_change(connection->xcb_connection,
- output->window);
+ output->window);
pepper_list_insert(&connection->output_list, &output->link);
xcb_flush(connection->xcb_connection);
wldisplay = pepper_compositor_get_display(connection->compositor);
loop = wl_display_get_event_loop(wldisplay);
output->frame_done_timer = wl_event_loop_add_timer(loop, frame_done_handler,
- output);
+ output);
/* Init renderer */
renderer_init(output, renderer);
/* Register output object */
snprintf(&output->name[0], 32, "x11-%p", output);
base = pepper_compositor_add_output(connection->compositor,
- &x11_output_backend, output->name, output,
- transform, scale);
+ &x11_output_backend, output->name, output,
+ transform, scale);
if (!base) {
PEPPER_ERROR("pepper_compositor_add_output failed\n");
x11_output_destroy(output);
PEPPER_ASSERT(conn);
output = pepper_x11_output_create(conn, 0, 0, 1024, 768,
- WL_OUTPUT_TRANSFORM_90, 1, renderer);
+ WL_OUTPUT_TRANSFORM_90, 1, renderer);
PEPPER_ASSERT(output);
if (!pepper_x11_input_create(conn))
projects / platform / core / uifw / pepper.git / commitdiff