fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/_o_p_b_d.py

@@ -0,0 +1,14 @@
+from .otBase import BaseTTXConverter
+
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6opbd.html
+class table__o_p_b_d(BaseTTXConverter):
+    """Optical Bounds table
+
+    The AAT ``opbd`` table contains optical boundary points for glyphs, which
+    applications can use for the visual alignment of lines of text.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6opbd.html
+    """
+
+    pass

fontTools/ttLib/tables/_p_o_s_t.py

@@ -0,0 +1,319 @@
+from fontTools import ttLib
+from fontTools.ttLib.standardGlyphOrder import standardGlyphOrder
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytechr, byteord, tobytes, tostr, safeEval, readHex
+from . import DefaultTable
+import sys
+import struct
+import array
+import logging
+
+log = logging.getLogger(__name__)
+
+postFormat = """
+	>
+	formatType:			16.16F
+	italicAngle:		16.16F		# italic angle in degrees
+	underlinePosition:	h
+	underlineThickness:	h
+	isFixedPitch:		L
+	minMemType42:		L			# minimum memory if TrueType font is downloaded
+	maxMemType42:		L			# maximum memory if TrueType font is downloaded
+	minMemType1:		L			# minimum memory if Type1 font is downloaded
+	maxMemType1:		L			# maximum memory if Type1 font is downloaded
+"""
+
+postFormatSize = sstruct.calcsize(postFormat)
+
+
+class table__p_o_s_t(DefaultTable.DefaultTable):
+    """PostScript table
+
+    The ``post`` table contains information needed to use the font on
+    PostScript printers, including the PostScript names of glyphs and
+    data that was stored in the ``FontInfo`` dictionary for Type 1 fonts.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/post
+    """
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack(postFormat, data[:postFormatSize], self)
+        data = data[postFormatSize:]
+        if self.formatType == 1.0:
+            self.decode_format_1_0(data, ttFont)
+        elif self.formatType == 2.0:
+            self.decode_format_2_0(data, ttFont)
+        elif self.formatType == 3.0:
+            self.decode_format_3_0(data, ttFont)
+        elif self.formatType == 4.0:
+            self.decode_format_4_0(data, ttFont)
+        else:
+            # supported format
+            raise ttLib.TTLibError(
+                "'post' table format %f not supported" % self.formatType
+            )
+
+    def compile(self, ttFont):
+        data = sstruct.pack(postFormat, self)
+        if self.formatType == 1.0:
+            pass  # we're done
+        elif self.formatType == 2.0:
+            data = data + self.encode_format_2_0(ttFont)
+        elif self.formatType == 3.0:
+            pass  # we're done
+        elif self.formatType == 4.0:
+            data = data + self.encode_format_4_0(ttFont)
+        else:
+            # supported format
+            raise ttLib.TTLibError(
+                "'post' table format %f not supported" % self.formatType
+            )
+        return data
+
+    def getGlyphOrder(self):
+        """This function will get called by a ttLib.TTFont instance.
+        Do not call this function yourself, use TTFont().getGlyphOrder()
+        or its relatives instead!
+        """
+        if not hasattr(self, "glyphOrder"):
+            raise ttLib.TTLibError("illegal use of getGlyphOrder()")
+        glyphOrder = self.glyphOrder
+        del self.glyphOrder
+        return glyphOrder
+
+    def decode_format_1_0(self, data, ttFont):
+        self.glyphOrder = standardGlyphOrder[: ttFont["maxp"].numGlyphs]
+
+    def decode_format_2_0(self, data, ttFont):
+        (numGlyphs,) = struct.unpack(">H", data[:2])
+        numGlyphs = int(numGlyphs)
+        if numGlyphs > ttFont["maxp"].numGlyphs:
+            # Assume the numGlyphs field is bogus, so sync with maxp.
+            # I've seen this in one font, and if the assumption is
+            # wrong elsewhere, well, so be it: it's hard enough to
+            # work around _one_ non-conforming post format...
+            numGlyphs = ttFont["maxp"].numGlyphs
+        data = data[2:]
+        indices = array.array("H")
+        indices.frombytes(data[: 2 * numGlyphs])
+        if sys.byteorder != "big":
+            indices.byteswap()
+        data = data[2 * numGlyphs :]
+        maxIndex = max(indices)
+        self.extraNames = extraNames = unpackPStrings(data, maxIndex - 257)
+        self.glyphOrder = glyphOrder = [""] * int(ttFont["maxp"].numGlyphs)
+        for glyphID in range(numGlyphs):
+            index = indices[glyphID]
+            if index > 257:
+                try:
+                    name = extraNames[index - 258]
+                except IndexError:
+                    name = ""
+            else:
+                # fetch names from standard list
+                name = standardGlyphOrder[index]
+            glyphOrder[glyphID] = name
+        self.build_psNameMapping(ttFont)
+
+    def build_psNameMapping(self, ttFont):
+        mapping = {}
+        allNames = {}
+        glyphOrderNames = set(self.glyphOrder)
+        for i in range(ttFont["maxp"].numGlyphs):
+            glyphName = psName = self.glyphOrder[i]
+            if glyphName == "":
+                glyphName = "glyph%.5d" % i
+
+            if glyphName in allNames:
+                # make up a new glyphName that's unique
+                n = allNames[glyphName]
+                # check if the glyph name exists in the glyph order
+                while f"{glyphName}.{n}" in glyphOrderNames:
+                    n += 1
+                allNames[glyphName] = n + 1
+                glyphName = f"{glyphName}.{n}"
+
+            allNames[glyphName] = 1
+            if glyphName != psName:
+                self.glyphOrder[i] = glyphName
+                mapping[glyphName] = psName
+
+        self.mapping = mapping
+
+    def decode_format_3_0(self, data, ttFont):
+        # Setting self.glyphOrder to None will cause the TTFont object
+        # try and construct glyph names from a Unicode cmap table.
+        self.glyphOrder = None
+
+    def decode_format_4_0(self, data, ttFont):
+        from fontTools import agl
+
+        numGlyphs = ttFont["maxp"].numGlyphs
+        indices = array.array("H")
+        indices.frombytes(data)
+        if sys.byteorder != "big":
+            indices.byteswap()
+        # In some older fonts, the size of the post table doesn't match
+        # the number of glyphs. Sometimes it's bigger, sometimes smaller.
+        self.glyphOrder = glyphOrder = [""] * int(numGlyphs)
+        for i in range(min(len(indices), numGlyphs)):
+            if indices[i] == 0xFFFF:
+                self.glyphOrder[i] = ""
+            elif indices[i] in agl.UV2AGL:
+                self.glyphOrder[i] = agl.UV2AGL[indices[i]]
+            else:
+                self.glyphOrder[i] = "uni%04X" % indices[i]
+        self.build_psNameMapping(ttFont)
+
+    def encode_format_2_0(self, ttFont):
+        numGlyphs = ttFont["maxp"].numGlyphs
+        glyphOrder = ttFont.getGlyphOrder()
+        assert len(glyphOrder) == numGlyphs
+        indices = array.array("H")
+        extraDict = {}
+        extraNames = self.extraNames = [
+            n for n in self.extraNames if n not in standardGlyphOrder
+        ]
+        for i, name in enumerate(extraNames):
+            extraDict[name] = i
+        for glyphName in glyphOrder:
+            if glyphName in self.mapping:
+                psName = self.mapping[glyphName]
+            else:
+                psName = glyphName
+            if psName in extraDict:
+                index = 258 + extraDict[psName]
+            elif psName in standardGlyphOrder:
+                index = standardGlyphOrder.index(psName)
+            else:
+                index = 258 + len(extraNames)
+                extraDict[psName] = len(extraNames)
+                extraNames.append(psName)
+            indices.append(index)
+        if sys.byteorder != "big":
+            indices.byteswap()
+        return (
+            struct.pack(">H", numGlyphs) + indices.tobytes() + packPStrings(extraNames)
+        )
+
+    def encode_format_4_0(self, ttFont):
+        from fontTools import agl
+
+        numGlyphs = ttFont["maxp"].numGlyphs
+        glyphOrder = ttFont.getGlyphOrder()
+        assert len(glyphOrder) == numGlyphs
+        indices = array.array("H")
+        for glyphID in glyphOrder:
+            glyphID = glyphID.split("#")[0]
+            if glyphID in agl.AGL2UV:
+                indices.append(agl.AGL2UV[glyphID])
+            elif len(glyphID) == 7 and glyphID[:3] == "uni":
+                indices.append(int(glyphID[3:], 16))
+            else:
+                indices.append(0xFFFF)
+        if sys.byteorder != "big":
+            indices.byteswap()
+        return indices.tobytes()
+
+    def toXML(self, writer, ttFont):
+        formatstring, names, fixes = sstruct.getformat(postFormat)
+        for name in names:
+            value = getattr(self, name)
+            writer.simpletag(name, value=value)
+            writer.newline()
+        if hasattr(self, "mapping"):
+            writer.begintag("psNames")
+            writer.newline()
+            writer.comment(
+                "This file uses unique glyph names based on the information\n"
+                "found in the 'post' table. Since these names might not be unique,\n"
+                "we have to invent artificial names in case of clashes. In order to\n"
+                "be able to retain the original information, we need a name to\n"
+                "ps name mapping for those cases where they differ. That's what\n"
+                "you see below.\n"
+            )
+            writer.newline()
+            items = sorted(self.mapping.items())
+            for name, psName in items:
+                writer.simpletag("psName", name=name, psName=psName)
+                writer.newline()
+            writer.endtag("psNames")
+            writer.newline()
+        if hasattr(self, "extraNames"):
+            writer.begintag("extraNames")
+            writer.newline()
+            writer.comment(
+                "following are the name that are not taken from the standard Mac glyph order"
+            )
+            writer.newline()
+            for name in self.extraNames:
+                writer.simpletag("psName", name=name)
+                writer.newline()
+            writer.endtag("extraNames")
+            writer.newline()
+        if hasattr(self, "data"):
+            writer.begintag("hexdata")
+            writer.newline()
+            writer.dumphex(self.data)
+            writer.endtag("hexdata")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name not in ("psNames", "extraNames", "hexdata"):
+            setattr(self, name, safeEval(attrs["value"]))
+        elif name == "psNames":
+            self.mapping = {}
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content = element
+                if name == "psName":
+                    self.mapping[attrs["name"]] = attrs["psName"]
+        elif name == "extraNames":
+            self.extraNames = []
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content = element
+                if name == "psName":
+                    self.extraNames.append(attrs["name"])
+        else:
+            self.data = readHex(content)
+
+
+def unpackPStrings(data, n):
+    # extract n Pascal strings from data.
+    # if there is not enough data, use ""
+
+    strings = []
+    index = 0
+    dataLen = len(data)
+
+    for _ in range(n):
+        if dataLen <= index:
+            length = 0
+        else:
+            length = byteord(data[index])
+        index += 1
+
+        if dataLen <= index + length - 1:
+            name = ""
+        else:
+            name = tostr(data[index : index + length], encoding="latin1")
+        strings.append(name)
+        index += length
+
+    if index < dataLen:
+        log.warning("%d extra bytes in post.stringData array", dataLen - index)
+
+    elif dataLen < index:
+        log.warning("not enough data in post.stringData array")
+
+    return strings
+
+
+def packPStrings(strings):
+    data = b""
+    for s in strings:
+        data = data + bytechr(len(s)) + tobytes(s, encoding="latin1")
+    return data

fontTools/ttLib/tables/_p_r_e_p.py

@@ -0,0 +1,16 @@
+from fontTools import ttLib
+
+superclass = ttLib.getTableClass("fpgm")
+
+
+class table__p_r_e_p(superclass):
+    """Control Value Program table
+
+    The ``prep`` table contains TrueType instructions that can makee font-wide
+    alterations to the Control Value Table. It may potentially be executed
+    before any glyph is processed.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/prep
+    """
+
+    pass

fontTools/ttLib/tables/_p_r_o_p.py

@@ -0,0 +1,12 @@
+from .otBase import BaseTTXConverter
+
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6prop.html
+class table__p_r_o_p(BaseTTXConverter):
+    """The AAT ``prop`` table can store a variety of per-glyph properties, such as
+       Unicode directionality or whether glyphs are non-spacing marks.
+
+    See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6prop.html
+    """
+
+    pass

fontTools/ttLib/tables/_s_b_i_x.py

@@ -0,0 +1,129 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval, num2binary, binary2num
+from . import DefaultTable
+from .sbixStrike import Strike
+
+
+sbixHeaderFormat = """
+	>
+	version:       H	# Version number (set to 1)
+	flags:         H	# The only two bits used in the flags field are bits 0
+						# and 1. For historical reasons, bit 0 must always be 1.
+						# Bit 1 is a sbixDrawOutlines flag and is interpreted as
+						# follows:
+						#     0: Draw only 'sbix' bitmaps
+						#     1: Draw both 'sbix' bitmaps and outlines, in that
+						#        order
+	numStrikes:    L	# Number of bitmap strikes to follow
+"""
+sbixHeaderFormatSize = sstruct.calcsize(sbixHeaderFormat)
+
+
+sbixStrikeOffsetFormat = """
+	>
+	strikeOffset:  L	# Offset from begining of table to data for the
+						# individual strike
+"""
+sbixStrikeOffsetFormatSize = sstruct.calcsize(sbixStrikeOffsetFormat)
+
+
+class table__s_b_i_x(DefaultTable.DefaultTable):
+    """Standard Bitmap Graphics table
+
+    The ``sbix`` table stores bitmap image data in standard graphics formats
+    like JPEG, PNG, or TIFF. The glyphs for which the ``sbix`` table provides
+    data are indexed by Glyph ID. For each such glyph, the ``sbix`` table can
+    hold different data for different sizes, called "strikes."
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/sbix
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.version = 1
+        self.flags = 1
+        self.numStrikes = 0
+        self.strikes = {}
+        self.strikeOffsets = []
+
+    def decompile(self, data, ttFont):
+        # read table header
+        sstruct.unpack(sbixHeaderFormat, data[:sbixHeaderFormatSize], self)
+        # collect offsets to individual strikes in self.strikeOffsets
+        for i in range(self.numStrikes):
+            current_offset = sbixHeaderFormatSize + i * sbixStrikeOffsetFormatSize
+            offset_entry = sbixStrikeOffset()
+            sstruct.unpack(
+                sbixStrikeOffsetFormat,
+                data[current_offset : current_offset + sbixStrikeOffsetFormatSize],
+                offset_entry,
+            )
+            self.strikeOffsets.append(offset_entry.strikeOffset)
+
+        # decompile Strikes
+        for i in range(self.numStrikes - 1, -1, -1):
+            current_strike = Strike(rawdata=data[self.strikeOffsets[i] :])
+            data = data[: self.strikeOffsets[i]]
+            current_strike.decompile(ttFont)
+            # print "  Strike length: %xh" % len(bitmapSetData)
+            # print "Number of Glyph entries:", len(current_strike.glyphs)
+            if current_strike.ppem in self.strikes:
+                from fontTools import ttLib
+
+                raise ttLib.TTLibError("Pixel 'ppem' must be unique for each Strike")
+            self.strikes[current_strike.ppem] = current_strike
+
+        # after the glyph data records have been extracted, we don't need the offsets anymore
+        del self.strikeOffsets
+        del self.numStrikes
+
+    def compile(self, ttFont):
+        sbixData = b""
+        self.numStrikes = len(self.strikes)
+        sbixHeader = sstruct.pack(sbixHeaderFormat, self)
+
+        # calculate offset to start of first strike
+        setOffset = sbixHeaderFormatSize + sbixStrikeOffsetFormatSize * self.numStrikes
+
+        for si in sorted(self.strikes.keys()):
+            current_strike = self.strikes[si]
+            current_strike.compile(ttFont)
+            # append offset to this strike to table header
+            current_strike.strikeOffset = setOffset
+            sbixHeader += sstruct.pack(sbixStrikeOffsetFormat, current_strike)
+            setOffset += len(current_strike.data)
+            sbixData += current_strike.data
+
+        return sbixHeader + sbixData
+
+    def toXML(self, xmlWriter, ttFont):
+        xmlWriter.simpletag("version", value=self.version)
+        xmlWriter.newline()
+        xmlWriter.simpletag("flags", value=num2binary(self.flags, 16))
+        xmlWriter.newline()
+        for i in sorted(self.strikes.keys()):
+            self.strikes[i].toXML(xmlWriter, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            setattr(self, name, safeEval(attrs["value"]))
+        elif name == "flags":
+            setattr(self, name, binary2num(attrs["value"]))
+        elif name == "strike":
+            current_strike = Strike()
+            for element in content:
+                if isinstance(element, tuple):
+                    name, attrs, content = element
+                    current_strike.fromXML(name, attrs, content, ttFont)
+            self.strikes[current_strike.ppem] = current_strike
+        else:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError("can't handle '%s' element" % name)
+
+
+# Helper classes
+
+
+class sbixStrikeOffset(object):
+    pass