pub struct Notifications { /* private fields */ }Expand description
The notifications, from cx.notifications(). A clone is cheap and
shares the one server.
Implementations§
Source§impl Notifications
impl Notifications
Sourcepub fn list(&self) -> ReadSignal<Vec<Notification>>
pub fn list(&self) -> ReadSignal<Vec<Notification>>
Every notification kept, oldest first: the history, from arrival until it is dismissed, picked or closed by its app. A replaced one keeps its place.
Sourcepub fn popups(&self) -> ReadSignal<Vec<Notification>>
pub fn popups(&self) -> ReadSignal<Vec<Notification>>
The notifications still showing as popups, newest first. Each stays
for its timeout, and until dismissed when that is
Timeout::Never or it is Urgency::Critical. A replaced one
counts its whole timeout again. An expired one stays in
list, unless it is transient.
Sourcepub fn set_default_timeout(&self, timeout: Duration)
pub fn set_default_timeout(&self, timeout: Duration)
Sets what Timeout::Default means for the popups that arrive or
are replaced from now on; those showing keep the countdown they
have. It is 5 s until set. A timeout too long for the clock to hold
shows until dismissed.
Sourcepub fn hold_popup(&self, id: u32, held: bool)
pub fn hold_popup(&self, id: u32, held: bool)
While held, popup id’s countdown stops, as for the pointer over
it; false resumes it with the time it had left. A popup replaced
while held stays held, with its whole timeout left. A reload resumes
every held popup, since the window that held it is gone. An unknown
id is ignored.
Sourcepub fn hide_popup(&self, id: u32)
pub fn hide_popup(&self, id: u32)
Ends popup id now, as if its time ran out: it leaves
popups and stays in list, and its
app isn’t told. A transient one goes from the list too, and its app
and on_closed hear CloseReason::Expired. An
unknown id is ignored.
Sourcepub fn popup_time_left(&self, id: u32) -> Option<(Duration, Duration)>
pub fn popup_time_left(&self, id: u32) -> Option<(Duration, Duration)>
Popup id’s time left and its whole timeout, to draw a countdown
bar of left / whole. The time left stops while
hold_popup holds it. None for a popup that
shows until dismissed or expires at once, or one not showing. It
isn’t a signal, so read it in a binding that cx.frames ticks while
the popup counts.
use crabshell_reactive::{Memo, Signal};
use crabshell_services::ServicesExt;
use crabshell_ui::Cx;
/// How full popup `id`'s countdown bar is, from 1 down to 0. It stops
/// while `hovered`, which the toast's button writes, and nothing
/// ticks then, or for a popup that never expires.
fn countdown(cx: &Cx, id: u32, hovered: Signal<bool>) -> Memo<f32> {
let notifications = cx.notifications();
let held = notifications.clone();
cx.effect(move || held.hold_popup(id, hovered.get()));
let (counting, popups) = (notifications.clone(), notifications.popups());
// Read again when a replacement gives the popup a new timeout.
let time = cx.frames(move || {
!hovered.get() && popups.with(|_| counting.popup_time_left(id).is_some())
});
cx.memo(move || {
time.get();
// A replacement while held fills the bar again with no frame ticking.
popups.with(|_| ());
let left = notifications.popup_time_left(id);
left.map_or(1.0, |(left, whole)| left.as_secs_f32() / whole.as_secs_f32())
})
}Sourcepub fn dismiss(&self, id: u32)
pub fn dismiss(&self, id: u32)
Takes notification id away, as the user’s close button does, and
tells its app. An unknown id is ignored.
Sourcepub fn invoke(&self, id: u32, key: &str)
pub fn invoke(&self, id: u32, key: &str)
Tells notification id’s app that the user picked its action
key, then takes it away unless it is resident. An unknown id or
key is logged.
Sourcepub fn set_body_markup(&self, on: bool)
pub fn set_body_markup(&self, on: bool)
When on, the server tells apps it shows body-markup and
body-hyperlinks, so they send the spec’s markup, and keeps each body
as sent, for Text::rich(parse_markup(&body)). Off by default, when
tags are taken out. Notifications already kept stay as they came.
Sourcepub fn on_closed(&self, handler: impl Fn(&Notification, CloseReason) + 'static)
pub fn on_closed(&self, handler: impl Fn(&Notification, CloseReason) + 'static)
Calls handler with each notification that leaves the history and
why, as Quickshell’s Notification.closed, for as long as the
context cx.notifications() was called on lives. It runs on the
main thread once the lists no longer show it. A popup that times out
stays in the history, so it hasn’t closed, unless it is transient.
If it panics, that is logged with where on_closed was called, and
it isn’t called again. Called on a handle whose context went, it
logs that and does nothing.
Sourcepub fn on_notification(&self, handler: impl Fn(&Notification) + 'static)
pub fn on_notification(&self, handler: impl Fn(&Notification) + 'static)
Calls handler with each notification as it arrives or is replaced,
as Quickshell’s onNotification, for as long as the context
cx.notifications() was called on lives. It runs on the main thread
before popups shows it, so a
hide_popup inside it, for do not disturb, means
it never pops up and only joins list.
If it panics, that is logged with where on_notification was
called, and it isn’t called again. Called on a handle whose context
went, it logs that and does nothing.