Struct Sense 

pub struct Sense {
    pub click: bool,
    pub drag: bool,
    pub hover: bool,
    pub focus: bool,
}

What interactions a widget is sensitive to

Using CLICK_AND_DRAG introduces latency to distinguish click vs drag intent.

Fields

click: bool

Widget responds to clicks

drag: bool

Widget responds to drags

hover: bool

Widget tracks hover state

focus: bool

Widget can receive keyboard focus

Implementations

impl Sense

pub const NONE: Sense

No interactions at all

pub const HOVER: Sense

Only hover detection

pub const CLICK: Sense

Click and hover (for buttons, checkboxes)

pub const DRAG: Sense

Drag and hover (for sliders, scrollbars)

pub const CLICK_AND_DRAG: Sense

Both click and drag (introduces latency)

pub const FOCUSABLE: Sense

Can receive keyboard focus but no mouse interaction

pub const ALL: Sense

Full interaction - click, drag, hover, focus

impl Sense

pub fn none() -> Self

Create empty sense (no interactions)

pub fn hover() -> Self

Create hover-only sense

pub fn click() -> Self

Create click sense (includes hover)

pub fn drag() -> Self

Create drag sense (includes hover)

pub fn click_and_drag() -> Self

Create click and drag sense (includes hover, introduces latency)

pub fn focusable() -> Self

Create focusable sense (for keyboard navigation)

pub fn all() -> Self

Create full interaction sense

impl Sense

pub fn union(self, other: Sense) -> Sense

Union of two senses (OR)

pub fn intersection(self, other: Sense) -> Sense

Intersection of two senses (AND)

pub fn with_click(self) -> Self

Add click sensing (also adds hover)

pub fn with_drag(self) -> Self

Add drag sensing (also adds hover)

pub fn with_focus(self) -> Self

Add focus capability

impl Sense

pub fn interactive(&self) -> bool

Check if any interaction is sensed (click, drag, or focus)

pub fn has_click_and_drag(&self) -> bool

Check if both click and drag are sensed (has latency)

pub fn is_passive(&self) -> bool

Check if widget is purely visual (no interactions)

Trait Implementations

impl BitOr for Sense

fn bitor(self, rhs: Self) -> Self::Output

Combine two senses using the | operator (equivalent to union)

type Output = Sense

The resulting type after applying the | operator.

impl BitOrAssign for Sense

fn bitor_assign(&mut self, rhs: Self)

Combine this sense with another using |=

impl Clone for Sense

fn clone(&self) -> Sense

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sense

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

Formats the value using the given formatter.

impl Default for Sense

fn default() -> Sense

Returns the “default value” for a type.

impl Hash for Sense

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Sense

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Sense

impl Eq for Sense

impl StructuralPartialEq for Sense