Initial test submit with mostly test code

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "sample-amp"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+gtk = { version = "0.6.6", package = "gtk4" }
+relm4 = { version = "0.6.0", features = ["libadwaita"] }
+relm4-components = "0.6.0"
+relm4-icons = { features = ["plus", "minus"] }

src/README.org

@@ -0,0 +1,6 @@
+* Libraries to use
+- Aubio for analyzing audio and getting BPM. It has a rust wrapper.
+
+* Use Figma for mockups
+- Sadly, penpot is not mature enough.
+- Or maybe we'll use penpot because figma also sucks. lmao

src/main.rs

@@ -0,0 +1,329 @@
+use gtk::prelude::*;
+use gtk::glib::BoxedAnyObject;
+use relm4::prelude::*;
+use relm4_icons::icon_name;
+use std::cell::Ref;
+
+struct HeaderModel;
+
+#[derive(Debug)]
+enum HeaderOutput {
+    Counters,
+    Edit,
+    Export,
+}
+
+#[relm4::component]
+impl SimpleComponent for HeaderModel {
+    type Init = ();
+    type Input = ();
+    type Output = HeaderOutput;
+
+    view! {
+        #[root]
+        gtk::HeaderBar {
+            #[wrap(Some)]
+            set_title_widget = &gtk::Box {
+                add_css_class: "linked",
+                #[name = "group"]
+                gtk::ToggleButton {
+                    set_label: "Counters",
+                    set_active: true,
+                    connect_toggled[sender] => move |btn| {
+                        if btn.is_active() {
+                            sender.output(HeaderOutput::Counters).unwrap()
+                        }
+                    },
+                },
+                gtk::ToggleButton {
+                    set_label: "Edit",
+                    set_group: Some(&group),
+                    connect_toggled[sender] => move |btn| {
+                        if btn.is_active() {
+                            sender.output(HeaderOutput::Edit).unwrap()
+                        }
+                    },
+                },
+                gtk::ToggleButton {
+                    set_label: "Export",
+                    set_group: Some(&group),
+                    connect_toggled[sender] => move |btn| {
+                        if btn.is_active() {
+                            sender.output(HeaderOutput::Export).unwrap()
+                        }
+                    },
+                },
+            }
+        }
+    }
+
+    fn init(
+        _init: Self::Init,
+        root: &Self::Root,
+        sender: ComponentSender<Self>,
+    ) -> ComponentParts<Self> {
+        let model = HeaderModel;
+        let widgets = view_output!();
+        ComponentParts { model, widgets }
+    }
+}
+
+struct DialogModel {
+    hidden: bool,
+}
+
+#[derive(Debug)]
+enum DialogInput {
+    Show,
+    Accept,
+    Cancel,
+}
+
+#[derive(Debug)]
+enum DialogOutput {
+    Close,
+}
+
+#[relm4::component]
+impl SimpleComponent for DialogModel {
+    type Init = ();
+    type Input = DialogInput;
+    type Output = DialogOutput;
+
+    view! {
+        gtk::MessageDialog {
+            set_modal: true,
+            #[watch]
+            set_visible: !model.hidden,
+            set_text: Some("Do you want to close before saving?"),
+            set_secondary_text: Some("All unsaved changes will be lost"),
+            add_button: ("Close", gtk::ResponseType::Accept),
+            add_button: ("Cancel", gtk::ResponseType::Cancel),
+            connect_response[sender] => move |_, resp| {
+                sender.input(if resp == gtk::ResponseType::Accept {
+                    DialogInput::Accept
+                } else {
+                    DialogInput::Cancel
+                })
+            }
+        }
+    }
+
+    fn update(&mut self, message: Self::Input, sender: ComponentSender<Self>) {
+        match message {
+            DialogInput::Show => self.hidden = false,
+            DialogInput::Accept => {
+                self.hidden = true;
+                sender.output(DialogOutput::Close).unwrap()
+            }
+            DialogInput::Cancel => self.hidden = true,
+        }
+    }
+
+    fn init(
+        _init: Self::Init,
+        root: &Self::Root,
+        sender: ComponentSender<Self>,
+    ) -> ComponentParts<Self> {
+        let model = DialogModel { hidden: true };
+        let widgets = view_output!();
+        ComponentParts { model, widgets }
+    }
+}
+
+#[derive(Debug)]
+enum AppMode {
+    Counters,
+    Edit,
+    Export,
+}
+
+#[derive(Debug)]
+enum AppMsg {
+    SetMode(AppMode),
+    CloseRequest,
+    Close,
+    Increment,
+    Decrement,
+}
+
+struct AppModel {
+    mode: AppMode,
+    header: Controller<HeaderModel>,
+    samples: gtk::MultiSelection,
+    dialog: Controller<DialogModel>,
+    counter: u8,
+}
+
+struct Sample {
+    name: String,
+    bpm: f32,
+}
+
+#[relm4::component]
+impl SimpleComponent for AppModel {
+    type Init = u8;
+
+    type Input = AppMsg;
+    type Output = ();
+
+    view! {
+        gtk::Window {
+            set_titlebar: Some(model.header.widget()),
+            set_default_width: 300,
+            set_default_height: 100,
+
+            connect_close_request[sender] => move |_| {
+                sender.input(AppMsg::CloseRequest);
+                gtk::Inhibit(true)
+            },
+
+            gtk::Box {
+                gtk::ScrolledWindow {
+                    gtk::ListView {
+
+                    }
+                },
+                gtk::Box {
+                    set_orientation: gtk::Orientation::Vertical,
+                    set_spacing: 5,
+                    set_margin_all: 5,
+                    set_hexpand: true,
+
+                    gtk::ScrolledWindow {
+                        set_vexpand: true,
+                        gtk::ColumnView {
+                            set_model: Some(&model.samples),
+                            append_column = &gtk::ColumnViewColumn {
+                                set_title: Some("Name"),
+                                set_resizable: true,
+                                set_factory:  Some(&factory1)
+                            },
+                            append_column = &gtk::ColumnViewColumn {
+                                set_title: Some("BPM"),
+                                set_factory: Some(&factory_bpm)
+                            },
+                            append_column = &gtk::ColumnViewColumn {
+                                set_title: Some("Key")
+                            },
+                            append_column = &gtk::ColumnViewColumn {
+                                set_title: Some("Tags"),
+                                set_resizable: true,
+                            }
+                        }
+                    },
+
+                    gtk::Label {
+                        #[watch]
+                        set_label: &format!("Currently in the {:?} mode", model.mode),
+                    },
+
+                    gtk::Box {
+                        set_orientation: gtk::Orientation::Horizontal,
+                        set_spacing: 5,
+                        gtk::Button::from_icon_name(icon_name::PLUS) {
+                            connect_clicked => AppMsg::Increment,
+                        },
+
+                        gtk::Button::from_icon_name(icon_name::MINUS) {
+                            connect_clicked => AppMsg::Decrement,
+                        },
+                    },
+
+                    gtk::Label {
+                        #[watch]
+                        set_label: &format!("Counter: {}", model.counter),
+                        set_margin_all: 5,
+                    },
+                }
+            }
+        }
+    }
+
+    fn init(
+        counter: Self::Init,
+        window: &Self::Root,
+        sender: ComponentSender<Self>,
+    ) -> relm4::ComponentParts<Self> {
+        let header: Controller<HeaderModel> =
+            HeaderModel::builder()
+                .launch(())
+                .forward(sender.input_sender(), |msg| match msg {
+                    HeaderOutput::Counters => AppMsg::SetMode(AppMode::Counters),
+                    HeaderOutput::Edit => AppMsg::SetMode(AppMode::Edit),
+                    HeaderOutput::Export => AppMsg::SetMode(AppMode::Export),
+                });
+
+        let dialog = DialogModel::builder()
+            .transient_for(window)
+            .launch(())
+            .forward(sender.input_sender(), |msg| match msg {
+                DialogOutput::Close => AppMsg::Close,
+            });
+
+        let factory1 = gtk::SignalListItemFactory::new();
+        factory1.connect_bind(move |_factory, item| {
+            let item = item.downcast_ref::<gtk::ListItem>().unwrap();
+            let obj = item.item().and_downcast::<BoxedAnyObject>().unwrap();
+            let sample: Ref<Sample> = obj.borrow();
+            let cell = gtk::Label::new(Some(&sample.name.to_string()));
+            cell.set_halign(gtk::Align::Start);
+            item.set_child(Some(&cell))
+        });
+
+        let factory_bpm = gtk::SignalListItemFactory::new();
+        factory_bpm.connect_bind(move |_factory, item| {
+            let item = item.downcast_ref::<gtk::ListItem>().unwrap();
+            let obj = item.item().and_downcast::<BoxedAnyObject>().unwrap();
+            let sample: Ref<Sample> = obj.borrow();
+            let cell = gtk::Label::new(Some(&sample.bpm.to_string()));
+            cell.set_halign(gtk::Align::End);
+            item.set_child(Some(&cell))
+        });
+
+        let samples = gtk::gio::ListStore::new(gtk::glib::types::Type::OBJECT);
+        let sample_a = BoxedAnyObject::new(Sample{name: "01 MOOLOO-108 bpm a.wav".to_string(), bpm: 108.0});
+        samples.append(&sample_a);
+        let sample_b = BoxedAnyObject::new(Sample{name: "03 FAST AND FURIOUS-144.3 bpm a.wav".to_string(), bpm: 144.3});
+        samples.append(&sample_b);
+
+        let samples = gtk::MultiSelection::new(Some(samples));
+
+        let model = AppModel {
+            counter,
+            mode: AppMode::Counters,
+            header,
+            dialog,
+            samples
+        };
+        let widgets = view_output!();
+
+        ComponentParts { model, widgets }
+    }
+
+    fn update(&mut self, message: Self::Input, _sender: ComponentSender<Self>) {
+        match message {
+            AppMsg::SetMode(mode) => {
+                self.mode = mode;
+            }
+            AppMsg::CloseRequest => {
+                self.dialog.sender().send(DialogInput::Show).unwrap();
+            }
+            AppMsg::Close => {
+                relm4::main_application().quit();
+            }
+            AppMsg::Increment => {
+                self.counter = self.counter.wrapping_add(1);
+            }
+            AppMsg::Decrement => {
+                self.counter = self.counter.wrapping_sub(1);
+            }
+        }
+    }
+}
+
+fn main() {
+    let app = RelmApp::new("relm.test.simple_manual");
+    relm4_icons::initialize_icons();
+    app.run::<AppModel>(0);
+}