libui 0.4.0

A native, cross-platform and lightweight UI toolkit.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use super::Control;
use callback_helpers::{from_void_ptr, to_heap_ptr};
use std::ffi::CStr;
use std::mem::MaybeUninit;
use std::os::raw::c_void;
use std::{convert::TryFrom, mem};
use ui::UI;
use libui_ffi::{self, uiControl, uiFontButton, uiFontDescriptor};

/// An enum listing font styles.
#[derive(Copy, Clone, Debug)]
pub enum SlantStyle {
    Normal,
    Oblique,
    Italic,
}

impl TryFrom<u32> for SlantStyle {
    type Error = ();

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(SlantStyle::Normal),
            1 => Ok(SlantStyle::Oblique),
            2 => Ok(SlantStyle::Italic),
            _ => Err(()),
        }
    }
}

/// An enum listing font stretch levels.
#[derive(Copy, Clone, Debug)]
pub enum StretchStyle {
    UltraCondensed,
    ExtraCondensed,
    Condensed,
    SemiCondensed,
    Normal,
    SemiExpanded,
    Expanded,
    ExtraExpanded,
    UltraExpanded,
}

impl TryFrom<u32> for StretchStyle {
    type Error = ();

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(StretchStyle::UltraCondensed),
            1 => Ok(StretchStyle::ExtraCondensed),
            2 => Ok(StretchStyle::Condensed),
            3 => Ok(StretchStyle::SemiCondensed),
            4 => Ok(StretchStyle::Normal),
            5 => Ok(StretchStyle::SemiExpanded),
            6 => Ok(StretchStyle::Expanded),
            7 => Ok(StretchStyle::ExtraExpanded),
            8 => Ok(StretchStyle::UltraExpanded),
            _ => Err(()),
        }
    }
}

/// A structure describing a font by it properties.
#[derive(Debug, Clone)]
pub struct FontDescription {
    pub family: String,
    pub size: f64,
    pub weight: u32,
    pub slant: SlantStyle,
    pub stretch: StretchStyle,
}

impl Default for FontDescription {
    fn default() -> Self {
        FontDescription {
            family: String::new(),
            size: 0.0,
            weight: 0,
            slant: SlantStyle::Normal,
            stretch: StretchStyle::Normal,
        }
    }
}

define_control! {
    /// A button which allows the user to pick a font.
    rust_type: FontButton,
    sys_type: uiFontButton
}

impl FontButton {
    /// Creates a new font button.
    pub fn new() -> FontButton {
        unsafe { FontButton::from_raw(libui_ffi::uiNewFontButton()) }
    }

    /// Returns the selected font.
    pub fn font(&self) -> FontDescription {
        unsafe {
            let mut cfd: uiFontDescriptor = { MaybeUninit::zeroed().assume_init() };

            libui_ffi::uiFontButtonFont(self.uiFontButton, &mut cfd as *mut uiFontDescriptor);

            let fd = FontDescription {
                family: CStr::from_ptr(cfd.Family).to_string_lossy().into(),
                size: cfd.Size,
                weight: cfd.Weight,
                slant: SlantStyle::try_from(cfd.Italic).unwrap(),
                stretch: StretchStyle::try_from(cfd.Stretch).unwrap(),
            };

            libui_ffi::uiFreeFontButtonFont(&mut cfd as *mut uiFontDescriptor);
            return fd;
        }
    }

    /// Registers a callback for when the font is changed.
    ///
    /// Note: Only one callback can be registered at a time.
    pub fn on_changed<'ctx, F>(&mut self, _ctx: &'ctx UI, callback: F)
    where
        F: FnMut(&mut FontButton) + 'static,
    {
        extern "C" fn c_callback<G>(button: *mut uiFontButton, data: *mut c_void)
        where
            G: FnMut(&mut FontButton),
        {
            let mut button = FontButton {
                uiFontButton: button,
            };
            unsafe {
                from_void_ptr::<G>(data)(&mut button);
            }
        }
        unsafe {
            libui_ffi::uiFontButtonOnChanged(
                self.uiFontButton,
                Some(c_callback::<F>),
                to_heap_ptr(callback),
            );
        }
    }
}