Revert merging of server and client repository

src/import/track_selector.rs

@@ -0,0 +1,122 @@
+use super::disc_source::DiscSource;
+use crate::widgets::{Navigator, NavigatorScreen};
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting tracks from a medium.
+pub struct TrackSelector {
+    source: Rc<DiscSource>,
+    widget: gtk::Box,
+    select_button: gtk::Button,
+    selection: RefCell<Vec<usize>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(Vec<usize>)>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl TrackSelector {
+    /// Create a new track selector.
+    pub fn new(source: Rc<DiscSource>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/track_selector.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, select_button);
+        get_widget!(builder, gtk::Frame, tracks_frame);
+
+        let track_list = gtk::ListBox::new();
+        track_list.set_selection_mode(gtk::SelectionMode::None);
+        track_list.set_vexpand(false);
+        track_list.show();
+        tracks_frame.add(&track_list);
+
+        let this = Rc::new(Self {
+            source,
+            widget,
+            select_button,
+            selection: RefCell::new(Vec::new()),
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.select_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+
+            if let Some(cb) = &*this.selected_cb.borrow() {
+                let selection = this.selection.borrow().clone();
+                cb(selection);
+            }
+        }));
+
+        for (index, track) in this.source.tracks.iter().enumerate() {
+            let check = gtk::CheckButton::new();
+
+            check.connect_toggled(clone!(@strong this => move |check| {
+                let mut selection = this.selection.borrow_mut();
+                if check.get_active() {
+                    selection.push(index);
+                } else {
+                    if let Some(pos) = selection.iter().position(|part| *part == index) {
+                        selection.remove(pos);
+                    }
+                }
+
+                if selection.is_empty() {
+                    this.select_button.set_sensitive(false);
+                } else {
+                    this.select_button.set_sensitive(true);
+                }
+            }));
+
+            let title = format!("Track {}", track.number);
+
+            let row = libhandy::ActionRow::new();
+            row.add_prefix(&check);
+            row.set_activatable_widget(Some(&check));
+            row.set_title(Some(&title));
+            row.show_all();
+
+            track_list.add(&row);
+        }
+
+        this
+    }
+
+    /// Set the closure to be called when the user has selected tracks. The
+    /// closure will be called with the indices of the selected tracks as its
+    /// argument.
+    pub fn set_selected_cb<F: Fn(Vec<usize>) + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+}
+
+impl NavigatorScreen for TrackSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}