cranpose-app-shell 0.1.159

Application orchestration shell 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

use super::*;

fn key_logging_shell(
    log: Rc<RefCell<Vec<String>>>,
    with_field: bool,
) -> AppShell<HitGraphRenderer> {
    AppShell::new(
        HitGraphRenderer::default(),
        location_key(file!(), line!(), column!()),
        move || {
            let outer = Rc::clone(&log);
            cranpose_ui::UnhandledKeyEvents(move |event| {
                outer
                    .borrow_mut()
                    .push(format!("outer {:?}", event.key_code));
                true
            });
            let inner = Rc::clone(&log);
            cranpose_ui::UnhandledKeyEvents(move |event| {
                inner
                    .borrow_mut()
                    .push(format!("inner {:?}", event.key_code));
                event.key_code == KeyCode::X
            });
            if with_field {
                let field = cranpose_core::remember(|| {
                    cranpose_foundation::text::TextFieldState::new("Receipt")
                })
                .with(|field| *field);
                cranpose_ui::BasicTextField(
                    field,
                    Modifier::empty()
                        .size(Size::new(200.0, 48.0))
                        .content_description("Merchant"),
                    TextStyle::default(),
                );
            }
        },
    )
}

#[test]
fn a_key_no_control_takes_goes_to_the_handler_composed_last_first() {
    let _guard = test_guard();
    let log = Rc::new(RefCell::new(Vec::new()));
    let mut shell = key_logging_shell(Rc::clone(&log), false);
    shell.update();

    assert!(shell.on_key_event(&KeyEvent::key_down(KeyCode::X, "x")));
    assert_eq!(*log.borrow(), vec!["inner X".to_string()]);

    log.borrow_mut().clear();
    assert!(shell.on_key_event(&KeyEvent::key_down(KeyCode::Z, "z")));
    assert_eq!(
        *log.borrow(),
        vec!["inner Z".to_string(), "outer Z".to_string()],
        "a key the newest handler lets pass reaches the one composed before it"
    );
}

#[test]
fn a_key_typed_into_a_text_field_never_reaches_the_handlers() {
    let _guard = test_guard();
    let log = Rc::new(RefCell::new(Vec::new()));
    let mut shell = key_logging_shell(Rc::clone(&log), true);
    shell.set_semantics_enabled(true);
    shell.update();
    let placed =
        crate::placed_semantics::placed_semantics_from_shell(&mut shell).expect("placed field");
    let field = placed
        .flatten()
        .into_iter()
        .find(|node| node.editable_text && node.label.as_deref() == Some("Merchant"))
        .expect("named editable field");
    assert!(shell.accessibility_activate(field.node_id, None));
    shell.update();

    shell.on_key_event(&KeyEvent::key_down(KeyCode::X, "x"));
    assert!(
        log.borrow().is_empty(),
        "typing an x into a field must not press the play key: {:?}",
        log.borrow()
    );
}

#[test]
fn a_handler_that_left_composition_is_no_longer_asked() {
    let _guard = test_guard();
    let log = Rc::new(RefCell::new(Vec::new()));
    let shown = Rc::new(RefCell::new(None::<MutableState<bool>>));
    let content_log = Rc::clone(&log);
    let content_shown = Rc::clone(&shown);
    let mut shell = AppShell::new(
        HitGraphRenderer::default(),
        location_key(file!(), line!(), column!()),
        move || {
            let visible = rememberMutableStateOf(|| true);
            *content_shown.borrow_mut() = Some(visible);
            if visible.get() {
                let log = Rc::clone(&content_log);
                cranpose_ui::UnhandledKeyEvents(move |event| {
                    log.borrow_mut().push(format!("{:?}", event.key_code));
                    true
                });
            }
        },
    );
    shell.update();
    assert!(shell.on_key_event(&KeyEvent::key_down(KeyCode::B, "b")));

    shown.borrow().expect("visibility state").set(false);
    shell.update();
    assert!(!shell.on_key_event(&KeyEvent::key_down(KeyCode::B, "b")));
    assert_eq!(*log.borrow(), vec!["B".to_string()]);
}