Struct Toast 

pub struct Toast { /* private fields */ }

Represents a Windows toast.

See https://docs.microsoft.com/en-us/uwp/api/windows.ui.notifications.toastnotification

Implementations

impl Toast

pub fn new() -> Self

Creates an empty toast.

Examples found in repository

examples/sample.rs (line 18)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn header(&mut self, header: Header) -> &mut Toast

Add a Header to this toast.

pub fn text1<T: Into<Text>>(&mut self, text: T) -> &mut Toast

The first text element, usually the title.

Example

// You can use anything that is Into<String>
toast.text1("text");

// Or you can use a `Text`
toast.text1(
    Text::new("text").with_placement(TextPlacement::Attribution)
);

Examples found in repository

examples/sample.rs (line 31)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn text2<T: Into<Text>>(&mut self, text: T) -> &mut Toast

The second text element, usually the body.

Examples found in repository

examples/sample.rs (line 32)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn text3<T: Into<Text>>(&mut self, text: T) -> &mut Toast

The third text element, usually the body or attribution.

Examples found in repository

examples/sample.rs (line 33)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn image(&mut self, id: u8, image: Image) -> &mut Toast

Add an image with the corresponding ID to the toast.

ID

The image element in the toast template that this image is intended for. If a template has only one image, then this value is 1. The number of available image positions is based on the template definition.

Examples found in repository

examples/sample.rs (line 34)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn input(&mut self, input: Input) -> &mut Toast

Add an input field to the toast.

Examples found in repository

examples/sample.rs (lines 38-42)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn selection(&mut self, selection: Selection) -> &mut Toast

Add a selection field to the toast.

Examples found in repository

examples/sample.rs (line 43)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn action(&mut self, action: Action) -> &mut Toast

Add a new action to the toast.

Examples found in repository

examples/sample.rs (line 46)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn tag(&mut self, tag: impl Into<String>) -> &mut Toast

Set the tag of this toast.

See https://docs.microsoft.com/en-us/windows/apps/design/shell/tiles-and-notifications/send-local-toast-cpp-uwp?tabs=xml#provide-a-primary-key-for-your-toast

Examples found in repository

examples/sample.rs (line 30)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn group(&mut self, group: impl Into<String>) -> &mut Toast

Set the group of this toast.

See https://docs.microsoft.com/en-us/windows/apps/design/shell/tiles-and-notifications/send-local-toast-cpp-uwp?tabs=xml#provide-a-primary-key-for-your-toast

pub fn remote_id(&mut self, remote_id: impl Into<String>) -> &mut Toast

Set a remote id for the notification that enables the system to correlate this notification with another one generated on another device.

pub fn scenario(&mut self, scenario: Scenario) -> &mut Toast

Set the scenario of this toast.

The scenario adjusts a few behaviors to create a consistent and unified user experience.

pub fn launch(&mut self, launch: impl Into<String>) -> &mut Toast

A string that is passed to the application when it is activated by the toast.

The format and contents of this string are defined by the app for its own use. When the user taps or clicks the toast to launch its associated app, the launch string provides the context to the app that allows it to show the user a view relevant to the toast content, rather than launching in its default way.

pub fn duration(&mut self, duration: ToastDuration) -> &mut Toast

The amount of time the toast should display.

Examples found in repository

examples/sample.rs (line 36)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

pub fn use_button_style(&mut self) -> &mut Toast

Enable the use of button style for this toast.

pub fn expires_in(&mut self, duration: Duration) -> &mut Toast

Set the expiration time of this toast, starting from the moment it is shown.

After expiration, the toast will be removed from the Notification Center.

pub fn audio(&mut self, audio: Audio) -> &mut Toast

Set the audio for this toast.

The audio will play when the toast is shown.

Examples found in repository

examples/sample.rs (line 37)

fn main() -> Result<()> {
    let manager = ToastManager::new(ToastManager::POWERSHELL_AUM_ID);

    let mut toast = Toast::new();

    let hero_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/flower.jpg"))?
            .with_placement(ImagePlacement::Hero);

    let icon_image =
        Image::new_local(Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/images/cat.jpg"))?
            .with_placement(ImagePlacement::AppLogoOverride)
            .with_hint_crop(ImageHintCrop::Circle);

    toast
        .tag("example")
        .text1("Title")
        .text2(Text::new("Body"))
        .text3(Text::new("Via SMS").with_placement(TextPlacement::Attribution))
        .image(1, hero_image)
        .image(2, icon_image)
        .duration(ToastDuration::Long)
        .audio(Audio::new(Sound::Looping(LoopingSound::Alarm5)).with_looping())
        .input(
            Input::new("box", InputType::Selection)
                .with_title("Select an option")
                .with_default_input("breakfast"),
        )
        .selection(Selection::new("breakfast", "Breakfast"))
        .selection(Selection::new("lunch", "Lunch"))
        .selection(Selection::new("dinner", "Dinner"))
        .action(Action::new("Send", "send", "").with_input_id("box"))
        .action(Action::new("Dismiss", "dismiss", ""));

    // Clone the action_take atomic bool for the closures
    // This is necessary because the closures are Fn/FnMut,
    // and we need to be able to modify the action_take bool
    // from within the closures
    let action_take = Arc::new(AtomicBool::new(false));
    let action_clone = Arc::clone(&action_take);
    let dismiss_clone = Arc::clone(&action_take);

    fn handle_activated_action(action: Option<ActivatedAction>) {
        match action {
            Some(action) => {
                let message = format!(
                    "You clicked on {}{}!",
                    action.arg,
                    action
                        .values
                        .get(&action.input_id.unwrap_or_default())
                        .map_or(String::new(), |value| format!(", input = {value}"))
                );
                println!("{message}");
            }
            None => println!("You clicked me!"),
        }
    }

    manager
        .on_activated(Some("box"), move |action| {
            handle_activated_action(action);
            action_clone.store(true, Ordering::SeqCst);
        })
        .on_dismissed(move |reason| {
            match reason {
                Ok(r) if r.reason == DismissalReason::UserCanceled => println!("UserCanceled"),
                Ok(r) if r.reason == DismissalReason::ApplicationHidden => {
                    println!("ApplicationHidden")
                }
                Ok(r) if r.reason == DismissalReason::TimedOut => println!("TimedOut"),
                Ok(_r) => println!("Unknown dismissal reason"),
                Err(e) => eprintln!("Error: {e:?}"),
            }
            dismiss_clone.store(true, Ordering::SeqCst);
        })
        .on_failed(|e| eprintln!("Error: {e:?}"))
        .show(&toast)
        .expect("Failed to show toast");

    // Wait for the user to interact with the toast
    let time_instant = Instant::now();
    while time_instant.elapsed() < Duration::from_secs(25) {
        if action_take.load(Ordering::SeqCst) {
            break;
        }
        sleep(Duration::from_millis(100));
    }

    Ok(())
}

Trait Implementations

impl Clone for Toast

fn clone(&self) -> Toast

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Toast

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Toast

fn default() -> Toast

Returns the “default value” for a type.