| # 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 |
| and GDEF.table.MarkGlyphSetsDef |
| ): |
| 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 |
