203 lines
7.1 KiB
Python
Executable File
203 lines
7.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright 2015 Google, Inc. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
# Google Author(s): Doug Felt
|
|
|
|
from __future__ import print_function
|
|
import argparse
|
|
import os
|
|
import os.path
|
|
import re
|
|
import sys
|
|
|
|
from fontTools import ttx
|
|
|
|
import add_svg_glyphs
|
|
|
|
def do_generate_test_html(font_basename, pairs, glyph=None, verbosity=1):
|
|
header = r"""<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<style type="text/css">
|
|
@font-face { font-family: svgfont; src: url("%s") }
|
|
body { font-family: sans-serif; font-size: 24px }
|
|
#emoji span { font-family: svgfont, sans-serif }
|
|
#panel { font-family: svgfont, sans-serif; font-size: 256px }
|
|
#paneltitle { font-family: sans-serif; font-size: 36px }
|
|
</style>
|
|
<script type="text/javascript">
|
|
function hexify(text) {
|
|
var surr_offset = 0x10000 - (0xd800 << 10) - 0xdc00
|
|
var str = text.trim()
|
|
var len = str.length
|
|
var result = ""
|
|
for (var i = 0; i < len; ++i) {
|
|
var cp = str.charCodeAt(i)
|
|
if (cp >= 0xd800 && cp < 0xdc00 && i < len - 1) {
|
|
ncp = str.charCodeAt(i+1)
|
|
if (ncp >= 0xdc00 && ncp < 0xe000) {
|
|
cp = (cp << 10) + ncp + surr_offset
|
|
++i;
|
|
}
|
|
}
|
|
result += " 0x" + cp.toString(16)
|
|
}
|
|
return result
|
|
};
|
|
|
|
function showText(event) {
|
|
var text = event.target.textContent
|
|
var p = document.getElementById('panel')
|
|
p.textContent = text
|
|
p = document.getElementById('paneltitle')
|
|
p.textContent = hexify(text)
|
|
};
|
|
|
|
function setup() {
|
|
var t = document.getElementById('emoji')
|
|
var tdlist = t.getElementsByTagName('span')
|
|
for (var i = 0; i < tdlist.length; ++i) {
|
|
var e = tdlist[i]
|
|
e.onmouseover = showText
|
|
}
|
|
};
|
|
</script>
|
|
</head>"""
|
|
|
|
body_head = r"""<body onload="setup();">
|
|
<p>Test for SVG glyphs in %(font)s. It uses the proposed
|
|
<a href="http://lists.w3.org/Archives/Public/public-svgopentype/2013Jul/0003.html">SVG-in-OpenType format</a>.
|
|
View using Firefox 26 and later.
|
|
<div style="float:left; text-align:center; margin:0 10px; width:40%%">
|
|
<div id='panel' style="margin-left:auto; margin-right:auto">%(glyph)s</div>
|
|
<div id='paneltitle' style="margin-left:auto; margin-right:auto">%(glyph_hex)s</div>
|
|
</div>
|
|
<div id='emoji'><p>"""
|
|
|
|
body_tail = r"""</div>
|
|
</body>
|
|
</html>
|
|
"""
|
|
|
|
font_name = font_basename + ".woff"
|
|
html_name = font_basename + "_test.html"
|
|
|
|
found_initial_glyph = False
|
|
initial_glyph_str = None;
|
|
initial_glyph_hex = None;
|
|
text_parts = []
|
|
for glyphstr, _ in pairs:
|
|
name_parts = []
|
|
hex_parts = []
|
|
for cp in glyphstr:
|
|
hex_str = hex(ord(cp))
|
|
name_parts.append('&#x%s;' % hex_str[2:])
|
|
hex_parts.append(hex_str)
|
|
glyph_str = ''.join(name_parts)
|
|
|
|
if not found_initial_glyph:
|
|
if not glyph or glyph_str == glyph:
|
|
initial_glyph_str = glyph_str
|
|
initial_glyph_hex = ' '.join(hex_parts)
|
|
found_initial_glyph = True
|
|
elif not initial_glyph_str:
|
|
initial_glyph_str = glyph_str
|
|
initial_glyph_hex = ' '.join(hex_parts)
|
|
|
|
text = '<span>%s</span>' % glyph_str
|
|
text_parts.append(text)
|
|
|
|
if verbosity and glyph and not found_initial_glyph:
|
|
print("Did not find glyph '%s', using initial glyph '%s'" % (glyph, initial_glyph_str))
|
|
elif verbosity > 1 and not glyph:
|
|
print("Using initial glyph '%s'" % initial_glyph_str)
|
|
|
|
lines = [header % font_name]
|
|
lines.append(body_head % {'font':font_name, 'glyph':initial_glyph_str,
|
|
'glyph_hex':initial_glyph_hex})
|
|
lines.extend(text_parts) # we'll end up with space between each emoji
|
|
lines.append(body_tail)
|
|
output = '\n'.join(lines)
|
|
with open(html_name, 'w') as fp:
|
|
fp.write(output)
|
|
if verbosity:
|
|
print('Wrote ' + html_name)
|
|
|
|
|
|
def do_generate_fonts(template_file, font_basename, pairs, reuse=0, verbosity=1):
|
|
out_woff = font_basename + '.woff'
|
|
if reuse > 1 and os.path.isfile(out_woff) and os.access(out_woff, os.R_OK):
|
|
if verbosity:
|
|
print('Reusing ' + out_woff)
|
|
return
|
|
|
|
out_ttx = font_basename + '.ttx'
|
|
if reuse == 0:
|
|
add_svg_glyphs.add_image_glyphs(template_file, out_ttx, pairs, verbosity=verbosity)
|
|
elif verbosity:
|
|
print('Reusing ' + out_ttx)
|
|
|
|
quiet=verbosity < 2
|
|
font = ttx.TTFont(flavor='woff', quiet=quiet)
|
|
font.importXML(out_ttx, quiet=quiet)
|
|
font.save(out_woff)
|
|
if verbosity:
|
|
print('Wrote ' + out_woff)
|
|
|
|
|
|
def main(argv):
|
|
usage = """This will search for files that have image_prefix followed by one or more
|
|
hex numbers (separated by underscore if more than one), and end in ".svg".
|
|
For example, if image_prefix is "icons/u", then files with names like
|
|
"icons/u1F4A9.svg" or "icons/u1F1EF_1F1F5.svg" will be found. It generates
|
|
an SVG font from this, converts it to woff, and also generates an html test
|
|
page containing text for all the SVG glyphs."""
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description='Generate font and html test file.', epilog=usage)
|
|
parser.add_argument('template_file', help='name of template .ttx file')
|
|
parser.add_argument('image_prefix', help='location and prefix of image files')
|
|
parser.add_argument('-i', '--include', help='include files whoses name matches this regex')
|
|
parser.add_argument('-e', '--exclude', help='exclude files whose name matches this regex')
|
|
parser.add_argument('-o', '--out_basename', help='base name of (ttx, woff, html) files to generate, '
|
|
'defaults to the template base name')
|
|
parser.add_argument('-g', '--glyph', help='set the initial glyph text (html encoded string), '
|
|
'defaults to first glyph')
|
|
parser.add_argument('-rt', '--reuse_ttx_font', dest='reuse_font', help='use existing ttx font',
|
|
default=0, const=1, action='store_const')
|
|
parser.add_argument('-r', '--reuse_font', dest='reuse_font', help='use existing woff font',
|
|
const=2, action='store_const')
|
|
parser.add_argument('-q', '--quiet', dest='v', help='quiet operation', default=1,
|
|
action='store_const', const=0)
|
|
parser.add_argument('-v', '--verbose', dest='v', help='verbose operation',
|
|
action='store_const', const=2)
|
|
args = parser.parse_args(argv)
|
|
|
|
pairs = add_svg_glyphs.collect_glyphstr_file_pairs(
|
|
args.image_prefix, 'svg', include=args.include, exclude=args.exclude, verbosity=args.v)
|
|
add_svg_glyphs.sort_glyphstr_tuples(pairs)
|
|
|
|
out_basename = args.out_basename
|
|
if not out_basename:
|
|
out_basename = args.template_file.split('.')[0] # exclude e.g. '.tmpl.ttx'
|
|
if args.v:
|
|
print("Output basename is %s." % out_basename)
|
|
do_generate_fonts(args.template_file, out_basename, pairs, reuse=args.reuse_font, verbosity=args.v)
|
|
do_generate_test_html(out_basename, pairs, glyph=args.glyph, verbosity=args.v)
|
|
|
|
if __name__ == '__main__':
|
|
main(sys.argv[1:])
|