Run rustfmt

Author: NoraCodes

iui/examples/basic.rs

@@ -2,17 +2,17 @@ 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");
+    // 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();
+    // 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

@@ -1,7 +1,7 @@
 use std::mem;
-use std::ffi::{CString, CStr};
+use std::ffi::{CStr, CString};
 use libc::c_void;
-use ui_sys::{self, uiButton, uiLabel, uiControl};
+use ui_sys::{self, uiButton, uiControl, uiLabel};
 use super::Control;
 use ui::UI;
 
@@ -22,7 +22,11 @@ impl Button {
 
     /// 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() }
+        unsafe {
+            CStr::from_ptr(ui_sys::uiButtonText(self.uiButton))
+                .to_string_lossy()
+                .into_owned()
+        }
     }
 
     /// Get a reference to the existing text on the button.
@@ -64,4 +68,3 @@ define_control!{
     rust_type: Label,
     sys_type: uiLabel
 }
-

iui/src/controls/create_macro.rs

@@ -48,7 +48,7 @@ macro_rules! define_control {
                 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)]

iui/src/controls/mod.rs

@@ -5,7 +5,8 @@ use ui::UI;
 
 use std::ptr;
 
-#[macro_use] mod create_macro;
+#[macro_use]
+mod create_macro;
 mod basic;
 pub use self::basic::*;
 mod window;
@@ -54,7 +55,6 @@ impl Control {
         // Don't check for initialization here since this can be run during deinitialization.
         ui_sys::uiControlDestroy(self.ui_control)
     }
-
 }
 
 impl UI {

iui/src/controls/window.rs

@@ -4,7 +4,7 @@ use controls::Control;
 use ui::UI;
 use libc::{c_int, c_void};
 use std::cell::RefCell;
-use std::ffi::{CString, CStr};
+use std::ffi::{CStr, CString};
 use std::mem;
 use ui_sys::{self, uiControl, uiWindow};
 
@@ -21,7 +21,7 @@ pub enum WindowType {
 
 define_control!{
     /// Contains a single child control and displays it and its children in a window on the screen.
-    rust_type: Window, 
+    rust_type: Window,
     sys_type: uiWindow
 }
 
@@ -50,14 +50,20 @@ impl Window {
 
         // Windows, by default, quit the application on closing.
         let ui = _ctx.clone();
-        window.on_closing(_ctx, move |_|{ ui.quit(); });
+        window.on_closing(_ctx, move |_| {
+            ui.quit();
+        });
 
         window
     }
 
     /// Get the current title of the window.
     pub fn title(&self, _ctx: &UI) -> String {
-        unsafe { CStr::from_ptr(ui_sys::uiWindowTitle(self.uiWindow)).to_string_lossy().into_owned() }
+        unsafe {
+            CStr::from_ptr(ui_sys::uiWindowTitle(self.uiWindow))
+                .to_string_lossy()
+                .into_owned()
+        }
     }
 
     /// Get a reference to the current title of the window.
@@ -80,7 +86,10 @@ impl Window {
     /// the application when the window is closed.
     pub fn on_closing<F: FnMut(&Window)>(&self, _ctx: &UI, mut callback: F) {
         unsafe {
-            let mut data: Box<Box<FnMut(&Window) -> bool>> = Box::new(Box::new(|window|{ callback(window); false }));
+            let mut data: Box<Box<FnMut(&Window) -> bool>> = Box::new(Box::new(|window| {
+                callback(window);
+                false
+            }));
             ui_sys::uiWindowOnClosing(
                 self.uiWindow,
                 c_callback,

iui/src/error.rs

@@ -5,9 +5,7 @@
 pub enum UIError {
     /// Signifies that the underlying library was unable to properly hook into the platform's GUI APIs.
     #[fail(display = "unable to initialize the underlying system bindings: {}", error)]
-    FailedInitError {
-        error: String,
-    },
+    FailedInitError { error: String },
     /// Signifies that an attempt was made to initialize a new instance of the underlying library while
     /// one already existed.
     #[fail(display = "cannot initialize multiple instances of the libui toolkit")]

iui/src/ffi_tools.rs

@@ -4,20 +4,20 @@ use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 static INITIALIZED: AtomicBool = ATOMIC_BOOL_INIT;
 
 /// Set the global flag stating that libUI is initialized.
-/// 
+///
 /// # Unsafety
-/// If this is called when the library is not, in fact, initialized, 
+/// If this is called when the library is not, in fact, initialized,
 /// the program will be placed in an undefined state.
-/// 
+///
 /// # Panics
 /// Panics if called when libUI is already marked as initialized.
 pub unsafe fn set_initialized() {
-    assert!(!INITIALIZED.swap(true, Ordering::SeqCst), 
+    assert!(!INITIALIZED.swap(true, Ordering::SeqCst),
         "Tried to initialize libUI when it was already initialized. Aborting because this is an unsafe situation.");
 }
 
 /// Set the global flag stating that libUI is no longer initialized.
-/// 
+///
 /// # Unsafety
 /// If this is called when the library is actually still initialized,
 /// the program could try to create a new instance, violating the library's

iui/src/lib.rs

@@ -1,17 +1,19 @@
-//! `iui`, the `i`mproved `u`ser `i`nterface crate, provides Rust bindings to `libui`, a wrapper library for native(ish) GUI libraries 
-//! - Win32API on Windows, Cocoa on Mac OS X, and GTK+ on Linux and elsewhere. This library exposes a Rusty procedural interface to the 
+//! `iui`, the `i`mproved `u`ser `i`nterface crate, provides Rust bindings to `libui`, a wrapper library for native(ish) GUI libraries
+//! - Win32API on Windows, Cocoa on Mac OS X, and GTK+ on Linux and elsewhere. This library exposes a Rusty procedural interface to the
 //! "Least Common Denominator" of GUI widgets. They are all available on all supported platforms.
 //! To use this library, import it in your `Cargo.toml`:
-//! 
+//!
 //! ```toml
 //! iui = { git = "https://github.com/LeoTindall/libui-rs" }
 //! ```
-//! 
-//! Most of the functionality of the crate is exposed via the [UI](struct.UI.html) RAII guard, which handles all initialization and cleanup for the 
+//!
+//! Most of the functionality of the crate is exposed via the [UI](struct.UI.html) RAII guard, which handles all initialization and cleanup for the
 //! underlying library.
 
-#[macro_use] extern crate failure;
-#[macro_use] extern crate bitflags;
+#[macro_use]
+extern crate bitflags;
+#[macro_use]
+extern crate failure;
 extern crate libc;
 extern crate ui_sys;
 

iui/src/ui.rs

@@ -12,12 +12,15 @@ use controls::Window;
 /// RAII guard for the UI; when dropped, it uninits libUI.
 struct UIToken {
     // This PhantomData prevents UIToken from being Send and Sync
-    _pd: PhantomData<*mut ()>
+    _pd: PhantomData<*mut ()>,
 }
 
 impl Drop for UIToken {
     fn drop(&mut self) {
-        assert!(ffi_tools::is_initialized(), "Attempted to uninit libUI in UIToken destructor when libUI was not initialized!");
+        assert!(
+            ffi_tools::is_initialized(),
+            "Attempted to uninit libUI in UIToken destructor when libUI was not initialized!"
+        );
         unsafe {
             Window::destroy_all_windows();
             ui_sys::uiUninit();
@@ -29,57 +32,61 @@ impl Drop for UIToken {
 /// A handle to user interface functionality.
 #[derive(Clone)]
 pub struct UI {
-    token: Rc<UIToken>
+    token: Rc<UIToken>,
 }
 
 impl UI {
     /// Initializes the underlying UI bindings, producing a [`UI`](struct.UI.html) struct which can be used
     /// to actually build your user interface. This is a reference counted type; clone it
     /// to get an additional reference that can be passed to, e.g., callbacks.
-    /// 
+    ///
     /// Only one libUI binding can be active at once; if multiple instances are detected,
     /// this function will return a [`MultipleInitError`](enum.UIError.html#variant.MultipleInitError).
-    /// 
+    ///
     /// ```
     /// # use iui::UI;
     /// {
     ///     let ui1 = UI::init().unwrap();
-    /// 
+    ///
     ///     // This will fail because there is already an instance of UI.
     ///     let ui2 = UI::init();
     ///     assert!(ui2.is_err());
-    /// 
+    ///
     ///     // ui1 dropped here.
     /// }
     /// let ui3 = UI::init().unwrap();
     /// ```
-    /// 
+    ///
     /// If libUI cannot initialize its hooks into the platform bindings, this function will
     /// return a [`FailedInitError`](enum.UIError.html#variant.FailedInitError) with the description of the problem.
     pub fn init() -> Result<UI, UIError> {
         if ffi_tools::is_initialized() {
-            return Err(UIError::MultipleInitError{})
+            return Err(UIError::MultipleInitError {});
         };
 
         unsafe {
             // Create the magic value needed to init libUI
             let mut init_options = ui_sys::uiInitOptions {
                 Size: mem::size_of::<ui_sys::uiInitOptions>(),
             };
-            
+
             // Actually start up the library's functionality
             let err = ui_sys::uiInit(&mut init_options);
             if err.is_null() {
                 // Success! We can safely give the user a token allowing them to do UI things.
                 ffi_tools::set_initialized();
-                Ok(UI {token: Rc::new(UIToken {_pd: PhantomData})})
+                Ok(UI {
+                    token: Rc::new(UIToken { _pd: PhantomData }),
+                })
             } else {
                 // Error occurred; copy the string describing it, then free that memory.
                 let error_string = CStr::from_ptr(err).to_string_lossy().into_owned();
                 ui_sys::uiFreeInitError(err);
-                Err(UIError::FailedInitError{ error: error_string })
+                Err(UIError::FailedInitError {
+                    error: error_string,
+                })
             }
-        }   
+        }
     }
 
     /// Hands control of this thread to the UI toolkit, allowing it to display the UI and respond to events. Does not return until the UI [quit](struct.UI.html#method.quit)s.

iui/src/util_types.rs

@@ -1,3 +1 @@
 //! Types describing data returned by various libUI items.
-
-