Add textual inputs and flesh out input example

Author: NoraCodes

iui/examples/inputs.rs

@@ -2,47 +2,83 @@
 
 extern crate iui;
 use iui::prelude::*;
-use iui::controls::{Label, Spinbox, Slider, VerticalBox, HorizontalBox, Group};
+use iui::controls::{Label, Spinbox, Slider, Entry, MultilineEntry, VerticalBox, HorizontalBox, HorizontalSeparator, Group, Spacer};
 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
+    spinner_val: i64,
+    entry_val: String,
+    multi_val: String,
 }
 
 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 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, slider, spinner, entry, multi) = {
+        // The group will hold all the inputs
+        let input_group = Group::new(&ui, "Inputs");
+        // The vertical box arranges the inputs within the groups
+        let 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.
+    let (output_group, add_label, sub_label, text_label, bigtext_label) = {
+        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, "");
+        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 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 window = Window::new(&ui, "Input Output Test", 300, 150, WindowType::NoMenubar);
     window.set_child(&ui, hbox);
     window.show(&ui);
 
+    // This update_view function is defined inline so that it can capture the environment, rather than
+    // needing to be passed ui, the labels, and the state each time it is invoked.
+    // It is wrapped in a refcounted pointer so it can be shared with several other closures.
     let update_view = Rc::new({
         let ui = ui.clone();
         let add_label = add_label.clone();
@@ -52,30 +88,54 @@ fn main() {
             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));
+            text_label.set_text(&ui, &format!("Text: {}", state.entry_val));
+            bigtext_label.set_text(&ui, &format!("Multiline Text: {}", state.multi_val));
         }
     });
 
-    update_view();
+    // These on_changed functions allow updating the application state when a
+    // control changes its value.
+    // Note the calls to update_view after each change to the state!
 
-    {
-        let ui = ui.clone();
+    slider.on_changed(&ui, {
         let update_view = update_view.clone();
         let state = state.clone();
-        slider.on_changed(&ui, |val| {
+        move |val| {
             state.borrow_mut().slider_val = val;
             update_view();
-        });
-    }
+        }
+    });
 
-    {
-        let ui = ui.clone();
+    spinner.on_changed(&ui, {
         let update_view = update_view.clone();
         let state = state.clone();
-        spinner.on_changed(&ui, |val| {
+        move |val| {
             state.borrow_mut().spinner_val = val;
             update_view();
-        });
-    }
+        }
+    });
+
+    entry.on_changed(&ui, {
+        let update_view = update_view.clone();
+        let state = state.clone();
+        move |val| {
+            state.borrow_mut().entry_val = val;
+            update_view();
+        }
+    });
+
+    multi.on_changed(&ui, {
+        let update_view = update_view.clone();
+        let state = state.clone();
+        move |val| {
+            state.borrow_mut().multi_val = val;
+            update_view();
+        }
+    });
+
+    // The initial call to update_view sets up the initial GUI state.
+    update_view();
 
+    // Start the application.
     ui.main();
 }

iui/src/controls/entry.rs

@@ -1,10 +1,10 @@
 //! User input mechanisms: numbers, colors, and text in various forms.
 
 use std::mem;
-use std::ffi::{CString};
+use std::ffi::{CStr, CString};
 use std::i64;
 use libc::c_void;
-use ui_sys::{self, uiControl, uiSpinbox, uiSlider};
+use ui_sys::{self, uiControl, uiSpinbox, uiSlider, uiEntry, uiMultilineEntry};
 use super::Control;
 use ui::UI;
 
@@ -21,13 +21,13 @@ pub trait TextEntry {
 }
 
 define_control!{
-    /// Numerical entry control which allows users to set any value in a range.
+    /// Numerical entry control which allows users to set any value in a range by typing or incrementing/decrementing.
     rust_type: Spinbox, 
     sys_type: uiSpinbox
 }
 
 define_control!{ 
-    /// Allows users to select a value by picking a location along a line.
+    /// Numerical entry which allows users to select a value by picking a location along a line.
     rust_type: Slider, 
     sys_type: uiSlider
 }
@@ -108,3 +108,87 @@ impl NumericEntry for Slider {
         }
     }
 }
+
+define_control! {
+    /// Single-line editable text buffer.
+    rust_type: Entry,
+    sys_type: uiEntry
+}
+
+define_control! {
+    /// Multi-line editable text buffer.
+    rust_type: MultilineEntry,
+    sys_type: uiMultilineEntry
+}
+
+impl Entry {
+    pub fn new(_ctx: &UI) -> Entry {
+        unsafe { Entry::from_raw(ui_sys::uiNewEntry()) }
+    }
+}
+
+impl MultilineEntry {
+    pub fn new(_ctx: &UI) -> MultilineEntry {
+        unsafe { MultilineEntry::from_raw(ui_sys::uiNewMultilineEntry()) }
+    }
+}
+
+impl TextEntry for Entry {
+    fn value(&self, _ctx: &UI) -> String {
+        unsafe { CStr::from_ptr(ui_sys::uiEntryText(self.uiEntry)).to_string_lossy().into_owned() }
+    }
+    fn set_value(&self, ctx: &UI, value: &str) {
+        let cstring = CString::new(value.as_bytes().to_vec()).unwrap();
+        unsafe { ui_sys::uiEntrySetText(self.uiEntry, cstring.as_ptr()) }
+    }
+
+    fn on_changed<F: FnMut(String)>(&self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(String)>> = Box::new(Box::new(callback));
+            ui_sys::uiEntryOnChanged(
+                self.uiEntry,
+                c_callback,
+                &mut *data as *mut Box<FnMut(String)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(entry: *mut uiEntry, data: *mut c_void) {
+            unsafe {
+                let string = CStr::from_ptr(ui_sys::uiEntryText(entry)).to_string_lossy().into_owned();
+                mem::transmute::<*mut c_void, &mut Box<FnMut(String)>>(data)(string);
+                mem::forget(entry);
+            }
+        }
+    }
+}
+
+impl TextEntry for MultilineEntry {
+    fn value(&self, _ctx: &UI) -> String {
+        unsafe { CStr::from_ptr(ui_sys::uiMultilineEntryText(self.uiMultilineEntry)).to_string_lossy().into_owned() }
+    }
+    fn set_value(&self, _ctx: &UI, value: &str) {
+        let cstring = CString::new(value.as_bytes().to_vec()).unwrap();
+        unsafe { ui_sys::uiMultilineEntrySetText(self.uiMultilineEntry, cstring.as_ptr()) }
+    }
+
+    fn on_changed<F: FnMut(String)>(&self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(String)>> = Box::new(Box::new(callback));
+            ui_sys::uiMultilineEntryOnChanged(
+                self.uiMultilineEntry,
+                c_callback,
+                &mut *data as *mut Box<FnMut(String)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(entry: *mut uiMultilineEntry, data: *mut c_void) {
+            unsafe {
+                let string = CStr::from_ptr(ui_sys::uiMultilineEntryText(entry)).to_string_lossy().into_owned();
+                mem::transmute::<*mut c_void, &mut Box<FnMut(String)>>(data)(string);
+                mem::forget(entry);
+            }
+        }
+    }
+}

iui/src/controls/layout.rs

@@ -15,13 +15,13 @@ pub enum LayoutStrategy {
 }
 
 define_control! {
-    /// A box that lays out its children vertically; see [`BoxExt`](trait.BoxExt.html) for functionality.
+    /// Lays out its children vertically; see [`BoxExt`](trait.BoxExt.html) for functionality.
     rust_type: VerticalBox,
     sys_type: uiBox
 }
 
 define_control! {
-    /// A box that lays out its children horizontally; see [`BoxExt`](trait.BoxExt.html) for functionality.
+    /// Lays out its children horizontally; see [`BoxExt`](trait.BoxExt.html) for functionality.
     rust_type: HorizontalBox,
     sys_type: uiBox
 }
@@ -99,13 +99,13 @@ impl HorizontalBox {
 }
 
 define_control! {
-    /// A group of tabs, each of which shows a different sub-control.
+    /// Group of tabs, each of which shows a different sub-control.
     rust_type: TabGroup,
     sys_type: uiTab
 }
 
 define_control! {
-    /// A group collects controls together, with (optionally) a margin and/or title.
+    /// Collects controls together, with (optionally) a margin and/or title.
     rust_type: Group,
     sys_type: uiGroup
 }
@@ -217,7 +217,7 @@ impl TabGroup {
 }
 
 define_control!{
-    /// Simply adds a horizontal line, to seperate things visually.
+    /// Horizontal line, to seperate things visually.
     rust_type: HorizontalSeparator, 
     sys_type: uiSeparator
 }
@@ -227,3 +227,15 @@ impl HorizontalSeparator {
         unsafe { HorizontalSeparator::from_raw(ui_sys::uiNewHorizontalSeparator()) }
     }
 }
+
+define_control! {
+    /// Seperates components with empty space.
+    rust_type: Spacer,
+    sys_type: uiBox
+}
+
+impl Spacer {
+    pub fn new(_ctx: &UI) -> Self {
+        unsafe { Spacer::from_raw(ui_sys::uiNewHorizontalBox()) }
+    }
+}

iui/src/lib.rs

@@ -9,6 +9,8 @@
 //!
 //! Most of the functionality of the crate is exposed via the [UI](struct.UI.html) RAII guard, which handles all initialization and cleanup for the
 //! underlying library.
+//! 
+//! After initialization, all the functionality used for creating actual UIs is in the [`controls`](controls/index.html) module. 
 
 #[macro_use]
 extern crate bitflags;