Enum EventPayload 

pub enum EventPayload<'a> {
    Clicked,
    TextChanged(&'a str),
    TextSubmitted(&'a str),
    FocusLost,
    ProtocolError {
        code: u32,
        message: &'a str,
    },
    KeyDown {
        key: Key,
        shift_key: bool,
        ctrl_key: bool,
        alt_key: bool,
        meta_key: bool,
    },
    RangeRequested {
        start: u32,
        count: u32,
    },
    ValueChanged(f64),
    WindowSizeChanged {
        width_dp: f32,
        height_dp: f32,
        class: WindowSizeClass,
        height_class: WindowHeightClass,
    },
    FilesEntered,
    FilesDropped(&'a str),
    DesignSystemResolved(DesignSystem),
    Resync,
    LifecycleStart,
    LifecycleStop,
    NotificationActivated {
        action: u32,
        key: &'a str,
    },
    NotificationPermissionChanged(NotificationPermission),
}

Variants

Clicked

TextChanged(&'a str)

TextSubmitted(&'a str)

FocusLost

ProtocolError

Fields

code: u32

message: &'a str

KeyDown

Fields

key: Key

shift_key: bool

ctrl_key: bool

alt_key: bool

meta_key: bool

RangeRequested

The Renderer asks the Host to materialise the visible item range.

Fields

start: u32

count: u32

ValueChanged(f64)

A control’s new value, in the widget’s own unit: an epoch count for a picker, a position for a slider, 0.0 or 1.0 for a toggle. The Renderer decided how the user reached it, so nothing about calendars, wheels, tracks or thumbs crosses here.

One f64 holds all of them: integers up to 2^53 survive it exactly, so splitting the event in two would only give the same concept two names.

WindowSizeChanged

The window, or one observed node, moved into a different size class. The Renderer measures it and sends this only when a class changes, never on every layout pass. A node_id of 0 is the window; anything else is the node that asked to be measured.

Fields

width_dp: f32

height_dp: f32

class: WindowSizeClass

height_class: WindowHeightClass

FilesEntered

Files are over a node that said it would take them. Nothing about what they are: the platforms disagree about what is knowable before a drop, and a screen that only needs to light up does not need to know.

FilesDropped(&'a str)

Files were let go over a node. The paths arrive together, separated by a byte no path on any of the three desktops may contain.

DesignSystemResolved(DesignSystem)

The Renderer resolved the theme and this is what it chose. Sent once and then only when the answer changes, the same way a size class is.

Resync

The Renderer lost its node table and asks for the whole tree again. A recreated Activity is the case that produces it.

LifecycleStart

The platform brought the UI back. Timers and animations resume.

LifecycleStop

The platform stopped the UI. Timers and animations are suppressed, so a process that is not on screen is not asked to draw.

NotificationActivated

The user pressed a notification the application posted. action is 0 for the body and 1 or 2 for an action button; key is the name the application gave it.

A name rather than a handler, because a notification outlives the component that posted it by hours and a callback dies with its scope.

Fields

action: u32

key: &'a str

NotificationPermissionChanged(NotificationPermission)

Whether notifications may be shown, sent once after start and then only when the answer changes.

Trait Implementations

impl<'a> Clone for EventPayload<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for EventPayload<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for EventPayload<'a>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for EventPayload<'a>