smudge-core 0.1.0

Widget tree, reactive bindings, layout, paint and damage tracking for the Smudge GUI library
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

//! Unit tests for the pure resolution of style variants.
//!
//! The integration tests observe the resolved style through the frame
//! pipeline; these tests call `resolve` directly and check the order the
//! patches apply in and the fields each one overrides.

use super::{PatchBuilder, StylePatch, Variants, resolve};
use crate::geometry::Color;
use crate::style::{Length, Style};
use crate::tree::interaction::Interaction;

/// A base style whose background tells the patches apart.
fn base() -> Style {
    let mut style = Style::default();
    style.paint.background = Some(Color::BLACK.into());
    style
}

/// A patch that sets only the background.
fn background_patch(color: Color) -> StylePatch {
    PatchBuilder::default().background(color).patch()
}

/// An interaction state with exactly the given bits set.
fn interaction(bits: &[u8]) -> Interaction {
    let mut interaction = Interaction::default();
    for bit in bits {
        interaction.set(*bit, true);
    }
    interaction
}

/// One patch per state, each with its own background.
fn every_patch() -> Variants {
    Variants {
        hovered: Some(background_patch(Color::rgb(10, 0, 0))),
        focused: Some(background_patch(Color::rgb(20, 0, 0))),
        pressed: Some(background_patch(Color::rgb(30, 0, 0))),
        disabled: Some(background_patch(Color::rgb(40, 0, 0))),
    }
}

#[test]
fn patches_apply_in_a_fixed_order_and_pressed_overrides_hovered() {
    let variants = every_patch();
    let hovered = interaction(&[Interaction::HOVERED]);
    let focused = interaction(&[Interaction::HOVERED, Interaction::KEYBOARD_FOCUS]);
    let pressed = interaction(&[
        Interaction::HOVERED,
        Interaction::KEYBOARD_FOCUS,
        Interaction::PRESSED,
    ]);
    let disabled = interaction(&[
        Interaction::HOVERED,
        Interaction::KEYBOARD_FOCUS,
        Interaction::PRESSED,
        Interaction::DISABLED,
    ]);

    assert_eq!(
        resolve(&base(), &variants, disabled).paint.background,
        Some(Color::rgb(40, 0, 0).into()),
        "the disabled patch wins over every other state"
    );
    assert_eq!(
        resolve(&base(), &variants, pressed).paint.background,
        Some(Color::rgb(30, 0, 0).into()),
        "pressed overrides hovered and focused for the same field"
    );
    assert_eq!(
        resolve(&base(), &variants, focused).paint.background,
        Some(Color::rgb(20, 0, 0).into()),
        "focused overrides hovered for the same field"
    );
    assert_eq!(
        resolve(&base(), &variants, hovered).paint.background,
        Some(Color::rgb(10, 0, 0).into())
    );
    assert_eq!(
        resolve(&base(), &variants, interaction(&[]))
            .paint
            .background,
        Some(Color::BLACK.into()),
        "without any state the base style stands"
    );
}

#[test]
fn a_focused_patch_applies_only_while_keyboard_navigation_is_on() {
    let variants = Variants {
        focused: Some(background_patch(Color::rgb(20, 0, 0))),
        ..Variants::default()
    };

    let mouse = interaction(&[Interaction::FOCUSED]);
    assert_eq!(
        resolve(&base(), &variants, mouse).paint.background,
        Some(Color::BLACK.into()),
        "a focus that a press moved draws no focus style"
    );

    let keyboard = interaction(&[Interaction::FOCUSED, Interaction::KEYBOARD_FOCUS]);
    assert_eq!(
        resolve(&base(), &variants, keyboard).paint.background,
        Some(Color::rgb(20, 0, 0).into()),
        "a focus that Tab moved applies the focused patch"
    );
}

#[test]
fn a_patch_overrides_only_the_fields_its_setters_wrote() {
    let mut base_style = base();
    base_style.layout.width = Length::px(10.0);
    let variants = Variants {
        hovered: Some(background_patch(Color::rgb(10, 0, 0))),
        ..Variants::default()
    };

    let resolved = resolve(&base_style, &variants, interaction(&[Interaction::HOVERED]));
    assert_eq!(resolved.paint.background, Some(Color::rgb(10, 0, 0).into()));
    assert_eq!(
        resolved.layout.width,
        Length::px(10.0),
        "a paint patch leaves the layout fields alone"
    );
}

#[test]
fn a_state_without_a_patch_keeps_the_base_style() {
    let variants = Variants {
        pressed: Some(background_patch(Color::rgb(30, 0, 0))),
        ..Variants::default()
    };

    let resolved = resolve(
        &base(),
        &variants,
        interaction(&[Interaction::HOVERED, Interaction::DISABLED]),
    );
    assert_eq!(
        resolved.paint.background,
        Some(Color::BLACK.into()),
        "hovered and disabled have no patch, so the base background stands"
    );
}