for MONO<1 fonts, just change dlig to calt, and don't remove any other features

Author: arrowtype

scripts/dlig2calt.py

@@ -9,29 +9,68 @@
 from fontTools.pens.ttGlyphPen import TTGlyphPen
 from argparse import ArgumentParser
 import pathops
+import subprocess
+import os
 
+def simpleDlig2calt(fontPath, inplace=False):
+    """
+        A simple way to change a "dlig" feature to "calt."
 
-# codeLigs = {} # probably not needed
+        Assumes the fontPath hasn’t already been converted to a TTX file,
+        as that would confuse the variables below.
+    """
 
-def dlig2calt(fontPath, inplace=False):
+    # convert font’s GSUB table to a TTX file
+    subprocess.run(["ttx", "-t", "GSUB", fontPath]) 
+
+    # make the path for a ttx
+    ttxPath = fontPath.replace(".ttf",".ttx")
+
+    # Read in the TTX file
+    with open(ttxPath, 'r') as file:
+        ttxData = file.read()
+
+    # Replace the target string to update the dlig feature tags to calt feature tags
+    ttxData = ttxData.replace('"dlig"', '"calt"')
+
+    # Write the TTX file out again
+    with open(ttxPath, 'w') as file:
+        file.write(ttxData)
+
+    # merge TTX back into font:
+    # ttx -m fontname.ttf fontname.ttx
+
+    # save font
+    if inplace:
+        subprocess.run(["ttx", "-f", "-m", fontPath, ttxPath])
+        print("\nCode ligatures are now under the calt feature and on by default.\n")
+    else:
+        newFontPath = fontPath.replace('.ttf','.calt_ligs.ttf')
+        subprocess.run(["ttx", "-o", newFontPath, "-m", fontPath, ttxPath])
+        print("Saved font with feature 'dlig' changed to 'calt' at ", newFontPath)
+
+    # clean up the temporary TTX file
+    os.remove(ttxPath)
+
+
+def makeCodeLigsMonospace(fontPath, inplace=False):
+    """
+        Takes code ligatures with different widths, and makes them all exactly one monospace character wide.
+
+        The extra width goes over the left bound, and the space is made up for by a newly-created "LIG" glyph.
+    """
 
     font = ttLib.TTFont(fontPath)
 
     # set unit width / tabular width ... assumes the "=" symbol will have a tabular width for any code font
     # 600 for most monospace fonts w/ UPM=1000
     unitWidth = font['hmtx']['equal'][0]
 
-    # make "LIG" glyph
+    # create the "LIG" glyph to fill in gaps for code ligatures made into single-unit-wide glyphs
     font['glyf'].__setitem__('LIG', font['glyf']['space'])
-
     font['hmtx'].__setitem__('LIG', font['hmtx']['space'])
 
     # set /LIG glyph width to /equal width, not /space, to allow proportional fonts
-
-    # print(font['glyf']._getPhantomPoints('LIG', font['hmtx'].metrics))
-
-    # newPhantomPoints = [(0,0), (600,0), (0, 0), (0, 0)]
-
     font['glyf']._setCoordinates('LIG', [(0,0), (600,0), (0, 0), (0, 0)], font['hmtx'].metrics)
 
 
@@ -62,29 +101,31 @@ def dlig2calt(fontPath, inplace=False):
                 newCoords = adjustedCoords+adjustedPhantoms
                 font['glyf']._setCoordinates(glyphName, newCoords, font['hmtx'].metrics)
 
-
     # add new feature code, using calt rather than dlig
     builder.addOpenTypeFeatures(font,"font-data/features/calt-generated--code_fonts_only.fea")
 
-
     # save font
     if inplace:
         font.save(fontPath)
         print("\nCode ligatures are now on by default.\n")
     else:
-        newPath = fontPath.replace('.ttf','.calt_ligs.ttf')
-        font.save(newPath)
-        print("Saved font with feature 'dlig' changed to 'calt' at ", newPath)
+        fontPath = fontPath.replace('.ttf','.calt_ligs.ttf')
+        font.save(fontPath)
+        print("Saved font with feature 'dlig' changed to 'calt' at ", fontPath)
 
 
 def main():
-  description = "Change dlig features to calt features."
-  parser = ArgumentParser(description=description)
-  parser.add_argument('font', nargs=1)
-  parser.add_argument('--inplace', action='store_true')
-  args = parser.parse_args()
-
-  dlig2calt(args.font[0], args.inplace)
+    description = "Change dlig features to calt features."
+    parser = ArgumentParser(description=description)
+    parser.add_argument('font', nargs=1)
+    parser.add_argument('--inplace', action='store_true')
+    parser.add_argument('--mono', '-m', action='store_true')
+    args = parser.parse_args()
+
+    if args.mono:
+        makeCodeLigsMonospace(args.font[0], args.inplace)
+    else:
+        simpleDlig2calt(args.font[0], args.inplace)
 
 
 if __name__ == '__main__':

scripts/instantiate-code-fonts.py

@@ -20,7 +20,7 @@
 from fontTools.varLib import instancer
 from fontTools.varLib.instancer import OverlapMode
 from opentype_feature_freezer import cli as pyftfeatfreeze
-from dlig2calt import dlig2calt
+from dlig2calt import (makeCodeLigsMonospace, simpleDlig2calt)
 from mergePowerlineFont import mergePowerlineFont
 from ttfautohint.options import USER_OPTIONS as ttfautohint_options
 
@@ -162,9 +162,12 @@ def splitFont(
             # if font is proportional, also keep the kern feature for kerning
             pyftfeatfreeze.main([f"--features=rvrn,{','.join(fontOptions['Features'])},kern", outputPath, outputPath])
 
-        if fontOptions['Code Ligatures']:
+        if fontOptions['Code Ligatures'] and fontOptions["Fonts"][instance]["MONO"] == 1:
             # swap dlig2calt to make code ligatures work in old code editor apps
-            dlig2calt(outputPath, inplace=True)
+            makeCodeLigsMonospace(outputPath, inplace=True)
+
+        if fontOptions['Code Ligatures'] and fontOptions["Fonts"][instance]["MONO"] < 1:
+            simpleDlig2calt(outputPath, inplace=True)
 
         # if casual, merge with casual PL; if linear merge w/ Linear PL
         if fontOptions["Fonts"][instance]["CASL"] > 0.5: