fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/_c_v_a_r.py

@@ -0,0 +1,94 @@
+from . import DefaultTable
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytesjoin
+from fontTools.ttLib.tables.TupleVariation import (
+    compileTupleVariationStore,
+    decompileTupleVariationStore,
+    TupleVariation,
+)
+
+
+# https://www.microsoft.com/typography/otspec/cvar.htm
+# https://www.microsoft.com/typography/otspec/otvarcommonformats.htm
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6cvar.html
+
+CVAR_HEADER_FORMAT = """
+    > # big endian
+    majorVersion:        H
+    minorVersion:        H
+    tupleVariationCount: H
+    offsetToData:        H
+"""
+
+CVAR_HEADER_SIZE = sstruct.calcsize(CVAR_HEADER_FORMAT)
+
+
+class table__c_v_a_r(DefaultTable.DefaultTable):
+    """Control Value Table (CVT) variations table
+
+    The ``cvar`` table contains variations for the values in a ``cvt``
+    table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cvar
+    """
+
+    dependencies = ["cvt ", "fvar"]
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.majorVersion, self.minorVersion = 1, 0
+        self.variations = []
+
+    def compile(self, ttFont, useSharedPoints=False):
+        tupleVariationCount, tuples, data = compileTupleVariationStore(
+            variations=[v for v in self.variations if v.hasImpact()],
+            pointCount=len(ttFont["cvt "].values),
+            axisTags=[axis.axisTag for axis in ttFont["fvar"].axes],
+            sharedTupleIndices={},
+            useSharedPoints=useSharedPoints,
+        )
+        header = {
+            "majorVersion": self.majorVersion,
+            "minorVersion": self.minorVersion,
+            "tupleVariationCount": tupleVariationCount,
+            "offsetToData": CVAR_HEADER_SIZE + len(tuples),
+        }
+        return b"".join([sstruct.pack(CVAR_HEADER_FORMAT, header), tuples, data])
+
+    def decompile(self, data, ttFont):
+        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
+        header = {}
+        sstruct.unpack(CVAR_HEADER_FORMAT, data[0:CVAR_HEADER_SIZE], header)
+        self.majorVersion = header["majorVersion"]
+        self.minorVersion = header["minorVersion"]
+        assert self.majorVersion == 1, self.majorVersion
+        self.variations = decompileTupleVariationStore(
+            tableTag=self.tableTag,
+            axisTags=axisTags,
+            tupleVariationCount=header["tupleVariationCount"],
+            pointCount=len(ttFont["cvt "].values),
+            sharedTuples=None,
+            data=data,
+            pos=CVAR_HEADER_SIZE,
+            dataPos=header["offsetToData"],
+        )
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.majorVersion = int(attrs.get("major", "1"))
+            self.minorVersion = int(attrs.get("minor", "0"))
+        elif name == "tuple":
+            valueCount = len(ttFont["cvt "].values)
+            var = TupleVariation({}, [None] * valueCount)
+            self.variations.append(var)
+            for tupleElement in content:
+                if isinstance(tupleElement, tuple):
+                    tupleName, tupleAttrs, tupleContent = tupleElement
+                    var.fromXML(tupleName, tupleAttrs, tupleContent)
+
+    def toXML(self, writer, ttFont):
+        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
+        writer.simpletag("version", major=self.majorVersion, minor=self.minorVersion)
+        writer.newline()
+        for var in self.variations:
+            var.toXML(writer, axisTags)

fontTools/ttLib/tables/_c_v_t.py

@@ -0,0 +1,56 @@
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import sys
+import array
+
+
+class table__c_v_t(DefaultTable.DefaultTable):
+    """Control Value Table
+
+    The Control Value Table holds a list of values that can be referenced
+    by TrueType font instructions.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cvt
+    """
+
+    def decompile(self, data, ttFont):
+        values = array.array("h")
+        values.frombytes(data)
+        if sys.byteorder != "big":
+            values.byteswap()
+        self.values = values
+
+    def compile(self, ttFont):
+        if not hasattr(self, "values"):
+            return b""
+        values = self.values[:]
+        if sys.byteorder != "big":
+            values.byteswap()
+        return values.tobytes()
+
+    def toXML(self, writer, ttFont):
+        for i, value in enumerate(self.values):
+            writer.simpletag("cv", value=value, index=i)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "values"):
+            self.values = array.array("h")
+        if name == "cv":
+            index = safeEval(attrs["index"])
+            value = safeEval(attrs["value"])
+            for i in range(1 + index - len(self.values)):
+                self.values.append(0)
+            self.values[index] = value
+
+    def __len__(self):
+        return len(self.values)
+
+    def __getitem__(self, index):
+        return self.values[index]
+
+    def __setitem__(self, index, value):
+        self.values[index] = value
+
+    def __delitem__(self, index):
+        del self.values[index]

fontTools/ttLib/tables/_f_e_a_t.py

@@ -0,0 +1,15 @@
+from .otBase import BaseTTXConverter
+
+
+class table__f_e_a_t(BaseTTXConverter):
+    """Feature name table
+
+    The feature name table is an AAT (Apple Advanced Typography) table for
+    storing font features, settings, and their human-readable names. It should
+    not be confused with the ``Feat`` table or the OpenType Layout ``GSUB``/``GPOS``
+    tables.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6feat.html
+    """
+
+    pass

fontTools/ttLib/tables/_f_p_g_m.py

@@ -0,0 +1,62 @@
+from . import DefaultTable
+from . import ttProgram
+
+
+class table__f_p_g_m(DefaultTable.DefaultTable):
+    """Font Program table
+
+    The ``fpgm`` table typically contains function defintions that are
+    used by font instructions. This Font Program is similar to the Control
+    Value Program that is stored in the ``prep`` table, but
+    the ``fpgm`` table is only executed one time, when the font is first
+    used.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/fpgm
+    """
+
+    def decompile(self, data, ttFont):
+        program = ttProgram.Program()
+        program.fromBytecode(data)
+        self.program = program
+
+    def compile(self, ttFont):
+        if hasattr(self, "program"):
+            return self.program.getBytecode()
+        return b""
+
+    def toXML(self, writer, ttFont):
+        self.program.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        program = ttProgram.Program()
+        program.fromXML(name, attrs, content, ttFont)
+        self.program = program
+
+    def __bool__(self):
+        """
+        >>> fpgm = table__f_p_g_m()
+        >>> bool(fpgm)
+        False
+        >>> p = ttProgram.Program()
+        >>> fpgm.program = p
+        >>> bool(fpgm)
+        False
+        >>> bc = bytearray([0])
+        >>> p.fromBytecode(bc)
+        >>> bool(fpgm)
+        True
+        >>> p.bytecode.pop()
+        0
+        >>> bool(fpgm)
+        False
+        """
+        return hasattr(self, "program") and bool(self.program)
+
+    __nonzero__ = __bool__
+
+
+if __name__ == "__main__":
+    import sys
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

fontTools/ttLib/tables/_f_v_a_r.py

@@ -0,0 +1,261 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import (
+    fixedToFloat as fi2fl,
+    floatToFixed as fl2fi,
+    floatToFixedToStr as fl2str,
+    strToFixedToFloat as str2fl,
+)
+from fontTools.misc.textTools import Tag, bytesjoin, safeEval
+from fontTools.ttLib import TTLibError
+from . import DefaultTable
+import struct
+
+
+# Apple's documentation of 'fvar':
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6fvar.html
+
+FVAR_HEADER_FORMAT = """
+    > # big endian
+    version:        L
+    offsetToData:   H
+    countSizePairs: H
+    axisCount:      H
+    axisSize:       H
+    instanceCount:  H
+    instanceSize:   H
+"""
+
+FVAR_AXIS_FORMAT = """
+    > # big endian
+    axisTag:        4s
+    minValue:       16.16F
+    defaultValue:   16.16F
+    maxValue:       16.16F
+    flags:          H
+    axisNameID:         H
+"""
+
+FVAR_INSTANCE_FORMAT = """
+    > # big endian
+    subfamilyNameID:     H
+    flags:      H
+"""
+
+
+class table__f_v_a_r(DefaultTable.DefaultTable):
+    """FonT Variations table
+
+    The ``fvar`` table contains records of the variation axes and of the
+    named instances in a variable font.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6fvar.html
+    """
+
+    dependencies = ["name"]
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.axes = []
+        self.instances = []
+
+    def compile(self, ttFont):
+        instanceSize = sstruct.calcsize(FVAR_INSTANCE_FORMAT) + (len(self.axes) * 4)
+        includePostScriptNames = any(
+            instance.postscriptNameID != 0xFFFF for instance in self.instances
+        )
+        if includePostScriptNames:
+            instanceSize += 2
+        header = {
+            "version": 0x00010000,
+            "offsetToData": sstruct.calcsize(FVAR_HEADER_FORMAT),
+            "countSizePairs": 2,
+            "axisCount": len(self.axes),
+            "axisSize": sstruct.calcsize(FVAR_AXIS_FORMAT),
+            "instanceCount": len(self.instances),
+            "instanceSize": instanceSize,
+        }
+        result = [sstruct.pack(FVAR_HEADER_FORMAT, header)]
+        result.extend([axis.compile() for axis in self.axes])
+        axisTags = [axis.axisTag for axis in self.axes]
+        for instance in self.instances:
+            result.append(instance.compile(axisTags, includePostScriptNames))
+        return bytesjoin(result)
+
+    def decompile(self, data, ttFont):
+        header = {}
+        headerSize = sstruct.calcsize(FVAR_HEADER_FORMAT)
+        header = sstruct.unpack(FVAR_HEADER_FORMAT, data[0:headerSize])
+        if header["version"] != 0x00010000:
+            raise TTLibError("unsupported 'fvar' version %04x" % header["version"])
+        pos = header["offsetToData"]
+        axisSize = header["axisSize"]
+        for _ in range(header["axisCount"]):
+            axis = Axis()
+            axis.decompile(data[pos : pos + axisSize])
+            self.axes.append(axis)
+            pos += axisSize
+        instanceSize = header["instanceSize"]
+        axisTags = [axis.axisTag for axis in self.axes]
+        for _ in range(header["instanceCount"]):
+            instance = NamedInstance()
+            instance.decompile(data[pos : pos + instanceSize], axisTags)
+            self.instances.append(instance)
+            pos += instanceSize
+
+    def toXML(self, writer, ttFont):
+        for axis in self.axes:
+            axis.toXML(writer, ttFont)
+        for instance in self.instances:
+            instance.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "Axis":
+            axis = Axis()
+            axis.fromXML(name, attrs, content, ttFont)
+            self.axes.append(axis)
+        elif name == "NamedInstance":
+            instance = NamedInstance()
+            instance.fromXML(name, attrs, content, ttFont)
+            self.instances.append(instance)
+
+    def getAxes(self):
+        return {a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in self.axes}
+
+
+class Axis(object):
+    def __init__(self):
+        self.axisTag = None
+        self.axisNameID = 0
+        self.flags = 0
+        self.minValue = -1.0
+        self.defaultValue = 0.0
+        self.maxValue = 1.0
+
+    def compile(self):
+        return sstruct.pack(FVAR_AXIS_FORMAT, self)
+
+    def decompile(self, data):
+        sstruct.unpack2(FVAR_AXIS_FORMAT, data, self)
+
+    def toXML(self, writer, ttFont):
+        name = (
+            ttFont["name"].getDebugName(self.axisNameID) if "name" in ttFont else None
+        )
+        if name is not None:
+            writer.newline()
+            writer.comment(name)
+            writer.newline()
+        writer.begintag("Axis")
+        writer.newline()
+        for tag, value in [
+            ("AxisTag", self.axisTag),
+            ("Flags", "0x%X" % self.flags),
+            ("MinValue", fl2str(self.minValue, 16)),
+            ("DefaultValue", fl2str(self.defaultValue, 16)),
+            ("MaxValue", fl2str(self.maxValue, 16)),
+            ("AxisNameID", str(self.axisNameID)),
+        ]:
+            writer.begintag(tag)
+            writer.write(value)
+            writer.endtag(tag)
+            writer.newline()
+        writer.endtag("Axis")
+        writer.newline()
+
+    def fromXML(self, name, _attrs, content, ttFont):
+        assert name == "Axis"
+        for tag, _, value in filter(lambda t: type(t) is tuple, content):
+            value = "".join(value)
+            if tag == "AxisTag":
+                self.axisTag = Tag(value)
+            elif tag in {"Flags", "MinValue", "DefaultValue", "MaxValue", "AxisNameID"}:
+                setattr(
+                    self,
+                    tag[0].lower() + tag[1:],
+                    str2fl(value, 16) if tag.endswith("Value") else safeEval(value),
+                )
+
+
+class NamedInstance(object):
+    def __init__(self):
+        self.subfamilyNameID = 0
+        self.postscriptNameID = 0xFFFF
+        self.flags = 0
+        self.coordinates = {}
+
+    def compile(self, axisTags, includePostScriptName):
+        result = [sstruct.pack(FVAR_INSTANCE_FORMAT, self)]
+        for axis in axisTags:
+            fixedCoord = fl2fi(self.coordinates[axis], 16)
+            result.append(struct.pack(">l", fixedCoord))
+        if includePostScriptName:
+            result.append(struct.pack(">H", self.postscriptNameID))
+        return bytesjoin(result)
+
+    def decompile(self, data, axisTags):
+        sstruct.unpack2(FVAR_INSTANCE_FORMAT, data, self)
+        pos = sstruct.calcsize(FVAR_INSTANCE_FORMAT)
+        for axis in axisTags:
+            value = struct.unpack(">l", data[pos : pos + 4])[0]
+            self.coordinates[axis] = fi2fl(value, 16)
+            pos += 4
+        if pos + 2 <= len(data):
+            self.postscriptNameID = struct.unpack(">H", data[pos : pos + 2])[0]
+        else:
+            self.postscriptNameID = 0xFFFF
+
+    def toXML(self, writer, ttFont):
+        name = (
+            ttFont["name"].getDebugName(self.subfamilyNameID)
+            if "name" in ttFont
+            else None
+        )
+        if name is not None:
+            writer.newline()
+            writer.comment(name)
+            writer.newline()
+        psname = (
+            ttFont["name"].getDebugName(self.postscriptNameID)
+            if "name" in ttFont
+            else None
+        )
+        if psname is not None:
+            writer.comment("PostScript: " + psname)
+            writer.newline()
+        if self.postscriptNameID == 0xFFFF:
+            writer.begintag(
+                "NamedInstance",
+                flags=("0x%X" % self.flags),
+                subfamilyNameID=self.subfamilyNameID,
+            )
+        else:
+            writer.begintag(
+                "NamedInstance",
+                flags=("0x%X" % self.flags),
+                subfamilyNameID=self.subfamilyNameID,
+                postscriptNameID=self.postscriptNameID,
+            )
+        writer.newline()
+        for axis in ttFont["fvar"].axes:
+            writer.simpletag(
+                "coord",
+                axis=axis.axisTag,
+                value=fl2str(self.coordinates[axis.axisTag], 16),
+            )
+            writer.newline()
+        writer.endtag("NamedInstance")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        assert name == "NamedInstance"
+        self.subfamilyNameID = safeEval(attrs["subfamilyNameID"])
+        self.flags = safeEval(attrs.get("flags", "0"))
+        if "postscriptNameID" in attrs:
+            self.postscriptNameID = safeEval(attrs["postscriptNameID"])
+        else:
+            self.postscriptNameID = 0xFFFF
+
+        for tag, elementAttrs, _ in filter(lambda t: type(t) is tuple, content):
+            if tag == "coord":
+                value = str2fl(elementAttrs["value"], 16)
+                self.coordinates[elementAttrs["axis"]] = value

fontTools/ttLib/tables/_g_a_s_p.py

@@ -0,0 +1,63 @@
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import struct
+
+
+GASP_SYMMETRIC_GRIDFIT = 0x0004
+GASP_SYMMETRIC_SMOOTHING = 0x0008
+GASP_DOGRAY = 0x0002
+GASP_GRIDFIT = 0x0001
+
+
+class table__g_a_s_p(DefaultTable.DefaultTable):
+    """Grid-fitting and Scan-conversion Procedure table
+
+    The ``gasp`` table defines the preferred rasterization settings for
+    the font when rendered on monochrome and greyscale output devices.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/gasp
+    """
+
+    def decompile(self, data, ttFont):
+        self.version, numRanges = struct.unpack(">HH", data[:4])
+        assert 0 <= self.version <= 1, "unknown 'gasp' format: %s" % self.version
+        data = data[4:]
+        self.gaspRange = {}
+        for i in range(numRanges):
+            rangeMaxPPEM, rangeGaspBehavior = struct.unpack(">HH", data[:4])
+            self.gaspRange[int(rangeMaxPPEM)] = int(rangeGaspBehavior)
+            data = data[4:]
+        assert not data, "too much data"
+
+    def compile(self, ttFont):
+        version = 0  # ignore self.version
+        numRanges = len(self.gaspRange)
+        data = b""
+        items = sorted(self.gaspRange.items())
+        for rangeMaxPPEM, rangeGaspBehavior in items:
+            data = data + struct.pack(">HH", rangeMaxPPEM, rangeGaspBehavior)
+            if rangeGaspBehavior & ~(GASP_GRIDFIT | GASP_DOGRAY):
+                version = 1
+        data = struct.pack(">HH", version, numRanges) + data
+        return data
+
+    def toXML(self, writer, ttFont):
+        items = sorted(self.gaspRange.items())
+        for rangeMaxPPEM, rangeGaspBehavior in items:
+            writer.simpletag(
+                "gaspRange",
+                [
+                    ("rangeMaxPPEM", rangeMaxPPEM),
+                    ("rangeGaspBehavior", rangeGaspBehavior),
+                ],
+            )
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name != "gaspRange":
+            return
+        if not hasattr(self, "gaspRange"):
+            self.gaspRange = {}
+        self.gaspRange[safeEval(attrs["rangeMaxPPEM"])] = safeEval(
+            attrs["rangeGaspBehavior"]
+        )

fontTools/ttLib/tables/_g_c_i_d.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6gcid.html
+class table__g_c_i_d(BaseTTXConverter):
+    """Glyph ID to CID table
+
+    The AAT ``gcid`` table stores glyphID-to-CID mappings.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6gcid.html
+    """
+
+    pass