acrylic 0.3.5

ultra-portable, web-inspired UI toolkit with SIMD graphics
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

//! The Node structure

use super::xml::{OptionalXmlNodeIndex, XmlTagParameters};
use super::visual::{PixelSource, NodeConfig, Margin, Size, Position};
use oakwood::{Cookie64, tree, index};
use super::event::Handlers;
use crate::{ArcStr, Box};
use core::any::Any;

#[cfg(doc)]
use super::event::Initializer;

index!(MutatorIndex, OptionalMutatorIndex, u16);

index!(StyleIndex, OptionalStyleIndex, u16);

tree!(NodeTree, Node, NodeKey, NodeIndex, OptionalNodeIndex, Cookie64);

/// A Visual Element
///
/// [`Mutator`]s typically convert XML Tags to one or more nodes.
#[derive(Debug, Default)]
pub struct Node {                                 // bits    div4
    pub config: NodeConfig,                       // 2x4     2
    pub margin: Margin,                           // 4x4     4

    pub size: Size,                               // 2x4     2
    pub position: Position,                       // 2x4     2

    pub background: PixelSource,                  // 2x8     4
    pub foreground: PixelSource,                  // 2x8     4

    pub factory: OptionalMutatorIndex,            // 1x2
    pub style_override: OptionalStyleIndex,       // 1x2     1

    pub xml_node_index: OptionalXmlNodeIndex,     // 1x4     1

    // todo:
    // pub transition: Transition,
}                                                 //         21x4

/// XML Tags & other event handlers are defined as Mutators
pub struct Mutator {
    pub name: ArcStr,
    pub xml_params: Option<XmlTagParameters>,
    pub handlers: Handlers,
    /// Must be None initially; initialize it via an [`Initializer`].
    pub storage: Option<Box<dyn Any>>,
}

/// Utility function for event handlers to get and downcast their storage
pub fn get_storage<T: Any>(mutators: &mut [Mutator], m: MutatorIndex) -> Option<&mut T> {
    mutators[usize::from(m)].storage.as_mut()?.downcast_mut()
}

impl Clone for Mutator {
    fn clone(&self) -> Self {
        Self {
            name: self.name.clone(),
            xml_params: self.xml_params.clone(),
            handlers: self.handlers.clone(),
            storage: match self.storage.is_some() {
                true => panic!("Tried to Clone Mutator with an initialized storage"),
                false => None,
            },
        }
    }
}