Initial public commit
This commit is contained in:
Rasmus Andersson
commit
3b1fffade1
6648 changed files with 363948 additions and 0 deletions
626
misc/svgsync2.py
Executable file
626
misc/svgsync2.py
Executable file
|
|
@ -0,0 +1,626 @@
|
|||
#!/usr/bin/env python
|
||||
# encoding: utf8
|
||||
#
|
||||
# Sync glyph shapes between SVG and UFO, creating a bridge between UFO and Figma.
|
||||
#
|
||||
import os
|
||||
import sys
|
||||
import argparse
|
||||
import re
|
||||
from StringIO import StringIO
|
||||
from hashlib import sha256
|
||||
from xml.dom.minidom import parseString as xmlparseString
|
||||
from svgpathtools import svg2paths, parse_path, Path, Line, CubicBezier
|
||||
from base64 import b64encode
|
||||
|
||||
# from robofab.world import world, RFont, RGlyph, OpenFont, NewFont
|
||||
from robofab.objects.objectsRF import RFont, RGlyph, OpenFont, NewFont, RContour
|
||||
from robofab.objects.objectsBase import MOVE, LINE, CORNER, CURVE, QCURVE, OFFCURVE
|
||||
|
||||
font = None # RFont
|
||||
ufopath = ''
|
||||
svgdir = ''
|
||||
effectiveAscender = 0
|
||||
|
||||
|
||||
def num(s):
|
||||
return int(s) if s.find('.') == -1 else float(s)
|
||||
|
||||
|
||||
def glyphToSVGPath(g, yMul=-1):
|
||||
commands = {'move':'M','line':'L','curve':'Y','offcurve':'X','offCurve':'X'}
|
||||
svg = ''
|
||||
contours = []
|
||||
if len(g.components):
|
||||
font.newGlyph('__svgsync')
|
||||
new = font['__svgsync']
|
||||
new.width = g.width
|
||||
new.appendGlyph(g)
|
||||
new.decompose()
|
||||
g = new
|
||||
if len(g):
|
||||
for c in range(len(g)):
|
||||
contours.append(g[c])
|
||||
for i in range(len(contours)):
|
||||
c = contours[i]
|
||||
contour = end = ''
|
||||
curve = False
|
||||
points = c.points
|
||||
if points[0].type == 'offCurve':
|
||||
points.append(points.pop(0))
|
||||
if points[0].type == 'offCurve':
|
||||
points.append(points.pop(0))
|
||||
for x in range(len(points)):
|
||||
p = points[x]
|
||||
command = commands[str(p.type)]
|
||||
if command == 'X':
|
||||
if curve == True:
|
||||
command = ''
|
||||
else:
|
||||
command = 'C'
|
||||
curve = True
|
||||
if command == 'Y':
|
||||
command = ''
|
||||
curve = False
|
||||
if x == 0:
|
||||
command = 'M'
|
||||
if p.type == 'curve':
|
||||
end = ' ' + str(p.x) + ' ' + str(p.y * yMul)
|
||||
contour += ' ' + command + str(p.x) + ' ' + str(p.y * yMul)
|
||||
svg += ' ' + contour + end + 'z'
|
||||
if font.has_key('__svgsync'):
|
||||
font.removeGlyph('__svgsync')
|
||||
return svg.strip()
|
||||
|
||||
|
||||
def vec2(x, y):
|
||||
return float(x) + float(y) * 1j
|
||||
|
||||
|
||||
def glyphToPaths(g, yMul=-1):
|
||||
paths = []
|
||||
contours = []
|
||||
yOffs = -font.info.unitsPerEm
|
||||
|
||||
# decompose components
|
||||
if len(g.components):
|
||||
font.newGlyph('__svgsync')
|
||||
ng = font['__svgsync']
|
||||
ng.width = g.width
|
||||
ng.appendGlyph(g)
|
||||
ng.decompose()
|
||||
g = ng
|
||||
|
||||
for c in g:
|
||||
curve = False
|
||||
points = c.points
|
||||
path = Path()
|
||||
currentPos = 0j
|
||||
controlPoints = []
|
||||
|
||||
for x in range(len(points)):
|
||||
p = points[x]
|
||||
# print 'p#' + str(x) + '.type = ' + repr(p.type)
|
||||
|
||||
if p.type == 'move':
|
||||
currentPos = vec2(p.x, (p.y + yOffs) * yMul)
|
||||
elif p.type == 'offcurve':
|
||||
controlPoints.append(p)
|
||||
elif p.type == 'curve':
|
||||
pos = vec2(p.x, (p.y + yOffs) * yMul)
|
||||
if len(controlPoints) == 2:
|
||||
cp1, cp2 = controlPoints
|
||||
path.append(CubicBezier(
|
||||
currentPos,
|
||||
vec2(cp1.x, (cp1.y + yOffs) * yMul),
|
||||
vec2(cp2.x, (cp2.y + yOffs) * yMul),
|
||||
pos))
|
||||
else:
|
||||
if len(controlPoints) != 1:
|
||||
raise Exception('unexpected number of control points for curve')
|
||||
cp = controlPoints[0]
|
||||
path.append(QuadraticBezier(currentPos, vec2(cp.x, (cp.y + yOffs) * yMul), pos))
|
||||
currentPos = pos
|
||||
controlPoints = []
|
||||
elif p.type == 'line':
|
||||
pos = vec2(p.x, (p.y + yOffs) * yMul)
|
||||
path.append(Line(currentPos, pos))
|
||||
currentPos = pos
|
||||
|
||||
paths.append(path)
|
||||
|
||||
if font.has_key('__svgsync'):
|
||||
font.removeGlyph('__svgsync')
|
||||
|
||||
return paths
|
||||
|
||||
|
||||
def maybeAddMove(contour, x, y, smooth):
|
||||
if len(contour.segments) == 0:
|
||||
contour.appendSegment(MOVE, [(x, y)], smooth=smooth)
|
||||
|
||||
|
||||
|
||||
svgPathDataRegEx = re.compile(r'(?:([A-Z])\s*|)([0-9\.\-\+eE]+)')
|
||||
|
||||
|
||||
def drawSVGPath(g, d, tr):
|
||||
yMul = -1
|
||||
xOffs = tr[0]
|
||||
yOffs = -(font.info.unitsPerEm - tr[1])
|
||||
|
||||
for pathd in d.split('M'):
|
||||
pathd = pathd.strip()
|
||||
# print 'pathd', pathd
|
||||
if len(pathd) == 0:
|
||||
continue
|
||||
i = 0
|
||||
closePath = False
|
||||
if pathd[-1] == 'z':
|
||||
closePath = True
|
||||
pathd = pathd[0:-1]
|
||||
|
||||
pv = []
|
||||
for m in svgPathDataRegEx.finditer('M' + pathd):
|
||||
if m.group(1) is not None:
|
||||
pv.append(m.group(1) + m.group(2))
|
||||
else:
|
||||
pv.append(m.group(2))
|
||||
|
||||
initX = 0
|
||||
initY = 0
|
||||
|
||||
pen = g.getPen()
|
||||
|
||||
while i < len(pv):
|
||||
pd = pv[i]; i += 1
|
||||
cmd = pd[0]
|
||||
x = num(pd[1:]) + xOffs
|
||||
y = (num(pv[i]) + yOffs) * yMul; i += 1
|
||||
|
||||
if cmd == 'M':
|
||||
# print cmd, x, y, '/', num(pv[i-2][1:])
|
||||
initX = x
|
||||
initY = y
|
||||
pen.moveTo((x, y))
|
||||
continue
|
||||
|
||||
if cmd == 'C':
|
||||
# Bezier curve: "C x1 y1, x2 y2, x y"
|
||||
x1 = x
|
||||
y1 = y
|
||||
x2 = num(pv[i]) + xOffs; i += 1
|
||||
y2 = (num(pv[i]) + yOffs) * yMul; i += 1
|
||||
x = num(pv[i]) + xOffs; i += 1
|
||||
y = (num(pv[i]) + yOffs) * yMul; i += 1
|
||||
pen.curveTo((x1, y1), (x2, y2), (x, y))
|
||||
# print cmd, x1, y1, x2, y2, x, y
|
||||
|
||||
elif cmd == 'L':
|
||||
pen.lineTo((x, y))
|
||||
|
||||
else:
|
||||
raise Exception('unexpected SVG path command %r' % cmd)
|
||||
|
||||
if closePath:
|
||||
pen.closePath()
|
||||
else:
|
||||
pen.endPath()
|
||||
# print 'path ended. closePath:', closePath
|
||||
|
||||
|
||||
def glyphToSVG(g, path, hash):
|
||||
width = g.width
|
||||
height = font.info.unitsPerEm
|
||||
|
||||
d = {
|
||||
'name': g.name,
|
||||
'width': width,
|
||||
'height': effectiveAscender - font.info.descender,
|
||||
'effectiveAscender': effectiveAscender,
|
||||
'leftMargin': g.leftMargin,
|
||||
'rightMargin': g.rightMargin,
|
||||
'd': path.d(use_closed_attrib=True),
|
||||
'ascender': font.info.ascender,
|
||||
'descender': font.info.descender,
|
||||
'baselineOffset': height + font.info.descender,
|
||||
'unitsPerEm': font.info.unitsPerEm,
|
||||
'hash': hash,
|
||||
}
|
||||
|
||||
svg = '''
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="%(width)d" height="%(height)d" data-svgsync-hash="%(hash)s">
|
||||
<g id="%(name)s">
|
||||
<path d="%(d)s" transform="translate(0 %(effectiveAscender)d)" />
|
||||
<rect x="0" y="0" width="%(width)d" height="%(height)d" fill="" stroke="black" />
|
||||
</g>
|
||||
</svg>
|
||||
''' % d
|
||||
# print svg
|
||||
return svg.strip()
|
||||
|
||||
|
||||
def _findPathNodes(n, paths, defs, uses, isDef=False):
|
||||
for cn in n.childNodes:
|
||||
if cn.nodeName == 'path':
|
||||
if isDef:
|
||||
defs[cn.getAttribute('id')] = cn
|
||||
else:
|
||||
paths.append(cn)
|
||||
elif cn.nodeName == 'use':
|
||||
uses[cn.getAttribute('xlink:href').lstrip('#')] = {'useNode': cn, 'targetNode': None}
|
||||
elif cn.nodeName == 'defs':
|
||||
_findPathNodes(cn, paths, defs, uses, isDef=True)
|
||||
elif not isinstance(cn, basestring) and cn.childNodes and len(cn.childNodes) > 0:
|
||||
_findPathNodes(cn, paths, defs, uses, isDef)
|
||||
# return translate
|
||||
|
||||
|
||||
def findPathNodes(n, isDef=False):
|
||||
paths = []
|
||||
defs = {}
|
||||
uses = {}
|
||||
# <g id="Canvas" transform="translate(-3677 -24988)">
|
||||
# <g id="six 2">
|
||||
# <g id="six">
|
||||
# <g id="Vector">
|
||||
# <use xlink:href="#path0_fill" transform="translate(3886 25729)"/>
|
||||
# ...
|
||||
# <defs>
|
||||
# <path id="path0_fill" ...
|
||||
#
|
||||
_findPathNodes(n, paths, defs, uses)
|
||||
|
||||
# flatten uses & defs
|
||||
for k in uses.keys():
|
||||
dfNode = defs.get(k)
|
||||
if dfNode is not None:
|
||||
v = uses[k]
|
||||
v['targetNode'] = dfNode
|
||||
if dfNode.nodeName == 'path':
|
||||
useNode = v['useNode']
|
||||
useNode.parentNode.replaceChild(dfNode, useNode)
|
||||
attrs = useNode.attributes
|
||||
for k in attrs.keys():
|
||||
if k != 'xlink:href':
|
||||
dfNode.setAttribute(k, attrs[k])
|
||||
paths.append(dfNode)
|
||||
|
||||
else:
|
||||
del defs[k]
|
||||
|
||||
return paths
|
||||
|
||||
|
||||
def nodeTranslation(path, x=0, y=0):
|
||||
tr = path.getAttribute('transform')
|
||||
if tr is not None:
|
||||
if not isinstance(tr, basestring):
|
||||
tr = tr.value
|
||||
if len(tr) > 0:
|
||||
m = re.match(r"translate\s*\(\s*(?P<x>[\-\d\.eE]+)[\s,]*(?P<y>[\-\d\.eE]+)\s*\)", tr)
|
||||
if m is not None:
|
||||
x += num(m.group('x'))
|
||||
y += num(m.group('y'))
|
||||
else:
|
||||
raise Exception('Unable to handle transform="%s"' % tr)
|
||||
# m = re.match(r"matrix\s*\(\s*(?P<a>[\-\d\.eE]+)[\s,]*(?P<b>[\-\d\.eE]+)[\s,]*(?P<c>[\-\d\.eE]+)[\s,]*(?P<d>[\-\d\.eE]+)[\s,]*(?P<e>[\-\d\.eE]+)[\s,]*(?P<f>[\-\d\.eE]+)[\s,]*", tr)
|
||||
# if m is not None:
|
||||
# a, b, c = num(m.group('a')), num(m.group('b')), num(m.group('c'))
|
||||
# d, e, f = num(m.group('d')), num(m.group('e')), num(m.group('f'))
|
||||
# # matrix -1 0 0 -1 -660.719 31947
|
||||
# print 'matrix', a, b, c, d, e, f
|
||||
# # matrix(-1 0 -0 -1 -2553 31943)
|
||||
pn = path.parentNode
|
||||
if pn is not None and pn.nodeName != '#document':
|
||||
x, y = nodeTranslation(pn, x, y)
|
||||
return (x, y)
|
||||
|
||||
|
||||
def glyphUpdateFromSVG(g, svgCode):
|
||||
doc = xmlparseString(svgCode)
|
||||
svg = doc.documentElement
|
||||
paths = findPathNodes(svg)
|
||||
if len(paths) == 0:
|
||||
raise Exception('no <path> found in SVG')
|
||||
path = paths[0]
|
||||
if len(paths) != 1:
|
||||
for p in paths:
|
||||
id = p.getAttribute('id')
|
||||
if id is not None and id.find('stroke') == -1:
|
||||
path = p
|
||||
break
|
||||
|
||||
tr = nodeTranslation(path)
|
||||
d = path.getAttribute('d')
|
||||
g.clearContours()
|
||||
drawSVGPath(g, d, tr)
|
||||
|
||||
|
||||
def stat(path):
|
||||
try:
|
||||
return os.stat(path)
|
||||
except OSError as e:
|
||||
return None
|
||||
|
||||
|
||||
def writeFile(file, s):
|
||||
with open(file, 'w') as f:
|
||||
f.write(s)
|
||||
|
||||
|
||||
def writeFileAndMkDirsIfNeeded(file, s):
|
||||
try:
|
||||
writeFile(file, s)
|
||||
except IOError as e:
|
||||
if e.errno == 2:
|
||||
os.makedirs(os.path.dirname(file))
|
||||
writeFile(file, s)
|
||||
|
||||
|
||||
def findSvgSyncHashInSVG(svgCode):
|
||||
# with open(svgFile, 'r') as f:
|
||||
# svgCode = f.readline(512)
|
||||
r = re.compile(r'^\s*<svg[^>]+data-svgsync-hash="([^"]*)".+')
|
||||
m = r.match(svgCode)
|
||||
if m is not None:
|
||||
return m.group(1)
|
||||
return None
|
||||
|
||||
|
||||
def computeSVGHashFromSVG(g):
|
||||
# h = sha256()
|
||||
return 'abc123'
|
||||
|
||||
|
||||
def encodePath(o, path):
|
||||
o.write(path.d())
|
||||
|
||||
|
||||
def hashPaths(paths):
|
||||
h = sha256()
|
||||
for path in paths:
|
||||
h.update(path.d()+';')
|
||||
return b64encode(h.digest(), '-_')
|
||||
|
||||
|
||||
def svgGetPaths(svgCode):
|
||||
doc = xmlparseString(svgCode)
|
||||
svg = doc.documentElement
|
||||
paths = findPathNodes(svg)
|
||||
isFigmaSVG = svgCode.find('Figma</desc>') != -1
|
||||
|
||||
if len(paths) == 0:
|
||||
return paths, (0,0)
|
||||
|
||||
paths2 = []
|
||||
for path in paths:
|
||||
id = path.getAttribute('id')
|
||||
if not isFigmaSVG or (id is None or id.find('stroke') == -1):
|
||||
tr = nodeTranslation(path)
|
||||
d = path.getAttribute('d')
|
||||
paths2.append((d, tr))
|
||||
|
||||
return paths2, isFigmaSVG
|
||||
|
||||
|
||||
def translatePath(path, trX, trY):
|
||||
pass
|
||||
|
||||
|
||||
def parseSVG(svgFile):
|
||||
svgCode = None
|
||||
with open(svgFile, 'r') as f:
|
||||
svgCode = f.read()
|
||||
|
||||
existingSvgHash = findSvgSyncHashInSVG(svgCode)
|
||||
print 'hash in SVG file:', existingSvgHash
|
||||
|
||||
svgPathDefs, isFigmaSVG = svgGetPaths(svgCode)
|
||||
paths = []
|
||||
for pathDef, tr in svgPathDefs:
|
||||
print 'pathDef:', pathDef, 'tr:', tr
|
||||
path = parse_path(pathDef)
|
||||
if tr[0] != 0 or tr[1] != 0:
|
||||
path = path.translated(vec2(*tr))
|
||||
paths.append(path)
|
||||
|
||||
return paths, existingSvgHash
|
||||
|
||||
|
||||
def syncGlyphUFOToSVG(g, glyphFile, svgFile, mtime, hasSvgFile):
|
||||
# # Let's print out the first path object and the color it was in the SVG
|
||||
# # We'll see it is composed of two CubicBezier objects and, in the SVG file it
|
||||
# # came from, it was red
|
||||
# paths, attributes, svg_attributes = svg2paths(svgFile, return_svg_attributes=True)
|
||||
# print('svg_attributes:', repr(svg_attributes))
|
||||
# # redpath = paths[0]
|
||||
# # redpath_attribs = attributes[0]
|
||||
# print(paths)
|
||||
# print(attributes)
|
||||
# wsvg(paths, attributes=attributes, svg_attributes=svg_attributes, filename=svgFile + '-x.svg')
|
||||
|
||||
# existingSVGHash = readSVGHash(svgFile)
|
||||
svgPaths = None
|
||||
existingSVGHash = None
|
||||
if hasSvgFile:
|
||||
svgPaths, existingSVGHash = parseSVG(svgFile)
|
||||
print 'existingSVGHash:', existingSVGHash
|
||||
print 'svgPaths:\n', '\n'.join([p.d() for p in svgPaths])
|
||||
svgHash = hashPaths(svgPaths)
|
||||
print 'hash(SVG-glyph) =>', svgHash
|
||||
|
||||
# computedSVGHash = computeSVGHashFromSVG(svgFile)
|
||||
# print 'computeSVGHashFromSVG:', computedSVGHash
|
||||
|
||||
ufoPaths = glyphToPaths(g)
|
||||
print 'ufoPaths:\n', '\n'.join([p.d() for p in ufoPaths])
|
||||
ufoGlyphHash = hashPaths(ufoPaths)
|
||||
print 'hash(UFO-glyph) =>', ufoGlyphHash
|
||||
|
||||
# svg = glyphToSVG(g, ufoGlyphHash)
|
||||
|
||||
# with open('/Users/rsms/src/interface/_local/svgPaths.txt', 'w') as f:
|
||||
# f.write(svgPaths[0].d())
|
||||
# with open('/Users/rsms/src/interface/_local/ufoPaths.txt', 'w') as f:
|
||||
# f.write(ufoPaths[0].d())
|
||||
# print svgPaths[0].d() == ufoPaths[0].d()
|
||||
|
||||
# svgHash = hashPaths()
|
||||
# print 'hash(UFO-glyph) =>', pathHash
|
||||
|
||||
sys.exit(1)
|
||||
if pathHash == existingSVGHash:
|
||||
return (None, 0) # did not change
|
||||
|
||||
svg = glyphToSVG(g, pathHash)
|
||||
sys.exit(1)
|
||||
|
||||
writeFileAndMkDirsIfNeeded(svgFile, svg)
|
||||
os.utime(svgFile, (mtime, mtime))
|
||||
print 'svgsync write', svgFile
|
||||
|
||||
g.lib['svgsync.hash'] = pathHash
|
||||
return (glyphFile, mtime)
|
||||
|
||||
|
||||
def syncGlyphSVGToUFO(glyphname, svgFile):
|
||||
print glyphname + ': SVG -> UFO'
|
||||
sys.exit(1)
|
||||
svg = ''
|
||||
with open(svgFile, 'r') as f:
|
||||
svg = f.read()
|
||||
g = font.getGlyph(glyphname)
|
||||
glyphUpdateFromSVG(g, svg)
|
||||
|
||||
|
||||
def findGlifFile(glyphname):
|
||||
# glyphname.glif
|
||||
# glyphname_.glif
|
||||
# glyphname__.glif
|
||||
# glyphname___.glif
|
||||
for underscoreCount in range(0, 5):
|
||||
fn = os.path.join(ufopath, 'glyphs', glyphname + ('_' * underscoreCount) + '.glif')
|
||||
st = stat(fn)
|
||||
if st is not None:
|
||||
return fn, st
|
||||
|
||||
if glyphname.find('.') != -1:
|
||||
# glyph_.name.glif
|
||||
# glyph__.name.glif
|
||||
# glyph___.name.glif
|
||||
for underscoreCount in range(0, 5):
|
||||
nv = glyphname.split('.')
|
||||
nv[0] = nv[0] + ('_' * underscoreCount)
|
||||
ns = '.'.join(nv)
|
||||
fn = os.path.join(ufopath, 'glyphs', ns + '.glif')
|
||||
st = stat(fn)
|
||||
if st is not None:
|
||||
return fn, st
|
||||
|
||||
if glyphname.find('_') != -1:
|
||||
# glyph_name.glif
|
||||
# glyph_name_.glif
|
||||
# glyph_name__.glif
|
||||
# glyph__name.glif
|
||||
# glyph__name_.glif
|
||||
# glyph__name__.glif
|
||||
# glyph___name.glif
|
||||
# glyph___name_.glif
|
||||
# glyph___name__.glif
|
||||
for x in range(0, 4):
|
||||
for y in range(0, 5):
|
||||
ns = glyphname.replace('_', '__' + ('_' * x))
|
||||
fn = os.path.join(ufopath, 'glyphs', ns + ('_' * y) + '.glif')
|
||||
st = stat(fn)
|
||||
if st is not None:
|
||||
return fn, st
|
||||
|
||||
return ('', None)
|
||||
|
||||
|
||||
def syncGlyph(glyphname, createSVG=False): # => (glyphname, mtime) or (None, 0) if noop
|
||||
glyphFile, glyphStat = findGlifFile(glyphname)
|
||||
|
||||
svgFile = os.path.join(svgdir, glyphname + '.svg')
|
||||
svgStat = stat(svgFile)
|
||||
|
||||
if glyphStat is None and svgStat is None:
|
||||
raise Exception("glyph %r doesn't exist in UFO or SVG directory" % glyphname)
|
||||
|
||||
c = cmp(
|
||||
0 if glyphStat is None else glyphStat.st_mtime,
|
||||
0 if svgStat is None else svgStat.st_mtime
|
||||
)
|
||||
|
||||
g = font.getGlyph(glyphname)
|
||||
ufoPathHash = g.lib['svgsync.hash'] if 'svgsync.hash' in g.lib else None
|
||||
print '[syncGlyph] g.lib["svgsync.hash"] =', ufoPathHash
|
||||
|
||||
c = 1 # XXX DEBUG
|
||||
|
||||
if c < 0:
|
||||
syncGlyphSVGToUFO(glyphname, svgFile)
|
||||
return (glyphFile, svgStat.st_mtime) # glif file in UFO change + it's new mtime
|
||||
elif c > 0 and (svgStat is not None or createSVG):
|
||||
print glyphname + ': UFO -> SVG'
|
||||
return syncGlyphUFOToSVG(
|
||||
g,
|
||||
glyphFile,
|
||||
svgFile,
|
||||
glyphStat.st_mtime,
|
||||
hasSvgFile=svgStat is not None
|
||||
)
|
||||
|
||||
return (None, 0) # UFO did not change
|
||||
|
||||
|
||||
# ————————————————————————————————————————————————————————————————————————
|
||||
# main
|
||||
|
||||
argparser = argparse.ArgumentParser(description='Convert UFO glyphs to SVG')
|
||||
|
||||
argparser.add_argument('--svgdir', dest='svgdir', metavar='<dir>', type=str,
|
||||
default='',
|
||||
help='Write SVG files to <dir>. If not specified, SVG files are' +
|
||||
' written to: {dirname(<ufopath>)/svg/<familyname>/<style>')
|
||||
|
||||
argparser.add_argument('ufopath', metavar='<ufopath>', type=str,
|
||||
help='Path to UFO packages')
|
||||
|
||||
argparser.add_argument('glyphs', metavar='<glyphname>', type=str, nargs='*',
|
||||
help='Glyphs to convert. Converts all if none specified.')
|
||||
|
||||
args = argparser.parse_args()
|
||||
|
||||
ufopath = args.ufopath.rstrip('/')
|
||||
|
||||
font = OpenFont(ufopath)
|
||||
effectiveAscender = max(font.info.ascender, font.info.unitsPerEm)
|
||||
|
||||
svgdir = args.svgdir
|
||||
if len(svgdir) == 0:
|
||||
svgdir = os.path.join(
|
||||
os.path.dirname(ufopath),
|
||||
'svg',
|
||||
font.info.familyName,
|
||||
font.info.styleName
|
||||
)
|
||||
|
||||
print 'svgsync sync %s (%s)' % (font.info.familyName, font.info.styleName)
|
||||
|
||||
createSVGs = len(args.glyphs) > 0
|
||||
glyphnames = args.glyphs if len(args.glyphs) else font.keys()
|
||||
|
||||
modifiedGlifFiles = []
|
||||
for glyphname in glyphnames:
|
||||
glyphFile, mtime = syncGlyph(glyphname, createSVG=createSVGs)
|
||||
if glyphFile is not None:
|
||||
modifiedGlifFiles.append((glyphFile, mtime))
|
||||
|
||||
if len(modifiedGlifFiles) > 0:
|
||||
font.save()
|
||||
for glyphFile, mtime in modifiedGlifFiles:
|
||||
os.utime(glyphFile, (mtime, mtime))
|
||||
print 'svgsync write', glyphFile
|
||||
|
||||
Reference in a new issue