Struct notify_rust::Notification

pub struct Notification {
    pub appname: String,
    pub summary: String,
    pub body: String,
    pub icon: String,
    pub hints: HashSet<NotificationHint>,
    pub actions: Vec<String>,
    pub timeout: i32,
}

Desktop Notification.

A desktop notification is configured via builder pattern, before it is launched with show().

Fields

appname: String

Filled by default with executable name.

summary: String

Single line to summarize the content.

body: String

Multiple lines possible, may support simple markup, checkout get_capabilities() -> body-markup and body-hyperlinks.

icon: String

Use a file:// URI or a name in an icon theme, must be compliant freedesktop.org.

hints: HashSet<NotificationHint>

Checkout NotificationHint

actions: Vec<String>

See Notification::actions() and Notification::action()

timeout: i32

Lifetime of the Notification in ms. Often not respected by server, sorry.

Methods

impl Notification

fn new() -> Notification

Constructs a new Notification.

Most fields are empty by default, only appname is prefilled with the name of the current executable. The appname is used by some desktop environments to group notifications.

fn appname(&mut self, appname: &str) -> &mut Notification

Overwrite the appname field used for Notification.

fn summary(&mut self, summary: &str) -> &mut Notification

Set the summary.

Often acts as title of the notification. For more elaborate content use the body field.

fn body(&mut self, body: &str) -> &mut Notification

Set the content of the body field.

Multiline textual content of the notification. Each line should be treated as a paragraph. Simple html markup should be supported, depending on the server implementation.

fn icon(&mut self, icon: &str) -> &mut Notification

Set the icon field.

You can use commom icon names here, usually those in /usr/share/icons can all be used. You can also use an absolute path to file.

fn hint(&mut self, hint: NotificationHint) -> &mut Notification

Adds a hint.

This method will add a hint to the internal hint hashset. Hints must be of type NotificationHint.

use notify_rust::Notification;
use notify_rust::NotificationHint;
Notification::new()
    .summary("Category:email")
    .body("This should not go away until you acknoledge it.")
    .icon("thunderbird")
    .appname("thunderbird")
    .hint(NotificationHint::Category("email".to_string()))
    .hint(NotificationHint::Resident(true))
    .show();

fn timeout(&mut self, timeout: i32) -> &mut Notification

Set the timeout.

This sets the time (in miliseconds) from the time the notification is displayed until it is closed again by the Notification Server. According to specification -1 will leave the timeout to be set by the server and 0 will cause the notification never to expire.

fn actions(&mut self, actions: Vec<String>) -> &mut Notification

Set actions.

To quote http://www.galago-project.org/specs/notification/0.9/x408.html#command-notify

Actions are sent over as a list of pairs. Each even element in the list (starting at index 0) represents the identifier for the action. Each odd element in the list is the localized string that will be displayed to the user.

There is nothing fancy going on here yet. Carefull! This replaces the internal list of actions!

fn action(&mut self, identifier: &str, label: &str) -> &mut Notification

Add an action.

This adds a single action to the internal list of actions.

fn finalize(&self) -> Notification

Finalizes a Notification.

Part of the builder pattern, returns a complete copy of the built notification.

fn show(&self) -> u32

Sends Notification to D-Bus.

Returns id from D-Bus.

fn show_debug(&self) -> u32

Wraps show() but prints notification to stdout.

fn show_and_wait_for_action<F>(&self, invokation_closure: F) -> u32 where F: FnOnce(&str)

Wraps show() and blocks.

This method takes a closure that takes an action name.

Example

use notify_rust::Notification;
use notify_rust::NotificationHint as Hint;
Notification::new()
    .summary("click me")
    .action("default", "default")
    .action("clicked", "click here")
    .hint(Hint::Resident(true))
    .show_and_wait_for_action({|action|
        match action {
            "default" => {println!("so boring")},
            "clicked" => {println!("that was correct")},
            _ => ()
        }
    });