Struct MessageBox 

pub struct MessageBox<'a> {
    pub title: &'a str,
    pub message: &'a str,
    pub icon: MessageIcon,
    pub buttons: MessageButtons,
    pub owner: Option<&'a dyn HasWindowHandle>,
}

Message box dialog.

let result = rustydialogs::MessageBox {
	title: "Confirm Action",
	message: "Are you sure you want to proceed?",
	icon: rustydialogs::MessageIcon::Question,
	buttons: rustydialogs::MessageButtons::YesNo,
	owner: None,
}.show();
if result == Some(rustydialogs::MessageResult::Yes) {
	println!("User chose Yes");
}

Fields

title: &'a str

The title of the dialog.

message: &'a str

The message to display to the user.

icon: MessageIcon

The icon to show in the dialog.

buttons: MessageButtons

The buttons to show in the dialog.

owner: Option<&'a dyn HasWindowHandle>

The owner window of the dialog.

Implementations

impl<'a> MessageBox<'a>

pub fn show(&self) -> Option<MessageResult>

Show the dialog.

Prefer to check if the dialog result matches Some(Ok) or Some(Yes) rather than checking for Some(No) or Some(Cancel).

When the dialog is dismissed (closing the dialog or pressing ESC), the result maybe None or may be any of the message results even if that button is not present (e.g. Some(Cancel)).

Examples found in repository

examples/message_box.rs (line 26)

fn main() {
	let i = std::process::id() / 4;

	let icon = match i % 4 {
		0 => rustydialogs::MessageIcon::Info,
		1 => rustydialogs::MessageIcon::Warning,
		2 => rustydialogs::MessageIcon::Error,
		_ => rustydialogs::MessageIcon::Question,
	};

	let buttons = match i / 4 % 4 {
		0 => rustydialogs::MessageButtons::Ok,
		1 => rustydialogs::MessageButtons::OkCancel,
		2 => rustydialogs::MessageButtons::YesNo,
		_ => rustydialogs::MessageButtons::YesNoCancel,
	};

	let dialog = rustydialogs::MessageBox {
		title: "Rusty Dialogs",
		message: "Hello from Rust!\nThis is a native message box.",
		icon,
		buttons,
		owner: None,
	};

	let selected = dialog.show();
	println!("Selected: {selected:?}");
}

examples/tests.rs (line 172)

fn test_message_box() {
	println!("\n{}", Color("==== Testing MessageBox ====", "120;190;255"));

	let icons: &[rustydialogs::MessageIcon] = &[
		rustydialogs::MessageIcon::Info,
		rustydialogs::MessageIcon::Warning,
		rustydialogs::MessageIcon::Error,
		rustydialogs::MessageIcon::Question,
	];

	let matrix: &[(rustydialogs::MessageButtons, &[Option<rustydialogs::MessageResult>])] = &[
		(rustydialogs::MessageButtons::Ok, &[Some(rustydialogs::MessageResult::Ok), None]),
		(rustydialogs::MessageButtons::OkCancel, &[Some(rustydialogs::MessageResult::Ok), Some(rustydialogs::MessageResult::Cancel), None]),
		(rustydialogs::MessageButtons::YesNo, &[Some(rustydialogs::MessageResult::Yes), Some(rustydialogs::MessageResult::No), None]),
		(rustydialogs::MessageButtons::YesNoCancel, &[Some(rustydialogs::MessageResult::Yes), Some(rustydialogs::MessageResult::No), Some(rustydialogs::MessageResult::Cancel), None]),
	];

	for &icon in icons {
		println!("\n{} Icon: {}", Color("Testing", "120;190;255"), Color(format_args!("{:?}", icon), "255;214;102"));
		let title = format!("[tests] MessageBox - {icon:?}");
		for &(buttons, results) in matrix {
			for &result in results {
				let desc = match result {
					Some(rustydialogs::MessageResult::Ok) => "Press OK.",
					Some(rustydialogs::MessageResult::Cancel) => "Press Cancel.",
					Some(rustydialogs::MessageResult::Yes) => "Press Yes.",
					Some(rustydialogs::MessageResult::No) => "Press No.",
					None => "Dismiss the dialog.",
				};
				let message = format!("Instruction: {desc}");
				let full_desc = format!("{desc}\n  Buttons: {}\n  Icon: {}", Color(format_args!("{:?}", buttons), "255;214;102"), Color(format_args!("{:?}", icon), "255;214;102"));
				step(&full_desc,
					result,
					|| rustydialogs::MessageBox {
						title: &title,
						message: &message,
						icon,
						buttons,
						owner: None,
					}.show()
				);
			}
		}
	}
}

Trait Implementations

impl<'a> Clone for MessageBox<'a>

fn clone(&self) -> MessageBox<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for MessageBox<'a>