freya-core 0.4.0-rc.7

Reactivity runtime, tree management, accessibility integration, rendering pipeline and more, for Freya
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

use keyboard_types::{
    Key,
    Modifiers,
    NamedKey,
};

use crate::{
    accessibility::id::AccessibilityId,
    integration::{
        ACCESSIBILITY_ROOT_ID,
        AccessibilityGenerator,
    },
    platform::{
        NavigationMode,
        Platform,
    },
    prelude::{
        AccessibilityFocusStrategy,
        KeyboardEventData,
        Memo,
        ScreenReader,
        UserEvent,
        consume_root_context,
        use_hook,
        use_memo,
    },
};

#[derive(Clone, Copy)]
pub struct Focus {
    a11y_id: AccessibilityId,
}

impl Focus {
    pub fn create() -> Self {
        Self::new_for_id(Self::new_id())
    }

    pub fn new_for_id(a11y_id: AccessibilityId) -> Self {
        Self { a11y_id }
    }

    pub fn new_id() -> AccessibilityId {
        let accessibility_generator = consume_root_context::<AccessibilityGenerator>();
        AccessibilityId(accessibility_generator.new_id())
    }

    pub fn a11y_id(&self) -> AccessibilityId {
        self.a11y_id
    }

    pub fn is_focused(&self) -> bool {
        let platform = Platform::get();
        *platform.focused_accessibility_id.peek() == self.a11y_id
    }

    pub fn is_focused_with_keyboard(&self) -> bool {
        let platform = Platform::get();
        *platform.focused_accessibility_id.peek() == self.a11y_id
            && *platform.navigation_mode.peek() == NavigationMode::Keyboard
    }

    pub fn request_focus(&self) {
        Platform::get().send(UserEvent::FocusAccessibilityNode(
            AccessibilityFocusStrategy::Node(self.a11y_id),
        ));
    }

    pub fn request_unfocus(&self) {
        Platform::get().send(UserEvent::FocusAccessibilityNode(
            AccessibilityFocusStrategy::Node(ACCESSIBILITY_ROOT_ID),
        ));
    }

    pub fn is_pressed(event: &KeyboardEventData) -> bool {
        let is_space = matches!(event.key, Key::Character(ref s) if s == " ");
        let is_enter = event.key == Key::Named(NamedKey::Enter);

        if cfg!(target_os = "macos") {
            let screen_reader = ScreenReader::get();
            if screen_reader.is_on() {
                is_space
                    && event.modifiers.contains(Modifiers::CONTROL)
                    && event.modifiers.contains(Modifiers::ALT)
            } else {
                is_enter || is_space
            }
        } else {
            is_enter || is_space
        }
    }
}

pub fn use_focus() -> Focus {
    use_hook(Focus::create)
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FocusStatus {
    Not,
    Pointer,
    Keyboard,
}

impl FocusStatus {
    pub fn is_focused(&self) -> bool {
        matches!(self, Self::Pointer | Self::Keyboard)
    }
}

pub fn use_focus_status(focus: Focus) -> Memo<FocusStatus> {
    use_memo(move || {
        let platform = Platform::get();
        let is_focused = *platform.focused_accessibility_id.read() == focus.a11y_id;
        let is_keyboard = *platform.navigation_mode.read() == NavigationMode::Keyboard;

        match (is_focused, is_keyboard) {
            (true, false) => FocusStatus::Pointer,
            (true, true) => FocusStatus::Keyboard,
            _ => FocusStatus::Not,
        }
    })
}