[cogl] Provide GTypes for COGL types

COGL types should be registered inside the GType system, for
bindings and type checking inside properties and signals.

CoglHandle is a boxed type with a ref+unref semantics; slightly evil
from a bindings perspective (we cannot associate custom data to it),
but better than nothing.

The rest of the exposed types are enumerations or bitmasks.

cogl-types.h

@@ -24,7 +24,7 @@
 #ifndef __COGL_TYPES_H__
 #define __COGL_TYPES_H__
 
-#include <glib.h>
+#include <glib-object.h>
 
 G_BEGIN_DECLS
 
@@ -51,6 +51,12 @@ typedef gpointer CoglHandle;
  */
 #define COGL_INVALID_HANDLE NULL
 
+#define COGL_TYPE_HANDLE        (cogl_handle_get_type ())
+GType cogl_handle_get_type (void) G_GNUC_CONST;
+
+CoglHandle cogl_handle_ref   (CoglHandle handle);
+void       cogl_handle_unref (CoglHandle Handle);
+
 /**
  * CoglFuncPtr:
  *
@@ -180,6 +186,9 @@ typedef enum
   
 } CoglPixelFormat;
 
+#define COGL_TYPE_PIXEL_FORMAT          (cogl_pixel_format_get_type ())
+GType cogl_pixel_format_get_type (void) G_GNUC_CONST;
+
 /**
  * CoglFeatureFlags:
  * @COGL_FEATURE_TEXTURE_RECTANGLE: ARB_texture_rectangle support
@@ -213,6 +222,9 @@ typedef enum
   COGL_FEATURE_VBOS		      = (1 << 11)
 } CoglFeatureFlags;
 
+#define COGL_TYPE_FEATURE_FLAGS         (cogl_feature_flags_get_type ())
+GType cogl_feature_flags_get_type (void) G_GNUC_CONST;
+
 /**
  * CoglBufferTarget:
  * @COGL_WINDOW_BUFFER: FIXME
@@ -228,9 +240,11 @@ typedef enum
   COGL_WINDOW_BUFFER      = (1 << 1),
   COGL_MASK_BUFFER        = (1 << 2),
   COGL_OFFSCREEN_BUFFER   = (1 << 3)
-  
 } CoglBufferTarget;
 
+#define COGL_TYPE_BUFFER_TARGET         (cogl_buffer_target_get_type ())
+GType cogl_buffer_target_get_type (void) G_GNUC_CONST;
+
 /**
  * CoglColor:
  *
@@ -290,6 +304,9 @@ typedef enum {
   COGL_TEXTURE_AUTO_MIPMAP = 1 << 0
 } CoglTextureFlags;
 
+#define COGL_TYPE_TEXTURE_FLAGS         (cogl_texture_flags_get_type ())
+GType cogl_texture_flags_get_type (void) G_GNUC_CONST;
+
 G_END_DECLS
 
 #endif /* __COGL_TYPES_H__ */

common/cogl-util.c

@@ -28,7 +28,13 @@
 #endif
 
 #include "cogl.h"
+
 #include "cogl-internal.h"
+#include "cogl-material.h"
+#include "cogl-offscreen.h"
+#include "cogl-shader.h"
+#include "cogl-texture.h"
+#include "cogl-types.h"
 #include "cogl-util.h"
 
 /**
@@ -49,3 +55,172 @@ cogl_util_next_p2 (int a)
 
   return rval;
 }
+
+/* gtypes */
+
+CoglHandle
+cogl_handle_ref (CoglHandle handle)
+{
+  g_return_val_if_fail (handle != COGL_INVALID_HANDLE, COGL_INVALID_HANDLE);
+
+  if (cogl_is_texture (handle))
+    return cogl_texture_ref (handle);
+
+  if (cogl_is_offscreen (handle))
+    return cogl_offscreen_ref (handle);
+
+  if (cogl_is_material (handle))
+    return cogl_material_ref (handle);
+
+  if (cogl_is_program (handle))
+    return cogl_program_ref (handle);
+
+  if (cogl_is_shader (handle))
+    return cogl_shader_ref (handle);
+
+  return COGL_INVALID_HANDLE;
+}
+
+void
+cogl_handle_unref (CoglHandle handle)
+{
+  g_return_if_fail (handle != COGL_INVALID_HANDLE);
+
+  if (cogl_is_texture (handle))
+    cogl_texture_unref (handle);
+
+  if (cogl_is_offscreen (handle))
+    cogl_offscreen_unref (handle);
+
+  if (cogl_is_material (handle))
+    cogl_material_unref (handle);
+
+  if (cogl_is_program (handle))
+    cogl_program_unref (handle);
+
+  if (cogl_is_shader (handle))
+    cogl_shader_unref (handle);
+}
+
+GType
+cogl_handle_get_type (void)
+{
+  static GType our_type = 0;
+
+  if (G_UNLIKELY (our_type == 0))
+    our_type = g_boxed_type_register_static (g_intern_static_string ("CoglHandle"),
+                                            (GBoxedCopyFunc) cogl_handle_ref,
+                                            (GBoxedFreeFunc) cogl_handle_unref);
+
+  return our_type;
+}
+
+GType
+cogl_pixel_format_get_type (void)
+{
+  static GType gtype = 0;
+
+  if (G_UNLIKELY (gtype == 0))
+    {
+      const GEnumValue values[] = {
+        { COGL_PIXEL_FORMAT_ANY, "COGL_PIXEL_FORMAT_ANY", "any" },
+        { COGL_PIXEL_FORMAT_A_8, "COGL_PIXEL_FORMAT_A_8", "a-8" },
+        { COGL_PIXEL_FORMAT_RGB_565, "COGL_PIXEL_FORMAT_RGB_565", "rgb-565" },
+        { COGL_PIXEL_FORMAT_RGBA_4444, "COGL_PIXEL_FORMAT_RGBA_4444", "rgba-4444" },
+        { COGL_PIXEL_FORMAT_RGBA_5551, "COGL_PIXEL_FORMAT_RGBA_5551", "rgba-5551" },
+        { COGL_PIXEL_FORMAT_YUV, "COGL_PIXEL_FORMAT_YUV", "yuv" },
+        { COGL_PIXEL_FORMAT_G_8, "COGL_PIXEL_FORMAT_G_8", "g-8" },
+        { COGL_PIXEL_FORMAT_RGB_888, "COGL_PIXEL_FORMAT_RGB_888", "rgb-888" },
+        { COGL_PIXEL_FORMAT_BGR_888, "COGL_PIXEL_FORMAT_BGR_888", "bgr-888" },
+        { COGL_PIXEL_FORMAT_RGBA_8888, "COGL_PIXEL_FORMAT_RGBA_8888", "rgba-8888" },
+        { COGL_PIXEL_FORMAT_BGRA_8888, "COGL_PIXEL_FORMAT_BGRA_8888", "bgra-8888" },
+        { COGL_PIXEL_FORMAT_ARGB_8888, "COGL_PIXEL_FORMAT_ARGB_8888", "argb-8888" },
+        { COGL_PIXEL_FORMAT_ABGR_8888, "COGL_PIXEL_FORMAT_ABGR_8888", "abgr-8888" },
+        { COGL_PIXEL_FORMAT_RGBA_8888_PRE, "COGL_PIXEL_FORMAT_RGBA_8888_PRE", "rgba-8888-pre" },
+        { COGL_PIXEL_FORMAT_BGRA_8888_PRE, "COGL_PIXEL_FORMAT_BGRA_8888_PRE", "bgra-8888-pre" },
+        { COGL_PIXEL_FORMAT_ARGB_8888_PRE, "COGL_PIXEL_FORMAT_ARGB_8888_PRE", "argb-8888-pre" },
+        { COGL_PIXEL_FORMAT_ABGR_8888_PRE, "COGL_PIXEL_FORMAT_ABGR_8888_PRE", "abgr-8888-pre" },
+        { COGL_PIXEL_FORMAT_RGBA_4444_PRE, "COGL_PIXEL_FORMAT_RGBA_4444_PRE", "rgba-4444-pre" },
+        { COGL_PIXEL_FORMAT_RGBA_5551_PRE, "COGL_PIXEL_FORMAT_RGBA_5551_PRE", "rgba-5551-pre" },
+        { 0, NULL, NULL }
+      };
+
+      gtype =
+        g_enum_register_static (g_intern_static_string ("CoglPixelFormat"),
+                                values);
+    }
+
+  return gtype;
+}
+
+GType
+cogl_feature_flags_get_type (void)
+{
+  static GType gtype = 0;
+
+  if (G_UNLIKELY (gtype == 0))
+    {
+      static const GFlagsValue values[] = {
+        { COGL_FEATURE_TEXTURE_RECTANGLE, "COGL_FEATURE_TEXTURE_RECTANGLE", "texture-rectangle" },
+        { COGL_FEATURE_TEXTURE_NPOT, "COGL_FEATURE_TEXTURE_NPOT", "texture-npot" },
+        { COGL_FEATURE_TEXTURE_YUV, "COGL_FEATURE_TEXTURE_YUV", "yuv" },
+        { COGL_FEATURE_TEXTURE_READ_PIXELS, "COGL_FEATURE_TEXTURE_READ_PIXELS", "read-pixels" },
+        { COGL_FEATURE_SHADERS_GLSL, "COGL_FEATURE_SHADERS_GLSL", "shaders-glsl" },
+        { COGL_FEATURE_OFFSCREEN, "COGL_FEATURE_OFFSCREEN", "offscreen" },
+        { COGL_FEATURE_OFFSCREEN_MULTISAMPLE, "COGL_FEATURE_OFFSCREEN_MULTISAMPLE", "offscreen-multisample" },
+        { COGL_FEATURE_OFFSCREEN_BLIT, "COGL_FEATURE_OFFSCREEN_BLIT", "offscreen-blit" },
+        { COGL_FEATURE_FOUR_CLIP_PLANES, "COGL_FEATURE_FOUR_CLIP_PLANES", "four-clip-planes" },
+        { COGL_FEATURE_STENCIL_BUFFER, "COGL_FEATURE_STENCIL_BUFFER", "stencil-buffer" },
+        { 0, NULL, NULL }
+      };
+
+      gtype =
+        g_flags_register_static (g_intern_static_string ("CoglFeatureFlags"),
+                                 values);
+    }
+
+  return gtype;
+}
+
+GType
+cogl_buffer_target_get_type (void)
+{
+  static GType gtype = 0;
+
+  if (G_UNLIKELY (gtype == 0))
+    {
+      static const GFlagsValue values[] = {
+        { COGL_WINDOW_BUFFER, "COGL_WINDOW_BUFFER", "window-buffer" },
+        { COGL_MASK_BUFFER, "COGL_MASK_BUFFER", "mask-buffer" },
+        { COGL_OFFSCREEN_BUFFER, "COGL_OFFSCREEN_BUFFER", "offscreen-buffer" },
+        { 0, NULL, NULL }
+      };
+
+      gtype =
+        g_flags_register_static (g_intern_static_string ("CoglBufferTarget"),
+                                 values);
+    }
+
+  return gtype;
+}
+
+GType
+cogl_texture_flags_get_type (void)
+{
+  static GType gtype = 0;
+
+  if (G_UNLIKELY (gtype == 0))
+    {
+      static const GFlagsValue values[] = {
+        { COGL_TEXTURE_NONE, "COGL_TEXTURE_NONE", "none" },
+        { COGL_TEXTURE_AUTO_MIPMAP, "COGL_TEXTURE_AUTO_MIPMAP", "auto-mipmap" },
+        { 0, NULL, NULL }
+      };
+
+      gtype =
+        g_flags_register_static (g_intern_static_string ("CoglTextureFlags"),
+                                 values);
+    }
+
+  return gtype;
+}