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.
2251 lines
75 KiB
2251 lines
75 KiB
# Copyright 2013 Google, Inc. All Rights Reserved. |
|
# |
|
# Google Author(s): Behdad Esfahbod |
|
|
|
"""Python OpenType Layout Subsetter. |
|
|
|
Later grown into full OpenType subsetter, supporting all standard tables. |
|
""" |
|
|
|
from __future__ import print_function, division, absolute_import |
|
from fontTools.misc.py23 import * |
|
from fontTools import ttLib |
|
from fontTools.ttLib.tables import otTables |
|
from fontTools.misc import psCharStrings |
|
from fontTools.pens import basePen |
|
import sys |
|
import struct |
|
import time |
|
import array |
|
|
|
|
|
def _add_method(*clazzes): |
|
"""Returns a decorator function that adds a new method to one or |
|
more classes.""" |
|
def wrapper(method): |
|
for clazz in clazzes: |
|
assert clazz.__name__ != 'DefaultTable', 'Oops, table class not found.' |
|
assert not hasattr(clazz, method.__name__), \ |
|
"Oops, class '%s' has method '%s'." % (clazz.__name__, |
|
method.__name__) |
|
setattr(clazz, method.__name__, method) |
|
return None |
|
return wrapper |
|
|
|
def _uniq_sort(l): |
|
return sorted(set(l)) |
|
|
|
def _set_update(s, *others): |
|
# Jython's set.update only takes one other argument. |
|
# Emulate real set.update... |
|
for other in others: |
|
s.update(other) |
|
|
|
|
|
@_add_method(otTables.Coverage) |
|
def intersect(self, glyphs): |
|
"Returns ascending list of matching coverage values." |
|
return [i for i,g in enumerate(self.glyphs) if g in glyphs] |
|
|
|
@_add_method(otTables.Coverage) |
|
def intersect_glyphs(self, glyphs): |
|
"Returns set of intersecting glyphs." |
|
return set(g for g in self.glyphs if g in glyphs) |
|
|
|
@_add_method(otTables.Coverage) |
|
def subset(self, glyphs): |
|
"Returns ascending list of remaining coverage values." |
|
indices = self.intersect(glyphs) |
|
self.glyphs = [g for g in self.glyphs if g in glyphs] |
|
return indices |
|
|
|
@_add_method(otTables.Coverage) |
|
def remap(self, coverage_map): |
|
"Remaps coverage." |
|
self.glyphs = [self.glyphs[i] for i in coverage_map] |
|
|
|
@_add_method(otTables.ClassDef) |
|
def intersect(self, glyphs): |
|
"Returns ascending list of matching class values." |
|
return _uniq_sort( |
|
([0] if any(g not in self.classDefs for g in glyphs) else []) + |
|
[v for g,v in self.classDefs.items() if g in glyphs]) |
|
|
|
@_add_method(otTables.ClassDef) |
|
def intersect_class(self, glyphs, klass): |
|
"Returns set of glyphs matching class." |
|
if klass == 0: |
|
return set(g for g in glyphs if g not in self.classDefs) |
|
return set(g for g,v in self.classDefs.items() |
|
if v == klass and g in glyphs) |
|
|
|
@_add_method(otTables.ClassDef) |
|
def subset(self, glyphs, remap=False): |
|
"Returns ascending list of remaining classes." |
|
self.classDefs = dict((g,v) for g,v in self.classDefs.items() if g in glyphs) |
|
# Note: while class 0 has the special meaning of "not matched", |
|
# if no glyph will ever /not match/, we can optimize class 0 out too. |
|
indices = _uniq_sort( |
|
([0] if any(g not in self.classDefs for g in glyphs) else []) + |
|
list(self.classDefs.values())) |
|
if remap: |
|
self.remap(indices) |
|
return indices |
|
|
|
@_add_method(otTables.ClassDef) |
|
def remap(self, class_map): |
|
"Remaps classes." |
|
self.classDefs = dict((g,class_map.index(v)) |
|
for g,v in self.classDefs.items()) |
|
|
|
@_add_method(otTables.SingleSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if cur_glyphs is None: cur_glyphs = s.glyphs |
|
s.glyphs.update(v for g,v in self.mapping.items() if g in cur_glyphs) |
|
|
|
@_add_method(otTables.SingleSubst) |
|
def subset_glyphs(self, s): |
|
self.mapping = dict((g,v) for g,v in self.mapping.items() |
|
if g in s.glyphs and v in s.glyphs) |
|
return bool(self.mapping) |
|
|
|
@_add_method(otTables.MultipleSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if cur_glyphs is None: cur_glyphs = s.glyphs |
|
indices = self.Coverage.intersect(cur_glyphs) |
|
_set_update(s.glyphs, *(self.Sequence[i].Substitute for i in indices)) |
|
|
|
@_add_method(otTables.MultipleSubst) |
|
def subset_glyphs(self, s): |
|
indices = self.Coverage.subset(s.glyphs) |
|
self.Sequence = [self.Sequence[i] for i in indices] |
|
# Now drop rules generating glyphs we don't want |
|
indices = [i for i,seq in enumerate(self.Sequence) |
|
if all(sub in s.glyphs for sub in seq.Substitute)] |
|
self.Sequence = [self.Sequence[i] for i in indices] |
|
self.Coverage.remap(indices) |
|
self.SequenceCount = len(self.Sequence) |
|
return bool(self.SequenceCount) |
|
|
|
@_add_method(otTables.AlternateSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if cur_glyphs is None: cur_glyphs = s.glyphs |
|
_set_update(s.glyphs, *(vlist for g,vlist in self.alternates.items() |
|
if g in cur_glyphs)) |
|
|
|
@_add_method(otTables.AlternateSubst) |
|
def subset_glyphs(self, s): |
|
self.alternates = dict((g,vlist) |
|
for g,vlist in self.alternates.items() |
|
if g in s.glyphs and |
|
all(v in s.glyphs for v in vlist)) |
|
return bool(self.alternates) |
|
|
|
@_add_method(otTables.LigatureSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if cur_glyphs is None: cur_glyphs = s.glyphs |
|
_set_update(s.glyphs, *([seq.LigGlyph for seq in seqs |
|
if all(c in s.glyphs for c in seq.Component)] |
|
for g,seqs in self.ligatures.items() |
|
if g in cur_glyphs)) |
|
|
|
@_add_method(otTables.LigatureSubst) |
|
def subset_glyphs(self, s): |
|
self.ligatures = dict((g,v) for g,v in self.ligatures.items() |
|
if g in s.glyphs) |
|
self.ligatures = dict((g,[seq for seq in seqs |
|
if seq.LigGlyph in s.glyphs and |
|
all(c in s.glyphs for c in seq.Component)]) |
|
for g,seqs in self.ligatures.items()) |
|
self.ligatures = dict((g,v) for g,v in self.ligatures.items() if v) |
|
return bool(self.ligatures) |
|
|
|
@_add_method(otTables.ReverseChainSingleSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if cur_glyphs is None: cur_glyphs = s.glyphs |
|
if self.Format == 1: |
|
indices = self.Coverage.intersect(cur_glyphs) |
|
if(not indices or |
|
not all(c.intersect(s.glyphs) |
|
for c in self.LookAheadCoverage + self.BacktrackCoverage)): |
|
return |
|
s.glyphs.update(self.Substitute[i] for i in indices) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ReverseChainSingleSubst) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
indices = self.Coverage.subset(s.glyphs) |
|
self.Substitute = [self.Substitute[i] for i in indices] |
|
# Now drop rules generating glyphs we don't want |
|
indices = [i for i,sub in enumerate(self.Substitute) |
|
if sub in s.glyphs] |
|
self.Substitute = [self.Substitute[i] for i in indices] |
|
self.Coverage.remap(indices) |
|
self.GlyphCount = len(self.Substitute) |
|
return bool(self.GlyphCount and |
|
all(c.subset(s.glyphs) |
|
for c in self.LookAheadCoverage+self.BacktrackCoverage)) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.SinglePos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
return len(self.Coverage.subset(s.glyphs)) |
|
elif self.Format == 2: |
|
indices = self.Coverage.subset(s.glyphs) |
|
self.Value = [self.Value[i] for i in indices] |
|
self.ValueCount = len(self.Value) |
|
return bool(self.ValueCount) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.SinglePos) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
# Drop device tables |
|
self.ValueFormat &= ~0x00F0 |
|
return True |
|
|
|
@_add_method(otTables.PairPos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
indices = self.Coverage.subset(s.glyphs) |
|
self.PairSet = [self.PairSet[i] for i in indices] |
|
for p in self.PairSet: |
|
p.PairValueRecord = [r for r in p.PairValueRecord |
|
if r.SecondGlyph in s.glyphs] |
|
p.PairValueCount = len(p.PairValueRecord) |
|
# Remove empty pairsets |
|
indices = [i for i,p in enumerate(self.PairSet) if p.PairValueCount] |
|
self.Coverage.remap(indices) |
|
self.PairSet = [self.PairSet[i] for i in indices] |
|
self.PairSetCount = len(self.PairSet) |
|
return bool(self.PairSetCount) |
|
elif self.Format == 2: |
|
class1_map = self.ClassDef1.subset(s.glyphs, remap=True) |
|
class2_map = self.ClassDef2.subset(s.glyphs, remap=True) |
|
self.Class1Record = [self.Class1Record[i] for i in class1_map] |
|
for c in self.Class1Record: |
|
c.Class2Record = [c.Class2Record[i] for i in class2_map] |
|
self.Class1Count = len(class1_map) |
|
self.Class2Count = len(class2_map) |
|
return bool(self.Class1Count and |
|
self.Class2Count and |
|
self.Coverage.subset(s.glyphs)) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.PairPos) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
# Drop device tables |
|
self.ValueFormat1 &= ~0x00F0 |
|
self.ValueFormat2 &= ~0x00F0 |
|
return True |
|
|
|
@_add_method(otTables.CursivePos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
indices = self.Coverage.subset(s.glyphs) |
|
self.EntryExitRecord = [self.EntryExitRecord[i] for i in indices] |
|
self.EntryExitCount = len(self.EntryExitRecord) |
|
return bool(self.EntryExitCount) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.Anchor) |
|
def prune_hints(self): |
|
# Drop device tables / contour anchor point |
|
self.ensureDecompiled() |
|
self.Format = 1 |
|
|
|
@_add_method(otTables.CursivePos) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
for rec in self.EntryExitRecord: |
|
if rec.EntryAnchor: rec.EntryAnchor.prune_hints() |
|
if rec.ExitAnchor: rec.ExitAnchor.prune_hints() |
|
return True |
|
|
|
@_add_method(otTables.MarkBasePos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
mark_indices = self.MarkCoverage.subset(s.glyphs) |
|
self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i] |
|
for i in mark_indices] |
|
self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord) |
|
base_indices = self.BaseCoverage.subset(s.glyphs) |
|
self.BaseArray.BaseRecord = [self.BaseArray.BaseRecord[i] |
|
for i in base_indices] |
|
self.BaseArray.BaseCount = len(self.BaseArray.BaseRecord) |
|
# Prune empty classes |
|
class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord) |
|
self.ClassCount = len(class_indices) |
|
for m in self.MarkArray.MarkRecord: |
|
m.Class = class_indices.index(m.Class) |
|
for b in self.BaseArray.BaseRecord: |
|
b.BaseAnchor = [b.BaseAnchor[i] for i in class_indices] |
|
return bool(self.ClassCount and |
|
self.MarkArray.MarkCount and |
|
self.BaseArray.BaseCount) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.MarkBasePos) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
for m in self.MarkArray.MarkRecord: |
|
if m.MarkAnchor: |
|
m.MarkAnchor.prune_hints() |
|
for b in self.BaseArray.BaseRecord: |
|
for a in b.BaseAnchor: |
|
if a: |
|
a.prune_hints() |
|
return True |
|
|
|
@_add_method(otTables.MarkLigPos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
mark_indices = self.MarkCoverage.subset(s.glyphs) |
|
self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i] |
|
for i in mark_indices] |
|
self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord) |
|
ligature_indices = self.LigatureCoverage.subset(s.glyphs) |
|
self.LigatureArray.LigatureAttach = [self.LigatureArray.LigatureAttach[i] |
|
for i in ligature_indices] |
|
self.LigatureArray.LigatureCount = len(self.LigatureArray.LigatureAttach) |
|
# Prune empty classes |
|
class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord) |
|
self.ClassCount = len(class_indices) |
|
for m in self.MarkArray.MarkRecord: |
|
m.Class = class_indices.index(m.Class) |
|
for l in self.LigatureArray.LigatureAttach: |
|
for c in l.ComponentRecord: |
|
c.LigatureAnchor = [c.LigatureAnchor[i] for i in class_indices] |
|
return bool(self.ClassCount and |
|
self.MarkArray.MarkCount and |
|
self.LigatureArray.LigatureCount) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.MarkLigPos) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
for m in self.MarkArray.MarkRecord: |
|
if m.MarkAnchor: |
|
m.MarkAnchor.prune_hints() |
|
for l in self.LigatureArray.LigatureAttach: |
|
for c in l.ComponentRecord: |
|
for a in c.LigatureAnchor: |
|
if a: |
|
a.prune_hints() |
|
return True |
|
|
|
@_add_method(otTables.MarkMarkPos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
mark1_indices = self.Mark1Coverage.subset(s.glyphs) |
|
self.Mark1Array.MarkRecord = [self.Mark1Array.MarkRecord[i] |
|
for i in mark1_indices] |
|
self.Mark1Array.MarkCount = len(self.Mark1Array.MarkRecord) |
|
mark2_indices = self.Mark2Coverage.subset(s.glyphs) |
|
self.Mark2Array.Mark2Record = [self.Mark2Array.Mark2Record[i] |
|
for i in mark2_indices] |
|
self.Mark2Array.MarkCount = len(self.Mark2Array.Mark2Record) |
|
# Prune empty classes |
|
class_indices = _uniq_sort(v.Class for v in self.Mark1Array.MarkRecord) |
|
self.ClassCount = len(class_indices) |
|
for m in self.Mark1Array.MarkRecord: |
|
m.Class = class_indices.index(m.Class) |
|
for b in self.Mark2Array.Mark2Record: |
|
b.Mark2Anchor = [b.Mark2Anchor[i] for i in class_indices] |
|
return bool(self.ClassCount and |
|
self.Mark1Array.MarkCount and |
|
self.Mark2Array.MarkCount) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.MarkMarkPos) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
# Drop device tables or contour anchor point |
|
for m in self.Mark1Array.MarkRecord: |
|
if m.MarkAnchor: |
|
m.MarkAnchor.prune_hints() |
|
for b in self.Mark2Array.Mark2Record: |
|
for m in b.Mark2Anchor: |
|
if m: |
|
m.prune_hints() |
|
return True |
|
|
|
@_add_method(otTables.SingleSubst, |
|
otTables.MultipleSubst, |
|
otTables.AlternateSubst, |
|
otTables.LigatureSubst, |
|
otTables.ReverseChainSingleSubst, |
|
otTables.SinglePos, |
|
otTables.PairPos, |
|
otTables.CursivePos, |
|
otTables.MarkBasePos, |
|
otTables.MarkLigPos, |
|
otTables.MarkMarkPos) |
|
def subset_lookups(self, lookup_indices): |
|
pass |
|
|
|
@_add_method(otTables.SingleSubst, |
|
otTables.MultipleSubst, |
|
otTables.AlternateSubst, |
|
otTables.LigatureSubst, |
|
otTables.ReverseChainSingleSubst, |
|
otTables.SinglePos, |
|
otTables.PairPos, |
|
otTables.CursivePos, |
|
otTables.MarkBasePos, |
|
otTables.MarkLigPos, |
|
otTables.MarkMarkPos) |
|
def collect_lookups(self): |
|
return [] |
|
|
|
@_add_method(otTables.SingleSubst, |
|
otTables.MultipleSubst, |
|
otTables.AlternateSubst, |
|
otTables.LigatureSubst, |
|
otTables.ContextSubst, |
|
otTables.ChainContextSubst, |
|
otTables.ReverseChainSingleSubst, |
|
otTables.SinglePos, |
|
otTables.PairPos, |
|
otTables.CursivePos, |
|
otTables.MarkBasePos, |
|
otTables.MarkLigPos, |
|
otTables.MarkMarkPos, |
|
otTables.ContextPos, |
|
otTables.ChainContextPos) |
|
def prune_pre_subset(self, options): |
|
return True |
|
|
|
@_add_method(otTables.SingleSubst, |
|
otTables.MultipleSubst, |
|
otTables.AlternateSubst, |
|
otTables.LigatureSubst, |
|
otTables.ReverseChainSingleSubst, |
|
otTables.ContextSubst, |
|
otTables.ChainContextSubst, |
|
otTables.ContextPos, |
|
otTables.ChainContextPos) |
|
def prune_post_subset(self, options): |
|
return True |
|
|
|
@_add_method(otTables.SingleSubst, |
|
otTables.AlternateSubst, |
|
otTables.ReverseChainSingleSubst) |
|
def may_have_non_1to1(self): |
|
return False |
|
|
|
@_add_method(otTables.MultipleSubst, |
|
otTables.LigatureSubst, |
|
otTables.ContextSubst, |
|
otTables.ChainContextSubst) |
|
def may_have_non_1to1(self): |
|
return True |
|
|
|
@_add_method(otTables.ContextSubst, |
|
otTables.ChainContextSubst, |
|
otTables.ContextPos, |
|
otTables.ChainContextPos) |
|
def __classify_context(self): |
|
|
|
class ContextHelper(object): |
|
def __init__(self, klass, Format): |
|
if klass.__name__.endswith('Subst'): |
|
Typ = 'Sub' |
|
Type = 'Subst' |
|
else: |
|
Typ = 'Pos' |
|
Type = 'Pos' |
|
if klass.__name__.startswith('Chain'): |
|
Chain = 'Chain' |
|
else: |
|
Chain = '' |
|
ChainTyp = Chain+Typ |
|
|
|
self.Typ = Typ |
|
self.Type = Type |
|
self.Chain = Chain |
|
self.ChainTyp = ChainTyp |
|
|
|
self.LookupRecord = Type+'LookupRecord' |
|
|
|
if Format == 1: |
|
Coverage = lambda r: r.Coverage |
|
ChainCoverage = lambda r: r.Coverage |
|
ContextData = lambda r:(None,) |
|
ChainContextData = lambda r:(None, None, None) |
|
RuleData = lambda r:(r.Input,) |
|
ChainRuleData = lambda r:(r.Backtrack, r.Input, r.LookAhead) |
|
SetRuleData = None |
|
ChainSetRuleData = None |
|
elif Format == 2: |
|
Coverage = lambda r: r.Coverage |
|
ChainCoverage = lambda r: r.Coverage |
|
ContextData = lambda r:(r.ClassDef,) |
|
ChainContextData = lambda r:(r.LookAheadClassDef, |
|
r.InputClassDef, |
|
r.BacktrackClassDef) |
|
RuleData = lambda r:(r.Class,) |
|
ChainRuleData = lambda r:(r.LookAhead, r.Input, r.Backtrack) |
|
def SetRuleData(r, d):(r.Class,) = d |
|
def ChainSetRuleData(r, d):(r.LookAhead, r.Input, r.Backtrack) = d |
|
elif Format == 3: |
|
Coverage = lambda r: r.Coverage[0] |
|
ChainCoverage = lambda r: r.InputCoverage[0] |
|
ContextData = None |
|
ChainContextData = None |
|
RuleData = lambda r: r.Coverage |
|
ChainRuleData = lambda r:(r.LookAheadCoverage + |
|
r.InputCoverage + |
|
r.BacktrackCoverage) |
|
SetRuleData = None |
|
ChainSetRuleData = None |
|
else: |
|
assert 0, "unknown format: %s" % Format |
|
|
|
if Chain: |
|
self.Coverage = ChainCoverage |
|
self.ContextData = ChainContextData |
|
self.RuleData = ChainRuleData |
|
self.SetRuleData = ChainSetRuleData |
|
else: |
|
self.Coverage = Coverage |
|
self.ContextData = ContextData |
|
self.RuleData = RuleData |
|
self.SetRuleData = SetRuleData |
|
|
|
if Format == 1: |
|
self.Rule = ChainTyp+'Rule' |
|
self.RuleCount = ChainTyp+'RuleCount' |
|
self.RuleSet = ChainTyp+'RuleSet' |
|
self.RuleSetCount = ChainTyp+'RuleSetCount' |
|
self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else [] |
|
elif Format == 2: |
|
self.Rule = ChainTyp+'ClassRule' |
|
self.RuleCount = ChainTyp+'ClassRuleCount' |
|
self.RuleSet = ChainTyp+'ClassSet' |
|
self.RuleSetCount = ChainTyp+'ClassSetCount' |
|
self.Intersect = lambda glyphs, c, r: c.intersect_class(glyphs, r) |
|
|
|
self.ClassDef = 'InputClassDef' if Chain else 'ClassDef' |
|
self.ClassDefIndex = 1 if Chain else 0 |
|
self.Input = 'Input' if Chain else 'Class' |
|
|
|
if self.Format not in [1, 2, 3]: |
|
return None # Don't shoot the messenger; let it go |
|
if not hasattr(self.__class__, "__ContextHelpers"): |
|
self.__class__.__ContextHelpers = {} |
|
if self.Format not in self.__class__.__ContextHelpers: |
|
helper = ContextHelper(self.__class__, self.Format) |
|
self.__class__.__ContextHelpers[self.Format] = helper |
|
return self.__class__.__ContextHelpers[self.Format] |
|
|
|
@_add_method(otTables.ContextSubst, |
|
otTables.ChainContextSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if cur_glyphs is None: cur_glyphs = s.glyphs |
|
c = self.__classify_context() |
|
|
|
indices = c.Coverage(self).intersect(s.glyphs) |
|
if not indices: |
|
return [] |
|
cur_glyphs = c.Coverage(self).intersect_glyphs(s.glyphs); |
|
|
|
if self.Format == 1: |
|
ContextData = c.ContextData(self) |
|
rss = getattr(self, c.RuleSet) |
|
rssCount = getattr(self, c.RuleSetCount) |
|
for i in indices: |
|
if i >= rssCount or not rss[i]: continue |
|
for r in getattr(rss[i], c.Rule): |
|
if not r: continue |
|
if all(all(c.Intersect(s.glyphs, cd, k) for k in klist) |
|
for cd,klist in zip(ContextData, c.RuleData(r))): |
|
chaos = False |
|
for ll in getattr(r, c.LookupRecord): |
|
if not ll: continue |
|
seqi = ll.SequenceIndex |
|
if chaos: |
|
pos_glyphs = s.glyphs |
|
else: |
|
if seqi == 0: |
|
pos_glyphs = set([c.Coverage(self).glyphs[i]]) |
|
else: |
|
pos_glyphs = set([r.Input[seqi - 1]]) |
|
lookup = s.table.LookupList.Lookup[ll.LookupListIndex] |
|
chaos = chaos or lookup.may_have_non_1to1() |
|
lookup.closure_glyphs(s, cur_glyphs=pos_glyphs) |
|
elif self.Format == 2: |
|
ClassDef = getattr(self, c.ClassDef) |
|
indices = ClassDef.intersect(cur_glyphs) |
|
ContextData = c.ContextData(self) |
|
rss = getattr(self, c.RuleSet) |
|
rssCount = getattr(self, c.RuleSetCount) |
|
for i in indices: |
|
if i >= rssCount or not rss[i]: continue |
|
for r in getattr(rss[i], c.Rule): |
|
if not r: continue |
|
if all(all(c.Intersect(s.glyphs, cd, k) for k in klist) |
|
for cd,klist in zip(ContextData, c.RuleData(r))): |
|
chaos = False |
|
for ll in getattr(r, c.LookupRecord): |
|
if not ll: continue |
|
seqi = ll.SequenceIndex |
|
if chaos: |
|
pos_glyphs = s.glyphs |
|
else: |
|
if seqi == 0: |
|
pos_glyphs = ClassDef.intersect_class(cur_glyphs, i) |
|
else: |
|
pos_glyphs = ClassDef.intersect_class(s.glyphs, |
|
getattr(r, c.Input)[seqi - 1]) |
|
lookup = s.table.LookupList.Lookup[ll.LookupListIndex] |
|
chaos = chaos or lookup.may_have_non_1to1() |
|
lookup.closure_glyphs(s, cur_glyphs=pos_glyphs) |
|
elif self.Format == 3: |
|
if not all(x.intersect(s.glyphs) for x in c.RuleData(self)): |
|
return [] |
|
r = self |
|
chaos = False |
|
for ll in getattr(r, c.LookupRecord): |
|
if not ll: continue |
|
seqi = ll.SequenceIndex |
|
if chaos: |
|
pos_glyphs = s.glyphs |
|
else: |
|
if seqi == 0: |
|
pos_glyphs = cur_glyphs |
|
else: |
|
pos_glyphs = r.InputCoverage[seqi].intersect_glyphs(s.glyphs) |
|
lookup = s.table.LookupList.Lookup[ll.LookupListIndex] |
|
chaos = chaos or lookup.may_have_non_1to1() |
|
lookup.closure_glyphs(s, cur_glyphs=pos_glyphs) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ContextSubst, |
|
otTables.ContextPos, |
|
otTables.ChainContextSubst, |
|
otTables.ChainContextPos) |
|
def subset_glyphs(self, s): |
|
c = self.__classify_context() |
|
|
|
if self.Format == 1: |
|
indices = self.Coverage.subset(s.glyphs) |
|
rss = getattr(self, c.RuleSet) |
|
rss = [rss[i] for i in indices] |
|
for rs in rss: |
|
if not rs: continue |
|
ss = getattr(rs, c.Rule) |
|
ss = [r for r in ss |
|
if r and all(all(g in s.glyphs for g in glist) |
|
for glist in c.RuleData(r))] |
|
setattr(rs, c.Rule, ss) |
|
setattr(rs, c.RuleCount, len(ss)) |
|
# Prune empty subrulesets |
|
rss = [rs for rs in rss if rs and getattr(rs, c.Rule)] |
|
setattr(self, c.RuleSet, rss) |
|
setattr(self, c.RuleSetCount, len(rss)) |
|
return bool(rss) |
|
elif self.Format == 2: |
|
if not self.Coverage.subset(s.glyphs): |
|
return False |
|
ContextData = c.ContextData(self) |
|
klass_maps = [x.subset(s.glyphs, remap=True) for x in ContextData] |
|
|
|
# Keep rulesets for class numbers that survived. |
|
indices = klass_maps[c.ClassDefIndex] |
|
rss = getattr(self, c.RuleSet) |
|
rssCount = getattr(self, c.RuleSetCount) |
|
rss = [rss[i] for i in indices if i < rssCount] |
|
del rssCount |
|
# Delete, but not renumber, unreachable rulesets. |
|
indices = getattr(self, c.ClassDef).intersect(self.Coverage.glyphs) |
|
rss = [rss if i in indices else None for i,rss in enumerate(rss)] |
|
while rss and rss[-1] is None: |
|
del rss[-1] |
|
|
|
for rs in rss: |
|
if not rs: continue |
|
ss = getattr(rs, c.Rule) |
|
ss = [r for r in ss |
|
if r and all(all(k in klass_map for k in klist) |
|
for klass_map,klist in zip(klass_maps, c.RuleData(r)))] |
|
setattr(rs, c.Rule, ss) |
|
setattr(rs, c.RuleCount, len(ss)) |
|
|
|
# Remap rule classes |
|
for r in ss: |
|
c.SetRuleData(r, [[klass_map.index(k) for k in klist] |
|
for klass_map,klist in zip(klass_maps, c.RuleData(r))]) |
|
return bool(rss) |
|
elif self.Format == 3: |
|
return all(x.subset(s.glyphs) for x in c.RuleData(self)) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ContextSubst, |
|
otTables.ChainContextSubst, |
|
otTables.ContextPos, |
|
otTables.ChainContextPos) |
|
def subset_lookups(self, lookup_indices): |
|
c = self.__classify_context() |
|
|
|
if self.Format in [1, 2]: |
|
for rs in getattr(self, c.RuleSet): |
|
if not rs: continue |
|
for r in getattr(rs, c.Rule): |
|
if not r: continue |
|
setattr(r, c.LookupRecord, |
|
[ll for ll in getattr(r, c.LookupRecord) |
|
if ll and ll.LookupListIndex in lookup_indices]) |
|
for ll in getattr(r, c.LookupRecord): |
|
if not ll: continue |
|
ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex) |
|
elif self.Format == 3: |
|
setattr(self, c.LookupRecord, |
|
[ll for ll in getattr(self, c.LookupRecord) |
|
if ll and ll.LookupListIndex in lookup_indices]) |
|
for ll in getattr(self, c.LookupRecord): |
|
if not ll: continue |
|
ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ContextSubst, |
|
otTables.ChainContextSubst, |
|
otTables.ContextPos, |
|
otTables.ChainContextPos) |
|
def collect_lookups(self): |
|
c = self.__classify_context() |
|
|
|
if self.Format in [1, 2]: |
|
return [ll.LookupListIndex |
|
for rs in getattr(self, c.RuleSet) if rs |
|
for r in getattr(rs, c.Rule) if r |
|
for ll in getattr(r, c.LookupRecord) if ll] |
|
elif self.Format == 3: |
|
return [ll.LookupListIndex |
|
for ll in getattr(self, c.LookupRecord) if ll] |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
if self.Format == 1: |
|
self.ExtSubTable.closure_glyphs(s, cur_glyphs) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst) |
|
def may_have_non_1to1(self): |
|
if self.Format == 1: |
|
return self.ExtSubTable.may_have_non_1to1() |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst, |
|
otTables.ExtensionPos) |
|
def prune_pre_subset(self, options): |
|
if self.Format == 1: |
|
return self.ExtSubTable.prune_pre_subset(options) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst, |
|
otTables.ExtensionPos) |
|
def subset_glyphs(self, s): |
|
if self.Format == 1: |
|
return self.ExtSubTable.subset_glyphs(s) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst, |
|
otTables.ExtensionPos) |
|
def prune_post_subset(self, options): |
|
if self.Format == 1: |
|
return self.ExtSubTable.prune_post_subset(options) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst, |
|
otTables.ExtensionPos) |
|
def subset_lookups(self, lookup_indices): |
|
if self.Format == 1: |
|
return self.ExtSubTable.subset_lookups(lookup_indices) |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.ExtensionSubst, |
|
otTables.ExtensionPos) |
|
def collect_lookups(self): |
|
if self.Format == 1: |
|
return self.ExtSubTable.collect_lookups() |
|
else: |
|
assert 0, "unknown format: %s" % self.Format |
|
|
|
@_add_method(otTables.Lookup) |
|
def closure_glyphs(self, s, cur_glyphs=None): |
|
for st in self.SubTable: |
|
if not st: continue |
|
st.closure_glyphs(s, cur_glyphs) |
|
|
|
@_add_method(otTables.Lookup) |
|
def prune_pre_subset(self, options): |
|
ret = False |
|
for st in self.SubTable: |
|
if not st: continue |
|
if st.prune_pre_subset(options): ret = True |
|
return ret |
|
|
|
@_add_method(otTables.Lookup) |
|
def subset_glyphs(self, s): |
|
self.SubTable = [st for st in self.SubTable if st and st.subset_glyphs(s)] |
|
self.SubTableCount = len(self.SubTable) |
|
return bool(self.SubTableCount) |
|
|
|
@_add_method(otTables.Lookup) |
|
def prune_post_subset(self, options): |
|
ret = False |
|
for st in self.SubTable: |
|
if not st: continue |
|
if st.prune_post_subset(options): ret = True |
|
return ret |
|
|
|
@_add_method(otTables.Lookup) |
|
def subset_lookups(self, lookup_indices): |
|
for s in self.SubTable: |
|
s.subset_lookups(lookup_indices) |
|
|
|
@_add_method(otTables.Lookup) |
|
def collect_lookups(self): |
|
return _uniq_sort(sum((st.collect_lookups() for st in self.SubTable |
|
if st), [])) |
|
|
|
@_add_method(otTables.Lookup) |
|
def may_have_non_1to1(self): |
|
return any(st.may_have_non_1to1() for st in self.SubTable if st) |
|
|
|
@_add_method(otTables.LookupList) |
|
def prune_pre_subset(self, options): |
|
ret = False |
|
for l in self.Lookup: |
|
if not l: continue |
|
if l.prune_pre_subset(options): ret = True |
|
return ret |
|
|
|
@_add_method(otTables.LookupList) |
|
def subset_glyphs(self, s): |
|
"Returns the indices of nonempty lookups." |
|
return [i for i,l in enumerate(self.Lookup) if l and l.subset_glyphs(s)] |
|
|
|
@_add_method(otTables.LookupList) |
|
def prune_post_subset(self, options): |
|
ret = False |
|
for l in self.Lookup: |
|
if not l: continue |
|
if l.prune_post_subset(options): ret = True |
|
return ret |
|
|
|
@_add_method(otTables.LookupList) |
|
def subset_lookups(self, lookup_indices): |
|
self.ensureDecompiled() |
|
self.Lookup = [self.Lookup[i] for i in lookup_indices |
|
if i < self.LookupCount] |
|
self.LookupCount = len(self.Lookup) |
|
for l in self.Lookup: |
|
l.subset_lookups(lookup_indices) |
|
|
|
@_add_method(otTables.LookupList) |
|
def closure_lookups(self, lookup_indices): |
|
lookup_indices = _uniq_sort(lookup_indices) |
|
recurse = lookup_indices |
|
while True: |
|
recurse_lookups = sum((self.Lookup[i].collect_lookups() |
|
for i in recurse if i < self.LookupCount), []) |
|
recurse_lookups = [l for l in recurse_lookups |
|
if l not in lookup_indices and l < self.LookupCount] |
|
if not recurse_lookups: |
|
return _uniq_sort(lookup_indices) |
|
recurse_lookups = _uniq_sort(recurse_lookups) |
|
lookup_indices.extend(recurse_lookups) |
|
recurse = recurse_lookups |
|
|
|
@_add_method(otTables.Feature) |
|
def subset_lookups(self, lookup_indices): |
|
self.LookupListIndex = [l for l in self.LookupListIndex |
|
if l in lookup_indices] |
|
# Now map them. |
|
self.LookupListIndex = [lookup_indices.index(l) |
|
for l in self.LookupListIndex] |
|
self.LookupCount = len(self.LookupListIndex) |
|
return self.LookupCount or self.FeatureParams |
|
|
|
@_add_method(otTables.Feature) |
|
def collect_lookups(self): |
|
return self.LookupListIndex[:] |
|
|
|
@_add_method(otTables.FeatureList) |
|
def subset_lookups(self, lookup_indices): |
|
"Returns the indices of nonempty features." |
|
# Note: Never ever drop feature 'pref', even if it's empty. |
|
# HarfBuzz chooses shaper for Khmer based on presence of this |
|
# feature. See thread at: |
|
# http://lists.freedesktop.org/archives/harfbuzz/2012-November/002660.html |
|
feature_indices = [i for i,f in enumerate(self.FeatureRecord) |
|
if (f.Feature.subset_lookups(lookup_indices) or |
|
f.FeatureTag == 'pref')] |
|
self.subset_features(feature_indices) |
|
return feature_indices |
|
|
|
@_add_method(otTables.FeatureList) |
|
def collect_lookups(self, feature_indices): |
|
return _uniq_sort(sum((self.FeatureRecord[i].Feature.collect_lookups() |
|
for i in feature_indices |
|
if i < self.FeatureCount), [])) |
|
|
|
@_add_method(otTables.FeatureList) |
|
def subset_features(self, feature_indices): |
|
self.ensureDecompiled() |
|
self.FeatureRecord = [self.FeatureRecord[i] for i in feature_indices] |
|
self.FeatureCount = len(self.FeatureRecord) |
|
return bool(self.FeatureCount) |
|
|
|
@_add_method(otTables.DefaultLangSys, |
|
otTables.LangSys) |
|
def subset_features(self, feature_indices): |
|
if self.ReqFeatureIndex in feature_indices: |
|
self.ReqFeatureIndex = feature_indices.index(self.ReqFeatureIndex) |
|
else: |
|
self.ReqFeatureIndex = 65535 |
|
self.FeatureIndex = [f for f in self.FeatureIndex if f in feature_indices] |
|
# Now map them. |
|
self.FeatureIndex = [feature_indices.index(f) for f in self.FeatureIndex |
|
if f in feature_indices] |
|
self.FeatureCount = len(self.FeatureIndex) |
|
return bool(self.FeatureCount or self.ReqFeatureIndex != 65535) |
|
|
|
@_add_method(otTables.DefaultLangSys, |
|
otTables.LangSys) |
|
def collect_features(self): |
|
feature_indices = self.FeatureIndex[:] |
|
if self.ReqFeatureIndex != 65535: |
|
feature_indices.append(self.ReqFeatureIndex) |
|
return _uniq_sort(feature_indices) |
|
|
|
@_add_method(otTables.Script) |
|
def subset_features(self, feature_indices): |
|
if(self.DefaultLangSys and |
|
not self.DefaultLangSys.subset_features(feature_indices)): |
|
self.DefaultLangSys = None |
|
self.LangSysRecord = [l for l in self.LangSysRecord |
|
if l.LangSys.subset_features(feature_indices)] |
|
self.LangSysCount = len(self.LangSysRecord) |
|
return bool(self.LangSysCount or self.DefaultLangSys) |
|
|
|
@_add_method(otTables.Script) |
|
def collect_features(self): |
|
feature_indices = [l.LangSys.collect_features() for l in self.LangSysRecord] |
|
if self.DefaultLangSys: |
|
feature_indices.append(self.DefaultLangSys.collect_features()) |
|
return _uniq_sort(sum(feature_indices, [])) |
|
|
|
@_add_method(otTables.ScriptList) |
|
def subset_features(self, feature_indices): |
|
self.ScriptRecord = [s for s in self.ScriptRecord |
|
if s.Script.subset_features(feature_indices)] |
|
self.ScriptCount = len(self.ScriptRecord) |
|
return bool(self.ScriptCount) |
|
|
|
@_add_method(otTables.ScriptList) |
|
def collect_features(self): |
|
return _uniq_sort(sum((s.Script.collect_features() |
|
for s in self.ScriptRecord), [])) |
|
|
|
@_add_method(ttLib.getTableClass('GSUB')) |
|
def closure_glyphs(self, s): |
|
s.table = self.table |
|
if self.table.ScriptList: |
|
feature_indices = self.table.ScriptList.collect_features() |
|
else: |
|
feature_indices = [] |
|
if self.table.FeatureList: |
|
lookup_indices = self.table.FeatureList.collect_lookups(feature_indices) |
|
else: |
|
lookup_indices = [] |
|
if self.table.LookupList: |
|
while True: |
|
orig_glyphs = s.glyphs.copy() |
|
for i in lookup_indices: |
|
if i >= self.table.LookupList.LookupCount: continue |
|
if not self.table.LookupList.Lookup[i]: continue |
|
self.table.LookupList.Lookup[i].closure_glyphs(s) |
|
if orig_glyphs == s.glyphs: |
|
break |
|
del s.table |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def subset_glyphs(self, s): |
|
s.glyphs = s.glyphs_gsubed |
|
if self.table.LookupList: |
|
lookup_indices = self.table.LookupList.subset_glyphs(s) |
|
else: |
|
lookup_indices = [] |
|
self.subset_lookups(lookup_indices) |
|
self.prune_lookups() |
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def subset_lookups(self, lookup_indices): |
|
"""Retains specified lookups, then removes empty features, language |
|
systems, and scripts.""" |
|
if self.table.LookupList: |
|
self.table.LookupList.subset_lookups(lookup_indices) |
|
if self.table.FeatureList: |
|
feature_indices = self.table.FeatureList.subset_lookups(lookup_indices) |
|
else: |
|
feature_indices = [] |
|
if self.table.ScriptList: |
|
self.table.ScriptList.subset_features(feature_indices) |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def prune_lookups(self): |
|
"Remove unreferenced lookups" |
|
if self.table.ScriptList: |
|
feature_indices = self.table.ScriptList.collect_features() |
|
else: |
|
feature_indices = [] |
|
if self.table.FeatureList: |
|
lookup_indices = self.table.FeatureList.collect_lookups(feature_indices) |
|
else: |
|
lookup_indices = [] |
|
if self.table.LookupList: |
|
lookup_indices = self.table.LookupList.closure_lookups(lookup_indices) |
|
else: |
|
lookup_indices = [] |
|
self.subset_lookups(lookup_indices) |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def subset_feature_tags(self, feature_tags): |
|
if self.table.FeatureList: |
|
feature_indices = [i for i,f in |
|
enumerate(self.table.FeatureList.FeatureRecord) |
|
if f.FeatureTag in feature_tags] |
|
self.table.FeatureList.subset_features(feature_indices) |
|
else: |
|
feature_indices = [] |
|
if self.table.ScriptList: |
|
self.table.ScriptList.subset_features(feature_indices) |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def prune_features(self): |
|
"Remove unreferenced featurs" |
|
if self.table.ScriptList: |
|
feature_indices = self.table.ScriptList.collect_features() |
|
else: |
|
feature_indices = [] |
|
if self.table.FeatureList: |
|
self.table.FeatureList.subset_features(feature_indices) |
|
if self.table.ScriptList: |
|
self.table.ScriptList.subset_features(feature_indices) |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def prune_pre_subset(self, options): |
|
# Drop undesired features |
|
if '*' not in options.layout_features: |
|
self.subset_feature_tags(options.layout_features) |
|
# Drop unreferenced lookups |
|
self.prune_lookups() |
|
# Prune lookups themselves |
|
if self.table.LookupList: |
|
self.table.LookupList.prune_pre_subset(options); |
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def remove_redundant_langsys(self): |
|
table = self.table |
|
if not table.ScriptList or not table.FeatureList: |
|
return |
|
|
|
features = table.FeatureList.FeatureRecord |
|
|
|
for s in table.ScriptList.ScriptRecord: |
|
d = s.Script.DefaultLangSys |
|
if not d: |
|
continue |
|
for lr in s.Script.LangSysRecord[:]: |
|
l = lr.LangSys |
|
# Compare d and l |
|
if len(d.FeatureIndex) != len(l.FeatureIndex): |
|
continue |
|
if (d.ReqFeatureIndex == 65535) != (l.ReqFeatureIndex == 65535): |
|
continue |
|
|
|
if d.ReqFeatureIndex != 65535: |
|
if features[d.ReqFeatureIndex] != features[l.ReqFeatureIndex]: |
|
continue |
|
|
|
for i in range(len(d.FeatureIndex)): |
|
if features[d.FeatureIndex[i]] != features[l.FeatureIndex[i]]: |
|
break |
|
else: |
|
# LangSys and default are equal; delete LangSys |
|
s.Script.LangSysRecord.remove(lr) |
|
|
|
@_add_method(ttLib.getTableClass('GSUB'), |
|
ttLib.getTableClass('GPOS')) |
|
def prune_post_subset(self, options): |
|
table = self.table |
|
|
|
# LookupList looks good. Just prune lookups themselves |
|
if table.LookupList: |
|
table.LookupList.prune_post_subset(options); |
|
# XXX Next two lines disabled because OTS is stupid and |
|
# doesn't like NULL offsetse here. |
|
#if not table.LookupList.Lookup: |
|
# table.LookupList = None |
|
|
|
if not table.LookupList: |
|
table.FeatureList = None |
|
|
|
if table.FeatureList: |
|
self.remove_redundant_langsys() |
|
# Remove unreferenced features |
|
self.prune_features() |
|
|
|
# XXX Next two lines disabled because OTS is stupid and |
|
# doesn't like NULL offsetse here. |
|
#if table.FeatureList and not table.FeatureList.FeatureRecord: |
|
# table.FeatureList = None |
|
|
|
# Never drop scripts themselves as them just being available |
|
# holds semantic significance. |
|
# XXX Next two lines disabled because OTS is stupid and |
|
# doesn't like NULL offsetse here. |
|
#if table.ScriptList and not table.ScriptList.ScriptRecord: |
|
# table.ScriptList = None |
|
|
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('GDEF')) |
|
def subset_glyphs(self, s): |
|
glyphs = s.glyphs_gsubed |
|
table = self.table |
|
if table.LigCaretList: |
|
indices = table.LigCaretList.Coverage.subset(glyphs) |
|
table.LigCaretList.LigGlyph = [table.LigCaretList.LigGlyph[i] |
|
for i in indices] |
|
table.LigCaretList.LigGlyphCount = len(table.LigCaretList.LigGlyph) |
|
if table.MarkAttachClassDef: |
|
table.MarkAttachClassDef.classDefs = dict((g,v) for g,v in |
|
table.MarkAttachClassDef. |
|
classDefs.items() |
|
if g in glyphs) |
|
if table.GlyphClassDef: |
|
table.GlyphClassDef.classDefs = dict((g,v) for g,v in |
|
table.GlyphClassDef. |
|
classDefs.items() |
|
if g in glyphs) |
|
if table.AttachList: |
|
indices = table.AttachList.Coverage.subset(glyphs) |
|
GlyphCount = table.AttachList.GlyphCount |
|
table.AttachList.AttachPoint = [table.AttachList.AttachPoint[i] |
|
for i in indices |
|
if i < GlyphCount] |
|
table.AttachList.GlyphCount = len(table.AttachList.AttachPoint) |
|
if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef: |
|
for coverage in table.MarkGlyphSetsDef.Coverage: |
|
coverage.subset(glyphs) |
|
# TODO: The following is disabled. If enabling, we need to go fixup all |
|
# lookups that use MarkFilteringSet and map their set. |
|
#indices = table.MarkGlyphSetsDef.Coverage = [c for c in table.MarkGlyphSetsDef.Coverage if c.glyphs] |
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('GDEF')) |
|
def prune_post_subset(self, options): |
|
table = self.table |
|
# XXX check these against OTS |
|
if table.LigCaretList and not table.LigCaretList.LigGlyphCount: |
|
table.LigCaretList = None |
|
if table.MarkAttachClassDef and not table.MarkAttachClassDef.classDefs: |
|
table.MarkAttachClassDef = None |
|
if table.GlyphClassDef and not table.GlyphClassDef.classDefs: |
|
table.GlyphClassDef = None |
|
if table.AttachList and not table.AttachList.GlyphCount: |
|
table.AttachList = None |
|
if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef and not table.MarkGlyphSetsDef.Coverage: |
|
table.MarkGlyphSetsDef = None |
|
if table.Version == 0x00010002/0x10000: |
|
table.Version = 1.0 |
|
return bool(table.LigCaretList or |
|
table.MarkAttachClassDef or |
|
table.GlyphClassDef or |
|
table.AttachList or |
|
(table.Version >= 0x00010002/0x10000 and table.MarkGlyphSetsDef)) |
|
|
|
@_add_method(ttLib.getTableClass('kern')) |
|
def prune_pre_subset(self, options): |
|
# Prune unknown kern table types |
|
self.kernTables = [t for t in self.kernTables if hasattr(t, 'kernTable')] |
|
return bool(self.kernTables) |
|
|
|
@_add_method(ttLib.getTableClass('kern')) |
|
def subset_glyphs(self, s): |
|
glyphs = s.glyphs_gsubed |
|
for t in self.kernTables: |
|
t.kernTable = dict(((a,b),v) for (a,b),v in t.kernTable.items() |
|
if a in glyphs and b in glyphs) |
|
self.kernTables = [t for t in self.kernTables if t.kernTable] |
|
return bool(self.kernTables) |
|
|
|
@_add_method(ttLib.getTableClass('vmtx')) |
|
def subset_glyphs(self, s): |
|
self.metrics = dict((g,v) for g,v in self.metrics.items() if g in s.glyphs) |
|
return bool(self.metrics) |
|
|
|
@_add_method(ttLib.getTableClass('hmtx')) |
|
def subset_glyphs(self, s): |
|
self.metrics = dict((g,v) for g,v in self.metrics.items() if g in s.glyphs) |
|
return True # Required table |
|
|
|
@_add_method(ttLib.getTableClass('hdmx')) |
|
def subset_glyphs(self, s): |
|
self.hdmx = dict((sz,dict((g,v) for g,v in l.items() if g in s.glyphs)) |
|
for sz,l in self.hdmx.items()) |
|
return bool(self.hdmx) |
|
|
|
@_add_method(ttLib.getTableClass('VORG')) |
|
def subset_glyphs(self, s): |
|
self.VOriginRecords = dict((g,v) for g,v in self.VOriginRecords.items() |
|
if g in s.glyphs) |
|
self.numVertOriginYMetrics = len(self.VOriginRecords) |
|
return True # Never drop; has default metrics |
|
|
|
@_add_method(ttLib.getTableClass('post')) |
|
def prune_pre_subset(self, options): |
|
if not options.glyph_names: |
|
self.formatType = 3.0 |
|
return True # Required table |
|
|
|
@_add_method(ttLib.getTableClass('post')) |
|
def subset_glyphs(self, s): |
|
self.extraNames = [] # This seems to do it |
|
return True # Required table |
|
|
|
@_add_method(ttLib.getTableModule('glyf').Glyph) |
|
def remapComponentsFast(self, indices): |
|
if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0: |
|
return # Not composite |
|
data = array.array("B", self.data) |
|
i = 10 |
|
more = 1 |
|
while more: |
|
flags =(data[i] << 8) | data[i+1] |
|
glyphID =(data[i+2] << 8) | data[i+3] |
|
# Remap |
|
glyphID = indices.index(glyphID) |
|
data[i+2] = glyphID >> 8 |
|
data[i+3] = glyphID & 0xFF |
|
i += 4 |
|
flags = int(flags) |
|
|
|
if flags & 0x0001: i += 4 # ARG_1_AND_2_ARE_WORDS |
|
else: i += 2 |
|
if flags & 0x0008: i += 2 # WE_HAVE_A_SCALE |
|
elif flags & 0x0040: i += 4 # WE_HAVE_AN_X_AND_Y_SCALE |
|
elif flags & 0x0080: i += 8 # WE_HAVE_A_TWO_BY_TWO |
|
more = flags & 0x0020 # MORE_COMPONENTS |
|
|
|
self.data = data.tostring() |
|
|
|
@_add_method(ttLib.getTableClass('glyf')) |
|
def closure_glyphs(self, s): |
|
decompose = s.glyphs |
|
while True: |
|
components = set() |
|
for g in decompose: |
|
if g not in self.glyphs: |
|
continue |
|
gl = self.glyphs[g] |
|
for c in gl.getComponentNames(self): |
|
if c not in s.glyphs: |
|
components.add(c) |
|
components = set(c for c in components if c not in s.glyphs) |
|
if not components: |
|
break |
|
decompose = components |
|
s.glyphs.update(components) |
|
|
|
@_add_method(ttLib.getTableClass('glyf')) |
|
def prune_pre_subset(self, options): |
|
if options.notdef_glyph and not options.notdef_outline: |
|
g = self[self.glyphOrder[0]] |
|
# Yay, easy! |
|
g.__dict__.clear() |
|
g.data = "" |
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('glyf')) |
|
def subset_glyphs(self, s): |
|
self.glyphs = dict((g,v) for g,v in self.glyphs.items() if g in s.glyphs) |
|
indices = [i for i,g in enumerate(self.glyphOrder) if g in s.glyphs] |
|
for v in self.glyphs.values(): |
|
if hasattr(v, "data"): |
|
v.remapComponentsFast(indices) |
|
else: |
|
pass # No need |
|
self.glyphOrder = [g for g in self.glyphOrder if g in s.glyphs] |
|
# Don't drop empty 'glyf' tables, otherwise 'loca' doesn't get subset. |
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('glyf')) |
|
def prune_post_subset(self, options): |
|
if not options.hinting: |
|
for v in self.glyphs.values(): |
|
v.removeHinting() |
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('CFF ')) |
|
def prune_pre_subset(self, options): |
|
cff = self.cff |
|
# CFF table must have one font only |
|
cff.fontNames = cff.fontNames[:1] |
|
|
|
if options.notdef_glyph and not options.notdef_outline: |
|
for fontname in cff.keys(): |
|
font = cff[fontname] |
|
c,_ = font.CharStrings.getItemAndSelector('.notdef') |
|
# XXX we should preserve the glyph width |
|
c.bytecode = '\x0e' # endchar |
|
c.program = None |
|
|
|
return True # bool(cff.fontNames) |
|
|
|
@_add_method(ttLib.getTableClass('CFF ')) |
|
def subset_glyphs(self, s): |
|
cff = self.cff |
|
for fontname in cff.keys(): |
|
font = cff[fontname] |
|
cs = font.CharStrings |
|
|
|
# Load all glyphs |
|
for g in font.charset: |
|
if g not in s.glyphs: continue |
|
c,sel = cs.getItemAndSelector(g) |
|
|
|
if cs.charStringsAreIndexed: |
|
indices = [i for i,g in enumerate(font.charset) if g in s.glyphs] |
|
csi = cs.charStringsIndex |
|
csi.items = [csi.items[i] for i in indices] |
|
csi.count = len(csi.items) |
|
del csi.file, csi.offsets |
|
if hasattr(font, "FDSelect"): |
|
sel = font.FDSelect |
|
sel.format = None |
|
sel.gidArray = [sel.gidArray[i] for i in indices] |
|
cs.charStrings = dict((g,indices.index(v)) |
|
for g,v in cs.charStrings.items() |
|
if g in s.glyphs) |
|
else: |
|
cs.charStrings = dict((g,v) |
|
for g,v in cs.charStrings.items() |
|
if g in s.glyphs) |
|
font.charset = [g for g in font.charset if g in s.glyphs] |
|
font.numGlyphs = len(font.charset) |
|
|
|
return True # any(cff[fontname].numGlyphs for fontname in cff.keys()) |
|
|
|
@_add_method(psCharStrings.T2CharString) |
|
def subset_subroutines(self, subrs, gsubrs): |
|
p = self.program |
|
assert len(p) |
|
for i in range(1, len(p)): |
|
if p[i] == 'callsubr': |
|
assert isinstance(p[i-1], int) |
|
p[i-1] = subrs._used.index(p[i-1] + subrs._old_bias) - subrs._new_bias |
|
elif p[i] == 'callgsubr': |
|
assert isinstance(p[i-1], int) |
|
p[i-1] = gsubrs._used.index(p[i-1] + gsubrs._old_bias) - gsubrs._new_bias |
|
|
|
@_add_method(psCharStrings.T2CharString) |
|
def drop_hints(self): |
|
hints = self._hints |
|
|
|
if hints.has_hint: |
|
self.program = self.program[hints.last_hint:] |
|
if hasattr(self, 'width'): |
|
# Insert width back if needed |
|
if self.width != self.private.defaultWidthX: |
|
self.program.insert(0, self.width - self.private.nominalWidthX) |
|
|
|
if hints.has_hintmask: |
|
i = 0 |
|
p = self.program |
|
while i < len(p): |
|
if p[i] in ['hintmask', 'cntrmask']: |
|
assert i + 1 <= len(p) |
|
del p[i:i+2] |
|
continue |
|
i += 1 |
|
|
|
# TODO: we currently don't drop calls to "empty" subroutines. |
|
|
|
assert len(self.program) |
|
|
|
del self._hints |
|
|
|
class _MarkingT2Decompiler(psCharStrings.SimpleT2Decompiler): |
|
|
|
def __init__(self, localSubrs, globalSubrs): |
|
psCharStrings.SimpleT2Decompiler.__init__(self, |
|
localSubrs, |
|
globalSubrs) |
|
for subrs in [localSubrs, globalSubrs]: |
|
if subrs and not hasattr(subrs, "_used"): |
|
subrs._used = set() |
|
|
|
def op_callsubr(self, index): |
|
self.localSubrs._used.add(self.operandStack[-1]+self.localBias) |
|
psCharStrings.SimpleT2Decompiler.op_callsubr(self, index) |
|
|
|
def op_callgsubr(self, index): |
|
self.globalSubrs._used.add(self.operandStack[-1]+self.globalBias) |
|
psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index) |
|
|
|
class _DehintingT2Decompiler(psCharStrings.SimpleT2Decompiler): |
|
|
|
class Hints(object): |
|
def __init__(self): |
|
# Whether calling this charstring produces any hint stems |
|
self.has_hint = False |
|
# Index to start at to drop all hints |
|
self.last_hint = 0 |
|
# Index up to which we know more hints are possible. Only |
|
# relevant if status is 0 or 1. |
|
self.last_checked = 0 |
|
# The status means: |
|
# 0: after dropping hints, this charstring is empty |
|
# 1: after dropping hints, there may be more hints continuing after this |
|
# 2: no more hints possible after this charstring |
|
self.status = 0 |
|
# Has hintmask instructions; not recursive |
|
self.has_hintmask = False |
|
pass |
|
|
|
def __init__(self, css, localSubrs, globalSubrs): |
|
self._css = css |
|
psCharStrings.SimpleT2Decompiler.__init__(self, |
|
localSubrs, |
|
globalSubrs) |
|
|
|
def execute(self, charString): |
|
old_hints = charString._hints if hasattr(charString, '_hints') else None |
|
charString._hints = self.Hints() |
|
|
|
psCharStrings.SimpleT2Decompiler.execute(self, charString) |
|
|
|
hints = charString._hints |
|
|
|
if hints.has_hint or hints.has_hintmask: |
|
self._css.add(charString) |
|
|
|
if hints.status != 2: |
|
# Check from last_check, make sure we didn't have any operators. |
|
for i in range(hints.last_checked, len(charString.program) - 1): |
|
if isinstance(charString.program[i], str): |
|
hints.status = 2 |
|
break; |
|
else: |
|
hints.status = 1 # There's *something* here |
|
hints.last_checked = len(charString.program) |
|
|
|
if old_hints: |
|
assert hints.__dict__ == old_hints.__dict__ |
|
|
|
def op_callsubr(self, index): |
|
subr = self.localSubrs[self.operandStack[-1]+self.localBias] |
|
psCharStrings.SimpleT2Decompiler.op_callsubr(self, index) |
|
self.processSubr(index, subr) |
|
|
|
def op_callgsubr(self, index): |
|
subr = self.globalSubrs[self.operandStack[-1]+self.globalBias] |
|
psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index) |
|
self.processSubr(index, subr) |
|
|
|
def op_hstem(self, index): |
|
psCharStrings.SimpleT2Decompiler.op_hstem(self, index) |
|
self.processHint(index) |
|
def op_vstem(self, index): |
|
psCharStrings.SimpleT2Decompiler.op_vstem(self, index) |
|
self.processHint(index) |
|
def op_hstemhm(self, index): |
|
psCharStrings.SimpleT2Decompiler.op_hstemhm(self, index) |
|
self.processHint(index) |
|
def op_vstemhm(self, index): |
|
psCharStrings.SimpleT2Decompiler.op_vstemhm(self, index) |
|
self.processHint(index) |
|
def op_hintmask(self, index): |
|
psCharStrings.SimpleT2Decompiler.op_hintmask(self, index) |
|
self.processHintmask(index) |
|
def op_cntrmask(self, index): |
|
psCharStrings.SimpleT2Decompiler.op_cntrmask(self, index) |
|
self.processHintmask(index) |
|
|
|
def processHintmask(self, index): |
|
cs = self.callingStack[-1] |
|
hints = cs._hints |
|
hints.has_hintmask = True |
|
if hints.status != 2 and hints.has_hint: |
|
# Check from last_check, see if we may be an implicit vstem |
|
for i in range(hints.last_checked, index - 1): |
|
if isinstance(cs.program[i], str): |
|
hints.status = 2 |
|
break; |
|
if hints.status != 2: |
|
# We are an implicit vstem |
|
hints.last_hint = index + 1 |
|
hints.status = 0 |
|
hints.last_checked = index + 1 |
|
|
|
def processHint(self, index): |
|
cs = self.callingStack[-1] |
|
hints = cs._hints |
|
hints.has_hint = True |
|
hints.last_hint = index |
|
hints.last_checked = index |
|
|
|
def processSubr(self, index, subr): |
|
cs = self.callingStack[-1] |
|
hints = cs._hints |
|
subr_hints = subr._hints |
|
|
|
if subr_hints.has_hint: |
|
if hints.status != 2: |
|
hints.has_hint = True |
|
hints.last_checked = index |
|
hints.status = subr_hints.status |
|
# Decide where to chop off from |
|
if subr_hints.status == 0: |
|
hints.last_hint = index |
|
else: |
|
hints.last_hint = index - 2 # Leave the subr call in |
|
else: |
|
# In my understanding, this is a font bug. Ie. it has hint stems |
|
# *after* path construction. I've seen this in widespread fonts. |
|
# Best to ignore the hints I suppose... |
|
pass |
|
#assert 0 |
|
else: |
|
hints.status = max(hints.status, subr_hints.status) |
|
if hints.status != 2: |
|
# Check from last_check, make sure we didn't have |
|
# any operators. |
|
for i in range(hints.last_checked, index - 1): |
|
if isinstance(cs.program[i], str): |
|
hints.status = 2 |
|
break; |
|
hints.last_checked = index |
|
if hints.status != 2: |
|
# Decide where to chop off from |
|
if subr_hints.status == 0: |
|
hints.last_hint = index |
|
else: |
|
hints.last_hint = index - 2 # Leave the subr call in |
|
|
|
@_add_method(ttLib.getTableClass('CFF ')) |
|
def prune_post_subset(self, options): |
|
cff = self.cff |
|
for fontname in cff.keys(): |
|
font = cff[fontname] |
|
cs = font.CharStrings |
|
|
|
|
|
# |
|
# Drop unused FontDictionaries |
|
# |
|
if hasattr(font, "FDSelect"): |
|
sel = font.FDSelect |
|
indices = _uniq_sort(sel.gidArray) |
|
sel.gidArray = [indices.index (ss) for ss in sel.gidArray] |
|
arr = font.FDArray |
|
arr.items = [arr[i] for i in indices] |
|
arr.count = len(arr.items) |
|
del arr.file, arr.offsets |
|
|
|
|
|
# |
|
# Drop hints if not needed |
|
# |
|
if not options.hinting: |
|
|
|
# |
|
# This can be tricky, but doesn't have to. What we do is: |
|
# |
|
# - Run all used glyph charstrings and recurse into subroutines, |
|
# - For each charstring (including subroutines), if it has any |
|
# of the hint stem operators, we mark it as such. Upon returning, |
|
# for each charstring we note all the subroutine calls it makes |
|
# that (recursively) contain a stem, |
|
# - Dropping hinting then consists of the following two ops: |
|
# * Drop the piece of the program in each charstring before the |
|
# last call to a stem op or a stem-calling subroutine, |
|
# * Drop all hintmask operations. |
|
# - It's trickier... A hintmask right after hints and a few numbers |
|
# will act as an implicit vstemhm. As such, we track whether |
|
# we have seen any non-hint operators so far and do the right |
|
# thing, recursively... Good luck understanding that :( |
|
# |
|
css = set() |
|
for g in font.charset: |
|
c,sel = cs.getItemAndSelector(g) |
|
# Make sure it's decompiled. We want our "decompiler" to walk |
|
# the program, not the bytecode. |
|
c.draw(basePen.NullPen()) |
|
subrs = getattr(c.private, "Subrs", []) |
|
decompiler = _DehintingT2Decompiler(css, subrs, c.globalSubrs) |
|
decompiler.execute(c) |
|
for charstring in css: |
|
charstring.drop_hints() |
|
|
|
# Drop font-wide hinting values |
|
all_privs = [] |
|
if hasattr(font, 'FDSelect'): |
|
all_privs.extend(fd.Private for fd in font.FDArray) |
|
else: |
|
all_privs.append(font.Private) |
|
for priv in all_privs: |
|
for k in ['BlueValues', 'OtherBlues', 'FamilyBlues', 'FamilyOtherBlues', |
|
'BlueScale', 'BlueShift', 'BlueFuzz', |
|
'StemSnapH', 'StemSnapV', 'StdHW', 'StdVW']: |
|
if hasattr(priv, k): |
|
setattr(priv, k, None) |
|
|
|
|
|
# |
|
# Renumber subroutines to remove unused ones |
|
# |
|
|
|
# Mark all used subroutines |
|
for g in font.charset: |
|
c,sel = cs.getItemAndSelector(g) |
|
subrs = getattr(c.private, "Subrs", []) |
|
decompiler = _MarkingT2Decompiler(subrs, c.globalSubrs) |
|
decompiler.execute(c) |
|
|
|
all_subrs = [font.GlobalSubrs] |
|
if hasattr(font, 'FDSelect'): |
|
all_subrs.extend(fd.Private.Subrs for fd in font.FDArray if hasattr(fd.Private, 'Subrs') and fd.Private.Subrs) |
|
elif hasattr(font.Private, 'Subrs') and font.Private.Subrs: |
|
all_subrs.append(font.Private.Subrs) |
|
|
|
subrs = set(subrs) # Remove duplicates |
|
|
|
# Prepare |
|
for subrs in all_subrs: |
|
if not hasattr(subrs, '_used'): |
|
subrs._used = set() |
|
subrs._used = _uniq_sort(subrs._used) |
|
subrs._old_bias = psCharStrings.calcSubrBias(subrs) |
|
subrs._new_bias = psCharStrings.calcSubrBias(subrs._used) |
|
|
|
# Renumber glyph charstrings |
|
for g in font.charset: |
|
c,sel = cs.getItemAndSelector(g) |
|
subrs = getattr(c.private, "Subrs", []) |
|
c.subset_subroutines (subrs, font.GlobalSubrs) |
|
|
|
# Renumber subroutines themselves |
|
for subrs in all_subrs: |
|
|
|
if subrs == font.GlobalSubrs: |
|
if not hasattr(font, 'FDSelect') and hasattr(font.Private, 'Subrs'): |
|
local_subrs = font.Private.Subrs |
|
else: |
|
local_subrs = [] |
|
else: |
|
local_subrs = subrs |
|
|
|
subrs.items = [subrs.items[i] for i in subrs._used] |
|
subrs.count = len(subrs.items) |
|
del subrs.file |
|
if hasattr(subrs, 'offsets'): |
|
del subrs.offsets |
|
|
|
for i in range (subrs.count): |
|
subrs[i].subset_subroutines (local_subrs, font.GlobalSubrs) |
|
|
|
# Cleanup |
|
for subrs in all_subrs: |
|
del subrs._used, subrs._old_bias, subrs._new_bias |
|
|
|
return True |
|
|
|
@_add_method(ttLib.getTableClass('cmap')) |
|
def closure_glyphs(self, s): |
|
tables = [t for t in self.tables if t.isUnicode()] |
|
for u in s.unicodes_requested: |
|
found = False |
|
for table in tables: |
|
if table.format == 14: |
|
for l in table.uvsDict.values(): |
|
# TODO(behdad) Speed this up! |
|
gids = [g for uc,g in l if u == uc and g is not None] |
|
s.glyphs.update(gids) |
|
# Intentionally not setting found=True here. |
|
else: |
|
if u in table.cmap: |
|
s.glyphs.add(table.cmap[u]) |
|
found = True |
|
if not found: |
|
s.log("No default glyph for Unicode %04X found." % u) |
|
|
|
@_add_method(ttLib.getTableClass('cmap')) |
|
def prune_pre_subset(self, options): |
|
if not options.legacy_cmap: |
|
# Drop non-Unicode / non-Symbol cmaps |
|
self.tables = [t for t in self.tables if t.isUnicode() or t.isSymbol()] |
|
if not options.symbol_cmap: |
|
self.tables = [t for t in self.tables if not t.isSymbol()] |
|
# TODO(behdad) Only keep one subtable? |
|
# For now, drop format=0 which can't be subset_glyphs easily? |
|
self.tables = [t for t in self.tables if t.format != 0] |
|
self.numSubTables = len(self.tables) |
|
return True # Required table |
|
|
|
@_add_method(ttLib.getTableClass('cmap')) |
|
def subset_glyphs(self, s): |
|
s.glyphs = s.glyphs_cmaped |
|
for t in self.tables: |
|
# For reasons I don't understand I need this here |
|
# to force decompilation of the cmap format 14. |
|
try: |
|
getattr(t, "asdf") |
|
except AttributeError: |
|
pass |
|
if t.format == 14: |
|
# TODO(behdad) We drop all the default-UVS mappings for glyphs_requested. |
|
# I don't think we care about that... |
|
t.uvsDict = dict((v,[(u,g) for u,g in l |
|
if g in s.glyphs or u in s.unicodes_requested]) |
|
for v,l in t.uvsDict.items()) |
|
t.uvsDict = dict((v,l) for v,l in t.uvsDict.items() if l) |
|
elif t.isUnicode(): |
|
t.cmap = dict((u,g) for u,g in t.cmap.items() |
|
if g in s.glyphs_requested or u in s.unicodes_requested) |
|
else: |
|
t.cmap = dict((u,g) for u,g in t.cmap.items() |
|
if g in s.glyphs_requested) |
|
self.tables = [t for t in self.tables |
|
if (t.cmap if t.format != 14 else t.uvsDict)] |
|
self.numSubTables = len(self.tables) |
|
# TODO(behdad) Convert formats when needed. |
|
# In particular, if we have a format=12 without non-BMP |
|
# characters, either drop format=12 one or convert it |
|
# to format=4 if there's not one. |
|
return True # Required table |
|
|
|
@_add_method(ttLib.getTableClass('name')) |
|
def prune_pre_subset(self, options): |
|
if '*' not in options.name_IDs: |
|
self.names = [n for n in self.names if n.nameID in options.name_IDs] |
|
if not options.name_legacy: |
|
self.names = [n for n in self.names if n.isUnicode()] |
|
# TODO(behdad) Option to keep only one platform's |
|
if '*' not in options.name_languages: |
|
# TODO(behdad) This is Windows-platform specific! |
|
self.names = [n for n in self.names if n.langID in options.name_languages] |
|
return True # Required table |
|
|
|
|
|
# TODO(behdad) OS/2 ulUnicodeRange / ulCodePageRange? |
|
# TODO(behdad) Drop AAT tables. |
|
# TODO(behdad) Drop unneeded GSUB/GPOS Script/LangSys entries. |
|
# TODO(behdad) Drop empty GSUB/GPOS, and GDEF if no GSUB/GPOS left |
|
# TODO(behdad) Drop GDEF subitems if unused by lookups |
|
# TODO(behdad) Avoid recursing too much (in GSUB/GPOS and in CFF) |
|
# TODO(behdad) Text direction considerations. |
|
# TODO(behdad) Text script / language considerations. |
|
# TODO(behdad) Optionally drop 'kern' table if GPOS available |
|
# TODO(behdad) Implement --unicode='*' to choose all cmap'ed |
|
# TODO(behdad) Drop old-spec Indic scripts |
|
|
|
|
|
class Options(object): |
|
|
|
class UnknownOptionError(Exception): |
|
pass |
|
|
|
_drop_tables_default = ['BASE', 'JSTF', 'DSIG', 'EBDT', 'EBLC', 'EBSC', 'SVG ', |
|
'PCLT', 'LTSH'] |
|
_drop_tables_default += ['Feat', 'Glat', 'Gloc', 'Silf', 'Sill'] # Graphite |
|
_drop_tables_default += ['CBLC', 'CBDT', 'sbix', 'COLR', 'CPAL'] # Color |
|
_no_subset_tables_default = ['gasp', 'head', 'hhea', 'maxp', 'vhea', 'OS/2', |
|
'loca', 'name', 'cvt ', 'fpgm', 'prep'] |
|
_hinting_tables_default = ['cvt ', 'fpgm', 'prep', 'hdmx', 'VDMX'] |
|
|
|
# Based on HarfBuzz shapers |
|
_layout_features_groups = { |
|
# Default shaper |
|
'common': ['ccmp', 'liga', 'locl', 'mark', 'mkmk', 'rlig'], |
|
'horizontal': ['calt', 'clig', 'curs', 'kern', 'rclt'], |
|
'vertical': ['valt', 'vert', 'vkrn', 'vpal', 'vrt2'], |
|
'ltr': ['ltra', 'ltrm'], |
|
'rtl': ['rtla', 'rtlm'], |
|
# Complex shapers |
|
'arabic': ['init', 'medi', 'fina', 'isol', 'med2', 'fin2', 'fin3', |
|
'cswh', 'mset'], |
|
'hangul': ['ljmo', 'vjmo', 'tjmo'], |
|
'tibetan': ['abvs', 'blws', 'abvm', 'blwm'], |
|
'indic': ['nukt', 'akhn', 'rphf', 'rkrf', 'pref', 'blwf', 'half', |
|
'abvf', 'pstf', 'cfar', 'vatu', 'cjct', 'init', 'pres', |
|
'abvs', 'blws', 'psts', 'haln', 'dist', 'abvm', 'blwm'], |
|
} |
|
_layout_features_default = _uniq_sort(sum( |
|
iter(_layout_features_groups.values()), [])) |
|
|
|
drop_tables = _drop_tables_default |
|
no_subset_tables = _no_subset_tables_default |
|
hinting_tables = _hinting_tables_default |
|
layout_features = _layout_features_default |
|
hinting = True |
|
glyph_names = False |
|
legacy_cmap = False |
|
symbol_cmap = False |
|
name_IDs = [1, 2] # Family and Style |
|
name_legacy = False |
|
name_languages = [0x0409] # English |
|
notdef_glyph = True # gid0 for TrueType / .notdef for CFF |
|
notdef_outline = False # No need for notdef to have an outline really |
|
recommended_glyphs = False # gid1, gid2, gid3 for TrueType |
|
recalc_bounds = False # Recalculate font bounding boxes |
|
recalc_timestamp = False # Recalculate font modified timestamp |
|
canonical_order = False # Order tables as recommended |
|
flavor = None # May be 'woff' |
|
|
|
def __init__(self, **kwargs): |
|
|
|
self.set(**kwargs) |
|
|
|
def set(self, **kwargs): |
|
for k,v in kwargs.items(): |
|
if not hasattr(self, k): |
|
raise self.UnknownOptionError("Unknown option '%s'" % k) |
|
setattr(self, k, v) |
|
|
|
def parse_opts(self, argv, ignore_unknown=False): |
|
ret = [] |
|
opts = {} |
|
for a in argv: |
|
orig_a = a |
|
if not a.startswith('--'): |
|
ret.append(a) |
|
continue |
|
a = a[2:] |
|
i = a.find('=') |
|
op = '=' |
|
if i == -1: |
|
if a.startswith("no-"): |
|
k = a[3:] |
|
v = False |
|
else: |
|
k = a |
|
v = True |
|
else: |
|
k = a[:i] |
|
if k[-1] in "-+": |
|
op = k[-1]+'=' # Ops is '-=' or '+=' now. |
|
k = k[:-1] |
|
v = a[i+1:] |
|
k = k.replace('-', '_') |
|
if not hasattr(self, k): |
|
if ignore_unknown is True or k in ignore_unknown: |
|
ret.append(orig_a) |
|
continue |
|
else: |
|
raise self.UnknownOptionError("Unknown option '%s'" % a) |
|
|
|
ov = getattr(self, k) |
|
if isinstance(ov, bool): |
|
v = bool(v) |
|
elif isinstance(ov, int): |
|
v = int(v) |
|
elif isinstance(ov, list): |
|
vv = v.split(',') |
|
if vv == ['']: |
|
vv = [] |
|
vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv] |
|
if op == '=': |
|
v = vv |
|
elif op == '+=': |
|
v = ov |
|
v.extend(vv) |
|
elif op == '-=': |
|
v = ov |
|
for x in vv: |
|
if x in v: |
|
v.remove(x) |
|
else: |
|
assert False |
|
|
|
opts[k] = v |
|
self.set(**opts) |
|
|
|
return ret |
|
|
|
|
|
class Subsetter(object): |
|
|
|
def __init__(self, options=None, log=None): |
|
|
|
if not log: |
|
log = Logger() |
|
if not options: |
|
options = Options() |
|
|
|
self.options = options |
|
self.log = log |
|
self.unicodes_requested = set() |
|
self.glyphs_requested = set() |
|
self.glyphs = set() |
|
|
|
def populate(self, glyphs=[], unicodes=[], text=""): |
|
self.unicodes_requested.update(unicodes) |
|
if isinstance(text, bytes): |
|
text = text.decode("utf8") |
|
for u in text: |
|
self.unicodes_requested.add(ord(u)) |
|
self.glyphs_requested.update(glyphs) |
|
self.glyphs.update(glyphs) |
|
|
|
def _prune_pre_subset(self, font): |
|
|
|
for tag in font.keys(): |
|
if tag == 'GlyphOrder': continue |
|
|
|
if(tag in self.options.drop_tables or |
|
(tag in self.options.hinting_tables and not self.options.hinting)): |
|
self.log(tag, "dropped") |
|
del font[tag] |
|
continue |
|
|
|
clazz = ttLib.getTableClass(tag) |
|
|
|
if hasattr(clazz, 'prune_pre_subset'): |
|
table = font[tag] |
|
self.log.lapse("load '%s'" % tag) |
|
retain = table.prune_pre_subset(self.options) |
|
self.log.lapse("prune '%s'" % tag) |
|
if not retain: |
|
self.log(tag, "pruned to empty; dropped") |
|
del font[tag] |
|
continue |
|
else: |
|
self.log(tag, "pruned") |
|
|
|
def _closure_glyphs(self, font): |
|
|
|
realGlyphs = set(font.getGlyphOrder()) |
|
|
|
self.glyphs = self.glyphs_requested.copy() |
|
|
|
if 'cmap' in font: |
|
font['cmap'].closure_glyphs(self) |
|
self.glyphs.intersection_update(realGlyphs) |
|
self.glyphs_cmaped = self.glyphs |
|
|
|
if self.options.notdef_glyph: |
|
if 'glyf' in font: |
|
self.glyphs.add(font.getGlyphName(0)) |
|
self.log("Added gid0 to subset") |
|
else: |
|
self.glyphs.add('.notdef') |
|
self.log("Added .notdef to subset") |
|
if self.options.recommended_glyphs: |
|
if 'glyf' in font: |
|
for i in range(min(4, len(font.getGlyphOrder()))): |
|
self.glyphs.add(font.getGlyphName(i)) |
|
self.log("Added first four glyphs to subset") |
|
|
|
if 'GSUB' in font: |
|
self.log("Closing glyph list over 'GSUB': %d glyphs before" % |
|
len(self.glyphs)) |
|
self.log.glyphs(self.glyphs, font=font) |
|
font['GSUB'].closure_glyphs(self) |
|
self.glyphs.intersection_update(realGlyphs) |
|
self.log("Closed glyph list over 'GSUB': %d glyphs after" % |
|
len(self.glyphs)) |
|
self.log.glyphs(self.glyphs, font=font) |
|
self.log.lapse("close glyph list over 'GSUB'") |
|
self.glyphs_gsubed = self.glyphs.copy() |
|
|
|
if 'glyf' in font: |
|
self.log("Closing glyph list over 'glyf': %d glyphs before" % |
|
len(self.glyphs)) |
|
self.log.glyphs(self.glyphs, font=font) |
|
font['glyf'].closure_glyphs(self) |
|
self.glyphs.intersection_update(realGlyphs) |
|
self.log("Closed glyph list over 'glyf': %d glyphs after" % |
|
len(self.glyphs)) |
|
self.log.glyphs(self.glyphs, font=font) |
|
self.log.lapse("close glyph list over 'glyf'") |
|
self.glyphs_glyfed = self.glyphs.copy() |
|
|
|
self.glyphs_all = self.glyphs.copy() |
|
|
|
self.log("Retaining %d glyphs: " % len(self.glyphs_all)) |
|
|
|
del self.glyphs |
|
|
|
|
|
def _subset_glyphs(self, font): |
|
for tag in font.keys(): |
|
if tag == 'GlyphOrder': continue |
|
clazz = ttLib.getTableClass(tag) |
|
|
|
if tag in self.options.no_subset_tables: |
|
self.log(tag, "subsetting not needed") |
|
elif hasattr(clazz, 'subset_glyphs'): |
|
table = font[tag] |
|
self.glyphs = self.glyphs_all |
|
retain = table.subset_glyphs(self) |
|
del self.glyphs |
|
self.log.lapse("subset '%s'" % tag) |
|
if not retain: |
|
self.log(tag, "subsetted to empty; dropped") |
|
del font[tag] |
|
else: |
|
self.log(tag, "subsetted") |
|
else: |
|
self.log(tag, "NOT subset; don't know how to subset; dropped") |
|
del font[tag] |
|
|
|
glyphOrder = font.getGlyphOrder() |
|
glyphOrder = [g for g in glyphOrder if g in self.glyphs_all] |
|
font.setGlyphOrder(glyphOrder) |
|
font._buildReverseGlyphOrderDict() |
|
self.log.lapse("subset GlyphOrder") |
|
|
|
def _prune_post_subset(self, font): |
|
for tag in font.keys(): |
|
if tag == 'GlyphOrder': continue |
|
clazz = ttLib.getTableClass(tag) |
|
if hasattr(clazz, 'prune_post_subset'): |
|
table = font[tag] |
|
retain = table.prune_post_subset(self.options) |
|
self.log.lapse("prune '%s'" % tag) |
|
if not retain: |
|
self.log(tag, "pruned to empty; dropped") |
|
del font[tag] |
|
else: |
|
self.log(tag, "pruned") |
|
|
|
def subset(self, font): |
|
|
|
self._prune_pre_subset(font) |
|
self._closure_glyphs(font) |
|
self._subset_glyphs(font) |
|
self._prune_post_subset(font) |
|
|
|
|
|
class Logger(object): |
|
|
|
def __init__(self, verbose=False, xml=False, timing=False): |
|
self.verbose = verbose |
|
self.xml = xml |
|
self.timing = timing |
|
self.last_time = self.start_time = time.time() |
|
|
|
def parse_opts(self, argv): |
|
argv = argv[:] |
|
for v in ['verbose', 'xml', 'timing']: |
|
if "--"+v in argv: |
|
setattr(self, v, True) |
|
argv.remove("--"+v) |
|
return argv |
|
|
|
def __call__(self, *things): |
|
if not self.verbose: |
|
return |
|
print(' '.join(str(x) for x in things)) |
|
|
|
def lapse(self, *things): |
|
if not self.timing: |
|
return |
|
new_time = time.time() |
|
print("Took %0.3fs to %s" %(new_time - self.last_time, |
|
' '.join(str(x) for x in things))) |
|
self.last_time = new_time |
|
|
|
def glyphs(self, glyphs, font=None): |
|
if not self.verbose: |
|
return |
|
self("Names: ", sorted(glyphs)) |
|
if font: |
|
reverseGlyphMap = font.getReverseGlyphMap() |
|
self("Gids : ", sorted(reverseGlyphMap[g] for g in glyphs)) |
|
|
|
def font(self, font, file=sys.stdout): |
|
if not self.xml: |
|
return |
|
from fontTools.misc import xmlWriter |
|
writer = xmlWriter.XMLWriter(file) |
|
for tag in font.keys(): |
|
writer.begintag(tag) |
|
writer.newline() |
|
font[tag].toXML(writer, font) |
|
writer.endtag(tag) |
|
writer.newline() |
|
|
|
|
|
def load_font(fontFile, |
|
options, |
|
allowVID=False, |
|
checkChecksums=False, |
|
dontLoadGlyphNames=False, |
|
lazy=True): |
|
|
|
font = ttLib.TTFont(fontFile, |
|
allowVID=allowVID, |
|
checkChecksums=checkChecksums, |
|
recalcBBoxes=options.recalc_bounds, |
|
recalcTimestamp=options.recalc_timestamp, |
|
lazy=lazy) |
|
|
|
# Hack: |
|
# |
|
# If we don't need glyph names, change 'post' class to not try to |
|
# load them. It avoid lots of headache with broken fonts as well |
|
# as loading time. |
|
# |
|
# Ideally ttLib should provide a way to ask it to skip loading |
|
# glyph names. But it currently doesn't provide such a thing. |
|
# |
|
if dontLoadGlyphNames: |
|
post = ttLib.getTableClass('post') |
|
saved = post.decode_format_2_0 |
|
post.decode_format_2_0 = post.decode_format_3_0 |
|
f = font['post'] |
|
if f.formatType == 2.0: |
|
f.formatType = 3.0 |
|
post.decode_format_2_0 = saved |
|
|
|
return font |
|
|
|
def save_font(font, outfile, options): |
|
if options.flavor and not hasattr(font, 'flavor'): |
|
raise Exception("fonttools version does not support flavors.") |
|
font.flavor = options.flavor |
|
font.save(outfile, reorderTables=options.canonical_order) |
|
|
|
def main(args): |
|
|
|
log = Logger() |
|
args = log.parse_opts(args) |
|
|
|
options = Options() |
|
args = options.parse_opts(args, ignore_unknown=['text']) |
|
|
|
if len(args) < 2: |
|
print("usage: pyftsubset font-file glyph... [--text=ABC]... [--option=value]...", file=sys.stderr) |
|
sys.exit(1) |
|
|
|
fontfile = args[0] |
|
args = args[1:] |
|
|
|
dontLoadGlyphNames =(not options.glyph_names and |
|
all(any(g.startswith(p) |
|
for p in ['gid', 'glyph', 'uni', 'U+']) |
|
for g in args)) |
|
|
|
font = load_font(fontfile, options, dontLoadGlyphNames=dontLoadGlyphNames) |
|
log.lapse("load font") |
|
subsetter = Subsetter(options=options, log=log) |
|
|
|
names = font.getGlyphNames() |
|
log.lapse("loading glyph names") |
|
|
|
glyphs = [] |
|
unicodes = [] |
|
text = "" |
|
for g in args: |
|
if g == '*': |
|
glyphs.extend(font.getGlyphOrder()) |
|
continue |
|
if g in names: |
|
glyphs.append(g) |
|
continue |
|
if g.startswith('--text='): |
|
text += g[7:] |
|
continue |
|
if g.startswith('uni') or g.startswith('U+'): |
|
if g.startswith('uni') and len(g) > 3: |
|
g = g[3:] |
|
elif g.startswith('U+') and len(g) > 2: |
|
g = g[2:] |
|
u = int(g, 16) |
|
unicodes.append(u) |
|
continue |
|
if g.startswith('gid') or g.startswith('glyph'): |
|
if g.startswith('gid') and len(g) > 3: |
|
g = g[3:] |
|
elif g.startswith('glyph') and len(g) > 5: |
|
g = g[5:] |
|
try: |
|
glyphs.append(font.getGlyphName(int(g), requireReal=True)) |
|
except ValueError: |
|
raise Exception("Invalid glyph identifier: %s" % g) |
|
continue |
|
raise Exception("Invalid glyph identifier: %s" % g) |
|
log.lapse("compile glyph list") |
|
log("Unicodes:", unicodes) |
|
log("Glyphs:", glyphs) |
|
|
|
subsetter.populate(glyphs=glyphs, unicodes=unicodes, text=text) |
|
subsetter.subset(font) |
|
|
|
outfile = fontfile + '.subset' |
|
|
|
save_font (font, outfile, options) |
|
log.lapse("compile and save font") |
|
|
|
log.last_time = log.start_time |
|
log.lapse("make one with everything(TOTAL TIME)") |
|
|
|
if log.verbose: |
|
import os |
|
log("Input font: %d bytes" % os.path.getsize(fontfile)) |
|
log("Subset font: %d bytes" % os.path.getsize(outfile)) |
|
|
|
log.font(font) |
|
|
|
font.close() |
|
|
|
|
|
__all__ = [ |
|
'Options', |
|
'Subsetter', |
|
'Logger', |
|
'load_font', |
|
'save_font', |
|
'main' |
|
] |
|
|
|
if __name__ == '__main__': |
|
main(sys.argv[1:])
|
|
|