bevy-persistent-windows 0.9.0

A Bevy plugin to easily create and manage windows that remember where they were.
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

//! Systems.

use crate::prelude::*;

/// System to automatically scale persistent windows on the first run.
pub fn auto_scale(
    mut persistent_windows: Query<
        (Entity, &mut Persistent<WindowState>),
        Changed<Persistent<WindowState>>,
    >,
    _to_run_in_main_thread: NonSendMarker,
) {
    WINIT_WINDOWS.with_borrow(|winit_windows| {
        for (entity, mut state) in persistent_windows.iter_mut() {
            if state.auto_scaled {
                if let Some(winit_window) = winit_windows.get_window(entity) {
                    if let Some(current_monitor) = winit_window.current_monitor() {
                        state.auto_scaled = false;
                        state.scale = Some(current_monitor.scale_factor());
                        state.persist().ok();
                    }
                }
            }
        }
    });
}

/// System to update persistent state when window is moved.
pub fn on_persistent_window_moved(
    mut window_moved_events: MessageReader<WindowMoved>,
    mut persistent_windows: Query<(Entity, &Window, &mut Persistent<WindowState>)>,
    _to_run_in_main_thread: NonSendMarker,
) {
    if window_moved_events.is_empty() {
        return;
    }

    WINIT_WINDOWS.with_borrow(|winit_windows| {
        for event in window_moved_events.read() {
            if let Some((entity, window, mut state)) =
                persistent_windows.iter_mut().find(|(entity, _, _)| event.window == *entity)
            {
                let winit_window_id = &winit_windows.entity_to_winit[&entity];
                let winit_window = &winit_windows.windows[winit_window_id];

                utils::apply_window_to_state(window, &mut state, winit_window);
            }
        }
    });
}

/// System to update persistent state when window is resized.
pub fn on_persistent_window_resized(
    mut window_resized_events: MessageReader<WindowResized>,
    mut persistent_windows: Query<(Entity, &Window, &mut Persistent<WindowState>)>,
    _to_run_in_main_thread: NonSendMarker,
) {
    if window_resized_events.is_empty() {
        return;
    }

    WINIT_WINDOWS.with_borrow(|winit_windows| {
        for event in window_resized_events.read() {
            if let Some((entity, window, mut state)) =
                persistent_windows.iter_mut().find(|(entity, _, _)| event.window == *entity)
            {
                let winit_window_id = &winit_windows.entity_to_winit[&entity];
                let winit_window = &winit_windows.windows[winit_window_id];

                utils::apply_window_to_state(window, &mut state, winit_window);
            }
        }
    });
}

/// System to update persistent state when window scale factor is changed.
pub fn on_persistent_window_scale_factor_changed(
    mut window_scale_factor_changed_events: MessageReader<WindowScaleFactorChanged>,
    mut persistent_windows: Query<(Entity, &Window, &mut Persistent<WindowState>)>,
    _to_run_in_main_thread: NonSendMarker,
) {
    if window_scale_factor_changed_events.is_empty() {
        return;
    }

    WINIT_WINDOWS.with_borrow(|winit_windows| {
        for event in window_scale_factor_changed_events.read() {
            if let Some((entity, window, mut state)) =
                persistent_windows.iter_mut().find(|(entity, _, _)| event.window == *entity)
            {
                let winit_window_id = &winit_windows.entity_to_winit[&entity];
                let winit_window = &winit_windows.windows[winit_window_id];

                utils::apply_window_to_state(window, &mut state, winit_window);
            }
        }
    });
}

/// System to update window when persistent state is modified programmatically.
pub fn on_persistent_window_state_changed(
    mut persistent_windows: Query<
        (&mut Window, &mut Persistent<WindowState>),
        Changed<Persistent<WindowState>>,
    >,
) {
    for (mut window, mut state) in persistent_windows.iter_mut() {
        if !state.sync {
            state.sync = true;
            continue;
        }

        state.persist().ok();
        utils::apply_state_to_window(window.deref_mut(), state.deref_mut());
    }
}