Other crap i added months ago

xmpd-cache/src/downloader/song.rs

@@ -10,6 +10,7 @@ lazy_static::lazy_static!(
 pub enum SongStatus {
     Downloading,
     Converting,
+    Failed(String),
     Done
 }
 
@@ -59,16 +60,27 @@ impl SongCacheDl {
                 let dl_child = dl_cmd.spawn()?;
                 self.jobs.insert(sid, SongStatus::Downloading);
                 std::thread::spawn(move || {
+                    let mut err_line = String::new();
                     if let Ok(output) = dl_child.wait_with_output() {
                         for line in String::from_utf8(output.stdout).unwrap().lines() {
+                            if line.contains("ERROR") {
+                                err_line = line.to_string();
+                            }
                             log::info!("CMD: {}", line);
                         }
                         for line in String::from_utf8(output.stderr).unwrap().lines() {
+                            if line.contains("ERROR") {
+                                err_line = line.to_string();
+                            }
                             log::error!("CMD: {}", line);
                         }
                     }
                     let mut cache = SONG_CACHE_DL.lock().unwrap();
-                    cache.jobs.insert(sid, SongStatus::Done);
+                    if song_p.exists() {
+                        cache.jobs.insert(sid, SongStatus::Done);
+                    } else {
+                        cache.jobs.insert(sid, SongStatus::Failed(err_line));
+                    }
                     cache.current_jobs -= 1;
                 });
             }
@@ -116,9 +128,12 @@ impl SongCacheDl {
                     log::debug!("from: {from:?} to: {to:?}");
                     std::fs::copy(&from, &to).unwrap();
                     from.pop();
-                    std::fs::remove_dir_all(from).unwrap();
                     let mut cache = SONG_CACHE_DL.lock().unwrap();
-                    cache.jobs.insert(sid, SongStatus::Done);
+                    if let Err(_) = std::fs::remove_dir_all(from) {
+                        cache.jobs.insert(sid, SongStatus::Failed(String::from("Unknown")));
+                    } else {
+                        cache.jobs.insert(sid, SongStatus::Done);
+                    }
                     cache.current_jobs -= 1;
                 });
             }

xmpd-cache/src/lib.rs

@@ -78,8 +78,15 @@ impl Cache {
     }
 
     pub fn download_song_to_cache(&mut self, sid: uuid::Uuid, song: Song) {
-        self.song_queue.push((sid, song));
-        self.song_cache.insert(sid, DlStatus::Downloading);
+        let song_format = xmpd_settings::Settings::get().unwrap().tooling.song_format.clone();
+        let mut p = self.cache_dir.clone();
+        p.push("songs");
+        p.push(format!("{sid}.{song_format}"));
+        if !p.exists() {
+            log::info!("p: {p:?}");
+            self.song_queue.push((sid, song));
+            self.song_cache.insert(sid, DlStatus::Downloading);
+        }
     }
     pub fn download_icon_to_cache(&mut self, sid: uuid::Uuid, song: Song) {
         self.icon_queue.push((sid, song));
@@ -128,6 +135,11 @@ fn start_cache_mv_thread(tx: Sender<Message>) {
                             cache.song_cache.insert(sid.clone(), DlStatus::Done(Some(song_p.into()))); 
                             done_jobs.push(sid.clone());
                         }
+                    } else if let SongStatus::Failed(e) = status {
+                        let mut cache = he!(tx, CACHE.lock());
+                        let _ = tx.send(Message::Error(std::file!(), std::line!() as usize, format!("Failed to download song {sid}: {e}")));
+                        cache.song_cache.insert(sid.clone(), DlStatus::Error(std::file!(), std::line!() as usize, format!("Failed to download song {sid}: {e}"))); 
+                        done_jobs.push(sid.clone());
                     }
                 }
                 for sid in done_jobs {

xmpd-gui/src/components/left_nav/mod.rs

@@ -1,5 +1,5 @@
 use egui::{CursorIcon, RichText, Sense, TextBuffer};
-use xmpd_manifest::store::BaseStore;
+use xmpd_manifest::store::{BaseStore, StoreExtras};
 use crate::utils::SearchType;
 
 use super::{CompGetter, CompUi};
@@ -23,12 +23,7 @@ impl CompUi for LeftNav {
                 ui.vertical(|ui| {
                     let len = state.manifest.store().get_songs().len();
                     add_playlist_tab(ui, &None, "All Songs", None, len, w);
-                    let mut playlists: Vec<_> = state.manifest.store().get_playlists().into_iter().collect();
-                    playlists.sort_by(|a, b| {
-                        let a = a.1.name().to_lowercase();
-                        let b = b.1.name().to_lowercase();
-                        a.cmp(&b)
-                    });
+                    let playlists = state.manifest.store().get_playlists_sorted();
                     let search_text = handle_error_ui!(header::Header::get()).search_text.clone();
                     let (qtyp, qtxt) = crate::utils::SearchType::from_str(&search_text);
                     for (pid, playlist) in playlists.iter() {

xmpd-gui/src/components/song_list/mod.rs

@@ -1,6 +1,6 @@
 use egui::{Color32, CursorIcon, ImageSource, RichText, Sense, Vec2};
 use xmpd_cache::DlStatus;
-use xmpd_manifest::{query, song::Song, store::BaseStore};
+use xmpd_manifest::{query, song::Song, store::{BaseStore, StoreExtras}};
 use crate::utils::SearchType;
 
 use super::{CompGetter, CompUi};
@@ -24,7 +24,7 @@ impl CompUi for SongList {
             sl.playable_songs = Self::get_playable_songs(&songs)?;
             if let Some((sid, _)) = songs.first() {
                 if sl.selected_sid == Default::default() {
-                    sl.selected_sid = sid.clone();
+                    sl.selected_sid = (*sid).clone();
                 }
             }
         }
@@ -34,8 +34,8 @@ impl CompUi for SongList {
             .show(ui, |ui| {
                 ui.vertical(|ui| {
                     ui.add_space(3.0);
-                    for (sid, song) in disp_songs {
-                         handle_error_ui!(Self::display_song_tab(ui, state, &sid, &song));
+                    for sid in disp_songs {
+                         handle_error_ui!(Self::display_song_tab(ui, state, &sid));
                     }
                 });
         });
@@ -44,40 +44,19 @@ impl CompUi for SongList {
 }
 
 impl SongList {
-    fn get_and_sort_songs(state: &mut crate::GuiState) -> crate::Result<Vec<(uuid::Uuid, Song)>> {
+    fn get_and_sort_songs(state: &mut crate::GuiState) -> crate::Result<Vec<(&uuid::Uuid, &Song)>> {
         let pid = super::left_nav::LeftNav::get()?.selected_playlist_id.clone();
         match pid {
             None => {
-                let songs = state.manifest.store().get_songs().clone().into_iter();
-                let mut songs: Vec<_> = songs.collect();
-                songs.sort_by(|a, b| {
-                    let a = a.1.name().to_lowercase();
-                    let b = b.1.name().to_lowercase();
-                    a.cmp(&b)
-                });
-                Ok(songs)
+                Ok(state.manifest.store().get_songs_sorted())
             }
             Some(pid) => {
-                let Some(playlist) = state.manifest.store().get_playlist(&pid) else {
-                    anyhow::bail!("Couldnt find playlist (corruption?)");
-                };
-                let mut songs = Vec::new();
-                for sid in playlist.songs() {
-                    if let Some(song) = state.manifest.store().get_song(&sid) {
-                        songs.push((sid.clone(), song.clone()));
-                    }
-                }
-                songs.sort_by(|a, b| {
-                    let a = a.1.name().to_lowercase();
-                    let b = b.1.name().to_lowercase();
-                    a.cmp(&b)
-                });
-                Ok(songs)
+                Ok(state.manifest.store().get_playlist_songs_sorted(pid).expect("Invalid pid"))
             }
         }
     }
 
-    fn get_songs_to_display(songs: &Vec<(uuid::Uuid, Song)>) -> crate::Result<Vec<(uuid::Uuid, Song)>>{
+    fn get_songs_to_display<'a>(songs: &'a [(&uuid::Uuid, &Song)]) -> crate::Result<Vec<uuid::Uuid>>{
         let mut to_display = Vec::new();
         let query = {header::Header::get()?.search_text.clone()};
         let (query_type, query_text) = crate::utils::SearchType::from_str(&query);
@@ -105,15 +84,16 @@ impl SongList {
             };
 
             if should_display {
-                to_display.push((sid.clone(), song.clone()));
+                to_display.push((*sid).clone());
             }
         }
         Ok(to_display)
     }
 
-    fn display_song_tab(ui: &mut egui::Ui, state: &mut crate::GuiState, sid: &uuid::Uuid, song: &Song) -> crate::Result<()> {
+    fn display_song_tab(ui: &mut egui::Ui, state: &mut crate::GuiState, sid: &uuid::Uuid) -> crate::Result<()> {
         let mut clicked = false;
         ui.horizontal(|ui| {
+            let song = handle_option!("(internal)", state.manifest.store().get_song(sid));
             let theme = handle_error_ui!(xmpd_settings::Settings::get()).theme.clone();
             // let icon_status = handle_error_ui!(xmpd_cache::Cache::get()).get_cached_icon_status(&sid).clone();
             let img = ui.add(
@@ -200,7 +180,7 @@ impl SongList {
                                 .size(16.0);
                         ui.add(spinner);
                     }
-                    Some(DlStatus::Error(e, ..)) => {
+                    Some(DlStatus::Error(_, _,  e)) => {
                         let img = egui::Image::new(crate::data::WARN_ICON)
                                 .tint(Color32::LIGHT_YELLOW)
                                 .sense(Sense::hover())
@@ -274,12 +254,12 @@ impl SongList {
         self.play_song(next, state)?;
         Ok(())
     }
-    fn get_playable_songs(songs: &Vec<(uuid::Uuid, Song)>) -> crate::Result<Vec<uuid::Uuid>> {
+    fn get_playable_songs(songs: &[(&uuid::Uuid, &Song)]) -> crate::Result<Vec<uuid::Uuid>> {
         let mut playable_songs = Vec::new();
         
         for (sid, _) in songs {
             if let Some(DlStatus::Done(_)) = xmpd_cache::Cache::get()?.get_cached_song_status(&sid) {
-                playable_songs.push(sid.clone());
+                playable_songs.push((*sid).clone());
             }
         }
         Ok(playable_songs)

xmpd-gui/src/components/top_nav.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use egui::TextBuffer;
+use egui::{Layout, TextBuffer};
 use xmpd_manifest::store::{JsonStore, TomlStore};
 
 use crate::windows::WindowId;
@@ -65,7 +65,10 @@ impl CompUi for TopNav {
                     }
         
                 });
-
+                #[cfg(debug_assertions)]
+                ui.with_layout(Layout::right_to_left(egui::Align::Max), |ui| {
+                    ui.label(format!("ft: {} ms", state.debug_info.last_frame_time.as_millis()));
+                });
              });
         });
         let mut used = false;

xmpd-gui/src/lib.rs

@@ -1,6 +1,4 @@
-#![feature(async_closure)]
-
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use xmpd_manifest::{store::JsonStore, Manifest};
 
 #[macro_use]
@@ -20,10 +18,19 @@ pub fn start() -> Result<()> {
     let options = eframe::NativeOptions::default();
     let mut state = GuiState::new()?;
     let res = eframe::run_simple_native(W_NAME, options, move |ctx, _frame| {
+        #[cfg(debug_assertions)]
+        let f_start = Instant::now();
+
         egui_extras::install_image_loaders(ctx);
-        state.windows.clone().draw_all(ctx, &mut state); 
+        windows::Windows::draw_all(ctx, &mut state); 
         handle_error_ui!(main_window::draw(ctx, &mut state, &cache_rx));
         ctx.request_repaint_after(Duration::from_millis(500));
+
+        #[cfg(debug_assertions)]
+        {
+            let f_end = Instant::now();
+            state.debug_info.last_frame_time = f_end.duration_since(f_start);
+        }
     });
     if let Err(e) = res { // dumb err value by eframe
         anyhow::bail!(e.to_string());
@@ -31,15 +38,34 @@ pub fn start() -> Result<()> {
     Ok(())
 }
 
-
+#[cfg(debug_assertions)]
+#[derive(Debug, Default)]
+pub struct DebugInfo {
+    pub last_frame_time: Duration,
+}
 
 pub struct GuiState {
+    #[cfg(debug_assertions)]
+    pub debug_info: DebugInfo,
     pub manifest: Manifest<JsonStore>,
     pub windows: windows::Windows,
     pub player: xmpd_player::Player,
 }
 
 impl GuiState {
+    #[cfg(debug_assertions)]
+    pub fn new() -> Result<Self> {
+        Ok(Self {
+            debug_info: DebugInfo {
+                last_frame_time: Default::default()
+            },
+            player: xmpd_player::Player::new(),
+            manifest: Manifest::new(&xmpd_cliargs::CLIARGS.manifest_path())?,
+            windows: windows::Windows::new(),
+        })
+    }
+
+    #[cfg(not(debug_assertions))]
     pub fn new() -> Result<Self> {
         Ok(Self {
             player: xmpd_player::Player::new(),

xmpd-gui/src/main_window.rs

@@ -30,13 +30,15 @@ pub fn draw(ctx: &egui::Context, state: &mut GuiState, cache_rx: &Receiver<Messa
                 ui.horizontal(|ui| {
                     ui.set_height(main_height);  
                     ui.vertical(|ui| {
+                        ui.set_height(main_height);
                         ui.group(|ui| {
                             //ui.set_height(main_height * 0.1);
                             ui.set_max_width(left_nav_width);
                             handle_error_ui!(crate::components::left_nav::header::Header::draw(ui, state));
                         });
+                        let avail = ui.available_size();
                         ui.group(|ui| {
-                            // ui.set_height(main_height * 0.9);
+                            ui.set_height(avail.y);
                             ui.set_max_width(left_nav_width);
                             handle_error_ui!(crate::components::left_nav::LeftNav::draw(ui, state));
                         });

xmpd-gui/src/windows/add_song.rs

@@ -1,9 +1,13 @@
+use egui::{RichText, TextEdit};
+use xmpd_cache::DlStatus;
+use xmpd_manifest::store::{BaseStore, StoreExtras};
+
 use super::Window;
 
 
 #[derive(Debug, Default)]
 pub struct AddSongW {
-
+    sid: uuid::Uuid,
 }
 
 impl Window for AddSongW {
@@ -13,8 +17,83 @@ impl Window for AddSongW {
     fn default_title() -> &'static str where Self: Sized {
         "Add Song to Playlist"
     }
-    fn draw(&mut self, ui: &mut egui::Ui, _: &mut crate::GuiState) -> crate::Result<()> {
-        ui.label("Hello from other window!");
+    fn draw(&mut self, ui: &mut egui::Ui, state: &mut crate::GuiState) -> crate::Result<()> {
+        let theme = xmpd_settings::Settings::get()?.theme.clone();
+
+        let songs: Vec<_> = state.manifest.store().get_songs_sorted();
+        if self.sid.is_nil() {
+            if let Some(sid) = songs.first() {
+                self.sid = sid.0.clone();
+            }
+        }
+        let avail = ui.available_size();
+        ui.horizontal(|ui| {
+            ui.vertical(|ui| {
+                ui.group(|ui| {
+                    ui.set_height(avail.y);
+                    let img = egui::Image::new(crate::data::NOTE_ICON)
+                        .tint(theme.accent_color)
+                        .fit_to_exact_size(egui::Vec2::new(64.0, 64.0));
+                    ui.add(img);
+                    let mut name = String::new();
+                    let mut author = String::new();
+                    if let Some(song) = state.manifest.store().get_song(&self.sid) {
+                        name = song.name().to_string();
+                        author = song.author().to_string();
+                    }
+                    ui.horizontal(|ui| {
+                        ui.style_mut().spacing.text_edit_width = 150.0;
+                        ui.label("Name:   ");
+                        ui.add_enabled(false, TextEdit::singleline(&mut name));
+                    });
+                    ui.horizontal(|ui| {
+                        ui.style_mut().spacing.text_edit_width = 150.0;
+                        ui.label("Author: ");
+                        ui.add_enabled(false, TextEdit::singleline(&mut author));
+                    });
+                });
+            });
+            ui.vertical(|ui| {
+                ui.group(|ui| {
+                    egui::ScrollArea::vertical()
+                        .id_source("song_list_song_add")
+                        .drag_to_scroll(false)
+                        .show(ui, |ui| {
+                            ui.vertical(|ui| {
+                                for (sid, song) in songs {
+                                    ui.group(|ui| {
+                                        let avail = ui.available_size();
+                                        ui.horizontal(|ui| {
+                                            ui.set_width(avail.x);
+                                            let img = egui::Image::new(crate::data::NOTE_ICON)
+                                                .tint(theme.accent_color)
+                                                .fit_to_exact_size(egui::Vec2::new(32.0, 32.0));
+                                            ui.add(img);
+                                            ui.vertical(|ui| {
+                                                let status = {
+                                                    handle_error_ui!(xmpd_cache::Cache::get()).get_cached_song_status(&sid).clone()
+                                                };
+                                                let label = if self.sid == *sid {
+                                                    RichText::new(song.name())
+                                                        .color(theme.accent_color)
+                                                } else if matches!(status, Some(DlStatus::Done(_))) {
+                                                    RichText::new(song.name())
+                                                        .color(theme.text_color)
+                                                } else {
+                                                    RichText::new(song.name())
+                                                        .color(theme.dim_text_color)
+                                                };
+                                                ui.label(label);
+                                            });
+                                        });
+                                    });
+                                }
+                            });
+                        }
+                    );
+                });
+            })
+        });
         Ok(()) 
     }
 }

xmpd-gui/src/windows/mod.rs

@@ -67,13 +67,13 @@ impl Windows {
         WINDOWS.lock().unwrap().insert(WT::id(), Box::<WT>::default());
     }
 
-    pub fn draw_all(&mut self, ctx: &egui::Context, state: &mut GuiState) {
+    pub fn draw_all(ctx: &egui::Context, state: &mut GuiState) {
         let theme = handle_error_ui!(xmpd_settings::Settings::get()).theme.clone();
-        for (win_id, (vp_id, builder)) in &self.windows {
-            if self.is_open(&win_id) {
+        for (win_id, (vp_id, builder)) in state.windows.windows.clone().into_iter() {
+            if state.windows.is_open(&win_id) {
                 ctx.show_viewport_immediate(vp_id.clone(), builder.clone(), |ctx, _vp_class| {        
                     ctx.input(|inp| {
-                        self.toggle(win_id, !inp.viewport().close_requested());
+                        state.windows.toggle(&win_id, !inp.viewport().close_requested());
                     });
                     egui::CentralPanel::default()
                         .frame(

xmpd-manifest/src/store/json.rs

@@ -15,6 +15,8 @@ pub struct JsonStore {
     playlists: HashMap<Uuid, Playlist>
 }
 
+impl super::StoreExtras for JsonStore {}
+
 impl super::BaseStore for JsonStore {
     fn get_default_file_contents() -> &'static str {
         &DEFAULT_TEXT

xmpd-manifest/src/store/mod.rs

@@ -40,3 +40,55 @@ pub trait BaseStore {
     fn get_original_path(&self) -> &Path;
 }
 
+pub trait StoreExtras: BaseStore {
+    fn get_songs_sorted(&self) -> Vec<(&Uuid, &Song)> {
+        let mut songs: Vec<_> = self.get_songs().iter().collect();
+        songs.sort_by(|a, b| {
+            let a = a.1.name().to_lowercase();
+            let b = b.1.name().to_lowercase();
+            a.cmp(&b)
+        });
+        songs
+    }
+
+    fn get_songs_sorted_cloned(&self) -> Vec<(Uuid, Song)> {
+        let mut songs = Vec::new();
+        for song in self.get_songs_sorted() {
+            songs.push((song.0.clone(), song.1.clone()));
+        }
+        songs
+    }
+
+    fn get_playlists_sorted(&self) -> Vec<(&Uuid, &Playlist)> {
+        let mut songs: Vec<_> = self.get_playlists().iter().collect();
+        songs.sort_by(|a, b| {
+            let a = a.1.name().to_lowercase();
+            let b = b.1.name().to_lowercase();
+            a.cmp(&b)
+        });
+        songs
+    }
+    fn get_playlist_songs_sorted(&self, pid: uuid::Uuid) -> Option<Vec<(&Uuid, &Song)>> {
+        let songs_ids: Vec<_> = self.get_playlist(&pid)?.songs().iter().collect();
+        let mut songs = Vec::new();
+
+        for sid in songs_ids {
+            songs.push((sid, self.get_song(sid)?));
+        }
+
+        songs.sort_by(|a, b| {
+            let a = a.1.name().to_lowercase();
+            let b = b.1.name().to_lowercase();
+            a.cmp(&b)
+        });
+        Some(songs)
+    }
+    fn get_playlist_songs_sorted_cloned(&self, pid: uuid::Uuid) -> Option<Vec<(Uuid, Song)>> {
+        let mut songs = Vec::new();
+        for song in self.get_playlist_songs_sorted(pid)? {
+            songs.push((song.0.clone(), song.1.clone()));
+        }
+        Some(songs)
+    }
+}
+

xmpd-manifest/src/store/toml.rs

@@ -15,6 +15,8 @@ pub struct TomlStore {
     playlists: HashMap<Uuid, Playlist>
 }
 
+impl super::StoreExtras for TomlStore {}
+
 impl super::BaseStore for TomlStore {
     fn get_default_file_contents() -> &'static str {
         &DEFAULT_TEXT