Struct Notification 

pub struct Notification { /* private fields */ }

A notification dialog, which can be used to send a notification to the user through the system’s API.

Examples

use nvdialog_rs::Notification;

let mut notification = Notification::new("Hello world!", "This is a notification.");
notification.send();

Implementations

impl Notification

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

Constructs a new Notification object with the given title, message and kind of notification.

Arguments

• title: A string for the title / summary of the notification.
• msg: The actual body of the notification.
• kind: The kind of the notification, see NotificationKind.

Errors

Returns an Error of type OutOfMemory if NvDialog’s allocation failed.

Examples

use nvdialog_rs::{Notification, NotificationKind};
let notification = Notification::new("Hello", "This is a notification", NotificationKind::Simple);

FFI

Correspons to nvd_notification_new.

Examples found in repository

examples/notification.rs (lines 29-33)

fn main() {
    nvdialog_rs::init().expect("Failed to initialize NvDialog!");
    let notification = Notification::new(
        "Notification from Rust!",
        "Here's a notification using nvdialog-rs!",
        NotificationKind::Simple,
    )
    .expect("Unable to construct notification");
    notification.send();
}

pub fn add_action<S: AsRef<str>>(&mut self, name: S, val: i32, ptr: &mut i32)

The add_action function in Rust adds a notification action with a specified name, value, and pointer.

Arguments:

• [name]: A string that that represents the name of an action to be added.
• [val]: The value to save in the address pointed to by [ptr]
• [ptr]: A pointer to the variable to save the response to

pub fn send(&self)

Sends the notification to the desktop notification system. If the notification has already been shown or sent, calling this method again will have no effect.

Examples

use nvdialog_rs::{Notification, NotificationKind};

let mut notification = Notification::new("Title", "Body", NotificationKind::Simple)
    .expect("Failed to create notification");

// Send the notification
notification.send();

FFI

Corresponds to nvd_send_notification.

Examples found in repository

examples/notification.rs (line 35)

fn main() {
    nvdialog_rs::init().expect("Failed to initialize NvDialog!");
    let notification = Notification::new(
        "Notification from Rust!",
        "Here's a notification using nvdialog-rs!",
        NotificationKind::Simple,
    )
    .expect("Unable to construct notification");
    notification.send();
}

Trait Implementations

impl Drop for Notification

fn drop(&mut self)

Executes the destructor for this type.

impl Object for Notification

type NativeType = _NvdNotification

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.