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
  34 #include "psdrv.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  38
  39 struct tagTYPE1 {
  40     DWORD glyph_sent_size;
  41     BOOL *glyph_sent;
  42     DWORD emsize;
  43 };
  44
  45 #define GLYPH_SENT_INC 128
  46
  47 /* Type 1 font commands */
  48 enum t1_cmds {
  49     rlineto = 5,
  50     rrcurveto = 8,
  51     closepath = 9,
  52     hsbw = 13,
  53     endchar = 14,
  54     rmoveto = 21
  55 };
  56
  57
  58 TYPE1 *T1_download_header(PSDRV_PDEVICE *physDev, char *ps_name, RECT *bbox, UINT emsize)
  59 {
  60     char *buf;
  61     TYPE1 *t1;
  62
  63     char dict[] = /* name, emsquare, fontbbox */
  64       "25 dict begin\n"
  65       " /FontName /%s def\n"
  66       " /Encoding 256 array 0 1 255{1 index exch /.notdef put} for def\n"
  67       " /PaintType 0 def\n"
  68       " /FontMatrix [1 %d div 0 0 1 %d div 0 0] def\n"
  69       " /FontBBox [%d %d %d %d] def\n"
  70       " /FontType 1 def\n"
  71       " /Private 7 dict begin\n"
  72       "  /RD {string currentfile exch readhexstring pop} def\n"
  73       "  /ND {def} def\n"
  74       "  /NP {put} def\n"
  75       "  /MinFeature {16 16} def\n"
  76       "  /BlueValues [] def\n"
  77       "  /password 5839 def\n"
  78       "  /lenIV -1 def\n"
  79       " currentdict end def\n"
  80       " currentdict dup /Private get begin\n"
  81       "  /CharStrings 256 dict begin\n"
  82       "   /.notdef 4 RD 8b8b0d0e ND\n"
  83       "  currentdict end put\n"
  84       " end\n"
  85       "currentdict end dup /FontName get exch definefont pop\n";
  86
  87     t1 = HeapAlloc(GetProcessHeap(), 0, sizeof(*t1));
  88     t1->emsize = emsize;
  89
  90     t1->glyph_sent_size = GLYPH_SENT_INC;
  91     t1->glyph_sent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  92                                t1->glyph_sent_size *
  93                                sizeof(*(t1->glyph_sent)));
  94
  95     buf = HeapAlloc(GetProcessHeap(), 0, sizeof(dict) + strlen(ps_name) +
  96                     100);
  97
  98     sprintf(buf, dict, ps_name, t1->emsize, t1->emsize,
  99             bbox->left, bbox->bottom, bbox->right, bbox->top);
 100
 101     PSDRV_WriteSpool(physDev, buf, strlen(buf));
 102
 103     HeapFree(GetProcessHeap(), 0, buf);
 104     return t1;
 105 }
 106
 107
 108 typedef struct {
 109   BYTE *str;
 110   int len, max_len;
 111 } STR;
 112
 113 static STR *str_init(int sz)
 114 {
 115   STR *str = HeapAlloc(GetProcessHeap(), 0, sizeof(*str));
 116   str->max_len = sz;
 117   str->str = HeapAlloc(GetProcessHeap(), 0, str->max_len);
 118   str->len = 0;
 119   return str;
 120 }
 121
 122 static void str_free(STR *str)
 123 {
 124   HeapFree(GetProcessHeap(), 0, str->str);
 125   HeapFree(GetProcessHeap(), 0, str);
 126 }
 127
 128 static void str_add_byte(STR *str, BYTE b)
 129 {
 130     if(str->len == str->max_len) {
 131         str->max_len *= 2;
 132         str->str = HeapReAlloc(GetProcessHeap(), 0, str->str, str->max_len);
 133     }
 134     str->str[str->len++] = b;
 135 }
 136
 137 static void str_add_num(STR *str, int num)
 138 {
 139     if(num <= 107 && num >= -107)
 140         str_add_byte(str, num + 139);
 141     else if(num >= 108 && num <= 1131) {
 142         str_add_byte(str, ((num - 108) >> 8) + 247);
 143         str_add_byte(str, (num - 108) & 0xff);
 144     } else if(num <= -108 && num >= -1131) {
 145         num = -num;
 146         str_add_byte(str, ((num - 108) >> 8) + 251);
 147         str_add_byte(str, (num - 108) & 0xff);
 148     } else {
 149         str_add_byte(str, 0xff);
 150         str_add_byte(str, (num >> 24) & 0xff);
 151         str_add_byte(str, (num >> 16) & 0xff);
 152         str_add_byte(str, (num >> 8) & 0xff);
 153         str_add_byte(str, (num & 0xff));
 154     }
 155 }
 156
 157 static void str_add_point(STR *str, POINTFX *pt, POINT *curpos)
 158 {
 159     POINT newpos;
 160     newpos.x = pt->x.value + ((pt->x.fract >> 15) & 0x1);
 161     newpos.y = pt->y.value + ((pt->y.fract >> 15) & 0x1);
 162
 163     str_add_num(str, newpos.x - curpos->x);
 164     str_add_num(str, newpos.y - curpos->y);
 165     *curpos = newpos;
 166 }
 167
 168 static void str_add_cmd(STR *str, enum t1_cmds cmd)
 169 {
 170     str_add_byte(str, (BYTE)cmd);
 171 }
 172
 173 static int str_get_bytes(STR *str, BYTE **b)
 174 {
 175   *b = str->str;
 176   return str->len;
 177 }
 178
 179 BOOL T1_download_glyph(PSDRV_PDEVICE *physDev, DOWNLOAD *pdl, DWORD index,
 180                        char *glyph_name)
 181 {
 182     DWORD len, i;
 183     char *buf;
 184     TYPE1 *t1;
 185     STR *charstring;
 186     BYTE *bytes;
 187     HFONT old_font, unscaled_font;
 188     GLYPHMETRICS gm;
 189     char *glyph_buf;
 190     POINT curpos;
 191     TTPOLYGONHEADER *pph;
 192     TTPOLYCURVE *ppc;
 193     LOGFONTW lf;
 194     RECT rc;
 195     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
 196     static const char glyph_def_begin[] =
 197       "/%s findfont dup\n"
 198       "/Private get begin\n"
 199       "/CharStrings get begin\n"
 200       "/%s %d RD\n";
 201     static const char glyph_def_end[] =
 202       "ND\n"
 203       "end end\n";
 204
 205     TRACE("%d %s\n", index, glyph_name);
 206     assert(pdl->type == Type1);
 207     t1 = pdl->typeinfo.Type1;
 208
 209     if(index < t1->glyph_sent_size) {
 210         if(t1->glyph_sent[index])
 211             return TRUE;
 212     } else {
 213         t1->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC;
 214         t1->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 215                                       t1->glyph_sent,
 216                                       t1->glyph_sent_size * sizeof(*(t1->glyph_sent)));
 217     }
 218
 219     GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
 220     rc.left = rc.right = rc.bottom = 0;
 221     rc.top = t1->emsize;
 222     DPtoLP(physDev->hdc, (POINT*)&rc, 2);
 223     lf.lfHeight = -abs(rc.top - rc.bottom);
 224     lf.lfWidth = 0;
 225     lf.lfOrientation = lf.lfEscapement = 0;
 226     unscaled_font = CreateFontIndirectW(&lf);
 227     old_font = SelectObject(physDev->hdc, unscaled_font);
 228     len = GetGlyphOutlineW(physDev->hdc, index, GGO_GLYPH_INDEX | GGO_BEZIER,
 229                            &gm, 0, NULL, &identity);
 230     if(len == GDI_ERROR) return FALSE;
 231     glyph_buf = HeapAlloc(GetProcessHeap(), 0, len);
 232     GetGlyphOutlineW(physDev->hdc, index, GGO_GLYPH_INDEX | GGO_BEZIER,
 233                      &gm, len, glyph_buf, &identity);
 234
 235     SelectObject(physDev->hdc, old_font);
 236     DeleteObject(unscaled_font);
 237
 238     charstring = str_init(100);
 239
 240     curpos.x = gm.gmptGlyphOrigin.x;
 241     curpos.y = 0;
 242
 243     str_add_num(charstring, curpos.x);
 244     str_add_num(charstring, gm.gmCellIncX);
 245     str_add_cmd(charstring, hsbw);
 246
 247     pph = (TTPOLYGONHEADER*)glyph_buf;
 248     while((char*)pph < glyph_buf + len) {
 249         TRACE("contour len %d\n", pph->cb);
 250         ppc = (TTPOLYCURVE*)((char*)pph + sizeof(*pph));
 251
 252         str_add_point(charstring, &pph->pfxStart, &curpos);
 253         str_add_cmd(charstring, rmoveto);
 254
 255         while((char*)ppc < (char*)pph + pph->cb) {
 256             TRACE("line type %d cpfx = %d\n", ppc->wType, ppc->cpfx);
 257             switch(ppc->wType) {
 258             case TT_PRIM_LINE:
 259                 for(i = 0; i < ppc->cpfx; i++) {
 260                     str_add_point(charstring, ppc->apfx + i, &curpos);
 261                     str_add_cmd(charstring, rlineto);
 262                 }
 263                 break;
 264             case TT_PRIM_CSPLINE:
 265                 for(i = 0; i < ppc->cpfx/3; i++) {
 266                     str_add_point(charstring, ppc->apfx + 3 * i, &curpos);
 267                     str_add_point(charstring, ppc->apfx + 3 * i + 1, &curpos);
 268                     str_add_point(charstring, ppc->apfx + 3 * i + 2, &curpos);
 269                     str_add_cmd(charstring, rrcurveto);
 270                 }
 271                 break;
 272             default:
 273                 ERR("curve type = %d\n", ppc->wType);
 274                 return FALSE;
 275             }
 276             ppc = (TTPOLYCURVE*)((char*)ppc + sizeof(*ppc) +
 277                                  (ppc->cpfx - 1) * sizeof(POINTFX));
 278         }
 279         str_add_cmd(charstring, closepath);
 280         pph = (TTPOLYGONHEADER*)((char*)pph + pph->cb);
 281     }
 282     str_add_cmd(charstring, endchar);
 283
 284     buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def_begin) +
 285                     strlen(pdl->ps_name) + strlen(glyph_name) + 100);
 286
 287     sprintf(buf, "%%%%glyph %04x\n", index);
 288     PSDRV_WriteSpool(physDev, buf, strlen(buf));
 289
 290     len = str_get_bytes(charstring, &bytes);
 291     sprintf(buf, glyph_def_begin, pdl->ps_name, glyph_name, len);
 292     PSDRV_WriteSpool(physDev, buf, strlen(buf));
 293     PSDRV_WriteBytes(physDev, bytes, len);
 294     sprintf(buf, glyph_def_end);
 295     PSDRV_WriteSpool(physDev, buf, strlen(buf));
 296     str_free(charstring);
 297
 298     t1->glyph_sent[index] = TRUE;
 299     HeapFree(GetProcessHeap(), 0, glyph_buf);
 300     HeapFree(GetProcessHeap(), 0, buf);
 301     return TRUE;
 302 }
 303
 304 void T1_free(TYPE1 *t1)
 305 {
 306     HeapFree(GetProcessHeap(), 0, t1->glyph_sent);
 307     HeapFree(GetProcessHeap(), 0, t1);
 308     return;
 309 }