def _kern_coverage(names, classes=None):
ret = []
for name in names:
if name.startswith('@'):
name = name[1:]
if classes is not None:
glyphs = tuple(ast.GlyphName(g) for g in sorted(classes[name]))
ret.append([ast.Enum(glyphs)])
else:
ret.append([ast.GroupName(f'KERN{name}', None)])
else:
ret.append([ast.GlyphName(name)])
return ret
def test_substitution_single_in_context(self):
parser = self.parser(
'DEF_GROUP "Denominators" ENUM GLYPH "one.dnom" GLYPH "two.dnom" '
'END_ENUM END_GROUP\n'
'DEF_LOOKUP "fracdnom" PROCESS_BASE PROCESS_MARKS ALL '
'DIRECTION LTR\n'
'IN_CONTEXT LEFT ENUM GROUP "Denominators" GLYPH "fraction" '
'END_ENUM\n'
'END_CONTEXT\n'
'AS_SUBSTITUTION\n'
'SUB GLYPH "one"\n'
'WITH GLYPH "one.dnom"\n'
'END_SUB\n'
'SUB GLYPH "two"\n'
'WITH GLYPH "two.dnom"\n'
'END_SUB\n'
'END_SUBSTITUTION')
[group, lookup] = parser.parse().statements
context = lookup.context[0]
self.assertEqual((lookup.name, list(lookup.sub.mapping.items()),
context.ex_or_in, context.left, context.right),
("fracdnom", [
(self.enum(["one"]), self.enum(["one.dnom"])),
(self.enum(["two"]), self.enum(["two.dnom"]))
], "IN_CONTEXT", [
ast.Enum([
ast.GroupName("Denominators", parser=parser),
ast.GlyphName("fraction")
])
], []))
def test_substitution_reverse_chaining_single(self):
parser = self.parser(
'DEF_GLYPH "zero" ID 1 UNICODE 48 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "one" ID 2 UNICODE 49 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "two" ID 3 UNICODE 50 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "three" ID 4 UNICODE 51 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "four" ID 5 UNICODE 52 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "five" ID 6 UNICODE 53 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "six" ID 7 UNICODE 54 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "seven" ID 8 UNICODE 55 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "eight" ID 9 UNICODE 56 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "nine" ID 10 UNICODE 57 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "zero.numr" ID 11 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "one.numr" ID 12 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "two.numr" ID 13 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "three.numr" ID 14 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "four.numr" ID 15 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "five.numr" ID 16 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "six.numr" ID 17 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "seven.numr" ID 18 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "eight.numr" ID 19 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "nine.numr" ID 20 TYPE BASE END_GLYPH\n'
'DEF_LOOKUP "numr" PROCESS_BASE PROCESS_MARKS ALL '
'DIRECTION LTR REVERSAL\n'
'IN_CONTEXT\n'
'RIGHT ENUM '
'GLYPH "fraction" '
'RANGE "zero.numr" TO "nine.numr" '
'END_ENUM\n'
'END_CONTEXT\n'
'AS_SUBSTITUTION\n'
'SUB RANGE "zero" TO "nine"\n'
'WITH RANGE "zero.numr" TO "nine.numr"\n'
'END_SUB\n'
'END_SUBSTITUTION')
lookup = parser.parse().statements[-1]
self.assertEqual(
(lookup.name, lookup.context[0].right,
list(lookup.sub.mapping.items())),
("numr", [(ast.Enum([
ast.GlyphName("fraction"),
ast.Range("zero.numr", "nine.numr", parser)
]))], [(ast.Enum([ast.Range("zero", "nine", parser)]),
ast.Enum([ast.Range("zero.numr", "nine.numr", parser)]))]))
def parse_coverage_(self):
coverage = []
location = self.cur_token_location_
while self.next_token_ in ("GLYPH", "GROUP", "RANGE", "ENUM"):
if self.next_token_ == "ENUM":
enum = self.parse_enum_()
coverage.append(enum)
elif self.next_token_ == "GLYPH":
self.expect_keyword_("GLYPH")
name = self.expect_string_()
coverage.append(ast.GlyphName(name, location=location))
elif self.next_token_ == "GROUP":
self.expect_keyword_("GROUP")
name = self.expect_string_()
coverage.append(ast.GroupName(name, self, location=location))
elif self.next_token_ == "RANGE":
self.expect_keyword_("RANGE")
start = self.expect_string_()
self.expect_keyword_("TO")
end = self.expect_string_()
coverage.append(ast.Range(start, end, self, location=location))
return tuple(coverage)
def exportVoltAnchors(font):
glyphOrder = [g.name for g in font]
# Save groups and lookups files for each master.
for master in font.masters:
# Collect anchors that need mkmk lookups (base glyph is a mark).
mkmk = set()
for glyph in font:
layer = glyph.layers[master.name]
for anchor in layer.anchors:
name = anchor.name
if not name.startswith('_') and glyph.openTypeGlyphClass == 3:
mkmk.add(name.split('_')[0])
# Collect anchors that need ligature lookups (anchor with index).
ligs = set()
for glyph in font:
layer = glyph.layers[master.name]
for anchor in layer.anchors:
name = anchor.name
if name.startswith('_'):
name = name[1:]
if '_' in name:
ligs.add(name.split('_')[0])
lookups = {}
groups = {}
anchors = []
for glyph in font:
layer = glyph.layers[master.name]
for anchor in layer.anchors:
x = otRound(anchor.x)
y = otRound(anchor.y)
if anchor.name.startswith('_'):
# Mark anchor.
if glyph.openTypeGlyphClass != 3:
# Not a mark glyph? Ignore the anchor or VOLT will error.
continue
name = anchor.name[1:]
# Add to groups. We build groups for mark glyphs by anchor.
group = f'MARK_{name}'
if group not in groups:
groups[group] = set()
groups[group].add(glyph.name)
# mkmk anchors are added to both mark and mkmk lookups
# because they might be used with non-mark bases after
# anchor propagation.
lookupnames = [f'mark_{name}']
if name in mkmk:
lookupnames.append(f'mkmk_{name}')
if name in ligs:
lookupnames.append(f'mark_{name}_ligs')
# Add the glyph to respective lookup(s).
for lookupname in lookupnames:
if lookupname not in lookups:
lookups[lookupname] = _attachment_lookup(
lookupname)
# For mkmk lookups we use individual glyphs, for mark
# lookups we use groups. There is no technical reason
# for this, just how JH likes it.
if lookupname.startswith('mkmk'):
to = ([ast.GlyphName(glyph.name)], name)
lookups[lookupname].pos.coverage_to.append(to)
elif not lookups[lookupname].pos.coverage_to:
to = ([ast.GroupName(group, None)], name)
lookups[lookupname].pos.coverage_to.append(to)
# Add the anchor.
name, comp = f'MARK_{name}', 1
pos = ast.Pos(None, x, y, {}, {}, {})
gid = glyphOrder.index(glyph.name)
anchors.append(
ast.AnchorDefinition(name, gid, glyph.name, comp,
False, pos))
else:
# Base anchor.
name, comp = anchor.name, 1
lookupname = f'mark_{name}'
if '_' in name:
# Split ligature anchor (e.g. “top_1” and use the
# number for ligature component.
name, comp = name.split('_')
lookupname = f'mark_{name}_ligs'
if glyph.openTypeGlyphClass == 3:
# If this is a mark glyph, then add to mkmk lookup.
lookupname = f'mkmk_{name}'
# Add the glyph to respective lookup.
if lookupname not in lookups:
lookups[lookupname] = _attachment_lookup(lookupname)
lookups[lookupname].pos.coverage.add(glyph.name)
# Add the anchor.
pos = ast.Pos(None, x, y, {}, {}, {})
gid = glyphOrder.index(glyph.name)
anchors.append(
ast.AnchorDefinition(name, gid, glyph.name, comp,
False, pos))
# Save groups file.
with open(master.psn + '-anchors.vtg', 'w') as fp:
doc = ast.VoltFile()
for group in groups:
glyphs = tuple(ast.GlyphName(g) for g in sorted(groups[group]))
enum = ast.Enum(glyphs)
doc.statements.append(ast.GroupDefinition(group, enum))
fp.write(str(doc))
# Save lookups file.
with open(master.psn + '-anchors.vtl', 'w') as fp:
doc = ast.VoltFile()
for lookup in lookups.values():
# Sort coverage by glyph ID to be stable.
lookup.pos.coverage = sorted(
[ast.GlyphName(g) for g in lookup.pos.coverage],
key=lambda g: glyphOrder.index(g.glyph),
)
doc.statements.append(lookup)
doc.statements += anchors
fp.write(str(doc))
def exportVoltKerning(font):
# Save groups and lookups files for each master.
for master in font.masters:
classes = {k.name: k.names for k in master.kerning.classes}
pairs = master.kerning.pairs.copy()
format1 = _pair_lookup(r'kern\1_PPF1')
format2 = _pair_lookup(r'kern\2_PPF2')
nullpos = ast.Pos(None, None, None, {}, {}, {})
# Left exceptions
filtered = {}
for left in pairs:
if left.startswith('@'):
names = []
for name in classes[left[1:]]:
if name in pairs:
pairs[name] = {**pairs[left], **pairs[name]}
else:
names.append(name)
filtered[left[1:]] = names
# Right exceptions
rights = set()
for left in pairs:
rights.update(pairs[left])
for right in sorted(rights):
if right.startswith('@'):
names = []
for name in classes[right[1:]]:
if name in rights:
for left in pairs:
if right in pairs[left]:
pairs[left][name] = pairs[left][right]
else:
names.append(name)
filtered[right[1:]] = names
groups = set()
values = {}
for left in pairs:
for right, value in pairs[left].items():
lookup = format1
if left.startswith('@') and right.startswith('@'):
lookup = format2
groups.update([left[1:], right[1:]])
else:
if left.startswith('@') and not filtered[left[1:]]:
continue
if right.startswith('@') and not filtered[right[1:]]:
continue
if left not in lookup.pos.coverages_1:
lookup.pos.coverages_1.append(left)
id1 = lookup.pos.coverages_1.index(left) + 1
if right not in lookup.pos.coverages_2:
lookup.pos.coverages_2.append(right)
id2 = lookup.pos.coverages_2.index(right) + 1
pos = ast.Pos(otRound(float(value)), None, None, {}, {}, {})
lookup.pos.adjust_pair[(id1, id2)] = (pos, nullpos)
_warn_overlapping_classes(master, groups)
# Save groups file.
with open(master.psn + '-kerning.vtg', 'w') as fp:
doc = ast.VoltFile()
for name in sorted(groups):
glyphs = tuple(ast.GlyphName(g) for g in sorted(classes[name]))
enum = ast.Enum(glyphs)
doc.statements.append(ast.GroupDefinition(f'KERN{name}', enum))
fp.write(str(doc))
# Save lookups file.
with open(master.psn + '-kerning.vtl', 'w') as fp:
format1.pos.coverages_1 = _kern_coverage(format1.pos.coverages_1,
filtered)
format1.pos.coverages_2 = _kern_coverage(format1.pos.coverages_2,
filtered)
format2.pos.coverages_1 = _kern_coverage(format2.pos.coverages_1)
format2.pos.coverages_2 = _kern_coverage(format2.pos.coverages_2)
doc = ast.VoltFile()
doc.statements = [format1, format2]
fp.write(str(doc))
def enum(self, glyphs):
return ast.Enum([ast.GlyphName(g) for g in glyphs])