1Font::TTF::Ttopen(3) User Contributed Perl Documentation Font::TTF::Ttopen(3)
2
6 Font::TTF::Ttopen - Opentype superclass for standard Opentype lookup
7 based tables (GSUB and GPOS)
8
10 Handles all the script, lang, feature, lookup stuff for a
11 Font::TTF::Gsub/Font::TTF::Gpos table leaving the class specifics to
12 the subclass
13
15 The instance variables of an opentype table form a complex sub-module
16 hierarchy.
17 Version
19 This contains the version of the table as a floating point number
20 SCRIPTS
22 The scripts list is a hash of script tags. Each script tag (of the
23 form $t->{'SCRIPTS'}{$tag}) has information below it.
24 OFFSET This variable is preceeded by a space and gives the offset
26 from the start of the table (not the table section) to the
27 script table for this script
28 REFTAG This variable is preceded by a space and gives a
30 corresponding script tag to this one such that the offsets
31 in the file are the same. When writing, it is up to the
32 caller to ensure that the REFTAGs are set correctly, since
33 these will be used to assume that the scripts are
34 identical. Note that REFTAG must refer to a script which
35 has no REFTAG of its own.
36 DEFAULT This corresponds to the default language for this script,
38 if there is one, and contains the same information as an
39 itemised language
40 LANG_TAGS
42 This contains an array of language tag strings (each 4
43 bytes) corresponding to the languages listed by this script
44 $lang Each language is a hash containing its information:
46 OFFSET This variable is preceeded by a a space and
48 gives the offset from the start of the whole
49 table to the language table for this language
50 REFTAG This variable is preceded by a space and has
52 the same function as for the script REFTAG,
53 only for the languages within a script.
54 RE-ORDER This indicates re-ordering information, and has
56 not been set. The value should always be 0.
57 DEFAULT This holds the index of the default feature, if
59 there is one, or -1 otherwise.
60 FEATURES This is an array of feature tags for all the
62 features enabled for this language
63 FEATURES
65 The features section of instance variables corresponds to the
66 feature table in the opentype table.
67 FEAT_TAGS
69 This array gives the ordered list of feature tags for this
70 table. It is used during reading and writing for converting
71 between feature index and feature tag.
72 The rest of the FEATURES variable is itself a hash based on the
74 feature tag for each feature. Each feature has the following
75 structure:
76 OFFSET This attribute is preceeded by a space and gives the offset
78 relative to the start of the whole table of this particular
79 feature.
80 PARMS This is an unused offset to the parameters for each feature
82 LOOKUPS This is an array containing indices to lookups in the
84 LOOKUP instance variable of the table
85 INDEX This gives the feature index for this feature and is used
87 during reading and writing for converting between feature
88 tag and feature index.
89 LOOKUP
91 This variable is an array of lookups in order and is indexed via
92 the features of a language of a script. Each lookup contains
93 subtables and other information:
94 OFFSET This name is preceeded by a space and contains the offset
96 from the start of the table to this particular lookup
97 TYPE This is a subclass specific type for a lookup. It
99 stipulates the type of lookup and hence subtables within
100 the lookup
101 FLAG Holds the lookup flag bits
103 SUB This holds an array of subtables which are subclass
105 specific. Each subtable must have an OFFSET. The other
106 variables described here are an abstraction used in both
107 the GSUB and GPOS tables which are the target subclasses of
108 this class.
109 OFFSET This is preceeded by a space and gives the
111 offset relative to the start of the table for
112 this subtable
113 FORMAT Gives the sub-table sub format for this GSUB
115 subtable. It is assumed that this value is
116 correct when it comes time to write the
117 subtable.
118 COVERAGE Most lookups consist of a coverage table
120 corresponding to the first glyph to match. The
121 offset of this coverage table is stored here
122 and the coverage table looked up against the
123 GSUB table proper. There are two lookups
124 without this initial coverage table which is
125 used to index into the RULES array. These
126 lookups have one element in the RULES array
127 which is used for the whole match.
128 RULES The rules are a complex array. Each element of
130 the array corresponds to an element in the
131 coverage table (governed by the coverage
132 index). If there is no coverage table, then
133 there is considered to be only one element in
134 the rules array. Each element of the array is
135 itself an array corresponding to the possibly
136 multiple string matches which may follow the
137 initial glyph. Each element of this array is a
138 hash with fixed keys corresponding to
139 information needed to match a glyph string or
140 act upon it. Thus the RULES element is an array
141 of arrays of hashes which contain the following
142 keys:
143 MATCH This contains a sequence of
145 elements held as an array. The
146 elements may be glyph ids
147 (gid), class ids (cids), or
148 offsets to coverage tables.
149 Each element corresponds to one
150 glyph in the glyph string. See
151 MATCH_TYPE for details of how
152 the different element types are
153 marked.
154 PRE This array holds the sequence
156 of elements preceeding the
157 first match element and has the
158 same form as the MATCH array.
159 POST This array holds the sequence
161 of elements to be tested for
162 following the match string and
163 is of the same form as the
164 MATCH array.
165 ACTION This array holds information
167 regarding what should be done
168 if a match is found. The array
169 may either hold glyph ids
170 (which are used to replace or
171 insert or whatever glyphs in
172 the glyph string) or 2 element
173 arrays consisting of:
174 OFFSET Offset from
176 the start
177 of the
178 matched
179 string that
180 the lookup
181 should
182 start at
183 when
184 processing
185 the
186 substring.
187 LOOKUP_INDEX The index
189 to a lookup
190 to be acted
191 upon on the
192 match
193 string.
194 CLASS
196 For those lookups which use class categories rather than glyph ids
197 for matching this is the offset to the class definition used to
198 categories glyphs in the match string.
199 PRE_CLASS
201 This is the offset to the class definition for the before match
202 glyphs
203 POST_CLASS
205 This is the offset to the class definition for the after match
206 glyphs.
207 ACTION_TYPE
209 This string holds the type of information held in the ACTION
210 variable of a RULE. It is subclass specific.
211 MATCH_TYPE
213 This holds the type of information in the MATCH array of a RULE.
214 This is subclass specific.
215 ADJUST
217 This corresponds to a single action for all items in a coverage
218 table. The meaning is subclass specific.
219 CACHE
221 This key starts with a space
222 A hash of other tables (such as coverage tables, classes, anchors,
224 device tables) based on the offset given in the subtable to that
225 other information. Note that the documentation is particularly
226 unhelpful here in that such tables are given as offsets relative to
227 the beginning of the subtable not the whole GSUB table. This
228 includes those items which are stored relative to another base
229 within the subtable.
230
232 $t->read
233 Reads the table passing control to the subclass to handle the subtable
234 specifics
235 $t->read_sub($fh, $lookup, $index)
237 This stub is to allow subclasses to read subtables of lookups in a
238 table specific manner. A reference to the lookup is passed in along
239 with the subtable index. The file is located at the start of the
240 subtable to be read
241 $t->extension()
243 Returns the lookup number for the extension table that allows access to
244 32-bit offsets.
245 $t->out($fh)
247 Writes this Opentype table to the output calling $t->out_sub for each
248 sub table at the appropriate point in the output. The assumption is
249 that on entry the number of scripts, languages, features, lookups, etc.
250 are all resolved and the relationships fixed. This includes a script's
251 LANG_TAGS list and that all scripts and languages in their respective
252 dictionaries either have a REFTAG or contain real data.
253 $t->num_sub($lookup)
255 Asks the subclass to count the number of subtables for a particular
256 lookup and to return that value. Used in out().
257 $t->out_sub($fh, $lookup, $index)
259 This stub is to allow subclasses to output subtables of lookups in a
260 table specific manner. A reference to the lookup is passed in along
261 with the subtable index. The file is located at the start of the
262 subtable to be output
263 $t->dirty
265 Setting GPOS or GSUB dirty means that OS/2 may need updating, so set it
266 dirty.
267 $t->maxContext
269 Returns the length of the longest opentype rule in this table.
270 $t->update
272 Unless $t->{' PARENT'}{' noharmony'} is true, update will make sure
273 that GPOS and GSUB include the same scripts and languages. Any added
274 scripts and languages will have empty feature sets.
275
277 Most of these methods are used by subclasses for handling such things
278 as coverage tables.
279 copy($ref)
281 Internal function to copy the top level of a dictionary to create a new
282 dictionary. Only the top level is copied.
283 $t->read_cover($cover_offset, $lookup_loc, $lookup, $fh, $is_cover)
285 Reads a coverage table and stores the results in $lookup->{' CACHE'},
286 that is, if it hasn't been read already.
287 ref_cache($obj, $cache, $offset)
289 Internal function to keep track of the local positioning of subobjects
290 such as coverage and class definition tables, and their offsets. What
291 happens is that the cache is a hash of sub objects indexed by the
292 reference (using a string mashing of the reference name which is valid
293 for the duration of the reference) and holds a list of locations in the
294 output string which should be filled in with the offset to the sub
295 object when the final string is output in out_final.
296 Uses tricks for Tie::Refhash
298 out_final($fh, $out, $cache_list, $state)
300 Internal function to actually output everything to the file handle
301 given that now we know the offset to the first sub object to be output
302 and which sub objects are to be output and what locations need to be
303 updated, we can now generate everything. $cache_list is an array of two
304 element arrays. The first element is a cache object, the second is an
305 offset to be subtracted from each reference to that object made in the
306 cache.
307 If $state is 1, then the output is not sent to the filehandle and the
309 return value is the string to be output. If $state is absent or 0 then
310 output is not limited by storing in a string first and the return value
311 is "";
312 $self->read_context($lookup, $fh, $type, $fmt, $cover, $count, $loc)
314 Internal method to read context (simple and chaining context) lookup
315 subtables for the GSUB and GPOS table types. The assumed values for
316 $type correspond to those for GSUB, so GPOS should adjust the values
317 upon calling.
318 $self->out_context($lookup, $fh, $type, $fmt, $ctables, $out, $num)
320 Provides shared behaviour between GSUB and GPOS tables during output
321 for context (chained and simple) rules. In addition, support is
322 provided here for type 4 GSUB tables, which are not used in GPOS. The
323 value for $type corresponds to the type in a GSUB table so calling from
324 GPOS should adjust the value accordingly.
325
327 ยท No way to share cachable items (coverage tables, classes, anchors,
328 device tables) across different lookups. The items are always
329 output after the lookup and repeated if necessary. Within lookup
330 sharing is possible.
331
333 Martin Hosken Martin_Hosken@sil.org. See Font::TTF::Font for copyright
334 and licensing.
335perl v5.10.1 2008-06-11 Font::TTF::Ttopen(3)