Revert merging of server and client repository

src/selectors/ensemble.rs

@@ -0,0 +1,111 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::Ensemble;
+use crate::editors::EnsembleEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a ensemble.
+pub struct EnsembleSelector {
+    backend: Rc<Backend>,
+    selector: Rc<Selector<Ensemble>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Ensemble) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl EnsembleSelector {
+    /// Create a new ensemble selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Ensemble>::new();
+        selector.set_title(&gettext("Select ensemble"));
+
+        let this = Rc::new(Self {
+            backend,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = EnsembleEditor::new(this.backend.clone(), None);
+                editor
+                    .set_saved_cb(clone!(@strong this => move |ensemble| this.select(&ensemble)));
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_ensembles().await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_ensembles().await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|ensemble| {
+            let label = gtk::Label::new(Some(&ensemble.name));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, ensemble| ensemble.name.to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |ensemble| this.select(ensemble)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Ensemble) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a ensemble.
+    fn select(&self, ensemble: &Ensemble) {        
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&ensemble);
+        }
+
+    }
+}
+
+impl NavigatorScreen for EnsembleSelector {
+    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) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/instrument.rs

@@ -0,0 +1,110 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::Instrument;
+use crate::editors::InstrumentEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a instrument.
+pub struct InstrumentSelector {
+    backend: Rc<Backend>,
+    selector: Rc<Selector<Instrument>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Instrument) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl InstrumentSelector {
+    /// Create a new instrument selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Instrument>::new();
+        selector.set_title(&gettext("Select instrument"));
+
+        let this = Rc::new(Self {
+            backend,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = InstrumentEditor::new(this.backend.clone(), None);
+                editor
+                    .set_saved_cb(clone!(@strong this => move |instrument| this.select(&instrument)));
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_instruments().await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_instruments().await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|instrument| {
+            let label = gtk::Label::new(Some(&instrument.name));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, instrument| instrument.name.to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |instrument| this.select(instrument)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Instrument) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a instrument.
+    fn select(&self, instrument: &Instrument) {
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&instrument);
+        }
+    }
+}
+
+impl NavigatorScreen for InstrumentSelector {
+    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) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/mod.rs

@@ -0,0 +1,16 @@
+pub mod ensemble;
+pub use ensemble::*;
+
+pub mod instrument;
+pub use instrument::*;
+
+pub mod person;
+pub use person::*;
+
+pub mod recording;
+pub use recording::*;
+
+pub mod work;
+pub use work::*;
+
+mod selector;

src/selectors/person.rs

@@ -0,0 +1,110 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::Person;
+use crate::editors::PersonEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a person.
+pub struct PersonSelector {
+    backend: Rc<Backend>,
+    selector: Rc<Selector<Person>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Person) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl PersonSelector {
+    /// Create a new person selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Person>::new();
+        selector.set_title(&gettext("Select person"));
+
+        let this = Rc::new(Self {
+            backend,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = PersonEditor::new(this.backend.clone(), None);
+                editor
+                    .set_saved_cb(clone!(@strong this => move |person| this.select(&person)));
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_persons().await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_persons().await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|person| {
+            let label = gtk::Label::new(Some(&person.name_lf()));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, person| person.name_fl().to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |person| this.select(person)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Person) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a person.
+    fn select(&self, person: &Person) {
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&person);
+        }
+    }
+}
+
+impl NavigatorScreen for PersonSelector {
+    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) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/recording.rs

@@ -0,0 +1,121 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::{Recording, Work};
+use crate::editors::RecordingEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a recording.
+pub struct RecordingSelector {
+    backend: Rc<Backend>,
+    work: Work,
+    selector: Rc<Selector<Recording>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Recording) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl RecordingSelector {
+    /// Create a new recording selector for recordings of a specific work.
+    pub fn new(backend: Rc<Backend>, work: Work) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Recording>::new();
+        selector.set_title(&gettext("Select recording"));
+        selector.set_subtitle(&work.get_title());
+
+        let this = Rc::new(Self {
+            backend,
+            work,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let recording = Recording::new(this.work.clone());
+
+                let editor = RecordingEditor::new(this.backend.clone(), Some(recording));
+                
+                editor
+                    .set_selected_cb(clone!(@strong this, @strong navigator => move |recording| {
+                        navigator.clone().pop();
+                        this.select(&recording);
+                    }));
+                
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_recordings_for_work(&clone.work.id).await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_recordings_for_work(&clone.work.id).await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|recording| {
+            let label = gtk::Label::new(Some(&recording.get_performers()));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector.set_filter(|search, recording| {
+            recording.get_performers().to_lowercase().contains(search)
+        });
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |recording| this.select(recording)));
+
+        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 {
+    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) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/selector.rs

@@ -0,0 +1,201 @@
+use crate::widgets::List;
+use anyhow::Result;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::HeaderBarExt;
+use std::cell::RefCell;
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
+
+/// A screen that presents a list of items. It allows to switch between the server and the local
+/// database and to search within the list.
+pub struct Selector<T: 'static> {
+    pub widget: gtk::Box,
+    header: libhandy::HeaderBar,
+    server_check_button: gtk::CheckButton,
+    stack: gtk::Stack,
+    list: Rc<List<T>>,
+    back_cb: RefCell<Option<Box<dyn Fn() -> ()>>>,
+    add_cb: RefCell<Option<Box<dyn Fn() -> ()>>>,
+    load_online: RefCell<Option<Box<dyn Fn() -> Box<dyn Future<Output = Result<Vec<T>>>>>>>,
+    load_local: RefCell<Option<Box<dyn Fn() -> Box<dyn Future<Output = Vec<T>>>>>>,
+    filter: RefCell<Option<Box<dyn Fn(&str, &T) -> bool>>>,
+}
+
+impl<T> Selector<T> {
+    /// Create a new selector.
+    pub fn new() -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/selector.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, libhandy::HeaderBar, header);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, add_button);
+        get_widget!(builder, gtk::SearchEntry, search_entry);
+        get_widget!(builder, gtk::CheckButton, server_check_button);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Frame, frame);
+        get_widget!(builder, gtk::Button, try_again_button);
+
+        let list = List::<T>::new(&gettext("Nothing found."));
+        frame.add(&list.widget);
+
+        let this = Rc::new(Self {
+            widget,
+            header,
+            server_check_button,
+            stack,
+            list,
+            back_cb: RefCell::new(None),
+            add_cb: RefCell::new(None),
+            load_online: RefCell::new(None),
+            load_local: RefCell::new(None),
+            filter: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.back_cb.borrow() {
+                cb();
+            }
+        }));
+
+        add_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.add_cb.borrow() {
+                cb();
+            }
+        }));
+
+        search_entry.connect_search_changed(clone!(@strong this => move |_| {
+            this.list.invalidate_filter();
+        }));
+
+        this.server_check_button
+            .connect_toggled(clone!(@strong this => move |_| {
+                if this.server_check_button.get_active() {
+                    this.clone().load_online();
+                } else {
+                    this.clone().load_local();
+                }
+            }));
+
+        this.list.set_filter(
+            clone!(@strong this, @strong search_entry => move |item: &T| {
+                match &*this.filter.borrow() {
+                    Some(filter) => {
+                        let search = search_entry.get_text().to_string().to_lowercase();
+                        search.is_empty() || filter(&search, item)
+                    }
+                    None => true,
+                }
+            }),
+        );
+
+        try_again_button.connect_clicked(clone!(@strong this => move |_| {
+            this.clone().load_online();
+        }));
+
+        // Initialize
+        this.clone().load_online();
+
+        this
+    }
+
+    /// Set the title to be shown in the header.
+    pub fn set_title(&self, title: &str) {
+        self.header.set_title(Some(title));
+    }
+
+    /// Set the subtitle to be shown in the header.
+    pub fn set_subtitle(&self, subtitle: &str) {
+        self.header.set_subtitle(Some(subtitle));
+    }
+
+    /// Set the closure to be called when the user wants to go back.
+    pub fn set_back_cb<F: Fn() -> () + 'static>(&self, cb: F) {
+        self.back_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Set the closure to be called when the user wants to add an item.
+    pub fn set_add_cb<F: Fn() -> () + 'static>(&self, cb: F) {
+        self.add_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Set the async closure to be called to fetch items from the server. If that results in an
+    /// error, an error screen is shown allowing to try again.
+    pub fn set_load_online<F, R>(&self, cb: F)
+    where
+        F: (Fn() -> R) + 'static,
+        R: Future<Output = Result<Vec<T>>> + 'static,
+    {
+        self.load_online
+            .replace(Some(Box::new(move || Box::new(cb()))));
+    }
+
+    /// Set the async closure to be called to get local items.
+    pub fn set_load_local<F, R>(&self, cb: F)
+    where
+        F: (Fn() -> R) + 'static,
+        R: Future<Output = Vec<T>> + 'static,
+    {
+        self.load_local
+            .replace(Some(Box::new(move || Box::new(cb()))));
+    }
+
+    /// Set the closure to be called for creating a new list row.
+    pub fn set_make_widget<F: Fn(&T) -> gtk::Widget + 'static>(&self, make_widget: F) {
+        self.list.set_make_widget(make_widget);
+    }
+
+    /// Set a closure to call when deciding whether to show an item based on a search string. The
+    /// search string will be converted to lowercase.
+    pub fn set_filter<F: Fn(&str, &T) -> bool + 'static>(&self, filter: F) {
+        self.filter.replace(Some(Box::new(filter)));
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&T) -> () + 'static>(&self, cb: F) {
+        self.list.set_selected(cb);
+    }
+
+    fn load_online(self: Rc<Self>) {
+        let context = glib::MainContext::default();
+        let clone = self.clone();
+        context.spawn_local(async move {
+            if let Some(cb) = &*self.load_online.borrow() {
+                self.stack.set_visible_child_name("loading");
+
+                match Pin::from(cb()).await {
+                    Ok(items) => {
+                        clone.list.show_items(items);
+                        clone.stack.set_visible_child_name("content");
+                    }
+                    Err(_) => {
+                        clone.list.show_items(Vec::new());
+                        clone.stack.set_visible_child_name("error");
+                    }
+                }
+            }
+        });
+    }
+
+    fn load_local(self: Rc<Self>) {
+        let context = glib::MainContext::default();
+        let clone = self.clone();
+        context.spawn_local(async move {
+            if let Some(cb) = &*self.load_local.borrow() {
+                self.stack.set_visible_child_name("loading");
+
+                let items = Pin::from(cb()).await;
+                clone.list.show_items(items);
+                clone.stack.set_visible_child_name("content");
+            }
+        });
+    }
+}

src/selectors/work.rs

@@ -0,0 +1,120 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::{Person, Work};
+use crate::editors::WorkEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a work.
+pub struct WorkSelector {
+    backend: Rc<Backend>,
+    person: Person,
+    selector: Rc<Selector<Work>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Work) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl WorkSelector {
+    /// Create a new work selector for works by a specific composer.
+    pub fn new(backend: Rc<Backend>, person: Person) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Work>::new();
+        selector.set_title(&gettext("Select work"));
+        selector.set_subtitle(&person.name_fl());
+
+        let this = Rc::new(Self {
+            backend,
+            person,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let work = Work::new(this.person.clone());
+
+                let editor = WorkEditor::new(this.backend.clone(), Some(work));
+
+                editor
+                    .set_saved_cb(clone!(@strong this, @strong navigator => move |work| {
+                        navigator.clone().pop();
+                        this.select(&work);
+                    }));
+
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_works(&clone.person.id).await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_works(&clone.person.id).await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|work| {
+            let label = gtk::Label::new(Some(&work.title));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, work| work.title.to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |work| this.select(work)));
+
+        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 {
+    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) {
+        self.navigator.replace(None);
+    }
+}