Use proper semantic mutability for methods

Author: NoraCodes

iui/examples/basic.rs

@@ -6,18 +6,31 @@ 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);
+    let mut win = Window::new(&ui, "Test App", 200, 200, WindowType::NoMenubar);
 
     // Create a vertical layout to hold the controls
-    let vbox = VerticalBox::new(&ui);
+    let mut vbox = VerticalBox::new(&ui);
     vbox.set_padded(&ui, true);
 
-    let group_vbox = VerticalBox::new(&ui);
-    let group = Group::new(&ui, "Group");
+    let mut group_vbox = VerticalBox::new(&ui);
+    let mut 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");
+    let mut button = Button::new(&ui, "Button");
+    button.on_clicked(&ui, {
+        let ui = ui.clone();
+        move |btn| {
+            btn.set_text(&ui, "Clicked!");
+        }
+    });
+
+    let mut quit_button = Button::new(&ui, "Quit");
+    quit_button.on_clicked(&ui, {
+        let ui = ui.clone();
+        move |_| {
+            ui.quit();
+        }
+    });
 
     // Create a new label. Note that labels don't auto-wrap!
     let mut label_text = String::new();

iui/examples/files.rs

@@ -14,11 +14,11 @@ fn main() {
 
     // Create the input controls
     let entry = MultilineEntry::new(&ui);
-    let button = Button::new(&ui, "Save Buffer");
+    let mut 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);
+    let mut window = Window::new(&ui, "Save Buffer to File", 640, 480, WindowType::NoMenubar);
+    let mut vbox = VerticalBox::new(&ui);
     vbox.append(&ui, entry.clone(), LayoutStrategy::Stretchy);
     vbox.append(&ui, button.clone(), LayoutStrategy::Compact);
     window.set_child(&ui, vbox);

iui/examples/inputs.rs

@@ -25,11 +25,11 @@ fn main() {
     // While it's not necessary to create a block for this, it makes the code a lot easier
     // to read; the indentation presents a visual cue informing the reader that these
     // statements are related.
-    let (input_group, slider, spinner, entry, multi) = {
+    let (input_group, mut slider, mut spinner, mut entry, mut multi) = {
         // The group will hold all the inputs
-        let input_group = Group::new(&ui, "Inputs");
+        let mut input_group = Group::new(&ui, "Inputs");
         // The vertical box arranges the inputs within the groups
-        let input_vbox = VerticalBox::new(&ui);
+        let mut input_vbox = VerticalBox::new(&ui);
         input_vbox.set_padded(&ui, true);
         // Numerical inputs
         let slider = Slider::new(&ui, 1, 100);
@@ -53,8 +53,8 @@ fn main() {
     // Set up the outputs for the application. Organization is very similar to the
     // previous setup.
     let (output_group, add_label, sub_label, text_label, bigtext_label) = {
-        let output_group = Group::new(&ui, "Outputs");
-        let output_vbox = VerticalBox::new(&ui);
+        let mut output_group = Group::new(&ui, "Outputs");
+        let mut output_vbox = VerticalBox::new(&ui);
         let add_label = Label::new(&ui, "");
         let sub_label = Label::new(&ui, "");
         let text_label = Label::new(&ui, "");
@@ -68,12 +68,12 @@ fn main() {
     };
 
     // This horizontal box will arrange the two groups of controls.
-    let hbox = HorizontalBox::new(&ui);
+    let mut hbox = HorizontalBox::new(&ui);
     hbox.append(&ui, input_group, LayoutStrategy::Stretchy);
     hbox.append(&ui, output_group, LayoutStrategy::Stretchy);
 
     // The window allows all constituent components to be displayed.
-    let window = Window::new(&ui, "Input Output Test", 300, 150, WindowType::NoMenubar);
+    let mut window = Window::new(&ui, "Input Output Test", 300, 150, WindowType::NoMenubar);
     window.set_child(&ui, hbox);
     window.show(&ui);
 
@@ -101,13 +101,16 @@ fn main() {
     });
 
 
-    // This update_view function is defined inline so that it can capture the environment, rather than
-    // needing to be passed ui, the labels, and the state each time it is invoked.
-    // It is defined last so that it can operate with the minimum number of `.clone()` calls (since
-    // the code won't need to access the controls after this).
-    // It is wrapped in a refcounted pointer so it can be shared with several other closures.
-    let update_view = Rc::new({
+    // Rather than just invoking ui.run(), using EventLoop gives a lot more control
+    // over the user interface event loop.
+    // Here, the on_tick() callback is used to update the view against the state.
+    let mut event_loop = ui.event_loop();
+    event_loop.on_tick(&ui, {
         let ui = ui.clone();
+        let mut add_label = add_label.clone();
+        let mut sub_label = sub_label.clone();
+        let mut text_label = text_label.clone();
+        let mut bigtext_label = bigtext_label.clone();
         move || {
             let state = state.borrow();
 
@@ -118,11 +121,5 @@ fn main() {
             bigtext_label.set_text(&ui, &format!("Multiline Text: {}", state.multi_val));
         }
     });
-
-    // Rather than just invoking ui.run(), using EventLoop gives a lot more control
-    // over the user interface event loop.
-    // Here, the on_tick() callback is used to update the view against the state.
-    let mut event_loop = ui.event_loop();
-    event_loop.on_tick(&ui, move || { update_view(); });
     event_loop.run(&ui);
 }

iui/src/controls/basic.rs

@@ -41,36 +41,38 @@ impl Button {
     }
 
     /// Set the text on the button.
-    pub fn set_text(&self, _ctx: &UI, text: &str) {
+    pub fn set_text(&mut 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) {
+    pub fn on_clicked<F: FnMut(&mut Button)>(&mut self, _ctx: &UI, callback: F) {
         unsafe {
-            let mut data: Box<Box<FnMut(&Button)>> = Box::new(Box::new(callback));
+            let mut data: Box<Box<FnMut(&mut Button)>> = Box::new(Box::new(callback));
             ui_sys::uiButtonOnClicked(
                 self.uiButton,
                 c_callback,
-                &mut *data as *mut Box<FnMut(&Button)> as *mut c_void,
+                &mut *data as *mut Box<FnMut(&mut 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)
+                let mut button = Button { uiButton: button };
+                mem::transmute::<*mut c_void, &mut Box<FnMut(&mut Button)>>(data)(&mut button)
             }
         }
     }
 }
 
 impl Label {
     /// Create a new label with the given string as its text.
+    /// Note that labels do not auto-wrap their text; they will expand as far as needed
+    /// to fit.
     pub fn new(_ctx: &UI, text: &str) -> Label {
         unsafe {
             let c_string = CString::new(text.as_bytes().to_vec()).unwrap();
@@ -93,7 +95,7 @@ impl Label {
     }
 
     /// Set the text on the label.
-    pub fn set_text(&self, _ctx: &UI, text: &str) {
+    pub fn set_text(&mut 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/create_macro.rs

@@ -44,13 +44,13 @@ macro_rules! define_control {
 
         impl $rust_type {
             // Show this control to the user. This will also show its non-hidden children.
-            pub fn show(&self, _ctx: &UI) {
+            pub fn show(&mut self, _ctx: &UI) {
                 let control: Control = self.clone().into();
                 unsafe { ui_sys::uiControlShow(control.ui_control) }
             }
 
             // Hide this control from the user. This will hide its children.
-            pub fn hide(&self, _ctx: &UI) {
+            pub fn hide(&mut self, _ctx: &UI) {
                 let control: Control = self.clone().into();
                 unsafe { ui_sys::uiControlHide(control.ui_control) }
             }

iui/src/controls/entry.rs

@@ -10,14 +10,14 @@ use ui::UI;
 
 pub trait NumericEntry {
     fn value(&self, ctx: &UI) -> i64;
-    fn set_value(&self, ctx: &UI, value: i64);
-    fn on_changed<F: FnMut(i64)>(&self, ctx: &UI, callback: F);
+    fn set_value(&mut self, ctx: &UI, value: i64);
+    fn on_changed<F: FnMut(i64)>(&mut self, ctx: &UI, callback: F);
 }
 
 pub trait TextEntry {
     fn value(&self, ctx: &UI) -> String;
-    fn set_value(&self, ctx: &UI, value: &str);
-    fn on_changed<F: FnMut(String)>(&self, ctx: &UI, callback: F);
+    fn set_value(&mut self, ctx: &UI, value: &str);
+    fn on_changed<F: FnMut(String)>(&mut self, ctx: &UI, callback: F);
 }
 
 define_control!{
@@ -56,11 +56,11 @@ impl NumericEntry for Spinbox {
         unsafe { ui_sys::uiSpinboxValue(self.uiSpinbox) }
     }
 
-    fn set_value(&self, _ctx: &UI, value: i64) {
+    fn set_value(&mut self, _ctx: &UI, value: i64) {
         unsafe { ui_sys::uiSpinboxSetValue(self.uiSpinbox, value) }
     }
 
-    fn on_changed<F: FnMut(i64)>(&self, _ctx: &UI, callback: F) {
+    fn on_changed<F: FnMut(i64)>(&mut self, _ctx: &UI, callback: F) {
         unsafe {
             let mut data: Box<Box<FnMut(i64)>> = Box::new(Box::new(callback));
             ui_sys::uiSpinboxOnChanged(
@@ -85,11 +85,11 @@ impl NumericEntry for Slider {
         unsafe { ui_sys::uiSliderValue(self.uiSlider) }
     }
 
-    fn set_value(&self, _ctx: &UI, value: i64) {
+    fn set_value(&mut self, _ctx: &UI, value: i64) {
         unsafe { ui_sys::uiSliderSetValue(self.uiSlider, value) }
     }
 
-    fn on_changed<F: FnMut(i64)>(&self, _ctx: &UI, callback: F) {
+    fn on_changed<F: FnMut(i64)>(&mut self, _ctx: &UI, callback: F) {
         unsafe {
             let mut data: Box<Box<FnMut(i64)>> = Box::new(Box::new(callback));
             ui_sys::uiSliderOnChanged(
@@ -137,12 +137,12 @@ impl TextEntry for Entry {
     fn value(&self, _ctx: &UI) -> String {
         unsafe { CStr::from_ptr(ui_sys::uiEntryText(self.uiEntry)).to_string_lossy().into_owned() }
     }
-    fn set_value(&self, _ctx: &UI, value: &str) {
+    fn set_value(&mut self, _ctx: &UI, value: &str) {
         let cstring = CString::new(value.as_bytes().to_vec()).unwrap();
         unsafe { ui_sys::uiEntrySetText(self.uiEntry, cstring.as_ptr()) }
     }
 
-    fn on_changed<F: FnMut(String)>(&self, _ctx: &UI, callback: F) {
+    fn on_changed<F: FnMut(String)>(&mut self, _ctx: &UI, callback: F) {
         unsafe {
             let mut data: Box<Box<FnMut(String)>> = Box::new(Box::new(callback));
             ui_sys::uiEntryOnChanged(
@@ -167,12 +167,12 @@ impl TextEntry for MultilineEntry {
     fn value(&self, _ctx: &UI) -> String {
         unsafe { CStr::from_ptr(ui_sys::uiMultilineEntryText(self.uiMultilineEntry)).to_string_lossy().into_owned() }
     }
-    fn set_value(&self, _ctx: &UI, value: &str) {
+    fn set_value(&mut self, _ctx: &UI, value: &str) {
         let cstring = CString::new(value.as_bytes().to_vec()).unwrap();
         unsafe { ui_sys::uiMultilineEntrySetText(self.uiMultilineEntry, cstring.as_ptr()) }
     }
 
-    fn on_changed<F: FnMut(String)>(&self, _ctx: &UI, callback: F) {
+    fn on_changed<F: FnMut(String)>(&mut self, _ctx: &UI, callback: F) {
         unsafe {
             let mut data: Box<Box<FnMut(String)>> = Box::new(Box::new(callback));
             ui_sys::uiMultilineEntryOnChanged(

iui/src/controls/layout.rs

@@ -66,7 +66,7 @@ fn set_padded(b: *mut uiBox, padded: bool, _ctx: &UI) {
 
 impl VerticalBox {
     /// Add a control to the end of the box, sized by the given layout strategy.
-    pub fn append<T: Into<Control>>(&self, _ctx: &UI, child: T, strategy: LayoutStrategy) {
+    pub fn append<T: Into<Control>>(&mut self, _ctx: &UI, child: T, strategy: LayoutStrategy) {
         append(self.uiBox, _ctx, child, strategy)
     }
 
@@ -76,14 +76,14 @@ impl VerticalBox {
     }
 
     /// Set whether or not the box should provide padding around its children.
-    pub fn set_padded(&self, _ctx: &UI, padded: bool) {
+    pub fn set_padded(&mut self, _ctx: &UI, padded: bool) {
         set_padded(self.uiBox, padded, _ctx)
     }
 }
 
 impl HorizontalBox {
     /// Add a control to the end of the box, sized by the given layout strategy.
-    pub fn append<T: Into<Control>>(&self, _ctx: &UI, child: T, strategy: LayoutStrategy) {
+    pub fn append<T: Into<Control>>(&mut self, _ctx: &UI, child: T, strategy: LayoutStrategy) {
         append(self.uiBox, _ctx, child, strategy)
     }
 
@@ -93,7 +93,7 @@ impl HorizontalBox {
     }
 
     /// Set whether or not the box should provide padding around its children.
-    pub fn set_padded(&self, _ctx: &UI, padded: bool) {
+    pub fn set_padded(&mut self, _ctx: &UI, padded: bool) {
         set_padded(self.uiBox, padded, _ctx)
     }
 }
@@ -113,7 +113,7 @@ define_control! {
 impl Group {
     /// Create a new group with the given title.
     pub fn new(_ctx: &UI, title: &str) -> Group {
-        let group = unsafe {
+        let mut group = unsafe {
             let c_string = CString::new(title.as_bytes().to_vec()).unwrap();
             Group::from_raw(ui_sys::uiNewGroup(c_string.as_ptr()))
         };
@@ -136,15 +136,15 @@ impl Group {
     }
 
     // Set the group's title.
-    pub fn set_title(&self, _ctx: &UI, title: &str) {
+    pub fn set_title(&mut 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) {
+    pub fn set_child<T: Into<Control>>(&mut self, _ctx: &UI, child: T) {
         unsafe { ui_sys::uiGroupSetChild(self.uiGroup, child.into().ui_control) }
     }
 
@@ -154,7 +154,7 @@ impl Group {
     }
 
     // Set whether or not the group draws a margin.
-    pub fn set_margined(&self, _ctx: &UI, margined: bool) {
+    pub fn set_margined(&mut self, _ctx: &UI, margined: bool) {
         unsafe { ui_sys::uiGroupSetMargined(self.uiGroup, margined as c_int) }
     }
 }
@@ -168,7 +168,7 @@ impl TabGroup {
     /// 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 {
+    pub fn append<T: Into<Control>>(&mut self, _ctx: &UI, name: &str, control: T) -> u64 {
         let control = control.into();
         unsafe {
             let c_string = CString::new(name.as_bytes().to_vec()).unwrap();
@@ -180,7 +180,7 @@ 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>>(&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);
@@ -195,7 +195,7 @@ impl TabGroup {
     /// 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> {
+    pub fn delete(&mut 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) };
@@ -211,7 +211,7 @@ impl TabGroup {
     }
 
     /// Set whether or not the tab group provides margins around its children.
-    pub fn set_margined(&self, _ctx: &UI, page: u64, margined: bool) {
+    pub fn set_margined(&mut self, _ctx: &UI, page: u64, margined: bool) {
         unsafe { ui_sys::uiTabSetMargined(self.uiTab, page, margined as c_int) }
     }
 }