pdf2swf/ttf2pt1/pt1.h

   1 /*
   2  * see COPYRIGHT
   3  */
   4
   5
   6 /* glyph entry, one drawing command */
   7 typedef struct gentry {
   8         /* this list links all GENTRYs of a GLYPH sequentially */
   9         struct gentry  *next;   /* double linked list */
  10         struct gentry  *prev;
  11
  12         /* this list links all GENTRYs of one contour -
  13          * of types GE_LINE and GE_CURVE only
  14          * bkwd is also reused: in the very first entry (normally
  15          * of type GE_MOVE) it points to g->entries
  16          */
  17         struct gentry  *cntr[2]; /* double-linked circular list */
  18 /* convenience handles */
  19 #define bkwd cntr[0]
  20 #define frwd cntr[1]
  21
  22         /* various extended structures used at some stage of transformation */
  23         void *ext;
  24
  25         union {
  26                 struct {
  27                         int  val[2][3]; /* integer values */
  28                 } i;
  29                 struct {
  30                         double  val[2][3];      /* floating values */
  31                 } f;
  32         } points; /* absolute values, NOT deltas */
  33 /* convenience handles */
  34 #define ipoints points.i.val
  35 #define fpoints points.f.val
  36 #define ixn ipoints[0]
  37 #define iyn ipoints[1]
  38 #define fxn fpoints[0]
  39 #define fyn fpoints[1]
  40 #define ix1     ixn[0]
  41 #define ix2 ixn[1]
  42 #define ix3 ixn[2]
  43 #define iy1     iyn[0]
  44 #define iy2 iyn[1]
  45 #define iy3 iyn[2]
  46 #define fx1     fxn[0]
  47 #define fx2 fxn[1]
  48 #define fx3 fxn[2]
  49 #define fy1     fyn[0]
  50 #define fy2 fyn[1]
  51 #define fy3 fyn[2]
  52
  53         char            flags;
  54 #define GEF_FLOAT       0x02 /* entry contains floating point data */
  55 #define GEF_LINE        0x04 /* entry looks like a line even if it's a curve */
  56
  57         unsigned char   dir; /* used to temporarily store the values for
  58                                 * the directions of the ends of curves */
  59 /* front end */
  60 #define CVDIR_FUP       0x02    /* goes over the line connecting the ends */
  61 #define CVDIR_FEQUAL    0x01    /* coincides with the line connecting the
  62                                  * ends */
  63 #define CVDIR_FDOWN     0x00    /* goes under the line connecting the ends */
  64 #define CVDIR_FRONT     0x0F    /* mask of all front directions */
  65 /* rear end */
  66 #define CVDIR_RSAME     0x30    /* is the same as for the front end */
  67 #define CVDIR_RUP       0x20    /* goes over the line connecting the ends */
  68 #define CVDIR_REQUAL    0x10    /* coincides with the line connecting the
  69                                  * ends */
  70 #define CVDIR_RDOWN     0x00    /* goes under the line connecting the ends */
  71 #define CVDIR_REAR      0xF0    /* mask of all rear directions */
  72
  73         signed char     stemid; /* connection to the substituted stem group */
  74         char            type;
  75 #define GE_HSBW 'B'
  76 #define GE_MOVE 'M'
  77 #define GE_LINE 'L'
  78 #define GE_CURVE 'C'
  79 #define GE_PATH 'P'
  80
  81         /* indexes of the points to be used for calculation of the tangents */
  82         signed char     ftg; /* front tangent */
  83         signed char     rtg; /* rear tangent, -1 means "idx 2 of the previous entry" */
  84 }               GENTRY;
  85
  86 /* stem structure, describes one [hv]stem  */
  87 /* acually, it describes one border of a stem */
  88 /* the whole stem is a pair of these structures */
  89
  90 typedef struct stem {
  91         short           value;  /* value of X or Y coordinate */
  92         short           origin; /* point of origin for curve stems */
  93         GENTRY         *ge; /* entry that has (value, origin) as its first dot */
  94                 /* also for all the stems the couple (value, origin)
  95                  * is used to determine whether a stem is relevant for a
  96                  * line, it's considered revelant if this tuple is
  97                  * equal to any of the ends of the line.
  98                  * ge is also used to resolve ambiguity if there is more than
  99                  * one line going through certain pointi, it is used to
 100                  * distinguish these lines.
 101                  */
 102
 103         short           from, to;       /* values of other coordinate between
 104                                          * which this stem is valid */
 105
 106         short           flags;
 107         /* ordering of ST_END, ST_FLAT, ST_ZONE is IMPORTANT for sorting */
 108 #define ST_END          0x01    /* end of line, lowest priority */
 109 #define ST_FLAT         0x02    /* stem is defined by a flat line, not a
 110                                  * curve */
 111 #define ST_ZONE         0x04    /* pseudo-stem, the limit of a blue zone */
 112 #define ST_UP           0x08    /* the black area is to up or right from
 113                                  * value */
 114 #define ST_3            0x20    /* first stem of [hv]stem3 */
 115 #define ST_BLUE         0x40    /* stem is in blue zone */
 116 #define ST_TOPZONE      0x80    /* 1 - top zone, 0 - bottom zone */
 117 #define ST_VERT     0x100       /* vertical stem (used in substitutions) */
 118 }               STEM;
 119
 120 #define MAX_STEMS       2000    /* we can't have more stems than path
 121                                  * elements (or hope so) */
 122 #define NSTEMGRP        50      /* maximal number of the substituted stem groups */
 123
 124 /* structure for economical representation of the
 125  * substituted stems
 126  */
 127
 128 typedef struct stembounds {
 129         short low; /* low bound */
 130         short high; /* high bound */
 131         char isvert; /* 1 - vertical, 0 - horizontal */
 132         char already; /* temp. flag: is aleready included */
 133 } STEMBOUNDS;
 134
 135 struct kern {
 136         unsigned id; /* ID of the second glyph */
 137         int val; /* kerning value */
 138 };
 139
 140 typedef struct contour {
 141         short           ymin, xofmin;
 142         short           inside; /* inside which contour */
 143         char            direction;
 144 #define DIR_OUTER 1
 145 #define DIR_INNER 0
 146 }               CONTOUR;
 147
 148 typedef struct glyph {
 149         int             char_no;/* Encoding of glyph */
 150         int             orig_code;/* code of glyph in the font's original encoding */
 151         char           *name;   /* Postscript name of glyph */
 152         int             xMin, yMin, xMax, yMax; /* values from TTF dictionary */
 153         int             lsb; /* left sidebearing */
 154         int             ttf_pathlen; /* total length of TTF paths */
 155         short           width;
 156         short           flags;
 157 #define GF_USED 0x0001          /* whether is this glyph used in T1 font */
 158 #define GF_FLOAT 0x0002         /* thys glyph contains floating point entries */
 159
 160         GENTRY         *entries;/* doube linked list of entries */
 161         GENTRY         *lastentry;      /* the last inserted entry */
 162         GENTRY         *path;   /* beggining of the last path */
 163         int             oldwidth; /* actually also scaled */
 164         int             scaledwidth;
 165 #define MAXLEGALWIDTH   10000
 166
 167         struct kern    *kern; /* kerning data */
 168         int             kerncount; /* number of kerning pairs */
 169         int             kernalloc; /* for how many pairs we have space */
 170
 171         STEM           *hstems; /* global horiz. and vert. stems */
 172         STEM           *vstems;
 173         int             nhs, nvs;       /* numbers of stems */
 174
 175         STEMBOUNDS     *sbstems; /* substituted stems for all the groups */
 176         short          *nsbs; /* indexes of the group ends in the common array */
 177         int             nsg; /* actual number of the stem groups */
 178         int             firstsubr; /* first substistuted stems subroutine number */
 179
 180         CONTOUR        *contours;       /* it is not used now */
 181         int             ncontours;
 182
 183         int             rymin, rymax;   /* real values */
 184         /* do we have flat surfaces on top/bottom */
 185         char            flatymin, flatymax;
 186
 187 }               GLYPH;
 188
 189 /* description of a dot for calculation of its distance to a curve */
 190
 191 struct dot_dist {
 192         double p[2 /*X,Y*/]; /* coordinates of a dot */
 193         double dist2; /* squared distance from the dot to the curve */
 194         short seg; /* the closest segment of the curve */
 195 };
 196
 197 extern int      stdhw, stdvw;   /* dominant stems widths */
 198 extern int      stemsnaph[12], stemsnapv[12];   /* most typical stem width */
 199
 200 extern int      bluevalues[14];
 201 extern int      nblues;
 202 extern int      otherblues[10];
 203 extern int      notherb;
 204 extern int      bbox[4];        /* the FontBBox array */
 205 extern double   italic_angle;
 206
 207 extern GLYPH   *glyph_list;
 208 extern int    encoding[];       /* inverse of glyph[].char_no */
 209
 210 /* prototypes of functions */
 211 void rmoveto( int dx, int dy);
 212 void rlineto( int dx, int dy);
 213 void rrcurveto( int dx1, int dy1, int dx2, int dy2, int dx3, int dy3);
 214 void assertpath( GENTRY * from, char *file, int line, char *name);
 215
 216 void fg_rmoveto( GLYPH * g, double x, double y);
 217 void ig_rmoveto( GLYPH * g, int x, int y);
 218 void fg_rlineto( GLYPH * g, double x, double y);
 219 void ig_rlineto( GLYPH * g, int x, int y);
 220 void fg_rrcurveto( GLYPH * g, double x1, double y1,
 221         double x2, double y2, double x3, double y3);
 222 void ig_rrcurveto( GLYPH * g, int x1, int y1,
 223         int x2, int y2, int x3, int y3);
 224 void g_closepath( GLYPH * g);
 225
 226 void pathtoint( GLYPH *g);
 227 void ffixquadrants( GLYPH *g);
 228 void flattencurves( GLYPH * g);
 229 int checkcv( GENTRY * ge, int dx, int dy);
 230 void iclosepaths( GLYPH * g);
 231 void fclosepaths( GLYPH * g);
 232 void smoothjoints( GLYPH * g);
 233 void buildstems( GLYPH * g);
 234 void fstraighten( GLYPH * g);
 235 void istraighten( GLYPH * g, int zigonly);
 236 void isplitzigzags( GLYPH * g);
 237 void fsplitzigzags( GLYPH * g);
 238 void fforceconcise( GLYPH * g);
 239 void iforceconcise( GLYPH * g);
 240 void reversepathsfromto( GENTRY * from, GENTRY * to);
 241 void reversepaths( GLYPH * g);
 242 void dumppaths( GLYPH * g, GENTRY *start, GENTRY *end);
 243 void print_glyph( int glyphno);
 244 int print_glyph_subs( int glyphno, int startid);
 245 void print_glyph_metrics( int code, int glyphno);
 246 void findblues(void);
 247 void stemstatistics(void);
 248 void docorrectwidth(void);
 249 void addkernpair( unsigned id1, unsigned id2, int unscval);
 250 void print_kerning( FILE *afm_file);
 251
 252 int fcrossrayscv( double curve[4][2], double *max1, double *max2);
 253 int fcrossraysge( GENTRY *ge1, GENTRY *ge2, double *max1, double *max2,
 254         double crossdot[2][2]);
 255 double fdotsegdist2( double seg[2][2], double dot[2]);
 256 double fdotcurvdist2( double curve[4][2], struct dot_dist *dots, int ndots, double *maxp);
 257 void fapproxcurve( double cv[4][2], struct dot_dist *dots, int ndots);