[clutter/wip/wayland: 3/7] Adds wayland-surface actor for wayland compositors
- From: Robert Bragg <rbragg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [clutter/wip/wayland: 3/7] Adds wayland-surface actor for wayland compositors
- Date: Mon, 5 Dec 2011 14:13:16 +0000 (UTC)
commit 9bdeb937655dc76de4848bb9f3e94059a88f1c81
Author: Robert Bragg <robert linux intel com>
Date: Fri May 13 16:54:11 2011 +0100
Adds wayland-surface actor for wayland compositors
This adds a --enable-wayland-compositor configure option which will add
support for a ClutterWaylandSurface actor which can be used to aid in
writing Wayland compositors using Clutter by providing a ClutterActor to
represent Wayland client surfaces.
Notably this configure option isn't tied into any particular backend
since conceptually the compositor support can be used in conjunction
with any clutter backend that has corresponding Cogl support.
clutter/Makefile.am | 8 +
clutter/clutter-backend.c | 41 ++
clutter/wayland/clutter-wayland-compositor.h | 43 ++
clutter/wayland/clutter-wayland-surface.c | 565 ++++++++++++++++++++++++++
clutter/wayland/clutter-wayland-surface.h | 94 +++++
configure.ac | 22 +
doc/reference/clutter/clutter-sections.txt | 15 +
7 files changed, 788 insertions(+), 0 deletions(-)
---
diff --git a/clutter/Makefile.am b/clutter/Makefile.am
index 6b8ad70..c73000b 100644
--- a/clutter/Makefile.am
+++ b/clutter/Makefile.am
@@ -599,6 +599,14 @@ backend_source_c += \
$(srcdir)/wayland/clutter-device-manager-wayland.c
endif # SUPPORT_WAYLAND
+if SUPPORT_WAYLAND_COMPOSITOR
+backend_source_h += \
+ $(srcdir)/wayland/clutter-wayland-compositor.h \
+ $(srcdir)/wayland/clutter-wayland-surface.h
+backend_source_c += \
+ $(srcdir)/wayland/clutter-wayland-surface.c
+endif
+
if SUPPORT_EGL
backend_source_h += $(egl_source_h)
backend_source_c += $(egl_source_c)
diff --git a/clutter/clutter-backend.c b/clutter/clutter-backend.c
index 99871ce..cdb16d4 100644
--- a/clutter/clutter-backend.c
+++ b/clutter/clutter-backend.c
@@ -78,6 +78,10 @@
#include "wayland/clutter-device-manager-wayland.h"
#endif
+#ifdef HAVE_CLUTTER_WAYLAND_COMPOSITOR
+#include <wayland-server.h>
+#endif
+
G_DEFINE_ABSTRACT_TYPE (ClutterBackend, clutter_backend, G_TYPE_OBJECT);
#define DEFAULT_FONT_NAME "Sans 10"
@@ -108,6 +112,13 @@ enum
static guint backend_signals[LAST_SIGNAL] = { 0, };
+/* Global for being able to specify a compositor side wayland display
+ * pointer before clutter initialization */
+#ifdef HAVE_CLUTTER_WAYLAND_COMPOSITOR
+static struct wl_display *_wayland_compositor_display;
+#endif
+
+
static void
clutter_backend_dispose (GObject *gobject)
{
@@ -297,6 +308,11 @@ clutter_backend_real_create_context (ClutterBackend *backend,
if (backend->cogl_display == NULL)
goto error;
+#ifdef HAVE_CLUTTER_WAYLAND_COMPOSITOR
+ cogl_wayland_display_set_compositor_display (backend->cogl_display,
+ _wayland_compositor_display);
+#endif
+
CLUTTER_NOTE (BACKEND, "Setting up the display");
if (!cogl_display_setup (backend->cogl_display, &internal_error))
goto error;
@@ -1302,3 +1318,28 @@ clutter_backend_get_cogl_context (ClutterBackend *backend)
{
return backend->cogl_context;
}
+
+#ifdef HAVE_CLUTTER_WAYLAND_COMPOSITOR
+/**
+ * clutter_wayland_set_compositor_display:
+ * @display: A compositor side struct wl_display pointer
+ *
+ * This informs Clutter of your compositor side Wayland display
+ * object. This must be called before calling clutter_init().
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+void
+clutter_wayland_set_compositor_display (struct wl_display *display)
+{
+ if (_clutter_context_is_initialized ())
+ {
+ g_warning ("%s() can only be used before calling clutter_init()",
+ G_STRFUNC);
+ return;
+ }
+
+ _wayland_compositor_display = display;
+}
+#endif
diff --git a/clutter/wayland/clutter-wayland-compositor.h b/clutter/wayland/clutter-wayland-compositor.h
new file mode 100644
index 0000000..f7fa96e
--- /dev/null
+++ b/clutter/wayland/clutter-wayland-compositor.h
@@ -0,0 +1,43 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2011 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Robert Bragg <robert linux intel com>
+ */
+
+/**
+ * SECTION:clutter-wayland-compositor
+ * @short_description: Wayland compositor specific APIs
+ *
+ * Clutter provides some Wayland specific APIs to aid in writing
+ * Clutter based compositors.
+ *
+ * The Clutter Wayland compositor API is available since Clutter 1.8
+ */
+
+#include <wayland-server.h>
+#include <clutter/wayland/clutter-wayland-surface.h>
+
+G_BEGIN_DECLS
+
+void
+clutter_wayland_set_compositor_display (struct wl_display *display);
+
+G_END_DECLS
diff --git a/clutter/wayland/clutter-wayland-surface.c b/clutter/wayland/clutter-wayland-surface.c
new file mode 100644
index 0000000..84c8dc6
--- /dev/null
+++ b/clutter/wayland/clutter-wayland-surface.c
@@ -0,0 +1,565 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Robert Bragg <robert linux intel com>
+ */
+
+/**
+ * SECTION:clutter-wayland-surface
+ * @Title: ClutterWaylandSurface
+ * @short_description: An actor which displays the content of a client surface
+ *
+ * #ClutterWaylandSurface is an actor for displaying the contents of a client
+ * surface. It is intended to support developers implementing Clutter based
+ * wayland compositors.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define CLUTTER_ENABLE_EXPERIMENTAL_API
+
+#include "clutter-wayland-surface.h"
+
+#include "clutter-actor-private.h"
+#include "clutter-marshal.h"
+#include "clutter-paint-volume-private.h"
+#include "clutter-private.h"
+#include "clutter-backend.h"
+
+#include <cogl/cogl.h>
+
+#include <wayland-server.h>
+
+enum
+{
+ PROP_SURFACE = 1,
+ PROP_WIDTH,
+ PROP_HEIGHT
+};
+
+#if 0
+enum
+{
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0, };
+#endif
+
+struct _ClutterWaylandSurfacePrivate
+{
+ struct wl_surface *surface;
+ CoglTexture2D *buffer;
+ int width, height;
+ CoglPipeline *pipeline;
+ GArray *damage;
+};
+
+G_DEFINE_TYPE (ClutterWaylandSurface,
+ clutter_wayland_surface,
+ CLUTTER_TYPE_ACTOR);
+
+static gboolean
+clutter_wayland_surface_get_paint_volume (ClutterActor *self,
+ ClutterPaintVolume *volume)
+{
+ return clutter_paint_volume_set_from_allocation (volume, self);
+}
+
+static void
+clutter_wayland_surface_queue_damage_redraw (ClutterWaylandSurface *texture,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ ClutterWaylandSurfacePrivate *priv = texture->priv;
+ ClutterActor *self = CLUTTER_ACTOR (texture);
+ ClutterActorBox allocation;
+ float scale_x;
+ float scale_y;
+ ClutterVertex origin;
+ ClutterPaintVolume clip;
+
+ /* NB: clutter_actor_queue_clipped_redraw expects a box in the actor's
+ * coordinate space so we need to convert from surface coordinates to
+ * actor coordinates...
+ */
+
+ /* Calling clutter_actor_get_allocation_box() is enormously expensive
+ * if the actor has an out-of-date allocation, since it triggers
+ * a full redraw. clutter_actor_queue_clipped_redraw() would redraw
+ * the whole stage anyways in that case, so just go ahead and do
+ * it here.
+ */
+ if (!clutter_actor_has_allocation (self))
+ {
+ clutter_actor_queue_redraw (self);
+ return;
+ }
+
+ if (priv->width == 0 || priv->height == 0)
+ return;
+
+ clutter_actor_get_allocation_box (self, &allocation);
+
+ scale_x = (allocation.x2 - allocation.x1) / priv->width;
+ scale_y = (allocation.y2 - allocation.y1) / priv->height;
+
+ _clutter_paint_volume_init_static (&clip, self);
+
+ origin.x = x * scale_x;
+ origin.y = y * scale_y;
+ origin.z = 0;
+ clutter_paint_volume_set_origin (&clip, &origin);
+ clutter_paint_volume_set_width (&clip, width * scale_x);
+ clutter_paint_volume_set_height (&clip, height * scale_y);
+
+ _clutter_actor_queue_redraw_with_clip (self, 0, &clip);
+ clutter_paint_volume_free (&clip);
+}
+
+static void
+free_pipeline (ClutterWaylandSurface *self)
+{
+ ClutterWaylandSurfacePrivate *priv = self->priv;
+
+ if (priv->pipeline)
+ {
+ cogl_object_unref (priv->pipeline);
+ priv->pipeline = NULL;
+ }
+}
+
+static void
+opacity_change_cb (ClutterWaylandSurface *self)
+{
+ free_pipeline (self);
+}
+
+static void
+clutter_wayland_surface_init (ClutterWaylandSurface *self)
+{
+ ClutterWaylandSurfacePrivate *priv =
+ G_TYPE_INSTANCE_GET_PRIVATE (self,
+ CLUTTER_WAYLAND_TYPE_SURFACE,
+ ClutterWaylandSurfacePrivate);
+
+ priv->surface = NULL;
+ priv->width = 0;
+ priv->height = 0;
+ priv->damage = g_array_new (FALSE, FALSE, sizeof (int));
+
+ self->priv = priv;
+
+ g_signal_connect (self, "notify::opacity", G_CALLBACK (opacity_change_cb), NULL);
+}
+
+static void
+clutter_wayland_surface_dispose (GObject *object)
+{
+ ClutterWaylandSurface *self = CLUTTER_WAYLAND_SURFACE (object);
+ ClutterWaylandSurfacePrivate *priv = self->priv;
+
+ if (priv->damage)
+ {
+ g_array_free (priv->damage, TRUE);
+ priv->damage = NULL;
+ }
+
+ G_OBJECT_CLASS (clutter_wayland_surface_parent_class)->dispose (object);
+}
+
+static void
+set_size (ClutterWaylandSurface *self,
+ int width,
+ int height)
+{
+ ClutterWaylandSurfacePrivate *priv = self->priv;
+
+ if (priv->width != width)
+ {
+ priv->width = width;
+ g_object_notify (G_OBJECT (self), "width");
+ }
+ if (priv->height != height)
+ {
+ priv->height = height;
+ g_object_notify (G_OBJECT (self), "height");
+ }
+}
+
+static void
+clutter_wayland_surface_set_surface (ClutterWaylandSurface *self,
+ struct wl_surface *surface)
+{
+ ClutterWaylandSurfacePrivate *priv;
+
+ g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+ priv = self->priv;
+
+ g_return_if_fail (priv->surface == NULL);
+ priv->surface = surface;
+
+ /* XXX: should we freeze/thaw notifications? */
+
+ g_object_notify (G_OBJECT (self), "surface");
+
+ /* We have to wait until the next attach event to find out the surface
+ * geometry... */
+ set_size (self, 0, 0);
+}
+
+static void
+clutter_wayland_surface_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ ClutterWaylandSurface *self = CLUTTER_WAYLAND_SURFACE (object);
+
+ switch (prop_id)
+ {
+ case PROP_SURFACE:
+ clutter_wayland_surface_set_surface (self, g_value_get_pointer (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+clutter_wayland_surface_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ ClutterWaylandSurface *self = CLUTTER_WAYLAND_SURFACE (object);
+ ClutterWaylandSurfacePrivate *priv = self->priv;
+
+ switch (prop_id)
+ {
+ case PROP_SURFACE:
+ g_value_set_pointer (value, priv->surface);
+ break;
+ case PROP_WIDTH:
+ g_value_set_uint (value, priv->width);
+ break;
+ case PROP_HEIGHT:
+ g_value_set_uint (value, priv->height);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+clutter_wayland_surface_paint (ClutterActor *self)
+{
+ ClutterWaylandSurfacePrivate *priv;
+ ClutterActorBox box;
+
+ g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+ priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
+
+ if (G_UNLIKELY (priv->pipeline == NULL))
+ {
+ guint8 paint_opacity = clutter_actor_get_paint_opacity (self);
+
+ priv->pipeline = cogl_pipeline_new ();
+ cogl_pipeline_set_color4ub (priv->pipeline,
+ paint_opacity,
+ paint_opacity,
+ paint_opacity,
+ paint_opacity);
+ cogl_pipeline_set_layer_texture (priv->pipeline, 0,
+ COGL_TEXTURE (priv->buffer));
+ }
+
+ cogl_set_source (priv->pipeline);
+ clutter_actor_get_allocation_box (self, &box);
+ cogl_rectangle (0, 0, box.x2 - box.x1, box.y2 - box.y1);
+}
+
+static void
+clutter_wayland_surface_pick (ClutterActor *self,
+ const ClutterColor *color)
+{
+ ClutterActorBox box;
+
+ cogl_set_source_color4ub (color->red, color->green, color->blue,
+ color->alpha);
+ clutter_actor_get_allocation_box (self, &box);
+ cogl_rectangle (0, 0, box.x2 - box.x1, box.y2 - box.y1);
+}
+
+static void
+clutter_wayland_surface_get_preferred_width (ClutterActor *self,
+ gfloat for_height,
+ gfloat *min_width_p,
+ gfloat *natural_width_p)
+{
+ ClutterWaylandSurfacePrivate *priv;
+
+ g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+ priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
+
+ if (min_width_p)
+ *min_width_p = 0;
+
+ if (natural_width_p)
+ *natural_width_p = priv->width;
+}
+
+static void
+clutter_wayland_surface_get_preferred_height (ClutterActor *self,
+ gfloat for_width,
+ gfloat *min_height_p,
+ gfloat *natural_height_p)
+{
+ ClutterWaylandSurfacePrivate *priv;
+
+ g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+ priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
+
+ if (min_height_p)
+ *min_height_p = 0;
+
+ if (natural_height_p)
+ *natural_height_p = priv->height;
+}
+
+static gboolean
+clutter_wayland_surface_has_overlaps (ClutterActor *self)
+{
+ /* Rectangles never need an offscreen redirect because there are
+ never any overlapping primitives */
+ return FALSE;
+}
+
+static void
+clutter_wayland_surface_class_init (ClutterWaylandSurfaceClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+ GParamSpec *pspec;
+
+ g_type_class_add_private (klass, sizeof (ClutterWaylandSurfacePrivate));
+
+ actor_class->get_paint_volume = clutter_wayland_surface_get_paint_volume;
+ actor_class->paint = clutter_wayland_surface_paint;
+ actor_class->pick = clutter_wayland_surface_pick;
+ actor_class->get_preferred_width =
+ clutter_wayland_surface_get_preferred_width;
+ actor_class->get_preferred_height =
+ clutter_wayland_surface_get_preferred_height;
+ actor_class->has_overlaps = clutter_wayland_surface_has_overlaps;
+
+ object_class->dispose = clutter_wayland_surface_dispose;
+ object_class->set_property = clutter_wayland_surface_set_property;
+ object_class->get_property = clutter_wayland_surface_get_property;
+
+ pspec = g_param_spec_pointer ("surface",
+ P_("Surface"),
+ P_("The underlying wayland surface"),
+ CLUTTER_PARAM_READWRITE|
+ G_PARAM_CONSTRUCT_ONLY);
+
+ g_object_class_install_property (object_class, PROP_SURFACE, pspec);
+
+ pspec = g_param_spec_uint ("width",
+ P_("Surface width"),
+ P_("The width of the underlying wayland surface"),
+ 0, G_MAXUINT,
+ 0,
+ G_PARAM_READABLE);
+
+ g_object_class_install_property (object_class, PROP_WIDTH, pspec);
+
+ pspec = g_param_spec_uint ("height",
+ P_("Surface height"),
+ P_("The height of the underlying wayland surface"),
+ 0, G_MAXUINT,
+ 0,
+ G_PARAM_READABLE);
+
+ g_object_class_install_property (object_class, PROP_HEIGHT, pspec);
+}
+
+/**
+ * clutter_wayland_surface_new:
+ * @surface: the Wayland surface this actor should represent
+ *
+ * Creates a new #ClutterWaylandSurface for @surface
+ *
+ * Return value: A new #ClutterWaylandSurface representing @surface
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+ClutterActor *
+clutter_wayland_surface_new (struct wl_surface *surface)
+{
+ ClutterActor *actor;
+
+ actor = g_object_new (CLUTTER_WAYLAND_TYPE_SURFACE,
+ "surface", surface,
+ NULL);
+
+ return actor;
+}
+
+static void
+free_surface_buffers (ClutterWaylandSurface *self)
+{
+ ClutterWaylandSurfacePrivate *priv = self->priv;
+
+ if (priv->buffer)
+ {
+ cogl_object_unref (priv->buffer);
+ priv->buffer = NULL;
+ free_pipeline (self);
+ }
+}
+
+/**
+ * clutter_wayland_surface_attach_buffer:
+ * @self: A #ClutterWaylandSurface actor
+ * @buffer: A compositor side struct wl_buffer pointer
+ * @error: A #GError
+ *
+ * This associates a client's buffer with the #ClutterWaylandSurface
+ * actor @self. This will automatically result in @self being re-drawn
+ * with the new buffer contents.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+gboolean
+clutter_wayland_surface_attach_buffer (ClutterWaylandSurface *self,
+ struct wl_buffer *buffer,
+ GError **error)
+{
+ ClutterWaylandSurfacePrivate *priv;
+ ClutterBackend *backend = clutter_get_default_backend ();
+ CoglContext *context = clutter_backend_get_cogl_context (backend);
+
+ g_return_val_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self), TRUE);
+
+ priv = self->priv;
+
+ free_surface_buffers (self);
+
+ set_size (self, buffer->width, buffer->height);
+
+ priv->buffer =
+ cogl_wayland_texture_2d_new_from_buffer (context, buffer, error);
+
+ clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
+
+ if (!priv->buffer)
+ return FALSE;
+
+ return TRUE;
+}
+
+/**
+ * clutter_wayland_surface_damage_buffer:
+ * @self: A #ClutterWaylandSurface actor
+ * @buffer: A compositor side struct wl_buffer pointer
+ * @x: The x coordinate of the damaged rectangle
+ * @y: The y coordinate of the damaged rectangle
+ * @width: The width of the damaged rectangle
+ * @height: The height of the damaged rectangle
+ *
+ * This marks a region of the given @buffer has having been changed by
+ * the client. This will automatically result in the corresponding damaged
+ * region of the actor @self being redrawn.
+ *
+ * If multiple regions are changed then this should be called multiple
+ * times with different damage rectangles.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+void
+clutter_wayland_surface_damage_buffer (ClutterWaylandSurface *self,
+ struct wl_buffer *buffer,
+ gint32 x,
+ gint32 y,
+ gint32 width,
+ gint32 height)
+{
+ ClutterWaylandSurfacePrivate *priv;
+
+ g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+ priv = self->priv;
+
+ if (priv->buffer && wl_buffer_is_shm (buffer))
+ {
+ CoglPixelFormat format;
+
+ switch (wl_shm_buffer_get_format (buffer))
+ {
+#if G_BYTE_ORDER == G_BIG_ENDIAN
+ case WL_SHM_FORMAT_PREMULTIPLIED_ARGB32:
+ format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
+ break;
+ case WL_SHM_FORMAT_ARGB32:
+ case WL_SHM_FORMAT_XRGB32:
+ format = COGL_PIXEL_FORMAT_ARGB_8888;
+ break;
+#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
+ case WL_SHM_FORMAT_PREMULTIPLIED_ARGB32:
+ format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
+ break;
+ case WL_SHM_FORMAT_ARGB32:
+ case WL_SHM_FORMAT_XRGB32:
+ 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 (priv->buffer),
+ x, y,
+ x, y,
+ width, height,
+ width, height,
+ format,
+ wl_shm_buffer_get_stride (buffer),
+ wl_shm_buffer_get_data (buffer));
+ }
+
+ clutter_wayland_surface_queue_damage_redraw (self, x, y, width, height);
+}
diff --git a/clutter/wayland/clutter-wayland-surface.h b/clutter/wayland/clutter-wayland-surface.h
new file mode 100644
index 0000000..187ca80
--- /dev/null
+++ b/clutter/wayland/clutter-wayland-surface.h
@@ -0,0 +1,94 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Robert Bragg <robert linux intel com>
+ *
+ */
+
+#ifndef __CLUTTER_WAYLAND_SURFACE_H__
+#define __CLUTTER_WAYLAND_SURFACE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <clutter/clutter.h>
+
+#include <wayland-server.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_WAYLAND_TYPE_SURFACE (clutter_wayland_surface_get_type ())
+#define CLUTTER_WAYLAND_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_WAYLAND_TYPE_SURFACE, ClutterWaylandSurface))
+#define CLUTTER_WAYLAND_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_WAYLAND_TYPE_SURFACE, ClutterWaylandSurfaceClass))
+#define CLUTTER_WAYLAND_IS_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_WAYLAND_TYPE_SURFACE))
+#define CLUTTER_WAYLAND_IS_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_WAYLAND_TYPE_SURFACE))
+#define CLUTTER_WAYLAND_SURFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_WAYLAND_TYPE_SURFACE, ClutterWaylandSurfaceClass))
+
+typedef struct _ClutterWaylandSurface ClutterWaylandSurface;
+typedef struct _ClutterWaylandSurfaceClass ClutterWaylandSurfaceClass;
+typedef struct _ClutterWaylandSurfacePrivate ClutterWaylandSurfacePrivate;
+
+/**
+ * ClutterWaylandSurface:
+ *
+ * The #ClutterWaylandSurface structure contains only private data
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+struct _ClutterWaylandSurface
+{
+ /*< private >*/
+ ClutterActor parent;
+
+ ClutterWaylandSurfacePrivate *priv;
+};
+
+/**
+ * ClutterWaylandSurfaceClass:
+ *
+ * The #ClutterWaylandSurfaceClass structure contains only private data
+ *
+ * Since: 0.8
+ * Stability: unstable
+ */
+struct _ClutterWaylandSurfaceClass
+{
+ /*< private >*/
+ ClutterActorClass parent_class;
+};
+
+GType clutter_wayland_surface_get_type (void) G_GNUC_CONST;
+
+ClutterActor *clutter_wayland_surface_new (struct wl_surface *surface);
+gboolean clutter_wayland_surface_attach_buffer (ClutterWaylandSurface *self,
+ struct wl_buffer *buffer,
+ GError **error);
+void clutter_wayland_surface_damage_buffer (ClutterWaylandSurface *self,
+ struct wl_buffer *buffer,
+ gint32 x,
+ gint32 y,
+ gint32 width,
+ gint32 height);
+
+G_END_DECLS
+
+#endif
diff --git a/configure.ac b/configure.ac
index 9b2cc31..2894097 100644
--- a/configure.ac
+++ b/configure.ac
@@ -325,6 +325,26 @@ AS_IF([test "x$enable_wayland" = "xyes"],
MAINTAINER_COMPILER_FLAGS="-Wshadow"
])
+dnl Note this is orthogonal to the client side support and you can
+dnl use the wayland compositor features with any of the clutter
+dnl backends with corresponding Cogl support.
+AC_ARG_ENABLE([wayland-compositor],
+ [AS_HELP_STRING([--enable-wayland-compositor], [Enable Wayland compositor features])],
+ [],
+ [AS_IF([test "x$SUPPORT_EGL" = "x1"],
+ [enable_wayland_compositor=yes],
+ [enable_wayland_compositor=no])
+ ])
+
+AS_IF([test "x$enable_wayland_compositor" = "xyes"],
+ [
+ PKG_CHECK_EXISTS([wayland-server],
+ [BACKEND_PC_FILES="$BACKEND_PC_FILES wayland-server"], [])
+ SUPPORT_WAYLAND_COMPOSITOR=1
+ AC_DEFINE([HAVE_CLUTTER_WAYLAND_COMPOSITOR], [1], [Have wayland compositor support])
+ ])
+AM_CONDITIONAL(SUPPORT_WAYLAND_COMPOSITOR, [test "x$SUPPORT_WAYLAND_COMPOSITOR" = "x1"])
+
AS_IF([test "x$enable_cex100" = "xyes"],
[
CLUTTER_BACKENDS="$CLUTTER_BACKENDS cex100"
@@ -1122,6 +1142,8 @@ echo " - CEx100 backend options:"
echo " libGDL include prefix: ${CLUTTER_CEX100_LIBGDL_PREFIX}"
fi
+echo " Wayland compositor features: ${SUPPORT_WAYLAND_COMPOSITOR}"
+
echo ""
# General warning about experimental features
diff --git a/doc/reference/clutter/clutter-sections.txt b/doc/reference/clutter/clutter-sections.txt
index b965b34..2cf4cbc 100644
--- a/doc/reference/clutter/clutter-sections.txt
+++ b/doc/reference/clutter/clutter-sections.txt
@@ -1343,6 +1343,21 @@ clutter_glx_texture_pixmap_get_type
</SECTION>
<SECTION>
+<FILE>clutter-wayland-compositor</FILE>
+<TITLE>Wayland compositor specific support</TITLE>
+clutter_wayland_set_compositor_display
+</SECTION>
+
+<SECTION>
+<FILE>clutter-wayland-surface</FILE>
+ClutterWaylandSurface
+ClutterWaylandSurfaceClass
+clutter_wayland_surface_new
+clutter_wayland_surface_attach_buffer
+clutter_wayland_surface_damage_buffer
+</SECTION>
+
+<SECTION>
<FILE>clutter-win32</FILE>
<TITLE>Win32 Specific Support</TITLE>
clutter_win32_disable_event_retrieval
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
