| # Copyright 2013 Google, Inc. All Rights Reserved. |
| # |
| # Google Author(s): Behdad Esfahbod, Roozbeh Pournader |
| |
| from fontTools import ttLib |
| from fontTools.ttLib.tables.DefaultTable import DefaultTable |
| from fontTools.ttLib.tables import otTables |
| from fontTools.merge.base import add_method, mergeObjects |
| from fontTools.merge.util import * |
| import logging |
| |
| |
| log = logging.getLogger("fontTools.merge") |
| |
| |
| def mergeLookupLists(lst): |
| # TODO Do smarter merge. |
| return sumLists(lst) |
| |
| def mergeFeatures(lst): |
| assert lst |
| self = otTables.Feature() |
| self.FeatureParams = None |
| self.LookupListIndex = mergeLookupLists([l.LookupListIndex for l in lst if l.LookupListIndex]) |
| self.LookupCount = len(self.LookupListIndex) |
| return self |
| |
| def mergeFeatureLists(lst): |
| d = {} |
| for l in lst: |
| for f in l: |
| tag = f.FeatureTag |
| if tag not in d: |
| d[tag] = [] |
| d[tag].append(f.Feature) |
| ret = [] |
| for tag in sorted(d.keys()): |
| rec = otTables.FeatureRecord() |
| rec.FeatureTag = tag |
| rec.Feature = mergeFeatures(d[tag]) |
| ret.append(rec) |
| return ret |
| |
| def mergeLangSyses(lst): |
| assert lst |
| |
| # TODO Support merging ReqFeatureIndex |
| assert all(l.ReqFeatureIndex == 0xFFFF for l in lst) |
| |
| self = otTables.LangSys() |
| self.LookupOrder = None |
| self.ReqFeatureIndex = 0xFFFF |
| self.FeatureIndex = mergeFeatureLists([l.FeatureIndex for l in lst if l.FeatureIndex]) |
| self.FeatureCount = len(self.FeatureIndex) |
| return self |
| |
| def mergeScripts(lst): |
| assert lst |
| |
| if len(lst) == 1: |
| return lst[0] |
| langSyses = {} |
| for sr in lst: |
| for lsr in sr.LangSysRecord: |
| if lsr.LangSysTag not in langSyses: |
| langSyses[lsr.LangSysTag] = [] |
| langSyses[lsr.LangSysTag].append(lsr.LangSys) |
| lsrecords = [] |
| for tag, langSys_list in sorted(langSyses.items()): |
| lsr = otTables.LangSysRecord() |
| lsr.LangSys = mergeLangSyses(langSys_list) |
| lsr.LangSysTag = tag |
| lsrecords.append(lsr) |
| |
| self = otTables.Script() |
| self.LangSysRecord = lsrecords |
| self.LangSysCount = len(lsrecords) |
| dfltLangSyses = [s.DefaultLangSys for s in lst if s.DefaultLangSys] |
| if dfltLangSyses: |
| self.DefaultLangSys = mergeLangSyses(dfltLangSyses) |
| else: |
| self.DefaultLangSys = None |
| return self |
| |
| def mergeScriptRecords(lst): |
| d = {} |
| for l in lst: |
| for s in l: |
| tag = s.ScriptTag |
| if tag not in d: |
| d[tag] = [] |
| d[tag].append(s.Script) |
| ret = [] |
| for tag in sorted(d.keys()): |
| rec = otTables.ScriptRecord() |
| rec.ScriptTag = tag |
| rec.Script = mergeScripts(d[tag]) |
| ret.append(rec) |
| return ret |
| |
| otTables.ScriptList.mergeMap = { |
| 'ScriptCount': lambda lst: None, # TODO |
| 'ScriptRecord': mergeScriptRecords, |
| } |
| otTables.BaseScriptList.mergeMap = { |
| 'BaseScriptCount': lambda lst: None, # TODO |
| # TODO: Merge duplicate entries |
| 'BaseScriptRecord': lambda lst: sorted(sumLists(lst), key=lambda s: s.BaseScriptTag), |
| } |
| |
| otTables.FeatureList.mergeMap = { |
| 'FeatureCount': sum, |
| 'FeatureRecord': lambda lst: sorted(sumLists(lst), key=lambda s: s.FeatureTag), |
| } |
| |
| otTables.LookupList.mergeMap = { |
| 'LookupCount': sum, |
| 'Lookup': sumLists, |
| } |
| |
| otTables.Coverage.mergeMap = { |
| 'Format': min, |
| 'glyphs': sumLists, |
| } |
| |
| otTables.ClassDef.mergeMap = { |
| 'Format': min, |
| 'classDefs': sumDicts, |
| } |
| |
| otTables.LigCaretList.mergeMap = { |
| 'Coverage': mergeObjects, |
| 'LigGlyphCount': sum, |
| 'LigGlyph': sumLists, |
| } |
| |
| otTables.AttachList.mergeMap = { |
| 'Coverage': mergeObjects, |
| 'GlyphCount': sum, |
| 'AttachPoint': sumLists, |
| } |
| |
| # XXX Renumber MarkFilterSets of lookups |
| otTables.MarkGlyphSetsDef.mergeMap = { |
| 'MarkSetTableFormat': equal, |
| 'MarkSetCount': sum, |
| 'Coverage': sumLists, |
| } |
| |
| otTables.Axis.mergeMap = { |
| '*': mergeObjects, |
| } |
| |
| # XXX Fix BASE table merging |
| otTables.BaseTagList.mergeMap = { |
| 'BaseTagCount': sum, |
| 'BaselineTag': sumLists, |
| } |
| |
| otTables.GDEF.mergeMap = \ |
| otTables.GSUB.mergeMap = \ |
| otTables.GPOS.mergeMap = \ |
| otTables.BASE.mergeMap = \ |
| otTables.JSTF.mergeMap = \ |
| otTables.MATH.mergeMap = \ |
| { |
| '*': mergeObjects, |
| 'Version': max, |
| } |
| |
| ttLib.getTableClass('GDEF').mergeMap = \ |
| ttLib.getTableClass('GSUB').mergeMap = \ |
| ttLib.getTableClass('GPOS').mergeMap = \ |
| ttLib.getTableClass('BASE').mergeMap = \ |
| ttLib.getTableClass('JSTF').mergeMap = \ |
| ttLib.getTableClass('MATH').mergeMap = \ |
| { |
| 'tableTag': onlyExisting(equal), # XXX clean me up |
| 'table': mergeObjects, |
| } |
| |
| @add_method(ttLib.getTableClass('GSUB')) |
| def merge(self, m, tables): |
| |
| assert len(tables) == len(m.duplicateGlyphsPerFont) |
| for i,(table,dups) in enumerate(zip(tables, m.duplicateGlyphsPerFont)): |
| if not dups: continue |
| if table is None or table is NotImplemented: |
| log.warning("Have non-identical duplicates to resolve for '%s' but no GSUB. Are duplicates intended?: %s", m.fonts[i]._merger__name, dups) |
| continue |
| |
| synthFeature = None |
| synthLookup = None |
| for script in table.table.ScriptList.ScriptRecord: |
| if script.ScriptTag == 'DFLT': continue # XXX |
| for langsys in [script.Script.DefaultLangSys] + [l.LangSys for l in script.Script.LangSysRecord]: |
| if langsys is None: continue # XXX Create! |
| feature = [v for v in langsys.FeatureIndex if v.FeatureTag == 'locl'] |
| assert len(feature) <= 1 |
| if feature: |
| feature = feature[0] |
| else: |
| if not synthFeature: |
| synthFeature = otTables.FeatureRecord() |
| synthFeature.FeatureTag = 'locl' |
| f = synthFeature.Feature = otTables.Feature() |
| f.FeatureParams = None |
| f.LookupCount = 0 |
| f.LookupListIndex = [] |
| table.table.FeatureList.FeatureRecord.append(synthFeature) |
| table.table.FeatureList.FeatureCount += 1 |
| feature = synthFeature |
| langsys.FeatureIndex.append(feature) |
| langsys.FeatureIndex.sort(key=lambda v: v.FeatureTag) |
| |
| if not synthLookup: |
| subtable = otTables.SingleSubst() |
| subtable.mapping = dups |
| synthLookup = otTables.Lookup() |
| synthLookup.LookupFlag = 0 |
| synthLookup.LookupType = 1 |
| synthLookup.SubTableCount = 1 |
| synthLookup.SubTable = [subtable] |
| if table.table.LookupList is None: |
| # mtiLib uses None as default value for LookupList, |
| # while feaLib points to an empty array with count 0 |
| # TODO: make them do the same |
| table.table.LookupList = otTables.LookupList() |
| table.table.LookupList.Lookup = [] |
| table.table.LookupList.LookupCount = 0 |
| table.table.LookupList.Lookup.append(synthLookup) |
| table.table.LookupList.LookupCount += 1 |
| |
| if feature.Feature.LookupListIndex[:1] != [synthLookup]: |
| feature.Feature.LookupListIndex[:0] = [synthLookup] |
| feature.Feature.LookupCount += 1 |
| |
| DefaultTable.merge(self, m, tables) |
| return self |
| |
| @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 mapLookups(self, lookupMap): |
| pass |
| |
| # Copied and trimmed down from subset.py |
| @add_method(otTables.ContextSubst, |
| otTables.ChainContextSubst, |
| otTables.ContextPos, |
| otTables.ChainContextPos) |
| def __merge_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: |
| self.Rule = ChainTyp+'Rule' |
| self.RuleSet = ChainTyp+'RuleSet' |
| elif Format == 2: |
| self.Rule = ChainTyp+'ClassRule' |
| self.RuleSet = ChainTyp+'ClassSet' |
| |
| if self.Format not in [1, 2, 3]: |
| return None # Don't shoot the messenger; let it go |
| if not hasattr(self.__class__, "_merge__ContextHelpers"): |
| self.__class__._merge__ContextHelpers = {} |
| if self.Format not in self.__class__._merge__ContextHelpers: |
| helper = ContextHelper(self.__class__, self.Format) |
| self.__class__._merge__ContextHelpers[self.Format] = helper |
| return self.__class__._merge__ContextHelpers[self.Format] |
| |
| |
| @add_method(otTables.ContextSubst, |
| otTables.ChainContextSubst, |
| otTables.ContextPos, |
| otTables.ChainContextPos) |
| def mapLookups(self, lookupMap): |
| c = self.__merge_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 |
| for ll in getattr(r, c.LookupRecord): |
| if not ll: continue |
| ll.LookupListIndex = lookupMap[ll.LookupListIndex] |
| elif self.Format == 3: |
| for ll in getattr(self, c.LookupRecord): |
| if not ll: continue |
| ll.LookupListIndex = lookupMap[ll.LookupListIndex] |
| else: |
| assert 0, "unknown format: %s" % self.Format |
| |
| @add_method(otTables.ExtensionSubst, |
| otTables.ExtensionPos) |
| def mapLookups(self, lookupMap): |
| if self.Format == 1: |
| self.ExtSubTable.mapLookups(lookupMap) |
| else: |
| assert 0, "unknown format: %s" % self.Format |
| |
| @add_method(otTables.Lookup) |
| def mapLookups(self, lookupMap): |
| for st in self.SubTable: |
| if not st: continue |
| st.mapLookups(lookupMap) |
| |
| @add_method(otTables.LookupList) |
| def mapLookups(self, lookupMap): |
| for l in self.Lookup: |
| if not l: continue |
| l.mapLookups(lookupMap) |
| |
| @add_method(otTables.Lookup) |
| def mapMarkFilteringSets(self, markFilteringSetMap): |
| if self.LookupFlag & 0x0010: |
| self.MarkFilteringSet = markFilteringSetMap[self.MarkFilteringSet] |
| |
| @add_method(otTables.LookupList) |
| def mapMarkFilteringSets(self, markFilteringSetMap): |
| for l in self.Lookup: |
| if not l: continue |
| l.mapMarkFilteringSets(markFilteringSetMap) |
| |
| @add_method(otTables.Feature) |
| def mapLookups(self, lookupMap): |
| self.LookupListIndex = [lookupMap[i] for i in self.LookupListIndex] |
| |
| @add_method(otTables.FeatureList) |
| def mapLookups(self, lookupMap): |
| for f in self.FeatureRecord: |
| if not f or not f.Feature: continue |
| f.Feature.mapLookups(lookupMap) |
| |
| @add_method(otTables.DefaultLangSys, |
| otTables.LangSys) |
| def mapFeatures(self, featureMap): |
| self.FeatureIndex = [featureMap[i] for i in self.FeatureIndex] |
| if self.ReqFeatureIndex != 65535: |
| self.ReqFeatureIndex = featureMap[self.ReqFeatureIndex] |
| |
| @add_method(otTables.Script) |
| def mapFeatures(self, featureMap): |
| if self.DefaultLangSys: |
| self.DefaultLangSys.mapFeatures(featureMap) |
| for l in self.LangSysRecord: |
| if not l or not l.LangSys: continue |
| l.LangSys.mapFeatures(featureMap) |
| |
| @add_method(otTables.ScriptList) |
| def mapFeatures(self, featureMap): |
| for s in self.ScriptRecord: |
| if not s or not s.Script: continue |
| s.Script.mapFeatures(featureMap) |
| |
| def layoutPreMerge(font): |
| # Map indices to references |
| |
| GDEF = font.get('GDEF') |
| GSUB = font.get('GSUB') |
| GPOS = font.get('GPOS') |
| |
| for t in [GSUB, GPOS]: |
| if not t: continue |
| |
| if t.table.LookupList: |
| lookupMap = {i:v for i,v in enumerate(t.table.LookupList.Lookup)} |
| t.table.LookupList.mapLookups(lookupMap) |
| t.table.FeatureList.mapLookups(lookupMap) |
| |
| if GDEF and GDEF.table.Version >= 0x00010002: |
| markFilteringSetMap = {i:v for i,v in enumerate(GDEF.table.MarkGlyphSetsDef.Coverage)} |
| t.table.LookupList.mapMarkFilteringSets(markFilteringSetMap) |
| |
| if t.table.FeatureList and t.table.ScriptList: |
| featureMap = {i:v for i,v in enumerate(t.table.FeatureList.FeatureRecord)} |
| t.table.ScriptList.mapFeatures(featureMap) |
| |
| # TODO FeatureParams nameIDs |
| |
| def layoutPostMerge(font): |
| # Map references back to indices |
| |
| GDEF = font.get('GDEF') |
| GSUB = font.get('GSUB') |
| GPOS = font.get('GPOS') |
| |
| for t in [GSUB, GPOS]: |
| if not t: continue |
| |
| if t.table.FeatureList and t.table.ScriptList: |
| |
| # Collect unregistered (new) features. |
| featureMap = GregariousIdentityDict(t.table.FeatureList.FeatureRecord) |
| t.table.ScriptList.mapFeatures(featureMap) |
| |
| # Record used features. |
| featureMap = AttendanceRecordingIdentityDict(t.table.FeatureList.FeatureRecord) |
| t.table.ScriptList.mapFeatures(featureMap) |
| usedIndices = featureMap.s |
| |
| # Remove unused features |
| t.table.FeatureList.FeatureRecord = [f for i,f in enumerate(t.table.FeatureList.FeatureRecord) if i in usedIndices] |
| |
| # Map back to indices. |
| featureMap = NonhashableDict(t.table.FeatureList.FeatureRecord) |
| t.table.ScriptList.mapFeatures(featureMap) |
| |
| t.table.FeatureList.FeatureCount = len(t.table.FeatureList.FeatureRecord) |
| |
| if t.table.LookupList: |
| |
| # Collect unregistered (new) lookups. |
| lookupMap = GregariousIdentityDict(t.table.LookupList.Lookup) |
| t.table.FeatureList.mapLookups(lookupMap) |
| t.table.LookupList.mapLookups(lookupMap) |
| |
| # Record used lookups. |
| lookupMap = AttendanceRecordingIdentityDict(t.table.LookupList.Lookup) |
| t.table.FeatureList.mapLookups(lookupMap) |
| t.table.LookupList.mapLookups(lookupMap) |
| usedIndices = lookupMap.s |
| |
| # Remove unused lookups |
| t.table.LookupList.Lookup = [l for i,l in enumerate(t.table.LookupList.Lookup) if i in usedIndices] |
| |
| # Map back to indices. |
| lookupMap = NonhashableDict(t.table.LookupList.Lookup) |
| t.table.FeatureList.mapLookups(lookupMap) |
| t.table.LookupList.mapLookups(lookupMap) |
| |
| t.table.LookupList.LookupCount = len(t.table.LookupList.Lookup) |
| |
| if GDEF and GDEF.table.Version >= 0x00010002: |
| markFilteringSetMap = NonhashableDict(GDEF.table.MarkGlyphSetsDef.Coverage) |
| t.table.LookupList.mapMarkFilteringSets(markFilteringSetMap) |
| |
| # TODO FeatureParams nameIDs |