diff options
Diffstat (limited to 'trunk/pango/opentype/harfbuzz-gsub-private.h')
| -rw-r--r-- | trunk/pango/opentype/harfbuzz-gsub-private.h | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/trunk/pango/opentype/harfbuzz-gsub-private.h b/trunk/pango/opentype/harfbuzz-gsub-private.h new file mode 100644 index 00000000..84c08df5 --- /dev/null +++ b/trunk/pango/opentype/harfbuzz-gsub-private.h @@ -0,0 +1,448 @@ +/******************************************************************* + * + * Copyright 1996-2000 by + * David Turner, Robert Wilhelm, and Werner Lemberg. + * + * Copyright 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * See the file name COPYING for licensing information. + * + ******************************************************************/ +#ifndef HARFBUZZ_GSUB_PRIVATE_H +#define HARFBUZZ_GSUB_PRIVATE_H + +#include "harfbuzz-gsub.h" + +FT_BEGIN_HEADER + + +typedef union HB_GSUB_SubTable_ HB_GSUB_SubTable; + +/* LookupType 1 */ + +struct HB_SingleSubstFormat1_ +{ + FT_Short DeltaGlyphID; /* constant added to get + substitution glyph index */ +}; + +typedef struct HB_SingleSubstFormat1_ HB_SingleSubstFormat1; + + +struct HB_SingleSubstFormat2_ +{ + FT_UShort GlyphCount; /* number of glyph IDs in + Substitute array */ + FT_UShort* Substitute; /* array of substitute glyph IDs */ +}; + +typedef struct HB_SingleSubstFormat2_ HB_SingleSubstFormat2; + + +struct HB_SingleSubst_ +{ + FT_UShort SubstFormat; /* 1 or 2 */ + HB_Coverage Coverage; /* Coverage table */ + + union + { + HB_SingleSubstFormat1 ssf1; + HB_SingleSubstFormat2 ssf2; + } ssf; +}; + +typedef struct HB_SingleSubst_ HB_SingleSubst; + + +/* LookupType 2 */ + +struct HB_Sequence_ +{ + FT_UShort GlyphCount; /* number of glyph IDs in the + Substitute array */ + FT_UShort* Substitute; /* string of glyph IDs to + substitute */ +}; + +typedef struct HB_Sequence_ HB_Sequence; + + +struct HB_MultipleSubst_ +{ + FT_UShort SubstFormat; /* always 1 */ + HB_Coverage Coverage; /* Coverage table */ + FT_UShort SequenceCount; /* number of Sequence tables */ + HB_Sequence* Sequence; /* array of Sequence tables */ +}; + +typedef struct HB_MultipleSubst_ HB_MultipleSubst; + + +/* LookupType 3 */ + +struct HB_AlternateSet_ +{ + FT_UShort GlyphCount; /* number of glyph IDs in the + Alternate array */ + FT_UShort* Alternate; /* array of alternate glyph IDs */ +}; + +typedef struct HB_AlternateSet_ HB_AlternateSet; + + +struct HB_AlternateSubst_ +{ + FT_UShort SubstFormat; /* always 1 */ + HB_Coverage Coverage; /* Coverage table */ + FT_UShort AlternateSetCount; + /* number of AlternateSet tables */ + HB_AlternateSet* AlternateSet; /* array of AlternateSet tables */ +}; + +typedef struct HB_AlternateSubst_ HB_AlternateSubst; + + +/* LookupType 4 */ + +struct HB_Ligature_ +{ + FT_UShort LigGlyph; /* glyphID of ligature + to substitute */ + FT_UShort ComponentCount; /* number of components in ligature */ + FT_UShort* Component; /* array of component glyph IDs */ +}; + +typedef struct HB_Ligature_ HB_Ligature; + + +struct HB_LigatureSet_ +{ + FT_UShort LigatureCount; /* number of Ligature tables */ + HB_Ligature* Ligature; /* array of Ligature tables */ +}; + +typedef struct HB_LigatureSet_ HB_LigatureSet; + + +struct HB_LigatureSubst_ +{ + FT_UShort SubstFormat; /* always 1 */ + HB_Coverage Coverage; /* Coverage table */ + FT_UShort LigatureSetCount; /* number of LigatureSet tables */ + HB_LigatureSet* LigatureSet; /* array of LigatureSet tables */ +}; + +typedef struct HB_LigatureSubst_ HB_LigatureSubst; + + +/* needed by both lookup type 5 and 6 */ + +struct HB_SubstLookupRecord_ +{ + FT_UShort SequenceIndex; /* index into current + glyph sequence */ + FT_UShort LookupListIndex; /* Lookup to apply to that pos. */ +}; + +typedef struct HB_SubstLookupRecord_ HB_SubstLookupRecord; + + +/* LookupType 5 */ + +struct HB_SubRule_ +{ + FT_UShort GlyphCount; /* total number of input glyphs */ + FT_UShort SubstCount; /* number of SubstLookupRecord + tables */ + FT_UShort* Input; /* array of input glyph IDs */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of SubstLookupRecord + tables */ +}; + +typedef struct HB_SubRule_ HB_SubRule; + + +struct HB_SubRuleSet_ +{ + FT_UShort SubRuleCount; /* number of SubRule tables */ + HB_SubRule* SubRule; /* array of SubRule tables */ +}; + +typedef struct HB_SubRuleSet_ HB_SubRuleSet; + + +struct HB_ContextSubstFormat1_ +{ + HB_Coverage Coverage; /* Coverage table */ + FT_UShort SubRuleSetCount; /* number of SubRuleSet tables */ + HB_SubRuleSet* SubRuleSet; /* array of SubRuleSet tables */ +}; + +typedef struct HB_ContextSubstFormat1_ HB_ContextSubstFormat1; + + +struct HB_SubClassRule_ +{ + FT_UShort GlyphCount; /* total number of context classes */ + FT_UShort SubstCount; /* number of SubstLookupRecord + tables */ + FT_UShort* Class; /* array of classes */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of SubstLookupRecord + tables */ +}; + +typedef struct HB_SubClassRule_ HB_SubClassRule; + + +struct HB_SubClassSet_ +{ + FT_UShort SubClassRuleCount; + /* number of SubClassRule tables */ + HB_SubClassRule* SubClassRule; /* array of SubClassRule tables */ +}; + +typedef struct HB_SubClassSet_ HB_SubClassSet; + + +/* The `MaxContextLength' field is not defined in the TTO specification + but simplifies the implementation of this format. It holds the + maximal context length used in the context rules. */ + +struct HB_ContextSubstFormat2_ +{ + FT_UShort MaxContextLength; + /* maximal context length */ + HB_Coverage Coverage; /* Coverage table */ + HB_ClassDefinition ClassDef; /* ClassDef table */ + FT_UShort SubClassSetCount; + /* number of SubClassSet tables */ + HB_SubClassSet* SubClassSet; /* array of SubClassSet tables */ +}; + +typedef struct HB_ContextSubstFormat2_ HB_ContextSubstFormat2; + + +struct HB_ContextSubstFormat3_ +{ + FT_UShort GlyphCount; /* number of input glyphs */ + FT_UShort SubstCount; /* number of SubstLookupRecords */ + HB_Coverage* Coverage; /* array of Coverage tables */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of substitution lookups */ +}; + +typedef struct HB_ContextSubstFormat3_ HB_ContextSubstFormat3; + + +struct HB_ContextSubst_ +{ + FT_UShort SubstFormat; /* 1, 2, or 3 */ + + union + { + HB_ContextSubstFormat1 csf1; + HB_ContextSubstFormat2 csf2; + HB_ContextSubstFormat3 csf3; + } csf; +}; + +typedef struct HB_ContextSubst_ HB_ContextSubst; + + +/* LookupType 6 */ + +struct HB_ChainSubRule_ +{ + FT_UShort BacktrackGlyphCount; + /* total number of backtrack glyphs */ + FT_UShort* Backtrack; /* array of backtrack glyph IDs */ + FT_UShort InputGlyphCount; + /* total number of input glyphs */ + FT_UShort* Input; /* array of input glyph IDs */ + FT_UShort LookaheadGlyphCount; + /* total number of lookahead glyphs */ + FT_UShort* Lookahead; /* array of lookahead glyph IDs */ + FT_UShort SubstCount; /* number of SubstLookupRecords */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of SubstLookupRecords */ +}; + +typedef struct HB_ChainSubRule_ HB_ChainSubRule; + + +struct HB_ChainSubRuleSet_ +{ + FT_UShort ChainSubRuleCount; + /* number of ChainSubRule tables */ + HB_ChainSubRule* ChainSubRule; /* array of ChainSubRule tables */ +}; + +typedef struct HB_ChainSubRuleSet_ HB_ChainSubRuleSet; + + +struct HB_ChainContextSubstFormat1_ +{ + HB_Coverage Coverage; /* Coverage table */ + FT_UShort ChainSubRuleSetCount; + /* number of ChainSubRuleSet tables */ + HB_ChainSubRuleSet* ChainSubRuleSet; + /* array of ChainSubRuleSet tables */ +}; + +typedef struct HB_ChainContextSubstFormat1_ HB_ChainContextSubstFormat1; + + +struct HB_ChainSubClassRule_ +{ + FT_UShort BacktrackGlyphCount; + /* total number of backtrack + classes */ + FT_UShort* Backtrack; /* array of backtrack classes */ + FT_UShort InputGlyphCount; + /* total number of context classes */ + FT_UShort* Input; /* array of context classes */ + FT_UShort LookaheadGlyphCount; + /* total number of lookahead + classes */ + FT_UShort* Lookahead; /* array of lookahead classes */ + FT_UShort SubstCount; /* number of SubstLookupRecords */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of substitution lookups */ +}; + +typedef struct HB_ChainSubClassRule_ HB_ChainSubClassRule; + + +struct HB_ChainSubClassSet_ +{ + FT_UShort ChainSubClassRuleCount; + /* number of ChainSubClassRule + tables */ + HB_ChainSubClassRule* ChainSubClassRule; + /* array of ChainSubClassRule + tables */ +}; + +typedef struct HB_ChainSubClassSet_ HB_ChainSubClassSet; + + +/* The `MaxXXXLength' fields are not defined in the TTO specification + but simplifies the implementation of this format. It holds the + maximal context length used in the specific context rules. */ + +struct HB_ChainContextSubstFormat2_ +{ + HB_Coverage Coverage; /* Coverage table */ + + FT_UShort MaxBacktrackLength; + /* maximal backtrack length */ + HB_ClassDefinition BacktrackClassDef; + /* BacktrackClassDef table */ + FT_UShort MaxInputLength; + /* maximal input length */ + HB_ClassDefinition InputClassDef; + /* InputClassDef table */ + FT_UShort MaxLookaheadLength; + /* maximal lookahead length */ + HB_ClassDefinition LookaheadClassDef; + /* LookaheadClassDef table */ + + FT_UShort ChainSubClassSetCount; + /* number of ChainSubClassSet + tables */ + HB_ChainSubClassSet* ChainSubClassSet; + /* array of ChainSubClassSet + tables */ +}; + +typedef struct HB_ChainContextSubstFormat2_ HB_ChainContextSubstFormat2; + + +struct HB_ChainContextSubstFormat3_ +{ + FT_UShort BacktrackGlyphCount; + /* number of backtrack glyphs */ + HB_Coverage* BacktrackCoverage; + /* array of backtrack Coverage + tables */ + FT_UShort InputGlyphCount; + /* number of input glyphs */ + HB_Coverage* InputCoverage; + /* array of input coverage + tables */ + FT_UShort LookaheadGlyphCount; + /* number of lookahead glyphs */ + HB_Coverage* LookaheadCoverage; + /* array of lookahead coverage + tables */ + FT_UShort SubstCount; /* number of SubstLookupRecords */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of substitution lookups */ +}; + +typedef struct HB_ChainContextSubstFormat3_ HB_ChainContextSubstFormat3; + + +struct HB_ChainContextSubst_ +{ + FT_UShort SubstFormat; /* 1, 2, or 3 */ + + union + { + HB_ChainContextSubstFormat1 ccsf1; + HB_ChainContextSubstFormat2 ccsf2; + HB_ChainContextSubstFormat3 ccsf3; + } ccsf; +}; + +typedef struct HB_ChainContextSubst_ HB_ChainContextSubst; + + +/* LookupType 8 */ +struct HB_ReverseChainContextSubst_ +{ + FT_UShort SubstFormat; /* always 1 */ + HB_Coverage Coverage; /* coverage table for input glyphs */ + FT_UShort BacktrackGlyphCount; /* number of backtrack glyphs */ + HB_Coverage* BacktrackCoverage; /* array of backtrack Coverage + tables */ + FT_UShort LookaheadGlyphCount; /* number of lookahead glyphs */ + HB_Coverage* LookaheadCoverage; /* array of lookahead Coverage + tables */ + FT_UShort GlyphCount; /* number of Glyph IDs */ + FT_UShort* Substitute; /* array of substitute Glyph ID */ +}; + +typedef struct HB_ReverseChainContextSubst_ HB_ReverseChainContextSubst; + + +union HB_GSUB_SubTable_ +{ + HB_SingleSubst single; + HB_MultipleSubst multiple; + HB_AlternateSubst alternate; + HB_LigatureSubst ligature; + HB_ContextSubst context; + HB_ChainContextSubst chain; + HB_ReverseChainContextSubst reverse; +}; + + + + + +FT_Error _HB_GSUB_Load_SubTable( HB_GSUB_SubTable* st, + FT_Stream stream, + FT_UShort lookup_type ); + +void _HB_GSUB_Free_SubTable( HB_GSUB_SubTable* st, + FT_Memory memory, + FT_UShort lookup_type ); + +FT_END_HEADER + +#endif /* HARFBUZZ_GSUB_PRIVATE_H */ |