Struct Transient 

pub struct Transient<T> { /* private fields */ }

A message an app shows over its content for a while. It is one of two kinds:

• plain information (a confirmation, a status, a failure, Self::show) stops reporting once it has been up for NOTICE_LIFETIME, so a message nobody takes down still leaves; showing one again starts its time over;
• progress (work under way, “Opening book.epub”, Self::show_progress) stays while the app reports the work as still running (Self::keep_while) and leaves once it no longer does, or a NOTICE_LIFETIME after it last did, so no stale progress stays.

The message shows in the window’s bar (Self::publish, on every sync): the app asks to be woken at Self::deadline and, there, renews progress and calls Self::expire. A message that needs the person to act before it goes is not a transient one.

Implementations

impl<T> Transient<T>

pub const fn new() -> Transient<T>

pub fn publish(&self, notice: impl FnOnce(&T) -> ToolbarNotice)

Show the message in the window’s bar while it lasts, as notice says it, and take it down once it has gone; call on every sync. A notice shown since from elsewhere in the window stays: the newest replaces the older.

pub fn showing(value: T) -> Transient<T>

value, shown from now as plain information.

pub fn showing_progress(value: T) -> Transient<T>

value, shown from now as progress of work under way.

pub fn show(&mut self, value: T)

Show value as plain information, replacing anything already up, for a full lifetime.

pub fn show_progress(&mut self, value: T)

Show value as progress of work under way, replacing anything already up: it stays while Self::keep_while reports the work running.

pub fn keep_while(&mut self, busy: bool) -> bool

Report whether the work a progress message follows is still running, on every sync: while it is the message stays, once it is not the message goes. Plain information keeps its own time. Whether a message went.

pub fn is_progress(&self) -> bool

Whether the message up is progress of work under way.

pub fn dismiss(&mut self) -> bool

Take the message down; whether one was up.

pub fn get(&self) -> Option<&T>

The message, while its lifetime lasts.

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>

where T: Deref,

The message borrowed through its Deref (a String as a &str).

pub fn is_shown(&self) -> bool

pub fn since(&self) -> Option<Instant>

When the message’s time started, while it is up: when it went up, or, for progress, when the work was last reported running.

pub fn expire(&mut self) -> bool

Drop the message once its lifetime is over; whether it did.

pub fn deadline(&self) -> Option<Instant>

When the message leaves (progress: when it must next be renewed), for a widget’s next_wake_deadline. It stays due while the window’s bar still shows the message, so the frame that takes it down runs at that time without further input; once a sync has published its leaving there is none, so the widget is not woken over and over. Under the capture clock nothing leaves.

Trait Implementations

impl<T> Clone for Transient<T>

where T: Clone,

A copy keeps the message but not the bar’s notice: the original took it up and takes it down.

fn clone(&self) -> Transient<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Transient<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Transient<T>

fn default() -> Transient<T>

Returns the “default value” for a type.

impl<T> Drop for Transient<T>

A message gone with its owner leaves the window’s bar with it.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.