mutter/cogl/cogl-gtype-private.h

/*
 * Cogl
 *
 * A Low Level GPU Graphics and Utilities API
 *
 * Copyright (C) 2010 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 *
 */

#ifndef __COGL_GTYPE_PRIVATE_H__
#define __COGL_GTYPE_PRIVATE_H__

#include "config.h"

#include <glib.h>
#include <glib-object.h>

#include "cogl-object-private.h"

/* Move this to public headers? */
typedef struct _CoglGtypeObject CoglGtypeObject;
typedef struct _CoglGtypeClass  CoglGtypeClass;

struct _CoglGtypeObject
{
  GTypeInstance parent_instance;

  guint dummy;
};

struct _CoglGtypeClass
{
  GTypeClass base_class;

  guint dummy;
};

#define I_(str)  (g_intern_static_string ((str)))

/**/

#define COGL_GTYPE_DEFINE_BOXED(Name,underscore_name,copy_func,free_func) \
GType \
cogl_##underscore_name##_get_gtype (void) \
{ \
   static volatile size_t type_volatile = 0; \
   if (g_once_init_enter (&type_volatile)) \
     { \
       GType type = \
         g_boxed_type_register_static (g_intern_static_string (I_("Cogl" # Name)), \
                                       (GBoxedCopyFunc)copy_func, \
                                       (GBoxedFreeFunc)free_func); \
       g_once_init_leave (&type_volatile, type); \
     } \
   return type_volatile; \
}

#define COGL_GTYPE_IMPLEMENT_INTERFACE(name) {                          \
    const GInterfaceInfo g_implement_interface_info = {                 \
      (GInterfaceInitFunc) _cogl_gtype_dummy_iface_init, NULL, NULL     \
    };                                                                  \
    g_type_add_interface_static (fundamental_type_id,                   \
                                 cogl_##name##_get_gtype(),         \
                                 &g_implement_interface_info);          \
  }

#define _COGL_GTYPE_DEFINE_BASE_CLASS_BEGIN(Name,name)                  \
GType                                                                   \
cogl_##name##_get_gtype (void)                                      \
{                                                                       \
  static volatile gsize type_id__volatile = 0;                          \
  if (g_once_init_enter (&type_id__volatile))                           \
    {                                                                   \
      static const GTypeFundamentalInfo finfo = {                       \
        (G_TYPE_FLAG_CLASSED |                                          \
         G_TYPE_FLAG_INSTANTIATABLE |                                   \
         G_TYPE_FLAG_DERIVABLE |                                        \
         G_TYPE_FLAG_DEEP_DERIVABLE),                                   \
      };                                                                \
      static const GTypeValueTable value_table = {                      \
        _cogl_gtype_object_init_value,                                  \
        _cogl_gtype_object_free_value,                                  \
        _cogl_gtype_object_copy_value,                                  \
        _cogl_gtype_object_peek_pointer,                                \
        "p",                                                            \
        _cogl_gtype_object_collect_value,                               \
        "p",                                                            \
        _cogl_gtype_object_lcopy_value,                                 \
      };                                                                \
      const GTypeInfo node_info = {                                     \
        sizeof (CoglObjectClass),                                       \
        (GBaseInitFunc) _cogl_gtype_object_class_base_init,             \
        (GBaseFinalizeFunc) _cogl_gtype_object_class_base_finalize,     \
        (GClassInitFunc) _cogl_gtype_object_class_init,                 \
        (GClassFinalizeFunc) NULL,                                      \
        NULL,                                                           \
        sizeof (CoglObject),                                            \
        0,                                                              \
        (GInstanceInitFunc) _cogl_gtype_object_init,                    \
        &value_table,                                                   \
      };                                                                \
      GType fundamental_type_id =                                       \
        g_type_register_fundamental (g_type_fundamental_next (),        \
                                     I_("Cogl" # Name),                 \
                                     &node_info, &finfo,                \
                                     G_TYPE_FLAG_ABSTRACT);             \
      g_once_init_leave (&type_id__volatile,                            \
                         fundamental_type_id);

#define _COGL_GTYPE_DEFINE_BASE_CLASS_END()                             \
    }                                                                   \
    return type_id__volatile;                                           \
  }

#define COGL_GTYPE_DEFINE_BASE_CLASS(Name,name,...)      \
  _COGL_GTYPE_DEFINE_BASE_CLASS_BEGIN(Name,name)         \
  {__VA_ARGS__;}                                         \
  _COGL_GTYPE_DEFINE_BASE_CLASS_END()

#define _COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_BEGIN(Name,name)          \
                                                                        \
  static void name##_default_init (Name##Interface *klass);             \
  GType                                                                 \
  name##_get_gtype (void)                                               \
  {                                                                     \
    static volatile gsize type_id__volatile = 0;                        \
    if (g_once_init_enter (&type_id__volatile))                         \
      {                                                                 \
        GType fundamental_type_id =                                     \
          g_type_register_static_simple (G_TYPE_INTERFACE,              \
                                         g_intern_static_string (#Name), \
                                         sizeof (Name##Interface),    \
                                         (GClassInitFunc)name##_default_init, \
                                         0,                             \
                                         (GInstanceInitFunc)NULL,       \
                                         (GTypeFlags) 0);               \
        g_type_interface_add_prerequisite (fundamental_type_id,         \
                                           cogl_object_get_gtype());    \
        { /* custom code follows */

#define _COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_END()                     \
  /* following custom code */                                           \
  }                                                                     \
    g_once_init_leave (&type_id__volatile,                              \
                       fundamental_type_id);                            \
    }                                                                   \
    return type_id__volatile;                                           \
    } /* closes name##_get_type() */


#define COGL_GTYPE_DEFINE_INTERFACE(Name,name)                          \
  typedef struct _Cogl##Name##Iface Cogl##Name##Iface;                  \
  typedef Cogl##Name##Iface  Cogl##Name##Interface;                     \
  struct _Cogl##Name##Iface                                             \
  {                                                                     \
    /*< private >*/                                                     \
    GTypeInterface g_iface;                                             \
  };                                                                    \
  _COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_BEGIN (Cogl##Name, cogl_##name) \
  _COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_END ()                          \
  static void                                                           \
  cogl_##name##_default_init (Cogl##Name##Interface *iface)             \
  {                                                                     \
  }

#define _COGL_GTYPE_DEFINE_TYPE_EXTENDED_BEGIN(Name,name,parent,flags)  \
                                                                        \
  static void     name##_init              (Name        *self);         \
  static void     name##_class_init        (Name##Class *klass);        \
  static gpointer name##_parent_class = NULL;                           \
  static gint     Name##_private_offset;                                \
                                                                        \
  static void                                                           \
  name##_class_intern_init (gpointer klass)                             \
  {                                                                     \
    name##_parent_class = g_type_class_peek_parent (klass);             \
    name##_class_init ((Name##Class*) klass);                           \
  }                                                                     \
                                                                        \
  static inline gpointer                                                \
  name##_get_instance_private (Name *self)                              \
    {                                                                   \
      return (G_STRUCT_MEMBER_P (self, Name ##_private_offset));        \
    }                                                                   \
                                                                        \
  GType                                                                 \
  name##_get_gtype (void)                                               \
  {                                                                     \
    static volatile gsize type_id__volatile = 0;                        \
    if (g_once_init_enter (&type_id__volatile))                         \
      {                                                                 \
        GType fundamental_type_id =                                     \
          g_type_register_static_simple (parent,                        \
                                         g_intern_static_string (#Name), \
                                         sizeof (Name##Class),          \
                                         (GClassInitFunc) name##_class_intern_init, \
                                         sizeof (Name),                 \
                                         (GInstanceInitFunc) name##_init, \
                                         (GTypeFlags) flags);           \
        { /* custom code follows */

#define _COGL_GTYPE_DEFINE_TYPE_EXTENDED_END()                          \
  /* following custom code */                                           \
  }                                                                     \
    g_once_init_leave (&type_id__volatile,                              \
                       fundamental_type_id);                            \
    }                                                                   \
    return type_id__volatile;                                           \
    } /* closes name##_get_type() */


#define COGL_GTYPE_DEFINE_CLASS(Name,name,...)                          \
  typedef struct _Cogl##Name##Class Cogl##Name##Class;                  \
  struct _Cogl##Name##Class {                                           \
    CoglObjectClass parent_class;                                       \
  };                                                                    \
  _COGL_GTYPE_DEFINE_TYPE_EXTENDED_BEGIN(Cogl##Name,                    \
                                         cogl_##name,                   \
                                         cogl_object_get_gtype(),       \
                                         0)                             \
  {__VA_ARGS__;}                                                        \
  _COGL_GTYPE_DEFINE_TYPE_EXTENDED_END()                                \
  static void                                                           \
  cogl_##name##_init (Cogl##Name *instance)                             \
  {                                                                     \
  }                                                                     \
  static void                                                           \
  cogl_##name##_class_init (Cogl##Name##Class *klass)                   \
  {                                                                     \
  }

void _cogl_gtype_object_init_value (GValue *value);
void _cogl_gtype_object_free_value (GValue *value);
void _cogl_gtype_object_copy_value (const GValue *src,
                                    GValue       *dst);
gpointer _cogl_gtype_object_peek_pointer (const GValue *value);
gchar *_cogl_gtype_object_collect_value (GValue      *value,
                                         guint        n_collect_values,
                                         GTypeCValue *collect_values,
                                         guint        collect_flags);
gchar *_cogl_gtype_object_lcopy_value (const GValue *value,
                                       guint         n_collect_values,
                                       GTypeCValue  *collect_values,
                                       guint         collect_flags);

void _cogl_gtype_object_class_base_init (CoglObjectClass *klass);
void _cogl_gtype_object_class_base_finalize (CoglObjectClass *klass);
void _cogl_gtype_object_class_init (CoglObjectClass *klass);
void _cogl_gtype_object_init (CoglObject *object);

void cogl_object_value_set_object (GValue   *value,
                                   gpointer  object);
gpointer cogl_object_value_get_object (const GValue *value);

void _cogl_gtype_dummy_iface_init (gpointer iface);

#endif /* __COGL_GTYPE_PRIVATE_H__ */