Merge iui for 0.1.0

Author: NoraCodes

.gitignore

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

.travis.yml

@@ -1,26 +1,28 @@
 language: rust
 rust:
-- stable
-- beta
-- nightly
+    - stable
+    - beta
+    - nightly
 matrix:
   allow_failures:
-  - rust: nightly
+    - rust: nightly
 before_install:
-- sudo apt-get -qq update
-- sudo apt-get install -y cmake
-- sudo apt-get install -y libgtk-3-dev
+    - 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 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/ui/ &&
+  cd $TRAVIS_BUILD_DIR/iui/ &&
   cargo doc &&
-  echo "<meta http-equiv=refresh content=0;url=ui/index.html>" > target/doc/index.html &&
+  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

README.md

@@ -1,17 +1,76 @@
-# libUI
+# The Improved User Interface Crate
 [![libui-rs build status](https://api.travis-ci.org/LeoTindall/libui-rs.svg?branch=master)](https://travis-ci.org/LeoTindall/libui-rs/)
 
-A Rusty user interface library that binds to platform native APIs. 
-These are work-in-progress Rust bindings to the minimalistic native UI library [libui][libui].
+`iui` is a simple, small, easy to distribute GUI library, a Rusty user interface library that binds to platform native APIs.
+These are work-in-progress bindings to the minimalistic native UI library [libui][libui].
 
-## Building
-`libui` is included as a submodule. You will need CMake to build `libui` itself; 
-after that, Cargo should be able to take care of the build process.
+Add this to your crate with:
 
-Based on work by @pcwalton
+```
+iui = "0.1.0"
+```
 
-[libui]: https://github.com/andlabs/libui
+## Example
+
+```
+extern crate iui;
+use iui::prelude::*;
+use iui::controls::{VerticalBox, MultilineEntry, Button};
+use std::io::prelude::*;
+use std::error::Error;
+use std::fs::File;
+
+fn main() {
+    // Initialize the UI
+    let ui = UI::init().unwrap();
+
+    // Create the input controls
+    let entry = MultilineEntry::new(&ui);
+    let button = Button::new(&ui, "Save Buffer");
+
+    // Set up the application's layout
+    let window = Window::new(&ui, "Save Buffer to File", 640, 480, WindowType::NoMenubar);
+    let vbox = VerticalBox::new(&ui);
+    vbox.append(&ui, entry.clone(), LayoutStrategy::Stretchy);
+    vbox.append(&ui, button.clone(), LayoutStrategy::Compact);
+    window.set_child(&ui, vbox);
+    window.show(&ui);
+
+    // When the button is clicked, get the name of a file and then write the entry's contents to it.
+    // Note the in real code you should spin off a thread to do the actual writing, do it between UI events,
+    // or use Tokio. Even with minmal content, this method shows noticable lag.
+    button.on_clicked(&ui, {
+        let ui = ui.clone();
+        move |_| {
+            if let Some(path) = window.save_file(&ui) {
+                let mut file = match File::create(&path) {
+                    Err(why) => { window.modal_err(&ui, "I/O Error", &format!("Could not open file {}: {}", path.display(), why.description())); return; }
+                    Ok(f) => f
+                };
+                match file.write_all(entry.value(&ui).as_bytes()) {
+                    Err(why) => { window.modal_err(&ui, "I/O Error", &format!("Could not write to file {}: {}", path.display(), why.description())); return; }
+                    Ok(_) => ()
+                };
+            }    
+        }
+    });
 
-# Testing Note
+    ui.main();
+}
+```
 
+## Organization
+
+`iui` is the safe Rust wrapper, to be used by most users.
+`ui` is the old version of the safe wrapper. Don't use this.
+`ui-sys` is the raw unsafe bindings to the `libui` C code. Requires `cmake` so it can build `libui`.
+
+## Building
+`libui` is included as a submodule. You will need CMake to build `libui` itself.
+
+Based on work by @pcwalton. Licensed MIT.
+
+## Testing Note
 Travis does not connect video devices to their testing environments, so the tests cannot be run. Therefore, the "tests" only check compilation.
+
+[libui]: https://github.com/andlabs/libui

iui/Cargo.toml

@@ -0,0 +1,51 @@
+[package]
+name = "iui"
+version = "0.1.0"
+authors = ["Leo Tindall <[email protected]>"]
+
+# A short blurb about the package. This is not rendered in any format when
+# uploaded to crates.io (aka this is not markdown).
+description = "Simple, small, easy to distribute GUI bindings."
+
+# These URLs point to more information about the package. These are
+# intended to be webviews of the relevant data, not necessarily compatible
+# with VCS tools and the like.
+documentation = "https://docs.rs/iui/"
+repository = "https://github.com/LeoTindall/libui-rs"
+
+# This points to a file under the package root (relative to this `Cargo.toml`).
+# The contents of this file are stored and indexed in the registry.
+# crates.io will render this file and place the result on the crate's page.
+readme = "../README.md"
+
+# This is a list of up to five keywords that describe this crate. Keywords
+# are searchable on crates.io, and you may choose any words that would
+# help someone find this crate.
+keywords = ["windows", "gtk", "gui", "user interface", "macos"]
+
+# This is a list of up to five categories where this crate would fit.
+# Categories are a fixed list available at crates.io/category_slugs, and
+# they must match exactly.
+categories = ["gui", "os::macos-apis", "os::unix-apis", "os::windows-apis"]
+license = "MIT"
+
+[badges]
+# Travis CI: `repository` in format "<user>/<project>" is required.
+# `branch` is optional; default is `master`
+travis-ci = { repository = "LeoTindall/libui-rs", branch = "master" }
+
+# Is it maintained resolution time: `repository` is required.
+is-it-maintained-issue-resolution = { repository = "LeoTindall/libui-rs" }
+
+# Is it maintained percentage of open issues: `repository` is required.
+is-it-maintained-open-issues = { repository = "LeoTindall/libui-rs" }
+
+maintenance = { status = "actively-developed" }
+
+[dependencies]
+bitflags = "0.7"
+libc = "0.2"
+failure = "0.1.1"
+
+[dependencies.ui-sys]
+path = "../ui-sys"

iui/examples/basic.rs

@@ -0,0 +1,41 @@
+extern crate iui;
+use iui::prelude::*;
+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 controls
+    let vbox = VerticalBox::new(&ui);
+    vbox.set_padded(&ui, true);
+
+    let group_vbox = VerticalBox::new(&ui);
+    let group = Group::new(&ui, "Group");
+
+    // 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);
+    // Show the window
+    win.show(&ui);
+    // Run the application
+    ui.main();
+}

iui/examples/files.rs

@@ -0,0 +1,48 @@
+//! Demonstrates the use of the Window::save_file() call to get a filename via a friendly GUI,
+//! and the Window::modal_err() call to display modal dialog boxes.
+
+extern crate iui;
+use iui::prelude::*;
+use iui::controls::{VerticalBox, MultilineEntry, Button};
+use std::io::prelude::*;
+use std::error::Error;
+use std::fs::File;
+
+fn main() {
+    // Initialize the UI
+    let ui = UI::init().unwrap();
+
+    // Create the input controls
+    let entry = MultilineEntry::new(&ui);
+    let button = Button::new(&ui, "Save Buffer");
+
+    // Set up the application's layout
+    let window = Window::new(&ui, "Save Buffer to File", 640, 480, WindowType::NoMenubar);
+    let vbox = VerticalBox::new(&ui);
+    vbox.append(&ui, entry.clone(), LayoutStrategy::Stretchy);
+    vbox.append(&ui, button.clone(), LayoutStrategy::Compact);
+    window.set_child(&ui, vbox);
+    window.show(&ui);
+
+    // When the button is clicked, get the name of a file and then write the entry's contents to it.
+    // Note the in real code you should spin off a thread to do the actual writing, do it between UI events,
+    // or use Tokio. Even with minmal content, this method shows noticable lag.
+    button.on_clicked(&ui, {
+        let ui = ui.clone();
+        move |_| {
+            if let Some(path) = window.save_file(&ui) {
+                let mut file = match File::create(&path) {
+                    Err(why) => { window.modal_err(&ui, "I/O Error", &format!("Could not open file {}: {}", path.display(), why.description())); return; }
+                    Ok(f) => f
+                };
+                match file.write_all(entry.value(&ui).as_bytes()) {
+                    Err(why) => { window.modal_err(&ui, "I/O Error", &format!("Could not write to file {}: {}", path.display(), why.description())); return; }
+                    Ok(_) => ()
+                };
+            }    
+        }
+    });
+
+    ui.main();
+
+}