Make fonts configurable per text class

Cargo.toml

@@ -89,4 +89,4 @@ features = ["serde"]
 members = ["kas-macros", "kas-theme", "kas-wgpu"]
 
 [patch.crates-io]
-kas-text = { git = "https://github.com/kas-gui/kas-text.git", rev = "c594569d5d8a4640c2b76865114453b2701d0c35" }
+kas-text = { git = "https://github.com/kas-gui/kas-text.git", rev = "05b50366a0a2fe7d1e611d93acbb2d9f83c52f0a" }

example-config/theme.yaml

@@ -43,3 +43,14 @@ font_aliases:
   Calibri:
     mode: Append
     list: [Carlito]
+fonts:
+  Edit:
+    families:
+      - serif
+  EditMulti:
+    families:
+      - serif
+  MenuLabel:
+    families:
+      - sans-serif
+    weight: 600

kas-theme/Cargo.toml

@@ -28,6 +28,7 @@ stack_dst = ["kas/stack_dst", "stack_dst_"]
 unsize = ["stack_dst_/unsize"]
 
 [dependencies]
+linear-map = "1.2.0"
 log = "0.4"
 serde = { version = "1.0.123", features = ["derive"], optional = true }
 stack_dst_ = { version = "0.6", package = "stack_dst", optional = true }

kas-theme/src/colors.rs

@@ -253,7 +253,7 @@ impl ColorsLinear {
     /// Get text colour from class
     pub fn text_class(&self, class: TextClass) -> Rgba {
         match class {
-            TextClass::Label | TextClass::LabelFixed | TextClass::LabelScroll => self.label_text,
+            TextClass::Label | TextClass::MenuLabel | TextClass::LabelScroll => self.label_text,
             TextClass::Button => self.button_text,
             TextClass::Edit | TextClass::EditMulti => self.text,
         }

kas-theme/src/config.rs

@@ -6,7 +6,8 @@
 //! Theme configuration
 
 use crate::{ColorsLinear, ColorsSrgb, ThemeConfig};
-use kas::text::fonts::{fonts, AddMode};
+use kas::draw::TextClass;
+use kas::text::fonts::{fonts, AddMode, FontSelector};
 use kas::TkAction;
 use std::collections::BTreeMap;
 
@@ -34,6 +35,10 @@ pub struct Config {
     /// Font aliases, used when searching for a font family matching the key.
     #[cfg_attr(feature = "config", serde(default))]
     font_aliases: BTreeMap<String, FontAliases>,
+
+    /// Standard fonts
+    #[cfg_attr(feature = "config", serde(default))]
+    fonts: BTreeMap<TextClass, FontSelector<'static>>,
 }
 
 impl Default for Config {
@@ -44,6 +49,7 @@ impl Default for Config {
             active_scheme: Default::default(),
             color_schemes: defaults::color_schemes(),
             font_aliases: Default::default(),
+            fonts: defaults::fonts(),
         }
     }
 }
@@ -85,6 +91,12 @@ impl Config {
     pub fn get_active_scheme(&self) -> Option<ColorsSrgb> {
         self.color_schemes.get(&self.active_scheme).cloned()
     }
+
+    /// Get an iterator over font mappings
+    #[inline]
+    pub fn iter_fonts(&self) -> impl Iterator<Item = (&TextClass, &FontSelector<'static>)> {
+        self.fonts.iter()
+    }
 }
 
 /// Setters
@@ -163,4 +175,14 @@ mod defaults {
         schemes.insert("dark".to_string(), ColorsLinear::dark().into());
         schemes
     }
+
+    pub fn fonts() -> BTreeMap<TextClass, FontSelector<'static>> {
+        let mut selector = FontSelector::new();
+        selector.set_families(vec!["serif".into()]);
+        let list = [
+            (TextClass::Edit, selector.clone()),
+            (TextClass::EditMulti, selector),
+        ];
+        list.iter().cloned().collect()
+    }
 }

kas-theme/src/dim.rs

@@ -7,15 +7,17 @@
 //!
 //! Widget size and appearance can be modified through themes.
 
+use linear_map::LinearMap;
 use std::any::Any;
 use std::f32;
 use std::path::Path;
+use std::rc::Rc;
 
 use kas::cast::{Cast, CastFloat, ConvFloat};
 use kas::draw::{self, DrawShared, ImageId, TextClass};
 use kas::geom::{Size, Vec2};
 use kas::layout::{AxisInfo, FrameRules, Margins, SizeRules, Stretch};
-use kas::text::{TextApi, TextApiExt};
+use kas::text::{fonts::FontId, TextApi, TextApiExt};
 
 /// Parameterisation of [`Dimensions`]
 ///
@@ -99,14 +101,25 @@ impl Dimensions {
 /// A convenient implementation of [`crate::Window`]
 pub struct DimensionsWindow {
     pub dims: Dimensions,
+    pub fonts: Rc<LinearMap<TextClass, FontId>>,
 }
 
 impl DimensionsWindow {
-    pub fn new(dims: DimensionsParams, pt_size: f32, scale_factor: f32) -> Self {
+    pub fn new(
+        dims: DimensionsParams,
+        pt_size: f32,
+        scale_factor: f32,
+        fonts: Rc<LinearMap<TextClass, FontId>>,
+    ) -> Self {
         DimensionsWindow {
             dims: Dimensions::new(dims, pt_size, scale_factor),
+            fonts,
         }
     }
+
+    pub fn update(&mut self, dims: DimensionsParams, pt_size: f32, scale_factor: f32) {
+        self.dims = Dimensions::new(dims, pt_size, scale_factor);
+    }
 }
 
 impl<D: DrawShared> crate::Window<D> for DimensionsWindow {
@@ -118,12 +131,12 @@ impl<D: DrawShared> crate::Window<D> for DimensionsWindow {
     #[cfg(not(feature = "gat"))]
     unsafe fn size_handle<'a>(&'a mut self, draw: &'a mut D) -> Self::SizeHandle {
         // We extend lifetimes (unsafe) due to the lack of associated type generics.
-        let h: SizeHandle<'a, D> = SizeHandle::new(&self.dims, draw);
+        let h: SizeHandle<'a, D> = SizeHandle::new(self, draw);
         std::mem::transmute(h)
     }
     #[cfg(feature = "gat")]
     fn size_handle<'a>(&'a mut self, draw: &'a mut D) -> Self::SizeHandle<'a> {
-        SizeHandle::new(&self.dims, draw)
+        SizeHandle::new(self, draw)
     }
 
     fn as_any_mut(&mut self) -> &mut dyn Any {
@@ -132,57 +145,57 @@ impl<D: DrawShared> crate::Window<D> for DimensionsWindow {
 }
 
 pub struct SizeHandle<'a, D: DrawShared> {
-    dims: &'a Dimensions,
+    w: &'a DimensionsWindow,
     draw: &'a mut D,
 }
 
 impl<'a, D: DrawShared> SizeHandle<'a, D> {
-    pub fn new(dims: &'a Dimensions, draw: &'a mut D) -> Self {
-        SizeHandle { dims, draw }
+    pub fn new(w: &'a DimensionsWindow, draw: &'a mut D) -> Self {
+        SizeHandle { w, draw }
     }
 }
 
 impl<'a, D: DrawShared> draw::SizeHandle for SizeHandle<'a, D> {
     fn scale_factor(&self) -> f32 {
-        self.dims.scale_factor
+        self.w.dims.scale_factor
     }
 
     fn pixels_from_points(&self, pt: f32) -> f32 {
-        self.dims.dpp * pt
+        self.w.dims.dpp * pt
     }
 
     fn pixels_from_em(&self, em: f32) -> f32 {
-        self.dims.dpp * self.dims.pt_size * em
+        self.w.dims.dpp * self.w.dims.pt_size * em
     }
 
     fn frame(&self, _vert: bool) -> FrameRules {
-        FrameRules::new_sym(self.dims.frame, 0, 0)
+        FrameRules::new_sym(self.w.dims.frame, 0, 0)
     }
     fn menu_frame(&self, vert: bool) -> FrameRules {
-        let mut size = self.dims.frame;
+        let mut size = self.w.dims.frame;
         if vert {
             size /= 2;
         }
         FrameRules::new_sym(size, 0, 0)
     }
     fn separator(&self) -> Size {
-        Size::splat(self.dims.frame)
+        Size::splat(self.w.dims.frame)
     }
 
     fn nav_frame(&self, _vert: bool) -> FrameRules {
-        FrameRules::new_sym(self.dims.inner_margin.into(), 0, 0)
+        FrameRules::new_sym(self.w.dims.inner_margin.into(), 0, 0)
     }
 
     fn inner_margin(&self) -> Size {
-        Size::splat(self.dims.inner_margin.into())
+        Size::splat(self.w.dims.inner_margin.into())
     }
 
     fn outer_margins(&self) -> Margins {
-        Margins::splat(self.dims.outer_margin)
+        Margins::splat(self.w.dims.outer_margin)
     }
 
     fn line_height(&self, _: TextClass) -> i32 {
-        self.dims.line_height
+        self.w.dims.line_height
     }
 
     fn text_bound(
@@ -192,8 +205,11 @@ impl<'a, D: DrawShared> draw::SizeHandle for SizeHandle<'a, D> {
         axis: AxisInfo,
     ) -> SizeRules {
         let required = text.update_env(|env| {
-            env.set_dpp(self.dims.dpp);
-            env.set_pt_size(self.dims.pt_size);
+            if let Some(font_id) = self.w.fonts.get(&class).cloned() {
+                env.set_font_id(font_id);
+            }
+            env.set_dpp(self.w.dims.dpp);
+            env.set_pt_size(self.w.dims.pt_size);
 
             let mut bounds = kas::text::Vec2::INFINITY;
             if let Some(size) = axis.size_other_if_fixed(false) {
@@ -209,11 +225,11 @@ impl<'a, D: DrawShared> draw::SizeHandle for SizeHandle<'a, D> {
             });
         });
 
-        let margin = self.dims.text_margin;
+        let margin = self.w.dims.text_margin;
         let margins = (margin, margin);
         if axis.is_horizontal() {
             let bound = i32::conv_ceil(required.0);
-            let min = self.dims.min_line_length;
+            let min = self.w.dims.min_line_length;
             let (min, ideal) = match class {
                 TextClass::Edit => (min, 2 * min),
                 TextClass::EditMulti => (min, 3 * min),
@@ -223,18 +239,18 @@ impl<'a, D: DrawShared> draw::SizeHandle for SizeHandle<'a, D> {
             // cause problems (e.g. edit boxes greedily consuming too much
             // space). This is a hard layout problem; for now don't do this.
             let stretch = match class {
-                TextClass::LabelFixed => Stretch::None,
+                TextClass::MenuLabel => Stretch::None,
                 TextClass::Button => Stretch::Filler,
                 _ => Stretch::Low,
             };
             SizeRules::new(min, ideal, margins, stretch)
         } else {
             let min = match class {
                 TextClass::Label => i32::conv_ceil(required.1),
-                TextClass::LabelFixed | TextClass::Button | TextClass::Edit => {
-                    self.dims.line_height
+                TextClass::MenuLabel | TextClass::Button | TextClass::Edit => {
+                    self.w.dims.line_height
                 }
-                TextClass::EditMulti | TextClass::LabelScroll => self.dims.line_height * 3,
+                TextClass::EditMulti | TextClass::LabelScroll => self.w.dims.line_height * 3,
             };
             let ideal = i32::conv_ceil(required.1).max(min);
             let stretch = match class {
@@ -246,23 +262,23 @@ impl<'a, D: DrawShared> draw::SizeHandle for SizeHandle<'a, D> {
     }
 
     fn edit_marker_width(&self) -> f32 {
-        self.dims.font_marker_width
+        self.w.dims.font_marker_width
     }
 
     fn button_surround(&self, _vert: bool) -> FrameRules {
-        let inner = self.dims.inner_margin.into();
-        let outer = self.dims.outer_margin;
-        FrameRules::new_sym(self.dims.frame, inner, outer)
+        let inner = self.w.dims.inner_margin.into();
+        let outer = self.w.dims.outer_margin;
+        FrameRules::new_sym(self.w.dims.frame, inner, outer)
     }
 
     fn edit_surround(&self, _vert: bool) -> FrameRules {
-        let inner = self.dims.inner_margin.into();
+        let inner = self.w.dims.inner_margin.into();
         let outer = 0;
-        FrameRules::new_sym(self.dims.frame, inner, outer)
+        FrameRules::new_sym(self.w.dims.frame, inner, outer)
     }
 
     fn checkbox(&self) -> Size {
-        Size::splat(self.dims.checkbox)
+        Size::splat(self.w.dims.checkbox)
     }
 
     #[inline]
@@ -271,17 +287,17 @@ impl<'a, D: DrawShared> draw::SizeHandle for SizeHandle<'a, D> {
     }
 
     fn scrollbar(&self) -> (Size, i32) {
-        let size = self.dims.scrollbar;
+        let size = self.w.dims.scrollbar;
         (size, 3 * size.0)
     }
 
     fn slider(&self) -> (Size, i32) {
-        let size = self.dims.slider;
+        let size = self.w.dims.slider;
         (size, 5 * size.0)
     }
 
     fn progress_bar(&self) -> Size {
-        self.dims.progress_bar
+        self.w.dims.progress_bar
     }
 
     fn load_image(&mut self, path: &Path) -> Result<ImageId, Box<dyn std::error::Error + 'static>> {

kas-theme/src/flat_theme.rs

@@ -7,10 +7,12 @@
 //!
 //! Widget size and appearance can be modified through themes.
 
+use linear_map::LinearMap;
 use std::f32;
 use std::ops::Range;
+use std::rc::Rc;
 
-use crate::{ColorsLinear, Config, Dimensions, DimensionsParams, DimensionsWindow, Theme, Window};
+use crate::{ColorsLinear, Config, DimensionsParams, DimensionsWindow, Theme, Window};
 use kas::cast::Cast;
 use kas::dir::{Direction, Directional};
 use kas::draw::{
@@ -19,7 +21,7 @@ use kas::draw::{
 };
 use kas::geom::*;
 use kas::text::format::FormattableText;
-use kas::text::{AccelString, Effect, Text, TextApi, TextDisplay};
+use kas::text::{fonts, AccelString, Effect, Text, TextApi, TextDisplay};
 use kas::TkAction;
 
 // Used to ensure a rectangular background is inside a circular corner.
@@ -29,8 +31,9 @@ const BG_SHRINK_FACTOR: f32 = 1.0 - std::f32::consts::FRAC_1_SQRT_2;
 /// A theme with flat (unshaded) rendering
 #[derive(Clone, Debug)]
 pub struct FlatTheme {
-    config: Config,
-    cols: ColorsLinear,
+    pub(crate) config: Config,
+    pub(crate) cols: ColorsLinear,
+    pub(crate) fonts: Option<Rc<LinearMap<TextClass, fonts::FontId>>>,
 }
 
 impl FlatTheme {
@@ -40,6 +43,7 @@ impl FlatTheme {
         FlatTheme {
             config: Default::default(),
             cols: ColorsLinear::default(),
+            fonts: None,
         }
     }
 
@@ -113,14 +117,22 @@ where
         if let Err(e) = kas::text::fonts::fonts().select_default() {
             panic!("Error loading font: {}", e);
         }
+        let fonts = fonts::fonts();
+        self.fonts = Some(Rc::new(
+            self.config
+                .iter_fonts()
+                .filter_map(|(c, s)| fonts.select_font(&s).ok().map(|id| (*c, id)))
+                .collect(),
+        ));
     }
 
-    fn new_window(&self, _draw: &mut D::Draw, dpi_factor: f32) -> Self::Window {
-        DimensionsWindow::new(DIMS, self.config.font_size(), dpi_factor)
+    fn new_window(&self, dpi_factor: f32) -> Self::Window {
+        let fonts = self.fonts.as_ref().clone().unwrap().clone();
+        DimensionsWindow::new(DIMS, self.config.font_size(), dpi_factor, fonts)
     }
 
     fn update_window(&self, window: &mut Self::Window, dpi_factor: f32) {
-        window.dims = Dimensions::new(DIMS, self.config.font_size(), dpi_factor);
+        window.update(DIMS, self.config.font_size(), dpi_factor);
     }
 
     #[cfg(not(feature = "gat"))]