Struct InputBox 

pub struct InputBox { /* private fields */ }

A struct representing an input box.

Input boxes are similar to DialogBox ones but instead of just showing text, they also allow the user to provide some text input. The input field is always single-line. In addition, the InputBox can display some optional text to provide more information to the user (Like “Enter your name here”).

Examples

Showing a simple input box, then retrieving the input:

use std::process::abort;
use nvdialog_rs::InputBox;
 
nvdialog_rs::init().unwrap_or_else(|e| {
eprintln!("Failed to initialize NvDialog: {}", e.to_string());
abort();
});
let mut input_box = InputBox::new(
    "Input Box",
    "Please enter some text here. The text will be printed to stdout.",
);
input_box.display();
let input = input_box.get_input();
if let Some(string) = input {
    println!("You entered the following text: \"{}\"", string);
} else {
    eprintln!("You didn't enter anything!");
}

Safety

The returned string’s contents, as described in the NvDialog documentation, is heap-allocated, and therefore it’s safe to modify this string through methods inside the struct. However, any modifications are applied to the original string DIRECTLY, meaning that if you wish to preserve the original string but still modify it somewhere, you should duplicate it instead.

FFI

Corresponds to NvdInputBox.

Implementations

impl InputBox

pub fn new<S: AsRef<str>>(title: S, prompt: S) -> Self

Examples found in repository

examples/input_box.rs (lines 35-38)

fn main() {
    nvdialog_rs::init().unwrap_or_else(|e| {
        eprintln!("Failed to initialize NvDialog: {}", e.to_string());
        abort();
    });

    let mut input_box = InputBox::new(
        "Input Box",
        "Please enter some text here. The text will be printed to stdout.",
    );
    input_box.display();
    let input = input_box.get_input();
    if let Some(string) = input {
        println!("You entered the following text: \"{}\"", string.to_string());
    } else {
        eprintln!("You didn't enter anything!");
    }
}

pub fn display(&mut self)

Examples found in repository

examples/input_box.rs (line 39)

fn main() {
    nvdialog_rs::init().unwrap_or_else(|e| {
        eprintln!("Failed to initialize NvDialog: {}", e.to_string());
        abort();
    });

    let mut input_box = InputBox::new(
        "Input Box",
        "Please enter some text here. The text will be printed to stdout.",
    );
    input_box.display();
    let input = input_box.get_input();
    if let Some(string) = input {
        println!("You entered the following text: \"{}\"", string.to_string());
    } else {
        eprintln!("You didn't enter anything!");
    }
}

pub fn get_input(&mut self) -> Option<DynamicString>

Examples found in repository

examples/input_box.rs (line 40)

fn main() {
    nvdialog_rs::init().unwrap_or_else(|e| {
        eprintln!("Failed to initialize NvDialog: {}", e.to_string());
        abort();
    });

    let mut input_box = InputBox::new(
        "Input Box",
        "Please enter some text here. The text will be printed to stdout.",
    );
    input_box.display();
    let input = input_box.get_input();
    if let Some(string) = input {
        println!("You entered the following text: \"{}\"", string.to_string());
    } else {
        eprintln!("You didn't enter anything!");
    }
}

Trait Implementations

impl Drop for InputBox

fn drop(&mut self)

Executes the destructor for this type.

impl Object for InputBox

type NativeType = _NvdInputBox

The type of the underlying native object, created by NvDialog. It will be used as a pointer to provide compatibility with the NvDialog API.

type ReturnValue = ()

The value that should be returned from Self::show. It should match the value that the dialog returns when it is presented to the user.

fn get_raw(&self) -> *mut Self::NativeType

Returns the raw object created by NvDialog internally. This should never return null.

fn show(&self) -> Self::ReturnValue

Presents the dialog to the user. If Self::ReturnValue is not () then it will also return that value. Sometimes this serves as an alias to the type’s implementation of the analogous function. If you cannot afford the overhead, you can use that instead.

fn free(&mut self)

Frees the underlying native object. This should not be usually called manually, instead the Drop implementation should handle it when the time is correct. Be wary, if you do call this, you might run into double freeing errors.