Optional cross-platform outline rendering mode

Lib/fontgoggles/font/dsFont.py

@@ -23,7 +23,7 @@
 from ..compile.dsCompiler import getTTPaths
 from ..misc.hbShape import HBShape
 from ..misc.properties import cachedProperty
-from ..mac.makePathFromOutline import makePathFromArrays
+from ..misc.platform import Platform
 
 
 class DesignSpaceSourceError(CompilerError):
@@ -443,7 +443,7 @@ def verticalOrigin(self):
         return self.getPoints()[-2]
 
     def getOutline(self):
-        return makePathFromArrays(self.getPoints(), self.tags, self.contours)
+        return Platform.pathFromArrays(self, self.getPoints(), self.tags, self.contours)
 
     def draw(self, pen):
         ppen = PointToSegmentPen(pen)

Lib/fontgoggles/font/glyphDrawing.py

@@ -1,6 +1,5 @@
-from AppKit import NSGraphicsContext
 from fontTools.misc.arrayTools import unionRect
-from ..mac.drawing import rectFromNSRect, nsColorFromRGBA
+from ..misc.platform import Platform
 from ..misc.properties import cachedProperty
 
 
@@ -24,11 +23,11 @@ def __init__(self, path):
     def bounds(self):
         bounds = None
         if self.path.elementCount():
-            bounds = rectFromNSRect(self.path.controlPointBounds())
+            bounds = Platform.convertRect(self.path.controlPointBounds())
         return bounds
 
     def draw(self, colorPalette, defaultColor):
-        nsColorFromRGBA(defaultColor).set()
+        Platform.convertColor(defaultColor).set()
         self.path.fill()
 
     def pointInside(self, pt):
@@ -46,7 +45,7 @@ def bounds(self):
         for path, colorID in self.layers:
             if not path.elementCount():
                 continue
-            pathBounds = rectFromNSRect(path.controlPointBounds())
+            pathBounds = Platform.convertRect(path.controlPointBounds())
             if bounds is None:
                 bounds = pathBounds
             else:
@@ -60,7 +59,7 @@ def draw(self, colorPalette, defaultColor):
                 if colorID < len(colorPalette) else
                 defaultColor
             )
-            nsColorFromRGBA(color).set()
+            Platform.convertColor(color).set()
             path.fill()
 
     def pointInside(self, pt):
@@ -77,15 +76,7 @@ def bounds(self):
         return self.colorFont.getGlyphBounds(self.glyphName)
 
     def draw(self, colorPalette, defaultColor):
-        from blackrenderer.backends.coregraphics import CoreGraphicsCanvas
-
-        cgContext = NSGraphicsContext.currentContext().CGContext()
-        self.colorFont.drawGlyph(
-            self.glyphName,
-            CoreGraphicsCanvas(cgContext),
-            palette=colorPalette,
-            textColor=defaultColor,
-        )
+        Platform.drawCOLRv1Glyph(self.colorFont, self.glyphName, colorPalette, defaultColor)
 
     def pointInside(self, pt):
         return False  # TODO: implement

Lib/fontgoggles/font/otfFont.py

@@ -3,23 +3,22 @@
 from .baseFont import BaseFont
 from .glyphDrawing import GlyphDrawing, GlyphLayersDrawing, GlyphCOLRv1Drawing
 from ..compile.compilerPool import compileTTXToBytes
-from ..mac.makePathFromOutline import makePathFromGlyph
 from ..misc.hbShape import HBShape
 from ..misc.properties import cachedProperty
+from ..misc.platform import PlatformPenWrapper, Platform
 
 
 class _OTFBaseFont(BaseFont):
 
     def _getGlyphOutline(self, name):
-        return makePathFromGlyph(self.shaper.font, self.shaper.glyphMap[name])
+        return Platform.pathFromGlyph(self.shaper.font, self.shaper.glyphMap[name])
 
     def _getGlyphDrawing(self, glyphName, colorLayers):
         if "VarC" in self.ttFont:
-            from fontTools.pens.cocoaPen import CocoaPen
-            pen = CocoaPen(None)
+            penwrapper = PlatformPenWrapper(None)
             location = self._currentVarLocation or {}
-            self.varcFont.drawGlyph(pen, glyphName, location)
-            return GlyphDrawing(pen.path)
+            self.varcFont.drawGlyph(penwrapper.pen, glyphName, location)
+            return GlyphDrawing(penwrapper.getOutline())
         if colorLayers:
             if self.colorLayers is not None:
                 layers = self.colorLayers.get(glyphName)

Lib/fontgoggles/font/ufoFont.py

@@ -10,7 +10,6 @@
 from fontTools.feaLib.ast import IncludeStatement
 from fontTools.feaLib.error import FeatureLibError
 from fontTools.fontBuilder import FontBuilder
-from fontTools.pens.cocoaPen import CocoaPen  # TODO: factor out mac-specific code
 from fontTools.ttLib import TTFont
 from fontTools.ufoLib import UFOReader, UFOFileStructure
 from fontTools.ufoLib import (FONTINFO_FILENAME, GROUPS_FILENAME, KERNING_FILENAME,
@@ -23,6 +22,7 @@
 from ..compile.ufoCompiler import fetchGlyphInfo
 from ..misc.hbShape import HBShape
 from ..misc.properties import cachedProperty
+from ..misc.platform import PlatformPenWrapper
 
 
 class UFOFont(BaseFont):
@@ -151,9 +151,9 @@ def _getGlyph(self, glyphName, layerName=None):
         return glyph
 
     def _addOutlinePathToGlyph(self, glyph):
-        pen = CocoaPen(self.glyphSet)
-        glyph.draw(pen)
-        glyph.outline = pen.path
+        penwrapper = PlatformPenWrapper(self.glyphSet)
+        glyph.draw(penwrapper.pen)
+        glyph.outline = penwrapper.getOutline()
 
     def _getHorizontalAdvance(self, glyphName):
         glyph = self._getGlyph(glyphName)
@@ -258,9 +258,9 @@ def setVarLocation(self, varLocation):
         pass
 
     def getOutline(self):
-        pen = CocoaPen(None)  # by now there are no more composites
-        self.draw(pen)
-        return pen.path
+        penwrapper = PlatformPenWrapper(None)
+        self.draw(penwrapper.pen)
+        return penwrapper.getOutline()
 
 
 class Glyph(GLIFGlyph):

Lib/fontgoggles/misc/platform.py

@@ -0,0 +1,84 @@
+from fontTools.pens.recordingPen import RecordingPen
+
+"""
+An abstraction on top of CocoaPen / any Mac-specific operations
+so that fontGoggles can function as a platform-agnostic library
+"""
+
+
+CAN_COCOA = True
+
+try:
+    from fontTools.pens.cocoaPen import CocoaPen
+    # TODO some other feature detection?
+except ImportError:
+    CAN_COCOA = False
+
+
+class Platform():
+    UseCocoa = CAN_COCOA
+
+    @staticmethod
+    def pathFromArrays(font, points, tags, contours):
+        if Platform.UseCocoa:
+            from ..mac.makePathFromOutline import makePathFromArrays
+            return makePathFromArrays(points, tags, contours)
+        else:
+            rp = RecordingPen()
+            font.draw(rp)
+            return rp
+
+    @staticmethod
+    def pathFromGlyph(font, gid):
+        if Platform.UseCocoa:
+            from ..mac.makePathFromOutline import makePathFromGlyph
+            return makePathFromGlyph(font, gid)
+        else:
+            rp = RecordingPen()
+            font.draw_glyph_with_pen(gid, rp)
+            return rp
+
+    @staticmethod
+    def convertRect(r):
+        if Platform.UseCocoa:
+            from ..mac.drawing import rectFromNSRect
+            return rectFromNSRect(r)
+
+    @staticmethod
+    def convertColor(c):
+        if Platform.UseCocoa:
+            from ..mac.drawing import nsColorFromRGBA
+            return nsColorFromRGBA(c)
+
+    @staticmethod
+    def drawCOLRv1Glyph(colorFont, glyphName, colorPalette, defaultColor):
+        if Platform.UseCocoa:
+            from AppKit import NSGraphicsContext
+            from blackrenderer.backends.coregraphics import CoreGraphicsCanvas
+
+            cgContext = NSGraphicsContext.currentContext().CGContext()
+            colorFont.drawGlyph(
+                glyphName,
+                CoreGraphicsCanvas(cgContext),
+                palette=colorPalette,
+                textColor=defaultColor,
+            )
+        else:
+            raise NotImplementedError()
+
+
+class PlatformPenWrapper():
+    def __init__(self, glyphSet, path=None):
+        if Platform.UseCocoa:
+            self.pen = CocoaPen(glyphSet, path=path)
+        else:
+            self.pen = RecordingPen()
+
+    def draw(self, pen):
+        self.pen.draw(pen)
+
+    def getOutline(self):
+        if isinstance(self.pen, CocoaPen):
+            return self.pen.path
+        else:
+            return self.pen

Tests/test_makeOutline.py

@@ -1,8 +1,8 @@
 import sys
 import pytest
-from fontTools.pens.cocoaPen import CocoaPen
 from fontTools.ttLib import TTFont
 from fontgoggles.font.otfFont import OTFFont
+from fontgoggles.misc.platform import PlatformPenWrapper
 from testSupport import getFontPath
 
 
@@ -19,12 +19,12 @@ async def test_getOutlinePath():
 
     for glyphName in ["a", "B", "O", "period", "bar", "aring"]:
         p = font._getGlyphOutline(glyphName)
-        pen = CocoaPen(ttfGlyphSet)
-        ttfGlyphSet[glyphName].draw(pen)
+        penwrapper = PlatformPenWrapper(ttfGlyphSet)
+        ttfGlyphSet[glyphName].draw(penwrapper.pen)
         # The paths are not identical, due to different rounding
         # of the implied points, and different closepath behavior,
         # so comparing is hard, so we'll settle for a bounding box.
-        assert p.controlPointBounds() == pen.path.controlPointBounds()
+        assert p.controlPointBounds() == penwrapper.pen.path.controlPointBounds()
 
 
 @pytest.mark.asyncio

Tests/test_noCocoa.py

@@ -0,0 +1,44 @@
+import pytest, sys
+from asyncio import run
+from fontgoggles.font import getOpener
+from fontgoggles.misc.textInfo import TextInfo
+from testSupport import getFontPath
+from fontTools.pens.recordingPen import RecordingPen
+
+from fontgoggles.misc.platform import Platform
+
+font_paths = [
+    "MutatorSans.ttf",
+    "MutatorSansBoldWide.ufo",
+    "MutatorSans.designspace",
+]
+
+
+def test_cocoaAndNoCocoa():
+    def getDrawings(path):
+        fontPath = getFontPath(path)
+        _, opener, _ = getOpener(fontPath)
+        font = opener(fontPath, 0)
+        run(font.load(sys.stderr.write)) # to test support for non-async
+
+        textInfo = TextInfo("abc")
+        glyphs = font.getGlyphRunFromTextInfo(textInfo)
+        glyphNames = [g.name for g in glyphs]
+        glyphDrawings = list(font.getGlyphDrawings(glyphNames, True))
+
+        assert len(glyphs) == 3
+        assert len(glyphDrawings) == 3
+
+        return glyphDrawings
+
+    for font_path in font_paths:
+        glyphDrawings = getDrawings(font_path)
+        for g in glyphDrawings:
+            assert "NSBezierPath" in str(type(g.path))
+
+    Platform.UseCocoa = False
+
+    for font_path in font_paths:
+        glyphDrawings = getDrawings(font_path)
+        for g in glyphDrawings:
+            assert isinstance(g.path, RecordingPen)

requirements.txt

@@ -4,15 +4,15 @@ py2app==0.28.8
 pyobjc==10.3.1
 corefoundationasyncio==0.0.1
 cocoa-vanilla==0.6.0
-blackrenderer==0.6.0
-fonttools[woff,lxml,unicode,ufo,type1]==4.53.1
+### blackrenderer==0.6.0 # moved to setup.py
+### fonttools[woff,lxml,unicode,ufo,type1]==4.53.1 # moved to setup.py
 # Temporarily add support for experimental extensions to the not-yet-official COLRv1 format:
 # fonttools[woff,ufo,type1,unicode,lxml] @ git+https://github.com/justvanrossum/fonttools@colrv1-varco
-uharfbuzz==0.42.0
-python-bidi==0.4.2  # pin for now
+### uharfbuzz==0.42.0 # moved to setup.py
+### python-bidi==0.4.2  # pin for now # moved to setup.py
 jundo==0.1.2
-ufo2ft==3.2.8
-numpy==2.1.1
-unicodedata2==15.1.0
+### ufo2ft==3.2.8 # moved to setup.py
+### numpy==2.1.1 # moved to setup.py
+### unicodedata2==15.1.0
 git+https://github.com/BlackFoundryCom/rcjk-tools/
 delocate==0.11.0  # pin for now

setup.py

@@ -3,13 +3,18 @@
 import re
 from setuptools import setup, find_packages
 import subprocess
+import platform
 
 
 class build(_build):
     def run(self):
-        # Build our C library
-        subprocess.check_call(['./Turbo/build_lib.sh'])
-        _build.run(self)
+        if platform.system() == "Darwin":
+            try:
+                # Build our C library
+                subprocess.check_call(['./Turbo/build_lib.sh'])
+                _build.run(self)
+            except:
+                print("! Could not build turbo")
 
 
 _versionRE = re.compile(r'__version__\s*=\s*\"([^\"]+)\"')
@@ -31,6 +36,13 @@ def run(self):
     packages=find_packages("Lib"),
     package_data={'fontgoggles.mac': ['*.dylib']},
     install_requires=[
+        "blackrenderer==0.6.0",
+        "fonttools[woff,lxml,unicode,ufo,type1]==4.53.1",
+        "uharfbuzz==0.42.0",
+        "python-bidi==0.4.2",
+        "ufo2ft==3.2.8",
+        "numpy",
+        "unicodedata2==15.1.0",
     ],
     extras_require={
     },