dlls/wineps.drv/type1.c

   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 "config.h"
  22 #include "wine/port.h"
  23
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <assert.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winternl.h"
  34
  35 #include "psdrv.h"
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  39
  40 struct tagTYPE1 {
  41     DWORD glyph_sent_size;
  42     BOOL *glyph_sent;
  43     DWORD emsize;
  44 };
  45
  46 #define GLYPH_SENT_INC 128
  47
  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
  56 };
  57
  58
  59 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
  60           ( ( (DWORD)_x4 << 24 ) |     \
  61             ( (DWORD)_x3 << 16 ) |     \
  62             ( (DWORD)_x2 <<  8 ) |     \
  63               (DWORD)_x1         )
  64
  65 #ifdef WORDS_BIGENDIAN
  66 static inline WORD  get_be_word(const void *p)  { return *(WORD*)p; }
  67 static inline DWORD get_be_dword(const void *p) { return *(DWORD*)p; }
  68 #else
  69 static inline WORD  get_be_word(const void *p)  { return RtlUshortByteSwap(*(WORD*)p); }
  70 static inline DWORD get_be_dword(const void *p) { return RtlUlongByteSwap(*(DWORD*)p); }
  71 #endif
  72
  73 TYPE1 *T1_download_header(PHYSDEV dev, char *ps_name, RECT *bbox, UINT emsize)
  74 {
  75     char *buf;
  76     TYPE1 *t1;
  77
  78     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";
 101
 102     t1 = HeapAlloc(GetProcessHeap(), 0, sizeof(*t1));
 103     t1->emsize = emsize;
 104
 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)));
 109
 110     buf = HeapAlloc(GetProcessHeap(), 0, sizeof(dict) + strlen(ps_name) +
 111                     100);
 112
 113     sprintf(buf, dict, ps_name, t1->emsize, t1->emsize,
 114             bbox->left, bbox->bottom, bbox->right, bbox->top);
 115
 116     PSDRV_WriteSpool(dev, buf, strlen(buf));
 117
 118     HeapFree(GetProcessHeap(), 0, buf);
 119     return t1;
 120 }
 121
 122
 123 typedef struct {
 124   BYTE *str;
 125   int len, max_len;
 126 } STR;
 127
 128 static STR *str_init(int sz)
 129 {
 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;
 135 }
 136
 137 static void str_free(STR *str)
 138 {
 139   HeapFree(GetProcessHeap(), 0, str->str);
 140   HeapFree(GetProcessHeap(), 0, str);
 141 }
 142
 143 static void str_add_byte(STR *str, BYTE b)
 144 {
 145     if(str->len == str->max_len) {
 146         str->max_len *= 2;
 147         str->str = HeapReAlloc(GetProcessHeap(), 0, str->str, str->max_len);
 148     }
 149     str->str[str->len++] = b;
 150 }
 151
 152 static void str_add_num(STR *str, int num)
 153 {
 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));
 169     }
 170 }
 171
 172 static void str_add_point(STR *str, POINT pt, POINT *curpos)
 173 {
 174     str_add_num(str, pt.x - curpos->x);
 175     str_add_num(str, pt.y - curpos->y);
 176     *curpos = pt;
 177 }
 178
 179 static void str_add_cmd(STR *str, enum t1_cmds cmd)
 180 {
 181     str_add_byte(str, (BYTE)cmd);
 182 }
 183
 184 static int str_get_bytes(STR *str, BYTE **b)
 185 {
 186   *b = str->str;
 187   return str->len;
 188 }
 189
 190 static BOOL get_hmetrics(HDC hdc, DWORD index, short *lsb, WORD *advance)
 191 {
 192     BYTE hhea[36];
 193     WORD num_of_long;
 194     BYTE buf[4];
 195
 196     *lsb = 0;
 197     *advance = 0;
 198
 199     GetFontData(hdc, MS_MAKE_TAG('h','h','e','a'), 0, hhea, sizeof(hhea));
 200     num_of_long = get_be_word(hhea + 34);
 201
 202     if(index < num_of_long)
 203     {
 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);
 207     }
 208     else
 209     {
 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);
 214     }
 215
 216     return TRUE;
 217 }
 218
 219 static BOOL get_glyf_pos(HDC hdc, DWORD index, DWORD *start, DWORD *end)
 220 {
 221     DWORD len;
 222     BYTE *head, *loca;
 223     WORD loca_format;
 224     BOOL ret = FALSE;
 225
 226     *start = *end = 0;
 227
 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);
 233
 234     len = GetFontData(hdc, MS_MAKE_TAG('l','o','c','a'), 0, NULL, 0);
 235     if (len == GDI_ERROR)
 236     {
 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;
 242     }
 243     loca = HeapAlloc(GetProcessHeap(), 0, len);
 244     GetFontData(hdc, MS_MAKE_TAG('l','o','c','a'), 0, loca, len);
 245
 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);
 261     }
 262
 263     HeapFree(GetProcessHeap(), 0, loca);
 264     HeapFree(GetProcessHeap(), 0, head);
 265     return ret;
 266 }
 267
 268
 269 static BYTE *get_glyph_data(HDC hdc, DWORD index)
 270 {
 271     DWORD start, end, len;
 272     BYTE *data;
 273
 274     if(!get_glyf_pos(hdc, index, &start, &end))
 275         return NULL;
 276
 277     len = end - start;
 278     if(!len) return NULL;
 279
 280     data = HeapAlloc(GetProcessHeap(), 0, len);
 281     if(!data) return NULL;
 282
 283     if(GetFontData(hdc, MS_MAKE_TAG('g','l','y','f'), start, data, len) != len)
 284     {
 285         HeapFree(GetProcessHeap(), 0, data);
 286         return NULL;
 287     }
 288     return data;
 289 }
 290
 291 typedef struct
 292 {
 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;
 300
 301 static inline WORD pts_in_outline(glyph_outline *outline)
 302 {
 303     WORD num_pts = 0;
 304
 305     if(outline->num_conts)
 306         num_pts = outline->end_pts[outline->num_conts - 1] + 1;
 307
 308     return num_pts;
 309 }
 310
 311 static BOOL append_glyph_outline(HDC hdc, DWORD index, glyph_outline *outline);
 312
 313 static BOOL append_simple_glyph(BYTE *data, glyph_outline *outline)
 314 {
 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;
 320
 321     start_cont = outline->num_conts;
 322     start_pt = pts_in_outline(outline);
 323
 324     num_conts = get_be_word(data);
 325
 326     end_pts = (WORD*)(data + 10);
 327     num_pts = get_be_word(end_pts + num_conts - 1) + 1;
 328
 329     ins_len = get_be_word(end_pts + num_conts);
 330
 331     ptr = (BYTE*)(end_pts + num_conts) + 2 + ins_len;
 332
 333     if(outline->num_conts)
 334     {
 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));
 338     }
 339     else
 340     {
 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));
 344     }
 345
 346     outline->num_conts += num_conts;
 347
 348     for(i = 0; i < num_conts; i++)
 349         outline->end_pts[start_cont + i] = start_pt + get_be_word(end_pts + i);
 350
 351     for(i = 0; i < num_pts; i++)
 352     {
 353         outline->flags[start_pt + i] = *ptr;
 354         if(*ptr & 8)
 355         {
 356             BYTE count = *++ptr;
 357             while(count)
 358             {
 359                 i++;
 360                 outline->flags[start_pt + i] = *(ptr - 1);
 361                 count--;
 362             }
 363         }
 364         ptr++;
 365     }
 366
 367     x = 0;
 368
 369     for(i = 0; i < num_pts; i++)
 370     {
 371         INT delta;
 372
 373         delta = 0;
 374         if(outline->flags[start_pt + i] & 2)
 375         {
 376             delta = *ptr++;
 377             if((outline->flags[start_pt + i] & 0x10) == 0)
 378                 delta = -delta;
 379         }
 380         else if((outline->flags[start_pt + i] & 0x10) == 0)
 381         {
 382             delta = (signed short)get_be_word(ptr);
 383             ptr += 2;
 384         }
 385         x += delta;
 386         outline->pts[start_pt + i].x = x;
 387     }
 388
 389     y = 0;
 390     for(i = 0; i < num_pts; i++)
 391     {
 392         INT delta;
 393
 394         delta = 0;
 395         if(outline->flags[start_pt + i] & 4)
 396         {
 397             delta = *ptr++;
 398             if((outline->flags[start_pt + i] & 0x20) == 0)
 399                 delta = -delta;
 400         }
 401         else if((outline->flags[start_pt + i] & 0x20) == 0)
 402         {
 403             delta = (signed short)get_be_word(ptr);
 404             ptr += 2;
 405         }
 406         y += delta;
 407         outline->pts[start_pt + i].y = y;
 408     }
 409     return TRUE;
 410 }
 411
 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)
 420
 421 static BOOL append_complex_glyph(HDC hdc, const BYTE *data, glyph_outline *outline)
 422 {
 423     const BYTE *ptr = data;
 424     WORD flags, index;
 425     short arg1, arg2;
 426     WORD scale_xx = 1 << 14, scale_xy = 0, scale_yx = 0, scale_yy = 1 << 14;
 427     WORD start_pt, end_pt;
 428
 429     ptr += 10;
 430     do
 431     {
 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)
 437         {
 438             arg1 = (short)get_be_word(ptr);
 439             ptr += 2;
 440             arg2 = (short)get_be_word(ptr);
 441             ptr += 2;
 442         }
 443         else
 444         {
 445             arg1 = *(char*)ptr++;
 446             arg2 = *(char*)ptr++;
 447         }
 448         if(flags & WE_HAVE_A_SCALE)
 449         {
 450             scale_xx = scale_yy = get_be_word(ptr);
 451             ptr += 2;
 452         }
 453         else if(flags & WE_HAVE_AN_X_AND_Y_SCALE)
 454         {
 455             scale_xx = get_be_word(ptr);
 456             ptr += 2;
 457             scale_yy = get_be_word(ptr);
 458             ptr += 2;
 459         }
 460         else if(flags & WE_HAVE_A_TWO_BY_TWO)
 461         {
 462             scale_xx = get_be_word(ptr);
 463             ptr += 2;
 464             scale_xy = get_be_word(ptr);
 465             ptr += 2;
 466             scale_yx = get_be_word(ptr);
 467             ptr += 2;
 468             scale_yy = get_be_word(ptr);
 469             ptr += 2;
 470         }
 471
 472         if ((flags & (WE_HAVE_A_SCALE | WE_HAVE_AN_X_AND_Y_SCALE | WE_HAVE_A_TWO_BY_TWO)) &&
 473             (scale_xx != 1 << 14 || scale_yy != 1 << 14 || scale_xy || scale_yx))
 474             FIXME( "unhandled scaling %x,%x,%x,%x of glyph %x\n",
 475                    scale_xx, scale_xy, scale_yx, scale_yy, index );
 476
 477         start_pt = pts_in_outline(outline);
 478         append_glyph_outline(hdc, index, outline);
 479         end_pt = pts_in_outline(outline);
 480
 481         if((flags & ARGS_ARE_XY_VALUES) == 0)
 482         {
 483             WORD orig_pt = arg1, new_pt = arg2;
 484             new_pt += start_pt;
 485
 486             if(orig_pt >= start_pt || new_pt >= end_pt) return FALSE;
 487
 488             arg1 = outline->pts[orig_pt].x - outline->pts[new_pt].x;
 489             arg2 = outline->pts[orig_pt].y - outline->pts[new_pt].y;
 490         }
 491         while(start_pt < end_pt)
 492         {
 493             outline->pts[start_pt].x += arg1;
 494             outline->pts[start_pt].y += arg2;
 495             start_pt++;
 496         }
 497
 498         if(flags & USE_MY_METRICS)
 499             get_hmetrics(hdc, index, &outline->lsb, &outline->advance);
 500
 501     } while(flags & MORE_COMPONENTS);
 502     return TRUE;
 503 }
 504
 505 static BOOL append_glyph_outline(HDC hdc, DWORD index, glyph_outline *outline)
 506 {
 507     BYTE *glyph_data;
 508     SHORT num_conts;
 509
 510     glyph_data = get_glyph_data(hdc, index);
 511     if(!glyph_data) return TRUE;
 512
 513     num_conts = get_be_word(glyph_data);
 514
 515     if(num_conts == -1)
 516         append_complex_glyph(hdc, glyph_data, outline);
 517     else if(num_conts > 0)
 518         append_simple_glyph(glyph_data, outline);
 519
 520     HeapFree(GetProcessHeap(), 0, glyph_data);
 521     return TRUE;
 522 }
 523
 524 static inline BOOL on_point(const glyph_outline *outline, WORD pt)
 525 {
 526     return outline->flags[pt] & 1;
 527 }
 528
 529 BOOL T1_download_glyph(PHYSDEV dev, DOWNLOAD *pdl, DWORD index, char *glyph_name)
 530 {
 531     DWORD len;
 532     WORD cur_pt, cont;
 533     char *buf;
 534     TYPE1 *t1;
 535     STR *charstring;
 536     BYTE *bytes;
 537     POINT curpos;
 538     glyph_outline outline;
 539
 540     static const char glyph_def_begin[] =
 541       "/%s findfont dup\n"
 542       "/Private get begin\n"
 543       "/CharStrings get begin\n"
 544       "/%s %d RD\n";
 545     static const char glyph_def_end[] =
 546       "ND\n"
 547       "end end\n";
 548
 549     TRACE("%d %s\n", index, glyph_name);
 550     assert(pdl->type == Type1);
 551     t1 = pdl->typeinfo.Type1;
 552
 553     if(index < t1->glyph_sent_size) {
 554         if(t1->glyph_sent[index])
 555             return TRUE;
 556     } else {
 557         t1->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC;
 558         t1->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 559                                       t1->glyph_sent,
 560                                       t1->glyph_sent_size * sizeof(*(t1->glyph_sent)));
 561     }
 562
 563     outline.num_conts = 0;
 564     outline.flags = NULL;
 565     outline.end_pts = NULL;
 566     outline.pts = NULL;
 567     get_hmetrics(dev->hdc, index, &outline.lsb, &outline.advance);
 568
 569     if(!append_glyph_outline(dev->hdc, index, &outline)) return FALSE;
 570
 571     charstring = str_init(100);
 572     curpos.x = outline.lsb;
 573     curpos.y = 0;
 574
 575     str_add_num(charstring, curpos.x);
 576     str_add_num(charstring, outline.advance);
 577     str_add_cmd(charstring, hsbw);
 578
 579     for(cur_pt = 0, cont = 0; cont < outline.num_conts; cont++)
 580     {
 581         POINT start_pos = outline.pts[cur_pt++];
 582         WORD end_pt = outline.end_pts[cont];
 583         POINT curve_pts[3] = {{0,0},{0,0},{0,0}};
 584
 585         str_add_point(charstring, start_pos, &curpos);
 586         str_add_cmd(charstring, rmoveto);
 587
 588         for(; cur_pt <= end_pt; cur_pt++)
 589         {
 590             if(on_point(&outline, cur_pt))
 591             {
 592                 str_add_point(charstring, outline.pts[cur_pt], &curpos);
 593                 str_add_cmd(charstring, rlineto);
 594             }
 595             else
 596             {
 597                 BOOL added_next = FALSE;
 598
 599                 /* temporarily store the start pt in curve_pts[0] */
 600                 if(on_point(&outline, cur_pt - 1))
 601                     curve_pts[0] = outline.pts[cur_pt - 1];
 602                 else /* last pt was off curve too, so the previous curve's
 603                         end pt was constructed */
 604                     curve_pts[0] = curve_pts[2];
 605
 606                 if(cur_pt != end_pt)
 607                 {
 608                     if(on_point(&outline, cur_pt + 1))
 609                     {
 610                         curve_pts[2] = outline.pts[cur_pt + 1];
 611                         added_next = TRUE;
 612                     }
 613                     else /* next pt is off curve too, so construct the end pt from the
 614                             average of the two */
 615                     {
 616                         curve_pts[2].x = (outline.pts[cur_pt].x + outline.pts[cur_pt + 1].x + 1) / 2;
 617                         curve_pts[2].y = (outline.pts[cur_pt].y + outline.pts[cur_pt + 1].y + 1) / 2;
 618                     }
 619                 }
 620                 else /* last pt of the contour is off curve, so the end pt is the
 621                         start pt of the contour */
 622                     curve_pts[2] = start_pos;
 623
 624                 curve_pts[0].x = (curve_pts[0].x + 2 * outline.pts[cur_pt].x + 1) / 3;
 625                 curve_pts[0].y = (curve_pts[0].y + 2 * outline.pts[cur_pt].y + 1) / 3;
 626
 627                 curve_pts[1].x = (curve_pts[2].x + 2 * outline.pts[cur_pt].x + 1) / 3;
 628                 curve_pts[1].y = (curve_pts[2].y + 2 * outline.pts[cur_pt].y + 1) / 3;
 629
 630                 str_add_point(charstring, curve_pts[0], &curpos);
 631                 str_add_point(charstring, curve_pts[1], &curpos);
 632                 str_add_point(charstring, curve_pts[2], &curpos);
 633                 str_add_cmd(charstring, rrcurveto);
 634                 if(added_next) cur_pt++;
 635             }
 636         }
 637         str_add_cmd(charstring, closepath);
 638     }
 639     str_add_cmd(charstring, endchar);
 640
 641     HeapFree(GetProcessHeap(), 0, outline.pts);
 642     HeapFree(GetProcessHeap(), 0, outline.end_pts);
 643     HeapFree(GetProcessHeap(), 0, outline.flags);
 644
 645     buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def_begin) +
 646                     strlen(pdl->ps_name) + strlen(glyph_name) + 100);
 647
 648     sprintf(buf, "%%%%glyph %04x\n", index);
 649     PSDRV_WriteSpool(dev, buf, strlen(buf));
 650
 651     len = str_get_bytes(charstring, &bytes);
 652     sprintf(buf, glyph_def_begin, pdl->ps_name, glyph_name, len);
 653     PSDRV_WriteSpool(dev, buf, strlen(buf));
 654     PSDRV_WriteBytes(dev, bytes, len);
 655     sprintf(buf, glyph_def_end);
 656     PSDRV_WriteSpool(dev, buf, strlen(buf));
 657     str_free(charstring);
 658
 659     t1->glyph_sent[index] = TRUE;
 660     HeapFree(GetProcessHeap(), 0, buf);
 661     return TRUE;
 662 }
 663
 664 void T1_free(TYPE1 *t1)
 665 {
 666     HeapFree(GetProcessHeap(), 0, t1->glyph_sent);
 667     HeapFree(GetProcessHeap(), 0, t1);
 668     return;
 669 }