[wxWidgets.git] / 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
cabec872 RR	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 */