pub fn process_events(&mut self, input_events: Vec<InputEvent>) {
        let mut dispatcher = self.event_dispatcher.to_owned();
        dispatcher.process_events(input_events, self);
        self.event_dispatcher = dispatcher;
    }
/// Processes the given input events
///
/// Events are processed in three phases: Capture, Target, Propagate. These phases are based on their
/// associated [W3 specifications](https://www.w3.org/TR/uievents/#dom-event-architecture).
///
/// ## Capture:
/// Currently, we do not support the Capture Phase. This is because the current event handling system is
///   made to handle events as a single enum. To achieve proper capturing, widgets would need to be able to
///   register separate event handlers so that specific ones could be captured while others would not. It
///   should generally be okay to skip this as it's not a common use-case.
///
/// ## Target:
///   The Target Phase simply identifies the target for an event so that we can generate the propagation path
///   for it.
///
/// ## Propagate:
///   The Propagate Phase (also known as the Bubble Phase) is where we bubble up the tree from the target node,
///   firing the bubbled event along the way. At any point, the bubbling can be stopped by calling
///   [`event.stop_propagation()`](Event::stop_propagation). Not every event can be propagated, in which case,
///   they will only fire for their specified target.
Processes the given input events
Events are processed in three phases: Capture, Target, Propagate. These phases are based on their
associated [W3 specifications].
Processes the given input events Events are processed in three phases : Capture Target Propagate . These phases are based on their associated [ W3 specifications ] .
pub fn process_events(&mut self, input_events: Vec<InputEvent>) {
        let mut dispatcher = self.event_dispatcher.to_owned();
        dispatcher.process_events(input_events, self);
        self.event_dispatcher = dispatcher;
    }
pub fn process_events ( & mut self , input_events : Vec < InputEvent > ) { let mut dispatcher = self . event_dispatcher . to_owned ( ) ; dispatcher . process_events ( input_events , self ) ; self . event_dispatcher = dispatcher ; }
Processes the given input events
Events are processed in three phases: Capture, Target, Propagate.
Processes the given input events Events are processed in three phases : Capture Target Propagate .
&mut self
input_events
Vec<InputEvent>
&mut self
input_events
Vec<InputEvent>
capture:
Currently, we do not support the Capture Phase. This is because the current event handling system is
made to handle events as a single enum. To achieve proper capturing, widgets would need to be able to
register separate event handlers so that specific ones could be captured while others would not. It
should generally be okay to skip this as it's not a common use-case.
Currently we do not support the Capture Phase . This is because the current event handling system is made to handle events as a single enum . To achieve proper capturing widgets would need to be able to register separate event handlers so that specific ones could be captured while others would not . It should generally be okay to skip this as it ' s not a common use - case .
target:
The Target Phase simply identifies the target for an event so that we can generate the propagation path
for it.
The Target Phase simply identifies the target for an event so that we can generate the propagation path for it .
propagate:
The Propagate Phase (also known as the Bubble Phase) is where we bubble up the tree from the target node,
firing the bubbled event along the way. At any point, the bubbling can be stopped by calling
[`event.stop_propagation()`](Event::stop_propagation). Not every event can be propagated, in which case,
they will only fire for their specified target.
The Propagate Phase ( also known as the Bubble Phase ) is where we bubble up the tree from the target node firing the bubbled event along the way . At any point the bubbling can be stopped by calling [ ` event . stop_propagation () ` ] ( Event :: stop_propagation ) . Not every event can be propagated in which case they will only fire for their specified target .