Add basic layout functionality.

Author: NoraCodes

iui/examples/basic.rs

@@ -1,16 +1,25 @@
 extern crate iui;
 use iui::prelude::*;
+use iui::controls::{Button, VerticalBox};
 
 fn main() {
     // Initialize the UI library
     let ui = UI::init().expect("Couldn't initialize UI library");
     // Create a window into which controls can be placed
     let win = Window::new(&ui, "Test App", 200, 200, WindowType::NoMenubar);
-    // Create a button to place in the window
-    let btn = iui::controls::Button::new(&ui, "Button");
+    
+    // Create a vertical layout to hold the buttons
+    let vbox = VerticalBox::new(&ui);
+    vbox.set_padded(&ui, true);
+
+    let button = iui::controls::Button::new(&ui, "Button");
+    let quit_button = iui::controls::Button::new(&ui, "Quit");
+
+    vbox.append(&ui, button, LayoutStrategy::Compact);
+    vbox.append(&ui, quit_button, LayoutStrategy::Compact);
 
     // Actually put the button in the window
-    win.set_child(&ui, btn);
+    win.set_child(&ui, vbox);
     // Show the window
     win.show(&ui);
     // Run the application

iui/src/controls/basic.rs

@@ -5,6 +5,12 @@ use ui_sys::{self, uiButton, uiControl, uiLabel};
 use super::Control;
 use ui::UI;
 
+define_control!{
+    /// A non-interactable piece of text.
+    rust_type: Label,
+    sys_type: uiLabel
+}
+
 define_control!{
     /// A textual button which users can click on, causing a callback to run.
     rust_type: Button,
@@ -62,9 +68,3 @@ impl Button {
         }
     }
 }
-
-define_control!{
-    /// A non-interactable piece of text.
-    rust_type: Label,
-    sys_type: uiLabel
-}

iui/src/controls/layout.rs

@@ -0,0 +1,98 @@
+use std::mem;
+use std::ffi::{CStr, CString};
+use libc::c_int;
+use ui_sys::{self, uiBox, uiControl, uiGroup};
+use super::Control;
+use ui::UI;
+
+/// Defines the ways in which the children of boxes can be layed out.
+pub enum LayoutStrategy {
+    /// Make the control the minimum possible size to contain its content
+    Compact,
+    /// Make the control expand to its maximum size
+    Stretchy,
+}
+
+define_control! {
+    /// A box that 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.
+    rust_type: HorizontalBox,
+    sys_type: uiBox
+}
+
+impl VerticalBox {
+    /// Create a new vertical box layout.
+    pub fn new(_ctx: &UI) -> VerticalBox {
+        VerticalBox {
+            uiBox: unsafe { ui_sys::uiNewVerticalBox() },
+        }
+    }
+}
+
+impl HorizontalBox {
+    /// Create a new horizontal box layout.
+    pub fn new(_ctx: &UI) -> VerticalBox {
+        VerticalBox {
+            uiBox: unsafe { ui_sys::uiNewHorizontalBox() },
+        }
+    }
+}
+
+fn append<T: Into<Control>>(b: *mut uiBox, ctx: &UI, child: T, strategy: LayoutStrategy) {
+    let stretchy = match strategy {
+        LayoutStrategy::Compact => false,
+        LayoutStrategy::Stretchy => true,
+    };
+    let control = child.into();
+    unsafe {
+        assert!(ctx.parent_of(control.clone()).is_none());
+        ui_sys::uiBoxAppend(b, control.ui_control, stretchy as c_int)
+    }
+}
+
+fn padded(b: *mut uiBox, _ctx: &UI) -> bool {
+    unsafe { ui_sys::uiBoxPadded(b) != 0 }
+}
+
+fn set_padded(b: *mut uiBox, padded: bool, _ctx: &UI) {
+    unsafe { ui_sys::uiBoxSetPadded(b, padded as c_int) }
+}
+
+impl VerticalBox {
+    /// Add a control to the end of the box, sized by the given layout strategy.
+    pub fn append<T: Into<Control>>(&self, _ctx: &UI, child: T, strategy: LayoutStrategy) {
+        append(self.uiBox, _ctx, child, strategy)
+    }
+
+    /// Determine whenther the box provides padding around its children.
+    pub fn padded(&self, _ctx: &UI) -> bool {
+        padded(self.uiBox, _ctx)
+    }
+
+    /// Set whether or not the box should provide padding around its children.
+    pub fn set_padded(&self, _ctx: &UI, padded: bool) {
+        set_padded(self.uiBox, padded, _ctx)
+    }
+}
+
+impl HorizontalBox {
+    /// Add a control to the end of the box, sized by the given layout strategy.
+    pub fn append<T: Into<Control>>(&self, _ctx: &UI, child: T, strategy: LayoutStrategy) {
+        append(self.uiBox, _ctx, child, strategy)
+    }
+
+    /// Determine whenther the box provides padding around its children.
+    pub fn padded(&self, _ctx: &UI) -> bool {
+        padded(self.uiBox, _ctx)
+    }
+
+    /// Set whether or not the box should provide padding around its children.
+    pub fn set_padded(&self, _ctx: &UI, padded: bool) {
+        set_padded(self.uiBox, padded, _ctx)
+    }
+}

iui/src/controls/mod.rs

@@ -1,4 +1,6 @@
-//! Available controls and related functionality. Note that these structs are created by methods on the `UI` struct.
+//! Available user interface controls and related functionality.
+//! 
+//! Note that `Control` and all specific control types are references to memory which is owned by the UI library.
 
 use ui_sys::{self, uiControl};
 use ui::UI;
@@ -11,24 +13,25 @@ mod basic;
 pub use self::basic::*;
 mod window;
 pub use self::window::*;
+mod layout;
+pub use self::layout::*;
 
 /// A generic UI control. Any UI control can be turned into this type.
+/// 
 /// Note that `Control` and all specific control types are references
 /// whose memory is owned by the UI library.
 pub struct Control {
     ui_control: *mut uiControl,
 }
 
 impl Drop for Control {
-    #[inline]
     fn drop(&mut self) {
         // For now this does nothing, but in the future, when `libui` supports proper memory
         // management, this will likely need to twiddle reference counts.
     }
 }
 
 impl Clone for Control {
-    #[inline]
     fn clone(&self) -> Control {
         Control {
             ui_control: self.ui_control,

iui/src/lib.rs

@@ -25,7 +25,9 @@ pub mod controls;
 pub use ui::UI;
 pub use error::UIError;
 
+/// Common imports are packaged into this module. It's meant to be glob-imported: `use iui::prelude::*`.
 pub mod prelude {
     pub use ui::UI;
     pub use controls::{Window, WindowType};
+    pub use controls::{LayoutStrategy};
 }