generate-mark-anchor-font.py

Enable keyboard shortcuts

#!/usr/bin/env python3

# Generates letter-spacing/support/mark-anchor-test.ttf, a font that positions a

# combining mark with an OpenType GPOS mark-to-base anchor.

# Usage: pip install fonttools && ./generate-mark-anchor-font.py

# Why a purpose-built font is needed

# ----------------------------------

# A test for "letter-spacing is not inserted inside a typographic character

# unit" needs a combining mark whose position comes from a *glyph offset* rather

# than from glyph advances, because that is the case where an implementation can

# get the cluster's advance right and the mark's paint position wrong. Whether a

# given system font does that for a given mark is not knowable from within a

# test, so the font is built here instead, with an explicit GPOS MarkBasePos

# anchor and a zero-advance mark glyph. Core Text additionally composes common

# Latin base-plus-mark pairs into a single precomposed glyph, which removes the

# mark entirely, so the mark must be one with no precomposed form.

# Glyph design

# ------------

# Marks are stacked *above* the base rather than beside it, and every glyph

# occupies a distinct horizontal band, so a correctly positioned cluster is

# pixel-identical to a single reference glyph without any two outlines sharing,

# crossing, or overlapping an edge:

#   'A'    -> bottombar   advance 1000, ink x [0,1000] y [0,200]

#   U+0301 -> midbar      advance 0,    ink x [0,1000] y [250,450]

#   U+0300 -> topbar      advance 0,    ink x [0,1000] y [500,700]

#   'B'    -> twobars     advance 1000, bottombar + midbar

#   'C'    -> threebars   advance 1000, bottombar + midbar + topbar

#   'D'    -> midbaronly  advance 1000, midbar's ink as a *spacing* glyph

#   "A" + U+0301            ==  "B"

#   "A" + U+0301 + U+0300   ==  "C"

#   "A" + space + U+0301    ==  "AD"      (see the space anchor below)

# The same glyphs are also mapped to Hebrew ALEF, BET, GIMEL and DALET so the RTL

# tests compare the same outlines the LTR ones do. A Hebrew base rather than

# 'unicode-bidi: bidi-override', because an override assigns the mark its level

# directly and so skips bidi rule W1, the rule that keeps a mark with its base.

#   U+05D0 -> bottombar    U+05D1 -> twobars

#   U+05D2 -> threebars    U+05D3 -> midbaronly

# Both marks anchor to the same point on the base, so each independently proves

# it landed on its base; giving them separate bands is what lets a two-mark

# cluster be compared exactly, since two marks painting the *same* rectangle

# would composite its antialiased edges twice and no longer match a reference

# that paints it once.

# 'space' is a mark-attachment base as well as 'A'. A word-spacing test needs a

# mark whose base is a word-separator character, and 'D' gives that test a

# reference: "A" + space + U+0301 paints the bottom bar in the first em and the

# middle bar in the second, which is exactly what "AD" paints.

# Deliberately avoided:

#   - No horizontal adjacency between base and marks, so there is no interior

#     vertical edge whose antialiasing could differ from the reference.

#   - No overlapping outlines anywhere, for the compositing reason above.

# Every ink coordinate is a multiple of 50 font units, so at a font-size that is

# a multiple of 20px every edge lands on a whole pixel at both 1x and 2x.

import io

import os

from fontTools.fontBuilder import FontBuilder

from fontTools.feaLib.builder import addOpenTypeFeatures

from fontTools.pens.ttGlyphPen import TTGlyphPen

EM = 1000

ASCENT = 800

DESCENT = 200

BOTTOM_BAR = (0, 200)     # y range of the base's ink

MID_BAR = (250, 450)      # y range of U+0301's ink

TOP_BAR = (500, 700)      # y range of U+0300's ink

# The base puts the mark's origin back at the base's own origin: the mark's

# anchor is at x=0, so a base anchor of x=0 means the shaper emits an offset of

# -EM (cancelling the base's advance) and the mark paints over the base.

BASE_ANCHOR_X = 0

FAMILY = "mark-anchor-test"

FEATURES = """

languagesystem DFLT dflt;

languagesystem latn dflt;

languagesystem hebr dflt;

markClass [midbar topbar] <anchor 0 0> @MARKS;

feature mark {

    pos base [bottombar space] <anchor %d 0> mark @MARKS;

} mark;

""" % BASE_ANCHOR_X

def bars(*y_ranges):

    pen = TTGlyphPen(None)

    for y_min, y_max in y_ranges:

        pen.moveTo((0, y_min))

        pen.lineTo((0, y_max))

        pen.lineTo((EM, y_max))

        pen.lineTo((EM, y_min))

        pen.closePath()

    return pen.glyph()

def empty():

    return TTGlyphPen(None).glyph()

def main():

    glyph_order = [".notdef", "space", "bottombar", "midbar", "topbar",

                   "twobars", "threebars", "midbaronly"]

    glyphs = {

        ".notdef": empty(),

        "space": empty(),

        "bottombar": bars(BOTTOM_BAR),

        "midbar": bars(MID_BAR),

        "topbar": bars(TOP_BAR),

        "twobars": bars(BOTTOM_BAR, MID_BAR),

        "threebars": bars(BOTTOM_BAR, MID_BAR, TOP_BAR),

        "midbaronly": bars(MID_BAR),

    # (advance, left side bearing). A combining mark must have a zero advance;

    # that is what makes it a mark rather than a spacing glyph. 'midbaronly' is

    # the same ink with a normal advance, for the word-spacing reference.

    metrics = {

        ".notdef": (EM, 0),

        "space": (EM, 0),

        "bottombar": (EM, 0),

        "midbar": (0, 0),

        "topbar": (0, 0),

        "twobars": (EM, 0),

        "threebars": (EM, 0),

        "midbaronly": (EM, 0),

    cmap = {

        0x0020: "space",

        0x0041: "bottombar",   # 'A'

        0x0042: "twobars",     # 'B'

        0x0043: "threebars",   # 'C'

        0x0044: "midbaronly",  # 'D'

        0x0300: "topbar",      # COMBINING GRAVE ACCENT

        0x0301: "midbar",      # COMBINING ACUTE ACCENT

        # Hebrew bases for the RTL tests; the marks are script-neutral and reused

        # as-is, and neither has a precomposed form on a Hebrew base.

        0x05D0: "bottombar",   # ALEF

        0x05D1: "twobars",     # BET

        0x05D2: "threebars",   # GIMEL

        0x05D3: "midbaronly",  # DALET

    fb = FontBuilder(EM, isTTF=True)

    fb.setupGlyphOrder(glyph_order)

    fb.setupCharacterMap(cmap)

    fb.setupGlyf(glyphs)

    fb.setupHorizontalMetrics(metrics)

    fb.setupHorizontalHeader(ascent=ASCENT, descent=-DESCENT)

    fb.setupNameTable({

        "familyName": FAMILY,

        "styleName": "Regular",

        "uniqueFontIdentifier": "%s;Regular;web-platform-tests" % FAMILY,

        "fullName": FAMILY,

        "version": "1.000",

        "psName": "mark-anchor-test-Regular",

        "manufacturer": "web-platform-tests",

        "licenseDescription":

            "Generated for web-platform-tests by "

            "css/css-text/tools/generate-mark-anchor-font.py. "

            "Available under the W3C 3-clause BSD license.",

})

    fb.setupOS2(

        sTypoAscender=ASCENT,

        sTypoDescender=-DESCENT,

        sTypoLineGap=0,

        usWinAscent=ASCENT,

        usWinDescent=DESCENT,

        sxHeight=TOP_BAR[1],

        sCapHeight=TOP_BAR[1],

        achVendID="NONE",

        fsType=0,

    fb.setupPost(isFixedPitch=0)

    addOpenTypeFeatures(fb.font, io.StringIO(FEATURES))

    # Lives in the shared /fonts/ directory because tests in three directories

    # across two specs use it: css-text/letter-spacing, css-text/word-spacing,

    # and css-fonts. Referenced as /fonts/mark-anchor-test.ttf.

    out_dir = os.path.join(

        os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "fonts")

    # Shipped uncompressed so that the font stays readable by standard OpenType

    # tooling: hb-shape has no WOFF support, and being able to run it on the

    # bundled file is worth more here than a few hundred bytes.

    out = os.path.normpath(os.path.join(out_dir, "%s.ttf" % FAMILY))

    fb.save(out)

    print("Wrote %s" % out)

if __name__ == "__main__":

    main()