src/freetype/base/ftextend.c

/***************************************************************************/
/*                                                                         */
/*  ftextend.h                                                             */
/*                                                                         */
/*    FreeType extensions implementation (body).                           */
/*                                                                         */
/*  Copyright 1996-2000 by                                                 */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used,       */
/*  modified, and distributed under the terms of the FreeType project      */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/

  /*************************************************************************/
  /*                                                                       */
  /*  This is an updated version of the extension component, now located   */
  /*  in the main library's source directory.  It allows the dynamic       */
  /*  registration/use of various face object extensions through a simple  */
  /*  API.                                                                 */
  /*                                                                       */
  /*************************************************************************/


#include <freetype/internal/ftextend.h>
#include <freetype/internal/ftdebug.h>


  /*************************************************************************/
  /*                                                                       */
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  /* messages during execution.                                            */
  /*                                                                       */
#undef  FT_COMPONENT
#define FT_COMPONENT  trace_extend


  typedef struct  FT_Extension_Registry_
  {
    FT_Int              num_extensions;
    FT_Long             cur_offset;
    FT_Extension_Class  classes[FT_MAX_EXTENSIONS];

  } FT_Extension_Registry;


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Init_Extensions                                                 */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Initializes the extension component.                               */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    driver :: A handle to the driver object.                           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  FT_Init_Extensions( FT_Driver  driver )
  {
    FT_Error                error;
    FT_Memory               memory;
    FT_Extension_Registry*  registry;


    memory = driver->root.library->memory;
    if ( ALLOC( registry, sizeof ( *registry ) ) )
      return error;

    registry->num_extensions = 0;
    registry->cur_offset     = 0;
    driver->extensions       = registry;

    FT_TRACE2(( "FT_Init_Extensions: success\n" ));

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_Extensions                                                 */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Finalizes the extension component.                                 */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    driver :: A handle to the driver object.                           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  FT_Done_Extensions( FT_Driver  driver )
  {
    FT_Memory  memory = driver->root.memory;


    FREE( driver->extensions );
    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Register_Extension                                              */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Registers a new extension.                                         */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    driver :: A handle to the driver object.                           */
  /*    class  :: A pointer to a class describing the extension.           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  FT_EXPORT_FUNC( FT_Error )  FT_Register_Extension(
                                FT_Driver            driver,
                                FT_Extension_Class*  clazz )
  {
    FT_Extension_Registry*  registry;


    if ( !driver )
      return FT_Err_Invalid_Driver_Handle;

    if ( !clazz )
      return FT_Err_Invalid_Argument;

    registry = (FT_Extension_Registry*)driver->extensions;
    if ( registry )
    {
      FT_Int               n   = registry->num_extensions;
      FT_Extension_Class*  cur = registry->classes + n;


      if ( n >= FT_MAX_EXTENSIONS )
        return FT_Err_Too_Many_Extensions;

      *cur = *clazz;

      cur->offset  = registry->cur_offset;

      registry->num_extensions++;
      registry->cur_offset +=
        ( cur->size + FT_ALIGNMENT - 1 ) & -FT_ALIGNMENT;

      FT_TRACE1(( "FT_Register_Extension: `%s' successfully registered\n",
                  cur->id ));
    }

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Get_Extension                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Queries an extension block by an extension ID string.              */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face                :: A handle to the face object.                */
  /*    extension_id        :: An ID string identifying the extension.     */
  /*                                                                       */
  /* <Output>                                                              */
  /*    extension_interface :: A generic pointer, usually pointing to a    */
  /*                           table of functions implementing the         */
  /*                           extension interface.                        */
  /*                                                                       */
  /* <Return>                                                              */
  /*    A generic pointer to the extension block.                          */
  /*                                                                       */
  FT_EXPORT_FUNC( void* )  FT_Get_Extension(
                             FT_Face      face,
                             const char*  extension_id,
                             void**       extension_interface )
  {
    FT_Extension_Registry*  registry;


    if ( !face || !extension_id || !extension_interface )
      return 0;

    registry = (FT_Extension_Registry*)face->driver->extensions;
    if ( registry && face->extensions )
    {
      FT_Extension_Class*  cur   = registry->classes;
      FT_Extension_Class*  limit = cur + registry->num_extensions;


      for ( ; cur < limit; cur++ )
        if ( strcmp( cur->id, extension_id ) == 0 )
        {
          *extension_interface = cur->interface;

          FT_TRACE1(( "FT_Get_Extension: got `%s'\n", extension_id ));

          return (void*)((char*)face->extensions + cur->offset);
        }
    }

    /* could not find the extension id */

    FT_ERROR(( "FT_Get_Extension: couldn't find `%s'\n", extension_id ));

    *extension_interface = 0;

    return 0;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Destroy_Extensions                                              */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Destroys all extensions within a face object.                      */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    face :: A handle to the face object.                               */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Called by the face object destructor.                              */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  FT_Destroy_Extensions( FT_Face  face )
  {
    FT_Extension_Registry*  registry;
    FT_Memory               memory;


    registry = (FT_Extension_Registry*)face->driver->extensions;
    if ( registry && face->extensions )
    {
      FT_Extension_Class*  cur   = registry->classes;
      FT_Extension_Class*  limit = cur + registry->num_extensions;


      for ( ; cur < limit; cur++ )
      {
        char*  ext = (char*)face->extensions + cur->offset;

        if ( cur->finalize )
          cur->finalize( ext, face );
      }

      memory = face->driver->root.memory;
      FREE( face->extensions );
    }

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Create_Extensions                                               */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Creates an extension object within a face object for all           */
  /*    registered extensions.                                             */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    face :: A handle to the face object.                               */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Called by the face object constructor.                             */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  FT_Create_Extensions( FT_Face  face )
  {
    FT_Extension_Registry*  registry;
    FT_Memory               memory;
    FT_Error                error;


    face->extensions = 0;

    /* load extensions registry; exit successfully if none is there */

    registry = (FT_Extension_Registry*)face->driver->extensions;
    if ( !registry )
      return FT_Err_Ok;

    memory = face->driver->root.memory;
    if ( ALLOC( face->extensions, registry->cur_offset ) )
      return error;

    {
      FT_Extension_Class*  cur   = registry->classes;
      FT_Extension_Class*  limit = cur + registry->num_extensions;


      for ( ; cur < limit; cur++ )
      {
        char*  ext = (char*)face->extensions + cur->offset;

        if ( cur->init )
        {
          error = cur->init( ext, face );
          if ( error )
            break;
        }
      }
    }

    return error;
  }


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* ftextend.h */
	4	/* */
	5	/* FreeType extensions implementation (body). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18	/*************************************************************************/
	19	/* */
	20	/* This is an updated version of the extension component, now located */
	21	/* in the main library's source directory. It allows the dynamic */
	22	/* registration/use of various face object extensions through a simple */
	23	/* API. */
	24	/* */
	25	/*************************************************************************/
	26
	27
	28	#include <freetype/internal/ftextend.h>
	29	#include <freetype/internal/ftdebug.h>
	30
	31
	32	/*************************************************************************/
	33	/* */
	34	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
	35	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
	36	/* messages during execution. */
	37	/* */
	38	#undef FT_COMPONENT
	39	#define FT_COMPONENT trace_extend
	40
	41
	42	typedef struct FT_Extension_Registry_
	43	{
	44	FT_Int num_extensions;
	45	FT_Long cur_offset;
	46	FT_Extension_Class classes[FT_MAX_EXTENSIONS];
	47
	48	} FT_Extension_Registry;
	49
	50
	51	/*************************************************************************/
	52	/* */
	53	/* <Function> */
	54	/* FT_Init_Extensions */
	55	/* */
	56	/* <Description> */
	57	/* Initializes the extension component. */
	58	/* */
	59	/* <InOut> */
	60	/* driver :: A handle to the driver object. */
	61	/* */
	62	/* <Return> */
	63	/* FreeType error code. 0 means success. */
	64	/* */
	65	LOCAL_FUNC
	66	FT_Error FT_Init_Extensions( FT_Driver driver )
	67	{
	68	FT_Error error;
	69	FT_Memory memory;
	70	FT_Extension_Registry* registry;
	71
	72
	73	memory = driver->root.library->memory;
	74	if ( ALLOC( registry, sizeof ( *registry ) ) )
	75	return error;
	76
	77	registry->num_extensions = 0;
	78	registry->cur_offset = 0;
	79	driver->extensions = registry;
	80
	81	FT_TRACE2(( "FT_Init_Extensions: success\n" ));
	82
	83	return FT_Err_Ok;
	84	}
	85
	86
	87	/*************************************************************************/
	88	/* */
	89	/* <Function> */
	90	/* FT_Done_Extensions */
	91	/* */
	92	/* <Description> */
	93	/* Finalizes the extension component. */
	94	/* */
	95	/* <InOut> */
	96	/* driver :: A handle to the driver object. */
	97	/* */
	98	/* <Return> */
	99	/* FreeType error code. 0 means success. */
	100	/* */
	101	LOCAL_FUNC
	102	FT_Error FT_Done_Extensions( FT_Driver driver )
	103	{
	104	FT_Memory memory = driver->root.memory;
	105
	106
	107	FREE( driver->extensions );
	108	return FT_Err_Ok;
	109	}
	110
	111
	112	/*************************************************************************/
	113	/* */
	114	/* <Function> */
	115	/* FT_Register_Extension */
	116	/* */
	117	/* <Description> */
	118	/* Registers a new extension. */
	119	/* */
	120	/* <InOut> */
	121	/* driver :: A handle to the driver object. */
	122	/* class :: A pointer to a class describing the extension. */
	123	/* */
	124	/* <Return> */
	125	/* FreeType error code. 0 means success. */
	126	/* */
	127	FT_EXPORT_FUNC( FT_Error ) FT_Register_Extension(
	128	FT_Driver driver,
	129	FT_Extension_Class* clazz )
	130	{
	131	FT_Extension_Registry* registry;
	132
	133
	134	if ( !driver )
	135	return FT_Err_Invalid_Driver_Handle;
	136
	137	if ( !clazz )
	138	return FT_Err_Invalid_Argument;
	139
	140	registry = (FT_Extension_Registry*)driver->extensions;
	141	if ( registry )
	142	{
	143	FT_Int n = registry->num_extensions;
	144	FT_Extension_Class* cur = registry->classes + n;
	145
	146
	147	if ( n >= FT_MAX_EXTENSIONS )
	148	return FT_Err_Too_Many_Extensions;
	149
	150	cur = clazz;
	151
	152	cur->offset = registry->cur_offset;
	153
	154	registry->num_extensions++;
	155	registry->cur_offset +=
	156	( cur->size + FT_ALIGNMENT - 1 ) & -FT_ALIGNMENT;
	157
	158	FT_TRACE1(( "FT_Register_Extension: `%s' successfully registered\n",
	159	cur->id ));
	160	}
	161
	162	return FT_Err_Ok;
	163	}
	164
	165
	166	/*************************************************************************/
	167	/* */
	168	/* <Function> */
	169	/* FT_Get_Extension */
	170	/* */
	171	/* <Description> */
	172	/* Queries an extension block by an extension ID string. */
	173	/* */
	174	/* <Input> */
	175	/* face :: A handle to the face object. */
	176	/* extension_id :: An ID string identifying the extension. */
	177	/* */
	178	/* <Output> */
	179	/* extension_interface :: A generic pointer, usually pointing to a */
	180	/* table of functions implementing the */
	181	/* extension interface. */
	182	/* */
	183	/* <Return> */
	184	/* A generic pointer to the extension block. */
	185	/* */
	186	FT_EXPORT_FUNC( void* ) FT_Get_Extension(
	187	FT_Face face,
	188	const char* extension_id,
	189	void** extension_interface )
	190	{
	191	FT_Extension_Registry* registry;
	192
	193
	194	if ( !face \|\| !extension_id \|\| !extension_interface )
	195	return 0;
	196
	197	registry = (FT_Extension_Registry*)face->driver->extensions;
	198	if ( registry && face->extensions )
	199	{
	200	FT_Extension_Class* cur = registry->classes;
	201	FT_Extension_Class* limit = cur + registry->num_extensions;
	202
	203
	204	for ( ; cur < limit; cur++ )
	205	if ( strcmp( cur->id, extension_id ) == 0 )
	206	{
	207	*extension_interface = cur->interface;
	208
	209	FT_TRACE1(( "FT_Get_Extension: got `%s'\n", extension_id ));
	210
	211	return (void)((char)face->extensions + cur->offset);
	212	}
	213	}
	214
	215	/* could not find the extension id */
	216
	217	FT_ERROR(( "FT_Get_Extension: couldn't find `%s'\n", extension_id ));
	218
	219	*extension_interface = 0;
	220
	221	return 0;
	222	}
	223
	224
	225	/*************************************************************************/
	226	/* */
	227	/* <Function> */
	228	/* FT_Destroy_Extensions */
	229	/* */
	230	/* <Description> */
	231	/* Destroys all extensions within a face object. */
	232	/* */
	233	/* <InOut> */
	234	/* face :: A handle to the face object. */
	235	/* */
	236	/* <Return> */
	237	/* FreeType error code. 0 means success. */
	238	/* */
	239	/* <Note> */
	240	/* Called by the face object destructor. */
	241	/* */
	242	LOCAL_FUNC
	243	FT_Error FT_Destroy_Extensions( FT_Face face )
	244	{
	245	FT_Extension_Registry* registry;
	246	FT_Memory memory;
	247
	248
	249	registry = (FT_Extension_Registry*)face->driver->extensions;
	250	if ( registry && face->extensions )
	251	{
	252	FT_Extension_Class* cur = registry->classes;
	253	FT_Extension_Class* limit = cur + registry->num_extensions;
	254
	255
	256	for ( ; cur < limit; cur++ )
	257	{
	258	char* ext = (char*)face->extensions + cur->offset;
	259
	260	if ( cur->finalize )
	261	cur->finalize( ext, face );
	262	}
	263
	264	memory = face->driver->root.memory;
	265	FREE( face->extensions );
	266	}
	267
	268	return FT_Err_Ok;
	269	}
	270
	271
	272	/*************************************************************************/
	273	/* */
	274	/* <Function> */
	275	/* FT_Create_Extensions */
	276	/* */
	277	/* <Description> */
	278	/* Creates an extension object within a face object for all */
	279	/* registered extensions. */
	280	/* */
	281	/* <InOut> */
	282	/* face :: A handle to the face object. */
	283	/* */
	284	/* <Return> */
	285	/* FreeType error code. 0 means success. */
	286	/* */
	287	/* <Note> */
	288	/* Called by the face object constructor. */
	289	/* */
	290	LOCAL_FUNC
	291	FT_Error FT_Create_Extensions( FT_Face face )
	292	{
	293	FT_Extension_Registry* registry;
	294	FT_Memory memory;
	295	FT_Error error;
	296
	297
	298	face->extensions = 0;
	299
	300	/* load extensions registry; exit successfully if none is there */
	301
	302	registry = (FT_Extension_Registry*)face->driver->extensions;
	303	if ( !registry )
	304	return FT_Err_Ok;
	305
	306	memory = face->driver->root.memory;
	307	if ( ALLOC( face->extensions, registry->cur_offset ) )
	308	return error;
	309
	310	{
	311	FT_Extension_Class* cur = registry->classes;
	312	FT_Extension_Class* limit = cur + registry->num_extensions;
	313
	314
	315	for ( ; cur < limit; cur++ )
	316	{
	317	char* ext = (char*)face->extensions + cur->offset;
	318
	319	if ( cur->init )
	320	{
	321	error = cur->init( ext, face );
	322	if ( error )
	323	break;
	324	}
	325	}
	326	}
	327
	328	return error;
	329	}
	330
	331
	332	/* END */