1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/* Copyright (C) 2001-2023 Artifex Software, Inc.
All Rights Reserved.
This software is provided AS-IS with no warranty, either express or
implied.
This software is distributed under license and may not be copied,
modified or distributed except as expressly authorized under the terms
of the license contained in the file LICENSE in this distribution.
Refer to licensing information at http://www.artifex.com or contact
Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
CA 94129, USA, for further information.
*/
/* The TrueType instruction interpreter interface definition. */
#ifndef incl_ttfoutl
#define incl_ttfoutl
/* For memento */
#include "malloc_.h"
#include "gxfcache.h"
typedef struct _TFace TFace;
typedef struct _TInstance TInstance;
typedef struct _TExecution_Context TExecution_Context;
/* Define auxiliary data types for the TT interpreter. */
typedef struct ttfMemoryDescriptor_s ttfMemoryDescriptor;
typedef struct {
double a, b, c, d, tx, ty;
} FloatMatrix;
typedef struct {
double x, y;
} FloatPoint;
#if ARCH_LOG2_SIZEOF_LONG == 2
typedef signed long F26Dot6;
#elif ARCH_LOG2_SIZEOF_INT == 2
typedef signed int F26Dot6;
#else
#error "No appropriate type for Fixed 26.6 Floats"
#endif
typedef struct {
F26Dot6 x;
F26Dot6 y;
} F26Dot6Point;
/* Define an abstract class for accessing memory managers from the TT interpreter. */
typedef struct ttfMemory_s ttfMemory;
struct ttfMemory_s {
void *(*alloc_bytes)(ttfMemory *, int size, const char *cname);
void *(*alloc_struct)(ttfMemory *, const ttfMemoryDescriptor *, const char *cname);
void (*free)(ttfMemory *, void *p, const char *cname);
} ;
typedef struct ttfSubGlyphUsage_s ttfSubGlyphUsage;
/* Define a capsule for the TT interpreter. */
struct ttfInterpreter_s {
TExecution_Context *exec;
ttfSubGlyphUsage *usage;
int usage_size;
int usage_top;
int lock;
ttfMemory *ttf_memory;
};
/* Define TT interpreter return codes. */
typedef enum {
fNoError,
fTableNotFound,
fNameNotFound,
fMemoryError,
fUnimplemented,
fCMapNotFound,
fGlyphNotFound,
fBadFontData,
fPatented,
fBadInstruction
} FontError;
/* Define an abstract class for accessing TT data from the TT interpreter. */
typedef struct ttfReader_s ttfReader;
struct ttfReader_s {
bool (*Eof)(ttfReader *);
void (*Read)(ttfReader *, void *p, int n);
void (*Seek)(ttfReader *, int nPos);
int (*Tell)(ttfReader *);
bool (*Error)(ttfReader *);
int (*LoadGlyph)(ttfReader *, int nIndex, const byte **, int *);
void (*ReleaseGlyph)(ttfReader *, int nIndex);
int (*get_metrics)(const ttfReader *ttf, uint glyph_index, bool bVertical,
short *sideBearing, unsigned short *nAdvance);
};
/* Define an auxiliary structure for ttfFont. */
typedef struct {
int nPos, nLen;
} ttfPtrElem;
/* Define a capsule for a TT face.
Diue to historical reason the name is some misleading.
It should be ttfFace. */
struct ttfFont_s {
ttfPtrElem t_cvt_;
ttfPtrElem t_fpgm;
ttfPtrElem t_glyf;
ttfPtrElem t_head;
ttfPtrElem t_hhea;
ttfPtrElem t_hmtx;
ttfPtrElem t_vhea;
ttfPtrElem t_vmtx;
ttfPtrElem t_loca;
ttfPtrElem t_maxp;
ttfPtrElem t_prep;
ttfPtrElem t_cmap;
unsigned short nUnitsPerEm;
unsigned int nFlags;
unsigned int nNumGlyphs;
unsigned int nMaxComponents;
unsigned int nLongMetricsVert;
unsigned int nLongMetricsHorz;
unsigned int nIndexToLocFormat;
bool patented;
bool design_grid;
TFace *face;
TInstance *inst;
TExecution_Context *exec;
ttfInterpreter *tti;
void (*DebugRepaint)(ttfFont *);
int (*DebugPrint)(ttfFont *, const char *s, ...);
const gs_memory_t *DebugMem;
};
void ttfFont__init(ttfFont *this, ttfMemory *mem,
void (*DebugRepaint)(ttfFont *),
int (*DebugPrint)(ttfFont *, const char *s, ...),
const gs_memory_t *);
void ttfFont__finit(ttfFont *this);
FontError ttfFont__Open(ttfInterpreter *, ttfFont *, ttfReader *r,
unsigned int nTTC, float w, float h,
bool design_grid);
/* Define an abstract class for exporting outlines from the TT interpreter. */
typedef struct ttfExport_s ttfExport;
struct ttfExport_s {
bool bPoints, bOutline;
void (*MoveTo)(ttfExport *, FloatPoint*);
void (*LineTo)(ttfExport *, FloatPoint*);
void (*CurveTo)(ttfExport *, FloatPoint*, FloatPoint*, FloatPoint*);
void (*Close)(ttfExport *);
void (*Point)(ttfExport *, FloatPoint*, bool bOnCurve, bool bNewPath);
void (*SetWidth)(ttfExport *, FloatPoint*);
void (*DebugPaint)(ttfExport *);
};
int ttfInterpreter__obtain(ttfMemory *mem, ttfInterpreter **ptti);
void ttfInterpreter__release(ttfInterpreter **ptti);
/* Define an class for outline description. */
typedef struct {
bool bCompound;
int contourCount;
uint pointCount;
F26Dot6Point advance;
F26Dot6 sideBearing;
F26Dot6 xMinB, yMinB, xMaxB, yMaxB;
} ttfGlyphOutline;
/* Define an class for generating TT outlines. */
typedef struct {
bool bOutline;
bool bFirst;
bool bVertical;
int nPointsTotal;
int nContoursTotal;
F26Dot6 ppx, ppy;
ttfReader *r;
ttfExport *exp;
ttfFont *pFont;
ttfGlyphOutline out;
FloatMatrix post_transform;
} ttfOutliner;
void ttfOutliner__init(ttfOutliner *, ttfFont *f, ttfReader *r, ttfExport *exp,
bool bOutline, bool bFirst, bool bVertical);
FontError ttfOutliner__Outline(ttfOutliner *this, int glyphIndex,
float orig_x, float orig_y, FloatMatrix *m1);
int ttfOutliner__DrawGlyphOutline(ttfOutliner *this);
#endif
|
