Final masmerge fixes

Author: NoraCodes

iui/src/controls/area.rs

@@ -1,13 +1,14 @@
 //! Provides a way to allocate an area in the window for custom drawing.
 
 use controls::Control;
-use ui::UI;
 use draw;
 use libc::c_int;
 use std::mem;
-use ui_sys::{self, uiArea, uiAreaDrawParams, uiAreaHandler, uiAreaKeyEvent, uiAreaMouseEvent,
-             uiControl};
+use ui::UI;
 pub use ui_sys::uiExtKey as ExtKey;
+use ui_sys::{
+    self, uiArea, uiAreaDrawParams, uiAreaHandler, uiAreaKeyEvent, uiAreaMouseEvent, uiControl,
+};
 
 pub trait AreaHandler {
     fn draw(&mut self, _area: &Area, _area_draw_params: &AreaDrawParams) {}
@@ -133,7 +134,12 @@ impl Area {
         }
     }
 
-    pub fn new_scrolling(ctx: &UI, area_handler: Box<AreaHandler>, width: i64, height: i64) -> Area {
+    pub fn new_scrolling(
+        ctx: &UI,
+        area_handler: Box<AreaHandler>,
+        width: i64,
+        height: i64,
+    ) -> Area {
         unsafe {
             let mut rust_area_handler = RustAreaHandler::new(ctx, area_handler);
             let area = Area::from_raw(ui_sys::uiNewScrollingArea(

iui/src/controls/basic.rs

@@ -1,9 +1,9 @@
-use std::mem;
-use std::ffi::{CStr, CString};
-use libc::c_void;
-use ui_sys::{self, uiButton, uiControl, uiLabel};
 use super::Control;
+use libc::c_void;
+use std::ffi::{CStr, CString};
+use std::mem;
 use ui::UI;
+use ui_sys::{self, uiButton, uiControl, uiLabel};
 
 define_control!{
     /// A non-interactable piece of text.

iui/src/controls/entry.rs

@@ -1,13 +1,14 @@
 //! User input mechanisms: numbers, colors, and text in various forms.
 
-use std::mem;
+use super::Control;
+use libc::c_void;
 use std::ffi::{CStr, CString};
 use std::i64;
-use libc::c_void;
-use ui_sys::{self, uiControl, uiSpinbox, uiSlider, uiEntry, uiMultilineEntry, uiCombobox,
-    uiCheckbox};
-use super::Control;
+use std::mem;
 use ui::UI;
+use ui_sys::{
+    self, uiCheckbox, uiCombobox, uiControl, uiEntry, uiMultilineEntry, uiSlider, uiSpinbox,
+};
 
 pub trait NumericEntry {
     fn value(&self, ctx: &UI) -> i64;
@@ -136,7 +137,11 @@ impl MultilineEntry {
 
 impl TextEntry for Entry {
     fn value(&self, _ctx: &UI) -> String {
-        unsafe { CStr::from_ptr(ui_sys::uiEntryText(self.uiEntry)).to_string_lossy().into_owned() }
+        unsafe {
+            CStr::from_ptr(ui_sys::uiEntryText(self.uiEntry))
+                .to_string_lossy()
+                .into_owned()
+        }
     }
     fn set_value(&mut self, _ctx: &UI, value: &str) {
         let cstring = CString::new(value.as_bytes().to_vec()).unwrap();
@@ -156,7 +161,9 @@ impl TextEntry for Entry {
 
         extern "C" fn c_callback(entry: *mut uiEntry, data: *mut c_void) {
             unsafe {
-                let string = CStr::from_ptr(ui_sys::uiEntryText(entry)).to_string_lossy().into_owned();
+                let string = CStr::from_ptr(ui_sys::uiEntryText(entry))
+                    .to_string_lossy()
+                    .into_owned();
                 mem::transmute::<*mut c_void, &mut Box<FnMut(String)>>(data)(string);
                 mem::forget(entry);
             }
@@ -166,7 +173,11 @@ impl TextEntry for Entry {
 
 impl TextEntry for MultilineEntry {
     fn value(&self, _ctx: &UI) -> String {
-        unsafe { CStr::from_ptr(ui_sys::uiMultilineEntryText(self.uiMultilineEntry)).to_string_lossy().into_owned() }
+        unsafe {
+            CStr::from_ptr(ui_sys::uiMultilineEntryText(self.uiMultilineEntry))
+                .to_string_lossy()
+                .into_owned()
+        }
     }
     fn set_value(&mut self, _ctx: &UI, value: &str) {
         let cstring = CString::new(value.as_bytes().to_vec()).unwrap();
@@ -186,7 +197,9 @@ impl TextEntry for MultilineEntry {
 
         extern "C" fn c_callback(entry: *mut uiMultilineEntry, data: *mut c_void) {
             unsafe {
-                let string = CStr::from_ptr(ui_sys::uiMultilineEntryText(entry)).to_string_lossy().into_owned();
+                let string = CStr::from_ptr(ui_sys::uiMultilineEntryText(entry))
+                    .to_string_lossy()
+                    .into_owned();
                 mem::transmute::<*mut c_void, &mut Box<FnMut(String)>>(data)(string);
                 mem::forget(entry);
             }
@@ -279,4 +292,4 @@ impl Checkbox {
             }
         }
     }
-}
+}

iui/src/controls/layout.rs

@@ -1,10 +1,10 @@
-use std::mem;
-use std::ffi::{CStr, CString};
-use libc::c_int;
-use ui_sys::{self, uiBox, uiControl, uiTab, uiGroup, uiSeparator};
 use super::Control;
-use ui::UI;
 use error::UIError;
+use libc::c_int;
+use std::ffi::{CStr, CString};
+use std::mem;
+use ui::UI;
+use ui_sys::{self, uiBox, uiControl, uiGroup, uiSeparator, uiTab};
 
 /// Defines the ways in which the children of boxes can be layed out.
 pub enum LayoutStrategy {
@@ -164,9 +164,9 @@ impl TabGroup {
     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>>(&mut self, _ctx: &UI, name: &str, control: T) -> u64 {
         let control = control.into();
@@ -178,20 +178,31 @@ impl TabGroup {
     }
 
     /// 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>>(&mut self, _ctx: &UI, name: &str, before: u64, control: T) -> u64 {
+    pub fn insert_at<T: Into<Control>>(
+        &mut 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::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…
@@ -201,7 +212,7 @@ impl TabGroup {
             unsafe { ui_sys::uiTabDelete(self.uiTab, index) };
             Ok(n)
         } else {
-            Err(UIError::TabGroupIndexOutOfBounds { index: index, n: n } )
+            Err(UIError::TabGroupIndexOutOfBounds { index: index, n: n })
         }
     }
 
@@ -218,7 +229,7 @@ impl TabGroup {
 
 define_control!{
     /// Horizontal line, to seperate things visually.
-    rust_type: HorizontalSeparator, 
+    rust_type: HorizontalSeparator,
     sys_type: uiSeparator
 }
 

iui/src/controls/mod.rs

@@ -2,8 +2,8 @@
 //!
 //! 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;
+use ui_sys::{self, uiControl};
 
 use std::ptr;
 

iui/src/controls/window.rs

@@ -1,12 +1,12 @@
 //! Functionality related to creating, managing, and destroying GUI windows.
 
 use controls::Control;
-use ui::UI;
 use libc::{c_int, c_void};
 use std::cell::RefCell;
 use std::ffi::{CStr, CString};
 use std::mem;
 use std::path::PathBuf;
+use ui::UI;
 use ui_sys::{self, uiControl, uiWindow};
 
 thread_local! {
@@ -104,8 +104,9 @@ impl Window {
         extern "C" fn c_callback(window: *mut uiWindow, data: *mut c_void) -> i32 {
             unsafe {
                 let mut window = Window { uiWindow: window };
-                mem::transmute::<*mut c_void, Box<Box<FnMut(&mut Window) -> bool>>>(data)(&mut window)
-                    as i32
+                mem::transmute::<*mut c_void, Box<Box<FnMut(&mut Window) -> bool>>>(data)(
+                    &mut window,
+                ) as i32
             }
         }
     }
@@ -137,31 +138,30 @@ impl Window {
     /// Allow the user to select an existing file.
     pub fn open_file(&self, _ctx: &UI) -> Option<PathBuf> {
         let ptr = unsafe { ui_sys::uiOpenFile(self.uiWindow) };
-        if ptr.is_null() { return None };
+        if ptr.is_null() {
+            return None;
+        };
         let path_string: String = unsafe { CStr::from_ptr(ptr).to_string_lossy().into() };
         Some(path_string.into())
     }
 
     /// Allow the user to select a new or existing file.
     pub fn save_file(&self, _ctx: &UI) -> Option<PathBuf> {
         let ptr = unsafe { ui_sys::uiSaveFile(self.uiWindow) };
-        if ptr.is_null() { return None };
+        if ptr.is_null() {
+            return None;
+        };
         let path_string: String = unsafe { CStr::from_ptr(ptr).to_string_lossy().into() };
         Some(path_string.into())
     }
 
-
     /// Open a generic message box to show a message to the user.
     /// Returns when the user acknowledges the message.
     pub fn modal_msg(&self, _ctx: &UI, title: &str, description: &str) {
         unsafe {
             let c_title = CString::new(title.as_bytes().to_vec()).unwrap();
             let c_description = CString::new(description.as_bytes().to_vec()).unwrap();
-            ui_sys::uiMsgBox(
-                self.uiWindow,
-                c_title.as_ptr(),
-                c_description.as_ptr(),
-            )
+            ui_sys::uiMsgBox(self.uiWindow, c_title.as_ptr(), c_description.as_ptr())
         }
     }
 
@@ -171,11 +171,7 @@ impl Window {
         unsafe {
             let c_title = CString::new(title.as_bytes().to_vec()).unwrap();
             let c_description = CString::new(description.as_bytes().to_vec()).unwrap();
-            ui_sys::uiMsgBoxError(
-                self.uiWindow,
-                c_title.as_ptr(),
-                c_description.as_ptr(),
-            )
+            ui_sys::uiMsgBoxError(self.uiWindow, c_title.as_ptr(), c_description.as_ptr())
         }
     }
 

iui/src/draw/brush.rs

@@ -1,6 +1,6 @@
-use ui::UI;
 use std::marker::PhantomData;
 use std::ptr;
+use ui::UI;
 use ui_sys::{uiDrawBrush, uiDrawBrushType};
 
 pub use ui_sys::uiDrawBrushGradientStop as BrushGradientStop;
@@ -114,14 +114,20 @@ impl<'a> BrushRef<'a> {
     }
 }
 
+/// A brush that paints all pixels with the same color, respecting alpha.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct SolidBrush {
+    /// Red component of the color
     pub r: f64,
+    /// Green component of the color
     pub g: f64,
+    /// Blue component of the color
     pub b: f64,
+    /// Alpha (α) component of the color (that is, opacity).
     pub a: f64,
 }
 
+/// A brush that paints a linear gradient.
 #[derive(Clone, Debug)]
 pub struct LinearGradientBrush {
     pub start_x: f64,
@@ -131,6 +137,7 @@ pub struct LinearGradientBrush {
     pub stops: Vec<BrushGradientStop>,
 }
 
+/// A brush that paints a radial gradient.
 #[derive(Clone, Debug)]
 pub struct RadialGradientBrush {
     pub start_x: f64,
@@ -139,4 +146,4 @@ pub struct RadialGradientBrush {
     pub outer_circle_center_y: f64,
     pub outer_radius: f64,
     pub stops: Vec<BrushGradientStop>,
-}
+}