whitespace

Cargo.toml

@@ -9,5 +9,7 @@ crate_type = "bin"
 
 [dependencies]
 dirs = "^3.0.1"
-druid = "^0.6.0"
+gio = "^0"
+gtk = "^0"
 rodio = "^0.11.0"
+iui = "0.3"

README.md

@@ -22,5 +22,6 @@ released under the MIT license.
     * vinyl crackle
     * white noise?
     * fan
+    * birdsong
 * set a window icon
     * create a nice icon?

src/main.rs

@@ -1,8 +1,8 @@
 #![windows_subsystem = "windows"]
 
-// use gio::prelude::*;
+use gio::prelude::*;
-// use gtk::prelude::*;
+use gtk::prelude::*;
-// use gtk::Orientation;
+use gtk::Orientation;
 use rodio::{Sink, Source};
 use std::env::args;
 use std::fs::File;
@@ -10,8 +10,13 @@ use std::io::BufReader;
 use std::path::PathBuf;
 use std::process::Command;
 
-const SPACING: i32 = 16;
+use iui::prelude::*;
-
+use iui::controls::{Label, Spinbox, Slider, Entry, MultilineEntry, VerticalBox, HorizontalBox, HorizontalSeparator, Group, Spacer};
+use std::rc::Rc;
+use std::cell::RefCell;
+//
+// const SPACING: i32 = 16;
+//
 // fn error_popup(message: &str) {
 //     let popup = gtk::Window::new(gtk::WindowType::Toplevel);
 //     popup.set_title("error");
@@ -34,18 +39,18 @@ const SPACING: i32 = 16;
 //         popup.destroy();
 //     });
 // }
-//
+
-// fn get_data_dir() -> PathBuf {
+fn get_data_dir() -> PathBuf {
-//     let mut data_dir = dirs::data_dir().expect("Couldn't find user data directory");
+    let mut data_dir = dirs::data_dir().expect("Couldn't find user data directory");
-//
+
-//     data_dir.push("ruin/lull");
+    data_dir.push("ruin/lull");
-//
+
-//     if !data_dir.exists() {
+    if !data_dir.exists() {
-//         std::fs::create_dir_all(&data_dir).expect("Couldn't create lull data directory");
+        std::fs::create_dir_all(&data_dir).expect("Couldn't create lull data directory");
-//     }
+    }
-//
+
-//     data_dir
+    data_dir
-// }
+}
 //
 // fn build_ui(application: &gtk::Application) {
 //     let window = gtk::ApplicationWindow::new(application);
@@ -145,42 +150,128 @@ const SPACING: i32 = 16;
 //
 //     window.show_all();
 // }
-//
-// fn main() {
-//     let application = gtk::Application::new(
-//         Some("dev.tinybird.max.lull"),
-//         Default::default()
-//     ).expect("Initialization failed...");
-//
-//     application.connect_activate(|app| {
-//         build_ui(app);
-//     });
-//
-//     application.run(&args().collect::<Vec<_>>());
-// }
 
-use druid::{AppLauncher, WindowDesc, Widget, PlatformError};
+/// This struct will hold the values that multiple callbacks will need to access.
-use druid::widget::{Label, Padding, Flex, Align, FlexParams, CrossAxisAlignment, Slider};
+struct State {
-
+    slider_val: i64,
-fn build_ui() -> impl Widget<()> {
+    spinner_val: i64,
-    Padding::new(
+    entry_val: String,
-        10.0,
+    multi_val: String,
-        Flex::column()
-            .with_flex_child(
-                Flex::row()
-                    .with_flex_child(Align::centered(Label::new("sound 1")), FlexParams::new(1.0, CrossAxisAlignment::End))
-                    .with_child(Align::centered(Label::new("slider"))),
-                1.0
-            )
-            .with_child(
-                Flex::row()
-                    .with_flex_child(Label::new("top right"), 1.0)
-                    .with_flex_child(Align::centered(Label::new("bottom right")), 1.0)
-            )
-    )
 }
 
-fn main() -> Result<(), PlatformError> {
+fn main() {
-    AppLauncher::with_window(WindowDesc::new(build_ui)).launch(())?;
+    // Initialize the UI framework.
-    Ok(())
+    let ui = UI::init().unwrap();
+
+    // Initialize the state of the application.
+    let state = Rc::new(RefCell::new(
+        State { slider_val: 0, spinner_val: 0, entry_val: "".into(), multi_val: "".into() }
+    ));
+
+    // Set up the inputs for the application.
+    // While it's not necessary to create a block for this, it makes the code a lot easier
+    // to read; the indentation presents a visual cue informing the reader that these
+    // statements are related.
+    let (input_group, mut slider, mut spinner, mut entry, mut multi) = {
+        // The group will hold all the inputs
+        let mut input_group = Group::new(&ui, "Inputs");
+
+        // The vertical box arranges the inputs within the groups
+        let mut input_vbox = VerticalBox::new(&ui);
+        input_vbox.set_padded(&ui, true);
+
+        // Numerical inputs
+        let slider = Slider::new(&ui, 1, 100);
+        let spinner = Spinbox::new(&ui, 1, 100);
+        let entry = Entry::new(&ui);
+        let multi = MultilineEntry::new(&ui);
+
+        // Add everything in hierarchy
+        // Note the reverse order here. Again, it's not necessary, but it improves
+        // readability.
+        input_vbox.append(&ui, slider.clone(), LayoutStrategy::Compact);
+        input_vbox.append(&ui, spinner.clone(), LayoutStrategy::Compact);
+        input_vbox.append(&ui, Spacer::new(&ui), LayoutStrategy::Compact);
+        input_vbox.append(&ui, HorizontalSeparator::new(&ui), LayoutStrategy::Compact);
+        input_vbox.append(&ui, Spacer::new(&ui), LayoutStrategy::Compact);
+        input_vbox.append(&ui, entry.clone(), LayoutStrategy::Compact);
+        input_vbox.append(&ui, multi.clone(), LayoutStrategy::Stretchy);
+        input_group.set_child(&ui, input_vbox);
+
+        (input_group, slider, spinner, entry, multi)
+    };
+
+    // Set up the outputs for the application. Organization is very similar to the
+    // previous setup.
+    let (output_group, add_label, sub_label, text_label, bigtext_label) = {
+        let mut output_group = Group::new(&ui, "Outputs");
+        let mut output_vbox = VerticalBox::new(&ui);
+        let add_label = Label::new(&ui, "");
+        let sub_label = Label::new(&ui, "");
+        let text_label = Label::new(&ui, "");
+        let bigtext_label = Label::new(&ui, "");
+        output_vbox.append(&ui, add_label.clone(), LayoutStrategy::Compact);
+        output_vbox.append(&ui, sub_label.clone(), LayoutStrategy::Compact);
+        output_vbox.append(&ui, text_label.clone(), LayoutStrategy::Compact);
+        output_vbox.append(&ui, bigtext_label.clone(), LayoutStrategy::Stretchy);
+        output_group.set_child(&ui, output_vbox);
+
+        (output_group, add_label, sub_label, text_label, bigtext_label)
+    };
+
+    // This horizontal box will arrange the two groups of controls.
+    let mut hbox = HorizontalBox::new(&ui);
+    hbox.append(&ui, input_group, LayoutStrategy::Stretchy);
+    hbox.append(&ui, output_group, LayoutStrategy::Stretchy);
+
+    // The window allows all constituent components to be displayed.
+    let mut window = Window::new(&ui, "Input Output Test", 300, 150, WindowType::NoMenubar);
+    window.set_child(&ui, hbox);
+    window.show(&ui);
+
+    // These on_changed functions allow updating the application state when a
+    // control changes its value.
+
+    slider.on_changed(&ui, {
+        let state = state.clone();
+        move |val| { state.borrow_mut().slider_val = val; }
+    });
+
+    spinner.on_changed(&ui, {
+        let state = state.clone();
+        move |val| { state.borrow_mut().spinner_val = val; }
+    });
+
+    entry.on_changed(&ui, {
+        let state = state.clone();
+        move |val| { state.borrow_mut().entry_val = val; }
+    });
+
+    multi.on_changed(&ui, {
+        let state = state.clone();
+        move |val| { state.borrow_mut().multi_val = val; }
+    });
+
+
+    // Rather than just invoking ui.run(), using EventLoop gives a lot more control
+    // over the user interface event loop.
+    // Here, the on_tick() callback is used to update the view against the state.
+    let mut event_loop = ui.event_loop();
+    event_loop.on_tick(&ui, {
+        let ui = ui.clone();
+        let mut add_label = add_label.clone();
+        let mut sub_label = sub_label.clone();
+        let mut text_label = text_label.clone();
+        let mut bigtext_label = bigtext_label.clone();
+        move || {
+            let state = state.borrow();
+
+            // Update all the labels
+            add_label.set_text(&ui, &format!("Added: {}", state.slider_val + state.spinner_val));
+            sub_label.set_text(&ui, &format!("Subtracted: {}", state.slider_val - state.spinner_val));
+            text_label.set_text(&ui, &format!("Text: {}", state.entry_val));
+            bigtext_label.set_text(&ui, &format!("Multiline Text: {}", state.multi_val));
+        }
+    });
+    event_loop.run(&ui);
 }