3339 lines
126 KiB
Python
3339 lines
126 KiB
Python
"""
|
|
designSpaceDocument
|
|
|
|
- Read and write designspace files
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import collections
|
|
import copy
|
|
import itertools
|
|
import math
|
|
import os
|
|
import posixpath
|
|
from io import BytesIO, StringIO
|
|
from textwrap import indent
|
|
from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Union, cast
|
|
|
|
from fontTools.misc import etree as ET
|
|
from fontTools.misc import plistlib
|
|
from fontTools.misc.loggingTools import LogMixin
|
|
from fontTools.misc.textTools import tobytes, tostr
|
|
|
|
|
|
__all__ = [
|
|
"AxisDescriptor",
|
|
"AxisLabelDescriptor",
|
|
"AxisMappingDescriptor",
|
|
"BaseDocReader",
|
|
"BaseDocWriter",
|
|
"DesignSpaceDocument",
|
|
"DesignSpaceDocumentError",
|
|
"DiscreteAxisDescriptor",
|
|
"InstanceDescriptor",
|
|
"LocationLabelDescriptor",
|
|
"RangeAxisSubsetDescriptor",
|
|
"RuleDescriptor",
|
|
"SourceDescriptor",
|
|
"ValueAxisSubsetDescriptor",
|
|
"VariableFontDescriptor",
|
|
]
|
|
|
|
# ElementTree allows to find namespace-prefixed elements, but not attributes
|
|
# so we have to do it ourselves for 'xml:lang'
|
|
XML_NS = "{http://www.w3.org/XML/1998/namespace}"
|
|
XML_LANG = XML_NS + "lang"
|
|
|
|
|
|
def posix(path):
|
|
"""Normalize paths using forward slash to work also on Windows."""
|
|
new_path = posixpath.join(*path.split(os.path.sep))
|
|
if path.startswith("/"):
|
|
# The above transformation loses absolute paths
|
|
new_path = "/" + new_path
|
|
elif path.startswith(r"\\"):
|
|
# The above transformation loses leading slashes of UNC path mounts
|
|
new_path = "//" + new_path
|
|
return new_path
|
|
|
|
|
|
def posixpath_property(private_name):
|
|
"""Generate a propery that holds a path always using forward slashes."""
|
|
|
|
def getter(self):
|
|
# Normal getter
|
|
return getattr(self, private_name)
|
|
|
|
def setter(self, value):
|
|
# The setter rewrites paths using forward slashes
|
|
if value is not None:
|
|
value = posix(value)
|
|
setattr(self, private_name, value)
|
|
|
|
return property(getter, setter)
|
|
|
|
|
|
class DesignSpaceDocumentError(Exception):
|
|
def __init__(self, msg, obj=None):
|
|
self.msg = msg
|
|
self.obj = obj
|
|
|
|
def __str__(self):
|
|
return str(self.msg) + (": %r" % self.obj if self.obj is not None else "")
|
|
|
|
|
|
class AsDictMixin(object):
|
|
def asdict(self):
|
|
d = {}
|
|
for attr, value in self.__dict__.items():
|
|
if attr.startswith("_"):
|
|
continue
|
|
if hasattr(value, "asdict"):
|
|
value = value.asdict()
|
|
elif isinstance(value, list):
|
|
value = [v.asdict() if hasattr(v, "asdict") else v for v in value]
|
|
d[attr] = value
|
|
return d
|
|
|
|
|
|
class SimpleDescriptor(AsDictMixin):
|
|
"""Containers for a bunch of attributes"""
|
|
|
|
# XXX this is ugly. The 'print' is inappropriate here, and instead of
|
|
# assert, it should simply return True/False
|
|
def compare(self, other):
|
|
# test if this object contains the same data as the other
|
|
for attr in self._attrs:
|
|
try:
|
|
assert getattr(self, attr) == getattr(other, attr)
|
|
except AssertionError:
|
|
print(
|
|
"failed attribute",
|
|
attr,
|
|
getattr(self, attr),
|
|
"!=",
|
|
getattr(other, attr),
|
|
)
|
|
|
|
def __repr__(self):
|
|
attrs = [f"{a}={repr(getattr(self, a))}," for a in self._attrs]
|
|
attrs = indent("\n".join(attrs), " ")
|
|
return f"{self.__class__.__name__}(\n{attrs}\n)"
|
|
|
|
|
|
class SourceDescriptor(SimpleDescriptor):
|
|
"""Simple container for data related to the source
|
|
|
|
.. code:: python
|
|
|
|
doc = DesignSpaceDocument()
|
|
s1 = SourceDescriptor()
|
|
s1.path = masterPath1
|
|
s1.name = "master.ufo1"
|
|
s1.font = defcon.Font("master.ufo1")
|
|
s1.location = dict(weight=0)
|
|
s1.familyName = "MasterFamilyName"
|
|
s1.styleName = "MasterStyleNameOne"
|
|
s1.localisedFamilyName = dict(fr="Caractère")
|
|
s1.mutedGlyphNames.append("A")
|
|
s1.mutedGlyphNames.append("Z")
|
|
doc.addSource(s1)
|
|
|
|
"""
|
|
|
|
flavor = "source"
|
|
_attrs = [
|
|
"filename",
|
|
"path",
|
|
"name",
|
|
"layerName",
|
|
"location",
|
|
"copyLib",
|
|
"copyGroups",
|
|
"copyFeatures",
|
|
"muteKerning",
|
|
"muteInfo",
|
|
"mutedGlyphNames",
|
|
"familyName",
|
|
"styleName",
|
|
"localisedFamilyName",
|
|
]
|
|
|
|
filename = posixpath_property("_filename")
|
|
path = posixpath_property("_path")
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
filename=None,
|
|
path=None,
|
|
font=None,
|
|
name=None,
|
|
location=None,
|
|
designLocation=None,
|
|
layerName=None,
|
|
familyName=None,
|
|
styleName=None,
|
|
localisedFamilyName=None,
|
|
copyLib=False,
|
|
copyInfo=False,
|
|
copyGroups=False,
|
|
copyFeatures=False,
|
|
muteKerning=False,
|
|
muteInfo=False,
|
|
mutedGlyphNames=None,
|
|
):
|
|
self.filename = filename
|
|
"""string. A relative path to the source file, **as it is in the document**.
|
|
|
|
MutatorMath + VarLib.
|
|
"""
|
|
self.path = path
|
|
"""The absolute path, calculated from filename."""
|
|
|
|
self.font = font
|
|
"""Any Python object. Optional. Points to a representation of this
|
|
source font that is loaded in memory, as a Python object (e.g. a
|
|
``defcon.Font`` or a ``fontTools.ttFont.TTFont``).
|
|
|
|
The default document reader will not fill-in this attribute, and the
|
|
default writer will not use this attribute. It is up to the user of
|
|
``designspaceLib`` to either load the resource identified by
|
|
``filename`` and store it in this field, or write the contents of
|
|
this field to the disk and make ```filename`` point to that.
|
|
"""
|
|
|
|
self.name = name
|
|
"""string. Optional. Unique identifier name for this source.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
|
|
self.designLocation = (
|
|
designLocation if designLocation is not None else location or {}
|
|
)
|
|
"""dict. Axis values for this source, in design space coordinates.
|
|
|
|
MutatorMath + varLib.
|
|
|
|
This may be only part of the full design location.
|
|
See :meth:`getFullDesignLocation()`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
self.layerName = layerName
|
|
"""string. The name of the layer in the source to look for
|
|
outline data. Default ``None`` which means ``foreground``.
|
|
"""
|
|
self.familyName = familyName
|
|
"""string. Family name of this source. Though this data
|
|
can be extracted from the font, it can be efficient to have it right
|
|
here.
|
|
|
|
varLib.
|
|
"""
|
|
self.styleName = styleName
|
|
"""string. Style name of this source. Though this data
|
|
can be extracted from the font, it can be efficient to have it right
|
|
here.
|
|
|
|
varLib.
|
|
"""
|
|
self.localisedFamilyName = localisedFamilyName or {}
|
|
"""dict. A dictionary of localised family name strings, keyed by
|
|
language code.
|
|
|
|
If present, will be used to build localized names for all instances.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
self.copyLib = copyLib
|
|
"""bool. Indicates if the contents of the font.lib need to
|
|
be copied to the instances.
|
|
|
|
MutatorMath.
|
|
|
|
.. deprecated:: 5.0
|
|
"""
|
|
self.copyInfo = copyInfo
|
|
"""bool. Indicates if the non-interpolating font.info needs
|
|
to be copied to the instances.
|
|
|
|
MutatorMath.
|
|
|
|
.. deprecated:: 5.0
|
|
"""
|
|
self.copyGroups = copyGroups
|
|
"""bool. Indicates if the groups need to be copied to the
|
|
instances.
|
|
|
|
MutatorMath.
|
|
|
|
.. deprecated:: 5.0
|
|
"""
|
|
self.copyFeatures = copyFeatures
|
|
"""bool. Indicates if the feature text needs to be
|
|
copied to the instances.
|
|
|
|
MutatorMath.
|
|
|
|
.. deprecated:: 5.0
|
|
"""
|
|
self.muteKerning = muteKerning
|
|
"""bool. Indicates if the kerning data from this source
|
|
needs to be muted (i.e. not be part of the calculations).
|
|
|
|
MutatorMath only.
|
|
"""
|
|
self.muteInfo = muteInfo
|
|
"""bool. Indicated if the interpolating font.info data for
|
|
this source needs to be muted.
|
|
|
|
MutatorMath only.
|
|
"""
|
|
self.mutedGlyphNames = mutedGlyphNames or []
|
|
"""list. Glyphnames that need to be muted in the
|
|
instances.
|
|
|
|
MutatorMath only.
|
|
"""
|
|
|
|
@property
|
|
def location(self):
|
|
"""dict. Axis values for this source, in design space coordinates.
|
|
|
|
MutatorMath + varLib.
|
|
|
|
.. deprecated:: 5.0
|
|
Use the more explicit alias for this property :attr:`designLocation`.
|
|
"""
|
|
return self.designLocation
|
|
|
|
@location.setter
|
|
def location(self, location: Optional[SimpleLocationDict]):
|
|
self.designLocation = location or {}
|
|
|
|
def setFamilyName(self, familyName, languageCode="en"):
|
|
"""Setter for :attr:`localisedFamilyName`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.localisedFamilyName[languageCode] = tostr(familyName)
|
|
|
|
def getFamilyName(self, languageCode="en"):
|
|
"""Getter for :attr:`localisedFamilyName`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return self.localisedFamilyName.get(languageCode)
|
|
|
|
def getFullDesignLocation(self, doc: "DesignSpaceDocument") -> SimpleLocationDict:
|
|
"""Get the complete design location of this source, from its
|
|
:attr:`designLocation` and the document's axis defaults.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
result: SimpleLocationDict = {}
|
|
for axis in doc.axes:
|
|
if axis.name in self.designLocation:
|
|
result[axis.name] = self.designLocation[axis.name]
|
|
else:
|
|
result[axis.name] = axis.map_forward(axis.default)
|
|
return result
|
|
|
|
|
|
class RuleDescriptor(SimpleDescriptor):
|
|
"""Represents the rule descriptor element: a set of glyph substitutions to
|
|
trigger conditionally in some parts of the designspace.
|
|
|
|
.. code:: python
|
|
|
|
r1 = RuleDescriptor()
|
|
r1.name = "unique.rule.name"
|
|
r1.conditionSets.append([dict(name="weight", minimum=-10, maximum=10), dict(...)])
|
|
r1.conditionSets.append([dict(...), dict(...)])
|
|
r1.subs.append(("a", "a.alt"))
|
|
|
|
.. code:: xml
|
|
|
|
<!-- optional: list of substitution rules -->
|
|
<rules>
|
|
<rule name="vertical.bars">
|
|
<conditionset>
|
|
<condition minimum="250.000000" maximum="750.000000" name="weight"/>
|
|
<condition minimum="100" name="width"/>
|
|
<condition minimum="10" maximum="40" name="optical"/>
|
|
</conditionset>
|
|
<sub name="cent" with="cent.alt"/>
|
|
<sub name="dollar" with="dollar.alt"/>
|
|
</rule>
|
|
</rules>
|
|
"""
|
|
|
|
_attrs = ["name", "conditionSets", "subs"] # what do we need here
|
|
|
|
def __init__(self, *, name=None, conditionSets=None, subs=None):
|
|
self.name = name
|
|
"""string. Unique name for this rule. Can be used to reference this rule data."""
|
|
# list of lists of dict(name='aaaa', minimum=0, maximum=1000)
|
|
self.conditionSets = conditionSets or []
|
|
"""a list of conditionsets.
|
|
|
|
- Each conditionset is a list of conditions.
|
|
- Each condition is a dict with ``name``, ``minimum`` and ``maximum`` keys.
|
|
"""
|
|
# list of substitutions stored as tuples of glyphnames ("a", "a.alt")
|
|
self.subs = subs or []
|
|
"""list of substitutions.
|
|
|
|
- Each substitution is stored as tuples of glyphnames, e.g. ("a", "a.alt").
|
|
- Note: By default, rules are applied first, before other text
|
|
shaping/OpenType layout, as they are part of the
|
|
`Required Variation Alternates OpenType feature <https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#-tag-rvrn>`_.
|
|
See ref:`rules-element` § Attributes.
|
|
"""
|
|
|
|
|
|
def evaluateRule(rule, location):
|
|
"""Return True if any of the rule's conditionsets matches the given location."""
|
|
return any(evaluateConditions(c, location) for c in rule.conditionSets)
|
|
|
|
|
|
def evaluateConditions(conditions, location):
|
|
"""Return True if all the conditions matches the given location.
|
|
|
|
- If a condition has no minimum, check for < maximum.
|
|
- If a condition has no maximum, check for > minimum.
|
|
"""
|
|
for cd in conditions:
|
|
value = location[cd["name"]]
|
|
if cd.get("minimum") is None:
|
|
if value > cd["maximum"]:
|
|
return False
|
|
elif cd.get("maximum") is None:
|
|
if cd["minimum"] > value:
|
|
return False
|
|
elif not cd["minimum"] <= value <= cd["maximum"]:
|
|
return False
|
|
return True
|
|
|
|
|
|
def processRules(rules, location, glyphNames):
|
|
"""Apply these rules at this location to these glyphnames.
|
|
|
|
Return a new list of glyphNames with substitutions applied.
|
|
|
|
- rule order matters
|
|
"""
|
|
newNames = []
|
|
for rule in rules:
|
|
if evaluateRule(rule, location):
|
|
for name in glyphNames:
|
|
swap = False
|
|
for a, b in rule.subs:
|
|
if name == a:
|
|
swap = True
|
|
break
|
|
if swap:
|
|
newNames.append(b)
|
|
else:
|
|
newNames.append(name)
|
|
glyphNames = newNames
|
|
newNames = []
|
|
return glyphNames
|
|
|
|
|
|
AnisotropicLocationDict = Dict[str, Union[float, Tuple[float, float]]]
|
|
SimpleLocationDict = Dict[str, float]
|
|
|
|
|
|
class AxisMappingDescriptor(SimpleDescriptor):
|
|
"""Represents the axis mapping element: mapping an input location
|
|
to an output location in the designspace.
|
|
|
|
.. code:: python
|
|
|
|
m1 = AxisMappingDescriptor()
|
|
m1.inputLocation = {"weight": 900, "width": 150}
|
|
m1.outputLocation = {"weight": 870}
|
|
|
|
.. code:: xml
|
|
|
|
<mappings>
|
|
<mapping>
|
|
<input>
|
|
<dimension name="weight" xvalue="900"/>
|
|
<dimension name="width" xvalue="150"/>
|
|
</input>
|
|
<output>
|
|
<dimension name="weight" xvalue="870"/>
|
|
</output>
|
|
</mapping>
|
|
</mappings>
|
|
"""
|
|
|
|
_attrs = ["inputLocation", "outputLocation"]
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
inputLocation=None,
|
|
outputLocation=None,
|
|
description=None,
|
|
groupDescription=None,
|
|
):
|
|
self.inputLocation: SimpleLocationDict = inputLocation or {}
|
|
"""dict. Axis values for the input of the mapping, in design space coordinates.
|
|
|
|
varLib.
|
|
|
|
.. versionadded:: 5.1
|
|
"""
|
|
self.outputLocation: SimpleLocationDict = outputLocation or {}
|
|
"""dict. Axis values for the output of the mapping, in design space coordinates.
|
|
|
|
varLib.
|
|
|
|
.. versionadded:: 5.1
|
|
"""
|
|
self.description = description
|
|
"""string. A description of the mapping.
|
|
|
|
varLib.
|
|
|
|
.. versionadded:: 5.2
|
|
"""
|
|
self.groupDescription = groupDescription
|
|
"""string. A description of the group of mappings.
|
|
|
|
varLib.
|
|
|
|
.. versionadded:: 5.2
|
|
"""
|
|
|
|
|
|
class InstanceDescriptor(SimpleDescriptor):
|
|
"""Simple container for data related to the instance
|
|
|
|
|
|
.. code:: python
|
|
|
|
i2 = InstanceDescriptor()
|
|
i2.path = instancePath2
|
|
i2.familyName = "InstanceFamilyName"
|
|
i2.styleName = "InstanceStyleName"
|
|
i2.name = "instance.ufo2"
|
|
# anisotropic location
|
|
i2.designLocation = dict(weight=500, width=(400,300))
|
|
i2.postScriptFontName = "InstancePostscriptName"
|
|
i2.styleMapFamilyName = "InstanceStyleMapFamilyName"
|
|
i2.styleMapStyleName = "InstanceStyleMapStyleName"
|
|
i2.lib['com.coolDesignspaceApp.specimenText'] = 'Hamburgerwhatever'
|
|
doc.addInstance(i2)
|
|
"""
|
|
|
|
flavor = "instance"
|
|
_defaultLanguageCode = "en"
|
|
_attrs = [
|
|
"filename",
|
|
"path",
|
|
"name",
|
|
"locationLabel",
|
|
"designLocation",
|
|
"userLocation",
|
|
"familyName",
|
|
"styleName",
|
|
"postScriptFontName",
|
|
"styleMapFamilyName",
|
|
"styleMapStyleName",
|
|
"localisedFamilyName",
|
|
"localisedStyleName",
|
|
"localisedStyleMapFamilyName",
|
|
"localisedStyleMapStyleName",
|
|
"glyphs",
|
|
"kerning",
|
|
"info",
|
|
"lib",
|
|
]
|
|
|
|
filename = posixpath_property("_filename")
|
|
path = posixpath_property("_path")
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
filename=None,
|
|
path=None,
|
|
font=None,
|
|
name=None,
|
|
location=None,
|
|
locationLabel=None,
|
|
designLocation=None,
|
|
userLocation=None,
|
|
familyName=None,
|
|
styleName=None,
|
|
postScriptFontName=None,
|
|
styleMapFamilyName=None,
|
|
styleMapStyleName=None,
|
|
localisedFamilyName=None,
|
|
localisedStyleName=None,
|
|
localisedStyleMapFamilyName=None,
|
|
localisedStyleMapStyleName=None,
|
|
glyphs=None,
|
|
kerning=True,
|
|
info=True,
|
|
lib=None,
|
|
):
|
|
self.filename = filename
|
|
"""string. Relative path to the instance file, **as it is
|
|
in the document**. The file may or may not exist.
|
|
|
|
MutatorMath + VarLib.
|
|
"""
|
|
self.path = path
|
|
"""string. Absolute path to the instance file, calculated from
|
|
the document path and the string in the filename attr. The file may
|
|
or may not exist.
|
|
|
|
MutatorMath.
|
|
"""
|
|
self.font = font
|
|
"""Same as :attr:`SourceDescriptor.font`
|
|
|
|
.. seealso:: :attr:`SourceDescriptor.font`
|
|
"""
|
|
self.name = name
|
|
"""string. Unique identifier name of the instance, used to
|
|
identify it if it needs to be referenced from elsewhere in the
|
|
document.
|
|
"""
|
|
self.locationLabel = locationLabel
|
|
"""Name of a :class:`LocationLabelDescriptor`. If
|
|
provided, the instance should have the same location as the
|
|
LocationLabel.
|
|
|
|
.. seealso::
|
|
:meth:`getFullDesignLocation`
|
|
:meth:`getFullUserLocation`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.designLocation: AnisotropicLocationDict = (
|
|
designLocation if designLocation is not None else (location or {})
|
|
)
|
|
"""dict. Axis values for this instance, in design space coordinates.
|
|
|
|
MutatorMath + varLib.
|
|
|
|
.. seealso:: This may be only part of the full location. See:
|
|
:meth:`getFullDesignLocation`
|
|
:meth:`getFullUserLocation`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.userLocation: SimpleLocationDict = userLocation or {}
|
|
"""dict. Axis values for this instance, in user space coordinates.
|
|
|
|
MutatorMath + varLib.
|
|
|
|
.. seealso:: This may be only part of the full location. See:
|
|
:meth:`getFullDesignLocation`
|
|
:meth:`getFullUserLocation`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.familyName = familyName
|
|
"""string. Family name of this instance.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.styleName = styleName
|
|
"""string. Style name of this instance.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.postScriptFontName = postScriptFontName
|
|
"""string. Postscript fontname for this instance.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.styleMapFamilyName = styleMapFamilyName
|
|
"""string. StyleMap familyname for this instance.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.styleMapStyleName = styleMapStyleName
|
|
"""string. StyleMap stylename for this instance.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.localisedFamilyName = localisedFamilyName or {}
|
|
"""dict. A dictionary of localised family name
|
|
strings, keyed by language code.
|
|
"""
|
|
self.localisedStyleName = localisedStyleName or {}
|
|
"""dict. A dictionary of localised stylename
|
|
strings, keyed by language code.
|
|
"""
|
|
self.localisedStyleMapFamilyName = localisedStyleMapFamilyName or {}
|
|
"""A dictionary of localised style map
|
|
familyname strings, keyed by language code.
|
|
"""
|
|
self.localisedStyleMapStyleName = localisedStyleMapStyleName or {}
|
|
"""A dictionary of localised style map
|
|
stylename strings, keyed by language code.
|
|
"""
|
|
self.glyphs = glyphs or {}
|
|
"""dict for special master definitions for glyphs. If glyphs
|
|
need special masters (to record the results of executed rules for
|
|
example).
|
|
|
|
MutatorMath.
|
|
|
|
.. deprecated:: 5.0
|
|
Use rules or sparse sources instead.
|
|
"""
|
|
self.kerning = kerning
|
|
""" bool. Indicates if this instance needs its kerning
|
|
calculated.
|
|
|
|
MutatorMath.
|
|
|
|
.. deprecated:: 5.0
|
|
"""
|
|
self.info = info
|
|
"""bool. Indicated if this instance needs the interpolating
|
|
font.info calculated.
|
|
|
|
.. deprecated:: 5.0
|
|
"""
|
|
|
|
self.lib = lib or {}
|
|
"""Custom data associated with this instance."""
|
|
|
|
@property
|
|
def location(self):
|
|
"""dict. Axis values for this instance.
|
|
|
|
MutatorMath + varLib.
|
|
|
|
.. deprecated:: 5.0
|
|
Use the more explicit alias for this property :attr:`designLocation`.
|
|
"""
|
|
return self.designLocation
|
|
|
|
@location.setter
|
|
def location(self, location: Optional[AnisotropicLocationDict]):
|
|
self.designLocation = location or {}
|
|
|
|
def setStyleName(self, styleName, languageCode="en"):
|
|
"""These methods give easier access to the localised names."""
|
|
self.localisedStyleName[languageCode] = tostr(styleName)
|
|
|
|
def getStyleName(self, languageCode="en"):
|
|
return self.localisedStyleName.get(languageCode)
|
|
|
|
def setFamilyName(self, familyName, languageCode="en"):
|
|
self.localisedFamilyName[languageCode] = tostr(familyName)
|
|
|
|
def getFamilyName(self, languageCode="en"):
|
|
return self.localisedFamilyName.get(languageCode)
|
|
|
|
def setStyleMapStyleName(self, styleMapStyleName, languageCode="en"):
|
|
self.localisedStyleMapStyleName[languageCode] = tostr(styleMapStyleName)
|
|
|
|
def getStyleMapStyleName(self, languageCode="en"):
|
|
return self.localisedStyleMapStyleName.get(languageCode)
|
|
|
|
def setStyleMapFamilyName(self, styleMapFamilyName, languageCode="en"):
|
|
self.localisedStyleMapFamilyName[languageCode] = tostr(styleMapFamilyName)
|
|
|
|
def getStyleMapFamilyName(self, languageCode="en"):
|
|
return self.localisedStyleMapFamilyName.get(languageCode)
|
|
|
|
def clearLocation(self, axisName: Optional[str] = None):
|
|
"""Clear all location-related fields. Ensures that
|
|
:attr:``designLocation`` and :attr:``userLocation`` are dictionaries
|
|
(possibly empty if clearing everything).
|
|
|
|
In order to update the location of this instance wholesale, a user
|
|
should first clear all the fields, then change the field(s) for which
|
|
they have data.
|
|
|
|
.. code:: python
|
|
|
|
instance.clearLocation()
|
|
instance.designLocation = {'Weight': (34, 36.5), 'Width': 100}
|
|
instance.userLocation = {'Opsz': 16}
|
|
|
|
In order to update a single axis location, the user should only clear
|
|
that axis, then edit the values:
|
|
|
|
.. code:: python
|
|
|
|
instance.clearLocation('Weight')
|
|
instance.designLocation['Weight'] = (34, 36.5)
|
|
|
|
Args:
|
|
axisName: if provided, only clear the location for that axis.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.locationLabel = None
|
|
if axisName is None:
|
|
self.designLocation = {}
|
|
self.userLocation = {}
|
|
else:
|
|
if self.designLocation is None:
|
|
self.designLocation = {}
|
|
if axisName in self.designLocation:
|
|
del self.designLocation[axisName]
|
|
if self.userLocation is None:
|
|
self.userLocation = {}
|
|
if axisName in self.userLocation:
|
|
del self.userLocation[axisName]
|
|
|
|
def getLocationLabelDescriptor(
|
|
self, doc: "DesignSpaceDocument"
|
|
) -> Optional[LocationLabelDescriptor]:
|
|
"""Get the :class:`LocationLabelDescriptor` instance that matches
|
|
this instances's :attr:`locationLabel`.
|
|
|
|
Raises if the named label can't be found.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
if self.locationLabel is None:
|
|
return None
|
|
label = doc.getLocationLabel(self.locationLabel)
|
|
if label is None:
|
|
raise DesignSpaceDocumentError(
|
|
"InstanceDescriptor.getLocationLabelDescriptor(): "
|
|
f"unknown location label `{self.locationLabel}` in instance `{self.name}`."
|
|
)
|
|
return label
|
|
|
|
def getFullDesignLocation(
|
|
self, doc: "DesignSpaceDocument"
|
|
) -> AnisotropicLocationDict:
|
|
"""Get the complete design location of this instance, by combining data
|
|
from the various location fields, default axis values and mappings, and
|
|
top-level location labels.
|
|
|
|
The source of truth for this instance's location is determined for each
|
|
axis independently by taking the first not-None field in this list:
|
|
|
|
- ``locationLabel``: the location along this axis is the same as the
|
|
matching STAT format 4 label. No anisotropy.
|
|
- ``designLocation[axisName]``: the explicit design location along this
|
|
axis, possibly anisotropic.
|
|
- ``userLocation[axisName]``: the explicit user location along this
|
|
axis. No anisotropy.
|
|
- ``axis.default``: default axis value. No anisotropy.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
label = self.getLocationLabelDescriptor(doc)
|
|
if label is not None:
|
|
return doc.map_forward(label.userLocation) # type: ignore
|
|
result: AnisotropicLocationDict = {}
|
|
for axis in doc.axes:
|
|
if axis.name in self.designLocation:
|
|
result[axis.name] = self.designLocation[axis.name]
|
|
elif axis.name in self.userLocation:
|
|
result[axis.name] = axis.map_forward(self.userLocation[axis.name])
|
|
else:
|
|
result[axis.name] = axis.map_forward(axis.default)
|
|
return result
|
|
|
|
def getFullUserLocation(self, doc: "DesignSpaceDocument") -> SimpleLocationDict:
|
|
"""Get the complete user location for this instance.
|
|
|
|
.. seealso:: :meth:`getFullDesignLocation`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return doc.map_backward(self.getFullDesignLocation(doc))
|
|
|
|
|
|
def tagForAxisName(name):
|
|
# try to find or make a tag name for this axis name
|
|
names = {
|
|
"weight": ("wght", dict(en="Weight")),
|
|
"width": ("wdth", dict(en="Width")),
|
|
"optical": ("opsz", dict(en="Optical Size")),
|
|
"slant": ("slnt", dict(en="Slant")),
|
|
"italic": ("ital", dict(en="Italic")),
|
|
}
|
|
if name.lower() in names:
|
|
return names[name.lower()]
|
|
if len(name) < 4:
|
|
tag = name + "*" * (4 - len(name))
|
|
else:
|
|
tag = name[:4]
|
|
return tag, dict(en=name)
|
|
|
|
|
|
class AbstractAxisDescriptor(SimpleDescriptor):
|
|
flavor = "axis"
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag=None,
|
|
name=None,
|
|
labelNames=None,
|
|
hidden=False,
|
|
map=None,
|
|
axisOrdering=None,
|
|
axisLabels=None,
|
|
):
|
|
# opentype tag for this axis
|
|
self.tag = tag
|
|
"""string. Four letter tag for this axis. Some might be
|
|
registered at the `OpenType
|
|
specification <https://www.microsoft.com/typography/otspec/fvar.htm#VAT>`__.
|
|
Privately-defined axis tags must begin with an uppercase letter and
|
|
use only uppercase letters or digits.
|
|
"""
|
|
# name of the axis used in locations
|
|
self.name = name
|
|
"""string. Name of the axis as it is used in the location dicts.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
# names for UI purposes, if this is not a standard axis,
|
|
self.labelNames = labelNames or {}
|
|
"""dict. When defining a non-registered axis, it will be
|
|
necessary to define user-facing readable names for the axis. Keyed by
|
|
xml:lang code. Values are required to be ``unicode`` strings, even if
|
|
they only contain ASCII characters.
|
|
"""
|
|
self.hidden = hidden
|
|
"""bool. Whether this axis should be hidden in user interfaces.
|
|
"""
|
|
self.map = map or []
|
|
"""list of input / output values that can describe a warp of user space
|
|
to design space coordinates. If no map values are present, it is assumed
|
|
user space is the same as design space, as in [(minimum, minimum),
|
|
(maximum, maximum)].
|
|
|
|
varLib.
|
|
"""
|
|
self.axisOrdering = axisOrdering
|
|
"""STAT table field ``axisOrdering``.
|
|
|
|
See: `OTSpec STAT Axis Record <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#axis-records>`_
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.axisLabels: List[AxisLabelDescriptor] = axisLabels or []
|
|
"""STAT table entries for Axis Value Tables format 1, 2, 3.
|
|
|
|
See: `OTSpec STAT Axis Value Tables <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-tables>`_
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
|
|
class AxisDescriptor(AbstractAxisDescriptor):
|
|
"""Simple container for the axis data.
|
|
|
|
Add more localisations?
|
|
|
|
.. code:: python
|
|
|
|
a1 = AxisDescriptor()
|
|
a1.minimum = 1
|
|
a1.maximum = 1000
|
|
a1.default = 400
|
|
a1.name = "weight"
|
|
a1.tag = "wght"
|
|
a1.labelNames['fa-IR'] = "قطر"
|
|
a1.labelNames['en'] = "Wéíght"
|
|
a1.map = [(1.0, 10.0), (400.0, 66.0), (1000.0, 990.0)]
|
|
a1.axisOrdering = 1
|
|
a1.axisLabels = [
|
|
AxisLabelDescriptor(name="Regular", userValue=400, elidable=True)
|
|
]
|
|
doc.addAxis(a1)
|
|
"""
|
|
|
|
_attrs = [
|
|
"tag",
|
|
"name",
|
|
"maximum",
|
|
"minimum",
|
|
"default",
|
|
"map",
|
|
"axisOrdering",
|
|
"axisLabels",
|
|
]
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag=None,
|
|
name=None,
|
|
labelNames=None,
|
|
minimum=None,
|
|
default=None,
|
|
maximum=None,
|
|
hidden=False,
|
|
map=None,
|
|
axisOrdering=None,
|
|
axisLabels=None,
|
|
):
|
|
super().__init__(
|
|
tag=tag,
|
|
name=name,
|
|
labelNames=labelNames,
|
|
hidden=hidden,
|
|
map=map,
|
|
axisOrdering=axisOrdering,
|
|
axisLabels=axisLabels,
|
|
)
|
|
self.minimum = minimum
|
|
"""number. The minimum value for this axis in user space.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.maximum = maximum
|
|
"""number. The maximum value for this axis in user space.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
self.default = default
|
|
"""number. The default value for this axis, i.e. when a new location is
|
|
created, this is the value this axis will get in user space.
|
|
|
|
MutatorMath + varLib.
|
|
"""
|
|
|
|
def serialize(self):
|
|
# output to a dict, used in testing
|
|
return dict(
|
|
tag=self.tag,
|
|
name=self.name,
|
|
labelNames=self.labelNames,
|
|
maximum=self.maximum,
|
|
minimum=self.minimum,
|
|
default=self.default,
|
|
hidden=self.hidden,
|
|
map=self.map,
|
|
axisOrdering=self.axisOrdering,
|
|
axisLabels=self.axisLabels,
|
|
)
|
|
|
|
def map_forward(self, v):
|
|
"""Maps value from axis mapping's input (user) to output (design)."""
|
|
from fontTools.varLib.models import piecewiseLinearMap
|
|
|
|
if not self.map:
|
|
return v
|
|
return piecewiseLinearMap(v, {k: v for k, v in self.map})
|
|
|
|
def map_backward(self, v):
|
|
"""Maps value from axis mapping's output (design) to input (user)."""
|
|
from fontTools.varLib.models import piecewiseLinearMap
|
|
|
|
if isinstance(v, tuple):
|
|
v = v[0]
|
|
if not self.map:
|
|
return v
|
|
return piecewiseLinearMap(v, {v: k for k, v in self.map})
|
|
|
|
|
|
class DiscreteAxisDescriptor(AbstractAxisDescriptor):
|
|
"""Container for discrete axis data.
|
|
|
|
Use this for axes that do not interpolate. The main difference from a
|
|
continuous axis is that a continuous axis has a ``minimum`` and ``maximum``,
|
|
while a discrete axis has a list of ``values``.
|
|
|
|
Example: an Italic axis with 2 stops, Roman and Italic, that are not
|
|
compatible. The axis still allows to bind together the full font family,
|
|
which is useful for the STAT table, however it can't become a variation
|
|
axis in a VF.
|
|
|
|
.. code:: python
|
|
|
|
a2 = DiscreteAxisDescriptor()
|
|
a2.values = [0, 1]
|
|
a2.default = 0
|
|
a2.name = "Italic"
|
|
a2.tag = "ITAL"
|
|
a2.labelNames['fr'] = "Italique"
|
|
a2.map = [(0, 0), (1, -11)]
|
|
a2.axisOrdering = 2
|
|
a2.axisLabels = [
|
|
AxisLabelDescriptor(name="Roman", userValue=0, elidable=True)
|
|
]
|
|
doc.addAxis(a2)
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
flavor = "axis"
|
|
_attrs = ("tag", "name", "values", "default", "map", "axisOrdering", "axisLabels")
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag=None,
|
|
name=None,
|
|
labelNames=None,
|
|
values=None,
|
|
default=None,
|
|
hidden=False,
|
|
map=None,
|
|
axisOrdering=None,
|
|
axisLabels=None,
|
|
):
|
|
super().__init__(
|
|
tag=tag,
|
|
name=name,
|
|
labelNames=labelNames,
|
|
hidden=hidden,
|
|
map=map,
|
|
axisOrdering=axisOrdering,
|
|
axisLabels=axisLabels,
|
|
)
|
|
self.default: float = default
|
|
"""The default value for this axis, i.e. when a new location is
|
|
created, this is the value this axis will get in user space.
|
|
|
|
However, this default value is less important than in continuous axes:
|
|
|
|
- it doesn't define the "neutral" version of outlines from which
|
|
deltas would apply, as this axis does not interpolate.
|
|
- it doesn't provide the reference glyph set for the designspace, as
|
|
fonts at each value can have different glyph sets.
|
|
"""
|
|
self.values: List[float] = values or []
|
|
"""List of possible values for this axis. Contrary to continuous axes,
|
|
only the values in this list can be taken by the axis, nothing in-between.
|
|
"""
|
|
|
|
def map_forward(self, value):
|
|
"""Maps value from axis mapping's input to output.
|
|
|
|
Returns value unchanged if no mapping entry is found.
|
|
|
|
Note: for discrete axes, each value must have its mapping entry, if
|
|
you intend that value to be mapped.
|
|
"""
|
|
return next((v for k, v in self.map if k == value), value)
|
|
|
|
def map_backward(self, value):
|
|
"""Maps value from axis mapping's output to input.
|
|
|
|
Returns value unchanged if no mapping entry is found.
|
|
|
|
Note: for discrete axes, each value must have its mapping entry, if
|
|
you intend that value to be mapped.
|
|
"""
|
|
if isinstance(value, tuple):
|
|
value = value[0]
|
|
return next((k for k, v in self.map if v == value), value)
|
|
|
|
|
|
class AxisLabelDescriptor(SimpleDescriptor):
|
|
"""Container for axis label data.
|
|
|
|
Analogue of OpenType's STAT data for a single axis (formats 1, 2 and 3).
|
|
All values are user values.
|
|
See: `OTSpec STAT Axis value table, format 1, 2, 3 <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-1>`_
|
|
|
|
The STAT format of the Axis value depends on which field are filled-in,
|
|
see :meth:`getFormat`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
flavor = "label"
|
|
_attrs = (
|
|
"userMinimum",
|
|
"userValue",
|
|
"userMaximum",
|
|
"name",
|
|
"elidable",
|
|
"olderSibling",
|
|
"linkedUserValue",
|
|
"labelNames",
|
|
)
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
name,
|
|
userValue,
|
|
userMinimum=None,
|
|
userMaximum=None,
|
|
elidable=False,
|
|
olderSibling=False,
|
|
linkedUserValue=None,
|
|
labelNames=None,
|
|
):
|
|
self.userMinimum: Optional[float] = userMinimum
|
|
"""STAT field ``rangeMinValue`` (format 2)."""
|
|
self.userValue: float = userValue
|
|
"""STAT field ``value`` (format 1, 3) or ``nominalValue`` (format 2)."""
|
|
self.userMaximum: Optional[float] = userMaximum
|
|
"""STAT field ``rangeMaxValue`` (format 2)."""
|
|
self.name: str = name
|
|
"""Label for this axis location, STAT field ``valueNameID``."""
|
|
self.elidable: bool = elidable
|
|
"""STAT flag ``ELIDABLE_AXIS_VALUE_NAME``.
|
|
|
|
See: `OTSpec STAT Flags <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#flags>`_
|
|
"""
|
|
self.olderSibling: bool = olderSibling
|
|
"""STAT flag ``OLDER_SIBLING_FONT_ATTRIBUTE``.
|
|
|
|
See: `OTSpec STAT Flags <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#flags>`_
|
|
"""
|
|
self.linkedUserValue: Optional[float] = linkedUserValue
|
|
"""STAT field ``linkedValue`` (format 3)."""
|
|
self.labelNames: MutableMapping[str, str] = labelNames or {}
|
|
"""User-facing translations of this location's label. Keyed by
|
|
``xml:lang`` code.
|
|
"""
|
|
|
|
def getFormat(self) -> int:
|
|
"""Determine which format of STAT Axis value to use to encode this label.
|
|
|
|
=========== ========= =========== =========== ===============
|
|
STAT Format userValue userMinimum userMaximum linkedUserValue
|
|
=========== ========= =========== =========== ===============
|
|
1 ✅ ❌ ❌ ❌
|
|
2 ✅ ✅ ✅ ❌
|
|
3 ✅ ❌ ❌ ✅
|
|
=========== ========= =========== =========== ===============
|
|
"""
|
|
if self.linkedUserValue is not None:
|
|
return 3
|
|
if self.userMinimum is not None or self.userMaximum is not None:
|
|
return 2
|
|
return 1
|
|
|
|
@property
|
|
def defaultName(self) -> str:
|
|
"""Return the English name from :attr:`labelNames` or the :attr:`name`."""
|
|
return self.labelNames.get("en") or self.name
|
|
|
|
|
|
class LocationLabelDescriptor(SimpleDescriptor):
|
|
"""Container for location label data.
|
|
|
|
Analogue of OpenType's STAT data for a free-floating location (format 4).
|
|
All values are user values.
|
|
|
|
See: `OTSpec STAT Axis value table, format 4 <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#axis-value-table-format-4>`_
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
flavor = "label"
|
|
_attrs = ("name", "elidable", "olderSibling", "userLocation", "labelNames")
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
name,
|
|
userLocation,
|
|
elidable=False,
|
|
olderSibling=False,
|
|
labelNames=None,
|
|
):
|
|
self.name: str = name
|
|
"""Label for this named location, STAT field ``valueNameID``."""
|
|
self.userLocation: SimpleLocationDict = userLocation or {}
|
|
"""Location in user coordinates along each axis.
|
|
|
|
If an axis is not mentioned, it is assumed to be at its default location.
|
|
|
|
.. seealso:: This may be only part of the full location. See:
|
|
:meth:`getFullUserLocation`
|
|
"""
|
|
self.elidable: bool = elidable
|
|
"""STAT flag ``ELIDABLE_AXIS_VALUE_NAME``.
|
|
|
|
See: `OTSpec STAT Flags <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#flags>`_
|
|
"""
|
|
self.olderSibling: bool = olderSibling
|
|
"""STAT flag ``OLDER_SIBLING_FONT_ATTRIBUTE``.
|
|
|
|
See: `OTSpec STAT Flags <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#flags>`_
|
|
"""
|
|
self.labelNames: Dict[str, str] = labelNames or {}
|
|
"""User-facing translations of this location's label. Keyed by
|
|
xml:lang code.
|
|
"""
|
|
|
|
@property
|
|
def defaultName(self) -> str:
|
|
"""Return the English name from :attr:`labelNames` or the :attr:`name`."""
|
|
return self.labelNames.get("en") or self.name
|
|
|
|
def getFullUserLocation(self, doc: "DesignSpaceDocument") -> SimpleLocationDict:
|
|
"""Get the complete user location of this label, by combining data
|
|
from the explicit user location and default axis values.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return {
|
|
axis.name: self.userLocation.get(axis.name, axis.default)
|
|
for axis in doc.axes
|
|
}
|
|
|
|
|
|
class VariableFontDescriptor(SimpleDescriptor):
|
|
"""Container for variable fonts, sub-spaces of the Designspace.
|
|
|
|
Use-cases:
|
|
|
|
- From a single DesignSpace with discrete axes, define 1 variable font
|
|
per value on the discrete axes. Before version 5, you would have needed
|
|
1 DesignSpace per such variable font, and a lot of data duplication.
|
|
- From a big variable font with many axes, define subsets of that variable
|
|
font that only include some axes and freeze other axes at a given location.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
flavor = "variable-font"
|
|
_attrs = ("filename", "axisSubsets", "lib")
|
|
|
|
filename = posixpath_property("_filename")
|
|
|
|
def __init__(self, *, name, filename=None, axisSubsets=None, lib=None):
|
|
self.name: str = name
|
|
"""string, required. Name of this variable to identify it during the
|
|
build process and from other parts of the document, and also as a
|
|
filename in case the filename property is empty.
|
|
|
|
VarLib.
|
|
"""
|
|
self.filename: str = filename
|
|
"""string, optional. Relative path to the variable font file, **as it is
|
|
in the document**. The file may or may not exist.
|
|
|
|
If not specified, the :attr:`name` will be used as a basename for the file.
|
|
"""
|
|
self.axisSubsets: List[
|
|
Union[RangeAxisSubsetDescriptor, ValueAxisSubsetDescriptor]
|
|
] = (axisSubsets or [])
|
|
"""Axis subsets to include in this variable font.
|
|
|
|
If an axis is not mentioned, assume that we only want the default
|
|
location of that axis (same as a :class:`ValueAxisSubsetDescriptor`).
|
|
"""
|
|
self.lib: MutableMapping[str, Any] = lib or {}
|
|
"""Custom data associated with this variable font."""
|
|
|
|
|
|
class RangeAxisSubsetDescriptor(SimpleDescriptor):
|
|
"""Subset of a continuous axis to include in a variable font.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
flavor = "axis-subset"
|
|
_attrs = ("name", "userMinimum", "userDefault", "userMaximum")
|
|
|
|
def __init__(
|
|
self, *, name, userMinimum=-math.inf, userDefault=None, userMaximum=math.inf
|
|
):
|
|
self.name: str = name
|
|
"""Name of the :class:`AxisDescriptor` to subset."""
|
|
self.userMinimum: float = userMinimum
|
|
"""New minimum value of the axis in the target variable font.
|
|
If not specified, assume the same minimum value as the full axis.
|
|
(default = ``-math.inf``)
|
|
"""
|
|
self.userDefault: Optional[float] = userDefault
|
|
"""New default value of the axis in the target variable font.
|
|
If not specified, assume the same default value as the full axis.
|
|
(default = ``None``)
|
|
"""
|
|
self.userMaximum: float = userMaximum
|
|
"""New maximum value of the axis in the target variable font.
|
|
If not specified, assume the same maximum value as the full axis.
|
|
(default = ``math.inf``)
|
|
"""
|
|
|
|
|
|
class ValueAxisSubsetDescriptor(SimpleDescriptor):
|
|
"""Single value of a discrete or continuous axis to use in a variable font.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
flavor = "axis-subset"
|
|
_attrs = ("name", "userValue")
|
|
|
|
def __init__(self, *, name, userValue):
|
|
self.name: str = name
|
|
"""Name of the :class:`AxisDescriptor` or :class:`DiscreteAxisDescriptor`
|
|
to "snapshot" or "freeze".
|
|
"""
|
|
self.userValue: float = userValue
|
|
"""Value in user coordinates at which to freeze the given axis."""
|
|
|
|
|
|
class BaseDocWriter(object):
|
|
_whiteSpace = " "
|
|
axisDescriptorClass = AxisDescriptor
|
|
discreteAxisDescriptorClass = DiscreteAxisDescriptor
|
|
axisLabelDescriptorClass = AxisLabelDescriptor
|
|
axisMappingDescriptorClass = AxisMappingDescriptor
|
|
locationLabelDescriptorClass = LocationLabelDescriptor
|
|
ruleDescriptorClass = RuleDescriptor
|
|
sourceDescriptorClass = SourceDescriptor
|
|
variableFontDescriptorClass = VariableFontDescriptor
|
|
valueAxisSubsetDescriptorClass = ValueAxisSubsetDescriptor
|
|
rangeAxisSubsetDescriptorClass = RangeAxisSubsetDescriptor
|
|
instanceDescriptorClass = InstanceDescriptor
|
|
|
|
@classmethod
|
|
def getAxisDecriptor(cls):
|
|
return cls.axisDescriptorClass()
|
|
|
|
@classmethod
|
|
def getAxisMappingDescriptor(cls):
|
|
return cls.axisMappingDescriptorClass()
|
|
|
|
@classmethod
|
|
def getSourceDescriptor(cls):
|
|
return cls.sourceDescriptorClass()
|
|
|
|
@classmethod
|
|
def getInstanceDescriptor(cls):
|
|
return cls.instanceDescriptorClass()
|
|
|
|
@classmethod
|
|
def getRuleDescriptor(cls):
|
|
return cls.ruleDescriptorClass()
|
|
|
|
def __init__(self, documentPath, documentObject: DesignSpaceDocument):
|
|
self.path = documentPath
|
|
self.documentObject = documentObject
|
|
self.effectiveFormatTuple = self._getEffectiveFormatTuple()
|
|
self.root = ET.Element("designspace")
|
|
|
|
def write(self, pretty=True, encoding="UTF-8", xml_declaration=True):
|
|
self.root.attrib["format"] = ".".join(str(i) for i in self.effectiveFormatTuple)
|
|
|
|
if (
|
|
self.documentObject.axes
|
|
or self.documentObject.axisMappings
|
|
or self.documentObject.elidedFallbackName is not None
|
|
):
|
|
axesElement = ET.Element("axes")
|
|
if self.documentObject.elidedFallbackName is not None:
|
|
axesElement.attrib["elidedfallbackname"] = (
|
|
self.documentObject.elidedFallbackName
|
|
)
|
|
self.root.append(axesElement)
|
|
for axisObject in self.documentObject.axes:
|
|
self._addAxis(axisObject)
|
|
|
|
if self.documentObject.axisMappings:
|
|
mappingsElement = None
|
|
lastGroup = object()
|
|
for mappingObject in self.documentObject.axisMappings:
|
|
if getattr(mappingObject, "groupDescription", None) != lastGroup:
|
|
if mappingsElement is not None:
|
|
self.root.findall(".axes")[0].append(mappingsElement)
|
|
lastGroup = getattr(mappingObject, "groupDescription", None)
|
|
mappingsElement = ET.Element("mappings")
|
|
if lastGroup is not None:
|
|
mappingsElement.attrib["description"] = lastGroup
|
|
self._addAxisMapping(mappingsElement, mappingObject)
|
|
if mappingsElement is not None:
|
|
self.root.findall(".axes")[0].append(mappingsElement)
|
|
|
|
if self.documentObject.locationLabels:
|
|
labelsElement = ET.Element("labels")
|
|
for labelObject in self.documentObject.locationLabels:
|
|
self._addLocationLabel(labelsElement, labelObject)
|
|
self.root.append(labelsElement)
|
|
|
|
if self.documentObject.rules:
|
|
if getattr(self.documentObject, "rulesProcessingLast", False):
|
|
attributes = {"processing": "last"}
|
|
else:
|
|
attributes = {}
|
|
self.root.append(ET.Element("rules", attributes))
|
|
for ruleObject in self.documentObject.rules:
|
|
self._addRule(ruleObject)
|
|
|
|
if self.documentObject.sources:
|
|
self.root.append(ET.Element("sources"))
|
|
for sourceObject in self.documentObject.sources:
|
|
self._addSource(sourceObject)
|
|
|
|
if self.documentObject.variableFonts:
|
|
variableFontsElement = ET.Element("variable-fonts")
|
|
for variableFont in self.documentObject.variableFonts:
|
|
self._addVariableFont(variableFontsElement, variableFont)
|
|
self.root.append(variableFontsElement)
|
|
|
|
if self.documentObject.instances:
|
|
self.root.append(ET.Element("instances"))
|
|
for instanceObject in self.documentObject.instances:
|
|
self._addInstance(instanceObject)
|
|
|
|
if self.documentObject.lib:
|
|
self._addLib(self.root, self.documentObject.lib, 2)
|
|
|
|
tree = ET.ElementTree(self.root)
|
|
tree.write(
|
|
self.path,
|
|
encoding=encoding,
|
|
method="xml",
|
|
xml_declaration=xml_declaration,
|
|
pretty_print=pretty,
|
|
)
|
|
|
|
def _getEffectiveFormatTuple(self):
|
|
"""Try to use the version specified in the document, or a sufficiently
|
|
recent version to be able to encode what the document contains.
|
|
"""
|
|
minVersion = self.documentObject.formatTuple
|
|
if (
|
|
any(
|
|
hasattr(axis, "values")
|
|
or axis.axisOrdering is not None
|
|
or axis.axisLabels
|
|
for axis in self.documentObject.axes
|
|
)
|
|
or self.documentObject.locationLabels
|
|
or any(source.localisedFamilyName for source in self.documentObject.sources)
|
|
or self.documentObject.variableFonts
|
|
or any(
|
|
instance.locationLabel or instance.userLocation
|
|
for instance in self.documentObject.instances
|
|
)
|
|
):
|
|
if minVersion < (5, 0):
|
|
minVersion = (5, 0)
|
|
if self.documentObject.axisMappings:
|
|
if minVersion < (5, 1):
|
|
minVersion = (5, 1)
|
|
return minVersion
|
|
|
|
def _makeLocationElement(self, locationObject, name=None):
|
|
"""Convert Location dict to a locationElement."""
|
|
locElement = ET.Element("location")
|
|
if name is not None:
|
|
locElement.attrib["name"] = name
|
|
validatedLocation = self.documentObject.newDefaultLocation()
|
|
for axisName, axisValue in locationObject.items():
|
|
if axisName in validatedLocation:
|
|
# only accept values we know
|
|
validatedLocation[axisName] = axisValue
|
|
for dimensionName, dimensionValue in validatedLocation.items():
|
|
dimElement = ET.Element("dimension")
|
|
dimElement.attrib["name"] = dimensionName
|
|
if type(dimensionValue) == tuple:
|
|
dimElement.attrib["xvalue"] = self.intOrFloat(dimensionValue[0])
|
|
dimElement.attrib["yvalue"] = self.intOrFloat(dimensionValue[1])
|
|
else:
|
|
dimElement.attrib["xvalue"] = self.intOrFloat(dimensionValue)
|
|
locElement.append(dimElement)
|
|
return locElement, validatedLocation
|
|
|
|
def intOrFloat(self, num):
|
|
if int(num) == num:
|
|
return "%d" % num
|
|
return ("%f" % num).rstrip("0").rstrip(".")
|
|
|
|
def _addRule(self, ruleObject):
|
|
# if none of the conditions have minimum or maximum values, do not add the rule.
|
|
ruleElement = ET.Element("rule")
|
|
if ruleObject.name is not None:
|
|
ruleElement.attrib["name"] = ruleObject.name
|
|
for conditions in ruleObject.conditionSets:
|
|
conditionsetElement = ET.Element("conditionset")
|
|
for cond in conditions:
|
|
if cond.get("minimum") is None and cond.get("maximum") is None:
|
|
# neither is defined, don't add this condition
|
|
continue
|
|
conditionElement = ET.Element("condition")
|
|
conditionElement.attrib["name"] = cond.get("name")
|
|
if cond.get("minimum") is not None:
|
|
conditionElement.attrib["minimum"] = self.intOrFloat(
|
|
cond.get("minimum")
|
|
)
|
|
if cond.get("maximum") is not None:
|
|
conditionElement.attrib["maximum"] = self.intOrFloat(
|
|
cond.get("maximum")
|
|
)
|
|
conditionsetElement.append(conditionElement)
|
|
if len(conditionsetElement):
|
|
ruleElement.append(conditionsetElement)
|
|
for sub in ruleObject.subs:
|
|
subElement = ET.Element("sub")
|
|
subElement.attrib["name"] = sub[0]
|
|
subElement.attrib["with"] = sub[1]
|
|
ruleElement.append(subElement)
|
|
if len(ruleElement):
|
|
self.root.findall(".rules")[0].append(ruleElement)
|
|
|
|
def _addAxis(self, axisObject):
|
|
axisElement = ET.Element("axis")
|
|
axisElement.attrib["tag"] = axisObject.tag
|
|
axisElement.attrib["name"] = axisObject.name
|
|
self._addLabelNames(axisElement, axisObject.labelNames)
|
|
if axisObject.map:
|
|
for inputValue, outputValue in axisObject.map:
|
|
mapElement = ET.Element("map")
|
|
mapElement.attrib["input"] = self.intOrFloat(inputValue)
|
|
mapElement.attrib["output"] = self.intOrFloat(outputValue)
|
|
axisElement.append(mapElement)
|
|
if axisObject.axisOrdering is not None or axisObject.axisLabels:
|
|
labelsElement = ET.Element("labels")
|
|
if axisObject.axisOrdering is not None:
|
|
labelsElement.attrib["ordering"] = str(axisObject.axisOrdering)
|
|
for label in axisObject.axisLabels:
|
|
self._addAxisLabel(labelsElement, label)
|
|
axisElement.append(labelsElement)
|
|
if hasattr(axisObject, "minimum"):
|
|
axisElement.attrib["minimum"] = self.intOrFloat(axisObject.minimum)
|
|
axisElement.attrib["maximum"] = self.intOrFloat(axisObject.maximum)
|
|
elif hasattr(axisObject, "values"):
|
|
axisElement.attrib["values"] = " ".join(
|
|
self.intOrFloat(v) for v in axisObject.values
|
|
)
|
|
axisElement.attrib["default"] = self.intOrFloat(axisObject.default)
|
|
if axisObject.hidden:
|
|
axisElement.attrib["hidden"] = "1"
|
|
self.root.findall(".axes")[0].append(axisElement)
|
|
|
|
def _addAxisMapping(self, mappingsElement, mappingObject):
|
|
mappingElement = ET.Element("mapping")
|
|
if getattr(mappingObject, "description", None) is not None:
|
|
mappingElement.attrib["description"] = mappingObject.description
|
|
for what in ("inputLocation", "outputLocation"):
|
|
whatObject = getattr(mappingObject, what, None)
|
|
if whatObject is None:
|
|
continue
|
|
whatElement = ET.Element(what[:-8])
|
|
mappingElement.append(whatElement)
|
|
|
|
for name, value in whatObject.items():
|
|
dimensionElement = ET.Element("dimension")
|
|
dimensionElement.attrib["name"] = name
|
|
dimensionElement.attrib["xvalue"] = self.intOrFloat(value)
|
|
whatElement.append(dimensionElement)
|
|
|
|
mappingsElement.append(mappingElement)
|
|
|
|
def _addAxisLabel(
|
|
self, axisElement: ET.Element, label: AxisLabelDescriptor
|
|
) -> None:
|
|
labelElement = ET.Element("label")
|
|
labelElement.attrib["uservalue"] = self.intOrFloat(label.userValue)
|
|
if label.userMinimum is not None:
|
|
labelElement.attrib["userminimum"] = self.intOrFloat(label.userMinimum)
|
|
if label.userMaximum is not None:
|
|
labelElement.attrib["usermaximum"] = self.intOrFloat(label.userMaximum)
|
|
labelElement.attrib["name"] = label.name
|
|
if label.elidable:
|
|
labelElement.attrib["elidable"] = "true"
|
|
if label.olderSibling:
|
|
labelElement.attrib["oldersibling"] = "true"
|
|
if label.linkedUserValue is not None:
|
|
labelElement.attrib["linkeduservalue"] = self.intOrFloat(
|
|
label.linkedUserValue
|
|
)
|
|
self._addLabelNames(labelElement, label.labelNames)
|
|
axisElement.append(labelElement)
|
|
|
|
def _addLabelNames(self, parentElement, labelNames):
|
|
for languageCode, labelName in sorted(labelNames.items()):
|
|
languageElement = ET.Element("labelname")
|
|
languageElement.attrib[XML_LANG] = languageCode
|
|
languageElement.text = labelName
|
|
parentElement.append(languageElement)
|
|
|
|
def _addLocationLabel(
|
|
self, parentElement: ET.Element, label: LocationLabelDescriptor
|
|
) -> None:
|
|
labelElement = ET.Element("label")
|
|
labelElement.attrib["name"] = label.name
|
|
if label.elidable:
|
|
labelElement.attrib["elidable"] = "true"
|
|
if label.olderSibling:
|
|
labelElement.attrib["oldersibling"] = "true"
|
|
self._addLabelNames(labelElement, label.labelNames)
|
|
self._addLocationElement(labelElement, userLocation=label.userLocation)
|
|
parentElement.append(labelElement)
|
|
|
|
def _addLocationElement(
|
|
self,
|
|
parentElement,
|
|
*,
|
|
designLocation: AnisotropicLocationDict = None,
|
|
userLocation: SimpleLocationDict = None,
|
|
):
|
|
locElement = ET.Element("location")
|
|
for axis in self.documentObject.axes:
|
|
if designLocation is not None and axis.name in designLocation:
|
|
dimElement = ET.Element("dimension")
|
|
dimElement.attrib["name"] = axis.name
|
|
value = designLocation[axis.name]
|
|
if isinstance(value, tuple):
|
|
dimElement.attrib["xvalue"] = self.intOrFloat(value[0])
|
|
dimElement.attrib["yvalue"] = self.intOrFloat(value[1])
|
|
else:
|
|
dimElement.attrib["xvalue"] = self.intOrFloat(value)
|
|
locElement.append(dimElement)
|
|
elif userLocation is not None and axis.name in userLocation:
|
|
dimElement = ET.Element("dimension")
|
|
dimElement.attrib["name"] = axis.name
|
|
value = userLocation[axis.name]
|
|
dimElement.attrib["uservalue"] = self.intOrFloat(value)
|
|
locElement.append(dimElement)
|
|
if len(locElement) > 0:
|
|
parentElement.append(locElement)
|
|
|
|
def _addInstance(self, instanceObject):
|
|
instanceElement = ET.Element("instance")
|
|
if instanceObject.name is not None:
|
|
instanceElement.attrib["name"] = instanceObject.name
|
|
if instanceObject.locationLabel is not None:
|
|
instanceElement.attrib["location"] = instanceObject.locationLabel
|
|
if instanceObject.familyName is not None:
|
|
instanceElement.attrib["familyname"] = instanceObject.familyName
|
|
if instanceObject.styleName is not None:
|
|
instanceElement.attrib["stylename"] = instanceObject.styleName
|
|
# add localisations
|
|
if instanceObject.localisedStyleName:
|
|
languageCodes = list(instanceObject.localisedStyleName.keys())
|
|
languageCodes.sort()
|
|
for code in languageCodes:
|
|
if code == "en":
|
|
continue # already stored in the element attribute
|
|
localisedStyleNameElement = ET.Element("stylename")
|
|
localisedStyleNameElement.attrib[XML_LANG] = code
|
|
localisedStyleNameElement.text = instanceObject.getStyleName(code)
|
|
instanceElement.append(localisedStyleNameElement)
|
|
if instanceObject.localisedFamilyName:
|
|
languageCodes = list(instanceObject.localisedFamilyName.keys())
|
|
languageCodes.sort()
|
|
for code in languageCodes:
|
|
if code == "en":
|
|
continue # already stored in the element attribute
|
|
localisedFamilyNameElement = ET.Element("familyname")
|
|
localisedFamilyNameElement.attrib[XML_LANG] = code
|
|
localisedFamilyNameElement.text = instanceObject.getFamilyName(code)
|
|
instanceElement.append(localisedFamilyNameElement)
|
|
if instanceObject.localisedStyleMapStyleName:
|
|
languageCodes = list(instanceObject.localisedStyleMapStyleName.keys())
|
|
languageCodes.sort()
|
|
for code in languageCodes:
|
|
if code == "en":
|
|
continue
|
|
localisedStyleMapStyleNameElement = ET.Element("stylemapstylename")
|
|
localisedStyleMapStyleNameElement.attrib[XML_LANG] = code
|
|
localisedStyleMapStyleNameElement.text = (
|
|
instanceObject.getStyleMapStyleName(code)
|
|
)
|
|
instanceElement.append(localisedStyleMapStyleNameElement)
|
|
if instanceObject.localisedStyleMapFamilyName:
|
|
languageCodes = list(instanceObject.localisedStyleMapFamilyName.keys())
|
|
languageCodes.sort()
|
|
for code in languageCodes:
|
|
if code == "en":
|
|
continue
|
|
localisedStyleMapFamilyNameElement = ET.Element("stylemapfamilyname")
|
|
localisedStyleMapFamilyNameElement.attrib[XML_LANG] = code
|
|
localisedStyleMapFamilyNameElement.text = (
|
|
instanceObject.getStyleMapFamilyName(code)
|
|
)
|
|
instanceElement.append(localisedStyleMapFamilyNameElement)
|
|
|
|
if self.effectiveFormatTuple >= (5, 0):
|
|
if instanceObject.locationLabel is None:
|
|
self._addLocationElement(
|
|
instanceElement,
|
|
designLocation=instanceObject.designLocation,
|
|
userLocation=instanceObject.userLocation,
|
|
)
|
|
else:
|
|
# Pre-version 5.0 code was validating and filling in the location
|
|
# dict while writing it out, as preserved below.
|
|
if instanceObject.location is not None:
|
|
locationElement, instanceObject.location = self._makeLocationElement(
|
|
instanceObject.location
|
|
)
|
|
instanceElement.append(locationElement)
|
|
if instanceObject.filename is not None:
|
|
instanceElement.attrib["filename"] = instanceObject.filename
|
|
if instanceObject.postScriptFontName is not None:
|
|
instanceElement.attrib["postscriptfontname"] = (
|
|
instanceObject.postScriptFontName
|
|
)
|
|
if instanceObject.styleMapFamilyName is not None:
|
|
instanceElement.attrib["stylemapfamilyname"] = (
|
|
instanceObject.styleMapFamilyName
|
|
)
|
|
if instanceObject.styleMapStyleName is not None:
|
|
instanceElement.attrib["stylemapstylename"] = (
|
|
instanceObject.styleMapStyleName
|
|
)
|
|
if self.effectiveFormatTuple < (5, 0):
|
|
# Deprecated members as of version 5.0
|
|
if instanceObject.glyphs:
|
|
if instanceElement.findall(".glyphs") == []:
|
|
glyphsElement = ET.Element("glyphs")
|
|
instanceElement.append(glyphsElement)
|
|
glyphsElement = instanceElement.findall(".glyphs")[0]
|
|
for glyphName, data in sorted(instanceObject.glyphs.items()):
|
|
glyphElement = self._writeGlyphElement(
|
|
instanceElement, instanceObject, glyphName, data
|
|
)
|
|
glyphsElement.append(glyphElement)
|
|
if instanceObject.kerning:
|
|
kerningElement = ET.Element("kerning")
|
|
instanceElement.append(kerningElement)
|
|
if instanceObject.info:
|
|
infoElement = ET.Element("info")
|
|
instanceElement.append(infoElement)
|
|
self._addLib(instanceElement, instanceObject.lib, 4)
|
|
self.root.findall(".instances")[0].append(instanceElement)
|
|
|
|
def _addSource(self, sourceObject):
|
|
sourceElement = ET.Element("source")
|
|
if sourceObject.filename is not None:
|
|
sourceElement.attrib["filename"] = sourceObject.filename
|
|
if sourceObject.name is not None:
|
|
if sourceObject.name.find("temp_master") != 0:
|
|
# do not save temporary source names
|
|
sourceElement.attrib["name"] = sourceObject.name
|
|
if sourceObject.familyName is not None:
|
|
sourceElement.attrib["familyname"] = sourceObject.familyName
|
|
if sourceObject.styleName is not None:
|
|
sourceElement.attrib["stylename"] = sourceObject.styleName
|
|
if sourceObject.layerName is not None:
|
|
sourceElement.attrib["layer"] = sourceObject.layerName
|
|
if sourceObject.localisedFamilyName:
|
|
languageCodes = list(sourceObject.localisedFamilyName.keys())
|
|
languageCodes.sort()
|
|
for code in languageCodes:
|
|
if code == "en":
|
|
continue # already stored in the element attribute
|
|
localisedFamilyNameElement = ET.Element("familyname")
|
|
localisedFamilyNameElement.attrib[XML_LANG] = code
|
|
localisedFamilyNameElement.text = sourceObject.getFamilyName(code)
|
|
sourceElement.append(localisedFamilyNameElement)
|
|
if sourceObject.copyLib:
|
|
libElement = ET.Element("lib")
|
|
libElement.attrib["copy"] = "1"
|
|
sourceElement.append(libElement)
|
|
if sourceObject.copyGroups:
|
|
groupsElement = ET.Element("groups")
|
|
groupsElement.attrib["copy"] = "1"
|
|
sourceElement.append(groupsElement)
|
|
if sourceObject.copyFeatures:
|
|
featuresElement = ET.Element("features")
|
|
featuresElement.attrib["copy"] = "1"
|
|
sourceElement.append(featuresElement)
|
|
if sourceObject.copyInfo or sourceObject.muteInfo:
|
|
infoElement = ET.Element("info")
|
|
if sourceObject.copyInfo:
|
|
infoElement.attrib["copy"] = "1"
|
|
if sourceObject.muteInfo:
|
|
infoElement.attrib["mute"] = "1"
|
|
sourceElement.append(infoElement)
|
|
if sourceObject.muteKerning:
|
|
kerningElement = ET.Element("kerning")
|
|
kerningElement.attrib["mute"] = "1"
|
|
sourceElement.append(kerningElement)
|
|
if sourceObject.mutedGlyphNames:
|
|
for name in sourceObject.mutedGlyphNames:
|
|
glyphElement = ET.Element("glyph")
|
|
glyphElement.attrib["name"] = name
|
|
glyphElement.attrib["mute"] = "1"
|
|
sourceElement.append(glyphElement)
|
|
if self.effectiveFormatTuple >= (5, 0):
|
|
self._addLocationElement(
|
|
sourceElement, designLocation=sourceObject.location
|
|
)
|
|
else:
|
|
# Pre-version 5.0 code was validating and filling in the location
|
|
# dict while writing it out, as preserved below.
|
|
locationElement, sourceObject.location = self._makeLocationElement(
|
|
sourceObject.location
|
|
)
|
|
sourceElement.append(locationElement)
|
|
self.root.findall(".sources")[0].append(sourceElement)
|
|
|
|
def _addVariableFont(
|
|
self, parentElement: ET.Element, vf: VariableFontDescriptor
|
|
) -> None:
|
|
vfElement = ET.Element("variable-font")
|
|
vfElement.attrib["name"] = vf.name
|
|
if vf.filename is not None:
|
|
vfElement.attrib["filename"] = vf.filename
|
|
if vf.axisSubsets:
|
|
subsetsElement = ET.Element("axis-subsets")
|
|
for subset in vf.axisSubsets:
|
|
subsetElement = ET.Element("axis-subset")
|
|
subsetElement.attrib["name"] = subset.name
|
|
# Mypy doesn't support narrowing union types via hasattr()
|
|
# https://mypy.readthedocs.io/en/stable/type_narrowing.html
|
|
# TODO(Python 3.10): use TypeGuard
|
|
if hasattr(subset, "userMinimum"):
|
|
subset = cast(RangeAxisSubsetDescriptor, subset)
|
|
if subset.userMinimum != -math.inf:
|
|
subsetElement.attrib["userminimum"] = self.intOrFloat(
|
|
subset.userMinimum
|
|
)
|
|
if subset.userMaximum != math.inf:
|
|
subsetElement.attrib["usermaximum"] = self.intOrFloat(
|
|
subset.userMaximum
|
|
)
|
|
if subset.userDefault is not None:
|
|
subsetElement.attrib["userdefault"] = self.intOrFloat(
|
|
subset.userDefault
|
|
)
|
|
elif hasattr(subset, "userValue"):
|
|
subset = cast(ValueAxisSubsetDescriptor, subset)
|
|
subsetElement.attrib["uservalue"] = self.intOrFloat(
|
|
subset.userValue
|
|
)
|
|
subsetsElement.append(subsetElement)
|
|
vfElement.append(subsetsElement)
|
|
self._addLib(vfElement, vf.lib, 4)
|
|
parentElement.append(vfElement)
|
|
|
|
def _addLib(self, parentElement: ET.Element, data: Any, indent_level: int) -> None:
|
|
if not data:
|
|
return
|
|
libElement = ET.Element("lib")
|
|
libElement.append(plistlib.totree(data, indent_level=indent_level))
|
|
parentElement.append(libElement)
|
|
|
|
def _writeGlyphElement(self, instanceElement, instanceObject, glyphName, data):
|
|
glyphElement = ET.Element("glyph")
|
|
if data.get("mute"):
|
|
glyphElement.attrib["mute"] = "1"
|
|
if data.get("unicodes") is not None:
|
|
glyphElement.attrib["unicode"] = " ".join(
|
|
[hex(u) for u in data.get("unicodes")]
|
|
)
|
|
if data.get("instanceLocation") is not None:
|
|
locationElement, data["instanceLocation"] = self._makeLocationElement(
|
|
data.get("instanceLocation")
|
|
)
|
|
glyphElement.append(locationElement)
|
|
if glyphName is not None:
|
|
glyphElement.attrib["name"] = glyphName
|
|
if data.get("note") is not None:
|
|
noteElement = ET.Element("note")
|
|
noteElement.text = data.get("note")
|
|
glyphElement.append(noteElement)
|
|
if data.get("masters") is not None:
|
|
mastersElement = ET.Element("masters")
|
|
for m in data.get("masters"):
|
|
masterElement = ET.Element("master")
|
|
if m.get("glyphName") is not None:
|
|
masterElement.attrib["glyphname"] = m.get("glyphName")
|
|
if m.get("font") is not None:
|
|
masterElement.attrib["source"] = m.get("font")
|
|
if m.get("location") is not None:
|
|
locationElement, m["location"] = self._makeLocationElement(
|
|
m.get("location")
|
|
)
|
|
masterElement.append(locationElement)
|
|
mastersElement.append(masterElement)
|
|
glyphElement.append(mastersElement)
|
|
return glyphElement
|
|
|
|
|
|
class BaseDocReader(LogMixin):
|
|
axisDescriptorClass = AxisDescriptor
|
|
discreteAxisDescriptorClass = DiscreteAxisDescriptor
|
|
axisLabelDescriptorClass = AxisLabelDescriptor
|
|
axisMappingDescriptorClass = AxisMappingDescriptor
|
|
locationLabelDescriptorClass = LocationLabelDescriptor
|
|
ruleDescriptorClass = RuleDescriptor
|
|
sourceDescriptorClass = SourceDescriptor
|
|
variableFontsDescriptorClass = VariableFontDescriptor
|
|
valueAxisSubsetDescriptorClass = ValueAxisSubsetDescriptor
|
|
rangeAxisSubsetDescriptorClass = RangeAxisSubsetDescriptor
|
|
instanceDescriptorClass = InstanceDescriptor
|
|
|
|
def __init__(self, documentPath, documentObject):
|
|
self.path = documentPath
|
|
self.documentObject = documentObject
|
|
tree = ET.parse(self.path)
|
|
self.root = tree.getroot()
|
|
self.documentObject.formatVersion = self.root.attrib.get("format", "3.0")
|
|
self._axes = []
|
|
self.rules = []
|
|
self.sources = []
|
|
self.instances = []
|
|
self.axisDefaults = {}
|
|
self._strictAxisNames = True
|
|
|
|
@classmethod
|
|
def fromstring(cls, string, documentObject):
|
|
f = BytesIO(tobytes(string, encoding="utf-8"))
|
|
self = cls(f, documentObject)
|
|
self.path = None
|
|
return self
|
|
|
|
def read(self):
|
|
self.readAxes()
|
|
self.readLabels()
|
|
self.readRules()
|
|
self.readVariableFonts()
|
|
self.readSources()
|
|
self.readInstances()
|
|
self.readLib()
|
|
|
|
def readRules(self):
|
|
# we also need to read any conditions that are outside of a condition set.
|
|
rules = []
|
|
rulesElement = self.root.find(".rules")
|
|
if rulesElement is not None:
|
|
processingValue = rulesElement.attrib.get("processing", "first")
|
|
if processingValue not in {"first", "last"}:
|
|
raise DesignSpaceDocumentError(
|
|
"<rules> processing attribute value is not valid: %r, "
|
|
"expected 'first' or 'last'" % processingValue
|
|
)
|
|
self.documentObject.rulesProcessingLast = processingValue == "last"
|
|
for ruleElement in self.root.findall(".rules/rule"):
|
|
ruleObject = self.ruleDescriptorClass()
|
|
ruleName = ruleObject.name = ruleElement.attrib.get("name")
|
|
# read any stray conditions outside a condition set
|
|
externalConditions = self._readConditionElements(
|
|
ruleElement,
|
|
ruleName,
|
|
)
|
|
if externalConditions:
|
|
ruleObject.conditionSets.append(externalConditions)
|
|
self.log.info(
|
|
"Found stray rule conditions outside a conditionset. "
|
|
"Wrapped them in a new conditionset."
|
|
)
|
|
# read the conditionsets
|
|
for conditionSetElement in ruleElement.findall(".conditionset"):
|
|
conditionSet = self._readConditionElements(
|
|
conditionSetElement,
|
|
ruleName,
|
|
)
|
|
if conditionSet is not None:
|
|
ruleObject.conditionSets.append(conditionSet)
|
|
for subElement in ruleElement.findall(".sub"):
|
|
a = subElement.attrib["name"]
|
|
b = subElement.attrib["with"]
|
|
ruleObject.subs.append((a, b))
|
|
rules.append(ruleObject)
|
|
self.documentObject.rules = rules
|
|
|
|
def _readConditionElements(self, parentElement, ruleName=None):
|
|
cds = []
|
|
for conditionElement in parentElement.findall(".condition"):
|
|
cd = {}
|
|
cdMin = conditionElement.attrib.get("minimum")
|
|
if cdMin is not None:
|
|
cd["minimum"] = float(cdMin)
|
|
else:
|
|
# will allow these to be None, assume axis.minimum
|
|
cd["minimum"] = None
|
|
cdMax = conditionElement.attrib.get("maximum")
|
|
if cdMax is not None:
|
|
cd["maximum"] = float(cdMax)
|
|
else:
|
|
# will allow these to be None, assume axis.maximum
|
|
cd["maximum"] = None
|
|
cd["name"] = conditionElement.attrib.get("name")
|
|
# # test for things
|
|
if cd.get("minimum") is None and cd.get("maximum") is None:
|
|
raise DesignSpaceDocumentError(
|
|
"condition missing required minimum or maximum in rule"
|
|
+ (" '%s'" % ruleName if ruleName is not None else "")
|
|
)
|
|
cds.append(cd)
|
|
return cds
|
|
|
|
def readAxes(self):
|
|
# read the axes elements, including the warp map.
|
|
axesElement = self.root.find(".axes")
|
|
if axesElement is not None and "elidedfallbackname" in axesElement.attrib:
|
|
self.documentObject.elidedFallbackName = axesElement.attrib[
|
|
"elidedfallbackname"
|
|
]
|
|
axisElements = self.root.findall(".axes/axis")
|
|
if not axisElements:
|
|
return
|
|
for axisElement in axisElements:
|
|
if (
|
|
self.documentObject.formatTuple >= (5, 0)
|
|
and "values" in axisElement.attrib
|
|
):
|
|
axisObject = self.discreteAxisDescriptorClass()
|
|
axisObject.values = [
|
|
float(s) for s in axisElement.attrib["values"].split(" ")
|
|
]
|
|
else:
|
|
axisObject = self.axisDescriptorClass()
|
|
axisObject.minimum = float(axisElement.attrib.get("minimum"))
|
|
axisObject.maximum = float(axisElement.attrib.get("maximum"))
|
|
axisObject.default = float(axisElement.attrib.get("default"))
|
|
axisObject.name = axisElement.attrib.get("name")
|
|
if axisElement.attrib.get("hidden", False):
|
|
axisObject.hidden = True
|
|
axisObject.tag = axisElement.attrib.get("tag")
|
|
for mapElement in axisElement.findall("map"):
|
|
a = float(mapElement.attrib["input"])
|
|
b = float(mapElement.attrib["output"])
|
|
axisObject.map.append((a, b))
|
|
for labelNameElement in axisElement.findall("labelname"):
|
|
# Note: elementtree reads the "xml:lang" attribute name as
|
|
# '{http://www.w3.org/XML/1998/namespace}lang'
|
|
for key, lang in labelNameElement.items():
|
|
if key == XML_LANG:
|
|
axisObject.labelNames[lang] = tostr(labelNameElement.text)
|
|
labelElement = axisElement.find(".labels")
|
|
if labelElement is not None:
|
|
if "ordering" in labelElement.attrib:
|
|
axisObject.axisOrdering = int(labelElement.attrib["ordering"])
|
|
for label in labelElement.findall(".label"):
|
|
axisObject.axisLabels.append(self.readAxisLabel(label))
|
|
self.documentObject.axes.append(axisObject)
|
|
self.axisDefaults[axisObject.name] = axisObject.default
|
|
|
|
self.documentObject.axisMappings = []
|
|
for mappingsElement in self.root.findall(".axes/mappings"):
|
|
groupDescription = mappingsElement.attrib.get("description")
|
|
for mappingElement in mappingsElement.findall("mapping"):
|
|
description = mappingElement.attrib.get("description")
|
|
inputElement = mappingElement.find("input")
|
|
outputElement = mappingElement.find("output")
|
|
inputLoc = {}
|
|
outputLoc = {}
|
|
for dimElement in inputElement.findall(".dimension"):
|
|
name = dimElement.attrib["name"]
|
|
value = float(dimElement.attrib["xvalue"])
|
|
inputLoc[name] = value
|
|
for dimElement in outputElement.findall(".dimension"):
|
|
name = dimElement.attrib["name"]
|
|
value = float(dimElement.attrib["xvalue"])
|
|
outputLoc[name] = value
|
|
axisMappingObject = self.axisMappingDescriptorClass(
|
|
inputLocation=inputLoc,
|
|
outputLocation=outputLoc,
|
|
description=description,
|
|
groupDescription=groupDescription,
|
|
)
|
|
self.documentObject.axisMappings.append(axisMappingObject)
|
|
|
|
def readAxisLabel(self, element: ET.Element):
|
|
xml_attrs = {
|
|
"userminimum",
|
|
"uservalue",
|
|
"usermaximum",
|
|
"name",
|
|
"elidable",
|
|
"oldersibling",
|
|
"linkeduservalue",
|
|
}
|
|
unknown_attrs = set(element.attrib) - xml_attrs
|
|
if unknown_attrs:
|
|
raise DesignSpaceDocumentError(
|
|
f"label element contains unknown attributes: {', '.join(unknown_attrs)}"
|
|
)
|
|
|
|
name = element.get("name")
|
|
if name is None:
|
|
raise DesignSpaceDocumentError("label element must have a name attribute.")
|
|
valueStr = element.get("uservalue")
|
|
if valueStr is None:
|
|
raise DesignSpaceDocumentError(
|
|
"label element must have a uservalue attribute."
|
|
)
|
|
value = float(valueStr)
|
|
minimumStr = element.get("userminimum")
|
|
minimum = float(minimumStr) if minimumStr is not None else None
|
|
maximumStr = element.get("usermaximum")
|
|
maximum = float(maximumStr) if maximumStr is not None else None
|
|
linkedValueStr = element.get("linkeduservalue")
|
|
linkedValue = float(linkedValueStr) if linkedValueStr is not None else None
|
|
elidable = True if element.get("elidable") == "true" else False
|
|
olderSibling = True if element.get("oldersibling") == "true" else False
|
|
labelNames = {
|
|
lang: label_name.text or ""
|
|
for label_name in element.findall("labelname")
|
|
for attr, lang in label_name.items()
|
|
if attr == XML_LANG
|
|
# Note: elementtree reads the "xml:lang" attribute name as
|
|
# '{http://www.w3.org/XML/1998/namespace}lang'
|
|
}
|
|
return self.axisLabelDescriptorClass(
|
|
name=name,
|
|
userValue=value,
|
|
userMinimum=minimum,
|
|
userMaximum=maximum,
|
|
elidable=elidable,
|
|
olderSibling=olderSibling,
|
|
linkedUserValue=linkedValue,
|
|
labelNames=labelNames,
|
|
)
|
|
|
|
def readLabels(self):
|
|
if self.documentObject.formatTuple < (5, 0):
|
|
return
|
|
|
|
xml_attrs = {"name", "elidable", "oldersibling"}
|
|
for labelElement in self.root.findall(".labels/label"):
|
|
unknown_attrs = set(labelElement.attrib) - xml_attrs
|
|
if unknown_attrs:
|
|
raise DesignSpaceDocumentError(
|
|
f"Label element contains unknown attributes: {', '.join(unknown_attrs)}"
|
|
)
|
|
|
|
name = labelElement.get("name")
|
|
if name is None:
|
|
raise DesignSpaceDocumentError(
|
|
"label element must have a name attribute."
|
|
)
|
|
designLocation, userLocation = self.locationFromElement(labelElement)
|
|
if designLocation:
|
|
raise DesignSpaceDocumentError(
|
|
f'<label> element "{name}" must only have user locations (using uservalue="").'
|
|
)
|
|
elidable = True if labelElement.get("elidable") == "true" else False
|
|
olderSibling = True if labelElement.get("oldersibling") == "true" else False
|
|
labelNames = {
|
|
lang: label_name.text or ""
|
|
for label_name in labelElement.findall("labelname")
|
|
for attr, lang in label_name.items()
|
|
if attr == XML_LANG
|
|
# Note: elementtree reads the "xml:lang" attribute name as
|
|
# '{http://www.w3.org/XML/1998/namespace}lang'
|
|
}
|
|
locationLabel = self.locationLabelDescriptorClass(
|
|
name=name,
|
|
userLocation=userLocation,
|
|
elidable=elidable,
|
|
olderSibling=olderSibling,
|
|
labelNames=labelNames,
|
|
)
|
|
self.documentObject.locationLabels.append(locationLabel)
|
|
|
|
def readVariableFonts(self):
|
|
if self.documentObject.formatTuple < (5, 0):
|
|
return
|
|
|
|
xml_attrs = {"name", "filename"}
|
|
for variableFontElement in self.root.findall(".variable-fonts/variable-font"):
|
|
unknown_attrs = set(variableFontElement.attrib) - xml_attrs
|
|
if unknown_attrs:
|
|
raise DesignSpaceDocumentError(
|
|
f"variable-font element contains unknown attributes: {', '.join(unknown_attrs)}"
|
|
)
|
|
|
|
name = variableFontElement.get("name")
|
|
if name is None:
|
|
raise DesignSpaceDocumentError(
|
|
"variable-font element must have a name attribute."
|
|
)
|
|
|
|
filename = variableFontElement.get("filename")
|
|
|
|
axisSubsetsElement = variableFontElement.find(".axis-subsets")
|
|
if axisSubsetsElement is None:
|
|
raise DesignSpaceDocumentError(
|
|
"variable-font element must contain an axis-subsets element."
|
|
)
|
|
axisSubsets = []
|
|
for axisSubset in axisSubsetsElement.iterfind(".axis-subset"):
|
|
axisSubsets.append(self.readAxisSubset(axisSubset))
|
|
|
|
lib = None
|
|
libElement = variableFontElement.find(".lib")
|
|
if libElement is not None:
|
|
lib = plistlib.fromtree(libElement[0])
|
|
|
|
variableFont = self.variableFontsDescriptorClass(
|
|
name=name,
|
|
filename=filename,
|
|
axisSubsets=axisSubsets,
|
|
lib=lib,
|
|
)
|
|
self.documentObject.variableFonts.append(variableFont)
|
|
|
|
def readAxisSubset(self, element: ET.Element):
|
|
if "uservalue" in element.attrib:
|
|
xml_attrs = {"name", "uservalue"}
|
|
unknown_attrs = set(element.attrib) - xml_attrs
|
|
if unknown_attrs:
|
|
raise DesignSpaceDocumentError(
|
|
f"axis-subset element contains unknown attributes: {', '.join(unknown_attrs)}"
|
|
)
|
|
|
|
name = element.get("name")
|
|
if name is None:
|
|
raise DesignSpaceDocumentError(
|
|
"axis-subset element must have a name attribute."
|
|
)
|
|
userValueStr = element.get("uservalue")
|
|
if userValueStr is None:
|
|
raise DesignSpaceDocumentError(
|
|
"The axis-subset element for a discrete subset must have a uservalue attribute."
|
|
)
|
|
userValue = float(userValueStr)
|
|
|
|
return self.valueAxisSubsetDescriptorClass(name=name, userValue=userValue)
|
|
else:
|
|
xml_attrs = {"name", "userminimum", "userdefault", "usermaximum"}
|
|
unknown_attrs = set(element.attrib) - xml_attrs
|
|
if unknown_attrs:
|
|
raise DesignSpaceDocumentError(
|
|
f"axis-subset element contains unknown attributes: {', '.join(unknown_attrs)}"
|
|
)
|
|
|
|
name = element.get("name")
|
|
if name is None:
|
|
raise DesignSpaceDocumentError(
|
|
"axis-subset element must have a name attribute."
|
|
)
|
|
|
|
userMinimum = element.get("userminimum")
|
|
userDefault = element.get("userdefault")
|
|
userMaximum = element.get("usermaximum")
|
|
if (
|
|
userMinimum is not None
|
|
and userDefault is not None
|
|
and userMaximum is not None
|
|
):
|
|
return self.rangeAxisSubsetDescriptorClass(
|
|
name=name,
|
|
userMinimum=float(userMinimum),
|
|
userDefault=float(userDefault),
|
|
userMaximum=float(userMaximum),
|
|
)
|
|
if all(v is None for v in (userMinimum, userDefault, userMaximum)):
|
|
return self.rangeAxisSubsetDescriptorClass(name=name)
|
|
|
|
raise DesignSpaceDocumentError(
|
|
"axis-subset element must have min/max/default values or none at all."
|
|
)
|
|
|
|
def readSources(self):
|
|
for sourceCount, sourceElement in enumerate(
|
|
self.root.findall(".sources/source")
|
|
):
|
|
filename = sourceElement.attrib.get("filename")
|
|
if filename is not None and self.path is not None:
|
|
sourcePath = os.path.abspath(
|
|
os.path.join(os.path.dirname(self.path), filename)
|
|
)
|
|
else:
|
|
sourcePath = None
|
|
sourceName = sourceElement.attrib.get("name")
|
|
if sourceName is None:
|
|
# add a temporary source name
|
|
sourceName = "temp_master.%d" % (sourceCount)
|
|
sourceObject = self.sourceDescriptorClass()
|
|
sourceObject.path = sourcePath # absolute path to the ufo source
|
|
sourceObject.filename = filename # path as it is stored in the document
|
|
sourceObject.name = sourceName
|
|
familyName = sourceElement.attrib.get("familyname")
|
|
if familyName is not None:
|
|
sourceObject.familyName = familyName
|
|
styleName = sourceElement.attrib.get("stylename")
|
|
if styleName is not None:
|
|
sourceObject.styleName = styleName
|
|
for familyNameElement in sourceElement.findall("familyname"):
|
|
for key, lang in familyNameElement.items():
|
|
if key == XML_LANG:
|
|
familyName = familyNameElement.text
|
|
sourceObject.setFamilyName(familyName, lang)
|
|
designLocation, userLocation = self.locationFromElement(sourceElement)
|
|
if userLocation:
|
|
raise DesignSpaceDocumentError(
|
|
f'<source> element "{sourceName}" must only have design locations (using xvalue="").'
|
|
)
|
|
sourceObject.location = designLocation
|
|
layerName = sourceElement.attrib.get("layer")
|
|
if layerName is not None:
|
|
sourceObject.layerName = layerName
|
|
for libElement in sourceElement.findall(".lib"):
|
|
if libElement.attrib.get("copy") == "1":
|
|
sourceObject.copyLib = True
|
|
for groupsElement in sourceElement.findall(".groups"):
|
|
if groupsElement.attrib.get("copy") == "1":
|
|
sourceObject.copyGroups = True
|
|
for infoElement in sourceElement.findall(".info"):
|
|
if infoElement.attrib.get("copy") == "1":
|
|
sourceObject.copyInfo = True
|
|
if infoElement.attrib.get("mute") == "1":
|
|
sourceObject.muteInfo = True
|
|
for featuresElement in sourceElement.findall(".features"):
|
|
if featuresElement.attrib.get("copy") == "1":
|
|
sourceObject.copyFeatures = True
|
|
for glyphElement in sourceElement.findall(".glyph"):
|
|
glyphName = glyphElement.attrib.get("name")
|
|
if glyphName is None:
|
|
continue
|
|
if glyphElement.attrib.get("mute") == "1":
|
|
sourceObject.mutedGlyphNames.append(glyphName)
|
|
for kerningElement in sourceElement.findall(".kerning"):
|
|
if kerningElement.attrib.get("mute") == "1":
|
|
sourceObject.muteKerning = True
|
|
self.documentObject.sources.append(sourceObject)
|
|
|
|
def locationFromElement(self, element):
|
|
"""Read a nested ``<location>`` element inside the given ``element``.
|
|
|
|
.. versionchanged:: 5.0
|
|
Return a tuple of (designLocation, userLocation)
|
|
"""
|
|
elementLocation = (None, None)
|
|
for locationElement in element.findall(".location"):
|
|
elementLocation = self.readLocationElement(locationElement)
|
|
break
|
|
return elementLocation
|
|
|
|
def readLocationElement(self, locationElement):
|
|
"""Read a ``<location>`` element.
|
|
|
|
.. versionchanged:: 5.0
|
|
Return a tuple of (designLocation, userLocation)
|
|
"""
|
|
if self._strictAxisNames and not self.documentObject.axes:
|
|
raise DesignSpaceDocumentError("No axes defined")
|
|
userLoc = {}
|
|
designLoc = {}
|
|
for dimensionElement in locationElement.findall(".dimension"):
|
|
dimName = dimensionElement.attrib.get("name")
|
|
if self._strictAxisNames and dimName not in self.axisDefaults:
|
|
# In case the document contains no axis definitions,
|
|
self.log.warning('Location with undefined axis: "%s".', dimName)
|
|
continue
|
|
userValue = xValue = yValue = None
|
|
try:
|
|
userValue = dimensionElement.attrib.get("uservalue")
|
|
if userValue is not None:
|
|
userValue = float(userValue)
|
|
except ValueError:
|
|
self.log.warning(
|
|
"ValueError in readLocation userValue %3.3f", userValue
|
|
)
|
|
try:
|
|
xValue = dimensionElement.attrib.get("xvalue")
|
|
if xValue is not None:
|
|
xValue = float(xValue)
|
|
except ValueError:
|
|
self.log.warning("ValueError in readLocation xValue %3.3f", xValue)
|
|
try:
|
|
yValue = dimensionElement.attrib.get("yvalue")
|
|
if yValue is not None:
|
|
yValue = float(yValue)
|
|
except ValueError:
|
|
self.log.warning("ValueError in readLocation yValue %3.3f", yValue)
|
|
if userValue is None == xValue is None:
|
|
raise DesignSpaceDocumentError(
|
|
f'Exactly one of uservalue="" or xvalue="" must be provided for location dimension "{dimName}"'
|
|
)
|
|
if yValue is not None:
|
|
if xValue is None:
|
|
raise DesignSpaceDocumentError(
|
|
f'Missing xvalue="" for the location dimension "{dimName}"" with yvalue="{yValue}"'
|
|
)
|
|
designLoc[dimName] = (xValue, yValue)
|
|
elif xValue is not None:
|
|
designLoc[dimName] = xValue
|
|
else:
|
|
userLoc[dimName] = userValue
|
|
return designLoc, userLoc
|
|
|
|
def readInstances(self, makeGlyphs=True, makeKerning=True, makeInfo=True):
|
|
instanceElements = self.root.findall(".instances/instance")
|
|
for instanceElement in instanceElements:
|
|
self._readSingleInstanceElement(
|
|
instanceElement,
|
|
makeGlyphs=makeGlyphs,
|
|
makeKerning=makeKerning,
|
|
makeInfo=makeInfo,
|
|
)
|
|
|
|
def _readSingleInstanceElement(
|
|
self, instanceElement, makeGlyphs=True, makeKerning=True, makeInfo=True
|
|
):
|
|
filename = instanceElement.attrib.get("filename")
|
|
if filename is not None and self.documentObject.path is not None:
|
|
instancePath = os.path.join(
|
|
os.path.dirname(self.documentObject.path), filename
|
|
)
|
|
else:
|
|
instancePath = None
|
|
instanceObject = self.instanceDescriptorClass()
|
|
instanceObject.path = instancePath # absolute path to the instance
|
|
instanceObject.filename = filename # path as it is stored in the document
|
|
name = instanceElement.attrib.get("name")
|
|
if name is not None:
|
|
instanceObject.name = name
|
|
familyname = instanceElement.attrib.get("familyname")
|
|
if familyname is not None:
|
|
instanceObject.familyName = familyname
|
|
stylename = instanceElement.attrib.get("stylename")
|
|
if stylename is not None:
|
|
instanceObject.styleName = stylename
|
|
postScriptFontName = instanceElement.attrib.get("postscriptfontname")
|
|
if postScriptFontName is not None:
|
|
instanceObject.postScriptFontName = postScriptFontName
|
|
styleMapFamilyName = instanceElement.attrib.get("stylemapfamilyname")
|
|
if styleMapFamilyName is not None:
|
|
instanceObject.styleMapFamilyName = styleMapFamilyName
|
|
styleMapStyleName = instanceElement.attrib.get("stylemapstylename")
|
|
if styleMapStyleName is not None:
|
|
instanceObject.styleMapStyleName = styleMapStyleName
|
|
# read localised names
|
|
for styleNameElement in instanceElement.findall("stylename"):
|
|
for key, lang in styleNameElement.items():
|
|
if key == XML_LANG:
|
|
styleName = styleNameElement.text
|
|
instanceObject.setStyleName(styleName, lang)
|
|
for familyNameElement in instanceElement.findall("familyname"):
|
|
for key, lang in familyNameElement.items():
|
|
if key == XML_LANG:
|
|
familyName = familyNameElement.text
|
|
instanceObject.setFamilyName(familyName, lang)
|
|
for styleMapStyleNameElement in instanceElement.findall("stylemapstylename"):
|
|
for key, lang in styleMapStyleNameElement.items():
|
|
if key == XML_LANG:
|
|
styleMapStyleName = styleMapStyleNameElement.text
|
|
instanceObject.setStyleMapStyleName(styleMapStyleName, lang)
|
|
for styleMapFamilyNameElement in instanceElement.findall("stylemapfamilyname"):
|
|
for key, lang in styleMapFamilyNameElement.items():
|
|
if key == XML_LANG:
|
|
styleMapFamilyName = styleMapFamilyNameElement.text
|
|
instanceObject.setStyleMapFamilyName(styleMapFamilyName, lang)
|
|
designLocation, userLocation = self.locationFromElement(instanceElement)
|
|
locationLabel = instanceElement.attrib.get("location")
|
|
if (designLocation or userLocation) and locationLabel is not None:
|
|
raise DesignSpaceDocumentError(
|
|
'instance element must have at most one of the location="..." attribute or the nested location element'
|
|
)
|
|
instanceObject.locationLabel = locationLabel
|
|
instanceObject.userLocation = userLocation or {}
|
|
instanceObject.designLocation = designLocation or {}
|
|
for glyphElement in instanceElement.findall(".glyphs/glyph"):
|
|
self.readGlyphElement(glyphElement, instanceObject)
|
|
for infoElement in instanceElement.findall("info"):
|
|
self.readInfoElement(infoElement, instanceObject)
|
|
for libElement in instanceElement.findall("lib"):
|
|
self.readLibElement(libElement, instanceObject)
|
|
self.documentObject.instances.append(instanceObject)
|
|
|
|
def readLibElement(self, libElement, instanceObject):
|
|
"""Read the lib element for the given instance."""
|
|
instanceObject.lib = plistlib.fromtree(libElement[0])
|
|
|
|
def readInfoElement(self, infoElement, instanceObject):
|
|
"""Read the info element."""
|
|
instanceObject.info = True
|
|
|
|
def readGlyphElement(self, glyphElement, instanceObject):
|
|
"""
|
|
Read the glyph element, which could look like either one of these:
|
|
|
|
.. code-block:: xml
|
|
|
|
<glyph name="b" unicode="0x62"/>
|
|
|
|
<glyph name="b"/>
|
|
|
|
<glyph name="b">
|
|
<master location="location-token-bbb" source="master-token-aaa2"/>
|
|
<master glyphname="b.alt1" location="location-token-ccc" source="master-token-aaa3"/>
|
|
<note>
|
|
This is an instance from an anisotropic interpolation.
|
|
</note>
|
|
</glyph>
|
|
"""
|
|
glyphData = {}
|
|
glyphName = glyphElement.attrib.get("name")
|
|
if glyphName is None:
|
|
raise DesignSpaceDocumentError("Glyph object without name attribute")
|
|
mute = glyphElement.attrib.get("mute")
|
|
if mute == "1":
|
|
glyphData["mute"] = True
|
|
# unicode
|
|
unicodes = glyphElement.attrib.get("unicode")
|
|
if unicodes is not None:
|
|
try:
|
|
unicodes = [int(u, 16) for u in unicodes.split(" ")]
|
|
glyphData["unicodes"] = unicodes
|
|
except ValueError:
|
|
raise DesignSpaceDocumentError(
|
|
"unicode values %s are not integers" % unicodes
|
|
)
|
|
|
|
for noteElement in glyphElement.findall(".note"):
|
|
glyphData["note"] = noteElement.text
|
|
break
|
|
designLocation, userLocation = self.locationFromElement(glyphElement)
|
|
if userLocation:
|
|
raise DesignSpaceDocumentError(
|
|
f'<glyph> element "{glyphName}" must only have design locations (using xvalue="").'
|
|
)
|
|
if designLocation is not None:
|
|
glyphData["instanceLocation"] = designLocation
|
|
glyphSources = None
|
|
for masterElement in glyphElement.findall(".masters/master"):
|
|
fontSourceName = masterElement.attrib.get("source")
|
|
designLocation, userLocation = self.locationFromElement(masterElement)
|
|
if userLocation:
|
|
raise DesignSpaceDocumentError(
|
|
f'<master> element "{fontSourceName}" must only have design locations (using xvalue="").'
|
|
)
|
|
masterGlyphName = masterElement.attrib.get("glyphname")
|
|
if masterGlyphName is None:
|
|
# if we don't read a glyphname, use the one we have
|
|
masterGlyphName = glyphName
|
|
d = dict(
|
|
font=fontSourceName, location=designLocation, glyphName=masterGlyphName
|
|
)
|
|
if glyphSources is None:
|
|
glyphSources = []
|
|
glyphSources.append(d)
|
|
if glyphSources is not None:
|
|
glyphData["masters"] = glyphSources
|
|
instanceObject.glyphs[glyphName] = glyphData
|
|
|
|
def readLib(self):
|
|
"""Read the lib element for the whole document."""
|
|
for libElement in self.root.findall(".lib"):
|
|
self.documentObject.lib = plistlib.fromtree(libElement[0])
|
|
|
|
|
|
class DesignSpaceDocument(LogMixin, AsDictMixin):
|
|
"""The DesignSpaceDocument object can read and write ``.designspace`` data.
|
|
It imports the axes, sources, variable fonts and instances to very basic
|
|
**descriptor** objects that store the data in attributes. Data is added to
|
|
the document by creating such descriptor objects, filling them with data
|
|
and then adding them to the document. This makes it easy to integrate this
|
|
object in different contexts.
|
|
|
|
The **DesignSpaceDocument** object can be subclassed to work with
|
|
different objects, as long as they have the same attributes. Reader and
|
|
Writer objects can be subclassed as well.
|
|
|
|
**Note:** Python attribute names are usually camelCased, the
|
|
corresponding `XML <document-xml-structure>`_ attributes are usually
|
|
all lowercase.
|
|
|
|
.. code:: python
|
|
|
|
from fontTools.designspaceLib import DesignSpaceDocument
|
|
doc = DesignSpaceDocument.fromfile("some/path/to/my.designspace")
|
|
doc.formatVersion
|
|
doc.elidedFallbackName
|
|
doc.axes
|
|
doc.axisMappings
|
|
doc.locationLabels
|
|
doc.rules
|
|
doc.rulesProcessingLast
|
|
doc.sources
|
|
doc.variableFonts
|
|
doc.instances
|
|
doc.lib
|
|
|
|
"""
|
|
|
|
def __init__(self, readerClass=None, writerClass=None):
|
|
self.path = None
|
|
"""String, optional. When the document is read from the disk, this is
|
|
the full path that was given to :meth:`read` or :meth:`fromfile`.
|
|
"""
|
|
self.filename = None
|
|
"""String, optional. When the document is read from the disk, this is
|
|
its original file name, i.e. the last part of its path.
|
|
|
|
When the document is produced by a Python script and still only exists
|
|
in memory, the producing script can write here an indication of a
|
|
possible "good" filename, in case one wants to save the file somewhere.
|
|
"""
|
|
|
|
self.formatVersion: Optional[str] = None
|
|
"""Format version for this document, as a string. E.g. "4.0" """
|
|
|
|
self.elidedFallbackName: Optional[str] = None
|
|
"""STAT Style Attributes Header field ``elidedFallbackNameID``.
|
|
|
|
See: `OTSpec STAT Style Attributes Header <https://docs.microsoft.com/en-us/typography/opentype/spec/stat#style-attributes-header>`_
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
|
|
self.axes: List[Union[AxisDescriptor, DiscreteAxisDescriptor]] = []
|
|
"""List of this document's axes."""
|
|
|
|
self.axisMappings: List[AxisMappingDescriptor] = []
|
|
"""List of this document's axis mappings."""
|
|
|
|
self.locationLabels: List[LocationLabelDescriptor] = []
|
|
"""List of this document's STAT format 4 labels.
|
|
|
|
.. versionadded:: 5.0"""
|
|
self.rules: List[RuleDescriptor] = []
|
|
"""List of this document's rules."""
|
|
self.rulesProcessingLast: bool = False
|
|
"""This flag indicates whether the substitution rules should be applied
|
|
before or after other glyph substitution features.
|
|
|
|
- False: before
|
|
- True: after.
|
|
|
|
Default is False. For new projects, you probably want True. See
|
|
the following issues for more information:
|
|
`fontTools#1371 <https://github.com/fonttools/fonttools/issues/1371#issuecomment-590214572>`__
|
|
`fontTools#2050 <https://github.com/fonttools/fonttools/issues/2050#issuecomment-678691020>`__
|
|
|
|
If you want to use a different feature altogether, e.g. ``calt``,
|
|
use the lib key ``com.github.fonttools.varLib.featureVarsFeatureTag``
|
|
|
|
.. code:: xml
|
|
|
|
<lib>
|
|
<dict>
|
|
<key>com.github.fonttools.varLib.featureVarsFeatureTag</key>
|
|
<string>calt</string>
|
|
</dict>
|
|
</lib>
|
|
"""
|
|
self.sources: List[SourceDescriptor] = []
|
|
"""List of this document's sources."""
|
|
self.variableFonts: List[VariableFontDescriptor] = []
|
|
"""List of this document's variable fonts.
|
|
|
|
.. versionadded:: 5.0"""
|
|
self.instances: List[InstanceDescriptor] = []
|
|
"""List of this document's instances."""
|
|
self.lib: Dict = {}
|
|
"""User defined, custom data associated with the whole document.
|
|
|
|
Use reverse-DNS notation to identify your own data.
|
|
Respect the data stored by others.
|
|
"""
|
|
|
|
self.default: Optional[str] = None
|
|
"""Name of the default master.
|
|
|
|
This attribute is updated by the :meth:`findDefault`
|
|
"""
|
|
|
|
if readerClass is not None:
|
|
self.readerClass = readerClass
|
|
else:
|
|
self.readerClass = BaseDocReader
|
|
if writerClass is not None:
|
|
self.writerClass = writerClass
|
|
else:
|
|
self.writerClass = BaseDocWriter
|
|
|
|
@classmethod
|
|
def fromfile(cls, path, readerClass=None, writerClass=None):
|
|
"""Read a designspace file from ``path`` and return a new instance of
|
|
:class:.
|
|
"""
|
|
self = cls(readerClass=readerClass, writerClass=writerClass)
|
|
self.read(path)
|
|
return self
|
|
|
|
@classmethod
|
|
def fromstring(cls, string, readerClass=None, writerClass=None):
|
|
self = cls(readerClass=readerClass, writerClass=writerClass)
|
|
reader = self.readerClass.fromstring(string, self)
|
|
reader.read()
|
|
if self.sources:
|
|
self.findDefault()
|
|
return self
|
|
|
|
def tostring(self, encoding=None):
|
|
"""Returns the designspace as a string. Default encoding ``utf-8``."""
|
|
if encoding is str or (encoding is not None and encoding.lower() == "unicode"):
|
|
f = StringIO()
|
|
xml_declaration = False
|
|
elif encoding is None or encoding == "utf-8":
|
|
f = BytesIO()
|
|
encoding = "UTF-8"
|
|
xml_declaration = True
|
|
else:
|
|
raise ValueError("unsupported encoding: '%s'" % encoding)
|
|
writer = self.writerClass(f, self)
|
|
writer.write(encoding=encoding, xml_declaration=xml_declaration)
|
|
return f.getvalue()
|
|
|
|
def read(self, path):
|
|
"""Read a designspace file from ``path`` and populates the fields of
|
|
``self`` with the data.
|
|
"""
|
|
if hasattr(path, "__fspath__"): # support os.PathLike objects
|
|
path = path.__fspath__()
|
|
self.path = path
|
|
self.filename = os.path.basename(path)
|
|
reader = self.readerClass(path, self)
|
|
reader.read()
|
|
if self.sources:
|
|
self.findDefault()
|
|
|
|
def write(self, path):
|
|
"""Write this designspace to ``path``."""
|
|
if hasattr(path, "__fspath__"): # support os.PathLike objects
|
|
path = path.__fspath__()
|
|
self.path = path
|
|
self.filename = os.path.basename(path)
|
|
self.updatePaths()
|
|
writer = self.writerClass(path, self)
|
|
writer.write()
|
|
|
|
def _posixRelativePath(self, otherPath):
|
|
relative = os.path.relpath(otherPath, os.path.dirname(self.path))
|
|
return posix(relative)
|
|
|
|
def updatePaths(self):
|
|
"""
|
|
Right before we save we need to identify and respond to the following situations:
|
|
In each descriptor, we have to do the right thing for the filename attribute.
|
|
|
|
::
|
|
|
|
case 1.
|
|
descriptor.filename == None
|
|
descriptor.path == None
|
|
|
|
-- action:
|
|
write as is, descriptors will not have a filename attr.
|
|
useless, but no reason to interfere.
|
|
|
|
|
|
case 2.
|
|
descriptor.filename == "../something"
|
|
descriptor.path == None
|
|
|
|
-- action:
|
|
write as is. The filename attr should not be touched.
|
|
|
|
|
|
case 3.
|
|
descriptor.filename == None
|
|
descriptor.path == "~/absolute/path/there"
|
|
|
|
-- action:
|
|
calculate the relative path for filename.
|
|
We're not overwriting some other value for filename, it should be fine
|
|
|
|
|
|
case 4.
|
|
descriptor.filename == '../somewhere'
|
|
descriptor.path == "~/absolute/path/there"
|
|
|
|
-- action:
|
|
there is a conflict between the given filename, and the path.
|
|
So we know where the file is relative to the document.
|
|
Can't guess why they're different, we just choose for path to be correct and update filename.
|
|
"""
|
|
assert self.path is not None
|
|
for descriptor in self.sources + self.instances:
|
|
if descriptor.path is not None:
|
|
# case 3 and 4: filename gets updated and relativized
|
|
descriptor.filename = self._posixRelativePath(descriptor.path)
|
|
|
|
def addSource(self, sourceDescriptor: SourceDescriptor):
|
|
"""Add the given ``sourceDescriptor`` to ``doc.sources``."""
|
|
self.sources.append(sourceDescriptor)
|
|
|
|
def addSourceDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`SourceDescriptor` using the given
|
|
``kwargs`` and add it to ``doc.sources``.
|
|
"""
|
|
source = self.writerClass.sourceDescriptorClass(**kwargs)
|
|
self.addSource(source)
|
|
return source
|
|
|
|
def addInstance(self, instanceDescriptor: InstanceDescriptor):
|
|
"""Add the given ``instanceDescriptor`` to :attr:`instances`."""
|
|
self.instances.append(instanceDescriptor)
|
|
|
|
def addInstanceDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`InstanceDescriptor` using the given
|
|
``kwargs`` and add it to :attr:`instances`.
|
|
"""
|
|
instance = self.writerClass.instanceDescriptorClass(**kwargs)
|
|
self.addInstance(instance)
|
|
return instance
|
|
|
|
def addAxis(self, axisDescriptor: Union[AxisDescriptor, DiscreteAxisDescriptor]):
|
|
"""Add the given ``axisDescriptor`` to :attr:`axes`."""
|
|
self.axes.append(axisDescriptor)
|
|
|
|
def addAxisDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`AxisDescriptor` using the given
|
|
``kwargs`` and add it to :attr:`axes`.
|
|
|
|
The axis will be and instance of :class:`DiscreteAxisDescriptor` if
|
|
the ``kwargs`` provide a ``value``, or a :class:`AxisDescriptor` otherwise.
|
|
"""
|
|
if "values" in kwargs:
|
|
axis = self.writerClass.discreteAxisDescriptorClass(**kwargs)
|
|
else:
|
|
axis = self.writerClass.axisDescriptorClass(**kwargs)
|
|
self.addAxis(axis)
|
|
return axis
|
|
|
|
def addAxisMapping(self, axisMappingDescriptor: AxisMappingDescriptor):
|
|
"""Add the given ``axisMappingDescriptor`` to :attr:`axisMappings`."""
|
|
self.axisMappings.append(axisMappingDescriptor)
|
|
|
|
def addAxisMappingDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`AxisMappingDescriptor` using the given
|
|
``kwargs`` and add it to :attr:`rules`.
|
|
"""
|
|
axisMapping = self.writerClass.axisMappingDescriptorClass(**kwargs)
|
|
self.addAxisMapping(axisMapping)
|
|
return axisMapping
|
|
|
|
def addRule(self, ruleDescriptor: RuleDescriptor):
|
|
"""Add the given ``ruleDescriptor`` to :attr:`rules`."""
|
|
self.rules.append(ruleDescriptor)
|
|
|
|
def addRuleDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`RuleDescriptor` using the given
|
|
``kwargs`` and add it to :attr:`rules`.
|
|
"""
|
|
rule = self.writerClass.ruleDescriptorClass(**kwargs)
|
|
self.addRule(rule)
|
|
return rule
|
|
|
|
def addVariableFont(self, variableFontDescriptor: VariableFontDescriptor):
|
|
"""Add the given ``variableFontDescriptor`` to :attr:`variableFonts`.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.variableFonts.append(variableFontDescriptor)
|
|
|
|
def addVariableFontDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`VariableFontDescriptor` using the given
|
|
``kwargs`` and add it to :attr:`variableFonts`.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
variableFont = self.writerClass.variableFontDescriptorClass(**kwargs)
|
|
self.addVariableFont(variableFont)
|
|
return variableFont
|
|
|
|
def addLocationLabel(self, locationLabelDescriptor: LocationLabelDescriptor):
|
|
"""Add the given ``locationLabelDescriptor`` to :attr:`locationLabels`.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
self.locationLabels.append(locationLabelDescriptor)
|
|
|
|
def addLocationLabelDescriptor(self, **kwargs):
|
|
"""Instantiate a new :class:`LocationLabelDescriptor` using the given
|
|
``kwargs`` and add it to :attr:`locationLabels`.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
locationLabel = self.writerClass.locationLabelDescriptorClass(**kwargs)
|
|
self.addLocationLabel(locationLabel)
|
|
return locationLabel
|
|
|
|
def newDefaultLocation(self):
|
|
"""Return a dict with the default location in design space coordinates."""
|
|
# Without OrderedDict, output XML would be non-deterministic.
|
|
# https://github.com/LettError/designSpaceDocument/issues/10
|
|
loc = collections.OrderedDict()
|
|
for axisDescriptor in self.axes:
|
|
loc[axisDescriptor.name] = axisDescriptor.map_forward(
|
|
axisDescriptor.default
|
|
)
|
|
return loc
|
|
|
|
def labelForUserLocation(
|
|
self, userLocation: SimpleLocationDict
|
|
) -> Optional[LocationLabelDescriptor]:
|
|
"""Return the :class:`LocationLabel` that matches the given
|
|
``userLocation``, or ``None`` if no such label exists.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return next(
|
|
(
|
|
label
|
|
for label in self.locationLabels
|
|
if label.userLocation == userLocation
|
|
),
|
|
None,
|
|
)
|
|
|
|
def updateFilenameFromPath(self, masters=True, instances=True, force=False):
|
|
"""Set a descriptor filename attr from the path and this document path.
|
|
|
|
If the filename attribute is not None: skip it.
|
|
"""
|
|
if masters:
|
|
for descriptor in self.sources:
|
|
if descriptor.filename is not None and not force:
|
|
continue
|
|
if self.path is not None:
|
|
descriptor.filename = self._posixRelativePath(descriptor.path)
|
|
if instances:
|
|
for descriptor in self.instances:
|
|
if descriptor.filename is not None and not force:
|
|
continue
|
|
if self.path is not None:
|
|
descriptor.filename = self._posixRelativePath(descriptor.path)
|
|
|
|
def newAxisDescriptor(self):
|
|
"""Ask the writer class to make us a new axisDescriptor."""
|
|
return self.writerClass.getAxisDecriptor()
|
|
|
|
def newSourceDescriptor(self):
|
|
"""Ask the writer class to make us a new sourceDescriptor."""
|
|
return self.writerClass.getSourceDescriptor()
|
|
|
|
def newInstanceDescriptor(self):
|
|
"""Ask the writer class to make us a new instanceDescriptor."""
|
|
return self.writerClass.getInstanceDescriptor()
|
|
|
|
def getAxisOrder(self):
|
|
"""Return a list of axis names, in the same order as defined in the document."""
|
|
names = []
|
|
for axisDescriptor in self.axes:
|
|
names.append(axisDescriptor.name)
|
|
return names
|
|
|
|
def getAxis(self, name: str) -> AxisDescriptor | DiscreteAxisDescriptor | None:
|
|
"""Return the axis with the given ``name``, or ``None`` if no such axis exists."""
|
|
return next((axis for axis in self.axes if axis.name == name), None)
|
|
|
|
def getAxisByTag(self, tag: str) -> AxisDescriptor | DiscreteAxisDescriptor | None:
|
|
"""Return the axis with the given ``tag``, or ``None`` if no such axis exists."""
|
|
return next((axis for axis in self.axes if axis.tag == tag), None)
|
|
|
|
def getLocationLabel(self, name: str) -> Optional[LocationLabelDescriptor]:
|
|
"""Return the top-level location label with the given ``name``, or
|
|
``None`` if no such label exists.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
for label in self.locationLabels:
|
|
if label.name == name:
|
|
return label
|
|
return None
|
|
|
|
def map_forward(self, userLocation: SimpleLocationDict) -> SimpleLocationDict:
|
|
"""Map a user location to a design location.
|
|
|
|
Assume that missing coordinates are at the default location for that axis.
|
|
|
|
Note: the output won't be anisotropic, only the xvalue is set.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return {
|
|
axis.name: axis.map_forward(userLocation.get(axis.name, axis.default))
|
|
for axis in self.axes
|
|
}
|
|
|
|
def map_backward(
|
|
self, designLocation: AnisotropicLocationDict
|
|
) -> SimpleLocationDict:
|
|
"""Map a design location to a user location.
|
|
|
|
Assume that missing coordinates are at the default location for that axis.
|
|
|
|
When the input has anisotropic locations, only the xvalue is used.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return {
|
|
axis.name: (
|
|
axis.map_backward(designLocation[axis.name])
|
|
if axis.name in designLocation
|
|
else axis.default
|
|
)
|
|
for axis in self.axes
|
|
}
|
|
|
|
def findDefault(self):
|
|
"""Set and return SourceDescriptor at the default location or None.
|
|
|
|
The default location is the set of all `default` values in user space
|
|
of all axes.
|
|
|
|
This function updates the document's :attr:`default` value.
|
|
|
|
.. versionchanged:: 5.0
|
|
Allow the default source to not specify some of the axis values, and
|
|
they are assumed to be the default.
|
|
See :meth:`SourceDescriptor.getFullDesignLocation()`
|
|
"""
|
|
self.default = None
|
|
|
|
# Convert the default location from user space to design space before comparing
|
|
# it against the SourceDescriptor locations (always in design space).
|
|
defaultDesignLocation = self.newDefaultLocation()
|
|
|
|
for sourceDescriptor in self.sources:
|
|
if sourceDescriptor.getFullDesignLocation(self) == defaultDesignLocation:
|
|
self.default = sourceDescriptor
|
|
return sourceDescriptor
|
|
|
|
return None
|
|
|
|
def normalizeLocation(self, location):
|
|
"""Return a dict with normalized axis values."""
|
|
from fontTools.varLib.models import normalizeValue
|
|
|
|
new = {}
|
|
for axis in self.axes:
|
|
if axis.name not in location:
|
|
# skipping this dimension it seems
|
|
continue
|
|
value = location[axis.name]
|
|
# 'anisotropic' location, take first coord only
|
|
if isinstance(value, tuple):
|
|
value = value[0]
|
|
triple = [
|
|
axis.map_forward(v) for v in (axis.minimum, axis.default, axis.maximum)
|
|
]
|
|
new[axis.name] = normalizeValue(value, triple)
|
|
return new
|
|
|
|
def normalize(self):
|
|
"""
|
|
Normalise the geometry of this designspace:
|
|
|
|
- scale all the locations of all masters and instances to the -1 - 0 - 1 value.
|
|
- we need the axis data to do the scaling, so we do those last.
|
|
"""
|
|
# masters
|
|
for item in self.sources:
|
|
item.location = self.normalizeLocation(item.location)
|
|
# instances
|
|
for item in self.instances:
|
|
# glyph masters for this instance
|
|
for _, glyphData in item.glyphs.items():
|
|
glyphData["instanceLocation"] = self.normalizeLocation(
|
|
glyphData["instanceLocation"]
|
|
)
|
|
for glyphMaster in glyphData["masters"]:
|
|
glyphMaster["location"] = self.normalizeLocation(
|
|
glyphMaster["location"]
|
|
)
|
|
item.location = self.normalizeLocation(item.location)
|
|
# the axes
|
|
for axis in self.axes:
|
|
# scale the map first
|
|
newMap = []
|
|
for inputValue, outputValue in axis.map:
|
|
newOutputValue = self.normalizeLocation({axis.name: outputValue}).get(
|
|
axis.name
|
|
)
|
|
newMap.append((inputValue, newOutputValue))
|
|
if newMap:
|
|
axis.map = newMap
|
|
# finally the axis values
|
|
minimum = self.normalizeLocation({axis.name: axis.minimum}).get(axis.name)
|
|
maximum = self.normalizeLocation({axis.name: axis.maximum}).get(axis.name)
|
|
default = self.normalizeLocation({axis.name: axis.default}).get(axis.name)
|
|
# and set them in the axis.minimum
|
|
axis.minimum = minimum
|
|
axis.maximum = maximum
|
|
axis.default = default
|
|
# now the rules
|
|
for rule in self.rules:
|
|
newConditionSets = []
|
|
for conditions in rule.conditionSets:
|
|
newConditions = []
|
|
for cond in conditions:
|
|
if cond.get("minimum") is not None:
|
|
minimum = self.normalizeLocation(
|
|
{cond["name"]: cond["minimum"]}
|
|
).get(cond["name"])
|
|
else:
|
|
minimum = None
|
|
if cond.get("maximum") is not None:
|
|
maximum = self.normalizeLocation(
|
|
{cond["name"]: cond["maximum"]}
|
|
).get(cond["name"])
|
|
else:
|
|
maximum = None
|
|
newConditions.append(
|
|
dict(name=cond["name"], minimum=minimum, maximum=maximum)
|
|
)
|
|
newConditionSets.append(newConditions)
|
|
rule.conditionSets = newConditionSets
|
|
|
|
def loadSourceFonts(self, opener, **kwargs):
|
|
"""Ensure SourceDescriptor.font attributes are loaded, and return list of fonts.
|
|
|
|
Takes a callable which initializes a new font object (e.g. TTFont, or
|
|
defcon.Font, etc.) from the SourceDescriptor.path, and sets the
|
|
SourceDescriptor.font attribute.
|
|
If the font attribute is already not None, it is not loaded again.
|
|
Fonts with the same path are only loaded once and shared among SourceDescriptors.
|
|
|
|
For example, to load UFO sources using defcon:
|
|
|
|
designspace = DesignSpaceDocument.fromfile("path/to/my.designspace")
|
|
designspace.loadSourceFonts(defcon.Font)
|
|
|
|
Or to load masters as FontTools binary fonts, including extra options:
|
|
|
|
designspace.loadSourceFonts(ttLib.TTFont, recalcBBoxes=False)
|
|
|
|
Args:
|
|
opener (Callable): takes one required positional argument, the source.path,
|
|
and an optional list of keyword arguments, and returns a new font object
|
|
loaded from the path.
|
|
**kwargs: extra options passed on to the opener function.
|
|
|
|
Returns:
|
|
List of font objects in the order they appear in the sources list.
|
|
"""
|
|
# we load fonts with the same source.path only once
|
|
loaded = {}
|
|
fonts = []
|
|
for source in self.sources:
|
|
if source.font is not None: # font already loaded
|
|
fonts.append(source.font)
|
|
continue
|
|
if source.path in loaded:
|
|
source.font = loaded[source.path]
|
|
else:
|
|
if source.path is None:
|
|
raise DesignSpaceDocumentError(
|
|
"Designspace source '%s' has no 'path' attribute"
|
|
% (source.name or "<Unknown>")
|
|
)
|
|
source.font = opener(source.path, **kwargs)
|
|
loaded[source.path] = source.font
|
|
fonts.append(source.font)
|
|
return fonts
|
|
|
|
@property
|
|
def formatTuple(self):
|
|
"""Return the formatVersion as a tuple of (major, minor).
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
if self.formatVersion is None:
|
|
return (5, 0)
|
|
numbers = (int(i) for i in self.formatVersion.split("."))
|
|
major = next(numbers)
|
|
minor = next(numbers, 0)
|
|
return (major, minor)
|
|
|
|
def getVariableFonts(self) -> List[VariableFontDescriptor]:
|
|
"""Return all variable fonts defined in this document, or implicit
|
|
variable fonts that can be built from the document's continuous axes.
|
|
|
|
In the case of Designspace documents before version 5, the whole
|
|
document was implicitly describing a variable font that covers the
|
|
whole space.
|
|
|
|
In version 5 and above documents, there can be as many variable fonts
|
|
as there are locations on discrete axes.
|
|
|
|
.. seealso:: :func:`splitInterpolable`
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
if self.variableFonts:
|
|
return self.variableFonts
|
|
|
|
variableFonts = []
|
|
discreteAxes = []
|
|
rangeAxisSubsets: List[
|
|
Union[RangeAxisSubsetDescriptor, ValueAxisSubsetDescriptor]
|
|
] = []
|
|
for axis in self.axes:
|
|
if hasattr(axis, "values"):
|
|
# Mypy doesn't support narrowing union types via hasattr()
|
|
# TODO(Python 3.10): use TypeGuard
|
|
# https://mypy.readthedocs.io/en/stable/type_narrowing.html
|
|
axis = cast(DiscreteAxisDescriptor, axis)
|
|
discreteAxes.append(axis) # type: ignore
|
|
else:
|
|
rangeAxisSubsets.append(RangeAxisSubsetDescriptor(name=axis.name))
|
|
valueCombinations = itertools.product(*[axis.values for axis in discreteAxes])
|
|
for values in valueCombinations:
|
|
basename = None
|
|
if self.filename is not None:
|
|
basename = os.path.splitext(self.filename)[0] + "-VF"
|
|
if self.path is not None:
|
|
basename = os.path.splitext(os.path.basename(self.path))[0] + "-VF"
|
|
if basename is None:
|
|
basename = "VF"
|
|
axisNames = "".join(
|
|
[f"-{axis.tag}{value}" for axis, value in zip(discreteAxes, values)]
|
|
)
|
|
variableFonts.append(
|
|
VariableFontDescriptor(
|
|
name=f"{basename}{axisNames}",
|
|
axisSubsets=rangeAxisSubsets
|
|
+ [
|
|
ValueAxisSubsetDescriptor(name=axis.name, userValue=value)
|
|
for axis, value in zip(discreteAxes, values)
|
|
],
|
|
)
|
|
)
|
|
return variableFonts
|
|
|
|
def deepcopyExceptFonts(self):
|
|
"""Allow deep-copying a DesignSpace document without deep-copying
|
|
attached UFO fonts or TTFont objects. The :attr:`font` attribute
|
|
is shared by reference between the original and the copy.
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
fonts = [source.font for source in self.sources]
|
|
try:
|
|
for source in self.sources:
|
|
source.font = None
|
|
res = copy.deepcopy(self)
|
|
for source, font in zip(res.sources, fonts):
|
|
source.font = font
|
|
return res
|
|
finally:
|
|
for source, font in zip(self.sources, fonts):
|
|
source.font = font
|
|
|
|
|
|
def main(args=None):
|
|
"""Roundtrip .designspace file through the DesignSpaceDocument class"""
|
|
|
|
if args is None:
|
|
import sys
|
|
|
|
args = sys.argv[1:]
|
|
|
|
from argparse import ArgumentParser
|
|
|
|
parser = ArgumentParser(prog="designspaceLib", description=main.__doc__)
|
|
parser.add_argument("input")
|
|
parser.add_argument("output")
|
|
|
|
options = parser.parse_args(args)
|
|
|
|
ds = DesignSpaceDocument.fromfile(options.input)
|
|
ds.write(options.output)
|