source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.h

   1 /* Copyright (C) 2000-2008 by George Williams */
   2 /*
   3  * Redistribution and use in source and binary forms, with or without
   4  * modification, are permitted provided that the following conditions are met:
   5
   6  * Redistributions of source code must retain the above copyright notice, this
   7  * list of conditions and the following disclaimer.
   8
   9  * Redistributions in binary form must reproduce the above copyright notice,
  10  * this list of conditions and the following disclaimer in the documentation
  11  * and/or other materials provided with the distribution.
  12
  13  * The name of the author may not be used to endorse or promote products
  14  * derived from this software without specific prior written permission.
  15
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #ifndef _SPLINEFONT_H
  28 #define _SPLINEFONT_H
  29
  30 #include "basics.h"
  31 #include "configure-pfaedit.h"
  32 #ifdef HAVE_ICONV_H
  33 # include <iconv.h>
  34 /* libiconv.h defines iconv as taking a const pointer for inbuf. iconv doesn't*/
  35 # ifdef _LIBICONV_VERSION
  36 #  define ICONV_CONST   const
  37 # else
  38 #  define ICONV_CONST
  39 # endif
  40 #else
  41 # include <gwwiconv.h>
  42 #  define ICONV_CONST
  43 #endif
  44
  45 #if defined( FONTFORGE_CONFIG_USE_LONGDOUBLE )
  46 # define real           long double
  47 # define bigreal        long double
  48 #elif defined( FONTFORGE_CONFIG_USE_DOUBLE )
  49 # define real           double
  50 # define bigreal        double
  51 #else
  52 # define real           float
  53 # define bigreal        double
  54 #endif
  55
  56 #if defined( HAVE_LONG_DOUBLE ) && defined( This_does_not_seem_to_make_a_difference )
  57 # define extended       long double
  58 # define CheckExtremaForSingleBitErrors(sp,t)   (t)
  59 # define EXTENDED_IS_LONG_DOUBLE        1
  60 #else
  61 # define extended       double
  62 #endif
  63         /* Solaris wants to define extended to be unsigned [3] unless we do this*/
  64 #define _EXTENDED
  65
  66 #define CHR(ch1,ch2,ch3,ch4) (((ch1)<<24)|((ch2)<<16)|((ch3)<<8)|(ch4))
  67
  68 #define MmMax           16      /* PS says at most this many instances for type1/2 mm fonts */
  69
  70 typedef struct ipoint {
  71     int x;
  72     int y;
  73 } IPoint;
  74
  75 typedef struct basepoint {
  76     real x;
  77     real y;
  78 } BasePoint;
  79
  80 typedef struct dbasepoint {
  81     bigreal x;
  82     bigreal y;
  83 } DBasePoint;
  84
  85 typedef struct tpoint {
  86     real x;
  87     real y;
  88     real t;
  89 } TPoint;
  90
  91 typedef struct dbounds {
  92     real minx, maxx;
  93     real miny, maxy;
  94 } DBounds;
  95
  96 typedef struct ibounds {
  97     int minx, maxx;
  98     int miny, maxy;
  99 } IBounds;
 100
 101 typedef struct val {
 102     enum val_type { v_int, v_real, v_str, v_unicode, v_lval, v_arr, v_arrfree,
 103             v_int32pt, v_int16pt, v_int8pt, v_void } type;
 104     union {
 105         int ival;
 106         real fval;
 107         char *sval;
 108         struct val *lval;
 109         struct array *aval;
 110         uint32 *u32ptval;
 111         uint16 *u16ptval;
 112         uint8  *u8ptval;
 113     } u;
 114 } Val;          /* Used by scripting */
 115
 116 struct psdict {
 117     int cnt, next;
 118     char **keys;
 119     char **values;
 120 };
 121
 122 struct pschars {
 123     int cnt, next;
 124     char **keys;
 125     uint8 **values;
 126     int *lens;
 127     int bias;           /* for type2 strings */
 128 };
 129
 130 enum linejoin {
 131     lj_miter,           /* Extend lines until they meet */
 132     lj_round,           /* circle centered at the join of expand radius */
 133     lj_bevel,           /* Straight line between the ends of next and prev */
 134     lj_inherited
 135 };
 136 enum linecap {
 137     lc_butt,            /* equiv to lj_bevel, straight line extends from one side to other */
 138     lc_round,           /* semi-circle */
 139     lc_square,          /* Extend lines by radius, then join them */
 140     lc_inherited
 141 };
 142 enum spreadMethod {
 143     sm_pad, sm_reflect, sm_repeat
 144 };
 145 #define COLOR_INHERITED 0xfffffffe
 146 struct gradient {
 147     BasePoint start;    /* focal of a radial gradient, start of a linear */
 148     BasePoint stop;     /* center of a radial gradient, end of a linear */
 149     real radius;        /* 0=>linear gradient, else radius of a radial gradient */
 150     enum spreadMethod sm;
 151     int stop_cnt;
 152     struct grad_stops {
 153         real offset;
 154         uint32 col;
 155         real opacity;
 156     } *grad_stops;
 157 };
 158
 159 struct pattern {
 160     char *pattern;
 161     real width, height;         /* Pattern is scaled to be repeated every width/height (in user coordinates) */
 162     real transform[6];
 163     /* Used during rasterization process */
 164     struct bdfchar *pat;
 165     real invtrans[6];
 166     int bminx, bminy, bwidth, bheight;  /* of the pattern at bdfchar scale */
 167 };
 168
 169 struct brush {
 170     uint32 col;
 171     float opacity;              /* number between [0,1], only for svg/pdf */
 172     struct pattern *pattern;    /* A pattern to be tiled */
 173     struct gradient *gradient;  /* A gradient fill */
 174 };
 175 #define WIDTH_INHERITED (-1)
 176 #define DASH_INHERITED  255     /* if the dashes[0]==0 && dashes[1]==DASH_INHERITED */
 177 #define DASH_MAX        8
 178 typedef unsigned char DashType;
 179 struct pen {
 180     struct brush brush;
 181     uint8 linejoin;
 182     uint8 linecap;
 183     float width;
 184     real trans[4];
 185     DashType dashes[DASH_MAX];
 186 };
 187
 188 struct spline;
 189 enum si_type { si_std, si_caligraphic, si_elipse, si_centerline };
 190 /* If you change this structure you may need to update MakeStrokeDlg */
 191 /*  and cvpalettes.c both contain statically initialized StrokeInfos */
 192 typedef struct strokeinfo {
 193     real radius;                        /* or major axis of pen */
 194     enum linejoin join;
 195     enum linecap cap;
 196     enum si_type stroke_type;
 197     unsigned int toobigwarn: 1;
 198     unsigned int removeinternal: 1;
 199     unsigned int removeexternal: 1;
 200     unsigned int removeoverlapifneeded: 1;
 201     unsigned int gottoobig: 1;
 202     unsigned int gottoobiglocal: 1;
 203     real penangle;
 204     real ratio;                         /* ratio of minor pen axis to major */
 205 /* For eplipse */
 206     real minorradius;
 207 /* For freehand tool */
 208     real radius2;
 209     int pressure1, pressure2;
 210 /* End freehand tool */
 211     bigreal c,s;
 212     real xoff[8], yoff[8];
 213     void *data;
 214     bigreal (*factor)(void *data,struct spline *spline,real t);
 215 } StrokeInfo;
 216
 217 enum overlap_type { over_remove, over_rmselected, over_intersect, over_intersel,
 218         over_exclude, over_findinter, over_fisel };
 219
 220 enum simpify_flags { sf_cleanup=-1, sf_normal=0, sf_ignoreslopes=1,
 221         sf_ignoreextremum=2, sf_smoothcurves=4, sf_choosehv=8,
 222         sf_forcelines=0x10, sf_nearlyhvlines=0x20,
 223         sf_mergelines=0x40, sf_setstart2extremum=0x80,
 224         sf_rmsingletonpoints=0x100 };
 225 struct simplifyinfo {
 226     int flags;
 227     bigreal err;
 228     bigreal tan_bounds;
 229     bigreal linefixup;
 230     bigreal linelenmax;         /* Don't simplify any straight lines longer than this */
 231     int set_as_default;
 232     int check_selected_contours;
 233 };
 234
 235 typedef struct italicinfo {
 236     double italic_angle;
 237     double xheight_percent;
 238     struct hsquash { double lsb_percent, stem_percent, counter_percent, rsb_percent; }
 239         lc, uc, neither;
 240     enum { srf_flat, srf_simpleslant, srf_complexslant } secondary_serif;
 241     /* |    | (flat)    |   | (simple)     |    | (complex) */
 242     /* |    |           |  /               |   /            */
 243     /* |    |           | /                |  /             */
 244     /* +----+           |/                 \ /              */
 245
 246     unsigned int transform_bottom_serifs: 1;
 247     unsigned int transform_top_xh_serifs: 1;    /* Those at x-height */
 248     unsigned int transform_top_as_serifs: 1;    /* Those at ascender-height */
 249     unsigned int transform_diagon_serifs: 1;    /* Those at baseline/xheight */
 250
 251     unsigned int a_from_d: 1;           /* replace the "a" glyph with the variant which looks like a "d" without an ascender */
 252   /* When I say "f" I also mean "f_f" ligature, "longs", cyrillic phi and other things shaped like "f" */
 253     unsigned int f_long_tail: 1;        /* Some Italic fonts have the "f" grow an extension of the main stem below the baseline */
 254     unsigned int f_rotate_top: 1;       /* Most Italic fonts take the top curve of the "f", rotate it 180 and attach to the bottom */
 255     unsigned int pq_deserif: 1;         /* Remove a serif from the descender of p or q and replace with a secondary serif as above */
 256
 257   /* Unsupported */
 258     /* e becomes rounder, cross bar slightly slanted */
 259     /* g closed counter at bottom */
 260     /* k closed counter at top */
 261     /* v-z diagonal stems become more curvatious */
 262
 263     unsigned int cyrl_phi: 1;           /* Gains an "f" like top, bottom treated like "f" */
 264     unsigned int cyrl_i: 1;             /* Turns into a latin u */
 265     unsigned int cyrl_pi: 1;            /* Turns into a latin n */
 266     unsigned int cyrl_te: 1;            /* Turns into a latin m */
 267     unsigned int cyrl_sha: 1;           /* Turns into a latin m rotated 180 */
 268     unsigned int cyrl_dje: 1;           /* Turns into a latin smallcaps T */
 269     unsigned int cyrl_dzhe: 1;          /* Turns into a latin u */
 270                     /* Is there a difference between dzhe and i? both look like u to me */
 271
 272   /* Unsupported */
 273     /* u432 curved B */
 274     /* u433 strange gamma */
 275     /* u434 normal delta */
 276     /* u436 */
 277     /* u43b lambda ? */
 278     /* u43c */
 279     /* u446 */
 280     /* u449 */
 281     /* u449 */
 282     /* u44a */
 283
 284 /* This half of the structure gets filled in later */
 285     double tan_ia;
 286     double x_height;
 287     double pq_depth;
 288     double ascender_height;
 289     double emsize;
 290     int order2;
 291     struct splinefont *sf;
 292     int layer;
 293     double serif_extent, serif_height;
 294     struct splinepoint *f_start, *f_end;                /* start has next pointing into the f head and up */
 295     struct splinepoint *ff_start1, *ff_end1, *ff_start2, *ff_end2;
 296     double f_height, ff_height;
 297 } ItalicInfo;
 298
 299 typedef struct bluedata {
 300     real xheight, xheighttop;           /* height of "x" and "o" (u,v,w,x,y,z) */
 301     real caph, caphtop;                 /* height of "I" and "O" */
 302     real base, basebelow;               /* bottom of "I" and "O" */
 303     real ascent;                        /* height of "l" */
 304     real descent;                       /* depth of "p" */
 305     real numh, numhtop;                 /* height of "7" and "8" */ /* numbers with ascenders */
 306     int bluecnt;                        /* If the private dica contains bluevalues... */
 307     real blues[12][2];                  /* 7 pairs from bluevalues, 5 from otherblues */
 308 } BlueData;
 309
 310 typedef struct bdffloat {
 311     int16 xmin,xmax,ymin,ymax;
 312     int16 bytes_per_line;
 313     unsigned int byte_data:1;
 314     uint8 depth;
 315     uint8 *bitmap;
 316 } BDFFloat;
 317
 318 /* OpenType does not document 'dflt' as a language, but we'll use it anyway. */
 319 /* (Adobe uses it too) we'll turn it into a default entry when we output it. */
 320 #define DEFAULT_LANG            CHR('d','f','l','t')
 321 /* The OpenType spec says in one place that the default script is 'dflt' and */
 322 /*  in another that it is 'DFLT'. 'DFLT' is correct */
 323 #define DEFAULT_SCRIPT          CHR('D','F','L','T')
 324 #define REQUIRED_FEATURE        CHR(' ','R','Q','D')
 325
 326 enum otlookup_type {
 327     ot_undef = 0,                       /* Not a lookup type */
 328     gsub_start         = 0x000,         /* Not a lookup type */
 329     gsub_single        = 0x001,
 330     gsub_multiple      = 0x002,
 331     gsub_alternate     = 0x003,
 332     gsub_ligature      = 0x004,
 333     gsub_context       = 0x005,
 334     gsub_contextchain  = 0x006,
 335      /* GSUB extension 7 */
 336     gsub_reversecchain = 0x008,
 337     /* ********************* */
 338     gpos_start         = 0x100,         /* Not a lookup type */
 339
 340     gpos_single        = 0x101,
 341     gpos_pair          = 0x102,
 342     gpos_cursive       = 0x103,
 343     gpos_mark2base     = 0x104,
 344     gpos_mark2ligature = 0x105,
 345     gpos_mark2mark     = 0x106,
 346     gpos_context       = 0x107,
 347     gpos_contextchain  = 0x108,
 348     /* GPOS extension 9 */
 349
 350     /* otlookup&0xff == lookup type for the appropriate table */
 351     /* otlookup>>8:     0=>GSUB, 1=>GPOS */
 352 };
 353
 354 enum otlookup_typemasks {
 355     gsub_single_mask        = 0x00001,
 356     gsub_multiple_mask      = 0x00002,
 357     gsub_alternate_mask     = 0x00004,
 358     gsub_ligature_mask      = 0x00008,
 359     gsub_context_mask       = 0x00010,
 360     gsub_contextchain_mask  = 0x00020,
 361     gsub_reversecchain_mask = 0x00040,
 362     /* ********************* */
 363     gpos_single_mask        = 0x00400,
 364     gpos_pair_mask          = 0x00800,
 365     gpos_cursive_mask       = 0x01000,
 366     gpos_mark2base_mask     = 0x02000,
 367     gpos_mark2ligature_mask = 0x04000,
 368     gpos_mark2mark_mask     = 0x08000,
 369     gpos_context_mask       = 0x10000,
 370     gpos_contextchain_mask  = 0x20000,
 371 };
 372
 373 #define MAX_LANG                4       /* If more than this we allocate more_langs in chunks of MAX_LANG */
 374 struct scriptlanglist {
 375     uint32 script;
 376     uint32 langs[MAX_LANG];
 377     uint32 *morelangs;
 378     int lang_cnt;
 379     struct scriptlanglist *next;
 380 };
 381
 382 extern struct opentype_feature_friendlynames {
 383     uint32 tag;
 384     char *tagstr;
 385     char *friendlyname;
 386     int masks;
 387 } friendlies[];
 388
 389 typedef struct featurescriptlanglist {
 390     uint32 featuretag;
 391     struct scriptlanglist *scripts;
 392     struct featurescriptlanglist *next;
 393 } FeatureScriptLangList;
 394
 395 enum pst_flags { pst_r2l=1, pst_ignorebaseglyphs=2, pst_ignoreligatures=4,
 396         pst_ignorecombiningmarks=8 };
 397
 398 typedef struct otlookup {
 399     struct otlookup *next;
 400     enum otlookup_type lookup_type;
 401     uint16 lookup_flags;
 402     char *lookup_name;
 403     FeatureScriptLangList *features;
 404     struct lookup_subtable {
 405         char *subtable_name;
 406         char *suffix;                   /* for gsub_single, used to find a default replacement */
 407         struct otlookup *lookup;
 408         unsigned int unused: 1;
 409         unsigned int per_glyph_pst_or_kern: 1;
 410         unsigned int anchor_classes: 1;
 411         unsigned int vertical_kerning: 1;
 412         unsigned int ticked: 1;
 413         struct kernclass *kc;
 414         struct generic_fpst *fpst;
 415         /* Each time an item is added to a lookup we must place it into a */
 416         /*  subtable. If it's a kerning class, fpst or state machine it has */
 417         /*  a subtable all to itself. If it's an anchor class it can share */
 418         /*  a subtable with other anchor classes (merge with). If it's a glyph */
 419         /*  PST it may share a subtable with other PSTs */
 420         /* Note items may only be placed in lookups in which they fit. Can't */
 421         /*  put kerning data in a gpos_single lookup, etc. */
 422         struct lookup_subtable *next;
 423         int32 subtable_offset;
 424         int32 *extra_subtables;
 425         /* If a kerning subtable has too much stuff in it, we are prepared to */
 426         /*  break it up into several smaller subtables, each of which has */
 427         /*  an offset in this list (extra-subtables[0]==subtable_offset) */
 428         /*  the list is terminated by an entry of -1 */
 429     } *subtables;
 430     unsigned int unused: 1;     /* No subtable is used (call SFFindUnusedLookups before examining) */
 431     unsigned int empty: 1;      /* No subtable is used, and no anchor classes are used */
 432     unsigned int store_in_afm: 1;       /* Used for ligatures, some get stored */
 433                                         /*  'liga' generally does, but 'frac' doesn't */
 434     unsigned int needs_extension: 1;    /* Used during opentype generation */
 435     unsigned int temporary_kern: 1;     /* Used when decomposing kerning classes into kern pairs for older formats */
 436     unsigned int def_lang_checked: 1;
 437     unsigned int def_lang_found: 1;
 438     unsigned int ticked: 1;
 439     int16 subcnt;               /* Actual number of subtables we will output */
 440                                 /* Some of our subtables may contain no data */
 441                                 /* Some may be too big and need to be broken up.*/
 442                                 /* So this field may be different than just counting the subtables */
 443     int lookup_index;           /* used during opentype generation */
 444     uint32 lookup_offset;
 445     uint32 lookup_length;
 446     char *tempname;
 447 } OTLookup;
 448
 449 #ifdef FONTFORGE_CONFIG_DEVICETABLES
 450 typedef struct devicetab {
 451     uint16 first_pixel_size, last_pixel_size;           /* A range of point sizes to which this table applies */
 452     int8 *corrections;                                  /* a set of pixel corrections, one for each point size */
 453 } DeviceTable;
 454
 455 typedef struct valdev {         /* Value records can have four associated device tables */
 456     DeviceTable xadjust;
 457     DeviceTable yadjust;
 458     DeviceTable xadv;
 459     DeviceTable yadv;
 460 } ValDevTab;
 461 #endif
 462
 463 enum anchorclass_type { act_mark, act_mkmk, act_curs, act_mklg };
 464 typedef struct anchorclass {
 465     char *name;                 /* in utf8 */
 466     struct lookup_subtable *subtable;
 467     uint8 type;         /* anchorclass_type */
 468     uint8 has_base;
 469     uint8 processed, has_mark, matches, ac_num;
 470     uint8 ticked;
 471     struct anchorclass *next;
 472 } AnchorClass;
 473
 474 enum anchor_type { at_mark, at_basechar, at_baselig, at_basemark, at_centry, at_cexit, at_max };
 475 typedef struct anchorpoint {
 476     AnchorClass *anchor;
 477     BasePoint me;
 478 #ifdef FONTFORGE_CONFIG_DEVICETABLES
 479     DeviceTable xadjust, yadjust;
 480 #endif
 481     unsigned int type: 4;
 482     unsigned int selected: 1;
 483     unsigned int ticked: 1;
 484     unsigned int has_ttf_pt: 1;
 485     uint16 ttf_pt_index;
 486     int16  lig_index;
 487     struct anchorpoint *next;
 488 } AnchorPoint;
 489
 490 typedef struct kernpair {
 491     struct lookup_subtable *subtable;
 492     struct splinechar *sc;
 493     int16 off;
 494     uint16 kcid;                        /* temporary value */
 495 #ifdef FONTFORGE_CONFIG_DEVICETABLES
 496     DeviceTable *adjust;                /* Only adjustment in one dimen, if more needed use pst */
 497 #endif
 498     struct kernpair *next;
 499 } KernPair;
 500
 501 typedef struct kernclass {
 502     int first_cnt, second_cnt;          /* Count of classes for first and second chars */
 503     char **firsts;                      /* list of a space seperated list of char names */
 504     char **seconds;                     /*  one entry for each class. Entry 0 is null */
 505                                         /*  and means everything not specified elsewhere */
 506     struct lookup_subtable *subtable;
 507     uint16 kcid;                        /* Temporary value, used for many things briefly */
 508     int16 *offsets;                     /* array of first_cnt*second_cnt entries */
 509 #ifdef FONTFORGE_CONFIG_DEVICETABLES
 510     DeviceTable *adjusts;               /* array of first_cnt*second_cnt entries */
 511 #endif
 512     struct kernclass *next;
 513 } KernClass;
 514
 515 enum possub_type { pst_null, pst_position, pst_pair,
 516         pst_substitution, pst_alternate,
 517         pst_multiple, pst_ligature,
 518         pst_lcaret /* must be pst_max-1, see charinfo.c*/,
 519         pst_max,
 520         /* These are not psts but are related so it's handly to have values for them */
 521         pst_kerning = pst_max, pst_vkerning, pst_anchors,
 522         /* And these are fpsts */
 523         pst_contextpos, pst_contextsub, pst_chainpos, pst_chainsub,
 524         pst_reversesub, fpst_max,
 525         /* And these are used to specify a kerning pair where the current */
 526         /*  char is the final glyph rather than the initial one */
 527         /* A kludge used when cutting and pasting features */
 528         pst_kernback, pst_vkernback
 529         };
 530
 531 struct vr {
 532     int16 xoff, yoff, h_adv_off, v_adv_off;
 533 #ifdef FONTFORGE_CONFIG_DEVICETABLES
 534     ValDevTab *adjust;
 535 #endif
 536 };
 537
 538 typedef struct generic_pst {
 539     unsigned int ticked: 1;
 540     unsigned int temporary: 1;          /* Used in afm ligature closure */
 541     /* enum possub_type*/ uint8 type;
 542     struct lookup_subtable *subtable;
 543     struct generic_pst *next;
 544     union {
 545         struct vr pos;
 546         struct { char *paired; struct vr *vr; } pair;
 547         struct { char *variant; } subs;
 548         struct { char *components; } mult, alt;
 549         struct { char *components; struct splinechar *lig; } lig;
 550         struct { int16 *carets; int cnt; } lcaret;      /* Ligature caret positions */
 551     } u;
 552 } PST;
 553
 554 typedef struct liglist {
 555     PST *lig;
 556     struct splinechar *first;           /* First component */
 557     struct splinecharlist *components;  /* Other than the first */
 558     struct liglist *next;
 559     int ccnt;                           /* Component count. (includes first component) */
 560 } LigList;
 561
 562 enum fpossub_format { pst_glyphs, pst_class, pst_coverage,
 563                     pst_reversecoverage, pst_formatmax };
 564
 565 typedef struct generic_fpst {
 566     uint16 /*enum sfpossub_type*/ type;
 567     uint16 /*enum fpossub_format*/ format;
 568     struct lookup_subtable *subtable;
 569     struct generic_fpst *next;
 570     uint16 nccnt, bccnt, fccnt;
 571     uint16 rule_cnt;
 572     char **nclass, **bclass, **fclass;
 573     struct fpst_rule {
 574         union {
 575             struct fpg { char *names, *back, *fore; } glyph;
 576             struct fpc { int ncnt, bcnt, fcnt; uint16 *nclasses, *bclasses, *fclasses, *allclasses; } class;
 577             struct fpv { int ncnt, bcnt, fcnt; char **ncovers, **bcovers, **fcovers; } coverage;
 578             struct fpr { int always1, bcnt, fcnt; char **ncovers, **bcovers, **fcovers; char *replacements; } rcoverage;
 579         } u;
 580         int lookup_cnt;
 581         struct seqlookup {
 582             int seq;
 583             struct otlookup *lookup;
 584         } *lookups;
 585     } *rules;
 586     uint8 ticked;
 587     uint8 effectively_by_glyphs;
 588 } FPST;
 589
 590 struct opentype_str {
 591     struct splinechar *sc;
 592     struct vr vr;               /* Scaled and rounded gpos modifications (device table info included in xoff, etc. not in adjusts) */
 593     struct kernpair *kp;
 594     struct kernclass *kc;
 595     int16 advance_width;        /* Basic advance, modifications in vr, scaled and rounded */
 596     int16 kc_index;
 597     int16 lig_pos;              /* when skipping marks to form a ligature keep track of what ligature element a mark was attached to */
 598     int16 context_pos;          /* When doing a contextual match remember which glyphs are used, and where in the match they occur. Skipped glyphs have -1 */
 599     int32 orig_index;
 600     void *fl;
 601     unsigned int line_break_after: 1;
 602     unsigned int r2l: 1;
 603     int16 bsln_off;
 604 };
 605
 606 /* Wow, the GPOS 'size' feature stores a string in the name table just as mac */
 607 /*  features do */
 608 struct otfname {
 609     struct otfname *next;
 610     uint16 lang;        /* windows language code */
 611     char *name;         /* utf8 */
 612 };
 613
 614 typedef struct undoes {
 615     struct undoes *next;
 616     enum undotype { ut_none=0, ut_state, ut_tstate, ut_statehint, ut_statename,
 617             ut_statelookup,
 618             ut_anchors,
 619             ut_width, ut_vwidth, ut_lbearing, ut_rbearing, ut_possub,
 620             ut_hints, ut_bitmap, ut_bitmapsel, ut_composit, ut_multiple, ut_layers,
 621             ut_noop } undotype;
 622     unsigned int was_modified: 1;
 623     unsigned int was_order2: 1;
 624     union {
 625         struct {
 626             int16 width, vwidth;
 627             int16 lbearingchange;
 628             int unicodeenc;                     /* only for ut_statename */
 629             char *charname;                     /* only for ut_statename */
 630             char *comment;                      /* in utf8 */
 631             PST *possub;                        /* only for ut_statename */
 632             struct splinepointlist *splines;
 633             struct refchar *refs;
 634
 635             struct imagelist *images;
 636             void *hints;                        /* ut_statehint, ut_statename */
 637             uint8 *instrs;
 638             int instrs_len;
 639             AnchorPoint *anchor;
 640 #ifdef FONTFORGE_CONFIG_TYPE3
 641             struct brush fill_brush;
 642             struct pen stroke_pen;
 643             unsigned int dofill: 1;
 644             unsigned int dostroke: 1;
 645             unsigned int fillfirst: 1;
 646 #endif
 647         } state;
 648         int width;      /* used by both ut_width and ut_vwidth */
 649         int lbearing;   /* used by ut_lbearing */
 650         int rbearing;   /* used by ut_rbearing */
 651         struct {
 652             int16 width;        /* width should be controled by postscript, but people don't like that */
 653             int16 xmin,xmax,ymin,ymax;
 654             int16 bytes_per_line;
 655             int16 pixelsize;
 656             int16 depth;
 657             uint8 *bitmap;
 658             BDFFloat *selection;
 659         } bmpstate;
 660         struct {                /* copy contains an outline state and a set of bitmap states */
 661             struct undoes *state;
 662             struct undoes *bitmaps;
 663         } composit;
 664         struct {
 665             struct undoes *mult; /* copy contains several sub copies (composits, or states or widths or...) */
 666                 /* Also used for ut_layers, each sub copy is a state (first is ly_fore, next ly_fore+1...) */
 667         } multiple;
 668         struct {
 669             enum possub_type pst;
 670             char **data;                /* First 4 bytes is tag, then space then data */
 671             struct undoes *more_pst;
 672             short cnt,max;              /* Not always set */
 673         } possub;
 674         uint8 *bitmap;
 675     } u;
 676     struct splinefont *copied_from;
 677 } Undoes;
 678
 679 typedef struct bdfchar {
 680     struct splinechar *sc;
 681     int16 xmin,xmax,ymin,ymax;
 682     int16 width;
 683     int16 bytes_per_line;
 684     uint8 *bitmap;
 685     int orig_pos;
 686     struct bitmapview *views;
 687     Undoes *undoes;
 688     Undoes *redoes;
 689     unsigned int changed: 1;
 690     unsigned int byte_data: 1;          /* for anti-aliased chars entries are grey-scale bytes not bw bits */
 691     unsigned int widthgroup: 1;         /* for ttf bitmap output */
 692     unsigned int isreference: 1;        /* for ttf bitmap input, */
 693     unsigned int ticked: 1;
 694     uint8 depth;                        /* for ttf bitmap output */
 695     uint16 vwidth;
 696     BDFFloat *selection;
 697 } BDFChar;
 698
 699 typedef struct enc {
 700     char *enc_name;
 701     int char_cnt;       /* Size of the next two arrays */
 702     int32 *unicode;     /* unicode value for each encoding point */
 703     char **psnames;     /* optional postscript name for each encoding point */
 704     struct enc *next;
 705     unsigned int builtin: 1;
 706     unsigned int hidden: 1;
 707     unsigned int only_1byte: 1;
 708     unsigned int has_1byte: 1;
 709     unsigned int has_2byte: 1;
 710     unsigned int is_unicodebmp: 1;
 711     unsigned int is_unicodefull: 1;
 712     unsigned int is_custom: 1;
 713     unsigned int is_original: 1;
 714     unsigned int is_compact: 1;
 715     unsigned int is_japanese: 1;
 716     unsigned int is_korean: 1;
 717     unsigned int is_tradchinese: 1;
 718     unsigned int is_simplechinese: 1;
 719     char iso_2022_escape[8];
 720     int iso_2022_escape_len;
 721     int low_page, high_page;
 722     char *iconv_name;   /* For compatibility to old versions we might use a different name from that used by iconv. */
 723     iconv_t *tounicode;
 724     iconv_t *fromunicode;
 725     int (*tounicode_func)(int);
 726     int (*fromunicode_func)(int);
 727     unsigned int is_temporary: 1;       /* freed when the map gets freed */
 728     int char_max;                       /* Used by temporary encodings */
 729 } Encoding;
 730
 731 typedef struct namelist {
 732     struct namelist *basedon;
 733     char *title;
 734     const char ***unicode[17];
 735     struct namelist *next;
 736     struct renames { char *from; char *to; } *renames;
 737     int uses_unicode;
 738     char *a_utf8_name;
 739 } NameList;
 740
 741 enum uni_interp { ui_unset= -1, ui_none, ui_adobe, ui_greek, ui_japanese,
 742         ui_trad_chinese, ui_simp_chinese, ui_korean, ui_ams };
 743
 744 struct remap { uint32 firstenc, lastenc; int32 infont; };
 745
 746 typedef struct encmap {         /* A per-font map of encoding to glyph id */
 747     int32 *map;                 /* Map from encoding to glyphid */
 748     int32 *backmap;             /* Map from glyphid to encoding */
 749     int enccount;               /* used size of the map array */
 750                                 /*  strictly speaking this might include */
 751                                 /*  glyphs that are not encoded, but which */
 752                                 /*  are displayed after the proper encoding */
 753     int encmax;                 /* allocated size of the map array */
 754     int backmax;                /* allocated size of the backmap array */
 755     struct remap *remap;
 756     Encoding *enc;
 757     unsigned int ticked: 1;
 758 } EncMap;
 759
 760 enum property_type { prt_string, prt_atom, prt_int, prt_uint, prt_property=0x10 };
 761
 762 typedef struct bdfprops {
 763     char *name;         /* These include both properties (like SLANT) and non-properties (like FONT) */
 764     int type;
 765     union {
 766         char *str;
 767         char *atom;
 768         int val;
 769     } u;
 770 } BDFProperties;
 771
 772 typedef struct bdffont {
 773     struct splinefont *sf;
 774     int glyphcnt, glyphmax,glyphmin;    /* used & allocated sizes of glyphs array */
 775     BDFChar **glyphs;           /* an array of charcnt entries */
 776     int16 pixelsize;
 777     int16 ascent, descent;
 778     int16 layer;                /* for piecemeal fonts */
 779     unsigned int piecemeal: 1;
 780     unsigned int bbsized: 1;
 781     unsigned int ticked: 1;
 782     unsigned int unhinted_freetype: 1;
 783     struct bdffont *next;
 784     struct clut *clut;
 785     char *foundry;
 786     int res;
 787     void *freetype_context;
 788     uint16 truesize;            /* for bbsized fonts */
 789     int16 prop_cnt;
 790     int16 prop_max;             /* only used within bdfinfo dlg */
 791     BDFProperties *props;
 792 } BDFFont;
 793
 794 #define HntMax  96              /* PS says at most 96 hints */
 795 typedef uint8 HintMask[HntMax/8];
 796
 797 enum pointtype { pt_curve, pt_corner, pt_tangent, pt_hvcurve };
 798 typedef struct splinepoint {
 799     BasePoint me;
 800     BasePoint nextcp;           /* control point */
 801     BasePoint prevcp;           /* control point */
 802     unsigned int nonextcp:1;
 803     unsigned int noprevcp:1;
 804     unsigned int nextcpdef:1;
 805     unsigned int prevcpdef:1;
 806     unsigned int selected:1;    /* for UI */
 807     unsigned int pointtype:2;
 808     unsigned int isintersection: 1;
 809     unsigned int flexy: 1;
 810     unsigned int flexx: 1;
 811     unsigned int roundx: 1;     /* For true type hinting */
 812     unsigned int roundy: 1;     /* For true type hinting */
 813     unsigned int dontinterpolate: 1;    /* in ttf, don't imply point by interpolating between cps */
 814     unsigned int ticked: 1;
 815     unsigned int watched: 1;
 816         /* 1 bits left... */
 817     uint16 ptindex;             /* Temporary value used by metafont routine */
 818     uint16 ttfindex;            /* Truetype point index */
 819         /* Special values 0xffff => point implied by averaging control points */
 820         /*                0xfffe => point created with no real number yet */
 821         /* (or perhaps point in context where no number is possible as in a glyph with points & refs) */
 822     uint16 nextcpindex;         /* Truetype point index */
 823     struct spline *next;
 824     struct spline *prev;
 825     HintMask *hintmask;
 826 } SplinePoint;
 827
 828 typedef struct linelist {
 829     IPoint here;
 830     struct linelist *next;
 831     /* The first two fields are constant for the linelist, the next ones */
 832     /*  refer to a particular screen. If some portion of the line from */
 833     /*  this point to the next one is on the screen then set cvli_onscreen */
 834     /*  if this point needs to be clipped then set cvli_clipped */
 835     /*  asend and asstart are the actual screen locations where this point */
 836     /*  intersects the clip edge. */
 837     enum { cvli_onscreen=0x1, cvli_clipped=0x2 } flags;
 838     IPoint asend, asstart;
 839 } LineList;
 840
 841 typedef struct linearapprox {
 842     real scale;
 843     unsigned int oneline: 1;
 844     unsigned int onepoint: 1;
 845     unsigned int any: 1;                /* refers to a particular screen */
 846     struct linelist *lines;
 847     struct linearapprox *next;
 848 } LinearApprox;
 849
 850 typedef struct spline1d {
 851     real a, b, c, d;
 852 } Spline1D;
 853
 854 typedef struct spline {
 855     unsigned int islinear: 1;           /* No control points */
 856     unsigned int isquadratic: 1;        /* probably read in from ttf */
 857     unsigned int isticked: 1;
 858     unsigned int isneeded: 1;           /* Used in remove overlap */
 859     unsigned int isunneeded: 1;         /* Used in remove overlap */
 860     unsigned int exclude: 1;            /* Used in remove overlap varient: exclude */
 861     unsigned int ishorvert: 1;
 862     unsigned int knowncurved: 1;        /* We know that it curves */
 863     unsigned int knownlinear: 1;        /* it might have control points, but still traces out a line */
 864         /* If neither knownlinear nor curved then we haven't checked */
 865     unsigned int order2: 1;             /* It's a bezier curve with only one cp */
 866     unsigned int touched: 1;
 867     unsigned int leftedge: 1;
 868     unsigned int rightedge: 1;
 869     unsigned int acceptableextrema: 1;  /* This spline has extrema, but we don't care */
 870     SplinePoint *from, *to;
 871     Spline1D splines[2];                /* splines[0] is the x spline, splines[1] is y */
 872     struct linearapprox *approx;
 873     /* Posible optimizations:
 874         Precalculate bounding box
 875         Precalculate min/max/ points of inflection
 876     */
 877 } Spline;
 878
 879
 880 typedef struct splinepointlist {
 881     SplinePoint *first, *last;
 882     struct splinepointlist *next;
 883     uint8 ticked;
 884     uint8 beziers_need_optimizer;       /* If the spiros have changed in spiro mode, then reverting to bezier mode might, someday, run a simplifier */
 885     uint8 is_clip_path;                 /* In type3/svg fonts */
 886     char *contour_name;
 887 } SplinePointList, SplineSet;
 888
 889 typedef struct imagelist {
 890     struct gimage *image;
 891     real xoff, yoff;            /* position in character space of upper left corner of image */
 892     real xscale, yscale;        /* scale to convert one pixel of image to one unit of character space */
 893     DBounds bb;
 894     struct imagelist *next;
 895     unsigned int selected: 1;
 896 } ImageList;
 897
 898 typedef struct refchar {
 899     unsigned int checked: 1;
 900     unsigned int selected: 1;
 901     unsigned int point_match: 1;        /* match_pt* are point indexes */
 902                                         /*  and need to be converted to a */
 903                                         /*  translation after truetype readin */
 904     unsigned int encoded: 1;            /* orig_pos is actually an encoded value, used for old sfd files */
 905     unsigned int justtranslated: 1;     /* The transformation matrix specifies a translation (or is identity) */
 906     unsigned int use_my_metrics: 1;     /* Retain the ttf "use_my_metrics" info. */
 907         /* important for glyphs with instructions which change the width used */
 908         /* inside composites */
 909     unsigned int round_translation_to_grid: 1;  /* Retain the ttf "round_to_grid" info. */
 910     unsigned int point_match_out_of_date: 1;    /* Someone has edited a base glyph */
 911     int16 adobe_enc;
 912     int orig_pos;
 913     int unicode_enc;            /* used by paste */
 914     real transform[6];          /* transformation matrix (first 2 rows of a 3x3 matrix, missing row is 0,0,1) */
 915     struct reflayer {
 916         unsigned int background: 1;
 917         unsigned int order2: 1;
 918         unsigned int anyflexes: 1;
 919 #ifdef FONTFORGE_CONFIG_TYPE3
 920         unsigned int dofill: 1;
 921         unsigned int dostroke: 1;
 922         unsigned int fillfirst: 1;
 923         struct brush fill_brush;
 924         struct pen stroke_pen;
 925 #endif
 926         SplinePointList *splines;
 927         ImageList *images;                      /* Only in background or type3 layer(s) */
 928     } *layers;
 929     int layer_cnt;
 930     struct refchar *next;
 931     DBounds bb;
 932     struct splinechar *sc;
 933     BasePoint top;
 934     uint16 match_pt_base, match_pt_ref;
 935 } RefChar;
 936
 937 /* Some stems may appear, disappear, reapear several times */
 938 /* Serif stems on I which appear at 0, disappear, reappear at top */
 939 /* Or the major vertical stems on H which disappear at the cross bar */
 940 typedef struct hintinstance {
 941     real begin;                 /* location in the non-major direction*/
 942     real end;                           /* width/height in non-major direction*/
 943     unsigned int closed: 1;
 944     short int counternumber;
 945     struct hintinstance *next;
 946 } HintInstance;
 947
 948 enum hinttypes { ht_unspecified=0, ht_h, ht_v, ht_d };
 949 typedef real _MMArray[2][MmMax];
 950
 951 typedef struct steminfo {
 952     struct steminfo *next;
 953     unsigned int hinttype: 2;   /* Only used by undoes */
 954     unsigned int ghost: 1;      /* this is a ghost stem hint. As such truetype should ignore it, type2 output should negate it, and type1 should use as is */
 955                     /* stored width will be either 20 or 21 */
 956                     /* Type2 says: -20 is "width" of top edge, -21 is "width" of bottom edge, type1 accepts either */
 957     unsigned int haspointleft:1;
 958     unsigned int haspointright:1;
 959     unsigned int hasconflicts:1;/* Does this stem have conflicts within its cluster? */
 960     unsigned int used: 1;       /* Temporary for counter hints or hint substitution */
 961     unsigned int tobeused: 1;   /* Temporary for counter hints or hint substitution */
 962     unsigned int active: 1;     /* Currently active hint in Review Hints dlg */
 963                                 /*  displayed differently in char display */
 964     unsigned int enddone: 1;    /* Used by ttf instructing, indicates a prev */
 965                                 /*  hint had the same end as this one (so */
 966                                 /*  the points on the end line have been */
 967                                 /*  instructed already */
 968     unsigned int startdone: 1;  /* Used by ttf instructing */
 969     /*unsigned int backwards: 1;*/      /* If we think this hint is better done with a negative width */
 970     unsigned int reordered: 1;  /* In AutoHinting. Means we changed the start of the hint, need to test for out of order */
 971     unsigned int pendingpt: 1;  /* A pending stem creation, not a true stem */
 972     unsigned int linearedges: 1;/* If we have a nice rectangle then we aren't */
 973                                 /*  interested in the orientation which is */
 974                                 /*  wider than long */
 975     int16 hintnumber;           /* when dumping out hintmasks we need to know */
 976                                 /*  what bit to set for this hint */
 977     union {
 978         int mask;               /* Mask of all references that use this hint */
 979                                 /*  in type2 output */
 980         _MMArray *unblended /*[2][MmMax]*/;     /* Used when reading in type1 mm hints */
 981     } u;
 982     real start;                 /* location at which the stem starts */
 983     real width;                 /* or height */
 984     HintInstance *where;        /* location(s) in the other coord */
 985 } StemInfo;
 986
 987 typedef struct dsteminfo {
 988     struct dsteminfo *next;     /* First two fields match those in steminfo */
 989     unsigned int hinttype: 2;   /* Only used by undoes */
 990     unsigned int used: 1;       /* used only by tottf.c:gendinstrs, metafont.c to mark a hint that has been dealt with */
 991     BasePoint left, right, unit;
 992     HintInstance *where;        /* location(s) along the unit vector */
 993 } DStemInfo;
 994
 995 typedef struct minimumdistance {
 996     /* If either point is NULL it will be assumed to mean either the origin */
 997     /*  or the width point (depending on which is closer). This allows user */
 998     /*  to control metrics... */
 999     SplinePoint *sp1, *sp2;
1000     unsigned int x: 1;
1001     unsigned int done: 1;
1002     struct minimumdistance *next;
1003 } MinimumDistance;
1004
1005 typedef struct layer /* : reflayer */{
1006     unsigned int background: 1;
1007     unsigned int order2: 1;
1008     unsigned int anyflexes: 1;
1009 #ifdef FONTFORGE_CONFIG_TYPE3
1010     unsigned int dofill: 1;
1011     unsigned int dostroke: 1;
1012     unsigned int fillfirst: 1;
1013     struct brush fill_brush;
1014     struct pen stroke_pen;
1015 #endif
1016     SplinePointList *splines;
1017     ImageList *images;                  /* Only in background or type3 layer(s) */
1018     RefChar *refs;                      /* Only in foreground layer(s) */
1019     Undoes *undoes;
1020     Undoes *redoes;
1021     uint32 validation_state;
1022     uint32 old_vs;
1023 } Layer;
1024
1025 enum layer_type { ly_all=-2, ly_grid= -1, ly_back=0, ly_fore=1,
1026     /* Possibly other foreground layers for type3 things */
1027     /* Possibly other background layers for normal fonts */
1028         ly_none = -3
1029     };
1030
1031 /* For the 'MATH' table (and for TeX) */
1032 struct glyphvariants {
1033     char *variants;     /* Space separated list of glyph names */
1034 /* Glyph assembly */
1035     int16 italic_correction;    /* Of the composed glyph */
1036 #ifdef FONTFORGE_CONFIG_DEVICETABLES
1037     DeviceTable *italic_adjusts;
1038 #endif
1039     int part_cnt;
1040     struct gv_part {
1041         char *component;
1042         unsigned int is_extender: 1;    /* This component may be skipped or repeated */
1043         uint16 startConnectorLength;
1044         uint16 endConnectorLength;
1045         uint16 fullAdvance;
1046     } *parts;
1047 };
1048
1049 /* For the 'MATH' table */
1050 struct mathkernvertex {
1051     int cnt;            /* There is one more kern entry than height entry */
1052             /* So the last mkd should have its height ignored */
1053             /* The MATH table stores the height count, I think the kern count */
1054             /*  is more useful. They differ by 1 */
1055     struct mathkerndata {
1056         int16 height,kern;
1057 #ifdef FONTFORGE_CONFIG_DEVICETABLES
1058         DeviceTable *height_adjusts;
1059         DeviceTable *kern_adjusts;
1060 #endif
1061     } *mkd;
1062 };
1063
1064 struct mathkern {
1065     struct mathkernvertex top_right;
1066     struct mathkernvertex top_left;
1067     struct mathkernvertex bottom_right;
1068     struct mathkernvertex bottom_left;
1069 };
1070
1071 enum privatedict_state {
1072     pds_odd        = 0x1,       /* Odd number of entries */
1073     pds_outoforder = 0x2,       /* Bluevalues should be listed in order */
1074     pds_toomany    = 0x4,       /* arrays are of limited sizes */
1075     pds_tooclose   = 0x8,       /* adjacent zones must not be within 2*bluefuzz+1 (or 3, if bluefuzz omitted) */
1076     pds_notintegral= 0x10,      /* Must be integers */
1077     pds_toobig     = 0x20,      /* within pair difference have some relation to BlueScale but the docs make no sense to me */
1078     pds_shift      = 8,         /* BlueValues/OtherBlues, unshifted, FamilyBlues/FamilyOtherBlues shifted once */
1079
1080     pds_missingblue  = 0x010000,
1081     pds_badbluefuzz  = 0x020000,
1082     pds_badbluescale = 0x040000,
1083     pds_badstdhw     = 0x080000,
1084     pds_badstdvw     = 0x100000,
1085     pds_badstemsnaph = 0x200000,
1086     pds_badstemsnapv = 0x400000,
1087     pds_stemsnapnostdh = 0x0800000,
1088     pds_stemsnapnostdv = 0x1000000,
1089     pds_badblueshift   = 0x2000000
1090
1091 };
1092
1093 enum validation_state { vs_unknown = 0,
1094         vs_known=0x01,                          /* It has been validated */
1095         vs_opencontour=0x02,
1096         vs_selfintersects=0x04,
1097         vs_wrongdirection=0x08,
1098         vs_flippedreferences=0x10,              /* special case of wrong direction */
1099         vs_missingextrema=0x20,
1100         vs_missingglyphnameingsub=0x40,
1101             /* Next few are postscript only */
1102         vs_toomanypoints=0x80,
1103         vs_toomanyhints=0x100,
1104         vs_badglyphname=0x200,
1105             /* Next few are only for fontlint */
1106             /* These are relative to maxp values which ff would fix on generating a font */
1107         vs_maxp_toomanypoints    =0x400,
1108         vs_maxp_toomanypaths     =0x800,
1109         vs_maxp_toomanycomppoints=0x1000,
1110         vs_maxp_toomanycomppaths =0x2000,
1111         vs_maxp_instrtoolong     =0x4000,
1112         vs_maxp_toomanyrefs      =0x8000,
1113         vs_maxp_refstoodeep      =0x10000,
1114         /* vs_maxp_prepfpgmtoolong=0x20000, */  /* I think I was wrong about this "error" */
1115             /* Oops, we need another one, two, for the glyphs */
1116         vs_pointstoofarapart    = 0x40000,
1117         vs_nonintegral          = 0x80000,      /* This will never be interesting in a real font, but might be in an sfd file */
1118         vs_missinganchor        = 0x100000,
1119         vs_dupname              = 0x200000,
1120         vs_dupunicode           = 0x400000,
1121
1122         vs_last = vs_dupunicode,
1123         vs_maskps = 0x3fe | vs_pointstoofarapart | vs_missinganchor | vs_dupname | vs_dupunicode,
1124         vs_maskcid = 0x1fe | vs_pointstoofarapart | vs_missinganchor | vs_dupname,
1125         vs_maskttf = 0x7e | vs_pointstoofarapart | vs_nonintegral | vs_missinganchor | vs_dupunicode,
1126         vs_maskfindproblems = 0x1be | vs_pointstoofarapart | vs_nonintegral | vs_missinganchor
1127         };
1128
1129 typedef struct splinechar {
1130     char *name;
1131     int unicodeenc;
1132     int orig_pos;               /* Original position in the glyph list */
1133     int16 width, vwidth, tsb;
1134     int16 xmin, ymin, xmax, ymax;
1135     int16 lsidebearing;         /* only used when reading in a type1 font */
1136                                 /*  Or an otf font where it is the subr number of a refered character */
1137                                 /*  or a ttf font without bit 1 of head.flags set */
1138                                 /*  or (once upon a time, but no longer) a ttf font with vert metrics where it is the ymax value when we had a font-wide vertical offset */
1139                                 /* Always a temporary value */
1140     int ttf_glyph;              /* only used when writing out a ttf or otf font */
1141     Layer *layers;              /* layer[0] is background, layer[1] foreground */
1142         /* In type3 fonts 2-n are also foreground, otherwise also background */
1143     int layer_cnt;
1144     StemInfo *hstem;            /* hstem hints have a vertical offset but run horizontally */
1145     StemInfo *vstem;            /* vstem hints have a horizontal offset but run vertically */
1146     DStemInfo *dstem;           /* diagonal hints for ttf */
1147     MinimumDistance *md;
1148     struct charviewbase *views;
1149     struct charinfo *charinfo;
1150     struct splinefont *parent;
1151     unsigned int changed: 1;
1152     unsigned int changedsincelasthinted: 1;
1153     unsigned int manualhints: 1;
1154     unsigned int ticked: 1;     /* For reference character processing */
1155                                 /* And fontview processing */
1156     unsigned int changed_since_autosave: 1;
1157     unsigned int widthset: 1;   /* needed so an emspace char doesn't disappear */
1158     unsigned int vconflicts: 1; /* Any hint overlaps in the vstem list? */
1159     unsigned int hconflicts: 1; /* Any hint overlaps in the hstem list? */
1160     unsigned int searcherdummy: 1;
1161     unsigned int changed_since_search: 1;
1162     unsigned int wasopen: 1;
1163     unsigned int namechanged: 1;
1164     unsigned int blended: 1;    /* An MM blended character */
1165     unsigned int ticked2: 1;
1166     unsigned int glyph_class: 3; /* 0=> fontforge determines class automagically, else one more than the class value in gdef so 2+1=>lig, 3+1=>mark */
1167     unsigned int numberpointsbackards: 1;
1168     unsigned int instructions_out_of_date: 1;
1169     unsigned int complained_about_ptnums: 1;
1170     unsigned int vs_open: 1;
1171     unsigned int unlink_rm_ovrlp_save_undo: 1;
1172     unsigned int inspiro: 1;
1173     unsigned int lig_caret_cnt_fixed: 1;
1174     /* 6 bits left (one more if we ignore compositionunit below) */
1175 #if HANYANG
1176     unsigned int compositionunit: 1;
1177     int16 jamo, varient;
1178 #endif
1179     struct splinecharlist { struct splinechar *sc; struct splinecharlist *next;} *dependents;
1180             /* The dependents list is a list of all characters which refenence*/
1181             /*  the current character directly */
1182     KernPair *kerns;
1183     KernPair *vkerns;
1184     PST *possub;                /* If we are a ligature then this tells us what */
1185                                 /*  It may also contain a bunch of other stuff now */
1186     LigList *ligofme;           /* If this is the first character of a ligature then this gives us the list of possible ones */
1187                                 /*  this field must be regenerated before the font is saved */
1188     char *comment;                      /* in utf8 */
1189     uint32 /*Color*/ color;
1190     AnchorPoint *anchor;
1191     uint8 *ttf_instrs;
1192     int16 ttf_instrs_len;
1193     int16 countermask_cnt;
1194     HintMask *countermasks;
1195     struct altuni { struct altuni *next; int unienc, vs, fid; } *altuni;
1196         /* vs is the "variation selector" a unicode codepoint which modifieds */
1197         /*  the code point before it. If vs is -1 then unienc is just an */
1198         /*  alternate encoding (greek Alpha and latin A), but if vs is one */
1199         /*  of unicode's variation selectors then this glyph is somehow a */
1200         /*  variant shape. The specifics depend on the selector and script */
1201         /*  fid is currently unused, but may, someday, be used to do ttcs */
1202         /* NOTE: GlyphInfo displays vs==-1 as vs==0, and fixes things up */
1203 /* for TeX */
1204     int16 tex_height, tex_depth;
1205 /* TeX also uses italic_correction and glyph variants below */
1206 /* For the 'MATH' table (and for TeX) */
1207     unsigned int is_extended_shape: 1;
1208     int16 italic_correction;
1209     int16 top_accent_horiz;             /* MATH table allows you to specific a*/
1210                 /* horizontal anchor for accent attachments, vertical */
1211                 /* positioning is done elsewhere */
1212 #ifdef FONTFORGE_CONFIG_DEVICETABLES
1213     DeviceTable *italic_adjusts;
1214     DeviceTable *top_accent_adjusts;
1215 #endif
1216     struct glyphvariants *vert_variants;
1217     struct glyphvariants *horiz_variants;
1218     struct mathkern *mathkern;
1219 /* End of MATH/TeX fields */
1220 #ifndef _NO_PYTHON
1221     void *python_sc_object;
1222     void *python_temporary;
1223 #endif
1224     void *python_persistent;            /* If python this will hold a python object, if not python this will hold a string containing a pickled object. We do nothing with it (if not python) except save it back out unchanged */
1225 #ifdef FONTFORGE_CONFIG_TYPE3
1226         /* If the glyph is used as a tile pattern, then the next two values */
1227         /*  determine the amount of white space around the tile. If extra is*/
1228         /*  non-zero then we add it to the max components of the bbox and   */
1229         /*  subtract it from the min components. If extra is 0 then tile_bounds*/
1230         /*  will be used. If tile_bounds is all zeros then the glyph's bbox */
1231         /*  will be used. */
1232     real tile_margin;                   /* If the glyph is used as a tile */
1233     DBounds tile_bounds;
1234 #endif
1235 } SplineChar;
1236
1237 #define TEX_UNDEF 0x7fff
1238
1239 enum ttfnames { ttf_copyright=0, ttf_family, ttf_subfamily, ttf_uniqueid,
1240     ttf_fullname, ttf_version, ttf_postscriptname, ttf_trademark,
1241     ttf_manufacturer, ttf_designer, ttf_descriptor, ttf_venderurl,
1242     ttf_designerurl, ttf_license, ttf_licenseurl, ttf_idontknow/*reserved*/,
1243     ttf_preffamilyname, ttf_prefmodifiers, ttf_compatfull, ttf_sampletext,
1244     ttf_cidfindfontname, ttf_wwsfamily, ttf_wwssubfamily, ttf_namemax };
1245 struct ttflangname {
1246     int lang;
1247     char *names[ttf_namemax];                   /* in utf8 */
1248     int frommac[(ttf_namemax+31)/32];           /* Used when parsing the 'name' table */
1249     struct ttflangname *next;
1250 };
1251
1252 #ifdef FONTFORGE_CONFIG_DEVICETABLES
1253 struct MATH {
1254 /* From the MATH Constants subtable (constants for positioning glyphs. Not PI)*/
1255     int16 ScriptPercentScaleDown;
1256     int16 ScriptScriptPercentScaleDown;
1257     uint16 DelimitedSubFormulaMinHeight;
1258     uint16 DisplayOperatorMinHeight;
1259     int16 MathLeading;
1260     DeviceTable *MathLeading_adjust;
1261     int16 AxisHeight;
1262     DeviceTable *AxisHeight_adjust;
1263     int16 AccentBaseHeight;
1264     DeviceTable *AccentBaseHeight_adjust;
1265     int16 FlattenedAccentBaseHeight;
1266     DeviceTable *FlattenedAccentBaseHeight_adjust;
1267     int16 SubscriptShiftDown;
1268     DeviceTable *SubscriptShiftDown_adjust;
1269     int16 SubscriptTopMax;
1270     DeviceTable *SubscriptTopMax_adjust;
1271     int16 SubscriptBaselineDropMin;
1272     DeviceTable *SubscriptBaselineDropMin_adjust;
1273     int16 SuperscriptShiftUp;
1274     DeviceTable *SuperscriptShiftUp_adjust;
1275     int16 SuperscriptShiftUpCramped;
1276     DeviceTable *SuperscriptShiftUpCramped_adjust;
1277     int16 SuperscriptBottomMin;
1278     DeviceTable *SuperscriptBottomMin_adjust;
1279     int16 SuperscriptBaselineDropMax;
1280     DeviceTable *SuperscriptBaselineDropMax_adjust;
1281     int16 SubSuperscriptGapMin;
1282     DeviceTable *SubSuperscriptGapMin_adjust;
1283     int16 SuperscriptBottomMaxWithSubscript;
1284     DeviceTable *SuperscriptBottomMaxWithSubscript_adjust;
1285     int16 SpaceAfterScript;
1286     DeviceTable *SpaceAfterScript_adjust;
1287     int16 UpperLimitGapMin;
1288     DeviceTable *UpperLimitGapMin_adjust;
1289     int16 UpperLimitBaselineRiseMin;
1290     DeviceTable *UpperLimitBaselineRiseMin_adjust;
1291     int16 LowerLimitGapMin;
1292     DeviceTable *LowerLimitGapMin_adjust;
1293     int16 LowerLimitBaselineDropMin;
1294     DeviceTable *LowerLimitBaselineDropMin_adjust;
1295     int16 StackTopShiftUp;
1296     DeviceTable *StackTopShiftUp_adjust;
1297     int16 StackTopDisplayStyleShiftUp;
1298     DeviceTable *StackTopDisplayStyleShiftUp_adjust;
1299     int16 StackBottomShiftDown;
1300     DeviceTable *StackBottomShiftDown_adjust;
1301     int16 StackBottomDisplayStyleShiftDown;
1302     DeviceTable *StackBottomDisplayStyleShiftDown_adjust;
1303     int16 StackGapMin;
1304     DeviceTable *StackGapMin_adjust;
1305     int16 StackDisplayStyleGapMin;
1306     DeviceTable *StackDisplayStyleGapMin_adjust;
1307     int16 StretchStackTopShiftUp;
1308     DeviceTable *StretchStackTopShiftUp_adjust;
1309     int16 StretchStackBottomShiftDown;
1310     DeviceTable *StretchStackBottomShiftDown_adjust;
1311     int16 StretchStackGapAboveMin;
1312     DeviceTable *StretchStackGapAboveMin_adjust;
1313     int16 StretchStackGapBelowMin;
1314     DeviceTable *StretchStackGapBelowMin_adjust;
1315     int16 FractionNumeratorShiftUp;
1316     DeviceTable *FractionNumeratorShiftUp_adjust;
1317     int16 FractionNumeratorDisplayStyleShiftUp;
1318     DeviceTable *FractionNumeratorDisplayStyleShiftUp_adjust;
1319     int16 FractionDenominatorShiftDown;
1320     DeviceTable *FractionDenominatorShiftDown_adjust;
1321     int16 FractionDenominatorDisplayStyleShiftDown;
1322     DeviceTable *FractionDenominatorDisplayStyleShiftDown_adjust;
1323     int16 FractionNumeratorGapMin;
1324     DeviceTable *FractionNumeratorGapMin_adjust;
1325     int16 FractionNumeratorDisplayStyleGapMin;
1326     DeviceTable *FractionNumeratorDisplayStyleGapMin_adjust;
1327     int16 FractionRuleThickness;
1328     DeviceTable *FractionRuleThickness_adjust;
1329     int16 FractionDenominatorGapMin;
1330     DeviceTable *FractionDenominatorGapMin_adjust;
1331     int16 FractionDenominatorDisplayStyleGapMin;
1332     DeviceTable *FractionDenominatorDisplayStyleGapMin_adjust;
1333     int16 SkewedFractionHorizontalGap;
1334     DeviceTable *SkewedFractionHorizontalGap_adjust;
1335     int16 SkewedFractionVerticalGap;
1336     DeviceTable *SkewedFractionVerticalGap_adjust;
1337     int16 OverbarVerticalGap;
1338     DeviceTable *OverbarVerticalGap_adjust;
1339     int16 OverbarRuleThickness;
1340     DeviceTable *OverbarRuleThickness_adjust;
1341     int16 OverbarExtraAscender;
1342     DeviceTable *OverbarExtraAscender_adjust;
1343     int16 UnderbarVerticalGap;
1344     DeviceTable *UnderbarVerticalGap_adjust;
1345     int16 UnderbarRuleThickness;
1346     DeviceTable *UnderbarRuleThickness_adjust;
1347     int16 UnderbarExtraDescender;
1348     DeviceTable *UnderbarExtraDescender_adjust;
1349     int16 RadicalVerticalGap;
1350     DeviceTable *RadicalVerticalGap_adjust;
1351     int16 RadicalDisplayStyleVerticalGap;
1352     DeviceTable *RadicalDisplayStyleVerticalGap_adjust;
1353     int16 RadicalRuleThickness;
1354     DeviceTable *RadicalRuleThickness_adjust;
1355     int16 RadicalExtraAscender;
1356     DeviceTable *RadicalExtraAscender_adjust;
1357     int16 RadicalKernBeforeDegree;
1358     DeviceTable *RadicalKernBeforeDegree_adjust;
1359     int16 RadicalKernAfterDegree;
1360     DeviceTable *RadicalKernAfterDegree_adjust;
1361     uint16 RadicalDegreeBottomRaisePercent;
1362 /* Global constants from other subtables */
1363     uint16 MinConnectorOverlap;                 /* in the math variants sub-table */
1364 };
1365 #else
1366 struct MATH {
1367 /* From the MATH Constants subtable (constants for positioning glyphs. Not PI)*/
1368     int16 ScriptPercentScaleDown;
1369     int16 ScriptScriptPercentScaleDown;
1370     uint16 DelimitedSubFormulaMinHeight;
1371     uint16 DisplayOperatorMinHeight;
1372     int16 MathLeading;
1373     int16 AxisHeight;
1374     int16 AccentBaseHeight;
1375     int16 FlattenedAccentBaseHeight;
1376     int16 SubscriptShiftDown;
1377     int16 SubscriptTopMax;
1378     int16 SubscriptBaselineDropMin;
1379     int16 SuperscriptShiftUp;
1380     int16 SuperscriptShiftUpCramped;
1381     int16 SuperscriptBottomMin;
1382     int16 SuperscriptBaselineDropMax;
1383     int16 SubSuperscriptGapMin;
1384     int16 SuperscriptBottomMaxWithSubscript;
1385     int16 SpaceAfterScript;
1386     int16 UpperLimitGapMin;
1387     int16 UpperLimitBaselineRiseMin;
1388     int16 LowerLimitGapMin;
1389     int16 LowerLimitBaselineDropMin;
1390     int16 StackTopShiftUp;
1391     int16 StackTopDisplayStyleShiftUp;
1392     int16 StackBottomShiftDown;
1393     int16 StackBottomDisplayStyleShiftDown;
1394     int16 StackGapMin;
1395     int16 StackDisplayStyleGapMin;
1396     int16 StretchStackTopShiftUp;
1397     int16 StretchStackBottomShiftDown;
1398     int16 StretchStackGapAboveMin;
1399     int16 StretchStackGapBelowMin;
1400     int16 FractionNumeratorShiftUp;
1401     int16 FractionNumeratorDisplayStyleShiftUp;
1402     int16 FractionDenominatorShiftDown;
1403     int16 FractionDenominatorDisplayStyleShiftDown;
1404     int16 FractionNumeratorGapMin;
1405     int16 FractionNumeratorDisplayStyleGapMin;
1406     int16 FractionRuleThickness;
1407     int16 FractionDenominatorGapMin;
1408     int16 FractionDenominatorDisplayStyleGapMin;
1409     int16 SkewedFractionHorizontalGap;
1410     int16 SkewedFractionVerticalGap;
1411     int16 OverbarVerticalGap;
1412     int16 OverbarRuleThickness;
1413     int16 OverbarExtraAscender;
1414     int16 UnderbarVerticalGap;
1415     int16 UnderbarRuleThickness;
1416     int16 UnderbarExtraDescender;
1417     int16 RadicalVerticalGap;
1418     int16 RadicalDisplayStyleVerticalGap;
1419     int16 RadicalRuleThickness;
1420     int16 RadicalExtraAscender;
1421     int16 RadicalKernBeforeDegree;
1422     int16 RadicalKernAfterDegree;
1423     uint16 RadicalDegreeBottomRaisePercent;
1424 /* Global constants from other subtables */
1425     uint16 MinConnectorOverlap;                 /* in the math variants sub-table */
1426 };
1427 #endif
1428
1429 enum backedup_state { bs_dontknow=0, bs_not=1, bs_backedup=2 };
1430 enum loadvalidation_state {
1431         lvs_bad_ps_fontname    = 0x001,
1432         lvs_bad_glyph_table    = 0x002,
1433         lvs_bad_cff_table      = 0x004,
1434         lvs_bad_metrics_table  = 0x008,
1435         lvs_bad_cmap_table     = 0x010,
1436         lvs_bad_bitmaps_table  = 0x020,
1437         lvs_bad_gx_table       = 0x040,
1438         lvs_bad_ot_table       = 0x080,
1439         lvs_bad_os2_version    = 0x100,
1440         lvs_bad_sfnt_header    = 0x200
1441     };
1442
1443 typedef struct layerinfo {
1444     char *name;
1445     unsigned int background: 1;                 /* Layer is to be treated as background: No width, images, not worth outputting */
1446     unsigned int order2: 1;                     /* Layer's data are order 2 bezier splines (truetype) rather than order 3 (postscript) */
1447                                                 /* In all glyphs in the font */
1448     unsigned int ticked: 1;
1449 } LayerInfo;
1450
1451 /* Baseline data from the 'BASE' table */
1452 struct baselangextent {
1453     uint32 lang;                /* also used for feature tag */
1454     struct baselangextent *next;
1455     int16 ascent, descent;
1456     struct baselangextent *features;
1457 };
1458
1459 struct basescript {
1460     uint32 script;
1461     struct basescript *next;
1462     int    def_baseline;        /* index [0-baseline_cnt) */
1463     int16 *baseline_pos;        /* baseline_cnt of these */
1464     struct baselangextent *langs;       /* Language specific extents (may be NULL) */
1465                                 /* The default one has the tag DEFAULT_LANG */
1466 };
1467
1468 struct Base {
1469     int baseline_cnt;
1470     uint32 *baseline_tags;
1471     /* A font does not need to provide info on all baselines, but if one script */
1472     /*  talks about a baseline, then all must. So the set of baselines is global*/
1473     struct basescript *scripts;
1474 };
1475
1476 typedef struct splinefont {
1477     char *fontname, *fullname, *familyname, *weight;
1478     char *copyright;
1479     char *filename;                             /* sfd name. NULL if we open a font, that's origname */
1480     char *defbasefilename;
1481     char *version;
1482     real italicangle, upos, uwidth;             /* In font info */
1483     int units_per_em;
1484     struct splinefont *next;
1485     int ascent, descent;
1486     int uniqueid;                               /* Not copied when reading in!!!! */
1487   int glyphcnt, glyphmax,glyphmin;                      /* allocated size of glyphs array */
1488     SplineChar **glyphs;
1489     unsigned int changed: 1;
1490     unsigned int changed_since_autosave: 1;
1491     unsigned int changed_since_xuidchanged: 1;
1492     unsigned int display_antialias: 1;
1493     unsigned int display_bbsized: 1;
1494     unsigned int dotlesswarn: 1;                /* User warned that font doesn't have a dotless i character */
1495     unsigned int onlybitmaps: 1;                /* it's a bdf editor, not a postscript editor */
1496     unsigned int serifcheck: 1;                 /* Have we checked to see if we have serifs? */
1497     unsigned int issans: 1;                     /* We have no serifs */
1498     unsigned int isserif: 1;                    /* We have serifs. If neither set then we don't know. */
1499     unsigned int hasvmetrics: 1;                /* We've got vertical metric data and should output vhea/vmtx/VORG tables */
1500     unsigned int loading_cid_map: 1;
1501     unsigned int dupnamewarn: 1;                /* Warn about duplicate names when loading bdf font */
1502     unsigned int encodingchanged: 1;            /* Font's encoding has changed since it was loaded */
1503     unsigned int multilayer: 1;                 /* only applies if TYPE3 is set, means this font can contain strokes & fills */
1504                                                 /*  I leave it in so as to avoid cluttering up code with #ifdefs */
1505     unsigned int strokedfont: 1;
1506     unsigned int new: 1;                        /* A new and unsaved font */
1507     unsigned int compacted: 1;                  /* only used when opening a font */
1508     unsigned int backedup: 2;                   /* 0=>don't know, 1=>no, 2=>yes */
1509     unsigned int use_typo_metrics: 1;           /* The standard says to. But MS */
1510                                                 /* seems to feel that isn't good */
1511                                                 /* enough and has created a bit */
1512                                                 /* to mean "really use them" */
1513     unsigned int weight_width_slope_only: 1;    /* This bit seems stupid to me */
1514     unsigned int save_to_dir: 1;                /* Loaded from an sfdir collection rather than a simple sfd file */
1515     unsigned int head_optimized_for_cleartype: 1;/* Bit in the 'head' flags field, if unset "East Asian fonts in the Windows Presentation Framework (Avalon) will not be hinted" */
1516     unsigned int ticked: 1;
1517     unsigned int internal_temp: 1;              /* Internal temporary font to be passed to freetype for rasterizing. Don't complain about oddities */
1518     unsigned int complained_about_spiros: 1;
1519     unsigned int use_xuid: 1;                   /* Adobe has deprecated these two */
1520     unsigned int use_uniqueid: 1;               /* fields. Mostly we don't want to use them */
1521         /* 2 bits left */
1522     struct fontviewbase *fv;
1523     struct metricsview *metrics;
1524     enum uni_interp uni_interp;
1525     NameList *for_new_glyphs;
1526     EncMap *map;                /* only used when opening a font to provide original default encoding */
1527     Layer grid;
1528     BDFFont *bitmaps;
1529     char *origname;             /* filename of font file (ie. if not an sfd) */
1530     char *autosavename;
1531     int display_size;           /* a val <0 => Generate our own images from splines, a value >0 => find a bdf font of that size */
1532     struct psdict *private;     /* read in from type1 file or provided by user */
1533     char *xuid;
1534     struct pfminfo {            /* A misnomer now. OS/2 info would be more accurate, but that's stuff in here from all over ttf files */
1535         unsigned int pfmset: 1;
1536         unsigned int winascent_add: 1;
1537         unsigned int windescent_add: 1;
1538         unsigned int hheadascent_add: 1;
1539         unsigned int hheaddescent_add: 1;
1540         unsigned int typoascent_add: 1;
1541         unsigned int typodescent_add: 1;
1542         unsigned int subsuper_set: 1;
1543         unsigned int panose_set: 1;
1544         unsigned int hheadset: 1;
1545         unsigned int vheadset: 1;
1546         unsigned int hascodepages: 1;
1547         unsigned int hasunicoderanges: 1;
1548         unsigned char pfmfamily;
1549         int16 weight;
1550         int16 width;
1551         char panose[10];
1552         int16 fstype;
1553         int16 linegap;          /* from hhea */
1554         int16 vlinegap;         /* from vhea */
1555         int16 hhead_ascent, hhead_descent;
1556         int16 os2_typoascent, os2_typodescent, os2_typolinegap;
1557         int16 os2_winascent, os2_windescent;
1558         int16 os2_subxsize, os2_subysize, os2_subxoff, os2_subyoff;
1559         int16 os2_supxsize, os2_supysize, os2_supxoff, os2_supyoff;
1560         int16 os2_strikeysize, os2_strikeypos;
1561         char os2_vendor[4];
1562         int16 os2_family_class;
1563         uint32 codepages[2];
1564         uint32 unicoderanges[4];
1565         uint16 avgwidth;
1566         uint16 firstchar;
1567         uint16 lastchar;
1568         int16 os2_xheight;
1569         int16 os2_capheight;
1570         uint16 os2_defaultchar;
1571         uint16 os2_breakchar;
1572     } pfminfo;
1573     struct ttflangname *names;
1574     char *cidregistry, *ordering;
1575     int supplement;
1576     int subfontcnt;
1577     struct splinefont **subfonts;
1578     struct splinefont *cidmaster;               /* Top level cid font */
1579     float cidversion;
1580 #if HANYANG
1581     struct compositionrules *rules;
1582 #endif
1583     char *comments;     /* Used to be restricted to ASCII, now utf8 */
1584     char *fontlog;
1585     int tempuniqueid;
1586     int top_enc;
1587     uint16 desired_row_cnt, desired_col_cnt;
1588     struct glyphnamehash *glyphnames;
1589     struct ttf_table {
1590         uint32 tag;
1591         int32 len, maxlen;
1592         uint8 *data;
1593         struct ttf_table *next;
1594         FILE *temp;     /* Temporary storage used during generation */
1595     } *ttf_tables, *ttf_tab_saved;
1596         /* We copy: fpgm, prep, cvt, maxp (into ttf_tables) user can ask for others, into saved*/
1597     char **cvt_names;
1598     /* The end of this array is marked by a special entry: */
1599 #define END_CVT_NAMES ((char *) (~(intpt) 0))
1600     struct instrdata *instr_dlgs;       /* Pointer to all table and character instruction dlgs in this font */
1601     struct shortview *cvt_dlg;
1602     struct kernclasslistdlg *kcld, *vkcld;
1603     struct kernclassdlg *kcd;
1604     struct texdata {
1605         enum { tex_unset, tex_text, tex_math, tex_mathext } type;
1606         int32 params[22];               /* param[6] has different meanings in normal and math fonts */
1607     } texdata;
1608     OTLookup *gsub_lookups, *gpos_lookups;
1609     AnchorClass *anchor;
1610     KernClass *kerns, *vkerns;
1611     FPST *possub;
1612     char *chosenname;                   /* Set for files with multiple fonts in them */
1613     struct mmset *mm;                   /* If part of a multiple master set */
1614     int16 macstyle;
1615     char *fondname;                     /* For use in generating mac families */
1616     /* from the GPOS 'size' feature. design_size, etc. are measured in tenths of a point */
1617     /*  bottom is exclusive, top is inclusive */
1618     /*  if any field is 0, it is undefined. All may be undefined, All may be */
1619     /*  defined, or design_size may be defined without any of the others */
1620     /*  but we can't define the range without defining the other junk */
1621     /*  Name must contain an English language name, may contain others */
1622     uint16 design_size;
1623     uint16 fontstyle_id;
1624     struct otfname *fontstyle_name;
1625     uint16 design_range_bottom, design_range_top;
1626     real strokewidth;
1627 /* For GDEF Mark Attachment Class -- used in lookup flags */
1628 /* As usual, class 0 is unused */
1629     int mark_class_cnt;
1630     char **mark_classes;                /* glyph name list */
1631     char **mark_class_names;            /* used within ff, utf8 (the name we've given to this class of marks) */
1632 #ifdef _HAS_LONGLONG
1633     long long creationtime;             /* seconds since 1970 */
1634     long long modificationtime;
1635 #else
1636     long creationtime;
1637     long modificationtime;
1638 #endif
1639     short os2_version;                  /* 0 means default rather than the real version 0 */
1640     short compression;                  /* If we opened a compressed sfd file, then save it out compressed too */
1641     short gasp_version;                 /* 0/1 currently */
1642     short gasp_cnt;
1643     struct gasp {
1644         uint16 ppem;
1645         uint16 flags;
1646     } *gasp;
1647     struct MATH *MATH;
1648     float sfd_version;                  /* Used only when reading in an sfd file */
1649     struct gfi_data *fontinfo;
1650     struct val_data *valwin;
1651     void *python_temporary;
1652     void *python_persistent;            /* If python this will hold a python object, if not python this will hold a string containing a pickled object. We do nothing with it (if not python) except save it back out unchanged */
1653     enum loadvalidation_state loadvalidation_state;
1654     LayerInfo *layers;
1655     int layer_cnt;
1656     int display_layer;
1657     struct Base *horiz_base, *vert_base;
1658     int extrema_bound;                  /* Splines do not count for extrema complaints when the distance between the endpoints is less than or equal to this */
1659 } SplineFont;
1660
1661 /* I am going to simplify my life and not encourage intermediate designs */
1662 /*  this means I can easily calculate ConvertDesignVector, and don't have */
1663 /*  to bother the user with specifying it. */
1664 /* (NormalizeDesignVector is fairly basic and shouldn't need user help ever) */
1665 /*  (As long as they want piecewise linear) */
1666 typedef struct mmset {
1667     int axis_count;
1668     char *axes[4];
1669     int instance_count;
1670     SplineFont **instances;
1671     SplineFont *normal;
1672     real *positions;    /* array[instance][axis] saying where each instance lies on each axis */
1673     real *defweights;   /* array[instance] saying how much of each instance makes the normal font */
1674     struct axismap {
1675         int points;     /* size of the next two arrays */
1676         real *blends;   /* between [0,1] ordered so that blend[0]<blend[1]<... */
1677         real *designs;  /* between the design ranges for this axis, typically [1,999] or [6,72] */
1678         real min, def, max;             /* For mac */
1679     } *axismaps;        /* array[axis] */
1680     char *cdv, *ndv;    /* for adobe */
1681     unsigned int changed: 1;
1682 } MMSet;
1683
1684 /* mac styles. Useful idea we'll just steal it */
1685 enum style_flags { sf_bold = 1, sf_italic = 2, sf_underline = 4, sf_outline = 8,
1686         sf_shadow = 0x10, sf_condense = 0x20, sf_extend = 0x40 };
1687
1688 struct sflist {
1689     SplineFont *sf;
1690     int32 *sizes;
1691     FILE *tempttf;              /* For ttf */
1692     int id;                     /* For ttf */
1693     int* ids;                   /* One for each size */
1694     BDFFont **bdfs;             /* Ditto */
1695     EncMap *map;
1696     struct sflist *next;
1697     char **former_names;
1698 };
1699
1700     /* Used for drawing text with mark to base anchors */
1701 typedef struct anchorpos {
1702     SplineChar *sc;             /* This is the mark being positioned */
1703     int x,y;                    /* Its origin should be shifted this much relative to that of the original base char */
1704     AnchorPoint *apm;           /* The anchor point in sc used to position it */
1705     AnchorPoint *apb;           /* The anchor point in the base character against which we are positioned */
1706     int base_index;             /* Index in this array to the base character (-1=> original base char) */
1707     unsigned int ticked: 1;     /* Used as a mark to mark */
1708 } AnchorPos;
1709
1710 enum ttf_flags { ttf_flag_shortps = 1, ttf_flag_nohints = 2,
1711                     ttf_flag_applemode=4,
1712                     ttf_flag_pfed_comments=8, ttf_flag_pfed_colors=0x10,
1713                     ttf_flag_otmode=0x20,
1714                     ttf_flag_glyphmap=0x40,
1715                     ttf_flag_TeXtable=0x80,
1716                     ttf_flag_ofm=0x100,
1717                     ttf_flag_oldkern=0x200,     /* never set in conjunction with applemode */
1718                     ttf_flag_brokensize=0x400,  /* Adobe originally issued fonts with a bug in the size feature. They now claim (Aug 2006) that this has been fixed. Legacy programs will do the wrong thing with the fixed feature though */
1719                     ttf_flag_pfed_lookupnames=0x800,
1720                     ttf_flag_pfed_guides=0x1000,
1721                     ttf_flag_pfed_layers=0x2000,
1722                     ttf_flag_symbol=0x4000,
1723                     ttf_flag_dummyDSIG=0x8000
1724                 };
1725 enum openflags { of_fstypepermitted=1, of_askcmap=2, of_all_glyphs_in_ttc=4,
1726         of_fontlint=8, of_hidewindow=0x10 };
1727 enum ps_flags { ps_flag_nohintsubs = 0x10000, ps_flag_noflex=0x20000,
1728                     ps_flag_nohints = 0x40000, ps_flag_restrict256=0x80000,
1729                     ps_flag_afm = 0x100000, ps_flag_pfm = 0x200000,
1730                     ps_flag_tfm = 0x400000,
1731                     ps_flag_round = 0x800000,
1732 /* CFF fonts are wrapped up in some postscript sugar -- unless they are to */
1733 /*  go into a pdf file or an otf font */
1734                     ps_flag_nocffsugar = 0x1000000,
1735 /* in type42 cid fonts we sometimes want an identity map from gid to cid */
1736                     ps_flag_identitycidmap = 0x2000000,
1737                     ps_flag_afmwithmarks = 0x4000000,
1738                     ps_flag_noseac = 0x8000000,
1739                     ps_flag_outputfontlog = 0x10000000,
1740                     ps_flag_mask = (ps_flag_nohintsubs|ps_flag_noflex|
1741                         ps_flag_afm|ps_flag_pfm|ps_flag_tfm|ps_flag_round)
1742                 };
1743
1744 struct compressors { char *ext, *decomp, *recomp; };
1745 struct archivers {
1746     char *ext, *unarchive, *archive, *listargs, *extractargs, *appendargs;
1747     enum archive_list_style { ars_tar, ars_zip } ars;
1748 };
1749
1750 struct fontdict;
1751 struct pschars;
1752 struct findsel;
1753 struct charprocs;
1754 struct enc;
1755
1756 /* extern void *chunkalloc(int size); */
1757 /* extern void chunkfree(void *, int size); */
1758
1759 #define chunkalloc(size)        gcalloc(1,size)
1760 #define chunkfree(item,size)    free(item)
1761
1762 extern char *strconcat(const char *str, const char *str2);
1763 extern char *strconcat3(const char *str, const char *str2, const char *str3);
1764
1765 extern char *XUIDFromFD(int xuid[20]);
1766 extern SplineFont *SplineFontFromPSFont(struct fontdict *fd);
1767 extern int CheckAfmOfPostscript(SplineFont *sf, const char *psname,EncMap *map);
1768 extern int LoadKerningDataFromAmfm(SplineFont *sf, char *filename, EncMap *map);
1769 extern int LoadKerningDataFromAfm(SplineFont *sf, char *filename, EncMap *map);
1770 extern int LoadKerningDataFromTfm(SplineFont *sf, char *filename, EncMap *map);
1771 extern int LoadKerningDataFromOfm(SplineFont *sf, char *filename, EncMap *map);
1772 extern int LoadKerningDataFromPfm(SplineFont *sf, char *filename, EncMap *map);
1773 extern int LoadKerningDataFromMacFOND(SplineFont *sf, char *filename, EncMap *map);
1774 extern int LoadKerningDataFromMetricsFile(SplineFont *sf, char *filename, EncMap *map);
1775 extern void FeatDumpFontLookups(FILE *out,SplineFont *sf);
1776 extern void FeatDumpOneLookup(FILE *out,SplineFont *sf, OTLookup *otl);
1777 extern void SFApplyFeatureFile(SplineFont *sf,FILE *file,char *filename);
1778 extern void SFApplyFeatureFilename(SplineFont *sf,char *filename);
1779 extern void SubsNew(SplineChar *to,enum possub_type type,int tag,char *components,
1780             SplineChar *default_script);
1781 extern void PosNew(SplineChar *to,int tag,int dx, int dy, int dh, int dv);
1782 extern int SFOneWidth(SplineFont *sf);
1783 extern int CIDOneWidth(SplineFont *sf);
1784 extern int SFOneHeight(SplineFont *sf);
1785 extern int SFIsCJK(SplineFont *sf,EncMap *map);
1786 extern void CIDMasterAsDes(SplineFont *sf);
1787 enum fontformat { ff_pfa, ff_pfb, ff_pfbmacbin, ff_multiple, ff_mma, ff_mmb,
1788         ff_ptype3, ff_ptype0, ff_cid, ff_cff, ff_cffcid,
1789         ff_type42, ff_type42cid,
1790         ff_ttf, ff_ttfsym, ff_ttfmacbin, ff_ttfdfont, ff_otf, ff_otfdfont,
1791         ff_otfcid, ff_otfciddfont, ff_svg, ff_ufo, ff_none };
1792 extern struct pschars *SplineFont2ChrsSubrs(SplineFont *sf, int iscjk,
1793         struct pschars *subrs,int flags,enum fontformat format,int layer);
1794 extern int CanonicalCombiner(int uni);
1795 struct cidbytes;
1796 struct fd2data;
1797 struct ttfinfo;
1798 struct alltabs;
1799 struct growbuf;
1800 struct glyphdata;
1801 extern int UnitsParallel(BasePoint *u1,BasePoint *u2,int strict);
1802 extern int CvtPsStem3(struct growbuf *gb, SplineChar *scs[MmMax], int instance_count,
1803         int ishstem, int round);
1804 extern struct pschars *SplineFont2ChrsSubrs2(SplineFont *sf, int nomwid,
1805         int defwid, const int *bygid, int cnt, int flags,
1806         struct pschars **_subrs,int layer);
1807 extern struct pschars *CID2ChrsSubrs2(SplineFont *cidmaster,struct fd2data *fds,
1808         int flags, struct pschars **_glbls,int layer);
1809 enum bitmapformat { bf_bdf, bf_ttf, bf_sfnt_dfont, bf_sfnt_ms, bf_otb,
1810         bf_nfntmacbin, /*bf_nfntdfont, */bf_fon, bf_fnt, bf_palm,
1811         bf_ptype3,
1812         bf_none };
1813 extern const char *GetAuthor(void);
1814 extern SplineChar *SFFindExistingCharMac(SplineFont *,EncMap *map, int unienc);
1815 extern void SC_PSDump(void (*dumpchar)(int ch,void *data), void *data,
1816         SplineChar *sc, int refs_to_splines, int pdfopers,int layer );
1817 extern int _WritePSFont(FILE *out,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,SplineFont *fullsf,int layer);
1818 extern int WritePSFont(char *fontname,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,SplineFont *fullsf,int layer);
1819 extern int WriteMacPSFont(char *fontname,SplineFont *sf,enum fontformat format,
1820         int flags,EncMap *enc,int layer);
1821 extern int _WriteTTFFont(FILE *ttf,SplineFont *sf, enum fontformat format,
1822         int32 *bsizes, enum bitmapformat bf,int flags,EncMap *enc,int layer);
1823 extern int WriteTTFFont(char *fontname,SplineFont *sf, enum fontformat format,
1824         int32 *bsizes, enum bitmapformat bf,int flags,EncMap *enc,int layer);
1825 extern int _WriteType42SFNTS(FILE *type42,SplineFont *sf,enum fontformat format,
1826         int flags,EncMap *enc,int layer);
1827 extern int WriteMacTTFFont(char *fontname,SplineFont *sf, enum fontformat format,
1828         int32 *bsizes, enum bitmapformat bf,int flags,EncMap *enc,int layer);
1829 extern int WriteMacBitmaps(char *filename,SplineFont *sf, int32 *sizes,
1830         int is_dfont,EncMap *enc);
1831 extern int WritePalmBitmaps(char *filename,SplineFont *sf, int32 *sizes,EncMap *enc);
1832 extern int WriteMacFamily(char *filename,struct sflist *sfs,enum fontformat format,
1833         enum bitmapformat bf,int flags,EncMap *enc,int layer);
1834 extern long mactime(void);
1835 extern int WriteSVGFont(char *fontname,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,int layer);
1836 extern int WriteUFOFont(char *fontname,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,int layer);
1837 extern void SfListFree(struct sflist *sfs);
1838 extern void DefaultTTFEnglishNames(struct ttflangname *dummy, SplineFont *sf);
1839 extern void TeXDefaultParams(SplineFont *sf);
1840 extern int AlreadyMSSymbolArea(SplineFont *sf,EncMap *map);
1841 extern void OS2FigureCodePages(SplineFont *sf, uint32 CodePage[2]);
1842 extern void OS2FigureUnicodeRanges(SplineFont *sf, uint32 Ranges[4]);
1843 extern void SFDefaultOS2Info(struct pfminfo *pfminfo,SplineFont *sf,char *fontname);
1844 extern void SFDefaultOS2Simple(struct pfminfo *pfminfo,SplineFont *sf);
1845 extern void SFDefaultOS2SubSuper(struct pfminfo *pfminfo,int emsize,double italicangle);
1846 extern void VerifyLanguages(SplineFont *sf);
1847 extern int ScriptIsRightToLeft(uint32 script);
1848 extern void ScriptMainRange(uint32 script, int *start, int *end);
1849 extern uint32 ScriptFromUnicode(int u,SplineFont *sf);
1850 extern uint32 SCScriptFromUnicode(SplineChar *sc);
1851 extern int SCRightToLeft(SplineChar *sc);
1852 extern int SLIContainsR2L(SplineFont *sf,int sli);
1853 extern void SFFindNearTop(SplineFont *);
1854 extern void SFRestoreNearTop(SplineFont *);
1855 extern int SFForceEncoding(SplineFont *sf,EncMap *old,Encoding *new_map);
1856 extern int CountOfEncoding(Encoding *encoding_name);
1857 extern void SFMatchGlyphs(SplineFont *sf,SplineFont *target,int addempties);
1858 extern void MMMatchGlyphs(MMSet *mm);
1859 extern char *_GetModifiers(char *fontname, char *familyname,char *weight);
1860 extern char *SFGetModifiers(SplineFont *sf);
1861 extern const unichar_t *_uGetModifiers(const unichar_t *fontname, const unichar_t *familyname,
1862         const unichar_t *weight);
1863 extern void SFSetFontName(SplineFont *sf, char *family, char *mods, char *full);
1864 extern void ttfdumpbitmap(SplineFont *sf,struct alltabs *at,int32 *sizes);
1865 extern void ttfdumpbitmapscaling(SplineFont *sf,struct alltabs *at,int32 *sizes);
1866 extern void SplineFontSetUnChanged(SplineFont *sf);
1867
1868 extern int RealNear(real a,real b);
1869 extern int RealNearish(real a,real b);
1870 extern int RealApprox(real a,real b);
1871 extern int RealWithin(real a,real b,real fudge);
1872 extern int RealRatio(real a,real b,real fudge);
1873
1874 extern int PointsDiagonalable(SplineFont *sf,BasePoint **bp,BasePoint *unit);
1875 extern int MergeDStemInfo(SplineFont *sf,DStemInfo **ds, DStemInfo *test);
1876
1877 extern void LineListFree(LineList *ll);
1878 extern void LinearApproxFree(LinearApprox *la);
1879 extern void SplineFree(Spline *spline);
1880 extern SplinePoint *SplinePointCreate(real x, real y);
1881 extern void SplinePointFree(SplinePoint *sp);
1882 extern void SplinePointMDFree(SplineChar *sc,SplinePoint *sp);
1883 extern void SplinePointsFree(SplinePointList *spl);
1884 extern void SplinePointListFree(SplinePointList *spl);
1885 extern void SplinePointListMDFree(SplineChar *sc,SplinePointList *spl);
1886 extern void SplinePointListsMDFree(SplineChar *sc,SplinePointList *spl);
1887 extern void SplinePointListsFree(SplinePointList *head);
1888 extern void SplineSetBeziersClear(SplineSet *spl);
1889 extern void RefCharFree(RefChar *ref);
1890 extern void RefCharsFree(RefChar *ref);
1891 extern void RefCharsFreeRef(RefChar *ref);
1892 extern void CopyBufferFree(void);
1893 extern void CopyBufferClearCopiedFrom(SplineFont *dying);
1894 extern void UndoesFree(Undoes *undo);
1895 extern void StemInfosFree(StemInfo *h);
1896 extern void StemInfoFree(StemInfo *h);
1897 extern void DStemInfosFree(DStemInfo *h);
1898 extern void DStemInfoFree(DStemInfo *h);
1899 extern void KernPairsFree(KernPair *kp);
1900 extern void SCOrderAP(SplineChar *sc);
1901 extern void AnchorPointsFree(AnchorPoint *ap);
1902 extern AnchorPoint *AnchorPointsCopy(AnchorPoint *alist);
1903 extern void SFRemoveAnchorClass(SplineFont *sf,AnchorClass *an);
1904 extern int AnchorClassesNextMerge(AnchorClass *ac);
1905 extern int IsAnchorClassUsed(SplineChar *sc,AnchorClass *an);
1906 extern AnchorPoint *APAnchorClassMerge(AnchorPoint *anchors,AnchorClass *into,AnchorClass *from);
1907 extern void AnchorClassMerge(SplineFont *sf,AnchorClass *into,AnchorClass *from);
1908 extern void AnchorClassesFree(AnchorClass *kp);
1909 extern void TtfTablesFree(struct ttf_table *tab);
1910 extern void SFRemoveSavedTable(SplineFont *sf, uint32 tag);
1911 extern AnchorClass *AnchorClassMatch(SplineChar *sc1,SplineChar *sc2,
1912         AnchorClass *restrict_, AnchorPoint **_ap1,AnchorPoint **_ap2 );
1913 extern AnchorClass *AnchorClassMkMkMatch(SplineChar *sc1,SplineChar *sc2,
1914         AnchorPoint **_ap1,AnchorPoint **_ap2 );
1915 extern AnchorClass *AnchorClassCursMatch(SplineChar *sc1,SplineChar *sc2,
1916         AnchorPoint **_ap1,AnchorPoint **_ap2 );
1917 extern void SCInsertPST(SplineChar *sc,PST *new);
1918 #ifdef FONTFORGE_CONFIG_DEVICETABLES
1919 extern void ValDevFree(ValDevTab *adjust);
1920 extern ValDevTab *ValDevTabCopy(ValDevTab *orig);
1921 extern void DeviceTableFree(DeviceTable *adjust);
1922 extern DeviceTable *DeviceTableCopy(DeviceTable *orig);
1923 extern void DeviceTableSet(DeviceTable *adjust, int size, int correction);
1924 #endif
1925 extern void PSTFree(PST *lig);
1926 extern uint16 PSTDefaultFlags(enum possub_type type,SplineChar *sc );
1927 extern int PSTContains(const char *components,const char *name);
1928 extern StemInfo *StemInfoCopy(StemInfo *h);
1929 extern DStemInfo *DStemInfoCopy(DStemInfo *h);
1930 extern MinimumDistance *MinimumDistanceCopy(MinimumDistance *h);
1931 extern void SPChangePointType(SplinePoint *sp, int pointtype);
1932 struct sfmergecontext {
1933     SplineFont *sf_from, *sf_to;
1934     int lcnt;
1935     struct lookup_cvt { OTLookup *from, *to; int old;} *lks;
1936     int scnt;
1937     struct sub_cvt { struct lookup_subtable *from, *to; int old;} *subs;
1938     int acnt;
1939     struct ac_cvt { AnchorClass *from, *to; int old;} *acs;
1940     char *prefix;
1941     int preserveCrossFontKerning;
1942     int lmax;
1943 };
1944 extern PST *PSTCopy(PST *base,SplineChar *sc,struct sfmergecontext *mc);
1945 extern struct lookup_subtable *MCConvertSubtable(struct sfmergecontext *mc,struct lookup_subtable *sub);
1946 extern AnchorClass *MCConvertAnchorClass(struct sfmergecontext *mc,AnchorClass *ac);
1947 extern void SFFinishMergeContext(struct sfmergecontext *mc);
1948 extern SplineChar *SplineCharCopy(SplineChar *sc,SplineFont *into,struct sfmergecontext *);
1949 extern BDFChar *BDFCharCopy(BDFChar *bc);
1950 extern void BCFlattenFloat(BDFChar *bc);
1951 extern void BitmapsCopy(SplineFont *to, SplineFont *from, int to_index, int from_index );
1952 extern struct gimage *ImageAlterClut(struct gimage *image);
1953 extern void ImageListsFree(ImageList *imgs);
1954 extern void TTFLangNamesFree(struct ttflangname *l);
1955 extern void AltUniFree(struct altuni *altuni);
1956 extern void AltUniRemove(SplineChar *sc,int uni);
1957 extern void MinimumDistancesFree(MinimumDistance *md);
1958 extern void LayerDefault(Layer *);
1959 extern SplineChar *SplineCharCreate(int layer_cnt);
1960 extern SplineChar *SFSplineCharCreate(SplineFont *sf);
1961 extern RefChar *RefCharCreate(void);
1962 extern RefChar *RefCharsCopy(RefChar *ref);     /* Still needs to be instanciated and have the dependency list adjusted */
1963 extern void SCAddRef(SplineChar *sc,SplineChar *rsc,int layer, real xoff, real yoff);
1964 extern void _SCAddRef(SplineChar *sc,SplineChar *rsc,int layer, real transform[6]);
1965 extern KernClass *KernClassCopy(KernClass *kc);
1966 extern void KernClassFreeContents(KernClass *kc);
1967 extern void KernClassListFree(KernClass *kc);
1968 extern int KernClassContains(KernClass *kc, char *name1, char *name2, int ordered );
1969 extern void OTLookupFree(OTLookup *lookup);
1970 extern void OTLookupListFree(OTLookup *lookup );
1971 extern FPST *FPSTCopy(FPST *fpst);
1972 extern void FPSTRuleContentsFree(struct fpst_rule *r, enum fpossub_format format);
1973 extern void FPSTRulesFree(struct fpst_rule *r, enum fpossub_format format, int rcnt);
1974 extern void FPSTFree(FPST *fpst);
1975 extern void GlyphVariantsFree(struct glyphvariants *gv);
1976 extern void MathKernVContentsFree(struct mathkernvertex *mk);
1977 extern void MathKernFree(struct mathkern *mk);
1978 extern struct mathkern *MathKernCopy(struct mathkern *mk);
1979 extern void SplineCharListsFree(struct splinecharlist *dlist);
1980 extern void LayerFreeContents(SplineChar *sc, int layer);
1981 extern void SplineCharFreeContents(SplineChar *sc);
1982 extern void SplineCharFree(SplineChar *sc);
1983 extern void EncMapFree(EncMap *map);
1984 extern EncMap *EncMapFromEncoding(SplineFont *sf,Encoding *enc);
1985 extern EncMap *CompactEncMap(EncMap *map, SplineFont *sf);
1986 extern EncMap *EncMapNew(int encmax, int backmax, Encoding *enc);
1987 extern EncMap *EncMap1to1(int enccount);
1988 extern EncMap *EncMapCopy(EncMap *map);
1989 extern void SFExpandGlyphCount(SplineFont *sf, int newcnt);
1990 extern void ScriptLangListFree(struct scriptlanglist *sl);
1991 extern void FeatureScriptLangListFree(FeatureScriptLangList *fl);
1992 extern void SFBaseSort(SplineFont *sf);
1993 extern struct baselangextent *BaseLangCopy(struct baselangextent *extent);
1994 extern void BaseLangFree(struct baselangextent *extent);
1995 extern void BaseScriptFree(struct basescript *bs);
1996 extern void BaseFree(struct Base *base);
1997 extern void SplineFontFree(SplineFont *sf);
1998 extern void MATHFree(struct MATH *math);
1999 extern struct MATH *MathTableNew(SplineFont *sf);
2000 extern void OtfNameListFree(struct otfname *on);
2001 extern void MarkClassFree(int cnt,char **classes,char **names);
2002 extern void MMSetFreeContents(MMSet *mm);
2003 extern void MMSetFree(MMSet *mm);
2004 extern void SFRemoveUndoes(SplineFont *sf,uint8 *selected,EncMap *map);
2005 extern void SplineRefigure3(Spline *spline);
2006 extern void SplineRefigure(Spline *spline);
2007 extern Spline *SplineMake3(SplinePoint *from, SplinePoint *to);
2008 extern LinearApprox *SplineApproximate(Spline *spline, real scale);
2009 extern int SplinePointListIsClockwise(const SplineSet *spl);
2010 extern void SplineSetFindBounds(const SplinePointList *spl, DBounds *bounds);
2011 extern void SplineCharLayerFindBounds(SplineChar *sc,int layer,DBounds *bounds);
2012 extern void SplineCharFindBounds(SplineChar *sc,DBounds *bounds);
2013 extern void SplineFontLayerFindBounds(SplineFont *sf,int layer,DBounds *bounds);
2014 extern void SplineFontFindBounds(SplineFont *sf,DBounds *bounds);
2015 extern void CIDLayerFindBounds(SplineFont *sf,int layer,DBounds *bounds);
2016 extern void SplineSetQuickBounds(SplineSet *ss,DBounds *b);
2017 extern void SplineCharQuickBounds(SplineChar *sc, DBounds *b);
2018 extern void SplineSetQuickConservativeBounds(SplineSet *ss,DBounds *b);
2019 extern void SplineCharQuickConservativeBounds(SplineChar *sc, DBounds *b);
2020 extern void SplineFontQuickConservativeBounds(SplineFont *sf,DBounds *b);
2021 extern void SplinePointCatagorize(SplinePoint *sp);
2022 extern int SplinePointIsACorner(SplinePoint *sp);
2023 extern void SPLCatagorizePoints(SplinePointList *spl);
2024 extern void SCCatagorizePoints(SplineChar *sc);
2025 extern SplinePointList *SplinePointListCopy1(const SplinePointList *spl);
2026 extern SplinePointList *SplinePointListCopy(const SplinePointList *base);
2027 extern SplinePointList *SplinePointListCopySelected(SplinePointList *base);
2028 extern ImageList *ImageListCopy(ImageList *cimg);
2029 extern ImageList *ImageListTransform(ImageList *cimg,real transform[6]);
2030 extern void ApTransform(AnchorPoint *ap, real transform[6]);
2031 extern SplinePointList *SplinePointListTransform(SplinePointList *base, real transform[6], int allpoints );
2032 extern SplinePointList *SplinePointListShift(SplinePointList *base, real xoff, int allpoints );
2033 extern HintMask *HintMaskFromTransformedRef(RefChar *ref,BasePoint *trans,
2034         SplineChar *basesc,HintMask *hm);
2035 extern SplinePointList *SPLCopyTranslatedHintMasks(SplinePointList *base,
2036         SplineChar *basesc, SplineChar *subsc, BasePoint *trans);
2037 extern SplinePointList *SPLCopyTransformedHintMasks(RefChar *r,
2038         SplineChar *basesc, BasePoint *trans,int layer);
2039 extern SplinePointList *SplinePointListRemoveSelected(SplineChar *sc,SplinePointList *base);
2040 extern void SplinePointListSet(SplinePointList *tobase, SplinePointList *frombase);
2041 extern void SplinePointListSelect(SplinePointList *spl,int sel);
2042 extern void SCRefToSplines(SplineChar *sc,RefChar *rf,int layer);
2043 extern void RefCharFindBounds(RefChar *rf);
2044 extern void SCReinstanciateRefChar(SplineChar *sc,RefChar *rf,int layer);
2045 extern void SCReinstanciateRef(SplineChar *sc,SplineChar *rsc,int layer);
2046 extern void SFReinstanciateRefs(SplineFont *sf);
2047 extern void SFInstanciateRefs(SplineFont *sf);
2048 extern SplineChar *MakeDupRef(SplineChar *base, int local_enc, int uni_enc);
2049 extern void SCRemoveDependent(SplineChar *dependent,RefChar *rf,int layer);
2050 extern void SCRemoveLayerDependents(SplineChar *dependent,int layer);
2051 extern void SCRemoveDependents(SplineChar *dependent);
2052 extern int SCDependsOnSC(SplineChar *parent, SplineChar *child);
2053 extern void BCCompressBitmap(BDFChar *bdfc);
2054 extern void BCRegularizeBitmap(BDFChar *bdfc);
2055 extern void BCRegularizeGreymap(BDFChar *bdfc);
2056 extern void BCPasteInto(BDFChar *bc,BDFChar *rbc,int ixoff,int iyoff, int invert, int cleartoo);
2057 extern void BCRotateCharForVert(BDFChar *bc,BDFChar *from, BDFFont *frombdf);
2058 extern int GradientHere(double scale,DBounds *bbox,int iy,int ix,
2059         struct gradient *grad,struct pattern *pat, int defgrey);
2060 extern void PatternPrep(SplineChar *sc,struct brush *brush,double scale);
2061 extern BDFChar *SplineCharRasterize(SplineChar *sc, int layer, double pixelsize);
2062 extern BDFFont *SplineFontToBDFHeader(SplineFont *_sf, int pixelsize, int indicate);
2063 extern BDFFont *SplineFontRasterize(SplineFont *sf, int layer, int pixelsize, int indicate);
2064 extern void BDFCAntiAlias(BDFChar *bc, int linear_scale);
2065 extern BDFChar *SplineCharAntiAlias(SplineChar *sc, int layer, int pixelsize,int linear_scale);
2066 extern BDFFont *SplineFontAntiAlias(SplineFont *sf, int layer, int pixelsize,int linear_scale);
2067 extern struct clut *_BDFClut(int linear_scale);
2068 extern void BDFClut(BDFFont *bdf, int linear_scale);
2069 extern int BDFDepth(BDFFont *bdf);
2070 extern BDFChar *BDFPieceMeal(BDFFont *bdf, int index);
2071 extern BDFChar *BDFPieceMealCheck(BDFFont *bdf, int index);
2072 enum piecemeal_flags { pf_antialias=1, pf_bbsized=2, pf_ft_nohints=4 };
2073 extern BDFFont *SplineFontPieceMeal(SplineFont *sf,int layer,int pixelsize,int flags,void *freetype_context);
2074 extern void BDFCharFindBounds(BDFChar *bc,IBounds *bb);
2075 extern BDFFont *BitmapFontScaleTo(BDFFont *old, int to);
2076 extern void BDFCharFree(BDFChar *bdfc);
2077 extern void BDFPropsFree(BDFFont *bdf);
2078 extern void BDFFontFree(BDFFont *bdf);
2079 extern void SFDefaultAscent(SplineFont *sf);
2080 extern int  PSBitmapDump(char *filename,BDFFont *font, EncMap *map);
2081 extern int  BDFFontDump(char *filename,BDFFont *font, EncMap *map, int res);
2082 extern int  FNTFontDump(char *filename,BDFFont *font, EncMap *map, int res);
2083 extern int  FONFontDump(char *filename,SplineFont *sf, int32 *sizes,int res,
2084         EncMap *map);
2085 extern void SFReplaceEncodingBDFProps(SplineFont *sf,EncMap *map);
2086 extern void SFReplaceFontnameBDFProps(SplineFont *sf);
2087 extern int  IsUnsignedBDFKey(char *key);
2088 extern int  BdfPropHasInt(BDFFont *font,const char *key, int def );
2089 extern char *BdfPropHasString(BDFFont *font,const char *key, char *def );
2090 extern void def_Charset_Enc(EncMap *map,char *reg,char *enc);
2091 extern void Default_XLFD(BDFFont *bdf,EncMap *map, int res);
2092 extern void Default_Properties(BDFFont *bdf,EncMap *map,char *onlyme);
2093 extern void BDFDefaultProps(BDFFont *bdf, EncMap *map, int res);
2094 extern BDFProperties *BdfPropsCopy(BDFProperties *props, int cnt );
2095 struct xlfd_components {
2096     char foundry[80];
2097     char family[100];
2098     char weight[80];
2099     char slant[40];
2100     char setwidth[50];
2101     char add_style[50];
2102     int pixel_size;
2103     int point_size;
2104     int res_x;
2105     int res_y;
2106     char spacing[40];
2107     int avg_width;
2108     char cs_reg[80];            /* encoding */
2109     char cs_enc[80];            /* encoding version? */
2110     int char_cnt;
2111 };
2112 struct std_bdf_props {
2113     char *name;
2114     int type;
2115     int defaultable;
2116 };
2117 extern void XLFD_GetComponents(char *xlfd,struct xlfd_components *comp);
2118 extern void XLFD_CreateComponents(BDFFont *bdf,EncMap *map,int res,struct xlfd_components *comp);
2119 /* Two lines intersect in at most 1 point */
2120 /* Two quadratics intersect in at most 4 points */
2121 /* Two cubics intersect in at most 9 points */ /* Plus an extra space for a trailing -1 */
2122 extern int SplinesIntersect(const Spline *s1, const Spline *s2, BasePoint pts[9],
2123         extended t1s[10], extended t2s[10]);
2124 extern SplineSet *LayerAllSplines(Layer *layer);
2125 extern SplineSet *LayerUnAllSplines(Layer *layer);
2126 extern int SplineSetIntersect(SplineSet *spl, Spline **_spline, Spline **_spline2 );
2127 extern int LineTangentToSplineThroughPt(Spline *s, BasePoint *pt, extended ts[4],
2128         extended tmin, extended tmax);
2129 extern int CubicSolve(const Spline1D *sp,extended ts[3]);
2130 extern extended IterateSplineSolve(const Spline1D *sp, extended tmin, extended tmax, extended sought_y, double err);
2131 extern extended SplineSolve(const Spline1D *sp, real tmin, real tmax, extended sought_y, real err);
2132 extern int SplineSolveFull(const Spline1D *sp,extended val, extended ts[3]);
2133 extern void SplineFindExtrema(const Spline1D *sp, extended *_t1, extended *_t2 );
2134
2135 SplineSet *SplineSetsInterpolate(SplineSet *base, SplineSet *other, real amount, SplineChar *sc);
2136 SplineChar *SplineCharInterpolate(SplineChar *base, SplineChar *other, real amount);
2137 extern SplineFont *InterpolateFont(SplineFont *base, SplineFont *other, real amount, Encoding *enc);
2138
2139 double SFSerifHeight(SplineFont *sf);
2140
2141 extern void DumpPfaEditEncodings(void);
2142 extern void ParseEncodingFile(char *filename);
2143 extern void LoadPfaEditEncodings(void);
2144
2145 extern int GenerateScript(SplineFont *sf,char *filename,char *bitmaptype,
2146         int fmflags,int res, char *subfontdirectory,struct sflist *sfs,
2147         EncMap *map,NameList *rename_to,int layer);
2148
2149 extern void _SCAutoTrace(SplineChar *sc, int layer, char **args);
2150 extern char **AutoTraceArgs(int ask);
2151
2152 #define CURVATURE_ERROR -1e9
2153 extern double SplineCurvature(Spline *s, double t);
2154
2155 #ifndef EXTENDED_IS_LONG_DOUBLE
2156 extern double CheckExtremaForSingleBitErrors(const Spline1D *sp, double t);
2157 #define esqrt(d)        sqrt(d)
2158 #else
2159 extern extended esqrt(extended e);
2160 #endif
2161 extern int Spline2DFindExtrema(const Spline *sp, extended extrema[4] );
2162 extern int Spline2DFindPointsOfInflection(const Spline *sp, extended poi[2] );
2163 extern int SplineAtInflection(Spline1D *sp, double t );
2164 extern int SplineAtMinMax(Spline1D *sp, double t );
2165 extern void SplineRemoveExtremaTooClose(Spline1D *sp, extended *_t1, extended *_t2 );
2166 extern int NearSpline(struct findsel *fs, Spline *spline);
2167 extern real SplineNearPoint(Spline *spline, BasePoint *bp, real fudge);
2168 extern void SCMakeDependent(SplineChar *dependent,SplineChar *base);
2169 extern SplinePoint *SplineBisect(Spline *spline, extended t);
2170 extern Spline *SplineSplit(Spline *spline, extended ts[3]);
2171 extern Spline *ApproximateSplineFromPoints(SplinePoint *from, SplinePoint *to,
2172         TPoint *mid, int cnt,int order2);
2173 extern Spline *ApproximateSplineFromPointsSlopes(SplinePoint *from, SplinePoint *to,
2174         TPoint *mid, int cnt,int order2);
2175 extern double SplineLength(Spline *spline);
2176 extern double SplineLengthRange(Spline *spline, real from_t, real to_t);
2177 extern double PathLength(SplineSet *ss);
2178 extern Spline *PathFindDistance(SplineSet *path,double d,double *_t);
2179 extern SplineSet *SplineSetBindToPath(SplineSet *ss,int doscale, int glyph_as_unit,
2180         int align,real offset, SplineSet *path);
2181 extern int SplineIsLinear(Spline *spline);
2182 extern int SplineIsLinearMake(Spline *spline);
2183 extern int SSPointWithin(SplineSet *spl,BasePoint *pt);
2184 extern SplineSet *SSRemoveZeroLengthSplines(SplineSet *base);
2185 extern void SSRemoveStupidControlPoints(SplineSet *base);
2186 extern void SSOverlapClusterCpAngles(SplineSet *base,double within);
2187 extern void SplinesRemoveBetween(SplineChar *sc, SplinePoint *from, SplinePoint *to,int type);
2188 extern void SplineCharMerge(SplineChar *sc,SplineSet **head,int type);
2189 extern void SPLNearlyHvCps(SplineChar *sc,SplineSet *ss,double err);
2190 extern void SPLNearlyHvLines(SplineChar *sc,SplineSet *ss,double err);
2191 extern int  SPLNearlyLines(SplineChar *sc,SplineSet *ss,double err);
2192 extern int SPInterpolate(SplinePoint *sp);
2193 extern void SplinePointListSimplify(SplineChar *sc,SplinePointList *spl,
2194         struct simplifyinfo *smpl);
2195 extern SplineSet *SplineCharSimplify(SplineChar *sc,SplineSet *head,
2196         struct simplifyinfo *smpl);
2197 extern void SPLStartToLeftmost(SplineChar *sc,SplinePointList *spl, int *changed);
2198 extern void SPLsStartToLeftmost(SplineChar *sc,int layer);
2199 extern void CanonicalContours(SplineChar *sc,int layer);
2200 extern void SplineSetJoinCpFixup(SplinePoint *sp);
2201 extern SplineSet *SplineSetJoin(SplineSet *start,int doall,real fudge,int *changed);
2202 enum ae_type { ae_all, ae_between_selected, ae_only_good, ae_only_good_rm_later };
2203 extern Spline *SplineAddExtrema(Spline *s,int always,real lenbound,
2204         real offsetbound,DBounds *b);
2205 extern void SplineSetAddExtrema(SplineChar *sc,SplineSet *ss,enum ae_type between_selected, int emsize);
2206 extern void SplineCharAddExtrema(SplineChar *sc,SplineSet *head,enum ae_type between_selected,int emsize);
2207 extern SplineSet *SplineCharRemoveTiny(SplineChar *sc,SplineSet *head);
2208 extern SplineFont *SplineFontNew(void);
2209 extern char *GetNextUntitledName(void);
2210 extern SplineFont *SplineFontEmpty(void);
2211 extern SplineFont *SplineFontBlank(int charcnt);
2212 extern void SFIncrementXUID(SplineFont *sf);
2213 extern void SFRandomChangeXUID(SplineFont *sf);
2214 extern SplineSet *SplineSetReverse(SplineSet *spl);
2215 extern SplineSet *SplineSetsExtractOpen(SplineSet **tbase);
2216 extern void SplineSetsInsertOpen(SplineSet **tbase,SplineSet *open);
2217 extern SplineSet *SplineSetsCorrect(SplineSet *base,int *changed);
2218 extern SplineSet *SplineSetsAntiCorrect(SplineSet *base);
2219 extern SplineSet *SplineSetsDetectDir(SplineSet **_base, int *lastscan);
2220 extern void SPAverageCps(SplinePoint *sp);
2221 extern void SPLAverageCps(SplinePointList *spl);
2222 extern void SPWeightedAverageCps(SplinePoint *sp);
2223 extern void SplineCharDefaultPrevCP(SplinePoint *base);
2224 extern void SplineCharDefaultNextCP(SplinePoint *base);
2225 extern void SplineCharTangentNextCP(SplinePoint *sp);
2226 extern void SplineCharTangentPrevCP(SplinePoint *sp);
2227 extern void SPHVCurveForce(SplinePoint *sp);
2228 extern void SPSmoothJoint(SplinePoint *sp);
2229 extern int PointListIsSelected(SplinePointList *spl);
2230 extern void SCSplinePointsUntick(SplineChar *sc,int layer);
2231 extern void SFOrderBitmapList(SplineFont *sf);
2232 extern int KernThreshold(SplineFont *sf, int cnt);
2233 extern real SFGuessItalicAngle(SplineFont *sf);
2234
2235 extern SplinePoint *SplineTtfApprox(Spline *ps);
2236 extern SplineSet *SSttfApprox(SplineSet *ss);
2237 extern SplineSet *SplineSetsTTFApprox(SplineSet *ss);
2238 extern SplineSet *SSPSApprox(SplineSet *ss);
2239 extern SplineSet *SplineSetsPSApprox(SplineSet *ss);
2240 extern SplineSet *SplineSetsConvertOrder(SplineSet *ss, int to_order2);
2241 extern void SplineRefigure2(Spline *spline);
2242 extern void SplineRefigureFixup(Spline *spline);
2243 extern Spline *SplineMake2(SplinePoint *from, SplinePoint *to);
2244 extern Spline *SplineMake(SplinePoint *from, SplinePoint *to, int order2);
2245 extern Spline *SFSplineMake(SplineFont *sf,SplinePoint *from, SplinePoint *to);
2246 extern void SCConvertToOrder2(SplineChar *sc);
2247 extern void SFConvertToOrder2(SplineFont *sf);
2248 extern void SCConvertToOrder3(SplineChar *sc);
2249 extern void SFConvertToOrder3(SplineFont *sf);
2250 extern void SFConvertGridToOrder2(SplineFont *_sf);
2251 extern void SCConvertLayerToOrder2(SplineChar *sc,int layer);
2252 extern void SFConvertLayerToOrder2(SplineFont *sf,int layer);
2253 extern void SFConvertGridToOrder3(SplineFont *_sf);
2254 extern void SCConvertLayerToOrder3(SplineChar *sc,int layer);
2255 extern void SFConvertLayerToOrder3(SplineFont *sf,int layer);
2256 extern void SCConvertOrder(SplineChar *sc, int to_order2);
2257 extern void SplinePointPrevCPChanged2(SplinePoint *sp);
2258 extern void SplinePointNextCPChanged2(SplinePoint *sp);
2259 extern int IntersectLines(BasePoint *inter,
2260         BasePoint *line1_1, BasePoint *line1_2,
2261         BasePoint *line2_1, BasePoint *line2_2);
2262 extern int IntersectLinesClip(BasePoint *inter,
2263         BasePoint *line1_1, BasePoint *line1_2,
2264         BasePoint *line2_1, BasePoint *line2_2);
2265
2266 #if 0
2267 extern void SSBisectTurners(SplineSet *spl);
2268 #endif
2269 extern SplineSet *SplineSetStroke(SplineSet *spl,StrokeInfo *si,SplineChar *sc);
2270 extern SplineSet *SSStroke(SplineSet *spl,StrokeInfo *si,SplineChar *sc);
2271 extern SplineSet *SplineSetRemoveOverlap(SplineChar *sc,SplineSet *base,enum overlap_type);
2272 extern SplineSet *SSShadow(SplineSet *spl,real angle, real outline_width,
2273         real shadow_length,SplineChar *sc, int wireframe);
2274
2275 extern double BlueScaleFigureForced(struct psdict *private,real bluevalues[], real otherblues[]);
2276 extern double BlueScaleFigure(struct psdict *private,real bluevalues[], real otherblues[]);
2277 extern void FindBlues( SplineFont *sf, int layer, real blues[14], real otherblues[10]);
2278 extern void QuickBlues(SplineFont *sf, int layer, BlueData *bd);
2279 extern void FindHStems( SplineFont *sf, real snaps[12], real cnt[12]);
2280 extern void FindVStems( SplineFont *sf, real snaps[12], real cnt[12]);
2281 extern double SFStdVW(SplineFont *sf);
2282 extern int SplineCharIsFlexible(SplineChar *sc,int layer);
2283 extern void SCGuessHintInstancesList(SplineChar *sc,int layer,StemInfo *hstem,StemInfo *vstem,DStemInfo *dstem,int hvforce,int dforce);
2284 extern void SCGuessDHintInstances(SplineChar *sc, int layer,DStemInfo *ds );
2285 extern void SCGuessHHintInstancesAndAdd(SplineChar *sc, int layer,StemInfo *stem, real guess1, real guess2);
2286 extern void SCGuessVHintInstancesAndAdd(SplineChar *sc, int layer,StemInfo *stem, real guess1, real guess2);
2287 extern void SCGuessHHintInstancesList(SplineChar *sc, int layer);
2288 extern void SCGuessVHintInstancesList(SplineChar *sc, int layer);
2289 extern real HIlen( StemInfo *stems);
2290 extern real HIoverlap( HintInstance *mhi, HintInstance *thi);
2291 extern int StemInfoAnyOverlaps(StemInfo *stems);
2292 extern int StemListAnyConflicts(StemInfo *stems);
2293 extern HintInstance *HICopyTrans(HintInstance *hi, real mul, real offset);
2294 extern void MDAdd(SplineChar *sc, int x, SplinePoint *sp1, SplinePoint *sp2);
2295 extern int SFNeedsAutoHint( SplineFont *_sf,int layer);
2296
2297 typedef struct bluezone {
2298     real base;
2299     int cvtindex;
2300     real family_base;      /* NaN if none */
2301     int family_cvtindex;
2302     real overshoot;        /* relative to baseline, NOT to base */
2303     int highest;           /* used in autoinstructing for HStem positioning */
2304     int lowest;            /* as above */
2305 } BlueZone;
2306
2307 typedef struct stdstem {
2308     real width;            /* -1 if none */
2309     int cvtindex;
2310     struct stdstem *snapto;/* NULL means stem isn't snapped to any other */
2311     int stopat;            /* at which ppem stop snapping to snapto */
2312 } StdStem;
2313
2314 typedef struct globalinstrct {
2315     SplineFont *sf;
2316     int layer;
2317     BlueData *bd;
2318     double fudge;
2319
2320     /* Did we initialize the tables needed? 'maxp' is skipped because */
2321     /* its initialization always succeeds. */
2322     int cvt_done;
2323     int fpgm_done;
2324     int prep_done;
2325
2326     /* PS private data with truetype-specific information added */
2327     BlueZone blues[12];    /* like in BlueData */
2328     int      bluecnt;
2329     StdStem  stdhw;
2330     StdStem  *stemsnaph;   /* StdHW excluded */
2331     int      stemsnaphcnt;
2332     StdStem  stdvw;
2333     StdStem  *stemsnapv;   /* StdVW excluded */
2334     int      stemsnapvcnt;
2335 } GlobalInstrCt;
2336
2337 extern void InitGlobalInstrCt( GlobalInstrCt *gic,SplineFont *sf,int layer,
2338         BlueData *bd );
2339 extern void FreeGlobalInstrCt( GlobalInstrCt *gic );
2340 extern void NowakowskiSCAutoInstr( GlobalInstrCt *gic,SplineChar *sc );
2341 extern void CVT_ImportPrivate(SplineFont *sf);
2342
2343 extern void SCModifyHintMasksAdd(SplineChar *sc,int layer,StemInfo *new);
2344 extern void SCClearHints(SplineChar *sc);
2345 extern void SCClearHintMasks(SplineChar *sc,int layer,int counterstoo);
2346 extern void SCFigureVerticalCounterMasks(SplineChar *sc);
2347 extern void SCFigureCounterMasks(SplineChar *sc);
2348 extern void SCFigureHintMasks(SplineChar *sc,int layer);
2349 extern void _SplineCharAutoHint( SplineChar *sc, int layer, BlueData *bd, struct glyphdata *gd2, int gen_undoes );
2350 extern void SplineCharAutoHint( SplineChar *sc,int layer, BlueData *bd);
2351 extern void SFSCAutoHint( SplineChar *sc,int layer,BlueData *bd);
2352 extern void SplineFontAutoHint( SplineFont *sf, int layer);
2353 extern void SplineFontAutoHintRefs( SplineFont *sf, int layer);
2354 extern StemInfo *HintCleanup(StemInfo *stem,int dosort,int instance_count);
2355 extern int SplineFontIsFlexible(SplineFont *sf,int layer, int flags);
2356 extern int SCDrawsSomething(SplineChar *sc);
2357 #define SCWorthOutputting(a) 1
2358 extern int SFFindNotdef(SplineFont *sf, int fixed);
2359 extern int doesGlyphExpandHorizontally(SplineChar *sc);
2360 extern int IsntBDFChar(BDFChar *bdfc);
2361 extern int CIDWorthOutputting(SplineFont *cidmaster, int enc); /* Returns -1 on failure, font number on success */
2362 extern int AmfmSplineFont(FILE *afm, MMSet *mm,int formattype,EncMap *map,int layer);
2363 extern int AfmSplineFont(FILE *afm, SplineFont *sf,int formattype,EncMap *map, int docc, SplineFont *fullsf,int layer);
2364 extern int PfmSplineFont(FILE *pfm, SplineFont *sf,int type0,EncMap *map,int layer);
2365 extern int TfmSplineFont(FILE *afm, SplineFont *sf,int formattype,EncMap *map,int layer);
2366 extern int OfmSplineFont(FILE *afm, SplineFont *sf,int formattype,EncMap *map,int layer);
2367 extern char *EncodingName(Encoding *map);
2368 extern char *SFEncodingName(SplineFont *sf,EncMap *map);
2369 extern void SFLigaturePrepare(SplineFont *sf);
2370 extern void SFLigatureCleanup(SplineFont *sf);
2371 extern void SFKernClassTempDecompose(SplineFont *sf,int isv);
2372 extern void SFKernCleanup(SplineFont *sf,int isv);
2373 extern int SCSetMetaData(SplineChar *sc,char *name,int unienc,
2374         const char *comment);
2375
2376 extern enum uni_interp interp_from_encoding(Encoding *enc,enum uni_interp interp);
2377 extern const char *EncName(Encoding *encname);
2378 extern const char*FindUnicharName(void);
2379 extern Encoding *_FindOrMakeEncoding(const char *name,int make_it);
2380 extern Encoding *FindOrMakeEncoding(const char *name);
2381 extern int SFDWrite(char *filename,SplineFont *sf,EncMap *map,EncMap *normal, int todir);
2382 extern int SFDWriteBak(SplineFont *sf,EncMap *map,EncMap *normal);
2383 extern SplineFont *SFDRead(char *filename);
2384 extern SplineFont *_SFDRead(char *filename,FILE *sfd);
2385 extern SplineFont *SFDirRead(char *filename);
2386 extern SplineChar *SFDReadOneChar(SplineFont *sf,const char *name);
2387 extern char *TTFGetFontName(FILE *ttf,int32 offset,int32 off2);
2388 extern char *TTFGetPSFontName(FILE *ttf,int32 offset,int32 off2);
2389 extern void TTFLoadBitmaps(FILE *ttf,struct ttfinfo *info, int onlyone);
2390 enum ttfflags { ttf_onlystrikes=1, ttf_onlyonestrike=2, ttf_onlykerns=4, ttf_onlynames=8 };
2391 extern SplineFont *_SFReadTTF(FILE *ttf,int flags,enum openflags openflags,
2392         char *filename,struct fontdict *fd);
2393 extern SplineFont *SFReadTTF(char *filename,int flags,enum openflags openflags);
2394 extern SplineFont *SFReadSVG(char *filename,int flags);
2395 extern SplineFont *SFReadUFO(char *filename,int flags);
2396 extern SplineFont *_CFFParse(FILE *temp,int len,char *fontsetname);
2397 extern SplineFont *CFFParse(char *filename);
2398 extern SplineFont *SFReadMacBinary(char *filename,int flags,enum openflags openflags);
2399 extern SplineFont *SFReadWinFON(char *filename,int toback);
2400 extern SplineFont *SFReadPalmPdb(char *filename,int toback);
2401 extern SplineFont *LoadSplineFont(char *filename,enum openflags);
2402 extern SplineFont *_ReadSplineFont(FILE *file,char *filename, enum openflags openflags);
2403 extern SplineFont *ReadSplineFont(char *filename,enum openflags);       /* Don't use this, use LoadSF instead */
2404 extern FILE *URLToTempFile(char *url,void *lock);
2405 extern int URLFromFile(char *url,FILE *from);
2406 extern int HttpGetBuf(char *url, char *databuf, int *datalen, void *mutex);
2407 extern void ArchiveCleanup(char *archivedir);
2408 extern char *Unarchive(char *name, char **_archivedir);
2409 extern char *Decompress(char *name, int compression);
2410 extern SplineFont *SFFromBDF(char *filename,int ispk,int toback);
2411 extern SplineFont *SFFromMF(char *filename);
2412 extern void SFCheckPSBitmap(SplineFont *sf);
2413 extern uint16 _MacStyleCode( char *styles, SplineFont *sf, uint16 *psstyle );
2414 extern uint16 MacStyleCode( SplineFont *sf, uint16 *psstyle );
2415 extern SplineFont *SFReadIkarus(char *fontname);
2416 extern SplineFont *_SFReadPdfFont(FILE *ttf,char *filename,char *select_this_font, enum openflags openflags);
2417 extern SplineFont *SFReadPdfFont(char *filename, enum openflags openflags);
2418 extern char **GetFontNames(char *filename);
2419 extern char **NamesReadSFD(char *filename);
2420 extern char **NamesReadTTF(char *filename);
2421 extern char **NamesReadCFF(char *filename);
2422 extern char **NamesReadPostscript(char *filename);
2423 extern char **_NamesReadPostscript(FILE *ps);
2424 extern char **NamesReadSVG(char *filename);
2425 extern char **NamesReadUFO(char *filename);
2426 extern char **NamesReadMacBinary(char *filename);
2427
2428 extern void SFSetOrder(SplineFont *sf,int order2);
2429 extern int SFFindOrder(SplineFont *sf);
2430
2431 extern const char *UnicodeRange(int unienc);
2432 extern SplineChar *SCBuildDummy(SplineChar *dummy,SplineFont *sf,EncMap *map,int i);
2433 extern SplineChar *SFMakeChar(SplineFont *sf,EncMap *map,int i);
2434 extern char *AdobeLigatureFormat(char *name);
2435 extern uint32 LigTagFromUnicode(int uni);
2436 extern void SCLigCaretheck(SplineChar *sc,int clean);
2437 extern BDFChar *BDFMakeGID(BDFFont *bdf,int gid);
2438 extern BDFChar *BDFMakeChar(BDFFont *bdf,EncMap *map,int enc);
2439
2440 extern RefChar *RefCharsCopyState(SplineChar *sc,int layer);
2441 extern int SCWasEmpty(SplineChar *sc, int skip_this_layer);
2442 extern void SCUndoSetLBearingChange(SplineChar *sc,int lb);
2443 extern Undoes *SCPreserveHints(SplineChar *sc,int layer);
2444 extern Undoes *SCPreserveLayer(SplineChar *sc,int layer,int dohints);
2445 extern Undoes *SCPreserveState(SplineChar *sc,int dohints);
2446 extern Undoes *SCPreserveBackground(SplineChar *sc);
2447 extern Undoes *SFPreserveGuide(SplineFont *sf);
2448 extern Undoes *SCPreserveWidth(SplineChar *sc);
2449 extern Undoes *SCPreserveVWidth(SplineChar *sc);
2450 extern Undoes *BCPreserveState(BDFChar *bc);
2451 extern void BCDoRedo(BDFChar *bc);
2452 extern void BCDoUndo(BDFChar *bc);
2453
2454 extern int isaccent(int uni);
2455 extern int SFIsCompositBuildable(SplineFont *sf,int unicodeenc,SplineChar *sc, int layer);
2456 extern int SFIsSomethingBuildable(SplineFont *sf,SplineChar *sc, int layer,int onlyaccents);
2457 extern int SFIsRotatable(SplineFont *sf,SplineChar *sc, int layer);
2458 extern int SCMakeDotless(SplineFont *sf, SplineChar *dotless, int layer, int copybmp, int doit);
2459 extern void SCBuildComposit(SplineFont *sf, SplineChar *sc, int layer, int copybmp);
2460 extern int SCAppendAccent(SplineChar *sc,int layer, char *glyph_name,int uni,int pos);
2461 extern const unichar_t *SFGetAlternate(SplineFont *sf, int base,SplineChar *sc,int nocheck);
2462
2463 extern int getAdobeEnc(char *name);
2464
2465 extern void SFSplinesFromLayers(SplineFont *sf,int tostroke);
2466 extern void SFSetLayerWidthsStroked(SplineFont *sf, real strokewidth);
2467 extern SplineSet *SplinePointListInterpretSVG(char *filename,char *memory, int memlen, int em_size, int ascent,int stroked);
2468 extern SplineSet *SplinePointListInterpretGlif(char *filename,char *memory, int memlen, int em_size, int ascent,int stroked);
2469 #define UNDEFINED_WIDTH -999999
2470 extern SplinePointList *SplinePointListInterpretPS(FILE *ps,int flags,int stroked,int *width);
2471 extern void PSFontInterpretPS(FILE *ps,struct charprocs *cp,char **encoding);
2472 extern struct enc *PSSlurpEncodings(FILE *file);
2473 extern int EvaluatePS(char *str,real *stack,int size);
2474 struct pscontext {
2475     int is_type2;
2476     int painttype;
2477     int instance_count;
2478     real blend_values[17];
2479     int blend_warn;
2480 };
2481 extern int UnblendedCompare(real u1[MmMax], real u2[MmMax], int cnt);
2482 extern SplineChar *PSCharStringToSplines(uint8 *type1, int len, struct pscontext *context,
2483         struct pschars *subrs, struct pschars *gsubrs, const char *name);
2484 extern SplineChar *PSCharStringToBB(uint8 *type1, int len, struct pscontext *context,
2485         struct pschars *subrs, struct pschars *gsubrs, const char *name);
2486 extern void MatMultiply(real m1[6], real m2[6], real to[6]);
2487
2488 extern int NameToEncoding(SplineFont *sf,EncMap *map,const char *uname);
2489 extern void GlyphHashFree(SplineFont *sf);
2490 extern void SFHashGlyph(SplineFont *sf,SplineChar *sc);
2491 extern SplineChar *SFHashName(SplineFont *sf,const char *name);
2492 extern int SFFindGID(SplineFont *sf, int unienc, const char *name );
2493 extern int SFFindSlot(SplineFont *sf, EncMap *map, int unienc, const char *name );
2494 extern int SFCIDFindCID(SplineFont *sf, int unienc, const char *name );
2495 extern SplineChar *SFGetChar(SplineFont *sf, int unienc, const char *name );
2496 extern int SFHasChar(SplineFont *sf, int unienc, const char *name );
2497 extern SplineChar *SFGetOrMakeChar(SplineFont *sf, int unienc, const char *name );
2498 extern int SFFindExistingSlot(SplineFont *sf, int unienc, const char *name );
2499 extern int SFCIDFindExistingChar(SplineFont *sf, int unienc, const char *name );
2500 extern int SFHasCID(SplineFont *sf, int cid);
2501
2502 extern char *getPfaEditDir(char *buffer);
2503 extern void _DoAutoSaves(struct fontviewbase *);
2504 extern void CleanAutoRecovery(void);
2505 extern int DoAutoRecovery(int);
2506 extern SplineFont *SFRecoverFile(char *autosavename,int inquire, int *state);
2507 extern void SFAutoSave(SplineFont *sf,EncMap *map);
2508 extern void SFClearAutoSave(SplineFont *sf);
2509
2510 extern void PSCharsFree(struct pschars *chrs);
2511 extern void PSDictFree(struct psdict *chrs);
2512 extern struct psdict *PSDictCopy(struct psdict *dict);
2513 extern int PSDictFindEntry(struct psdict *dict, char *key);
2514 extern char *PSDictHasEntry(struct psdict *dict, char *key);
2515 extern int PSDictRemoveEntry(struct psdict *dict, char *key);
2516 extern int PSDictChangeEntry(struct psdict *dict, char *key, char *newval);
2517 extern int SFPrivateGuess(SplineFont *sf,int layer, struct psdict *private,
2518         char *name, int onlyone);
2519
2520 extern void SFRemoveLayer(SplineFont *sf,int l);
2521 extern void SFAddLayer(SplineFont *sf,char *name,int order2, int background);
2522 extern void SFLayerSetBackground(SplineFont *sf,int layer,int is_back);
2523
2524 extern void SplineSetsRound2Int(SplineSet *spl,real factor,int inspiro,int onlysel);
2525 extern void SCRound2Int(SplineChar *sc,int layer, real factor);
2526 extern int SCRoundToCluster(SplineChar *sc,int layer,int sel,double within,double max);
2527 extern int SplineSetsRemoveAnnoyingExtrema(SplineSet *ss,double err);
2528 extern int hascomposing(SplineFont *sf,int u,SplineChar *sc);
2529 #if 0
2530 extern void SFFigureGrid(SplineFont *sf);
2531 #endif
2532
2533 struct cidmap;                  /* private structure to encoding.c */
2534 extern int CIDFromName(char *name,SplineFont *cidmaster);
2535 extern int CID2Uni(struct cidmap *map,int cid);
2536 extern int CID2NameUni(struct cidmap *map,int cid, char *buffer, int len);
2537 extern int NameUni2CID(struct cidmap *map,int uni, const char *name);
2538 extern int MaxCID(struct cidmap *map);
2539 extern struct cidmap *FindCidMap(char *registry,char *ordering,int supplement,
2540         SplineFont *sf);
2541 extern void SFEncodeToMap(SplineFont *sf,struct cidmap *map);
2542 extern SplineFont *CIDFlatten(SplineFont *cidmaster,SplineChar **chars,int charcnt);
2543 extern void SFFlatten(SplineFont *cidmaster);
2544 extern int  SFFlattenByCMap(SplineFont *sf,char *cmapname);
2545 extern SplineFont *MakeCIDMaster(SplineFont *sf,EncMap *oldmap,int bycmap,char *cmapfilename,struct cidmap *cidmap);
2546
2547 int getushort(FILE *ttf);
2548 int32 getlong(FILE *ttf);
2549 int get3byte(FILE *ttf);
2550 real getfixed(FILE *ttf);
2551 real get2dot14(FILE *ttf);
2552 void putshort(FILE *file,int sval);
2553 void putlong(FILE *file,int val);
2554 void putfixed(FILE *file,real dval);
2555 int ttfcopyfile(FILE *ttf, FILE *other, int pos, char *table_name);
2556
2557 extern void SCCopyLayerToLayer(SplineChar *sc, int from, int to,int doclear);
2558
2559 extern int hasFreeType(void);
2560 extern int hasFreeTypeDebugger(void);
2561 extern int hasFreeTypeByteCode(void);
2562 extern int FreeTypeAtLeast(int major, int minor, int patch);
2563 extern void doneFreeType(void);
2564 extern void *_FreeTypeFontContext(SplineFont *sf,SplineChar *sc,struct fontviewbase *fv,
2565         int layer, enum fontformat ff,int flags,void *shared_ftc);
2566 extern void *FreeTypeFontContext(SplineFont *sf,SplineChar *sc,struct fontviewbase *fv,int layer);
2567 extern BDFFont *SplineFontFreeTypeRasterize(void *freetypecontext,int pixelsize,int depth);
2568 extern BDFChar *SplineCharFreeTypeRasterize(void *freetypecontext,int gid,
2569         int pixelsize,int depth);
2570 extern void FreeTypeFreeContext(void *freetypecontext);
2571 extern SplineSet *FreeType_GridFitChar(void *single_glyph_context,
2572         int enc, real ptsizey, real ptsizex, int dpi, uint16 *width, SplineChar *sc, int depth);
2573 extern struct freetype_raster *FreeType_GetRaster(void *single_glyph_context,
2574         int enc, real ptsizey, real ptsizex, int dpi,int depth);
2575 extern BDFChar *SplineCharFreeTypeRasterizeNoHints(SplineChar *sc,int layer,
2576         int pixelsize,int depth);
2577 extern BDFFont *SplineFontFreeTypeRasterizeNoHints(SplineFont *sf,int layer,
2578         int pixelsize,int depth);
2579 extern void FreeType_FreeRaster(struct freetype_raster *raster);
2580 struct TT_ExecContextRec_;
2581 extern struct freetype_raster *DebuggerCurrentRaster(struct  TT_ExecContextRec_ *exc,int depth);
2582
2583 extern int UniFromName(const char *name,enum uni_interp interp, Encoding *encname);
2584 extern const char *StdGlyphName(char *buffer, int uni, enum uni_interp interp, NameList *for_this_font);
2585 extern char **AllGlyphNames(int uni, NameList *for_this_font,SplineChar *sc/* May be NULL*/);
2586 extern char **AllNamelistNames(void);
2587 extern NameList *DefaultNameListForNewFonts(void);
2588 extern NameList *NameListByName(char *name);
2589 extern NameList *LoadNamelist(char *filename);
2590 extern void LoadNamelistDir(char *dir);
2591 extern const char *RenameGlyphToNamelist(char *buffer, SplineChar *sc,NameList *old,NameList *new);
2592 extern void SFRenameGlyphsToNamelist(SplineFont *sf,NameList *new);
2593 extern char **SFTemporaryRenameGlyphsToNamelist(SplineFont *sf,NameList *new);
2594 extern void SFTemporaryRestoreGlyphNames(SplineFont *sf,char **former);
2595
2596 extern void doversion(const char *);
2597
2598 extern AnchorPos *AnchorPositioning(SplineChar *sc,unichar_t *ustr,SplineChar **sstr );
2599 extern void AnchorPosFree(AnchorPos *apos);
2600
2601 extern int  SF_CloseAllInstrs(SplineFont *sf);
2602 extern int  SSTtfNumberPoints(SplineSet *ss);
2603 extern int  SCNumberPoints(SplineChar *sc,int layer);
2604 extern int  SCPointsNumberedProperly(SplineChar *sc,int layer);
2605 extern int  ttfFindPointInSC(SplineChar *sc,int layer,int pnum,BasePoint *pos,
2606         RefChar *bound);
2607
2608 int SFFigureDefWidth(SplineFont *sf, int *_nomwid);
2609
2610 extern int SFRenameTheseFeatureTags(SplineFont *sf, uint32 tag, int sli, int flags,
2611         uint32 totag, int tosli, int toflags, int ismac);
2612 extern int SFRemoveUnusedNestedFeatures(SplineFont *sf);
2613
2614 extern char *utf8_verify_copy(const char *str);
2615
2616 extern char *MacStrToUtf8(const char *str,int macenc,int maclang);
2617 extern char *Utf8ToMacStr(const char *ustr,int macenc,int maclang);
2618 extern uint8 MacEncFromMacLang(int maclang);
2619 extern uint16 WinLangFromMac(int maclang);
2620 extern uint16 WinLangToMac(int winlang);
2621 extern int CanEncodingWinLangAsMac(int winlang);
2622 extern const int32 *MacEncToUnicode(int script,int lang);
2623 extern int MacLangFromLocale(void);
2624 extern char *MacLanguageFromCode(int code);
2625
2626 extern int32 UniFromEnc(int enc, Encoding *encname);
2627 extern int32 EncFromUni(int32 uni, Encoding *encname);
2628 extern int32 EncFromName(const char *name,enum uni_interp interp,Encoding *encname);
2629
2630 extern void MatInverse(real into[6], real orig[6]);
2631
2632 extern int BpColinear(BasePoint *first, BasePoint *mid, BasePoint *last);
2633
2634 enum psstrokeflags { sf_toobigwarn=1, sf_removeoverlap=2, sf_handle_eraser=4,
2635         sf_correctdir=8, sf_clearbeforeinput=16 };
2636
2637 extern char *MMAxisAbrev(char *axis_name);
2638 extern char *MMMakeMasterFontname(MMSet *mm,int ipos,char **fullname);
2639 extern char *MMGuessWeight(MMSet *mm,int ipos,char *def);
2640 extern char *MMExtractNth(char *pt,int ipos);
2641 extern char *MMExtractArrayNth(char *pt,int ipos);
2642 extern int MMValid(MMSet *mm,int complain);
2643 extern void MMKern(SplineFont *sf,SplineChar *first,SplineChar *second,int diff,
2644         struct lookup_subtable *sub,KernPair *oldkp);
2645 extern char *MMBlendChar(MMSet *mm, int gid);
2646
2647 extern char *EnforcePostScriptName(char *old);
2648
2649 extern char *ToAbsolute(char *filename);
2650
2651 enum Compare_Ret {      SS_DiffContourCount     = 1,
2652                         SS_MismatchOpenClosed   = 2,
2653                         SS_DisorderedContours   = 4,
2654                         SS_DisorderedStart      = 8,
2655                         SS_DisorderedDirection  = 16,
2656                         SS_PointsMatch          = 32,
2657                         SS_ContourMatch         = 64,
2658                         SS_NoMatch              = 128,
2659                         SS_RefMismatch          = 256,
2660                         SS_WidthMismatch        = 512,
2661                         SS_VWidthMismatch       = 1024,
2662                         SS_HintMismatch         = 2048,
2663                         SS_HintMaskMismatch     = 4096,
2664                         SS_LayerCntMismatch     = 8192,
2665                         SS_ContourMismatch      = 16384,
2666                         SS_UnlinkRefMatch       = 32768,
2667
2668                         BC_DepthMismatch        = 1<<16,
2669                         BC_BoundingBoxMismatch  = 2<<16,
2670                         BC_BitmapMismatch       = 4<<16,
2671                         BC_NoMatch              = 8<<16,
2672                         BC_Match                = 16<<16,
2673
2674                         SS_RefPtMismatch        = 32<<16
2675                 };
2676
2677 extern enum Compare_Ret BitmapCompare(BDFChar *bc1, BDFChar *bc2, int err, int bb_err);
2678 extern enum Compare_Ret SSsCompare(const SplineSet *ss1, const SplineSet *ss2,
2679         real pt_err, real spline_err, SplinePoint **hmfail);
2680 enum font_compare_flags { fcf_outlines=1, fcf_exact=2, fcf_warn_not_exact=4,
2681         fcf_hinting=8, fcf_hintmasks=0x10, fcf_hmonlywithconflicts=0x20,
2682         fcf_warn_not_ref_exact=0x40,
2683         fcf_bitmaps=0x80, fcf_names = 0x100, fcf_gpos=0x200, fcf_gsub=0x400,
2684         fcf_adddiff2sf1=0x800, fcf_addmissing=0x1000 };
2685 extern int CompareFonts(SplineFont *sf1, EncMap *map1, SplineFont *sf2,
2686         FILE *diffs, int flags);
2687 extern int LayersSimilar(Layer *ly1, Layer *ly2, double spline_err);
2688
2689
2690 # if HANYANG
2691 extern void SFDDumpCompositionRules(FILE *sfd,struct compositionrules *rules);
2692 extern struct compositionrules *SFDReadCompositionRules(FILE *sfd);
2693 extern void SFModifyComposition(SplineFont *sf);
2694 extern void SFBuildSyllables(SplineFont *sf);
2695 # endif
2696
2697 extern void DefaultOtherSubrs(void);
2698 extern int ReadOtherSubrsFile(char *filename);
2699
2700 extern char *utf8toutf7_copy(const char *_str);
2701 extern char *utf7toutf8_copy(const char *_str);
2702
2703 extern void SFSetModTime(SplineFont *sf);
2704 extern void SFTimesFromFile(SplineFont *sf,FILE *);
2705
2706 extern int SFHasInstructions(SplineFont *sf);
2707 extern int RefDepth(RefChar *ref,int layer);
2708
2709 extern SplineChar *SCHasSubs(SplineChar *sc,uint32 tag);
2710
2711 extern char *TagFullName(SplineFont *sf,uint32 tag, int onlyifknown);
2712
2713 extern uint32 *SFScriptsInLookups(SplineFont *sf,int gpos);
2714 extern uint32 *SFLangsInScript(SplineFont *sf,int gpos,uint32 script);
2715 extern uint32 *SFFeaturesInScriptLang(SplineFont *sf,int gpos,uint32 script,uint32 lang);
2716 extern OTLookup **SFLookupsInScriptLangFeature(SplineFont *sf,int gpos,uint32 script,uint32 lang, uint32 feature);
2717 extern SplineChar **SFGlyphsWithPSTinSubtable(SplineFont *sf,struct lookup_subtable *subtable);
2718 extern SplineChar **SFGlyphsWithLigatureinLookup(SplineFont *sf,struct lookup_subtable *subtable);
2719 extern void SFFindUnusedLookups(SplineFont *sf);
2720 extern void SFFindClearUnusedLookupBits(SplineFont *sf);
2721 extern int LookupUsedNested(SplineFont *sf,OTLookup *checkme);
2722 extern void SFRemoveUnusedLookupSubTables(SplineFont *sf,
2723         int remove_incomplete_anchorclasses,
2724         int remove_unused_lookups);
2725 extern void SFRemoveLookupSubTable(SplineFont *sf,struct lookup_subtable *sub);
2726 extern void SFRemoveLookup(SplineFont *sf,OTLookup *otl);
2727 extern struct lookup_subtable *SFFindLookupSubtable(SplineFont *sf,char *name);
2728 extern struct lookup_subtable *SFFindLookupSubtableAndFreeName(SplineFont *sf,char *name);
2729 extern OTLookup *SFFindLookup(SplineFont *sf,char *name);
2730 extern void NameOTLookup(OTLookup *otl,SplineFont *sf);
2731 extern void FListAppendScriptLang(FeatureScriptLangList *fl,uint32 script_tag,uint32 lang_tag);
2732 extern void FListsAppendScriptLang(FeatureScriptLangList *fl,uint32 script_tag,uint32 lang_tag);
2733 struct scriptlanglist *SLCopy(struct scriptlanglist *sl);
2734 struct scriptlanglist *SListCopy(struct scriptlanglist *sl);
2735 extern FeatureScriptLangList *FeatureListCopy(FeatureScriptLangList *fl);
2736 extern void SLMerge(FeatureScriptLangList *into, struct scriptlanglist *fsl);
2737 extern void FLMerge(OTLookup *into, OTLookup *from);
2738 extern FeatureScriptLangList *FLOrder(FeatureScriptLangList *fl);
2739 extern int FeatureScriptTagInFeatureScriptList(uint32 tag, uint32 script, FeatureScriptLangList *fl);
2740 extern FeatureScriptLangList *FindFeatureTagInFeatureScriptList(uint32 tag, FeatureScriptLangList *fl);
2741 extern int FeatureTagInFeatureScriptList(uint32 tag, FeatureScriptLangList *fl);
2742 extern int DefaultLangTagInOneScriptList(struct scriptlanglist *sl);
2743 extern struct scriptlanglist *DefaultLangTagInScriptList(struct scriptlanglist *sl, int DFLT_ok);
2744 extern int ScriptInFeatureScriptList(uint32 script, FeatureScriptLangList *fl);
2745 extern int _FeatureOrderId( int isgpos,uint32 tag );
2746 extern int FeatureOrderId( int isgpos,FeatureScriptLangList *fl );
2747 extern void SFSubTablesMerge(SplineFont *_sf,struct lookup_subtable *subfirst,
2748         struct lookup_subtable *subsecond);
2749 extern struct lookup_subtable *SFSubTableFindOrMake(SplineFont *sf,uint32 tag,uint32 script,
2750         int lookup_type );
2751 extern struct lookup_subtable *SFSubTableMake(SplineFont *sf,uint32 tag,uint32 script,
2752         int lookup_type );
2753 extern OTLookup *OTLookupCopyInto(SplineFont *into_sf,SplineFont *from_sf, OTLookup *from_otl);
2754 extern void OTLookupsCopyInto(SplineFont *into_sf,SplineFont *from_sf,
2755         OTLookup **from_list, OTLookup *before);
2756 extern struct opentype_str *ApplyTickedFeatures(SplineFont *sf,uint32 *flist, uint32 script, uint32 lang,
2757         int pixelsize, SplineChar **glyphs);
2758 extern int VerticalKernFeature(SplineFont *sf, OTLookup *otl, int ask);
2759
2760 struct sllk { uint32 script; int cnt, max; OTLookup **lookups; int lcnt, lmax; uint32 *langs; };
2761 extern void SllkFree(struct sllk *sllk,int sllk_cnt);
2762 extern struct sllk *AddOTLToSllks( OTLookup *otl, struct sllk *sllk,
2763         int *_sllk_cnt, int *_sllk_max );
2764 extern OTLookup *NewAALTLookup(SplineFont *sf,struct sllk *sllk, int sllk_cnt, int i);
2765 extern void AddNewAALTFeatures(SplineFont *sf);
2766
2767 extern void SplinePointRound(SplinePoint *,real);
2768
2769 extern int KCFindName(char *name, char **classnames, int cnt );
2770 extern int KCFindIndex(KernClass *kc,char *name1, char *name2);
2771 extern KernClass *SFFindKernClass(SplineFont *sf,SplineChar *first,SplineChar *last,
2772         int *index,int allow_zero);
2773 extern KernClass *SFFindVKernClass(SplineFont *sf,SplineChar *first,SplineChar *last,
2774         int *index,int allow_zero);
2775
2776 extern void SCClearRounds(SplineChar *sc,int layer);
2777 extern void MDReplace(MinimumDistance *md,SplineSet *old,SplineSet *rpl);
2778 extern void SCSynchronizeWidth(SplineChar *sc,real newwidth, real oldwidth,struct fontviewbase *fv);
2779 extern RefChar *HasUseMyMetrics(SplineChar *sc,int layer);
2780 extern void SCSynchronizeLBearing(SplineChar *sc,real off,int layer);
2781 extern void RevertedGlyphReferenceFixup(SplineChar *sc, SplineFont *sf);
2782
2783 extern void SFUntickAll(SplineFont *sf);
2784
2785 extern void BDFOrigFixup(BDFFont *bdf,int orig_cnt,SplineFont *sf);
2786
2787 extern int HasSVG(void);
2788 extern void SCImportSVG(SplineChar *sc,int layer,char *path,char  *memory, int memlen,int doclear);
2789 extern int HasUFO(void);
2790 extern void SCImportGlif(SplineChar *sc,int layer,char *path,char  *memory, int memlen,int doclear);
2791 extern void SCImportPS(SplineChar *sc,int layer,char *path,int doclear, int flags);
2792 extern void SCImportPSFile(SplineChar *sc,int layer,FILE *ps,int doclear,int flags);
2793 extern void SCImportPDF(SplineChar *sc,int layer,char *path,int doclear, int flags);
2794 extern void SCImportPDFFile(SplineChar *sc,int layer,FILE *ps,int doclear,int flags);
2795 extern void SCImportPlateFile(SplineChar *sc,int layer,FILE *plate,int doclear,int flags);
2796 extern void SCAddScaleImage(SplineChar *sc,struct gimage *image,int doclear,int layer);
2797 extern void SCInsertImage(SplineChar *sc,struct gimage *image,real scale,real yoff, real xoff, int layer);
2798 extern void SCImportFig(SplineChar *sc,int layer,char *path,int doclear);
2799
2800 extern int _ExportPlate(FILE *pdf,SplineChar *sc,int layer);
2801 extern int _ExportPDF(FILE *pdf,SplineChar *sc,int layer);
2802 extern int _ExportEPS(FILE *eps,SplineChar *sc,int layer, int gen_preview);
2803 extern int _ExportSVG(FILE *svg,SplineChar *sc,int layer);
2804 extern int _ExportGlif(FILE *glif,SplineChar *sc,int layer);
2805 extern int ExportEPS(char *filename,SplineChar *sc,int layer);
2806 extern int ExportPDF(char *filename,SplineChar *sc,int layer);
2807 extern int ExportPlate(char *filename,SplineChar *sc,int layer);
2808 extern int ExportSVG(char *filename,SplineChar *sc,int layer);
2809 extern int ExportGlif(char *filename,SplineChar *sc,int layer);
2810 extern int ExportFig(char *filename,SplineChar *sc,int layer);
2811 extern int BCExportXBM(char *filename,BDFChar *bdfc, int format);
2812 extern int ExportImage(char *filename,SplineChar *sc, int layer, int format, int pixelsize, int bitsperpixel);
2813 extern void ScriptExport(SplineFont *sf, BDFFont *bdf, int format, int gid,
2814         char *format_spec, EncMap *map);
2815
2816 extern EncMap *EncMapFromEncoding(SplineFont *sf,Encoding *enc);
2817 extern void SFRemoveGlyph(SplineFont *sf,SplineChar *sc, int *flags);
2818 extern void SFAddEncodingSlot(SplineFont *sf,int gid);
2819 extern void SFAddGlyphAndEncode(SplineFont *sf,SplineChar *sc,EncMap *basemap, int baseenc);
2820 extern void SCDoRedo(SplineChar *sc,int layer);
2821 extern void SCDoUndo(SplineChar *sc,int layer);
2822 extern void SCCopyWidth(SplineChar *sc,enum undotype);
2823 extern void SCAppendPosSub(SplineChar *sc,enum possub_type type, char **d,SplineFont *copied_from);
2824 extern void SCClearBackground(SplineChar *sc);
2825 extern void BackgroundImageTransform(SplineChar *sc, ImageList *img,real transform[6]);
2826 extern int SFIsDuplicatable(SplineFont *sf, SplineChar *sc);
2827
2828 extern void DoAutoSaves(void);
2829
2830 extern void SCClearLayer(SplineChar *sc,int layer);
2831 extern void SCClearContents(SplineChar *sc,int layer);
2832 extern void SCClearAll(SplineChar *sc,int layer);
2833 extern void BCClearAll(BDFChar *bc);
2834
2835 #if !defined(_NO_PYTHON)
2836 extern void FontForge_PythonInit(void);
2837 extern void PyFF_ErrorString(const char *msg,const char *str);
2838 extern void PyFF_ErrorF3(const char *frmt, const char *str, int size, int depth);
2839 extern void PyFF_Stdin(void);
2840 extern void PyFF_Main(int argc,char **argv,int start);
2841 extern void PyFF_ScriptFile(struct fontviewbase *fv,SplineChar *sc,char *filename);
2842 extern void PyFF_ScriptString(struct fontviewbase *fv,SplineChar *sc,int layer,char *str);
2843 extern void PyFF_FreeFV(struct fontviewbase *fv);
2844 extern void PyFF_FreeSC(SplineChar *sc);
2845 extern void PyFF_FreeSF(SplineFont *sf);
2846 extern void PyFF_ProcessInitFiles(void);
2847 extern char *PyFF_PickleMeToString(void *pydata);
2848 extern void *PyFF_UnPickleMeToObjects(char *str);
2849 struct _object;         /* Python Object */
2850 extern void PyFF_CallDictFunc(struct _object *dict,char *key,char *argtypes, ... );
2851 extern void ff_init(void);
2852 #endif
2853 extern void doinitFontForgeMain(void);
2854
2855 extern void InitSimpleStuff(void);
2856
2857 extern int SSExistsInLayer(SplineSet *ss,SplineSet *lots );
2858 extern int SplineExistsInSS(Spline *s,SplineSet *ss);
2859 extern int SpExistsInSS(SplinePoint *sp,SplineSet *ss);
2860
2861 extern int MSLanguageFromLocale(void);
2862
2863 extern struct math_constants_descriptor {
2864     char *ui_name;
2865     char *script_name;
2866     int offset;
2867     int devtab_offset;
2868     char *message;
2869     int new_page;
2870 } math_constants_descriptor[];
2871
2872 extern int BPTooFar(BasePoint *bp1, BasePoint *bp2);
2873 extern char *VSErrorsFromMask(int mask,int private_mask);
2874 extern int SCValidate(SplineChar *sc, int layer, int force);
2875 extern AnchorClass *SCValidateAnchors(SplineChar *sc);
2876 extern void SCTickValidationState(SplineChar *sc,int layer);
2877 extern int ValidatePrivate(SplineFont *sf);
2878 extern int SFValidate(SplineFont *sf, int layer, int force);
2879 extern int VSMaskFromFormat(SplineFont *sf, int layer, enum fontformat format);
2880
2881 struct lang_frequencies;
2882 extern unichar_t *PrtBuildDef( SplineFont *sf, void *tf,
2883         void (*langsyscallback)(void *tf, int end, uint32 script, uint32 lang) );
2884 extern char *RandomParaFromScriptLang(uint32 script, uint32 lang, SplineFont *sf,
2885         struct lang_frequencies *freq);
2886 extern char *RandomParaFromScript(uint32 script, uint32 *lang, SplineFont *sf);
2887 extern int   SF2Scripts(SplineFont *sf,uint32 scripts[100]);
2888 extern char **SFScriptLangs(SplineFont *sf,struct lang_frequencies ***freq);
2889
2890 extern int SSHasClip(SplineSet *ss);
2891 extern int SSHasDrawn(SplineSet *ss);
2892 extern struct gradient *GradientCopy(struct gradient *old);
2893 extern void GradientFree(struct gradient *grad);
2894 extern struct pattern *PatternCopy(struct pattern *old);
2895 extern void PatternFree(struct pattern *pat);
2896 extern void BrushCopy(struct brush *into, struct brush *from);
2897 extern void PenCopy(struct pen *into, struct pen *from);
2898 extern void PatternSCBounds(SplineChar *sc,DBounds *b);
2899
2900 extern char *SFDefaultImage(SplineFont *sf,char *filename);
2901 extern void SCClearInstrsOrMark(SplineChar *sc, int layer, int complain);
2902 extern void instrcheck(SplineChar *sc,int layer);
2903 extern void TTFPointMatches(SplineChar *sc,int layer,int top);
2904
2905 #ifdef LUA_FF_LIB
2906 extern SplineFont *ReadSplineFontInfo(char *filename,enum openflags openflags); /* splinefont.c */
2907 extern SplineFont *SFReadTTFInfo(char *filename, int flags, enum openflags openflags);  /* parsettf.c */
2908 extern SplineFont *SFReadMacBinaryInfo(char *filename,int flags,enum openflags openflags); /* macbinary.c */
2909 #endif
2910
2911
2912
2913 #endif