isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-10 07:56:14 -05:00
Code Issues Packages Projects Releases Wiki Activity
688a3e196b
mutter/cogl/cogl-object-private.h

298 lines
15 KiB
C
Raw Normal View History

CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2008,2009,2010 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
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
*/
#ifndef __COGL_OBJECT_PRIVATE_H
#define __COGL_OBJECT_PRIVATE_H
cogl-object-private.h: #include glib.h and cogl-types.h cogl-object-private.h was only working in places that had already included glib.h and cogl-types.h
2010-07-03 16:10:05 -04:00
#include <glib.h>
#include "cogl-types.h"
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
#include "cogl-object.h"
cogl-object-private.h: Include cogl-debug.h If COGL_OBJECT_DEBUG is defined then cogl-object-private.h will call COGL_NOTE in the ref and unref macros. For this to work the debug header needs to also be included or COGL_NOTE won't necessarily be defined.
2010-09-17 12:18:09 -04:00
#include "cogl-debug.h"
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
/* For compatability until all components have been converted */
typedef struct _CoglObjectClass CoglHandleClass;
typedef struct _CoglObject CoglHandleObject;
cogl-object: Adds an internal _cogl_object_set_user_data This adds an internal alternative to cogl_object_set_user_data that also passes an instance pointer to destroy notify callbacks. When setting private data on a CoglObject it's often desirable to know the instance being destroyed when we are being notified to free the private data due to the object being freed. The typical solution to this is to track a pointer to the instance in the private data itself so it can be identified but that usually requires an extra micro allocation for the private data that could have been avoided if only the callback were given an instance pointer. The new internal _cogl_object_set_user_data passes the instance pointer as a second argument which means it is ABI compatible for us to layer the public version on top of this internal function.
2011-01-12 15:37:53 -05:00
/* XXX: sadly we didn't fully consider when we copied the cairo API
* for _set_user_data that the callback doesn't get a pointer to the
* instance which is desired in most cases. This means you tend to end
* up creating micro allocations for the private data just so you can
* pair up the data of interest with the original instance for
* identification when it is later destroyed.
*
* Internally we use a small hack to avoid needing these micro
* allocations by actually passing the instance as a second argument
* to the callback */
typedef void (*CoglUserDataDestroyInternalCallback) (void *user_data,
void *instance);
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
typedef struct _CoglObjectClass
{
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
const char *name;
void *virt_free;
object: Add a virtual pointer for the unref function The virtual function gets called in cogl_object_unref. Any definition of a CoglObject type can replace the default unref function by using COGL_OBJECT_DEFINE_WITH_CODE to directly manipulate the CoglObjectClass struct. The generated object constructors set the pointer to the default implementation. The default implementation is exported in the private header so that any overriding implementations can chain up to it. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:36:16 -05:00
void *virt_unref;
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
} CoglObjectClass;
#define COGL_OBJECT_N_PRE_ALLOCATED_USER_DATA_ENTRIES 2
typedef struct
{
CoglUserDataKey *key;
void *user_data;
cogl-object: Adds an internal _cogl_object_set_user_data This adds an internal alternative to cogl_object_set_user_data that also passes an instance pointer to destroy notify callbacks. When setting private data on a CoglObject it's often desirable to know the instance being destroyed when we are being notified to free the private data due to the object being freed. The typical solution to this is to track a pointer to the instance in the private data itself so it can be identified but that usually requires an extra micro allocation for the private data that could have been avoided if only the callback were given an instance pointer. The new internal _cogl_object_set_user_data passes the instance pointer as a second argument which means it is ABI compatible for us to layer the public version on top of this internal function.
2011-01-12 15:37:53 -05:00
CoglUserDataDestroyInternalCallback destroy;
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
} CoglUserDataEntry;
/* All Cogl objects inherit from this base object by adding a member:
*
* CoglObject _parent;
*
* at the top of its main structure. This structure is initialized
* when you call _cogl_#type_name#_object_new (new_object);
*/
struct _CoglObject
{
object: Reorder the CoglObject members by size This moves the pointer members of CoglObject to the top and the int members to the bottom so that there won't be any padding inserted on 64-bit machines. This reduces the size of the struct from 80 bytes to 72. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 10:55:27 -05:00
CoglObjectClass *klass;
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
CoglUserDataEntry user_data_entry[
COGL_OBJECT_N_PRE_ALLOCATED_USER_DATA_ENTRIES];
GArray *user_data_array;
int n_user_data_entries;
object: Reorder the CoglObject members by size This moves the pointer members of CoglObject to the top and the int members to the bottom so that there won't be any padding inserted on 64-bit machines. This reduces the size of the struct from 80 bytes to 72. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 10:55:27 -05:00
unsigned int ref_count;
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
};
/* Helper macro to encapsulate the common code for COGL reference
counted objects */
#ifdef COGL_OBJECT_DEBUG
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
#define _COGL_OBJECT_DEBUG_NEW(type_name, obj) \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
COGL_NOTE (HANDLE, "COGL " G_STRINGIFY (type_name) " NEW %p %i", \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
(obj), (obj)->ref_count)
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
#define _COGL_OBJECT_DEBUG_REF(type_name, object) G_STMT_START { \
CoglObject *__obj = (CoglObject *)object; \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
COGL_NOTE (HANDLE, "COGL %s REF %p %i", \
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
(__obj)->klass->name, \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
(__obj), (__obj)->ref_count); } G_STMT_END
#define _COGL_OBJECT_DEBUG_UNREF(type_name, object) G_STMT_START { \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
CoglObject *__obj = (CoglObject *)object; \
COGL_NOTE (HANDLE, "COGL %s UNREF %p %i", \
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
(__obj)->klass->name, \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
(__obj), (__obj)->ref_count - 1); } G_STMT_END
#define COGL_OBJECT_DEBUG_FREE(obj) \
COGL_NOTE (HANDLE, "COGL %s FREE %p", \
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
(obj)->klass->name, (obj))
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
#else /* !COGL_OBJECT_DEBUG */
#define _COGL_OBJECT_DEBUG_NEW(type_name, obj)
#define _COGL_OBJECT_DEBUG_REF(type_name, obj)
#define _COGL_OBJECT_DEBUG_UNREF(type_name, obj)
#define COGL_OBJECT_DEBUG_FREE(obj)
#endif /* COGL_OBJECT_DEBUG */
/* For temporary compatability */
#define _COGL_HANDLE_DEBUG_NEW _COGL_OBJECT_DEBUG_NEW
#define _COGL_HANDLE_DEBUG_REF _COGL_OBJECT_DEBUG_REF
#define _COGL_HANDLE_DEBUG_UNREF _COGL_OBJECT_DEBUG_UNREF
#define COGL_HANDLE_DEBUG_FREE COGL_OBJECT_DEBUG_FREE
cogl-debug: add instrumentation to track the number of objects This allows to track the number of objects allocated by Cogl. The results are displayed on the standard output by calling : cogl_debug_print_instances (); Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-10 13:44:09 -04:00
#define COGL_OBJECT_COMMON_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
CoglObjectClass _cogl_##type_name##_class; \
cogl-debug: add instrumentation to track the number of objects This allows to track the number of objects allocated by Cogl. The results are displayed on the standard output by calling : cogl_debug_print_instances (); Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-10 13:44:09 -04:00
static unsigned long _cogl_object_##type_name##_count; \
\
static inline void \
_cogl_object_##type_name##_inc (void) \
{ \
_cogl_object_##type_name##_count++; \
} \
\
static inline void \
_cogl_object_##type_name##_dec (void) \
{ \
_cogl_object_##type_name##_count--; \
} \
\
static void \
_cogl_object_##type_name##_indirect_free (CoglObject *obj) \
{ \
_cogl_##type_name##_free ((Cogl##TypeName *) obj); \
_cogl_object_##type_name##_dec (); \
} \
\
static Cogl##TypeName * \
_cogl_##type_name##_object_new (Cogl##TypeName *new_obj) \
{ \
CoglObject *obj = (CoglObject *)&new_obj->_parent; \
obj->ref_count = 0; \
cogl_object_ref (obj); \
obj->n_user_data_entries = 0; \
obj->user_data_array = NULL; \
\
obj->klass = &_cogl_##type_name##_class; \
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
if (!obj->klass->virt_free) \
cogl-debug: add instrumentation to track the number of objects This allows to track the number of objects allocated by Cogl. The results are displayed on the standard output by calling : cogl_debug_print_instances (); Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-10 13:44:09 -04:00
{ \
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
_cogl_object_##type_name##_count = 0; \
\
if (_cogl_debug_instances == NULL) \
_cogl_debug_instances = \
g_hash_table_new (g_str_hash, g_str_equal); \
\
cogl-debug: add instrumentation to track the number of objects This allows to track the number of objects allocated by Cogl. The results are displayed on the standard output by calling : cogl_debug_print_instances (); Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-10 13:44:09 -04:00
obj->klass->virt_free = \
_cogl_object_##type_name##_indirect_free; \
object: Add a virtual pointer for the unref function The virtual function gets called in cogl_object_unref. Any definition of a CoglObject type can replace the default unref function by using COGL_OBJECT_DEFINE_WITH_CODE to directly manipulate the CoglObjectClass struct. The generated object constructors set the pointer to the default implementation. The default implementation is exported in the private header so that any overriding implementations can chain up to it. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:36:16 -05:00
obj->klass->virt_unref = \
_cogl_object_default_unref; \
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
obj->klass->name = "Cogl"#TypeName, \
\
g_hash_table_insert (_cogl_debug_instances, \
(void *) obj->klass->name, \
&_cogl_object_##type_name##_count); \
\
{ code; } \
cogl-debug: add instrumentation to track the number of objects This allows to track the number of objects allocated by Cogl. The results are displayed on the standard output by calling : cogl_debug_print_instances (); Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-10 13:44:09 -04:00
} \
\
_cogl_object_##type_name##_inc (); \
_COGL_OBJECT_DEBUG_NEW (TypeName, obj); \
return new_obj; \
} \
\
Cogl##TypeName * \
_cogl_##type_name##_pointer_from_handle (CoglHandle handle) \
{ \
return handle; \
Don't define public cogl_is_* functions for internal types This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_* function with an underscore so that it doesn't get exported in the shared library.
2010-07-09 13:46:31 -04:00
}
#define COGL_OBJECT_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
COGL_OBJECT_COMMON_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
gboolean \
cogl_is_##type_name (void *object) \
{ \
CoglObject *obj = object; \
\
if (object == NULL) \
return FALSE; \
\
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
return obj->klass == &_cogl_##type_name##_class; \
Don't define public cogl_is_* functions for internal types This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_* function with an underscore so that it doesn't get exported in the shared library.
2010-07-09 13:46:31 -04:00
}
#define COGL_OBJECT_INTERNAL_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
COGL_OBJECT_COMMON_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
gboolean \
_cogl_is_##type_name (void *object) \
{ \
CoglObject *obj = object; \
\
if (object == NULL) \
return FALSE; \
\
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
return obj->klass == &_cogl_##type_name##_class; \
cogl: Don't define the deprecated ref/unref accessors for new types Previously COGL_OBJECT_DEFINE would always define deprecated cogl_$type_{ref,unref} functions even if the type is new or if the type is entirely internal. An application would still find it difficult to use these because they wouldn't be in the headers, but it still looks bad that they are exported from the shared library. This patch changes it so that the deprecated ref counting functions are defined using a separate macro and only the types that have these functions in the headers call this macro.
2010-07-09 12:59:16 -04:00
}
#define COGL_OBJECT_DEFINE_DEPRECATED_REF_COUNTING(type_name) \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
\
void * G_GNUC_DEPRECATED \
cogl_##type_name##_ref (void *object) \
{ \
if (!cogl_is_##type_name (object)) \
return NULL; \
\
_COGL_OBJECT_DEBUG_REF (TypeName, object); \
\
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
cogl_handle_ref (object); \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
\
return object; \
} \
\
void G_GNUC_DEPRECATED \
cogl_##type_name##_unref (void *object) \
{ \
if (!cogl_is_##type_name (object)) \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
{ \
g_warning (G_STRINGIFY (cogl_##type_name##_unref) \
": Ignoring unref of Cogl handle " \
"due to type mismatch"); \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
return; \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
} \
cogl-object-private.h: white space cleanup simply replaces tabs with spaces
2010-06-01 14:27:07 -04:00
\
_COGL_OBJECT_DEBUG_UNREF (TypeName, object); \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
\
cogl_handle_unref (object); \
}
Add COGL_{OBJECT,HANDLE}_DEFINE_WITH_CODE This macro is similar to COGL_HANDLE_DEFINE_WITH_CODE except that it allows a snippet of code to be inserted into the _get_type() function. This is similar to how G_DEFINE_TYPE_WITH_CODE works. COGL_HANDLE_DEFINE is now just a wrapper around COGL_HANDLE_DEFINE_WITH_CODE.
2010-06-11 08:44:27 -04:00
#define COGL_OBJECT_DEFINE(TypeName, type_name) \
COGL_OBJECT_DEFINE_WITH_CODE (TypeName, type_name, (void) 0)
Don't define public cogl_is_* functions for internal types This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_* function with an underscore so that it doesn't get exported in the shared library.
2010-07-09 13:46:31 -04:00
#define COGL_OBJECT_INTERNAL_DEFINE(TypeName, type_name) \
COGL_OBJECT_INTERNAL_DEFINE_WITH_CODE (TypeName, type_name, (void) 0)
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
/* For temporary compatability */
Don't define public cogl_is_* functions for internal types This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_* function with an underscore so that it doesn't get exported in the shared library.
2010-07-09 13:46:31 -04:00
#define COGL_HANDLE_INTERNAL_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
COGL_OBJECT_INTERNAL_DEFINE_WITH_CODE (TypeName, type_name, code) \
\
static Cogl##TypeName * \
_cogl_##type_name##_handle_new (CoglHandle handle) \
{ \
return _cogl_##type_name##_object_new (handle); \
}
#define COGL_HANDLE_DEFINE_WITH_CODE(TypeName, type_name, code) \
\
COGL_OBJECT_DEFINE_WITH_CODE (TypeName, type_name, code) \
\
static Cogl##TypeName * \
_cogl_##type_name##_handle_new (CoglHandle handle) \
{ \
return _cogl_##type_name##_object_new (handle); \
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
}
Don't define public cogl_is_* functions for internal types This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_* function with an underscore so that it doesn't get exported in the shared library.
2010-07-09 13:46:31 -04:00
#define COGL_HANDLE_INTERNAL_DEFINE(TypeName, type_name) \
COGL_HANDLE_INTERNAL_DEFINE_WITH_CODE (TypeName, type_name, (void) 0)
Add COGL_{OBJECT,HANDLE}_DEFINE_WITH_CODE This macro is similar to COGL_HANDLE_DEFINE_WITH_CODE except that it allows a snippet of code to be inserted into the _get_type() function. This is similar to how G_DEFINE_TYPE_WITH_CODE works. COGL_HANDLE_DEFINE is now just a wrapper around COGL_HANDLE_DEFINE_WITH_CODE.
2010-06-11 08:44:27 -04:00
#define COGL_HANDLE_DEFINE(TypeName, type_name) \
COGL_HANDLE_DEFINE_WITH_CODE (TypeName, type_name, (void) 0)
cogl-object: Adds an internal _cogl_object_set_user_data This adds an internal alternative to cogl_object_set_user_data that also passes an instance pointer to destroy notify callbacks. When setting private data on a CoglObject it's often desirable to know the instance being destroyed when we are being notified to free the private data due to the object being freed. The typical solution to this is to track a pointer to the instance in the private data itself so it can be identified but that usually requires an extra micro allocation for the private data that could have been avoided if only the callback were given an instance pointer. The new internal _cogl_object_set_user_data passes the instance pointer as a second argument which means it is ABI compatible for us to layer the public version on top of this internal function.
2011-01-12 15:37:53 -05:00
void
_cogl_object_set_user_data (CoglObject *object,
CoglUserDataKey *key,
void *user_data,
CoglUserDataDestroyInternalCallback destroy);
object: Add a virtual pointer for the unref function The virtual function gets called in cogl_object_unref. Any definition of a CoglObject type can replace the default unref function by using COGL_OBJECT_DEFINE_WITH_CODE to directly manipulate the CoglObjectClass struct. The generated object constructors set the pointer to the default implementation. The default implementation is exported in the private header so that any overriding implementations can chain up to it. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:36:16 -05:00
void
_cogl_object_default_unref (void *obj);
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 17:24:56 -04:00
#endif /* __COGL_OBJECT_PRIVATE_H */
Reference in New Issue Copy Permalink