egui 0.12.0

Simple, portable immediate mode GUI library for Rust
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
145
146
147
148
149
150
151
152
153
154
155

use crate::any::serializable::type_id::TypeId;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::any::Any;
use std::fmt;
use AnyMapElementInner::{Deserialized, Serialized};

pub(crate) struct AnyMapElement(AnyMapElementInner);

enum AnyMapElementInner {
    Deserialized {
        value: Box<dyn Any + 'static + Send + Sync>,
        clone_fn: fn(&Box<dyn Any + 'static + Send + Sync>) -> Box<dyn Any + 'static + Send + Sync>,

        serialize_fn: fn(&Box<dyn Any + 'static + Send + Sync>) -> Result<String, ron::Error>,
    },
    Serialized(String, TypeId),
}

#[derive(Deserialize, Serialize)]
struct AnyMapElementInnerSer(String, TypeId);

impl Serialize for AnyMapElement {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let inner = match &self.0 {
            Deserialized {
                value,
                serialize_fn,
                ..
            } => {
                let s = serialize_fn(value).map_err(serde::ser::Error::custom)?;
                AnyMapElementInnerSer(s, self.type_id())
            }
            Serialized(s, id) => AnyMapElementInnerSer(s.clone(), *id),
        };

        inner.serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for AnyMapElement {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let AnyMapElementInnerSer(s, id) = AnyMapElementInnerSer::deserialize(deserializer)?;

        Ok(AnyMapElement(Serialized(s, id)))
    }
}

impl fmt::Debug for AnyMapElement {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.0 {
            Deserialized { value, .. } => f
                .debug_struct("AnyMapElement_Deserialized")
                .field("value_type_id", &value.type_id())
                .finish(),
            Serialized(s, id) => f
                .debug_tuple("AnyMapElement_Serialized")
                .field(&s)
                .field(&id)
                .finish(),
        }
    }
}

impl Clone for AnyMapElement {
    fn clone(&self) -> Self {
        match &self.0 {
            Deserialized {
                value,
                clone_fn,
                serialize_fn,
            } => AnyMapElement(Deserialized {
                value: clone_fn(value),
                clone_fn: *clone_fn,
                serialize_fn: *serialize_fn,
            }),
            Serialized(s, id) => AnyMapElement(Serialized(s.clone(), *id)),
        }
    }
}

pub trait AnyMapTrait:
    'static + Any + Clone + Serialize + for<'a> Deserialize<'a> + Send + Sync
{
}
impl<T: 'static + Any + Clone + Serialize + for<'a> Deserialize<'a> + Send + Sync> AnyMapTrait
    for T
{
}

impl AnyMapElement {
    pub(crate) fn new<T: AnyMapTrait>(t: T) -> Self {
        AnyMapElement(Deserialized {
            value: Box::new(t),
            clone_fn: |x| {
                let x = x.downcast_ref::<T>().unwrap(); // This unwrap will never panic, because we always construct this type using this `new` function and because we return &mut reference only with this type `T`, so type cannot change.
                Box::new(x.clone())
            },

            serialize_fn: |x| {
                let x = x.downcast_ref::<T>().unwrap(); // This will never panic too, for same reason.
                ron::to_string(x)
            },
        })
    }

    pub(crate) fn type_id(&self) -> TypeId {
        match self {
            AnyMapElement(Deserialized { value, .. }) => (**value).type_id().into(),
            AnyMapElement(Serialized(_, id)) => *id,
        }
    }

    pub(crate) fn get_mut<T: AnyMapTrait>(&mut self) -> Option<&mut T> {
        match self {
            AnyMapElement(Deserialized { value, .. }) => value.downcast_mut(),
            AnyMapElement(Serialized(s, _)) => {
                *self = Self::new(ron::from_str::<T>(s).ok()?);

                match self {
                    AnyMapElement(Deserialized { value, .. }) => value.downcast_mut(),
                    AnyMapElement(Serialized(_, _)) => unreachable!(),
                }
            }
        }
    }

    pub(crate) fn get_mut_or_set_with<T: AnyMapTrait>(
        &mut self,
        set_with: impl FnOnce() -> T,
    ) -> &mut T {
        match &mut self.0 {
            Deserialized { value, .. } => {
                if !value.is::<T>() {
                    *self = Self::new(set_with());
                    // TODO: log this error, because it can occurs when user used same Id or same type for different widgets
                }
            }
            Serialized(s, _) => {
                *self = Self::new(ron::from_str::<T>(s).unwrap_or_else(|_| set_with()));
                // TODO: log deserialization error
            }
        }

        match &mut self.0 {
            Deserialized { value, .. } => value.downcast_mut().unwrap(), // This unwrap will never panic because we already converted object to required type
            Serialized(_, _) => unreachable!(),
        }
    }
}