?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
xactengine3_7: Map IXACT3Wave interfaces.
[wine.git] / dlls / wineps.drv / type1.c
blobf31c6dd3beea366f312bdac6f2ae0aaa1d492b0e
1 /*
2 * PostScript driver Type1 font functions
3 *
4 * Copyright 2002 Huw D M Davies for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <string.h>
22 #include <stdlib.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <assert.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winternl.h"
31
32 #include "psdrv.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
36
37 struct tagTYPE1 {
38 DWORD glyph_sent_size;
39 BOOL *glyph_sent;
40 DWORD emsize;
41 };
42
43 #define GLYPH_SENT_INC 128
44
45 /* Type 1 font commands */
46 enum t1_cmds {
47 rlineto = 5,
48 rrcurveto = 8,
49 closepath = 9,
50 hsbw = 13,
51 endchar = 14,
52 rmoveto = 21
53 };
54
55
56 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
57 ( ( (DWORD)_x4 << 24 ) | \
58 ( (DWORD)_x3 << 16 ) | \
59 ( (DWORD)_x2 << 8 ) | \
60 (DWORD)_x1 )
61
62 #ifdef WORDS_BIGENDIAN
63 static inline WORD get_be_word(const void *p) { return *(const WORD*)p; }
64 static inline DWORD get_be_dword(const void *p) { return *(const DWORD*)p; }
65 #else
66 static inline WORD get_be_word(const void *p) { return RtlUshortByteSwap(*(const WORD*)p); }
67 static inline DWORD get_be_dword(const void *p) { return RtlUlongByteSwap(*(const DWORD*)p); }
68 #endif
69
70 TYPE1 *T1_download_header(PHYSDEV dev, char *ps_name, RECT *bbox, UINT emsize)
71 {
72 char *buf;
73 TYPE1 *t1;
74
75 static const char dict[] = /* name, emsquare, fontbbox */
76 "25 dict begin\n"
77 " /FontName /%s def\n"
78 " /Encoding 256 array 0 1 255{1 index exch /.notdef put} for def\n"
79 " /PaintType 0 def\n"
80 " /FontMatrix [1 %ld div 0 0 1 %ld div 0 0] def\n"
81 " /FontBBox [%ld %ld %ld %ld] def\n"
82 " /FontType 1 def\n"
83 " /Private 7 dict begin\n"
84 " /RD {string currentfile exch readhexstring pop} def\n"
85 " /ND {def} def\n"
86 " /NP {put} def\n"
87 " /MinFeature {16 16} def\n"
88 " /BlueValues [] def\n"
89 " /password 5839 def\n"
90 " /lenIV -1 def\n"
91 " currentdict end def\n"
92 " currentdict dup /Private get begin\n"
93 " /CharStrings 256 dict begin\n"
94 " /.notdef 4 RD 8b8b0d0e ND\n"
95 " currentdict end put\n"
96 " end\n"
97 "currentdict end dup /FontName get exch definefont pop\n";
98
99 t1 = HeapAlloc(GetProcessHeap(), 0, sizeof(*t1));
100 t1->emsize = emsize;
101
102 t1->glyph_sent_size = GLYPH_SENT_INC;
103 t1->glyph_sent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
104 t1->glyph_sent_size *
105 sizeof(*(t1->glyph_sent)));
106
107 buf = HeapAlloc(GetProcessHeap(), 0, sizeof(dict) + strlen(ps_name) +
108 100);
109
110 sprintf(buf, dict, ps_name, t1->emsize, t1->emsize,
111 bbox->left, bbox->bottom, bbox->right, bbox->top);
112
113 PSDRV_WriteSpool(dev, buf, strlen(buf));
114
115 HeapFree(GetProcessHeap(), 0, buf);
116 return t1;
117 }
118
119
120 typedef struct {
121 BYTE *str;
122 int len, max_len;
123 } STR;
124
125 static STR *str_init(int sz)
126 {
127 STR *str = HeapAlloc(GetProcessHeap(), 0, sizeof(*str));
128 str->max_len = sz;
129 str->str = HeapAlloc(GetProcessHeap(), 0, str->max_len);
130 str->len = 0;
131 return str;
132 }
133
134 static void str_free(STR *str)
135 {
136 HeapFree(GetProcessHeap(), 0, str->str);
137 HeapFree(GetProcessHeap(), 0, str);
138 }
139
140 static void str_add_byte(STR *str, BYTE b)
141 {
142 if(str->len == str->max_len) {
143 str->max_len *= 2;
144 str->str = HeapReAlloc(GetProcessHeap(), 0, str->str, str->max_len);
145 }
146 str->str[str->len++] = b;
147 }
148
149 static void str_add_num(STR *str, int num)
150 {
151 if(num <= 107 && num >= -107)
152 str_add_byte(str, num + 139);
153 else if(num >= 108 && num <= 1131) {
154 str_add_byte(str, ((num - 108) >> 8) + 247);
155 str_add_byte(str, (num - 108) & 0xff);
156 } else if(num <= -108 && num >= -1131) {
157 num = -num;
158 str_add_byte(str, ((num - 108) >> 8) + 251);
159 str_add_byte(str, (num - 108) & 0xff);
160 } else {
161 str_add_byte(str, 0xff);
162 str_add_byte(str, (num >> 24) & 0xff);
163 str_add_byte(str, (num >> 16) & 0xff);
164 str_add_byte(str, (num >> 8) & 0xff);
165 str_add_byte(str, (num & 0xff));
166 }
167 }
168
169 static void str_add_point(STR *str, POINT pt, POINT *curpos)
170 {
171 str_add_num(str, pt.x - curpos->x);
172 str_add_num(str, pt.y - curpos->y);
173 *curpos = pt;
174 }
175
176 static void str_add_cmd(STR *str, enum t1_cmds cmd)
177 {
178 str_add_byte(str, (BYTE)cmd);
179 }
180
181 static int str_get_bytes(STR *str, BYTE **b)
182 {
183 *b = str->str;
184 return str->len;
185 }
186
187 static BOOL get_hmetrics(HDC hdc, DWORD index, short *lsb, WORD *advance)
188 {
189 BYTE hhea[36];
190 WORD num_of_long;
191 BYTE buf[4];
192
193 *lsb = 0;
194 *advance = 0;
195
196 GetFontData(hdc, MS_MAKE_TAG('h','h','e','a'), 0, hhea, sizeof(hhea));
197 num_of_long = get_be_word(hhea + 34);
198
199 if(index < num_of_long)
200 {
201 if(GetFontData(hdc, MS_MAKE_TAG('h','m','t','x'), index * 4, buf, 4) != 4) return FALSE;
202 *advance = get_be_word(buf);
203 *lsb = (signed short)get_be_word(buf + 2);
204 }
205 else
206 {
207 if(GetFontData(hdc, MS_MAKE_TAG('h','m','t','x'), (num_of_long - 1) * 4, buf, 2) != 2) return FALSE;
208 *advance = get_be_word(buf);
209 if(GetFontData(hdc, MS_MAKE_TAG('h','m','t','x'), num_of_long * 4 + (index - num_of_long) * 2, buf, 2) != 2) return FALSE;
210 *lsb = (signed short)get_be_word(buf);
211 }
212
213 return TRUE;
214 }
215
216 static BOOL get_glyf_pos(HDC hdc, DWORD index, DWORD *start, DWORD *end)
217 {
218 DWORD len;
219 BYTE *head, *loca;
220 WORD loca_format;
221 BOOL ret = FALSE;
222
223 *start = *end = 0;
224
225 len = GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, NULL, 0);
226 if (len == GDI_ERROR) return FALSE;
227 head = HeapAlloc(GetProcessHeap(), 0, len);
228 GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, head, len);
229 loca_format = get_be_word(head + 50);
230
231 len = GetFontData(hdc, MS_MAKE_TAG('l','o','c','a'), 0, NULL, 0);
232 if (len == GDI_ERROR)
233 {
234 len = GetFontData(hdc, MS_MAKE_TAG('C','F','F',' '), 0, NULL, 0);
235 if (len != GDI_ERROR) FIXME( "CFF tables not supported yet\n" );
236 else ERR( "loca table not found\n" );
237 HeapFree(GetProcessHeap(), 0, head);
238 return FALSE;
239 }
240 loca = HeapAlloc(GetProcessHeap(), 0, len);
241 GetFontData(hdc, MS_MAKE_TAG('l','o','c','a'), 0, loca, len);
242
243 switch(loca_format) {
244 case 0:
245 *start = get_be_word(((WORD*)loca) + index);
246 *start <<= 1;
247 *end = get_be_word(((WORD*)loca) + index + 1);
248 *end <<= 1;
249 ret = TRUE;
250 break;
251 case 1:
252 *start = get_be_dword(((DWORD*)loca) + index);
253 *end = get_be_dword(((DWORD*)loca) + index + 1);
254 ret = TRUE;
255 break;
256 default:
257 ERR("Unknown loca_format %d\n", loca_format);
258 }
259
260 HeapFree(GetProcessHeap(), 0, loca);
261 HeapFree(GetProcessHeap(), 0, head);
262 return ret;
263 }
264
265
266 static BYTE *get_glyph_data(HDC hdc, DWORD index)
267 {
268 DWORD start, end, len;
269 BYTE *data;
270
271 if(!get_glyf_pos(hdc, index, &start, &end))
272 return NULL;
273
274 len = end - start;
275 if(!len) return NULL;
276
277 data = HeapAlloc(GetProcessHeap(), 0, len);
278 if(!data) return NULL;
279
280 if(GetFontData(hdc, MS_MAKE_TAG('g','l','y','f'), start, data, len) != len)
281 {
282 HeapFree(GetProcessHeap(), 0, data);
283 return NULL;
284 }
285 return data;
286 }
287
288 typedef struct
289 {
290 WORD num_conts;
291 WORD *end_pts; /* size_is(num_conts) */
292 BYTE *flags; /* size_is(end_pts[num_conts - 1] + 1) */
293 POINT *pts; /* size_is(end_pts[num_conts - 1] + 1) */
294 short lsb;
295 WORD advance;
296 } glyph_outline;
297
298 static inline WORD pts_in_outline(glyph_outline *outline)
299 {
300 WORD num_pts = 0;
301
302 if(outline->num_conts)
303 num_pts = outline->end_pts[outline->num_conts - 1] + 1;
304
305 return num_pts;
306 }
307
308 static BOOL append_glyph_outline(HDC hdc, DWORD index, glyph_outline *outline);
309
310 static BOOL append_simple_glyph(BYTE *data, glyph_outline *outline)
311 {
312 USHORT num_pts, start_pt = 0, ins_len;
313 WORD *end_pts;
314 int num_conts, start_cont, i;
315 BYTE *ptr;
316 int x, y;
317
318 start_cont = outline->num_conts;
319 start_pt = pts_in_outline(outline);
320
321 num_conts = get_be_word(data);
322
323 end_pts = (WORD*)(data + 10);
324 num_pts = get_be_word(end_pts + num_conts - 1) + 1;
325
326 ins_len = get_be_word(end_pts + num_conts);
327
328 ptr = (BYTE*)(end_pts + num_conts) + 2 + ins_len;
329
330 if(outline->num_conts)
331 {
332 outline->end_pts = HeapReAlloc(GetProcessHeap(), 0, outline->end_pts, (start_cont + num_conts) * sizeof(*outline->end_pts));
333 outline->flags = HeapReAlloc(GetProcessHeap(), 0, outline->flags, start_pt + num_pts);
334 outline->pts = HeapReAlloc(GetProcessHeap(), 0, outline->pts, (start_pt + num_pts) * sizeof(*outline->pts));
335 }
336 else
337 {
338 outline->end_pts = HeapAlloc(GetProcessHeap(), 0, num_conts * sizeof(*outline->end_pts));
339 outline->flags = HeapAlloc(GetProcessHeap(), 0, num_pts);
340 outline->pts = HeapAlloc(GetProcessHeap(), 0, num_pts * sizeof(*outline->pts));
341 }
342
343 outline->num_conts += num_conts;
344
345 for(i = 0; i < num_conts; i++)
346 outline->end_pts[start_cont + i] = start_pt + get_be_word(end_pts + i);
347
348 for(i = 0; i < num_pts; i++)
349 {
350 outline->flags[start_pt + i] = *ptr;
351 if(*ptr & 8)
352 {
353 BYTE count = *++ptr;
354 while(count)
355 {
356 i++;
357 outline->flags[start_pt + i] = *(ptr - 1);
358 count--;
359 }
360 }
361 ptr++;
362 }
363
364 x = 0;
365
366 for(i = 0; i < num_pts; i++)
367 {
368 INT delta;
369
370 delta = 0;
371 if(outline->flags[start_pt + i] & 2)
372 {
373 delta = *ptr++;
374 if((outline->flags[start_pt + i] & 0x10) == 0)
375 delta = -delta;
376 }
377 else if((outline->flags[start_pt + i] & 0x10) == 0)
378 {
379 delta = (signed short)get_be_word(ptr);
380 ptr += 2;
381 }
382 x += delta;
383 outline->pts[start_pt + i].x = x;
384 }
385
386 y = 0;
387 for(i = 0; i < num_pts; i++)
388 {
389 INT delta;
390
391 delta = 0;
392 if(outline->flags[start_pt + i] & 4)
393 {
394 delta = *ptr++;
395 if((outline->flags[start_pt + i] & 0x20) == 0)
396 delta = -delta;
397 }
398 else if((outline->flags[start_pt + i] & 0x20) == 0)
399 {
400 delta = (signed short)get_be_word(ptr);
401 ptr += 2;
402 }
403 y += delta;
404 outline->pts[start_pt + i].y = y;
405 }
406 return TRUE;
407 }
408
409 /* Some flags for composite glyphs. See glyf table in OT spec */
410 #define ARG_1_AND_2_ARE_WORDS (1L << 0)
411 #define ARGS_ARE_XY_VALUES (1L << 1)
412 #define WE_HAVE_A_SCALE (1L << 3)
413 #define MORE_COMPONENTS (1L << 5)
414 #define WE_HAVE_AN_X_AND_Y_SCALE (1L << 6)
415 #define WE_HAVE_A_TWO_BY_TWO (1L << 7)
416 #define USE_MY_METRICS (1L << 9)
417
418 static BOOL append_complex_glyph(HDC hdc, const BYTE *data, glyph_outline *outline)
419 {
420 const BYTE *ptr = data;
421 WORD flags, index;
422 short arg1, arg2;
423 FLOAT scale_xx = 1, scale_xy = 0, scale_yx = 0, scale_yy = 1;
424 WORD start_pt, end_pt;
425
426 ptr += 10;
427 do
428 {
429 flags = get_be_word(ptr);
430 ptr += 2;
431 index = get_be_word(ptr);
432 ptr += 2;
433 if(flags & ARG_1_AND_2_ARE_WORDS)
434 {
435 arg1 = (short)get_be_word(ptr);
436 ptr += 2;
437 arg2 = (short)get_be_word(ptr);
438 ptr += 2;
439 }
440 else
441 {
442 arg1 = *(const char*)ptr++;
443 arg2 = *(const char*)ptr++;
444 }
445 if(flags & WE_HAVE_A_SCALE)
446 {
447 scale_xx = scale_yy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
448 ptr += 2;
449 }
450 else if(flags & WE_HAVE_AN_X_AND_Y_SCALE)
451 {
452 scale_xx = (FLOAT)(short)get_be_word(ptr) / 0x4000;
453 ptr += 2;
454 scale_yy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
455 ptr += 2;
456 }
457 else if(flags & WE_HAVE_A_TWO_BY_TWO)
458 {
459 scale_xx = (FLOAT)(short)get_be_word(ptr) / 0x4000;
460 ptr += 2;
461 scale_xy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
462 ptr += 2;
463 scale_yx = (FLOAT)(short)get_be_word(ptr) / 0x4000;
464 ptr += 2;
465 scale_yy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
466 ptr += 2;
467 }
468
469 start_pt = pts_in_outline(outline);
470 append_glyph_outline(hdc, index, outline);
471 end_pt = pts_in_outline(outline);
472
473 if (flags & (WE_HAVE_A_SCALE | WE_HAVE_AN_X_AND_Y_SCALE | WE_HAVE_A_TWO_BY_TWO))
474 {
475 WORD i;
476 TRACE("transform %f,%f,%f,%f of glyph %x\n", scale_xx, scale_xy, scale_yx, scale_yy, index);
477 for (i = start_pt; i < end_pt; i++)
478 {
479 LONG x = outline->pts[i].x, y = outline->pts[i].y;
480 outline->pts[i].x = x * scale_xx + y * scale_yx;
481 outline->pts[i].y = x * scale_xy + y * scale_yy;
482 }
483 }
484
485 if((flags & ARGS_ARE_XY_VALUES) == 0)
486 {
487 WORD orig_pt = arg1, new_pt = arg2;
488 new_pt += start_pt;
489
490 if(orig_pt >= start_pt || new_pt >= end_pt) return FALSE;
491
492 arg1 = outline->pts[orig_pt].x - outline->pts[new_pt].x;
493 arg2 = outline->pts[orig_pt].y - outline->pts[new_pt].y;
494 }
495 while(start_pt < end_pt)
496 {
497 outline->pts[start_pt].x += arg1;
498 outline->pts[start_pt].y += arg2;
499 start_pt++;
500 }
501
502 if(flags & USE_MY_METRICS)
503 get_hmetrics(hdc, index, &outline->lsb, &outline->advance);
504
505 } while(flags & MORE_COMPONENTS);
506 return TRUE;
507 }
508
509 static BOOL append_glyph_outline(HDC hdc, DWORD index, glyph_outline *outline)
510 {
511 BYTE *glyph_data;
512 SHORT num_conts;
513
514 glyph_data = get_glyph_data(hdc, index);
515 if(!glyph_data) return TRUE;
516
517 num_conts = get_be_word(glyph_data);
518
519 if(num_conts == -1)
520 append_complex_glyph(hdc, glyph_data, outline);
521 else if(num_conts > 0)
522 append_simple_glyph(glyph_data, outline);
523
524 HeapFree(GetProcessHeap(), 0, glyph_data);
525 return TRUE;
526 }
527
528 static inline BOOL on_point(const glyph_outline *outline, WORD pt)
529 {
530 return outline->flags[pt] & 1;
531 }
532
533 BOOL T1_download_glyph(PHYSDEV dev, DOWNLOAD *pdl, DWORD index, char *glyph_name)
534 {
535 DWORD len;
536 WORD cur_pt, cont;
537 char *buf;
538 TYPE1 *t1;
539 STR *charstring;
540 BYTE *bytes;
541 POINT curpos;
542 glyph_outline outline;
543
544 static const char glyph_def_begin[] =
545 "/%s findfont dup\n"
546 "/Private get begin\n"
547 "/CharStrings get begin\n"
548 "/%s %ld RD\n";
549 static const char glyph_def_end[] =
550 "ND\n"
551 "end end\n";
552
553 TRACE("%ld %s\n", index, glyph_name);
554 assert(pdl->type == Type1);
555 t1 = pdl->typeinfo.Type1;
556
557 if(index < t1->glyph_sent_size) {
558 if(t1->glyph_sent[index])
559 return TRUE;
560 } else {
561 t1->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC;
562 t1->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
563 t1->glyph_sent,
564 t1->glyph_sent_size * sizeof(*(t1->glyph_sent)));
565 }
566
567 outline.num_conts = 0;
568 outline.flags = NULL;
569 outline.end_pts = NULL;
570 outline.pts = NULL;
571 get_hmetrics(dev->hdc, index, &outline.lsb, &outline.advance);
572
573 if(!append_glyph_outline(dev->hdc, index, &outline)) return FALSE;
574
575 charstring = str_init(100);
576 curpos.x = outline.lsb;
577 curpos.y = 0;
578
579 str_add_num(charstring, curpos.x);
580 str_add_num(charstring, outline.advance);
581 str_add_cmd(charstring, hsbw);
582
583 for(cur_pt = 0, cont = 0; cont < outline.num_conts; cont++)
584 {
585 POINT start_pos = outline.pts[cur_pt++];
586 WORD end_pt = outline.end_pts[cont];
587 POINT curve_pts[3] = {{0,0},{0,0},{0,0}};
588
589 str_add_point(charstring, start_pos, &curpos);
590 str_add_cmd(charstring, rmoveto);
591
592 for(; cur_pt <= end_pt; cur_pt++)
593 {
594 if(on_point(&outline, cur_pt))
595 {
596 str_add_point(charstring, outline.pts[cur_pt], &curpos);
597 str_add_cmd(charstring, rlineto);
598 }
599 else
600 {
601 BOOL added_next = FALSE;
602
603 /* temporarily store the start pt in curve_pts[0] */
604 if(on_point(&outline, cur_pt - 1))
605 curve_pts[0] = outline.pts[cur_pt - 1];
606 else /* last pt was off curve too, so the previous curve's
607 end pt was constructed */
608 curve_pts[0] = curve_pts[2];
609
610 if(cur_pt != end_pt)
611 {
612 if(on_point(&outline, cur_pt + 1))
613 {
614 curve_pts[2] = outline.pts[cur_pt + 1];
615 added_next = TRUE;
616 }
617 else /* next pt is off curve too, so construct the end pt from the
618 average of the two */
619 {
620 curve_pts[2].x = (outline.pts[cur_pt].x + outline.pts[cur_pt + 1].x + 1) / 2;
621 curve_pts[2].y = (outline.pts[cur_pt].y + outline.pts[cur_pt + 1].y + 1) / 2;
622 }
623 }
624 else /* last pt of the contour is off curve, so the end pt is the
625 start pt of the contour */
626 curve_pts[2] = start_pos;
627
628 curve_pts[0].x = (curve_pts[0].x + 2 * outline.pts[cur_pt].x + 1) / 3;
629 curve_pts[0].y = (curve_pts[0].y + 2 * outline.pts[cur_pt].y + 1) / 3;
630
631 curve_pts[1].x = (curve_pts[2].x + 2 * outline.pts[cur_pt].x + 1) / 3;
632 curve_pts[1].y = (curve_pts[2].y + 2 * outline.pts[cur_pt].y + 1) / 3;
633
634 str_add_point(charstring, curve_pts[0], &curpos);
635 str_add_point(charstring, curve_pts[1], &curpos);
636 str_add_point(charstring, curve_pts[2], &curpos);
637 str_add_cmd(charstring, rrcurveto);
638 if(added_next) cur_pt++;
639 }
640 }
641 str_add_cmd(charstring, closepath);
642 }
643 str_add_cmd(charstring, endchar);
644
645 HeapFree(GetProcessHeap(), 0, outline.pts);
646 HeapFree(GetProcessHeap(), 0, outline.end_pts);
647 HeapFree(GetProcessHeap(), 0, outline.flags);
648
649 buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def_begin) +
650 strlen(pdl->ps_name) + strlen(glyph_name) + 100);
651
652 sprintf(buf, "%%%%glyph %04lx\n", index);
653 PSDRV_WriteSpool(dev, buf, strlen(buf));
654
655 len = str_get_bytes(charstring, &bytes);
656 sprintf(buf, glyph_def_begin, pdl->ps_name, glyph_name, len);
657 PSDRV_WriteSpool(dev, buf, strlen(buf));
658 PSDRV_WriteBytes(dev, bytes, len);
659 sprintf(buf, glyph_def_end);
660 PSDRV_WriteSpool(dev, buf, strlen(buf));
661 str_free(charstring);
662
663 t1->glyph_sent[index] = TRUE;
664 HeapFree(GetProcessHeap(), 0, buf);
665 return TRUE;
666 }
667
668 void T1_free(TYPE1 *t1)
669 {
670 HeapFree(GetProcessHeap(), 0, t1->glyph_sent);
671 HeapFree(GetProcessHeap(), 0, t1);
672 return;
673 }
Windows API implementation