diff options
Diffstat (limited to 'common/quicktime_win32/SFNTLayoutTypes.h')
| -rw-r--r-- | common/quicktime_win32/SFNTLayoutTypes.h | 1431 |
1 files changed, 1431 insertions, 0 deletions
diff --git a/common/quicktime_win32/SFNTLayoutTypes.h b/common/quicktime_win32/SFNTLayoutTypes.h new file mode 100644 index 0000000..aa16736 --- /dev/null +++ b/common/quicktime_win32/SFNTLayoutTypes.h @@ -0,0 +1,1431 @@ +/* + File: SFNTLayoutTypes.h + + Contains: SFNT file layout structures and constants. + + Version: QuickTime 7.3 + + Copyright: (c) 2007 (c) 1994-2001 by Apple Computer, Inc., all rights reserved. + + Bugs?: For bug reports, consult the following page on + the World Wide Web: + + http://developer.apple.com/bugreporter/ + +*/ +#ifndef __SFNTLAYOUTTYPES__ +#define __SFNTLAYOUTTYPES__ + +#ifndef __MACTYPES__ +#include <MacTypes.h> +#endif + + + +#if PRAGMA_ONCE +#pragma once +#endif + +#if PRAGMA_IMPORT +#pragma import on +#endif + +#if PRAGMA_STRUCT_ALIGN + #pragma options align=mac68k +#elif PRAGMA_STRUCT_PACKPUSH + #pragma pack(push, 2) +#elif PRAGMA_STRUCT_PACK + #pragma pack(2) +#endif + +/* ----------------------------------------------------------------------------------------- */ +/* CONSTANTS */ +/* + The following values can be used to set run feature values. Note that unless the + feature is defaulted differently in different fonts, the zero value for the + selectors represents the default value. Check the following URL site for further info: + "http://fonts.apple.com/Registry" +*/ + + +/* + * Summary: + * Feature types + */ +enum { + kAllTypographicFeaturesType = 0, + kLigaturesType = 1, + kCursiveConnectionType = 2, + kLetterCaseType = 3, + kVerticalSubstitutionType = 4, + kLinguisticRearrangementType = 5, + kNumberSpacingType = 6, + kSmartSwashType = 8, + kDiacriticsType = 9, + kVerticalPositionType = 10, + kFractionsType = 11, + kOverlappingCharactersType = 13, + kTypographicExtrasType = 14, + kMathematicalExtrasType = 15, + kOrnamentSetsType = 16, + kCharacterAlternativesType = 17, + kDesignComplexityType = 18, + kStyleOptionsType = 19, + kCharacterShapeType = 20, + kNumberCaseType = 21, + kTextSpacingType = 22, + kTransliterationType = 23, + kAnnotationType = 24, + kKanaSpacingType = 25, + kIdeographicSpacingType = 26, + kUnicodeDecompositionType = 27, + kRubyKanaType = 28, + kCJKSymbolAlternativesType = 29, + kIdeographicAlternativesType = 30, + kCJKVerticalRomanPlacementType = 31, + kItalicCJKRomanType = 32, + kCJKRomanSpacingType = 103, + kLastFeatureType = -1 +}; + + +/* + * Summary: + * Selectors for feature type kAllTypographicFeaturesType + */ +enum { + kAllTypeFeaturesOnSelector = 0, + kAllTypeFeaturesOffSelector = 1 +}; + + + +/* + * Summary: + * Selectors for feature type kLigaturesType + */ +enum { + kRequiredLigaturesOnSelector = 0, + kRequiredLigaturesOffSelector = 1, + kCommonLigaturesOnSelector = 2, + kCommonLigaturesOffSelector = 3, + kRareLigaturesOnSelector = 4, + kRareLigaturesOffSelector = 5, + kLogosOnSelector = 6, + kLogosOffSelector = 7, + kRebusPicturesOnSelector = 8, + kRebusPicturesOffSelector = 9, + kDiphthongLigaturesOnSelector = 10, + kDiphthongLigaturesOffSelector = 11, + kSquaredLigaturesOnSelector = 12, + kSquaredLigaturesOffSelector = 13, + kAbbrevSquaredLigaturesOnSelector = 14, + kAbbrevSquaredLigaturesOffSelector = 15, + kSymbolLigaturesOnSelector = 16, + kSymbolLigaturesOffSelector = 17 +}; + + +/* + * Summary: + * Selectors for feature type kCursiveConnectionType + */ +enum { + kUnconnectedSelector = 0, + kPartiallyConnectedSelector = 1, + kCursiveSelector = 2 +}; + + +/* + * Summary: + * Selectors for feature type kLetterCaseType + */ +enum { + kUpperAndLowerCaseSelector = 0, + kAllCapsSelector = 1, + kAllLowerCaseSelector = 2, + kSmallCapsSelector = 3, + kInitialCapsSelector = 4, + kInitialCapsAndSmallCapsSelector = 5 +}; + + +/* + * Summary: + * Selectors for feature type kVerticalSubstitutionType + */ +enum { + kSubstituteVerticalFormsOnSelector = 0, + kSubstituteVerticalFormsOffSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kLinguisticRearrangementType + */ +enum { + kLinguisticRearrangementOnSelector = 0, + kLinguisticRearrangementOffSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kNumberSpacingType + */ +enum { + kMonospacedNumbersSelector = 0, + kProportionalNumbersSelector = 1, + kThirdWidthNumbersSelector = 2, + kQuarterWidthNumbersSelector = 3 +}; + + +/* + * Summary: + * Selectors for feature type kSmartSwashType + */ +enum { + kWordInitialSwashesOnSelector = 0, + kWordInitialSwashesOffSelector = 1, + kWordFinalSwashesOnSelector = 2, + kWordFinalSwashesOffSelector = 3, + kLineInitialSwashesOnSelector = 4, + kLineInitialSwashesOffSelector = 5, + kLineFinalSwashesOnSelector = 6, + kLineFinalSwashesOffSelector = 7, + kNonFinalSwashesOnSelector = 8, + kNonFinalSwashesOffSelector = 9 +}; + + +/* + * Summary: + * Selectors for feature type kDiacriticsType + */ +enum { + kShowDiacriticsSelector = 0, + kHideDiacriticsSelector = 1, + kDecomposeDiacriticsSelector = 2 +}; + + +/* + * Summary: + * Selectors for feature type kVerticalPositionType + */ +enum { + kNormalPositionSelector = 0, + kSuperiorsSelector = 1, + kInferiorsSelector = 2, + kOrdinalsSelector = 3 +}; + + +/* + * Summary: + * Selectors for feature type kFractionsType + */ +enum { + kNoFractionsSelector = 0, + kVerticalFractionsSelector = 1, + kDiagonalFractionsSelector = 2 +}; + + +/* + * Summary: + * Selectors for feature type kOverlappingCharactersType + */ +enum { + kPreventOverlapOnSelector = 0, + kPreventOverlapOffSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kTypographicExtrasType + */ +enum { + kHyphensToEmDashOnSelector = 0, + kHyphensToEmDashOffSelector = 1, + kHyphenToEnDashOnSelector = 2, + kHyphenToEnDashOffSelector = 3, + kSlashedZeroOnSelector = 4, + kSlashedZeroOffSelector = 5, + kFormInterrobangOnSelector = 6, + kFormInterrobangOffSelector = 7, + kSmartQuotesOnSelector = 8, + kSmartQuotesOffSelector = 9, + kPeriodsToEllipsisOnSelector = 10, + kPeriodsToEllipsisOffSelector = 11 +}; + + +/* + * Summary: + * Selectors for feature type kMathematicalExtrasType + */ +enum { + kHyphenToMinusOnSelector = 0, + kHyphenToMinusOffSelector = 1, + kAsteriskToMultiplyOnSelector = 2, + kAsteriskToMultiplyOffSelector = 3, + kSlashToDivideOnSelector = 4, + kSlashToDivideOffSelector = 5, + kInequalityLigaturesOnSelector = 6, + kInequalityLigaturesOffSelector = 7, + kExponentsOnSelector = 8, + kExponentsOffSelector = 9 +}; + + +/* + * Summary: + * Selectors for feature type kOrnamentSetsType + */ +enum { + kNoOrnamentsSelector = 0, + kDingbatsSelector = 1, + kPiCharactersSelector = 2, + kFleuronsSelector = 3, + kDecorativeBordersSelector = 4, + kInternationalSymbolsSelector = 5, + kMathSymbolsSelector = 6 +}; + + +/* + * Summary: + * Selectors for feature type kCharacterAlternativesType + */ +enum { + kNoAlternatesSelector = 0 +}; + + +/* + * Summary: + * Selectors for feature type kDesignComplexityType + */ +enum { + kDesignLevel1Selector = 0, + kDesignLevel2Selector = 1, + kDesignLevel3Selector = 2, + kDesignLevel4Selector = 3, + kDesignLevel5Selector = 4 +}; + + +/* + * Summary: + * Selectors for feature type kStyleOptionsType + */ +enum { + kNoStyleOptionsSelector = 0, + kDisplayTextSelector = 1, + kEngravedTextSelector = 2, + kIlluminatedCapsSelector = 3, + kTitlingCapsSelector = 4, + kTallCapsSelector = 5 +}; + + +/* + * Summary: + * Selectors for feature type kCharacterShapeType + */ +enum { + kTraditionalCharactersSelector = 0, + kSimplifiedCharactersSelector = 1, + kJIS1978CharactersSelector = 2, + kJIS1983CharactersSelector = 3, + kJIS1990CharactersSelector = 4, + kTraditionalAltOneSelector = 5, + kTraditionalAltTwoSelector = 6, + kTraditionalAltThreeSelector = 7, + kTraditionalAltFourSelector = 8, + kTraditionalAltFiveSelector = 9, + kExpertCharactersSelector = 10 +}; + + +/* + * Summary: + * Selectors for feature type kNumberCaseType + */ +enum { + kLowerCaseNumbersSelector = 0, + kUpperCaseNumbersSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kTextSpacingType + */ +enum { + kProportionalTextSelector = 0, + kMonospacedTextSelector = 1, + kHalfWidthTextSelector = 2 +}; + + +/* + * Summary: + * Selectors for feature type kTransliterationType + */ +enum { + kNoTransliterationSelector = 0, + kHanjaToHangulSelector = 1, + kHiraganaToKatakanaSelector = 2, + kKatakanaToHiraganaSelector = 3, + kKanaToRomanizationSelector = 4, + kRomanizationToHiraganaSelector = 5, + kRomanizationToKatakanaSelector = 6, + kHanjaToHangulAltOneSelector = 7, + kHanjaToHangulAltTwoSelector = 8, + kHanjaToHangulAltThreeSelector = 9 +}; + + +/* + * Summary: + * Selectors for feature type kAnnotationType + */ +enum { + kNoAnnotationSelector = 0, + kBoxAnnotationSelector = 1, + kRoundedBoxAnnotationSelector = 2, + kCircleAnnotationSelector = 3, + kInvertedCircleAnnotationSelector = 4, + kParenthesisAnnotationSelector = 5, + kPeriodAnnotationSelector = 6, + kRomanNumeralAnnotationSelector = 7, + kDiamondAnnotationSelector = 8, + kInvertedBoxAnnotationSelector = 9, + kInvertedRoundedBoxAnnotationSelector = 10 +}; + + +/* + * Summary: + * Selectors for feature type kKanaSpacingType + */ +enum { + kFullWidthKanaSelector = 0, + kProportionalKanaSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kIdeographicSpacingType + */ +enum { + kFullWidthIdeographsSelector = 0, + kProportionalIdeographsSelector = 1, + kHalfWidthIdeographsSelector = 2 +}; + + +/* + * Summary: + * Selectors for feature type kUnicodeDecompositionType + */ +enum { + kCanonicalCompositionOnSelector = 0, + kCanonicalCompositionOffSelector = 1, + kCompatibilityCompositionOnSelector = 2, + kCompatibilityCompositionOffSelector = 3, + kTranscodingCompositionOnSelector = 4, + kTranscodingCompositionOffSelector = 5 +}; + + +/* + * Summary: + * Selectors for feature type kRubyKanaType + */ +enum { + kNoRubyKanaSelector = 0, + kRubyKanaSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kCJKSymbolAlternativesType + */ +enum { + kNoCJKSymbolAlternativesSelector = 0, + kCJKSymbolAltOneSelector = 1, + kCJKSymbolAltTwoSelector = 2, + kCJKSymbolAltThreeSelector = 3, + kCJKSymbolAltFourSelector = 4, + kCJKSymbolAltFiveSelector = 5 +}; + + +/* + * Summary: + * Selectors for feature type kIdeographicAlternativesType + */ +enum { + kNoIdeographicAlternativesSelector = 0, + kIdeographicAltOneSelector = 1, + kIdeographicAltTwoSelector = 2, + kIdeographicAltThreeSelector = 3, + kIdeographicAltFourSelector = 4, + kIdeographicAltFiveSelector = 5 +}; + + +/* + * Summary: + * Selectors for feature type kCJKVerticalRomanPlacementType + */ +enum { + kCJKVerticalRomanCenteredSelector = 0, + kCJKVerticalRomanHBaselineSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kItalicCJKRomanType + */ +enum { + kNoCJKItalicRomanSelector = 0, + kCJKItalicRomanSelector = 1 +}; + + +/* + * Summary: + * Selectors for feature type kCJKRomanSpacingType + */ +enum { + kHalfWidthCJKRomanSelector = 0, + kProportionalCJKRomanSelector = 1, + kDefaultCJKRomanSelector = 2, + kFullWidthCJKRomanSelector = 3 +}; + +/* --------------------------------------------------------------------------- */ +/* ---------------- Table Specific Typedefs and Constants -------------------- */ +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: lookup tables - used within various other tables */ +enum { + kSFNTLookupSimpleArray = 0, /* a simple array indexed by glyph code */ + kSFNTLookupSegmentSingle = 2, /* segment mapping to single value */ + kSFNTLookupSegmentArray = 4, /* segment mapping to lookup array */ + kSFNTLookupSingleTable = 6, /* sorted list of glyph, value pairs */ + kSFNTLookupTrimmedArray = 8 /* a simple trimmed array indexed by glyph code */ +}; + +typedef UInt16 SFNTLookupTableFormat; +typedef UInt16 SFNTLookupValue; +typedef UInt16 SFNTLookupOffset; +typedef UInt32 SFNTLookupKind; +/* + A BinarySearchHeader defines the five standard fields needed to perform quick + lookups in a lookup table (note that using UInt16s, and not ItemCounts or + similar types, is important here, since these tables are in fonts, and the + documented font formats specify 16-bit quantities). +*/ +struct SFNTLookupBinarySearchHeader { + UInt16 unitSize; /* size of a unit in bytes */ + UInt16 nUnits; /* number of units in table */ + UInt16 searchRange; /* (largest power of two <= nUnits) * unitSize */ + UInt16 entrySelector; /* log2 (largest power of two <= nUnits) */ + UInt16 rangeShift; /* (nUnits - largest power of two <= nUnits) * unitSize */ +}; +typedef struct SFNTLookupBinarySearchHeader SFNTLookupBinarySearchHeader; +/* A format 0 lookup table maps all glyphs in the font to lookup values */ +struct SFNTLookupArrayHeader { + SFNTLookupValue lookupValues[1]; +}; +typedef struct SFNTLookupArrayHeader SFNTLookupArrayHeader; +/* A format 8 lookup table maps some range of glyphs in the font to lookup values */ +struct SFNTLookupTrimmedArrayHeader { + UInt16 firstGlyph; + UInt16 count; + SFNTLookupValue valueArray[1]; +}; +typedef struct SFNTLookupTrimmedArrayHeader SFNTLookupTrimmedArrayHeader; +/* + Format 2 and format 4 lookup tables map ranges of glyphs to either single lookup + values (format 2), or per-glyph lookup values (format 4). Since both formats + use the same kind of data, only one unified set of segment-related structures + is defined. +*/ +struct SFNTLookupSegment { + UInt16 lastGlyph; + UInt16 firstGlyph; + UInt16 value[1]; +}; +typedef struct SFNTLookupSegment SFNTLookupSegment; +struct SFNTLookupSegmentHeader { + SFNTLookupBinarySearchHeader binSearch; + SFNTLookupSegment segments[1]; +}; +typedef struct SFNTLookupSegmentHeader SFNTLookupSegmentHeader; +/* A format 6 lookup table maps single glyphs to lookup values. */ +struct SFNTLookupSingle { + UInt16 glyph; + UInt16 value[1]; +}; +typedef struct SFNTLookupSingle SFNTLookupSingle; +struct SFNTLookupSingleHeader { + SFNTLookupBinarySearchHeader binSearch; + SFNTLookupSingle entries[1]; +}; +typedef struct SFNTLookupSingleHeader SFNTLookupSingleHeader; +/* The format-specific part of the subtable header */ +union SFNTLookupFormatSpecificHeader { + SFNTLookupArrayHeader theArray; + SFNTLookupSegmentHeader segment; + SFNTLookupSingleHeader single; + SFNTLookupTrimmedArrayHeader trimmedArray; +}; +typedef union SFNTLookupFormatSpecificHeader SFNTLookupFormatSpecificHeader; +/* The overall subtable header */ +struct SFNTLookupTable { + SFNTLookupTableFormat format; /* table format */ + SFNTLookupFormatSpecificHeader fsHeader; /* format specific header */ +}; +typedef struct SFNTLookupTable SFNTLookupTable; +typedef SFNTLookupTable * SFNTLookupTablePtr; +typedef SFNTLookupTablePtr * SFNTLookupTableHandle; +/* --------------------------------------------------------------------------- */ +/* GENERAL FORMATS FOR STATE TABLES -- prefix "ST" */ +enum { + kSTClassEndOfText = 0, + kSTClassOutOfBounds = 1, + kSTClassDeletedGlyph = 2, + kSTClassEndOfLine = 3, + kSTSetMark = 0x8000, + kSTNoAdvance = 0x4000, + kSTMarkEnd = 0x2000, + kSTLigActionMask = 0x3FFF, + kSTRearrVerbMask = 0x000F +}; + +typedef UInt8 STClass; +typedef UInt8 STEntryIndex; +struct STHeader { + UInt8 filler; + STClass nClasses; + UInt16 classTableOffset; + UInt16 stateArrayOffset; + UInt16 entryTableOffset; +}; +typedef struct STHeader STHeader; +struct STClassTable { + UInt16 firstGlyph; + UInt16 nGlyphs; + STClass classes[1]; +}; +typedef struct STClassTable STClassTable; +struct STEntryZero { + UInt16 newState; + UInt16 flags; +}; +typedef struct STEntryZero STEntryZero; +struct STEntryOne { + UInt16 newState; + UInt16 flags; + UInt16 offset1; +}; +typedef struct STEntryOne STEntryOne; +struct STEntryTwo { + UInt16 newState; + UInt16 flags; + UInt16 offset1; + UInt16 offset2; +}; +typedef struct STEntryTwo STEntryTwo; +/* --------------------------------------------------------------------------- */ +/* GENERAL FORMATS FOR STATE TABLES to be used with 'morx' tables -- prefix "STX" */ +enum { + kSTXHasLigAction = 0x2000 +}; + + +typedef UInt16 STXClass; +typedef UInt16 STXStateIndex; +typedef UInt16 STXEntryIndex; +struct STXHeader { + UInt32 nClasses; + UInt32 classTableOffset; + UInt32 stateArrayOffset; + UInt32 entryTableOffset; +}; +typedef struct STXHeader STXHeader; + +typedef SFNTLookupTable STXClassTable; +struct STXEntryZero { + STXStateIndex newState; + UInt16 flags; +}; +typedef struct STXEntryZero STXEntryZero; +struct STXEntryOne { + STXStateIndex newState; + UInt16 flags; + UInt16 index1; +}; +typedef struct STXEntryOne STXEntryOne; +struct STXEntryTwo { + STXStateIndex newState; + UInt16 flags; + UInt16 index1; + UInt16 index2; +}; +typedef struct STXEntryTwo STXEntryTwo; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'lcar' */ +/* CONSTANTS */ +enum { + kLCARTag = 0x6C636172, /* 'lcar' */ + kLCARCurrentVersion = 0x00010000, /* current version number for 'lcar' table */ + kLCARLinearFormat = 0, + kLCARCtlPointFormat = 1 +}; + +/* TYPES */ +struct LcarCaretClassEntry { + UInt16 count; + UInt16 partials[1]; /* these are either FUnits or control-point numbers */ +}; +typedef struct LcarCaretClassEntry LcarCaretClassEntry; +struct LcarCaretTable { + Fixed version; + UInt16 format; + SFNTLookupTable lookup; +}; +typedef struct LcarCaretTable LcarCaretTable; +typedef LcarCaretTable * LcarCaretTablePtr; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'just' */ +/* CONSTANTS */ +enum { + kJUSTTag = 0x6A757374, /* 'just' */ + kJUSTCurrentVersion = 0x00010000, + kJUSTStandardFormat = 0, + kJUSTnoGlyphcode = 0xFFFF, /* used in a pcConditionalAddAction */ + kJUSTpcDecompositionAction = 0, + kJUSTpcUnconditionalAddAction = 1, + kJUSTpcConditionalAddAction = 2, + kJUSTpcGlyphStretchAction = 3, + kJUSTpcDuctilityAction = 4, + kJUSTpcGlyphRepeatAddAction = 5 +}; + +/* Justification priority levels */ +enum { + kJUSTKashidaPriority = 0, + kJUSTSpacePriority = 1, + kJUSTLetterPriority = 2, + kJUSTNullPriority = 3, + kJUSTPriorityCount = 4 +}; + +/* Justification flags */ +enum { + kJUSTOverridePriority = 0x8000, + kJUSTOverrideLimits = 0x4000, + kJUSTOverrideUnlimited = 0x2000, + kJUSTUnlimited = 0x1000, + kJUSTPriorityMask = 0x0003 +}; + +/* TYPES */ +typedef UInt16 JustPCActionType; +typedef UInt16 JustificationFlags; +/* A JustPCDecompositionAction defines a ligature decomposition action. */ +struct JustPCDecompositionAction { + Fixed lowerLimit; + Fixed upperLimit; + UInt16 order; + UInt16 count; + UInt16 glyphs[1]; +}; +typedef struct JustPCDecompositionAction JustPCDecompositionAction; +/* A JUSTPCUnconditionalAddAction defines an unconditional glyph add action. */ + +typedef UInt16 JustPCUnconditionalAddAction; +/* + A JUSTPCConditionalAddAction defines a glyph substitution and add action. If the addGlyph + is equal to kJUSTnoGlyphcode, then no glyph will be added, and the justification for + the line will be redone. +*/ +struct JustPCConditionalAddAction { + Fixed substThreshhold; /* threshhold of growth factor at which subst occurs */ + UInt16 addGlyph; + UInt16 substGlyph; +}; +typedef struct JustPCConditionalAddAction JustPCConditionalAddAction; +/* A PCDuctilityAction defines a ductile axis along which the glyph will be varied. */ +struct JustPCDuctilityAction { + UInt32 ductilityAxis; + Fixed minimumLimit; + Fixed noStretchValue; + Fixed maximumLimit; +}; +typedef struct JustPCDuctilityAction JustPCDuctilityAction; +/* + A PCGlyphRepetitionAction defines a glyph which will not be stretched or otherwise + transformed, but rather which will be emplaced however many times are needed to fill + the needed gap. +*/ +struct JustPCGlyphRepeatAddAction { + UInt16 flags; + UInt16 glyph; +}; +typedef struct JustPCGlyphRepeatAddAction JustPCGlyphRepeatAddAction; +/* PCActionSubrecords contain the actual postcompensation actions. */ +struct JustPCActionSubrecord { + UInt16 theClass; /* justification class value associated with this rec */ + JustPCActionType theType; + UInt32 length; + UInt32 data; /* not really a UInt32; cast as ptr to appropriate action */ +}; +typedef struct JustPCActionSubrecord JustPCActionSubrecord; +/* The set of postcompensation records is defined in a PCAction struct. */ +struct JustPCAction { + UInt32 actionCount; /* long for alignment purposes */ + JustPCActionSubrecord actions[1]; +}; +typedef struct JustPCAction JustPCAction; +/* + JustWidthDeltaEntry is the justification table entry structure. The justClass value (which is + actually limited to 7 bits by the state table structure) is defined as a long for PPC alignment reasons. +*/ +struct JustWidthDeltaEntry { + UInt32 justClass; + Fixed beforeGrowLimit; /* ems AW can grow by at most on LT */ + Fixed beforeShrinkLimit; /* ems AW can shrink by at most on LT */ + Fixed afterGrowLimit; /* ems AW can grow by at most on RB */ + Fixed afterShrinkLimit; /* ems AW can shrink by at most on RB */ + JustificationFlags growFlags; /* flags controlling grow case */ + JustificationFlags shrinkFlags; /* flags controlling shrink case */ +}; +typedef struct JustWidthDeltaEntry JustWidthDeltaEntry; +struct JustWidthDeltaGroup { + UInt32 count; + JustWidthDeltaEntry entries[1]; +}; +typedef struct JustWidthDeltaGroup JustWidthDeltaGroup; +/* Overall structure of a postcompensation table is defined in PostcompTable. */ +struct JustPostcompTable { + SFNTLookupTable lookupTable; + /* action records here */ +}; +typedef struct JustPostcompTable JustPostcompTable; +struct JustDirectionTable { + UInt16 justClass; /* offset to state table (0=none) */ + UInt16 widthDeltaClusters; /* offset to clusters */ + UInt16 postcomp; /* offset to postcomp table (0=none) */ + SFNTLookupTable lookup; +}; +typedef struct JustDirectionTable JustDirectionTable; +struct JustTable { + Fixed version; + UInt16 format; + UInt16 horizHeaderOffset; + UInt16 vertHeaderOffset; +}; +typedef struct JustTable JustTable; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'opbd' */ +/* CONSTANTS */ +enum { + kOPBDTag = 0x6F706264, /* 'opbd' */ + kOPBDCurrentVersion = 0x00010000, + kOPBDDistanceFormat = 0, + kOPBDControlPointFormat = 1 +}; + +/* TYPES */ + +typedef UInt16 OpbdTableFormat; +/* + The OpbdSideValues struct is the lookup result from the FindSingle call for the + optical tables. It contains the 4 FUnit values that are relevant to the specified + glyph, or the 4 control gxPoint values. +*/ +struct OpbdSideValues { + SInt16 leftSideShift; + SInt16 topSideShift; + SInt16 rightSideShift; + SInt16 bottomSideShift; +}; +typedef struct OpbdSideValues OpbdSideValues; +struct OpbdTable { + Fixed version; + OpbdTableFormat format; + SFNTLookupTable lookupTable; +}; +typedef struct OpbdTable OpbdTable; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'mort' */ +/* CONSTANTS */ +enum { + kMORTTag = 0x6D6F7274, /* 'mort' */ + kMORTCurrentVersion = 0x00010000, /* current version number for 'mort' table */ + /* Coverage masks */ + kMORTCoverVertical = 0x8000, + kMORTCoverDescending = 0x4000, + kMORTCoverIgnoreVertical = 0x2000, + kMORTCoverTypeMask = 0x000F, /* Subtable types */ + kMORTRearrangementType = 0, + kMORTContextualType = 1, + kMORTLigatureType = 2, + kMORTSwashType = 4, + kMORTInsertionType = 5, /* Ligature subtable constants */ + kMORTLigLastAction = (long)0x80000000, + kMORTLigStoreLigature = 0x40000000, + kMORTLigFormOffsetMask = 0x3FFFFFFF, + kMORTLigFormOffsetShift = 2, /* Rearrangement subtable actions */ + kMORTraNoAction = 0, /* no action */ + kMORTraxA = 1, /* Ax => xA */ + kMORTraDx = 2, /* xD => Dx */ + kMORTraDxA = 3, /* AxD => DxA */ + kMORTraxAB = 4, /* ABx => xAB */ + kMORTraxBA = 5, /* ABx => xBA */ + kMORTraCDx = 6, /* xCD => CDx */ + kMORTraDCx = 7, /* xCD => DCx */ + kMORTraCDxA = 8, /* AxCD => CDxA */ + kMORTraDCxA = 9, /* AxCD => DCxA */ + kMORTraDxAB = 10, /* ABxD => DxAB */ + kMORTraDxBA = 11, /* ABxD => DxBA */ + kMORTraCDxAB = 12, /* ABxCD => CDxAB */ + kMORTraCDxBA = 13, /* ABxCD => CDxBA */ + kMORTraDCxAB = 14, /* ABxCD => DCxAB */ + kMORTraDCxBA = 15, /* ABxCD => DCxBA */ + /* Insertion subtable constants */ + kMORTDoInsertionsBefore = 0x80, + kMORTIsSplitVowelPiece = 0x40, + kMORTInsertionsCountMask = 0x3F, + kMORTCurrInsertKashidaLike = 0x2000, + kMORTMarkInsertKashidaLike = 0x1000, + kMORTCurrInsertBefore = 0x0800, + kMORTMarkInsertBefore = 0x0400, + kMORTMarkJustTableCountMask = 0x3F80, + kMORTMarkJustTableCountShift = 7, /* JustTableIndex for marked character */ + kMORTCurrJustTableCountMask = 0x007F, + kMORTCurrJustTableCountShift = 0, /* JustTableIndex for current character */ + kMORTCurrInsertCountMask = 0x03E0, + kMORTCurrInsertCountShift = 5, /* count to insert after current glyphRec */ + kMORTMarkInsertCountMask = 0x001F, + kMORTMarkInsertCountShift = 0 /* count to insert after marked glyphRec */ +}; + +/* TYPES */ + +typedef UInt32 MortSubtableMaskFlags; +typedef UInt32 MortLigatureActionEntry; +struct MortRearrangementSubtable { + STHeader header; +}; +typedef struct MortRearrangementSubtable MortRearrangementSubtable; +struct MortContextualSubtable { + STHeader header; + UInt16 substitutionTableOffset; +}; +typedef struct MortContextualSubtable MortContextualSubtable; +struct MortLigatureSubtable { + STHeader header; + UInt16 ligatureActionTableOffset; + UInt16 componentTableOffset; + UInt16 ligatureTableOffset; +}; +typedef struct MortLigatureSubtable MortLigatureSubtable; +struct MortSwashSubtable { + SFNTLookupTable lookup; +}; +typedef struct MortSwashSubtable MortSwashSubtable; +struct MortInsertionSubtable { + STHeader header; +}; +typedef struct MortInsertionSubtable MortInsertionSubtable; +union MortSpecificSubtable { + MortRearrangementSubtable rearrangement; + MortContextualSubtable contextual; + MortLigatureSubtable ligature; + MortSwashSubtable swash; + MortInsertionSubtable insertion; +}; +typedef union MortSpecificSubtable MortSpecificSubtable; +struct MortSubtable { + UInt16 length; + UInt16 coverage; + MortSubtableMaskFlags flags; + MortSpecificSubtable u; +}; +typedef struct MortSubtable MortSubtable; +struct MortFeatureEntry { + UInt16 featureType; + UInt16 featureSelector; + MortSubtableMaskFlags enableFlags; + MortSubtableMaskFlags disableFlags; +}; +typedef struct MortFeatureEntry MortFeatureEntry; +struct MortChain { + MortSubtableMaskFlags defaultFlags; /* default flags for this chain */ + UInt32 length; /* byte length of this chain */ + UInt16 nFeatures; /* number of feature entries */ + UInt16 nSubtables; /* number of subtables */ + MortFeatureEntry featureEntries[1]; + /* the subtables follow */ +}; +typedef struct MortChain MortChain; +struct MortTable { + Fixed version; + UInt32 nChains; + MortChain chains[1]; +}; +typedef struct MortTable MortTable; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'morx' (version 2 and beyond metamorphosis tables) */ +/* CONSTANTS */ +enum { + kMORXTag = 0x6D6F7278, /* 'morx' */ + kMORXCurrentVersion = 0x00020000, /* version number for current 'morx' table */ + /* Coverage masks */ + kMORXCoverVertical = (long)0x80000000, + kMORXCoverDescending = 0x40000000, + kMORXCoverIgnoreVertical = 0x20000000, + kMORXCoverTypeMask = 0x000000FF +}; + +/* TYPES */ +struct MorxRearrangementSubtable { + STXHeader header; +}; +typedef struct MorxRearrangementSubtable MorxRearrangementSubtable; +struct MorxContextualSubtable { + STXHeader header; + UInt32 substitutionTableOffset; +}; +typedef struct MorxContextualSubtable MorxContextualSubtable; +struct MorxLigatureSubtable { + STXHeader header; + UInt32 ligatureActionTableOffset; + UInt32 componentTableOffset; + UInt32 ligatureTableOffset; +}; +typedef struct MorxLigatureSubtable MorxLigatureSubtable; +struct MorxInsertionSubtable { + STXHeader header; + UInt32 insertionGlyphTableOffset; +}; +typedef struct MorxInsertionSubtable MorxInsertionSubtable; +union MorxSpecificSubtable { + MorxRearrangementSubtable rearrangement; + MorxContextualSubtable contextual; + MorxLigatureSubtable ligature; + MortSwashSubtable swash; + MorxInsertionSubtable insertion; +}; +typedef union MorxSpecificSubtable MorxSpecificSubtable; +struct MorxSubtable { + UInt32 length; + UInt32 coverage; + MortSubtableMaskFlags flags; + MorxSpecificSubtable u; +}; +typedef struct MorxSubtable MorxSubtable; +struct MorxChain { + MortSubtableMaskFlags defaultFlags; /* default flags for this chain */ + UInt32 length; /* byte length of this chain */ + UInt32 nFeatures; /* number of feature entries */ + UInt32 nSubtables; /* number of subtables */ + MortFeatureEntry featureEntries[1]; + /* the subtables follow */ +}; +typedef struct MorxChain MorxChain; +struct MorxTable { + Fixed version; + UInt32 nChains; + MorxChain chains[1]; +}; +typedef struct MorxTable MorxTable; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'prop' */ +/* CONSTANTS */ +enum { + kPROPTag = 0x70726F70, /* 'prop' */ + kPROPCurrentVersion = 0x00030000, /* current version number for 'prop' table */ + kPROPPairOffsetShift = 8, + kPROPPairOffsetSign = 7, + kPROPIsFloaterMask = 0x8000, /* glyph is floater */ + kPROPCanHangLTMask = 0x4000, /* glyph can hang left/top */ + kPROPCanHangRBMask = 0x2000, /* glyph can hang right/bottom */ + kPROPUseRLPairMask = 0x1000, /* if glyph lands in RL streak, use paired glyph */ + kPROPPairOffsetMask = 0x0F00, /* 4-bit signed offset to other pair member */ + kPROPRightConnectMask = 0x0080, /* glyph connects to glyph on right */ + kPROPZeroReserved = 0x0060, /* must be zero */ + kPROPDirectionMask = 0x001F /* direction bits */ +}; + +/* These are the Unicode direction classes (plus the Special European Number class). */ +enum { + kPROPLDirectionClass = 0, /* Left-to-Right */ + kPROPRDirectionClass = 1, /* Right-to-Left */ + kPROPALDirectionClass = 2, /* Right-to-Left Arabic Letter */ + kPROPENDirectionClass = 3, /* European Number */ + kPROPESDirectionClass = 4, /* European Number Seperator */ + kPROPETDirectionClass = 5, /* European Number Terminator */ + kPROPANDirectionClass = 6, /* Arabic Number */ + kPROPCSDirectionClass = 7, /* Common Number Seperator */ + kPROPPSDirectionClass = 8, /* Paragraph Seperator (also referred to as Block Separator) */ + kPROPSDirectionClass = 9, /* Segment Seperator */ + kPROPWSDirectionClass = 10, /* Whitespace */ + kPROPONDirectionClass = 11, /* Other Neutral */ + kPROPSENDirectionClass = 12, /* Special European Number (not a Unicode class) */ + kPROPLREDirectionClass = 13, /* Left-to-Right Embeding */ + kPROPLRODirectionClass = 14, /* Left-to-Right Override */ + kPROPRLEDirectionClass = 15, /* Right-to-Left Embeding */ + kPROPRLODirectionClass = 16, /* Right-to-Left Override */ + kPROPPDFDirectionClass = 17, /* Pop Directional Format */ + kPROPNSMDirectionClass = 18, /* Non-Spacing Mark */ + kPROPBNDirectionClass = 19, /* Boundary Neutral */ + kPROPNumDirectionClasses = 20 /* Number of Unicode directional types + Special European Number */ +}; + +/* TYPES */ + +typedef UInt16 PropCharProperties; +struct PropTable { + Fixed version; + UInt16 format; + PropCharProperties defaultProps; + SFNTLookupTable lookup; +}; +typedef struct PropTable PropTable; +struct PropLookupSegment { + UInt16 lastGlyph; + UInt16 firstGlyph; + UInt16 value; +}; +typedef struct PropLookupSegment PropLookupSegment; +struct PropLookupSingle { + UInt16 glyph; + PropCharProperties props; +}; +typedef struct PropLookupSingle PropLookupSingle; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'trak' */ +/* CONSTANTS */ +enum { + kTRAKTag = 0x7472616B, /* 'trak' */ + kTRAKCurrentVersion = 0x00010000, /* current version number for 'trak' table */ + kTRAKUniformFormat = 0 /* kTRAKPerGlyphFormat = 2*/ +}; + +/* TYPES */ + +typedef SInt16 TrakValue; +struct TrakTableEntry { + Fixed track; + UInt16 nameTableIndex; + UInt16 sizesOffset; /* offset to array of TrackingValues */ +}; +typedef struct TrakTableEntry TrakTableEntry; +struct TrakTableData { + UInt16 nTracks; + UInt16 nSizes; + UInt32 sizeTableOffset; + TrakTableEntry trakTable[1]; +}; +typedef struct TrakTableData TrakTableData; +struct TrakTable { + Fixed version; + UInt16 format; + UInt16 horizOffset; + UInt16 vertOffset; +}; +typedef struct TrakTable TrakTable; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'kern' */ +/* CONSTANTS */ +enum { + kKERNTag = 0x6B65726E, /* 'kern' */ + kKERNCurrentVersion = 0x00010000, + kKERNVertical = 0x8000, /* set if this table has vertical kerning information */ + kKERNResetCrossStream = 0x8000, /* this value in a cross-stream table means reset to zero */ + kKERNCrossStream = 0x4000, /* set if this table contains cross-stream kerning values */ + kKERNVariation = 0x2000, /* set if this table contains variation kerning values */ + kKERNUnusedBits = 0x1F00, /* UNUSED, MUST BE ZERO */ + kKERNFormatMask = 0x00FF /* format of this subtable */ +}; + +enum { + kKERNOrderedList = 0, /* ordered list of kerning pairs */ + kKERNStateTable = 1, /* state table for n-way contextual kerning */ + kKERNSimpleArray = 2, /* simple n X m array of kerning values */ + kKERNIndexArray = 3 /* modifed version of SimpleArray */ +}; + +/* Message Type Flags */ +enum { + kKERNLineStart = 0x00000001, /* Array of glyphs starts a line */ + kKERNLineEndKerning = 0x00000002, /* Array of glyphs ends a line */ + kKERNNoCrossKerning = 0x00000004, /* Prohibit cross kerning */ + kKERNNotesRequested = 0x00000008, /* Caller wants kerning notes */ + kKERNNoStakeNote = 1, /* Indicates a glyph was involved in a kerning pair/group */ + kKERNCrossStreamResetNote = 2, /* Indicates a return-to-baseline in cross-stream kerning */ + kKERNNotApplied = 0x00000001 /* All kerning values were zero, kerning call had no effect */ +}; + +/* TYPES */ + +typedef UInt8 KernTableFormat; +typedef UInt16 KernSubtableInfo; +typedef SInt16 KernKerningValue; +typedef UInt16 KernArrayOffset; +/* header for version 0 kerning table */ +struct KernVersion0Header { + UInt16 version; /* font version number (will be 0!) */ + UInt16 nTables; /* number of subtables present */ + UInt16 firstSubtable[1]; /* first subtable starts here */ +}; +typedef struct KernVersion0Header KernVersion0Header; +/* Header for a kerning table */ +struct KernTableHeader { + Fixed version; /* font version number (currently 1.0) */ + SInt32 nTables; /* number of subtables present */ + UInt16 firstSubtable[1]; /* first subtable starts here */ +}; +typedef struct KernTableHeader KernTableHeader; +typedef KernTableHeader * KernTableHeaderPtr; +typedef KernTableHeaderPtr * KernTableHeaderHandle; +/* + F O R M A T S P E C I F I C D E F I N I T I O N S + + kernOrderedList: + + The table is a sorted list of [left glyph, right glyph, value] triples. + There's enough information in the header so that the list can be + efficiently binary searched. +*/ +/* defines a single kerning pair of Glyphcodes */ +struct KernKerningPair { + UInt16 left; + UInt16 right; +}; +typedef struct KernKerningPair KernKerningPair; +/* a single list entry */ +struct KernOrderedListEntry { + KernKerningPair pair; /* the kerning pair */ + KernKerningValue value; /* the kerning value for the above pair */ +}; +typedef struct KernOrderedListEntry KernOrderedListEntry; +typedef KernOrderedListEntry * KernOrderedListEntryPtr; +/* the header information for binary searching the list */ +struct KernOrderedListHeader { + UInt16 nPairs; /* number of kerning pairs in table */ + UInt16 searchRange; /* (largest power of two <= nPairs) * entry size */ + UInt16 entrySelector; /* log2 (largest power of two <= nPairs) */ + UInt16 rangeShift; /* (nPairs - largest power of two <= nPairs) * entry size */ + UInt16 table[1]; /* entries are first glyph, second glyph, and value */ +}; +typedef struct KernOrderedListHeader KernOrderedListHeader; +/* KernStateTable: like the the generic state tables */ +struct KernStateHeader { + STHeader header; /* state table header */ + UInt16 valueTable; /* offset to kerning value table */ + UInt8 firstTable[1]; /* first table starts here */ +}; +typedef struct KernStateHeader KernStateHeader; +struct KernStateEntry { + UInt16 newState; + UInt16 flags; /* flags per above enum */ +}; +typedef struct KernStateEntry KernStateEntry; +/* + Kern offset table header. + The offset table is a trimmed array from firstGlyph to limitGlyph. + Glyphs outside of this range should get zero for right-hand glyphs + and the offset of the beginning of the kerning array for left-hand glyphs. +*/ +struct KernOffsetTable { + UInt16 firstGlyph; /* first glyph in class range */ + UInt16 nGlyphs; /* number of glyphs in class range */ + KernArrayOffset offsetTable[1]; /* offset table starts here */ +}; +typedef struct KernOffsetTable KernOffsetTable; +typedef KernOffsetTable * KernOffsetTablePtr; +/* Header information for accessing offset tables and kerning array */ +/* + KernSimpleArray: + + The array is an nXm array of kenring values. Each row in the array + represents one left-hand glyph, and each column one right-hand glyph. + The zeroth row and column always represent glyphs that are out of bounds + and will always contain zero. + + A pair is looked up by indexing the left-hand glyph through the left + offset table, the right-hand glyph through the right offset table, + adding both offsets to the starting address of the kerning array, + and fetching the kerning value pointed to. +*/ +/* Kern offset table header. */ +/* The offset table is a trimmed array from firstGlyph to limitGlyph. */ +/* Glyphs outside of this range should get zero for right-hand glyphs */ +/* and the offset of the beginning of the kerning array for left- */ +/* hand glyphs. */ +struct KernSimpleArrayHeader { + UInt16 rowWidth; /* width, in bytes, of a row in the table */ + UInt16 leftOffsetTable; /* offset to left-hand offset table */ + UInt16 rightOffsetTable; /* offset to right-hand offset table */ + KernArrayOffset theArray; /* offset to start of kerning array */ + UInt16 firstTable[1]; /* first offset table starts here... */ +}; +typedef struct KernSimpleArrayHeader KernSimpleArrayHeader; +/* Index Array */ +struct KernIndexArrayHeader { + UInt16 glyphCount; + UInt8 kernValueCount; + UInt8 leftClassCount; + UInt8 rightClassCount; + UInt8 flags; /* set to 0 for now */ + SInt16 kernValue[1]; /* actual kerning values reference by index in kernIndex */ + UInt8 leftClass[1]; /* maps left glyph to offset into kern index */ + UInt8 rightClass[1]; /* maps right glyph to offset into kern index */ + UInt8 kernIndex[1]; /* contains indicies into kernValue */ +}; +typedef struct KernIndexArrayHeader KernIndexArrayHeader; +/* format specific part of subtable header */ +union KernFormatSpecificHeader { + KernOrderedListHeader orderedList; + KernStateHeader stateTable; + KernSimpleArrayHeader simpleArray; + KernIndexArrayHeader indexArray; +}; +typedef union KernFormatSpecificHeader KernFormatSpecificHeader; +/* version 0 subtable header */ +struct KernVersion0SubtableHeader { + UInt16 version; /* kerning table version number */ + UInt16 length; /* length in bytes (including this header) */ + KernSubtableInfo stInfo; /* sub-table info */ + KernFormatSpecificHeader fsHeader; /* format specific sub-header */ +}; +typedef struct KernVersion0SubtableHeader KernVersion0SubtableHeader; +/* Overall Subtable header format */ +struct KernSubtableHeader { + SInt32 length; /* length in bytes (including this header) */ + KernSubtableInfo stInfo; /* subtable info */ + SInt16 tupleIndex; /* tuple index for variation subtables */ + KernFormatSpecificHeader fsHeader; /* format specific sub-header */ +}; +typedef struct KernSubtableHeader KernSubtableHeader; +typedef KernSubtableHeader * KernSubtableHeaderPtr; +/* --------------------------------------------------------------------------- */ +/* FORMATS FOR TABLE: 'bsln' */ +/* CONSTANTS */ +enum { + kBSLNTag = 0x62736C6E, /* 'bsln' */ + kBSLNCurrentVersion = 0x00010000, /* current version number for 'bsln' table */ + kBSLNDistanceFormatNoMap = 0, + kBSLNDistanceFormatWithMap = 1, + kBSLNControlPointFormatNoMap = 2, + kBSLNControlPointFormatWithMap = 3 +}; + +/* Baseline classes and constants */ +enum { + kBSLNRomanBaseline = 0, + kBSLNIdeographicCenterBaseline = 1, + kBSLNIdeographicLowBaseline = 2, + kBSLNHangingBaseline = 3, + kBSLNMathBaseline = 4, + kBSLNLastBaseline = 31, + kBSLNNumBaselineClasses = kBSLNLastBaseline + 1, + kBSLNNoBaselineOverride = 255 +}; + +/* TYPES */ +typedef UInt32 BslnBaselineClass; +/* The BslnBaselineRecord array defines the baseline deltas for the line. */ +typedef Fixed BslnBaselineRecord[32]; +/* + BslnFormat0Part is the format-specific data for a distance table with no mapping (i.e. + all the glyphs belong to the defaultBaseline). +*/ +struct BslnFormat0Part { + SInt16 deltas[32]; +}; +typedef struct BslnFormat0Part BslnFormat0Part; +/* BslnFormat1Part is the format-specific data for a distance table with a gxMapping. */ +struct BslnFormat1Part { + SInt16 deltas[32]; + SFNTLookupTable mappingData; +}; +typedef struct BslnFormat1Part BslnFormat1Part; +/* + BslnFormat2Part is the format-specific data for a control-point table with no + mapping (i.e. all the glyphs belong to the defaultBaseline). It specifies a single + glyph to use and the set of control points in that glyph that designate each of + the baselines. +*/ +struct BslnFormat2Part { + UInt16 stdGlyph; + SInt16 ctlPoints[32]; +}; +typedef struct BslnFormat2Part BslnFormat2Part; +/* + BslnFormat3Part is the format-specific data for a distance table with a mapping. Like + format 2, it contains a single glyph and its set of control-point values for each + of the baselines. +*/ +struct BslnFormat3Part { + UInt16 stdGlyph; + SInt16 ctlPoints[32]; + SFNTLookupTable mappingData; +}; +typedef struct BslnFormat3Part BslnFormat3Part; +/* The BslnFormatUnion is a union containing the format-specific parts of the baseline table. */ +union BslnFormatUnion { + BslnFormat0Part fmt0Part; + BslnFormat1Part fmt1Part; + BslnFormat2Part fmt2Part; + BslnFormat3Part fmt3Part; +}; +typedef union BslnFormatUnion BslnFormatUnion; +/* The table format used in BaselineTable */ + +typedef UInt16 BslnTableFormat; +/* BaselineTable defines the top-level format of the baseline table in the font. */ +struct BslnTable { + Fixed version; + BslnTableFormat format; + UInt16 defaultBaseline; + BslnFormatUnion parts; +}; +typedef struct BslnTable BslnTable; +typedef BslnTable * BslnTablePtr; +/* --------------------------------------------------------------------------- */ + +#if PRAGMA_STRUCT_ALIGN + #pragma options align=reset +#elif PRAGMA_STRUCT_PACKPUSH + #pragma pack(pop) +#elif PRAGMA_STRUCT_PACK + #pragma pack() +#endif + +#ifdef PRAGMA_IMPORT_OFF +#pragma import off +#elif PRAGMA_IMPORT +#pragma import reset +#endif + + +#endif /* __SFNTLAYOUTTYPES__ */ + |