← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/include/freetype/internal/ftserv.h

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/libfreetype/include/freetype/internal/ftserv.h
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftserv.h                                                               */
 
4
/*                                                                         */
 
5
/*    The FreeType services (specification only).                          */
 
6
/*                                                                         */
 
7
/*  Copyright 2003, 2004, 2005, 2006, 2007 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
  /*  Each module can export one or more `services'.  Each service is      */
 
21
  /*  identified by a constant string and modeled by a pointer; the latter */
 
22
  /*  generally corresponds to a structure containing function pointers.   */
 
23
  /*                                                                       */
 
24
  /*  Note that a service's data cannot be a mere function pointer because */
 
25
  /*  in C it is possible that function pointers might be implemented      */
 
26
  /*  differently than data pointers (e.g. 48 bits instead of 32).         */
 
27
  /*                                                                       */
 
28
  /*************************************************************************/
 
29
 
 
30
 
 
31
#ifndef __FTSERV_H__
 
32
#define __FTSERV_H__
 
33
 
 
34
 
 
35
FT_BEGIN_HEADER
 
36
 
 
37
#if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
 
38
 
 
39
  /* we disable the warning `conditional expression is constant' here */
 
40
  /* in order to compile cleanly with the maximum level of warnings   */
 
41
#pragma warning( disable : 4127 )
 
42
 
 
43
#endif /* _MSC_VER */
 
44
 
 
45
  /*
 
46
   * @macro:
 
47
   *   FT_FACE_FIND_SERVICE
 
48
   *
 
49
   * @description:
 
50
   *   This macro is used to look up a service from a face's driver module.
 
51
   *
 
52
   * @input:
 
53
   *   face ::
 
54
   *     The source face handle.
 
55
   *
 
56
   *   id ::
 
57
   *     A string describing the service as defined in the service's
 
58
   *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
 
59
   *     `multi-masters').  It is automatically prefixed with
 
60
   *     `FT_SERVICE_ID_'.
 
61
   *
 
62
   * @output:
 
63
   *   ptr ::
 
64
   *     A variable that receives the service pointer.  Will be NULL
 
65
   *     if not found.
 
66
   */
 
67
#ifdef __cplusplus
 
68
 
 
69
#define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
 
70
  FT_BEGIN_STMNT                                                            \
 
71
    FT_Module    module = FT_MODULE( FT_FACE( face )->driver );             \
 
72
    FT_Pointer   _tmp_  = NULL;                                             \
 
73
    FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                              \
 
74
                                                                            \
 
75
                                                                            \
 
76
    if ( module->clazz->get_interface )                                     \
 
77
      _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
 
78
    *_pptr_ = _tmp_;                                                        \
 
79
  FT_END_STMNT
 
80
 
 
81
#else /* !C++ */
 
82
 
 
83
#define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
 
84
  FT_BEGIN_STMNT                                                            \
 
85
    FT_Module   module = FT_MODULE( FT_FACE( face )->driver );              \
 
86
    FT_Pointer  _tmp_  = NULL;                                              \
 
87
                                                                            \
 
88
    if ( module->clazz->get_interface )                                     \
 
89
      _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
 
90
    ptr = _tmp_;                                                            \
 
91
  FT_END_STMNT
 
92
 
 
93
#endif /* !C++ */
 
94
 
 
95
  /*
 
96
   * @macro:
 
97
   *   FT_FACE_FIND_GLOBAL_SERVICE
 
98
   *
 
99
   * @description:
 
100
   *   This macro is used to look up a service from all modules.
 
101
   *
 
102
   * @input:
 
103
   *   face ::
 
104
   *     The source face handle.
 
105
   *
 
106
   *   id ::
 
107
   *     A string describing the service as defined in the service's
 
108
   *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
 
109
   *     `multi-masters').  It is automatically prefixed with
 
110
   *     `FT_SERVICE_ID_'.
 
111
   *
 
112
   * @output:
 
113
   *   ptr ::
 
114
   *     A variable that receives the service pointer.  Will be NULL
 
115
   *     if not found.
 
116
   */
 
117
#ifdef __cplusplus
 
118
 
 
119
#define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
 
120
  FT_BEGIN_STMNT                                                   \
 
121
    FT_Module    module = FT_MODULE( FT_FACE( face )->driver );    \
 
122
    FT_Pointer   _tmp_;                                            \
 
123
    FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                     \
 
124
                                                                   \
 
125
                                                                   \
 
126
    _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
 
127
    *_pptr_ = _tmp_;                                               \
 
128
  FT_END_STMNT
 
129
 
 
130
#else /* !C++ */
 
131
 
 
132
#define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
 
133
  FT_BEGIN_STMNT                                                   \
 
134
    FT_Module   module = FT_MODULE( FT_FACE( face )->driver );     \
 
135
    FT_Pointer  _tmp_;                                             \
 
136
                                                                   \
 
137
                                                                   \
 
138
    _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
 
139
    ptr   = _tmp_;                                                 \
 
140
  FT_END_STMNT
 
141
 
 
142
#endif /* !C++ */
 
143
 
 
144
 
 
145
  /*************************************************************************/
 
146
  /*************************************************************************/
 
147
  /*****                                                               *****/
 
148
  /*****         S E R V I C E   D E S C R I P T O R S                 *****/
 
149
  /*****                                                               *****/
 
150
  /*************************************************************************/
 
151
  /*************************************************************************/
 
152
 
 
153
  /*
 
154
   *  The following structure is used to _describe_ a given service
 
155
   *  to the library.  This is useful to build simple static service lists.
 
156
   */
 
157
  typedef struct  FT_ServiceDescRec_
 
158
  {
 
159
    const char*  serv_id;     /* service name         */
 
160
    const void*  serv_data;   /* service pointer/data */
 
161
 
 
162
  } FT_ServiceDescRec;
 
163
 
 
164
  typedef const FT_ServiceDescRec*  FT_ServiceDesc;
 
165
 
 
166
  /*************************************************************************/
 
167
  /*                                                                       */
 
168
  /* <Macro>                                                               */
 
169
  /*    FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6             */
 
170
  /*                                                                       */
 
171
  /* <Description>                                                         */
 
172
  /*    Used to initialize an array of FT_ServiceDescRec structs.          */
 
173
  /*                                                                       */
 
174
  /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
 
175
  /*    to called with a pointer where the allocated array is returned.    */
 
176
  /*    And when it is no longer needed a Destroy function needs           */
 
177
  /*    to be called to release that allocation.                           */
 
178
  /*                                                                       */
 
179
  /*    These functions should be manyally called from the pic_init and    */
 
180
  /*    pic_free functions of your module (see FT_DEFINE_MODULE)           */
 
181
  /*                                                                       */
 
182
  /*    When FT_CONFIG_OPTION_PIC is not defined the array will be         */
 
183
  /*    allocated in the global scope (or the scope where the macro        */
 
184
  /*    is used).                                                          */
 
185
  /*                                                                       */
 
186
#ifndef FT_CONFIG_OPTION_PIC
 
187
 
 
188
#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
 
189
  static const FT_ServiceDescRec class_[] =                                  \
 
190
  {                                                                          \
 
191
  {serv_id_1, serv_data_1},                                                  \
 
192
  {NULL, NULL}                                                               \
 
193
  };
 
194
#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
 
195
        serv_id_2, serv_data_2)                                              \
 
196
  static const FT_ServiceDescRec class_[] =                                  \
 
197
  {                                                                          \
 
198
  {serv_id_1, serv_data_1},                                                  \
 
199
  {serv_id_2, serv_data_2},                                                  \
 
200
  {NULL, NULL}                                                               \
 
201
  };
 
202
#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
 
203
        serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
 
204
  static const FT_ServiceDescRec class_[] =                                  \
 
205
  {                                                                          \
 
206
  {serv_id_1, serv_data_1},                                                  \
 
207
  {serv_id_2, serv_data_2},                                                  \
 
208
  {serv_id_3, serv_data_3},                                                  \
 
209
  {NULL, NULL}                                                               \
 
210
  };
 
211
#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
 
212
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
213
        serv_id_4, serv_data_4)                                              \
 
214
  static const FT_ServiceDescRec class_[] =                                  \
 
215
  {                                                                          \
 
216
  {serv_id_1, serv_data_1},                                                  \
 
217
  {serv_id_2, serv_data_2},                                                  \
 
218
  {serv_id_3, serv_data_3},                                                  \
 
219
  {serv_id_4, serv_data_4},                                                  \
 
220
  {NULL, NULL}                                                               \
 
221
  };
 
222
#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
 
223
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
224
        serv_id_4, serv_data_4, serv_id_5, serv_data_5)                      \
 
225
  static const FT_ServiceDescRec class_[] =                                  \
 
226
  {                                                                          \
 
227
  {serv_id_1, serv_data_1},                                                  \
 
228
  {serv_id_2, serv_data_2},                                                  \
 
229
  {serv_id_3, serv_data_3},                                                  \
 
230
  {serv_id_4, serv_data_4},                                                  \
 
231
  {serv_id_5, serv_data_5},                                                  \
 
232
  {NULL, NULL}                                                               \
 
233
  };
 
234
#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
 
235
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
236
        serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
 
237
        serv_id_6, serv_data_6)                                              \
 
238
  static const FT_ServiceDescRec class_[] =                                  \
 
239
  {                                                                          \
 
240
  {serv_id_1, serv_data_1},                                                  \
 
241
  {serv_id_2, serv_data_2},                                                  \
 
242
  {serv_id_3, serv_data_3},                                                  \
 
243
  {serv_id_4, serv_data_4},                                                  \
 
244
  {serv_id_5, serv_data_5},                                                  \
 
245
  {serv_id_6, serv_data_6},                                                  \
 
246
  {NULL, NULL}                                                               \
 
247
  };
 
248
 
 
249
#else /* FT_CONFIG_OPTION_PIC */ 
 
250
 
 
251
#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
 
252
  void                                                                       \
 
253
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
254
                             FT_ServiceDescRec* clazz )                      \
 
255
  {                                                                          \
 
256
    FT_Memory memory = library->memory;                                      \
 
257
    if ( clazz )                                                             \
 
258
      FT_FREE( clazz );                                                      \
 
259
  }                                                                          \
 
260
                                                                             \
 
261
  FT_Error                                                                   \
 
262
  FT_Create_Class_##class_( FT_Library library,                              \
 
263
                            FT_ServiceDescRec** output_class)                \
 
264
  {                                                                          \
 
265
    FT_ServiceDescRec*  clazz;                                               \
 
266
    FT_Error          error;                                                 \
 
267
    FT_Memory memory = library->memory;                                      \
 
268
                                                                             \
 
269
    if ( FT_ALLOC( clazz, sizeof(*clazz)*2 ) )                               \
 
270
      return error;                                                          \
 
271
    clazz[0].serv_id = serv_id_1;                                            \
 
272
    clazz[0].serv_data = serv_data_1;                                        \
 
273
    clazz[1].serv_id = NULL;                                                 \
 
274
    clazz[1].serv_data = NULL;                                               \
 
275
    *output_class = clazz;                                                   \
 
276
    return FT_Err_Ok;                                                        \
 
277
  } 
 
278
 
 
279
#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
 
280
        serv_id_2, serv_data_2)                                              \
 
281
  void                                                                       \
 
282
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
283
                             FT_ServiceDescRec* clazz )                      \
 
284
  {                                                                          \
 
285
    FT_Memory memory = library->memory;                                      \
 
286
    if ( clazz )                                                             \
 
287
      FT_FREE( clazz );                                                      \
 
288
  }                                                                          \
 
289
                                                                             \
 
290
  FT_Error                                                                   \
 
291
  FT_Create_Class_##class_( FT_Library library,                              \
 
292
                            FT_ServiceDescRec** output_class)                \
 
293
  {                                                                          \
 
294
    FT_ServiceDescRec*  clazz;                                               \
 
295
    FT_Error          error;                                                 \
 
296
    FT_Memory memory = library->memory;                                      \
 
297
                                                                             \
 
298
    if ( FT_ALLOC( clazz, sizeof(*clazz)*3 ) )                               \
 
299
      return error;                                                          \
 
300
    clazz[0].serv_id = serv_id_1;                                            \
 
301
    clazz[0].serv_data = serv_data_1;                                        \
 
302
    clazz[1].serv_id = serv_id_2;                                            \
 
303
    clazz[1].serv_data = serv_data_2;                                        \
 
304
    clazz[2].serv_id = NULL;                                                 \
 
305
    clazz[2].serv_data = NULL;                                               \
 
306
    *output_class = clazz;                                                   \
 
307
    return FT_Err_Ok;                                                        \
 
308
  } 
 
309
 
 
310
#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
 
311
        serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
 
312
  void                                                                       \
 
313
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
314
                             FT_ServiceDescRec* clazz )                      \
 
315
  {                                                                          \
 
316
    FT_Memory memory = library->memory;                                      \
 
317
    if ( clazz )                                                             \
 
318
      FT_FREE( clazz );                                                      \
 
319
  }                                                                          \
 
320
                                                                             \
 
321
  FT_Error                                                                   \
 
322
  FT_Create_Class_##class_( FT_Library library,                              \
 
323
                            FT_ServiceDescRec** output_class)                \
 
324
  {                                                                          \
 
325
    FT_ServiceDescRec*  clazz;                                               \
 
326
    FT_Error          error;                                                 \
 
327
    FT_Memory memory = library->memory;                                      \
 
328
                                                                             \
 
329
    if ( FT_ALLOC( clazz, sizeof(*clazz)*4 ) )                               \
 
330
      return error;                                                          \
 
331
    clazz[0].serv_id = serv_id_1;                                            \
 
332
    clazz[0].serv_data = serv_data_1;                                        \
 
333
    clazz[1].serv_id = serv_id_2;                                            \
 
334
    clazz[1].serv_data = serv_data_2;                                        \
 
335
    clazz[2].serv_id = serv_id_3;                                            \
 
336
    clazz[2].serv_data = serv_data_3;                                        \
 
337
    clazz[3].serv_id = NULL;                                                 \
 
338
    clazz[3].serv_data = NULL;                                               \
 
339
    *output_class = clazz;                                                   \
 
340
    return FT_Err_Ok;                                                        \
 
341
  } 
 
342
 
 
343
#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
 
344
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
345
        serv_id_4, serv_data_4)                                              \
 
346
  void                                                                       \
 
347
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
348
                             FT_ServiceDescRec* clazz )                      \
 
349
  {                                                                          \
 
350
    FT_Memory memory = library->memory;                                      \
 
351
    if ( clazz )                                                             \
 
352
      FT_FREE( clazz );                                                      \
 
353
  }                                                                          \
 
354
                                                                             \
 
355
  FT_Error                                                                   \
 
356
  FT_Create_Class_##class_( FT_Library library,                              \
 
357
                            FT_ServiceDescRec** output_class)                \
 
358
  {                                                                          \
 
359
    FT_ServiceDescRec*  clazz;                                               \
 
360
    FT_Error          error;                                                 \
 
361
    FT_Memory memory = library->memory;                                      \
 
362
                                                                             \
 
363
    if ( FT_ALLOC( clazz, sizeof(*clazz)*5 ) )                               \
 
364
      return error;                                                          \
 
365
    clazz[0].serv_id = serv_id_1;                                            \
 
366
    clazz[0].serv_data = serv_data_1;                                        \
 
367
    clazz[1].serv_id = serv_id_2;                                            \
 
368
    clazz[1].serv_data = serv_data_2;                                        \
 
369
    clazz[2].serv_id = serv_id_3;                                            \
 
370
    clazz[2].serv_data = serv_data_3;                                        \
 
371
    clazz[3].serv_id = serv_id_4;                                            \
 
372
    clazz[3].serv_data = serv_data_4;                                        \
 
373
    clazz[4].serv_id = NULL;                                                 \
 
374
    clazz[4].serv_data = NULL;                                               \
 
375
    *output_class = clazz;                                                   \
 
376
    return FT_Err_Ok;                                                        \
 
377
  } 
 
378
 
 
379
#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
 
380
        serv_id_2, serv_data_2, serv_id_3, serv_data_3, serv_id_4,           \
 
381
        serv_data_4, serv_id_5, serv_data_5)                                 \
 
382
  void                                                                       \
 
383
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
384
                             FT_ServiceDescRec* clazz )                      \
 
385
  {                                                                          \
 
386
    FT_Memory memory = library->memory;                                      \
 
387
    if ( clazz )                                                             \
 
388
      FT_FREE( clazz );                                                      \
 
389
  }                                                                          \
 
390
                                                                             \
 
391
  FT_Error                                                                   \
 
392
  FT_Create_Class_##class_( FT_Library library,                              \
 
393
                            FT_ServiceDescRec** output_class)                \
 
394
  {                                                                          \
 
395
    FT_ServiceDescRec*  clazz;                                               \
 
396
    FT_Error          error;                                                 \
 
397
    FT_Memory memory = library->memory;                                      \
 
398
                                                                             \
 
399
    if ( FT_ALLOC( clazz, sizeof(*clazz)*6 ) )                               \
 
400
      return error;                                                          \
 
401
    clazz[0].serv_id = serv_id_1;                                            \
 
402
    clazz[0].serv_data = serv_data_1;                                        \
 
403
    clazz[1].serv_id = serv_id_2;                                            \
 
404
    clazz[1].serv_data = serv_data_2;                                        \
 
405
    clazz[2].serv_id = serv_id_3;                                            \
 
406
    clazz[2].serv_data = serv_data_3;                                        \
 
407
    clazz[3].serv_id = serv_id_4;                                            \
 
408
    clazz[3].serv_data = serv_data_4;                                        \
 
409
    clazz[4].serv_id = serv_id_5;                                            \
 
410
    clazz[4].serv_data = serv_data_5;                                        \
 
411
    clazz[5].serv_id = NULL;                                                 \
 
412
    clazz[5].serv_data = NULL;                                               \
 
413
    *output_class = clazz;                                                   \
 
414
    return FT_Err_Ok;                                                        \
 
415
  } 
 
416
 
 
417
#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
 
418
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
419
        serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
 
420
        serv_id_6, serv_data_6)                                              \
 
421
  void                                                                       \
 
422
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
423
                             FT_ServiceDescRec* clazz )                      \
 
424
  {                                                                          \
 
425
    FT_Memory memory = library->memory;                                      \
 
426
    if ( clazz )                                                             \
 
427
      FT_FREE( clazz );                                                      \
 
428
  }                                                                          \
 
429
                                                                             \
 
430
  FT_Error                                                                   \
 
431
  FT_Create_Class_##class_( FT_Library library,                              \
 
432
                            FT_ServiceDescRec** output_class)                \
 
433
  {                                                                          \
 
434
    FT_ServiceDescRec*  clazz;                                               \
 
435
    FT_Error          error;                                                 \
 
436
    FT_Memory memory = library->memory;                                      \
 
437
                                                                             \
 
438
    if ( FT_ALLOC( clazz, sizeof(*clazz)*7 ) )                               \
 
439
      return error;                                                          \
 
440
    clazz[0].serv_id = serv_id_1;                                            \
 
441
    clazz[0].serv_data = serv_data_1;                                        \
 
442
    clazz[1].serv_id = serv_id_2;                                            \
 
443
    clazz[1].serv_data = serv_data_2;                                        \
 
444
    clazz[2].serv_id = serv_id_3;                                            \
 
445
    clazz[2].serv_data = serv_data_3;                                        \
 
446
    clazz[3].serv_id = serv_id_4;                                            \
 
447
    clazz[3].serv_data = serv_data_4;                                        \
 
448
    clazz[4].serv_id = serv_id_5;                                            \
 
449
    clazz[4].serv_data = serv_data_5;                                        \
 
450
    clazz[5].serv_id = serv_id_6;                                            \
 
451
    clazz[5].serv_data = serv_data_6;                                        \
 
452
    clazz[6].serv_id = NULL;                                                 \
 
453
    clazz[6].serv_data = NULL;                                               \
 
454
    *output_class = clazz;                                                   \
 
455
    return FT_Err_Ok;                                                        \
 
456
  } 
 
457
#endif /* FT_CONFIG_OPTION_PIC */ 
 
458
 
 
459
  /*
 
460
   *  Parse a list of FT_ServiceDescRec descriptors and look for
 
461
   *  a specific service by ID.  Note that the last element in the
 
462
   *  array must be { NULL, NULL }, and that the function should
 
463
   *  return NULL if the service isn't available.
 
464
   *
 
465
   *  This function can be used by modules to implement their
 
466
   *  `get_service' method.
 
467
   */
 
468
  FT_BASE( FT_Pointer )
 
469
  ft_service_list_lookup( FT_ServiceDesc  service_descriptors,
 
470
                          const char*     service_id );
 
471
 
 
472
 
 
473
  /*************************************************************************/
 
474
  /*************************************************************************/
 
475
  /*****                                                               *****/
 
476
  /*****             S E R V I C E S   C A C H E                       *****/
 
477
  /*****                                                               *****/
 
478
  /*************************************************************************/
 
479
  /*************************************************************************/
 
480
 
 
481
  /*
 
482
   *  This structure is used to store a cache for several frequently used
 
483
   *  services.  It is the type of `face->internal->services'.  You
 
484
   *  should only use FT_FACE_LOOKUP_SERVICE to access it.
 
485
   *
 
486
   *  All fields should have the type FT_Pointer to relax compilation
 
487
   *  dependencies.  We assume the developer isn't completely stupid.
 
488
   *
 
489
   *  Each field must be named `service_XXXX' where `XXX' corresponds to
 
490
   *  the correct FT_SERVICE_ID_XXXX macro.  See the definition of
 
491
   *  FT_FACE_LOOKUP_SERVICE below how this is implemented.
 
492
   *
 
493
   */
 
494
  typedef struct  FT_ServiceCacheRec_
 
495
  {
 
496
    FT_Pointer  service_POSTSCRIPT_FONT_NAME;
 
497
    FT_Pointer  service_MULTI_MASTERS;
 
498
    FT_Pointer  service_GLYPH_DICT;
 
499
    FT_Pointer  service_PFR_METRICS;
 
500
    FT_Pointer  service_WINFNT;
 
501
 
 
502
  } FT_ServiceCacheRec, *FT_ServiceCache;
 
503
 
 
504
 
 
505
  /*
 
506
   *  A magic number used within the services cache.
 
507
   */
 
508
#define FT_SERVICE_UNAVAILABLE  ((FT_Pointer)-2)  /* magic number */
 
509
 
 
510
 
 
511
  /*
 
512
   * @macro:
 
513
   *   FT_FACE_LOOKUP_SERVICE
 
514
   *
 
515
   * @description:
 
516
   *   This macro is used to lookup a service from a face's driver module
 
517
   *   using its cache.
 
518
   *
 
519
   * @input:
 
520
   *   face::
 
521
   *     The source face handle containing the cache.
 
522
   *
 
523
   *   field ::
 
524
   *     The field name in the cache.
 
525
   *
 
526
   *   id ::
 
527
   *     The service ID.
 
528
   *
 
529
   * @output:
 
530
   *   ptr ::
 
531
   *     A variable receiving the service data.  NULL if not available.
 
532
   */
 
533
#ifdef __cplusplus
 
534
 
 
535
#define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
 
536
  FT_BEGIN_STMNT                                               \
 
537
    FT_Pointer   svc;                                          \
 
538
    FT_Pointer*  Pptr = (FT_Pointer*)&(ptr);                   \
 
539
                                                               \
 
540
                                                               \
 
541
    svc = FT_FACE( face )->internal->services. service_ ## id; \
 
542
    if ( svc == FT_SERVICE_UNAVAILABLE )                       \
 
543
      svc = NULL;                                              \
 
544
    else if ( svc == NULL )                                    \
 
545
    {                                                          \
 
546
      FT_FACE_FIND_SERVICE( face, svc, id );                   \
 
547
                                                               \
 
548
      FT_FACE( face )->internal->services. service_ ## id =    \
 
549
        (FT_Pointer)( svc != NULL ? svc                        \
 
550
                                  : FT_SERVICE_UNAVAILABLE );  \
 
551
    }                                                          \
 
552
    *Pptr = svc;                                               \
 
553
  FT_END_STMNT
 
554
 
 
555
#else /* !C++ */
 
556
 
 
557
#define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
 
558
  FT_BEGIN_STMNT                                               \
 
559
    FT_Pointer  svc;                                           \
 
560
                                                               \
 
561
                                                               \
 
562
    svc = FT_FACE( face )->internal->services. service_ ## id; \
 
563
    if ( svc == FT_SERVICE_UNAVAILABLE )                       \
 
564
      svc = NULL;                                              \
 
565
    else if ( svc == NULL )                                    \
 
566
    {                                                          \
 
567
      FT_FACE_FIND_SERVICE( face, svc, id );                   \
 
568
                                                               \
 
569
      FT_FACE( face )->internal->services. service_ ## id =    \
 
570
        (FT_Pointer)( svc != NULL ? svc                        \
 
571
                                  : FT_SERVICE_UNAVAILABLE );  \
 
572
    }                                                          \
 
573
    ptr = svc;                                                 \
 
574
  FT_END_STMNT
 
575
 
 
576
#endif /* !C++ */
 
577
 
 
578
  /*
 
579
   *  A macro used to define new service structure types.
 
580
   */
 
581
 
 
582
#define FT_DEFINE_SERVICE( name )            \
 
583
  typedef struct FT_Service_ ## name ## Rec_ \
 
584
    FT_Service_ ## name ## Rec ;             \
 
585
  typedef struct FT_Service_ ## name ## Rec_ \
 
586
    const * FT_Service_ ## name ;            \
 
587
  struct FT_Service_ ## name ## Rec_
 
588
 
 
589
  /* */
 
590
 
 
591
  /*
 
592
   *  The header files containing the services.
 
593
   */
 
594
 
 
595
#define FT_SERVICE_BDF_H                <freetype/internal/services/svbdf.h>
 
596
#define FT_SERVICE_CID_H                <freetype/internal/services/svcid.h>
 
597
#define FT_SERVICE_GLYPH_DICT_H         <freetype/internal/services/svgldict.h>
 
598
#define FT_SERVICE_GX_VALIDATE_H        <freetype/internal/services/svgxval.h>
 
599
#define FT_SERVICE_KERNING_H            <freetype/internal/services/svkern.h>
 
600
#define FT_SERVICE_MULTIPLE_MASTERS_H   <freetype/internal/services/svmm.h>
 
601
#define FT_SERVICE_OPENTYPE_VALIDATE_H  <freetype/internal/services/svotval.h>
 
602
#define FT_SERVICE_PFR_H                <freetype/internal/services/svpfr.h>
 
603
#define FT_SERVICE_POSTSCRIPT_CMAPS_H   <freetype/internal/services/svpscmap.h>
 
604
#define FT_SERVICE_POSTSCRIPT_INFO_H    <freetype/internal/services/svpsinfo.h>
 
605
#define FT_SERVICE_POSTSCRIPT_NAME_H    <freetype/internal/services/svpostnm.h>
 
606
#define FT_SERVICE_SFNT_H               <freetype/internal/services/svsfnt.h>
 
607
#define FT_SERVICE_TRUETYPE_ENGINE_H    <freetype/internal/services/svtteng.h>
 
608
#define FT_SERVICE_TT_CMAP_H            <freetype/internal/services/svttcmap.h>
 
609
#define FT_SERVICE_WINFNT_H             <freetype/internal/services/svwinfnt.h>
 
610
#define FT_SERVICE_XFREE86_NAME_H       <freetype/internal/services/svxf86nm.h>
 
611
#define FT_SERVICE_TRUETYPE_GLYF_H      <freetype/internal/services/svttglyf.h>
 
612
 
 
613
 /* */
 
614
 
 
615
FT_END_HEADER
 
616
 
 
617
#endif /* __FTSERV_H__ */
 
618
 
 
619
 
 
620
/* END */