fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/G__l_a_t.py

@@ -0,0 +1,235 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import floatToFixedToStr
+from fontTools.misc.textTools import safeEval
+
+# from itertools import *
+from functools import partial
+from . import DefaultTable
+from . import grUtils
+import struct
+
+
+Glat_format_0 = """
+    >        # big endian
+    version: 16.16F
+"""
+
+Glat_format_3 = """
+    >
+    version: 16.16F
+    compression:L    # compression scheme or reserved 
+"""
+
+Glat_format_1_entry = """
+    >
+    attNum:     B    # Attribute number of first attribute
+    num:        B    # Number of attributes in this run
+"""
+Glat_format_23_entry = """
+    >
+    attNum:     H    # Attribute number of first attribute
+    num:        H    # Number of attributes in this run
+"""
+
+Glat_format_3_octabox_metrics = """
+    >
+    subboxBitmap:   H    # Which subboxes exist on 4x4 grid
+    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
+    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
+    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
+    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
+"""
+
+Glat_format_3_subbox_entry = """
+    >
+    left:           B    # xi
+    right:          B    # xa
+    bottom:         B    # yi
+    top:            B    # ya
+    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
+    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
+    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
+    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
+"""
+
+
+class _Object:
+    pass
+
+
+class _Dict(dict):
+    pass
+
+
+class table_G__l_a_t(DefaultTable.DefaultTable):
+    """Graphite Glyph Attributes table
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-tables
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.scheme = 0
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack2(Glat_format_0, data, self)
+        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
+        if self.version <= 1.9:
+            decoder = partial(self.decompileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version <= 2.9:
+            decoder = partial(self.decompileAttributes12, fmt=Glat_format_23_entry)
+        elif self.version >= 3.0:
+            (data, self.scheme) = grUtils.decompress(data)
+            sstruct.unpack2(Glat_format_3, data, self)
+            self.hasOctaboxes = (self.compression & 1) == 1
+            decoder = self.decompileAttributes3
+
+        gloc = ttFont["Gloc"]
+        self.attributes = {}
+        count = 0
+        for s, e in zip(gloc, gloc[1:]):
+            self.attributes[ttFont.getGlyphName(count)] = decoder(data[s:e])
+            count += 1
+
+    def decompileAttributes12(self, data, fmt):
+        attributes = _Dict()
+        while len(data) > 3:
+            e, data = sstruct.unpack2(fmt, data, _Object())
+            keys = range(e.attNum, e.attNum + e.num)
+            if len(data) >= 2 * e.num:
+                vals = struct.unpack_from((">%dh" % e.num), data)
+                attributes.update(zip(keys, vals))
+                data = data[2 * e.num :]
+        return attributes
+
+    def decompileAttributes3(self, data):
+        if self.hasOctaboxes:
+            o, data = sstruct.unpack2(Glat_format_3_octabox_metrics, data, _Object())
+            numsub = bin(o.subboxBitmap).count("1")
+            o.subboxes = []
+            for b in range(numsub):
+                if len(data) >= 8:
+                    subbox, data = sstruct.unpack2(
+                        Glat_format_3_subbox_entry, data, _Object()
+                    )
+                    o.subboxes.append(subbox)
+        attrs = self.decompileAttributes12(data, Glat_format_23_entry)
+        if self.hasOctaboxes:
+            attrs.octabox = o
+        return attrs
+
+    def compile(self, ttFont):
+        data = sstruct.pack(Glat_format_0, self)
+        if self.version <= 1.9:
+            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version <= 2.9:
+            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version >= 3.0:
+            self.compression = (self.scheme << 27) + (1 if self.hasOctaboxes else 0)
+            data = sstruct.pack(Glat_format_3, self)
+            encoder = self.compileAttributes3
+
+        glocs = []
+        for n in range(len(self.attributes)):
+            glocs.append(len(data))
+            data += encoder(self.attributes[ttFont.getGlyphName(n)])
+        glocs.append(len(data))
+        ttFont["Gloc"].set(glocs)
+
+        if self.version >= 3.0:
+            data = grUtils.compress(self.scheme, data)
+        return data
+
+    def compileAttributes12(self, attrs, fmt):
+        data = b""
+        for e in grUtils.entries(attrs):
+            data += sstruct.pack(fmt, {"attNum": e[0], "num": e[1]}) + struct.pack(
+                (">%dh" % len(e[2])), *e[2]
+            )
+        return data
+
+    def compileAttributes3(self, attrs):
+        if self.hasOctaboxes:
+            o = attrs.octabox
+            data = sstruct.pack(Glat_format_3_octabox_metrics, o)
+            numsub = bin(o.subboxBitmap).count("1")
+            for b in range(numsub):
+                data += sstruct.pack(Glat_format_3_subbox_entry, o.subboxes[b])
+        else:
+            data = ""
+        return data + self.compileAttributes12(attrs, Glat_format_23_entry)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", version=self.version, compressionScheme=self.scheme)
+        writer.newline()
+        for n, a in sorted(
+            self.attributes.items(), key=lambda x: ttFont.getGlyphID(x[0])
+        ):
+            writer.begintag("glyph", name=n)
+            writer.newline()
+            if hasattr(a, "octabox"):
+                o = a.octabox
+                formatstring, names, fixes = sstruct.getformat(
+                    Glat_format_3_octabox_metrics
+                )
+                vals = {}
+                for k in names:
+                    if k == "subboxBitmap":
+                        continue
+                    vals[k] = "{:.3f}%".format(getattr(o, k) * 100.0 / 255)
+                vals["bitmap"] = "{:0X}".format(o.subboxBitmap)
+                writer.begintag("octaboxes", **vals)
+                writer.newline()
+                formatstring, names, fixes = sstruct.getformat(
+                    Glat_format_3_subbox_entry
+                )
+                for s in o.subboxes:
+                    vals = {}
+                    for k in names:
+                        vals[k] = "{:.3f}%".format(getattr(s, k) * 100.0 / 255)
+                    writer.simpletag("octabox", **vals)
+                    writer.newline()
+                writer.endtag("octaboxes")
+                writer.newline()
+            for k, v in sorted(a.items()):
+                writer.simpletag("attribute", index=k, value=v)
+                writer.newline()
+            writer.endtag("glyph")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = float(safeEval(attrs["version"]))
+            self.scheme = int(safeEval(attrs["compressionScheme"]))
+        if name != "glyph":
+            return
+        if not hasattr(self, "attributes"):
+            self.attributes = {}
+        gname = attrs["name"]
+        attributes = _Dict()
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            tag, attrs, subcontent = element
+            if tag == "attribute":
+                k = int(safeEval(attrs["index"]))
+                v = int(safeEval(attrs["value"]))
+                attributes[k] = v
+            elif tag == "octaboxes":
+                self.hasOctaboxes = True
+                o = _Object()
+                o.subboxBitmap = int(attrs["bitmap"], 16)
+                o.subboxes = []
+                del attrs["bitmap"]
+                for k, v in attrs.items():
+                    setattr(o, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
+                for element in subcontent:
+                    if not isinstance(element, tuple):
+                        continue
+                    (tag, attrs, subcontent) = element
+                    so = _Object()
+                    for k, v in attrs.items():
+                        setattr(so, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
+                    o.subboxes.append(so)
+                attributes.octabox = o
+        self.attributes[gname] = attributes

fontTools/ttLib/tables/G__l_o_c.py

@@ -0,0 +1,85 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import array
+import sys
+
+
+Gloc_header = """
+    >        # big endian
+    version: 16.16F    # Table version
+    flags:        H    # bit 0: 1=long format, 0=short format
+                       # bit 1: 1=attribute names, 0=no names
+    numAttribs:   H    # NUmber of attributes
+"""
+
+
+class table_G__l_o_c(DefaultTable.DefaultTable):
+    """Graphite Index to Glyph Atttributes table
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-tables
+    """
+
+    dependencies = ["Glat"]
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.attribIds = None
+        self.numAttribs = 0
+
+    def decompile(self, data, ttFont):
+        _, data = sstruct.unpack2(Gloc_header, data, self)
+        flags = self.flags
+        del self.flags
+        self.locations = array.array("I" if flags & 1 else "H")
+        self.locations.frombytes(data[: len(data) - self.numAttribs * (flags & 2)])
+        if sys.byteorder != "big":
+            self.locations.byteswap()
+        self.attribIds = array.array("H")
+        if flags & 2:
+            self.attribIds.frombytes(data[-self.numAttribs * 2 :])
+            if sys.byteorder != "big":
+                self.attribIds.byteswap()
+
+    def compile(self, ttFont):
+        data = sstruct.pack(
+            Gloc_header,
+            dict(
+                version=1.0,
+                flags=(bool(self.attribIds) << 1) + (self.locations.typecode == "I"),
+                numAttribs=self.numAttribs,
+            ),
+        )
+        if sys.byteorder != "big":
+            self.locations.byteswap()
+        data += self.locations.tobytes()
+        if sys.byteorder != "big":
+            self.locations.byteswap()
+        if self.attribIds:
+            if sys.byteorder != "big":
+                self.attribIds.byteswap()
+            data += self.attribIds.tobytes()
+            if sys.byteorder != "big":
+                self.attribIds.byteswap()
+        return data
+
+    def set(self, locations):
+        long_format = max(locations) >= 65536
+        self.locations = array.array("I" if long_format else "H", locations)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("attributes", number=self.numAttribs)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "attributes":
+            self.numAttribs = int(safeEval(attrs["number"]))
+
+    def __getitem__(self, index):
+        return self.locations[index]
+
+    def __len__(self):
+        return len(self.locations)
+
+    def __iter__(self):
+        return iter(self.locations)

fontTools/ttLib/tables/H_V_A_R_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_H_V_A_R_(BaseTTXConverter):
+    """Horizontal Metrics Variations table
+
+    The ``HVAR`` table contains variations in horizontal glyph metrics
+    in variable fonts.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/hvar
+    """
+
+    pass

fontTools/ttLib/tables/J_S_T_F_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_J_S_T_F_(BaseTTXConverter):
+    """Justification table
+
+    The ``JSTF`` table contains glyph substitution and positioning
+    data used to perform text justification.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/jstf
+    """
+
+    pass

fontTools/ttLib/tables/L_T_S_H_.py

@@ -0,0 +1,58 @@
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import struct
+import array
+
+# XXX I've lowered the strictness, to make sure Apple's own Chicago
+# XXX gets through. They're looking into it, I hope to raise the standards
+# XXX back to normal eventually.
+
+
+class table_L_T_S_H_(DefaultTable.DefaultTable):
+    """Linear Threshold table
+
+    The ``LTSH`` table contains per-glyph settings indicating the ppem sizes
+    at which the advance width metric should be scaled linearly, despite the
+    effects of any TrueType instructions that might otherwise alter the
+    advance width.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/ltsh
+    """
+
+    def decompile(self, data, ttFont):
+        version, numGlyphs = struct.unpack(">HH", data[:4])
+        data = data[4:]
+        assert version == 0, "unknown version: %s" % version
+        assert (len(data) % numGlyphs) < 4, "numGlyphs doesn't match data length"
+        # ouch: the assertion is not true in Chicago!
+        # assert numGlyphs == ttFont['maxp'].numGlyphs
+        yPels = array.array("B")
+        yPels.frombytes(data)
+        self.yPels = {}
+        for i in range(numGlyphs):
+            self.yPels[ttFont.getGlyphName(i)] = yPels[i]
+
+    def compile(self, ttFont):
+        version = 0
+        names = list(self.yPels.keys())
+        numGlyphs = len(names)
+        yPels = [0] * numGlyphs
+        # ouch: the assertion is not true in Chicago!
+        # assert len(self.yPels) == ttFont['maxp'].numGlyphs == numGlyphs
+        for name in names:
+            yPels[ttFont.getGlyphID(name)] = self.yPels[name]
+        yPels = array.array("B", yPels)
+        return struct.pack(">HH", version, numGlyphs) + yPels.tobytes()
+
+    def toXML(self, writer, ttFont):
+        names = sorted(self.yPels.keys())
+        for name in names:
+            writer.simpletag("yPel", name=name, value=self.yPels[name])
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "yPels"):
+            self.yPels = {}
+        if name != "yPel":
+            return  # ignore unknown tags
+        self.yPels[attrs["name"]] = safeEval(attrs["value"])

fontTools/ttLib/tables/M_A_T_H_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_M_A_T_H_(BaseTTXConverter):
+    """Mathematical Typesetting table
+
+    The ``MATH`` table contains a variety of information needed to
+    typeset glyphs in mathematical formulas and expressions.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/math
+    """
+
+    pass