marcel 0.1.1

Dynamic theme library for the iced GUI framework
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

//! Pick list theme.



pub(crate) mod serial;



use crate::{ Color, Theme };

use iced_native::{
    widget::{
        pane_grid::{
            Line, StyleSheet,
        },
    },
};

use serial::Component;



#[derive(Clone, Copy, Debug)]
pub struct PaneGrid {
    /// Pane Grid states.
    pub state: [State; 2],
}

impl PaneGrid {
    /// Attempts to create a theme from its serialized version.
    pub(crate) fn create(serial: &serial::PaneGrid, theme: &Theme) -> Result<Self, ()> {
        // Get all the themes.
        let picked  = Self::state( &serial.picked , theme, 0 )?;
        let hovered = Self::state( &serial.hovered, theme, 1 )?;
        
        // Find the first state theme that is not None.
        let default = match (picked, hovered) {
            (Some(d), _) => d,
            (_, Some(d)) => d,

            _ => return Err(()),
        };

        Ok(PaneGrid {
            state: [
                if picked.is_some()   { picked.unwrap()   } else { default },
                if hovered.is_some()  { hovered.unwrap()  } else { default },
            ],
        })
    }

    fn state(serial: &serial::Component, theme: &Theme, index: usize) -> Result<Option<State>, ()> {
        match serial {
            Component::Defined( state ) => Ok( Some( State::from(&state, &theme)? ) ),

            Component::Inherited( name ) => match theme.panegrid.get( name ) {
                Some( panegrid ) => Ok( Some( panegrid.state[index].clone() ) ),
                _ => Err(()),
            },

            Component::None => Ok( None ),
        }
    }
}

impl StyleSheet for PaneGrid {
    type Style = iced::Theme;

    fn picked_split(&self, _: &Self::Style) -> Option<Line> {
        Some( Line {
            color: self.state[0].color.into(),
            width: self.state[0].width.into(),
        } )
    }

    fn hovered_split(&self, _: &Self::Style) -> Option<Line> {
        Some( Line {
            color: self.state[1].color.into(),
            width: self.state[1].width.into(),
        } )
    }
}



#[derive(Clone, Copy, Debug)]
pub struct State {
    /// Line color.
    pub color: Color,

    /// Line width.
    pub width: f32,
}

impl State {
    /// Attempts to create a theme from its serialized version.
    fn from(serial: &serial::State, theme: &Theme) -> Result<Self, ()> {
        // Get the background color.
        let color = match theme.color.get(&serial.color) {
            Some(color) => *color,
            _ => return Err(()),
        };

        Ok( State { color, width: serial.width } )
    }
}