Enum Icon 

pub enum Icon {
    Png(Arc<[u8]>),
    Svg(Arc<[u8]>),
    Checkmark,
    Symbol(&'static str),
}

A leading/trailing icon or logo. Raster (PNG) bytes are decoded at load; SVG bytes are rasterized by muri’s own zeno-backed restricted-subset rasterizer (paths, basic shapes, solid fills, transform; no filters/text/ gradients — those should ship as PNG). Both feed the same icon path.

Variants

Png(Arc<[u8]>)

A PNG (or other auto-detected raster format) from raw bytes.

Svg(Arc<[u8]>)

An SVG from raw bytes, rasterized per target size via muri’s restricted SVG subset (see the Icon note for what’s supported).

Checkmark

The themed checkmark glyph, drawn in the leading column.

Symbol(&'static str)

A named symbol: an SF Symbol on macOS, with a bundled fallback elsewhere.

Implementations

impl Icon

pub fn from_png(bytes: impl Into<Arc<[u8]>>) -> Self

The one obvious way to build a raster icon: from encoded PNG (or any auto-detected raster format) bytes. The 90% path for a logo/avatar.

Examples found in repository

examples/usagio_menu.rs (line 99)

fn capture_submenu(groups: &[Group]) -> Menu {
    let mut menu = Menu::new();
    for group in groups {
        menu = menu.row(
            Row::new(format!("capture:{}", group.display_name.to_lowercase()))
                .leading(Icon::from_png(group.icon_png))
                .label(format!("Capture {} login", group.display_name)),
        );
    }
    menu
}

/// The Settings submenu: a checkable toggle, an auto-swap threshold flyout, and
/// a backup flyout — exercising nested submenus, `checked`, and an SVG icon.
fn settings_submenu() -> Menu {
    let autoswap = Menu::new()
        .row(Row::new("autoswap:off").checked(false).label("Off"))
        .row(Row::new("autoswap:80").checked(false).label("At 80%"))
        .row(Row::new("autoswap:90").checked(true).label("At 90%"))
        .separator()
        .row(Row::new("autoswap:now").label("Swap now"));

    let backup = Menu::new()
        .row(Row::new("backup:save").label("Save backup\u{2026}"))
        .row(Row::new("backup:restore").label("Restore backup\u{2026}"));

    Menu::new()
        .row(
            Row::new("notifications:limits")
                .checked(true)
                .label("Notify near limits"),
        )
        .submenu(Row::new("autoswap").label("Auto-swap threshold"), autoswap)
        .submenu(
            Row::new("backup")
                // An SVG leading icon, rasterized per-DPI at draw time.
                .leading(Icon::from_svg(
                    br#"<svg xmlns="http://www.w3.org/2000/svg"/>"#.as_slice(),
                ))
                .label("Backup"),
            backup,
        )
        .separator()
        .row(Row::new("refresh:now").label("Refresh now"))
}

fn build(groups: &[Group]) -> Menu {
    let mut menu = Menu::new();

    for group in groups {
        // Bold, logo'd, non-interactive group header (Claude, then Codex).
        menu = menu.section_header(
            Row::default()
                .leading(Icon::from_png(group.icon_png))
                .segment(Segment::new(group.display_name).font(Font::system(13.0, Weight::Bold))),
        );

        for acct in &group.accounts {
            // The label Grows to eat the leftover width, so the value segment
            // sits flush at the true right edge — no reserved chevron column.
            let label = Segment::new(acct.display)
                .flex(Flex::Grow)
                .font(if acct.active {
                    Font::system(13.0, Weight::Bold)
                } else {
                    Font::system(13.0, Weight::Regular)
                });

            let value = Segment::new(acct.trailing)
                .align(Align::Right)
                .runs(severity_runs(&acct.severity));

            let mut label_row = Row::new(format!("switch:{}:{}", acct.provider, acct.key))
                .segments(vec![label, value])
                .checked(acct.active);
            if acct.active {
                label_row = label_row.leading(Icon::Checkmark);
            }

            menu = menu.submenu(label_row, account_submenu(acct));
        }

        menu = menu.separator();
    }

    // Bottom actions — now with populated submenus.
    menu = menu
        .submenu(
            Row::new("capture").label("Capture current login"),
            capture_submenu(groups),
        )
        .submenu(Row::new("settings").label("Settings"), settings_submenu());

    // "Quit ........ usagio vX" — label Grows, version tail is greyed + flush-right.
    menu = menu.row(Row::new("quit").segments(vec![
        Segment::new("Quit").flex(Flex::Grow),
        Segment::new(format!("usagio v{}", env!("CARGO_PKG_VERSION")))
            .align(Align::Right)
            .color(Color::SecondaryLabel),
    ]));

    menu
}

examples/demo_tray.rs (line 67)

fn demo_menu() -> Menu {
    let claude_logo = swatch_png(217, 119, 87);
    let codex_logo = swatch_png(80, 80, 90);

    Menu::new()
        .section_header(
            Row::default()
                .leading(Icon::from_png(claude_logo))
                .segment(Segment::new("Claude").font(Font::system(13.0, Weight::Bold))),
        )
        .submenu(
            Row::new("acct:claude:me")
                .leading(Icon::Checkmark)
                .checked(true)
                .segments(vec![
                    Segment::new("me@example.com")
                        .flex(Flex::Grow)
                        .font(Font::system(13.0, Weight::Bold)),
                    Segment::new("47% / 89%")
                        .align(Align::Right)
                        .runs(vec![StyleRun::new(6, 3, Color::SystemRed)]),
                ]),
            account_submenu("claude:me"),
        )
        .submenu(
            Row::new("acct:claude:work").segments(vec![
                Segment::new("work@example.com").flex(Flex::Grow),
                Segment::new("12% / 30%")
                    .align(Align::Right)
                    .runs(vec![StyleRun::new(0, 3, Color::SystemGreen)]),
            ]),
            account_submenu("claude:work"),
        )
        .separator()
        .section_header(
            Row::default()
                .leading(Icon::from_png(codex_logo))
                .segment(Segment::new("Codex").font(Font::system(13.0, Weight::Bold))),
        )
        .row(Row::new("switch:codex:me").segments(vec![
            Segment::new("me@example.com").flex(Flex::Grow),
            Segment::new("3h 12m")
                .align(Align::Right)
                .runs(vec![StyleRun::new(0, 6, Color::SystemOrange)]),
        ]))
        .separator()
        .submenu(
            Row::new("settings").label("Settings"),
            Menu::new()
                .row(Row::new("settings:apikey").label("API key…"))
                .row(Row::new("settings:autoswap").label("Auto-swap accounts"))
                .separator()
                .row(Row::new("settings:notifications").label("Notifications…")),
        )
        .row(Row::new("quit").segments(vec![
            Segment::new("Quit").flex(Flex::Grow),
            Segment::new(concat!("usagio v", env!("CARGO_PKG_VERSION")))
                .align(Align::Right)
                .color(Color::SecondaryLabel),
        ]))
}

fn main() {
    let icon = Icon::from_png(swatch_png(120, 170, 255));
    let tray = Tray::new(icon)
        .tooltip("muri demo")
        .menu(demo_menu())
        .on_click(|id| {
            println!("clicked: {}", id.as_str());
            if id.as_str() == "quit" {
                std::process::exit(0);
            }
        });

    println!("muri demo_tray: click the status-bar icon to open the styled popup.");
    // The tray owns the platform status item, which has main-thread affinity on
    // macOS; `Tray::run` proves that at compile time by taking a MainThreadMarker
    // (issue #46). `main` runs on the main thread, so this is always `Some`.
    let Some(mtm) = muri::MainThreadMarker::new() else {
        eprintln!("tray error: must be started on the main thread");
        return;
    };
    if let Err(e) = tray.run(mtm) {
        eprintln!("tray error: {e}");
    }
}

pub fn from_rgba(rgba: &[u8], width: u32, height: u32) -> Result<Self>

The one obvious way to build an icon from raw straight-alpha RGBA8 pixels: width * height * 4 bytes, row-major. muri keeps a single encoded-bytes representation internally (the pixels are encoded to PNG), so a consumer never has to choose a representation — hence this returns a plain Icon, indistinguishable at the type level from one built with Icon::from_png. Returns Error::BadIcon when the buffer length doesn’t equal width * height * 4 (or either dimension is zero).

pub fn from_svg(bytes: impl Into<Arc<[u8]>>) -> Self

The one obvious way to build an icon from raw SVG bytes (rasterized per target size via muri’s restricted SVG subset; see the Icon note).

Examples found in repository

examples/usagio_menu.rs (lines 130-132)

fn settings_submenu() -> Menu {
    let autoswap = Menu::new()
        .row(Row::new("autoswap:off").checked(false).label("Off"))
        .row(Row::new("autoswap:80").checked(false).label("At 80%"))
        .row(Row::new("autoswap:90").checked(true).label("At 90%"))
        .separator()
        .row(Row::new("autoswap:now").label("Swap now"));

    let backup = Menu::new()
        .row(Row::new("backup:save").label("Save backup\u{2026}"))
        .row(Row::new("backup:restore").label("Restore backup\u{2026}"));

    Menu::new()
        .row(
            Row::new("notifications:limits")
                .checked(true)
                .label("Notify near limits"),
        )
        .submenu(Row::new("autoswap").label("Auto-swap threshold"), autoswap)
        .submenu(
            Row::new("backup")
                // An SVG leading icon, rasterized per-DPI at draw time.
                .leading(Icon::from_svg(
                    br#"<svg xmlns="http://www.w3.org/2000/svg"/>"#.as_slice(),
                ))
                .label("Backup"),
            backup,
        )
        .separator()
        .row(Row::new("refresh:now").label("Refresh now"))
}

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.