Source code for fontTools.ttLib.ttFont

from fontTools.misc import xmlWriter
from fontTools.misc.py23 import *
from fontTools.misc.loggingTools import deprecateArgument
from fontTools.ttLib import TTLibError
from fontTools.ttLib.sfnt import SFNTReader, SFNTWriter
import os
import logging
import itertools

log = logging.getLogger(__name__)

[docs]class TTFont(object): """The main font object. It manages file input and output, and offers a convenient way of accessing tables. Tables will be only decompiled when necessary, ie. when they're actually accessed. This means that simple operations can be extremely fast. """ def __init__(self, file=None, res_name_or_index=None, sfntVersion="\000\001\000\000", flavor=None, checkChecksums=0, verbose=None, recalcBBoxes=True, allowVID=False, ignoreDecompileErrors=False, recalcTimestamp=True, fontNumber=-1, lazy=None, quiet=None, _tableCache=None): """The constructor can be called with a few different arguments. When reading a font from disk, 'file' should be either a pathname pointing to a file, or a readable file object. It we're running on a Macintosh, 'res_name_or_index' maybe an sfnt resource name or an sfnt resource index number or zero. The latter case will cause TTLib to autodetect whether the file is a flat file or a suitcase. (If it's a suitcase, only the first 'sfnt' resource will be read!) The 'checkChecksums' argument is used to specify how sfnt checksums are treated upon reading a file from disk: 0: don't check (default) 1: check, print warnings if a wrong checksum is found 2: check, raise an exception if a wrong checksum is found. The TTFont constructor can also be called without a 'file' argument: this is the way to create a new empty font. In this case you can optionally supply the 'sfntVersion' argument, and a 'flavor' which can be None, 'woff', or 'woff2'. If the recalcBBoxes argument is false, a number of things will *not* be recalculated upon save/compile: 1) 'glyf' glyph bounding boxes 2) 'CFF ' font bounding box 3) 'head' font bounding box 4) 'hhea' min/max values 5) 'vhea' min/max values (1) is needed for certain kinds of CJK fonts (ask Werner Lemberg ;-). Additionally, upon importing an TTX file, this option cause glyphs to be compiled right away. This should reduce memory consumption greatly, and therefore should have some impact on the time needed to parse/compile large fonts. If the recalcTimestamp argument is false, the modified timestamp in the 'head' table will *not* be recalculated upon save/compile. If the allowVID argument is set to true, then virtual GID's are supported. Asking for a glyph ID with a glyph name or GID that is not in the font will return a virtual GID. This is valid for GSUB and cmap tables. For SING glyphlets, the cmap table is used to specify Unicode values for virtual GI's used in GSUB/GPOS rules. If the gid N is requested and does not exist in the font, or the glyphname has the form glyphN and does not exist in the font, then N is used as the virtual GID. Else, the first virtual GID is assigned as 0x1000 -1; for subsequent new virtual GIDs, the next is one less than the previous. If ignoreDecompileErrors is set to True, exceptions raised in individual tables during decompilation will be ignored, falling back to the DefaultTable implementation, which simply keeps the binary data. If lazy is set to True, many data structures are loaded lazily, upon access only. If it is set to False, many data structures are loaded immediately. The default is lazy=None which is somewhere in between. """ for name in ("verbose", "quiet"): val = locals().get(name) if val is not None: deprecateArgument(name, "configure logging instead") setattr(self, name, val) self.lazy = lazy self.recalcBBoxes = recalcBBoxes self.recalcTimestamp = recalcTimestamp self.tables = {} self.reader = None # Permit the user to reference glyphs that are not int the font. self.last_vid = 0xFFFE # Can't make it be 0xFFFF, as the world is full unsigned short integer counters that get incremented after the last seen GID value. self.reverseVIDDict = {} self.VIDDict = {} self.allowVID = allowVID self.ignoreDecompileErrors = ignoreDecompileErrors if not file: self.sfntVersion = sfntVersion self.flavor = flavor self.flavorData = None return if not hasattr(file, "read"): closeStream = True # assume file is a string if res_name_or_index is not None: # see if it contains 'sfnt' resources in the resource or data fork from . import macUtils if res_name_or_index == 0: if macUtils.getSFNTResIndices(file): # get the first available sfnt font. file = macUtils.SFNTResourceReader(file, 1) else: file = open(file, "rb") else: file = macUtils.SFNTResourceReader(file, res_name_or_index) else: file = open(file, "rb") else: # assume "file" is a readable file object closeStream = False if not self.lazy: # read input file in memory and wrap a stream around it to allow overwriting tmp = BytesIO( if hasattr(file, 'name'): # save reference to input file name = if closeStream: file.close() file = tmp self._tableCache = _tableCache self.reader = SFNTReader(file, checkChecksums, fontNumber=fontNumber) self.sfntVersion = self.reader.sfntVersion self.flavor = self.reader.flavor self.flavorData = self.reader.flavorData def __enter__(self): return self def __exit__(self, type, value, traceback): self.close()
[docs] def close(self): """If we still have a reader object, close it.""" if self.reader is not None: self.reader.close()
[docs] def save(self, file, reorderTables=True): """Save the font to disk. Similarly to the constructor, the 'file' argument can be either a pathname or a writable file object. """ if not hasattr(file, "write"): if self.lazy and == file: raise TTLibError( "Can't overwrite TTFont when 'lazy' attribute is True") closeStream = True file = open(file, "wb") else: # assume "file" is a writable file object closeStream = False tmp = BytesIO() writer_reordersTables = self._save(tmp) if (reorderTables is None or writer_reordersTables or (reorderTables is False and self.reader is None)): # don't reorder tables and save as is file.write(tmp.getvalue()) tmp.close() else: if reorderTables is False: # sort tables using the original font's order tableOrder = list(self.reader.keys()) else: # use the recommended order from the OpenType specification tableOrder = None tmp.flush() tmp2 = BytesIO() reorderFontTables(tmp, tmp2, tableOrder) file.write(tmp2.getvalue()) tmp.close() tmp2.close() if closeStream: file.close()
[docs] def _save(self, file, tableCache=None): """Internal function, to be shared by save() and""" if self.recalcTimestamp and 'head' in self: self['head'] # make sure 'head' is loaded so the recalculation is actually done tags = list(self.keys()) if "GlyphOrder" in tags: tags.remove("GlyphOrder") numTables = len(tags) # write to a temporary stream to allow saving to unseekable streams writer = SFNTWriter(file, numTables, self.sfntVersion, self.flavor, self.flavorData) done = [] for tag in tags: self._writeTable(tag, writer, done, tableCache) writer.close() return writer.reordersTables()
[docs] def saveXML(self, fileOrPath, newlinestr=None, **kwargs): """Export the font as TTX (an XML-based text file), or as a series of text files when splitTables is true. In the latter case, the 'fileOrPath' argument should be a path to a directory. The 'tables' argument must either be false (dump all tables) or a list of tables to dump. The 'skipTables' argument may be a list of tables to skip, but only when the 'tables' argument is false. """ writer = xmlWriter.XMLWriter(fileOrPath, newlinestr=newlinestr) self._saveXML(writer, **kwargs) writer.close()
[docs] def _saveXML(self, writer, writeVersion=True, quiet=None, tables=None, skipTables=None, splitTables=False, splitGlyphs=False, disassembleInstructions=True, bitmapGlyphDataFormat='raw'): if quiet is not None: deprecateArgument("quiet", "configure logging instead") self.disassembleInstructions = disassembleInstructions self.bitmapGlyphDataFormat = bitmapGlyphDataFormat if not tables: tables = list(self.keys()) if "GlyphOrder" not in tables: tables = ["GlyphOrder"] + tables if skipTables: for tag in skipTables: if tag in tables: tables.remove(tag) numTables = len(tables) if writeVersion: from fontTools import version version = ".".join(version.split('.')[:2]) writer.begintag("ttFont", sfntVersion=repr(tostr(self.sfntVersion))[1:-1], ttLibVersion=version) else: writer.begintag("ttFont", sfntVersion=repr(tostr(self.sfntVersion))[1:-1]) writer.newline() # always splitTables if splitGlyphs is enabled splitTables = splitTables or splitGlyphs if not splitTables: writer.newline() else: path, ext = os.path.splitext(writer.filename) fileNameTemplate = path + ".%s" + ext for i in range(numTables): tag = tables[i] if splitTables: tablePath = fileNameTemplate % tagToIdentifier(tag) tableWriter = xmlWriter.XMLWriter(tablePath, newlinestr=writer.newlinestr) tableWriter.begintag("ttFont", ttLibVersion=version) tableWriter.newline() tableWriter.newline() writer.simpletag(tagToXML(tag), src=os.path.basename(tablePath)) writer.newline() else: tableWriter = writer self._tableToXML(tableWriter, tag, splitGlyphs=splitGlyphs) if splitTables: tableWriter.endtag("ttFont") tableWriter.newline() tableWriter.close() writer.endtag("ttFont") writer.newline()
[docs] def _tableToXML(self, writer, tag, quiet=None, splitGlyphs=False): if quiet is not None: deprecateArgument("quiet", "configure logging instead") if tag in self: table = self[tag] report = "Dumping '%s' table..." % tag else: report = "No '%s' table found." % tag if tag not in self: return xmlTag = tagToXML(tag) attrs = dict() if hasattr(table, "ERROR"): attrs['ERROR'] = "decompilation error" from .tables.DefaultTable import DefaultTable if table.__class__ == DefaultTable: attrs['raw'] = True writer.begintag(xmlTag, **attrs) writer.newline() if tag == "glyf": table.toXML(writer, self, splitGlyphs=splitGlyphs) else: table.toXML(writer, self) writer.endtag(xmlTag) writer.newline() writer.newline()
[docs] def importXML(self, fileOrPath, quiet=None): """Import a TTX file (an XML-based text format), so as to recreate a font object. """ if quiet is not None: deprecateArgument("quiet", "configure logging instead") if "maxp" in self and "post" in self: # Make sure the glyph order is loaded, as it otherwise gets # lost if the XML doesn't contain the glyph order, yet does # contain the table which was originally used to extract the # glyph names from (ie. 'post', 'cmap' or 'CFF '). self.getGlyphOrder() from fontTools.misc import xmlReader reader = xmlReader.XMLReader(fileOrPath, self)
[docs] def isLoaded(self, tag): """Return true if the table identified by 'tag' has been decompiled and loaded into memory.""" return tag in self.tables
[docs] def has_key(self, tag): if self.isLoaded(tag): return True elif self.reader and tag in self.reader: return True elif tag == "GlyphOrder": return True else: return False
__contains__ = has_key
[docs] def keys(self): keys = list(self.tables.keys()) if self.reader: for key in list(self.reader.keys()): if key not in keys: keys.append(key) if "GlyphOrder" in keys: keys.remove("GlyphOrder") keys = sortedTagList(keys) return ["GlyphOrder"] + keys
def __len__(self): return len(list(self.keys())) def __getitem__(self, tag): tag = Tag(tag) try: return self.tables[tag] except KeyError: if tag == "GlyphOrder": table = GlyphOrder(tag) self.tables[tag] = table return table if self.reader is not None: import traceback log.debug("Reading '%s' table from disk", tag) data = self.reader[tag] if self._tableCache is not None: table = self._tableCache.get((Tag(tag), data)) if table is not None: return table tableClass = getTableClass(tag) table = tableClass(tag) self.tables[tag] = table log.debug("Decompiling '%s' table", tag) try: table.decompile(data, self) except: if not self.ignoreDecompileErrors: raise # fall back to DefaultTable, retaining the binary table data log.exception( "An exception occurred during the decompilation of the '%s' table", tag) from .tables.DefaultTable import DefaultTable file = StringIO() traceback.print_exc(file=file) table = DefaultTable(tag) table.ERROR = file.getvalue() self.tables[tag] = table table.decompile(data, self) if self._tableCache is not None: self._tableCache[(Tag(tag), data)] = table return table else: raise KeyError("'%s' table not found" % tag) def __setitem__(self, tag, table): self.tables[Tag(tag)] = table def __delitem__(self, tag): if tag not in self: raise KeyError("'%s' table not found" % tag) if tag in self.tables: del self.tables[tag] if self.reader and tag in self.reader: del self.reader[tag]
[docs] def get(self, tag, default=None): try: return self[tag] except KeyError: return default
[docs] def setGlyphOrder(self, glyphOrder): self.glyphOrder = glyphOrder
[docs] def getGlyphOrder(self): try: return self.glyphOrder except AttributeError: pass if 'CFF ' in self: cff = self['CFF '] self.glyphOrder = cff.getGlyphOrder() elif 'post' in self: # TrueType font glyphOrder = self['post'].getGlyphOrder() if glyphOrder is None: # # No names found in the 'post' table. # Try to create glyph names from the unicode cmap (if available) # in combination with the Adobe Glyph List (AGL). # self._getGlyphNamesFromCmap() else: self.glyphOrder = glyphOrder else: self._getGlyphNamesFromCmap() return self.glyphOrder
[docs] def _getGlyphNamesFromCmap(self): # # This is rather convoluted, but then again, it's an interesting problem: # - we need to use the unicode values found in the cmap table to # build glyph names (eg. because there is only a minimal post table, # or none at all). # - but the cmap parser also needs glyph names to work with... # So here's what we do: # - make up glyph names based on glyphID # - load a temporary cmap table based on those names # - extract the unicode values, build the "real" glyph names # - unload the temporary cmap table # if self.isLoaded("cmap"): # Bootstrapping: we're getting called by the cmap parser # itself. This means self.tables['cmap'] contains a partially # loaded cmap, making it impossible to get at a unicode # subtable here. We remove the partially loaded cmap and # restore it later. # This only happens if the cmap table is loaded before any # other table that does f.getGlyphOrder() or f.getGlyphName(). cmapLoading = self.tables['cmap'] del self.tables['cmap'] else: cmapLoading = None # Make up glyph names based on glyphID, which will be used by the # temporary cmap and by the real cmap in case we don't find a unicode # cmap. numGlyphs = int(self['maxp'].numGlyphs) glyphOrder = [None] * numGlyphs glyphOrder[0] = ".notdef" for i in range(1, numGlyphs): glyphOrder[i] = "glyph%.5d" % i # Set the glyph order, so the cmap parser has something # to work with (so we don't get called recursively). self.glyphOrder = glyphOrder # Make up glyph names based on the reversed cmap table. Because some # glyphs (eg. ligatures or alternates) may not be reachable via cmap, # this naming table will usually not cover all glyphs in the font. # If the font has no Unicode cmap table, reversecmap will be empty. if 'cmap' in self: reversecmap = self['cmap'].buildReversed() else: reversecmap = {} useCount = {} for i in range(numGlyphs): tempName = glyphOrder[i] if tempName in reversecmap: # If a font maps both U+0041 LATIN CAPITAL LETTER A and # U+0391 GREEK CAPITAL LETTER ALPHA to the same glyph, # we prefer naming the glyph as "A". glyphName = self._makeGlyphName(min(reversecmap[tempName])) numUses = useCount[glyphName] = useCount.get(glyphName, 0) + 1 if numUses > 1: glyphName = "%s.alt%d" % (glyphName, numUses - 1) glyphOrder[i] = glyphName if 'cmap' in self: # Delete the temporary cmap table from the cache, so it can # be parsed again with the right names. del self.tables['cmap'] self.glyphOrder = glyphOrder if cmapLoading: # restore partially loaded cmap, so it can continue loading # using the proper names. self.tables['cmap'] = cmapLoading
[docs] @staticmethod def _makeGlyphName(codepoint): from fontTools import agl # Adobe Glyph List if codepoint in agl.UV2AGL: return agl.UV2AGL[codepoint] elif codepoint <= 0xFFFF: return "uni%04X" % codepoint else: return "u%X" % codepoint
[docs] def getGlyphNames(self): """Get a list of glyph names, sorted alphabetically.""" glyphNames = sorted(self.getGlyphOrder()) return glyphNames
[docs] def getGlyphNames2(self): """Get a list of glyph names, sorted alphabetically, but not case sensitive. """ from fontTools.misc import textTools return textTools.caselessSort(self.getGlyphOrder())
[docs] def getGlyphName(self, glyphID, requireReal=False): try: return self.getGlyphOrder()[glyphID] except IndexError: if requireReal or not self.allowVID: # XXX The ??.W8.otf font that ships with OSX uses higher glyphIDs in # the cmap table than there are glyphs. I don't think it's legal... return "glyph%.5d" % glyphID else: # user intends virtual GID support try: glyphName = self.VIDDict[glyphID] except KeyError: glyphName ="glyph%.5d" % glyphID self.last_vid = min(glyphID, self.last_vid ) self.reverseVIDDict[glyphName] = glyphID self.VIDDict[glyphID] = glyphName return glyphName
[docs] def getGlyphID(self, glyphName, requireReal=False): if not hasattr(self, "_reverseGlyphOrderDict"): self._buildReverseGlyphOrderDict() glyphOrder = self.getGlyphOrder() d = self._reverseGlyphOrderDict if glyphName not in d: if glyphName in glyphOrder: self._buildReverseGlyphOrderDict() return self.getGlyphID(glyphName) else: if requireReal: raise KeyError(glyphName) elif not self.allowVID: # Handle glyphXXX only if glyphName[:5] == "glyph": try: return int(glyphName[5:]) except (NameError, ValueError): raise KeyError(glyphName) else: # user intends virtual GID support try: glyphID = self.reverseVIDDict[glyphName] except KeyError: # if name is in glyphXXX format, use the specified name. if glyphName[:5] == "glyph": try: glyphID = int(glyphName[5:]) except (NameError, ValueError): glyphID = None if glyphID is None: glyphID = self.last_vid -1 self.last_vid = glyphID self.reverseVIDDict[glyphName] = glyphID self.VIDDict[glyphID] = glyphName return glyphID glyphID = d[glyphName] if glyphName != glyphOrder[glyphID]: self._buildReverseGlyphOrderDict() return self.getGlyphID(glyphName) return glyphID
[docs] def getReverseGlyphMap(self, rebuild=False): if rebuild or not hasattr(self, "_reverseGlyphOrderDict"): self._buildReverseGlyphOrderDict() return self._reverseGlyphOrderDict
[docs] def _buildReverseGlyphOrderDict(self): self._reverseGlyphOrderDict = d = {} glyphOrder = self.getGlyphOrder() for glyphID in range(len(glyphOrder)): d[glyphOrder[glyphID]] = glyphID
[docs] def _writeTable(self, tag, writer, done, tableCache=None): """Internal helper function for Keeps track of inter-table dependencies. """ if tag in done: return tableClass = getTableClass(tag) for masterTable in tableClass.dependencies: if masterTable not in done: if masterTable in self: self._writeTable(masterTable, writer, done, tableCache) else: done.append(masterTable) done.append(tag) tabledata = self.getTableData(tag) if tableCache is not None: entry = tableCache.get((Tag(tag), tabledata)) if entry is not None: log.debug("reusing '%s' table", tag) writer.setEntry(tag, entry) return log.debug("writing '%s' table to disk", tag) writer[tag] = tabledata if tableCache is not None: tableCache[(Tag(tag), tabledata)] = writer[tag]
[docs] def getTableData(self, tag): """Returns raw table data, whether compiled or directly read from disk. """ tag = Tag(tag) if self.isLoaded(tag): log.debug("compiling '%s' table", tag) return self.tables[tag].compile(self) elif self.reader and tag in self.reader: log.debug("Reading '%s' table from disk", tag) return self.reader[tag] else: raise KeyError(tag)
[docs] def getGlyphSet(self, preferCFF=True): """Return a generic GlyphSet, which is a dict-like object mapping glyph names to glyph objects. The returned glyph objects have a .draw() method that supports the Pen protocol, and will have an attribute named 'width'. If the font is CFF-based, the outlines will be taken from the 'CFF ' or 'CFF2' tables. Otherwise the outlines will be taken from the 'glyf' table. If the font contains both a 'CFF '/'CFF2' and a 'glyf' table, you can use the 'preferCFF' argument to specify which one should be taken. If the font contains both a 'CFF ' and a 'CFF2' table, the latter is taken. """ glyphs = None if (preferCFF and any(tb in self for tb in ["CFF ", "CFF2"]) or ("glyf" not in self and any(tb in self for tb in ["CFF ", "CFF2"]))): table_tag = "CFF2" if "CFF2" in self else "CFF " glyphs = _TTGlyphSet(self, list(self[table_tag].cff.values())[0].CharStrings, _TTGlyphCFF) if glyphs is None and "glyf" in self: glyphs = _TTGlyphSet(self, self["glyf"], _TTGlyphGlyf) if glyphs is None: raise TTLibError("Font contains no outlines") return glyphs
[docs] def getBestCmap(self, cmapPreferences=((3, 10), (0, 6), (0, 4), (3, 1), (0, 3), (0, 2), (0, 1), (0, 0))): """Return the 'best' unicode cmap dictionary available in the font, or None, if no unicode cmap subtable is available. By default it will search for the following (platformID, platEncID) pairs: (3, 10), (0, 6), (0, 4), (3, 1), (0, 3), (0, 2), (0, 1), (0, 0) This can be customized via the cmapPreferences argument. """ return self["cmap"].getBestCmap(cmapPreferences=cmapPreferences)
[docs]class _TTGlyphSet(object): """Generic dict-like GlyphSet class that pulls metrics from hmtx and glyph shape from TrueType or CFF. """ def __init__(self, ttFont, glyphs, glyphType): """Construct a new glyphset. Args: font (TTFont): The font object (used to get metrics). glyphs (dict): A dictionary mapping glyph names to ``_TTGlyph`` objects. glyphType (class): Either ``_TTGlyphCFF`` or ``_TTGlyphGlyf``. """ self._glyphs = glyphs self._hmtx = ttFont['hmtx'] self._vmtx = ttFont['vmtx'] if 'vmtx' in ttFont else None self._glyphType = glyphType
[docs] def keys(self): return list(self._glyphs.keys())
[docs] def has_key(self, glyphName): return glyphName in self._glyphs
__contains__ = has_key def __getitem__(self, glyphName): horizontalMetrics = self._hmtx[glyphName] verticalMetrics = self._vmtx[glyphName] if self._vmtx else None return self._glyphType( self, self._glyphs[glyphName], horizontalMetrics, verticalMetrics) def __len__(self): return len(self._glyphs)
[docs] def get(self, glyphName, default=None): try: return self[glyphName] except KeyError: return default
[docs]class _TTGlyph(object): """Wrapper for a TrueType glyph that supports the Pen protocol, meaning that it has .draw() and .drawPoints() methods that take a pen object as their only argument. Additionally there are 'width' and 'lsb' attributes, read from the 'hmtx' table. If the font contains a 'vmtx' table, there will also be 'height' and 'tsb' attributes. """ def __init__(self, glyphset, glyph, horizontalMetrics, verticalMetrics=None): """Construct a new _TTGlyph. Args: glyphset (_TTGlyphSet): A glyphset object used to resolve components. glyph (ttLib.tables._g_l_y_f.Glyph): The glyph object. horizontalMetrics (int, int): The glyph's width and left sidebearing. """ self._glyphset = glyphset self._glyph = glyph self.width, self.lsb = horizontalMetrics if verticalMetrics: self.height, self.tsb = verticalMetrics else: self.height, self.tsb = None, None
[docs] def draw(self, pen): """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details how that works. """ self._glyph.draw(pen)
[docs] def drawPoints(self, pen): # drawPoints is only implemented for _TTGlyphGlyf at this time. raise NotImplementedError()
[docs]class _TTGlyphCFF(_TTGlyph): pass
[docs]class _TTGlyphGlyf(_TTGlyph):
[docs] def draw(self, pen): """Draw the glyph onto Pen. See fontTools.pens.basePen for details how that works. """ glyfTable = self._glyphset._glyphs glyph = self._glyph offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 glyph.draw(pen, glyfTable, offset)
[docs] def drawPoints(self, pen): """Draw the glyph onto PointPen. See fontTools.pens.pointPen for details how that works. """ glyfTable = self._glyphset._glyphs glyph = self._glyph offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 glyph.drawPoints(pen, glyfTable, offset)
[docs]class GlyphOrder(object): """A pseudo table. The glyph order isn't in the font as a separate table, but it's nice to present it as such in the TTX format. """ def __init__(self, tag=None): pass
[docs] def toXML(self, writer, ttFont): glyphOrder = ttFont.getGlyphOrder() writer.comment("The 'id' attribute is only for humans; " "it is ignored when parsed.") writer.newline() for i in range(len(glyphOrder)): glyphName = glyphOrder[i] writer.simpletag("GlyphID", id=i, name=glyphName) writer.newline()
[docs] def fromXML(self, name, attrs, content, ttFont): if not hasattr(self, "glyphOrder"): self.glyphOrder = [] ttFont.setGlyphOrder(self.glyphOrder) if name == "GlyphID": self.glyphOrder.append(attrs["name"])
[docs]def getTableModule(tag): """Fetch the packer/unpacker module for a table. Return None when no module is found. """ from . import tables pyTag = tagToIdentifier(tag) try: __import__("fontTools.ttLib.tables." + pyTag) except ImportError as err: # If pyTag is found in the ImportError message, # means table is not implemented. If it's not # there, then some other module is missing, don't # suppress the error. if str(err).find(pyTag) >= 0: return None else: raise err else: return getattr(tables, pyTag)
# Registry for custom table packer/unpacker classes. Keys are table # tags, values are (moduleName, className) tuples. # See registerCustomTableClass() and getCustomTableClass() _customTableRegistry = {}
[docs]def registerCustomTableClass(tag, moduleName, className=None): """Register a custom packer/unpacker class for a table. The 'moduleName' must be an importable module. If no 'className' is given, it is derived from the tag, for example it will be table_C_U_S_T_ for a 'CUST' tag. The registered table class should be a subclass of fontTools.ttLib.tables.DefaultTable.DefaultTable """ if className is None: className = "table_" + tagToIdentifier(tag) _customTableRegistry[tag] = (moduleName, className)
[docs]def unregisterCustomTableClass(tag): """Unregister the custom packer/unpacker class for a table.""" del _customTableRegistry[tag]
[docs]def getCustomTableClass(tag): """Return the custom table class for tag, if one has been registered with 'registerCustomTableClass()'. Else return None. """ if tag not in _customTableRegistry: return None import importlib moduleName, className = _customTableRegistry[tag] module = importlib.import_module(moduleName) return getattr(module, className)
[docs]def getTableClass(tag): """Fetch the packer/unpacker class for a table.""" tableClass = getCustomTableClass(tag) if tableClass is not None: return tableClass module = getTableModule(tag) if module is None: from .tables.DefaultTable import DefaultTable return DefaultTable pyTag = tagToIdentifier(tag) tableClass = getattr(module, "table_" + pyTag) return tableClass
[docs]def getClassTag(klass): """Fetch the table tag for a class object.""" name = klass.__name__ assert name[:6] == 'table_' name = name[6:] # Chop 'table_' return identifierToTag(name)
[docs]def newTable(tag): """Return a new instance of a table.""" tableClass = getTableClass(tag) return tableClass(tag)
[docs]def _escapechar(c): """Helper function for tagToIdentifier()""" import re if re.match("[a-z0-9]", c): return "_" + c elif re.match("[A-Z]", c): return c + "_" else: return hex(byteord(c))[2:]
[docs]def tagToIdentifier(tag): """Convert a table tag to a valid (but UGLY) python identifier, as well as a filename that's guaranteed to be unique even on a caseless file system. Each character is mapped to two characters. Lowercase letters get an underscore before the letter, uppercase letters get an underscore after the letter. Trailing spaces are trimmed. Illegal characters are escaped as two hex bytes. If the result starts with a number (as the result of a hex escape), an extra underscore is prepended. Examples: 'glyf' -> '_g_l_y_f' 'cvt ' -> '_c_v_t' 'OS/2' -> 'O_S_2f_2' """ import re tag = Tag(tag) if tag == "GlyphOrder": return tag assert len(tag) == 4, "tag should be 4 characters long" while len(tag) > 1 and tag[-1] == ' ': tag = tag[:-1] ident = "" for c in tag: ident = ident + _escapechar(c) if re.match("[0-9]", ident): ident = "_" + ident return ident
[docs]def identifierToTag(ident): """the opposite of tagToIdentifier()""" if ident == "GlyphOrder": return ident if len(ident) % 2 and ident[0] == "_": ident = ident[1:] assert not (len(ident) % 2) tag = "" for i in range(0, len(ident), 2): if ident[i] == "_": tag = tag + ident[i+1] elif ident[i+1] == "_": tag = tag + ident[i] else: # assume hex tag = tag + chr(int(ident[i:i+2], 16)) # append trailing spaces tag = tag + (4 - len(tag)) * ' ' return Tag(tag)
[docs]def tagToXML(tag): """Similarly to tagToIdentifier(), this converts a TT tag to a valid XML element name. Since XML element names are case sensitive, this is a fairly simple/readable translation. """ import re tag = Tag(tag) if tag == "OS/2": return "OS_2" elif tag == "GlyphOrder": return tag if re.match("[A-Za-z_][A-Za-z_0-9]* *$", tag): return tag.strip() else: return tagToIdentifier(tag)
[docs]def xmlToTag(tag): """The opposite of tagToXML()""" if tag == "OS_2": return Tag("OS/2") if len(tag) == 8: return identifierToTag(tag) else: return Tag(tag + " " * (4 - len(tag)))
# Table order as recommended in the OpenType specification 1.4 TTFTableOrder = ["head", "hhea", "maxp", "OS/2", "hmtx", "LTSH", "VDMX", "hdmx", "cmap", "fpgm", "prep", "cvt ", "loca", "glyf", "kern", "name", "post", "gasp", "PCLT"] OTFTableOrder = ["head", "hhea", "maxp", "OS/2", "name", "cmap", "post", "CFF "]
[docs]def sortedTagList(tagList, tableOrder=None): """Return a sorted copy of tagList, sorted according to the OpenType specification, or according to a custom tableOrder. If given and not None, tableOrder needs to be a list of tag names. """ tagList = sorted(tagList) if tableOrder is None: if "DSIG" in tagList: # DSIG should be last (XXX spec reference?) tagList.remove("DSIG") tagList.append("DSIG") if "CFF " in tagList: tableOrder = OTFTableOrder else: tableOrder = TTFTableOrder orderedTables = [] for tag in tableOrder: if tag in tagList: orderedTables.append(tag) tagList.remove(tag) orderedTables.extend(tagList) return orderedTables
[docs]def reorderFontTables(inFile, outFile, tableOrder=None, checkChecksums=False): """Rewrite a font file, ordering the tables as recommended by the OpenType specification 1.4. """ reader = SFNTReader(inFile, checkChecksums=checkChecksums) writer = SFNTWriter(outFile, len(reader.tables), reader.sfntVersion, reader.flavor, reader.flavorData) tables = list(reader.keys()) for tag in sortedTagList(tables, tableOrder): writer[tag] = reader[tag] writer.close()
[docs]def maxPowerOfTwo(x): """Return the highest exponent of two, so that (2 ** exponent) <= x. Return 0 if x is 0. """ exponent = 0 while x: x = x >> 1 exponent = exponent + 1 return max(exponent - 1, 0)
[docs]def getSearchRange(n, itemSize=16): """Calculate searchRange, entrySelector, rangeShift. """ # itemSize defaults to 16, for backward compatibility # with upstream fonttools. exponent = maxPowerOfTwo(n) searchRange = (2 ** exponent) * itemSize entrySelector = exponent rangeShift = max(0, n * itemSize - searchRange) return searchRange, entrySelector, rangeShift