Struct Icon 

pub struct Icon { /* private fields */ }

A tray icon stored as raw, non-premultiplied RGBA8 pixels in row-major order ([r, g, b, a, r, g, b, a, ...], top row first).

RGBA is the universal representation; each backend converts it to whatever the platform wants (ARGB32 pixmaps on Linux, an HICON on Windows, an NSImage on macOS). Keeping the source format toolkit-neutral is what lets the whole crate avoid linking against any image library.

Implementations

impl Icon

pub fn from_rgba(width: u32, height: u32, rgba: Vec<u8>) -> Result<Icon>

Builds an icon from raw RGBA8 pixels.

rgba must be exactly width * height * 4 bytes and non-empty, otherwise Error::Backend is returned.

Examples found in repository

examples/smoke.rs (line 23)

fn demo_icon() -> Icon {
    let side = 16u32;
    let mut rgba = Vec::with_capacity((side * side * 4) as usize);
    for _ in 0..side * side {
        rgba.extend_from_slice(&[10, 120, 220, 255]);
    }
    Icon::from_rgba(side, side, rgba).expect("valid icon")
}

examples/basic.rs (line 21)

fn main() {
    // A 16x16 solid red icon.
    let side = 16u32;
    let mut rgba = Vec::with_capacity((side * side * 4) as usize);
    for _ in 0..side * side {
        rgba.extend_from_slice(&[220, 40, 40, 255]);
    }
    let icon = Icon::from_rgba(side, side, rgba).expect("valid icon");
    let notify_icon = icon.clone();

    let menu = Menu::new()
        .item(MenuItem::button(SAY_HI, "Say hi"))
        .item(MenuItem::checkbox(TOGGLE, "Toggle me", false))
        .item(MenuItem::separator())
        .item(MenuItem::button(QUIT, "Quit"));

    let config = TrayConfig::new(icon).tooltip("ldtray example").menu(menu);

    let tray = match Tray::new(config) {
        Ok(tray) => tray,
        Err(err) => {
            eprintln!("tray unavailable: {err}");
            eprintln!("(this is expected on a headless server — exiting cleanly)");
            return;
        }
    };

    let handle = tray.handle();
    println!("tray is up — right-click it for the menu, or Ctrl-C to abort");

    let result = tray.run(move |event| {
        println!("event: {event:?}");
        match event {
            Event::Menu(id) if id.0 == SAY_HI => {
                // Actions are shown on Linux; ignored (message still shown)
                // elsewhere.
                let _ = handle.notify(
                    Notification::new("ldtray", "Hello from the tray!")
                        .with_icon(notify_icon.clone())
                        .action(100, "Wave back"),
                );
            }
            Event::NotificationAction(action) => {
                println!("notification action clicked: {}", action.0);
            }
            Event::Menu(id) if id.0 == QUIT => {
                let _ = handle.quit();
            }
            _ => {}
        }
    });

    if let Err(err) = result {
        eprintln!("event loop ended with error: {err}");
    }
}

pub fn width(&self) -> u32

Icon width in pixels.

pub fn height(&self) -> u32

Icon height in pixels.

pub fn rgba(&self) -> &[u8]

Raw RGBA8 pixels, width * height * 4 bytes, row-major.

Trait Implementations

impl Clone for Icon

fn clone(&self) -> Icon

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Icon

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

Formats the value using the given formatter.