brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f7c3c2dc95
mutter/examples/cogland.c
Neil Roberts f7c3c2dc95 cogland: Listen for Expose events when Cogl is using X 
Since 906e1b5eb535a86 Cogland no longer redraws constantly but instead
only draws once at startup and then again whenever a client attaches a
new buffer. Sometimes however it seems that the first paint will get
lost perhaps because it is sent before the window is fully mapped. As
it was previously not handling expose events it would not paint again
until the first client is connected so there would be a blank window
which looks broken.

This patch makes it handle Expose events when it detects that Cogl is
using an X backend. On other backends it will resort to queuing a
redraw every 16ms as it did before.

Although this is probably a bit overkill for such a small example, it
seems like a good idea to only redraw when we think it's necessary so
that we can be sure that the mechanism works. Handling the expose
events means we can have at least one platform where we can test this.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit 99cf15b285302243395873d78f05a5895c173eef)
2013-05-13 17:32:34 +01:00

1237 lines
33 KiB
C
Raw Blame History

#include <cogl/cogl.h>
#include <cogl/cogl-wayland-server.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <string.h>
#include <wayland-server.h>
#ifdef COGL_HAS_XLIB_SUPPORT
#include <cogl/cogl-xlib.h>
#endif
typedef struct _CoglandCompositor CoglandCompositor;
typedef struct
{
int x1, y1, x2, y2;
} CoglandRegion;
typedef struct
{
struct wl_resource resource;
CoglandRegion region;
} CoglandSharedRegion;
typedef struct
{
CoglandCompositor *compositor;
struct wl_resource resource;
int x;
int y;
struct wl_buffer *buffer;
struct wl_listener buffer_destroy_listener;
CoglTexture2D *texture;
CoglBool has_shell_surface;
/* All the pending state, that wl_surface.commit will apply. */
struct
{
/* wl_surface.attach */
CoglBool newly_attached;
struct wl_buffer *buffer;
struct wl_listener buffer_destroy_listener;
int32_t sx;
int32_t sy;
/* wl_surface.damage */
CoglandRegion damage;
/* wl_surface.frame */
struct wl_list frame_callback_list;
} pending;
} CoglandSurface;
typedef struct
{
CoglandSurface *surface;
struct wl_resource resource;
struct wl_listener surface_destroy_listener;
} CoglandShellSurface;
typedef struct
{
uint32_t flags;
int width;
int height;
int refresh;
} CoglandMode;
typedef struct
{
struct wl_object wayland_output;
int32_t x;
int32_t y;
int32_t width_mm;
int32_t height_mm;
CoglOnscreen *onscreen;
GList *modes;
} CoglandOutput;
typedef struct
{
GSource source;
GPollFD pfd;
struct wl_display *display;
} WaylandEventSource;
struct _CoglandCompositor
{
struct wl_display *wayland_display;
struct wl_event_loop *wayland_loop;
CoglContext *cogl_context;
int virtual_width;
int virtual_height;
GList *outputs;
struct wl_list frame_callbacks;
CoglPrimitive *triangle;
CoglPipeline *triangle_pipeline;
GSource *wayland_event_source;
GList *surfaces;
unsigned int redraw_idle;
};
static CoglBool option_multiple_outputs = FALSE;
static GOptionEntry
options[] =
{
{
"multiple", 'm', 0, G_OPTION_ARG_NONE, &option_multiple_outputs,
"Split the compositor into four outputs", NULL
},
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
static CoglBool
process_arguments (int *argc, char ***argv,
GError **error)
{
GOptionContext *context;
CoglBool ret;
GOptionGroup *group;
group = g_option_group_new (NULL, /* name */
NULL, /* description */
NULL, /* help_description */
NULL, /* user_data */
NULL /* destroy notify */);
g_option_group_add_entries (group, options);
context = g_option_context_new ("- An example Wayland compositor using Cogl");
g_option_context_set_main_group (context, group);
ret = g_option_context_parse (context, argc, argv, error);
g_option_context_free (context);
if (ret && *argc > 1)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
"Unknown option '%s'", (* argv)[1]);
ret = FALSE;
}
return ret;
}
static uint32_t
get_time (void)
{
struct timeval tv;
gettimeofday (&tv, NULL);
return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}
static void
region_init (CoglandRegion *region)
{
memset (region, 0, sizeof (*region));
}
static CoglBool
region_is_empty (const CoglandRegion *region)
{
return region->x1 == region->x2 || region->y1 == region->y2;
}
static void
region_add (CoglandRegion *region,
int x,
int y,
int w,
int h)
{
if (region_is_empty (region))
{
region->x1 = x;
region->y1 = y;
region->x2 = x + w;
region->y2 = y + h;
}
else
{
if (x < region->x1)
region->x1 = x;
if (y < region->y1)
region->y1 = y;
if (x + w > region->x2)
region->x2 = x + w;
if (y + h > region->y2)
region->y2 = y + h;
}
}
static void
region_subtract (CoglandRegion *region,
int x,
int y,
int w,
int h)
{
/* FIXME */
}
static CoglBool
wayland_event_source_prepare (GSource *base, int *timeout)
{
WaylandEventSource *source = (WaylandEventSource *)base;
*timeout = -1;
wl_display_flush_clients (source->display);
return FALSE;
}
static CoglBool
wayland_event_source_check (GSource *base)
{
WaylandEventSource *source = (WaylandEventSource *)base;
return source->pfd.revents;
}
static CoglBool
wayland_event_source_dispatch (GSource *base,
GSourceFunc callback,
void *data)
{
WaylandEventSource *source = (WaylandEventSource *)base;
struct wl_event_loop *loop = wl_display_get_event_loop (source->display);
wl_event_loop_dispatch (loop, 0);
return TRUE;
}
static GSourceFuncs wayland_event_source_funcs =
{
wayland_event_source_prepare,
wayland_event_source_check,
wayland_event_source_dispatch,
NULL
};
static GSource *
wayland_event_source_new (struct wl_display *display)
{
WaylandEventSource *source;
struct wl_event_loop *loop =
wl_display_get_event_loop (display);
source = (WaylandEventSource *) g_source_new (&wayland_event_source_funcs,
sizeof (WaylandEventSource));
source->display = display;
source->pfd.fd = wl_event_loop_get_fd (loop);
source->pfd.events = G_IO_IN | G_IO_ERR;
g_source_add_poll (&source->source, &source->pfd);
return &source->source;
}
typedef struct _CoglandFrameCallback
{
struct wl_list link;
/* Pointer back to the compositor */
CoglandCompositor *compositor;
struct wl_resource resource;
} CoglandFrameCallback;
static CoglBool
paint_cb (void *user_data)
{
CoglandCompositor *compositor = user_data;
GList *l;
for (l = compositor->outputs; l; l = l->next)
{
CoglandOutput *output = l->data;
CoglFramebuffer *fb = COGL_FRAMEBUFFER (output->onscreen);
GList *l2;
cogl_push_framebuffer (fb);
cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
cogl_framebuffer_draw_primitive (fb, compositor->triangle_pipeline,
compositor->triangle);
for (l2 = compositor->surfaces; l2; l2 = l2->next)
{
CoglandSurface *surface = l2->data;
if (surface->texture)
{
CoglTexture2D *texture = surface->texture;
cogl_set_source_texture (COGL_TEXTURE (texture));
cogl_rectangle (-1, 1, 1, -1);
}
}
cogl_onscreen_swap_buffers (COGL_ONSCREEN (fb));
cogl_pop_framebuffer ();
}
while (!wl_list_empty (&compositor->frame_callbacks))
{
CoglandFrameCallback *callback =
wl_container_of (compositor->frame_callbacks.next, callback, link);
wl_resource_post_event (&callback->resource,
WL_CALLBACK_DONE, get_time ());
wl_resource_destroy (&callback->resource);
}
compositor->redraw_idle = 0;
return G_SOURCE_REMOVE;
}
static void
cogland_queue_redraw (CoglandCompositor *compositor)
{
if (compositor->redraw_idle == 0)
compositor->redraw_idle = g_idle_add (paint_cb, compositor);
}
static void
surface_damaged (CoglandSurface *surface,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
{
struct wl_buffer *wayland_buffer = surface->buffer;
if (surface->texture &&
wl_buffer_is_shm (surface->buffer))
{
CoglPixelFormat format;
int stride = wl_shm_buffer_get_stride (wayland_buffer);
const uint8_t *data = wl_shm_buffer_get_data (wayland_buffer);
switch (wl_shm_buffer_get_format (wayland_buffer))
{
#if G_BYTE_ORDER == G_BIG_ENDIAN
case WL_SHM_FORMAT_ARGB8888:
format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
break;
case WL_SHM_FORMAT_XRGB8888:
format = COGL_PIXEL_FORMAT_ARGB_8888;
break;
#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
case WL_SHM_FORMAT_ARGB8888:
format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
break;
case WL_SHM_FORMAT_XRGB8888:
format = COGL_PIXEL_FORMAT_BGRA_8888;
break;
#endif
default:
g_warn_if_reached ();
format = COGL_PIXEL_FORMAT_ARGB_8888;
}
cogl_texture_set_region (COGL_TEXTURE (surface->texture),
x, y, /* src_x/y */
x, y, /* dst_x/y */
width, height, /* dst_width/height */
width, height, /* width/height */
format,
stride,
data);
}
cogland_queue_redraw (surface->compositor);
}
static void
cogland_surface_destroy (struct wl_client *wayland_client,
struct wl_resource *wayland_resource)
{
wl_resource_destroy (wayland_resource);
}
static void
cogland_surface_detach_buffer (CoglandSurface *surface)
{
struct wl_buffer *buffer = surface->buffer;
if (buffer)
{
wl_list_remove (&surface->buffer_destroy_listener.link);
surface->buffer = NULL;
if (surface->texture)
{
cogl_object_unref (surface->texture);
surface->texture = NULL;
}
cogland_queue_redraw (surface->compositor);
}
}
static void
surface_handle_buffer_destroy (struct wl_listener *listener,
void *data)
{
CoglandSurface *surface =
wl_container_of (listener, surface, buffer_destroy_listener);
cogland_surface_detach_buffer (surface);
}
static void
cogland_surface_detach_buffer_and_notify (CoglandSurface *surface)
{
struct wl_buffer *buffer = surface->buffer;
if (buffer)
{
g_assert (buffer->resource.client != NULL);
wl_resource_queue_event (&buffer->resource, WL_BUFFER_RELEASE);
cogland_surface_detach_buffer (surface);
}
}
static void
cogland_surface_attach (struct wl_client *wayland_client,
struct wl_resource *wayland_surface_resource,
struct wl_resource *wayland_buffer_resource,
int32_t sx, int32_t sy)
{
CoglandSurface *surface = wayland_surface_resource->data;
struct wl_buffer *buffer =
wayland_buffer_resource ? wayland_buffer_resource->data : NULL;
/* Attach without commit in between does not went wl_buffer.release */
if (surface->pending.buffer)
wl_list_remove (&surface->pending.buffer_destroy_listener.link);
surface->pending.sx = sx;
surface->pending.sy = sy;
surface->pending.buffer = buffer;
surface->pending.newly_attached = TRUE;
if (buffer)
wl_signal_add (&buffer->resource.destroy_signal,
&surface->pending.buffer_destroy_listener);
}
static void
cogland_surface_damage (struct wl_client *client,
struct wl_resource *resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
{
CoglandSurface *surface = resource->data;
region_add (&surface->pending.damage, x, y, width, height);
}
static void
destroy_frame_callback (struct wl_resource *callback_resource)
{
CoglandFrameCallback *callback = callback_resource->data;
wl_list_remove (&callback->link);
g_slice_free (CoglandFrameCallback, callback);
}
static void
cogland_surface_frame (struct wl_client *client,
struct wl_resource *surface_resource,
uint32_t callback_id)
{
CoglandFrameCallback *callback;
CoglandSurface *surface = surface_resource->data;
callback = g_slice_new0 (CoglandFrameCallback);
callback->compositor = surface->compositor;
callback->resource.object.interface = &wl_callback_interface;
callback->resource.object.id = callback_id;
callback->resource.destroy = destroy_frame_callback;
callback->resource.data = callback;
wl_client_add_resource (client, &callback->resource);
wl_list_insert (surface->pending.frame_callback_list.prev, &callback->link);
}
static void
cogland_surface_set_opaque_region (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region)
{
}
static void
cogland_surface_set_input_region (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region)
{
}
static void
cogland_surface_commit (struct wl_client *client,
struct wl_resource *resource)
{
CoglandSurface *surface = resource->data;
CoglandCompositor *compositor = surface->compositor;
/* wl_surface.attach */
if (surface->pending.newly_attached &&
surface->buffer != surface->pending.buffer)
{
CoglError *error = NULL;
cogland_surface_detach_buffer_and_notify (surface);
if (surface->pending.buffer)
{
surface->texture =
cogl_wayland_texture_2d_new_from_buffer (compositor->cogl_context,
surface->pending.buffer,
&error);
if (!surface->texture)
{
g_error ("Failed to create texture_2d from wayland buffer: %s",
error->message);
cogl_error_free (error);
}
surface->buffer = surface->pending.buffer;
wl_signal_add (&surface->buffer->resource.destroy_signal,
&surface->buffer_destroy_listener);
}
}
if (surface->pending.buffer)
{
wl_list_remove (&surface->pending.buffer_destroy_listener.link);
surface->pending.buffer = NULL;
}
surface->pending.sx = 0;
surface->pending.sy = 0;
surface->pending.newly_attached = FALSE;
/* wl_surface.damage */
if (surface->buffer &&
surface->texture &&
!region_is_empty (&surface->pending.damage))
{
CoglandRegion *region = &surface->pending.damage;
CoglTexture *texture = COGL_TEXTURE (surface->texture);
if (region->x2 > cogl_texture_get_width (texture))
region->x2 = cogl_texture_get_width (texture);
if (region->y2 > cogl_texture_get_height (texture))
region->y2 = cogl_texture_get_height (texture);
if (region->x1 < 0)
region->x1 = 0;
if (region->y1 < 0)
region->y1 = 0;
surface_damaged (surface,
region->x1,
region->y1,
region->x2 - region->x1,
region->y2 - region->y1);
}
region_init (&surface->pending.damage);
/* wl_surface.frame */
wl_list_insert_list (&compositor->frame_callbacks,
&surface->pending.frame_callback_list);
wl_list_init (&surface->pending.frame_callback_list);
}
static void
cogland_surface_set_buffer_transform (struct wl_client *client,
struct wl_resource *resource,
int32_t transform)
{
}
const struct wl_surface_interface cogland_surface_interface = {
cogland_surface_destroy,
cogland_surface_attach,
cogland_surface_damage,
cogland_surface_frame,
cogland_surface_set_opaque_region,
cogland_surface_set_input_region,
cogland_surface_commit,
cogland_surface_set_buffer_transform
};
static void
cogland_surface_free (CoglandSurface *surface)
{
CoglandCompositor *compositor = surface->compositor;
CoglandFrameCallback *cb, *next;
compositor->surfaces = g_list_remove (compositor->surfaces, surface);
cogland_surface_detach_buffer_and_notify (surface);
if (surface->pending.buffer)
wl_list_remove (&surface->pending.buffer_destroy_listener.link);
wl_list_for_each_safe (cb, next,
&surface->pending.frame_callback_list, link)
wl_resource_destroy (&cb->resource);
g_slice_free (CoglandSurface, surface);
}
static void
cogland_surface_resource_destroy_cb (struct wl_resource *resource)
{
CoglandSurface *surface = resource->data;
cogland_surface_free (surface);
}
static void
surface_handle_pending_buffer_destroy (struct wl_listener *listener,
void *data)
{
CoglandSurface *surface =
wl_container_of (listener, surface, pending.buffer_destroy_listener);
surface->pending.buffer = NULL;
}
static void
cogland_compositor_create_surface (struct wl_client *wayland_client,
struct wl_resource *wayland_compositor_resource,
uint32_t id)
{
CoglandCompositor *compositor = wayland_compositor_resource->data;
CoglandSurface *surface = g_slice_new0 (CoglandSurface);
surface->compositor = compositor;
surface->resource.destroy =
cogland_surface_resource_destroy_cb;
surface->resource.object.id = id;
surface->resource.object.interface = &wl_surface_interface;
surface->resource.object.implementation =
(void (**)(void)) &cogland_surface_interface;
surface->resource.data = surface;
surface->buffer_destroy_listener.notify =
surface_handle_buffer_destroy;
surface->pending.buffer_destroy_listener.notify =
surface_handle_pending_buffer_destroy;
wl_list_init (&surface->pending.frame_callback_list);
region_init (&surface->pending.damage);
wl_client_add_resource (wayland_client, &surface->resource);
compositor->surfaces = g_list_prepend (compositor->surfaces,
surface);
}
static void
cogland_region_destroy (struct wl_client *client,
struct wl_resource *resource)
{
wl_resource_destroy (resource);
}
static void
cogland_region_add (struct wl_client *client,
struct wl_resource *resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
{
CoglandSharedRegion *shared_region = resource->data;
region_add (&shared_region->region, x, y, width, height);
}
static void
cogland_region_subtract (struct wl_client *client,
struct wl_resource *resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
{
CoglandSharedRegion *shared_region = resource->data;
region_subtract (&shared_region->region, x, y, width, height);
}
const struct wl_region_interface cogland_region_interface = {
cogland_region_destroy,
cogland_region_add,
cogland_region_subtract
};
static void
cogland_region_resource_destroy_cb (struct wl_resource *resource)
{
CoglandSharedRegion *region = resource->data;
g_slice_free (CoglandSharedRegion, region);
}
static void
cogland_compositor_create_region (struct wl_client *wayland_client,
struct wl_resource *compositor_resource,
uint32_t id)
{
CoglandSharedRegion *region = g_slice_new0 (CoglandSharedRegion);
region->resource.destroy =
cogland_region_resource_destroy_cb;
region->resource.object.id = id;
region->resource.object.interface = &wl_region_interface;
region->resource.object.implementation =
(void (**)(void)) &cogland_region_interface;
region->resource.data = region;
region_init (&region->region);
wl_client_add_resource (wayland_client, &region->resource);
}
static void
bind_output (struct wl_client *client,
void *data,
uint32_t version,
uint32_t id)
{
CoglandOutput *output = data;
struct wl_resource *resource =
wl_client_add_object (client, &wl_output_interface, NULL, id, data);
GList *l;
wl_resource_post_event (resource,
WL_OUTPUT_GEOMETRY,
output->x, output->y,
output->width_mm,
output->height_mm,
0, /* subpixel: unknown */
"unknown", /* make */
"unknown"); /* model */
for (l = output->modes; l; l = l->next)
{
CoglandMode *mode = l->data;
wl_resource_post_event (resource,
WL_OUTPUT_MODE,
mode->flags,
mode->width,
mode->height,
mode->refresh);
}
}
static void
cogland_compositor_create_output (CoglandCompositor *compositor,
int x,
int y,
int width_mm,
int height_mm)
{
CoglandOutput *output = g_slice_new0 (CoglandOutput);
CoglFramebuffer *fb;
CoglError *error = NULL;
CoglandMode *mode;
output->x = x;
output->y = y;
output->width_mm = width_mm;
output->height_mm = height_mm;
output->wayland_output.interface = &wl_output_interface;
wl_display_add_global (compositor->wayland_display,
&wl_output_interface,
output,
bind_output);
output->onscreen = cogl_onscreen_new (compositor->cogl_context,
width_mm, height_mm);
/* Eventually there will be an implicit allocate on first use so this
* will become optional... */
fb = COGL_FRAMEBUFFER (output->onscreen);
if (!cogl_framebuffer_allocate (fb, &error))
g_error ("Failed to allocate framebuffer: %s\n", error->message);
cogl_onscreen_show (output->onscreen);
cogl_framebuffer_set_viewport (fb, -x, -y,
compositor->virtual_width,
compositor->virtual_height);
mode = g_slice_new0 (CoglandMode);
mode->flags = 0;
mode->width = width_mm;
mode->height = height_mm;
mode->refresh = 60;
output->modes = g_list_prepend (output->modes, mode);
compositor->outputs = g_list_prepend (compositor->outputs, output);
}
const static struct wl_compositor_interface cogland_compositor_interface =
{
cogland_compositor_create_surface,
cogland_compositor_create_region
};
static void
compositor_bind (struct wl_client *client,
void *data,
uint32_t version,
uint32_t id)
{
CoglandCompositor *compositor = data;
wl_client_add_object (client, &wl_compositor_interface,
&cogland_compositor_interface, id, compositor);
}
static void
shell_surface_pong (struct wl_client *client,
struct wl_resource *resource,
uint32_t serial)
{
}
static void
shell_surface_move (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *seat,
uint32_t serial)
{
}
static void
shell_surface_resize (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *seat,
uint32_t serial,
uint32_t edges)
{
}
static void
shell_surface_set_toplevel (struct wl_client *client,
struct wl_resource *resource)
{
}
static void
shell_surface_set_transient (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *parent,
int32_t x,
int32_t y,
uint32_t flags)
{
}
static void
shell_surface_set_fullscreen (struct wl_client *client,
struct wl_resource *resource,
uint32_t method,
uint32_t framerate,
struct wl_resource *output)
{
}
static void
shell_surface_set_popup (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *seat,
uint32_t serial,
struct wl_resource *parent,
int32_t x,
int32_t y,
uint32_t flags)
{
}
static void
shell_surface_set_maximized (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *output)
{
}
static void
shell_surface_set_title (struct wl_client *client,
struct wl_resource *resource,
const char *title)
{
}
static void
shell_surface_set_class (struct wl_client *client,
struct wl_resource *resource,
const char *class_)
{
}
static const struct wl_shell_surface_interface cogl_shell_surface_interface =
{
shell_surface_pong,
shell_surface_move,
shell_surface_resize,
shell_surface_set_toplevel,
shell_surface_set_transient,
shell_surface_set_fullscreen,
shell_surface_set_popup,
shell_surface_set_maximized,
shell_surface_set_title,
shell_surface_set_class
};
static void
shell_handle_surface_destroy (struct wl_listener *listener,
void *data)
{
CoglandShellSurface *shell_surface =
wl_container_of (listener, shell_surface, surface_destroy_listener);
shell_surface->surface->has_shell_surface = FALSE;
shell_surface->surface = NULL;
wl_resource_destroy (&shell_surface->resource);
}
static void
destroy_shell_surface (struct wl_resource *resource)
{
CoglandShellSurface *shell_surface = resource->data;
/* In case cleaning up a dead client destroys shell_surface first */
if (shell_surface->surface)
{
wl_list_remove (&shell_surface->surface_destroy_listener.link);
shell_surface->surface->has_shell_surface = FALSE;
}
g_free (shell_surface);
}
static void
get_shell_surface (struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource)
{
CoglandSurface *surface = surface_resource->data;
CoglandShellSurface *shell_surface;
if (surface->has_shell_surface)
{
wl_resource_post_error (surface_resource,
WL_DISPLAY_ERROR_INVALID_OBJECT,
"wl_shell::get_shell_surface already requested");
return;
}
shell_surface = g_new0 (CoglandShellSurface, 1);
shell_surface->resource.destroy = destroy_shell_surface;
shell_surface->resource.object.id = id;
shell_surface->resource.object.interface = &wl_shell_surface_interface;
shell_surface->resource.object.implementation =
(void (**) (void)) &cogl_shell_surface_interface;
shell_surface->resource.data = shell_surface;
shell_surface->surface = surface;
shell_surface->surface_destroy_listener.notify = shell_handle_surface_destroy;
wl_signal_add (&surface->resource.destroy_signal,
&shell_surface->surface_destroy_listener);
surface->has_shell_surface = TRUE;
wl_client_add_resource (client, &shell_surface->resource);
}
static const struct wl_shell_interface cogland_shell_interface =
{
get_shell_surface
};
static void
bind_shell (struct wl_client *client,
void *data,
uint32_t version,
uint32_t id)
{
wl_client_add_object (client, &wl_shell_interface,
&cogland_shell_interface, id, data);
}
static CoglContext *
create_cogl_context (CoglandCompositor *compositor,
CoglBool use_egl_constraint,
CoglError **error)
{
CoglRenderer *renderer = renderer = cogl_renderer_new ();
CoglDisplay *display;
CoglContext *context;
if (use_egl_constraint)
cogl_renderer_add_constraint (renderer, COGL_RENDERER_CONSTRAINT_USES_EGL);
if (!cogl_renderer_connect (renderer, error))
{
cogl_object_unref (renderer);
return NULL;
}
display = cogl_display_new (renderer, NULL);
cogl_wayland_display_set_compositor_display (display,
compositor->wayland_display);
context = cogl_context_new (display, error);
cogl_object_unref (renderer);
cogl_object_unref (display);
return context;
}
#ifdef COGL_HAS_XLIB_SUPPORT
static CoglFilterReturn
x_event_cb (XEvent *event,
void *data)
{
CoglandCompositor *compositor = data;
if (event->type == Expose)
cogland_queue_redraw (compositor);
return COGL_FILTER_CONTINUE;
}
#endif /* COGL_HAS_XLIB_SUPPORT */
static gboolean
timeout_cb (void *data)
{
cogland_queue_redraw (data);
return TRUE;
}
static void
init_redraws (CoglandCompositor *compositor)
{
#ifdef COGL_HAS_XLIB_SUPPORT
CoglRenderer *renderer = cogl_context_get_renderer (compositor->cogl_context);
CoglWinsysID winsys = cogl_renderer_get_winsys_id (renderer);
/* If Cogl is using X then we can listen for Expose events to know
* when to repaint the window. Otherwise we don't have any code to
* know when the contents of the window is dirty so we'll just
* redraw constantly */
switch (winsys)
{
case COGL_WINSYS_ID_GLX:
case COGL_WINSYS_ID_EGL_XLIB:
{
Display *display = cogl_xlib_renderer_get_display (renderer);
GList *l;
for (l = compositor->outputs; l; l = l->next)
{
CoglandOutput *output = l->data;
XWindowAttributes win_attribs;
Window win;
win = cogl_x11_onscreen_get_window_xid (output->onscreen);
if (XGetWindowAttributes (display, win, &win_attribs))
{
XSelectInput (display,
win,
win_attribs.your_event_mask | ExposureMask);
cogl_xlib_renderer_add_filter (renderer,
x_event_cb,
compositor);
}
}
}
return;
default:
break;
}
#endif /* COGL_HAS_XLIB_SUPPORT */
g_timeout_add (16, timeout_cb, compositor);
}
int
main (int argc, char **argv)
{
CoglandCompositor compositor;
GMainLoop *loop;
CoglError *error = NULL;
GError *gerror = NULL;
CoglVertexP2C4 triangle_vertices[] = {
{0, 0.7, 0xff, 0x00, 0x00, 0xff},
{-0.7, -0.7, 0x00, 0xff, 0x00, 0xff},
{0.7, -0.7, 0x00, 0x00, 0xff, 0xff}
};
GSource *cogl_source;
if (!process_arguments (&argc, &argv, &gerror))
{
fprintf (stderr, "%s\n", gerror->message);
return EXIT_FAILURE;
}
memset (&compositor, 0, sizeof (compositor));
compositor.wayland_display = wl_display_create ();
if (compositor.wayland_display == NULL)
g_error ("failed to create wayland display");
wl_list_init (&compositor.frame_callbacks);
if (!wl_display_add_global (compositor.wayland_display,
&wl_compositor_interface,
&compositor,
compositor_bind))
g_error ("Failed to register wayland compositor object");
wl_display_init_shm (compositor.wayland_display);
loop = g_main_loop_new (NULL, FALSE);
compositor.wayland_loop =
wl_display_get_event_loop (compositor.wayland_display);
compositor.wayland_event_source =
wayland_event_source_new (compositor.wayland_display);
g_source_attach (compositor.wayland_event_source, NULL);
/* We want Cogl to use an EGL renderer because otherwise it won't
* set up the wl_drm object and only SHM buffers will work. */
compositor.cogl_context =
create_cogl_context (&compositor,
TRUE /* use EGL constraint */,
&error);
if (compositor.cogl_context == NULL)
{
/* If we couldn't get an EGL context then try any type of
* context */
cogl_error_free (error);
error = NULL;
compositor.cogl_context =
create_cogl_context (&compositor,
FALSE, /* don't set EGL constraint */
&error);
if (compositor.cogl_context)
g_warning ("Failed to create context with EGL constraint, "
"falling back");
else
g_error ("Failed to create a Cogl context: %s\n", error->message);
}
compositor.virtual_width = 800;
compositor.virtual_height = 600;
if (option_multiple_outputs)
{
int hw = compositor.virtual_width / 2;
int hh = compositor.virtual_height / 2;
/* Emulate compositing with multiple monitors... */
cogland_compositor_create_output (&compositor, 0, 0, hw, hh);
cogland_compositor_create_output (&compositor, hw, 0, hw, hh);
cogland_compositor_create_output (&compositor, 0, hh, hw, hh);
cogland_compositor_create_output (&compositor, hw, hh, hw, hh);
}
else
{
cogland_compositor_create_output (&compositor,
0, 0,
compositor.virtual_width,
compositor.virtual_height);
}
if (wl_display_add_global (compositor.wayland_display, &wl_shell_interface,
&compositor, bind_shell) == NULL)
g_error ("Failed to register a global shell object");
if (wl_display_add_socket (compositor.wayland_display, "wayland-0"))
g_error ("Failed to create socket");
compositor.triangle = cogl_primitive_new_p2c4 (compositor.cogl_context,
COGL_VERTICES_MODE_TRIANGLES,
3, triangle_vertices);
compositor.triangle_pipeline = cogl_pipeline_new (compositor.cogl_context);
cogl_source = cogl_glib_source_new (compositor.cogl_context,
G_PRIORITY_DEFAULT);
g_source_attach (cogl_source, NULL);
init_redraws (&compositor);
g_main_loop_run (loop);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink