# Authors: see git history
#
# Copyright (c) 2010 Authors
# Licensed under the GNU GPL version 3.0 or later. See the file LICENSE for details.
import json
import os
from copy import deepcopy
from random import randint
import inkex
from ..commands import add_commands, ensure_symbol
from ..elements import FillStitch, SatinColumn, Stroke, nodes_to_elements
from ..exceptions import InkstitchException
from ..extensions.lettering_custom_font_dir import get_custom_font_dir
from ..i18n import _, get_languages
from ..marker import MARKER, ensure_marker, has_marker
from ..stitches.auto_satin import auto_satin
from ..svg.tags import (CONNECTION_END, CONNECTION_START, EMBROIDERABLE_TAGS,
INKSCAPE_LABEL, SVG_GROUP_TAG, SVG_PATH_TAG,
SVG_USE_TAG, XLINK_HREF)
from ..utils import Point
from .font_variant import FontVariant
class FontError(InkstitchException):
pass
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)
def localized_font_metadata(name, default=None):
def getter(self):
# If the font contains a localized version of the attribute, use it.
for language in get_languages():
attr = "%s_%s" % (name, language)
if attr in self.metadata:
return self.metadata.get(attr)
if name in self.metadata:
# This may be a font packaged with Ink/Stitch, in which case the
# text will have been sent to CrowdIn for community translation.
# Try to fetch the translated version.
original_metadata = self.metadata.get(name)
localized_metadata = ""
if original_metadata != "":
localized_metadata = _(original_metadata)
return localized_metadata
else:
return default
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.metadata = {}
self.license = None
self.variants = {}
self._load_metadata()
self._load_license()
def _load_metadata(self):
try:
with open(os.path.join(self.path, "font.json"), encoding="utf-8-sig") as metadata_file:
self.metadata = json.load(metadata_file)
except IOError:
pass
def _load_license(self):
try:
with open(os.path.join(self.path, "LICENSE"), encoding="utf-8-sig") as license_file:
self.license = license_file.read()
except IOError:
pass
def _load_variants(self):
if not 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 = localized_font_metadata('name', '')
description = localized_font_metadata('description', '')
letter_case = font_metadata('letter_case', '')
default_glyph = font_metadata('default_glyph', "�")
leading = font_metadata('leading', 100)
kerning_pairs = font_metadata('kerning_pairs', {})
auto_satin = font_metadata('auto_satin', True)
min_scale = font_metadata('min_scale', 1.0)
max_scale = font_metadata('max_scale', 1.0)
size = font_metadata('size', 0)
# use values from SVG Font, example:
# ... .... />
# Example font.json : "horiz_adv_x": {"A":49},
horiz_adv_x = font_metadata('horiz_adv_x', {})
# Example font.json : "horiz_adv_x_default" : 45,
horiz_adv_x_default = font_metadata('horiz_adv_x_default')
# Define by , Example font.json : "horiz_adv_x_space":22,
word_spacing = font_metadata('horiz_adv_x_space', 20)
reversible = font_metadata('reversible', True)
@property
def id(self):
return os.path.basename(self.path)
@property
def default_variant(self):
# Set default variant to any existing variant if default font file is missing
default_variant = font_metadata('default_variant', FontVariant.LEFT_TO_RIGHT)
font_variants = self.has_variants()
if default_variant not in font_variants and len(font_variants) > 0:
default_variant = font_variants[0]
return default_variant
@property
def preview_image(self):
preview_image_path = os.path.join(self.path, "preview.png")
if os.path.isfile(preview_image_path):
return preview_image_path
return None
def has_variants(self):
# returns available variants
font_variants = []
for variant in FontVariant.VARIANT_TYPES:
if os.path.isfile(os.path.join(self.path, "%s.svg" % variant)):
font_variants.append(variant)
elif (os.path.isdir(os.path.join(self.path, "%s" % variant)) and
[svg for svg in os.listdir(os.path.join(self.path, "%s" % variant)) if svg.endswith('.svg')]):
font_variants.append(variant)
if not font_variants:
raise FontError(_("The font '%s' has no variants.") % self.name)
return font_variants
@property
def marked_custom_font_id(self):
if not self.is_custom_font():
return self.id
else:
return self.id + '*'
@property
def marked_custom_font_name(self):
if not self.is_custom_font():
return self.name
else:
return self.name + '*'
def is_custom_font(self):
return get_custom_font_dir() in self.path
def render_text(self, text, destination_group, variant=None, back_and_forth=True, trim_option=0):
"""Render text into an SVG group element."""
self._load_variants()
if variant is None:
variant = self.default_variant
if back_and_forth and self.reversible:
glyph_sets = [self.get_variant(variant), self.get_variant(FontVariant.reversed_variant(variant))]
else:
glyph_sets = [self.get_variant(variant)] * 2
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 back_and_forth and self.reversible and i % 2 == 1:
letter_group[:] = reversed(letter_group)
destination_group.append(letter_group)
position.x = 0
position.y += self.leading
if self.auto_satin and len(destination_group) > 0:
self._apply_auto_satin(destination_group)
# make sure font stroke styles have always a similar look
for element in destination_group.iterdescendants(SVG_PATH_TAG):
style = inkex.Style(element.get('style'))
if style.get('fill') == 'none':
style += inkex.Style("stroke-width:1px")
if style.get('stroke-dasharray') and style.get('stroke-dasharray') != 'none':
style += inkex.Style("stroke-dasharray:3, 1")
# Set a smaller width to auto-route running stitches
if self.auto_satin or element.get_id().startswith("autosatinrun"):
style += inkex.Style("stroke-width:0.5px")
element.set('style', '%s' % style.to_str())
# add trims
self._add_trims(destination_group, text, trim_option, back_and_forth)
# make sure necessary marker and command symbols are in the defs section
self._ensure_command_symbols(destination_group)
self._ensure_marker_symbols(destination_group)
return destination_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.Group(attrib={
INKSCAPE_LABEL: line
})
last_character = None
for character in line:
if self.letter_case == "upper":
character = character.upper()
elif self.letter_case == "lower":
character = character.lower()
glyph = glyph_set[character]
if character == " " or (glyph is None and self.default_glyph == " "):
position.x += self.word_spacing
last_character = None
else:
if glyph is None:
glyph = 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.
"""
# Concerning min_x: I add it before moving the letter because it is to
# take into account the margin in the drawing of the letter. With respect
# to point 0 the letter can start at 5 or -5. The letters have a defined
# place in the drawing that's important.
# Then to calculate the position of x for the next letter I have to remove
# the min_x margin because the horizontal adv is calculated from point 0 of the drawing.
node = deepcopy(glyph.node)
if last_character is not None:
position.x += glyph.min_x - self.kerning_pairs.get(last_character + character, 0)
transform = "translate(%s, %s)" % position.as_tuple()
node.set('transform', transform)
horiz_adv_x_default = self.horiz_adv_x_default
if horiz_adv_x_default is None:
horiz_adv_x_default = glyph.width + glyph.min_x
position.x += self.horiz_adv_x.get(character, horiz_adv_x_default) - glyph.min_x
self._update_commands(node, glyph)
# this is used to recognize a glyph layer later in the process
# because this is not unique it will be overwritten by inkscape when inserted into the document
node.set("id", "glyph")
return node
def _update_commands(self, node, glyph):
for element, connectors in glyph.commands.items():
# update element
el = node.find(".//*[@id='%s']" % element)
# we cannot get a unique id from the document at this point
# so let's create a random id which will most probably work as well
new_element_id = "%s_%s" % (element, randint(0, 9999))
el.set_id(new_element_id)
for connector, symbol in connectors:
# update symbol
new_symbol_id = "%s_%s" % (symbol, randint(0, 9999))
s = node.find(".//*[@id='%s']" % symbol)
s.set_id(new_symbol_id)
# update connector
c = node.find(".//*[@id='%s']" % connector)
c.set(CONNECTION_END, "#%s" % new_element_id)
c.set(CONNECTION_START, "#%s" % new_symbol_id)
def _add_trims(self, destination_group, text, trim_option, back_and_forth):
"""
trim_option == 0 --> no trims
trim_option == 1 --> trim at the end of each line
trim_option == 2 --> trim after each word
trim_option == 3 --> trim after each letter
"""
if trim_option == 0:
return
# reverse every second line of text if back and forth is true and strip spaces
text = text.splitlines()
text = [t[::-1].strip() if i % 2 != 0 and back_and_forth else t.strip() for i, t in enumerate(text)]
text = "\n".join(text)
i = -1
space_indices = [i for i, t in enumerate(text) if t == " "]
line_break_indices = [i for i, t in enumerate(text) if t == "\n"]
for group in destination_group.iterdescendants(SVG_GROUP_TAG):
# make sure we are only looking at glyph groups
if group.get("id") != "glyph":
continue
i += 1
while i in space_indices + line_break_indices:
i += 1
# letter
if trim_option == 3:
self._process_trim(group)
# word
elif trim_option == 2 and i+1 in space_indices + line_break_indices:
self._process_trim(group)
# line
elif trim_option == 1 and i+1 in line_break_indices:
self._process_trim(group)
def _process_trim(self, group):
# find the last path that does not carry a marker and add a trim there
for path_child in group.iterdescendants(EMBROIDERABLE_TAGS):
if not has_marker(path_child):
path = path_child
if path.get('style') and "fill" in path.get('style'):
element = FillStitch(path)
else:
element = Stroke(path)
if element.shape:
element_id = "%s_%s" % (element.node.get('id'), randint(0, 9999))
element.node.set("id", element_id)
add_commands(element, ['trim'])
def _ensure_command_symbols(self, group):
# collect commands
commands = set()
for element in group.iterdescendants(SVG_USE_TAG):
xlink = element.get(XLINK_HREF, ' ')
if xlink.startswith('#inkstitch_'):
commands.add(xlink[11:])
# make sure all necessary command symbols are in the document
for command in commands:
ensure_symbol(group.getroottree().getroot(), command)
def _ensure_marker_symbols(self, group):
for marker in MARKER:
xpath = ".//*[contains(@style, 'marker-start:url(#inkstitch-%s-marker')]" % marker
marked_elements = group.xpath(xpath, namespaces=inkex.NSS)
if marked_elements:
ensure_marker(group.getroottree().getroot(), marker)
for element in marked_elements:
element.style['marker-start'] = "url(#inkstitch-%s-marker)" % marker
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))
elements = [element for element in elements if isinstance(element, SatinColumn) or isinstance(element, Stroke)]
if elements:
auto_satin(elements, preserve_order=True, trim=False)