Port additional functionality, finishing basic example.

Author: NoraCodes

iui/examples/basic.rs

@@ -1,22 +1,36 @@
 extern crate iui;
 use iui::prelude::*;
-use iui::controls::{Button, VerticalBox};
+use iui::controls::{Label, Button, VerticalBox, Group};
 
 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 vertical layout to hold the buttons
+    // Create a vertical layout to hold the controls
     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");
+    let group_vbox = VerticalBox::new(&ui);
+    let group = Group::new(&ui, "Group");
 
-    vbox.append(&ui, button, LayoutStrategy::Compact);
-    vbox.append(&ui, quit_button, LayoutStrategy::Compact);
+    // Create two buttons to place in the window
+    let button = Button::new(&ui, "Button");
+    let quit_button = Button::new(&ui, "Quit");
+
+    // Create a new label. Note that labels don't auto-wrap!
+    let mut label_text = String::new();
+    label_text.push_str("There is a ton of text in this label.\n");
+    label_text.push_str("Pretty much every unicode character is supported.\n");
+    label_text.push_str("🎉 用户界面 사용자 인터페이스");
+    let label = Label::new(&ui, &label_text);
+
+    vbox.append(&ui, label, LayoutStrategy::Stretchy);
+    group_vbox.append(&ui, button, LayoutStrategy::Compact);
+    group_vbox.append(&ui, quit_button, LayoutStrategy::Compact);
+    group.set_child(&ui, group_vbox);
+    vbox.append(&ui, group, LayoutStrategy::Compact);
 
     // Actually put the button in the window
     win.set_child(&ui, vbox);

iui/src/controls/basic.rs

@@ -68,3 +68,35 @@ impl Button {
         }
     }
 }
+
+impl Label {
+    /// Create a new label with the given string as its text.
+    pub fn new(_ctx: &UI, text: &str) -> Label {
+        unsafe {
+            let c_string = CString::new(text.as_bytes().to_vec()).unwrap();
+            Label::from_raw(ui_sys::uiNewLabel(c_string.as_ptr()))
+        }
+    }
+
+    /// Get a copy of the existing text on the label.
+    pub fn text(&self, _ctx: &UI) -> String {
+        unsafe {
+            CStr::from_ptr(ui_sys::uiLabelText(self.uiLabel))
+                .to_string_lossy()
+                .into_owned()
+        }
+    }
+
+    /// Get a reference to the existing text on the label.
+    pub fn text_ref(&self, _ctx: &UI) -> &CStr {
+        unsafe { CStr::from_ptr(ui_sys::uiLabelText(self.uiLabel)) }
+    }
+
+    /// Set the text on the label.
+    pub fn set_text(&self, _ctx: &UI, text: &str) {
+        unsafe {
+            let c_string = CString::new(text.as_bytes().to_vec()).unwrap();
+            ui_sys::uiLabelSetText(self.uiLabel, c_string.as_ptr())
+        }
+    }
+}

iui/src/controls/layout.rs

@@ -1,9 +1,10 @@
 use std::mem;
 use std::ffi::{CStr, CString};
 use libc::c_int;
-use ui_sys::{self, uiBox, uiControl, uiGroup};
+use ui_sys::{self, uiBox, uiControl, uiTab, uiGroup};
 use super::Control;
 use ui::UI;
+use error::UIError;
 
 /// Defines the ways in which the children of boxes can be layed out.
 pub enum LayoutStrategy {
@@ -96,3 +97,123 @@ impl HorizontalBox {
         set_padded(self.uiBox, padded, _ctx)
     }
 }
+
+define_control! {
+    /// A 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.
+    rust_type: Group,
+    sys_type: uiGroup
+}
+
+impl Group {
+    /// Create a new group with the given title.
+    pub fn new(_ctx: &UI, title: &str) -> Group {
+        let group = unsafe {
+            let c_string = CString::new(title.as_bytes().to_vec()).unwrap();
+            Group::from_raw(ui_sys::uiNewGroup(c_string.as_ptr()))
+        };
+        group.set_margined(_ctx, true);
+        group
+    }
+
+    /// Get a copy of the current group title.
+    pub fn title(&self, _ctx: &UI) -> String {
+        unsafe {
+            CStr::from_ptr(ui_sys::uiGroupTitle(self.uiGroup))
+                .to_string_lossy()
+                .into_owned()
+        }
+    }
+
+    /// Get a reference to the existing group title.
+    pub fn title_ref(&self, _ctx: &UI) -> &CStr {
+        unsafe { CStr::from_ptr(ui_sys::uiGroupTitle(self.uiGroup)) }
+    }
+
+    // Set the group's title.
+    pub fn set_title(&self, _ctx: &UI, title: &str) {
+        unsafe {
+            let c_string = CString::new(title.as_bytes().to_vec()).unwrap();
+            ui_sys::uiGroupSetTitle(self.uiGroup, c_string.as_ptr())
+        }
+    }
+
+    // Set the group's child widget.
+    pub fn set_child<T: Into<Control>>(&self, _ctx: &UI, child: T) {
+        unsafe { ui_sys::uiGroupSetChild(self.uiGroup, child.into().ui_control) }
+    }
+
+    // Check whether or not the group draws a margin.
+    pub fn margined(&self, _ctx: &UI) -> bool {
+        unsafe { ui_sys::uiGroupMargined(self.uiGroup) != 0 }
+    }
+
+    // Set whether or not the group draws a margin.
+    pub fn set_margined(&self, _ctx: &UI, margined: bool) {
+        unsafe { ui_sys::uiGroupSetMargined(self.uiGroup, margined as c_int) }
+    }
+}
+
+impl TabGroup {
+    /// Create a new, empty group of tabs.
+    pub fn new(_ctx: &UI) -> TabGroup {
+        unsafe { TabGroup::from_raw(ui_sys::uiNewTab()) }
+    }
+    
+    /// Add the given control as a new tab in the tab group with the given name.
+    /// 
+    /// Returns the number of tabs in the group after adding the new tab.
+    pub fn append<T: Into<Control>>(&self, _ctx: &UI, name: &str, control: T) -> u64 {
+        let control = control.into();
+        unsafe {
+            let c_string = CString::new(name.as_bytes().to_vec()).unwrap();
+            ui_sys::uiTabAppend(self.uiTab, c_string.as_ptr(), control.ui_control);
+            ui_sys::uiTabNumPages(self.uiTab) as u64
+        }
+    }
+
+    /// Add the given control before the given index in the tab group, as a new tab with a given name.
+    /// 
+    /// Returns the number of tabs in the group after adding the new tab.
+    pub fn insert_at<T: Into<Control>>(&self, _ctx: &UI, name: &str, before: u64, control: T) -> u64 {
+        unsafe {
+            let c_string = CString::new(name.as_bytes().to_vec()).unwrap();
+            ui_sys::uiTabInsertAt(self.uiTab, c_string.as_ptr(), before, control.into().ui_control);
+            ui_sys::uiTabNumPages(self.uiTab) as u64
+        }
+    }
+
+    /// Remove the control at the given index in the tab group.
+    /// 
+    /// Returns the number of tabs in the group after removing the tab, or an error if that index was out of bounds.
+    /// 
+    /// NOTE: This will leak the deleted control! We have no way of actually getting it
+    /// to decrement its reference count per `libui`'s UI as of today, unless we maintain a
+    /// separate list of children ourselves…
+    pub fn delete(&self, _ctx: &UI, index: u64) -> Result<u64, UIError> {
+        let n = unsafe { ui_sys::uiTabNumPages(self.uiTab) as u64 };
+        if index < n {
+            unsafe { ui_sys::uiTabDelete(self.uiTab, index) };
+            Ok(n)
+        } else {
+            Err(UIError::TabGroupIndexOutOfBounds { index: index, n: n } )
+        }
+    }
+
+    /// Determine whether or not the tab group provides margins around its children.
+    pub fn margined(&self, _ctx: &UI, page: u64) -> bool {
+        unsafe { ui_sys::uiTabMargined(self.uiTab, page) != 0 }
+    }
+
+    /// Set whether or not the tab group provides margins around its children.
+    pub fn set_margined(&self, _ctx: &UI, page: u64, margined: bool) {
+        unsafe { ui_sys::uiTabSetMargined(self.uiTab, page, margined as c_int) }
+    }
+
+
+}

iui/src/controls/window.rs

@@ -54,6 +54,9 @@ impl Window {
             ui.quit();
         });
 
+        // Windows, by default, draw margins
+        window.set_margined(_ctx, true);
+
         window
     }
 
@@ -107,6 +110,16 @@ impl Window {
         }
     }
 
+    /// Check whether or not this window has margins around the edges.
+    pub fn margined(&self, _ctx: &UI) -> bool {
+        unsafe { ui_sys::uiWindowMargined(self.uiWindow) != 0 }
+    }
+
+    /// Set whether or not the window has margins around the edges.
+    pub fn set_margined(&self, _ctx: &UI, margined: bool) {
+        unsafe { ui_sys::uiWindowSetMargined(self.uiWindow, margined as c_int) }
+    }
+
     /// Sets the window's child widget. The window can only have one child widget at a time.
     pub fn set_child<T: Into<Control>>(&self, _ctx: &UI, child: T) {
         unsafe { ui_sys::uiWindowSetChild(self.uiWindow, child.into().as_ui_control()) }

iui/src/error.rs

@@ -10,4 +10,7 @@ pub enum UIError {
     /// one already existed.
     #[fail(display = "cannot initialize multiple instances of the libui toolkit")]
     MultipleInitError(),
+    /// Signifies that an attempt was made to remove a tab from a tab group that was out of bounds.
+    #[fail(display = "cannot remove index {} from tab group: there are only {} tabs in the group", index, n)]
+    TabGroupIndexOutOfBounds { index: u64, n: u64 },
 }