diff options
Diffstat (limited to 'Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.h')
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.h | 3044 |
1 files changed, 3044 insertions, 0 deletions
diff --git a/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.h b/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.h new file mode 100644 index 00000000000..fa989d61543 --- /dev/null +++ b/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/splinefont.h @@ -0,0 +1,3044 @@ +/* Copyright (C) 2000-2008 by George Williams */ +/* + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + + * The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef _SPLINEFONT_H +#define _SPLINEFONT_H + +#include "basics.h" +#include "configure-pfaedit.h" +#ifdef HAVE_ICONV_H +# include <iconv.h> +/* libiconv.h defines iconv as taking a const pointer for inbuf. iconv doesn't*/ +# ifdef _LIBICONV_VERSION +# define ICONV_CONST const +# else +# define ICONV_CONST +# endif +#else +# include <gwwiconv.h> +# define ICONV_CONST +#endif + +#if defined( FONTFORGE_CONFIG_USE_LONGDOUBLE ) +# define real long double +# define bigreal long double +#elif defined( FONTFORGE_CONFIG_USE_DOUBLE ) +# define real double +# define bigreal double +#else +# define real float +# define bigreal double +#endif + +#if defined( HAVE_LONG_DOUBLE ) && defined( This_does_not_seem_to_make_a_difference ) +# define extended long double +# define CheckExtremaForSingleBitErrors(sp,t) (t) +# define EXTENDED_IS_LONG_DOUBLE 1 +#else +# define extended double +#endif + /* Solaris wants to define extended to be unsigned [3] unless we do this*/ +#define _EXTENDED + +#define CHR(ch1,ch2,ch3,ch4) (((ch1)<<24)|((ch2)<<16)|((ch3)<<8)|(ch4)) + +#define MmMax 16 /* PS says at most this many instances for type1/2 mm fonts */ +#define AppleMmMax 26 /* Apple sort of has a limit of 4095, but we only support this many */ + +typedef struct ipoint { + int x; + int y; +} IPoint; + +typedef struct basepoint { + real x; + real y; +} BasePoint; + +typedef struct dbasepoint { + bigreal x; + bigreal y; +} DBasePoint; + +typedef struct tpoint { + real x; + real y; + real t; +} TPoint; + +typedef struct dbounds { + real minx, maxx; + real miny, maxy; +} DBounds; + +typedef struct ibounds { + int minx, maxx; + int miny, maxy; +} IBounds; + +typedef struct val { + enum val_type { v_int, v_real, v_str, v_unicode, v_lval, v_arr, v_arrfree, + v_int32pt, v_int16pt, v_int8pt, v_void } type; + union { + int ival; + real fval; + char *sval; + struct val *lval; + struct array *aval; + uint32 *u32ptval; + uint16 *u16ptval; + uint8 *u8ptval; + } u; +} Val; /* Used by scripting */ + +struct psdict { + int cnt, next; + char **keys; + char **values; +}; + +struct pschars { + int cnt, next; + char **keys; + uint8 **values; + int *lens; + int bias; /* for type2 strings */ +}; + +enum linejoin { + lj_miter, /* Extend lines until they meet */ + lj_round, /* circle centered at the join of expand radius */ + lj_bevel, /* Straight line between the ends of next and prev */ + lj_inherited +}; +enum linecap { + lc_butt, /* equiv to lj_bevel, straight line extends from one side to other */ + lc_round, /* semi-circle */ + lc_square, /* Extend lines by radius, then join them */ + lc_inherited +}; +enum spreadMethod { + sm_pad, sm_reflect, sm_repeat +}; +#define COLOR_INHERITED 0xfffffffe +struct gradient { + BasePoint start; /* focal of a radial gradient, start of a linear */ + BasePoint stop; /* center of a radial gradient, end of a linear */ + real radius; /* 0=>linear gradient, else radius of a radial gradient */ + enum spreadMethod sm; + int stop_cnt; + struct grad_stops { + real offset; + uint32 col; + real opacity; + } *grad_stops; +}; + +struct pattern { + char *pattern; + real width, height; /* Pattern is scaled to be repeated every width/height (in user coordinates) */ + real transform[6]; + /* Used during rasterization process */ + struct bdfchar *pat; + real invtrans[6]; + int bminx, bminy, bwidth, bheight; /* of the pattern at bdfchar scale */ +}; + +struct brush { + uint32 col; + float opacity; /* number between [0,1], only for svg/pdf */ + struct pattern *pattern; /* A pattern to be tiled */ + struct gradient *gradient; /* A gradient fill */ +}; +#define WIDTH_INHERITED (-1) +#define DASH_INHERITED 255 /* if the dashes[0]==0 && dashes[1]==DASH_INHERITED */ +#define DASH_MAX 8 +typedef unsigned char DashType; +struct pen { + struct brush brush; + uint8 linejoin; + uint8 linecap; + float width; + real trans[4]; + DashType dashes[DASH_MAX]; +}; + +struct spline; +enum si_type { si_std, si_caligraphic, si_elipse, si_centerline }; +/* If you change this structure you may need to update MakeStrokeDlg */ +/* and cvpalettes.c both contain statically initialized StrokeInfos */ +typedef struct strokeinfo { + real radius; /* or major axis of pen */ + enum linejoin join; + enum linecap cap; + enum si_type stroke_type; + unsigned int toobigwarn: 1; + unsigned int removeinternal: 1; + unsigned int removeexternal: 1; + unsigned int removeoverlapifneeded: 1; + unsigned int gottoobig: 1; + unsigned int gottoobiglocal: 1; + real penangle; + real ratio; /* ratio of minor pen axis to major */ +/* For eplipse */ + real minorradius; +/* For freehand tool */ + real radius2; + int pressure1, pressure2; +/* End freehand tool */ + bigreal c,s; + real xoff[8], yoff[8]; + void *data; + bigreal (*factor)(void *data,struct spline *spline,real t); +} StrokeInfo; + +enum overlap_type { over_remove, over_rmselected, over_intersect, over_intersel, + over_exclude, over_findinter, over_fisel }; + +enum simpify_flags { sf_cleanup=-1, sf_normal=0, sf_ignoreslopes=1, + sf_ignoreextremum=2, sf_smoothcurves=4, sf_choosehv=8, + sf_forcelines=0x10, sf_nearlyhvlines=0x20, + sf_mergelines=0x40, sf_setstart2extremum=0x80, + sf_rmsingletonpoints=0x100 }; +struct simplifyinfo { + int flags; + bigreal err; + bigreal tan_bounds; + bigreal linefixup; + bigreal linelenmax; /* Don't simplify any straight lines longer than this */ + int set_as_default; + int check_selected_contours; +}; + +typedef struct italicinfo { + double italic_angle; + double xheight_percent; + struct hsquash { double lsb_percent, stem_percent, counter_percent, rsb_percent; } + lc, uc, neither; + enum { srf_flat, srf_simpleslant, srf_complexslant } secondary_serif; + /* | | (flat) | | (simple) | | (complex) */ + /* | | | / | / */ + /* | | | / | / */ + /* +----+ |/ \ / */ + + unsigned int transform_bottom_serifs: 1; + unsigned int transform_top_xh_serifs: 1; /* Those at x-height */ + unsigned int transform_top_as_serifs: 1; /* Those at ascender-height */ + unsigned int transform_diagon_serifs: 1; /* Those at baseline/xheight */ + + unsigned int a_from_d: 1; /* replace the "a" glyph with the variant which looks like a "d" without an ascender */ + /* When I say "f" I also mean "f_f" ligature, "longs", cyrillic phi and other things shaped like "f" */ + unsigned int f_long_tail: 1; /* Some Italic fonts have the "f" grow an extension of the main stem below the baseline */ + unsigned int f_rotate_top: 1; /* Most Italic fonts take the top curve of the "f", rotate it 180 and attach to the bottom */ + unsigned int pq_deserif: 1; /* Remove a serif from the descender of p or q and replace with a secondary serif as above */ + + /* Unsupported */ + /* e becomes rounder, cross bar slightly slanted */ + /* g closed counter at bottom */ + /* k closed counter at top */ + /* v-z diagonal stems become more curvatious */ + + unsigned int cyrl_phi: 1; /* Gains an "f" like top, bottom treated like "f" */ + unsigned int cyrl_i: 1; /* Turns into a latin u */ + unsigned int cyrl_pi: 1; /* Turns into a latin n */ + unsigned int cyrl_te: 1; /* Turns into a latin m */ + unsigned int cyrl_sha: 1; /* Turns into a latin m rotated 180 */ + unsigned int cyrl_dje: 1; /* Turns into a latin smallcaps T */ + unsigned int cyrl_dzhe: 1; /* Turns into a latin u */ + /* Is there a difference between dzhe and i? both look like u to me */ + + /* Unsupported */ + /* u432 curved B */ + /* u433 strange gamma */ + /* u434 normal delta */ + /* u436 */ + /* u43b lambda ? */ + /* u43c */ + /* u446 */ + /* u449 */ + /* u449 */ + /* u44a */ + +/* This half of the structure gets filled in later */ + double tan_ia; + double x_height; + double pq_depth; + double ascender_height; + double emsize; + int order2; + struct splinefont *sf; + int layer; + double serif_extent, serif_height; + struct splinepoint *f_start, *f_end; /* start has next pointing into the f head and up */ + struct splinepoint *ff_start1, *ff_end1, *ff_start2, *ff_end2; + double f_height, ff_height; +} ItalicInfo; + +typedef struct bluedata { + real xheight, xheighttop; /* height of "x" and "o" (u,v,w,x,y,z) */ + real caph, caphtop; /* height of "I" and "O" */ + real base, basebelow; /* bottom of "I" and "O" */ + real ascent; /* height of "l" */ + real descent; /* depth of "p" */ + real numh, numhtop; /* height of "7" and "8" */ /* numbers with ascenders */ + int bluecnt; /* If the private dica contains bluevalues... */ + real blues[12][2]; /* 7 pairs from bluevalues, 5 from otherblues */ +} BlueData; + +typedef struct bdffloat { + int16 xmin,xmax,ymin,ymax; + int16 bytes_per_line; + unsigned int byte_data:1; + uint8 depth; + uint8 *bitmap; +} BDFFloat; + +/* OpenType does not document 'dflt' as a language, but we'll use it anyway. */ +/* (Adobe uses it too) we'll turn it into a default entry when we output it. */ +#define DEFAULT_LANG CHR('d','f','l','t') +/* The OpenType spec says in one place that the default script is 'dflt' and */ +/* in another that it is 'DFLT'. 'DFLT' is correct */ +#define DEFAULT_SCRIPT CHR('D','F','L','T') +#define REQUIRED_FEATURE CHR(' ','R','Q','D') + +enum otlookup_type { + ot_undef = 0, /* Not a lookup type */ + gsub_start = 0x000, /* Not a lookup type */ + gsub_single = 0x001, + gsub_multiple = 0x002, + gsub_alternate = 0x003, + gsub_ligature = 0x004, + gsub_context = 0x005, + gsub_contextchain = 0x006, + /* GSUB extension 7 */ + gsub_reversecchain = 0x008, + /* mac state machines */ + morx_indic = 0x0fd, + morx_context = 0x0fe, + morx_insert = 0x0ff, + /* ********************* */ + gpos_start = 0x100, /* Not a lookup type */ + + gpos_single = 0x101, + gpos_pair = 0x102, + gpos_cursive = 0x103, + gpos_mark2base = 0x104, + gpos_mark2ligature = 0x105, + gpos_mark2mark = 0x106, + gpos_context = 0x107, + gpos_contextchain = 0x108, + /* GPOS extension 9 */ + kern_statemachine = 0x1ff + + /* otlookup&0xff == lookup type for the appropriate table */ + /* otlookup>>8: 0=>GSUB, 1=>GPOS */ +}; + +enum otlookup_typemasks { + gsub_single_mask = 0x00001, + gsub_multiple_mask = 0x00002, + gsub_alternate_mask = 0x00004, + gsub_ligature_mask = 0x00008, + gsub_context_mask = 0x00010, + gsub_contextchain_mask = 0x00020, + gsub_reversecchain_mask = 0x00040, + morx_indic_mask = 0x00080, + morx_context_mask = 0x00100, + morx_insert_mask = 0x00200, + /* ********************* */ + gpos_single_mask = 0x00400, + gpos_pair_mask = 0x00800, + gpos_cursive_mask = 0x01000, + gpos_mark2base_mask = 0x02000, + gpos_mark2ligature_mask = 0x04000, + gpos_mark2mark_mask = 0x08000, + gpos_context_mask = 0x10000, + gpos_contextchain_mask = 0x20000, + kern_statemachine_mask = 0x40000 +}; + +#define MAX_LANG 4 /* If more than this we allocate more_langs in chunks of MAX_LANG */ +struct scriptlanglist { + uint32 script; + uint32 langs[MAX_LANG]; + uint32 *morelangs; + int lang_cnt; + struct scriptlanglist *next; +}; + +extern struct opentype_feature_friendlynames { + uint32 tag; + char *tagstr; + char *friendlyname; + int masks; +} friendlies[]; + +typedef struct featurescriptlanglist { + uint32 featuretag; + struct scriptlanglist *scripts; + struct featurescriptlanglist *next; + unsigned int ismac: 1; /* treat the featuretag as a mac feature/setting */ +} FeatureScriptLangList; + +enum pst_flags { pst_r2l=1, pst_ignorebaseglyphs=2, pst_ignoreligatures=4, + pst_ignorecombiningmarks=8 }; + +typedef struct otlookup { + struct otlookup *next; + enum otlookup_type lookup_type; + uint16 lookup_flags; + char *lookup_name; + FeatureScriptLangList *features; + struct lookup_subtable { + char *subtable_name; + char *suffix; /* for gsub_single, used to find a default replacement */ + struct otlookup *lookup; + unsigned int unused: 1; + unsigned int per_glyph_pst_or_kern: 1; + unsigned int anchor_classes: 1; + unsigned int vertical_kerning: 1; + unsigned int ticked: 1; + struct kernclass *kc; + struct generic_fpst *fpst; + struct generic_asm *sm; + /* Each time an item is added to a lookup we must place it into a */ + /* subtable. If it's a kerning class, fpst or state machine it has */ + /* a subtable all to itself. If it's an anchor class it can share */ + /* a subtable with other anchor classes (merge with). If it's a glyph */ + /* PST it may share a subtable with other PSTs */ + /* Note items may only be placed in lookups in which they fit. Can't */ + /* put kerning data in a gpos_single lookup, etc. */ + struct lookup_subtable *next; + int32 subtable_offset; + int32 *extra_subtables; + /* If a kerning subtable has too much stuff in it, we are prepared to */ + /* break it up into several smaller subtables, each of which has */ + /* an offset in this list (extra-subtables[0]==subtable_offset) */ + /* the list is terminated by an entry of -1 */ + } *subtables; + unsigned int unused: 1; /* No subtable is used (call SFFindUnusedLookups before examining) */ + unsigned int empty: 1; /* No subtable is used, and no anchor classes are used */ + unsigned int store_in_afm: 1; /* Used for ligatures, some get stored */ + /* 'liga' generally does, but 'frac' doesn't */ + unsigned int needs_extension: 1; /* Used during opentype generation */ + unsigned int temporary_kern: 1; /* Used when decomposing kerning classes into kern pairs for older formats */ + unsigned int def_lang_checked: 1; + unsigned int def_lang_found: 1; + unsigned int ticked: 1; + int16 subcnt; /* Actual number of subtables we will output */ + /* Some of our subtables may contain no data */ + /* Some may be too big and need to be broken up.*/ + /* So this field may be different than just counting the subtables */ + int lookup_index; /* used during opentype generation */ + uint32 lookup_offset; + uint32 lookup_length; + char *tempname; +} OTLookup; + +#ifdef FONTFORGE_CONFIG_DEVICETABLES +typedef struct devicetab { + uint16 first_pixel_size, last_pixel_size; /* A range of point sizes to which this table applies */ + int8 *corrections; /* a set of pixel corrections, one for each point size */ +} DeviceTable; + +typedef struct valdev { /* Value records can have four associated device tables */ + DeviceTable xadjust; + DeviceTable yadjust; + DeviceTable xadv; + DeviceTable yadv; +} ValDevTab; +#endif + +enum anchorclass_type { act_mark, act_mkmk, act_curs, act_mklg }; +typedef struct anchorclass { + char *name; /* in utf8 */ + struct lookup_subtable *subtable; + uint8 type; /* anchorclass_type */ + uint8 has_base; + uint8 processed, has_mark, matches, ac_num; + uint8 ticked; + struct anchorclass *next; +} AnchorClass; + +enum anchor_type { at_mark, at_basechar, at_baselig, at_basemark, at_centry, at_cexit, at_max }; +typedef struct anchorpoint { + AnchorClass *anchor; + BasePoint me; +#ifdef FONTFORGE_CONFIG_DEVICETABLES + DeviceTable xadjust, yadjust; +#endif + unsigned int type: 4; + unsigned int selected: 1; + unsigned int ticked: 1; + unsigned int has_ttf_pt: 1; + uint16 ttf_pt_index; + int16 lig_index; + struct anchorpoint *next; +} AnchorPoint; + +typedef struct kernpair { + struct lookup_subtable *subtable; + struct splinechar *sc; + int16 off; + uint16 kcid; /* temporary value */ +#ifdef FONTFORGE_CONFIG_DEVICETABLES + DeviceTable *adjust; /* Only adjustment in one dimen, if more needed use pst */ +#endif + struct kernpair *next; +} KernPair; + +typedef struct kernclass { + int first_cnt, second_cnt; /* Count of classes for first and second chars */ + char **firsts; /* list of a space seperated list of char names */ + char **seconds; /* one entry for each class. Entry 0 is null */ + /* and means everything not specified elsewhere */ + struct lookup_subtable *subtable; + uint16 kcid; /* Temporary value, used for many things briefly */ + int16 *offsets; /* array of first_cnt*second_cnt entries */ +#ifdef FONTFORGE_CONFIG_DEVICETABLES + DeviceTable *adjusts; /* array of first_cnt*second_cnt entries */ +#endif + struct kernclass *next; +} KernClass; + +enum possub_type { pst_null, pst_position, pst_pair, + pst_substitution, pst_alternate, + pst_multiple, pst_ligature, + pst_lcaret /* must be pst_max-1, see charinfo.c*/, + pst_max, + /* These are not psts but are related so it's handly to have values for them */ + pst_kerning = pst_max, pst_vkerning, pst_anchors, + /* And these are fpsts */ + pst_contextpos, pst_contextsub, pst_chainpos, pst_chainsub, + pst_reversesub, fpst_max, + /* And these are used to specify a kerning pair where the current */ + /* char is the final glyph rather than the initial one */ + /* A kludge used when cutting and pasting features */ + pst_kernback, pst_vkernback + }; + +struct vr { + int16 xoff, yoff, h_adv_off, v_adv_off; +#ifdef FONTFORGE_CONFIG_DEVICETABLES + ValDevTab *adjust; +#endif +}; + +typedef struct generic_pst { + unsigned int ticked: 1; + unsigned int temporary: 1; /* Used in afm ligature closure */ + /* enum possub_type*/ uint8 type; + struct lookup_subtable *subtable; + struct generic_pst *next; + union { + struct vr pos; + struct { char *paired; struct vr *vr; } pair; + struct { char *variant; } subs; + struct { char *components; } mult, alt; + struct { char *components; struct splinechar *lig; } lig; + struct { int16 *carets; int cnt; } lcaret; /* Ligature caret positions */ + } u; +} PST; + +typedef struct liglist { + PST *lig; + struct splinechar *first; /* First component */ + struct splinecharlist *components; /* Other than the first */ + struct liglist *next; + int ccnt; /* Component count. (includes first component) */ +} LigList; + +enum fpossub_format { pst_glyphs, pst_class, pst_coverage, + pst_reversecoverage, pst_formatmax }; + +typedef struct generic_fpst { + uint16 /*enum sfpossub_type*/ type; + uint16 /*enum fpossub_format*/ format; + struct lookup_subtable *subtable; + struct generic_fpst *next; + uint16 nccnt, bccnt, fccnt; + uint16 rule_cnt; + char **nclass, **bclass, **fclass; + struct fpst_rule { + union { + struct fpg { char *names, *back, *fore; } glyph; + struct fpc { int ncnt, bcnt, fcnt; uint16 *nclasses, *bclasses, *fclasses, *allclasses; } class; + struct fpv { int ncnt, bcnt, fcnt; char **ncovers, **bcovers, **fcovers; } coverage; + struct fpr { int always1, bcnt, fcnt; char **ncovers, **bcovers, **fcovers; char *replacements; } rcoverage; + } u; + int lookup_cnt; + struct seqlookup { + int seq; + struct otlookup *lookup; + } *lookups; + } *rules; + uint8 ticked; + uint8 effectively_by_glyphs; +} FPST; + +enum asm_type { asm_indic, asm_context, asm_lig, asm_simple=4, asm_insert, + asm_kern=0x11 }; +enum asm_flags { asm_vert=0x8000, asm_descending=0x4000, asm_always=0x2000 }; + +typedef struct generic_asm { /* Apple State Machine */ + struct generic_asm *next; + uint16 /*enum asm_type*/ type; + struct lookup_subtable *subtable; /* Lookup contains feature setting info */ + uint16 flags; /* 0x8000=>vert, 0x4000=>r2l, 0x2000=>hor&vert */ + uint8 ticked; + + uint16 class_cnt, state_cnt; + char **classes; + struct asm_state { + uint16 next_state; + uint16 flags; + union { + struct { + struct otlookup *mark_lookup; /* for contextual glyph subs (tag of a nested lookup) */ + struct otlookup *cur_lookup; /* for contextual glyph subs */ + } context; + struct { + char *mark_ins; + char *cur_ins; + } insert; + struct { + int16 *kerns; + int kcnt; + } kern; + } u; + } *state; + /*uint32 opentype_tag; */ /* If converted from opentype */ +} ASM; +/* State Flags: + Indic: + 0x8000 mark current glyph as first in rearrangement + 0x4000 don't advance to next glyph + 0x2000 mark current glyph as last + 0x000f verb + 0 = no change 8 = AxCD => CDxA + 1 = Ax => xA 9 = AxCD => DCxA + 2 = xD => Dx a = ABxD => DxAB + 3 = AxD => DxA b = ABxD => DxBA + 4 = ABx => xAB c = ABxCD => CDxAB + 5 = ABx => xBA d = ABxCD => CDxBA + 6 = xCD => CDx e = ABxCD => DCxAB + 7 = xCD => DCx f = ABxCD => DCxBA + Contextual: + 0x8000 mark current glyph + 0x4000 don't advance to next glyph + Insert: + 0x8000 mark current glyph + 0x4000 don't advance to next glyph + 0x2000 current is Kashida like + 0x1000 mark is Kashida like + 0x0800 current insert before + 0x0400 mark insert before + 0x03e0 count of chars to be inserted at current (31 max) + 0x001f count of chars to be inserted at mark (31 max) + Kern: + 0x8000 add current glyph to kerning stack + 0x4000 don't advance to next glyph + 0x3fff value offset +*/ + +struct opentype_str { + struct splinechar *sc; + struct vr vr; /* Scaled and rounded gpos modifications (device table info included in xoff, etc. not in adjusts) */ + struct kernpair *kp; + struct kernclass *kc; + int16 advance_width; /* Basic advance, modifications in vr, scaled and rounded */ + int16 kc_index; + int16 lig_pos; /* when skipping marks to form a ligature keep track of what ligature element a mark was attached to */ + int16 context_pos; /* When doing a contextual match remember which glyphs are used, and where in the match they occur. Skipped glyphs have -1 */ + int32 orig_index; + void *fl; + unsigned int line_break_after: 1; + unsigned int r2l: 1; + int16 bsln_off; +}; + +struct macname { + struct macname *next; + uint16 enc; /* Platform specific encoding. 0=>mac roman, 1=>sjis, 7=>russian */ + uint16 lang; /* Mac languages 0=>english, 1=>french, 2=>german */ + char *name; /* Not a unicode string, uninterpreted mac encoded string */ +}; + +/* Wow, the GPOS 'size' feature stores a string in the name table just as mac */ +/* features do */ +struct otfname { + struct otfname *next; + uint16 lang; /* windows language code */ + char *name; /* utf8 */ +}; + +typedef struct macfeat { + struct macfeat *next; + uint16 feature; + uint8 ismutex; + uint8 default_setting; /* Apple's docs say both that this is a byte and a short. It's a byte */ + uint16 strid; /* Temporary value, used when reading in */ + struct macname *featname; + struct macsetting { + struct macsetting *next; + uint16 setting; + uint16 strid; + struct macname *setname; + unsigned int initially_enabled: 1; + } *settings; +} MacFeat; + +typedef struct undoes { + struct undoes *next; + enum undotype { ut_none=0, ut_state, ut_tstate, ut_statehint, ut_statename, + ut_statelookup, + ut_anchors, + ut_width, ut_vwidth, ut_lbearing, ut_rbearing, ut_possub, + ut_hints, ut_bitmap, ut_bitmapsel, ut_composit, ut_multiple, ut_layers, + ut_noop } undotype; + unsigned int was_modified: 1; + unsigned int was_order2: 1; + union { + struct { + int16 width, vwidth; + int16 lbearingchange; + int unicodeenc; /* only for ut_statename */ + char *charname; /* only for ut_statename */ + char *comment; /* in utf8 */ + PST *possub; /* only for ut_statename */ + struct splinepointlist *splines; + struct refchar *refs; + + struct imagelist *images; + void *hints; /* ut_statehint, ut_statename */ + uint8 *instrs; + int instrs_len; + AnchorPoint *anchor; +#ifdef FONTFORGE_CONFIG_TYPE3 + struct brush fill_brush; + struct pen stroke_pen; + unsigned int dofill: 1; + unsigned int dostroke: 1; + unsigned int fillfirst: 1; +#endif + } state; + int width; /* used by both ut_width and ut_vwidth */ + int lbearing; /* used by ut_lbearing */ + int rbearing; /* used by ut_rbearing */ + struct { + int16 width; /* width should be controled by postscript, but people don't like that */ + int16 xmin,xmax,ymin,ymax; + int16 bytes_per_line; + int16 pixelsize; + int16 depth; + uint8 *bitmap; + BDFFloat *selection; + } bmpstate; + struct { /* copy contains an outline state and a set of bitmap states */ + struct undoes *state; + struct undoes *bitmaps; + } composit; + struct { + struct undoes *mult; /* copy contains several sub copies (composits, or states or widths or...) */ + /* Also used for ut_layers, each sub copy is a state (first is ly_fore, next ly_fore+1...) */ + } multiple; + struct { + enum possub_type pst; + char **data; /* First 4 bytes is tag, then space then data */ + struct undoes *more_pst; + short cnt,max; /* Not always set */ + } possub; + uint8 *bitmap; + } u; + struct splinefont *copied_from; +} Undoes; + +typedef struct bdfchar { + struct splinechar *sc; + int16 xmin,xmax,ymin,ymax; + int16 width; + int16 bytes_per_line; + uint8 *bitmap; + int orig_pos; + struct bitmapview *views; + Undoes *undoes; + Undoes *redoes; + unsigned int changed: 1; + unsigned int byte_data: 1; /* for anti-aliased chars entries are grey-scale bytes not bw bits */ + unsigned int widthgroup: 1; /* for ttf bitmap output */ + unsigned int isreference: 1; /* for ttf bitmap input, */ + unsigned int ticked: 1; + uint8 depth; /* for ttf bitmap output */ + uint16 vwidth; + BDFFloat *selection; +} BDFChar; + +typedef struct enc { + char *enc_name; + int char_cnt; /* Size of the next two arrays */ + int32 *unicode; /* unicode value for each encoding point */ + char **psnames; /* optional postscript name for each encoding point */ + struct enc *next; + unsigned int builtin: 1; + unsigned int hidden: 1; + unsigned int only_1byte: 1; + unsigned int has_1byte: 1; + unsigned int has_2byte: 1; + unsigned int is_unicodebmp: 1; + unsigned int is_unicodefull: 1; + unsigned int is_custom: 1; + unsigned int is_original: 1; + unsigned int is_compact: 1; + unsigned int is_japanese: 1; + unsigned int is_korean: 1; + unsigned int is_tradchinese: 1; + unsigned int is_simplechinese: 1; + char iso_2022_escape[8]; + int iso_2022_escape_len; + int low_page, high_page; + char *iconv_name; /* For compatibility to old versions we might use a different name from that used by iconv. */ + iconv_t *tounicode; + iconv_t *fromunicode; + int (*tounicode_func)(int); + int (*fromunicode_func)(int); + unsigned int is_temporary: 1; /* freed when the map gets freed */ + int char_max; /* Used by temporary encodings */ +} Encoding; + +typedef struct namelist { + struct namelist *basedon; + char *title; + const char ***unicode[17]; + struct namelist *next; + struct renames { char *from; char *to; } *renames; + int uses_unicode; + char *a_utf8_name; +} NameList; + +enum uni_interp { ui_unset= -1, ui_none, ui_adobe, ui_greek, ui_japanese, + ui_trad_chinese, ui_simp_chinese, ui_korean, ui_ams }; + +struct remap { uint32 firstenc, lastenc; int32 infont; }; + +typedef struct encmap { /* A per-font map of encoding to glyph id */ + int32 *map; /* Map from encoding to glyphid */ + int32 *backmap; /* Map from glyphid to encoding */ + int enccount; /* used size of the map array */ + /* strictly speaking this might include */ + /* glyphs that are not encoded, but which */ + /* are displayed after the proper encoding */ + int encmax; /* allocated size of the map array */ + int backmax; /* allocated size of the backmap array */ + struct remap *remap; + Encoding *enc; + unsigned int ticked: 1; +} EncMap; + +enum property_type { prt_string, prt_atom, prt_int, prt_uint, prt_property=0x10 }; + +typedef struct bdfprops { + char *name; /* These include both properties (like SLANT) and non-properties (like FONT) */ + int type; + union { + char *str; + char *atom; + int val; + } u; +} BDFProperties; + +typedef struct bdffont { + struct splinefont *sf; + int glyphcnt, glyphmax; /* used & allocated sizes of glyphs array */ + BDFChar **glyphs; /* an array of charcnt entries */ + int16 pixelsize; + int16 ascent, descent; + int16 layer; /* for piecemeal fonts */ + unsigned int piecemeal: 1; + unsigned int bbsized: 1; + unsigned int ticked: 1; + unsigned int unhinted_freetype: 1; + struct bdffont *next; + struct clut *clut; + char *foundry; + int res; + void *freetype_context; + uint16 truesize; /* for bbsized fonts */ + int16 prop_cnt; + int16 prop_max; /* only used within bdfinfo dlg */ + BDFProperties *props; +} BDFFont; + +#define HntMax 96 /* PS says at most 96 hints */ +typedef uint8 HintMask[HntMax/8]; + +enum pointtype { pt_curve, pt_corner, pt_tangent, pt_hvcurve }; +typedef struct splinepoint { + BasePoint me; + BasePoint nextcp; /* control point */ + BasePoint prevcp; /* control point */ + unsigned int nonextcp:1; + unsigned int noprevcp:1; + unsigned int nextcpdef:1; + unsigned int prevcpdef:1; + unsigned int selected:1; /* for UI */ + unsigned int pointtype:2; + unsigned int isintersection: 1; + unsigned int flexy: 1; + unsigned int flexx: 1; + unsigned int roundx: 1; /* For true type hinting */ + unsigned int roundy: 1; /* For true type hinting */ + unsigned int dontinterpolate: 1; /* in ttf, don't imply point by interpolating between cps */ + unsigned int ticked: 1; + unsigned int watched: 1; + /* 1 bits left... */ + uint16 ptindex; /* Temporary value used by metafont routine */ + uint16 ttfindex; /* Truetype point index */ + /* Special values 0xffff => point implied by averaging control points */ + /* 0xfffe => point created with no real number yet */ + /* (or perhaps point in context where no number is possible as in a glyph with points & refs) */ + uint16 nextcpindex; /* Truetype point index */ + struct spline *next; + struct spline *prev; + HintMask *hintmask; +} SplinePoint; + +typedef struct linelist { + IPoint here; + struct linelist *next; + /* The first two fields are constant for the linelist, the next ones */ + /* refer to a particular screen. If some portion of the line from */ + /* this point to the next one is on the screen then set cvli_onscreen */ + /* if this point needs to be clipped then set cvli_clipped */ + /* asend and asstart are the actual screen locations where this point */ + /* intersects the clip edge. */ + enum { cvli_onscreen=0x1, cvli_clipped=0x2 } flags; + IPoint asend, asstart; +} LineList; + +typedef struct linearapprox { + real scale; + unsigned int oneline: 1; + unsigned int onepoint: 1; + unsigned int any: 1; /* refers to a particular screen */ + struct linelist *lines; + struct linearapprox *next; +} LinearApprox; + +typedef struct spline1d { + real a, b, c, d; +} Spline1D; + +typedef struct spline { + unsigned int islinear: 1; /* No control points */ + unsigned int isquadratic: 1; /* probably read in from ttf */ + unsigned int isticked: 1; + unsigned int isneeded: 1; /* Used in remove overlap */ + unsigned int isunneeded: 1; /* Used in remove overlap */ + unsigned int exclude: 1; /* Used in remove overlap varient: exclude */ + unsigned int ishorvert: 1; + unsigned int knowncurved: 1; /* We know that it curves */ + unsigned int knownlinear: 1; /* it might have control points, but still traces out a line */ + /* If neither knownlinear nor curved then we haven't checked */ + unsigned int order2: 1; /* It's a bezier curve with only one cp */ + unsigned int touched: 1; + unsigned int leftedge: 1; + unsigned int rightedge: 1; + unsigned int acceptableextrema: 1; /* This spline has extrema, but we don't care */ + SplinePoint *from, *to; + Spline1D splines[2]; /* splines[0] is the x spline, splines[1] is y */ + struct linearapprox *approx; + /* Posible optimizations: + Precalculate bounding box + Precalculate min/max/ points of inflection + */ +} Spline; + + +typedef struct splinepointlist { + SplinePoint *first, *last; + struct splinepointlist *next; + uint8 ticked; + uint8 beziers_need_optimizer; /* If the spiros have changed in spiro mode, then reverting to bezier mode might, someday, run a simplifier */ + uint8 is_clip_path; /* In type3/svg fonts */ + char *contour_name; +} SplinePointList, SplineSet; + +typedef struct imagelist { + struct gimage *image; + real xoff, yoff; /* position in character space of upper left corner of image */ + real xscale, yscale; /* scale to convert one pixel of image to one unit of character space */ + DBounds bb; + struct imagelist *next; + unsigned int selected: 1; +} ImageList; + +typedef struct refchar { + unsigned int checked: 1; + unsigned int selected: 1; + unsigned int point_match: 1; /* match_pt* are point indexes */ + /* and need to be converted to a */ + /* translation after truetype readin */ + unsigned int encoded: 1; /* orig_pos is actually an encoded value, used for old sfd files */ + unsigned int justtranslated: 1; /* The transformation matrix specifies a translation (or is identity) */ + unsigned int use_my_metrics: 1; /* Retain the ttf "use_my_metrics" info. */ + /* important for glyphs with instructions which change the width used */ + /* inside composites */ + unsigned int round_translation_to_grid: 1; /* Retain the ttf "round_to_grid" info. */ + unsigned int point_match_out_of_date: 1; /* Someone has edited a base glyph */ + int16 adobe_enc; + int orig_pos; + int unicode_enc; /* used by paste */ + real transform[6]; /* transformation matrix (first 2 rows of a 3x3 matrix, missing row is 0,0,1) */ + struct reflayer { + unsigned int background: 1; + unsigned int order2: 1; + unsigned int anyflexes: 1; +#ifdef FONTFORGE_CONFIG_TYPE3 + unsigned int dofill: 1; + unsigned int dostroke: 1; + unsigned int fillfirst: 1; + struct brush fill_brush; + struct pen stroke_pen; +#endif + SplinePointList *splines; + ImageList *images; /* Only in background or type3 layer(s) */ + } *layers; + int layer_cnt; + struct refchar *next; + DBounds bb; + struct splinechar *sc; + BasePoint top; + uint16 match_pt_base, match_pt_ref; +} RefChar; + +/* Some stems may appear, disappear, reapear several times */ +/* Serif stems on I which appear at 0, disappear, reappear at top */ +/* Or the major vertical stems on H which disappear at the cross bar */ +typedef struct hintinstance { + real begin; /* location in the non-major direction*/ + real end; /* width/height in non-major direction*/ + unsigned int closed: 1; + short int counternumber; + struct hintinstance *next; +} HintInstance; + +enum hinttypes { ht_unspecified=0, ht_h, ht_v, ht_d }; +typedef real _MMArray[2][MmMax]; + +typedef struct steminfo { + struct steminfo *next; + unsigned int hinttype: 2; /* Only used by undoes */ + 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 */ + /* stored width will be either 20 or 21 */ + /* Type2 says: -20 is "width" of top edge, -21 is "width" of bottom edge, type1 accepts either */ + unsigned int haspointleft:1; + unsigned int haspointright:1; + unsigned int hasconflicts:1;/* Does this stem have conflicts within its cluster? */ + unsigned int used: 1; /* Temporary for counter hints or hint substitution */ + unsigned int tobeused: 1; /* Temporary for counter hints or hint substitution */ + unsigned int active: 1; /* Currently active hint in Review Hints dlg */ + /* displayed differently in char display */ + unsigned int enddone: 1; /* Used by ttf instructing, indicates a prev */ + /* hint had the same end as this one (so */ + /* the points on the end line have been */ + /* instructed already */ + unsigned int startdone: 1; /* Used by ttf instructing */ + /*unsigned int backwards: 1;*/ /* If we think this hint is better done with a negative width */ + unsigned int reordered: 1; /* In AutoHinting. Means we changed the start of the hint, need to test for out of order */ + unsigned int pendingpt: 1; /* A pending stem creation, not a true stem */ + unsigned int linearedges: 1;/* If we have a nice rectangle then we aren't */ + /* interested in the orientation which is */ + /* wider than long */ + int16 hintnumber; /* when dumping out hintmasks we need to know */ + /* what bit to set for this hint */ + union { + int mask; /* Mask of all references that use this hint */ + /* in type2 output */ + _MMArray *unblended /*[2][MmMax]*/; /* Used when reading in type1 mm hints */ + } u; + real start; /* location at which the stem starts */ + real width; /* or height */ + HintInstance *where; /* location(s) in the other coord */ +} StemInfo; + +typedef struct dsteminfo { + struct dsteminfo *next; /* First two fields match those in steminfo */ + unsigned int hinttype: 2; /* Only used by undoes */ + unsigned int used: 1; /* used only by tottf.c:gendinstrs, metafont.c to mark a hint that has been dealt with */ + BasePoint left, right, unit; + HintInstance *where; /* location(s) along the unit vector */ +} DStemInfo; + +typedef struct minimumdistance { + /* If either point is NULL it will be assumed to mean either the origin */ + /* or the width point (depending on which is closer). This allows user */ + /* to control metrics... */ + SplinePoint *sp1, *sp2; + unsigned int x: 1; + unsigned int done: 1; + struct minimumdistance *next; +} MinimumDistance; + +typedef struct layer /* : reflayer */{ + unsigned int background: 1; + unsigned int order2: 1; + unsigned int anyflexes: 1; +#ifdef FONTFORGE_CONFIG_TYPE3 + unsigned int dofill: 1; + unsigned int dostroke: 1; + unsigned int fillfirst: 1; + struct brush fill_brush; + struct pen stroke_pen; +#endif + SplinePointList *splines; + ImageList *images; /* Only in background or type3 layer(s) */ + RefChar *refs; /* Only in foreground layer(s) */ + Undoes *undoes; + Undoes *redoes; + uint32 validation_state; + uint32 old_vs; +} Layer; + +enum layer_type { ly_all=-2, ly_grid= -1, ly_back=0, ly_fore=1, + /* Possibly other foreground layers for type3 things */ + /* Possibly other background layers for normal fonts */ + ly_none = -3 + }; + +/* For the 'MATH' table (and for TeX) */ +struct glyphvariants { + char *variants; /* Space separated list of glyph names */ +/* Glyph assembly */ + int16 italic_correction; /* Of the composed glyph */ +#ifdef FONTFORGE_CONFIG_DEVICETABLES + DeviceTable *italic_adjusts; +#endif + int part_cnt; + struct gv_part { + char *component; + unsigned int is_extender: 1; /* This component may be skipped or repeated */ + uint16 startConnectorLength; + uint16 endConnectorLength; + uint16 fullAdvance; + } *parts; +}; + +/* For the 'MATH' table */ +struct mathkernvertex { + int cnt; /* There is one more kern entry than height entry */ + /* So the last mkd should have its height ignored */ + /* The MATH table stores the height count, I think the kern count */ + /* is more useful. They differ by 1 */ + struct mathkerndata { + int16 height,kern; +#ifdef FONTFORGE_CONFIG_DEVICETABLES + DeviceTable *height_adjusts; + DeviceTable *kern_adjusts; +#endif + } *mkd; +}; + +struct mathkern { + struct mathkernvertex top_right; + struct mathkernvertex top_left; + struct mathkernvertex bottom_right; + struct mathkernvertex bottom_left; +}; + +enum privatedict_state { + pds_odd = 0x1, /* Odd number of entries */ + pds_outoforder = 0x2, /* Bluevalues should be listed in order */ + pds_toomany = 0x4, /* arrays are of limited sizes */ + pds_tooclose = 0x8, /* adjacent zones must not be within 2*bluefuzz+1 (or 3, if bluefuzz omitted) */ + pds_notintegral= 0x10, /* Must be integers */ + pds_toobig = 0x20, /* within pair difference have some relation to BlueScale but the docs make no sense to me */ + pds_shift = 8, /* BlueValues/OtherBlues, unshifted, FamilyBlues/FamilyOtherBlues shifted once */ + + pds_missingblue = 0x010000, + pds_badbluefuzz = 0x020000, + pds_badbluescale = 0x040000, + pds_badstdhw = 0x080000, + pds_badstdvw = 0x100000, + pds_badstemsnaph = 0x200000, + pds_badstemsnapv = 0x400000, + pds_stemsnapnostdh = 0x0800000, + pds_stemsnapnostdv = 0x1000000, + pds_badblueshift = 0x2000000 + +}; + +enum validation_state { vs_unknown = 0, + vs_known=0x01, /* It has been validated */ + vs_opencontour=0x02, + vs_selfintersects=0x04, + vs_wrongdirection=0x08, + vs_flippedreferences=0x10, /* special case of wrong direction */ + vs_missingextrema=0x20, + vs_missingglyphnameingsub=0x40, + /* Next few are postscript only */ + vs_toomanypoints=0x80, + vs_toomanyhints=0x100, + vs_badglyphname=0x200, + /* Next few are only for fontlint */ + /* These are relative to maxp values which ff would fix on generating a font */ + vs_maxp_toomanypoints =0x400, + vs_maxp_toomanypaths =0x800, + vs_maxp_toomanycomppoints=0x1000, + vs_maxp_toomanycomppaths =0x2000, + vs_maxp_instrtoolong =0x4000, + vs_maxp_toomanyrefs =0x8000, + vs_maxp_refstoodeep =0x10000, + /* vs_maxp_prepfpgmtoolong=0x20000, */ /* I think I was wrong about this "error" */ + /* Oops, we need another one, two, for the glyphs */ + vs_pointstoofarapart = 0x40000, + vs_nonintegral = 0x80000, /* This will never be interesting in a real font, but might be in an sfd file */ + vs_missinganchor = 0x100000, + vs_dupname = 0x200000, + vs_dupunicode = 0x400000, + + vs_last = vs_dupunicode, + vs_maskps = 0x3fe | vs_pointstoofarapart | vs_missinganchor | vs_dupname | vs_dupunicode, + vs_maskcid = 0x1fe | vs_pointstoofarapart | vs_missinganchor | vs_dupname, + vs_maskttf = 0x7e | vs_pointstoofarapart | vs_nonintegral | vs_missinganchor | vs_dupunicode, + vs_maskfindproblems = 0x1be | vs_pointstoofarapart | vs_nonintegral | vs_missinganchor + }; + +typedef struct splinechar { + char *name; + int unicodeenc; + int orig_pos; /* Original position in the glyph list */ + int16 width, vwidth; + int16 xmin, ymin, xmax, ymax; + int16 lsidebearing; /* only used when reading in a type1 font */ + /* Or an otf font where it is the subr number of a refered character */ + /* or a ttf font without bit 1 of head.flags set */ + /* 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 */ + /* or when generating morx where it is the mask of tables in which the glyph occurs */ + /* Always a temporary value */ + int ttf_glyph; /* only used when writing out a ttf or otf font */ + Layer *layers; /* layer[0] is background, layer[1] foreground */ + /* In type3 fonts 2-n are also foreground, otherwise also background */ + int layer_cnt; + StemInfo *hstem; /* hstem hints have a vertical offset but run horizontally */ + StemInfo *vstem; /* vstem hints have a horizontal offset but run vertically */ + DStemInfo *dstem; /* diagonal hints for ttf */ + MinimumDistance *md; + struct charviewbase *views; + struct charinfo *charinfo; + struct splinefont *parent; + unsigned int changed: 1; + unsigned int changedsincelasthinted: 1; + unsigned int manualhints: 1; + unsigned int ticked: 1; /* For reference character processing */ + /* And fontview processing */ + unsigned int changed_since_autosave: 1; + unsigned int widthset: 1; /* needed so an emspace char doesn't disappear */ + unsigned int vconflicts: 1; /* Any hint overlaps in the vstem list? */ + unsigned int hconflicts: 1; /* Any hint overlaps in the hstem list? */ + unsigned int searcherdummy: 1; + unsigned int changed_since_search: 1; + unsigned int wasopen: 1; + unsigned int namechanged: 1; + unsigned int blended: 1; /* An MM blended character */ + unsigned int ticked2: 1; + 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 */ + unsigned int numberpointsbackards: 1; + unsigned int instructions_out_of_date: 1; + unsigned int complained_about_ptnums: 1; + unsigned int vs_open: 1; + unsigned int unlink_rm_ovrlp_save_undo: 1; + unsigned int inspiro: 1; + unsigned int lig_caret_cnt_fixed: 1; + /* 6 bits left (one more if we ignore compositionunit below) */ +#if HANYANG + unsigned int compositionunit: 1; + int16 jamo, varient; +#endif + struct splinecharlist { struct splinechar *sc; struct splinecharlist *next;} *dependents; + /* The dependents list is a list of all characters which refenence*/ + /* the current character directly */ + KernPair *kerns; + KernPair *vkerns; + PST *possub; /* If we are a ligature then this tells us what */ + /* It may also contain a bunch of other stuff now */ + LigList *ligofme; /* If this is the first character of a ligature then this gives us the list of possible ones */ + /* this field must be regenerated before the font is saved */ + char *comment; /* in utf8 */ + uint32 /*Color*/ color; + AnchorPoint *anchor; + uint8 *ttf_instrs; + int16 ttf_instrs_len; + int16 countermask_cnt; + HintMask *countermasks; + struct altuni { struct altuni *next; int unienc, vs, fid; } *altuni; + /* vs is the "variation selector" a unicode codepoint which modifieds */ + /* the code point before it. If vs is -1 then unienc is just an */ + /* alternate encoding (greek Alpha and latin A), but if vs is one */ + /* of unicode's variation selectors then this glyph is somehow a */ + /* variant shape. The specifics depend on the selector and script */ + /* fid is currently unused, but may, someday, be used to do ttcs */ + /* NOTE: GlyphInfo displays vs==-1 as vs==0, and fixes things up */ +/* for TeX */ + int16 tex_height, tex_depth; +/* TeX also uses italic_correction and glyph variants below */ +/* For the 'MATH' table (and for TeX) */ + unsigned int is_extended_shape: 1; + int16 italic_correction; + int16 top_accent_horiz; /* MATH table allows you to specific a*/ + /* horizontal anchor for accent attachments, vertical */ + /* positioning is done elsewhere */ +#ifdef FONTFORGE_CONFIG_DEVICETABLES + DeviceTable *italic_adjusts; + DeviceTable *top_accent_adjusts; +#endif + struct glyphvariants *vert_variants; + struct glyphvariants *horiz_variants; + struct mathkern *mathkern; +/* End of MATH/TeX fields */ +#ifndef _NO_PYTHON + void *python_sc_object; + void *python_temporary; +#endif + 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 */ +#ifdef FONTFORGE_CONFIG_TYPE3 + /* If the glyph is used as a tile pattern, then the next two values */ + /* determine the amount of white space around the tile. If extra is*/ + /* non-zero then we add it to the max components of the bbox and */ + /* subtract it from the min components. If extra is 0 then tile_bounds*/ + /* will be used. If tile_bounds is all zeros then the glyph's bbox */ + /* will be used. */ + real tile_margin; /* If the glyph is used as a tile */ + DBounds tile_bounds; +#endif +} SplineChar; + +#define TEX_UNDEF 0x7fff + +enum ttfnames { ttf_copyright=0, ttf_family, ttf_subfamily, ttf_uniqueid, + ttf_fullname, ttf_version, ttf_postscriptname, ttf_trademark, + ttf_manufacturer, ttf_designer, ttf_descriptor, ttf_venderurl, + ttf_designerurl, ttf_license, ttf_licenseurl, ttf_idontknow/*reserved*/, + ttf_preffamilyname, ttf_prefmodifiers, ttf_compatfull, ttf_sampletext, + ttf_cidfindfontname, ttf_wwsfamily, ttf_wwssubfamily, ttf_namemax }; +struct ttflangname { + int lang; + char *names[ttf_namemax]; /* in utf8 */ + int frommac[(ttf_namemax+31)/32]; /* Used when parsing the 'name' table */ + struct ttflangname *next; +}; + +#ifdef FONTFORGE_CONFIG_DEVICETABLES +struct MATH { +/* From the MATH Constants subtable (constants for positioning glyphs. Not PI)*/ + int16 ScriptPercentScaleDown; + int16 ScriptScriptPercentScaleDown; + uint16 DelimitedSubFormulaMinHeight; + uint16 DisplayOperatorMinHeight; + int16 MathLeading; + DeviceTable *MathLeading_adjust; + int16 AxisHeight; + DeviceTable *AxisHeight_adjust; + int16 AccentBaseHeight; + DeviceTable *AccentBaseHeight_adjust; + int16 FlattenedAccentBaseHeight; + DeviceTable *FlattenedAccentBaseHeight_adjust; + int16 SubscriptShiftDown; + DeviceTable *SubscriptShiftDown_adjust; + int16 SubscriptTopMax; + DeviceTable *SubscriptTopMax_adjust; + int16 SubscriptBaselineDropMin; + DeviceTable *SubscriptBaselineDropMin_adjust; + int16 SuperscriptShiftUp; + DeviceTable *SuperscriptShiftUp_adjust; + int16 SuperscriptShiftUpCramped; + DeviceTable *SuperscriptShiftUpCramped_adjust; + int16 SuperscriptBottomMin; + DeviceTable *SuperscriptBottomMin_adjust; + int16 SuperscriptBaselineDropMax; + DeviceTable *SuperscriptBaselineDropMax_adjust; + int16 SubSuperscriptGapMin; + DeviceTable *SubSuperscriptGapMin_adjust; + int16 SuperscriptBottomMaxWithSubscript; + DeviceTable *SuperscriptBottomMaxWithSubscript_adjust; + int16 SpaceAfterScript; + DeviceTable *SpaceAfterScript_adjust; + int16 UpperLimitGapMin; + DeviceTable *UpperLimitGapMin_adjust; + int16 UpperLimitBaselineRiseMin; + DeviceTable *UpperLimitBaselineRiseMin_adjust; + int16 LowerLimitGapMin; + DeviceTable *LowerLimitGapMin_adjust; + int16 LowerLimitBaselineDropMin; + DeviceTable *LowerLimitBaselineDropMin_adjust; + int16 StackTopShiftUp; + DeviceTable *StackTopShiftUp_adjust; + int16 StackTopDisplayStyleShiftUp; + DeviceTable *StackTopDisplayStyleShiftUp_adjust; + int16 StackBottomShiftDown; + DeviceTable *StackBottomShiftDown_adjust; + int16 StackBottomDisplayStyleShiftDown; + DeviceTable *StackBottomDisplayStyleShiftDown_adjust; + int16 StackGapMin; + DeviceTable *StackGapMin_adjust; + int16 StackDisplayStyleGapMin; + DeviceTable *StackDisplayStyleGapMin_adjust; + int16 StretchStackTopShiftUp; + DeviceTable *StretchStackTopShiftUp_adjust; + int16 StretchStackBottomShiftDown; + DeviceTable *StretchStackBottomShiftDown_adjust; + int16 StretchStackGapAboveMin; + DeviceTable *StretchStackGapAboveMin_adjust; + int16 StretchStackGapBelowMin; + DeviceTable *StretchStackGapBelowMin_adjust; + int16 FractionNumeratorShiftUp; + DeviceTable *FractionNumeratorShiftUp_adjust; + int16 FractionNumeratorDisplayStyleShiftUp; + DeviceTable *FractionNumeratorDisplayStyleShiftUp_adjust; + int16 FractionDenominatorShiftDown; + DeviceTable *FractionDenominatorShiftDown_adjust; + int16 FractionDenominatorDisplayStyleShiftDown; + DeviceTable *FractionDenominatorDisplayStyleShiftDown_adjust; + int16 FractionNumeratorGapMin; + DeviceTable *FractionNumeratorGapMin_adjust; + int16 FractionNumeratorDisplayStyleGapMin; + DeviceTable *FractionNumeratorDisplayStyleGapMin_adjust; + int16 FractionRuleThickness; + DeviceTable *FractionRuleThickness_adjust; + int16 FractionDenominatorGapMin; + DeviceTable *FractionDenominatorGapMin_adjust; + int16 FractionDenominatorDisplayStyleGapMin; + DeviceTable *FractionDenominatorDisplayStyleGapMin_adjust; + int16 SkewedFractionHorizontalGap; + DeviceTable *SkewedFractionHorizontalGap_adjust; + int16 SkewedFractionVerticalGap; + DeviceTable *SkewedFractionVerticalGap_adjust; + int16 OverbarVerticalGap; + DeviceTable *OverbarVerticalGap_adjust; + int16 OverbarRuleThickness; + DeviceTable *OverbarRuleThickness_adjust; + int16 OverbarExtraAscender; + DeviceTable *OverbarExtraAscender_adjust; + int16 UnderbarVerticalGap; + DeviceTable *UnderbarVerticalGap_adjust; + int16 UnderbarRuleThickness; + DeviceTable *UnderbarRuleThickness_adjust; + int16 UnderbarExtraDescender; + DeviceTable *UnderbarExtraDescender_adjust; + int16 RadicalVerticalGap; + DeviceTable *RadicalVerticalGap_adjust; + int16 RadicalDisplayStyleVerticalGap; + DeviceTable *RadicalDisplayStyleVerticalGap_adjust; + int16 RadicalRuleThickness; + DeviceTable *RadicalRuleThickness_adjust; + int16 RadicalExtraAscender; + DeviceTable *RadicalExtraAscender_adjust; + int16 RadicalKernBeforeDegree; + DeviceTable *RadicalKernBeforeDegree_adjust; + int16 RadicalKernAfterDegree; + DeviceTable *RadicalKernAfterDegree_adjust; + uint16 RadicalDegreeBottomRaisePercent; +/* Global constants from other subtables */ + uint16 MinConnectorOverlap; /* in the math variants sub-table */ +}; +#else +struct MATH { +/* From the MATH Constants subtable (constants for positioning glyphs. Not PI)*/ + int16 ScriptPercentScaleDown; + int16 ScriptScriptPercentScaleDown; + uint16 DelimitedSubFormulaMinHeight; + uint16 DisplayOperatorMinHeight; + int16 MathLeading; + int16 AxisHeight; + int16 AccentBaseHeight; + int16 FlattenedAccentBaseHeight; + int16 SubscriptShiftDown; + int16 SubscriptTopMax; + int16 SubscriptBaselineDropMin; + int16 SuperscriptShiftUp; + int16 SuperscriptShiftUpCramped; + int16 SuperscriptBottomMin; + int16 SuperscriptBaselineDropMax; + int16 SubSuperscriptGapMin; + int16 SuperscriptBottomMaxWithSubscript; + int16 SpaceAfterScript; + int16 UpperLimitGapMin; + int16 UpperLimitBaselineRiseMin; + int16 LowerLimitGapMin; + int16 LowerLimitBaselineDropMin; + int16 StackTopShiftUp; + int16 StackTopDisplayStyleShiftUp; + int16 StackBottomShiftDown; + int16 StackBottomDisplayStyleShiftDown; + int16 StackGapMin; + int16 StackDisplayStyleGapMin; + int16 StretchStackTopShiftUp; + int16 StretchStackBottomShiftDown; + int16 StretchStackGapAboveMin; + int16 StretchStackGapBelowMin; + int16 FractionNumeratorShiftUp; + int16 FractionNumeratorDisplayStyleShiftUp; + int16 FractionDenominatorShiftDown; + int16 FractionDenominatorDisplayStyleShiftDown; + int16 FractionNumeratorGapMin; + int16 FractionNumeratorDisplayStyleGapMin; + int16 FractionRuleThickness; + int16 FractionDenominatorGapMin; + int16 FractionDenominatorDisplayStyleGapMin; + int16 SkewedFractionHorizontalGap; + int16 SkewedFractionVerticalGap; + int16 OverbarVerticalGap; + int16 OverbarRuleThickness; + int16 OverbarExtraAscender; + int16 UnderbarVerticalGap; + int16 UnderbarRuleThickness; + int16 UnderbarExtraDescender; + int16 RadicalVerticalGap; + int16 RadicalDisplayStyleVerticalGap; + int16 RadicalRuleThickness; + int16 RadicalExtraAscender; + int16 RadicalKernBeforeDegree; + int16 RadicalKernAfterDegree; + uint16 RadicalDegreeBottomRaisePercent; +/* Global constants from other subtables */ + uint16 MinConnectorOverlap; /* in the math variants sub-table */ +}; +#endif + +enum backedup_state { bs_dontknow=0, bs_not=1, bs_backedup=2 }; +enum loadvalidation_state { + lvs_bad_ps_fontname = 0x001, + lvs_bad_glyph_table = 0x002, + lvs_bad_cff_table = 0x004, + lvs_bad_metrics_table = 0x008, + lvs_bad_cmap_table = 0x010, + lvs_bad_bitmaps_table = 0x020, + lvs_bad_gx_table = 0x040, + lvs_bad_ot_table = 0x080, + lvs_bad_os2_version = 0x100, + lvs_bad_sfnt_header = 0x200 + }; + +typedef struct layerinfo { + char *name; + unsigned int background: 1; /* Layer is to be treated as background: No width, images, not worth outputting */ + unsigned int order2: 1; /* Layer's data are order 2 bezier splines (truetype) rather than order 3 (postscript) */ + /* In all glyphs in the font */ + unsigned int ticked: 1; +} LayerInfo; + +/* Baseline data from the 'BASE' table */ +struct baselangextent { + uint32 lang; /* also used for feature tag */ + struct baselangextent *next; + int16 ascent, descent; + struct baselangextent *features; +}; + +struct basescript { + uint32 script; + struct basescript *next; + int def_baseline; /* index [0-baseline_cnt) */ + int16 *baseline_pos; /* baseline_cnt of these */ + struct baselangextent *langs; /* Language specific extents (may be NULL) */ + /* The default one has the tag DEFAULT_LANG */ +}; + +struct Base { + int baseline_cnt; + uint32 *baseline_tags; + /* A font does not need to provide info on all baselines, but if one script */ + /* talks about a baseline, then all must. So the set of baselines is global*/ + struct basescript *scripts; +}; + +typedef struct splinefont { + char *fontname, *fullname, *familyname, *weight; + char *copyright; + char *filename; /* sfd name. NULL if we open a font, that's origname */ + char *defbasefilename; + char *version; + real italicangle, upos, uwidth; /* In font info */ + int units_per_em; + struct splinefont *next; + int ascent, descent; + int uniqueid; /* Not copied when reading in!!!! */ + int glyphcnt, glyphmax; /* allocated size of glyphs array */ + SplineChar **glyphs; + unsigned int changed: 1; + unsigned int changed_since_autosave: 1; + unsigned int changed_since_xuidchanged: 1; + unsigned int display_antialias: 1; + unsigned int display_bbsized: 1; + unsigned int dotlesswarn: 1; /* User warned that font doesn't have a dotless i character */ + unsigned int onlybitmaps: 1; /* it's a bdf editor, not a postscript editor */ + unsigned int serifcheck: 1; /* Have we checked to see if we have serifs? */ + unsigned int issans: 1; /* We have no serifs */ + unsigned int isserif: 1; /* We have serifs. If neither set then we don't know. */ + unsigned int hasvmetrics: 1; /* We've got vertical metric data and should output vhea/vmtx/VORG tables */ + unsigned int loading_cid_map: 1; + unsigned int dupnamewarn: 1; /* Warn about duplicate names when loading bdf font */ + unsigned int encodingchanged: 1; /* Font's encoding has changed since it was loaded */ + unsigned int multilayer: 1; /* only applies if TYPE3 is set, means this font can contain strokes & fills */ + /* I leave it in so as to avoid cluttering up code with #ifdefs */ + unsigned int strokedfont: 1; + unsigned int new: 1; /* A new and unsaved font */ + unsigned int compacted: 1; /* only used when opening a font */ + unsigned int backedup: 2; /* 0=>don't know, 1=>no, 2=>yes */ + unsigned int use_typo_metrics: 1; /* The standard says to. But MS */ + /* seems to feel that isn't good */ + /* enough and has created a bit */ + /* to mean "really use them" */ + unsigned int weight_width_slope_only: 1; /* This bit seems stupid to me */ + unsigned int save_to_dir: 1; /* Loaded from an sfdir collection rather than a simple sfd file */ + 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" */ + unsigned int ticked: 1; + unsigned int internal_temp: 1; /* Internal temporary font to be passed to freetype for rasterizing. Don't complain about oddities */ + unsigned int complained_about_spiros: 1; + unsigned int use_xuid: 1; /* Adobe has deprecated these two */ + unsigned int use_uniqueid: 1; /* fields. Mostly we don't want to use them */ + /* 2 bits left */ + struct fontviewbase *fv; + struct metricsview *metrics; + enum uni_interp uni_interp; + NameList *for_new_glyphs; + EncMap *map; /* only used when opening a font to provide original default encoding */ + Layer grid; + BDFFont *bitmaps; + char *origname; /* filename of font file (ie. if not an sfd) */ + char *autosavename; + int display_size; /* a val <0 => Generate our own images from splines, a value >0 => find a bdf font of that size */ + struct psdict *private; /* read in from type1 file or provided by user */ + char *xuid; + struct pfminfo { /* A misnomer now. OS/2 info would be more accurate, but that's stuff in here from all over ttf files */ + unsigned int pfmset: 1; + unsigned int winascent_add: 1; + unsigned int windescent_add: 1; + unsigned int hheadascent_add: 1; + unsigned int hheaddescent_add: 1; + unsigned int typoascent_add: 1; + unsigned int typodescent_add: 1; + unsigned int subsuper_set: 1; + unsigned int panose_set: 1; + unsigned int hheadset: 1; + unsigned int vheadset: 1; + unsigned int hascodepages: 1; + unsigned int hasunicoderanges: 1; + unsigned char pfmfamily; + int16 weight; + int16 width; + char panose[10]; + int16 fstype; + int16 linegap; /* from hhea */ + int16 vlinegap; /* from vhea */ + int16 hhead_ascent, hhead_descent; + int16 os2_typoascent, os2_typodescent, os2_typolinegap; + int16 os2_winascent, os2_windescent; + int16 os2_subxsize, os2_subysize, os2_subxoff, os2_subyoff; + int16 os2_supxsize, os2_supysize, os2_supxoff, os2_supyoff; + int16 os2_strikeysize, os2_strikeypos; + char os2_vendor[4]; + int16 os2_family_class; + uint32 codepages[2]; + uint32 unicoderanges[4]; + uint16 avgwidth; + uint16 firstchar; + uint16 lastchar; + int16 os2_xheight; + int16 os2_capheight; + uint16 os2_defaultchar; + uint16 os2_breakchar; + } pfminfo; + struct ttflangname *names; + char *cidregistry, *ordering; + int supplement; + int subfontcnt; + struct splinefont **subfonts; + struct splinefont *cidmaster; /* Top level cid font */ + float cidversion; +#if HANYANG + struct compositionrules *rules; +#endif + char *comments; /* Used to be restricted to ASCII, now utf8 */ + char *fontlog; + int tempuniqueid; + int top_enc; + uint16 desired_row_cnt, desired_col_cnt; + struct glyphnamehash *glyphnames; + struct ttf_table { + uint32 tag; + int32 len, maxlen; + uint8 *data; + struct ttf_table *next; + FILE *temp; /* Temporary storage used during generation */ + } *ttf_tables, *ttf_tab_saved; + /* We copy: fpgm, prep, cvt, maxp (into ttf_tables) user can ask for others, into saved*/ + char **cvt_names; + /* The end of this array is marked by a special entry: */ +#define END_CVT_NAMES ((char *) (~(intpt) 0)) + struct instrdata *instr_dlgs; /* Pointer to all table and character instruction dlgs in this font */ + struct shortview *cvt_dlg; + struct kernclasslistdlg *kcld, *vkcld; + struct kernclassdlg *kcd; + struct texdata { + enum { tex_unset, tex_text, tex_math, tex_mathext } type; + int32 params[22]; /* param[6] has different meanings in normal and math fonts */ + } texdata; + OTLookup *gsub_lookups, *gpos_lookups; + /* Apple morx subtables become gsub, and kern subtables become gpos */ + AnchorClass *anchor; + KernClass *kerns, *vkerns; + FPST *possub; + ASM *sm; /* asm is a keyword */ + MacFeat *features; + char *chosenname; /* Set for files with multiple fonts in them */ + struct mmset *mm; /* If part of a multiple master set */ + int16 macstyle; + char *fondname; /* For use in generating mac families */ + /* from the GPOS 'size' feature. design_size, etc. are measured in tenths of a point */ + /* bottom is exclusive, top is inclusive */ + /* if any field is 0, it is undefined. All may be undefined, All may be */ + /* defined, or design_size may be defined without any of the others */ + /* but we can't define the range without defining the other junk */ + /* Name must contain an English language name, may contain others */ + uint16 design_size; + uint16 fontstyle_id; + struct otfname *fontstyle_name; + uint16 design_range_bottom, design_range_top; + real strokewidth; +/* For GDEF Mark Attachment Class -- used in lookup flags */ +/* As usual, class 0 is unused */ + int mark_class_cnt; + char **mark_classes; /* glyph name list */ + char **mark_class_names; /* used within ff, utf8 (the name we've given to this class of marks) */ +#ifdef _HAS_LONGLONG + long long creationtime; /* seconds since 1970 */ + long long modificationtime; +#else + long creationtime; + long modificationtime; +#endif + short os2_version; /* 0 means default rather than the real version 0 */ + short compression; /* If we opened a compressed sfd file, then save it out compressed too */ + short gasp_version; /* 0/1 currently */ + short gasp_cnt; + struct gasp { + uint16 ppem; + uint16 flags; + } *gasp; + struct MATH *MATH; + float sfd_version; /* Used only when reading in an sfd file */ + struct gfi_data *fontinfo; + struct val_data *valwin; + void *python_temporary; + 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 */ + enum loadvalidation_state loadvalidation_state; + LayerInfo *layers; + int layer_cnt; + int display_layer; + struct Base *horiz_base, *vert_base; + int extrema_bound; /* Splines do not count for extrema complaints when the distance between the endpoints is less than or equal to this */ +} SplineFont; + +/* I am going to simplify my life and not encourage intermediate designs */ +/* this means I can easily calculate ConvertDesignVector, and don't have */ +/* to bother the user with specifying it. */ +/* (NormalizeDesignVector is fairly basic and shouldn't need user help ever) */ +/* (As long as they want piecewise linear) */ +/* I'm not going to support intermediate designs at all for apple var tables */ +typedef struct mmset { + int axis_count; + char *axes[4]; + int instance_count; + SplineFont **instances; + SplineFont *normal; + real *positions; /* array[instance][axis] saying where each instance lies on each axis */ + real *defweights; /* array[instance] saying how much of each instance makes the normal font */ + /* for adobe */ + struct axismap { + int points; /* size of the next two arrays */ + real *blends; /* between [0,1] ordered so that blend[0]<blend[1]<... */ + real *designs; /* between the design ranges for this axis, typically [1,999] or [6,72] */ + real min, def, max; /* For mac */ + struct macname *axisnames; /* For mac */ + } *axismaps; /* array[axis] */ + char *cdv, *ndv; /* for adobe */ + int named_instance_count; + struct named_instance { /* For mac */ + real *coords; /* array[axis], these are in user units */ + struct macname *names; + } *named_instances; + unsigned int changed: 1; + unsigned int apple: 1; +} MMSet; + +/* mac styles. Useful idea we'll just steal it */ +enum style_flags { sf_bold = 1, sf_italic = 2, sf_underline = 4, sf_outline = 8, + sf_shadow = 0x10, sf_condense = 0x20, sf_extend = 0x40 }; + +struct sflist { + SplineFont *sf; + int32 *sizes; + FILE *tempttf; /* For ttf */ + int id; /* For ttf */ + int* ids; /* One for each size */ + BDFFont **bdfs; /* Ditto */ + EncMap *map; + struct sflist *next; + char **former_names; +}; + + /* Used for drawing text with mark to base anchors */ +typedef struct anchorpos { + SplineChar *sc; /* This is the mark being positioned */ + int x,y; /* Its origin should be shifted this much relative to that of the original base char */ + AnchorPoint *apm; /* The anchor point in sc used to position it */ + AnchorPoint *apb; /* The anchor point in the base character against which we are positioned */ + int base_index; /* Index in this array to the base character (-1=> original base char) */ + unsigned int ticked: 1; /* Used as a mark to mark */ +} AnchorPos; + +enum ttf_flags { ttf_flag_shortps = 1, ttf_flag_nohints = 2, + ttf_flag_applemode=4, + ttf_flag_pfed_comments=8, ttf_flag_pfed_colors=0x10, + ttf_flag_otmode=0x20, + ttf_flag_glyphmap=0x40, + ttf_flag_TeXtable=0x80, + ttf_flag_ofm=0x100, + ttf_flag_oldkern=0x200, /* never set in conjunction with applemode */ + 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 */ + ttf_flag_pfed_lookupnames=0x800, + ttf_flag_pfed_guides=0x1000, + ttf_flag_pfed_layers=0x2000, + ttf_flag_symbol=0x4000, + ttf_flag_dummyDSIG=0x8000 + }; +enum openflags { of_fstypepermitted=1, of_askcmap=2, of_all_glyphs_in_ttc=4, + of_fontlint=8, of_hidewindow=0x10 }; +enum ps_flags { ps_flag_nohintsubs = 0x10000, ps_flag_noflex=0x20000, + ps_flag_nohints = 0x40000, ps_flag_restrict256=0x80000, + ps_flag_afm = 0x100000, ps_flag_pfm = 0x200000, + ps_flag_tfm = 0x400000, + ps_flag_round = 0x800000, +/* CFF fonts are wrapped up in some postscript sugar -- unless they are to */ +/* go into a pdf file or an otf font */ + ps_flag_nocffsugar = 0x1000000, +/* in type42 cid fonts we sometimes want an identity map from gid to cid */ + ps_flag_identitycidmap = 0x2000000, + ps_flag_afmwithmarks = 0x4000000, + ps_flag_noseac = 0x8000000, + ps_flag_outputfontlog = 0x10000000, + ps_flag_mask = (ps_flag_nohintsubs|ps_flag_noflex| + ps_flag_afm|ps_flag_pfm|ps_flag_tfm|ps_flag_round) + }; + +struct compressors { char *ext, *decomp, *recomp; }; +struct archivers { + char *ext, *unarchive, *archive, *listargs, *extractargs, *appendargs; + enum archive_list_style { ars_tar, ars_zip } ars; +}; + +struct fontdict; +struct pschars; +struct findsel; +struct charprocs; +struct enc; + +extern void *chunkalloc(int size); +extern void chunkfree(void *, int size); + +extern char *strconcat(const char *str, const char *str2); +extern char *strconcat3(const char *str, const char *str2, const char *str3); + +extern char *XUIDFromFD(int xuid[20]); +extern SplineFont *SplineFontFromPSFont(struct fontdict *fd); +extern int CheckAfmOfPostscript(SplineFont *sf,char *psname,EncMap *map); +extern int LoadKerningDataFromAmfm(SplineFont *sf, char *filename, EncMap *map); +extern int LoadKerningDataFromAfm(SplineFont *sf, char *filename, EncMap *map); +extern int LoadKerningDataFromTfm(SplineFont *sf, char *filename, EncMap *map); +extern int LoadKerningDataFromOfm(SplineFont *sf, char *filename, EncMap *map); +extern int LoadKerningDataFromPfm(SplineFont *sf, char *filename, EncMap *map); +extern int LoadKerningDataFromMacFOND(SplineFont *sf, char *filename, EncMap *map); +extern int LoadKerningDataFromMetricsFile(SplineFont *sf, char *filename, EncMap *map); +extern void FeatDumpFontLookups(FILE *out,SplineFont *sf); +extern void FeatDumpOneLookup(FILE *out,SplineFont *sf, OTLookup *otl); +extern void SFApplyFeatureFile(SplineFont *sf,FILE *file,char *filename); +extern void SFApplyFeatureFilename(SplineFont *sf,char *filename); +extern void SubsNew(SplineChar *to,enum possub_type type,int tag,char *components, + SplineChar *default_script); +extern void PosNew(SplineChar *to,int tag,int dx, int dy, int dh, int dv); +extern int SFOneWidth(SplineFont *sf); +extern int CIDOneWidth(SplineFont *sf); +extern int SFOneHeight(SplineFont *sf); +extern int SFIsCJK(SplineFont *sf,EncMap *map); +extern void CIDMasterAsDes(SplineFont *sf); +enum fontformat { ff_pfa, ff_pfb, ff_pfbmacbin, ff_multiple, ff_mma, ff_mmb, + ff_ptype3, ff_ptype0, ff_cid, ff_cff, ff_cffcid, + ff_type42, ff_type42cid, + ff_ttf, ff_ttfsym, ff_ttfmacbin, ff_ttfdfont, ff_otf, ff_otfdfont, + ff_otfcid, ff_otfciddfont, ff_svg, ff_ufo, ff_none }; +extern struct pschars *SplineFont2ChrsSubrs(SplineFont *sf, int iscjk, + struct pschars *subrs,int flags,enum fontformat format,int layer); +extern int CanonicalCombiner(int uni); +struct cidbytes; +struct fd2data; +struct ttfinfo; +struct alltabs; +struct growbuf; +struct glyphdata; +extern int UnitsParallel(BasePoint *u1,BasePoint *u2,int strict); +extern int CvtPsStem3(struct growbuf *gb, SplineChar *scs[MmMax], int instance_count, + int ishstem, int round); +extern struct pschars *CID2ChrsSubrs(SplineFont *cidmaster,struct cidbytes *cidbytes,int flags,int layer); +extern struct pschars *SplineFont2ChrsSubrs2(SplineFont *sf, int nomwid, + int defwid, const int *bygid, int cnt, int flags, + struct pschars **_subrs,int layer); +extern struct pschars *CID2ChrsSubrs2(SplineFont *cidmaster,struct fd2data *fds, + int flags, struct pschars **_glbls,int layer); +enum bitmapformat { bf_bdf, bf_ttf, bf_sfnt_dfont, bf_sfnt_ms, bf_otb, + bf_nfntmacbin, /*bf_nfntdfont, */bf_fon, bf_fnt, bf_palm, + bf_ptype3, + bf_none }; +extern const char *GetAuthor(void); +extern SplineChar *SFFindExistingCharMac(SplineFont *,EncMap *map, int unienc); +extern void SC_PSDump(void (*dumpchar)(int ch,void *data), void *data, + SplineChar *sc, int refs_to_splines, int pdfopers,int layer ); +extern int _WritePSFont(FILE *out,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,SplineFont *fullsf,int layer); +extern int WritePSFont(char *fontname,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,SplineFont *fullsf,int layer); +extern int WriteMacPSFont(char *fontname,SplineFont *sf,enum fontformat format, + int flags,EncMap *enc,int layer); +extern int _WriteTTFFont(FILE *ttf,SplineFont *sf, enum fontformat format, + int32 *bsizes, enum bitmapformat bf,int flags,EncMap *enc,int layer); +extern int WriteTTFFont(char *fontname,SplineFont *sf, enum fontformat format, + int32 *bsizes, enum bitmapformat bf,int flags,EncMap *enc,int layer); +extern int _WriteType42SFNTS(FILE *type42,SplineFont *sf,enum fontformat format, + int flags,EncMap *enc,int layer); +extern int WriteMacTTFFont(char *fontname,SplineFont *sf, enum fontformat format, + int32 *bsizes, enum bitmapformat bf,int flags,EncMap *enc,int layer); +extern int WriteMacBitmaps(char *filename,SplineFont *sf, int32 *sizes, + int is_dfont,EncMap *enc); +extern int WritePalmBitmaps(char *filename,SplineFont *sf, int32 *sizes,EncMap *enc); +extern int WriteMacFamily(char *filename,struct sflist *sfs,enum fontformat format, + enum bitmapformat bf,int flags,EncMap *enc,int layer); +extern long mactime(void); +extern int WriteSVGFont(char *fontname,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,int layer); +extern int WriteUFOFont(char *fontname,SplineFont *sf,enum fontformat format,int flags,EncMap *enc,int layer); +extern void SfListFree(struct sflist *sfs); +extern void TTF_PSDupsDefault(SplineFont *sf); +extern void DefaultTTFEnglishNames(struct ttflangname *dummy, SplineFont *sf); +extern void TeXDefaultParams(SplineFont *sf); +extern int AlreadyMSSymbolArea(SplineFont *sf,EncMap *map); +extern void OS2FigureCodePages(SplineFont *sf, uint32 CodePage[2]); +extern void OS2FigureUnicodeRanges(SplineFont *sf, uint32 Ranges[4]); +extern void SFDefaultOS2Info(struct pfminfo *pfminfo,SplineFont *sf,char *fontname); +extern void SFDefaultOS2Simple(struct pfminfo *pfminfo,SplineFont *sf); +extern void SFDefaultOS2SubSuper(struct pfminfo *pfminfo,int emsize,double italicangle); +extern void VerifyLanguages(SplineFont *sf); +extern int ScriptIsRightToLeft(uint32 script); +extern void ScriptMainRange(uint32 script, int *start, int *end); +extern uint32 ScriptFromUnicode(int u,SplineFont *sf); +extern uint32 SCScriptFromUnicode(SplineChar *sc); +extern int SCRightToLeft(SplineChar *sc); +extern int SLIContainsR2L(SplineFont *sf,int sli); +extern void SFFindNearTop(SplineFont *); +extern void SFRestoreNearTop(SplineFont *); +extern int SFForceEncoding(SplineFont *sf,EncMap *old,Encoding *new_map); +extern int CountOfEncoding(Encoding *encoding_name); +extern void SFMatchGlyphs(SplineFont *sf,SplineFont *target,int addempties); +extern void MMMatchGlyphs(MMSet *mm); +extern char *_GetModifiers(char *fontname, char *familyname,char *weight); +extern char *SFGetModifiers(SplineFont *sf); +extern const unichar_t *_uGetModifiers(const unichar_t *fontname, const unichar_t *familyname, + const unichar_t *weight); +extern void SFSetFontName(SplineFont *sf, char *family, char *mods, char *full); +extern void ttfdumpbitmap(SplineFont *sf,struct alltabs *at,int32 *sizes); +extern void ttfdumpbitmapscaling(SplineFont *sf,struct alltabs *at,int32 *sizes); +extern void SplineFontSetUnChanged(SplineFont *sf); + +extern int RealNear(real a,real b); +extern int RealNearish(real a,real b); +extern int RealApprox(real a,real b); +extern int RealWithin(real a,real b,real fudge); +extern int RealRatio(real a,real b,real fudge); + +extern int PointsDiagonalable(SplineFont *sf,BasePoint **bp,BasePoint *unit); +extern int MergeDStemInfo(SplineFont *sf,DStemInfo **ds, DStemInfo *test); + +extern void LineListFree(LineList *ll); +extern void LinearApproxFree(LinearApprox *la); +extern void SplineFree(Spline *spline); +extern SplinePoint *SplinePointCreate(real x, real y); +extern void SplinePointFree(SplinePoint *sp); +extern void SplinePointMDFree(SplineChar *sc,SplinePoint *sp); +extern void SplinePointsFree(SplinePointList *spl); +extern void SplinePointListFree(SplinePointList *spl); +extern void SplinePointListMDFree(SplineChar *sc,SplinePointList *spl); +extern void SplinePointListsMDFree(SplineChar *sc,SplinePointList *spl); +extern void SplinePointListsFree(SplinePointList *head); +extern void SplineSetBeziersClear(SplineSet *spl); +extern void RefCharFree(RefChar *ref); +extern void RefCharsFree(RefChar *ref); +extern void RefCharsFreeRef(RefChar *ref); +extern void CopyBufferFree(void); +extern void CopyBufferClearCopiedFrom(SplineFont *dying); +extern void UndoesFree(Undoes *undo); +extern void StemInfosFree(StemInfo *h); +extern void StemInfoFree(StemInfo *h); +extern void DStemInfosFree(DStemInfo *h); +extern void DStemInfoFree(DStemInfo *h); +extern void KernPairsFree(KernPair *kp); +extern void SCOrderAP(SplineChar *sc); +extern void AnchorPointsFree(AnchorPoint *ap); +extern AnchorPoint *AnchorPointsCopy(AnchorPoint *alist); +extern void SFRemoveAnchorClass(SplineFont *sf,AnchorClass *an); +extern int AnchorClassesNextMerge(AnchorClass *ac); +extern int IsAnchorClassUsed(SplineChar *sc,AnchorClass *an); +extern AnchorPoint *APAnchorClassMerge(AnchorPoint *anchors,AnchorClass *into,AnchorClass *from); +extern void AnchorClassMerge(SplineFont *sf,AnchorClass *into,AnchorClass *from); +extern void AnchorClassesFree(AnchorClass *kp); +extern void TtfTablesFree(struct ttf_table *tab); +extern void SFRemoveSavedTable(SplineFont *sf, uint32 tag); +extern AnchorClass *AnchorClassMatch(SplineChar *sc1,SplineChar *sc2, + AnchorClass *restrict_, AnchorPoint **_ap1,AnchorPoint **_ap2 ); +extern AnchorClass *AnchorClassMkMkMatch(SplineChar *sc1,SplineChar *sc2, + AnchorPoint **_ap1,AnchorPoint **_ap2 ); +extern AnchorClass *AnchorClassCursMatch(SplineChar *sc1,SplineChar *sc2, + AnchorPoint **_ap1,AnchorPoint **_ap2 ); +extern void SCInsertPST(SplineChar *sc,PST *new); +#ifdef FONTFORGE_CONFIG_DEVICETABLES +extern void ValDevFree(ValDevTab *adjust); +extern ValDevTab *ValDevTabCopy(ValDevTab *orig); +extern void DeviceTableFree(DeviceTable *adjust); +extern DeviceTable *DeviceTableCopy(DeviceTable *orig); +extern void DeviceTableSet(DeviceTable *adjust, int size, int correction); +#endif +extern void PSTFree(PST *lig); +extern uint16 PSTDefaultFlags(enum possub_type type,SplineChar *sc ); +extern int PSTContains(const char *components,const char *name); +extern StemInfo *StemInfoCopy(StemInfo *h); +extern DStemInfo *DStemInfoCopy(DStemInfo *h); +extern MinimumDistance *MinimumDistanceCopy(MinimumDistance *h); +extern void SPChangePointType(SplinePoint *sp, int pointtype); +struct sfmergecontext { + SplineFont *sf_from, *sf_to; + int lcnt; + struct lookup_cvt { OTLookup *from, *to; int old;} *lks; + int scnt; + struct sub_cvt { struct lookup_subtable *from, *to; int old;} *subs; + int acnt; + struct ac_cvt { AnchorClass *from, *to; int old;} *acs; + char *prefix; + int preserveCrossFontKerning; + int lmax; +}; +extern PST *PSTCopy(PST *base,SplineChar *sc,struct sfmergecontext *mc); +extern struct lookup_subtable *MCConvertSubtable(struct sfmergecontext *mc,struct lookup_subtable *sub); +extern AnchorClass *MCConvertAnchorClass(struct sfmergecontext *mc,AnchorClass *ac); +extern void SFFinishMergeContext(struct sfmergecontext *mc); +extern SplineChar *SplineCharCopy(SplineChar *sc,SplineFont *into,struct sfmergecontext *); +extern BDFChar *BDFCharCopy(BDFChar *bc); +extern void BCFlattenFloat(BDFChar *bc); +extern void BitmapsCopy(SplineFont *to, SplineFont *from, int to_index, int from_index ); +extern struct gimage *ImageAlterClut(struct gimage *image); +extern void ImageListsFree(ImageList *imgs); +extern void TTFLangNamesFree(struct ttflangname *l); +extern void AltUniFree(struct altuni *altuni); +extern void AltUniFigure(SplineFont *sf,EncMap *map); +extern void AltUniRemove(SplineChar *sc,int uni); +extern void AltUniAdd(SplineChar *sc,int uni); +extern void MinimumDistancesFree(MinimumDistance *md); +extern void LayerDefault(Layer *); +extern SplineChar *SplineCharCreate(int layer_cnt); +extern SplineChar *SFSplineCharCreate(SplineFont *sf); +extern RefChar *RefCharCreate(void); +extern RefChar *RefCharsCopy(RefChar *ref); /* Still needs to be instanciated and have the dependency list adjusted */ +extern void SCAddRef(SplineChar *sc,SplineChar *rsc,int layer, real xoff, real yoff); +extern void _SCAddRef(SplineChar *sc,SplineChar *rsc,int layer, real transform[6]); +extern KernClass *KernClassCopy(KernClass *kc); +extern void KernClassFreeContents(KernClass *kc); +extern void KernClassListFree(KernClass *kc); +extern int KernClassContains(KernClass *kc, char *name1, char *name2, int ordered ); +extern void OTLookupFree(OTLookup *lookup); +extern void OTLookupListFree(OTLookup *lookup ); +extern FPST *FPSTCopy(FPST *fpst); +extern void FPSTRuleContentsFree(struct fpst_rule *r, enum fpossub_format format); +extern void FPSTRulesFree(struct fpst_rule *r, enum fpossub_format format, int rcnt); +extern void FPSTFree(FPST *fpst); +extern void ASMFree(ASM *sm); +extern struct macname *MacNameCopy(struct macname *mn); +extern void MacNameListFree(struct macname *mn); +extern void MacSettingListFree(struct macsetting *ms); +extern void MacFeatListFree(MacFeat *mf); +extern void GlyphVariantsFree(struct glyphvariants *gv); +extern void MathKernVContentsFree(struct mathkernvertex *mk); +extern void MathKernFree(struct mathkern *mk); +extern struct mathkern *MathKernCopy(struct mathkern *mk); +extern void SplineCharListsFree(struct splinecharlist *dlist); +extern void LayerFreeContents(SplineChar *sc, int layer); +extern void SplineCharFreeContents(SplineChar *sc); +extern void SplineCharFree(SplineChar *sc); +extern void EncMapFree(EncMap *map); +extern EncMap *EncMapFromEncoding(SplineFont *sf,Encoding *enc); +extern EncMap *CompactEncMap(EncMap *map, SplineFont *sf); +extern EncMap *EncMapNew(int encmax, int backmax, Encoding *enc); +extern EncMap *EncMap1to1(int enccount); +extern EncMap *EncMapCopy(EncMap *map); +extern void SFExpandGlyphCount(SplineFont *sf, int newcnt); +extern void ScriptLangListFree(struct scriptlanglist *sl); +extern void FeatureScriptLangListFree(FeatureScriptLangList *fl); +extern void SFBaseSort(SplineFont *sf); +extern struct baselangextent *BaseLangCopy(struct baselangextent *extent); +extern void BaseLangFree(struct baselangextent *extent); +extern void BaseScriptFree(struct basescript *bs); +extern void BaseFree(struct Base *base); +extern void SplineFontFree(SplineFont *sf); +extern void MATHFree(struct MATH *math); +extern struct MATH *MathTableNew(SplineFont *sf); +extern void OtfNameListFree(struct otfname *on); +extern void MarkClassFree(int cnt,char **classes,char **names); +extern void MMSetFreeContents(MMSet *mm); +extern void MMSetFree(MMSet *mm); +extern void SFRemoveUndoes(SplineFont *sf,uint8 *selected,EncMap *map); +extern void SplineRefigure3(Spline *spline); +extern void SplineRefigure(Spline *spline); +extern Spline *SplineMake3(SplinePoint *from, SplinePoint *to); +extern LinearApprox *SplineApproximate(Spline *spline, real scale); +extern int SplinePointListIsClockwise(const SplineSet *spl); +extern void SplineSetFindBounds(const SplinePointList *spl, DBounds *bounds); +extern void SplineCharLayerFindBounds(SplineChar *sc,int layer,DBounds *bounds); +extern void SplineCharFindBounds(SplineChar *sc,DBounds *bounds); +extern void SplineFontLayerFindBounds(SplineFont *sf,int layer,DBounds *bounds); +extern void SplineFontFindBounds(SplineFont *sf,DBounds *bounds); +extern void CIDLayerFindBounds(SplineFont *sf,int layer,DBounds *bounds); +extern void SplineSetQuickBounds(SplineSet *ss,DBounds *b); +extern void SplineCharQuickBounds(SplineChar *sc, DBounds *b); +extern void SplineSetQuickConservativeBounds(SplineSet *ss,DBounds *b); +extern void SplineCharQuickConservativeBounds(SplineChar *sc, DBounds *b); +extern void SplineFontQuickConservativeBounds(SplineFont *sf,DBounds *b); +extern void SplinePointCatagorize(SplinePoint *sp); +extern int SplinePointIsACorner(SplinePoint *sp); +extern void SPLCatagorizePoints(SplinePointList *spl); +extern void SCCatagorizePoints(SplineChar *sc); +extern SplinePointList *SplinePointListCopy1(const SplinePointList *spl); +extern SplinePointList *SplinePointListCopy(const SplinePointList *base); +extern SplinePointList *SplinePointListCopySelected(SplinePointList *base); +extern ImageList *ImageListCopy(ImageList *cimg); +extern ImageList *ImageListTransform(ImageList *cimg,real transform[6]); +extern void ApTransform(AnchorPoint *ap, real transform[6]); +extern SplinePointList *SplinePointListTransform(SplinePointList *base, real transform[6], int allpoints ); +extern SplinePointList *SplinePointListShift(SplinePointList *base, real xoff, int allpoints ); +extern HintMask *HintMaskFromTransformedRef(RefChar *ref,BasePoint *trans, + SplineChar *basesc,HintMask *hm); +extern SplinePointList *SPLCopyTranslatedHintMasks(SplinePointList *base, + SplineChar *basesc, SplineChar *subsc, BasePoint *trans); +extern SplinePointList *SPLCopyTransformedHintMasks(RefChar *r, + SplineChar *basesc, BasePoint *trans,int layer); +extern SplinePointList *SplinePointListRemoveSelected(SplineChar *sc,SplinePointList *base); +extern void SplinePointListSet(SplinePointList *tobase, SplinePointList *frombase); +extern void SplinePointListSelect(SplinePointList *spl,int sel); +extern void SCRefToSplines(SplineChar *sc,RefChar *rf,int layer); +extern void RefCharFindBounds(RefChar *rf); +extern void SCReinstanciateRefChar(SplineChar *sc,RefChar *rf,int layer); +extern void SCReinstanciateRef(SplineChar *sc,SplineChar *rsc,int layer); +extern void SFReinstanciateRefs(SplineFont *sf); +extern void SFInstanciateRefs(SplineFont *sf); +extern SplineChar *MakeDupRef(SplineChar *base, int local_enc, int uni_enc); +extern void SCRemoveDependent(SplineChar *dependent,RefChar *rf,int layer); +extern void SCRemoveLayerDependents(SplineChar *dependent,int layer); +extern void SCRemoveDependents(SplineChar *dependent); +extern int SCDependsOnSC(SplineChar *parent, SplineChar *child); +extern void BCCompressBitmap(BDFChar *bdfc); +extern void BCRegularizeBitmap(BDFChar *bdfc); +extern void BCRegularizeGreymap(BDFChar *bdfc); +extern void BCPasteInto(BDFChar *bc,BDFChar *rbc,int ixoff,int iyoff, int invert, int cleartoo); +extern void BCRotateCharForVert(BDFChar *bc,BDFChar *from, BDFFont *frombdf); +extern int GradientHere(double scale,DBounds *bbox,int iy,int ix, + struct gradient *grad,struct pattern *pat, int defgrey); +extern void PatternPrep(SplineChar *sc,struct brush *brush,double scale); +extern BDFChar *SplineCharRasterize(SplineChar *sc, int layer, double pixelsize); +extern BDFFont *SplineFontToBDFHeader(SplineFont *_sf, int pixelsize, int indicate); +extern BDFFont *SplineFontRasterize(SplineFont *sf, int layer, int pixelsize, int indicate); +extern void BDFCAntiAlias(BDFChar *bc, int linear_scale); +extern BDFChar *SplineCharAntiAlias(SplineChar *sc, int layer, int pixelsize,int linear_scale); +extern BDFFont *SplineFontAntiAlias(SplineFont *sf, int layer, int pixelsize,int linear_scale); +extern struct clut *_BDFClut(int linear_scale); +extern void BDFClut(BDFFont *bdf, int linear_scale); +extern int BDFDepth(BDFFont *bdf); +extern BDFChar *BDFPieceMeal(BDFFont *bdf, int index); +extern BDFChar *BDFPieceMealCheck(BDFFont *bdf, int index); +enum piecemeal_flags { pf_antialias=1, pf_bbsized=2, pf_ft_nohints=4 }; +extern BDFFont *SplineFontPieceMeal(SplineFont *sf,int layer,int pixelsize,int flags,void *freetype_context); +extern void BDFCharFindBounds(BDFChar *bc,IBounds *bb); +extern BDFFont *BitmapFontScaleTo(BDFFont *old, int to); +extern void BDFCharFree(BDFChar *bdfc); +extern void BDFPropsFree(BDFFont *bdf); +extern void BDFFontFree(BDFFont *bdf); +extern void SFDefaultAscent(SplineFont *sf); +extern int PSBitmapDump(char *filename,BDFFont *font, EncMap *map); +extern int BDFFontDump(char *filename,BDFFont *font, EncMap *map, int res); +extern int FNTFontDump(char *filename,BDFFont *font, EncMap *map, int res); +extern int FONFontDump(char *filename,SplineFont *sf, int32 *sizes,int res, + EncMap *map); +extern void SFReplaceEncodingBDFProps(SplineFont *sf,EncMap *map); +extern void SFReplaceFontnameBDFProps(SplineFont *sf); +extern int IsUnsignedBDFKey(char *key); +extern int BdfPropHasInt(BDFFont *font,const char *key, int def ); +extern char *BdfPropHasString(BDFFont *font,const char *key, char *def ); +extern void def_Charset_Enc(EncMap *map,char *reg,char *enc); +extern void Default_XLFD(BDFFont *bdf,EncMap *map, int res); +extern void Default_Properties(BDFFont *bdf,EncMap *map,char *onlyme); +extern void BDFDefaultProps(BDFFont *bdf, EncMap *map, int res); +extern BDFProperties *BdfPropsCopy(BDFProperties *props, int cnt ); +struct xlfd_components { + char foundry[80]; + char family[100]; + char weight[80]; + char slant[40]; + char setwidth[50]; + char add_style[50]; + int pixel_size; + int point_size; + int res_x; + int res_y; + char spacing[40]; + int avg_width; + char cs_reg[80]; /* encoding */ + char cs_enc[80]; /* encoding version? */ + int char_cnt; +}; +struct std_bdf_props { + char *name; + int type; + int defaultable; +}; +extern void XLFD_GetComponents(char *xlfd,struct xlfd_components *comp); +extern void XLFD_CreateComponents(BDFFont *bdf,EncMap *map,int res,struct xlfd_components *comp); +/* Two lines intersect in at most 1 point */ +/* Two quadratics intersect in at most 4 points */ +/* Two cubics intersect in at most 9 points */ /* Plus an extra space for a trailing -1 */ +extern int SplinesIntersect(const Spline *s1, const Spline *s2, BasePoint pts[9], + extended t1s[10], extended t2s[10]); +extern SplineSet *LayerAllSplines(Layer *layer); +extern SplineSet *LayerUnAllSplines(Layer *layer); +extern int SplineSetIntersect(SplineSet *spl, Spline **_spline, Spline **_spline2 ); +extern int LineTangentToSplineThroughPt(Spline *s, BasePoint *pt, extended ts[4], + extended tmin, extended tmax); +extern int CubicSolve(const Spline1D *sp,extended ts[3]); +extern extended IterateSplineSolve(const Spline1D *sp, extended tmin, extended tmax, extended sought_y, double err); +extern extended SplineSolve(const Spline1D *sp, real tmin, real tmax, extended sought_y, real err); +extern int SplineSolveFull(const Spline1D *sp,extended val, extended ts[3]); +extern void SplineFindExtrema(const Spline1D *sp, extended *_t1, extended *_t2 ); + +SplineSet *SplineSetsInterpolate(SplineSet *base, SplineSet *other, real amount, SplineChar *sc); +SplineChar *SplineCharInterpolate(SplineChar *base, SplineChar *other, real amount); +extern SplineFont *InterpolateFont(SplineFont *base, SplineFont *other, real amount, Encoding *enc); + +double SFSerifHeight(SplineFont *sf); + +extern void DumpPfaEditEncodings(void); +extern void ParseEncodingFile(char *filename); +extern void LoadPfaEditEncodings(void); + +extern int GenerateScript(SplineFont *sf,char *filename,char *bitmaptype, + int fmflags,int res, char *subfontdirectory,struct sflist *sfs, + EncMap *map,NameList *rename_to,int layer); + +extern void _SCAutoTrace(SplineChar *sc, int layer, char **args); +extern char **AutoTraceArgs(int ask); + +#define CURVATURE_ERROR -1e9 +extern double SplineCurvature(Spline *s, double t); + +#ifndef EXTENDED_IS_LONG_DOUBLE +extern double CheckExtremaForSingleBitErrors(const Spline1D *sp, double t); +#define esqrt(d) sqrt(d) +#else +extern extended esqrt(extended e); +#endif +extern int Spline2DFindExtrema(const Spline *sp, extended extrema[4] ); +extern int Spline2DFindPointsOfInflection(const Spline *sp, extended poi[2] ); +extern int SplineAtInflection(Spline1D *sp, double t ); +extern int SplineAtMinMax(Spline1D *sp, double t ); +extern void SplineRemoveExtremaTooClose(Spline1D *sp, extended *_t1, extended *_t2 ); +extern int NearSpline(struct findsel *fs, Spline *spline); +extern real SplineNearPoint(Spline *spline, BasePoint *bp, real fudge); +extern void SCMakeDependent(SplineChar *dependent,SplineChar *base); +extern SplinePoint *SplineBisect(Spline *spline, extended t); +extern Spline *SplineSplit(Spline *spline, extended ts[3]); +extern Spline *ApproximateSplineFromPoints(SplinePoint *from, SplinePoint *to, + TPoint *mid, int cnt,int order2); +extern Spline *ApproximateSplineFromPointsSlopes(SplinePoint *from, SplinePoint *to, + TPoint *mid, int cnt,int order2); +extern double SplineLength(Spline *spline); +extern double SplineLengthRange(Spline *spline, real from_t, real to_t); +extern double PathLength(SplineSet *ss); +extern Spline *PathFindDistance(SplineSet *path,double d,double *_t); +extern SplineSet *SplineSetBindToPath(SplineSet *ss,int doscale, int glyph_as_unit, + int align,real offset, SplineSet *path); +extern int SplineIsLinear(Spline *spline); +extern int SplineIsLinearMake(Spline *spline); +extern int SSPointWithin(SplineSet *spl,BasePoint *pt); +extern SplineSet *SSRemoveZeroLengthSplines(SplineSet *base); +extern void SSRemoveStupidControlPoints(SplineSet *base); +extern void SSOverlapClusterCpAngles(SplineSet *base,double within); +extern void SplinesRemoveBetween(SplineChar *sc, SplinePoint *from, SplinePoint *to,int type); +extern void SplineCharMerge(SplineChar *sc,SplineSet **head,int type); +extern void SPLNearlyHvCps(SplineChar *sc,SplineSet *ss,double err); +extern void SPLNearlyHvLines(SplineChar *sc,SplineSet *ss,double err); +extern int SPLNearlyLines(SplineChar *sc,SplineSet *ss,double err); +extern int SPInterpolate(SplinePoint *sp); +extern void SplinePointListSimplify(SplineChar *sc,SplinePointList *spl, + struct simplifyinfo *smpl); +extern SplineSet *SplineCharSimplify(SplineChar *sc,SplineSet *head, + struct simplifyinfo *smpl); +extern void SPLStartToLeftmost(SplineChar *sc,SplinePointList *spl, int *changed); +extern void SPLsStartToLeftmost(SplineChar *sc,int layer); +extern void CanonicalContours(SplineChar *sc,int layer); +extern void SplineSetJoinCpFixup(SplinePoint *sp); +extern SplineSet *SplineSetJoin(SplineSet *start,int doall,real fudge,int *changed); +enum ae_type { ae_all, ae_between_selected, ae_only_good, ae_only_good_rm_later }; +extern Spline *SplineAddExtrema(Spline *s,int always,real lenbound, + real offsetbound,DBounds *b); +extern void SplineSetAddExtrema(SplineChar *sc,SplineSet *ss,enum ae_type between_selected, int emsize); +extern void SplineCharAddExtrema(SplineChar *sc,SplineSet *head,enum ae_type between_selected,int emsize); +extern SplineSet *SplineCharRemoveTiny(SplineChar *sc,SplineSet *head); +extern SplineFont *SplineFontNew(void); +extern char *GetNextUntitledName(void); +extern SplineFont *SplineFontEmpty(void); +extern SplineFont *SplineFontBlank(int charcnt); +extern void SFIncrementXUID(SplineFont *sf); +extern void SFRandomChangeXUID(SplineFont *sf); +extern SplineSet *SplineSetReverse(SplineSet *spl); +extern SplineSet *SplineSetsExtractOpen(SplineSet **tbase); +extern void SplineSetsInsertOpen(SplineSet **tbase,SplineSet *open); +extern SplineSet *SplineSetsCorrect(SplineSet *base,int *changed); +extern SplineSet *SplineSetsAntiCorrect(SplineSet *base); +extern SplineSet *SplineSetsDetectDir(SplineSet **_base, int *lastscan); +extern void SPAverageCps(SplinePoint *sp); +extern void SPLAverageCps(SplinePointList *spl); +extern void SPWeightedAverageCps(SplinePoint *sp); +extern void SplineCharDefaultPrevCP(SplinePoint *base); +extern void SplineCharDefaultNextCP(SplinePoint *base); +extern void SplineCharTangentNextCP(SplinePoint *sp); +extern void SplineCharTangentPrevCP(SplinePoint *sp); +extern void SPHVCurveForce(SplinePoint *sp); +extern void SPSmoothJoint(SplinePoint *sp); +extern int PointListIsSelected(SplinePointList *spl); +extern void SCSplinePointsUntick(SplineChar *sc,int layer); +extern void SFOrderBitmapList(SplineFont *sf); +extern int KernThreshold(SplineFont *sf, int cnt); +extern real SFGuessItalicAngle(SplineFont *sf); + +extern SplinePoint *SplineTtfApprox(Spline *ps); +extern SplineSet *SSttfApprox(SplineSet *ss); +extern SplineSet *SplineSetsTTFApprox(SplineSet *ss); +extern SplineSet *SSPSApprox(SplineSet *ss); +extern SplineSet *SplineSetsPSApprox(SplineSet *ss); +extern SplineSet *SplineSetsConvertOrder(SplineSet *ss, int to_order2); +extern void SplineRefigure2(Spline *spline); +extern void SplineRefigureFixup(Spline *spline); +extern Spline *SplineMake2(SplinePoint *from, SplinePoint *to); +extern Spline *SplineMake(SplinePoint *from, SplinePoint *to, int order2); +extern Spline *SFSplineMake(SplineFont *sf,SplinePoint *from, SplinePoint *to); +extern void SCConvertToOrder2(SplineChar *sc); +extern void SFConvertToOrder2(SplineFont *sf); +extern void SCConvertToOrder3(SplineChar *sc); +extern void SFConvertToOrder3(SplineFont *sf); +extern void SFConvertGridToOrder2(SplineFont *_sf); +extern void SCConvertLayerToOrder2(SplineChar *sc,int layer); +extern void SFConvertLayerToOrder2(SplineFont *sf,int layer); +extern void SFConvertGridToOrder3(SplineFont *_sf); +extern void SCConvertLayerToOrder3(SplineChar *sc,int layer); +extern void SFConvertLayerToOrder3(SplineFont *sf,int layer); +extern void SCConvertOrder(SplineChar *sc, int to_order2); +extern void SplinePointPrevCPChanged2(SplinePoint *sp); +extern void SplinePointNextCPChanged2(SplinePoint *sp); +extern int IntersectLines(BasePoint *inter, + BasePoint *line1_1, BasePoint *line1_2, + BasePoint *line2_1, BasePoint *line2_2); +extern int IntersectLinesClip(BasePoint *inter, + BasePoint *line1_1, BasePoint *line1_2, + BasePoint *line2_1, BasePoint *line2_2); + +#if 0 +extern void SSBisectTurners(SplineSet *spl); +#endif +extern SplineSet *SplineSetStroke(SplineSet *spl,StrokeInfo *si,SplineChar *sc); +extern SplineSet *SSStroke(SplineSet *spl,StrokeInfo *si,SplineChar *sc); +extern SplineSet *SplineSetRemoveOverlap(SplineChar *sc,SplineSet *base,enum overlap_type); +extern SplineSet *SSShadow(SplineSet *spl,real angle, real outline_width, + real shadow_length,SplineChar *sc, int wireframe); + +extern double BlueScaleFigureForced(struct psdict *private,real bluevalues[], real otherblues[]); +extern double BlueScaleFigure(struct psdict *private,real bluevalues[], real otherblues[]); +extern void FindBlues( SplineFont *sf, int layer, real blues[14], real otherblues[10]); +extern void QuickBlues(SplineFont *sf, int layer, BlueData *bd); +extern void FindHStems( SplineFont *sf, real snaps[12], real cnt[12]); +extern void FindVStems( SplineFont *sf, real snaps[12], real cnt[12]); +extern double SFStdVW(SplineFont *sf); +extern int SplineCharIsFlexible(SplineChar *sc,int layer); +extern void SCGuessHintInstancesList(SplineChar *sc,int layer,StemInfo *hstem,StemInfo *vstem,DStemInfo *dstem,int hvforce,int dforce); +extern void SCGuessDHintInstances(SplineChar *sc, int layer,DStemInfo *ds ); +extern void SCGuessHHintInstancesAndAdd(SplineChar *sc, int layer,StemInfo *stem, real guess1, real guess2); +extern void SCGuessVHintInstancesAndAdd(SplineChar *sc, int layer,StemInfo *stem, real guess1, real guess2); +extern void SCGuessHHintInstancesList(SplineChar *sc, int layer); +extern void SCGuessVHintInstancesList(SplineChar *sc, int layer); +extern real HIlen( StemInfo *stems); +extern real HIoverlap( HintInstance *mhi, HintInstance *thi); +extern int StemInfoAnyOverlaps(StemInfo *stems); +extern int StemListAnyConflicts(StemInfo *stems); +extern HintInstance *HICopyTrans(HintInstance *hi, real mul, real offset); +extern void MDAdd(SplineChar *sc, int x, SplinePoint *sp1, SplinePoint *sp2); +extern int SFNeedsAutoHint( SplineFont *_sf,int layer); + +typedef struct bluezone { + real base; + int cvtindex; + real family_base; /* NaN if none */ + int family_cvtindex; + real overshoot; /* relative to baseline, NOT to base */ + int highest; /* used in autoinstructing for HStem positioning */ + int lowest; /* as above */ +} BlueZone; + +typedef struct stdstem { + real width; /* -1 if none */ + int cvtindex; + struct stdstem *snapto;/* NULL means stem isn't snapped to any other */ + int stopat; /* at which ppem stop snapping to snapto */ +} StdStem; + +typedef struct globalinstrct { + SplineFont *sf; + int layer; + BlueData *bd; + double fudge; + + /* Did we initialize the tables needed? 'maxp' is skipped because */ + /* its initialization always succeeds. */ + int cvt_done; + int fpgm_done; + int prep_done; + + /* PS private data with truetype-specific information added */ + BlueZone blues[12]; /* like in BlueData */ + int bluecnt; + StdStem stdhw; + StdStem *stemsnaph; /* StdHW excluded */ + int stemsnaphcnt; + StdStem stdvw; + StdStem *stemsnapv; /* StdVW excluded */ + int stemsnapvcnt; +} GlobalInstrCt; + +extern void InitGlobalInstrCt( GlobalInstrCt *gic,SplineFont *sf,int layer, + BlueData *bd ); +extern void FreeGlobalInstrCt( GlobalInstrCt *gic ); +extern void NowakowskiSCAutoInstr( GlobalInstrCt *gic,SplineChar *sc ); +extern void CVT_ImportPrivate(SplineFont *sf); + +extern void SCModifyHintMasksAdd(SplineChar *sc,int layer,StemInfo *new); +extern void SCClearHints(SplineChar *sc); +extern void SCClearHintMasks(SplineChar *sc,int layer,int counterstoo); +extern void SCFigureVerticalCounterMasks(SplineChar *sc); +extern void SCFigureCounterMasks(SplineChar *sc); +extern void SCFigureHintMasks(SplineChar *sc,int layer); +extern void _SplineCharAutoHint( SplineChar *sc, int layer, BlueData *bd, struct glyphdata *gd2, int gen_undoes ); +extern void SplineCharAutoHint( SplineChar *sc,int layer, BlueData *bd); +extern void SFSCAutoHint( SplineChar *sc,int layer,BlueData *bd); +extern void SplineFontAutoHint( SplineFont *sf, int layer); +extern void SplineFontAutoHintRefs( SplineFont *sf, int layer); +extern StemInfo *HintCleanup(StemInfo *stem,int dosort,int instance_count); +extern int SplineFontIsFlexible(SplineFont *sf,int layer, int flags); +extern int SCDrawsSomething(SplineChar *sc); +#define SCWorthOutputting(a) 1 +extern int SFFindNotdef(SplineFont *sf, int fixed); +extern int doesGlyphExpandHorizontally(SplineChar *sc); +extern int IsntBDFChar(BDFChar *bdfc); +extern int CIDWorthOutputting(SplineFont *cidmaster, int enc); /* Returns -1 on failure, font number on success */ +extern int AmfmSplineFont(FILE *afm, MMSet *mm,int formattype,EncMap *map,int layer); +extern int AfmSplineFont(FILE *afm, SplineFont *sf,int formattype,EncMap *map, int docc, SplineFont *fullsf,int layer); +extern int PfmSplineFont(FILE *pfm, SplineFont *sf,int type0,EncMap *map,int layer); +extern int TfmSplineFont(FILE *afm, SplineFont *sf,int formattype,EncMap *map,int layer); +extern int OfmSplineFont(FILE *afm, SplineFont *sf,int formattype,EncMap *map,int layer); +extern char *EncodingName(Encoding *map); +extern char *SFEncodingName(SplineFont *sf,EncMap *map); +extern void SFLigaturePrepare(SplineFont *sf); +extern void SFLigatureCleanup(SplineFont *sf); +extern void SFKernClassTempDecompose(SplineFont *sf,int isv); +extern void SFKernCleanup(SplineFont *sf,int isv); +extern int SCSetMetaData(SplineChar *sc,char *name,int unienc, + const char *comment); + +extern enum uni_interp interp_from_encoding(Encoding *enc,enum uni_interp interp); +extern const char *EncName(Encoding *encname); +extern const char*FindUnicharName(void); +extern Encoding *_FindOrMakeEncoding(const char *name,int make_it); +extern Encoding *FindOrMakeEncoding(const char *name); +extern void SFDDumpMacFeat(FILE *sfd,MacFeat *mf); +extern MacFeat *SFDParseMacFeatures(FILE *sfd, char *tok); +extern int SFDWrite(char *filename,SplineFont *sf,EncMap *map,EncMap *normal, int todir); +extern int SFDWriteBak(SplineFont *sf,EncMap *map,EncMap *normal); +extern SplineFont *SFDRead(char *filename); +extern SplineFont *_SFDRead(char *filename,FILE *sfd); +extern SplineFont *SFDirRead(char *filename); +extern SplineChar *SFDReadOneChar(SplineFont *sf,const char *name); +extern char *TTFGetFontName(FILE *ttf,int32 offset,int32 off2); +extern void TTFLoadBitmaps(FILE *ttf,struct ttfinfo *info, int onlyone); +enum ttfflags { ttf_onlystrikes=1, ttf_onlyonestrike=2, ttf_onlykerns=4, ttf_onlynames=8 }; +extern SplineFont *_SFReadTTF(FILE *ttf,int flags,enum openflags openflags, + char *filename,struct fontdict *fd); +extern SplineFont *SFReadTTF(char *filename,int flags,enum openflags openflags); +extern SplineFont *SFReadSVG(char *filename,int flags); +extern SplineFont *SFReadUFO(char *filename,int flags); +extern SplineFont *_CFFParse(FILE *temp,int len,char *fontsetname); +extern SplineFont *CFFParse(char *filename); +extern SplineFont *SFReadMacBinary(char *filename,int flags,enum openflags openflags); +extern SplineFont *SFReadWinFON(char *filename,int toback); +extern SplineFont *SFReadPalmPdb(char *filename,int toback); +extern SplineFont *LoadSplineFont(char *filename,enum openflags); +extern SplineFont *_ReadSplineFont(FILE *file,char *filename, enum openflags openflags); +extern SplineFont *ReadSplineFont(char *filename,enum openflags); /* Don't use this, use LoadSF instead */ +extern FILE *URLToTempFile(char *url,void *lock); +extern int URLFromFile(char *url,FILE *from); +extern int HttpGetBuf(char *url, char *databuf, int *datalen, void *mutex); +extern void ArchiveCleanup(char *archivedir); +extern char *Unarchive(char *name, char **_archivedir); +extern char *Decompress(char *name, int compression); +extern SplineFont *SFFromBDF(char *filename,int ispk,int toback); +extern SplineFont *SFFromMF(char *filename); +extern void SFCheckPSBitmap(SplineFont *sf); +extern uint16 _MacStyleCode( char *styles, SplineFont *sf, uint16 *psstyle ); +extern uint16 MacStyleCode( SplineFont *sf, uint16 *psstyle ); +extern SplineFont *SFReadIkarus(char *fontname); +extern SplineFont *_SFReadPdfFont(FILE *ttf,char *filename,char *select_this_font, enum openflags openflags); +extern SplineFont *SFReadPdfFont(char *filename, enum openflags openflags); +extern char **GetFontNames(char *filename); +extern char **NamesReadSFD(char *filename); +extern char **NamesReadTTF(char *filename); +extern char **NamesReadCFF(char *filename); +extern char **NamesReadPostscript(char *filename); +extern char **_NamesReadPostscript(FILE *ps); +extern char **NamesReadSVG(char *filename); +extern char **NamesReadUFO(char *filename); +extern char **NamesReadMacBinary(char *filename); + +extern void SFSetOrder(SplineFont *sf,int order2); +extern int SFFindOrder(SplineFont *sf); + +extern const char *UnicodeRange(int unienc); +extern SplineChar *SCBuildDummy(SplineChar *dummy,SplineFont *sf,EncMap *map,int i); +extern SplineChar *SFMakeChar(SplineFont *sf,EncMap *map,int i); +extern char *AdobeLigatureFormat(char *name); +extern uint32 LigTagFromUnicode(int uni); +extern void SCLigCaretheck(SplineChar *sc,int clean); +extern BDFChar *BDFMakeGID(BDFFont *bdf,int gid); +extern BDFChar *BDFMakeChar(BDFFont *bdf,EncMap *map,int enc); + +extern RefChar *RefCharsCopyState(SplineChar *sc,int layer); +extern int SCWasEmpty(SplineChar *sc, int skip_this_layer); +extern void SCUndoSetLBearingChange(SplineChar *sc,int lb); +extern Undoes *SCPreserveHints(SplineChar *sc,int layer); +extern Undoes *SCPreserveLayer(SplineChar *sc,int layer,int dohints); +extern Undoes *SCPreserveState(SplineChar *sc,int dohints); +extern Undoes *SCPreserveBackground(SplineChar *sc); +extern Undoes *SFPreserveGuide(SplineFont *sf); +extern Undoes *SCPreserveWidth(SplineChar *sc); +extern Undoes *SCPreserveVWidth(SplineChar *sc); +extern Undoes *BCPreserveState(BDFChar *bc); +extern void BCDoRedo(BDFChar *bc); +extern void BCDoUndo(BDFChar *bc); + +extern int isaccent(int uni); +extern int SFIsCompositBuildable(SplineFont *sf,int unicodeenc,SplineChar *sc, int layer); +extern int SFIsSomethingBuildable(SplineFont *sf,SplineChar *sc, int layer,int onlyaccents); +extern int SFIsRotatable(SplineFont *sf,SplineChar *sc, int layer); +extern int SCMakeDotless(SplineFont *sf, SplineChar *dotless, int layer, int copybmp, int doit); +extern void SCBuildComposit(SplineFont *sf, SplineChar *sc, int layer, int copybmp); +extern int SCAppendAccent(SplineChar *sc,int layer, char *glyph_name,int uni,int pos); +extern const unichar_t *SFGetAlternate(SplineFont *sf, int base,SplineChar *sc,int nocheck); + +extern int getAdobeEnc(char *name); + +extern void SFSplinesFromLayers(SplineFont *sf,int tostroke); +extern void SFSetLayerWidthsStroked(SplineFont *sf, real strokewidth); +extern SplineSet *SplinePointListInterpretSVG(char *filename,char *memory, int memlen, int em_size, int ascent,int stroked); +extern SplineSet *SplinePointListInterpretGlif(char *filename,char *memory, int memlen, int em_size, int ascent,int stroked); +#define UNDEFINED_WIDTH -999999 +extern SplinePointList *SplinePointListInterpretPS(FILE *ps,int flags,int stroked,int *width); +extern void PSFontInterpretPS(FILE *ps,struct charprocs *cp,char **encoding); +extern struct enc *PSSlurpEncodings(FILE *file); +extern int EvaluatePS(char *str,real *stack,int size); +struct pscontext { + int is_type2; + int painttype; + int instance_count; + real blend_values[17]; + int blend_warn; +}; +extern int UnblendedCompare(real u1[MmMax], real u2[MmMax], int cnt); +extern SplineChar *PSCharStringToSplines(uint8 *type1, int len, struct pscontext *context, + struct pschars *subrs, struct pschars *gsubrs, const char *name); +extern void MatMultiply(real m1[6], real m2[6], real to[6]); + +extern int NameToEncoding(SplineFont *sf,EncMap *map,const char *uname); +extern void GlyphHashFree(SplineFont *sf); +extern void SFHashGlyph(SplineFont *sf,SplineChar *sc); +extern SplineChar *SFHashName(SplineFont *sf,const char *name); +extern int SFFindGID(SplineFont *sf, int unienc, const char *name ); +extern int SFFindSlot(SplineFont *sf, EncMap *map, int unienc, const char *name ); +extern int SFCIDFindCID(SplineFont *sf, int unienc, const char *name ); +extern SplineChar *SFGetChar(SplineFont *sf, int unienc, const char *name ); +extern int SFHasChar(SplineFont *sf, int unienc, const char *name ); +extern SplineChar *SFGetOrMakeChar(SplineFont *sf, int unienc, const char *name ); +extern int SFFindExistingSlot(SplineFont *sf, int unienc, const char *name ); +extern int SFCIDFindExistingChar(SplineFont *sf, int unienc, const char *name ); +extern int SFHasCID(SplineFont *sf, int cid); + +extern char *getPfaEditDir(char *buffer); +extern void _DoAutoSaves(struct fontviewbase *); +extern void CleanAutoRecovery(void); +extern int DoAutoRecovery(int); +extern SplineFont *SFRecoverFile(char *autosavename,int inquire, int *state); +extern void SFAutoSave(SplineFont *sf,EncMap *map); +extern void SFClearAutoSave(SplineFont *sf); + +extern void PSCharsFree(struct pschars *chrs); +extern void PSDictFree(struct psdict *chrs); +extern struct psdict *PSDictCopy(struct psdict *dict); +extern int PSDictFindEntry(struct psdict *dict, char *key); +extern char *PSDictHasEntry(struct psdict *dict, char *key); +extern int PSDictRemoveEntry(struct psdict *dict, char *key); +extern int PSDictChangeEntry(struct psdict *dict, char *key, char *newval); +extern int SFPrivateGuess(SplineFont *sf,int layer, struct psdict *private, + char *name, int onlyone); + +extern void SFRemoveLayer(SplineFont *sf,int l); +extern void SFAddLayer(SplineFont *sf,char *name,int order2, int background); +extern void SFLayerSetBackground(SplineFont *sf,int layer,int is_back); + +extern void SplineSetsRound2Int(SplineSet *spl,real factor,int inspiro,int onlysel); +extern void SCRound2Int(SplineChar *sc,int layer, real factor); +extern int SCRoundToCluster(SplineChar *sc,int layer,int sel,double within,double max); +extern int SplineSetsRemoveAnnoyingExtrema(SplineSet *ss,double err); +extern int hascomposing(SplineFont *sf,int u,SplineChar *sc); +#if 0 +extern void SFFigureGrid(SplineFont *sf); +#endif + +struct cidmap; /* private structure to encoding.c */ +extern int CIDFromName(char *name,SplineFont *cidmaster); +extern int CID2Uni(struct cidmap *map,int cid); +extern int CID2NameUni(struct cidmap *map,int cid, char *buffer, int len); +extern int NameUni2CID(struct cidmap *map,int uni, const char *name); +extern int MaxCID(struct cidmap *map); +extern struct cidmap *LoadMapFromFile(char *file,char *registry,char *ordering, + int supplement); +extern struct cidmap *FindCidMap(char *registry,char *ordering,int supplement, + SplineFont *sf); +extern void SFEncodeToMap(SplineFont *sf,struct cidmap *map); +extern SplineFont *CIDFlatten(SplineFont *cidmaster,SplineChar **chars,int charcnt); +extern void SFFlatten(SplineFont *cidmaster); +extern int SFFlattenByCMap(SplineFont *sf,char *cmapname); +extern SplineFont *MakeCIDMaster(SplineFont *sf,EncMap *oldmap,int bycmap,char *cmapfilename,struct cidmap *cidmap); + +int getushort(FILE *ttf); +int32 getlong(FILE *ttf); +int get3byte(FILE *ttf); +real getfixed(FILE *ttf); +real get2dot14(FILE *ttf); +void putshort(FILE *file,int sval); +void putlong(FILE *file,int val); +void putfixed(FILE *file,real dval); +int ttfcopyfile(FILE *ttf, FILE *other, int pos, char *table_name); + +extern void SCCopyLayerToLayer(SplineChar *sc, int from, int to,int doclear); + +extern int hasFreeType(void); +extern int hasFreeTypeDebugger(void); +extern int hasFreeTypeByteCode(void); +extern int FreeTypeAtLeast(int major, int minor, int patch); +extern void doneFreeType(void); +extern void *_FreeTypeFontContext(SplineFont *sf,SplineChar *sc,struct fontviewbase *fv, + int layer, enum fontformat ff,int flags,void *shared_ftc); +extern void *FreeTypeFontContext(SplineFont *sf,SplineChar *sc,struct fontviewbase *fv,int layer); +extern BDFFont *SplineFontFreeTypeRasterize(void *freetypecontext,int pixelsize,int depth); +extern BDFChar *SplineCharFreeTypeRasterize(void *freetypecontext,int gid, + int pixelsize,int depth); +extern void FreeTypeFreeContext(void *freetypecontext); +extern SplineSet *FreeType_GridFitChar(void *single_glyph_context, + int enc, real ptsizey, real ptsizex, int dpi, uint16 *width, SplineChar *sc, int depth); +extern struct freetype_raster *FreeType_GetRaster(void *single_glyph_context, + int enc, real ptsizey, real ptsizex, int dpi,int depth); +extern BDFChar *SplineCharFreeTypeRasterizeNoHints(SplineChar *sc,int layer, + int pixelsize,int depth); +extern BDFFont *SplineFontFreeTypeRasterizeNoHints(SplineFont *sf,int layer, + int pixelsize,int depth); +extern void FreeType_FreeRaster(struct freetype_raster *raster); +struct TT_ExecContextRec_; +extern struct freetype_raster *DebuggerCurrentRaster(struct TT_ExecContextRec_ *exc,int depth); + +extern int UniFromName(const char *name,enum uni_interp interp, Encoding *encname); +extern const char *StdGlyphName(char *buffer, int uni, enum uni_interp interp, NameList *for_this_font); +extern char **AllGlyphNames(int uni, NameList *for_this_font,SplineChar *sc/* May be NULL*/); +extern char **AllNamelistNames(void); +extern NameList *DefaultNameListForNewFonts(void); +extern NameList *NameListByName(char *name); +extern NameList *LoadNamelist(char *filename); +extern void LoadNamelistDir(char *dir); +extern const char *RenameGlyphToNamelist(char *buffer, SplineChar *sc,NameList *old,NameList *new); +extern void SFRenameGlyphsToNamelist(SplineFont *sf,NameList *new); +extern char **SFTemporaryRenameGlyphsToNamelist(SplineFont *sf,NameList *new); +extern void SFTemporaryRestoreGlyphNames(SplineFont *sf,char **former); + +extern void doversion(const char *); + +extern AnchorPos *AnchorPositioning(SplineChar *sc,unichar_t *ustr,SplineChar **sstr ); +extern void AnchorPosFree(AnchorPos *apos); + +extern int SF_CloseAllInstrs(SplineFont *sf); +extern int SSTtfNumberPoints(SplineSet *ss); +extern int SCNumberPoints(SplineChar *sc,int layer); +extern int SCPointsNumberedProperly(SplineChar *sc,int layer); +extern int ttfFindPointInSC(SplineChar *sc,int layer,int pnum,BasePoint *pos, + RefChar *bound); + +int SFFigureDefWidth(SplineFont *sf, int *_nomwid); + +extern int SFRenameTheseFeatureTags(SplineFont *sf, uint32 tag, int sli, int flags, + uint32 totag, int tosli, int toflags, int ismac); +extern int SFRemoveUnusedNestedFeatures(SplineFont *sf); +extern int ClassesMatch(int cnt1,char **classes1,int cnt2,char **classes2); +extern FPST *FPSTGlyphToClass(FPST *fpst); + +extern ASM *ASMFromOpenTypeForms(SplineFont *sf,uint32 script); +extern ASM *ASMFromFPST(SplineFont *sf,FPST *fpst,int ordered); + +extern char *utf8_verify_copy(const char *str); + +extern char *MacStrToUtf8(const char *str,int macenc,int maclang); +extern char *Utf8ToMacStr(const char *ustr,int macenc,int maclang); +extern uint8 MacEncFromMacLang(int maclang); +extern uint16 WinLangFromMac(int maclang); +extern uint16 WinLangToMac(int winlang); +extern int CanEncodingWinLangAsMac(int winlang); +extern const int32 *MacEncToUnicode(int script,int lang); +extern int MacLangFromLocale(void); +extern char *MacLanguageFromCode(int code); +extern char *FindEnglishNameInMacName(struct macname *mn); +extern char *PickNameFromMacName(struct macname *mn); +extern MacFeat *FindMacFeature(SplineFont *sf, int feat,MacFeat **secondary); +extern struct macsetting *FindMacSetting(SplineFont *sf, int feat, int set,struct macsetting **secondary); +extern struct macname *FindMacSettingName(SplineFont *sf, int feat, int set); + +extern int32 UniFromEnc(int enc, Encoding *encname); +extern int32 EncFromUni(int32 uni, Encoding *encname); +extern int32 EncFromName(const char *name,enum uni_interp interp,Encoding *encname); + +extern void MatInverse(real into[6], real orig[6]); + +extern int BpColinear(BasePoint *first, BasePoint *mid, BasePoint *last); + +enum psstrokeflags { sf_toobigwarn=1, sf_removeoverlap=2, sf_handle_eraser=4, + sf_correctdir=8, sf_clearbeforeinput=16 }; + +extern char *MMAxisAbrev(char *axis_name); +extern char *MMMakeMasterFontname(MMSet *mm,int ipos,char **fullname); +extern char *MMGuessWeight(MMSet *mm,int ipos,char *def); +extern char *MMExtractNth(char *pt,int ipos); +extern char *MMExtractArrayNth(char *pt,int ipos); +extern int MMValid(MMSet *mm,int complain); +extern void MMKern(SplineFont *sf,SplineChar *first,SplineChar *second,int diff, + struct lookup_subtable *sub,KernPair *oldkp); +extern char *MMBlendChar(MMSet *mm, int gid); + +extern char *EnforcePostScriptName(char *old); + +extern char *ToAbsolute(char *filename); + +enum Compare_Ret { SS_DiffContourCount = 1, + SS_MismatchOpenClosed = 2, + SS_DisorderedContours = 4, + SS_DisorderedStart = 8, + SS_DisorderedDirection = 16, + SS_PointsMatch = 32, + SS_ContourMatch = 64, + SS_NoMatch = 128, + SS_RefMismatch = 256, + SS_WidthMismatch = 512, + SS_VWidthMismatch = 1024, + SS_HintMismatch = 2048, + SS_HintMaskMismatch = 4096, + SS_LayerCntMismatch = 8192, + SS_ContourMismatch = 16384, + SS_UnlinkRefMatch = 32768, + + BC_DepthMismatch = 1<<16, + BC_BoundingBoxMismatch = 2<<16, + BC_BitmapMismatch = 4<<16, + BC_NoMatch = 8<<16, + BC_Match = 16<<16, + + SS_RefPtMismatch = 32<<16 + }; + +extern enum Compare_Ret BitmapCompare(BDFChar *bc1, BDFChar *bc2, int err, int bb_err); +extern enum Compare_Ret SSsCompare(const SplineSet *ss1, const SplineSet *ss2, + real pt_err, real spline_err, SplinePoint **hmfail); +enum font_compare_flags { fcf_outlines=1, fcf_exact=2, fcf_warn_not_exact=4, + fcf_hinting=8, fcf_hintmasks=0x10, fcf_hmonlywithconflicts=0x20, + fcf_warn_not_ref_exact=0x40, + fcf_bitmaps=0x80, fcf_names = 0x100, fcf_gpos=0x200, fcf_gsub=0x400, + fcf_adddiff2sf1=0x800, fcf_addmissing=0x1000 }; +extern int CompareFonts(SplineFont *sf1, EncMap *map1, SplineFont *sf2, + FILE *diffs, int flags); +extern int LayersSimilar(Layer *ly1, Layer *ly2, double spline_err); + + +# if HANYANG +extern void SFDDumpCompositionRules(FILE *sfd,struct compositionrules *rules); +extern struct compositionrules *SFDReadCompositionRules(FILE *sfd); +extern void SFModifyComposition(SplineFont *sf); +extern void SFBuildSyllables(SplineFont *sf); +# endif + +extern void DefaultOtherSubrs(void); +extern int ReadOtherSubrsFile(char *filename); + +extern char *utf8toutf7_copy(const char *_str); +extern char *utf7toutf8_copy(const char *_str); + +extern void SFSetModTime(SplineFont *sf); +extern void SFTimesFromFile(SplineFont *sf,FILE *); + +extern int SFHasInstructions(SplineFont *sf); +extern int RefDepth(RefChar *ref,int layer); + +extern SplineChar *SCHasSubs(SplineChar *sc,uint32 tag); + +extern char *TagFullName(SplineFont *sf,uint32 tag, int ismac, int onlyifknown); + +extern uint32 *SFScriptsInLookups(SplineFont *sf,int gpos); +extern uint32 *SFLangsInScript(SplineFont *sf,int gpos,uint32 script); +extern uint32 *SFFeaturesInScriptLang(SplineFont *sf,int gpos,uint32 script,uint32 lang); +extern OTLookup **SFLookupsInScriptLangFeature(SplineFont *sf,int gpos,uint32 script,uint32 lang, uint32 feature); +extern SplineChar **SFGlyphsWithPSTinSubtable(SplineFont *sf,struct lookup_subtable *subtable); +extern SplineChar **SFGlyphsWithLigatureinLookup(SplineFont *sf,struct lookup_subtable *subtable); +extern void SFFindUnusedLookups(SplineFont *sf); +extern void SFFindClearUnusedLookupBits(SplineFont *sf); +extern int LookupUsedNested(SplineFont *sf,OTLookup *checkme); +extern void SFRemoveUnusedLookupSubTables(SplineFont *sf, + int remove_incomplete_anchorclasses, + int remove_unused_lookups); +extern void SFRemoveLookupSubTable(SplineFont *sf,struct lookup_subtable *sub); +extern void SFRemoveLookup(SplineFont *sf,OTLookup *otl); +extern struct lookup_subtable *SFFindLookupSubtable(SplineFont *sf,char *name); +extern struct lookup_subtable *SFFindLookupSubtableAndFreeName(SplineFont *sf,char *name); +extern OTLookup *SFFindLookup(SplineFont *sf,char *name); +extern void NameOTLookup(OTLookup *otl,SplineFont *sf); +extern void FListAppendScriptLang(FeatureScriptLangList *fl,uint32 script_tag,uint32 lang_tag); +extern void FListsAppendScriptLang(FeatureScriptLangList *fl,uint32 script_tag,uint32 lang_tag); +struct scriptlanglist *SLCopy(struct scriptlanglist *sl); +struct scriptlanglist *SListCopy(struct scriptlanglist *sl); +extern FeatureScriptLangList *FeatureListCopy(FeatureScriptLangList *fl); +extern void SLMerge(FeatureScriptLangList *into, struct scriptlanglist *fsl); +extern void FLMerge(OTLookup *into, OTLookup *from); +extern FeatureScriptLangList *FLOrder(FeatureScriptLangList *fl); +extern int FeatureScriptTagInFeatureScriptList(uint32 tag, uint32 script, FeatureScriptLangList *fl); +extern FeatureScriptLangList *FindFeatureTagInFeatureScriptList(uint32 tag, FeatureScriptLangList *fl); +extern int FeatureTagInFeatureScriptList(uint32 tag, FeatureScriptLangList *fl); +extern int DefaultLangTagInOneScriptList(struct scriptlanglist *sl); +extern struct scriptlanglist *DefaultLangTagInScriptList(struct scriptlanglist *sl, int DFLT_ok); +extern int ScriptInFeatureScriptList(uint32 script, FeatureScriptLangList *fl); +extern int _FeatureOrderId( int isgpos,uint32 tag ); +extern int FeatureOrderId( int isgpos,FeatureScriptLangList *fl ); +extern void SFSubTablesMerge(SplineFont *_sf,struct lookup_subtable *subfirst, + struct lookup_subtable *subsecond); +extern struct lookup_subtable *SFSubTableFindOrMake(SplineFont *sf,uint32 tag,uint32 script, + int lookup_type ); +extern struct lookup_subtable *SFSubTableMake(SplineFont *sf,uint32 tag,uint32 script, + int lookup_type ); +extern OTLookup *OTLookupCopyInto(SplineFont *into_sf,SplineFont *from_sf, OTLookup *from_otl); +extern void OTLookupsCopyInto(SplineFont *into_sf,SplineFont *from_sf, + OTLookup **from_list, OTLookup *before); +extern struct opentype_str *ApplyTickedFeatures(SplineFont *sf,uint32 *flist, uint32 script, uint32 lang, + int pixelsize, SplineChar **glyphs); +extern int VerticalKernFeature(SplineFont *sf, OTLookup *otl, int ask); +extern void SFGlyphRenameFixup(SplineFont *sf, char *old, char *new); + +struct sllk { uint32 script; int cnt, max; OTLookup **lookups; int lcnt, lmax; uint32 *langs; }; +extern void SllkFree(struct sllk *sllk,int sllk_cnt); +extern struct sllk *AddOTLToSllks( OTLookup *otl, struct sllk *sllk, + int *_sllk_cnt, int *_sllk_max ); +extern OTLookup *NewAALTLookup(SplineFont *sf,struct sllk *sllk, int sllk_cnt, int i); +extern void AddNewAALTFeatures(SplineFont *sf); + +extern void SplinePointRound(SplinePoint *,real); + +extern int KCFindName(char *name, char **classnames, int cnt ); +extern int KCFindIndex(KernClass *kc,char *name1, char *name2); +extern KernClass *SFFindKernClass(SplineFont *sf,SplineChar *first,SplineChar *last, + int *index,int allow_zero); +extern KernClass *SFFindVKernClass(SplineFont *sf,SplineChar *first,SplineChar *last, + int *index,int allow_zero); + +extern void SCClearRounds(SplineChar *sc,int layer); +extern void MDReplace(MinimumDistance *md,SplineSet *old,SplineSet *rpl); +extern void SCSynchronizeWidth(SplineChar *sc,real newwidth, real oldwidth,struct fontviewbase *fv); +extern RefChar *HasUseMyMetrics(SplineChar *sc,int layer); +extern void SCSynchronizeLBearing(SplineChar *sc,real off,int layer); +extern void RevertedGlyphReferenceFixup(SplineChar *sc, SplineFont *sf); + +extern void SFUntickAll(SplineFont *sf); + +extern void BDFOrigFixup(BDFFont *bdf,int orig_cnt,SplineFont *sf); + +extern int HasSVG(void); +extern void SCImportSVG(SplineChar *sc,int layer,char *path,char *memory, int memlen,int doclear); +extern int HasUFO(void); +extern void SCImportGlif(SplineChar *sc,int layer,char *path,char *memory, int memlen,int doclear); +extern void SCImportPS(SplineChar *sc,int layer,char *path,int doclear, int flags); +extern void SCImportPSFile(SplineChar *sc,int layer,FILE *ps,int doclear,int flags); +extern void SCImportPDF(SplineChar *sc,int layer,char *path,int doclear, int flags); +extern void SCImportPDFFile(SplineChar *sc,int layer,FILE *ps,int doclear,int flags); +extern void SCImportPlateFile(SplineChar *sc,int layer,FILE *plate,int doclear,int flags); +extern void SCAddScaleImage(SplineChar *sc,struct gimage *image,int doclear,int layer); +extern void SCInsertImage(SplineChar *sc,struct gimage *image,real scale,real yoff, real xoff, int layer); +extern void SCImportFig(SplineChar *sc,int layer,char *path,int doclear); + +extern int _ExportPlate(FILE *pdf,SplineChar *sc,int layer); +extern int _ExportPDF(FILE *pdf,SplineChar *sc,int layer); +extern int _ExportEPS(FILE *eps,SplineChar *sc,int layer, int gen_preview); +extern int _ExportSVG(FILE *svg,SplineChar *sc,int layer); +extern int _ExportGlif(FILE *glif,SplineChar *sc,int layer); +extern int ExportEPS(char *filename,SplineChar *sc,int layer); +extern int ExportPDF(char *filename,SplineChar *sc,int layer); +extern int ExportPlate(char *filename,SplineChar *sc,int layer); +extern int ExportSVG(char *filename,SplineChar *sc,int layer); +extern int ExportGlif(char *filename,SplineChar *sc,int layer); +extern int ExportFig(char *filename,SplineChar *sc,int layer); +extern int BCExportXBM(char *filename,BDFChar *bdfc, int format); +extern int ExportImage(char *filename,SplineChar *sc, int layer, int format, int pixelsize, int bitsperpixel); +extern void ScriptExport(SplineFont *sf, BDFFont *bdf, int format, int gid, + char *format_spec, EncMap *map); + +extern EncMap *EncMapFromEncoding(SplineFont *sf,Encoding *enc); +extern void SFRemoveGlyph(SplineFont *sf,SplineChar *sc, int *flags); +extern void SFAddEncodingSlot(SplineFont *sf,int gid); +extern void SFAddGlyphAndEncode(SplineFont *sf,SplineChar *sc,EncMap *basemap, int baseenc); +extern void SCDoRedo(SplineChar *sc,int layer); +extern void SCDoUndo(SplineChar *sc,int layer); +extern void SCCopyWidth(SplineChar *sc,enum undotype); +extern void SCAppendPosSub(SplineChar *sc,enum possub_type type, char **d,SplineFont *copied_from); +extern void SCClearBackground(SplineChar *sc); +extern void BackgroundImageTransform(SplineChar *sc, ImageList *img,real transform[6]); +extern int SFIsDuplicatable(SplineFont *sf, SplineChar *sc); + +extern void DoAutoSaves(void); + +extern void SCClearLayer(SplineChar *sc,int layer); +extern void SCClearContents(SplineChar *sc,int layer); +extern void SCClearAll(SplineChar *sc,int layer); +extern void BCClearAll(BDFChar *bc); + +#if !defined(_NO_PYTHON) +extern void FontForge_PythonInit(void); +extern void PyFF_ErrorString(const char *msg,const char *str); +extern void PyFF_ErrorF3(const char *frmt, const char *str, int size, int depth); +extern void PyFF_Stdin(void); +extern void PyFF_Main(int argc,char **argv,int start); +extern void PyFF_ScriptFile(struct fontviewbase *fv,SplineChar *sc,char *filename); +extern void PyFF_ScriptString(struct fontviewbase *fv,SplineChar *sc,int layer,char *str); +extern void PyFF_FreeFV(struct fontviewbase *fv); +extern void PyFF_FreeSC(SplineChar *sc); +extern void PyFF_FreeSF(SplineFont *sf); +extern void PyFF_ProcessInitFiles(void); +extern char *PyFF_PickleMeToString(void *pydata); +extern void *PyFF_UnPickleMeToObjects(char *str); +struct _object; /* Python Object */ +extern void PyFF_CallDictFunc(struct _object *dict,char *key,char *argtypes, ... ); +extern void ff_init(void); +#endif +extern void doinitFontForgeMain(void); + +extern void InitSimpleStuff(void); + +extern int SSExistsInLayer(SplineSet *ss,SplineSet *lots ); +extern int SplineExistsInSS(Spline *s,SplineSet *ss); +extern int SpExistsInSS(SplinePoint *sp,SplineSet *ss); + +extern int MSLanguageFromLocale(void); + +extern struct math_constants_descriptor { + char *ui_name; + char *script_name; + int offset; + int devtab_offset; + char *message; + int new_page; +} math_constants_descriptor[]; + +extern int BPTooFar(BasePoint *bp1, BasePoint *bp2); +extern char *VSErrorsFromMask(int mask,int private_mask); +extern int SCValidate(SplineChar *sc, int layer, int force); +extern AnchorClass *SCValidateAnchors(SplineChar *sc); +extern void SCTickValidationState(SplineChar *sc,int layer); +extern int ValidatePrivate(SplineFont *sf); +extern int SFValidate(SplineFont *sf, int layer, int force); +extern int VSMaskFromFormat(SplineFont *sf, int layer, enum fontformat format); + +struct lang_frequencies; +extern unichar_t *PrtBuildDef( SplineFont *sf, void *tf, + void (*langsyscallback)(void *tf, int end, uint32 script, uint32 lang) ); +extern char *RandomParaFromScriptLang(uint32 script, uint32 lang, SplineFont *sf, + struct lang_frequencies *freq); +extern char *RandomParaFromScript(uint32 script, uint32 *lang, SplineFont *sf); +extern int SF2Scripts(SplineFont *sf,uint32 scripts[100]); +extern char **SFScriptLangs(SplineFont *sf,struct lang_frequencies ***freq); + +extern int SSHasClip(SplineSet *ss); +extern int SSHasDrawn(SplineSet *ss); +extern struct gradient *GradientCopy(struct gradient *old); +extern void GradientFree(struct gradient *grad); +extern struct pattern *PatternCopy(struct pattern *old); +extern void PatternFree(struct pattern *pat); +extern void BrushCopy(struct brush *into, struct brush *from); +extern void PenCopy(struct pen *into, struct pen *from); +extern void PatternSCBounds(SplineChar *sc,DBounds *b); + +extern char *SFDefaultImage(SplineFont *sf,char *filename); +extern void SCClearInstrsOrMark(SplineChar *sc, int layer, int complain); +extern void instrcheck(SplineChar *sc,int layer); +extern void TTFPointMatches(SplineChar *sc,int layer,int top); + +#ifdef LUA_FF_LIB +extern SplineFont *ReadSplineFontInfo(char *filename,enum openflags openflags); /* splinefont.c */ +extern SplineFont *SFReadTTFInfo(char *filename, int flags, enum openflags openflags); /* parsettf.c */ +extern SplineFont *SFReadMacBinaryInfo(char *filename,int flags,enum openflags openflags); /* macbinary.c */ +#endif + + + +#endif |