internal static void GetComplexLanguageList(
OpenTypeTags tableTag,
FontTable table,
uint[] featureTagsList,
uint[] glyphBits,
ushort minGlyphId,
ushort maxGlyphId,
out WritingSystem[] complexLanguages,
out int complexLanguageCount
)
{
ScriptList scriptList = new ScriptList(0);
FeatureList featureList = new FeatureList(0);
LookupList lookupList = new LookupList(0);
Debug.Assert(tableTag == OpenTypeTags.GSUB || tableTag == OpenTypeTags.GPOS);
switch (tableTag)
{
case OpenTypeTags.GSUB:
GSUBHeader gsubHeader = new GSUBHeader(0);
scriptList = gsubHeader.GetScriptList(table);
featureList = gsubHeader.GetFeatureList(table);
lookupList = gsubHeader.GetLookupList(table);
break;
case OpenTypeTags.GPOS:
GPOSHeader gposHeader = new GPOSHeader(0);
scriptList = gposHeader.GetScriptList(table);
featureList = gposHeader.GetFeatureList(table);
lookupList = gposHeader.GetLookupList(table);
break;
}
int scriptCount = scriptList.GetScriptCount(table);
int featureCount = featureList.FeatureCount(table);
int lookupCount = lookupList.LookupCount(table);
// We will mark lookups that should be tested.
// At the end, we will have only complex ones marked
uint[] lookupBits = new uint[(lookupCount+31)>>5];
for(int i = 0; i < (lookupCount+31)>>5; i++)
{
lookupBits[i] = 0;
}
// Iterate through list of featuers in the table
for(ushort featureIndex = 0; featureIndex < featureCount; featureIndex++)
{
uint featureTag = (uint)featureList.FeatureTag(table, featureIndex);
bool tagFound = false;
//Search for tag in the list of features in question
for(int j = 0; j < featureTagsList.Length; j++)
{
if (featureTagsList[j] == featureTag)
{
tagFound = true;
break;
}
}
if (tagFound)
{
// We should mark all lookup mapped to this feature
FeatureTable featureTable = featureList.FeatureTable(table, featureIndex);
ushort featureLookupCount = featureTable.LookupCount(table);
for(ushort j = 0; j < featureLookupCount; j++)
{
ushort lookupIndex = featureTable.LookupIndex(table, j);
if (lookupIndex >= lookupCount)
{
//This should be invalid font. Lookup associated with the feature is not in lookup array.
throw new FileFormatException();
}
lookupBits[lookupIndex>>5] |= (uint)(1 << (lookupIndex%32));
}
}
}
//
//
//Now test all marked lookups
for(ushort lookupIndex = 0; lookupIndex < lookupCount; lookupIndex++)
{
if ((lookupBits[lookupIndex>>5] & (1 << (lookupIndex%32))) == 0)
{
continue;
}
LookupTable lookup = lookupList.Lookup(table,lookupIndex);
ushort lookupType = lookup.LookupType();
ushort subtableCount = lookup.SubTableCount();
bool lookupIsCovered = false;
ushort originalLookupType = lookupType; // We need it to recover,
// if extension lookup updated lookupFormat
for(ushort subtableIndex = 0;
!lookupIsCovered && subtableIndex < subtableCount;
subtableIndex++)
{
lookupType = originalLookupType;
int subtableOffset = lookup.SubtableOffset(table, subtableIndex);
switch (tableTag)
{
case OpenTypeTags.GSUB:
{
if (lookupType == 7)
{
ExtensionLookupTable extension =
new ExtensionLookupTable(subtableOffset);
lookupType = extension.LookupType(table);
subtableOffset = extension.LookupSubtableOffset(table);
}
switch (lookupType)
{
case 1: //SingleSubst
SingleSubstitutionSubtable singleSub =
new SingleSubstitutionSubtable(subtableOffset);
lookupIsCovered = singleSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 2: //MultipleSubst
MultipleSubstitutionSubtable multipleSub =
new MultipleSubstitutionSubtable(subtableOffset);
lookupIsCovered = multipleSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 3: //AlternateSubst
AlternateSubstitutionSubtable alternateSub =
new AlternateSubstitutionSubtable(subtableOffset);
lookupIsCovered = alternateSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 4: //Ligature subst
LigatureSubstitutionSubtable ligaSub =
new LigatureSubstitutionSubtable(subtableOffset);
lookupIsCovered = ligaSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 5: //ContextualSubst
ContextSubtable contextSub =
new ContextSubtable(subtableOffset);
lookupIsCovered = contextSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 6: //ChainingSubst
ChainingSubtable chainingSub =
new ChainingSubtable(subtableOffset);
lookupIsCovered = chainingSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 7: //Extension lookup
Debug.Assert(false,"Ext.Lookup processed earlier!");
break;
case 8: //ReverseCahiningSubst
ReverseChainingSubtable reverseChainingSub =
new ReverseChainingSubtable(subtableOffset);
lookupIsCovered = reverseChainingSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
default:
// Unknown format
lookupIsCovered = true;
break;
}
break;
}
case OpenTypeTags.GPOS:
{
if (lookupType == 9)
{
ExtensionLookupTable extension =
new ExtensionLookupTable(subtableOffset);
lookupType = extension.LookupType(table);
subtableOffset = extension.LookupSubtableOffset(table);
}
switch (lookupType)
{
case 1: //SinglePos
SinglePositioningSubtable singlePos =
new SinglePositioningSubtable(subtableOffset);
lookupIsCovered = singlePos.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 2: //PairPos
PairPositioningSubtable pairPos =
new PairPositioningSubtable(subtableOffset);
lookupIsCovered = pairPos.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 3: // CursivePos
// Under construction
CursivePositioningSubtable cursivePositioningSubtable =
new CursivePositioningSubtable(subtableOffset);
lookupIsCovered = cursivePositioningSubtable.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 4: //MarkToBasePos
MarkToBasePositioningSubtable markToBasePos =
new MarkToBasePositioningSubtable(subtableOffset);
lookupIsCovered = markToBasePos.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 5: //MarkToLigaturePos
// Under construction
MarkToLigaturePositioningSubtable markToLigaPos =
new MarkToLigaturePositioningSubtable(subtableOffset);
lookupIsCovered = markToLigaPos.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 6: //MarkToMarkPos
MarkToMarkPositioningSubtable markToMarkPos =
new MarkToMarkPositioningSubtable(subtableOffset);
lookupIsCovered = markToMarkPos.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 7: // Contextual
ContextSubtable contextSub =
new ContextSubtable(subtableOffset);
lookupIsCovered = contextSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 8: // Chaining
ChainingSubtable chainingSub =
new ChainingSubtable(subtableOffset);
lookupIsCovered = chainingSub.IsLookupCovered(table,glyphBits,minGlyphId,maxGlyphId);
break;
case 9: //Extension lookup
Debug.Assert(false,"Ext.Lookup processed earlier!");
break;
default:
// Unknown format
lookupIsCovered = true;
break;
}
break;
}
default:
Debug.Assert(false,"Unknown OpenType layout table!");
break;
}
}
if (!lookupIsCovered)
{
// Clean the flag
lookupBits[lookupIndex>>5] &= ~(uint)(1 << (lookupIndex%32));
}
}
// Check if we have any lookup left
bool complexLookupFound = false;
for(int i = 0; i < (lookupCount+31)>>5; i++)
{
if (lookupBits[i] != 0)
{
complexLookupFound = true;
break;
}
}
if (!complexLookupFound)
{
// There are no complex lookups
complexLanguages = null;
complexLanguageCount = 0;
return;
}
// Now go through all langauages and fill the list
complexLanguages = new WritingSystem[10];
complexLanguageCount = 0;
for(ushort scriptIndex = 0; scriptIndex < scriptCount; scriptIndex++)
{
ScriptTable scriptTable = scriptList.GetScriptTable(table, scriptIndex);
uint scriptTag = scriptList.GetScriptTag(table, scriptIndex);
ushort langSysCount = scriptTable.GetLangSysCount(table);
if (scriptTable.IsDefaultLangSysExists(table))
{
AppendLangSys(scriptTag, (uint)OpenTypeTags.dflt,
scriptTable.GetDefaultLangSysTable(table),
featureList,
table,
featureTagsList,
lookupBits,
ref complexLanguages,
ref complexLanguageCount
);
}
for(ushort langSysIndex = 0; langSysIndex < langSysCount; langSysIndex++)
{
uint langSysTag = scriptTable.GetLangSysTag(table, langSysIndex);
AppendLangSys(scriptTag, langSysTag,
scriptTable.GetLangSysTable(table, langSysIndex),
featureList,
table,
featureTagsList,
lookupBits,
ref complexLanguages,
ref complexLanguageCount
);
}
}
}
internal static bool ApplyLookup(
IOpenTypeFont Font, // Font access interface
OpenTypeTags TableTag, // Layout table tag (GSUB or GPOS)
FontTable Table, // Layout table (GSUB or GPOS)
LayoutMetrics Metrics, // LayoutMetrics
LookupTable Lookup, // List definition structure
int CharCount, // Characters count (i.e. Charmap.Length);
UshortList Charmap, // Char to glyph mapping
GlyphInfoList GlyphInfo, // List of GlyphInfo structs
int* Advances, // Glyph adv.widths
LayoutOffset* Offsets, // Glyph offsets
int FirstGlyph, // where to apply it
int AfterLastGlyph, // how long is a context we can use
uint Parameter, // lookup parameter
int nestingLevel, // Contextual lookup nesting level
out int NextGlyph // out: next glyph index
)
{
Debug.Assert(TableTag==OpenTypeTags.GSUB || TableTag==OpenTypeTags.GPOS);
Debug.Assert(FirstGlyph<AfterLastGlyph);
Debug.Assert(AfterLastGlyph<=GlyphInfo.Length);
ushort lookupType = Lookup.LookupType();
ushort lookupFlags = Lookup.LookupFlags();
ushort subtableCount = Lookup.SubTableCount();
bool match=false;
NextGlyph=FirstGlyph+1; //Just to avoid compiler error
// Find first glyph
if (!IsLookupReversal(TableTag,lookupType))
{
FirstGlyph=LayoutEngine.GetNextGlyphInLookup(Font,GlyphInfo,FirstGlyph,
lookupFlags,LayoutEngine.LookForward);
}
else
{
AfterLastGlyph = LayoutEngine.GetNextGlyphInLookup(Font,GlyphInfo,AfterLastGlyph-1,
lookupFlags,LayoutEngine.LookBackward) + 1;
}
if (FirstGlyph>=AfterLastGlyph) return match;
ushort originalLookupType = lookupType; // We need it to recover, if extension lookup updated lookupFormat
for(ushort subtableIndex=0; !match && subtableIndex < subtableCount; subtableIndex++)
{
lookupType = originalLookupType;
int subtableOffset = Lookup.SubtableOffset(Table, subtableIndex);
switch (TableTag)
{
case OpenTypeTags.GSUB:
{
if (lookupType == 7)
{
ExtensionLookupTable extension =
new ExtensionLookupTable(subtableOffset);
lookupType = extension.LookupType(Table);
subtableOffset = extension.LookupSubtableOffset(Table);
}
switch (lookupType)
{
case 1: //SingleSubst
SingleSubstitutionSubtable singleSub =
new SingleSubstitutionSubtable(subtableOffset);
match = singleSub.Apply( Table,
GlyphInfo,
FirstGlyph,
out NextGlyph
);
break;
case 2: //MultipleSubst
MultipleSubstitutionSubtable multipleSub =
new MultipleSubstitutionSubtable(subtableOffset);
match = multipleSub.Apply( Font,
Table,
CharCount,
Charmap,
GlyphInfo,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
out NextGlyph
);
break;
case 3: //AlternateSubst
AlternateSubstitutionSubtable alternateSub =
new AlternateSubstitutionSubtable(subtableOffset);
match = alternateSub.Apply( Table,
GlyphInfo,
Parameter,
FirstGlyph,
out NextGlyph
);
break;
case 4: //Ligature subst
LigatureSubstitutionSubtable ligaSub =
new LigatureSubstitutionSubtable(subtableOffset);
match = ligaSub.Apply( Font,
Table,
CharCount,
Charmap,
GlyphInfo,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
out NextGlyph
);
break;
case 5: //ContextualSubst
ContextSubtable contextSub =
new ContextSubtable(subtableOffset);
match = contextSub.Apply( Font,
TableTag,
Table,
Metrics,
CharCount,
Charmap,
GlyphInfo,
Advances,
Offsets,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
Parameter,
nestingLevel,
out NextGlyph
);
break;
case 6: //ChainingSubst
ChainingSubtable chainingSub =
new ChainingSubtable(subtableOffset);
match = chainingSub.Apply( Font,
TableTag,
Table,
Metrics,
CharCount,
Charmap,
GlyphInfo,
Advances,
Offsets,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
Parameter,
nestingLevel,
out NextGlyph
);
break;
case 7: //Extension lookup
// Ext.Lookup processed earlier. It can't contain another ext.lookups in it.
// Just skip it (do nothing);
NextGlyph = FirstGlyph + 1;
break;
case 8: //ReverseCahiningSubst
ReverseChainingSubtable reverseChainingSub =
new ReverseChainingSubtable(subtableOffset);
match = reverseChainingSub.Apply(
Font,
TableTag,
Table,
Metrics,
CharCount,
Charmap,
GlyphInfo,
Advances,
Offsets,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
Parameter,
out NextGlyph
);
break;
default:
// Unknown format
NextGlyph = FirstGlyph+1;
break;
}
if (match)
{
if (!IsLookupReversal(TableTag,lookupType))
{
UpdateGlyphFlags(Font,GlyphInfo,FirstGlyph,NextGlyph,true,GlyphFlags.Substituted);
}
else
{
UpdateGlyphFlags(Font,GlyphInfo,NextGlyph,AfterLastGlyph,true,GlyphFlags.Substituted);
}
}
break;
}
case OpenTypeTags.GPOS:
{
if (lookupType == 9)
{
ExtensionLookupTable extension =
new ExtensionLookupTable(subtableOffset);
lookupType = extension.LookupType(Table);
subtableOffset = extension.LookupSubtableOffset(Table);
}
switch (lookupType)
{
case 1: //SinglePos
SinglePositioningSubtable singlePos =
new SinglePositioningSubtable(subtableOffset);
match = singlePos.Apply(Table,
Metrics,
GlyphInfo,
Advances,
Offsets,
FirstGlyph,
AfterLastGlyph,
out NextGlyph
);
break;
case 2: //PairPos
PairPositioningSubtable pairPos =
new PairPositioningSubtable(subtableOffset);
match = pairPos.Apply( Font,
Table,
Metrics, // LayoutMetrics
GlyphInfo, // List of GlyphInfo structs
lookupFlags, // Lookup flags for glyph lookups
Advances, // Glyph adv.widths
Offsets, // Glyph offsets
FirstGlyph, // where to apply lookup
AfterLastGlyph, // how long is a context we can use
out NextGlyph // Next glyph to process
);
break;
case 3: // CursivePos
// Under construction
CursivePositioningSubtable cursivePositioningSubtable =
new CursivePositioningSubtable(subtableOffset);
cursivePositioningSubtable.Apply( Font,
Table,
Metrics, // LayoutMetrics
GlyphInfo, // List of GlyphInfo structs
lookupFlags, // Lookup flags for glyph lookups
Advances, // Glyph adv.widths
Offsets, // Glyph offsets
FirstGlyph, // where to apply lookup
AfterLastGlyph, // how long is a context we can use
out NextGlyph // Next glyph to process
);
break;
case 4: //MarkToBasePos
MarkToBasePositioningSubtable markToBasePos =
new MarkToBasePositioningSubtable(subtableOffset);
match = markToBasePos.Apply(Font,
Table,
Metrics, // LayoutMetrics
GlyphInfo, // List of GlyphInfo structs
lookupFlags, // Lookup flags for glyph lookups
Advances, // Glyph adv.widths
Offsets, // Glyph offsets
FirstGlyph, // where to apply lookup
AfterLastGlyph, // how long is a context we can use
out NextGlyph // Next glyph to process
);
break;
case 5: //MarkToLigaturePos
// Under construction
MarkToLigaturePositioningSubtable markToLigaPos =
new MarkToLigaturePositioningSubtable(subtableOffset);
match = markToLigaPos.Apply(
Font,
Table,
Metrics, // LayoutMetrics
GlyphInfo, // List of GlyphInfo structs
lookupFlags, // Lookup flags for glyph lookups
CharCount, // Characters count (i.e. Charmap.Length);
Charmap, // Char to glyph mapping
Advances, // Glyph adv.widths
Offsets, // Glyph offsets
FirstGlyph, // where to apply lookup
AfterLastGlyph, // how long is a context we can use
out NextGlyph // Next glyph to process
);
break;
case 6: //MarkToMarkPos
MarkToMarkPositioningSubtable markToMarkPos =
new MarkToMarkPositioningSubtable(subtableOffset);
match = markToMarkPos.Apply(
Font,
Table,
Metrics, // LayoutMetrics
GlyphInfo, // List of GlyphInfo structs
lookupFlags, // Lookup flags for glyph lookups
Advances, // Glyph adv.widths
Offsets, // Glyph offsets
FirstGlyph, // where to apply lookup
AfterLastGlyph, // how long is a context we can use
out NextGlyph // Next glyph to process
);
break;
case 7: // Contextual
ContextSubtable contextSub =
new ContextSubtable(subtableOffset);
match = contextSub.Apply( Font,
TableTag,
Table,
Metrics,
CharCount,
Charmap,
GlyphInfo,
Advances,
Offsets,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
Parameter,
nestingLevel,
out NextGlyph
);
break;
case 8: // Chaining
ChainingSubtable chainingSub =
new ChainingSubtable(subtableOffset);
match = chainingSub.Apply( Font,
TableTag,
Table,
Metrics,
CharCount,
Charmap,
GlyphInfo,
Advances,
Offsets,
lookupFlags,
FirstGlyph,
AfterLastGlyph,
Parameter,
nestingLevel,
out NextGlyph
);
break;
case 9: //Extension lookup
// Ext.Lookup processed earlier. It can't contain another ext.lookups in it.
// Just skip it (do nothing);
NextGlyph = FirstGlyph + 1;
break;
default:
// Unknown format
NextGlyph = FirstGlyph + 1;
break;
}
if (match)
{
UpdateGlyphFlags(Font,GlyphInfo,FirstGlyph,NextGlyph,false,GlyphFlags.Positioned);
}
break;
}
default:
Debug.Assert(false,"Unknown OpenType layout table!");
break;
}
}
return match;
}