Add new work and recording selectors

src/editors/recording.rs

@@ -1,7 +1,7 @@
 use super::performance::PerformanceEditor;
 use crate::backend::Backend;
 use crate::database::*;
-use crate::selectors::PersonSelector;
+use crate::selectors::{PersonSelector, WorkSelector};
 use crate::widgets::{List, Widget};
 use crate::navigator::{NavigationHandle, Screen};
 use anyhow::Result;
@@ -94,7 +94,10 @@ impl Screen<Option<Recording>, Recording> for RecordingEditor {
 
         work_button.connect_clicked(clone!(@weak this => move |_| {
             spawn!(@clone this, async move {
-                // TODO: We need the pushed screen to return a work here.
+                if let Some(work) = push!(this.handle, WorkSelector).await {
+                    this.work_selected(&work);
+                    this.work.replace(Some(work));
+                }
             });
         }));
 

src/import/track_set_editor.rs

@@ -4,7 +4,7 @@ use super::track_selector::TrackSelector;
 use crate::backend::Backend;
 use crate::database::Recording;
 use crate::navigator::{NavigationHandle, Screen};
-use crate::selectors::PersonSelector;
+use crate::selectors::{PersonSelector, RecordingSelector};
 use crate::widgets::{List, Widget};
 use gettextrs::gettext;
 use glib::clone;
@@ -88,7 +88,12 @@ impl Screen<Rc<Box<dyn Source>>, TrackSetData> for TrackSetEditor {
         }));
 
         select_recording_button.connect_clicked(clone!(@weak this => move |_| {
-            // TODO: We need to push a screen returning a recording here.
+            spawn!(@clone this, async move {
+                if let Some(recording) = push!(this.handle, RecordingSelector).await {
+                    this.recording.replace(Some(recording));
+                    this.recording_selected();
+                }
+            });
         }));
 
         edit_tracks_button.connect_clicked(clone!(@weak this => move |_| {

src/selectors/mod.rs

@@ -7,12 +7,10 @@ pub use instrument::*;
 pub mod person;
 pub use person::*;
 
-// TODO: Readd a better version of these.
+pub mod recording;
-//
+pub use recording::*;
-// pub mod recording;
+
-// pub use recording::*;
+pub mod work;
-//
+pub use work::*;
-// pub mod work;
-// pub use work::*;
 
 mod selector;

src/selectors/recording.rs

@@ -1,8 +1,9 @@
 use super::selector::Selector;
 use crate::backend::Backend;
-use crate::database::{Recording, Work};
+use crate::database::{Person, Work, Recording};
-use crate::editors::RecordingEditor;
+use crate::editors::{PersonEditor, WorkEditor, RecordingEditor};
-use crate::widgets::{Navigator, NavigatorScreen};
+use crate::navigator::{NavigationHandle, Screen};
+use crate::widgets::Widget;
 use gettextrs::gettext;
 use glib::clone;
 use gtk::prelude::*;
@@ -12,111 +13,222 @@ use std::rc::Rc;
 
 /// A screen for selecting a recording.
 pub struct RecordingSelector {
-    backend: Rc<Backend>,
+    handle: NavigationHandle<Recording>,
-    work: Work,
+    selector: Rc<Selector<Person>>,
-    selector: Rc<Selector<Recording>>,
-    selected_cb: RefCell<Option<Box<dyn Fn(&Recording) -> ()>>>,
-    navigator: RefCell<Option<Rc<Navigator>>>,
 }
 
-impl RecordingSelector {
+impl Screen<(), Recording> for RecordingSelector {
-    /// Create a new recording selector for recordings of a specific work.
+    fn new(_: (), handle: NavigationHandle<Recording>) -> Rc<Self> {
-    pub fn new(backend: Rc<Backend>, work: Work) -> Rc<Self> {
         // Create UI
 
-        let selector = Selector::<Recording>::new();
+        let selector = Selector::<Person>::new();
-        selector.set_title(&gettext("Select recording"));
+        selector.set_title(&gettext("Select composer"));
-        selector.set_subtitle(&work.get_title());
 
         let this = Rc::new(Self {
-            backend,
+            handle,
-            work,
             selector,
-            selected_cb: RefCell::new(None),
-            navigator: RefCell::new(None),
         });
 
         // Connect signals and callbacks
 
-        this.selector.set_back_cb(clone!(@strong this => move || {
+        this.selector.set_back_cb(clone!(@weak this => move || {
-            let navigator = this.navigator.borrow().clone();
+            this.handle.pop(None);
-            if let Some(navigator) = navigator {
-                navigator.pop();
-            }
         }));
 
-        this.selector.set_add_cb(clone!(@strong this => move || {
+        this.selector.set_add_cb(clone!(@weak this => move || {
-            let navigator = this.navigator.borrow().clone();
+            spawn!(@clone this, async move {
-            if let Some(navigator) = navigator {
+                if let Some(person) = push!(this.handle, PersonEditor, None).await {
-                let recording = Recording::new(this.work.clone());
+                    // We can assume that there are no existing works of this composer and
+                    // immediately show the work editor. Going back from the work editor will
+                    // correctly show the person selector again.
 
-                let editor = RecordingEditor::new(this.backend.clone(), Some(recording));
+                    let work = Work::new(person);
-                
+                    if let Some(work) = push!(this.handle, WorkEditor, Some(work)).await {
-                editor
+                        // There will also be no existing recordings, so we show the recording
-                    .set_selected_cb(clone!(@strong this, @strong navigator => move |recording| {
+                        // editor next.
-                        navigator.clone().pop();
+
-                        this.select(&recording);
+                        let recording = Recording::new(work);
-                    }));
+                        if let Some(recording) = push!(this.handle, RecordingEditor, Some(recording)).await {
-                
+                            this.handle.pop(Some(recording));
-                navigator.push(editor);
+                        }
-            }
+                    }
+                }
+            });
         }));
 
-        this.selector
+        this.selector.set_load_online(clone!(@weak this => move || {
-            .set_load_online(clone!(@strong this => move || {
+            async move { this.handle.backend.get_persons().await }
-                let clone = this.clone();
+        }));
-                async move { clone.backend.get_recordings_for_work(&clone.work.id).await }
-            }));
 
-        this.selector
+        this.selector.set_load_local(clone!(@weak this => move || {
-            .set_load_local(clone!(@strong this => move || {
+            async move { this.handle.backend.db().get_persons().await.unwrap() }
-                let clone = this.clone();
+        }));
-                async move { clone.backend.db().get_recordings_for_work(&clone.work.id).await.unwrap() }
-            }));
 
-        this.selector.set_make_widget(clone!(@strong this => move |recording| {
+        this.selector.set_make_widget(clone!(@weak this => move |person| {
             let row = libadwaita::ActionRow::new();
             row.set_activatable(true);
-            row.set_title(Some(&recording.get_performers()));
+            row.set_title(Some(&person.name_lf()));
 
-            let recording = recording.to_owned();
+            let person = person.to_owned();
-            row.connect_activated(clone!(@strong this => move |_| {
+            row.connect_activated(clone!(@weak this => move |_| {
-                this.select(&recording);
+                // Instead of returning the person from here, like the person selector does, we
+                // show a second selector for choosing the work.
+
+                let person = person.clone();
+                spawn!(@clone this, async move {
+                    if let Some(work) = push!(this.handle, RecordingSelectorWorkScreen, person).await {
+                        // Now the user can select a recording for that work.
+
+                        if let Some(recording) = push!(this.handle, RecordingSelectorRecordingScreen, work).await {
+                            this.handle.pop(Some(recording));
+                        }
+                    }
+                });
             }));
 
             row.upcast()
         }));
 
-        this.selector.set_filter(|search, recording| {
+        this.selector
-            recording.get_performers().to_lowercase().contains(search)
+            .set_filter(|search, person| person.name_fl().to_lowercase().contains(search));
-        });
 
         this
     }
-
-    /// Set the closure to be called when an item is selected.
-    pub fn set_selected_cb<F: Fn(&Recording) -> () + 'static>(&self, cb: F) {
-        self.selected_cb.replace(Some(Box::new(cb)));
-    }
-
-    /// Select a recording.
-    fn select(&self, recording: &Recording) {
-        if let Some(cb) = &*self.selected_cb.borrow() {
-            cb(&recording);
-        }
-    }
 }
 
-impl NavigatorScreen for RecordingSelector {
+impl Widget for RecordingSelector {
-    fn attach_navigator(&self, navigator: Rc<Navigator>) {
-        self.navigator.replace(Some(navigator));
-    }
-
     fn get_widget(&self) -> gtk::Widget {
         self.selector.widget.clone().upcast()
     }
+}
 
-    fn detach_navigator(&self) {
+/// The work selector within the recording selector.
-        self.navigator.replace(None);
+struct RecordingSelectorWorkScreen {
+    handle: NavigationHandle<Work>,
+    person: Person,
+    selector: Rc<Selector<Work>>,
+}
+
+impl Screen<Person, Work> for RecordingSelectorWorkScreen {
+    fn new(person: Person, handle: NavigationHandle<Work>) -> Rc<Self> {
+        let selector = Selector::<Work>::new();
+        selector.set_title(&gettext("Select work"));
+        selector.set_subtitle(&person.name_fl());
+
+        let this = Rc::new(Self {
+            handle,
+            person,
+            selector,
+        });
+
+        this.selector.set_back_cb(clone!(@weak this => move || {
+            this.handle.pop(None);
+        }));
+
+        this.selector.set_add_cb(clone!(@weak this => move || {
+            spawn!(@clone this, async move {
+                let work = Work::new(this.person.clone());
+                if let Some(work) = push!(this.handle, WorkEditor, Some(work)).await {
+                    this.handle.pop(Some(work));
+                }
+            });
+        }));
+
+        this.selector.set_load_online(clone!(@weak this => move || {
+            async move { this.handle.backend.get_works(&this.person.id).await }
+        }));
+
+        this.selector.set_load_local(clone!(@weak this => move || {
+            async move { this.handle.backend.db().get_works(&this.person.id).await.unwrap() }
+        }));
+
+        this.selector.set_make_widget(clone!(@weak this => move |work| {
+            let row = libadwaita::ActionRow::new();
+            row.set_activatable(true);
+            row.set_title(Some(&work.title));
+
+            let work = work.to_owned();
+            row.connect_activated(clone!(@weak this => move |_| {
+                this.handle.pop(Some(work.clone()));
+            }));
+
+            row.upcast()
+        }));
+
+        this.selector.set_filter(|search, work| work.title.to_lowercase().contains(search));
+
+        this
+    }
+}
+
+impl Widget for RecordingSelectorWorkScreen {
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
+    }
+}
+
+/// The actual recording selector within the recording selector.
+struct RecordingSelectorRecordingScreen {
+    handle: NavigationHandle<Recording>,
+    work: Work,
+    selector: Rc<Selector<Recording>>,
+}
+
+impl Screen<Work, Recording> for RecordingSelectorRecordingScreen {
+    fn new(work: Work, handle: NavigationHandle<Recording>) -> Rc<Self> {
+        let selector = Selector::<Recording>::new();
+        selector.set_title(&gettext("Select recording"));
+        selector.set_subtitle(&work.get_title());
+
+        let this = Rc::new(Self {
+            handle,
+            work,
+            selector,
+        });
+
+        this.selector.set_back_cb(clone!(@weak this => move || {
+            this.handle.pop(None);
+        }));
+
+        this.selector.set_add_cb(clone!(@weak this => move || {
+            spawn!(@clone this, async move {
+                let recording = Recording::new(this.work.clone());
+                if let Some(recording) = push!(this.handle, RecordingEditor, Some(recording)).await {
+                    this.handle.pop(Some(recording));
+                }
+            });
+        }));
+
+        this.selector.set_load_online(clone!(@weak this => move || {
+            async move { this.handle.backend.get_recordings_for_work(&this.work.id).await }
+        }));
+
+        this.selector.set_load_local(clone!(@weak this => move || {
+            async move { this.handle.backend.db().get_recordings_for_work(&this.work.id).await.unwrap() }
+        }));
+
+        this.selector.set_make_widget(clone!(@weak this => move |recording| {
+            let row = libadwaita::ActionRow::new();
+            row.set_activatable(true);
+            row.set_title(Some(&recording.get_performers()));
+
+            let recording = recording.to_owned();
+            row.connect_activated(clone!(@weak this => move |_| {
+                this.handle.pop(Some(recording.clone()));
+            }));
+
+            row.upcast()
+        }));
+
+        this.selector
+            .set_filter(|search, recording| recording.get_performers().to_lowercase().contains(search));
+
+        this
+    }
+}
+
+impl Widget for RecordingSelectorRecordingScreen {
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
     }
 }

src/selectors/work.rs

@@ -1,8 +1,9 @@
 use super::selector::Selector;
 use crate::backend::Backend;
 use crate::database::{Person, Work};
-use crate::editors::WorkEditor;
+use crate::editors::{PersonEditor, WorkEditor};
-use crate::widgets::{Navigator, NavigatorScreen};
+use crate::navigator::{NavigationHandle, Screen};
+use crate::widgets::Widget;
 use gettextrs::gettext;
 use glib::clone;
 use gtk::prelude::*;
@@ -12,110 +13,146 @@ use std::rc::Rc;
 
 /// A screen for selecting a work.
 pub struct WorkSelector {
-    backend: Rc<Backend>,
+    handle: NavigationHandle<Work>,
-    person: Person,
+    selector: Rc<Selector<Person>>,
-    selector: Rc<Selector<Work>>,
-    selected_cb: RefCell<Option<Box<dyn Fn(&Work) -> ()>>>,
-    navigator: RefCell<Option<Rc<Navigator>>>,
 }
 
-impl WorkSelector {
+impl Screen<(), Work> for WorkSelector {
-    /// Create a new work selector for works by a specific composer.
+    fn new(_: (), handle: NavigationHandle<Work>) -> Rc<Self> {
-    pub fn new(backend: Rc<Backend>, person: Person) -> Rc<Self> {
         // Create UI
 
-        let selector = Selector::<Work>::new();
+        let selector = Selector::<Person>::new();
-        selector.set_title(&gettext("Select work"));
+        selector.set_title(&gettext("Select composer"));
-        selector.set_subtitle(&person.name_fl());
 
         let this = Rc::new(Self {
-            backend,
+            handle,
-            person,
             selector,
-            selected_cb: RefCell::new(None),
-            navigator: RefCell::new(None),
         });
 
         // Connect signals and callbacks
 
-        this.selector.set_back_cb(clone!(@strong this => move || {
+        this.selector.set_back_cb(clone!(@weak this => move || {
-            let navigator = this.navigator.borrow().clone();
+            this.handle.pop(None);
-            if let Some(navigator) = navigator {
-                navigator.pop();
-            }
         }));
 
-        this.selector.set_add_cb(clone!(@strong this => move || {
+        this.selector.set_add_cb(clone!(@weak this => move || {
-            let navigator = this.navigator.borrow().clone();
+            spawn!(@clone this, async move {
-            if let Some(navigator) = navigator {
+                if let Some(person) = push!(this.handle, PersonEditor, None).await {
-                let work = Work::new(this.person.clone());
+                    // We can assume that there are no existing works of this composer and
+                    // immediately show the work editor. Going back from the work editor will
+                    // correctly show the person selector again.
 
-                let editor = WorkEditor::new(this.backend.clone(), Some(work));
+                    let work = Work::new(person);
-
+                    if let Some(work) = push!(this.handle, WorkEditor, Some(work)).await {
-                editor
+                        this.handle.pop(Some(work));
-                    .set_saved_cb(clone!(@strong this, @strong navigator => move |work| {
+                    }
-                        navigator.clone().pop();
+                }
-                        this.select(&work);
+            });
-                    }));
-
-                navigator.push(editor);
-            }
         }));
 
-        this.selector
+        this.selector.set_load_online(clone!(@weak this => move || {
-            .set_load_online(clone!(@strong this => move || {
+            async move { this.handle.backend.get_persons().await }
-                let clone = this.clone();
+        }));
-                async move { clone.backend.get_works(&clone.person.id).await }
-            }));
 
-        this.selector
+        this.selector.set_load_local(clone!(@weak this => move || {
-            .set_load_local(clone!(@strong this => move || {
+            async move { this.handle.backend.db().get_persons().await.unwrap() }
-                let clone = this.clone();
+        }));
-                async move { clone.backend.db().get_works(&clone.person.id).await.unwrap() }
-            }));
 
-        this.selector.set_make_widget(clone!(@strong this => move |work| {
+        this.selector.set_make_widget(clone!(@weak this => move |person| {
             let row = libadwaita::ActionRow::new();
             row.set_activatable(true);
-            row.set_title(Some(&work.title));
+            row.set_title(Some(&person.name_lf()));
 
-            let work = work.to_owned();
+            let person = person.to_owned();
-            row.connect_activated(clone!(@strong this => move |_| {
+            row.connect_activated(clone!(@weak this => move |_| {
-                this.select(&work);
+                // Instead of returning the person from here, like the person selector does, we
+                // show a second selector for choosing the work.
+
+                let person = person.clone();
+                spawn!(@clone this, async move {
+                    if let Some(work) = push!(this.handle, WorkSelectorWorkScreen, person).await {
+                        this.handle.pop(Some(work));
+                    }
+                });
             }));
 
             row.upcast()
         }));
 
         this.selector
-            .set_filter(|search, work| work.title.to_lowercase().contains(search));
+            .set_filter(|search, person| person.name_fl().to_lowercase().contains(search));
 
         this
     }
-
-    /// Set the closure to be called when an item is selected.
-    pub fn set_selected_cb<F: Fn(&Work) -> () + 'static>(&self, cb: F) {
-        self.selected_cb.replace(Some(Box::new(cb)));
-    }
-
-    /// Select a work.
-    fn select(&self, work: &Work) {
-        if let Some(cb) = &*self.selected_cb.borrow() {
-            cb(&work);
-        }
-    }
 }
 
-impl NavigatorScreen for WorkSelector {
+impl Widget for WorkSelector {
-    fn attach_navigator(&self, navigator: Rc<Navigator>) {
-        self.navigator.replace(Some(navigator));
-    }
-
     fn get_widget(&self) -> gtk::Widget {
         self.selector.widget.clone().upcast()
     }
+}
 
-    fn detach_navigator(&self) {
+/// The actual work selector that is displayed after the user has selected a composer.
-        self.navigator.replace(None);
+struct WorkSelectorWorkScreen {
+    handle: NavigationHandle<Work>,
+    person: Person,
+    selector: Rc<Selector<Work>>,
+}
+
+impl Screen<Person, Work> for WorkSelectorWorkScreen {
+    fn new(person: Person, handle: NavigationHandle<Work>) -> Rc<Self> {
+        let selector = Selector::<Work>::new();
+        selector.set_title(&gettext("Select work"));
+        selector.set_subtitle(&person.name_fl());
+
+        let this = Rc::new(Self {
+            handle,
+            person,
+            selector,
+        });
+
+        this.selector.set_back_cb(clone!(@weak this => move || {
+            this.handle.pop(None);
+        }));
+
+        this.selector.set_add_cb(clone!(@weak this => move || {
+            spawn!(@clone this, async move {
+                let work = Work::new(this.person.clone());
+                if let Some(work) = push!(this.handle, WorkEditor, Some(work)).await {
+                    this.handle.pop(Some(work));
+                }
+            });
+        }));
+
+        this.selector.set_load_online(clone!(@weak this => move || {
+            async move { this.handle.backend.get_works(&this.person.id).await }
+        }));
+
+        this.selector.set_load_local(clone!(@weak this => move || {
+            async move { this.handle.backend.db().get_works(&this.person.id).await.unwrap() }
+        }));
+
+        this.selector.set_make_widget(clone!(@weak this => move |work| {
+            let row = libadwaita::ActionRow::new();
+            row.set_activatable(true);
+            row.set_title(Some(&work.title));
+
+            let work = work.to_owned();
+            row.connect_activated(clone!(@weak this => move |_| {
+                this.handle.pop(Some(work.clone()));
+            }));
+
+            row.upcast()
+        }));
+
+        this.selector.set_filter(|search, work| work.title.to_lowercase().contains(search));
+
+        this
+    }
+}
+
+impl Widget for WorkSelectorWorkScreen {
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
     }
 }