1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
# -*- coding: UTF-8 -*-
from copy import deepcopy
import json
import os
import inkex
from ..elements import nodes_to_elements
from ..i18n import _
from ..stitches.auto_satin import auto_satin
from ..svg import PIXELS_PER_MM
from ..svg.tags import SVG_GROUP_TAG, SVG_PATH_TAG, INKSCAPE_LABEL
from ..utils import Point
from .font_variant import FontVariant
def font_metadata(name, default=None, multiplier=None):
def getter(self):
value = self.metadata.get(name, default)
if multiplier is not None:
value *= multiplier
return value
return property(getter)
class Font(object):
"""Represents a font with multiple variants.
Each font may have multiple FontVariants for left-to-right, right-to-left,
etc. Each variant has a set of Glyphs, one per character.
Properties:
path -- the path to the directory containing this font
metadata -- A dict of information about the font.
name -- Shortcut property for metadata["name"]
license -- contents of the font's LICENSE file, or None if no LICENSE file exists.
variants -- A dict of FontVariants, with keys in FontVariant.VARIANT_TYPES.
"""
def __init__(self, font_path):
self.path = font_path
self._load_metadata()
self._load_license()
self._load_variants()
def _load_metadata(self):
try:
with open(os.path.join(self.path, "font.json")) as metadata_file:
self.metadata = json.load(metadata_file)
except IOError:
self.metadata = {}
def _load_license(self):
try:
with open(os.path.join(self.path, "LICENSE")) as license_file:
self.license = license_file.read()
except IOError:
self.license = None
def _load_variants(self):
self.variants = {}
for variant in FontVariant.VARIANT_TYPES:
try:
self.variants[variant] = FontVariant(self.path, variant, self.default_glyph)
except IOError:
# we'll deal with missing variants when we apply lettering
pass
name = font_metadata('name', '')
description = font_metadata('description', '')
default_variant = font_metadata('default_variant', FontVariant.LEFT_TO_RIGHT)
default_glyph = font_metadata('defalt_glyph', u"�")
letter_spacing = font_metadata('letter_spacing', 1.5, multiplier=PIXELS_PER_MM)
leading = font_metadata('leading', 5, multiplier=PIXELS_PER_MM)
word_spacing = font_metadata('word_spacing', 3, multiplier=PIXELS_PER_MM)
kerning_pairs = font_metadata('kerning_pairs', {})
auto_satin = font_metadata('auto_satin', True)
def render_text(self, text, variant=None, back_and_forth=True):
if variant is None:
variant = self.default_variant
if back_and_forth:
glyph_sets = [self.get_variant(variant), self.get_variant(FontVariant.reversed_variant(variant))]
else:
glyph_sets = [self.get_variant(variant)] * 2
line_group = inkex.etree.Element(SVG_GROUP_TAG, {
INKSCAPE_LABEL: _("Ink/Stitch Text")
})
position = Point(0, 0)
for i, line in enumerate(text.splitlines()):
glyph_set = glyph_sets[i % 2]
line = line.strip()
letter_group = self._render_line(line, position, glyph_set)
if glyph_set.variant == FontVariant.RIGHT_TO_LEFT:
letter_group[:] = reversed(letter_group)
line_group.append(letter_group)
position.x = 0
position.y += self.leading
if self.auto_satin and len(line_group) > 0:
self._apply_auto_satin(line_group)
return line_group
def get_variant(self, variant):
return self.variants.get(variant, self.variants[self.default_variant])
def _render_line(self, line, position, glyph_set):
"""Render a line of text.
An SVG XML node tree will be returned, with an svg:g at its root. If
the font metadata requests it, Auto-Satin will be applied.
Parameters:
line -- the line of text to render.
position -- Current position. Will be updated to point to the spot
immediately after the last character.
glyph_set -- a FontVariant instance.
Returns:
An svg:g element containing the rendered text.
"""
group = inkex.etree.Element(SVG_GROUP_TAG, {
INKSCAPE_LABEL: line
})
last_character = None
for character in line:
if character == " ":
position.x += self.word_spacing
last_character = None
else:
glyph = glyph_set[character] or glyph_set[self.default_glyph]
if glyph is not None:
node = self._render_glyph(glyph, position, character, last_character)
group.append(node)
last_character = character
return group
def _render_glyph(self, glyph, position, character, last_character):
"""Render a single glyph.
An SVG XML node tree will be returned, with an svg:g at its root.
Parameters:
glyph -- a Glyph instance
position -- Current position. Will be updated based on the width
of this character and the letter spacing.
character -- the current Unicode character.
last_character -- the previous character in the line, or None if
we're at the start of the line or a word.
"""
node = deepcopy(glyph.node)
if last_character is not None:
position.x += self.letter_spacing + self.kerning_pairs.get(last_character + character, 0) * PIXELS_PER_MM
transform = "translate(%s, %s)" % position.as_tuple()
node.set('transform', transform)
position.x += glyph.width
return node
def _apply_auto_satin(self, group):
"""Apply Auto-Satin to an SVG XML node tree with an svg:g at its root.
The group's contents will be replaced with the results of the auto-
satin operation. Any nested svg:g elements will be removed.
"""
elements = nodes_to_elements(group.iterdescendants(SVG_PATH_TAG))
auto_satin(elements, preserve_order=True)
|
