The 'Zapf' Table
General table information
The 'Zapf' table—named with permission after legendary type designer Hermann Zapf—contains information about the individual glyphs in the font. Conceptually, this information consists of:
- A text string which the glyph represents
- A set of identifiers
- A set of font features
- A set of glyph collections
The Text String
The text string is the (Unicode) text which the glyph represents. This is to be used when recreating the original text given only the glyph stream. An “a” glyph would simply map to the string <U+0061>, whereas a “ct” ligature could map to the string <U+0063 U+0074>.
Note that this is not a mechanism for associating different characters with the glyph. In general, even if two characters look exactly the same (e.g., Latin ‘A’, Greek ‘Α’ and Cyrillic ‘а’), they should be drawn with different glyphs. Re-using glyphs for different characters may make AAT or OpenType font features work incorrectly, and they make it impossible to unambiguously convert characters to glyph.
The Identifiers
Within the font itself, glyphs are always identified by their glyph index, and the 'post' table makes it possible to associate a single name with each glyph with rather severe restrictions on the characters which may be used and the name’s length. The font designer, however, may want to use multiple glyph identifiers while working on the font. They may use the formal PostScript name for the 'post' table but have alternate names they prefer to use, or want to keep track of the glyph’s CID in different Adobe collections, or even have notes about the glyph. All of these are available in the 'Zapf' table as glyph identifiers.
The Font Features
In some situations, it may not be sufficient simply to recreate the original text. One may want to recreate as much of the original document as possible.
For example, consider a document that uses small caps. If trying to rebuild the document from the glyphs, the fact that the small caps feature is being applied is significant. The 'Zapf' table allows the type designer to associate features with a glyph to capture this information.
The Glyph Collections
Fonts with rich glyph collections may have multiple glyphs for a certain character. Common examples are lining and proportional numerals, cased and uncased numerals, and small caps. For UI purposes, it’s useful to provide users with information as to which glyphs are available for a given character so that they can, for example, select a particular swash version of a glyph in the middle of a word to make the text look better. It's also useful to generate a set of glyphs used for a particular purpose, such as punctuation, even when they represent different characters.
Table Format
Header
The 'Zapf' table has the following header:
| Type | Name | Description |
|---|---|---|
Uint16 |
version |
Set to 2 |
Uint16 |
(unused) |
0 |
UInt32 |
extraInfo |
Offset from start of table to start of extra info space (added to groupOffset and featOffset in GlyphInfo) |
The header is immediately followed by a lookup table. Values in the lookup table are Uint32 offsets from the beginning of the 'Zapf' table to a GlyphInfo structure for the given glyph.
(In version 1 of the 'Zapf' table, the header is immediately followed by an array of UInt32 offsets, one for each glyph.)
The GlyphInfo structure
The header is followed immediately by an array of GlyphInfo structures. Each entry in this array is of variable size; the offset to a particular GlyphInfo is contained in the offsets[] array in the header. A GlyphInfo structure has the following format:
| Type | Name | Description |
|---|---|---|
UInt32 |
groupOffset |
Byte offset from start of extraInfo to the GlyphGroup or GlyphGroupOffsetArray for this glyph, or 0xFFFFFFFF if none |
UInt32 |
featOffset |
Byte offset from start of extraInfo to FeatureInfo for this glyph, or 0xFFFFFFFF if none |
UInt8 |
flags |
Described below |
UInt8 |
num16BitUnicodes |
Described below (may be 0) |
UInt16 |
unicodes[] |
Unicode code points for this glyph (see below) |
UInt16 |
numGlyphIDs |
Number of GlyphIdentifiers that follow (may be 0) |
GlyphIdentifier |
glyphIDs[] |
GlyphIdentifiers for this glyph (if any) |
(UInt8 |
padding2[1..3] |
If needed, to pad to 32-bit alignment before next GlyphInfo in the array) |
The only GlyphInfo.flags value available currently is kIsCanonicalGlyphFlag (0x80), which indicates that this is the "canonical" glyph for the given Unicode string. Prior to version 2 of the 'Zapf' table, a flags GlyphIdentifier (GlyphIdentifier.kind 127) was used for this purpose.
The kIsCanonicalGlyphFlag is set if the glyph in question is the preferred glyph for the given Unicode string. Where the glyph corresponds to a single Unicode character, this bit should be set if and only if the 'cmap' maps that character to this glyph. The flag, however, can be used for glyphs corresponding to multiple characters. For example, Zapfino has two glyphs for an 'es' ligature, named 'e_s' and 'e_s.2'. The flag is set for the 'e_s' glyph and not the 'e_s.2' glyph.
The kIsCanonicalGlyphFlag can be used to quickly generate a table of Unicode code-points covered by the font. This data can also be derived from the 'cmap' table, but inasmuch as the 'cmap' table is optimized to do single lookups, using the 'cmap' table means running through every defined character in Unicode and checking to see if the 'cmap' has a mapping for it. Deriving this data from the 'Zapf' table is much faster.
The GlyphInfo.num16BitUnicodes field is the number of UInt16 values in the following GlyphInfo.unicodes array. The array itself contains the unique text string (in UTF-16) this glyph represents. Typically, a glyph will represent at most one character, but to allow for characters outside the BMP and to allow for complex ligatures, we use an actual Unicode string.
Again, this does not allow the same glyph to be used for multiple characters. Even if a glyph is used for more than one character (say for a Latin A and Greek Α)—itself never a good idea—the GlyphInfo.unicodes array should only include one of them. Including both would indicate that the glyph maps to the character sequence <U+0040 U+0391> and not to either the character <U+0040> or the character <U+0391>.
If GlyphInfo.num16BitUnicodes is 0, then the glyph isn’t used to represent actual text. This is true, for example, for glyph 0.
The GlyphIdentifier structure
A GlyphIdentifier identifies a glyph, and indicates what kind of identifier it is. It is structured as follows:
| Type | Name | Description |
|---|---|---|
UInt8 |
kind |
What kind of identifier this is |
UInt8 |
data[] |
Identifier data |
The defined values for the GlyphIdentifier.kind field are divided into four ranges:
| kind value | Type | Description |
|---|---|---|
| 0 to 63 | Pascal string | The bytes immediately following the kind byte comprise a Pascal string in UTF-8; depending on the value, this name may or may not need to be compliant with Adobe’s guidelines for PostScript glyph names |
| 64 to 126 | 2-byte binary | The bytes immediately following the kind byte should be treated as the two bytes (big-endian) of a 16-bit quantity. Note that alignment is not guaranteed, so software reading this value should do it bytewise. The interpretation of the value, whether a direct numeric value, a 'name' table index, or something else, is controlled by the actual value. See the description below for more details. |
| 127 | 2-byte binary | The bytes immediately following the kind byte should be treated as the two bytes (big-endian) of a 16-bit flags field. Note that alignment is not guaranteed, so software reading this value should do it bytewise. This works around the lack of a flags field in the original design of the GlyphInfo structure. |
| 128 to 255 | reserved | These values are not yet defined and must not be used. |
Not all these values are currently associated with specific identifier types, but the use of ranges allows parsers to correctly handle GlyphIdentifiers even if they don’t know their precise significance.
The currently defined specific values for the GlyphIdentifier.kind field are the following:
| Type | Name | Description |
|---|---|---|
| UInt8 | kind | (UTF-8 Pascal strings) |
| 0=Universal PostScript name (that is, a name which complies with all naming conventions) | ||
| 1=Apple PostScript name | ||
| 2=Adobe (AGL) PostScript name | ||
| 3=AFII PostScript name | ||
| 4=Character name using Unicode character-naming conventions | ||
| (The following indicate direct binary values) | ||
| 64=CID for Japanese | ||
| 65=CID for Traditional Chinese | ||
| 66=CID for Simplified Chinese | ||
| 67=CID for Korean | ||
(The following indicate 'name' table indices) |
||
| 68=Version history note, which allows the designer to keep track of versions of a glyph | ||
| 69=Designer's short name, intended to be a short but unique name for the glyph | ||
| 70=Designer's long name, intended to be a fuller name, if needed | ||
| 71=Designer's usage notes, intended to guide users under what circumstances the glyph was intended to be used (and not used!) | ||
| 72=Designer's historical notes, including information on how this glyph arose, and how it fits stylistically in the world of type | ||
| (The following indicates a two-byte flags field) | ||
| 127=Flags | ||
| (variable) | name | A Pascal string or binary value, depending on the top two bits of the kind, as listed in the above descriptions. |
The Unicode GlyphIdentifier should only be used for glyphs corresponding to a single Unicode character. Ordinarily, such names can be inferred entirely from the Unicode Standard. This name might be useful, however, for a designer creating an experimental font for an unencoded script used in the Unicode Private Use Area.
There is currently only one flag defined for the flags GlyphIdentifier: namely, kIsCanonicalGlyph, 0x8000. This flag should not be used in version 2 of the 'Zapf' table; the kIsCanonicalGlyphFlag in the GlyphInfo.flags field should be used instead.
Note there is no requirement that GlyphIdentifiers are individually padded for any alignment. Such padding as is used is for the GlyphInfo structure as a whole.
Structures For Groups of Glyphs
When presenting an interface to a user for the selection of particular glyphs, an application would often like to know the set of glyphs in a font which are logically related (or perhaps, those which are related in the designer's eye). In order to accommodate this, the GlyphGroup structure gathers together information about related glyphs. A GlyphGroup is a collection of GlyphSubgroup structures, where each named group has a name (via a 'name' table index), and a collection of glyph indices in whatever order the designer sees fit to impose. So for instance, a designer whose font contains many different swashes for a given letter could create groups for all the glyphs for that letter, where each group has a name (e.g. "long-tailed," "fat-stemmed," etc.).
The 'Zapf' table does this by associating each glyph with zero or more glyph groups, each of which, in turn, consists of one or more subgroups. There are three structures used to provide these associations.
The GlyphSubgroup structure
The GlyphSubgroup is the basic structure for creating a set of glyphs. GlyphSubgroups reside in the extraInfo space, and have the following format:
| Type | Name | Description |
|---|---|---|
UInt16 |
nameIndex |
Index in the 'name' table for this group's name; a value of zero indicates no name for this group |
UInt16 |
numGlyphs |
Number of glyph indices in this named group; this may be zero, in which case no glyphs will follow and this name is the name for the whole group (this convention is only valid for the first name in a group) |
UInt16 |
glyphs[] |
Glyph indices for this group. |
Note: There is no requirement that all the glyphs in a GlyphSubgroup be used for the same string. A font designer is perfectly free to include a GlyphSubgroup for, say, all of the punctuation glyphs in the font.
The GlyphGroup structure
The GlyphGroup structure is an array of GlyphSubgroups and looks like this:
| Type | Name | Description |
|---|---|---|
UInt16 |
numGroups |
The low-order 14 bits specify the count of the number of GlyphSubgroups being defined; they follow this field one after the other. If the top bit is 1, each GlyphSubgroup is preceded by a 16-bit flag word. Bit 14 should be 0. |
| (variable) | groups[] | The GlyphSubgroups for this GlyphGroup. Each group may be preceded by a 16-bit flag (depending on the high bit of the numGroups field) |
The following flags are are available for use:
| Mask | Name | Description |
|---|---|---|
0x8000 |
isAligned |
If this bit is on, this GlyphSubgroup is padded to a 32-bit boundary |
0x4000 |
isSubdivided |
If this bit is on, this GlyphSubgroup is actually a subdivision of a larger single group. If this bit is off, this group is a unique self-contained group. This bit should be set in those parts of a group which are intended to be used to present a user interface. |
0x3FFF |
(reserved) | These bits are not currently defined and must be zero |
The GlyphGroupOffsetArray structure
The GlyphGroupOffsetArray structure is an array of offsets to GlyphGroups. It looks like this:
| Type | Name | Description |
|---|---|---|
UInt16 |
numGroups |
The low-order 14 bits specify the number of offsets to GlyphGroups in the array. Bit 15 should be 0, and bit 14 should be 1. |
UInt16 |
padding |
This field is not currently used and should be set to 0. It is present to maintain as far as possible 32-bit alignment within the 'Zapf' table. |
UInt32 |
groupOffsets[] |
Offsets (relative to extraInfo) to the GlyphGroups associated with this GlyphGroupOffsetArray. The first value in this field indicates the group to be used as the “alternate forms” for the given glyph, as in the Character Palette on OS X. In the case where no group containing this glyph contains the alternate forms for the glyph, the first groupOffset should be 0xFFFFFFFF. |
The GlyphInfo.groupOffset for a given glyph points to either a GlyphGroup or a GlyphGroupOffsetArray. Each begins with a two-byte numGroups field, and bit 14 of this field is used to distinguish the two. If bit 14 is clear, this is a GlyphGroup. If bit 14 is set, then it’s a GlyphGroupOffsetArray.
In general, the GlyphInfo.groupOffset should point to a GlyphGroupOffsetArray if:
- The glyph belongs to more than one glyph group, or
- You want to explicitly mark the one group to which a glyph belongs as the set of alternate glyphs for the same string
Tool writers may also have each GlyphInfo.groupOffset point to a GlyphGroupOffsetArray for the sake of cleaner code.
Examples
Let's look at a few examples to see how these structures can be used to represent various glyph groupings.
A simple group
First, in the simplest case, the font designer wishes to include ten different swash ampersands in a font, and they want to put them together in a single group so the user can choose one. In this example, each ampersand glyph's GlyphInfo structure will have the same groupOffset value, an offset which will refer to the following GlyphGroup:
| Name | Value | Description |
|---|---|---|
numGroups |
0x0001 | This is a GlyphGroup. There is only one GlyphSubgroup for all ampersands and it is not preceded by a flag word |
nameIndex |
300 | Index into the 'name' table for this group's name (which would be something like "Swash Ampersands") |
nGlyphs |
10 | Number of glyphs which belong to this group |
glyphs[] |
... | The ten glyph indices for the ampersands |
An application could use this information to present the user with a simple palette of the ten ampersands to choose from.
Multiple subgroups within a group
In a slightly more complex example, the designer still has ten swash ampersands and wishes the user to see all ten of them, but grouped into labelled groups, with an overall label, so that a menu would look something like this:
All ten ampersands' GlyphInfo structures would still have an offset to the same GlyphGroup, which might look like this:
| Name | Value | Description |
|---|---|---|
numGroups |
0x8003 | Bit 14 is clear, so this is a GlyphGroup. Bit16 is set, so each GlyphSubgroup has a preceding flag field. A total of three GlyphSubgroups follow. |
flag |
0x4000 | This group is one subdivision of a larger group |
nameIndex |
300 | Name index for 'Swash Ampersands' string |
nGlyphs |
0 | When the nGlyphs is zero, the nameIndex identifies the whole grouping |
flag |
0xC000 | This group is one subdivision of a larger group and is padded to a four-byte boundary |
nameIndex |
301 | Name index for '"Classic" style' string |
nGlyphs |
6 | There are six ampersands in the Classic style |
glyphs[] |
... | Glyph indices for the six ampersands |
| 0 | Two bytes of padding | |
flag |
0x4000 | This group is one subdivision of a larger group |
nameIndex |
302 | Name index for '"Nouveau" style' string |
nGlyphs |
4 | There are four ampersands in the Nouveau style |
glyphs[] |
... | Glyph indices for the four ampersands |
(Having only one of the three GlyphSubgroups padded to a long boundary is pointless in practice but is included to illustrate the use of the flag.)
Glyphs in multiple groups
A yet more complex example deals with a font designer who wishes to have glyphs belong to multiple groups. For example, the ten ampersands of our previous example are to have all the characteristics just described, but they are also to belong to a separate group of all punctuation in the font. Again, each ampersand could have the same groupOffset value, referring to this GlyphGroupOffsetArray structure:
| Name | Value | Description |
|---|---|---|
numGroups |
0x4002 | This is a GlyphGroupOffsetArray structure (bit 14 is set) and there are two offsets within it. |
padding |
0 | Padding word |
offset[0] |
… | Offset (relative to extraInfo) to the GlyphGroup structure for alternate ampersands (as above) |
offset[1] |
… | Offset (relative to extraInfo) to the GlyphGroup structure for punctuation glyphs |
The period glyph would also be a member of the punctuation group, but (unlike the ampersand), it has no alternate glyphs for the user to select. Its GlyphInfo structure would contain an offset to a GlyphGroupOffsetArray like this:
| Name | Value | Description |
|---|---|---|
numGroups |
0x4002 | This is a GlyphGroupOffsetArray structure (bit 14 is set) and there are two offsets within it. |
padding |
0 | Padding word |
offset[0] |
0xFFFFFFFF |
There are no alternate glyphs for the period |
offset[1] |
… | Offset (relative to extraInfo) to the GlyphGroup structure for punctuation glyphs |
The punctuation GlyphGroup would look like this:
| Name | Value | Description |
|---|---|---|
numGroups |
0x0001 | One GlyphSubgroup follows and is not preceded by a flag word |
nameIndex |
350 | Name index for 'Punctuation' string |
nGlyphs |
40 | There are 40 punctuation glyphs in the following array (this will include our ten ampersands and one period, among others) |
glyphs[] |
... | The glyph indices for all the punctuation (again, including our ten ampersands and one period) |
The FeatureInfo structure
A FeatureInfo structure identifies the layout engine inputs which force the appearance of this glyph. In many cases, nothing is specified because the given glyph is the default glyph for the string. An example of this is 'A', where nothing else needs to happen. However, in the case of multiple swashes, line-start or line-end swashes, or contextual forms, more information is needed to let the user know how to get this glyph when a line is being laid out. (Of course, an application could just present the user with a palette of all the glyphs in the font, but that can sometimes be overwhelming!)
One of the interesting problems here is the identification of kinds of context which matter in the choice of certain glyphs.
The format of a FeatureInfo is as follows:
| Type | Name | Description |
|---|---|---|
UInt16 |
context |
Bitfield identifying the contexts in which this glyph appears. Note more than one bit may be on! A value of zero means context is irrelevant. |
| 0x0001 = line-initial | ||
| 0x0002 = line-medial | ||
| 0x0004 = line-final | ||
| 0x0008 = word-initial | ||
| 0x0010 = word-medial | ||
| 0x0020 = word-final | ||
| 0x0040 = auto-fraction numerator | ||
| 0x0080 = auto-fraction denominator | ||
UInt16 |
nAATFeatures |
Number of <type,selector> pairs which follow to select this feature |
sfntFontRunFeature |
features[] |
The <type,selector> pairs. (This type is defined in SFNTTypes.h, with constants in SFNTLayoutTypes.h) |
UInt32 |
nOTTags |
Number of 4-byte feature tags which follow to select this feature. |
UInt32 |
tags[] |
The array of tags. |
Example
To help clarify how all this information is represented, let's look at a concrete example. Suppose we have a font with this (somewhat odd) repertoire:
The numbers are the glyph indices, and the images show the actual glyphs. Here is an example 'Zapf' file for this font:
| Offset | Value | Description |
|---|---|---|
| 0 | 0x00010000 | Version 1.0 in fixed notation |
| 4 | 482 | Offset to start of extraInfo part |
The offsets to the GlyphInfo records start here |
||
| 8 | 68 | Offset to GlyphInfo for glyph 0 |
| 12 | 88 | Offset to GlyphInfo for glyph 1 |
| 16 | 108 | Offset to GlyphInfo for glyph 2 |
| 20 | 128 | Offset to GlyphInfo for glyph 3 |
| 24 | 148 | Offset to GlyphInfo for glyph 4 |
| 28 | 168 | Offset to GlyphInfo for glyph 5 |
| 32 | 188 | Offset to GlyphInfo for glyph 6 |
| 36 | 216 | Offset to GlyphInfo for glyph 7 |
| 40 | 244 | Offset to GlyphInfo for glyph 8 |
| 44 | 272 | Offset to GlyphInfo for glyph 9 |
| 48 | 304 | Offset to GlyphInfo for glyph 10 |
| 52 | 336 | Offset to GlyphInfo for glyph 11 |
| 56 | 364 | Offset to GlyphInfo for glyph 12 |
| 60 | 416 | Offset to GlyphInfo for glyph 13 |
| 64 | 444 | Offset to GlyphInfo for glyph 14 |
| GlyphInfo for glyph 0 starts here | ||
| 68 | 0xFFFFFFFF | No GlyphGroup for this glyph |
| 72 | 0xFFFFFFFF | No FeatureInfo for this glyph |
| 76 | 1 | Number of 16-bit Unicode values which follow |
| 78 | 0x0063 | Unicode for 'c' |
| 80 | 1 | Number of GlyphIdentifiers which follow |
| 82 | 0 | This is a universal name |
| 84 | 1 | A byte of string length |
| 85 | 'c' | UTF-8 name 'c' |
| 86 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 1 starts here | ||
| 88 | 0xFFFFFFFF | No GlyphGroup for this glyph |
| 92 | 0xFFFFFFFF | No FeatureInfo for this glyph |
| 96 | 1 | Number of 16-bit Unicode values which follow |
| 98 | 0x0066 | Unicode for 'f' |
| 100 | 1 | Number of GlyphIdentifiers which follow |
| 102 | 0 | This is a universal name |
| 104 | 1 | A byte of string length |
| 105 | 'f' | UTF-8 name 'f' |
| 106 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 2 starts here | ||
| 108 | 0xFFFFFFFF | No GlyphGroup for this glyph |
| 112 | 0xFFFFFFFF | No FeatureInfo for this glyph |
| 116 | 1 | Number of 16-bit Unicode values which follow |
| 118 | 0x0069 | Unicode for 'i' |
| 120 | 1 | Number of GlyphIdentifiers which follow |
| 122 | 0 | This is a universal name |
| 124 | 1 | A byte of string length |
| 125 | 'i' | UTF-8 name 'i' |
| 126 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 3 starts here | ||
| 128 | 0xFFFFFFFF | No GlyphGroup for this glyph |
| 132 | 0xFFFFFFFF | No FeatureInfo for this glyph |
| 136 | 1 | Number of 16-bit Unicode values which follow |
| 138 | 0x006C | Unicode for 'l' |
| 140 | 1 | Number of GlyphIdentifiers which follow |
| 142 | 0 | This is a universal name |
| 144 | 1 | A byte of string length |
| 145 | 'l' | UTF-8 name 'l' |
| 146 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 4 starts here | ||
| 148 | 0xFFFFFFFF | No GlyphGroup for this glyph |
| 152 | 0xFFFFFFFF | No FeatureInfo for this glyph |
| 156 | 1 | Number of 16-bit Unicode values which follow |
| 158 | 0x0073 | Unicode for 's' |
| 160 | 1 | Number of GlyphIdentifiers which follow |
| 162 | 0 | This is a universal name |
| 164 | 1 | A byte of string length |
| 165 | 's' | UTF-8 name 's' |
| 166 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 5 starts here | ||
| 168 | 0xFFFFFFFF | No GlyphGroup for this glyph |
| 172 | 0xFFFFFFFF | No FeatureInfo for this glyph |
| 176 | 1 | Number of 16-bit Unicode values which follow |
| 178 | 0x0074 | Unicode for 't' |
| 180 | 1 | Number of GlyphIdentifiers which follow |
| 182 | 0 | This is a universal name |
| 184 | 1 | A byte of string length |
| 185 | 't' | UTF-8 name 't' |
| 186 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 6 starts here | ||
| 188 | 90 | Offset in extra info space to group information for this glyph |
| 192 | 0 | Offset in extra info space to FeatureInfo |
| 196 | 2 | Number of 16-bit Unicode values which follow |
| 198 | 0x0066 | Unicode for 'f' |
| 200 | 0x0069 | Unicode for 'i' (note we don't use the composed 0xFB01 value as it’s intended for compatibility only) |
| 202 | 2 | Number of GlyphIdentifiers which follow |
| 204 | 1 | Apple name follows |
| 205 | 2 | Length of Apple name |
| 206 | 'fi' | UTF-8 name 'fi' |
| 208 | 2 | Adobe name follows |
| 209 | 3 | Length of Adobe name |
| 210 | 'f_i' | UTF-8 name 'f_i' |
| 213 | 0 | Three bytes of padding for long alignment |
| GlyphInfo for glyph 7 starts here | ||
| 216 | 90 | Offset in extra info space to group information for this glyph |
| 220 | 0 | Offset in extra info space to FeatureInfo |
| 224 | 2 | Number of 16-bit Unicode values which follow |
| 226 | 0x0066 | Unicode for 'f' |
| 228 | 0x006C | Unicode for 'l' (note we don't use the composed 0xFB02 value as it’s intended for compatibility only) |
| 230 | 2 | Number of GlyphIdentifiers which follow |
| 232 | 1 | Apple name follows |
| 233 | 2 | Length of Apple name |
| 234 | 'fl' | UTF-8 name 'fl' |
| 236 | 2 | Adobe name follows |
| 237 | 3 | Length of Adobe name |
| 238 | 'f_l' | UTF-8 name 'f_l' |
| 241 | 0 | Three bytes of padding for long alignment |
| GlyphInfo for glyph 8 starts here | ||
| 244 | 90 | Offset in extra info space to group information for this glyph |
| 248 | 0 | Offset in extra info space to FeatureInfo |
| 252 | 2 | Number of 16-bit Unicode values which follow |
| 254 | 0x0066 | Unicode for 'f' |
| 256 | 0x0066 | Unicode for 'f' (note we don't use the composed 0xFB00 value as it’s intended for compatibility only) |
| 258 | 2 | Number of GlyphIdentifiers which follow |
| 260 | 1 | Apple name follows |
| 261 | 2 | Length of Apple name |
| 262 | 'ff' | UTF-8 name 'fi' |
| 264 | 2 | Adobe name follows |
| 265 | 3 | Length of Adobe name |
| 266 | 'f_f' | UTF-8 name 'f_i' |
| 269 | 0 | Three bytes of padding for long alignment |
| GlyphInfo for glyph 9 starts here | ||
| 272 | 90 | Offset in extra info space to group information for this glyph |
| 276 | 0 | Offset in extra info space to FeatureInfo |
| 280 | 3 | Number of 16-bit Unicode values which follow |
| 282 | 0x0066 | Unicode for 'f' |
| 284 | 0x0066 | Unicode for 'f' |
| 286 | 0x0069 | Unicode for 'i' (note we don't use the composed 0xFB03 value as it’s intended for compatibility only) |
| 288 | 2 | Number of GlyphIdentifiers which follow |
| 290 | 1 | Apple name follows |
| 291 | 3 | Length of Apple name |
| 292 | 'ffi' | UTF-8 name 'ffi' |
| 295 | 2 | Adobe name follows |
| 296 | 5 | Length of Adobe name |
| 297 | 'f_f_i' | UTF-8 name 'f_f_i' |
| 302 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 10 starts here | ||
| 304 | 90 | Offset in extra info space to group information for this glyph |
| 308 | 0 | Offset in extra info space to FeatureInfo |
| 312 | 3 | Number of 16-bit Unicode values which follow |
| 314 | 0x0066 | Unicode for 'f' |
| 316 | 0x0066 | Unicode for 'f' |
| 318 | 0x006C | Unicode for 'l' (note we don't use the composed 0xFB04 value as it’s intended for compatibility only) |
| 320 | 2 | Number of GlyphIdentifiers which follow |
| 322 | 1 | Apple name follows |
| 323 | 3 | Length of Apple name |
| 324 | 'ffl' | UTF-8 name 'ffl' |
| 327 | 2 | Adobe name follows |
| 328 | 5 | Length of Adobe name |
| 329 | 'f_f_l' | UTF-8 name 'f_f_l' |
| 334 | 0 | Two bytes of padding for long alignment |
| GlyphInfo for glyph 11 starts here | ||
| 336 | 90 | Offset in extra info space to group information for this glyph |
| 340 | 10 | Offset in extra info space to FeatureInfo |
| 344 | 2 | Number of 16-bit Unicode values which follow |
| 346 | 0x0063 | Unicode for 'c' |
| 348 | 0x0074 | Unicode for 't' |
| 350 | 2 | Number of GlyphIdentifiers which follow |
| 352 | 1 | Apple name follows |
| 353 | 2 | Length of Apple name |
| 354 | 'ct' | UTF-8 name 'ct' |
| 356 | 2 | Adobe name follows |
| 357 | 3 | Length of Adobe name |
| 358 | 'c_t' | UTF-8 name 'c_t' |
| 361 | 0 | Three bytes of padding for long alignment |
| GlyphInfo for glyph 12 starts here | ||
| 364 | 80 | Offset to group information for this group |
| 368 | 24 | Offset in extra info space to FeatureInfo |
| 372 | 2 | Number of 16-bit Unicode values which follow |
| 374 | 0x0073 | Unicode for 's' |
| 376 | 0x0074 | Unicode for 't' (note we don't use the composed 0xFB05 value as it’s intended for compatibility only) |
| 378 | 3 | Number of GlyphIdentifiers which follow |
| 380 | 1 | Apple name follows |
| 381 | 10 | Length of Apple name |
| 382 | 'stoldstyle' | UTF-8 name 'stoldstyle' |
| 392 | 2 | Adobe name follows |
| 393 | 12 | Length of Adobe name |
| 394 | 's_t.oldstyle' | UTF-8 name 's_t.oldstyle' |
| 406 | 68 | 'name' table entry follows |
| 407 | 290 | 'name' table entry for version history |
| 409 | 71 | 'name' table entry follows |
| 410 | 291 | 'name' table entry for guide for use |
| 412 | 72 | 'name' table entry follows |
| 413 | 292 | 'name' table entry for history of this glyph |
| 415 | 0 | Padding |
| GlyphInfo for glyph 13 starts here | ||
| 416 | 80 | Offset to group information for this group |
| 420 | 10 | Offset in extra info space to FeatureInfo |
| 424 | 2 | Number of 16-bit Unicode values which follow |
| 426 | 0x0073 | Unicode for 's' |
| 428 | 0x0074 | Unicode for 't' (note we don't use the composed 0xFB06 value; these Unicodes are always decomposed) |
| 430 | 3 | Number of GlyphIdentifiers which follow |
| 432 | 1 | Apple name follows |
| 433 | 2 | Length of Apple name |
| 434 | 'st' | UTF-8 name 'st' |
| 436 | 2 | Adobe name follows |
| 437 | 3 | Length of Adobe name |
| 438 | 's_t' | UTF-8 name 's_t' |
| 441 | 127 | Flags field follows |
| 442 | 0x8000 | This is the default glyph for the 'st' string |
| GlyphInfo for glyph 14 starts here | ||
| 444 | 80 | Offset to group information for this group |
| 448 | 44 | Offset in extra info space to FeatureInfo |
| 452 | 2 | Number of 16-bit Unicode values which follow |
| 454 | 0x0073 | Unicode for 's' |
| 456 | 0x0074 | Unicode for 't' |
| 458 | 2 | Number of GlyphIdentifiers which follow |
| 460 | 1 | Apple name follows |
| 461 | 7 | Length of Apple name |
| 462 | 'stfinal' | UTF-8 name 'st' |
| 469 | 2 | Adobe name follows |
| 470 | 9 | Length of Adobe name |
| 471 | 's_t.final' | UTF-8 name 's_t.final' |
| 480 | 0 | Two bytes of padding for long alignment |
| Extra info space | ||
| FeatureInfo for common ligatures starts here (offset 0) | ||
| 482 | 0 | Context is irrelevant for the common ligatures |
| 484 | 1 | One AAT-style <type,selector> pair follows |
| 486 | 1 | "Ligature" type |
| 488 | 2 | "Common ligatures on" selector |
| 490 | 0 | No OpenType feature tags follow |
| FeatureInfo for rare ligatures starts here (offset 10) | ||
| 492 | 0 | Context is irrelevant for the rare ligatures |
| 494 | 1 | One AAT-style <type,selector> pair follows |
| 496 | 1 | "Ligature" type |
| 498 | 4 | "Rare ligatures on" selector |
| 500 | 1 | One OpenType feature follows |
| 502 | 'rlig' | "Rare ligatures" OpenType tag |
| FeatureInfo for rare oldstyle ligatures starts here (offset 24) | ||
| 506 | 0x0018 | Context is word-start or word-middle |
| 508 | 2 | Two AAT-style <type,selector> pairs follow |
| 510 | 1 | "Ligature" type |
| 512 | 4 | "Rare ligatures on" selector |
| 514 | 8 | "Smart swashes" type |
| 518 | 8 | "Non-final swashes on" selector |
| 520 | 1 | One OpenType feature follows |
| 522 | 'rlig' | "Rare ligatures" OpenType tag |
| FeatureInfo for rare final swash ligatures starts here (offset 44) | ||
| 526 | 0x0024 | Context is word-final or line-final |
| 528 | 3 | Two AAT-style <type,selector> pairs follow |
| 530 | 1 | "Ligature" type |
| 532 | 4 | "Rare ligatures on" selector |
| 534 | 8 | "Smart swashes" type |
| 536 | 2 | "Word-final swashes on" selector |
| 538 | 8 | "Smart swashes" type |
| 540 | 6 | "Line-final swashes on" selector |
| 542 | 1 | One OpenType feature follows |
| 544 | 'rlig' | "Rare ligatures" OpenType tag |
| Group information for "st" variants (offset 66) | ||
| 548 | 0x4002 | This is a GlyphGroupOffsetArray with two entries |
| 552 | 0 | Padding |
| 554 | 0x00000050 | Alternate glyphs group for the "st" glyphs |
| 558 | 0x00000058 | Ligature glyph group |
| Alternate glyphs for "st" variants (offset 80) | ||
| 562 | 0x0001 | This is a GlyphGroup containing one GlyphSubgroup and no flags |
| 564 | 0 | No name for this group |
| 566 | 3 | There are three glyphs |
| 568 | 12 | Glyph 12 |
| 570 | 13 | Glyph 13 |
| 572 | 14 | Glyph 14 |
| Group information for all ligatures (offset 90) | ||
| 574 | 0x8003 | This is a GlyphGroup containing two GlyphSubgroups with preceding flags |
| 576 | 0x4000 | This group is one subdivision of a larger group |
| 578 | 300 | 'name' table entry for the "Ligatures" string |
| 580 | 0 | No actual glyphs; this is the name for the entire set of GlyphSubgroups |
| 582 | 0x4000 | This group is one subdivision of a larger group |
| 584 | 301 | 'name' table entry for the "Common Ligatures" string |
| 586 | 5 | Five glyphs in this GlyphSubgroup |
| 588 | 6 | Glyph 6 (fi) |
| 590 | 7 | Glyph 7 (fl) |
| 592 | 8 | Glyph 8 (ff) |
| 594 | 9 | Glyph 9 (ffi) |
| 596 | 10 | Glyph 10 (ffl) |
| 598 | 0x4000 | This group is one subdivision of a larger group |
| 600 | 302 | 'name' table entry for the "Rare Ligatures" string |
| 602 | 4 | Four glyphs in this GlyphSubgroup |
| 604 | 11 | Glyph 11 (ct) |
| 606 | 12 | Glyph 13 (slong-t) |
| 608 | 13 | Glyph 13 (st) |
| 610 | 14 | Glyph 14 (s-tswash) |
Dependencies
The 'Zapf' table contains a table with potentially an entry for every glyph in the font; this will typically need to be updated whenever the glyph count recorded in the 'maxp' table changes.