mirror of
https://github.com/weiweihuanghuang/Work-Sans.git
synced 2024-11-26 09:20:15 +03:00
332 lines
11 KiB
Python
Executable File
332 lines
11 KiB
Python
Executable File
"""
|
|
Fontmake can only generate a single variable font. It cannot generate a
|
|
family of variable fonts, that are related to one another.
|
|
|
|
This script will update the nametables and STAT tables so a family
|
|
which has more than one variable font will work correctly in desktop
|
|
applications.
|
|
|
|
It will also work on single font VF families by creating a better STAT
|
|
table.
|
|
|
|
TODO make script work on VFs which have multiple axises. We'll need to
|
|
change the axis array format to v4 (we're using v1),
|
|
https://docs.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-4
|
|
|
|
Atm, the script will work well for single axis fonts and families which
|
|
have a single vf for Roman and another for Italic/Condensed, both using the wght
|
|
axis (covers 95% of GF cases).
|
|
"""
|
|
from argparse import ArgumentParser
|
|
from fontTools.ttLib import TTFont, newTable
|
|
from fontTools.ttLib.tables import otTables
|
|
import os
|
|
|
|
|
|
OS_2_WEIGHT_CLASS = {
|
|
'Thin': 250,
|
|
'ExtraLight': 275,
|
|
'Light': 300,
|
|
'Regular': 400,
|
|
'': 400,
|
|
'Medium': 500,
|
|
'SemiBold': 600,
|
|
'Bold': 700,
|
|
'ExtraBold': 800,
|
|
'Black': 900,
|
|
}
|
|
|
|
|
|
def _parse_styles(stylename):
|
|
bold, italic = False, False
|
|
if 'Italic' in stylename:
|
|
italic = True
|
|
bold = False
|
|
if 'Bold' == stylename or 'Bold Italic' == stylename:
|
|
bold = True
|
|
return bold, italic
|
|
|
|
|
|
def set_fsselection(style, fsselection,):
|
|
bold, italic = _parse_styles(style)
|
|
|
|
mask = 0b1100001
|
|
fsselection = (fsselection | mask) ^ mask
|
|
|
|
if bold:
|
|
fsselection |= 0b100000
|
|
else:
|
|
fsselection |= 0b1000000
|
|
if italic:
|
|
# unset Reg bit
|
|
fsselection = (fsselection | 0b1000000) ^ 0b1000000
|
|
fsselection |= 0b1
|
|
return fsselection
|
|
|
|
|
|
def set_mac_style(stylename, macstyle):
|
|
bold, italic = _parse_styles(stylename)
|
|
|
|
mask = ~0b11
|
|
bold_bit = 0b1 if bold else 0b0
|
|
italic_bit = 0b10 if italic else 0b0
|
|
|
|
macstyle = (macstyle | mask) ^ mask
|
|
macstyle |= (bold_bit + italic_bit)
|
|
return macstyle
|
|
|
|
|
|
def set_weight_class(stylename):
|
|
weight = stylename.replace('Italic', '').replace(' ', '')
|
|
return OS_2_WEIGHT_CLASS[weight]
|
|
|
|
|
|
def fonts_are_same_family(ttfonts):
|
|
"""Check fonts have the same preferred family name or family name"""
|
|
family_names = []
|
|
for ttfont in ttfonts:
|
|
pref_family_name = ttfont['name'].getName(16, 3, 1, 1033)
|
|
family_name = ttfont['name'].getName(1, 3, 1, 1033)
|
|
name = pref_family_name if pref_family_name else family_name
|
|
family_names.append(name.toUnicode())
|
|
if len(set(family_names)) != 1:
|
|
return False
|
|
return True
|
|
|
|
|
|
def fix_nametable(ttfont):
|
|
"""Cleanup nametable issues caused by fontmake"""
|
|
table = ttfont['name']
|
|
family_name = table.getName(1, 3, 1, 1033).toUnicode()
|
|
|
|
# Remove style from family name. Often happens for Italic fonts
|
|
# Family Name Light --> Family Name
|
|
for style in (' Regular', ' Light', ' Bold'):
|
|
if style in family_name:
|
|
table.setName(family_name.replace(style, ''), 1, 3, 1, 1033)
|
|
# Remove preferred family name and prefered style
|
|
idx = 0
|
|
while idx < len(table.names) - 1:
|
|
if table.names[idx].nameID in [16, 17]:
|
|
table.names.pop(idx)
|
|
idx = 0
|
|
else:
|
|
idx += 1
|
|
|
|
# Update existing nameids based on the varfont's default style
|
|
default_style = _get_vf_default_style(ttfont)
|
|
family_name = table.getName(1, 3, 1, 1033).toUnicode()
|
|
table.setName(default_style, 2, 3, 1, 1033)
|
|
|
|
fullname = '{} {}'.format(family_name, default_style)
|
|
table.setName(unicode(fullname), 4, 3, 1, 1033)
|
|
|
|
psname = '{}-{}'.format(family_name.replace(' ', ''), default_style.replace(' ', ''))
|
|
table.setName(unicode(psname), 6, 3, 1, 1033)
|
|
|
|
# uniqueid basedon fontmake output version;vendorid;psname
|
|
font_version = format(ttfont['head'].fontRevision, '.3f')
|
|
vendor = ttfont['OS/2'].achVendID
|
|
uniqueid = '{};{};{}'.format(font_version, vendor, psname)
|
|
table.setName(unicode(uniqueid), 3, 3, 1, 1033)
|
|
|
|
|
|
def fix_bits(ttfont):
|
|
"""Set fsSelection, macStyle and usWeightClass to correct values.
|
|
|
|
The values must be derived from the default style. By default, the
|
|
Regular instance's values are used"""
|
|
dflt_style = _get_vf_default_style(ttfont)
|
|
ttfont['OS/2'].fsSelection = set_fsselection(
|
|
dflt_style, ttfont['OS/2'].fsSelection
|
|
)
|
|
ttfont['OS/2'].usWeightClass = set_weight_class(dflt_style)
|
|
ttfont['head'].macStyle = set_mac_style(
|
|
dflt_style, ttfont['head'].macStyle
|
|
)
|
|
|
|
|
|
def create_stat_table(ttfont):
|
|
"""Atm, Fontmake is only able to produce a basic stat table. Because of
|
|
this, we'll create a STAT using the font's fvar table."""
|
|
stat = newTable('STAT')
|
|
stat.table = otTables.STAT()
|
|
stat.table.Version = 0x00010001
|
|
|
|
# # Build DesignAxisRecords from fvar
|
|
stat.table.DesignAxisRecord = otTables.AxisRecordArray()
|
|
stat.table.DesignAxisRecord.Axis = []
|
|
|
|
stat_axises = stat.table.DesignAxisRecord.Axis
|
|
|
|
# TODO (M Foley) add support for fonts which have multiple
|
|
# axises e.g Barlow
|
|
if len(ttfont['fvar'].axes) > 1:
|
|
raise Exception('VFs with more than one axis are currently '
|
|
'not supported.')
|
|
|
|
for idx, axis in enumerate(ttfont['fvar'].axes):
|
|
append_stat_axis(stat, axis.axisTag, axis.axisNameID)
|
|
|
|
# Build AxisValueArrays for each namedInstance from fvar namedInstances
|
|
stat.table.AxisValueArray = otTables.AxisValueArray()
|
|
stat.table.AxisValueArray.AxisValue = []
|
|
|
|
for idx, instance in enumerate(ttfont['fvar'].instances):
|
|
append_stat_record(stat, 0, instance.coordinates.values()[0], instance.subfamilyNameID)
|
|
|
|
# Set ElidedFallbackNameID
|
|
stat.table.ElidedFallbackNameID = 2
|
|
ttfont['STAT'] = stat
|
|
|
|
|
|
def _get_vf_types(ttfonts):
|
|
styles = []
|
|
for ttfont in ttfonts:
|
|
styles.append(_get_vf_type(ttfont))
|
|
return styles
|
|
|
|
|
|
def _get_vf_type(ttfont):
|
|
style = ttfont['name'].getName(2, 3, 1, 1033).toUnicode()
|
|
return 'Italic' if 'Italic' in style else 'Roman'
|
|
|
|
|
|
def _get_vf_default_style(ttfont):
|
|
"""Return the name record string of the default style"""
|
|
default_fvar_val = ttfont['fvar'].axes[0].defaultValue
|
|
|
|
name_id = None
|
|
for inst in ttfont['fvar'].instances:
|
|
if inst.coordinates['wght'] == default_fvar_val:
|
|
name_id = inst.subfamilyNameID
|
|
return ttfont['name'].getName(name_id, 1, 0, 0).toUnicode()
|
|
|
|
|
|
def add_other_vf_styles_to_nametable(ttfont, text_records):
|
|
"""Each nametable in a font must reference every font in the family.
|
|
Since fontmake doesn't append the other families to the nametable,
|
|
we'll do this ourselves. Skip this step if these records already
|
|
exist."""
|
|
found = set()
|
|
for name in ttfont['name'].names[:-len(text_records)-1:-1]:
|
|
found.add(name.toUnicode())
|
|
leftover = set(text_records) - found
|
|
|
|
if leftover:
|
|
nameid = ttfont['name'].names[-1].nameID + 1
|
|
for record in leftover:
|
|
ttfont['name'].setName(unicode(record), nameid, 3, 1, 1033)
|
|
nameid += 1
|
|
|
|
|
|
def get_custom_name_record(ttfont, text):
|
|
"""Return a name record by text. Record ID must be greater than 255"""
|
|
for record in ttfont['name'].names[::-1]:
|
|
if record.nameID > 255:
|
|
rec_text = record.toUnicode()
|
|
if rec_text == text:
|
|
return record
|
|
return None
|
|
|
|
|
|
def append_stat_axis(stat, tag, namerecord_id):
|
|
"""Add a STAT axis if the tag does not exist already."""
|
|
has_tags = []
|
|
axises = stat.table.DesignAxisRecord.Axis
|
|
for axis in axises:
|
|
has_tags.append(axis.AxisTag)
|
|
|
|
if tag in has_tags:
|
|
raise Exception('{} has already been declared in the STAT table')
|
|
|
|
axis_record = otTables.AxisRecord()
|
|
axis_record.AxisTag = tag
|
|
axis_record.AxisNameID = namerecord_id
|
|
axis_record.AxisOrdering = len(axises)
|
|
axises.append(axis_record)
|
|
|
|
|
|
def append_stat_record(stat, axis_index, value, namerecord_id, linked_value=None):
|
|
records = stat.table.AxisValueArray.AxisValue
|
|
axis_record = otTables.AxisValue()
|
|
axis_record.Format = 1
|
|
axis_record.ValueNameID = namerecord_id
|
|
axis_record.Value = value
|
|
axis_record.AxisIndex = axis_index
|
|
|
|
axis_record.Flags = 0
|
|
if linked_value:
|
|
axis_record.Format = 3
|
|
axis_record.LinkedValue = linked_value
|
|
records.append(axis_record)
|
|
|
|
|
|
def get_stat_axis_index(ttfont, axis_name):
|
|
axises = ttfont['STAT'].table.DesignAxisRecord.Axis
|
|
available_axises = [a.AxisTag for a in axises]
|
|
for idx, axis in enumerate(axises):
|
|
if axis.AxisTag == axis_name:
|
|
return idx
|
|
raise Exception('{} is not a valid axis. Font has [{}] axises'.format(
|
|
axis_name, available_axises)
|
|
)
|
|
|
|
|
|
def set_stat_for_font_in_family(ttfont, family_styles):
|
|
"""Based on examples from:
|
|
https://docs.microsoft.com/en-us/typography/opentype/spec/stat"""
|
|
font_type = _get_vf_type(ttfont)
|
|
# See example 5
|
|
if font_type == 'Roman' and 'Italic' in family_styles:
|
|
name_record = get_custom_name_record(ttfont, 'Italic')
|
|
append_stat_axis(ttfont['STAT'], 'ital', name_record.nameID)
|
|
|
|
name_record = get_custom_name_record(ttfont, 'Roman')
|
|
axis_idx = get_stat_axis_index(ttfont, 'ital')
|
|
append_stat_record(ttfont['STAT'], axis_idx, 0, name_record.nameID, linked_value=1.0)
|
|
|
|
elif font_type == 'Italic' and 'Roman' in family_styles:
|
|
name_record = get_custom_name_record(ttfont, 'Italic')
|
|
append_stat_axis(ttfont['STAT'], 'ital', name_record.nameID)
|
|
|
|
name_record = get_custom_name_record(ttfont, 'Italic')
|
|
axis_idx = get_stat_axis_index(ttfont, 'ital')
|
|
append_stat_record(ttfont['STAT'], axis_idx, 1.0, name_record.nameID)
|
|
|
|
|
|
def harmonize_vf_families(ttfonts):
|
|
"""Make sure the fonts which are part of a vf family reference each other
|
|
in both the nametable and STAT table. For examples see:
|
|
https://docs.microsoft.com/en-us/typography/opentype/spec/stat
|
|
|
|
"""
|
|
family_styles = _get_vf_types(ttfonts)
|
|
for ttfont in ttfonts:
|
|
add_other_vf_styles_to_nametable(ttfont, family_styles)
|
|
set_stat_for_font_in_family(ttfont, family_styles)
|
|
|
|
|
|
def main():
|
|
parser = ArgumentParser()
|
|
parser.add_argument('fonts', nargs='+',
|
|
help='All fonts within a font family must be included')
|
|
args = parser.parse_args()
|
|
font_paths = args.fonts
|
|
ttfonts = [TTFont(p) for p in font_paths]
|
|
if not fonts_are_same_family(ttfonts):
|
|
raise Exception('Fonts have different family_names: [{}]'.format(
|
|
', '.join(map(os.path.basename, ttfonts))
|
|
))
|
|
|
|
map(fix_nametable, ttfonts)
|
|
map(fix_bits, ttfonts)
|
|
map(create_stat_table, ttfonts)
|
|
harmonize_vf_families(ttfonts)
|
|
|
|
for path, ttfont in zip(font_paths, ttfonts):
|
|
ttfont.save(path + '.fix')
|
|
|
|
if __name__ == '__main__':
|
|
main()
|