comctl32: Use SetRect() instead of open coding it.
[wine.git] / dlls / wineps.drv / type1.c
blob58fe11f26945f911f92c488846de797554c60539
1 /*
2 * PostScript driver Type1 font functions
4 * Copyright 2002 Huw D M Davies for CodeWeavers
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.
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.
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
21 #include "config.h"
22 #include "wine/port.h"
24 #include <string.h>
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <assert.h>
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winternl.h"
35 #include "psdrv.h"
36 #include "wine/debug.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
40 struct tagTYPE1 {
41 DWORD glyph_sent_size;
42 BOOL *glyph_sent;
43 DWORD emsize;
46 #define GLYPH_SENT_INC 128
48 /* Type 1 font commands */
49 enum t1_cmds {
50 rlineto = 5,
51 rrcurveto = 8,
52 closepath = 9,
53 hsbw = 13,
54 endchar = 14,
55 rmoveto = 21
59 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
60 ( ( (DWORD)_x4 << 24 ) | \
61 ( (DWORD)_x3 << 16 ) | \
62 ( (DWORD)_x2 << 8 ) | \
63 (DWORD)_x1 )
65 #ifdef WORDS_BIGENDIAN
66 static inline WORD get_be_word(const void *p) { return *(const WORD*)p; }
67 static inline DWORD get_be_dword(const void *p) { return *(const DWORD*)p; }
68 #else
69 static inline WORD get_be_word(const void *p) { return RtlUshortByteSwap(*(const WORD*)p); }
70 static inline DWORD get_be_dword(const void *p) { return RtlUlongByteSwap(*(const DWORD*)p); }
71 #endif
73 TYPE1 *T1_download_header(PHYSDEV dev, char *ps_name, RECT *bbox, UINT emsize)
75 char *buf;
76 TYPE1 *t1;
78 static const char dict[] = /* name, emsquare, fontbbox */
79 "25 dict begin\n"
80 " /FontName /%s def\n"
81 " /Encoding 256 array 0 1 255{1 index exch /.notdef put} for def\n"
82 " /PaintType 0 def\n"
83 " /FontMatrix [1 %d div 0 0 1 %d div 0 0] def\n"
84 " /FontBBox [%d %d %d %d] def\n"
85 " /FontType 1 def\n"
86 " /Private 7 dict begin\n"
87 " /RD {string currentfile exch readhexstring pop} def\n"
88 " /ND {def} def\n"
89 " /NP {put} def\n"
90 " /MinFeature {16 16} def\n"
91 " /BlueValues [] def\n"
92 " /password 5839 def\n"
93 " /lenIV -1 def\n"
94 " currentdict end def\n"
95 " currentdict dup /Private get begin\n"
96 " /CharStrings 256 dict begin\n"
97 " /.notdef 4 RD 8b8b0d0e ND\n"
98 " currentdict end put\n"
99 " end\n"
100 "currentdict end dup /FontName get exch definefont pop\n";
102 t1 = HeapAlloc(GetProcessHeap(), 0, sizeof(*t1));
103 t1->emsize = emsize;
105 t1->glyph_sent_size = GLYPH_SENT_INC;
106 t1->glyph_sent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
107 t1->glyph_sent_size *
108 sizeof(*(t1->glyph_sent)));
110 buf = HeapAlloc(GetProcessHeap(), 0, sizeof(dict) + strlen(ps_name) +
111 100);
113 sprintf(buf, dict, ps_name, t1->emsize, t1->emsize,
114 bbox->left, bbox->bottom, bbox->right, bbox->top);
116 PSDRV_WriteSpool(dev, buf, strlen(buf));
118 HeapFree(GetProcessHeap(), 0, buf);
119 return t1;
123 typedef struct {
124 BYTE *str;
125 int len, max_len;
126 } STR;
128 static STR *str_init(int sz)
130 STR *str = HeapAlloc(GetProcessHeap(), 0, sizeof(*str));
131 str->max_len = sz;
132 str->str = HeapAlloc(GetProcessHeap(), 0, str->max_len);
133 str->len = 0;
134 return str;
137 static void str_free(STR *str)
139 HeapFree(GetProcessHeap(), 0, str->str);
140 HeapFree(GetProcessHeap(), 0, str);
143 static void str_add_byte(STR *str, BYTE b)
145 if(str->len == str->max_len) {
146 str->max_len *= 2;
147 str->str = HeapReAlloc(GetProcessHeap(), 0, str->str, str->max_len);
149 str->str[str->len++] = b;
152 static void str_add_num(STR *str, int num)
154 if(num <= 107 && num >= -107)
155 str_add_byte(str, num + 139);
156 else if(num >= 108 && num <= 1131) {
157 str_add_byte(str, ((num - 108) >> 8) + 247);
158 str_add_byte(str, (num - 108) & 0xff);
159 } else if(num <= -108 && num >= -1131) {
160 num = -num;
161 str_add_byte(str, ((num - 108) >> 8) + 251);
162 str_add_byte(str, (num - 108) & 0xff);
163 } else {
164 str_add_byte(str, 0xff);
165 str_add_byte(str, (num >> 24) & 0xff);
166 str_add_byte(str, (num >> 16) & 0xff);
167 str_add_byte(str, (num >> 8) & 0xff);
168 str_add_byte(str, (num & 0xff));
172 static void str_add_point(STR *str, POINT pt, POINT *curpos)
174 str_add_num(str, pt.x - curpos->x);
175 str_add_num(str, pt.y - curpos->y);
176 *curpos = pt;
179 static void str_add_cmd(STR *str, enum t1_cmds cmd)
181 str_add_byte(str, (BYTE)cmd);
184 static int str_get_bytes(STR *str, BYTE **b)
186 *b = str->str;
187 return str->len;
190 static BOOL get_hmetrics(HDC hdc, DWORD index, short *lsb, WORD *advance)
192 BYTE hhea[36];
193 WORD num_of_long;
194 BYTE buf[4];
196 *lsb = 0;
197 *advance = 0;
199 GetFontData(hdc, MS_MAKE_TAG('h','h','e','a'), 0, hhea, sizeof(hhea));
200 num_of_long = get_be_word(hhea + 34);
202 if(index < num_of_long)
204 if(GetFontData(hdc, MS_MAKE_TAG('h','m','t','x'), index * 4, buf, 4) != 4) return FALSE;
205 *advance = get_be_word(buf);
206 *lsb = (signed short)get_be_word(buf + 2);
208 else
210 if(GetFontData(hdc, MS_MAKE_TAG('h','m','t','x'), (num_of_long - 1) * 4, buf, 2) != 2) return FALSE;
211 *advance = get_be_word(buf);
212 if(GetFontData(hdc, MS_MAKE_TAG('h','m','t','x'), num_of_long * 4 + (index - num_of_long) * 2, buf, 2) != 2) return FALSE;
213 *lsb = (signed short)get_be_word(buf);
216 return TRUE;
219 static BOOL get_glyf_pos(HDC hdc, DWORD index, DWORD *start, DWORD *end)
221 DWORD len;
222 BYTE *head, *loca;
223 WORD loca_format;
224 BOOL ret = FALSE;
226 *start = *end = 0;
228 len = GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, NULL, 0);
229 if (len == GDI_ERROR) return FALSE;
230 head = HeapAlloc(GetProcessHeap(), 0, len);
231 GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, head, len);
232 loca_format = get_be_word(head + 50);
234 len = GetFontData(hdc, MS_MAKE_TAG('l','o','c','a'), 0, NULL, 0);
235 if (len == GDI_ERROR)
237 len = GetFontData(hdc, MS_MAKE_TAG('C','F','F',' '), 0, NULL, 0);
238 if (len != GDI_ERROR) FIXME( "CFF tables not supported yet\n" );
239 else ERR( "loca table not found\n" );
240 HeapFree(GetProcessHeap(), 0, head);
241 return FALSE;
243 loca = HeapAlloc(GetProcessHeap(), 0, len);
244 GetFontData(hdc, MS_MAKE_TAG('l','o','c','a'), 0, loca, len);
246 switch(loca_format) {
247 case 0:
248 *start = get_be_word(((WORD*)loca) + index);
249 *start <<= 1;
250 *end = get_be_word(((WORD*)loca) + index + 1);
251 *end <<= 1;
252 ret = TRUE;
253 break;
254 case 1:
255 *start = get_be_dword(((DWORD*)loca) + index);
256 *end = get_be_dword(((DWORD*)loca) + index + 1);
257 ret = TRUE;
258 break;
259 default:
260 ERR("Unknown loca_format %d\n", loca_format);
263 HeapFree(GetProcessHeap(), 0, loca);
264 HeapFree(GetProcessHeap(), 0, head);
265 return ret;
269 static BYTE *get_glyph_data(HDC hdc, DWORD index)
271 DWORD start, end, len;
272 BYTE *data;
274 if(!get_glyf_pos(hdc, index, &start, &end))
275 return NULL;
277 len = end - start;
278 if(!len) return NULL;
280 data = HeapAlloc(GetProcessHeap(), 0, len);
281 if(!data) return NULL;
283 if(GetFontData(hdc, MS_MAKE_TAG('g','l','y','f'), start, data, len) != len)
285 HeapFree(GetProcessHeap(), 0, data);
286 return NULL;
288 return data;
291 typedef struct
293 WORD num_conts;
294 WORD *end_pts; /* size_is(num_conts) */
295 BYTE *flags; /* size_is(end_pts[num_conts - 1] + 1) */
296 POINT *pts; /* size_is(end_pts[num_conts - 1] + 1) */
297 short lsb;
298 WORD advance;
299 } glyph_outline;
301 static inline WORD pts_in_outline(glyph_outline *outline)
303 WORD num_pts = 0;
305 if(outline->num_conts)
306 num_pts = outline->end_pts[outline->num_conts - 1] + 1;
308 return num_pts;
311 static BOOL append_glyph_outline(HDC hdc, DWORD index, glyph_outline *outline);
313 static BOOL append_simple_glyph(BYTE *data, glyph_outline *outline)
315 USHORT num_pts, start_pt = 0, ins_len;
316 WORD *end_pts;
317 int num_conts, start_cont, i;
318 BYTE *ptr;
319 int x, y;
321 start_cont = outline->num_conts;
322 start_pt = pts_in_outline(outline);
324 num_conts = get_be_word(data);
326 end_pts = (WORD*)(data + 10);
327 num_pts = get_be_word(end_pts + num_conts - 1) + 1;
329 ins_len = get_be_word(end_pts + num_conts);
331 ptr = (BYTE*)(end_pts + num_conts) + 2 + ins_len;
333 if(outline->num_conts)
335 outline->end_pts = HeapReAlloc(GetProcessHeap(), 0, outline->end_pts, (start_cont + num_conts) * sizeof(*outline->end_pts));
336 outline->flags = HeapReAlloc(GetProcessHeap(), 0, outline->flags, start_pt + num_pts);
337 outline->pts = HeapReAlloc(GetProcessHeap(), 0, outline->pts, (start_pt + num_pts) * sizeof(*outline->pts));
339 else
341 outline->end_pts = HeapAlloc(GetProcessHeap(), 0, num_conts * sizeof(*outline->end_pts));
342 outline->flags = HeapAlloc(GetProcessHeap(), 0, num_pts);
343 outline->pts = HeapAlloc(GetProcessHeap(), 0, num_pts * sizeof(*outline->pts));
346 outline->num_conts += num_conts;
348 for(i = 0; i < num_conts; i++)
349 outline->end_pts[start_cont + i] = start_pt + get_be_word(end_pts + i);
351 for(i = 0; i < num_pts; i++)
353 outline->flags[start_pt + i] = *ptr;
354 if(*ptr & 8)
356 BYTE count = *++ptr;
357 while(count)
359 i++;
360 outline->flags[start_pt + i] = *(ptr - 1);
361 count--;
364 ptr++;
367 x = 0;
369 for(i = 0; i < num_pts; i++)
371 INT delta;
373 delta = 0;
374 if(outline->flags[start_pt + i] & 2)
376 delta = *ptr++;
377 if((outline->flags[start_pt + i] & 0x10) == 0)
378 delta = -delta;
380 else if((outline->flags[start_pt + i] & 0x10) == 0)
382 delta = (signed short)get_be_word(ptr);
383 ptr += 2;
385 x += delta;
386 outline->pts[start_pt + i].x = x;
389 y = 0;
390 for(i = 0; i < num_pts; i++)
392 INT delta;
394 delta = 0;
395 if(outline->flags[start_pt + i] & 4)
397 delta = *ptr++;
398 if((outline->flags[start_pt + i] & 0x20) == 0)
399 delta = -delta;
401 else if((outline->flags[start_pt + i] & 0x20) == 0)
403 delta = (signed short)get_be_word(ptr);
404 ptr += 2;
406 y += delta;
407 outline->pts[start_pt + i].y = y;
409 return TRUE;
412 /* Some flags for composite glyphs. See glyf table in OT spec */
413 #define ARG_1_AND_2_ARE_WORDS (1L << 0)
414 #define ARGS_ARE_XY_VALUES (1L << 1)
415 #define WE_HAVE_A_SCALE (1L << 3)
416 #define MORE_COMPONENTS (1L << 5)
417 #define WE_HAVE_AN_X_AND_Y_SCALE (1L << 6)
418 #define WE_HAVE_A_TWO_BY_TWO (1L << 7)
419 #define USE_MY_METRICS (1L << 9)
421 static BOOL append_complex_glyph(HDC hdc, const BYTE *data, glyph_outline *outline)
423 const BYTE *ptr = data;
424 WORD flags, index;
425 short arg1, arg2;
426 FLOAT scale_xx = 1, scale_xy = 0, scale_yx = 0, scale_yy = 1;
427 WORD start_pt, end_pt;
429 ptr += 10;
432 flags = get_be_word(ptr);
433 ptr += 2;
434 index = get_be_word(ptr);
435 ptr += 2;
436 if(flags & ARG_1_AND_2_ARE_WORDS)
438 arg1 = (short)get_be_word(ptr);
439 ptr += 2;
440 arg2 = (short)get_be_word(ptr);
441 ptr += 2;
443 else
445 arg1 = *(const char*)ptr++;
446 arg2 = *(const char*)ptr++;
448 if(flags & WE_HAVE_A_SCALE)
450 scale_xx = scale_yy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
451 ptr += 2;
453 else if(flags & WE_HAVE_AN_X_AND_Y_SCALE)
455 scale_xx = (FLOAT)(short)get_be_word(ptr) / 0x4000;
456 ptr += 2;
457 scale_yy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
458 ptr += 2;
460 else if(flags & WE_HAVE_A_TWO_BY_TWO)
462 scale_xx = (FLOAT)(short)get_be_word(ptr) / 0x4000;
463 ptr += 2;
464 scale_xy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
465 ptr += 2;
466 scale_yx = (FLOAT)(short)get_be_word(ptr) / 0x4000;
467 ptr += 2;
468 scale_yy = (FLOAT)(short)get_be_word(ptr) / 0x4000;
469 ptr += 2;
472 start_pt = pts_in_outline(outline);
473 append_glyph_outline(hdc, index, outline);
474 end_pt = pts_in_outline(outline);
476 if (flags & (WE_HAVE_A_SCALE | WE_HAVE_AN_X_AND_Y_SCALE | WE_HAVE_A_TWO_BY_TWO))
478 WORD i;
479 TRACE("transform %f,%f,%f,%f of glyph %x\n", scale_xx, scale_xy, scale_yx, scale_yy, index);
480 for (i = start_pt; i < end_pt; i++)
482 LONG x = outline->pts[i].x, y = outline->pts[i].y;
483 outline->pts[i].x = x * scale_xx + y * scale_yx;
484 outline->pts[i].y = x * scale_xy + y * scale_yy;
488 if((flags & ARGS_ARE_XY_VALUES) == 0)
490 WORD orig_pt = arg1, new_pt = arg2;
491 new_pt += start_pt;
493 if(orig_pt >= start_pt || new_pt >= end_pt) return FALSE;
495 arg1 = outline->pts[orig_pt].x - outline->pts[new_pt].x;
496 arg2 = outline->pts[orig_pt].y - outline->pts[new_pt].y;
498 while(start_pt < end_pt)
500 outline->pts[start_pt].x += arg1;
501 outline->pts[start_pt].y += arg2;
502 start_pt++;
505 if(flags & USE_MY_METRICS)
506 get_hmetrics(hdc, index, &outline->lsb, &outline->advance);
508 } while(flags & MORE_COMPONENTS);
509 return TRUE;
512 static BOOL append_glyph_outline(HDC hdc, DWORD index, glyph_outline *outline)
514 BYTE *glyph_data;
515 SHORT num_conts;
517 glyph_data = get_glyph_data(hdc, index);
518 if(!glyph_data) return TRUE;
520 num_conts = get_be_word(glyph_data);
522 if(num_conts == -1)
523 append_complex_glyph(hdc, glyph_data, outline);
524 else if(num_conts > 0)
525 append_simple_glyph(glyph_data, outline);
527 HeapFree(GetProcessHeap(), 0, glyph_data);
528 return TRUE;
531 static inline BOOL on_point(const glyph_outline *outline, WORD pt)
533 return outline->flags[pt] & 1;
536 BOOL T1_download_glyph(PHYSDEV dev, DOWNLOAD *pdl, DWORD index, char *glyph_name)
538 DWORD len;
539 WORD cur_pt, cont;
540 char *buf;
541 TYPE1 *t1;
542 STR *charstring;
543 BYTE *bytes;
544 POINT curpos;
545 glyph_outline outline;
547 static const char glyph_def_begin[] =
548 "/%s findfont dup\n"
549 "/Private get begin\n"
550 "/CharStrings get begin\n"
551 "/%s %d RD\n";
552 static const char glyph_def_end[] =
553 "ND\n"
554 "end end\n";
556 TRACE("%d %s\n", index, glyph_name);
557 assert(pdl->type == Type1);
558 t1 = pdl->typeinfo.Type1;
560 if(index < t1->glyph_sent_size) {
561 if(t1->glyph_sent[index])
562 return TRUE;
563 } else {
564 t1->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC;
565 t1->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
566 t1->glyph_sent,
567 t1->glyph_sent_size * sizeof(*(t1->glyph_sent)));
570 outline.num_conts = 0;
571 outline.flags = NULL;
572 outline.end_pts = NULL;
573 outline.pts = NULL;
574 get_hmetrics(dev->hdc, index, &outline.lsb, &outline.advance);
576 if(!append_glyph_outline(dev->hdc, index, &outline)) return FALSE;
578 charstring = str_init(100);
579 curpos.x = outline.lsb;
580 curpos.y = 0;
582 str_add_num(charstring, curpos.x);
583 str_add_num(charstring, outline.advance);
584 str_add_cmd(charstring, hsbw);
586 for(cur_pt = 0, cont = 0; cont < outline.num_conts; cont++)
588 POINT start_pos = outline.pts[cur_pt++];
589 WORD end_pt = outline.end_pts[cont];
590 POINT curve_pts[3] = {{0,0},{0,0},{0,0}};
592 str_add_point(charstring, start_pos, &curpos);
593 str_add_cmd(charstring, rmoveto);
595 for(; cur_pt <= end_pt; cur_pt++)
597 if(on_point(&outline, cur_pt))
599 str_add_point(charstring, outline.pts[cur_pt], &curpos);
600 str_add_cmd(charstring, rlineto);
602 else
604 BOOL added_next = FALSE;
606 /* temporarily store the start pt in curve_pts[0] */
607 if(on_point(&outline, cur_pt - 1))
608 curve_pts[0] = outline.pts[cur_pt - 1];
609 else /* last pt was off curve too, so the previous curve's
610 end pt was constructed */
611 curve_pts[0] = curve_pts[2];
613 if(cur_pt != end_pt)
615 if(on_point(&outline, cur_pt + 1))
617 curve_pts[2] = outline.pts[cur_pt + 1];
618 added_next = TRUE;
620 else /* next pt is off curve too, so construct the end pt from the
621 average of the two */
623 curve_pts[2].x = (outline.pts[cur_pt].x + outline.pts[cur_pt + 1].x + 1) / 2;
624 curve_pts[2].y = (outline.pts[cur_pt].y + outline.pts[cur_pt + 1].y + 1) / 2;
627 else /* last pt of the contour is off curve, so the end pt is the
628 start pt of the contour */
629 curve_pts[2] = start_pos;
631 curve_pts[0].x = (curve_pts[0].x + 2 * outline.pts[cur_pt].x + 1) / 3;
632 curve_pts[0].y = (curve_pts[0].y + 2 * outline.pts[cur_pt].y + 1) / 3;
634 curve_pts[1].x = (curve_pts[2].x + 2 * outline.pts[cur_pt].x + 1) / 3;
635 curve_pts[1].y = (curve_pts[2].y + 2 * outline.pts[cur_pt].y + 1) / 3;
637 str_add_point(charstring, curve_pts[0], &curpos);
638 str_add_point(charstring, curve_pts[1], &curpos);
639 str_add_point(charstring, curve_pts[2], &curpos);
640 str_add_cmd(charstring, rrcurveto);
641 if(added_next) cur_pt++;
644 str_add_cmd(charstring, closepath);
646 str_add_cmd(charstring, endchar);
648 HeapFree(GetProcessHeap(), 0, outline.pts);
649 HeapFree(GetProcessHeap(), 0, outline.end_pts);
650 HeapFree(GetProcessHeap(), 0, outline.flags);
652 buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def_begin) +
653 strlen(pdl->ps_name) + strlen(glyph_name) + 100);
655 sprintf(buf, "%%%%glyph %04x\n", index);
656 PSDRV_WriteSpool(dev, buf, strlen(buf));
658 len = str_get_bytes(charstring, &bytes);
659 sprintf(buf, glyph_def_begin, pdl->ps_name, glyph_name, len);
660 PSDRV_WriteSpool(dev, buf, strlen(buf));
661 PSDRV_WriteBytes(dev, bytes, len);
662 sprintf(buf, glyph_def_end);
663 PSDRV_WriteSpool(dev, buf, strlen(buf));
664 str_free(charstring);
666 t1->glyph_sent[index] = TRUE;
667 HeapFree(GetProcessHeap(), 0, buf);
668 return TRUE;
671 void T1_free(TYPE1 *t1)
673 HeapFree(GetProcessHeap(), 0, t1->glyph_sent);
674 HeapFree(GetProcessHeap(), 0, t1);
675 return;