BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/common/quicktime_win32/SFNTLayoutTypes.h

1432 lines
49 KiB
C
Raw Permalink Blame History

/*
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__ */
Reference in New Issue View Git Blame Copy Permalink