fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/_t_r_a_k.py

@@ -0,0 +1,332 @@
+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 bytesjoin, safeEval
+from fontTools.ttLib import TTLibError
+from . import DefaultTable
+import struct
+from collections.abc import MutableMapping
+
+
+# Apple's documentation of 'trak':
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6trak.html
+
+TRAK_HEADER_FORMAT = """
+	> # big endian
+	version:     16.16F
+	format:      H
+	horizOffset: H
+	vertOffset:  H
+	reserved:    H
+"""
+
+TRAK_HEADER_FORMAT_SIZE = sstruct.calcsize(TRAK_HEADER_FORMAT)
+
+
+TRACK_DATA_FORMAT = """
+	> # big endian
+	nTracks:         H
+	nSizes:          H
+	sizeTableOffset: L
+"""
+
+TRACK_DATA_FORMAT_SIZE = sstruct.calcsize(TRACK_DATA_FORMAT)
+
+
+TRACK_TABLE_ENTRY_FORMAT = """
+	> # big endian
+	track:      16.16F
+	nameIndex:       H
+	offset:          H
+"""
+
+TRACK_TABLE_ENTRY_FORMAT_SIZE = sstruct.calcsize(TRACK_TABLE_ENTRY_FORMAT)
+
+
+# size values are actually '16.16F' fixed-point values, but here I do the
+# fixedToFloat conversion manually instead of relying on sstruct
+SIZE_VALUE_FORMAT = ">l"
+SIZE_VALUE_FORMAT_SIZE = struct.calcsize(SIZE_VALUE_FORMAT)
+
+# per-Size values are in 'FUnits', i.e. 16-bit signed integers
+PER_SIZE_VALUE_FORMAT = ">h"
+PER_SIZE_VALUE_FORMAT_SIZE = struct.calcsize(PER_SIZE_VALUE_FORMAT)
+
+
+class table__t_r_a_k(DefaultTable.DefaultTable):
+    """The AAT ``trak`` table can store per-size adjustments to each glyph's
+    sidebearings to make when tracking is enabled, which applications can
+    use to provide more visually balanced line spacing.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6trak.html
+    """
+
+    dependencies = ["name"]
+
+    def compile(self, ttFont):
+        dataList = []
+        offset = TRAK_HEADER_FORMAT_SIZE
+        for direction in ("horiz", "vert"):
+            trackData = getattr(self, direction + "Data", TrackData())
+            offsetName = direction + "Offset"
+            # set offset to 0 if None or empty
+            if not trackData:
+                setattr(self, offsetName, 0)
+                continue
+            # TrackData table format must be longword aligned
+            alignedOffset = (offset + 3) & ~3
+            padding, offset = b"\x00" * (alignedOffset - offset), alignedOffset
+            setattr(self, offsetName, offset)
+
+            data = trackData.compile(offset)
+            offset += len(data)
+            dataList.append(padding + data)
+
+        self.reserved = 0
+        tableData = bytesjoin([sstruct.pack(TRAK_HEADER_FORMAT, self)] + dataList)
+        return tableData
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack(TRAK_HEADER_FORMAT, data[:TRAK_HEADER_FORMAT_SIZE], self)
+        for direction in ("horiz", "vert"):
+            trackData = TrackData()
+            offset = getattr(self, direction + "Offset")
+            if offset != 0:
+                trackData.decompile(data, offset)
+            setattr(self, direction + "Data", trackData)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", value=self.version)
+        writer.newline()
+        writer.simpletag("format", value=self.format)
+        writer.newline()
+        for direction in ("horiz", "vert"):
+            dataName = direction + "Data"
+            writer.begintag(dataName)
+            writer.newline()
+            trackData = getattr(self, dataName, TrackData())
+            trackData.toXML(writer, ttFont)
+            writer.endtag(dataName)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = safeEval(attrs["value"])
+        elif name == "format":
+            self.format = safeEval(attrs["value"])
+        elif name in ("horizData", "vertData"):
+            trackData = TrackData()
+            setattr(self, name, trackData)
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content_ = element
+                trackData.fromXML(name, attrs, content_, ttFont)
+
+
+class TrackData(MutableMapping):
+    def __init__(self, initialdata={}):
+        self._map = dict(initialdata)
+
+    def compile(self, offset):
+        nTracks = len(self)
+        sizes = self.sizes()
+        nSizes = len(sizes)
+
+        # offset to the start of the size subtable
+        offset += TRACK_DATA_FORMAT_SIZE + TRACK_TABLE_ENTRY_FORMAT_SIZE * nTracks
+        trackDataHeader = sstruct.pack(
+            TRACK_DATA_FORMAT,
+            {"nTracks": nTracks, "nSizes": nSizes, "sizeTableOffset": offset},
+        )
+
+        entryDataList = []
+        perSizeDataList = []
+        # offset to per-size tracking values
+        offset += SIZE_VALUE_FORMAT_SIZE * nSizes
+        # sort track table entries by track value
+        for track, entry in sorted(self.items()):
+            assert entry.nameIndex is not None
+            entry.track = track
+            entry.offset = offset
+            entryDataList += [sstruct.pack(TRACK_TABLE_ENTRY_FORMAT, entry)]
+            # sort per-size values by size
+            for size, value in sorted(entry.items()):
+                perSizeDataList += [struct.pack(PER_SIZE_VALUE_FORMAT, value)]
+            offset += PER_SIZE_VALUE_FORMAT_SIZE * nSizes
+        # sort size values
+        sizeDataList = [
+            struct.pack(SIZE_VALUE_FORMAT, fl2fi(sv, 16)) for sv in sorted(sizes)
+        ]
+
+        data = bytesjoin(
+            [trackDataHeader] + entryDataList + sizeDataList + perSizeDataList
+        )
+        return data
+
+    def decompile(self, data, offset):
+        # initial offset is from the start of trak table to the current TrackData
+        trackDataHeader = data[offset : offset + TRACK_DATA_FORMAT_SIZE]
+        if len(trackDataHeader) != TRACK_DATA_FORMAT_SIZE:
+            raise TTLibError("not enough data to decompile TrackData header")
+        sstruct.unpack(TRACK_DATA_FORMAT, trackDataHeader, self)
+        offset += TRACK_DATA_FORMAT_SIZE
+
+        nSizes = self.nSizes
+        sizeTableOffset = self.sizeTableOffset
+        sizeTable = []
+        for i in range(nSizes):
+            sizeValueData = data[
+                sizeTableOffset : sizeTableOffset + SIZE_VALUE_FORMAT_SIZE
+            ]
+            if len(sizeValueData) < SIZE_VALUE_FORMAT_SIZE:
+                raise TTLibError("not enough data to decompile TrackData size subtable")
+            (sizeValue,) = struct.unpack(SIZE_VALUE_FORMAT, sizeValueData)
+            sizeTable.append(fi2fl(sizeValue, 16))
+            sizeTableOffset += SIZE_VALUE_FORMAT_SIZE
+
+        for i in range(self.nTracks):
+            entry = TrackTableEntry()
+            entryData = data[offset : offset + TRACK_TABLE_ENTRY_FORMAT_SIZE]
+            if len(entryData) < TRACK_TABLE_ENTRY_FORMAT_SIZE:
+                raise TTLibError("not enough data to decompile TrackTableEntry record")
+            sstruct.unpack(TRACK_TABLE_ENTRY_FORMAT, entryData, entry)
+            perSizeOffset = entry.offset
+            for j in range(nSizes):
+                size = sizeTable[j]
+                perSizeValueData = data[
+                    perSizeOffset : perSizeOffset + PER_SIZE_VALUE_FORMAT_SIZE
+                ]
+                if len(perSizeValueData) < PER_SIZE_VALUE_FORMAT_SIZE:
+                    raise TTLibError(
+                        "not enough data to decompile per-size track values"
+                    )
+                (perSizeValue,) = struct.unpack(PER_SIZE_VALUE_FORMAT, perSizeValueData)
+                entry[size] = perSizeValue
+                perSizeOffset += PER_SIZE_VALUE_FORMAT_SIZE
+            self[entry.track] = entry
+            offset += TRACK_TABLE_ENTRY_FORMAT_SIZE
+
+    def toXML(self, writer, ttFont):
+        nTracks = len(self)
+        nSizes = len(self.sizes())
+        writer.comment("nTracks=%d, nSizes=%d" % (nTracks, nSizes))
+        writer.newline()
+        for track, entry in sorted(self.items()):
+            assert entry.nameIndex is not None
+            entry.track = track
+            entry.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name != "trackEntry":
+            return
+        entry = TrackTableEntry()
+        entry.fromXML(name, attrs, content, ttFont)
+        self[entry.track] = entry
+
+    def sizes(self):
+        if not self:
+            return frozenset()
+        tracks = list(self.tracks())
+        sizes = self[tracks.pop(0)].sizes()
+        for track in tracks:
+            entrySizes = self[track].sizes()
+            if sizes != entrySizes:
+                raise TTLibError(
+                    "'trak' table entries must specify the same sizes: "
+                    "%s != %s" % (sorted(sizes), sorted(entrySizes))
+                )
+        return frozenset(sizes)
+
+    def __getitem__(self, track):
+        return self._map[track]
+
+    def __delitem__(self, track):
+        del self._map[track]
+
+    def __setitem__(self, track, entry):
+        self._map[track] = entry
+
+    def __len__(self):
+        return len(self._map)
+
+    def __iter__(self):
+        return iter(self._map)
+
+    def keys(self):
+        return self._map.keys()
+
+    tracks = keys
+
+    def __repr__(self):
+        return "TrackData({})".format(self._map if self else "")
+
+
+class TrackTableEntry(MutableMapping):
+    def __init__(self, values={}, nameIndex=None):
+        self.nameIndex = nameIndex
+        self._map = dict(values)
+
+    def toXML(self, writer, ttFont):
+        name = ttFont["name"].getDebugName(self.nameIndex)
+        writer.begintag(
+            "trackEntry",
+            (("value", fl2str(self.track, 16)), ("nameIndex", self.nameIndex)),
+        )
+        writer.newline()
+        if name:
+            writer.comment(name)
+            writer.newline()
+        for size, perSizeValue in sorted(self.items()):
+            writer.simpletag("track", size=fl2str(size, 16), value=perSizeValue)
+            writer.newline()
+        writer.endtag("trackEntry")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.track = str2fl(attrs["value"], 16)
+        self.nameIndex = safeEval(attrs["nameIndex"])
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, _ = element
+            if name != "track":
+                continue
+            size = str2fl(attrs["size"], 16)
+            self[size] = safeEval(attrs["value"])
+
+    def __getitem__(self, size):
+        return self._map[size]
+
+    def __delitem__(self, size):
+        del self._map[size]
+
+    def __setitem__(self, size, value):
+        self._map[size] = value
+
+    def __len__(self):
+        return len(self._map)
+
+    def __iter__(self):
+        return iter(self._map)
+
+    def keys(self):
+        return self._map.keys()
+
+    sizes = keys
+
+    def __repr__(self):
+        return "TrackTableEntry({}, nameIndex={})".format(self._map, self.nameIndex)
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.nameIndex == other.nameIndex and dict(self) == dict(other)
+
+    def __ne__(self, other):
+        result = self.__eq__(other)
+        return result if result is NotImplemented else not result

fontTools/ttLib/tables/_v_h_e_a.py

@@ -0,0 +1,139 @@
+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
+
+
+vheaFormat = """
+		>	# big endian
+		tableVersion:		L
+		ascent:			h
+		descent:		h
+		lineGap:		h
+		advanceHeightMax:	H
+		minTopSideBearing:	h
+		minBottomSideBearing:	h
+		yMaxExtent:		h
+		caretSlopeRise:		h
+		caretSlopeRun:		h
+		caretOffset:		h
+		reserved1:		h
+		reserved2:		h
+		reserved3:		h
+		reserved4:		h
+		metricDataFormat:	h
+		numberOfVMetrics:	H
+"""
+
+
+class table__v_h_e_a(DefaultTable.DefaultTable):
+    """Vertical Header table
+
+    The ``vhea`` table contains information needed during vertical
+    text layout.
+
+    .. note::
+       This converter class is kept in sync with the :class:`._h_h_e_a.table__h_h_e_a`
+       table constructor.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/vhea
+    """
+
+    # Note: Keep in sync with table__h_h_e_a
+
+    dependencies = ["vmtx", "glyf", "CFF ", "CFF2"]
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack(vheaFormat, 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(vheaFormat, self)
+
+    def recalc(self, ttFont):
+        if "vmtx" not in ttFont:
+            return
+
+        vmtxTable = ttFont["vmtx"]
+        self.advanceHeightMax = max(adv for adv, _ in vmtxTable.metrics.values())
+
+        boundsHeightDict = {}
+        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, "yMax"):
+                    # Composite glyph without extents set.
+                    # Calculate those.
+                    g.recalcBounds(glyfTable)
+                boundsHeightDict[name] = g.yMax - g.yMin
+        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:
+                    boundsHeightDict[name] = int(
+                        math.ceil(bounds[3]) - math.floor(bounds[1])
+                    )
+
+        if boundsHeightDict:
+            minTopSideBearing = float("inf")
+            minBottomSideBearing = float("inf")
+            yMaxExtent = -float("inf")
+            for name, boundsHeight in boundsHeightDict.items():
+                advanceHeight, tsb = vmtxTable[name]
+                bsb = advanceHeight - tsb - boundsHeight
+                extent = tsb + boundsHeight
+                minTopSideBearing = min(minTopSideBearing, tsb)
+                minBottomSideBearing = min(minBottomSideBearing, bsb)
+                yMaxExtent = max(yMaxExtent, extent)
+            self.minTopSideBearing = minTopSideBearing
+            self.minBottomSideBearing = minBottomSideBearing
+            self.yMaxExtent = yMaxExtent
+
+        else:  # No glyph has outlines.
+            self.minTopSideBearing = 0
+            self.minBottomSideBearing = 0
+            self.yMaxExtent = 0
+
+    def toXML(self, writer, ttFont):
+        formatstring, names, fixes = sstruct.getformat(vheaFormat)
+        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"]))
+
+    # reserved0 is caretOffset for legacy reasons
+    @property
+    def reserved0(self):
+        return self.caretOffset
+
+    @reserved0.setter
+    def reserved0(self, value):
+        self.caretOffset = value

fontTools/ttLib/tables/_v_m_t_x.py

@@ -0,0 +1,19 @@
+from fontTools import ttLib
+
+superclass = ttLib.getTableClass("hmtx")
+
+
+class table__v_m_t_x(superclass):
+    """Vertical Metrics table
+
+    The ``vmtx`` table contains per-glyph metrics for the glyphs in a
+    ``glyf``, ``CFF ``, or ``CFF2`` table, as needed for vertical text
+    layout.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/vmtx
+    """
+
+    headerTag = "vhea"
+    advanceName = "height"
+    sideBearingName = "tsb"
+    numberOfMetricsName = "numberOfVMetrics"

fontTools/ttLib/tables/asciiTable.py

@@ -0,0 +1,20 @@
+from fontTools.misc.textTools import strjoin, tobytes, tostr
+from . import DefaultTable
+
+
+class asciiTable(DefaultTable.DefaultTable):
+    def toXML(self, writer, ttFont):
+        data = tostr(self.data)
+        # removing null bytes. XXX needed??
+        data = data.split("\0")
+        data = strjoin(data)
+        writer.begintag("source")
+        writer.newline()
+        writer.write_noindent(data)
+        writer.newline()
+        writer.endtag("source")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        lines = strjoin(content).split("\n")
+        self.data = tobytes("\n".join(lines[1:-1]))

fontTools/ttLib/tables/grUtils.py

@@ -0,0 +1,92 @@
+import struct, warnings
+
+try:
+    import lz4
+except ImportError:
+    lz4 = None
+else:
+    import lz4.block
+
+# old scheme for VERSION < 0.9 otherwise use lz4.block
+
+
+def decompress(data):
+    (compression,) = struct.unpack(">L", data[4:8])
+    scheme = compression >> 27
+    size = compression & 0x07FFFFFF
+    if scheme == 0:
+        pass
+    elif scheme == 1 and lz4:
+        res = lz4.block.decompress(struct.pack("<L", size) + data[8:])
+        if len(res) != size:
+            warnings.warn("Table decompression failed.")
+        else:
+            data = res
+    else:
+        warnings.warn("Table is compressed with an unsupported compression scheme")
+    return (data, scheme)
+
+
+def compress(scheme, data):
+    hdr = data[:4] + struct.pack(">L", (scheme << 27) + (len(data) & 0x07FFFFFF))
+    if scheme == 0:
+        return data
+    elif scheme == 1 and lz4:
+        res = lz4.block.compress(
+            data, mode="high_compression", compression=16, store_size=False
+        )
+        return hdr + res
+    else:
+        warnings.warn("Table failed to compress by unsupported compression scheme")
+    return data
+
+
+def _entries(attrs, sameval):
+    ak = 0
+    vals = []
+    lastv = 0
+    for k, v in attrs:
+        if len(vals) and (k != ak + 1 or (sameval and v != lastv)):
+            yield (ak - len(vals) + 1, len(vals), vals)
+            vals = []
+        ak = k
+        vals.append(v)
+        lastv = v
+    yield (ak - len(vals) + 1, len(vals), vals)
+
+
+def entries(attributes, sameval=False):
+    g = _entries(sorted(attributes.items(), key=lambda x: int(x[0])), sameval)
+    return g
+
+
+def bininfo(num, size=1):
+    if num == 0:
+        return struct.pack(">4H", 0, 0, 0, 0)
+    srange = 1
+    select = 0
+    while srange <= num:
+        srange *= 2
+        select += 1
+    select -= 1
+    srange //= 2
+    srange *= size
+    shift = num * size - srange
+    return struct.pack(">4H", num, srange, select, shift)
+
+
+def num2tag(n):
+    if n < 0x200000:
+        return str(n)
+    else:
+        return (
+            struct.unpack("4s", struct.pack(">L", n))[0].replace(b"\000", b"").decode()
+        )
+
+
+def tag2num(n):
+    try:
+        return int(n)
+    except ValueError:
+        n = (n + "    ")[:4]
+        return struct.unpack(">L", n.encode("ascii"))[0]