You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1431 lines
49 KiB
1431 lines
49 KiB
/* |
|
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__ */ |
|
|
|
|