rgx 0.9.0

A 2D graphics toolkit 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

use std::borrow::Borrow;
use std::collections::HashMap;
use std::marker::PhantomData;

use crate::ui::{text, TextureId, TextureInfo};

/// An environment value.
#[derive(Debug)]
pub enum Value {
    Font(Box<text::Font>),
    Texture(TextureId),
    TextureInfo(TextureInfo),
}

#[derive(thiserror::Error, Debug)]
pub enum ValueTypeError {
    #[error("wrong type")]
    WrongType,
}

/// Values which can be stored in an environment.
pub trait ValueType: Sized + Clone + Into<Value> {
    /// Attempt to convert the generic `Value` into this type.
    fn try_from_value(v: &Value) -> Result<Self, ValueTypeError>;
}

impl From<TextureId> for Value {
    fn from(id: TextureId) -> Self {
        Self::Texture(id)
    }
}

impl ValueType for TextureId {
    fn try_from_value(v: &Value) -> Result<Self, ValueTypeError> {
        if let Value::Texture(id) = v {
            Ok(*id)
        } else {
            Err(ValueTypeError::WrongType)
        }
    }
}

impl From<TextureInfo> for Value {
    fn from(info: TextureInfo) -> Self {
        Self::TextureInfo(info)
    }
}

impl ValueType for TextureInfo {
    fn try_from_value(v: &Value) -> Result<Self, ValueTypeError> {
        if let Value::TextureInfo(info) = v {
            Ok(*info)
        } else {
            Err(ValueTypeError::WrongType)
        }
    }
}

/// Widget environment.
#[derive(Default, Debug)]
pub struct Env {
    /// Map of user-defined data.
    map: HashMap<&'static str, Value>,
}

impl Env {
    pub fn get<V: ValueType>(&self, key: impl Borrow<Key<V>>) -> Option<V> {
        self.map
            .get(key.borrow().key)
            .map(|v| V::try_from_value(v).unwrap())
    }

    pub fn set<V: ValueType>(&mut self, key: Key<V>, value: impl Into<V>) {
        let key = key.into();
        let value = value.into().into();

        self.map.insert(key, value);
    }
}

/// An environment key.
#[derive(Clone, Debug, PartialEq)]
pub struct Key<V> {
    key: &'static str,
    value: PhantomData<V>,
}

impl<V> Key<V> {
    pub fn new(key: &'static str) -> Self {
        Self {
            key,
            value: PhantomData,
        }
    }
}

impl<V> From<Key<V>> for &'static str {
    fn from(key: Key<V>) -> Self {
        key.key
    }
}