Merge pull request #12 from LeoTindall/uigrid

Implement UI Grid

Author: NoraCodes

iui/Cargo.toml

@@ -46,4 +46,4 @@ maintenance = { status = "actively-developed" }
 bitflags = "1.0"
 libc = "0.2"
 failure = "0.1.1"
-ui-sys = "0.1.1"
+ui-sys = { path = "../ui-sys" }

iui/examples/inputs-grid.rs

@@ -0,0 +1,128 @@
+//! Demonstrates a mutable application state manipulated over a number of UIs
+//! Using the UIGrid function for a prettier interface.
+
+extern crate iui;
+use iui::prelude::*;
+use iui::controls::{Label, Spinbox, Slider, Entry, MultilineEntry, LayoutGrid, 
+    GridAlignment, HorizontalSeparator};
+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,
+    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, entry_val: "".into(), multi_val: "".into() }));
+
+    // Create the grid which we'll use to lay out controls
+    let mut grid = LayoutGrid::new(&ui);
+    grid.set_padded(&ui, true);
+
+    // 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 (mut slider, mut spinner, mut entry, mut multi) = {
+        // Numerical inputs
+        let slider = Slider::new(&ui, 1, 100);
+        let spinner = Spinbox::new(&ui, 1, 100);
+        // Text inputs
+        let entry = Entry::new(&ui);
+        let multi = MultilineEntry::new(&ui);
+        // Add everything into the grid
+        grid.append(&ui, slider.clone(),
+            // This is position (by slot) and size, expansion, and alignment.
+            // In this case, row 0, col 0, 1 by 1, compress as much as possible,
+            // and align to the fill.
+            0, 0, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, spinner.clone(),
+            // This one is at column zero, row 1.
+            0, 1, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, HorizontalSeparator::new(&ui),
+            0, 3, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, entry.clone(),
+            0, 4, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, multi.clone(),
+            // The multiline entry is at column 0, row 1, and expands vertically.
+            0, 5, 1, 1, false, true, GridAlignment::Fill, GridAlignment::Fill);
+        (slider, spinner, entry, multi)
+    };
+
+    // Set up the outputs for the application. Organization is very similar to the
+    // previous setup.
+    let (add_label, sub_label, text_label, bigtext_label) = {
+        let add_label = Label::new(&ui, "");
+        let sub_label = Label::new(&ui, "");
+        let text_label = Label::new(&ui, "");
+        let bigtext_label = Label::new(&ui, "");
+        grid.append(&ui, add_label.clone(), 
+            1, 0, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, sub_label.clone(),
+            1, 1, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, text_label.clone(),
+            1, 2, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        grid.append(&ui, bigtext_label.clone(),
+            1, 3, 1, 1, false, false, GridAlignment::Fill, GridAlignment::Fill);
+        (add_label, sub_label, text_label, bigtext_label)
+    };
+
+    // 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, grid);
+    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);
+}

iui/src/controls/layout.rs

@@ -4,7 +4,7 @@ use libc::c_int;
 use std::ffi::{CStr, CString};
 use std::mem;
 use ui::UI;
-use ui_sys::{self, uiBox, uiControl, uiGroup, uiSeparator, uiTab};
+use ui_sys::{self, uiBox, uiControl, uiGroup, uiSeparator, uiTab, uiGrid, uiAlign, uiAt};
 
 /// Defines the ways in which the children of boxes can be layed out.
 pub enum LayoutStrategy {
@@ -250,3 +250,100 @@ impl Spacer {
         unsafe { Spacer::from_raw(ui_sys::uiNewHorizontalBox()) }
     }
 }
+
+/// Informs a `LayoutGrid` how to align a control.
+#[derive(Clone, Copy, PartialEq)]
+pub enum GridAlignment {
+    /// Expand to use all available space.
+    Fill,
+    /// Collapse toward the start of the available space.
+    Start,
+    /// Collapse equally on both sides of the available space.
+    Center,
+    /// Collapse toward the end of the available space.
+    End
+}
+
+impl GridAlignment {
+    fn into_ui_align(self) -> uiAlign {
+        use self::GridAlignment::*;
+        use self::uiAlign::*;
+        match self {
+            Fill => uiAlignFill,
+            Start => uiAlignStart,
+            Center => uiAlignCenter,
+            End => uiAlignEnd 
+        }
+    }
+}
+
+/// Informs a `LayoutGrid` as to position a control.
+#[derive(Clone, Copy, PartialEq)]
+pub enum GridInsertionStrategy {
+    Leading,
+    Top,
+    Trailing,
+    Bottom
+}
+
+impl GridInsertionStrategy {
+    fn into_ui_at(self) -> uiAt {
+        use self::GridInsertionStrategy::*;
+        use self::uiAt::*;
+        match self {
+            Leading => uiAtLeading,
+            Top => uiAtTop,
+            Trailing => uiAtTrailing,
+            Bottom => uiAtBottom 
+        }
+    }
+}
+
+define_control!{
+    /// Lays out its children in a grid according to insertion instructions.
+    rust_type: LayoutGrid,
+    sys_type: uiGrid
+}
+
+
+impl LayoutGrid {
+    /// Creates a new `LayoutGrid`.
+    pub fn new(_ctx: &UI) -> Self {
+        unsafe { LayoutGrid::from_raw(ui_sys::uiNewGrid()) }
+    }
+    
+    /// Returns `true` if the `LayoutGrid` is padded and `false` if not.
+    pub fn padded(&self, _ctx: &UI) -> bool {
+        if unsafe { ui_sys::uiGridPadded(self.uiGrid) } == 0 {
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Sets the padding state of the `LayoutGrid`
+    pub fn set_padded(&mut self, _ctx: &UI, padded: bool) {
+       let v = if padded { 1 } else { 0 };
+
+       unsafe {
+           ui_sys::uiGridSetPadded(self.uiGrid, v);
+       }
+    }
+
+    /// Adds a control to the `LayoutGrid`.
+    pub fn append<T: Into<Control>>(&mut self, _ctx: &UI, control: T,
+                                    left: i32, height: i32,
+                                    xspan: i32, yspan: i32,
+                                    hexpand: bool, vexpand: bool,
+                                    halign: GridAlignment, valign: GridAlignment) {
+        let hexpand = if hexpand { 1 } else { 0 }; 
+        let vexpand = if vexpand { 1 } else { 0 };
+        unsafe { 
+            ui_sys::uiGridAppend(
+                self.uiGrid, control.into().ui_control, left, height, xspan, yspan,
+                hexpand, halign.into_ui_align(), vexpand, valign.into_ui_align()
+            );
+        }    
+    }
+}
+

ui-sys/src/lib.rs

@@ -761,3 +761,32 @@ extern {
                              xScale: c_double,
                              yScale: c_double);
 }
+
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq)]
+pub enum uiAlign {
+    uiAlignFill,
+    uiAlignStart,
+    uiAlignCenter,
+    uiAlignEnd,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq)]
+pub enum uiAt {
+    uiAtLeading,
+    uiAtTop,
+    uiAtTrailing,
+    uiAtBottom,
+}
+
+pub enum uiGrid {}
+
+extern {
+    pub fn uiGridAppend(g: *mut uiGrid, c: *mut uiControl, left: c_int, height: c_int, xspan: c_int, yspan: c_int, hexpand: c_int, halign: uiAlign, vexpand: c_int, valign: uiAlign);
+    pub fn uiGridInsertAt(g: *mut uiGrid, c: *mut uiControl, existing: *mut uiControl, at: uiAt, left: c_int, height: c_int, xspan: c_int, yspan: c_int, hexpand: c_int, halign: uiAlign, vexpand: c_int, valign: uiAlign);
+    pub fn uiGridPadded(g: *mut uiGrid) -> c_int;
+    pub fn uiGridSetPadded(g: *mut uiGrid, padded: c_int);
+    pub fn uiNewGrid() -> *mut uiGrid;
+}
+