ori-core 0.1.0-alpha.1

Core library for Ori, a declarative UI framework 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

use std::{
    path::{Path, PathBuf},
    time::SystemTime,
};

use crate::{StyleLoadError, Stylesheet};

/// A style that has been loaded from a file.
#[derive(Clone, Debug)]
pub struct LoadedStyle {
    modified: SystemTime,
    path: PathBuf,
    style: Stylesheet,
}

impl LoadedStyle {
    /// Loads a style from a file.
    pub fn load(path: impl AsRef<Path>) -> Result<Self, StyleLoadError> {
        let modified = path.as_ref().metadata()?.modified()?;
        let style = Stylesheet::load(&path)?;
        Ok(Self {
            modified,
            path: path.as_ref().to_path_buf(),
            style,
        })
    }

    /// Reloads the style if the file has been modified.
    ///
    /// Returns true if the style was reloaded.
    pub fn reload(&mut self) -> Result<bool, StyleLoadError> {
        let modified = self.path.metadata()?.modified()?;

        let needs_reload = modified > self.modified;
        if needs_reload {
            self.modified = modified;
            self.style = Stylesheet::load(&self.path)?;
        }

        Ok(needs_reload)
    }
}

/// A style that can be loaded from a file or be an inline style.
#[derive(Clone, Debug)]
pub enum LoadedStyleKind {
    Loaded(LoadedStyle),
    Inline(Stylesheet),
}

impl LoadedStyleKind {
    /// Reloads the style if the file has been modified.
    ///
    /// Returns true if the style was reloaded.
    pub fn reload(&mut self) -> Result<bool, StyleLoadError> {
        match self {
            Self::Loaded(loaded) => loaded.reload(),
            Self::Inline(_) => Ok(false),
        }
    }

    /// Returns the style.
    pub fn style(&self) -> &Stylesheet {
        match self {
            Self::Loaded(style) => &style.style,
            Self::Inline(style) => style,
        }
    }
}

impl From<Stylesheet> for LoadedStyleKind {
    fn from(style: Stylesheet) -> Self {
        Self::Inline(style)
    }
}

impl TryFrom<&str> for LoadedStyleKind {
    type Error = StyleLoadError;

    fn try_from(path: &str) -> Result<Self, Self::Error> {
        Ok(Self::Loaded(LoadedStyle::load(path)?))
    }
}

impl TryFrom<&Path> for LoadedStyleKind {
    type Error = StyleLoadError;

    fn try_from(path: &Path) -> Result<Self, Self::Error> {
        Ok(Self::Loaded(LoadedStyle::load(path)?))
    }
}

/// A style loader that can load styles from files and inline styles.
///
/// Styles that are loaded from files are reloaded when the file is modified.
#[derive(Clone, Debug)]
pub struct StyleLoader {
    styles: Vec<LoadedStyleKind>,
    cache: Stylesheet,
}

impl StyleLoader {
    /// Creates a new style loader.
    pub fn new() -> Self {
        Self {
            styles: Vec::new(),
            cache: Stylesheet::new(),
        }
    }

    pub fn clear(&mut self) {
        self.styles.clear();
        self.cache = Stylesheet::new();
    }

    /// Adds a style to the loader.
    pub fn add_style<T: TryInto<LoadedStyleKind>>(&mut self, style: T) -> Result<(), T::Error> {
        self.styles.push(style.try_into()?);
        self.compute_cache();
        Ok(())
    }

    /// Recomputes the cache.
    fn compute_cache(&mut self) {
        self.cache = Stylesheet::new();

        for style in self.styles.iter() {
            self.cache.extend(style.style().clone());
        }
    }

    /// Reloads the styles if the files have been modified.
    pub fn reload(&mut self) -> Result<bool, StyleLoadError> {
        let mut needs_reload = false;

        for style in self.styles.iter_mut() {
            if style.reload()? {
                needs_reload = true;
            }
        }

        if needs_reload {
            self.compute_cache();
        }

        Ok(needs_reload)
    }

    /// Returns the style.
    pub fn style(&self) -> &Stylesheet {
        &self.cache
    }
}