Load playlists only when opening the playlist screen

src/events.rs

@@ -3,10 +3,12 @@ use cursive::{CbFunc, Cursive};
 
 use queue::QueueChange;
 use spotify::PlayerState;
+use ui::playlist::PlaylistEvent;
 
 pub enum Event {
     Queue(QueueChange),
     Player(PlayerState),
+    Playlist(PlaylistEvent),
 }
 
 pub type EventSender = Sender<Event>;

src/main.rs

@@ -37,6 +37,7 @@ mod theme;
 mod ui;
 
 use events::{Event, EventManager};
+use ui::playlist::PlaylistEvent;
 use queue::QueueChange;
 
 fn init_logger(content: TextContent) {
@@ -133,8 +134,8 @@ fn main() {
     cursive.add_fullscreen_layer(search.view);
 
     let playlistscreen = cursive.add_active_screen();
-    let playlists = ui::playlist::PlaylistView::new(queue.clone(), spotify.clone());
+    let mut playlists = ui::playlist::PlaylistView::new(queue.clone(), spotify.clone());
-    cursive.add_fullscreen_layer(playlists.view);
+    cursive.add_fullscreen_layer(playlists.view.take().unwrap());
 
     let queuescreen = cursive.add_active_screen();
     let mut queueview = ui::queue::QueueView::new(queue.clone(), spotify.clone());
@@ -161,9 +162,13 @@ fn main() {
         s.set_screen(searchscreen);
     });
 
-    cursive.add_global_callback(Key::F4, move |s| {
+    {
-        s.set_screen(playlistscreen);
+        let ev = event_manager.clone();
-    });
+        cursive.add_global_callback(Key::F4, move |s| {
+            s.set_screen(playlistscreen);
+            ev.send(Event::Playlist(PlaylistEvent::Refresh));
+        });
+    }
 
     // cursive event loop
     while cursive.is_running() {
@@ -173,6 +178,7 @@ fn main() {
             match event {
                 Event::Queue(ev) => queueview.handle_ev(&mut cursive, ev),
                 Event::Player(state) => spotify.updatestate(state),
+                Event::Playlist(event) => playlists.handle_ev(&mut cursive, event),
             }
         }
     }

src/ui/playlist.rs

@@ -1,41 +1,69 @@
 use std::sync::{Arc, Mutex};
 
+use cursive::traits::Identifiable;
 use cursive::direction::Orientation;
 use cursive::traits::Boxable;
 use cursive::views::*;
+use cursive::Cursive;
 
 use spotify::Spotify;
 use queue::Queue;
 
+pub enum PlaylistEvent {
+    Refresh,
+}
+
 pub struct PlaylistView {
-    pub view: Panel<LinearLayout>,
+    pub view: Option<Panel<LinearLayout>>,
+    queue: Arc<Mutex<Queue>>,
+    spotify: Arc<Spotify>,
 }
 
 impl PlaylistView {
     pub fn new(queue: Arc<Mutex<Queue>>, spotify: Arc<Spotify>) -> PlaylistView {
-        let mut results = SelectView::new();
+        let playlist_overview: IdView<SelectView> = SelectView::new().with_id("playlists_overview");
-        let playlists = spotify.current_user_playlist(50, 0).unwrap().items;
+        let scrollable = ScrollView::new(playlist_overview).full_width().full_height();
-
-        for playlist in &playlists {
-            results.add_item(playlist.name.clone(), playlist.id.clone());
-        }
-
-        let spotify_ref = spotify.clone();
-        results.set_on_submit(move |_s, id| {
-            let tracks = spotify_ref.user_playlist_tracks(id).unwrap().items;
-
-            let mut l_queue = queue.lock().expect("Could not aquire lock");
-            for playlist_track in tracks {
-                l_queue.enqueue(playlist_track.track.clone());
-            }
-        });
-
-        let scrollable = ScrollView::new(results).full_width().full_height();
         let layout = LinearLayout::new(Orientation::Vertical).child(scrollable);
         let rootpanel = Panel::new(layout).title("Playlists");
 
         PlaylistView {
-            view: rootpanel,
+            view: Some(rootpanel),
+            queue: queue,
+            spotify: spotify,
+        }
+    }
+    fn clear_playlists(&self, playlist_overview: &mut ViewRef<SelectView>) {
+        playlist_overview.clear();
+    }
+
+    fn show_playlists(&self, playlist_overview: &mut ViewRef<SelectView>) {
+        let playlists = self.spotify.current_user_playlist(50, 0).unwrap().items;
+        for playlist in &playlists {
+            playlist_overview.add_item(playlist.name.clone(), playlist.id.clone());
+        }
+
+        let spotify_ref = self.spotify.clone();
+        let queue_ref = self.queue.clone();
+        playlist_overview.set_on_submit(move |_s, id| {
+            let tracks = spotify_ref.user_playlist_tracks(id).unwrap().items;
+
+            let mut locked_queue = queue_ref.lock().expect("Could not aquire lock");
+            for playlist_track in tracks {
+                locked_queue.enqueue(playlist_track.track.clone());
+            }
+        });
+    }
+
+    pub fn handle_ev(&self, cursive: &mut Cursive, event: PlaylistEvent) {
+        let view_ref: Option<ViewRef<SelectView>> = cursive.find_id("playlists_overview");
+
+        if let Some(mut playlist_overview) = view_ref {
+            match event {
+                PlaylistEvent::Refresh => {
+                    self.clear_playlists(&mut playlist_overview);
+                    self.show_playlists(&mut playlist_overview);
+                }
+            }
         }
     }
 }