← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/freetype/include/freetype/internal/pshints.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/freetype/include/freetype/internal/pshints.h
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  pshints.h                                                              */
 
4
/*                                                                         */
 
5
/*    Interface to Postscript-specific (Type 1 and Type 2) hints           */
 
6
/*    recorders (specification only).  These are used to support native    */
 
7
/*    T1/T2 hints in the "type1", "cid" and "cff" font drivers.            */
 
8
/*                                                                         */
 
9
/*  Copyright 2001, 2002, 2003 by                                          */
 
10
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 
11
/*                                                                         */
 
12
/*  This file is part of the FreeType project, and may only be used,       */
 
13
/*  modified, and distributed under the terms of the FreeType project      */
 
14
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 
15
/*  this file you indicate that you have read the license and              */
 
16
/*  understand and accept it fully.                                        */
 
17
/*                                                                         */
 
18
/***************************************************************************/
 
19
 
 
20
 
 
21
#ifndef __PSHINTS_H__
 
22
#define __PSHINTS_H__
 
23
 
 
24
 
 
25
#include <ft2build.h>
 
26
#include FT_FREETYPE_H
 
27
#include FT_TYPE1_TABLES_H
 
28
 
 
29
 
 
30
FT_BEGIN_HEADER
 
31
 
 
32
 
 
33
  /*************************************************************************/
 
34
  /*************************************************************************/
 
35
  /*****                                                               *****/
 
36
  /*****               INTERNAL REPRESENTATION OF GLOBALS              *****/
 
37
  /*****                                                               *****/
 
38
  /*************************************************************************/
 
39
  /*************************************************************************/
 
40
 
 
41
  typedef struct PSH_GlobalsRec_*  PSH_Globals;
 
42
 
 
43
  typedef FT_Error
 
44
  (*PSH_Globals_NewFunc)( FT_Memory     memory,
 
45
                          T1_Private*   private_dict,
 
46
                          PSH_Globals*  aglobals );
 
47
 
 
48
  typedef FT_Error
 
49
  (*PSH_Globals_SetScaleFunc)( PSH_Globals  globals,
 
50
                               FT_Fixed     x_scale,
 
51
                               FT_Fixed     y_scale,
 
52
                               FT_Fixed     x_delta,
 
53
                               FT_Fixed     y_delta );
 
54
 
 
55
  typedef void
 
56
  (*PSH_Globals_DestroyFunc)( PSH_Globals  globals );
 
57
 
 
58
 
 
59
  typedef struct  PSH_Globals_FuncsRec_
 
60
  {
 
61
    PSH_Globals_NewFunc       create;
 
62
    PSH_Globals_SetScaleFunc  set_scale;
 
63
    PSH_Globals_DestroyFunc   destroy;
 
64
 
 
65
  } PSH_Globals_FuncsRec, *PSH_Globals_Funcs;
 
66
 
 
67
 
 
68
  /*************************************************************************/
 
69
  /*************************************************************************/
 
70
  /*****                                                               *****/
 
71
  /*****                  PUBLIC TYPE 1 HINTS RECORDER                 *****/
 
72
  /*****                                                               *****/
 
73
  /*************************************************************************/
 
74
  /*************************************************************************/
 
75
 
 
76
  /*************************************************************************/
 
77
  /*                                                                       */
 
78
  /* @type:                                                                */
 
79
  /*    T1_Hints                                                           */
 
80
  /*                                                                       */
 
81
  /* @description:                                                         */
 
82
  /*    This is a handle to an opaque structure used to record glyph hints */
 
83
  /*    from a Type 1 character glyph character string.                    */
 
84
  /*                                                                       */
 
85
  /*    The methods used to operate on this object are defined by the      */
 
86
  /*    @T1_Hints_FuncsRec structure.  Recording glyph hints is normally   */
 
87
  /*    achieved through the following scheme:                             */
 
88
  /*                                                                       */
 
89
  /*    - Open a new hint recording session by calling the "open" method.  */
 
90
  /*      This will rewind the recorder and prepare it for new input.      */
 
91
  /*                                                                       */
 
92
  /*    - For each hint found in the glyph charstring, call the            */
 
93
  /*      corresponding method ("stem", "stem3", or "reset").  Note that   */
 
94
  /*      these functions do not return an error code.                     */
 
95
  /*                                                                       */
 
96
  /*    - Close the recording session by calling the "close" method.  It   */
 
97
  /*      will return an error code if the hints were invalid or something */
 
98
  /*      strange happened (e.g. memory shortage).                         */
 
99
  /*                                                                       */
 
100
  /*    The hints accumulated in the object can later be used by the       */
 
101
  /*    PostScript hinter.                                                 */
 
102
  /*                                                                       */
 
103
  typedef struct T1_HintsRec_*  T1_Hints;
 
104
 
 
105
 
 
106
  /*************************************************************************/
 
107
  /*                                                                       */
 
108
  /* @type:                                                                */
 
109
  /*    T1_Hints_Funcs                                                     */
 
110
  /*                                                                       */
 
111
  /* @description:                                                         */
 
112
  /*    A pointer to the @T1_Hints_FuncsRec structure that defines the     */
 
113
  /*    API of a given @T1_Hints object.                                   */
 
114
  /*                                                                       */
 
115
  typedef const struct T1_Hints_FuncsRec_*  T1_Hints_Funcs;
 
116
 
 
117
 
 
118
  /*************************************************************************/
 
119
  /*                                                                       */
 
120
  /* @functype:                                                            */
 
121
  /*    T1_Hints_OpenFunc                                                  */
 
122
  /*                                                                       */
 
123
  /* @description:                                                         */
 
124
  /*    A method of the @T1_Hints class used to prepare it for a new       */
 
125
  /*    Type 1 hints recording session.                                    */
 
126
  /*                                                                       */
 
127
  /* @input:                                                               */
 
128
  /*    hints :: A handle to the Type 1 hints recorder.                    */
 
129
  /*                                                                       */
 
130
  /* @note:                                                                */
 
131
  /*    You should always call the @T1_Hints_CloseFunc method in order to  */
 
132
  /*    close an opened recording session.                                 */
 
133
  /*                                                                       */
 
134
  typedef void
 
135
  (*T1_Hints_OpenFunc)( T1_Hints  hints );
 
136
 
 
137
 
 
138
  /*************************************************************************/
 
139
  /*                                                                       */
 
140
  /* @functype:                                                            */
 
141
  /*    T1_Hints_SetStemFunc                                               */
 
142
  /*                                                                       */
 
143
  /* @description:                                                         */
 
144
  /*    A method of the @T1_Hints class used to record a new horizontal or */
 
145
  /*    vertical stem.  This corresponds to the Type 1 "hstem" and "vstem" */
 
146
  /*    operators.                                                         */
 
147
  /*                                                                       */
 
148
  /* @input:                                                               */
 
149
  /*    hints     :: A handle to the Type 1 hints recorder.                */
 
150
  /*                                                                       */
 
151
  /*    dimension :: 0 for horizontal stems (hstem), 1 for vertical ones   */
 
152
  /*                 (vstem).                                              */
 
153
  /*                                                                       */
 
154
  /*    coords    :: Array of 2 integers, used as (position,length) stem   */
 
155
  /*                 descriptor.                                           */
 
156
  /*                                                                       */
 
157
  /* @note:                                                                */
 
158
  /*    Use vertical coordinates (y) for horizontal stems (dim=0).  Use    */
 
159
  /*    horizontal coordinates (x) for vertical stems (dim=1).             */
 
160
  /*                                                                       */
 
161
  /*    "coords[0]" is the absolute stem position (lowest coordinate);     */
 
162
  /*    "coords[1]" is the length.                                         */
 
163
  /*                                                                       */
 
164
  /*    The length can be negative, in which case it must be either -20 or */
 
165
  /*    -21.  It will be interpreted as a "ghost" stem, according to       */
 
166
  /*    Type 1 specification.                                              */
 
167
  /*                                                                       */
 
168
  /*    If the length is -21 (corresponding to a bottom ghost stem), then  */
 
169
  /*    the real stem position is "coords[0]+coords[1]".                   */
 
170
  /*                                                                       */
 
171
  typedef void
 
172
  (*T1_Hints_SetStemFunc)( T1_Hints  hints,
 
173
                           FT_UInt   dimension,
 
174
                           FT_Long*  coords );
 
175
 
 
176
 
 
177
  /*************************************************************************/
 
178
  /*                                                                       */
 
179
  /* @functype:                                                            */
 
180
  /*    T1_Hints_SetStem3Func                                              */
 
181
  /*                                                                       */
 
182
  /* @description:                                                         */
 
183
  /*    A method of the @T1_Hints class used to record three               */
 
184
  /*    counter-controlled horizontal or vertical stems at once.           */
 
185
  /*                                                                       */
 
186
  /* @input:                                                               */
 
187
  /*    hints     :: A handle to the Type 1 hints recorder.                */
 
188
  /*                                                                       */
 
189
  /*    dimension :: 0 for horizontal stems, 1 for vertical ones.          */
 
190
  /*                                                                       */
 
191
  /*    coords    :: An array of 6 integers, holding 3 (position,length)   */
 
192
  /*                 pairs for the counter-controlled stems.               */
 
193
  /*                                                                       */
 
194
  /* @note:                                                                */
 
195
  /*    Use vertical coordinates (y) for horizontal stems (dim=0).  Use    */
 
196
  /*    horizontal coordinates (x) for vertical stems (dim=1).             */
 
197
  /*                                                                       */
 
198
  /*    The lengths cannot be negative (ghost stems are never              */
 
199
  /*    counter-controlled).                                               */
 
200
  /*                                                                       */
 
201
  typedef void
 
202
  (*T1_Hints_SetStem3Func)( T1_Hints  hints,
 
203
                            FT_UInt   dimension,
 
204
                            FT_Long*  coords );
 
205
 
 
206
 
 
207
  /*************************************************************************/
 
208
  /*                                                                       */
 
209
  /* @functype:                                                            */
 
210
  /*    T1_Hints_ResetFunc                                                 */
 
211
  /*                                                                       */
 
212
  /* @description:                                                         */
 
213
  /*    A method of the @T1_Hints class used to reset the stems hints in a */
 
214
  /*    recording session.                                                 */
 
215
  /*                                                                       */
 
216
  /* @input:                                                               */
 
217
  /*    hints     :: A handle to the Type 1 hints recorder.                */
 
218
  /*                                                                       */
 
219
  /*    end_point :: The index of the last point in the input glyph in     */
 
220
  /*                 which the previously defined hints apply.             */
 
221
  /*                                                                       */
 
222
  typedef void
 
223
  (*T1_Hints_ResetFunc)( T1_Hints  hints,
 
224
                         FT_UInt   end_point );
 
225
 
 
226
 
 
227
  /*************************************************************************/
 
228
  /*                                                                       */
 
229
  /* @functype:                                                            */
 
230
  /*    T1_Hints_CloseFunc                                                 */
 
231
  /*                                                                       */
 
232
  /* @description:                                                         */
 
233
  /*    A method of the @T1_Hints class used to close a hint recording     */
 
234
  /*    session.                                                           */
 
235
  /*                                                                       */
 
236
  /* @input:                                                               */
 
237
  /*    hints     :: A handle to the Type 1 hints recorder.                */
 
238
  /*                                                                       */
 
239
  /*    end_point :: The index of the last point in the input glyph.       */
 
240
  /*                                                                       */
 
241
  /* @return:                                                              */
 
242
  /*    FreeType error code.  0 means success.                             */
 
243
  /*                                                                       */
 
244
  /* @note:                                                                */
 
245
  /*    The error code will be set to indicate that an error occured       */
 
246
  /*    during the recording session.                                      */
 
247
  /*                                                                       */
 
248
  typedef FT_Error
 
249
  (*T1_Hints_CloseFunc)( T1_Hints  hints,
 
250
                         FT_UInt   end_point );
 
251
 
 
252
 
 
253
  /*************************************************************************/
 
254
  /*                                                                       */
 
255
  /* @functype:                                                            */
 
256
  /*    T1_Hints_ApplyFunc                                                 */
 
257
  /*                                                                       */
 
258
  /* @description:                                                         */
 
259
  /*    A method of the @T1_Hints class used to apply hints to the         */
 
260
  /*    corresponding glyph outline.  Must be called once all hints have   */
 
261
  /*    been recorded.                                                     */
 
262
  /*                                                                       */
 
263
  /* @input:                                                               */
 
264
  /*   hints     :: A handle to the Type 1 hints recorder.                 */
 
265
  /*                                                                       */
 
266
  /*   outline   :: A pointer to the target outline descriptor.            */
 
267
  /*                                                                       */
 
268
  /*   globals   :: The hinter globals for this font.                      */
 
269
  /*                                                                       */
 
270
  /*   hint_mode :: Hinting information.                                   */
 
271
  /*                                                                       */
 
272
  /* @return:                                                              */
 
273
  /*   FreeType error code.  0 means success.                              */
 
274
  /*                                                                       */
 
275
  /* @note:                                                                */
 
276
  /*    On input, all points within the outline are in font coordinates.   */
 
277
  /*    On output, they are in 1/64th of pixels.                           */
 
278
  /*                                                                       */
 
279
  /*    The scaling transformation is taken from the "globals" object      */
 
280
  /*    which must correspond to the same font as the glyph.               */
 
281
  /*                                                                       */
 
282
  typedef FT_Error
 
283
  (*T1_Hints_ApplyFunc)( T1_Hints        hints,
 
284
                         FT_Outline*     outline,
 
285
                         PSH_Globals     globals,
 
286
                         FT_Render_Mode  hint_mode );
 
287
 
 
288
 
 
289
  /*************************************************************************/
 
290
  /*                                                                       */
 
291
  /* @struct:                                                              */
 
292
  /*    T1_Hints_FuncsRec                                                  */
 
293
  /*                                                                       */
 
294
  /* @description:                                                         */
 
295
  /*    The structure used to provide the API to @T1_Hints objects.        */
 
296
  /*                                                                       */
 
297
  /* @fields:                                                              */
 
298
  /*    hints :: A handle to the T1 Hints recorder.                        */
 
299
  /*                                                                       */
 
300
  /*    open  :: The function to open a recording session.                 */
 
301
  /*                                                                       */
 
302
  /*    close :: The function to close a recording session.                */
 
303
  /*                                                                       */
 
304
  /*    stem  :: The function to set a simple stem.                        */
 
305
  /*                                                                       */
 
306
  /*    stem3 :: The function to set counter-controlled stems.             */
 
307
  /*                                                                       */
 
308
  /*    reset :: The function to reset stem hints.                         */
 
309
  /*                                                                       */
 
310
  /*    apply :: The function to apply the hints to the corresponding      */
 
311
  /*             glyph outline.                                            */
 
312
  /*                                                                       */
 
313
  typedef struct  T1_Hints_FuncsRec_
 
314
  {
 
315
    T1_Hints               hints;
 
316
    T1_Hints_OpenFunc      open;
 
317
    T1_Hints_CloseFunc     close;
 
318
    T1_Hints_SetStemFunc   stem;
 
319
    T1_Hints_SetStem3Func  stem3;
 
320
    T1_Hints_ResetFunc     reset;
 
321
    T1_Hints_ApplyFunc     apply;
 
322
 
 
323
  } T1_Hints_FuncsRec;
 
324
 
 
325
 
 
326
  /*************************************************************************/
 
327
  /*************************************************************************/
 
328
  /*****                                                               *****/
 
329
  /*****                  PUBLIC TYPE 2 HINTS RECORDER                 *****/
 
330
  /*****                                                               *****/
 
331
  /*************************************************************************/
 
332
  /*************************************************************************/
 
333
 
 
334
  /*************************************************************************/
 
335
  /*                                                                       */
 
336
  /* @type:                                                                */
 
337
  /*    T2_Hints                                                           */
 
338
  /*                                                                       */
 
339
  /* @description:                                                         */
 
340
  /*    This is a handle to an opaque structure used to record glyph hints */
 
341
  /*    from a Type 2 character glyph character string.                    */
 
342
  /*                                                                       */
 
343
  /*    The methods used to operate on this object are defined by the      */
 
344
  /*    @T2_Hints_FuncsRec structure.  Recording glyph hints is normally   */
 
345
  /*    achieved through the following scheme:                             */
 
346
  /*                                                                       */
 
347
  /*    - Open a new hint recording session by calling the "open" method.  */
 
348
  /*      This will rewind the recorder and prepare it for new input.      */
 
349
  /*                                                                       */
 
350
  /*    - For each hint found in the glyph charstring, call the            */
 
351
  /*      corresponding method ("stems", "hintmask", "counters").  Note    */
 
352
  /*      that these functions do not return an error code.                */
 
353
  /*                                                                       */
 
354
  /*    - Close the recording session by calling the "close" method.  It   */
 
355
  /*      will return an error code if the hints were invalid or something */
 
356
  /*      strange happened (e.g. memory shortage).                         */
 
357
  /*                                                                       */
 
358
  /*    The hints accumulated in the object can later be used by the       */
 
359
  /*    Postscript hinter.                                                 */
 
360
  /*                                                                       */
 
361
  typedef struct T2_HintsRec_*  T2_Hints;
 
362
 
 
363
 
 
364
  /*************************************************************************/
 
365
  /*                                                                       */
 
366
  /* @type:                                                                */
 
367
  /*    T2_Hints_Funcs                                                     */
 
368
  /*                                                                       */
 
369
  /* @description:                                                         */
 
370
  /*    A pointer to the @T2_Hints_FuncsRec structure that defines the API */
 
371
  /*    of a given @T2_Hints object.                                       */
 
372
  /*                                                                       */
 
373
  typedef const struct T2_Hints_FuncsRec_*  T2_Hints_Funcs;
 
374
 
 
375
 
 
376
  /*************************************************************************/
 
377
  /*                                                                       */
 
378
  /* @functype:                                                            */
 
379
  /*    T2_Hints_OpenFunc                                                  */
 
380
  /*                                                                       */
 
381
  /* @description:                                                         */
 
382
  /*    A method of the @T2_Hints class used to prepare it for a new       */
 
383
  /*    Type 2 hints recording session.                                    */
 
384
  /*                                                                       */
 
385
  /* @input:                                                               */
 
386
  /*    hints :: A handle to the Type 2 hints recorder.                    */
 
387
  /*                                                                       */
 
388
  /* @note:                                                                */
 
389
  /*    You should always call the @T2_Hints_CloseFunc method in order to  */
 
390
  /*    close an opened recording session.                                 */
 
391
  /*                                                                       */
 
392
  typedef void
 
393
  (*T2_Hints_OpenFunc)( T2_Hints  hints );
 
394
 
 
395
 
 
396
  /*************************************************************************/
 
397
  /*                                                                       */
 
398
  /* @functype:                                                            */
 
399
  /*    T2_Hints_StemsFunc                                                 */
 
400
  /*                                                                       */
 
401
  /* @description:                                                         */
 
402
  /*    A method of the @T2_Hints class used to set the table of stems in  */
 
403
  /*    either the vertical or horizontal dimension.  Equivalent to the    */
 
404
  /*    "hstem", "vstem", "hstemhm", and "vstemhm" Type 2 operators.       */
 
405
  /*                                                                       */
 
406
  /* @input:                                                               */
 
407
  /*    hints     :: A handle to the Type 2 hints recorder.                */
 
408
  /*                                                                       */
 
409
  /*    dimension :: 0 for horizontal stems (hstem), 1 for vertical ones   */
 
410
  /*                 (vstem).                                              */
 
411
  /*                                                                       */
 
412
  /*    count     :: The number of stems.                                  */
 
413
  /*                                                                       */
 
414
  /*    coords    :: An array of "count" (position,length) pairs.          */
 
415
  /*                                                                       */
 
416
  /* @note:                                                                */
 
417
  /*    Use vertical coordinates (y) for horizontal stems (dim=0).  Use    */
 
418
  /*    horizontal coordinates (x) for vertical stems (dim=1).             */
 
419
  /*                                                                       */
 
420
  /*    There are "2*count" elements in the "coords" aray.  Each even      */
 
421
  /*    element is an absolute position in font units, each odd element is */
 
422
  /*    a length in font units.                                            */
 
423
  /*                                                                       */
 
424
  /*    A length can be negative, in which case it must be either -20 or   */
 
425
  /*    -21.  It will be interpreted as a "ghost" stem, according to the   */
 
426
  /*    Type 1 specification.                                              */
 
427
  /*                                                                       */
 
428
  typedef void
 
429
  (*T2_Hints_StemsFunc)( T2_Hints   hints,
 
430
                         FT_UInt    dimension,
 
431
                         FT_UInt    count,
 
432
                         FT_Fixed*  coordinates );
 
433
 
 
434
 
 
435
  /*************************************************************************/
 
436
  /*                                                                       */
 
437
  /* @functype:                                                            */
 
438
  /*    T2_Hints_MaskFunc                                                  */
 
439
  /*                                                                       */
 
440
  /* @description:                                                         */
 
441
  /*    A method of the @T2_Hints class used to set a given hintmask       */
 
442
  /*    (this corresponds to the "hintmask" Type 2 operator).              */
 
443
  /*                                                                       */
 
444
  /* @input:                                                               */
 
445
  /*    hints     :: A handle to the Type 2 hints recorder.                */
 
446
  /*                                                                       */
 
447
  /*    end_point :: The glyph index of the last point to which the        */
 
448
  /*                 previously defined/activated hints apply.             */
 
449
  /*                                                                       */
 
450
  /*    bit_count :: The number of bits in the hint mask.                  */
 
451
  /*                                                                       */
 
452
  /*    bytes     :: An array of bytes modelling the hint mask.            */
 
453
  /*                                                                       */
 
454
  /* @note:                                                                */
 
455
  /*    If the hintmask starts the charstring (before any glyph point      */
 
456
  /*    definition), the value of "end_point" should be 0.                 */
 
457
  /*                                                                       */
 
458
  /*    "bit_count" is the number of meaningful bits in the "bytes" array; */
 
459
  /*    it must be equal to the total number of hints defined so far       */
 
460
  /*    (i.e. horizontal+verticals).                                       */
 
461
  /*                                                                       */
 
462
  /*    The "bytes" array can come directly from the Type 2 charstring and */
 
463
  /*    respects the same format.                                          */
 
464
  /*                                                                       */
 
465
  typedef void
 
466
  (*T2_Hints_MaskFunc)( T2_Hints        hints,
 
467
                        FT_UInt         end_point,
 
468
                        FT_UInt         bit_count,
 
469
                        const FT_Byte*  bytes );
 
470
 
 
471
 
 
472
  /*************************************************************************/
 
473
  /*                                                                       */
 
474
  /* @functype:                                                            */
 
475
  /*    T2_Hints_CounterFunc                                               */
 
476
  /*                                                                       */
 
477
  /* @description:                                                         */
 
478
  /*    A method of the @T2_Hints class used to set a given counter mask   */
 
479
  /*    (this corresponds to the "hintmask" Type 2 operator).              */
 
480
  /*                                                                       */
 
481
  /* @input:                                                               */
 
482
  /*    hints     :: A handle to the Type 2 hints recorder.                */
 
483
  /*                                                                       */
 
484
  /*    end_point :: A glyph index of the last point to which the          */
 
485
  /*                 previously defined/active hints apply.                */
 
486
  /*                                                                       */
 
487
  /*    bit_count :: The number of bits in the hint mask.                  */
 
488
  /*                                                                       */
 
489
  /*    bytes     :: An array of bytes modelling the hint mask.            */
 
490
  /*                                                                       */
 
491
  /* @note:                                                                */
 
492
  /*    If the hintmask starts the charstring (before any glyph point      */
 
493
  /*    definition), the value of "end_point" should be 0.                 */
 
494
  /*                                                                       */
 
495
  /*    "bit_count" is the number of meaningful bits in the "bytes" array; */
 
496
  /*    it must be equal to the total number of hints defined so far       */
 
497
  /*    (i.e. horizontal+verticals).                                       */
 
498
  /*                                                                       */
 
499
  /*    The "bytes" array can come directly from the Type 2 charstring and */
 
500
  /*    respects the same format.                                          */
 
501
  /*                                                                       */
 
502
  typedef void
 
503
  (*T2_Hints_CounterFunc)( T2_Hints        hints,
 
504
                           FT_UInt         bit_count,
 
505
                           const FT_Byte*  bytes );
 
506
 
 
507
 
 
508
  /*************************************************************************/
 
509
  /*                                                                       */
 
510
  /* @functype:                                                            */
 
511
  /*    T2_Hints_CloseFunc                                                 */
 
512
  /*                                                                       */
 
513
  /* @description:                                                         */
 
514
  /*    A method of the @T2_Hints class used to close a hint recording     */
 
515
  /*    session.                                                           */
 
516
  /*                                                                       */
 
517
  /* @input:                                                               */
 
518
  /*    hints     :: A handle to the Type 2 hints recorder.                */
 
519
  /*                                                                       */
 
520
  /*    end_point :: The index of the last point in the input glyph.       */
 
521
  /*                                                                       */
 
522
  /* @return:                                                              */
 
523
  /*    FreeType error code.  0 means success.                             */
 
524
  /*                                                                       */
 
525
  /* @note:                                                                */
 
526
  /*    The error code will be set to indicate that an error occured       */
 
527
  /*    during the recording session.                                      */
 
528
  /*                                                                       */
 
529
  typedef FT_Error
 
530
  (*T2_Hints_CloseFunc)( T2_Hints  hints,
 
531
                         FT_UInt   end_point );
 
532
 
 
533
 
 
534
  /*************************************************************************/
 
535
  /*                                                                       */
 
536
  /* @functype:                                                            */
 
537
  /*    T2_Hints_ApplyFunc                                                 */
 
538
  /*                                                                       */
 
539
  /* @description:                                                         */
 
540
  /*    A method of the @T2_Hints class used to apply hints to the         */
 
541
  /*    corresponding glyph outline.  Must be called after the "close"     */
 
542
  /*    method.                                                            */
 
543
  /*                                                                       */
 
544
  /* @input:                                                               */
 
545
  /*    hints     :: A handle to the Type 2 hints recorder.                */
 
546
  /*                                                                       */
 
547
  /*    outline   :: A pointer to the target outline descriptor.           */
 
548
  /*                                                                       */
 
549
  /*    globals   :: The hinter globals for this font.                     */
 
550
  /*                                                                       */
 
551
  /*    hint_mode :: Hinting information.                                  */
 
552
  /*                                                                       */
 
553
  /* @return:                                                              */
 
554
  /*   FreeType error code.  0 means success.                              */
 
555
  /*                                                                       */
 
556
  /* @note:                                                                */
 
557
  /*    On input, all points within the outline are in font coordinates.   */
 
558
  /*    On output, they are in 1/64th of pixels.                           */
 
559
  /*                                                                       */
 
560
  /*    The scaling transformation is taken from the "globals" object      */
 
561
  /*    which must correspond to the same font than the glyph.             */
 
562
  /*                                                                       */
 
563
  typedef FT_Error
 
564
  (*T2_Hints_ApplyFunc)( T2_Hints        hints,
 
565
                         FT_Outline*     outline,
 
566
                         PSH_Globals     globals,
 
567
                         FT_Render_Mode  hint_mode );
 
568
 
 
569
 
 
570
  /*************************************************************************/
 
571
  /*                                                                       */
 
572
  /* @struct:                                                              */
 
573
  /*    T2_Hints_FuncsRec                                                  */
 
574
  /*                                                                       */
 
575
  /* @description:                                                         */
 
576
  /*    The structure used to provide the API to @T2_Hints objects.        */
 
577
  /*                                                                       */
 
578
  /* @fields:                                                              */
 
579
  /*    hints    :: A handle to the T2 hints recorder object.              */
 
580
  /*                                                                       */
 
581
  /*    open     :: The function to open a recording session.              */
 
582
  /*                                                                       */
 
583
  /*    close    :: The function to close a recording session.             */
 
584
  /*                                                                       */
 
585
  /*    stems    :: The function to set the dimension's stems table.       */
 
586
  /*                                                                       */
 
587
  /*    hintmask :: The function to set hint masks.                        */
 
588
  /*                                                                       */
 
589
  /*    counter  :: The function to set counter masks.                     */
 
590
  /*                                                                       */
 
591
  /*    apply    :: The function to apply the hints on the corresponding   */
 
592
  /*                glyph outline.                                         */
 
593
  /*                                                                       */
 
594
  typedef struct  T2_Hints_FuncsRec_
 
595
  {
 
596
    T2_Hints              hints;
 
597
    T2_Hints_OpenFunc     open;
 
598
    T2_Hints_CloseFunc    close;
 
599
    T2_Hints_StemsFunc    stems;
 
600
    T2_Hints_MaskFunc     hintmask;
 
601
    T2_Hints_CounterFunc  counter;
 
602
    T2_Hints_ApplyFunc    apply;
 
603
 
 
604
  } T2_Hints_FuncsRec;
 
605
 
 
606
 
 
607
  /* */
 
608
 
 
609
 
 
610
  typedef struct  PSHinter_Interface_
 
611
  {
 
612
    PSH_Globals_Funcs  (*get_globals_funcs)( FT_Module  module );
 
613
    T1_Hints_Funcs     (*get_t1_funcs)     ( FT_Module  module );
 
614
    T2_Hints_Funcs     (*get_t2_funcs)     ( FT_Module  module );
 
615
 
 
616
  } PSHinter_Interface;
 
617
 
 
618
  typedef PSHinter_Interface*  PSHinter_Service;
 
619
 
 
620
 
 
621
FT_END_HEADER
 
622
 
 
623
#endif /* __PSHINTS_H__ */
 
624
 
 
625
 
 
626
/* END */