Add open/close file and other modals.

Author: NoraCodes

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();
+
+}

iui/src/controls/create_macro.rs

@@ -43,10 +43,18 @@ 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) {
                 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) {
+                let control: Control = self.clone().into();
+                unsafe { ui_sys::uiControlHide(control.ui_control) }
+            }
+
             /// Create an `iui` struct for this control from the raw pointer for it.
             ///
             /// # Unsafety
@@ -58,6 +66,11 @@ macro_rules! define_control {
                     $sys_type: $sys_type
                 }
             }
+
+            #[allow(non_snake_case)]
+            pub unsafe fn ptr(&self) -> *mut $sys_type {
+                self.$sys_type
+            }
         }
     }
 }

iui/src/controls/window.rs

@@ -6,6 +6,7 @@ use libc::{c_int, c_void};
 use std::cell::RefCell;
 use std::ffi::{CStr, CString};
 use std::mem;
+use std::path::PathBuf;
 use ui_sys::{self, uiControl, uiWindow};
 
 thread_local! {
@@ -36,7 +37,7 @@ impl Window {
         };
         let window = unsafe {
             let c_string = CString::new(title.as_bytes().to_vec()).unwrap();
-            let window = Window::from_ui_window(ui_sys::uiNewWindow(
+            let window = Window::from_raw(ui_sys::uiNewWindow(
                 c_string.as_ptr(),
                 width,
                 height,
@@ -125,12 +126,49 @@ impl Window {
         unsafe { ui_sys::uiWindowSetChild(self.uiWindow, child.into().as_ui_control()) }
     }
 
-    pub unsafe fn from_ui_window(window: *mut uiWindow) -> Window {
-        Window { uiWindow: 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 };
+        let path_string: String = unsafe { CStr::from_ptr(ptr).to_string_lossy().into() };
+        Some(path_string.into())
     }
 
-    pub fn as_ui_window(&self) -> *mut uiWindow {
-        self.uiWindow
+    /// 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 };
+        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(),
+            )
+        }
+    }
+
+    /// Open an error-themed message box to show a message to the user.
+    /// Returns when the user acknowledges the message.
+    pub fn modal_err(&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::uiMsgBoxError(
+                self.uiWindow,
+                c_title.as_ptr(),
+                c_description.as_ptr(),
+            )
+        }
     }
 
     pub unsafe fn destroy_all_windows() {

iui/src/lib.rs

@@ -1,10 +1,11 @@
 //! `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" }
+//! iui = "0.1.0"
 //! ```
 //!
 //! 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