534 lines
13 KiB
C
534 lines
13 KiB
C
#ifndef __FT_OBJECT_H__
|
|
#define __FT_OBJECT_H__
|
|
|
|
#include <ft2build.h>
|
|
#include FT_FREETYPE_H
|
|
|
|
FT_BEGIN_HEADER
|
|
|
|
/**************************************************************
|
|
*
|
|
* @type: FT_Object
|
|
*
|
|
* @description:
|
|
* handle to a FreeType Object. See @FT_ObjectRec
|
|
*/
|
|
typedef struct FT_ObjectRec_* FT_Object;
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @type: FT_Class
|
|
*
|
|
* @description:
|
|
* handle to a constant class handle to a FreeType Object.
|
|
*
|
|
* Note that a class is itself a @FT_Object and are dynamically
|
|
* allocated on the heap.
|
|
*
|
|
* @also:
|
|
* @FT_ClassRec, @FT_Object, @FT_ObjectRec, @FT_Type, @FT_TypeRec
|
|
*/
|
|
typedef const struct FT_ClassRec_* FT_Class;
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @type: FT_Type
|
|
*
|
|
* @description:
|
|
* handle to a constant structure (of type @FT_TypeRec) used
|
|
* to describe a given @FT_Class type to the FreeType object
|
|
* sub-system.
|
|
*/
|
|
typedef const struct FT_TypeRec_* FT_Type;
|
|
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @struct: FT_ObjectRec
|
|
*
|
|
* @description:
|
|
* a structure describing the root fields of all @FT_Object
|
|
* class instances in FreeType
|
|
*
|
|
* @fields:
|
|
* clazz :: handle to the object's class
|
|
* ref_count :: object's reference count. Starts at 1
|
|
*/
|
|
typedef struct FT_ObjectRec_
|
|
{
|
|
FT_Class clazz;
|
|
FT_Int ref_count;
|
|
|
|
} FT_ObjectRec;
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_OBJECT (x)
|
|
*
|
|
* @description:
|
|
* a useful macro to type-cast anything to a @FT_Object
|
|
* handle. No check performed..
|
|
*/
|
|
#define FT_OBJECT(x) ((FT_Object)(x))
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_OBJECT_P (x)
|
|
*
|
|
* @description:
|
|
* a useful macro to type-cast anything to a pointer to
|
|
* @FT_Object handle.
|
|
*/
|
|
#define FT_OBJECT_P(x) ((FT_Object*)(x))
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_OBJECT__CLASS (obj)
|
|
*
|
|
* @description:
|
|
* a useful macro to return the class of any object
|
|
*/
|
|
#define FT_OBJECT__CLASS(x) FT_OBJECT(x)->clazz
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_OBJECT__REF_COUNT (obj)
|
|
*
|
|
* @description:
|
|
* a useful macro to return the reference count of any object
|
|
*/
|
|
#define FT_OBJECT__REF_COUNT(x) FT_OBJECT(x)->ref_count
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_OBJECT__MEMORY (obj)
|
|
*
|
|
* @description:
|
|
* a useful macro to return a handle to the memory manager
|
|
* used to allocate a given object
|
|
*/
|
|
#define FT_OBJECT__MEMORY(x) FT_CLASS__MEMORY(FT_OBJECT(x)->clazz)
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_OBJECT__LIBRARY (obj)
|
|
*
|
|
* @description:
|
|
* a useful macro to return a handle to the library handle
|
|
* that owns the object
|
|
*/
|
|
#define FT_OBJECT__LIBRARY(x) FT_CLASS__LIBRARY(FT_OBJECT(x)->clazz)
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @functype: FT_Object_InitFunc
|
|
*
|
|
* @description:
|
|
* a function used to initialize a new object
|
|
*
|
|
* @input:
|
|
* object :: target object handle
|
|
* init_data :: optional pointer to initialization data
|
|
*
|
|
* @return:
|
|
* error code. 0 means success
|
|
*/
|
|
typedef FT_Error (*FT_Object_InitFunc)( FT_Object object,
|
|
FT_Pointer init_data );
|
|
|
|
/**************************************************************
|
|
*
|
|
* @functype: FT_Object_DoneFunc
|
|
*
|
|
* @description:
|
|
* a function used to finalize a given object
|
|
*
|
|
* @input:
|
|
* object :: handle to target object
|
|
*/
|
|
typedef void (*FT_Object_DoneFunc)( FT_Object object );
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @struct: FT_ClassRec
|
|
*
|
|
* @description:
|
|
* a structure used to describe a given object class within
|
|
* FreeType
|
|
*
|
|
* @fields:
|
|
* object :: root @FT_ObjectRec fields, since each class is
|
|
* itself an object. (it's an instance of the
|
|
* "metaclass", a special object of the FreeType
|
|
* object sub-system.)
|
|
*
|
|
* magic :: a 32-bit magic number used for decoding
|
|
* super :: pointer to super class
|
|
* type :: the @FT_Type descriptor of this class
|
|
* memory :: the current memory manager handle
|
|
* library :: the current library handle
|
|
* info :: an opaque pointer to class-specific information
|
|
* managed by the FreeType object sub-system
|
|
*
|
|
* class_done :: the class destructor function
|
|
*
|
|
* obj_size :: size of class instances in bytes
|
|
* obj_init :: class instance constructor
|
|
* obj_done :: class instance destructor
|
|
*/
|
|
typedef struct FT_ClassRec_
|
|
{
|
|
FT_ObjectRec object;
|
|
FT_UInt32 magic;
|
|
FT_Class super;
|
|
FT_Type type;
|
|
FT_Memory memory;
|
|
FT_Library library;
|
|
FT_Pointer info;
|
|
|
|
FT_Object_DoneFunc class_done;
|
|
|
|
FT_UInt obj_size;
|
|
FT_Object_InitFunc obj_init;
|
|
FT_Object_DoneFunc obj_done;
|
|
|
|
} FT_ClassRec;
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_CLASS (x)
|
|
*
|
|
* @description:
|
|
* a useful macro to convert anything to a class handle
|
|
* without checks
|
|
*/
|
|
#define FT_CLASS(x) ((FT_Class)(x))
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_CLASS_P (x)
|
|
*
|
|
* @description:
|
|
* a useful macro to convert anything to a pointer to a class
|
|
* handle without checks
|
|
*/
|
|
#define FT_CLASS_P(x) ((FT_Class*)(x))
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_CLASS__MEMORY (clazz)
|
|
*
|
|
* @description:
|
|
* a useful macro to return the memory manager handle of a
|
|
* given class
|
|
*/
|
|
#define FT_CLASS__MEMORY(x) FT_CLASS(x)->memory
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_CLASS__LIBRARY (clazz)
|
|
*
|
|
* @description:
|
|
* a useful macro to return the library handle of a
|
|
* given class
|
|
*/
|
|
#define FT_CLASS__LIBRARY(x) FT_CLASS(x)->library
|
|
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_CLASS__TYPE (clazz)
|
|
*
|
|
* @description:
|
|
* a useful macro to return the type of a given class
|
|
* given class
|
|
*/
|
|
#define FT_CLASS__TYPE(x) FT_CLASS(x)->type
|
|
|
|
/* */
|
|
#define FT_CLASS__INFO(x) FT_CLASS(x)->info
|
|
#define FT_CLASS__MAGIC(x) FT_CLASS(x)->magic
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @struct: FT_TypeRec
|
|
*
|
|
* @description:
|
|
* a structure used to describe a given class to the FreeType
|
|
* object sub-system.
|
|
*
|
|
* @fields:
|
|
* name :: class name. only used for debugging
|
|
* super :: type of super-class. NULL if none
|
|
*
|
|
* class_size :: size of class structure in bytes
|
|
* class_init :: class constructor
|
|
* class_done :: class finalizer
|
|
*
|
|
* obj_size :: instance size in bytes
|
|
* obj_init :: instance constructor. can be NULL
|
|
* obj_done :: instance destructor. can be NULL
|
|
*
|
|
* @note:
|
|
* if 'obj_init' is NULL, the class will use it's parent
|
|
* constructor, if any
|
|
*
|
|
* if 'obj_done' is NULL, the class will use it's parent
|
|
* finalizer, if any
|
|
*
|
|
* the object sub-system allocates a new class, copies
|
|
* the content of its super-class into the new structure,
|
|
* _then_ calls 'clazz_init'.
|
|
*
|
|
* 'class_init' and 'class_done' can be NULL, in which case
|
|
* the parent's class constructor and destructor wil be used
|
|
*/
|
|
typedef struct FT_TypeRec_
|
|
{
|
|
const char* name;
|
|
FT_Type super;
|
|
|
|
FT_UInt class_size;
|
|
FT_Object_InitFunc class_init;
|
|
FT_Object_DoneFunc class_done;
|
|
|
|
FT_UInt obj_size;
|
|
FT_Object_InitFunc obj_init;
|
|
FT_Object_DoneFunc obj_done;
|
|
|
|
} FT_TypeRec;
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro: FT_TYPE (x)
|
|
*
|
|
* @description:
|
|
* a useful macro to convert anything to a class type handle
|
|
* without checks
|
|
*/
|
|
#define FT_TYPE(x) ((FT_Type)(x))
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @function: ft_object_check
|
|
*
|
|
* @description:
|
|
* checks that a handle points to a valid @FT_Object
|
|
*
|
|
* @input:
|
|
* obj :: handle/pointer
|
|
*
|
|
* @return:
|
|
* 1 iff the handle points to a valid object. 0 otherwise
|
|
*/
|
|
FT_BASE( FT_Int )
|
|
ft_object_check( FT_Pointer obj );
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @function: ft_object_is_a
|
|
*
|
|
* @description:
|
|
* checks that a handle points to a valid @FT_Object that
|
|
* is an instance of a given class (or of any of its sub-classes)
|
|
*
|
|
* @input:
|
|
* obj :: handle/pointer
|
|
* clazz :: class handle to check
|
|
*
|
|
* @return:
|
|
* 1 iff the handle points to a valid 'clazz' instance. 0
|
|
* otherwise.
|
|
*/
|
|
FT_BASE( FT_Int )
|
|
ft_object_is_a( FT_Pointer obj,
|
|
FT_Class clazz );
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @function: ft_object_create
|
|
*
|
|
* @description:
|
|
* create a new object (class instance)
|
|
*
|
|
* @output:
|
|
* aobject :: new object handle. NULL in case of error
|
|
*
|
|
* @input:
|
|
* clazz :: object's class pointer
|
|
* init_data :: optional pointer to initialization data
|
|
*
|
|
* @return:
|
|
* error code. 0 means success
|
|
*/
|
|
FT_BASE( FT_Error )
|
|
ft_object_create( FT_Object *aobject,
|
|
FT_Class clazz,
|
|
FT_Pointer init_data );
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @function: ft_object_create_from_type
|
|
*
|
|
* @description:
|
|
* create a new object (class instance) from a @FT_Type
|
|
*
|
|
* @output:
|
|
* aobject :: new object handle. NULL in case of error
|
|
*
|
|
* @input:
|
|
* type :: object's type descriptor
|
|
* init_data :: optional pointer to initialization data
|
|
*
|
|
* @return:
|
|
* error code. 0 means success
|
|
*
|
|
* @note:
|
|
* this function is slower than @ft_object_create
|
|
*
|
|
* this is equivalent to calling @ft_class_from_type followed by
|
|
* @ft_object_create
|
|
*/
|
|
FT_BASE( FT_Error )
|
|
ft_object_create_from_type( FT_Object *aobject,
|
|
FT_Type type,
|
|
FT_Pointer init_data,
|
|
FT_Library library );
|
|
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro FT_OBJ_CREATE (object,class,init)
|
|
*
|
|
* @description:
|
|
* a convenient macro used to create new objects. see
|
|
* @ft_object_create for details
|
|
*/
|
|
#define FT_OBJ_CREATE( _obj, _clazz, _init ) \
|
|
ft_object_create( FT_OBJECT_P(&(_obj)), _clazz, _init )
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro FT_CREATE (object,class,init)
|
|
*
|
|
* @description:
|
|
* a convenient macro used to create new objects. It also
|
|
* sets an _implicit_ local variable named "error" to the error
|
|
* code returned by the object constructor.
|
|
*/
|
|
#define FT_CREATE( _obj, _clazz, _init ) \
|
|
FT_SET_ERROR( FT_OBJ_CREATE( _obj, _clazz, _init ) )
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro FT_OBJ_CREATE_FROM_TYPE (object,type,init)
|
|
*
|
|
* @description:
|
|
* a convenient macro used to create new objects. see
|
|
* @ft_object_create_from_type for details
|
|
*/
|
|
#define FT_OBJ_CREATE_FROM_TYPE( _obj, _type, _init, _lib ) \
|
|
ft_object_create_from_type( FT_OBJECT_P(&(_obj)), _type, _init, _lib )
|
|
|
|
|
|
/**************************************************************
|
|
*
|
|
* @macro FT_CREATE_FROM_TYPE (object,type,init)
|
|
*
|
|
* @description:
|
|
* a convenient macro used to create new objects. It also
|
|
* sets an _implicit_ local variable named "error" to the error
|
|
* code returned by the object constructor.
|
|
*/
|
|
#define FT_CREATE_FROM_TYPE( _obj, _type, _init, _lib ) \
|
|
FT_SET_ERROR( FT_OBJ_CREATE_FROM_TYPE( _obj, _type, _init, _lib ) )
|
|
|
|
|
|
/* */
|
|
|
|
/**************************************************************
|
|
*
|
|
* @function: ft_class_from_type
|
|
*
|
|
* @description:
|
|
* retrieves the class object corresponding to a given type
|
|
* descriptor. The class is created when needed
|
|
*
|
|
* @output:
|
|
* aclass :: handle to corresponding class object. NULL in
|
|
* case of error
|
|
*
|
|
* @input:
|
|
* type :: type descriptor handle
|
|
* library :: library handle
|
|
*
|
|
* @return:
|
|
* error code. 0 means success
|
|
*/
|
|
FT_BASE( FT_Error )
|
|
ft_class_from_type( FT_Class *aclass,
|
|
FT_Type type,
|
|
FT_Library library );
|
|
|
|
|
|
/* */
|
|
|
|
#include FT_INTERNAL_HASH_H
|
|
|
|
typedef struct FT_ClassHNodeRec_* FT_ClassHNode;
|
|
|
|
typedef struct FT_ClassHNodeRec_
|
|
{
|
|
FT_HashNodeRec hnode;
|
|
FT_Type type;
|
|
FT_Class clazz;
|
|
|
|
} FT_ClassHNodeRec;
|
|
|
|
typedef struct FT_MetaClassRec_
|
|
{
|
|
FT_ClassRec clazz; /* the meta-class is a class itself */
|
|
FT_HashRec type_to_class; /* the type => class hash table */
|
|
|
|
} FT_MetaClassRec, *FT_MetaClass;
|
|
|
|
|
|
/* initialize meta class */
|
|
FT_BASE( FT_Error )
|
|
ft_metaclass_init( FT_MetaClass meta,
|
|
FT_Library library );
|
|
|
|
/* finalize meta class - destroy all registered class objects */
|
|
FT_BASE( void )
|
|
ft_metaclass_done( FT_MetaClass meta );
|
|
|
|
/* */
|
|
|
|
FT_END_HEADER
|
|
|
|
#endif /* __FT_OBJECT_H__ */
|