Font trait and parser

pyface/font.py

@@ -368,7 +368,7 @@ def to_toolkit(self):
         return font_to_toolkit_font(self)
 
     def __str__(self):
-        """ Produce a CSS-style representation of the font. """
+        """ Produce a CSS2-style representation of the font. """
         terms = []
         if self.style != 'normal':
             terms.append(self.style)

pyface/tests/test_ui_traits.py

@@ -12,6 +12,8 @@
 import os
 import unittest
 
+from pyface.util.font_parser import simple_parser
+
 # importlib.resources is new in Python 3.7, and importlib.resources.files is
 # new in Python 3.9, so for Python < 3.9 we must rely on the 3rd party
 # importlib_resources package.
@@ -30,6 +32,7 @@
 from traits.testing.api import UnittestTools
 
 from ..color import Color
+from ..font import Font
 from ..image_resource import ImageResource
 from ..ui_traits import (
     Border,
@@ -38,6 +41,7 @@
     Image,
     Margin,
     PyfaceColor,
+    PyfaceFont,
     image_resource_cache,
     image_bitmap_cache,
 )
@@ -56,6 +60,11 @@ class ColorClass(HasTraits):
     color = PyfaceColor()
 
 
+class FontClass(HasTraits):
+
+    font = PyfaceFont()
+
+
 class HasMarginClass(HasTraits):
 
     margin = HasMargin
@@ -354,6 +363,130 @@ def test_set_structured_dtype(self):
         self.assertEqual(color_class.color, color)
 
 
+class TestPyfaceFont(unittest.TestCase):
+
+    def test_init(self):
+        trait = PyfaceFont()
+        self.assertEqual(trait.default_value, (Font, (), {}))
+        self.assertEqual(
+            trait.default_value_type,
+            DefaultValue.callable_and_args,
+        )
+
+    def test_init_empty_string(self):
+        trait = PyfaceFont("")
+        self.assertEqual(
+            trait.default_value,
+            (
+                Font,
+                (),
+                {
+                    'family': ["default"],
+                    'size': 12.0,
+                    'weight': "normal",
+                    'stretch': 100,
+                    'style': "normal",
+                    'variants': set(),
+                    'decorations': set(),
+                },
+            )
+        )
+
+    def test_init_empty_string(self):
+        trait = PyfaceFont(
+            "10 pt bold condensed italic underline Helvetica sans-serif")
+        self.assertEqual(
+            trait.default_value,
+            (
+                Font,
+                (),
+                {
+                    'family': ["helvetica", "sans-serif"],
+                    'size': 10.0,
+                    'weight': "bold",
+                    'stretch': 75.0,
+                    'style': "italic",
+                    'variants': set(),
+                    'decorations': {"underline"},
+                },
+            )
+        )
+
+    def test_init_font(self):
+        font = Font(
+            family=["helvetica", "sans-serif"],
+            size=10.0,
+            weight="bold",
+            stretch=75.0,
+            style="italic",
+            variants=set(),
+            decorations={"underline"},
+        )
+        trait = PyfaceFont(font)
+        self.assertEqual(
+            trait.default_value,
+            (
+                Font,
+                (),
+                {
+                    'family': ["helvetica", "sans-serif"],
+                    'size': 10.0,
+                    'weight': "bold",
+                    'stretch': 75.0,
+                    'style': "italic",
+                    'variants': set(),
+                    'decorations': {"underline"},
+                },
+            )
+        )
+
+    def test_set_empty_string(self):
+        font_class = FontClass()
+        font_class.font = ""
+        self.assertFontEqual(font_class.font, Font())
+
+    def test_set_typical_string(self):
+        font_class = FontClass()
+        font_class.font = "10 pt bold condensed italic underline Helvetica sans-serif"  # noqa: E501
+        self.assertFontEqual(
+            font_class.font,
+            Font(
+                family=["helvetica", "sans-serif"],
+                size=10.0,
+                weight="bold",
+                stretch=75.0,
+                style="italic",
+                variants=set(),
+                decorations={"underline"},
+            ),
+        )
+
+    def test_set_font(self):
+        font_class = FontClass()
+        font = Font(
+            family=["helvetica", "sans-serif"],
+            size=10.0,
+            weight="bold",
+            stretch=75.0,
+            style="italic",
+            variants=set(),
+            decorations={"underline"},
+        )
+        font_class.font = font
+        self.assertIs(font_class.font, font)
+
+    def test_set_failure(self):
+        font_class = FontClass()
+
+        with self.assertRaises(TraitError):
+            font_class.font = None
+
+    def assertFontEqual(self, font1, font2):
+        state1 = font1.trait_get(transient=lambda x: not x)
+        state2 = font2.trait_get(transient=lambda x: not x)
+        self.assertEqual(state1, state2)
+
+
 class TestHasMargin(unittest.TestCase, UnittestTools):
     def test_defaults(self):
         has_margin = HasMarginClass()

pyface/ui/wx/font.py

@@ -18,9 +18,6 @@
 
 import wx
 
-from pyface.font import Font
-
-
 # font weight and size features changed in wxPython 4.1/wxWidgets 3.1
 wx_python_4_1 = (wx.VERSION >= (4, 1))
 

pyface/ui_traits.py

@@ -30,8 +30,10 @@
 from traits.trait_base import get_resource_path
 
 from pyface.color import Color
+from pyface.font import Font
 from pyface.i_image import IImage
 from pyface.util.color_parser import ColorParseError
+from pyface.util.font_parser import simple_parser, FontParseError
 
 
 logger = logging.getLogger(__name__)
@@ -144,7 +146,7 @@ def create_editor(self):
 
 
 class PyfaceColor(TraitType):
-    """ A Trait which casts strings and tuples to a PyfaceColor value.
+    """ A Trait which casts strings and tuples to a Pyface Color value.
     """
 
     #: The default value should be a tuple (factory, args, kwargs)
@@ -186,6 +188,54 @@ def info(self):
         )
 
 
+# -------------------------------------------------------------------------------
+#  Font
+# -------------------------------------------------------------------------------
+
+
+class PyfaceFont(TraitType):
+    """ A Trait which casts strings to a Pyface Font value.
+    """
+
+    #: The default value should be a tuple (factory, args, kwargs)
+    default_value_type = DefaultValue.callable_and_args
+
+    #: The parser to use when converting text to keyword args.  This should
+    #: accept a string and return a dictionary of Font class trait values (ie.
+    #: "family", "size", "weight", etc.).
+    parser = None
+
+    def __init__(self, value=None, *, parser=simple_parser, **metadata):
+        if parser is not None:
+            self.parser = parser
+        if value is not None:
+            font = self.validate(None, None, value)
+            default_value = (
+                Font,
+                (),
+                font.trait_get(transient=lambda x: not x),
+            )
+        else:
+            default_value = (Font, (), {})
+        super().__init__(default_value, **metadata)
+
+    def validate(self, object, name, value):
+        if isinstance(value, Font):
+            return value
+        if isinstance(value, str):
+            try:
+                return Font(**self.parser(value))
+            except FontParseError:
+                self.error(object, name, value)
+
+        self.error(object, name, value)
+
+    def info(self):
+        return (
+            "a Pyface Font, or a string describing a Pyface Font"
+        )
+
+
 # -------------------------------------------------------------------------------
 #  Borders, Margins and Layout
 # -------------------------------------------------------------------------------