fixes #118, use egui with rfd to show open file dialog to load tab from disk

Author: yjpark

Cargo.lock

@@ -9,11 +9,13 @@ fn main() {
     #[cfg(not(target_arch = "wasm32"))]
     let tabs = vec![
         "songs/misc/scarborough_fair.ron".to_owned(),
+        /*
         "songs/misc/stand_by_me.ron".to_owned(),
         "songs/jay/long_juan_feng.ron".to_owned(),
         "songs/pu_shu/bai_hua_lin.ron".to_owned(),
         "beginner/1_right_hand.ron".to_owned(),
         "test.ron".to_owned(),
+         */
     ];
     notation_bevy::prelude::NotationViewer::run(tabs);
 }

apps/notation_viewer/src/main.rs

@@ -60,6 +60,7 @@ bevy_easings = "0.4.1"
 # bevy_svg_map = "0.2"
 
 bevy-inspector-egui = { version = "0.5.1", optional = true }
+rfd = "0.6.2"
 
 #[target."cfg(not(target_arch = "wasm32"))".dependencies]
 # Can not enable bevy_wgpu in this way, so the actually binary crate

crates/notation_bevy/Cargo.toml

@@ -42,6 +42,8 @@ impl PluginGroup for NotationPlugins {
 pub struct NotationApp;
 
 impl NotationApp {
+    pub const TITLE:&'static str = "Notation Viewer";
+
     pub fn new_builder(title: &str) -> AppBuilder {
         let mut app = App::build();
         AssetLoader::new(NotationAssetsStates::Loading, NotationAssetsStates::Loaded)
@@ -137,6 +139,7 @@ fn setup_camera(mut commands: Commands) {
 fn load_tab(
     mut commands: Commands,
     time: Res<Time>,
+    mut windows: ResMut<Windows>,
     mut state: ResMut<NotationAppState>,
     mut theme: ResMut<NotationTheme>,
     entities: Query<Entity, With<GlobalTransform>>,
@@ -178,6 +181,10 @@ fn load_tab(
             match Tab::try_parse_arc(asset.tab.clone()) {
                 Ok(tab) => {
                     state.tab = Some(tab.clone());
+                    if let Some(window) = windows.get_primary_mut() {
+                        let title = format!("{} - {}", NotationApp::TITLE, state.tab_path);
+                        window.set_title(title);
+                    }
                     theme._bypass_systems = false;
                     evts.send(AddTabEvent(tab));
                 }

crates/notation_bevy/src/app/app.rs

@@ -37,7 +37,13 @@ impl NotationAppState {
             _load_tab_delay_seconds: 0.0,
         }
     }
-    pub fn change_tab(&mut self, asset_server: &AssetServer, tab_path: String) {
+    pub fn change_tab(
+        &mut self,
+        asset_server: &AssetServer,
+        theme: &mut NotationTheme,
+        tab_path: String
+    ) {
+        theme._bypass_systems = true;
         self.tab_path = tab_path;
         self.tab_asset = asset_server.load(self.tab_path.as_str());
         self.parse_error = None;

crates/notation_bevy/src/app/app_state.rs

@@ -159,7 +159,7 @@ impl NotationViewer {
         }
     }
     pub fn run(tab_pathes: Vec<String>) {
-        NotationApp::run("Notation Viewer", tab_pathes, |app| {
+        NotationApp::run(NotationApp::TITLE, tab_pathes, |app| {
             app.add_system_set(
                 SystemSet::on_update(NotationAssetsStates::Loaded)
                     .with_system(ControlView::control_ui.system())

crates/notation_bevy/src/viewer/app.rs

@@ -427,29 +427,48 @@ impl ControlView {
     pub fn tab_ui(
         ui: &mut Ui,
         asset_server: &AssetServer,
+        pathes: &mut TabPathes,
         state: &mut NotationAppState,
         _settings: &mut NotationSettings,
         theme: &mut NotationTheme,
-        tab_pathes: &TabPathes,
     ) {
-        if tab_pathes.0.len() > 1 {
+        if theme._bypass_systems {
+            ui.label("Loading Tab ...");
+            return;
+        }
+        ui.horizontal(|ui| {
+            if ui.button("Reset Tab").clicked() {
+                Control::reload_tab(state, theme);
+            }
+            #[cfg(not(target_arch = "wasm32"))]
+            if ui.button("Open Tab").clicked() {
+                if let Some(path) = rfd::FileDialog::new()
+                        .add_filter("Fun Notation", &["ron"])
+                        .pick_file() {
+                    let path_str = path.clone().into_os_string().into_string();
+                    if let Ok(path_str) = path_str {
+                        pathes.0.insert(0, path_str.clone());
+                        state.change_tab(asset_server, theme, path_str.clone());
+                    } else {
+                        println!("Failed to convert path to string: {:?} -> {:?}", path, path_str);
+                    }
+                }
+            }
+        });
+        if pathes.0.len() > 1 {
             let width = Self::calc_width(state.window_width);
             egui::ComboBox::from_label("")
                 .selected_text(state.tab_path.clone())
                 .width(width - 24.0)
                 .show_ui(ui, |ui| {
-                    for path in tab_pathes.0.iter() {
+                    for path in pathes.0.iter() {
                         if ui.selectable_label(*path == state.tab_path, path).clicked()
                         {
-                            theme._bypass_systems = true;
-                            state.change_tab(asset_server, path.clone());
+                            state.change_tab(asset_server, theme, path.clone());
                         }
                     }
                 });
         }
-        if ui.button("Reset Tab").clicked() {
-            Control::reload_tab(state, theme);
-        }
     }
     pub fn guitar_tab_display_ui(
         ui: &mut Ui,
@@ -622,10 +641,10 @@ impl ControlView {
         egui_ctx: Res<EguiContext>,
         mut windows: ResMut<Windows>,
         asset_server: Res<AssetServer>,
+        mut pathes: ResMut<TabPathes>,
         mut state: ResMut<NotationAppState>,
         mut settings: ResMut<NotationSettings>,
         mut theme: ResMut<NotationTheme>,
-        tab_pathes: Res<TabPathes>,
         mut midi_settings: ResMut<MidiSettings>,
         mut midi_state: ResMut<MidiState>,
         mut play_control_evts: EventWriter<PlayControlEvent>,
@@ -649,7 +668,7 @@ impl ControlView {
                     }
                     ui.separator();
                      */
-                    Self::tab_ui(ui, &asset_server, &mut state, &mut settings, &mut theme, &tab_pathes);
+                    Self::tab_ui(ui, &asset_server, &mut pathes, &mut state, &mut settings, &mut theme);
                     ui.separator();
                     Self::play_control_ui(ui, &mut settings, &mut midi_state, &mut play_control_evts);
                     ui.separator();

crates/notation_bevy/src/viewer/control_view.rs

@@ -1,4 +1,5 @@
 pub mod misc;
 pub mod text;
+pub mod path;
 
 pub struct BevyUtil();

crates/notation_bevy_utils/src/util/mod.rs

@@ -0,0 +1,49 @@
+use std::path::PathBuf;
+
+use super::BevyUtil;
+
+impl BevyUtil {
+    pub fn check_assets_path(root: PathBuf) -> Option<PathBuf> {
+        let mut path = root.clone();
+        path.push("assets");
+        if !path.exists() && path.is_dir() {
+            println!("BevyUtil check_assets_path() not exist: {:?} -> {:?}", root, path);
+        } else if !path.is_dir() {
+            println!("BevyUtil check_assets_path() is not dir: {:?} -> {:?}", root, path);
+        } else {
+            return Some(path);
+        }
+        None
+    }
+    pub fn get_assets_path() -> Option<PathBuf> {
+        let mut path = None;
+        if let Ok(root) = std::env::current_exe() {
+            if let Some(root) = root.parent() {
+                path = Self::check_assets_path(root.to_path_buf());
+            }
+        }
+        if path.is_none() {
+            if let Ok(root) = std::env::current_dir() {
+                path = Self::check_assets_path(root.to_path_buf());
+            }
+        }
+        path
+    }
+    fn _get_asset_path(root: PathBuf, name: &str, extension: &str) -> Option<PathBuf> {
+        let mut path = root.clone();
+        path.push(name);
+        path.set_extension(extension);
+        if path.exists() {
+            Some(path)
+        } else {
+            println!("BevyUtil check_asset_path() not exist: {:?} {}.{} -> {:?}", root, name, extension, path);
+            None
+        }
+    }
+    pub fn get_asset_path(name: &str, extension: &str) -> Option<PathBuf> {
+        match Self::get_assets_path() {
+            Some(root) => Self::_get_asset_path(root, name, extension),
+            None => None
+        }
+    }
+}