Implement numeric entries and sample for their use

Author: NoraCodes

iui/examples/inputs.rs

@@ -0,0 +1,81 @@
+//! Demonstrates a mutable application state manipulated over a number of UIs
+
+extern crate iui;
+use iui::prelude::*;
+use iui::controls::{Label, Spinbox, Slider, VerticalBox, HorizontalBox, Group};
+use std::rc::Rc;
+use std::cell::RefCell;
+
+/// This struct will hold the values that multiple callbacks will need to access.
+struct State {
+    slider_val: i64,
+    spinner_val: i64
+}
+
+fn main() {
+    // Initialize the UI framework.
+    let ui = UI::init().unwrap();
+
+    // Initialize the state of the application.
+    let state = Rc::new(RefCell::new(State { slider_val: 0, spinner_val: 0}));
+
+    let input_group = Group::new(&ui, "Inputs");
+    let input_vbox = VerticalBox::new(&ui);
+    let slider = Slider::new(&ui, 1, 100);
+    let spinner = Spinbox::new(&ui, 1, 100);
+    input_vbox.append(&ui, slider.clone(), LayoutStrategy::Compact);
+    input_vbox.append(&ui, spinner.clone(), LayoutStrategy::Compact);
+    input_group.set_child(&ui, input_vbox);
+
+    let output_group = Group::new(&ui, "Outputs");
+    let output_vbox = VerticalBox::new(&ui);
+    let add_label = Label::new(&ui, "");
+    let sub_label = Label::new(&ui, "");
+    output_vbox.append(&ui, add_label.clone(), LayoutStrategy::Compact);
+    output_vbox.append(&ui, sub_label.clone(), LayoutStrategy::Compact);
+    output_group.set_child(&ui, output_vbox);
+
+    let hbox = HorizontalBox::new(&ui);
+    hbox.append(&ui, input_group, LayoutStrategy::Stretchy);
+    hbox.append(&ui, output_group, LayoutStrategy::Stretchy);
+
+    let window = Window::new(&ui, "Input Output Test", 300, 150, WindowType::NoMenubar);
+    window.set_child(&ui, hbox);
+    window.show(&ui);
+
+    let update_view = Rc::new({
+        let ui = ui.clone();
+        let add_label = add_label.clone();
+        let sub_label = sub_label.clone();
+        let state = state.clone();
+        move || {
+            let state = state.borrow();
+            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));
+        }
+    });
+
+    update_view();
+
+    {
+        let ui = ui.clone();
+        let update_view = update_view.clone();
+        let state = state.clone();
+        slider.on_changed(&ui, |val| {
+            state.borrow_mut().slider_val = val;
+            update_view();
+        });
+    }
+
+    {
+        let ui = ui.clone();
+        let update_view = update_view.clone();
+        let state = state.clone();
+        spinner.on_changed(&ui, |val| {
+            state.borrow_mut().spinner_val = val;
+            update_view();
+        });
+    }
+
+    ui.main();
+}

iui/src/controls/entry.rs

@@ -0,0 +1,110 @@
+//! User input mechanisms: numbers, colors, and text in various forms.
+
+use std::mem;
+use std::ffi::{CString};
+use std::i64;
+use libc::c_void;
+use ui_sys::{self, uiControl, uiSpinbox, uiSlider};
+use super::Control;
+use ui::UI;
+
+pub trait NumericEntry {
+    fn value(&self, ctx: &UI) -> i64;
+    fn set_value(&self, ctx: &UI, value: i64);
+    fn on_changed<F: FnMut(i64)>(&self, ctx: &UI, callback: F);
+}
+
+pub trait TextEntry {
+    fn value(&self, ctx: &UI) -> String;
+    fn set_value(&self, ctx: &UI, value: &str);
+    fn on_changed<F: FnMut(String)>(&self, ctx: &UI, callback: F);
+}
+
+define_control!{
+    /// Numerical entry control which allows users to set any value in a range.
+    rust_type: Spinbox, 
+    sys_type: uiSpinbox
+}
+
+define_control!{ 
+    /// Allows users to select a value by picking a location along a line.
+    rust_type: Slider, 
+    sys_type: uiSlider
+}
+
+impl Spinbox {
+    // Create a new Spinbox which can produce values from `min` to `max`.
+    pub fn new(_ctx: &UI, min: i64, max: i64) -> Self {
+        unsafe { Spinbox::from_raw(ui_sys::uiNewSpinbox(min, max)) }
+    }
+
+    // Create a new Spinbox with the maximum possible range.
+    pub fn new_unlimited(_ctx: &UI) -> Self {
+        Self::new(_ctx, i64::MIN, i64::MAX)
+    }
+}
+
+impl Slider {
+    // Create a new Spinbox which can produce values from `min` to `max`.
+    pub fn new(_ctx: &UI, min: i64, max: i64) -> Self {
+        unsafe { Slider::from_raw(ui_sys::uiNewSlider(min, max)) }
+    }
+}
+
+impl NumericEntry for Spinbox {
+    fn value(&self, _ctx: &UI) -> i64 {
+        unsafe { ui_sys::uiSpinboxValue(self.uiSpinbox) }
+    }
+
+    fn set_value(&self, _ctx: &UI, value: i64) {
+        unsafe { ui_sys::uiSpinboxSetValue(self.uiSpinbox, value) }
+    }
+
+    fn on_changed<F: FnMut(i64)>(&self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(i64)>> = Box::new(Box::new(callback));
+            ui_sys::uiSpinboxOnChanged(
+                self.uiSpinbox,
+                c_callback,
+                &mut *data as *mut Box<FnMut(i64)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(spinbox: *mut uiSpinbox, data: *mut c_void) {
+            unsafe {
+                let val = ui_sys::uiSpinboxValue(spinbox);
+                mem::transmute::<*mut c_void, &mut Box<FnMut(i64)>>(data)(val);
+            }
+        }
+    }
+}
+
+impl NumericEntry for Slider {
+    fn value(&self, _ctx: &UI) -> i64 {
+        unsafe { ui_sys::uiSliderValue(self.uiSlider) }
+    }
+
+    fn set_value(&self, _ctx: &UI, value: i64) {
+        unsafe { ui_sys::uiSliderSetValue(self.uiSlider, value) }
+    }
+
+    fn on_changed<F: FnMut(i64)>(&self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(i64)>> = Box::new(Box::new(callback));
+            ui_sys::uiSliderOnChanged(
+                self.uiSlider,
+                c_callback,
+                &mut *data as *mut Box<FnMut(i64)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(slider: *mut uiSlider, data: *mut c_void) {
+            unsafe {
+                let val = ui_sys::uiSliderValue(slider);
+                mem::transmute::<*mut c_void, &mut Box<FnMut(i64)>>(data)(val);
+            }
+        }
+    }
+}

iui/src/controls/layout.rs

@@ -1,7 +1,7 @@
 use std::mem;
 use std::ffi::{CStr, CString};
 use libc::c_int;
-use ui_sys::{self, uiBox, uiControl, uiTab, uiGroup};
+use ui_sys::{self, uiBox, uiControl, uiTab, uiGroup, uiSeparator};
 use super::Control;
 use ui::UI;
 use error::UIError;
@@ -214,6 +214,16 @@ impl TabGroup {
     pub fn set_margined(&self, _ctx: &UI, page: u64, margined: bool) {
         unsafe { ui_sys::uiTabSetMargined(self.uiTab, page, margined as c_int) }
     }
+}
 
+define_control!{
+    /// Simply adds a horizontal line, to seperate things visually.
+    rust_type: HorizontalSeparator, 
+    sys_type: uiSeparator
+}
 
+impl HorizontalSeparator {
+    pub fn new(_ctx: &UI) -> Self {
+        unsafe { HorizontalSeparator::from_raw(ui_sys::uiNewHorizontalSeparator()) }
+    }
 }

iui/src/controls/mod.rs

@@ -15,6 +15,8 @@ mod window;
 pub use self::window::*;
 mod layout;
 pub use self::layout::*;
+mod entry;
+pub use self::entry::*;
 
 /// A generic UI control. Any UI control can be turned into this type.
 /// 

iui/src/lib.rs

@@ -30,4 +30,5 @@ pub mod prelude {
     pub use ui::UI;
     pub use controls::{Window, WindowType};
     pub use controls::{LayoutStrategy};
+    pub use controls::{NumericEntry, TextEntry};
 }