]> git.saurik.com Git - wxWidgets.git/blob - src/freetype/type1z/z1afm.c
Added missing files to listing
[wxWidgets.git] / src / freetype / type1z / z1afm.c
1 /***************************************************************************/
2 /* */
3 /* z1afm.c */
4 /* */
5 /* AFM support for Type 1 fonts (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 "z1afm.h"
22
23 #else
24
25 #include <type1z/z1afm.h>
26
27 #endif
28
29
30 #include <freetype/internal/ftstream.h>
31 #include <freetype/internal/t1types.h>
32
33 #include <stdlib.h> /* for qsort() */
34 #include <string.h> /* for strcmp() */
35 #include <ctype.h> /* for isalnum() */
36
37
38 /*************************************************************************/
39 /* */
40 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
41 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
42 /* messages during execution. */
43 /* */
44 #undef FT_COMPONENT
45 #define FT_COMPONENT trace_z1afm
46
47
48 LOCAL_FUNC
49 void Z1_Done_AFM( FT_Memory memory,
50 Z1_AFM* afm )
51 {
52 FREE( afm->kern_pairs );
53 afm->num_pairs = 0;
54 }
55
56
57 #undef IS_KERN_PAIR
58 #define IS_KERN_PAIR( p ) ( p[0] == 'K' && p[1] == 'P' )
59
60 #define IS_ALPHANUM( c ) ( isalnum( c ) || \
61 c == '_' || \
62 c == '.' )
63
64
65 /* read a glyph name and return the equivalent glyph index */
66 static
67 FT_UInt afm_atoindex( FT_Byte** start,
68 FT_Byte* limit,
69 T1_Font* type1 )
70 {
71 FT_Byte* p = *start;
72 FT_Int len;
73 FT_UInt result = 0;
74 char temp[64];
75
76
77 /* skip whitespace */
78 while ( ( *p == ' ' || *p == '\t' || *p == ':' || *p == ';' ) &&
79 p < limit )
80 p++;
81 *start = p;
82
83 /* now, read glyph name */
84 while ( IS_ALPHANUM( *p ) && p < limit )
85 p++;
86
87 len = p - *start;
88
89 if ( len > 0 && len < 64 )
90 {
91 FT_Int n;
92
93
94 /* copy glyph name to intermediate array */
95 MEM_Copy( temp, *start, len );
96 temp[len] = 0;
97
98 /* lookup glyph name in face array */
99 for ( n = 0; n < type1->num_glyphs; n++ )
100 {
101 char* gname = (char*)type1->glyph_names[n];
102
103
104 if ( gname && gname[0] == temp[0] && strcmp( gname, temp ) == 0 )
105 {
106 result = n;
107 break;
108 }
109 }
110 }
111 *start = p;
112 return result;
113 }
114
115
116 /* read an integer */
117 static
118 int afm_atoi( FT_Byte** start,
119 FT_Byte* limit )
120 {
121 FT_Byte* p = *start;
122 int sum = 0;
123 int sign = 1;
124
125
126 /* skip everything that is not a number */
127 while ( p < limit && !isdigit( *p ) )
128 {
129 sign = 1;
130 if ( *p == '-' )
131 sign = -1;
132
133 p++;
134 }
135
136 while ( p < limit && isdigit( *p ) )
137 {
138 sum = sum * 10 + ( *p - '0' );
139 p++;
140 }
141 *start = p;
142
143 return sum * sign;
144 }
145
146
147 #undef KERN_INDEX
148 #define KERN_INDEX( g1, g2 ) ( ( (FT_ULong)g1 << 16 ) | g2 )
149
150
151 /* compare two kerning pairs */
152 static
153 int compare_kern_pairs( const void* a,
154 const void* b )
155 {
156 Z1_Kern_Pair* pair1 = (Z1_Kern_Pair*)a;
157 Z1_Kern_Pair* pair2 = (Z1_Kern_Pair*)b;
158
159 FT_ULong index1 = KERN_INDEX( pair1->glyph1, pair1->glyph2 );
160 FT_ULong index2 = KERN_INDEX( pair2->glyph1, pair2->glyph2 );
161
162
163 return ( index1 - index2 );
164 }
165
166
167 /* parse an AFM file -- for now, only read the kerning pairs */
168 LOCAL_FUNC
169 FT_Error Z1_Read_AFM( FT_Face t1_face,
170 FT_Stream stream )
171 {
172 FT_Error error;
173 FT_Memory memory = stream->memory;
174 FT_Byte* start;
175 FT_Byte* limit;
176 FT_Byte* p;
177 FT_Int count = 0;
178 Z1_Kern_Pair* pair;
179 T1_Font* type1 = &((T1_Face)t1_face)->type1;
180 Z1_AFM* afm = 0;
181
182
183 if ( ACCESS_Frame( stream->size ) )
184 return error;
185
186 start = (FT_Byte*)stream->cursor;
187 limit = (FT_Byte*)stream->limit;
188 p = start;
189
190 /* we are now going to count the occurences of `KP' or `KPX' in */
191 /* the AFM file */
192 count = 0;
193 for ( p = start; p < limit - 3; p++ )
194 {
195 if ( IS_KERN_PAIR( p ) )
196 count++;
197 }
198
199 /* Actually, kerning pairs are simply optional! */
200 if ( count == 0 )
201 goto Exit;
202
203 /* allocate the pairs */
204 if ( ALLOC( afm, sizeof ( *afm ) ) ||
205 ALLOC_ARRAY( afm->kern_pairs, count, Z1_Kern_Pair ) )
206 goto Exit;
207
208 /* now, read each kern pair */
209 pair = afm->kern_pairs;
210 afm->num_pairs = count;
211
212 /* save in face object */
213 ((T1_Face)t1_face)->afm_data = afm;
214
215 for ( p = start; p < limit - 3; p++ )
216 {
217 if ( IS_KERN_PAIR( p ) )
218 {
219 FT_Byte* q;
220
221
222 /* skip keyword (KP or KPX) */
223 q = p + 2;
224 if ( *q == 'X' )
225 q++;
226
227 pair->glyph1 = afm_atoindex( &q, limit, type1 );
228 pair->glyph2 = afm_atoindex( &q, limit, type1 );
229 pair->kerning.x = afm_atoi( &q, limit );
230
231 pair->kerning.y = 0;
232 if ( p[2] != 'X' )
233 pair->kerning.y = afm_atoi( &q, limit );
234
235 pair++;
236 }
237 }
238
239 /* now, sort the kern pairs according to their glyph indices */
240 qsort( afm->kern_pairs, count, sizeof ( Z1_Kern_Pair ),
241 compare_kern_pairs );
242
243 Exit:
244 if ( error )
245 FREE( afm );
246
247 FORGET_Frame();
248
249 return error;
250 }
251
252
253 /* find the kerning for a given glyph pair */
254 LOCAL_FUNC
255 void Z1_Get_Kerning( Z1_AFM* afm,
256 FT_UInt glyph1,
257 FT_UInt glyph2,
258 FT_Vector* kerning )
259 {
260 Z1_Kern_Pair *min, *mid, *max;
261 FT_ULong index = KERN_INDEX( glyph1, glyph2 );
262
263
264 /* simple binary search */
265 min = afm->kern_pairs;
266 max = min + afm->num_pairs - 1;
267
268 while ( min <= max )
269 {
270 FT_ULong midi;
271
272
273 mid = min + ( max - min ) / 2;
274 midi = KERN_INDEX( mid->glyph1, mid->glyph2 );
275
276 if ( midi == index )
277 {
278 *kerning = mid->kerning;
279 return;
280 }
281
282 if ( midi < index )
283 min = mid + 1;
284 else
285 max = mid - 1;
286 }
287
288 kerning->x = 0;
289 kerning->y = 0;
290 }
291
292
293 /* END */