cranpose-ui 0.1.164

UI primitives for Cranpose
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

use cranpose_foundation::{InvalidationKind, ModifierInvalidation, ModifierNode, NodeCapabilities};

use super::*;
use crate::{modifier::Color, modifier_nodes::PaddingNode};

#[test]
fn attaches_padding_node_and_invalidates_layout() {
    let mut handle = ModifierChainHandle::new();

    let _ = handle.update(&Modifier::empty().padding(8.0));

    assert_eq!(handle.chain().len(), 1);

    let invalidations = handle.take_invalidations();
    assert_eq!(
        invalidations,
        vec![ModifierInvalidation::new(
            InvalidationKind::Layout,
            NodeCapabilities::LAYOUT
        )]
    );
}

#[test]
fn reuses_nodes_between_updates() {
    let mut handle = ModifierChainHandle::new();

    let _ = handle.update(&Modifier::empty().padding(12.0));
    let first_ptr = node_ptr::<PaddingNode>(&handle);
    handle.take_invalidations();

    let _ = handle.update(&Modifier::empty().padding(12.0));
    let second_ptr = node_ptr::<PaddingNode>(&handle);

    assert_eq!(first_ptr, second_ptr, "expected the node to be reused");
    assert!(
        handle.take_invalidations().is_empty(),
        "no additional invalidations should be issued for a pure update"
    );
}

#[test]
fn modifier_slices_capture_background_and_shape() {
    use crate::modifier::slices::collect_modifier_slices;

    let mut handle = ModifierChainHandle::new();
    let _ = handle.update(
        &Modifier::empty()
            .background(Color(0.2, 0.3, 0.4, 1.0))
            .then(Modifier::empty().rounded_corners(8.0)),
    );

    let slices = collect_modifier_slices(handle.chain());
    assert!(
        !slices.draw_commands().is_empty(),
        "Expected draw commands for background"
    );

    let _ = handle.update(
        &Modifier::empty()
            .rounded_corners(4.0)
            .then(Modifier::empty().background(Color(0.9, 0.1, 0.1, 1.0))),
    );
    let slices = collect_modifier_slices(handle.chain());
    assert!(
        !slices.draw_commands().is_empty(),
        "Expected draw commands after update"
    );

    let _ = handle.update(&Modifier::empty());
    let slices = collect_modifier_slices(handle.chain());
    assert!(
        slices.draw_commands().is_empty(),
        "Expected no draw commands with empty modifier"
    );
}

#[test]
fn capability_mask_updates_with_chain() {
    let mut handle = ModifierChainHandle::new();
    let _ = handle.update(&Modifier::empty().padding(4.0));
    assert_eq!(handle.capabilities(), NodeCapabilities::LAYOUT);
    assert!(handle.has_layout_nodes());
    assert!(!handle.has_draw_nodes());
    handle.take_invalidations();

    let color = Color(0.5, 0.6, 0.7, 1.0);
    let _ = handle.update(&Modifier::empty().background(color));
    assert_eq!(handle.capabilities(), NodeCapabilities::DRAW);
    assert!(handle.has_draw_nodes());
    assert!(!handle.has_layout_nodes());
}

#[test]
fn offset_update_invalidates_layout_for_retained_placement() {
    let mut handle = ModifierChainHandle::new();
    let _ = handle.update(&Modifier::empty().offset(0.0, 0.0));
    handle.take_invalidations();

    let _ = handle.update(&Modifier::empty().offset(12.0, 0.0));
    let invalidations = handle.take_invalidations();

    assert!(
        invalidations
            .iter()
            .any(|invalidation| invalidation.kind() == InvalidationKind::Layout),
        "expected offset value changes to refresh retained placement"
    );
    assert!(
        invalidations
            .iter()
            .all(|invalidation| invalidation.kind() != InvalidationKind::Draw),
        "offset value changes must not leave retained geometry stale through a draw-only invalidation"
    );
    assert_eq!(handle.resolved_modifiers().offset(), Point::new(12.0, 0.0));
}

fn node_ptr<N: ModifierNode + 'static>(handle: &ModifierChainHandle) -> *const N {
    handle
        .chain()
        .node::<N>(0)
        .map(|node| &*node as *const N)
        .expect("expected node to exist")
}