mirror of
https://github.com/rsms/inter.git
synced 2024-12-12 15:22:36 +03:00
627 lines
17 KiB
Python
Executable File
627 lines
17 KiB
Python
Executable File
#!/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
|
|
|