Initial test implementation of iui

This is an improved libUI safe interface.

Author: NoraCodes

.gitignore

@@ -2,4 +2,5 @@ Cargo.lock
 *.swp
 ui/target
 ui-sys/target
+iui/target
 

.travis.yml

@@ -4,16 +4,29 @@ rust:
     - beta
     - nightly
 matrix:
-    allow_failures:
-        - rust: nightly
-
-before_install: 
+  allow_failures:
+    - rust: nightly
+before_install:
     - sudo apt-get -qq update
     - sudo apt-get install -y cmake
     - sudo apt-get install -y libgtk-3-dev
-
 script:
     - cd ui-sys
     - cargo build --verbose --tests --examples
     - cd ../ui
     - cargo build --verbose --tests --examples
+    - cd ../iui
+    - cargo build --verbose --tests --examples
+after_success: |
+  [ $TRAVIS_BRANCH = master ] &&
+  [ $TRAVIS_PULL_REQUEST = false ] &&
+  cd $TRAVIS_BUILD_DIR/iui/ &&
+  cargo doc &&
+  echo "<meta http-equiv=refresh content=0;url=iui/index.html>" > target/doc/index.html &&
+  sudo pip install ghp-import &&
+  ghp-import -n target/doc &&
+  git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
+
+env:
+  global:
+    secure: dfPG6E3lrxnbah17u8S4xJmqFMhrAKoXNxQKGSnEoP3HjZL1NrFFsGCtGbIGPGyz02sCQ3U35nmuGHjUP9SOn+oRV6oQlBx41PPHULoDfsMKojEG80Uphjhd6rCXhdTG10EeIjqK+thNvbhnKXJoSPxe7rIk+r+z4HWHjQhxQuT6i4A6AsjvLGV1UI/WxCzrRFJohnaSyd/jx4/BgBd6XXsHzBvrjYSKSDrrBfJJwqrVchLozD6wSKTaTYdK9CSVGYx8S58Kx2m1j1Hk7FuuC6tqPtOARpwlNOX83p4PUMgZln74QzPN65Y2oYx5dszjflyAf5p264ltDwMLlygDTs92kilRCrznnP1iHgtrO3+aV2jwtRtqXB16JpeYKGFMkRtd3afWZ1SaMjU7s+6tVbSvlXg88GstZPqYYw7B4qYP1BGPX6UGiYMtpqH3Tm1Ne3lX3sPQYDFaV7vkd4JoS05vuHuGU+FERJRmaMAHjz2PCEhcgwnQTzL5LFKTcfNHEFv7NkQ8zPiJ7GELg9n2KnWiRhdB4JGUu8WB1LyYP6j3CQ9NwfBj0VGiH8Urgl9fC3IJnXQW3f284vk0VxBQnSdKILHsvdo8pe6INbDu97XOhzZNIc4jLZRT08aQe5Lk+3e7nGf0CCxFNQSlP6FFN7UP9c/Qvd4M3Ys5atBAryQ=

iui/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "iui"
+version = "0.1.0"
+authors = ["Leo Tindall <[email protected]>"]
+
+[dependencies]
+bitflags = "0.7"
+libc = "*"
+failure = "0.1.1"
+
+[dependencies.ui-sys]
+path = "../ui-sys"

iui/examples/basic.rs

@@ -0,0 +1,18 @@
+extern crate iui;
+use iui::prelude::*;
+
+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");
+
+        // Actually put the button in the window
+        win.set_child(&ui, btn);
+        // Show the window
+        win.show(&ui);
+        // Run the application
+        ui.main();
+}

iui/src/controls/basic.rs

@@ -0,0 +1,67 @@
+use std::mem;
+use std::ffi::{CString, CStr};
+use libc::c_void;
+use ui_sys::{self, uiButton, uiLabel, uiControl};
+use super::Control;
+use ui::UI;
+
+define_control!{
+    /// A textual button which users can click on, causing a callback to run.
+    rust_type: Button,
+    sys_type: uiButton
+}
+
+impl Button {
+    /// Create a new button with the given text as its label.
+    pub fn new(_ctx: &UI, text: &str) -> Button {
+        unsafe {
+            let c_string = CString::new(text.as_bytes().to_vec()).unwrap();
+            Button::from_raw(ui_sys::uiNewButton(c_string.as_ptr()))
+        }
+    }
+
+    /// Get a copy of the existing text on the button.
+    pub fn text(&self, _ctx: &UI) -> String {
+        unsafe { CStr::from_ptr(ui_sys::uiButtonText(self.uiButton)).to_string_lossy().into_owned() }
+    }
+
+    /// Get a reference to the existing text on the button.
+    pub fn text_ref(&self, _ctx: &UI) -> &CStr {
+        unsafe { CStr::from_ptr(ui_sys::uiButtonText(self.uiButton)) }
+    }
+
+    /// Set the text on the button.
+    pub fn set_text(&self, _ctx: &UI, text: &str) {
+        unsafe {
+            let c_string = CString::new(text.as_bytes().to_vec()).unwrap();
+            ui_sys::uiButtonSetText(self.uiButton, c_string.as_ptr())
+        }
+    }
+
+    /// Run the given callback when the button is clicked.
+    pub fn on_clicked<F: FnMut(&Button)>(&self, _ctx: &UI, callback: F) {
+        unsafe {
+            let mut data: Box<Box<FnMut(&Button)>> = Box::new(Box::new(callback));
+            ui_sys::uiButtonOnClicked(
+                self.uiButton,
+                c_callback,
+                &mut *data as *mut Box<FnMut(&Button)> as *mut c_void,
+            );
+            mem::forget(data);
+        }
+
+        extern "C" fn c_callback(button: *mut uiButton, data: *mut c_void) {
+            unsafe {
+                let button = Button { uiButton: button };
+                mem::transmute::<*mut c_void, &mut Box<FnMut(&Button)>>(data)(&button)
+            }
+        }
+    }
+}
+
+define_control!{
+    /// A non-interactable piece of text.
+    rust_type: Label,
+    sys_type: uiLabel
+}
+

iui/src/controls/create_macro.rs

@@ -0,0 +1,63 @@
+// Defines a new control, creating a Rust wrapper, a `Deref` implementation, and a destructor.
+// An example of use:
+//
+//      define_control!{
+//          /// Some documentation
+//          #[attribute(whatever="something")]
+//          rust_type: Slider,
+//          sys_type: uiSlider,
+//      }
+macro_rules! define_control {
+    // Match first any attributes (incl. doc comments) and then the actual invocation
+    {$(#[$attr:meta])* rust_type: $rust_type:ident, sys_type: $sys_type:ident } => {
+        #[allow(non_snake_case)]
+        // Include all attributes
+        $(#[$attr])*
+        pub struct $rust_type {
+            $sys_type: *mut $sys_type,
+        }
+
+        impl Drop for $rust_type {
+            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 $rust_type {
+            fn clone(&self) -> $rust_type {
+                $rust_type {
+                    $sys_type: self.$sys_type,
+                }
+            }
+        }
+
+        impl Into<Control> for $rust_type {
+            fn into(self) -> Control {
+                unsafe {
+                    let control = Control::from_ui_control(self.$sys_type as *mut uiControl);
+                    mem::forget(self);
+                    control
+                }
+            }
+        }
+
+        impl $rust_type {
+            pub fn show(&self, _ctx: &UI) {
+                let control: Control = self.clone().into();
+                unsafe { ui_sys::uiControlShow(control.ui_control) }
+            }
+            /// Create an `iui` struct for this control from the raw pointer for it.
+            /// 
+            /// # Unsafety
+            /// The given pointer must point to a valid control or memory unsafety may result.
+            #[allow(non_snake_case)]
+            #[allow(unused)]
+            pub unsafe fn from_raw($sys_type: *mut $sys_type) -> $rust_type {
+                $rust_type {
+                    $sys_type: $sys_type
+                }
+            }
+        }
+    }
+}

iui/src/controls/mod.rs

@@ -0,0 +1,121 @@
+//! Available controls and related functionality. Note that these structs are created by methods on the `UI` struct.
+
+use ui_sys::{self, uiControl};
+use ui::UI;
+
+use std::ptr;
+
+#[macro_use] mod create_macro;
+mod basic;
+pub use self::basic::*;
+mod window;
+pub use self::window::*;
+
+/// 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,
+        }
+    }
+}
+
+impl Control {
+    /// Creates a new `Control` object from an existing `*mut uiControl`.
+    pub unsafe fn from_ui_control(ui_control: *mut uiControl) -> Control {
+        Control {
+            ui_control: ui_control,
+        }
+    }
+
+    /// Returns the underlying `*mut uiControl`.
+    pub fn as_ui_control(&self) -> *mut uiControl {
+        self.ui_control
+    }
+
+    /// Destroys a control. Any use of the control after this is use-after-free; therefore, this
+    /// is marked unsafe.
+    pub unsafe fn destroy(&self) {
+        // Don't check for initialization here since this can be run during deinitialization.
+        ui_sys::uiControlDestroy(self.ui_control)
+    }
+
+}
+
+impl UI {
+    // Return the parent control of the given control, or None if the control is orphaned.
+    pub fn parent_of<T: Into<Control>>(&self, control: T) -> Option<Control> {
+        unsafe {
+            let ptr = ui_sys::uiControlParent(control.into().ui_control);
+            if ptr.is_null() {
+                None
+            } else {
+                Some(Control::from_ui_control(ptr))
+            }
+        }
+    }
+
+    /// Set the parent control of this control, "moving" it to a new place in
+    /// the UI tree or, if passed `None`, removing it from the tree.
+    // TODO: Does this actually need to be unsafe? I don't really see why it is.
+    pub unsafe fn set_parent_of<T: Into<Control>>(&self, control: T, parent: Option<T>) {
+        ui_sys::uiControlSetParent(
+            control.into().ui_control,
+            match parent {
+                None => ptr::null_mut(),
+                Some(parent) => parent.into().ui_control,
+            },
+        )
+    }
+
+    /// Returns true if this control is a top-level control; the root of
+    /// the UI tree.
+    pub fn is_toplevel<T: Into<Control>>(&self, control: T) -> bool {
+        unsafe { ui_sys::uiControlToplevel(control.into().ui_control) != 0 }
+    }
+
+    /// Returns true if this control is currently set to be displayed.
+    pub fn is_shown<T: Into<Control>>(&self, control: T) -> bool {
+        unsafe { ui_sys::uiControlVisible(control.into().ui_control) != 0 }
+    }
+
+    /// Sets whether or not the control should be displayed.
+    pub fn set_shown<T: Into<Control>>(&self, control: T, show: bool) {
+        if show {
+            unsafe { ui_sys::uiControlShow(control.into().ui_control) }
+        } else {
+            unsafe { ui_sys::uiControlHide(control.into().ui_control) }
+        }
+    }
+
+    /// Returns true if the control is enabled (can be interacted with).
+    pub fn is_enabled<T: Into<Control>>(&self, control: T) -> bool {
+        unsafe { ui_sys::uiControlEnabled(control.into().ui_control) != 0 }
+    }
+
+    /// Sets the enable/disable state of the control. If disabled, a control
+    /// cannot be interacted with, and visual cues to that effect are presented
+    /// to the user.
+    pub fn set_enabled<T: Into<Control>>(&self, control: T, enabled: bool) {
+        if enabled {
+            unsafe { ui_sys::uiControlEnable(control.into().ui_control) }
+        } else {
+            unsafe { ui_sys::uiControlDisable(control.into().ui_control) }
+        }
+    }
+}