def extractFontFromVFB(pathOrFile, destination, doGlyphs=True, doInfo=True, doKerning=True, doGroups=True, doFeatures=True, doLib=True, customFunctions=[]):
ufoPath = tempfile.mkdtemp(suffix=".ufo")
cmds = [_ufo2vfbLocation, "-64", pathOrFile, ufoPath]
cmds = subprocess.list2cmdline(cmds)
popen = subprocess.Popen(cmds, shell=True)
popen.wait()
try:
# vfb2ufo writes ufo2, and has no update since 2015...so dont get to crazy here...
source = UFOReader(ufoPath)
if doInfo:
source.readInfo(destination.info)
if doKerning:
kerning = source.readKerning()
destination.kerning.update(kerning)
if doGroups:
groups = source.readGroups()
destination.groups.update(groups)
if doFeatures:
features = source.readFeatures()
destination.features.text = features
if doLib:
lib = source.readLib()
destination.lib.update(lib)
if doGlyphs:
glyphSet = source.getGlyphSet()
for glyphName in glyphSet.keys():
destination.newGlyph(glyphName)
glyph = destination[glyphName]
pointPen = glyph.getPointPen()
glyphSet.readGlyph(glyphName=glyphName, glyphObject=glyph, pointPen=pointPen)
for function in customFunctions:
function(source, destination)
finally:
shutil.rmtree(ufoPath)
def testUFO2(self): self.makeUFO(formatVersion=2) reader = UFOReader(self.ufoPath) kerning = reader.readKerning() self.assertEqual(self.expectedKerning, kerning) groups = reader.readGroups() self.assertEqual(self.expectedGroups, groups) info = TestInfoObject() reader.readInfo(info)
def testUFO2(self):
self.makeUFO(formatVersion=2)
reader = UFOReader(self.ufoPath, validate=True)
kerning = reader.readKerning()
self.assertEqual(self.expectedKerning, kerning)
groups = reader.readGroups()
self.assertEqual(self.expectedGroups, groups)
info = TestInfoObject()
reader.readInfo(info)
def testRead(self): originalData = dict(fontInfoVersion1) self._writeInfoToPlist(originalData) infoObject = TestInfoObject() reader = UFOReader(self.dstDir) reader.readInfo(infoObject) for attr in dir(infoObject): if attr not in fontInfoVersion2: continue originalValue = fontInfoVersion2[attr] readValue = getattr(infoObject, attr) self.assertEqual(originalValue, readValue)
def testRead(self):
originalData = dict(fontInfoVersion1)
self._writeInfoToPlist(originalData)
infoObject = TestInfoObject()
reader = UFOReader(self.dstDir)
reader.readInfo(infoObject)
for attr in dir(infoObject):
if attr not in fontInfoVersion2:
continue
originalValue = fontInfoVersion2[attr]
readValue = getattr(infoObject, attr)
self.assertEqual(originalValue, readValue)
def testFontStyleConversion(self):
fontStyle1To2 = {
64 : "regular",
1 : "italic",
32 : "bold",
33 : "bold italic"
}
for old, new in list(fontStyle1To2.items()):
info = dict(fontInfoVersion1)
info["fontStyle"] = old
self._writeInfoToPlist(info)
reader = UFOReader(self.dstDir)
infoObject = TestInfoObject()
reader.readInfo(infoObject)
self.assertEqual(new, infoObject.styleMapStyleName)
def testFontStyleConversion(self):
fontStyle1To2 = {
64: "regular",
1: "italic",
32: "bold",
33: "bold italic"
}
for old, new in list(fontStyle1To2.items()):
info = dict(fontInfoVersion1)
info["fontStyle"] = old
self._writeInfoToPlist(info)
reader = UFOReader(self.dstDir)
infoObject = TestInfoObject()
reader.readInfo(infoObject)
self.assertEqual(new, infoObject.styleMapStyleName)
def _loadData(self, path):
from ufoLib import UFOReader
reader = UFOReader(path)
fontLib = reader.readLib()
# info
reader.readInfo(self.info)
# kerning
self.kerning.update(reader.readKerning())
self.kerning.setChanged(False)
# groups
self.groups.update(reader.readGroups())
# features
if reader.formatVersion == 1:
# migrate features from the lib
features = []
classes = fontLib.get("org.robofab.opentype.classes")
if classes is not None:
del fontLib["org.robofab.opentype.classes"]
features.append(classes)
splitFeatures = fontLib.get("org.robofab.opentype.features")
if splitFeatures is not None:
order = fontLib.get("org.robofab.opentype.featureorder")
if order is None:
order = splitFeatures.keys()
order.sort()
else:
del fontLib["org.robofab.opentype.featureorder"]
del fontLib["org.robofab.opentype.features"]
for tag in order:
oneFeature = splitFeatures.get(tag)
if oneFeature is not None:
features.append(oneFeature)
features = "\n".join(features)
else:
features = reader.readFeatures()
self.features.text = features
# hint data
self.psHints = PostScriptFontHintValues(self)
if postScriptHintDataLibKey in fontLib:
del fontLib[postScriptHintDataLibKey]
# lib
self.lib.update(fontLib)
# glyphs
self._glyphSet = reader.getGlyphSet()
self._hasNotChanged(doGlyphs=False)
def _loadData(self, path):
from ufoLib import UFOReader
reader = UFOReader(path)
fontLib = reader.readLib()
# info
reader.readInfo(self.info)
# kerning
self.kerning.update(reader.readKerning())
self.kerning.setChanged(False)
# groups
self.groups.update(reader.readGroups())
# features
if reader.formatVersion == 1:
# migrate features from the lib
features = []
classes = fontLib.get("org.robofab.opentype.classes")
if classes is not None:
del fontLib["org.robofab.opentype.classes"]
features.append(classes)
splitFeatures = fontLib.get("org.robofab.opentype.features")
if splitFeatures is not None:
order = fontLib.get("org.robofab.opentype.featureorder")
if order is None:
order = splitFeatures.keys()
order.sort()
else:
del fontLib["org.robofab.opentype.featureorder"]
del fontLib["org.robofab.opentype.features"]
for tag in order:
oneFeature = splitFeatures.get(tag)
if oneFeature is not None:
features.append(oneFeature)
features = "\n".join(features)
else:
features = reader.readFeatures()
self.features.text = features
# hint data
self.psHints = PostScriptFontHintValues(self)
if postScriptHintDataLibKey in fontLib:
del fontLib[postScriptHintDataLibKey]
# lib
self.lib.update(fontLib)
# glyphs
self._glyphSet = reader.getGlyphSet()
self._hasNotChanged(doGlyphs=False)
def extractFontFromVFB(pathOrFile,
destination,
doGlyphs=True,
doInfo=True,
doKerning=True,
doGroups=True,
doFeatures=True,
doLib=True,
customFunctions=[]):
ufoPath = tempfile.mkdtemp(suffix=".ufo")
cmds = [_ufo2vfbLocation, "-64", pathOrFile, ufoPath]
cmds = subprocess.list2cmdline(cmds)
popen = subprocess.Popen(cmds, shell=True)
popen.wait()
try:
# vfb2ufo writes ufo2, and has no update since 2015...so dont get to crazy here...
source = UFOReader(ufoPath)
if doInfo:
source.readInfo(destination.info)
if doKerning:
kerning = source.readKerning()
destination.kerning.update(kerning)
if doGroups:
groups = source.readGroups()
destination.groups.update(groups)
if doFeatures:
features = source.readFeatures()
destination.features.text = features
if doLib:
lib = source.readLib()
destination.lib.update(lib)
if doGlyphs:
glyphSet = source.getGlyphSet()
for glyphName in glyphSet.keys():
destination.newGlyph(glyphName)
glyph = destination[glyphName]
pointPen = glyph.getPointPen()
glyphSet.readGlyph(glyphName=glyphName,
glyphObject=glyph,
pointPen=pointPen)
for function in customFunctions:
function(source, destination)
finally:
shutil.rmtree(ufoPath)
def testWidthNameConversion(self):
widthName1To2 = {
"Ultra-condensed" : 1,
"Extra-condensed" : 2,
"Condensed" : 3,
"Semi-condensed" : 4,
"Medium (normal)" : 5,
"Semi-expanded" : 6,
"Expanded" : 7,
"Extra-expanded" : 8,
"Ultra-expanded" : 9
}
for old, new in list(widthName1To2.items()):
info = dict(fontInfoVersion1)
info["widthName"] = old
self._writeInfoToPlist(info)
reader = UFOReader(self.dstDir)
infoObject = TestInfoObject()
reader.readInfo(infoObject)
self.assertEqual(new, infoObject.openTypeOS2WidthClass)
def testWidthNameConversion(self):
widthName1To2 = {
"Ultra-condensed": 1,
"Extra-condensed": 2,
"Condensed": 3,
"Semi-condensed": 4,
"Medium (normal)": 5,
"Semi-expanded": 6,
"Expanded": 7,
"Extra-expanded": 8,
"Ultra-expanded": 9
}
for old, new in list(widthName1To2.items()):
info = dict(fontInfoVersion1)
info["widthName"] = old
self._writeInfoToPlist(info)
reader = UFOReader(self.dstDir)
infoObject = TestInfoObject()
reader.readInfo(infoObject)
self.assertEqual(new, infoObject.openTypeOS2WidthClass)
def run_ufolib_import_validation(self):
"""
ufoLib UFOReader.readInfo method validates value types in the fontinfo.plist file
:return: (list) list of test failure Result objects
"""
res = Result(self.testpath)
ss = StdStreamer(self.ufopath)
if file_exists(self.testpath) is False:
res.test_failed = False # not a mandatory file in UFO spec, test passes if missing
ss.stream_result(res)
return self.test_fail_list
try:
# read fontinfo.plist with ufoLib - the ufoLib library performs type validations on values on read
ufolib_reader = UFOReader(self.ufopath, validate=True)
ufolib_reader.readInfo(self.fontinfo_obj)
res.test_failed = False
ss.stream_result(res)
except Exception as e:
res.test_failed = True
res.test_long_stdstream_string = self.testpath + " failed ufoLib import test with error: " + str(
e)
ss.stream_result(res)
self.test_fail_list.append(res)
return self.test_fail_list
class UFOFontData:
def __init__(self, path, log_only, allow_decimal_coords,
write_to_default_layer):
self._reader = UFOReader(path, validate=False)
self.path = path
self.glyphMap = {}
self.processedLayerGlyphMap = {}
self.newGlyphMap = {}
self.glyphList = []
self._fontInfo = None
self._glyphsets = {}
# If True, we are running in report mode and not doing any changes, so
# we skip the hash map and process all glyphs.
self.log_only = log_only
# Used to store the hash of glyph data of already processed glyphs. If
# the stored hash matches the calculated one, we skip the glyph.
self._hashmap = None
self.fontDict = None
self.hashMapChanged = False
# If True, then write data to the default layer
self.writeToDefaultLayer = write_to_default_layer
# if True, do NOT round x,y values when processing.
self.allowDecimalCoords = allow_decimal_coords
self._load_glyphmap()
def getUnitsPerEm(self):
return self.fontInfo.get("unitsPerEm", 1000)
def getPSName(self):
return self.fontInfo.get("postscriptFontName", "PSName-Undefined")
@staticmethod
def isCID():
return False
def convertToBez(self, glyphName, read_hints, doAll=False):
# We do not yet support reading hints, so read_hints is ignored.
width, bez, skip = self._get_or_skip_glyph(glyphName, doAll)
if skip:
return None, width
bezString = "\n".join(bez)
bezString = "\n".join(["% " + glyphName, "sc", bezString, "ed", ""])
return bezString, width
def updateFromBez(self, bezData, name, width):
# For UFO font, we don't use the width parameter:
# it is carried over from the input glif file.
layer = None
if name in self.processedLayerGlyphMap:
layer = PROCESSED_LAYER_NAME
glyphset = self._get_glyphset(layer)
glyph = BezGlyph(bezData)
glyphset.readGlyph(name, glyph)
self.newGlyphMap[name] = glyph
# updateFromBez is called only if the glyph has been autohinted which
# might also change its outline data. We need to update the edit status
# in the hash map entry. I assume that convertToBez has been run
# before, which will add an entry for this glyph.
self.updateHashEntry(name)
def save(self, path):
if path is None:
path = self.path
if os.path.abspath(self.path) != os.path.abspath(path):
# If user has specified a path other than the source font path,
# then copy the entire UFO font, and operate on the copy.
log.info("Copying from source UFO font to output UFO font before "
"processing...")
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree(self.path, path)
writer = UFOWriter(path, self._reader.formatVersion, validate=False)
if self.hashMapChanged:
self.writeHashMap(writer)
self.hashMapChanged = False
layer = PROCESSED_LAYER_NAME
if self.writeToDefaultLayer:
layer = None
# Write glyphs.
glyphset = writer.getGlyphSet(layer, defaultLayer=layer is None)
for name, glyph in self.newGlyphMap.items():
filename = self.glyphMap[name]
if not self.writeToDefaultLayer and \
name in self.processedLayerGlyphMap:
filename = self.processedLayerGlyphMap[name]
glyphset.contents[name] = filename
glyphset.writeGlyph(name, glyph, glyph.drawPoints)
glyphset.writeContents()
# Write layer contents.
layers = {DEFAULT_LAYER_NAME: DEFAULT_GLYPHS_DIRNAME}
if self.processedLayerGlyphMap:
layers[PROCESSED_LAYER_NAME] = PROCESSED_GLYPHS_DIRNAME
writer.layerContents.update(layers)
writer.writeLayerContents([DEFAULT_LAYER_NAME, PROCESSED_LAYER_NAME])
@property
def hashMap(self):
if self._hashmap is None:
data = self._reader.readBytesFromPath(
os.path.join(DATA_DIRNAME, HASHMAP_NAME))
if data:
hashmap = ast.literal_eval(data.decode("utf-8"))
else:
hashmap = {HASHMAP_VERSION_NAME: HASHMAP_VERSION}
version = (0, 0)
if HASHMAP_VERSION_NAME in hashmap:
version = hashmap[HASHMAP_VERSION_NAME]
if version[0] > HASHMAP_VERSION[0]:
raise FontParseError("Hash map version is newer than "
"psautohint. Please update.")
elif version[0] < HASHMAP_VERSION[0]:
log.info("Updating hash map: was older version")
hashmap = {HASHMAP_VERSION_NAME: HASHMAP_VERSION}
self._hashmap = hashmap
return self._hashmap
def writeHashMap(self, writer):
hashMap = self.hashMap
if not hashMap:
return # no glyphs were processed.
hasMapKeys = hashMap.keys()
hasMapKeys = sorted(hasMapKeys)
data = ["{"]
for gName in hasMapKeys:
data.append("'%s': %s," % (gName, hashMap[gName]))
data.append("}")
data.append("")
data = "\n".join(data)
writer.writeBytesToPath(os.path.join(DATA_DIRNAME, HASHMAP_NAME),
data.encode("utf-8"))
def updateHashEntry(self, glyphName):
# srcHash has already been set: we are fixing the history list.
# Get hash entry for glyph
srcHash, historyList = self.hashMap[glyphName]
self.hashMapChanged = True
# If the program is not in the history list, add it.
if AUTOHINT_NAME not in historyList:
historyList.append(AUTOHINT_NAME)
def checkSkipGlyph(self, glyphName, newSrcHash, doAll):
skip = False
if self.log_only:
return skip
srcHash = None
historyList = []
# Get hash entry for glyph
if glyphName in self.hashMap:
srcHash, historyList = self.hashMap[glyphName]
if srcHash == newSrcHash:
if AUTOHINT_NAME in historyList:
# The glyph has already been autohinted, and there have been no
# changes since.
skip = not doAll
if not skip and AUTOHINT_NAME not in historyList:
historyList.append(AUTOHINT_NAME)
else:
if CHECKOUTLINE_NAME in historyList:
log.error("Glyph '%s' has been edited. You must first "
"run '%s' before running '%s'. Skipping.",
glyphName, CHECKOUTLINE_NAME, AUTOHINT_NAME)
skip = True
# If the source hash has changed, we need to delete the processed
# layer glyph.
self.hashMapChanged = True
self.hashMap[glyphName] = [newSrcHash, [AUTOHINT_NAME]]
if glyphName in self.processedLayerGlyphMap:
del self.processedLayerGlyphMap[glyphName]
return skip
def _get_glyphset(self, layer_name=None):
if layer_name not in self._glyphsets:
glyphset = None
if layer_name is None or layer_name in \
self._reader.getLayerNames():
glyphset = self._reader.getGlyphSet(layer_name)
self._glyphsets[layer_name] = glyphset
return self._glyphsets[layer_name]
def get_glyph_bez(self, glyph):
pen = BezPen(glyph.glyphSet, self)
glyph.draw(pen)
if not hasattr(glyph, "width"):
glyph.width = 1000
return pen.bez
def _get_or_skip_glyph(self, name, doAll):
# Get default glyph layer data, so we can check if the glyph
# has been edited since this program was last run.
# If the program name is in the history list, and the srcHash
# matches the default glyph layer data, we can skip.
glyphset = self._get_glyphset()
glyph = glyphset[name]
bez = self.get_glyph_bez(glyph)
# Hash is always from the default glyph layer.
hash_pen = HashPointPen(glyph)
glyph.drawPoints(hash_pen)
skip = self.checkSkipGlyph(name, hash_pen.getHash(), doAll)
# If there is a glyph in the processed layer, get the outline from it.
if name in self.processedLayerGlyphMap:
glyphset = self._get_glyphset(PROCESSED_LAYER_NAME)
glyph = glyphset[name]
bez = self.get_glyph_bez(glyph)
return glyph.width, bez, skip
def getGlyphList(self):
return self.glyphList
def _load_glyphmap(self):
# Need to both get the list of glyphs in the font, and also the glyph
# order. The latter is taken from the public.glyphOrder key in the lib,
# if it exists, else it is taken from the contents. Any existing
# glyphs which are not named in the public.glyphOrder are sorted after
# all glyphs which are named in the public.glyphOrder, in the order
# that they occurred in contents.plist.
glyphset = self._get_glyphset()
self.glyphMap = glyphset.contents
self.glyphList = glyphset.keys()
self.orderMap = {}
fontlib = self._reader.readLib()
glyphOrder = fontlib.get(PUBLIC_GLYPH_ORDER, self.glyphList)
for i, name in enumerate(glyphOrder):
self.orderMap[name] = i
# If there are glyphs in the font which are not named in the
# public.glyphOrder entry, add them in the order of the
# contents.plist file.
for name in self.glyphList:
if name not in self.orderMap:
self.orderMap[name] = len(self.orderMap)
self.glyphList = sorted(list(self.orderMap.keys()))
# I also need to get the glyph map for the processed layer,
# and use this when the glyph is read from the processed layer.
# glyph file names that differ from what is in the default glyph layer.
# Because checkOutliensUFO used the defcon library, it can write
glyphset = self._get_glyphset(PROCESSED_LAYER_NAME)
if glyphset is not None:
self.processedLayerGlyphMap = glyphset.contents
@property
def fontInfo(self):
if self._fontInfo is None:
info = SimpleNamespace()
self._reader.readInfo(info)
self._fontInfo = vars(info)
return self._fontInfo
def getFontInfo(self, allow_no_blues, noFlex,
vCounterGlyphs, hCounterGlyphs, fdIndex=0):
if self.fontDict is not None:
return self.fontDict
fdDict = fdTools.FDDict()
# should be 1 if the glyphs are ideographic, else 0.
fdDict.LanguageGroup = self.fontInfo.get("languagegroup", "0")
fdDict.OrigEmSqUnits = self.getUnitsPerEm()
fdDict.FontName = self.getPSName()
upm = self.getUnitsPerEm()
low = min(-upm * 0.25,
self.fontInfo.get("openTypeOS2WinDescent", 0) - 200)
high = max(upm * 1.25,
self.fontInfo.get("openTypeOS2WinAscent", 0) + 200)
# Make a set of inactive alignment zones: zones outside of the font
# bbox so as not to affect hinting. Used when src font has no
# BlueValues or has invalid BlueValues. Some fonts have bad BBox
# values, so I don't let this be smaller than -upm*0.25, upm*1.25.
inactiveAlignmentValues = [low, low, high, high]
blueValues = self.fontInfo.get("postscriptBlueValues", [])
numBlueValues = len(blueValues)
if numBlueValues < 4:
if allow_no_blues:
blueValues = inactiveAlignmentValues
numBlueValues = len(blueValues)
else:
raise FontParseError(
"Font must have at least four values in its "
"BlueValues array for PSAutoHint to work!")
blueValues.sort()
# The first pair only is a bottom zone, where the first value is the
# overshoot position; the rest are top zones, and second value of the
# pair is the overshoot position.
blueValues[0] = blueValues[0] - blueValues[1]
for i in range(3, numBlueValues, 2):
blueValues[i] = blueValues[i] - blueValues[i - 1]
blueValues = [str(v) for v in blueValues]
numBlueValues = min(numBlueValues, len(fdTools.kBlueValueKeys))
for i in range(numBlueValues):
key = fdTools.kBlueValueKeys[i]
value = blueValues[i]
setattr(fdDict, key, value)
otherBlues = self.fontInfo.get("postscriptOtherBlues", [])
numBlueValues = len(otherBlues)
if len(otherBlues) > 0:
i = 0
numBlueValues = len(otherBlues)
otherBlues.sort()
for i in range(0, numBlueValues, 2):
otherBlues[i] = otherBlues[i] - otherBlues[i + 1]
otherBlues = [str(v) for v in otherBlues]
numBlueValues = min(numBlueValues,
len(fdTools.kOtherBlueValueKeys))
for i in range(numBlueValues):
key = fdTools.kOtherBlueValueKeys[i]
value = otherBlues[i]
setattr(fdDict, key, value)
vstems = self.fontInfo.get("postscriptStemSnapV", [])
if not vstems:
if allow_no_blues:
# dummy value. Needs to be larger than any hint will likely be,
# as the autohint program strips out any hint wider than twice
# the largest global stem width.
vstems = [fdDict.OrigEmSqUnits]
else:
raise FontParseError("Font does not have postscriptStemSnapV!")
vstems.sort()
if not vstems or (len(vstems) == 1 and vstems[0] < 1):
# dummy value that will allow PyAC to run
vstems = [fdDict.OrigEmSqUnits]
log.warning("There is no value or 0 value for DominantV.")
fdDict.DominantV = "[" + " ".join([str(v) for v in vstems]) + "]"
hstems = self.fontInfo.get("postscriptStemSnapH", [])
if not hstems:
if allow_no_blues:
# dummy value. Needs to be larger than any hint will likely be,
# as the autohint program strips out any hint wider than twice
# the largest global stem width.
hstems = [fdDict.OrigEmSqUnits]
else:
raise FontParseError("Font does not have postscriptStemSnapH!")
hstems.sort()
if not hstems or (len(hstems) == 1 and hstems[0] < 1):
# dummy value that will allow PyAC to run
hstems = [fdDict.OrigEmSqUnits]
log.warning("There is no value or 0 value for DominantH.")
fdDict.DominantH = "[" + " ".join([str(v) for v in hstems]) + "]"
if noFlex:
fdDict.FlexOK = "false"
else:
fdDict.FlexOK = "true"
# Add candidate lists for counter hints, if any.
if vCounterGlyphs:
temp = " ".join(vCounterGlyphs)
fdDict.VCounterChars = "( %s )" % (temp)
if hCounterGlyphs:
temp = " ".join(hCounterGlyphs)
fdDict.HCounterChars = "( %s )" % (temp)
fdDict.BlueFuzz = self.fontInfo.get("postscriptBlueFuzz", 1)
# postscriptBlueShift
# postscriptBlueScale
self.fontDict = fdDict
return fdDict
def getfdInfo(self, allow_no_blues, noFlex, vCounterGlyphs, hCounterGlyphs,
glyphList, fdIndex=0):
fdGlyphDict = None
fdDict = self.getFontInfo(allow_no_blues, noFlex,
vCounterGlyphs, hCounterGlyphs, fdIndex)
fontDictList = [fdDict]
# Check the fontinfo file, and add any other font dicts
srcFontInfo = os.path.dirname(self.path)
srcFontInfo = os.path.join(srcFontInfo, "fontinfo")
maxX = self.getUnitsPerEm() * 2
maxY = maxX
minY = -self.getUnitsPerEm()
if os.path.exists(srcFontInfo):
with open(srcFontInfo, "r", encoding="utf-8") as fi:
fontInfoData = fi.read()
fontInfoData = re.sub(r"#[^\r\n]+", "", fontInfoData)
if "FDDict" in fontInfoData:
fdGlyphDict, fontDictList, finalFDict = \
fdTools.parseFontInfoFile(
fontDictList, fontInfoData, glyphList, maxY, minY,
self.getPSName())
if finalFDict is None:
# If a font dict was not explicitly specified for the
# output font, use the first user-specified font dict.
fdTools.mergeFDDicts(fontDictList[1:], self.fontDict)
else:
fdTools.mergeFDDicts([finalFDict], self.fontDict)
return fdGlyphDict, fontDictList
def getGlyphID(self, glyphName):
try:
gid = self.orderMap[glyphName]
except IndexError:
raise FontParseError(
"Could not find glyph name '%s' in UFO font contents plist. "
"'%s'. " % (glyphName, self.path))
return gid
@staticmethod
def close():
return
def main(args=None):
from io import open
options = parse_args(args)
config = getConfig(options.config)
svg_file = options.infile
# Parse SVG to read the width, height attributes defined in it
svgObj = parseSvg(svg_file)
width = float(svgObj.attrib['width'].replace("px", " "))
height = float(svgObj.attrib['height'].replace("px", " "))
name = os.path.splitext(os.path.basename(svg_file))[0]
ufo_font_path = config['font']['ufo']
# Get the font metadata from UFO
reader = UFOReader(ufo_font_path)
writer = UFOWriter(ufo_font_path)
infoObject = InfoObject()
reader.readInfo(infoObject)
fontName = config['font']['name']
# Get the configuration for this svg
try:
svg_config = config['svgs'][name]
except KeyError:
print("\033[93mSkip: Configuration not found for svg : %r\033[0m" %
name)
return
if 'unicode' in svg_config:
unicodeVal = unicode_hex_list(svg_config['unicode'])
else:
unicodeVal = None
glyphWidth = width + int(svg_config['left']) + int(svg_config['right'])
if glyphWidth < 0:
raise UFOLibError("Glyph %s has negative width." % name)
contentsPlistPath = ufo_font_path + '/glyphs/contents.plist'
try:
with open(contentsPlistPath, "rb") as f:
contentsPlist = readPlist(f)
except:
raise UFOLibError("The file %s could not be read." % contentsPlistPath)
glyph_name = svg_config['glyph_name']
# Replace all capital letters with a following '_' to avoid file name clash in Windows
glyph_file_name = re.sub(r'([A-Z]){1}', lambda pat: pat.group(1) + '_',
glyph_name) + '.glif'
if glyph_name in contentsPlist:
existing_glyph = True
else:
existing_glyph = False
# Calculate the transformation to do
transform = transform_list(config['font']['transform'])
base = 0
if 'base' in svg_config:
base = int(svg_config['base'])
transform[4] += int(svg_config['left']) # X offset = left bearing
transform[5] += height + base # Y offset
glif = svg2glif(svg_file,
name=svg_config['glyph_name'],
width=glyphWidth,
height=getattr(infoObject, 'unitsPerEm'),
unicodes=unicodeVal,
transform=transform,
version=config['font']['version'])
if options.outfile is None:
output_file = ufo_font_path + '/glyphs/' + glyph_file_name
else:
output_file = options.outfile
with open(output_file, 'w', encoding='utf-8') as f:
f.write(glif)
print(
"\033[94m[%s]\033[0m \033[92mConvert\033[0m %s -> %s \033[92m✔️\033[0m"
% (fontName, name, output_file))
# If this is a new glyph, add it to the UFO/glyphs/contents.plist
if not existing_glyph:
contentsPlist[glyph_name] = glyph_file_name
writePlistAtomically(contentsPlist, contentsPlistPath)
print(
"\033[94m[%s]\033[0m \033[92mAdd\033[0m %s -> %s \033[92m✔️\033[0m"
% (fontName, glyph_name, glyph_file_name))
lib_obj = reader.readLib()
lib_obj['public.glyphOrder'].append(glyph_name)
writer.writeLib(lib_obj)
print 'overlapping and valid', sorted(overlapping)
writer = UFOWriter('sources/jomhuria-latin.ufo', formatVersion=2)
newGlypsSet = writer.getGlyphSet()
for glyphName in filtered + overlapping:
# note how incestuous Glyph and GlyphSet interact.
glyph = Glyph(glyphName, sourceGlyphSet)
# this reads just the attributes
sourceGlyphSet.readGlyph(glyphName, glyph)
newGlypsSet.writeGlyph(
glyphName
, glyphObject=glyph
, drawPointsFunc=glyph.drawPoints
)
# after writing glyphs write the contents.plist
newGlypsSet.writeContents()
# affects only ufo version >= 3
writer.writeLayerContents()
# let's also copy fontinfo.plist
class Info(object):
pass
info = Info()
sourceReader.readInfo(info)
writer.writeInfo(info)
