Add font select to text element (#28)

Author: Zerthox

src/elements/icon.rs

@@ -118,8 +118,8 @@ impl Icon {
                     let color = with_alpha(colors::WHITE, alpha);
                     let shadow_color = with_alpha(colors::BLACK, alpha);
 
-                    TextDecoration::Shadow.render(ui, text, text_pos, font_size, shadow_color);
-                    draw_text_bg(ui, text, text_pos, font_size, color);
+                    TextDecoration::Shadow.render(ui, text, text_pos, font_scale, shadow_color);
+                    draw_text_bg(ui, text, text_pos, font_scale, color);
                 }
             }
 
@@ -147,10 +147,10 @@ impl Icon {
                                 ui,
                                 &text,
                                 text_pos,
-                                font_size,
+                                font_scale,
                                 shadow_color,
                             );
-                            draw_text_bg(ui, &text, text_pos, font_size, color);
+                            draw_text_bg(ui, &text, text_pos, font_scale, color);
                         }
                     }
                 }

src/elements/icon_source.rs

@@ -78,6 +78,9 @@ impl IconSource {
     pub fn render_select(&mut self, ui: &Ui) {
         enum_combo(ui, "Icon", self, ComboBoxFlags::empty());
 
+        // we assume this stays in place, otherwise we consider the file dialog invalidated
+        let id = self as *mut _ as usize;
+
         match self {
             Self::Unknown | Self::Empty => {}
             Self::File(path) => {
@@ -87,9 +90,6 @@ impl IconSource {
                     .read_only(true)
                     .build();
 
-                // we assume this stays in place, otherwise we consider the file dialog invalidated
-                let id = path.as_os_str().as_encoded_bytes().as_ptr() as usize;
-
                 static FILE: Lockbox<usize, PathBuf> = Lockbox::new();
 
                 ui.same_line();

src/elements/text.rs

@@ -4,7 +4,8 @@ use crate::{
     component_wise::ComponentWise,
     context::{Context, ContextUpdate},
     render_util::{
-        draw_text_bg, helper, input_float_with_format, input_text_multi_with_menu, Rect,
+        draw_text_bg, font_select, helper, input_float_with_format, input_text_multi_with_menu,
+        Font, Rect,
     },
     traits::{Render, RenderOptions},
     tree::TreeLeaf,
@@ -20,11 +21,17 @@ pub struct Text {
     pub progress: ProgressTrigger,
 
     pub text: String,
+
+    #[serde(rename = "font")]
+    pub font_name: Option<String>,
     pub size: f32,
     pub align: AlignHorizontal,
     pub color: [f32; 4],
     pub decoration: TextDecoration,
 
+    #[serde(skip)]
+    loaded_font: Option<Font>,
+
     #[serde(skip)]
     text_memo: Option<String>,
 }
@@ -85,6 +92,16 @@ impl Text {
         let offset = self.align.text_offset(ui, text, self.size);
         pos.add(offset)
     }
+
+    pub fn load(&mut self) {
+        if let Some(name) = &self.font_name {
+            if let Some(font_id) = Font::try_from_name(name) {
+                self.loaded_font = Some(font_id);
+            } else {
+                log::warn!("Failed to find font \"{name}\"");
+            }
+        }
+    }
 }
 
 impl TreeLeaf for Text {}
@@ -94,16 +111,16 @@ impl Render for Text {
         self.update_text(ctx, state);
 
         if let Some(text) = &self.text_memo {
+            let _font = self.loaded_font.map(|font| font.push());
             let font_scale = self.size;
-            let font_size = font_scale * ui.current_font_size();
             let pos = self.calc_pos(ui, state.pos, text);
             let [r, g, b, a] = self.color;
             let alpha = a * ui.clone_style().alpha;
             let color = [r, g, b, alpha];
 
             self.decoration
-                .render(ui, text, pos, font_size, [0.0, 0.0, 0.0, alpha]);
-            draw_text_bg(ui, text, pos, font_size, color);
+                .render(ui, text, pos, font_scale, [0.0, 0.0, 0.0, alpha]);
+            draw_text_bg(ui, text, pos, font_scale, color);
         }
     }
 }
@@ -160,6 +177,10 @@ impl RenderOptions for Text {
             self.size = size / 100.0;
         }
 
+        if font_select(ui, "Font", &mut self.loaded_font) {
+            self.font_name = self.loaded_font.map(|font| font.name_owned());
+        }
+
         self.align.render_combo(ui);
 
         ColorEdit::new("Color", &mut self.color)
@@ -177,8 +198,10 @@ impl Default for Text {
             progress: ProgressTrigger::default(),
             align: AlignHorizontal::Center,
             size: 1.0,
+            font_name: None,
             color: [1.0, 1.0, 1.0, 1.0],
             decoration: TextDecoration::default(),
+            loaded_font: None,
             text_memo: None,
         }
     }

src/elements/text_decoration.rs

@@ -40,36 +40,36 @@ pub enum TextDecoration {
 }
 
 impl TextDecoration {
-    fn render_at(ui: &Ui, pos: [f32; 2], text: &str, font_size: f32, color: [f32; 4]) {
-        draw_text_bg(ui, text, pos, font_size, color)
+    fn render_at(ui: &Ui, pos: [f32; 2], text: &str, font_scale: f32, color: [f32; 4]) {
+        draw_text_bg(ui, text, pos, font_scale, color)
     }
 
     pub fn render(
         &self,
         ui: &Ui,
         text: impl AsRef<str>,
         pos: [f32; 2],
-        font_size: f32,
+        font_scale: f32,
         color: [f32; 4],
     ) {
         // FIXME: shadow renders behind transparent text
         let text = text.as_ref();
         match self {
             Self::None => {}
-            Self::Shadow => Self::render_at(ui, pos.add([1.0, 1.0]), text, font_size, color),
+            Self::Shadow => Self::render_at(ui, pos.add([1.0, 1.0]), text, font_scale, color),
             Self::ShadowDouble => {
                 for offset in [[0.0, 1.0], [1.0, 0.0]] {
-                    Self::render_at(ui, pos.add(offset), text, font_size, color)
+                    Self::render_at(ui, pos.add(offset), text, font_scale, color)
                 }
             }
             Self::Outline => {
                 for offset in [[-1.0, -1.0], [1.0, 1.0]] {
-                    Self::render_at(ui, pos.add(offset), text, font_size, color)
+                    Self::render_at(ui, pos.add(offset), text, font_scale, color)
                 }
             }
             Self::OutlineDouble => {
                 for offset in [[-1.0, -1.0], [-1.0, 1.0], [1.0, -1.0], [1.0, 1.0]] {
-                    Self::render_at(ui, pos.add(offset), text, font_size, color)
+                    Self::render_at(ui, pos.add(offset), text, font_scale, color)
                 }
             }
         }

src/render_util/font.rs

@@ -0,0 +1,108 @@
+use nexus::imgui::{sys, ComboBoxFlags, Selectable, SelectableFlags, Ui};
+use std::{
+    borrow::Cow,
+    ffi::{CStr, CString},
+    ptr::NonNull,
+    slice,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct Font(pub NonNull<sys::ImFont>);
+
+impl Font {
+    pub unsafe fn get_all() -> impl Iterator<Item = Self> {
+        let io = sys::igGetIO();
+        let atlas = (*io).Fonts;
+        let data = (*atlas).Fonts.Data;
+        let len = (*atlas).Fonts.Size;
+
+        slice::from_raw_parts(data, len as usize)
+            .into_iter()
+            .copied()
+            .filter_map(NonNull::new)
+            .map(Self)
+    }
+
+    pub fn try_from_name(name: impl AsRef<str>) -> Option<Self> {
+        let name = CString::new(name.as_ref()).ok()?;
+        for font in unsafe { Self::get_all() } {
+            if unsafe { font.name_raw() } == name.as_c_str() {
+                return Some(font);
+            }
+        }
+        None
+    }
+
+    pub unsafe fn name_raw<'a>(&self) -> &'a CStr {
+        unsafe {
+            let config = (*self.as_ptr()).ConfigData;
+            let name = (*config).Name.as_ptr();
+            CStr::from_ptr(name)
+        }
+    }
+
+    pub fn name_owned(&self) -> String {
+        unsafe { self.name_raw() }.to_string_lossy().into_owned()
+    }
+
+    pub fn as_ptr(&self) -> *mut sys::ImFont {
+        self.0.as_ptr()
+    }
+
+    pub fn push(&self) -> FontToken {
+        unsafe { sys::igPushFont(self.as_ptr()) }
+        FontToken
+    }
+}
+
+pub struct FontToken;
+
+impl Drop for FontToken {
+    fn drop(&mut self) {
+        unsafe { sys::igPopFont() }
+    }
+}
+
+unsafe impl Send for Font {}
+
+pub fn font_select(ui: &Ui, label: impl AsRef<str>, current: &mut Option<Font>) -> bool {
+    const DEFAULT: &str = "Default";
+
+    let mut changed = false;
+    let preview = match *current {
+        Some(font) => {
+            let name = unsafe { font.name_raw() };
+            name.to_string_lossy()
+        }
+        None => Cow::Borrowed(DEFAULT),
+    };
+
+    if let Some(_token) = ui.begin_combo_with_flags(label, preview, ComboBoxFlags::HEIGHT_LARGE) {
+        if Selectable::new(DEFAULT).build(ui) {
+            *current = None;
+            changed = true;
+        }
+
+        for font in unsafe { Font::get_all() } {
+            let _font = font.push();
+            let is_selected = Some(font) == *current;
+            if unsafe {
+                sys::igSelectable_Bool(
+                    font.name_raw().as_ptr(),
+                    is_selected,
+                    SelectableFlags::empty().bits() as i32,
+                    [0.0, 0.0].into(),
+                )
+            } {
+                *current = Some(font);
+                changed = true;
+            }
+            if is_selected {
+                ui.set_item_default_focus();
+            }
+        }
+    }
+
+    changed
+}

src/render_util/mod.rs

@@ -1,5 +1,6 @@
 mod button;
 mod combo;
+mod font;
 mod helper;
 mod input;
 mod input_text;
@@ -10,8 +11,8 @@ mod text;
 mod tree;
 
 pub use self::{
-    button::*, combo::*, helper::*, input::*, input_text::*, popup::*, spinner::*, style::*,
-    text::*, tree::*,
+    button::*, combo::*, font::*, helper::*, input::*, input_text::*, popup::*, spinner::*,
+    style::*, text::*, tree::*,
 };
 
 use nexus::imgui::{sys, Ui};

src/render_util/text.rs

@@ -5,7 +5,7 @@ pub fn draw_text_bg(
     ui: &Ui,
     text: impl AsRef<str>,
     pos: [f32; 2],
-    font_size: f32,
+    font_scale: f32,
     color: impl Into<ImColor32>,
 ) {
     let range = text.as_ref().as_bytes().as_ptr_range();
@@ -14,11 +14,12 @@ pub fn draw_text_bg(
     unsafe {
         let bg = sys::igGetBackgroundDrawList();
         let font = sys::igGetFont();
+        let font_size = sys::igGetFontSize();
 
         sys::ImDrawList_AddText_FontPtr(
             bg,
             font,
-            font_size,
+            font_scale * font_size,
             pos.into(),
             color.into().into(),
             range.start.cast(),

src/tree/load.rs

@@ -1,6 +1,6 @@
 use super::VisitMut;
 use crate::{
-    elements::{IconElement, IconList},
+    elements::{IconElement, IconList, Text},
     trigger::FilterTrigger,
 };
 
@@ -18,6 +18,10 @@ impl VisitMut for Loader {
         el.icon.load()
     }
 
+    fn visit_text(&mut self, text: &mut Text) {
+        text.load();
+    }
+
     fn visit_filter_trigger(&mut self, trigger: &mut FilterTrigger) {
         trigger.load();
     }