#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__ */