tomt_bevycss 0.7.1

Expansion and fixes based on bevy_ecss. Allows for using a slightly wider subset of CSS to interact with Bevy ECS. Now on Bevy 0.13!
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

use super::SelectedEntities;
use crate::{
    selector::Selector,
    stylesheet::StyleSheetAsset,
};

use bevy::{
    prelude::{
        Assets,
        Deref, DerefMut,
        Entity,
        Handle,
        Resource,
    },
    utils::HashMap,
};

#[derive(Debug, Clone)]
pub struct StyleSource
{
    pub styleheet: Handle<StyleSheetAsset>,
    pub selector: Selector,
}

#[derive(Debug, Clone, Default, Deref, DerefMut)]
pub struct ComputedStyle(
    HashMap<
        String,
        StyleSource
    >
);

/// Maps sheets for each [`StyleSheetAsset`].
#[derive(Debug, Clone, Default, Deref, DerefMut, Resource)]
pub struct StyleSheetStateBuilder(
    HashMap<
        Handle<StyleSheetAsset>,
        SelectedEntities
    >
);

#[derive(Debug, Clone, Default, Deref, DerefMut, Resource)]
pub struct StyleSheetState(
    HashMap<
        Entity,
        ComputedStyle
    >
);

impl StyleSheetStateBuilder
{
    pub(crate) fn build(
        &mut self,
        assets: &Assets<StyleSheetAsset>
    ) -> StyleSheetState {
        let mut result = StyleSheetState::default();

        for (handle, selected) in self.iter()
        {
            if let Some(sheet) = assets.get(handle)
            {
                // Invert list of entities for each selector, into a list of selectors for each entity
                let mut inverted = HashMap::<Entity, Vec<Selector>>::new();
                for (selector, entities) in selected.iter()
                {
                    for entity in entities.iter()
                    {
                        inverted.entry(*entity)
                            .or_default()
                            .push(selector.clone());
                    }
                }

                // "Pre-apply" the selectors to get a list of properties without duplicates
                for (entity, mut selectors) in inverted
                {
                    let style = result.entry(entity).or_default();

                    selectors.sort();
                    for selector in selectors.iter()
                    {
                        for prop in sheet.get_property_names(selector).unwrap_or_default()
                        {
                            style.insert(prop, StyleSource
                                {
                                    styleheet: handle.clone(),
                                    selector: selector.clone(),
                                });
                        }
                    }
                }
            }
        }

        result
    }
}