fltk 1.5.22

Rust bindings for the FLTK GUI library
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

use crate::prelude::WidgetExt;
use crate::utils::oncelock::*;
use std::any::Any;
use std::collections::HashMap;
use std::sync::Mutex;

#[cfg(feature = "single-threaded")]
use std::cell::RefCell;

static STATE: OnceCell<Mutex<Box<dyn Any + Send + Sync + 'static>>> = OnceCell::new();

/// Represents global state
#[derive(Debug, Copy)]
pub struct GlobalState<T> {
    marker: std::marker::PhantomData<T>,
}

impl<T> Clone for GlobalState<T> {
    fn clone(&self) -> Self {
        Self {
            marker: std::marker::PhantomData,
        }
    }
}

impl<T: Sync + Send + 'static> GlobalState<T> {
    /// Creates a new global state
    pub fn new(val: T) -> Self {
        STATE.set(Mutex::new(Box::new(val))).unwrap();
        GlobalState {
            marker: std::marker::PhantomData,
        }
    }

    /// Modifies the global state by acquiring a mutable reference
    /// # Panics
    /// Panics on state downcast errors
    pub fn with<V: Clone, F: 'static + FnMut(&mut T) -> V>(&self, mut cb: F) -> V {
        if let Some(state) = STATE.get() {
            if let Ok(mut state) = state.try_lock() {
                if let Some(state) = state.downcast_mut::<T>() {
                    cb(state)
                } else {
                    panic!("failed to downcast state");
                }
            } else {
                panic!("failed to lock state");
            }
        } else {
            panic!("failed to get state");
        }
    }

    /// Gets the already initialized global state
    pub fn get() -> Self {
        GlobalState {
            marker: std::marker::PhantomData,
        }
    }
}

#[cfg(not(feature = "single-threaded"))]
static WIDGET_MAP: Lazy<Mutex<HashMap<String, Box<dyn Any + Send + Sync + 'static>>>> =
    Lazy::new(|| Mutex::new(HashMap::default()));

#[cfg(feature = "single-threaded")]
thread_local! {
    static WIDGET_MAP: RefCell<HashMap<String, Box<dyn Any>>> = RefCell::new(HashMap::new());
}

/// Allows setting a an id to a widget.
pub trait WidgetId<W>
where
    W: WidgetExt,
{
    /// Set the widget's Id
    fn set_id(&mut self, id: &str);

    #[allow(clippy::return_self_not_must_use)]
    /// Construct a widget with an Id
    fn with_id(self, id: &str) -> Self
    where
        Self: Sized;
}

#[cfg(not(feature = "single-threaded"))]
impl<W> WidgetId<W> for W
where
    W: WidgetExt + Clone + Send + Sync + 'static,
{
    fn set_id(&mut self, id: &str) {
        WIDGET_MAP
            .lock()
            .unwrap()
            .insert(id.to_string(), Box::new(self.clone()));
    }
    fn with_id(mut self, id: &str) -> Self {
        self.set_id(id);
        self
    }
}

#[cfg(feature = "single-threaded")]
impl<W> WidgetId<W> for W
where
    W: WidgetExt + Clone + 'static,
{
    fn set_id(&mut self, id: &str) {
        WIDGET_MAP.with(|w| {
            w.borrow_mut()
                .insert(id.to_string(), Box::new(self.clone()))
        });
    }
    fn with_id(mut self, id: &str) -> Self {
        self.set_id(id);
        self
    }
}

/// Get back the widget thru its id
pub fn widget_from_id<T: 'static + Clone>(id: &str) -> Option<T> {
    #[cfg(not(feature = "single-threaded"))]
    if let Some(w) = WIDGET_MAP.lock().unwrap().get(id) {
        w.downcast_ref::<T>().map(|w| (*w).clone())
    } else {
        None
    }
    #[cfg(feature = "single-threaded")]
    WIDGET_MAP.with(|w| {
        if let Some(w) = w.borrow().get(id) {
            w.downcast_ref::<T>().map(|w| (*w).clone())
        } else {
            None
        }
    })
}