Source code for enaml.fonts

# Copyright (c) 2013-2018, Nucleic Development Team.
# Distributed under the terms of the Modified BSD License.
# The full license is in the file LICENSE, distributed with this software.
""" A utility module for dealing with CSS3 font strings.


from atom.api import Coerced

from .fontext import Font, FontStyle, FontCaps, FontStretch

#: A mapping from CSS font style keyword to style enum
    'normal': FontStyle.Normal,
    'italic': FontStyle.Italic,
    'oblique': FontStyle.Oblique,

#: A mapping from CSS font strecth keyword to style enum
    'ultra-condensed': FontStretch.UltraCondensed,
    'extra-condensed': FontStretch.ExtraCondensed,
    'condensed': FontStretch.Condensed,
    'semi-condensed': FontStretch.SemiCondensed,
    'normal': FontStretch.Unstretched,
    'semi-expanded': FontStretch.SemiExpanded,
    'expanded': FontStretch.Expanded,
    'extra-expanded': FontStretch.ExtraExpanded,
    'ultra-expanded': FontStretch.UltraExpanded,

#: A mapping from CSS font variant keyword to caps enum
    'normal': FontCaps.MixedCase,
    'small-caps':  FontCaps.SmallCaps,

#: A mapping from CSS font weight to integer weight. These values are
#: pulled from the Qt stylesheet implementation of font parsing. Enaml
#: does not support the 'bolder' and 'lighter' keywords.
    '100': 12,
    '200': 25,
    '300': 37,
    '400': 50,
    '500': 62,
    '600': 75,
    '700': 87,
    '800': 99,
    '900': 99,
    'normal': 50,
    'bold': 75,

#: A mapping from CSS font size keywords to font point sizes. These are
#: based on a standard 12 point font size.
_SIZES = {
    'xx-small': 7,
    'x-small': 8,
    'small': 9,
    'medium': 12,
    'large': 14,
    'x-large': 18,
    'xx-large': 24,

#: A mapping from CSS font units to functions which convert to points.
_UNITS = {
    'in': lambda size: int(size * 72.0),
    'cm': lambda size: int(size * 72.0 / 2.54),
    'mm': lambda size: int(size * 72.0 / 254.0),
    'pt': lambda size: int(size),
    'pc': lambda size: int(size * 12.0),
    'px': lambda size: int(size * 0.75),

[docs] def parse_font(font): """ Parse a CSS3 shorthand font string into an Enaml Font object. Returns ------- result : Font or None A font object representing the parsed font. If the string is invalid, None will be returned. """ token = [] tokens = [] quotechar = None for char in font: if quotechar is not None: if char == quotechar: tokens.append(''.join(token)) token = [] quotechar = None else: token.append(char) elif char == '"' or char == "'": quotechar = char elif char in ' \t': if token: tokens.append(''.join(token)) token = [] else: token.append(char) # Failed to close quoted string. if quotechar is not None: return if token: tokens.append(''.join(token)) sizes = [] families = [] optionals = [] for token in tokens: if (token in _STYLES or token in _VARIANTS or token in _WEIGHTS or token in _STRETCH): optionals.append(token) elif token in _SIZES or token[-2:] in _UNITS: sizes.append(token) else: families.append(token) if len(optionals) > 4: return None if len(sizes) != 1: return None if len(families) != 1: return None style = None variant = None weight = None stretch = None for opt in optionals: if opt == 'normal': continue elif opt in _STYLES: if style is not None: return None style = opt elif opt in _VARIANTS: if variant is not None: return None variant = opt elif opt in _WEIGHTS: if weight is not None: return None weight = opt elif opt in _STRETCH: if stretch is not None: return None stretch = opt else: return None size = sizes[0] if size in _SIZES: size = _SIZES[size] else: sizenum, units = size[:-2], size[-2:] try: sizenum = float(sizenum) except ValueError: return None size = _UNITS[units](sizenum) family = str(families[0]) weight = _WEIGHTS[weight] if weight else _WEIGHTS['normal'] style = _STYLES[style] if style else _STYLES['normal'] variant = _VARIANTS[variant] if variant else _VARIANTS['normal'] stretch = _STRETCH[stretch] if stretch else _STRETCH['normal'] return Font(family, size, weight, style, variant, stretch)
def coerce_font(font): """ The coercing function for the FontMember. """ if isinstance(font, str): return parse_font(font) class FontMember(Coerced): """ An Atom member class which coerces a value to a font. A font member can be set to a Font, a string, or None. A string font will be parsed into a Font object. If the parsing fails, the font will be None. Font strings must be given in CSS grammar, e.g. 'bold 12pt arial', which is order dependant. The order is the following: style variant weight stretch size family """ __slots__ = () def __init__(self, default=None, factory=None): """ Initialize a FontMember. default : Font, string, or None, optional The default font to use for the member. factory : callable, optional An optional callable which takes no arguments and returns the default value for the member. If this is provided, it will override any value passed as 'default'. Notes ----- When providing a default font value, prefer using a Font object directly as this object will be shared among all instances of the class. Using a font string will result in a new Font object being created for each class instance. """ if factory is None: factory = lambda: default kind = (Font, type(None)) sup = super(FontMember, self) sup.__init__(kind, factory=factory, coercer=coerce_font)