refs #79, more fix to prevent panic

Author: yjpark

crates/notation_bevy/src/app/app.rs

@@ -134,10 +134,14 @@ fn setup_camera(mut commands: Commands) {
 }
 
 fn load_tab(
+    mut commands: Commands,
+    time: Res<Time>,
     mut state: ResMut<NotationAppState>,
+    mut theme: ResMut<NotationTheme>,
     entities: Query<Entity, With<GlobalTransform>>,
     assets: ResMut<Assets<TabAsset>>,
     mut evts: EventWriter<AddTabEvent>,
+    viewer_query: Query<(Entity, &Arc<NotationViewer>), With<Arc<NotationViewer>>>,
 ) {
     if state.window_width > 0.0 && state.window_height > 0.0 && state.tab.is_none() && state.parse_error.is_none() {
         let mut count = 0;
@@ -146,13 +150,34 @@ fn load_tab(
         }
         //A bit hacky to make sure despawning finished, otherwise might got panic with "Entity not exist"
         if count > 1 {
-            println!("Waiting for entities to be despawned: {}", count);
+            if state._despawn_delay_seconds > 0.0 {
+                state._despawn_delay_seconds -= time.delta_seconds();
+                println!("load_tab(): Waiting to despawn: {} -> {}", count, state._despawn_delay_seconds);
+                return;
+            }
+            let mut despawn_count = 0;
+            for (entity, _viewer) in viewer_query.iter() {
+                commands.entity(entity).despawn_recursive();
+                despawn_count += 1;
+            }
+            if despawn_count > 0 {
+                println!("load_tab(): Despawning viewers: {} {}", despawn_count, count);
+            } else {
+                println!("load_tab(): Waiting for entities to be despawned: {}", count);
+            }
+            return;
+        }
+        if state._load_tab_delay_seconds > 0.0 {
+            state._load_tab_delay_seconds -= time.delta_seconds();
+            println!("load_tab(): Waiting to Load tab: -> {}", state._load_tab_delay_seconds);
             return;
         }
+        println!("\nload_tab(): Loading: {}", state.tab_path);
         if let Some(asset) = assets.get(&state.tab_asset) {
             match Tab::try_parse_arc(asset.tab.clone()) {
                 Ok(tab) => {
                     state.tab = Some(tab.clone());
+                    theme.loaded = true;
                     evts.send(AddTabEvent(tab));
                 }
                 Err(err) => {
@@ -165,17 +190,19 @@ fn load_tab(
 }
 
 fn handle_keyboard_inputs(
-    mut commands: Commands,
     keyboard_input: Res<Input<KeyCode>>,
-    mut state: ResMut<NotationAppState>,
+    mut app_state: ResMut<NotationAppState>,
     mut settings: ResMut<NotationSettings>,
+    mut theme: ResMut<NotationTheme>,
     mut midi_state: ResMut<MidiState>,
     mut play_control_evts: EventWriter<PlayControlEvent>,
     mut window_resized_evts: EventWriter<WindowResizedEvent>,
-    viewer_query: Query<(Entity, &Arc<NotationViewer>), With<Arc<NotationViewer>>>,
 ) {
+    if app_state.tab.is_none() {
+        return;
+    }
     if keyboard_input.just_released(KeyCode::LControl) {
-        state.hide_control = !state.hide_control;
+        app_state.hide_control = !app_state.hide_control;
         if !ControlView::HUD_MODE {
             window_resized_evts.send(WindowResizedEvent());
         }
@@ -184,19 +211,23 @@ fn handle_keyboard_inputs(
     } else if keyboard_input.just_released(KeyCode::Return) {
         crate::viewer::control::ControlView::play_or_stop(&mut midi_state, &mut play_control_evts);
     } else if keyboard_input.just_released(KeyCode::Backslash) {
-        crate::viewer::control::ControlView::toggle_layout_mode(&mut commands, &mut state, &mut settings, &viewer_query);
+        crate::viewer::control::ControlView::toggle_layout_mode(&mut app_state, &mut settings, &mut theme);
     }
 }
 
 fn handle_mouse_inputs(
     windows: Res<Windows>,
     mouse_input: Res<Input<MouseButton>>,
+    app_state: Res<NotationAppState>,
     settings: Res<NotationSettings>,
     mut mouse_motion_events: EventReader<MouseMotion>,
     mut mouse_wheel_input: EventReader<bevy::input::mouse::MouseWheel>,
     mut mouse_clicked: EventWriter<MouseClickedEvent>,
     mut mouse_dragged: EventWriter<MouseDraggedEvent>,
 ) {
+    if app_state.tab.is_none() {
+        return;
+    }
     if mouse_input.just_released(MouseButton::Left) {
         windows
             .get_primary()
@@ -235,6 +266,9 @@ fn handle_touch_inputs(
     mut mouse_clicked: EventWriter<MouseClickedEvent>,
     //mut mouse_dragged: EventWriter<MouseDraggedEvent>,
 ) {
+    if app_state.tab.is_none() {
+        return;
+    }
     for (_index, finger) in touch_input.iter().enumerate() {
         if touch_input.just_pressed(finger.id()) {
             windows
@@ -288,6 +322,9 @@ fn on_window_resized(
     mut app_state: ResMut<NotationAppState>,
     mut window_resized_evts: EventWriter<WindowResizedEvent>,
 ) {
+    if app_state.tab.is_none() {
+        return;
+    }
     for evt in evts.iter() {
         if evt.width as usize != window.width as usize
             || evt.height as usize != window.height as usize

crates/notation_bevy/src/app/app_state.rs

@@ -2,7 +2,6 @@ use std::sync::Arc;
 
 use crate::prelude::*;
 use bevy::prelude::*;
-use bevy::utils::Uuid;
 use notation_model::prelude::*;
 
 pub struct TabPathes(pub Vec<String>);
@@ -15,9 +14,10 @@ pub struct NotationAppState {
     pub tab_asset: Handle<TabAsset>,
     pub tab: Option<Arc<Tab>>,
     pub hide_control: bool,
-    pub viewer_uuid: Uuid,
     pub parse_error: Option<ParseError>,
     pub debug_str: Option<String>,
+    pub _despawn_delay_seconds: f32,
+    pub _load_tab_delay_seconds: f32,
 }
 
 impl NotationAppState {
@@ -31,16 +31,22 @@ impl NotationAppState {
             tab_asset,
             tab: None,
             hide_control: true,
-            viewer_uuid: Uuid::new_v4(),
             parse_error: None,
             debug_str: None,
+            _despawn_delay_seconds: 0.0,
+            _load_tab_delay_seconds: 0.0,
         }
     }
     pub fn change_tab(&mut self, asset_server: &AssetServer, tab_path: String) {
         self.tab_path = tab_path;
         self.tab_asset = asset_server.load(self.tab_path.as_str());
-        self.tab = None;
         self.parse_error = None;
+        self.reset_tab()
+    }
+    pub fn reset_tab(&mut self) {
+        self.tab = None;
+        self._despawn_delay_seconds = 0.1;
+        self._load_tab_delay_seconds = 0.2;
     }
     pub fn convert_pos(&self, pos: Vec2) -> Vec2 {
         Vec2::new(

crates/notation_bevy/src/bar/bar_view.rs

@@ -41,6 +41,7 @@ impl BarView {
         mut sep_query: Query<(Entity, &mut BarSeparatorData)>,
         mut beat_query: Query<(Entity, &mut BarBeatData)>,
     ) {
+        if !theme.loaded { return; }
         let engine = NotationLayout::new(&theme, &state, &settings);
         let mut bars = Vec::new();
         for evt in evts.iter() {
@@ -77,6 +78,7 @@ impl BarView {
         mut evts: EventReader<BarViewDoLayoutEvent>,
         mut text_query: Query<(&Parent, &mut Transform), With<Text>>,
     ) {
+        if !theme.loaded { return; }
         if !settings.hide_bar_number {
             for evt in evts.iter() {
                 for (parent, mut transform) in text_query.iter_mut() {

crates/notation_bevy/src/chord/chord_view.rs

@@ -46,6 +46,7 @@ impl ChordView {
         mut dot_query: Query<(Entity, &mut IntervalDotData)>,
         mut text_query: Query<&mut Transform, With<Text>>,
     ) {
+        if !theme.loaded { return; }
         for (_entity, _view, layout, children) in query.iter() {
             let radius = layout.size.width * theme.sizes.chord.diagram_factor;
             for child in children.iter() {
@@ -106,6 +107,7 @@ impl ChordView {
         >,
         mut diagram_query: Query<(Entity, &mut ChordDiagramData)>,
     ) {
+        if !theme.loaded { return; }
         for (_entity, playing, _view, children) in query.iter_mut() {
             for child in children.iter() {
                 if let Ok((diagram_entity, mut diagram_data)) = diagram_query.get_mut(*child) {

crates/notation_bevy/src/entry/entry_plugin.rs

@@ -150,6 +150,7 @@ fn on_tab_bars_resized(
     mut shape_diagram_6_query: Query<(Entity, &mut ShapeDiagramData6), With<ShapeDiagramData6>>,
     mut shape_diagram_4_query: Query<(Entity, &mut ShapeDiagramData4), With<ShapeDiagramData4>>,
 ) {
+    if !theme.loaded { return; }
     for evt in evts.iter() {
         let bars = &evt.0;
         for (entity, mut data) in tone_note_query.iter_mut() {

crates/notation_bevy/src/guitar/guitar_view.rs

@@ -134,6 +134,7 @@ impl GuitarView {
         mut capo_query: Query<(&Parent, Entity, &mut GuitarCapoData), With<GuitarCapoData>>,
         mut finger_query: Query<(&Parent, Entity, &mut FretFingerData), With<FretFingerData>>,
     ) {
+        if !theme.loaded { return; }
         for (entity, _view, layout) in query.iter() {
             let guitar_height = layout.size.width * theme.guitar.image_size.1 / theme.guitar.image_size.0;
             let guitar_size = LayoutSize::new(layout.size.width, guitar_height);
@@ -178,6 +179,7 @@ impl GuitarView {
         if Self::CHECKING_FRETS {
             return;
         }
+        if !theme.loaded { return; }
         let mut current_entry_pick = None;
         let mut string_states = [None; 6];
         let mut hit_strings = [(false, Duration::Zero); 6];
@@ -247,6 +249,7 @@ impl GuitarView {
         if Self::CHECKING_FRETS {
             return;
         }
+        if !theme.loaded { return; }
         let mut current_shape = None;
         for (entry, shape, playing) in query.iter() {
             if playing.value.is_current() {
@@ -326,6 +329,7 @@ impl GuitarView {
         capo_query: Query<&GuitarCapoData, Changed<GuitarCapoData>>,
         mut guitar_view_query: Query<&mut Transform, With<Arc<GuitarView>>>,
     ) {
+        if !theme.loaded { return; }
         if settings.override_guitar_y.is_some() {
             return;
         }

crates/notation_bevy/src/mini/mini_bar.rs

@@ -59,8 +59,7 @@ impl ShapeOp<NotationTheme, OutlineRectangle> for MiniBarData {
             theme
             .colors
             .mini_map
-            .bar_outline
-            .of_state(&self.value.playing_state)
+            .bar_outline_current
         } else {
             theme.colors.of_section(self.bar_props.section_ordinal)
         };

crates/notation_bevy/src/play/play_button.rs

@@ -175,6 +175,7 @@ impl PlayButton {
         query: LayoutChangedWithChildrenQuery<PlayButton>,
         mut shape_query: Query<(Entity, &mut PlayButtonShape)>,
     ) {
+        if !theme.loaded { return; }
         for (_entity, _view, layout, children) in query.iter() {
             for child in children.iter() {
                 if let Ok((entity, mut data)) = shape_query.get_mut(*child) {

crates/notation_bevy/src/play/play_panel.rs

@@ -98,6 +98,7 @@ impl PlayPanel {
         mut layout_query: LayoutQuery,
         cell_query: ViewQuery<PlayButton>,
     ) {
+        if !theme.loaded { return; }
         let engine = NotationLayout::new(&theme, &state, &settings);
         for evt in evts.iter() {
             evt.view.do_layout(
@@ -116,6 +117,7 @@ impl PlayPanel {
         mut evts: EventReader<PlayControlEvent>,
         mut shape_query: Query<(Entity, &mut PlayButtonShape)>,
     ) {
+        if !theme.loaded { return; }
         for evt in evts.iter() {
             match evt {
                 PlayControlEvent::OnTick {position: _, tick_result} => {

crates/notation_bevy/src/play/play_plugin.rs

@@ -114,6 +114,7 @@ fn on_tab_resized(
         &Arc<GridData>,
     )>,
 ) {
+    if !theme.loaded { return; }
     let mut bars = None;
     for evt in evts.iter() {
         bars = Some(&evt.0);
@@ -167,6 +168,7 @@ fn on_bar_playing_changed(
         &Arc<GridData>,
     )>,
 ) {
+    if !theme.loaded { return; }
     for (_entity, playing, _view, layout) in query.iter_mut() {
         if playing.value == PlayingState::Current {
             update_indicators(
@@ -204,6 +206,7 @@ fn on_tab_play_state_changed(
         &Arc<GridData>,
     )>,
 ) {
+    if !theme.loaded { return; }
     for (state_entity, tab_state) in query.iter_mut() {
         TabState::clear_play_state_changed(&mut commands, state_entity);
         if let Some(pos_data) = PosIndicatorData::update_pos(
@@ -310,6 +313,7 @@ fn on_play_control_evt(
     )>,
     mut beat_query: Query<(Entity, &mut BarBeatData)>,
 ) {
+    if !theme.loaded { return; }
     for evt in evts.iter() {
         for (state_entity, mut tab_state) in tab_state_query.iter_mut() {
             if !tab_state.under_control {