[wxWidgets.git] / src / freetype / type1z / z1driver.c

/***************************************************************************/
/*                                                                         */
/*  z1driver.c                                                             */
/*                                                                         */
/*    Experimental Type 1 driver interface (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.                                        */
/*                                                                         */
/***************************************************************************/


#ifdef FT_FLAT_COMPILE

#include "z1driver.h"
#include "z1gload.h"
#include "z1load.h"
#include "z1afm.h"

#else

#include <type1z/z1driver.h>
#include <type1z/z1gload.h>
#include <type1z/z1load.h>
#include <type1z/z1afm.h>

#endif


#include <freetype/internal/ftdebug.h>
#include <freetype/internal/ftstream.h>
#include <freetype/internal/psnames.h>

#include <string.h>     /* for strcmp() */


  /*************************************************************************/
  /*                                                                       */
  /* 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_z1driver


  static
  FT_Error  get_z1_glyph_name( T1_Face     face,
                               FT_UInt     glyph_index,
                               FT_Pointer  buffer,
                               FT_UInt     buffer_max )
  {
    FT_String*  gname;
    

    gname = face->type1.glyph_names[glyph_index];

    if ( buffer_max > 0 )
    {
      FT_UInt  len = strlen( gname );
      

      if (len >= buffer_max)
        len = buffer_max - 1;
        
      MEM_Copy( buffer, gname, len );
      ((FT_Byte*)buffer)[len] = 0;
    }

    return T1_Err_Ok;
  }                                  


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    Get_Interface                                                      */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Each driver can provide one or more extensions to the base         */
  /*    FreeType API.  These can be used to access format specific         */
  /*    features (e.g., all TrueType/OpenType resources share a common     */
  /*    file structure and common tables which can be accessed through the */
  /*    `sfnt' interface), or more simply generic ones (e.g., the          */
  /*    `postscript names' interface which can be used to retrieve the     */
  /*     PostScript name of a given glyph index).                          */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    driver    :: A handle to a driver object.                          */
  /*                                                                       */
  /* <Input>                                                               */
  /*    interface :: A string designing the interface.  Examples are       */
  /*                 `sfnt', `post_names', `charmaps', etc.                */
  /*                                                                       */
  /* <Return>                                                              */
  /*    A typeless pointer to the extension's interface (normally a table  */
  /*    of function pointers).  Returns NULL if the requested extension    */
  /*    isn't available (i.e., wasn't compiled in the driver at build      */
  /*    time).                                                             */
  /*                                                                       */
  static
  FT_Module_Interface  Get_Interface( FT_Driver         driver,
                                      const FT_String*  interface )
  {
    FT_UNUSED( driver );
    FT_UNUSED( interface );

    if ( strcmp( (const char*)interface, "glyph_name" ) == 0 )
      return (FT_Module_Interface)get_z1_glyph_name;

#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT
    if ( strcmp( (const char*)interface, "get_mm" ) == 0 )
      return (FT_Module_Interface)Z1_Get_Multi_Master;

    if ( strcmp( (const char*)interface, "set_mm_design") == 0 )
      return (FT_Module_Interface)Z1_Set_MM_Design;

    if ( strcmp( (const char*)interface, "set_mm_blend") == 0 )
      return (FT_Module_Interface)Z1_Set_MM_Blend;
#endif
    return 0;
  }


#ifndef Z1_CONFIG_OPTION_NO_AFM

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    Get_Kerning                                                        */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A driver method used to return the kerning vector between two      */
  /*    glyphs of the same face.                                           */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face        :: A handle to the source face object.                 */
  /*                                                                       */
  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
  /*                                                                       */
  /*    right_glyph :: The index of the right glyph in the kern pair.      */
  /*                                                                       */
  /* <Output>                                                              */
  /*    kerning     :: The kerning vector.  This is in font units for      */
  /*                   scalable formats, and in pixels for fixed-sizes     */
  /*                   formats.                                            */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
  /*    supported by this function.  Other layouts, or more sophisticated  */
  /*    kernings are out of scope of this method (the basic driver         */
  /*    interface is meant to be simple).                                  */
  /*                                                                       */
  /*    They can be implemented by format-specific interfaces.             */
  /*                                                                       */
  static
  FT_Error  Get_Kerning( T1_Face     face,
                         FT_UInt     left_glyph,
                         FT_UInt     right_glyph,
                         FT_Vector*  kerning )
  {
    Z1_AFM*  afm;


    kerning->x = 0;
    kerning->y = 0;

    afm = (Z1_AFM*)face->afm_data;
    if ( afm )
      Z1_Get_Kerning( afm, left_glyph, right_glyph, kerning );

    return T1_Err_Ok;
  }


#endif /* T1_CONFIG_OPTION_NO_AFM */


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    Get_Char_Index                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Uses a charmap to return a given character code's glyph index.     */
  /*                                                                       */
  /* <Input>                                                               */
  /*    charmap  :: A handle to the source charmap object.                 */
  /*    charcode :: The character code.                                    */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Glyph index.  0 means `undefined character code'.                  */
  /*                                                                       */
  static
  FT_UInt  Get_Char_Index( FT_CharMap  charmap,
                           FT_Long     charcode )
  {
    T1_Face             face;
    FT_UInt             result = 0;
    PSNames_Interface*  psnames;


    face    = (T1_Face)charmap->face;
    psnames = (PSNames_Interface*)face->psnames;
    if ( psnames )
      switch ( charmap->encoding )
      {
        /*******************************************************************/
        /*                                                                 */
        /* Unicode encoding support                                        */
        /*                                                                 */
      case ft_encoding_unicode:
        /* use the `PSNames' module to synthetize the Unicode charmap */
        result = psnames->lookup_unicode( &face->unicode_map,
                                          (FT_ULong)charcode );

        /* the function returns 0xFFFF if the Unicode charcode has */
        /* no corresponding glyph                                  */
        if ( result == 0xFFFF )
          result = 0;
        goto Exit;

        /*******************************************************************/
        /*                                                                 */
        /* Custom Type 1 encoding                                          */
        /*                                                                 */
      case ft_encoding_adobe_custom:
        {
          T1_Encoding*  encoding = &face->type1.encoding;


          if ( charcode >= encoding->code_first &&
               charcode <= encoding->code_last  )
            result = encoding->char_index[charcode];
          goto Exit;
        }

        /*******************************************************************/
        /*                                                                 */
        /* Adobe Standard & Expert encoding support                        */
        /*                                                                 */
      default:
        if ( charcode < 256 )
        {
          FT_UInt      code;
          FT_Int       n;
          const char*  glyph_name;


          code = psnames->adobe_std_encoding[charcode];
          if ( charmap->encoding == ft_encoding_adobe_expert )
            code = psnames->adobe_expert_encoding[charcode];

          glyph_name = psnames->adobe_std_strings( code );
          if ( !glyph_name )
            break;

          for ( n = 0; n < face->type1.num_glyphs; n++ )
          {
            const char*  gname = face->type1.glyph_names[n];


            if ( gname && gname[0] == glyph_name[0] &&
                 strcmp( gname, glyph_name ) == 0   )
            {
              result = n;
              break;
            }
          }
        }
      }
  Exit:
    return result;
  }


  const FT_Driver_Class  t1_driver_class =
  {
    {
      ft_module_font_driver | ft_module_driver_scalable,
      sizeof( FT_DriverRec ),

      "type1",
      0x10000L,
      0x20000L,

      0,   /* format interface */

      (FT_Module_Constructor)Z1_Init_Driver,
      (FT_Module_Destructor) Z1_Done_Driver,
      (FT_Module_Requester)  Get_Interface,
    },

    sizeof( T1_FaceRec ),
    sizeof( Z1_SizeRec ),
    sizeof( Z1_GlyphSlotRec ),

    (FTDriver_initFace)     Z1_Init_Face,
    (FTDriver_doneFace)     Z1_Done_Face,
    (FTDriver_initSize)     0,
    (FTDriver_doneSize)     0,
    (FTDriver_initGlyphSlot)0,
    (FTDriver_doneGlyphSlot)0,

    (FTDriver_setCharSizes) 0,
    (FTDriver_setPixelSizes)0,
    (FTDriver_loadGlyph)    Z1_Load_Glyph,
    (FTDriver_getCharIndex) Get_Char_Index,

#ifdef Z1_CONFIG_OPTION_NO_AFM
    (FTDriver_getKerning)   0,
    (FTDriver_attachFile)   0,
#else
    (FTDriver_getKerning)   Get_Kerning,
    (FTDriver_attachFile)   Z1_Read_AFM,
#endif
    (FTDriver_getAdvances)  0
  };


#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS

  EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
  {
    return &t1z_driver_class;
  }

#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */


/* END */
Commit	Line	Data
cabec872 RR	1	/***************************************************************************/
	2	/* */
	3	/* z1driver.c */
	4	/* */
	5	/* Experimental Type 1 driver interface (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	#ifdef FT_FLAT_COMPILE
	20
	21	#include "z1driver.h"
	22	#include "z1gload.h"
	23	#include "z1load.h"
	24	#include "z1afm.h"
	25
	26	#else
	27
	28	#include <type1z/z1driver.h>
	29	#include <type1z/z1gload.h>
	30	#include <type1z/z1load.h>
	31	#include <type1z/z1afm.h>
	32
	33	#endif
	34
	35
	36	#include <freetype/internal/ftdebug.h>
	37	#include <freetype/internal/ftstream.h>
	38	#include <freetype/internal/psnames.h>
	39
	40	#include <string.h> /* for strcmp() */
	41
	42
	43	/*************************************************************************/
	44	/* */
	45	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
	46	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
	47	/* messages during execution. */
	48	/* */
	49	#undef FT_COMPONENT
	50	#define FT_COMPONENT trace_z1driver
	51
	52
	53	static
	54	FT_Error get_z1_glyph_name( T1_Face face,
	55	FT_UInt glyph_index,
	56	FT_Pointer buffer,
	57	FT_UInt buffer_max )
	58	{
	59	FT_String* gname;
	60
	61
	62	gname = face->type1.glyph_names[glyph_index];
	63
	64	if ( buffer_max > 0 )
65	{
66	FT_UInt len = strlen( gname );
67
68
69	if (len >= buffer_max)
70	len = buffer_max - 1;
71
72	MEM_Copy( buffer, gname, len );
73	((FT_Byte*)buffer)[len] = 0;
74	}
75
76	return T1_Err_Ok;
77	}
78
79
80	/*************************************************************************/
81	/* */
82	/* <Function> */
83	/* Get_Interface */
84	/* */
85	/* <Description> */
86	/* Each driver can provide one or more extensions to the base */
87	/* FreeType API. These can be used to access format specific */
88	/* features (e.g., all TrueType/OpenType resources share a common */
89	/* file structure and common tables which can be accessed through the */
90	/* `sfnt' interface), or more simply generic ones (e.g., the */
91	/* `postscript names' interface which can be used to retrieve the */
92	/* PostScript name of a given glyph index). */
93	/* */
94	/* <InOut> */
95	/* driver :: A handle to a driver object. */
96	/* */
97	/* <Input> */
98	/* interface :: A string designing the interface. Examples are */
99	/* `sfnt', `post_names', `charmaps', etc. */
100	/* */
101	/* <Return> */
102	/* A typeless pointer to the extension's interface (normally a table */
103	/* of function pointers). Returns NULL if the requested extension */
104	/* isn't available (i.e., wasn't compiled in the driver at build */
105	/* time). */
106	/* */
107	static
108	FT_Module_Interface Get_Interface( FT_Driver driver,
109	const FT_String* interface )
110	{
111	FT_UNUSED( driver );
112	FT_UNUSED( interface );
113
114	if ( strcmp( (const char*)interface, "glyph_name" ) == 0 )
115	return (FT_Module_Interface)get_z1_glyph_name;
116
117	#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT
118	if ( strcmp( (const char*)interface, "get_mm" ) == 0 )
119	return (FT_Module_Interface)Z1_Get_Multi_Master;
120
121	if ( strcmp( (const char*)interface, "set_mm_design") == 0 )
122	return (FT_Module_Interface)Z1_Set_MM_Design;
123
124	if ( strcmp( (const char*)interface, "set_mm_blend") == 0 )
125	return (FT_Module_Interface)Z1_Set_MM_Blend;
126	#endif
127	return 0;
128	}
129
130
131	#ifndef Z1_CONFIG_OPTION_NO_AFM
132
133	/*************************************************************************/
134	/* */
135	/* <Function> */
136	/* Get_Kerning */
137	/* */
138	/* <Description> */
139	/* A driver method used to return the kerning vector between two */
140	/* glyphs of the same face. */
141	/* */
142	/* <Input> */
143	/* face :: A handle to the source face object. */
144	/* */
145	/* left_glyph :: The index of the left glyph in the kern pair. */
146	/* */
147	/* right_glyph :: The index of the right glyph in the kern pair. */
148	/* */
149	/* <Output> */
150	/* kerning :: The kerning vector. This is in font units for */
151	/* scalable formats, and in pixels for fixed-sizes */
152	/* formats. */
153	/* */
154	/* <Return> */
155	/* FreeType error code. 0 means success. */
156	/* */
157	/* <Note> */
158	/* Only horizontal layouts (left-to-right & right-to-left) are */
159	/* supported by this function. Other layouts, or more sophisticated */
160	/* kernings are out of scope of this method (the basic driver */
161	/* interface is meant to be simple). */
162	/* */
163	/* They can be implemented by format-specific interfaces. */
164	/* */
165	static
166	FT_Error Get_Kerning( T1_Face face,
167	FT_UInt left_glyph,
168	FT_UInt right_glyph,
169	FT_Vector* kerning )
170	{
171	Z1_AFM* afm;
172
173
174	kerning->x = 0;
175	kerning->y = 0;
176
177	afm = (Z1_AFM*)face->afm_data;
178	if ( afm )
179	Z1_Get_Kerning( afm, left_glyph, right_glyph, kerning );
180
181	return T1_Err_Ok;
182	}
183
184
185	#endif /* T1_CONFIG_OPTION_NO_AFM */
186
187
188	/*************************************************************************/
189	/* */
190	/* <Function> */
191	/* Get_Char_Index */
192	/* */
193	/* <Description> */
194	/* Uses a charmap to return a given character code's glyph index. */
195	/* */
196	/* <Input> */
197	/* charmap :: A handle to the source charmap object. */
198	/* charcode :: The character code. */
199	/* */
200	/* <Return> */
201	/* Glyph index. 0 means `undefined character code'. */
202	/* */
203	static
204	FT_UInt Get_Char_Index( FT_CharMap charmap,
205	FT_Long charcode )
206	{
207	T1_Face face;
208	FT_UInt result = 0;
209	PSNames_Interface* psnames;
210
211
212	face = (T1_Face)charmap->face;
213	psnames = (PSNames_Interface*)face->psnames;
214	if ( psnames )
215	switch ( charmap->encoding )
216	{
217	/*******************************************************************/
218	/* */
219	/* Unicode encoding support */
220	/* */
221	case ft_encoding_unicode:
222	/* use the `PSNames' module to synthetize the Unicode charmap */
223	result = psnames->lookup_unicode( &face->unicode_map,
224	(FT_ULong)charcode );
225
226	/* the function returns 0xFFFF if the Unicode charcode has */
227	/* no corresponding glyph */
228	if ( result == 0xFFFF )
229	result = 0;
230	goto Exit;
231
232	/*******************************************************************/
233	/* */
234	/* Custom Type 1 encoding */
235	/* */
236	case ft_encoding_adobe_custom:
237	{
238	T1_Encoding* encoding = &face->type1.encoding;
239
240
241	if ( charcode >= encoding->code_first &&
242	charcode <= encoding->code_last )
243	result = encoding->char_index[charcode];
244	goto Exit;
245	}
246
247	/*******************************************************************/
248	/* */
249	/* Adobe Standard & Expert encoding support */
250	/* */
251	default:
252	if ( charcode < 256 )
253	{
254	FT_UInt code;
255	FT_Int n;
256	const char* glyph_name;
257
258
259	code = psnames->adobe_std_encoding[charcode];
260	if ( charmap->encoding == ft_encoding_adobe_expert )
261	code = psnames->adobe_expert_encoding[charcode];
262
263	glyph_name = psnames->adobe_std_strings( code );
264	if ( !glyph_name )
265	break;
266
267	for ( n = 0; n < face->type1.num_glyphs; n++ )
268	{
269	const char* gname = face->type1.glyph_names[n];
270
271
272	if ( gname && gname[0] == glyph_name[0] &&
273	strcmp( gname, glyph_name ) == 0 )
274	{
275	result = n;
276	break;
277	}
278	}
279	}
280	}
281	Exit:
282	return result;
283	}
284
285
286	const FT_Driver_Class t1_driver_class =
287	{
288	{
289	ft_module_font_driver \| ft_module_driver_scalable,
290	sizeof( FT_DriverRec ),
291
292	"type1",
293	0x10000L,
294	0x20000L,
295
296	0, /* format interface */
297
298	(FT_Module_Constructor)Z1_Init_Driver,
299	(FT_Module_Destructor) Z1_Done_Driver,
300	(FT_Module_Requester) Get_Interface,
301	},
302
303	sizeof( T1_FaceRec ),
304	sizeof( Z1_SizeRec ),
305	sizeof( Z1_GlyphSlotRec ),
306
307	(FTDriver_initFace) Z1_Init_Face,
308	(FTDriver_doneFace) Z1_Done_Face,
309	(FTDriver_initSize) 0,
310	(FTDriver_doneSize) 0,
311	(FTDriver_initGlyphSlot)0,
312	(FTDriver_doneGlyphSlot)0,
313
314	(FTDriver_setCharSizes) 0,
315	(FTDriver_setPixelSizes)0,
316	(FTDriver_loadGlyph) Z1_Load_Glyph,
317	(FTDriver_getCharIndex) Get_Char_Index,
318
319	#ifdef Z1_CONFIG_OPTION_NO_AFM
320	(FTDriver_getKerning) 0,
321	(FTDriver_attachFile) 0,
322	#else
323	(FTDriver_getKerning) Get_Kerning,
324	(FTDriver_attachFile) Z1_Read_AFM,
325	#endif
326	(FTDriver_getAdvances) 0
327	};
328
329
330	#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
331
332	EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void )
333	{
334	return &t1z_driver_class;
335	}
336
337	#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
338
339
340	/* END */