Adds Cogl Hello World and "X11 foreign" example applications

This adds a simple standalone Cogl application that can be used to
smoke test a standalone build of Cogl without Clutter.

This also adds an x11-foreign app that shows how a toolkit can ask Cogl
to draw to an X Window that it owns instead of Cogl being responsible
for automatically creating and mapping an X Window for CoglOnscreen.

Makefile.am

@@ -1,7 +1,7 @@
 SUBDIRS = cogl pango
 
 if COGL_STANDALONE_BUILD
-SUBDIRS += po
+SUBDIRS += po examples
 endif
 
 ACLOCAL_AMFLAGS = -I build/autotools ${ACLOCAL_FLAGS}

configure.ac

@@ -660,6 +660,7 @@ cogl/cogl-1.0.pc
 cogl/cogl-$COGL_MAJOR_VERSION.0.pc:cogl/cogl.pc.in
 cogl/cogl-defines.h
 pango/Makefile
+examples/Makefile
 po/Makefile.in
 )
 

examples/Makefile.am

@@ -0,0 +1,31 @@
+include $(top_srcdir)/build/autotools/Makefile.am.silent
+
+INCLUDES = \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/clutter/cogl \
+	-I$(top_builddir)/clutter/cogl
+
+AM_CFLAGS = \
+	$(COGL_DEP_CFLAGS) \
+	$(COGL_EXTRA_CFLAGS) \
+	-DCOGL_ENABLE_EXPERIMENTAL_2_0_API
+
+AM_CPPFLAGS = \
+	-DG_DISABLE_SINGLE_INCLUDES \
+	-DCOGL_DISABLE_DEPRECATED
+
+
+common_ldadd = \
+	$(top_builddir)/cogl/libcogl.la \
+	$(top_builddir)/pango/libcoglpango.la
+
+noinst_PROGRAMS = hello
+
+hello_SOURCES = hello.c
+hello_LDADD = $(common_ldadd)
+
+if X11_TESTS
+noinst_PROGRAMS += x11-foreign
+x11_foreign_SOURCES = x11-foreign.c
+x11_foreign_LDADD = $(common_ldadd)
+endif

examples/hello.c

@@ -0,0 +1,47 @@
+#include <cogl/cogl.h>
+#include <glib.h>
+#include <stdio.h>
+
+int
+main (int argc, char **argv)
+{
+    CoglContext *ctx;
+    CoglOnscreen *onscreen;
+    CoglFramebuffer *fb;
+    GError *error = NULL;
+    CoglVertexP2C4 triangle_vertices[] = {
+        {0, 0.7, 0xff, 0x00, 0x00, 0x80},
+        {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff},
+        {0.7, -0.7, 0x00, 0x00, 0xff, 0xff}
+    };
+    CoglPrimitive *triangle;
+
+    ctx = cogl_context_new (NULL, &error);
+    if (!ctx) {
+        fprintf (stderr, "Failed to create context: %s\n", error->message);
+        return 1;
+    }
+    /* Eventually we want to get rid of any "default context" but for now it's
+     * needed...  */
+    cogl_set_default_context (ctx);
+
+    onscreen = cogl_onscreen_new (ctx, 640, 480);
+    /* Eventually there will be an implicit allocate on first use so this
+     * will become optional... */
+    fb = COGL_FRAMEBUFFER (onscreen);
+    if (!cogl_framebuffer_allocate (fb, &error)) {
+        fprintf (stderr, "Failed to allocate framebuffer: %s\n", error->message);
+        return 1;
+    }
+
+    cogl_push_framebuffer (fb);
+
+    triangle = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLES,
+                                        3, triangle_vertices);
+    for (;;) {
+        cogl_primitive_draw (triangle);
+        cogl_framebuffer_swap_buffers (fb);
+    }
+
+    return 0;
+}

examples/x11-foreign.c

@@ -0,0 +1,136 @@
+#include <cogl/cogl.h>
+#include <glib.h>
+#include <stdio.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+int
+main (int argc, char **argv)
+{
+  Display *xdpy;
+  CoglRenderer *renderer;
+  CoglSwapChain *chain;
+  CoglOnscreenTemplate *onscreen_template;
+  CoglDisplay *display;
+  CoglContext *ctx;
+  CoglOnscreen *onscreen;
+  CoglFramebuffer *fb;
+  GError *error = NULL;
+  guint32 visual;
+  XVisualInfo template, *xvisinfo;
+  int visinfos_count;
+  XSetWindowAttributes xattr;
+  unsigned long mask;
+  Window xwin;
+
+  /* Since we want to test external ownership of the X display,
+   * connect to X manually... */
+  xdpy = XOpenDisplay (NULL);
+  if (!xdpy)
+    {
+      fprintf (stderr, "Failed to open X Display\n");
+      return 1;
+    }
+
+  /* Conceptually choose a GPU... */
+  renderer = cogl_renderer_new ();
+  /* FIXME: This should conceptually be part of the configuration of
+   * a renderer. */
+  cogl_renderer_xlib_set_foreign_display (renderer, xdpy);
+  if (!cogl_renderer_connect (renderer, &error))
+    {
+      fprintf (stderr, "Failed to connect to a renderer: %s\n",
+               error->message);
+    }
+
+  chain = cogl_swap_chain_new ();
+  cogl_swap_chain_set_has_alpha (chain, TRUE);
+
+  /* Conceptually declare upfront the kinds of windows we anticipate
+   * creating so that when we configure the display pipeline we can avoid
+   * having an impedance miss-match between the format of windows and the
+   * format the display pipeline expects. */
+  onscreen_template = cogl_onscreen_template_new (chain);
+  cogl_object_unref (chain);
+
+  /* Conceptually setup a display pipeline */
+  display = cogl_display_new (renderer, onscreen_template);
+  cogl_object_unref (renderer);
+  if (!cogl_display_setup (display, &error))
+    {
+      fprintf (stderr, "Failed to setup a display pipeline: %s\n",
+               error->message);
+      return 1;
+    }
+
+  ctx = cogl_context_new (display, &error);
+  if (!ctx)
+    {
+      fprintf (stderr, "Failed to create context: %s\n", error->message);
+      return 1;
+    }
+  /* Eventually we want to get rid of any "default context" but for now it's
+   * needed...  */
+  cogl_set_default_context (ctx);
+
+  onscreen = cogl_onscreen_new (ctx, 640, 480);
+
+  /* We want to test that Cogl can handle foreign X windows... */
+
+  visual = cogl_onscreen_x11_get_visual_xid (onscreen);
+  if (!visual)
+    {
+      fprintf (stderr, "Failed to query an X visual suitable for the "
+               "configured CoglOnscreen framebuffer\n");
+      return 1;
+    }
+
+  template.visualid = visual;
+  xvisinfo = XGetVisualInfo (xdpy, VisualIDMask, &template, &visinfos_count);
+
+  /* window attributes */
+  xattr.background_pixel = WhitePixel (xdpy, DefaultScreen (xdpy));
+  xattr.border_pixel = 0;
+  xattr.colormap = XCreateColormap (xdpy,
+                                    DefaultRootWindow (xdpy),
+                                    xvisinfo->visual,
+                                    AllocNone);
+  mask = CWBorderPixel | CWColormap;
+
+  xwin = XCreateWindow (xdpy,
+                        DefaultRootWindow (xdpy),
+                        0, 0,
+                        800, 600,
+                        0,
+                        xvisinfo->depth,
+                        InputOutput,
+                        xvisinfo->visual,
+                        mask, &xattr);
+
+  XFree (xvisinfo);
+
+  cogl_onscreen_x11_set_foreign_window_xid (onscreen, xwin);
+
+  fb = COGL_FRAMEBUFFER (onscreen);
+  /* Eventually there will be an implicit allocate on first use so this
+   * will become optional... */
+  if (!cogl_framebuffer_allocate (fb, &error))
+    {
+      fprintf (stderr, "Failed to allocate framebuffer: %s\n", error->message);
+      return 1;
+    }
+
+  XMapWindow (xdpy, xwin);
+
+  cogl_push_framebuffer (fb);
+
+  cogl_set_source_color4f (1, 0, 0, 1);
+  for (;;)
+    {
+      cogl_rectangle (-1, 1, 1, -1);
+      cogl_framebuffer_swap_buffers (fb);
+    }
+
+  return 0;
+}