[VARC] Variable Composites table

Lib/fontTools/fontBuilder.py

@@ -656,11 +656,7 @@ def setupGlyf(self, glyphs, calcGlyphBounds=True, validateGlyphFormat=True):
 
         if validateGlyphFormat and self.font["head"].glyphDataFormat == 0:
             for name, g in glyphs.items():
-                if g.isVarComposite():
-                    raise ValueError(
-                        f"Glyph {name!r} is a variable composite, but glyphDataFormat=0"
-                    )
-                elif g.numberOfContours > 0 and any(f & flagCubic for f in g.flags):
+                if g.numberOfContours > 0 and any(f & flagCubic for f in g.flags):
                     raise ValueError(
                         f"Glyph {name!r} has cubic Bezier outlines, but glyphDataFormat=0; "
                         "either convert to quadratics with cu2qu or set glyphDataFormat=1."

Lib/fontTools/merge/tables.py

@@ -225,7 +225,7 @@ def merge(self, m, tables):
                 g.removeHinting()
             # Expand composite glyphs to load their
             # composite glyph names.
-            if g.isComposite() or g.isVarComposite():
+            if g.isComposite():
                 g.expand(table)
     return DefaultTable.merge(self, m, tables)
 

Lib/fontTools/misc/iterTools.py

@@ -0,0 +1,12 @@
+from itertools import *
+
+# Python 3.12:
+if "batched" not in globals():
+    # https://docs.python.org/3/library/itertools.html#itertools.batched
+    def batched(iterable, n):
+        # batched('ABCDEFG', 3) --> ABC DEF G
+        if n < 1:
+            raise ValueError("n must be at least one")
+        it = iter(iterable)
+        while batch := tuple(islice(it, n)):
+            yield batch

Lib/fontTools/misc/lazyTools.py

@@ -0,0 +1,42 @@
+from collections import UserDict, UserList
+
+__all__ = ["LazyDict", "LazyList"]
+
+
+class LazyDict(UserDict):
+    def __init__(self, data):
+        super().__init__()
+        self.data = data
+
+    def __getitem__(self, k):
+        v = self.data[k]
+        if callable(v):
+            v = v(k)
+            self.data[k] = v
+        return v
+
+
+class LazyList(UserList):
+    def __getitem__(self, k):
+        if isinstance(k, slice):
+            indices = range(*k.indices(len(self)))
+            return [self[i] for i in indices]
+        v = self.data[k]
+        if callable(v):
+            v = v(k)
+            self.data[k] = v
+        return v
+
+    def __add__(self, other):
+        if isinstance(other, LazyList):
+            other = list(other)
+        elif isinstance(other, list):
+            pass
+        else:
+            return NotImplemented
+        return list(self) + other
+
+    def __radd__(self, other):
+        if not isinstance(other, list):
+            return NotImplemented
+        return other + list(self)

Lib/fontTools/misc/transform.py

@@ -422,6 +422,19 @@
     tCenterX: float = 0
     tCenterY: float = 0
 
+    def __bool__(self):
+        return (
+            self.translateX != 0
+            or self.translateY != 0
+            or self.rotation != 0
+            or self.scaleX != 1
+            or self.scaleY != 1
+            or self.skewX != 0
+            or self.skewY != 0
+            or self.tCenterX != 0
+            or self.tCenterY != 0
+        )
+
     @classmethod
     def fromTransform(self, transform):
         # Adapted from an answer on

Lib/fontTools/pens/svgPathPen.py

@@ -2,7 +2,7 @@
 from fontTools.pens.basePen import BasePen
 
 
-def pointToString(pt, ntos=str):
+def pointToString(pt, ntos):
     return " ".join(ntos(i) for i in pt)
 
 
@@ -37,7 +37,13 @@ class SVGPathPen(BasePen):
             print(tpen.getCommands())
     """
 
-    def __init__(self, glyphSet, ntos: Callable[[float], str] = str):
+    def __init__(
+        self,
+        glyphSet,
+        ntos: Callable[[float], str] = (
+            lambda x: ("%.2f" % x) if x != int(x) else str(int(x))
+        ),
+    ):
         BasePen.__init__(self, glyphSet)
         self._commands = []
         self._lastCommand = None

Lib/fontTools/subset/__init__.py

@@ -14,7 +14,7 @@
 from fontTools.subset.util import _add_method, _uniq_sort
 from fontTools.subset.cff import *
 from fontTools.subset.svg import *
-from fontTools.varLib import varStore  # for subset_varidxes
+from fontTools.varLib import varStore, multiVarStore  # For monkey-patching
 from fontTools.ttLib.tables._n_a_m_e import NameRecordVisitor
 import sys
 import struct
@@ -2630,6 +2630,88 @@
     s.glyphs.update(variants)
 
 
+@_add_method(ttLib.getTableClass("VARC"))
+def subset_glyphs(self, s):
+    indices = self.table.Coverage.subset(s.glyphs)
+    self.table.VarCompositeGlyphs.VarCompositeGlyph = _list_subset(
+        self.table.VarCompositeGlyphs.VarCompositeGlyph, indices
+    )
+    return bool(self.table.VarCompositeGlyphs.VarCompositeGlyph)
+
+
+@_add_method(ttLib.getTableClass("VARC"))
+def closure_glyphs(self, s):
+    if self.table.VarCompositeGlyphs is None:
+        return
+
+    glyphMap = {glyphName: i for i, glyphName in enumerate(self.table.Coverage.glyphs)}
+    glyphRecords = self.table.VarCompositeGlyphs.VarCompositeGlyph
+
+    glyphs = s.glyphs
+    covered = set()
+    new = set(glyphs)
+    while new:
+        oldNew = new
+        new = set()
+        for glyphName in oldNew:
+            if glyphName in covered:
+                continue
+            idx = glyphMap.get(glyphName)
+            if idx is None:
+                continue
+            glyph = glyphRecords[idx]
+            for comp in glyph.components:
+                name = comp.glyphName
+                glyphs.add(name)
+                if name not in covered:
+                    new.add(name)
+
+
+@_add_method(ttLib.getTableClass("VARC"))
+def prune_post_subset(self, font, options):
+    table = self.table
+
+    store = table.MultiVarStore
+    if store is not None:
+        usedVarIdxes = set()
+        table.collect_varidxes(usedVarIdxes)
+        varidx_map = store.subset_varidxes(usedVarIdxes)
+        table.remap_varidxes(varidx_map)
+
+    axisIndicesList = table.AxisIndicesList.Item
+    if axisIndicesList is not None:
+        usedIndices = set()
+        for glyph in table.VarCompositeGlyphs.VarCompositeGlyph:
+            for comp in glyph.components:
+                if comp.axisIndicesIndex is not None:
+                    usedIndices.add(comp.axisIndicesIndex)
+        usedIndices = sorted(usedIndices)
+        table.AxisIndicesList.Item = _list_subset(axisIndicesList, usedIndices)
+        mapping = {old: new for new, old in enumerate(usedIndices)}
+        for glyph in table.VarCompositeGlyphs.VarCompositeGlyph:
+            for comp in glyph.components:
+                if comp.axisIndicesIndex is not None:
+                    comp.axisIndicesIndex = mapping[comp.axisIndicesIndex]
+
+    conditionList = table.ConditionList
+    if conditionList is not None:
+        conditionTables = conditionList.ConditionTable
+        usedIndices = set()
+        for glyph in table.VarCompositeGlyphs.VarCompositeGlyph:
+            for comp in glyph.components:
+                if comp.conditionIndex is not None:
+                    usedIndices.add(comp.conditionIndex)
+        usedIndices = sorted(usedIndices)
+        conditionList.ConditionTable = _list_subset(conditionTables, usedIndices)
+        mapping = {old: new for new, old in enumerate(usedIndices)}
+        for glyph in table.VarCompositeGlyphs.VarCompositeGlyph:
+            for comp in glyph.components:
+                if comp.conditionIndex is not None:
+                    comp.conditionIndex = mapping[comp.conditionIndex]
+
+    return True
+
+
 @_add_method(ttLib.getTableClass("MATH"))
 def closure_glyphs(self, s):
     if self.table.MathVariants:
@@ -3298,33 +3380,33 @@
                     self.glyphs.add(font.getGlyphName(i))
                 log.info("Added first four glyphs to subset")
 
-        if self.options.layout_closure and "GSUB" in font:
-            with timer("close glyph list over 'GSUB'"):
+        if "MATH" in font:
+            with timer("close glyph list over 'MATH'"):
                 log.info(
-                    "Closing glyph list over 'GSUB': %d glyphs before", len(self.glyphs)
+                    "Closing glyph list over 'MATH': %d glyphs before", len(self.glyphs)
                 )
                 log.glyphs(self.glyphs, font=font)
-                font["GSUB"].closure_glyphs(self)
+                font["MATH"].closure_glyphs(self)
                 self.glyphs.intersection_update(realGlyphs)
                 log.info(
-                    "Closed glyph list over 'GSUB': %d glyphs after", len(self.glyphs)
+                    "Closed glyph list over 'MATH': %d glyphs after", len(self.glyphs)
                 )
                 log.glyphs(self.glyphs, font=font)
-        self.glyphs_gsubed = frozenset(self.glyphs)
+        self.glyphs_mathed = frozenset(self.glyphs)
 
-        if "MATH" in font:
-            with timer("close glyph list over 'MATH'"):
+        if self.options.layout_closure and "GSUB" in font:
+            with timer("close glyph list over 'GSUB'"):
                 log.info(
-                    "Closing glyph list over 'MATH': %d glyphs before", len(self.glyphs)
+                    "Closing glyph list over 'GSUB': %d glyphs before", len(self.glyphs)
                 )
                 log.glyphs(self.glyphs, font=font)
-                font["MATH"].closure_glyphs(self)
+                font["GSUB"].closure_glyphs(self)
                 self.glyphs.intersection_update(realGlyphs)
                 log.info(
-                    "Closed glyph list over 'MATH': %d glyphs after", len(self.glyphs)
+                    "Closed glyph list over 'GSUB': %d glyphs after", len(self.glyphs)
                 )
                 log.glyphs(self.glyphs, font=font)
-        self.glyphs_mathed = frozenset(self.glyphs)
+        self.glyphs_gsubed = frozenset(self.glyphs)
 
         for table in ("COLR", "bsln"):
             if table in font:
@@ -3345,6 +3427,20 @@
                     log.glyphs(self.glyphs, font=font)
             setattr(self, f"glyphs_{table.lower()}ed", frozenset(self.glyphs))
 
+        if "VARC" in font:
+            with timer("close glyph list over 'VARC'"):
+                log.info(
+                    "Closing glyph list over 'VARC': %d glyphs before", len(self.glyphs)
+                )
+                log.glyphs(self.glyphs, font=font)
+                font["VARC"].closure_glyphs(self)
+                self.glyphs.intersection_update(realGlyphs)
+                log.info(
+                    "Closed glyph list over 'VARC': %d glyphs after", len(self.glyphs)
+                )
+                log.glyphs(self.glyphs, font=font)
+        self.glyphs_glyfed = frozenset(self.glyphs)
+
         if "glyf" in font:
             with timer("close glyph list over 'glyf'"):
                 log.info(