exwlshell

The daemon function provides a high-level way to create a program by passing it the core application logic. It manages the lifecycle of the application and integrates with the Wayland shell.

To use daemon, you provide:

1. A factory function to create your application state.
2. A namespace function.
3. An update function.
4. A view function.

You can then chain configuration methods like .title(), .subscription(), .on_new_shell(), and .settings() before calling .run().

Monitoring Shell Surfaces

There are two primary ways to react to shell surfaces (windows/layers) created by the runtime:

1. on_new_shell (Synchronous): This hook runs synchronously before a surface's first frame is rendered. This is critical for use cases like session locks, where the initial frame must be correct to prevent flickering or security bypasses.
2. Settings::shell_broadcast (Asynchronous): This is the asynchronous counterpart. You pass the sending end of iced_wayland_subscriber::shell::channel() to the Settings object, and keep the receiving end (ShellReceiver) in your application state. You can then use this receiver in your subscription to listen for surface and monitor changes as they happen.

Example Usage

use iced_exwlshell::daemon;
use iced_exwlshell::settings::{Settings, LayerShellSettings};
use iced_wayland_subscriber::shell::{ShellReceiver, ShellEvent};

// ... inside main or setup ...

// 1. Create the channel
let (shell_broadcast, shell_events) = iced_wayland_subscriber::shell::channel();

// 2. Initialize daemon
daemon(
    move || MyCounter::new("hello", shell_events.clone()),
    MyCounter::namespace,
    MyCounter::update,
    MyCounter::view,
)
.on_new_shell(|info: ShellInfo| {
    // Handle synchronous events like session locks
    matches!(info.shell, ShellType::SessionLock).then(|| Message::LockAppeared(info.window))
})
.settings(Settings {
    shell_broadcast,
    // ... other settings
    ..Default::default()
})
.run()

use iced_exwlshell::daemon;
use iced_exwlshell::settings::{Settings, LayerShellSettings};
use iced_wayland_subscriber::shell::{ShellReceiver, ShellEvent};

// The runtime gets the sending end, the application keeps the receiving one.
let (shell_broadcast, shell_events) = iced_wayland_subscriber::shell::channel();

daemon(
    move || Counter::new("hello", shell_events.clone()),
    Counter::namespace,
    Counter::update,
    Counter::view,
)
.title(Counter::title)
.subscription(Counter::subscription)
.on_new_shell(|info: ShellInfo| {
    matches!(info.shell, ShellType::SessionLock).then(|| Message::LockAppeared(info.window))
})
.settings(Settings {
    layer_settings: LayerShellSettings {
        size: LayerSize::fill_width(400),
        exclusive_zone: 400,
        anchor: Anchor::Bottom | Anchor::Left | Anchor::Right,
        start_mode: StartMode::AllScreens,
        ..Default::default()
    },
    with_connection: Some(connection.into()),
    shell_broadcast,
    ..Default::default()
})
.run()

The ShellInfo trait and NewShell variant have been replaced by two distinct mechanisms:

1. Synchronous Hook (Before first frame)

Use .on_new_shell on the daemon to react to new shells before the surface's first frame.

daemon(...).on_new_shell(|info: ShellInfo| {
    matches!(info.shell, ShellType::SessionLock)
        .then(|| Message::LockAppeared(info.window))
})

2. Asynchronous Channel (Runtime-wide)

Use iced_wayland_subscriber::shell::channel() to create a broadcast/event pair. This works for iced_layershell, iced_exwlshell, and iced_sessionlock.

let (shell_broadcast, shell_events) = iced_wayland_subscriber::shell::channel();

application(move || App::new(shell_events.clone()), ...)
    .settings(Settings { shell_broadcast, ..Default::default() })

ShellEvent Variants:

• NewShell(info) (contains info.window, info.shell)
• Closed(id)
• WindowOutputChanged { window, output }
• OutputAdded(info)
• OutputUpdated(info)
• OutputRemoved(info)

ShellType Variants: LayerShell, PopUp, XdgTopLevel, InputPanel, SessionLock.

Note: Late subscribers receive a replay of current monitors, live shells, and their outputs before new events.

self.shell_events.listen().filter_map(|event| match event {
    ShellEvent::NewShell(info) => {
        // Handle new shell
        Some(Message::HandleNew(info.window, info.shell))
    },
    ShellEvent::Closed(id) => Some(Message::WindowClosed(id)),
    _ => None,
})

The shell::channel() function provides a sender/receiver pair used to bridge the shell runtime and your iced application. You must pass the sender to the runtime via Settings::shell_broadcast and keep the receiver in your application to subscribe to Wayland events like new surfaces, closed windows, and monitor changes.

Subscribing late is safe: the channel replays current monitors, live shells, and their outputs to new subscribers before any new events are emitted, ensuring the application state is synchronized even if it wasn't listening from the first frame.

Available ShellEvents

ShellType allows you to distinguish between LayerShell, PopUp, XdgTopLevel, InputPanel, and SessionLock without manually tracking IDs.

use iced_layershell::daemon;
use iced_layershell::settings::Settings;
use iced_wayland_subscriber::shell::{ShellEvent, ShellReceiver};

pub fn main() -> Result<(), iced_layershell::Error> {
    // 1. Create the channel
    let (shell_broadcast, shell_events) = iced_wayland_subscriber::shell::channel();

    daemon(
        move || Counter::new(shell_events.clone()),
        Counter::namespace,
        Counter::update,
        Counter::view,
    )
    .subscription(Counter::subscription)
    .settings(Settings {
        shell_broadcast, // 2. Pass sender to settings
        ..Default::default()
    })
    .run()
}

impl Counter {
    fn subscription(&self) -> iced::Subscription<Message> {
        // 3. Listen to events in your subscription
        self.shell_events.listen().map(Message::Shell)
    }
}