fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/V_A_R_C_.py

@@ -0,0 +1,12 @@
+from .otBase import BaseTTXConverter
+
+
+class table_V_A_R_C_(BaseTTXConverter):
+    """Variable Components table
+
+    The ``VARC`` table contains variation information for composite glyphs.
+
+    See also https://github.com/harfbuzz/boring-expansion-spec/blob/main/VARC.md
+    """
+
+    pass

fontTools/ttLib/tables/V_D_M_X_.py

@@ -0,0 +1,249 @@
+from . import DefaultTable
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+import struct
+
+VDMX_HeaderFmt = """
+	>                 # big endian
+	version:     H    # Version number (0 or 1)
+	numRecs:     H    # Number of VDMX groups present
+	numRatios:   H    # Number of aspect ratio groupings
+"""
+# the VMDX header is followed by an array of RatRange[numRatios] (i.e. aspect
+# ratio ranges);
+VDMX_RatRangeFmt = """
+	>                 # big endian
+	bCharSet:    B    # Character set
+	xRatio:      B    # Value to use for x-Ratio
+	yStartRatio: B    # Starting y-Ratio value
+	yEndRatio:   B    # Ending y-Ratio value
+"""
+# followed by an array of offset[numRatios] from start of VDMX table to the
+# VDMX Group for this ratio range (offsets will be re-calculated on compile);
+# followed by an array of Group[numRecs] records;
+VDMX_GroupFmt = """
+	>                 # big endian
+	recs:        H    # Number of height records in this group
+	startsz:     B    # Starting yPelHeight
+	endsz:       B    # Ending yPelHeight
+"""
+# followed by an array of vTable[recs] records.
+VDMX_vTableFmt = """
+	>                 # big endian
+	yPelHeight:  H    # yPelHeight to which values apply
+	yMax:        h    # Maximum value (in pels) for this yPelHeight
+	yMin:        h    # Minimum value (in pels) for this yPelHeight
+"""
+
+
+class table_V_D_M_X_(DefaultTable.DefaultTable):
+    """Vertical Device Metrics table
+
+    The ``VDMX`` table records changes to the vertical glyph minima
+    and maxima that result from Truetype instructions.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/vdmx
+    """
+
+    def decompile(self, data, ttFont):
+        pos = 0  # track current position from to start of VDMX table
+        dummy, data = sstruct.unpack2(VDMX_HeaderFmt, data, self)
+        pos += sstruct.calcsize(VDMX_HeaderFmt)
+        self.ratRanges = []
+        for i in range(self.numRatios):
+            ratio, data = sstruct.unpack2(VDMX_RatRangeFmt, data)
+            pos += sstruct.calcsize(VDMX_RatRangeFmt)
+            # the mapping between a ratio and a group is defined further below
+            ratio["groupIndex"] = None
+            self.ratRanges.append(ratio)
+        lenOffset = struct.calcsize(">H")
+        _offsets = []  # temporarily store offsets to groups
+        for i in range(self.numRatios):
+            offset = struct.unpack(">H", data[0:lenOffset])[0]
+            data = data[lenOffset:]
+            pos += lenOffset
+            _offsets.append(offset)
+        self.groups = []
+        for groupIndex in range(self.numRecs):
+            # the offset to this group from beginning of the VDMX table
+            currOffset = pos
+            group, data = sstruct.unpack2(VDMX_GroupFmt, data)
+            # the group lenght and bounding sizes are re-calculated on compile
+            recs = group.pop("recs")
+            startsz = group.pop("startsz")
+            endsz = group.pop("endsz")
+            pos += sstruct.calcsize(VDMX_GroupFmt)
+            for j in range(recs):
+                vTable, data = sstruct.unpack2(VDMX_vTableFmt, data)
+                vTableLength = sstruct.calcsize(VDMX_vTableFmt)
+                pos += vTableLength
+                # group is a dict of (yMax, yMin) tuples keyed by yPelHeight
+                group[vTable["yPelHeight"]] = (vTable["yMax"], vTable["yMin"])
+            # make sure startsz and endsz match the calculated values
+            minSize = min(group.keys())
+            maxSize = max(group.keys())
+            assert (
+                startsz == minSize
+            ), "startsz (%s) must equal min yPelHeight (%s): group %d" % (
+                group.startsz,
+                minSize,
+                groupIndex,
+            )
+            assert (
+                endsz == maxSize
+            ), "endsz (%s) must equal max yPelHeight (%s): group %d" % (
+                group.endsz,
+                maxSize,
+                groupIndex,
+            )
+            self.groups.append(group)
+            # match the defined offsets with the current group's offset
+            for offsetIndex, offsetValue in enumerate(_offsets):
+                # when numRecs < numRatios there can more than one ratio range
+                # sharing the same VDMX group
+                if currOffset == offsetValue:
+                    # map the group with the ratio range thas has the same
+                    # index as the offset to that group (it took me a while..)
+                    self.ratRanges[offsetIndex]["groupIndex"] = groupIndex
+        # check that all ratio ranges have a group
+        for i in range(self.numRatios):
+            ratio = self.ratRanges[i]
+            if ratio["groupIndex"] is None:
+                from fontTools import ttLib
+
+                raise ttLib.TTLibError("no group defined for ratRange %d" % i)
+
+    def _getOffsets(self):
+        """
+        Calculate offsets to VDMX_Group records.
+        For each ratRange return a list of offset values from the beginning of
+        the VDMX table to a VDMX_Group.
+        """
+        lenHeader = sstruct.calcsize(VDMX_HeaderFmt)
+        lenRatRange = sstruct.calcsize(VDMX_RatRangeFmt)
+        lenOffset = struct.calcsize(">H")
+        lenGroupHeader = sstruct.calcsize(VDMX_GroupFmt)
+        lenVTable = sstruct.calcsize(VDMX_vTableFmt)
+        # offset to the first group
+        pos = lenHeader + self.numRatios * lenRatRange + self.numRatios * lenOffset
+        groupOffsets = []
+        for group in self.groups:
+            groupOffsets.append(pos)
+            lenGroup = lenGroupHeader + len(group) * lenVTable
+            pos += lenGroup  # offset to next group
+        offsets = []
+        for ratio in self.ratRanges:
+            groupIndex = ratio["groupIndex"]
+            offsets.append(groupOffsets[groupIndex])
+        return offsets
+
+    def compile(self, ttFont):
+        if not (self.version == 0 or self.version == 1):
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError(
+                "unknown format for VDMX table: version %s" % self.version
+            )
+        data = sstruct.pack(VDMX_HeaderFmt, self)
+        for ratio in self.ratRanges:
+            data += sstruct.pack(VDMX_RatRangeFmt, ratio)
+        # recalculate offsets to VDMX groups
+        for offset in self._getOffsets():
+            data += struct.pack(">H", offset)
+        for group in self.groups:
+            recs = len(group)
+            startsz = min(group.keys())
+            endsz = max(group.keys())
+            gHeader = {"recs": recs, "startsz": startsz, "endsz": endsz}
+            data += sstruct.pack(VDMX_GroupFmt, gHeader)
+            for yPelHeight, (yMax, yMin) in sorted(group.items()):
+                vTable = {"yPelHeight": yPelHeight, "yMax": yMax, "yMin": yMin}
+                data += sstruct.pack(VDMX_vTableFmt, vTable)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", value=self.version)
+        writer.newline()
+        writer.begintag("ratRanges")
+        writer.newline()
+        for ratio in self.ratRanges:
+            groupIndex = ratio["groupIndex"]
+            writer.simpletag(
+                "ratRange",
+                bCharSet=ratio["bCharSet"],
+                xRatio=ratio["xRatio"],
+                yStartRatio=ratio["yStartRatio"],
+                yEndRatio=ratio["yEndRatio"],
+                groupIndex=groupIndex,
+            )
+            writer.newline()
+        writer.endtag("ratRanges")
+        writer.newline()
+        writer.begintag("groups")
+        writer.newline()
+        for groupIndex in range(self.numRecs):
+            group = self.groups[groupIndex]
+            recs = len(group)
+            startsz = min(group.keys())
+            endsz = max(group.keys())
+            writer.begintag("group", index=groupIndex)
+            writer.newline()
+            writer.comment("recs=%d, startsz=%d, endsz=%d" % (recs, startsz, endsz))
+            writer.newline()
+            for yPelHeight, (yMax, yMin) in sorted(group.items()):
+                writer.simpletag(
+                    "record",
+                    [("yPelHeight", yPelHeight), ("yMax", yMax), ("yMin", yMin)],
+                )
+                writer.newline()
+            writer.endtag("group")
+            writer.newline()
+        writer.endtag("groups")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = safeEval(attrs["value"])
+        elif name == "ratRanges":
+            if not hasattr(self, "ratRanges"):
+                self.ratRanges = []
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content = element
+                if name == "ratRange":
+                    if not hasattr(self, "numRatios"):
+                        self.numRatios = 1
+                    else:
+                        self.numRatios += 1
+                    ratio = {
+                        "bCharSet": safeEval(attrs["bCharSet"]),
+                        "xRatio": safeEval(attrs["xRatio"]),
+                        "yStartRatio": safeEval(attrs["yStartRatio"]),
+                        "yEndRatio": safeEval(attrs["yEndRatio"]),
+                        "groupIndex": safeEval(attrs["groupIndex"]),
+                    }
+                    self.ratRanges.append(ratio)
+        elif name == "groups":
+            if not hasattr(self, "groups"):
+                self.groups = []
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content = element
+                if name == "group":
+                    if not hasattr(self, "numRecs"):
+                        self.numRecs = 1
+                    else:
+                        self.numRecs += 1
+                    group = {}
+                    for element in content:
+                        if not isinstance(element, tuple):
+                            continue
+                        name, attrs, content = element
+                        if name == "record":
+                            yPelHeight = safeEval(attrs["yPelHeight"])
+                            yMax = safeEval(attrs["yMax"])
+                            yMin = safeEval(attrs["yMin"])
+                            group[yPelHeight] = (yMax, yMin)
+                    self.groups.append(group)

fontTools/ttLib/tables/V_O_R_G_.py

@@ -0,0 +1,165 @@
+from fontTools.misc.textTools import bytesjoin, safeEval
+from . import DefaultTable
+import struct
+
+
+class table_V_O_R_G_(DefaultTable.DefaultTable):
+    """Vertical Origin table
+
+    The ``VORG`` table contains the vertical origin of each glyph
+    in a `CFF` or `CFF2` font.
+
+    This table is structured so that you can treat it like a dictionary keyed by glyph name.
+
+    ``ttFont['VORG'][<glyphName>]`` will return the vertical origin for any glyph.
+
+    ``ttFont['VORG'][<glyphName>] = <value>`` will set the vertical origin for any glyph.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/vorg
+    """
+
+    def decompile(self, data, ttFont):
+        self.getGlyphName = (
+            ttFont.getGlyphName
+        )  # for use in get/set item functions, for access by GID
+        (
+            self.majorVersion,
+            self.minorVersion,
+            self.defaultVertOriginY,
+            self.numVertOriginYMetrics,
+        ) = struct.unpack(">HHhH", data[:8])
+        assert (
+            self.majorVersion <= 1
+        ), "Major version of VORG table is higher than I know how to handle"
+        data = data[8:]
+        vids = []
+        gids = []
+        pos = 0
+        for i in range(self.numVertOriginYMetrics):
+            gid, vOrigin = struct.unpack(">Hh", data[pos : pos + 4])
+            pos += 4
+            gids.append(gid)
+            vids.append(vOrigin)
+
+        self.VOriginRecords = vOrig = {}
+        glyphOrder = ttFont.getGlyphOrder()
+        try:
+            names = [glyphOrder[gid] for gid in gids]
+        except IndexError:
+            getGlyphName = self.getGlyphName
+            names = map(getGlyphName, gids)
+
+        for name, vid in zip(names, vids):
+            vOrig[name] = vid
+
+    def compile(self, ttFont):
+        vorgs = list(self.VOriginRecords.values())
+        names = list(self.VOriginRecords.keys())
+        nameMap = ttFont.getReverseGlyphMap()
+        try:
+            gids = [nameMap[name] for name in names]
+        except KeyError:
+            nameMap = ttFont.getReverseGlyphMap(rebuild=True)
+            gids = [nameMap[name] for name in names]
+        vOriginTable = list(zip(gids, vorgs))
+        self.numVertOriginYMetrics = len(vorgs)
+        vOriginTable.sort()  # must be in ascending GID order
+        dataList = [struct.pack(">Hh", rec[0], rec[1]) for rec in vOriginTable]
+        header = struct.pack(
+            ">HHhH",
+            self.majorVersion,
+            self.minorVersion,
+            self.defaultVertOriginY,
+            self.numVertOriginYMetrics,
+        )
+        dataList.insert(0, header)
+        data = bytesjoin(dataList)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("majorVersion", value=self.majorVersion)
+        writer.newline()
+        writer.simpletag("minorVersion", value=self.minorVersion)
+        writer.newline()
+        writer.simpletag("defaultVertOriginY", value=self.defaultVertOriginY)
+        writer.newline()
+        writer.simpletag("numVertOriginYMetrics", value=self.numVertOriginYMetrics)
+        writer.newline()
+        vOriginTable = []
+        glyphNames = self.VOriginRecords.keys()
+        for glyphName in glyphNames:
+            try:
+                gid = ttFont.getGlyphID(glyphName)
+            except:
+                assert 0, (
+                    "VORG table contains a glyph name not in ttFont.getGlyphNames(): "
+                    + str(glyphName)
+                )
+            vOriginTable.append([gid, glyphName, self.VOriginRecords[glyphName]])
+        vOriginTable.sort()
+        for entry in vOriginTable:
+            vOriginRec = VOriginRecord(entry[1], entry[2])
+            vOriginRec.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "VOriginRecords"):
+            self.VOriginRecords = {}
+        self.getGlyphName = (
+            ttFont.getGlyphName
+        )  # for use in get/set item functions, for access by GID
+        if name == "VOriginRecord":
+            vOriginRec = VOriginRecord()
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                name, attrs, content = element
+                vOriginRec.fromXML(name, attrs, content, ttFont)
+            self.VOriginRecords[vOriginRec.glyphName] = vOriginRec.vOrigin
+        elif "value" in attrs:
+            setattr(self, name, safeEval(attrs["value"]))
+
+    def __getitem__(self, glyphSelector):
+        if isinstance(glyphSelector, int):
+            # its a gid, convert to glyph name
+            glyphSelector = self.getGlyphName(glyphSelector)
+
+        if glyphSelector not in self.VOriginRecords:
+            return self.defaultVertOriginY
+
+        return self.VOriginRecords[glyphSelector]
+
+    def __setitem__(self, glyphSelector, value):
+        if isinstance(glyphSelector, int):
+            # its a gid, convert to glyph name
+            glyphSelector = self.getGlyphName(glyphSelector)
+
+        if value != self.defaultVertOriginY:
+            self.VOriginRecords[glyphSelector] = value
+        elif glyphSelector in self.VOriginRecords:
+            del self.VOriginRecords[glyphSelector]
+
+    def __delitem__(self, glyphSelector):
+        del self.VOriginRecords[glyphSelector]
+
+
+class VOriginRecord(object):
+    def __init__(self, name=None, vOrigin=None):
+        self.glyphName = name
+        self.vOrigin = vOrigin
+
+    def toXML(self, writer, ttFont):
+        writer.begintag("VOriginRecord")
+        writer.newline()
+        writer.simpletag("glyphName", value=self.glyphName)
+        writer.newline()
+        writer.simpletag("vOrigin", value=self.vOrigin)
+        writer.newline()
+        writer.endtag("VOriginRecord")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        value = attrs["value"]
+        if name == "glyphName":
+            setattr(self, name, value)
+        else:
+            setattr(self, name, safeEval(value))

fontTools/ttLib/tables/V_V_A_R_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_V_V_A_R_(BaseTTXConverter):
+    """Vertical Metrics Variations table
+
+    The ``VVAR`` table contains variation data for per-glyph vertical metrics
+    in a variable font.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/vvar
+    """
+
+    pass

fontTools/ttLib/tables/__init__.py

@@ -0,0 +1,98 @@
+# DON'T EDIT! This file is generated by MetaTools/buildTableList.py.
+def _moduleFinderHint():
+    """Dummy function to let modulefinder know what tables may be
+    dynamically imported. Generated by MetaTools/buildTableList.py.
+
+        >>> _moduleFinderHint()
+    """
+    from . import B_A_S_E_
+    from . import C_B_D_T_
+    from . import C_B_L_C_
+    from . import C_F_F_
+    from . import C_F_F__2
+    from . import C_O_L_R_
+    from . import C_P_A_L_
+    from . import D_S_I_G_
+    from . import D__e_b_g
+    from . import E_B_D_T_
+    from . import E_B_L_C_
+    from . import F_F_T_M_
+    from . import F__e_a_t
+    from . import G_D_E_F_
+    from . import G_M_A_P_
+    from . import G_P_K_G_
+    from . import G_P_O_S_
+    from . import G_S_U_B_
+    from . import G_V_A_R_
+    from . import G__l_a_t
+    from . import G__l_o_c
+    from . import H_V_A_R_
+    from . import J_S_T_F_
+    from . import L_T_S_H_
+    from . import M_A_T_H_
+    from . import M_E_T_A_
+    from . import M_V_A_R_
+    from . import O_S_2f_2
+    from . import S_I_N_G_
+    from . import S_T_A_T_
+    from . import S_V_G_
+    from . import S__i_l_f
+    from . import S__i_l_l
+    from . import T_S_I_B_
+    from . import T_S_I_C_
+    from . import T_S_I_D_
+    from . import T_S_I_J_
+    from . import T_S_I_P_
+    from . import T_S_I_S_
+    from . import T_S_I_V_
+    from . import T_S_I__0
+    from . import T_S_I__1
+    from . import T_S_I__2
+    from . import T_S_I__3
+    from . import T_S_I__5
+    from . import T_T_F_A_
+    from . import V_A_R_C_
+    from . import V_D_M_X_
+    from . import V_O_R_G_
+    from . import V_V_A_R_
+    from . import _a_n_k_r
+    from . import _a_v_a_r
+    from . import _b_s_l_n
+    from . import _c_i_d_g
+    from . import _c_m_a_p
+    from . import _c_v_a_r
+    from . import _c_v_t
+    from . import _f_e_a_t
+    from . import _f_p_g_m
+    from . import _f_v_a_r
+    from . import _g_a_s_p
+    from . import _g_c_i_d
+    from . import _g_l_y_f
+    from . import _g_v_a_r
+    from . import _h_d_m_x
+    from . import _h_e_a_d
+    from . import _h_h_e_a
+    from . import _h_m_t_x
+    from . import _k_e_r_n
+    from . import _l_c_a_r
+    from . import _l_o_c_a
+    from . import _l_t_a_g
+    from . import _m_a_x_p
+    from . import _m_e_t_a
+    from . import _m_o_r_t
+    from . import _m_o_r_x
+    from . import _n_a_m_e
+    from . import _o_p_b_d
+    from . import _p_o_s_t
+    from . import _p_r_e_p
+    from . import _p_r_o_p
+    from . import _s_b_i_x
+    from . import _t_r_a_k
+    from . import _v_h_e_a
+    from . import _v_m_t_x
+
+
+if __name__ == "__main__":
+    import doctest, sys
+
+    sys.exit(doctest.testmod().failed)

fontTools/ttLib/tables/_a_n_k_r.py

@@ -0,0 +1,15 @@
+from .otBase import BaseTTXConverter
+
+
+class table__a_n_k_r(BaseTTXConverter):
+    """Anchor Point table
+
+    The anchor point table provides a way to define anchor points.
+    These are points within the coordinate space of a given glyph,
+    independent of the control points used to render the glyph.
+    Anchor points are used in conjunction with the ``kerx`` table.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6ankr.html
+    """
+
+    pass