Struct SyntheticEvent 

pub struct SyntheticEvent {
    pub event_type: EventType,
    pub source: EventSource,
    pub phase: EventPhase,
    pub target: DomNodeId,
    pub current_target: DomNodeId,
    pub timestamp: Instant,
    pub data: EventData,
    pub stopped: bool,
    pub stopped_immediate: bool,
    pub prevented_default: bool,
}

Unified event wrapper (similar to React’s SyntheticEvent).

All events in the system are wrapped in this structure, providing a consistent interface and enabling event propagation control.

Fields

event_type: EventType

The type of event

source: EventSource

Where the event came from

phase: EventPhase

Current propagation phase

target: DomNodeId

Target node that the event was dispatched to

current_target: DomNodeId

Current node in the propagation path

timestamp: Instant

Timestamp when event was created

data: EventData

Type-specific event data

stopped: bool

Whether propagation has been stopped

stopped_immediate: bool

Whether immediate propagation has been stopped

prevented_default: bool

Whether default action has been prevented

Implementations

impl SyntheticEvent

pub fn new( event_type: EventType, source: EventSource, target: DomNodeId, timestamp: Instant, data: EventData, ) -> Self

Create a new synthetic event.

Parameters

• timestamp: Current time from (system_callbacks.get_system_time_fn.cb)()

pub fn stop_propagation(&mut self)

Stop event propagation after the current phase completes.

This prevents the event from reaching handlers in subsequent phases (e.g., stopping during capture prevents bubble phase).

pub fn stop_immediate_propagation(&mut self)

Stop event propagation immediately.

This prevents any further handlers from being called, even on the current target element.

pub fn prevent_default(&mut self)

Prevent the default action associated with this event.

For example, prevents form submission on Enter key, or prevents text selection on drag.

pub fn is_propagation_stopped(&self) -> bool

Check if propagation was stopped.

pub fn is_immediate_propagation_stopped(&self) -> bool

Check if immediate propagation was stopped.

pub fn is_default_prevented(&self) -> bool

Check if default action was prevented.

Trait Implementations

impl Clone for SyntheticEvent

fn clone(&self) -> SyntheticEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyntheticEvent

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

Formats the value using the given formatter.

impl PartialEq for SyntheticEvent

fn eq(&self, other: &SyntheticEvent) -> 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 StructuralPartialEq for SyntheticEvent