fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/_l_t_a_g.py

@@ -0,0 +1,72 @@
+from fontTools.misc.textTools import bytesjoin, tobytes, safeEval
+from . import DefaultTable
+import struct
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6ltag.html
+
+
+class table__l_t_a_g(DefaultTable.DefaultTable):
+    """Language Tag table
+
+    The AAT ``ltag`` table contains mappings between the numeric codes used
+    in the language field of the ``name`` table and IETF language tags.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6ltag.html
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.version, self.flags = 1, 0
+        self.tags = []
+
+    def addTag(self, tag):
+        """Add 'tag' to the list of langauge tags if not already there.
+
+        Returns the integer index of 'tag' in the list of all tags.
+        """
+        try:
+            return self.tags.index(tag)
+        except ValueError:
+            self.tags.append(tag)
+            return len(self.tags) - 1
+
+    def decompile(self, data, ttFont):
+        self.version, self.flags, numTags = struct.unpack(">LLL", data[:12])
+        assert self.version == 1
+        self.tags = []
+        for i in range(numTags):
+            pos = 12 + i * 4
+            offset, length = struct.unpack(">HH", data[pos : pos + 4])
+            tag = data[offset : offset + length].decode("ascii")
+            self.tags.append(tag)
+
+    def compile(self, ttFont):
+        dataList = [struct.pack(">LLL", self.version, self.flags, len(self.tags))]
+        stringPool = ""
+        for tag in self.tags:
+            offset = stringPool.find(tag)
+            if offset < 0:
+                offset = len(stringPool)
+                stringPool = stringPool + tag
+            offset = offset + 12 + len(self.tags) * 4
+            dataList.append(struct.pack(">HH", offset, len(tag)))
+        dataList.append(tobytes(stringPool))
+        return bytesjoin(dataList)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", value=self.version)
+        writer.newline()
+        writer.simpletag("flags", value=self.flags)
+        writer.newline()
+        for tag in self.tags:
+            writer.simpletag("LanguageTag", tag=tag)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "tags"):
+            self.tags = []
+        if name == "LanguageTag":
+            self.tags.append(attrs["tag"])
+        elif "value" in attrs:
+            value = safeEval(attrs["value"])
+            setattr(self, name, value)

fontTools/ttLib/tables/_m_a_x_p.py

@@ -0,0 +1,147 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+
+maxpFormat_0_5 = """
+		>	# big endian
+		tableVersion:           i
+		numGlyphs:              H
+"""
+
+maxpFormat_1_0_add = """
+		>	# big endian
+		maxPoints:              H
+		maxContours:            H
+		maxCompositePoints:     H
+		maxCompositeContours:   H
+		maxZones:               H
+		maxTwilightPoints:      H
+		maxStorage:             H
+		maxFunctionDefs:        H
+		maxInstructionDefs:     H
+		maxStackElements:       H
+		maxSizeOfInstructions:  H
+		maxComponentElements:   H
+		maxComponentDepth:      H
+"""
+
+
+class table__m_a_x_p(DefaultTable.DefaultTable):
+    """Maximum Profile table
+
+    The ``maxp`` table contains the memory requirements for the data in
+    the font.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/maxp
+    """
+
+    dependencies = ["glyf"]
+
+    def decompile(self, data, ttFont):
+        dummy, data = sstruct.unpack2(maxpFormat_0_5, data, self)
+        self.numGlyphs = int(self.numGlyphs)
+        if self.tableVersion != 0x00005000:
+            dummy, data = sstruct.unpack2(maxpFormat_1_0_add, data, self)
+        assert len(data) == 0
+
+    def compile(self, ttFont):
+        if "glyf" in ttFont:
+            if ttFont.isLoaded("glyf") and ttFont.recalcBBoxes:
+                self.recalc(ttFont)
+        else:
+            pass  # CFF
+        self.numGlyphs = len(ttFont.getGlyphOrder())
+        if self.tableVersion != 0x00005000:
+            self.tableVersion = 0x00010000
+        data = sstruct.pack(maxpFormat_0_5, self)
+        if self.tableVersion == 0x00010000:
+            data = data + sstruct.pack(maxpFormat_1_0_add, self)
+        return data
+
+    def recalc(self, ttFont):
+        """Recalculate the font bounding box, and most other maxp values except
+        for the TT instructions values. Also recalculate the value of bit 1
+        of the flags field and the font bounding box of the 'head' table.
+        """
+        glyfTable = ttFont["glyf"]
+        hmtxTable = ttFont["hmtx"]
+        headTable = ttFont["head"]
+        self.numGlyphs = len(glyfTable)
+        INFINITY = 100000
+        xMin = +INFINITY
+        yMin = +INFINITY
+        xMax = -INFINITY
+        yMax = -INFINITY
+        maxPoints = 0
+        maxContours = 0
+        maxCompositePoints = 0
+        maxCompositeContours = 0
+        maxComponentElements = 0
+        maxComponentDepth = 0
+        allXMinIsLsb = 1
+        for glyphName in ttFont.getGlyphOrder():
+            g = glyfTable[glyphName]
+            if g.numberOfContours:
+                if hmtxTable[glyphName][1] != g.xMin:
+                    allXMinIsLsb = 0
+                xMin = min(xMin, g.xMin)
+                yMin = min(yMin, g.yMin)
+                xMax = max(xMax, g.xMax)
+                yMax = max(yMax, g.yMax)
+                if g.numberOfContours > 0:
+                    nPoints, nContours = g.getMaxpValues()
+                    maxPoints = max(maxPoints, nPoints)
+                    maxContours = max(maxContours, nContours)
+                elif g.isComposite():
+                    nPoints, nContours, componentDepth = g.getCompositeMaxpValues(
+                        glyfTable
+                    )
+                    maxCompositePoints = max(maxCompositePoints, nPoints)
+                    maxCompositeContours = max(maxCompositeContours, nContours)
+                    maxComponentElements = max(maxComponentElements, len(g.components))
+                    maxComponentDepth = max(maxComponentDepth, componentDepth)
+        if xMin == +INFINITY:
+            headTable.xMin = 0
+            headTable.yMin = 0
+            headTable.xMax = 0
+            headTable.yMax = 0
+        else:
+            headTable.xMin = xMin
+            headTable.yMin = yMin
+            headTable.xMax = xMax
+            headTable.yMax = yMax
+        self.maxPoints = maxPoints
+        self.maxContours = maxContours
+        self.maxCompositePoints = maxCompositePoints
+        self.maxCompositeContours = maxCompositeContours
+        self.maxComponentElements = maxComponentElements
+        self.maxComponentDepth = maxComponentDepth
+        if allXMinIsLsb:
+            headTable.flags = headTable.flags | 0x2
+        else:
+            headTable.flags = headTable.flags & ~0x2
+
+    def testrepr(self):
+        items = sorted(self.__dict__.items())
+        print(". . . . . . . . .")
+        for combo in items:
+            print("  %s: %s" % combo)
+        print(". . . . . . . . .")
+
+    def toXML(self, writer, ttFont):
+        if self.tableVersion != 0x00005000:
+            writer.comment("Most of this table will be recalculated by the compiler")
+            writer.newline()
+        formatstring, names, fixes = sstruct.getformat(maxpFormat_0_5)
+        if self.tableVersion != 0x00005000:
+            formatstring, names_1_0, fixes = sstruct.getformat(maxpFormat_1_0_add)
+            names = {**names, **names_1_0}
+        for name in names:
+            value = getattr(self, name)
+            if name == "tableVersion":
+                value = hex(value)
+            writer.simpletag(name, value=value)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        setattr(self, name, safeEval(attrs["value"]))

fontTools/ttLib/tables/_m_e_t_a.py

@@ -0,0 +1,112 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytesjoin, strjoin, readHex
+from fontTools.ttLib import TTLibError
+from . import DefaultTable
+
+# Apple's documentation of 'meta':
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6meta.html
+
+META_HEADER_FORMAT = """
+    > # big endian
+    version:     L
+    flags:       L
+    dataOffset:  L
+    numDataMaps: L
+"""
+
+
+DATA_MAP_FORMAT = """
+    > # big endian
+    tag:         4s
+    dataOffset:  L
+    dataLength:  L
+"""
+
+
+class table__m_e_t_a(DefaultTable.DefaultTable):
+    """Metadata table
+
+    The ``meta`` table contains various metadata values for the font. Each
+    category of metadata in the table is identified by a four-character tag.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/meta
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.data = {}
+
+    def decompile(self, data, ttFont):
+        headerSize = sstruct.calcsize(META_HEADER_FORMAT)
+        header = sstruct.unpack(META_HEADER_FORMAT, data[0:headerSize])
+        if header["version"] != 1:
+            raise TTLibError("unsupported 'meta' version %d" % header["version"])
+        dataMapSize = sstruct.calcsize(DATA_MAP_FORMAT)
+        for i in range(header["numDataMaps"]):
+            dataMapOffset = headerSize + i * dataMapSize
+            dataMap = sstruct.unpack(
+                DATA_MAP_FORMAT, data[dataMapOffset : dataMapOffset + dataMapSize]
+            )
+            tag = dataMap["tag"]
+            offset = dataMap["dataOffset"]
+            self.data[tag] = data[offset : offset + dataMap["dataLength"]]
+            if tag in ["dlng", "slng"]:
+                self.data[tag] = self.data[tag].decode("utf-8")
+
+    def compile(self, ttFont):
+        keys = sorted(self.data.keys())
+        headerSize = sstruct.calcsize(META_HEADER_FORMAT)
+        dataOffset = headerSize + len(keys) * sstruct.calcsize(DATA_MAP_FORMAT)
+        header = sstruct.pack(
+            META_HEADER_FORMAT,
+            {
+                "version": 1,
+                "flags": 0,
+                "dataOffset": dataOffset,
+                "numDataMaps": len(keys),
+            },
+        )
+        dataMaps = []
+        dataBlocks = []
+        for tag in keys:
+            if tag in ["dlng", "slng"]:
+                data = self.data[tag].encode("utf-8")
+            else:
+                data = self.data[tag]
+            dataMaps.append(
+                sstruct.pack(
+                    DATA_MAP_FORMAT,
+                    {"tag": tag, "dataOffset": dataOffset, "dataLength": len(data)},
+                )
+            )
+            dataBlocks.append(data)
+            dataOffset += len(data)
+        return bytesjoin([header] + dataMaps + dataBlocks)
+
+    def toXML(self, writer, ttFont):
+        for tag in sorted(self.data.keys()):
+            if tag in ["dlng", "slng"]:
+                writer.begintag("text", tag=tag)
+                writer.newline()
+                writer.write(self.data[tag])
+                writer.newline()
+                writer.endtag("text")
+                writer.newline()
+            else:
+                writer.begintag("hexdata", tag=tag)
+                writer.newline()
+                data = self.data[tag]
+                if min(data) >= 0x20 and max(data) <= 0x7E:
+                    writer.comment("ascii: " + data.decode("ascii"))
+                    writer.newline()
+                writer.dumphex(data)
+                writer.endtag("hexdata")
+                writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "hexdata":
+            self.data[attrs["tag"]] = readHex(content)
+        elif name == "text" and attrs["tag"] in ["dlng", "slng"]:
+            self.data[attrs["tag"]] = strjoin(content).strip()
+        else:
+            raise TTLibError("can't handle '%s' element" % name)

fontTools/ttLib/tables/_m_o_r_t.py

@@ -0,0 +1,14 @@
+from .otBase import BaseTTXConverter
+
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6mort.html
+class table__m_o_r_t(BaseTTXConverter):
+    """The AAT ``mort`` table contains glyph transformations used for script shaping and
+    for various other optional smart features.
+
+    Note: ``mort`` has been deprecated in favor of the newer ``morx`` table.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6mort.html
+    """
+
+    pass

fontTools/ttLib/tables/_m_o_r_x.py

@@ -0,0 +1,15 @@
+from .otBase import BaseTTXConverter
+
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html
+class table__m_o_r_x(BaseTTXConverter):
+    """The AAT ``morx`` table contains glyph transformations used for script shaping and
+    for various other optional smart features, akin to ``GSUB`` and ``GPOS`` features
+    in OpenType Layout.
+
+    Note: ``morx`` is a replacement for the now deprecated ``mort`` table.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html
+    """
+
+    pass