def install_cvt(fo, cvs, base): """If base is greater than zero, we append CVs to an existing CVT table. If not, we generate a new table.""" if base > 0: assert base == len(fo['cvt '].values) for c in cvs: fo['cvt '].values.append(c) else: fo['cvt '] = ttFont.newTable('cvt ') setattr(fo['cvt '], 'values', array.array('h', cvs))
def install_functions(fo, fns, base): """If base greater than zero, we append our own functions to those already in the font. If not, generate a new fpgm table.""" if base > 0: oldfpgm = "\n".join(fo['fpgm'].program.getAssembly()) newfpgm = oldfpgm + "\n" + str(fns) fo['fpgm'].program.fromAssembly(newfpgm) fo['fpgm'].program.getBytecode() else: fo['fpgm'] = ttFont.newTable('fpgm') fo['fpgm'].program = tables.ttProgram.Program() fo['fpgm'].program.fromAssembly(str(fns))
def install_prep(fo, pr, keepold, replace): """If keepold is True, we append our own prep table to the existing one. It is up to the Xgridfit programmer to make sure that no conflicts arise (though if there's a duplication--for example, instructions being disabled at a different ppem in the new code than in the old, the new code will take precedence.)""" if keepold and not replace: oldprep = "\n".join(fo['prep'].program.getAssembly()) newprep = oldprep + "\n" + str(pr) fo['prep'].program.fromAssembly(newprep) else: fo['prep'] = ttFont.newTable('prep') fo['prep'].program = tables.ttProgram.Program() fo['prep'].program.fromAssembly(str(pr))
def add_avar_table(ttFont): avar = newTable("avar") avar.segments = { "wght": { -1.0: -1.0, 0: 0, 1.0: 1.0 }, "ital": { -1.0: -1.0, 0: 0, 1.0: 1.0 } } ttFont['avar'] = avar
from fontTools.ttLib.ttFont import newTable from fontmake import __main__ from fontTools.ttLib import TTFont, newTable import shutil, subprocess, glob from pathlib import Path print ("[Train One] Generating TTFs") __main__.main(("-g","sources/TrainOne.glyphs", "-o","ttf",)) for font in Path("master_ttf").glob("*.ttf"): modifiedFont = TTFont(font) print ("["+str(font).split("/")[1][:-4]+"] Adding stub DSIG") modifiedFont["DSIG"] = newTable("DSIG") #need that stub dsig modifiedFont["DSIG"].ulVersion = 1 modifiedFont["DSIG"].usFlag = 0 modifiedFont["DSIG"].usNumSigs = 0 modifiedFont["DSIG"].signatureRecords = [] print ("["+str(font).split("/")[1][:-4]+"] Making other changes") modifiedFont["name"].addMultilingualName({'ja':'トレイン One'}, modifiedFont, nameID = 1, windows=True, mac=False) modifiedFont["name"].addMultilingualName({'ja':'Regular'}, modifiedFont, nameID = 2, windows=True, mac=False) modifiedFont["head"].flags |= 1 << 3 #sets flag to always round PPEM to integer modifiedFont.save("fonts/ttf/"+str(font).split("/")[1]) shutil.rmtree("instance_ufo") shutil.rmtree("master_ufo") shutil.rmtree("master_ttf") for font in Path("fonts/ttf/").glob("*.ttf"): print ("["+str(font).split("/")[2][:-4]+"] Autohinting")
def GASP_set(font:TTFont): if "gasp" not in font: font["gasp"] = newTable("gasp") font["gasp"].gaspRange = {} if font["gasp"].gaspRange != {65535: 0x000A}: font["gasp"].gaspRange = {65535: 0x000A}
def install_cvar(fo, cvarstore, keepold, cvtbase): """If keepold is True, we append our own cvar data to the existing TupleVariation objects. If False, generate our own cvar table. Since The old cvar may not exactly match the new one, there are contingencies: If a tuple is missing in the old or the new cvar, pad the new one and issue a warning. If there is no cvar at all in the existing font (this can easily happen with VTT or the non-VF version of ttfautohint), pad all our tuples and issue a warning. In such cases it may be a good idea to manually edit the cvar table.""" cvtlen = len(fo['cvt '].values) if keepold: complications = False needoldfontpadding = False try: oldcvarstore = fo['cvar'].variations except: if quietcount < 2: print( "Warning: No cvar table in existing font. Making a dummy table." ) # Create a dummy cvar table to merge the new one into. complications = True cvardummy = [] for cvst in cvarstore: cvardummy.append(TupleVariation(cvst[0], [None] * cvtlen)) fo['cvar'] = ttFont.newTable('cvar') fo['cvar'].variations = cvardummy oldcvarstore = fo['cvar'].variations try: # When you fiddle the size of the cvt, fonttools helpfully # extends the cvar coordinate lists to match. But test to make # sure it has been done (as it doesn't seem to be documented). assert cvtlen == len(oldcvarstore[0].coordinates) except: print("Size of cvt does not match size of cvar.") print("Size of cvt: " + str(cvtlen)) print("Size of cvar: " + str(len(oldcvarstore[0].coordinates))) sys.exit(1) oldcoordlen = len(oldcvarstore[0].coordinates) newcoordlen = len(cvarstore[0][1]) new_tuple_found = [0] * len(cvarstore) for oldc in oldcvarstore: try: newc = None new_tuple_counter = 0 for tc in cvarstore: # if oldc.axes == tc[0]: if _axes_match(oldc.axes, tc[0]): newc = tc break new_tuple_counter += 1 if newc: new_tuple_found[new_tuple_counter] = 1 newcoordinates = newc[1] i = 0 for val in newcoordinates: if val != None and val != 0: oldc.coordinates[i + cvtbase] = val i += 1 else: # we've failed to find a match for one of the TupleVariations # in the existing font. We don't need to do anything (the # table is okay), but we'll warn. complications = True except Exception as err: print(err) print("Here are the regions in the existing font:") for tup in oldcvarstore: print(str(tup.axes)) sys.exit(1) # If there are new TupleVariations unaccounted for: tt_index = 0 for tt in new_tuple_found: if tt == 0: # In the absence of an old coordinate list, we'll pad # the beginning of the new list. newcoordlist = [None] * cvtbase newcoordlist.extend(cvarstore[tt_index][1]) thistuple = TupleVariation(cvarstore[tt_index][0], newcoordlist) oldcvarstore.append(thistuple) # fo['cvar'].variations.append(thistuple) tt_index += 1 complications = True if complications and quietcount < 2: print("Warning: The cvar table in the existing font and the one") print("in the Xgridfit program were not a perfect match. I have") print("done my best to combine them, but you should check over it") print("and make changes if necessary. Here is the new cvar table:") print(fo['cvar'].variations) else: ts = [] for s in cvarstore: ts.append(TupleVariation(s[0], s[1])) fo['cvar'] = ttFont.newTable('cvar') fo['cvar'].variations = ts
def _write_math_table(self, style: str, input_path: str, output_path: str): with TTFont(input_path) as tt_font: tt_font['MATH'] = newTable('MATH') tt_font['MATH'].table = self.math_tables[style].encode() tt_font.save(output_path)