fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/_h_h_e_a.py

@@ -0,0 +1,147 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from fontTools.misc.fixedTools import (
+    ensureVersionIsLong as fi2ve,
+    versionToFixed as ve2fi,
+)
+from . import DefaultTable
+import math
+
+
+hheaFormat = """
+		>  # big endian
+		tableVersion:           L
+		ascent:                 h
+		descent:                h
+		lineGap:                h
+		advanceWidthMax:        H
+		minLeftSideBearing:     h
+		minRightSideBearing:    h
+		xMaxExtent:             h
+		caretSlopeRise:         h
+		caretSlopeRun:          h
+		caretOffset:            h
+		reserved0:              h
+		reserved1:              h
+		reserved2:              h
+		reserved3:              h
+		metricDataFormat:       h
+		numberOfHMetrics:       H
+"""
+
+
+class table__h_h_e_a(DefaultTable.DefaultTable):
+    """Horizontal Header table
+
+    The ``hhea`` table contains information needed during horizontal
+    text layout.
+
+    .. note::
+       This converter class is kept in sync with the :class:`._v_h_e_a.table__v_h_e_a`
+       table constructor.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/hhea
+    """
+
+    # Note: Keep in sync with table__v_h_e_a
+
+    dependencies = ["hmtx", "glyf", "CFF ", "CFF2"]
+
+    # OpenType spec renamed these, add aliases for compatibility
+    @property
+    def ascender(self):
+        return self.ascent
+
+    @ascender.setter
+    def ascender(self, value):
+        self.ascent = value
+
+    @property
+    def descender(self):
+        return self.descent
+
+    @descender.setter
+    def descender(self, value):
+        self.descent = value
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack(hheaFormat, data, self)
+
+    def compile(self, ttFont):
+        if ttFont.recalcBBoxes and (
+            ttFont.isLoaded("glyf")
+            or ttFont.isLoaded("CFF ")
+            or ttFont.isLoaded("CFF2")
+        ):
+            self.recalc(ttFont)
+        self.tableVersion = fi2ve(self.tableVersion)
+        return sstruct.pack(hheaFormat, self)
+
+    def recalc(self, ttFont):
+        if "hmtx" not in ttFont:
+            return
+
+        hmtxTable = ttFont["hmtx"]
+        self.advanceWidthMax = max(adv for adv, _ in hmtxTable.metrics.values())
+
+        boundsWidthDict = {}
+        if "glyf" in ttFont:
+            glyfTable = ttFont["glyf"]
+            for name in ttFont.getGlyphOrder():
+                g = glyfTable[name]
+                if g.numberOfContours == 0:
+                    continue
+                if g.numberOfContours < 0 and not hasattr(g, "xMax"):
+                    # Composite glyph without extents set.
+                    # Calculate those.
+                    g.recalcBounds(glyfTable)
+                boundsWidthDict[name] = g.xMax - g.xMin
+        elif "CFF " in ttFont or "CFF2" in ttFont:
+            if "CFF " in ttFont:
+                topDict = ttFont["CFF "].cff.topDictIndex[0]
+            else:
+                topDict = ttFont["CFF2"].cff.topDictIndex[0]
+            charStrings = topDict.CharStrings
+            for name in ttFont.getGlyphOrder():
+                cs = charStrings[name]
+                bounds = cs.calcBounds(charStrings)
+                if bounds is not None:
+                    boundsWidthDict[name] = int(
+                        math.ceil(bounds[2]) - math.floor(bounds[0])
+                    )
+
+        if boundsWidthDict:
+            minLeftSideBearing = float("inf")
+            minRightSideBearing = float("inf")
+            xMaxExtent = -float("inf")
+            for name, boundsWidth in boundsWidthDict.items():
+                advanceWidth, lsb = hmtxTable[name]
+                rsb = advanceWidth - lsb - boundsWidth
+                extent = lsb + boundsWidth
+                minLeftSideBearing = min(minLeftSideBearing, lsb)
+                minRightSideBearing = min(minRightSideBearing, rsb)
+                xMaxExtent = max(xMaxExtent, extent)
+            self.minLeftSideBearing = minLeftSideBearing
+            self.minRightSideBearing = minRightSideBearing
+            self.xMaxExtent = xMaxExtent
+
+        else:  # No glyph has outlines.
+            self.minLeftSideBearing = 0
+            self.minRightSideBearing = 0
+            self.xMaxExtent = 0
+
+    def toXML(self, writer, ttFont):
+        formatstring, names, fixes = sstruct.getformat(hheaFormat)
+        for name in names:
+            value = getattr(self, name)
+            if name == "tableVersion":
+                value = fi2ve(value)
+                value = "0x%08x" % value
+            writer.simpletag(name, value=value)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "tableVersion":
+            setattr(self, name, ve2fi(attrs["value"]))
+            return
+        setattr(self, name, safeEval(attrs["value"]))

fontTools/ttLib/tables/_h_m_t_x.py

@@ -0,0 +1,164 @@
+from fontTools.misc.roundTools import otRound
+from fontTools import ttLib
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import sys
+import struct
+import array
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+class table__h_m_t_x(DefaultTable.DefaultTable):
+    """Horizontal Metrics table
+
+    The ``hmtx`` table contains per-glyph metrics for the glyphs in a
+    ``glyf``, ``CFF ``, or ``CFF2`` table, as needed for horizontal text
+    layout.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/hmtx
+    """
+
+    headerTag = "hhea"
+    advanceName = "width"
+    sideBearingName = "lsb"
+    numberOfMetricsName = "numberOfHMetrics"
+    longMetricFormat = "Hh"
+
+    def decompile(self, data, ttFont):
+        numGlyphs = ttFont["maxp"].numGlyphs
+        headerTable = ttFont.get(self.headerTag)
+        if headerTable is not None:
+            numberOfMetrics = int(getattr(headerTable, self.numberOfMetricsName))
+        else:
+            numberOfMetrics = numGlyphs
+        if numberOfMetrics > numGlyphs:
+            log.warning(
+                "The %s.%s exceeds the maxp.numGlyphs"
+                % (self.headerTag, self.numberOfMetricsName)
+            )
+            numberOfMetrics = numGlyphs
+        numberOfSideBearings = numGlyphs - numberOfMetrics
+        tableSize = 4 * numberOfMetrics + 2 * numberOfSideBearings
+        if len(data) < tableSize:
+            raise ttLib.TTLibError(
+                f"not enough '{self.tableTag}' table data: "
+                f"expected {tableSize} bytes, got {len(data)}"
+            )
+        # Note: advanceWidth is unsigned, but some font editors might
+        # read/write as signed. We can't be sure whether it was a mistake
+        # or not, so we read as unsigned but also issue a warning...
+        metricsFmt = ">" + self.longMetricFormat * numberOfMetrics
+        metrics = struct.unpack(metricsFmt, data[: 4 * numberOfMetrics])
+        data = data[4 * numberOfMetrics :]
+        sideBearings = array.array("h", data[: 2 * numberOfSideBearings])
+        data = data[2 * numberOfSideBearings :]
+
+        if sys.byteorder != "big":
+            sideBearings.byteswap()
+        if data:
+            log.warning("too much '%s' table data" % self.tableTag)
+        self.metrics = {}
+        glyphOrder = ttFont.getGlyphOrder()
+        for i in range(numberOfMetrics):
+            glyphName = glyphOrder[i]
+            advanceWidth, lsb = metrics[i * 2 : i * 2 + 2]
+            if advanceWidth > 32767:
+                log.warning(
+                    "Glyph %r has a huge advance %s (%d); is it intentional or "
+                    "an (invalid) negative value?",
+                    glyphName,
+                    self.advanceName,
+                    advanceWidth,
+                )
+            self.metrics[glyphName] = (advanceWidth, lsb)
+        lastAdvance = metrics[-2]
+        for i in range(numberOfSideBearings):
+            glyphName = glyphOrder[i + numberOfMetrics]
+            self.metrics[glyphName] = (lastAdvance, sideBearings[i])
+
+    def compile(self, ttFont):
+        metrics = []
+        hasNegativeAdvances = False
+        for glyphName in ttFont.getGlyphOrder():
+            advanceWidth, sideBearing = self.metrics[glyphName]
+            if advanceWidth < 0:
+                log.error(
+                    "Glyph %r has negative advance %s" % (glyphName, self.advanceName)
+                )
+                hasNegativeAdvances = True
+            metrics.append([advanceWidth, sideBearing])
+
+        headerTable = ttFont.get(self.headerTag)
+        if headerTable is not None:
+            lastAdvance = metrics[-1][0]
+            lastIndex = len(metrics)
+            while metrics[lastIndex - 2][0] == lastAdvance:
+                lastIndex -= 1
+                if lastIndex <= 1:
+                    # all advances are equal
+                    lastIndex = 1
+                    break
+            additionalMetrics = metrics[lastIndex:]
+            additionalMetrics = [otRound(sb) for _, sb in additionalMetrics]
+            metrics = metrics[:lastIndex]
+            numberOfMetrics = len(metrics)
+            setattr(headerTable, self.numberOfMetricsName, numberOfMetrics)
+        else:
+            # no hhea/vhea, can't store numberOfMetrics; assume == numGlyphs
+            numberOfMetrics = ttFont["maxp"].numGlyphs
+            additionalMetrics = []
+
+        allMetrics = []
+        for advance, sb in metrics:
+            allMetrics.extend([otRound(advance), otRound(sb)])
+        metricsFmt = ">" + self.longMetricFormat * numberOfMetrics
+        try:
+            data = struct.pack(metricsFmt, *allMetrics)
+        except struct.error as e:
+            if "out of range" in str(e) and hasNegativeAdvances:
+                raise ttLib.TTLibError(
+                    "'%s' table can't contain negative advance %ss"
+                    % (self.tableTag, self.advanceName)
+                )
+            else:
+                raise
+        additionalMetrics = array.array("h", additionalMetrics)
+        if sys.byteorder != "big":
+            additionalMetrics.byteswap()
+        data = data + additionalMetrics.tobytes()
+        return data
+
+    def toXML(self, writer, ttFont):
+        names = sorted(self.metrics.keys())
+        for glyphName in names:
+            advance, sb = self.metrics[glyphName]
+            writer.simpletag(
+                "mtx",
+                [
+                    ("name", glyphName),
+                    (self.advanceName, advance),
+                    (self.sideBearingName, sb),
+                ],
+            )
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "metrics"):
+            self.metrics = {}
+        if name == "mtx":
+            self.metrics[attrs["name"]] = (
+                safeEval(attrs[self.advanceName]),
+                safeEval(attrs[self.sideBearingName]),
+            )
+
+    def __delitem__(self, glyphName):
+        del self.metrics[glyphName]
+
+    def __getitem__(self, glyphName):
+        return self.metrics[glyphName]
+
+    def __setitem__(self, glyphName, advance_sb_pair):
+        self.metrics[glyphName] = tuple(advance_sb_pair)

fontTools/ttLib/tables/_k_e_r_n.py

@@ -0,0 +1,289 @@
+from fontTools.ttLib import getSearchRange
+from fontTools.misc.textTools import safeEval, readHex
+from fontTools.misc.fixedTools import fixedToFloat as fi2fl, floatToFixed as fl2fi
+from . import DefaultTable
+import struct
+import sys
+import array
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+class table__k_e_r_n(DefaultTable.DefaultTable):
+    """Kerning table
+
+    The ``kern`` table contains values that contextually adjust the inter-glyph
+    spacing for the glyphs in a ``glyf`` table.
+
+    Note that similar contextual spacing adjustments can also be stored
+    in the "kern" feature of a ``GPOS`` table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/kern
+    """
+
+    def getkern(self, format):
+        for subtable in self.kernTables:
+            if subtable.format == format:
+                return subtable
+        return None  # not found
+
+    def decompile(self, data, ttFont):
+        version, nTables = struct.unpack(">HH", data[:4])
+        apple = False
+        if (len(data) >= 8) and (version == 1):
+            # AAT Apple's "new" format. Hm.
+            version, nTables = struct.unpack(">LL", data[:8])
+            self.version = fi2fl(version, 16)
+            data = data[8:]
+            apple = True
+        else:
+            self.version = version
+            data = data[4:]
+        self.kernTables = []
+        for i in range(nTables):
+            if self.version == 1.0:
+                # Apple
+                length, coverage, subtableFormat = struct.unpack(">LBB", data[:6])
+            else:
+                # in OpenType spec the "version" field refers to the common
+                # subtable header; the actual subtable format is stored in
+                # the 8-15 mask bits of "coverage" field.
+                # This "version" is always 0 so we ignore it here
+                _, length, subtableFormat, coverage = struct.unpack(">HHBB", data[:6])
+                if nTables == 1 and subtableFormat == 0:
+                    # The "length" value is ignored since some fonts
+                    # (like OpenSans and Calibri) have a subtable larger than
+                    # its value.
+                    (nPairs,) = struct.unpack(">H", data[6:8])
+                    calculated_length = (nPairs * 6) + 14
+                    if length != calculated_length:
+                        log.warning(
+                            "'kern' subtable longer than defined: "
+                            "%d bytes instead of %d bytes" % (calculated_length, length)
+                        )
+                    length = calculated_length
+            if subtableFormat not in kern_classes:
+                subtable = KernTable_format_unkown(subtableFormat)
+            else:
+                subtable = kern_classes[subtableFormat](apple)
+            subtable.decompile(data[:length], ttFont)
+            self.kernTables.append(subtable)
+            data = data[length:]
+
+    def compile(self, ttFont):
+        if hasattr(self, "kernTables"):
+            nTables = len(self.kernTables)
+        else:
+            nTables = 0
+        if self.version == 1.0:
+            # AAT Apple's "new" format.
+            data = struct.pack(">LL", fl2fi(self.version, 16), nTables)
+        else:
+            data = struct.pack(">HH", self.version, nTables)
+        if hasattr(self, "kernTables"):
+            for subtable in self.kernTables:
+                data = data + subtable.compile(ttFont)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", value=self.version)
+        writer.newline()
+        for subtable in self.kernTables:
+            subtable.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = safeEval(attrs["value"])
+            return
+        if name != "kernsubtable":
+            return
+        if not hasattr(self, "kernTables"):
+            self.kernTables = []
+        format = safeEval(attrs["format"])
+        if format not in kern_classes:
+            subtable = KernTable_format_unkown(format)
+        else:
+            apple = self.version == 1.0
+            subtable = kern_classes[format](apple)
+        self.kernTables.append(subtable)
+        subtable.fromXML(name, attrs, content, ttFont)
+
+
+class KernTable_format_0(object):
+    # 'version' is kept for backward compatibility
+    version = format = 0
+
+    def __init__(self, apple=False):
+        self.apple = apple
+
+    def decompile(self, data, ttFont):
+        if not self.apple:
+            version, length, subtableFormat, coverage = struct.unpack(">HHBB", data[:6])
+            if version != 0:
+                from fontTools.ttLib import TTLibError
+
+                raise TTLibError("unsupported kern subtable version: %d" % version)
+            tupleIndex = None
+            # Should we also assert length == len(data)?
+            data = data[6:]
+        else:
+            length, coverage, subtableFormat, tupleIndex = struct.unpack(
+                ">LBBH", data[:8]
+            )
+            data = data[8:]
+        assert self.format == subtableFormat, "unsupported format"
+        self.coverage = coverage
+        self.tupleIndex = tupleIndex
+
+        self.kernTable = kernTable = {}
+
+        nPairs, searchRange, entrySelector, rangeShift = struct.unpack(
+            ">HHHH", data[:8]
+        )
+        data = data[8:]
+
+        datas = array.array("H", data[: 6 * nPairs])
+        if sys.byteorder != "big":
+            datas.byteswap()
+        it = iter(datas)
+        glyphOrder = ttFont.getGlyphOrder()
+        for k in range(nPairs):
+            left, right, value = next(it), next(it), next(it)
+            if value >= 32768:
+                value -= 65536
+            try:
+                kernTable[(glyphOrder[left], glyphOrder[right])] = value
+            except IndexError:
+                # Slower, but will not throw an IndexError on an invalid
+                # glyph id.
+                kernTable[(ttFont.getGlyphName(left), ttFont.getGlyphName(right))] = (
+                    value
+                )
+        if len(data) > 6 * nPairs + 4:  # Ignore up to 4 bytes excess
+            log.warning(
+                "excess data in 'kern' subtable: %d bytes", len(data) - 6 * nPairs
+            )
+
+    def compile(self, ttFont):
+        nPairs = min(len(self.kernTable), 0xFFFF)
+        searchRange, entrySelector, rangeShift = getSearchRange(nPairs, 6)
+        searchRange &= 0xFFFF
+        entrySelector = min(entrySelector, 0xFFFF)
+        rangeShift = min(rangeShift, 0xFFFF)
+        data = struct.pack(">HHHH", nPairs, searchRange, entrySelector, rangeShift)
+
+        # yeehee! (I mean, turn names into indices)
+        try:
+            reverseOrder = ttFont.getReverseGlyphMap()
+            kernTable = sorted(
+                (reverseOrder[left], reverseOrder[right], value)
+                for ((left, right), value) in self.kernTable.items()
+            )
+        except KeyError:
+            # Slower, but will not throw KeyError on invalid glyph id.
+            getGlyphID = ttFont.getGlyphID
+            kernTable = sorted(
+                (getGlyphID(left), getGlyphID(right), value)
+                for ((left, right), value) in self.kernTable.items()
+            )
+
+        for left, right, value in kernTable:
+            data = data + struct.pack(">HHh", left, right, value)
+
+        if not self.apple:
+            version = 0
+            length = len(data) + 6
+            if length >= 0x10000:
+                log.warning(
+                    '"kern" subtable overflow, '
+                    "truncating length value while preserving pairs."
+                )
+                length &= 0xFFFF
+            header = struct.pack(">HHBB", version, length, self.format, self.coverage)
+        else:
+            if self.tupleIndex is None:
+                # sensible default when compiling a TTX from an old fonttools
+                # or when inserting a Windows-style format 0 subtable into an
+                # Apple version=1.0 kern table
+                log.warning("'tupleIndex' is None; default to 0")
+                self.tupleIndex = 0
+            length = len(data) + 8
+            header = struct.pack(
+                ">LBBH", length, self.coverage, self.format, self.tupleIndex
+            )
+        return header + data
+
+    def toXML(self, writer, ttFont):
+        attrs = dict(coverage=self.coverage, format=self.format)
+        if self.apple:
+            if self.tupleIndex is None:
+                log.warning("'tupleIndex' is None; default to 0")
+                attrs["tupleIndex"] = 0
+            else:
+                attrs["tupleIndex"] = self.tupleIndex
+        writer.begintag("kernsubtable", **attrs)
+        writer.newline()
+        items = sorted(self.kernTable.items())
+        for (left, right), value in items:
+            writer.simpletag("pair", [("l", left), ("r", right), ("v", value)])
+            writer.newline()
+        writer.endtag("kernsubtable")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.coverage = safeEval(attrs["coverage"])
+        subtableFormat = safeEval(attrs["format"])
+        if self.apple:
+            if "tupleIndex" in attrs:
+                self.tupleIndex = safeEval(attrs["tupleIndex"])
+            else:
+                # previous fontTools versions didn't export tupleIndex
+                log.warning("Apple kern subtable is missing 'tupleIndex' attribute")
+                self.tupleIndex = None
+        else:
+            self.tupleIndex = None
+        assert subtableFormat == self.format, "unsupported format"
+        if not hasattr(self, "kernTable"):
+            self.kernTable = {}
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            self.kernTable[(attrs["l"], attrs["r"])] = safeEval(attrs["v"])
+
+    def __getitem__(self, pair):
+        return self.kernTable[pair]
+
+    def __setitem__(self, pair, value):
+        self.kernTable[pair] = value
+
+    def __delitem__(self, pair):
+        del self.kernTable[pair]
+
+
+class KernTable_format_unkown(object):
+    def __init__(self, format):
+        self.format = format
+
+    def decompile(self, data, ttFont):
+        self.data = data
+
+    def compile(self, ttFont):
+        return self.data
+
+    def toXML(self, writer, ttFont):
+        writer.begintag("kernsubtable", format=self.format)
+        writer.newline()
+        writer.comment("unknown 'kern' subtable format")
+        writer.newline()
+        writer.dumphex(self.data)
+        writer.endtag("kernsubtable")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.decompile(readHex(content), ttFont)
+
+
+kern_classes = {0: KernTable_format_0}

fontTools/ttLib/tables/_l_c_a_r.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table__l_c_a_r(BaseTTXConverter):
+    """Ligature Caret table
+
+    The AAT ``lcar`` table stores division points within ligatures, which applications
+    can use to position carets properly between the logical parts of the ligature.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6lcar.html
+    """
+
+    pass

fontTools/ttLib/tables/_l_o_c_a.py

@@ -0,0 +1,70 @@
+from . import DefaultTable
+import sys
+import array
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+class table__l_o_c_a(DefaultTable.DefaultTable):
+    """Index to Location table
+
+    The ``loca`` table stores the offsets in the ``glyf`` table that correspond
+    to the descriptions of each glyph. The glyphs are references by Glyph ID.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/loca
+    """
+
+    dependencies = ["glyf"]
+
+    def decompile(self, data, ttFont):
+        longFormat = ttFont["head"].indexToLocFormat
+        if longFormat:
+            format = "I"
+        else:
+            format = "H"
+        locations = array.array(format)
+        locations.frombytes(data)
+        if sys.byteorder != "big":
+            locations.byteswap()
+        if not longFormat:
+            locations = array.array("I", (2 * l for l in locations))
+        if len(locations) < (ttFont["maxp"].numGlyphs + 1):
+            log.warning(
+                "corrupt 'loca' table, or wrong numGlyphs in 'maxp': %d %d",
+                len(locations) - 1,
+                ttFont["maxp"].numGlyphs,
+            )
+        self.locations = locations
+
+    def compile(self, ttFont):
+        try:
+            max_location = max(self.locations)
+        except AttributeError:
+            self.set([])
+            max_location = 0
+        if max_location < 0x20000 and all(l % 2 == 0 for l in self.locations):
+            locations = array.array("H")
+            for location in self.locations:
+                locations.append(location // 2)
+            ttFont["head"].indexToLocFormat = 0
+        else:
+            locations = array.array("I", self.locations)
+            ttFont["head"].indexToLocFormat = 1
+        if sys.byteorder != "big":
+            locations.byteswap()
+        return locations.tobytes()
+
+    def set(self, locations):
+        self.locations = array.array("I", locations)
+
+    def toXML(self, writer, ttFont):
+        writer.comment("The 'loca' table will be calculated by the compiler")
+        writer.newline()
+
+    def __getitem__(self, index):
+        return self.locations[index]
+
+    def __len__(self):
+        return len(self.locations)