fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/_g_v_a_r.py

@@ -0,0 +1,340 @@
+from collections import deque
+from functools import partial
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from fontTools.misc.lazyTools import LazyDict
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED
+from fontTools.ttLib.tables.TupleVariation import TupleVariation
+from . import DefaultTable
+import array
+import itertools
+import logging
+import struct
+import sys
+import fontTools.ttLib.tables.TupleVariation as tv
+
+log = logging.getLogger(__name__)
+
+# https://www.microsoft.com/typography/otspec/gvar.htm
+# https://www.microsoft.com/typography/otspec/otvarcommonformats.htm
+#
+# Apple's documentation of 'gvar':
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6gvar.html
+#
+# FreeType2 source code for parsing 'gvar':
+# http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/src/truetype/ttgxvar.c
+
+GVAR_HEADER_FORMAT_HEAD = """
+	> # big endian
+	version:			H
+	reserved:			H
+	axisCount:			H
+	sharedTupleCount:		H
+	offsetToSharedTuples:		I
+"""
+# In between the HEAD and TAIL lies the glyphCount, which is
+# of different size: 2 bytes for gvar, and 3 bytes for GVAR.
+GVAR_HEADER_FORMAT_TAIL = """
+	> # big endian
+	flags:				H
+	offsetToGlyphVariationData:	I
+"""
+
+GVAR_HEADER_SIZE_HEAD = sstruct.calcsize(GVAR_HEADER_FORMAT_HEAD)
+GVAR_HEADER_SIZE_TAIL = sstruct.calcsize(GVAR_HEADER_FORMAT_TAIL)
+
+
+class table__g_v_a_r(DefaultTable.DefaultTable):
+    """Glyph Variations table
+
+    The ``gvar`` table provides the per-glyph variation data that
+    describe how glyph outlines in the ``glyf`` table change across
+    the variation space that is defined for the font in the ``fvar``
+    table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/gvar
+    """
+
+    dependencies = ["fvar", "glyf"]
+    gid_size = 2
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.version, self.reserved = 1, 0
+        self.variations = {}
+
+    def compile(self, ttFont):
+        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
+        sharedTuples = tv.compileSharedTuples(
+            axisTags, itertools.chain(*self.variations.values())
+        )
+        sharedTupleIndices = {coord: i for i, coord in enumerate(sharedTuples)}
+        sharedTupleSize = sum([len(c) for c in sharedTuples])
+        compiledGlyphs = self.compileGlyphs_(ttFont, axisTags, sharedTupleIndices)
+        offset = 0
+        offsets = []
+        for glyph in compiledGlyphs:
+            offsets.append(offset)
+            offset += len(glyph)
+        offsets.append(offset)
+        compiledOffsets, tableFormat = self.compileOffsets_(offsets)
+
+        GVAR_HEADER_SIZE = GVAR_HEADER_SIZE_HEAD + self.gid_size + GVAR_HEADER_SIZE_TAIL
+        header = {}
+        header["version"] = self.version
+        header["reserved"] = self.reserved
+        header["axisCount"] = len(axisTags)
+        header["sharedTupleCount"] = len(sharedTuples)
+        header["offsetToSharedTuples"] = GVAR_HEADER_SIZE + len(compiledOffsets)
+        header["flags"] = tableFormat
+        header["offsetToGlyphVariationData"] = (
+            header["offsetToSharedTuples"] + sharedTupleSize
+        )
+
+        result = [
+            sstruct.pack(GVAR_HEADER_FORMAT_HEAD, header),
+            len(compiledGlyphs).to_bytes(self.gid_size, "big"),
+            sstruct.pack(GVAR_HEADER_FORMAT_TAIL, header),
+        ]
+
+        result.append(compiledOffsets)
+        result.extend(sharedTuples)
+        result.extend(compiledGlyphs)
+        return b"".join(result)
+
+    def compileGlyphs_(self, ttFont, axisTags, sharedCoordIndices):
+        optimizeSpeed = ttFont.cfg[OPTIMIZE_FONT_SPEED]
+        result = []
+        glyf = ttFont["glyf"]
+        for glyphName in ttFont.getGlyphOrder():
+            variations = self.variations.get(glyphName, [])
+            if not variations:
+                result.append(b"")
+                continue
+            pointCountUnused = 0  # pointCount is actually unused by compileGlyph
+            result.append(
+                compileGlyph_(
+                    self.gid_size,
+                    variations,
+                    pointCountUnused,
+                    axisTags,
+                    sharedCoordIndices,
+                    optimizeSize=not optimizeSpeed,
+                )
+            )
+        return result
+
+    def decompile(self, data, ttFont):
+        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
+        glyphs = ttFont.getGlyphOrder()
+
+        # Parse the header
+        GVAR_HEADER_SIZE = GVAR_HEADER_SIZE_HEAD + self.gid_size + GVAR_HEADER_SIZE_TAIL
+        sstruct.unpack(GVAR_HEADER_FORMAT_HEAD, data[:GVAR_HEADER_SIZE_HEAD], self)
+        self.glyphCount = int.from_bytes(
+            data[GVAR_HEADER_SIZE_HEAD : GVAR_HEADER_SIZE_HEAD + self.gid_size], "big"
+        )
+        sstruct.unpack(
+            GVAR_HEADER_FORMAT_TAIL,
+            data[GVAR_HEADER_SIZE_HEAD + self.gid_size : GVAR_HEADER_SIZE],
+            self,
+        )
+
+        assert len(glyphs) == self.glyphCount, (len(glyphs), self.glyphCount)
+        assert len(axisTags) == self.axisCount, (
+            len(axisTags),
+            self.axisCount,
+            axisTags,
+        )
+        sharedCoords = tv.decompileSharedTuples(
+            axisTags, self.sharedTupleCount, data, self.offsetToSharedTuples
+        )
+        variations = {}
+        offsetToData = self.offsetToGlyphVariationData
+        glyf = ttFont["glyf"]
+
+        def get_read_item():
+            reverseGlyphMap = ttFont.getReverseGlyphMap()
+            tableFormat = self.flags & 1
+
+            def read_item(glyphName):
+                gid = reverseGlyphMap[glyphName]
+                offsetSize = 2 if tableFormat == 0 else 4
+                startOffset = GVAR_HEADER_SIZE + offsetSize * gid
+                endOffset = startOffset + offsetSize * 2
+                offsets = table__g_v_a_r.decompileOffsets_(
+                    data[startOffset:endOffset],
+                    tableFormat=tableFormat,
+                    glyphCount=1,
+                )
+                gvarData = data[offsetToData + offsets[0] : offsetToData + offsets[1]]
+                if not gvarData:
+                    return []
+                glyph = glyf[glyphName]
+                numPointsInGlyph = self.getNumPoints_(glyph)
+                return decompileGlyph_(
+                    self.gid_size, numPointsInGlyph, sharedCoords, axisTags, gvarData
+                )
+
+            return read_item
+
+        read_item = get_read_item()
+        l = LazyDict({glyphs[gid]: read_item for gid in range(self.glyphCount)})
+
+        self.variations = l
+
+        if ttFont.lazy is False:  # Be lazy for None and True
+            self.ensureDecompiled()
+
+    def ensureDecompiled(self, recurse=False):
+        # The recurse argument is unused, but part of the signature of
+        # ensureDecompiled across the library.
+        # Use a zero-length deque to consume the lazy dict
+        deque(self.variations.values(), maxlen=0)
+
+    @staticmethod
+    def decompileOffsets_(data, tableFormat, glyphCount):
+        if tableFormat == 0:
+            # Short format: array of UInt16
+            offsets = array.array("H")
+            offsetsSize = (glyphCount + 1) * 2
+        else:
+            # Long format: array of UInt32
+            offsets = array.array("I")
+            offsetsSize = (glyphCount + 1) * 4
+        offsets.frombytes(data[0:offsetsSize])
+        if sys.byteorder != "big":
+            offsets.byteswap()
+
+        # In the short format, offsets need to be multiplied by 2.
+        # This is not documented in Apple's TrueType specification,
+        # but can be inferred from the FreeType implementation, and
+        # we could verify it with two sample GX fonts.
+        if tableFormat == 0:
+            offsets = [off * 2 for off in offsets]
+
+        return offsets
+
+    @staticmethod
+    def compileOffsets_(offsets):
+        """Packs a list of offsets into a 'gvar' offset table.
+
+        Returns a pair (bytestring, tableFormat). Bytestring is the
+        packed offset table. Format indicates whether the table
+        uses short (tableFormat=0) or long (tableFormat=1) integers.
+        The returned tableFormat should get packed into the flags field
+        of the 'gvar' header.
+        """
+        assert len(offsets) >= 2
+        for i in range(1, len(offsets)):
+            assert offsets[i - 1] <= offsets[i]
+        if max(offsets) <= 0xFFFF * 2:
+            packed = array.array("H", [n >> 1 for n in offsets])
+            tableFormat = 0
+        else:
+            packed = array.array("I", offsets)
+            tableFormat = 1
+        if sys.byteorder != "big":
+            packed.byteswap()
+        return (packed.tobytes(), tableFormat)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", value=self.version)
+        writer.newline()
+        writer.simpletag("reserved", value=self.reserved)
+        writer.newline()
+        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
+        for glyphName in ttFont.getGlyphNames():
+            variations = self.variations.get(glyphName)
+            if not variations:
+                continue
+            writer.begintag("glyphVariations", glyph=glyphName)
+            writer.newline()
+            for gvar in variations:
+                gvar.toXML(writer, axisTags)
+            writer.endtag("glyphVariations")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = safeEval(attrs["value"])
+        elif name == "reserved":
+            self.reserved = safeEval(attrs["value"])
+        elif name == "glyphVariations":
+            if not hasattr(self, "variations"):
+                self.variations = {}
+            glyphName = attrs["glyph"]
+            glyph = ttFont["glyf"][glyphName]
+            numPointsInGlyph = self.getNumPoints_(glyph)
+            glyphVariations = []
+            for element in content:
+                if isinstance(element, tuple):
+                    name, attrs, content = element
+                    if name == "tuple":
+                        gvar = TupleVariation({}, [None] * numPointsInGlyph)
+                        glyphVariations.append(gvar)
+                        for tupleElement in content:
+                            if isinstance(tupleElement, tuple):
+                                tupleName, tupleAttrs, tupleContent = tupleElement
+                                gvar.fromXML(tupleName, tupleAttrs, tupleContent)
+            self.variations[glyphName] = glyphVariations
+
+    @staticmethod
+    def getNumPoints_(glyph):
+        NUM_PHANTOM_POINTS = 4
+
+        if glyph.isComposite():
+            return len(glyph.components) + NUM_PHANTOM_POINTS
+        else:
+            # Empty glyphs (eg. space, nonmarkingreturn) have no "coordinates" attribute.
+            return len(getattr(glyph, "coordinates", [])) + NUM_PHANTOM_POINTS
+
+
+def compileGlyph_(
+    dataOffsetSize,
+    variations,
+    pointCount,
+    axisTags,
+    sharedCoordIndices,
+    *,
+    optimizeSize=True,
+):
+    assert dataOffsetSize in (2, 3)
+    tupleVariationCount, tuples, data = tv.compileTupleVariationStore(
+        variations, pointCount, axisTags, sharedCoordIndices, optimizeSize=optimizeSize
+    )
+    if tupleVariationCount == 0:
+        return b""
+
+    offsetToData = 2 + dataOffsetSize + len(tuples)
+
+    result = [
+        tupleVariationCount.to_bytes(2, "big"),
+        offsetToData.to_bytes(dataOffsetSize, "big"),
+        tuples,
+        data,
+    ]
+    if (offsetToData + len(data)) % 2 != 0:
+        result.append(b"\0")  # padding
+    return b"".join(result)
+
+
+def decompileGlyph_(dataOffsetSize, pointCount, sharedTuples, axisTags, data):
+    assert dataOffsetSize in (2, 3)
+    if len(data) < 2 + dataOffsetSize:
+        return []
+
+    tupleVariationCount = int.from_bytes(data[:2], "big")
+    offsetToData = int.from_bytes(data[2 : 2 + dataOffsetSize], "big")
+
+    dataPos = offsetToData
+    return tv.decompileTupleVariationStore(
+        "gvar",
+        axisTags,
+        tupleVariationCount,
+        pointCount,
+        sharedTuples,
+        data,
+        2 + dataOffsetSize,
+        offsetToData,
+    )

fontTools/ttLib/tables/_h_d_m_x.py

@@ -0,0 +1,127 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytechr, byteord, strjoin
+from . import DefaultTable
+import array
+from collections.abc import Mapping
+
+hdmxHeaderFormat = """
+	>   # big endian!
+	version:	H
+	numRecords:	H
+	recordSize:	l
+"""
+
+
+class _GlyphnamedList(Mapping):
+    def __init__(self, reverseGlyphOrder, data):
+        self._array = data
+        self._map = dict(reverseGlyphOrder)
+
+    def __getitem__(self, k):
+        return self._array[self._map[k]]
+
+    def __len__(self):
+        return len(self._map)
+
+    def __iter__(self):
+        return iter(self._map)
+
+    def keys(self):
+        return self._map.keys()
+
+
+class table__h_d_m_x(DefaultTable.DefaultTable):
+    """Horizontal Device Metrics table
+
+    The ``hdmx`` table is an optional table that stores advance widths for
+    glyph outlines at specified pixel sizes.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/hdmx
+    """
+
+    def decompile(self, data, ttFont):
+        numGlyphs = ttFont["maxp"].numGlyphs
+        glyphOrder = ttFont.getGlyphOrder()
+        dummy, data = sstruct.unpack2(hdmxHeaderFormat, data, self)
+        self.hdmx = {}
+        for i in range(self.numRecords):
+            ppem = byteord(data[0])
+            maxSize = byteord(data[1])
+            widths = _GlyphnamedList(
+                ttFont.getReverseGlyphMap(), array.array("B", data[2 : 2 + numGlyphs])
+            )
+            self.hdmx[ppem] = widths
+            data = data[self.recordSize :]
+        assert len(data) == 0, "too much hdmx data"
+
+    def compile(self, ttFont):
+        self.version = 0
+        numGlyphs = ttFont["maxp"].numGlyphs
+        glyphOrder = ttFont.getGlyphOrder()
+        self.recordSize = 4 * ((2 + numGlyphs + 3) // 4)
+        pad = (self.recordSize - 2 - numGlyphs) * b"\0"
+        self.numRecords = len(self.hdmx)
+        data = sstruct.pack(hdmxHeaderFormat, self)
+        items = sorted(self.hdmx.items())
+        for ppem, widths in items:
+            data = data + bytechr(ppem) + bytechr(max(widths.values()))
+            for glyphName in glyphOrder:
+                width = widths[glyphName]
+                data = data + bytechr(width)
+            data = data + pad
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.begintag("hdmxData")
+        writer.newline()
+        ppems = sorted(self.hdmx.keys())
+        records = []
+        format = ""
+        for ppem in ppems:
+            widths = self.hdmx[ppem]
+            records.append(widths)
+            format = format + "%4d"
+        glyphNames = ttFont.getGlyphOrder()[:]
+        glyphNames.sort()
+        maxNameLen = max(map(len, glyphNames))
+        format = "%" + repr(maxNameLen) + "s:" + format + " ;"
+        writer.write(format % (("ppem",) + tuple(ppems)))
+        writer.newline()
+        writer.newline()
+        for glyphName in glyphNames:
+            row = []
+            for ppem in ppems:
+                widths = self.hdmx[ppem]
+                row.append(widths[glyphName])
+            if ";" in glyphName:
+                glyphName = "\\x3b".join(glyphName.split(";"))
+            writer.write(format % ((glyphName,) + tuple(row)))
+            writer.newline()
+        writer.endtag("hdmxData")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name != "hdmxData":
+            return
+        content = strjoin(content)
+        lines = content.split(";")
+        topRow = lines[0].split()
+        assert topRow[0] == "ppem:", "illegal hdmx format"
+        ppems = list(map(int, topRow[1:]))
+        self.hdmx = hdmx = {}
+        for ppem in ppems:
+            hdmx[ppem] = {}
+        lines = (line.split() for line in lines[1:])
+        for line in lines:
+            if not line:
+                continue
+            assert line[0][-1] == ":", "illegal hdmx format"
+            glyphName = line[0][:-1]
+            if "\\" in glyphName:
+                from fontTools.misc.textTools import safeEval
+
+                glyphName = safeEval('"""' + glyphName + '"""')
+            line = list(map(int, line[1:]))
+            assert len(line) == len(ppems), "illegal hdmx format"
+            for i, ppem in enumerate(ppems):
+                hdmx[ppem][glyphName] = line[i]

fontTools/ttLib/tables/_h_e_a_d.py

@@ -0,0 +1,130 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import floatToFixedToStr, strToFixedToFloat
+from fontTools.misc.textTools import safeEval, num2binary, binary2num
+from fontTools.misc.timeTools import (
+    timestampFromString,
+    timestampToString,
+    timestampNow,
+)
+from fontTools.misc.timeTools import epoch_diff as mac_epoch_diff  # For backward compat
+from fontTools.misc.arrayTools import intRect, unionRect
+from . import DefaultTable
+import logging
+
+
+log = logging.getLogger(__name__)
+
+headFormat = """
+		>	# big endian
+		tableVersion:       16.16F
+		fontRevision:       16.16F
+		checkSumAdjustment: I
+		magicNumber:        I
+		flags:              H
+		unitsPerEm:         H
+		created:            Q
+		modified:           Q
+		xMin:               h
+		yMin:               h
+		xMax:               h
+		yMax:               h
+		macStyle:           H
+		lowestRecPPEM:      H
+		fontDirectionHint:  h
+		indexToLocFormat:   h
+		glyphDataFormat:    h
+"""
+
+
+class table__h_e_a_d(DefaultTable.DefaultTable):
+    """Font Header table
+
+    The ``head`` table contains a variety of font-wide information.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/head
+    """
+
+    dependencies = ["maxp", "loca", "CFF ", "CFF2"]
+
+    def decompile(self, data, ttFont):
+        dummy, rest = sstruct.unpack2(headFormat, data, self)
+        if rest:
+            # this is quite illegal, but there seem to be fonts out there that do this
+            log.warning("extra bytes at the end of 'head' table")
+            assert rest == b"\0\0"
+
+        # For timestamp fields, ignore the top four bytes.  Some fonts have
+        # bogus values there.  Since till 2038 those bytes only can be zero,
+        # ignore them.
+        #
+        # https://github.com/fonttools/fonttools/issues/99#issuecomment-66776810
+        for stamp in "created", "modified":
+            value = getattr(self, stamp)
+            if value > 0xFFFFFFFF:
+                log.warning("'%s' timestamp out of range; ignoring top bytes", stamp)
+                value &= 0xFFFFFFFF
+                setattr(self, stamp, value)
+            if value < 0x7C259DC0:  # January 1, 1970 00:00:00
+                log.warning(
+                    "'%s' timestamp seems very low; regarding as unix timestamp", stamp
+                )
+                value += 0x7C259DC0
+                setattr(self, stamp, value)
+
+    def compile(self, ttFont):
+        if ttFont.recalcBBoxes:
+            # For TT-flavored fonts, xMin, yMin, xMax and yMax are set in table__m_a_x_p.recalc().
+            if "CFF " in ttFont:
+                topDict = ttFont["CFF "].cff.topDictIndex[0]
+                self.xMin, self.yMin, self.xMax, self.yMax = intRect(topDict.FontBBox)
+            elif "CFF2" in ttFont:
+                topDict = ttFont["CFF2"].cff.topDictIndex[0]
+                charStrings = topDict.CharStrings
+                fontBBox = None
+                for charString in charStrings.values():
+                    bounds = charString.calcBounds(charStrings)
+                    if bounds is not None:
+                        if fontBBox is not None:
+                            fontBBox = unionRect(fontBBox, bounds)
+                        else:
+                            fontBBox = bounds
+                if fontBBox is not None:
+                    self.xMin, self.yMin, self.xMax, self.yMax = intRect(fontBBox)
+        if ttFont.recalcTimestamp:
+            self.modified = timestampNow()
+        data = sstruct.pack(headFormat, self)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.comment("Most of this table will be recalculated by the compiler")
+        writer.newline()
+        _, names, fixes = sstruct.getformat(headFormat)
+        for name in names:
+            value = getattr(self, name)
+            if name in fixes:
+                value = floatToFixedToStr(value, precisionBits=fixes[name])
+            elif name in ("created", "modified"):
+                value = timestampToString(value)
+            elif name in ("magicNumber", "checkSumAdjustment"):
+                if value < 0:
+                    value = value + 0x100000000
+                value = hex(value)
+                if value[-1:] == "L":
+                    value = value[:-1]
+            elif name in ("macStyle", "flags"):
+                value = num2binary(value, 16)
+            writer.simpletag(name, value=value)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        value = attrs["value"]
+        fixes = sstruct.getformat(headFormat)[2]
+        if name in fixes:
+            value = strToFixedToFloat(value, precisionBits=fixes[name])
+        elif name in ("created", "modified"):
+            value = timestampFromString(value)
+        elif name in ("macStyle", "flags"):
+            value = binary2num(value)
+        else:
+            value = safeEval(value)
+        setattr(self, name, value)