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

//! Has systems for the display settings menu.

use bevy::prelude::*;
use game_library::{
    font_resource::{ChangeFont, FontChoice, FontResource},
    settings::{next_font_family, AccessibilitySettings, SettingCategory, SettingChanged},
    state::Settings,
};

use crate::{despawn_with_tag, resources::style_prefab};

use super::{
    base::SettingsMenuEntity,
    button_actions::{ButtonAction, SettingsMenuButton},
    events::{ChangeSetting, IndividualSetting},
};

/// Component for tagging entities that are part of the display settings menu.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component)]
struct AccessibilitySettingsMenuEntity;

fn show_accessibility_settings(
    mut commands: Commands,
    fonts: Res<FontResource>,
    accessibility_settings: Res<AccessibilitySettings>,
) {
    commands
        .spawn((
            style_prefab::settings_menu_full_node_bundle(),
            AccessibilitySettingsMenuEntity,
            SettingsMenuEntity,
        ))
        .with_children(|parent| {
            // Game Title
            parent.spawn(style_prefab::settings_menu_title_bundle(
                "Accessibility",
                fonts.display_font.clone(),
            ));
            // #### MENU BUTTONS #####
            parent
                .spawn(style_prefab::settings_menu_column_node_bundle())
                .with_children(|menu_buttons| {
                    // font choice (as a row with a label and a button)
                    menu_buttons
                        .spawn(style_prefab::settings_menu_button_row_node_bundle())
                        .with_children(|row| {
                            // Button for rotating font family
                            row.spawn((
                                style_prefab::menu_button_bundle(),
                                ButtonAction::RotateFontFamily,
                                SettingsMenuButton,
                            ))
                            .with_children(|button| {
                                button.spawn(style_prefab::menu_button_text(
                                    "Interface Font",
                                    fonts.interface_font.clone(),
                                ));
                            });
                            // Text for current font family
                            row.spawn((
                                style_prefab::settings_menu_info_text_bundle(
                                    accessibility_settings.interface_font_family,
                                    fonts.main_font.clone(),
                                ),
                                CurrentFontFamilyText,
                            ));
                        });
                    // Back button (=> settings)
                    menu_buttons
                        .spawn((
                            style_prefab::menu_button_bundle(),
                            ButtonAction::BackToMenu,
                            SettingsMenuButton,
                        ))
                        .with_children(|button| {
                            button.spawn(style_prefab::menu_button_text(
                                "Back",
                                fonts.interface_font.clone(),
                            ));
                        });
                });
        });
}

#[derive(Component)]
struct CurrentFontFamilyText;

pub(super) struct AccessibilitySettingsMenuPlugin;

impl Plugin for AccessibilitySettingsMenuPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(
            OnEnter(Settings::Accessibility),
            show_accessibility_settings,
        );
        app.add_systems(
            Update,
            (
                handle_accessibility_setting_changes,
                (update_current_font_family_text),
            )
                .run_if(in_state(Settings::Accessibility)),
        );
        app.add_systems(
            OnExit(Settings::Accessibility),
            despawn_with_tag::<AccessibilitySettingsMenuEntity>,
        );
    }
}

/// System to handle the accessibility menu button actions.
fn handle_accessibility_setting_changes(
    mut er_change_setting: EventReader<ChangeSetting>,
    mut accessibility_settings: ResMut<AccessibilitySettings>,
    mut ew_setting_changed: EventWriter<SettingChanged>,
    mut ew_change_font: EventWriter<ChangeFont>,
    fonts: Res<FontResource>,
) {
    for change_setting in er_change_setting.read() {
        if matches!(change_setting.setting, IndividualSetting::FontFamily) {
            let new_font_family = next_font_family(accessibility_settings.interface_font_family);
            accessibility_settings.interface_font_family = new_font_family;
            ew_change_font.send(ChangeFont {
                font_choice: FontChoice::Interface,
                new_font: fonts.get_font_handle(new_font_family),
            });
            // Alert the system that the font has changed (to flush settings to disk)
            ew_setting_changed.send(SettingChanged(SettingCategory::Accessibility));
        }
    }
}

/// System to update the text of the current font family.
fn update_current_font_family_text(
    accessibility_settings: Res<AccessibilitySettings>,
    fonts: Res<FontResource>,
    mut text_query: Query<&mut Text, With<CurrentFontFamilyText>>,
) {
    for mut text in &mut text_query {
        text.sections[0].value = accessibility_settings.interface_font_family.into();
        // Set the font to reflect the new font family
        text.sections[0].style.font =
            fonts.get_font_handle(accessibility_settings.interface_font_family);
    }
}