Struct DialogBox 

pub struct DialogBox { /* private fields */ }

A struct representing a dialog box.

This struct provides a simple interface for creating and showing different types of dialog boxes, such as message boxes or question boxes. Once a dialog box is created using the DialogBox::new method, it can be shown to the user using the DialogBox::show method.

Examples

Showing a simple dialog box:

use my_{DialogBox, DialogType};

let mut dialog_box = DialogBox::new("My App", "Hello World", DialogType::Simple);
dialog_box.show();

Safety

Showing the same dialog box more than once is undefined behavior and depending on the platform, may or may not raise an error.

FFI

Corresponds to NvdDialogBox.

Implementations

impl DialogBox

pub fn new<S: AsRef<str>>( title: S, msg: S, dialog_type: DialogType, ) -> Result<Self, Error>

Creates a new instance of DialogBox with the given title, msg and dialog_type.

Arguments

• title - The title of the dialog box.

• msg - The message to display in the dialog box.

• dialog_type - The type of dialog box to display, either Simple, Warning or Error.

Returns

Returns Ok(DialogBox) if the dialog box was successfully created, otherwise returns Err(Error) with the error converted from NvDialog’s error code.

Panics

This function will panic if CString::new fails to convert the given title or msg to a null-terminated byte string.

Examples found in repository

examples/dialog.rs (lines 32-36)

fn main() {
    nvdialog_rs::init().expect("failed to initialize nvdialog");

    let dialog_box = DialogBox::new(
        "Hello World (from Rust!)",
        "A very basic dialog box from Rust.",
        DialogType::Simple,
    )
    .expect("Error");
    dialog_box.show()
}

examples/file-dialog.rs (line 47)

fn main() {
    nvdialog_rs::init().expect("Can't initialize NvDialog");
    let file_dialog = FileDialog::new(
        String::from("Select an image"),
        FileDialogType::OpenFile,
        Some(vec![
            "png".to_owned(),
            "jpg".to_owned(),
            "jpeg".to_owned(),
            "ico".to_owned(),
            "webp".to_owned(),
        ]),
    );

    if let Some(file) = file_dialog.retrieve_filename() {
        DialogBox::new("File chosen", &file.to_str().unwrap(), DialogType::Simple)
            .expect("Can't create dialog")
            .show()
    } else {
        DialogBox::new("Error", "No file chosen", DialogType::Error)
            .expect("Can't create dialog")
            .show()
    }
}

pub fn set_accept_label<S: AsRef<str>>(&mut self, label: S)

Trait Implementations

impl Drop for DialogBox

fn drop(&mut self)

Executes the destructor for this type.

impl Object for DialogBox

type NativeType = _NvdDialogBox

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)

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.