use bevy::{
prelude::{Component, Entity, KeyCode, World},
utils::{HashMap, HashSet},
};
use crate::{
context::KayakRootContext,
cursor::{CursorEvent, PointerEvents, ScrollEvent, ScrollUnit},
event::{Event, EventType},
focus_tree::FocusTree,
input_event::{InputEvent, InputEventCategory},
keyboard_event::{KeyboardEvent, KeyboardModifiers},
layout::Rect,
node::{Node, WrappedIndex},
on_event::OnEvent,
prelude::KayakWidgetContext,
styles::{ComputedStyles, KStyle, RenderCommand},
Focusable,
};
type EventMap = HashMap<WrappedIndex, HashSet<EventType>>;
type TreeNode = (
// The node ID
WrappedIndex,
// The node depth
isize,
);
#[derive(Debug, Clone)]
struct EventState {
best_z_index: f32,
best_match: Option<WrappedIndex>,
best_depth: isize,
}
impl Default for EventState {
fn default() -> Self {
Self {
best_z_index: f32::NEG_INFINITY,
best_match: None,
best_depth: -1,
}
}
}
#[derive(Component, Debug, Clone, Default)]
pub struct EventDispatcher {
is_mouse_pressed: bool,
next_mouse_pressed: bool,
current_mouse_position: (f32, f32),
next_mouse_position: (f32, f32),
previous_events: EventMap,
keyboard_modifiers: KeyboardModifiers,
// pub last_clicked: Binding<WrappedIndex>,
contains_cursor: Option<bool>,
wants_cursor: Option<bool>,
has_cursor: Option<WrappedIndex>,
pub(crate) cursor_capture: Option<WrappedIndex>,
pub(crate) hovered: Option<WrappedIndex>,
}
impl EventDispatcher {
pub(crate) fn new() -> Self {
Self {
// last_clicked: Binding::new(WrappedIndex(Entity::from_raw(0))),
is_mouse_pressed: Default::default(),
next_mouse_pressed: Default::default(),
current_mouse_position: Default::default(),
next_mouse_position: Default::default(),
previous_events: Default::default(),
keyboard_modifiers: Default::default(),
contains_cursor: None,
wants_cursor: None,
has_cursor: None,
cursor_capture: None,
hovered: None,
}
}
/// Returns whether the mouse is currently pressed or not
#[allow(dead_code)]
pub fn is_mouse_pressed(&self) -> bool {
self.is_mouse_pressed
}
/// Gets the current mouse position (since last mouse event)
#[allow(dead_code)]
pub fn current_mouse_position(&self) -> (f32, f32) {
self.current_mouse_position
}
/// Captures all cursor events and instead makes the given index the target
pub fn capture_cursor(&mut self, index: Entity) -> Option<WrappedIndex> {
let old = self.cursor_capture;
self.cursor_capture = Some(WrappedIndex(index));
old
}
/// Releases the captured cursor
///
/// Returns true if successful.
///
/// This will only release the cursor if the given index matches the current captor. This
/// prevents other widgets from accidentally releasing against the will of the original captor.
///
/// This check can be side-stepped if necessary by calling [`force_release_cursor`](Self::force_release_cursor)
/// instead (or by calling this method with the correct index).
pub fn release_cursor(&mut self, index: Entity) -> bool {
if self.cursor_capture == Some(WrappedIndex(index)) {
self.force_release_cursor();
true
} else {
false
}
}
/// Releases the captured cursor
///
/// Returns the index of the previous captor.
///
/// This will force the release, regardless of which widget has called it. To safely release,
/// use the standard [`release_cursor`](Self::release_cursor) method instead.
pub fn force_release_cursor(&mut self) -> Option<WrappedIndex> {
let old = self.cursor_capture;
self.cursor_capture = None;
old
}
/// Returns true if the cursor is currently over a valid widget
///
/// For the purposes of this method, a valid widget is one which has the means to display a visual component on its own.
/// This means widgets specified with [`RenderCommand::Empty`], [`RenderCommand::Layout`], or [`RenderCommand::Clip`]
/// do not meet the requirements to "contain" the cursor.
#[allow(dead_code)]
pub fn contains_cursor(&self) -> bool {
self.contains_cursor.unwrap_or_default()
}
/// Returns true if the cursor may be needed by a widget or it's already in use by one
///
/// This is useful for checking if certain events (such as a click) would "matter" to the UI at all. Example widgets
/// include buttons, sliders, and text boxes.
#[allow(dead_code)]
pub fn wants_cursor(&self) -> bool {
self.wants_cursor.unwrap_or_default() || self.has_cursor.is_some()
}
/// Returns true if the cursor is currently in use by a widget
///
/// This is most often useful for checking drag events as it will still return true even if the drag continues outside
/// the widget bounds (as long as it started within it).
#[allow(dead_code)]
pub fn has_cursor(&self) -> bool {
self.has_cursor.is_some()
}
/// The currently hovered node
#[allow(dead_code)]
pub fn hovered(&self) -> Option<WrappedIndex> {
self.hovered
}
/// Process and dispatch an [InputEvent](crate::InputEvent)
// #[allow(dead_code)]
// pub fn process_event(
// &mut self,
// input_event: InputEvent,
// context: &mut Context,
// focusable_query: &Query<&Focusable>,
// style_query: &Query<&Style>,
// on_event_query: &Query<&OnEvent>,
// ) {
// let events = self.build_event_stream(&[input_event], context, focusable_query, style_query);
// self.dispatch_events(events, context, on_event_query);
// }
/// Process and dispatch a set of [InputEvents](crate::InputEvent)
pub(crate) fn process_events(
&mut self,
input_events: &Vec<InputEvent>,
context: &mut KayakRootContext,
world: &mut World,
) {
let events = { self.build_event_stream(input_events, context, world) };
self.dispatch_events(events, context, world);
}
/// Dispatch an [Event](crate::Event)
#[allow(dead_code)]
pub fn dispatch_event(
&mut self,
event: Event,
context: &mut KayakRootContext,
world: &mut World,
) {
self.dispatch_events(vec![event], context, world);
}
/// Dispatch a set of [Events](crate::Event)
pub fn dispatch_events(
&mut self,
events: Vec<Event>,
context: &mut KayakRootContext,
world: &mut World,
) {
// === Dispatch Events === //
let mut next_events = HashMap::default();
for mut event in events {
let mut current_target: Option<WrappedIndex> = Some(WrappedIndex(event.target));
while let Some(index) = current_target {
// Create a copy of the event, specific for this node
// This is to make sure unauthorized changes to the event are not propagated
// (e.g., changing the event type, removing the target, etc.)
let mut node_event = Event {
current_target: index.0,
..event.clone()
};
// --- Update State --- //
Self::insert_event(&mut next_events, &index, node_event.event_type);
// --- Call Event --- //
if let Some(mut entity) = world.get_entity_mut(index.0) {
if let Some(mut on_event) = entity.remove::<OnEvent>() {
let mut event_dispatcher_context = EventDispatcherContext {
cursor_capture: self.cursor_capture,
};
(event_dispatcher_context, node_event) = on_event.try_call(
event_dispatcher_context,
context.widget_state.clone(),
index.0,
node_event,
world,
);
world.entity_mut(index.0).insert(on_event);
event_dispatcher_context.merge(self);
// Sometimes events will require systems to be called.
// IE OnChange
let widget_context = KayakWidgetContext::new(
context.tree.clone(),
context.context_entities.clone(),
context.layout_cache.clone(),
context.widget_state.clone(),
context.order_tree.clone(),
context.index.clone(),
None,
);
node_event.run_on_change(world, widget_context);
}
}
event.default_prevented |= node_event.default_prevented;
// --- Propagate Event --- //
if node_event.should_propagate {
if let Ok(node_tree) = context.tree.try_read() {
current_target = node_tree.get_parent(index);
} else {
current_target = None;
}
} else {
current_target = None;
}
}
if !event.default_prevented {
self.execute_default(event, context, world);
}
}
// === Maintain Events === //
// Events that need to be maintained without re-firing between event updates should be managed here
for (index, events) in &self.previous_events {
// Mouse is currently pressed for this node
if self.is_mouse_pressed && events.contains(&EventType::MouseDown(Default::default())) {
// Make sure this event isn't removed while mouse is still held down
Self::insert_event(
&mut next_events,
index,
EventType::MouseDown(Default::default()),
);
}
// Mouse is currently within this node
if events.contains(&EventType::MouseIn(Default::default()))
&& !Self::contains_event(
&next_events,
index,
&EventType::MouseOut(Default::default()),
)
{
// Make sure this event isn't removed while mouse is still within node
Self::insert_event(
&mut next_events,
index,
EventType::MouseIn(Default::default()),
);
}
}
// Replace the previous events with the next set
self.previous_events = next_events;
}
/// Generates a stream of [Events](crate::Event) from a set of [InputEvents](crate::InputEvent)
fn build_event_stream(
&mut self,
input_events: &[InputEvent],
context: &mut KayakRootContext,
world: &mut World,
) -> Vec<Event> {
let mut event_stream = Vec::<Event>::new();
let mut states: HashMap<EventType, EventState> = HashMap::new();
if let Ok(node_tree) = context.tree.try_read() {
let root = if let Some(root) = node_tree.root_node {
root
} else {
return event_stream;
};
// === Setup Cursor States === //
let old_hovered = self.hovered;
let old_contains_cursor = self.contains_cursor;
let old_wants_cursor = self.wants_cursor;
self.hovered = None;
self.contains_cursor = None;
self.wants_cursor = None;
self.next_mouse_position = self.current_mouse_position;
self.next_mouse_pressed = self.is_mouse_pressed;
// --- Pre-Process --- //
// We pre-process some events so that we can provide accurate event data (such as if the mouse is pressed)
// This is faster than resolving data after the fact since `input_events` is generally very small
for input_event in input_events {
if let InputEvent::MouseMoved(point) = input_event {
// Reset next global mouse position
self.next_mouse_position = *point;
}
if matches!(input_event, InputEvent::MouseLeftPress) {
// Reset next global mouse pressed
self.next_mouse_pressed = true;
break;
} else if matches!(input_event, InputEvent::MouseLeftRelease) {
// Reset next global mouse pressed
self.next_mouse_pressed = false;
// Reset global cursor container
self.has_cursor = None;
break;
}
}
// === Mouse Events === //
if let Some(captor) = self.cursor_capture {
// A widget has been set to capture pointer events -> it should be the only one receiving events
for input_event in input_events {
// --- Process Event --- //
if matches!(input_event.category(), InputEventCategory::Mouse) {
// A widget's PointerEvents style will determine how it and its children are processed
let pointer_events = Self::resolve_pointer_events(captor, world);
match pointer_events {
PointerEvents::All | PointerEvents::SelfOnly => {
let events = self.process_pointer_events(
input_event,
(captor, 0),
&mut states,
world,
context,
true,
);
event_stream.extend(events);
}
_ => {}
}
}
}
} else {
// No capturing widget -> process cursor events as normal
let mut stack: Vec<TreeNode> = vec![(root, 0)];
while !stack.is_empty() {
let (current, depth) = stack.pop().unwrap();
let mut enter_children = true;
if let Some(entity_ref) = world.get_entity(current.0) {
if entity_ref.contains::<OnEvent>() {
for input_event in input_events {
// --- Process Event --- //
if matches!(input_event.category(), InputEventCategory::Mouse) {
// A widget's PointerEvents style will determine how it and its children are processed
let pointer_events =
Self::resolve_pointer_events(current, world);
match pointer_events {
PointerEvents::All | PointerEvents::SelfOnly => {
let events = self.process_pointer_events(
input_event,
(current, depth),
&mut states,
world,
context,
false,
);
event_stream.extend(events);
if matches!(pointer_events, PointerEvents::SelfOnly) {
enter_children = false;
}
}
PointerEvents::None => enter_children = false,
PointerEvents::ChildrenOnly => {}
}
}
}
}
}
// --- Push Children to Stack --- //
if enter_children {
if let Some(children) = node_tree.children.get(¤t) {
let mut stack_children = Vec::new();
for child in children {
let child_z = world
.entity(child.0)
.get::<Node>()
.map(|node| node.z)
.unwrap_or(0.0);
stack_children.push((child_z, (*child, depth + 1)));
}
stack_children.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
stack.extend(stack_children.iter().map(|c| c.1));
}
}
}
}
if let Ok(mut focus_tree) = context.focus_tree.try_write() {
// === Keyboard Events === //
for input_event in input_events {
// Keyboard events only care about the currently focused widget so we don't need to run this over every node in the tree
let events =
self.process_keyboard_events(input_event, &mut states, &focus_tree);
event_stream.extend(events);
}
// === Additional Events === //
let mut had_focus_event = false;
// These events are ones that require a specific target and need the tree to be evaluated before selecting the best match
for (event_type, state) in states {
if let Some(node) = state.best_match {
event_stream.push(Event::new(node.0, event_type));
match event_type {
EventType::Focus => {
had_focus_event = true;
if let Some(current_focus) = focus_tree.current() {
if current_focus != node {
event_stream
.push(Event::new(current_focus.0, EventType::Blur));
}
}
focus_tree.focus(node);
}
EventType::Hover(..) => {
self.hovered = Some(node);
}
_ => {}
}
}
}
// --- Blur Event --- //
if !had_focus_event && input_events.contains(&InputEvent::MouseLeftPress) {
// A mouse press didn't contain a focus event -> blur
if let Some(current_focus) = focus_tree.current() {
event_stream.push(Event::new(current_focus.0, EventType::Blur));
focus_tree.blur();
}
}
// === Process Cursor States === //
self.current_mouse_position = self.next_mouse_position;
self.is_mouse_pressed = self.next_mouse_pressed;
if self.hovered.is_none() {
// No change -> revert
self.hovered = old_hovered;
}
if self.contains_cursor.is_none() {
// No change -> revert
self.contains_cursor = old_contains_cursor;
}
if self.wants_cursor.is_none() {
// No change -> revert
self.wants_cursor = old_wants_cursor;
}
}
}
event_stream
}
/// Process the pointer-related events of an input event
///
/// # Arguments
///
/// * `input_event`: The input event
/// * `tree_node`: The current node to process
/// * `states`: The map of events to their current state (for selecting best fit)
/// * `widget_manager`: The widget manager
/// * `ignore_layout`: Whether to ignore layout (useful for handling captured events)
///
/// returns: Vec<Event>
fn process_pointer_events(
&mut self,
input_event: &InputEvent,
tree_node: TreeNode,
states: &mut HashMap<EventType, EventState>,
world: &mut World,
context: &KayakRootContext,
ignore_layout: bool,
) -> Vec<Event> {
let mut event_stream = Vec::<Event>::new();
let (node, depth) = tree_node;
// let widget_name = world.entity(node.0).get::<WidgetName>();
// dbg!(widget_name);
match input_event {
InputEvent::MouseMoved(point) => {
if let Some(layout) = context.get_layout(&node) {
let cursor_event = self.get_cursor_event(*point);
let was_contained = layout.contains(&self.current_mouse_position);
let is_contained = layout.contains(point);
if !ignore_layout && was_contained != is_contained {
if was_contained {
// Mouse out should fire even when
event_stream
.push(Event::new(node.0, EventType::MouseOut(cursor_event)));
// Self::update_state(
// states,
// (node, depth),
// &layout,
// EventType::MouseOut(cursor_event),
// );
} else {
// event_stream.push(Event::new(node.0, EventType::MouseIn(cursor_event)));
Self::update_state(
states,
(node, depth),
&layout,
EventType::MouseIn(cursor_event),
);
}
}
if self.contains_cursor.is_none() || !self.contains_cursor.unwrap_or_default() {
if let Some(styles) = world.get::<ComputedStyles>(node.0) {
// Check if the cursor moved onto a widget that qualifies as one that can contain it
if ignore_layout || Self::can_contain_cursor(&styles.0) {
self.contains_cursor = Some(is_contained);
}
}
}
if self.wants_cursor.is_none() || !self.wants_cursor.unwrap_or_default() {
let focusable = world.get::<Focusable>(node.0).is_some();
// Check if the cursor moved onto a focusable widget (i.e. one that would want it)
if focusable {
self.wants_cursor = Some(is_contained);
}
}
// Check for hover eligibility
if ignore_layout || is_contained {
Self::update_state(
states,
(node, depth),
&layout,
EventType::Hover(cursor_event),
);
}
}
}
InputEvent::MouseLeftPress => {
if let Some(layout) = context.get_layout(&node) {
if ignore_layout || layout.contains(&self.current_mouse_position) {
let cursor_event = self.get_cursor_event(self.current_mouse_position);
// event_stream.push(Event::new(node.0, EventType::MouseDown(cursor_event)));
Self::update_state(
states,
(node, depth),
&layout,
EventType::MouseDown(cursor_event),
);
if world.get::<Focusable>(node.0).is_some() {
Self::update_state(states, (node, depth), &layout, EventType::Focus);
}
if self.has_cursor.is_none() {
if let Some(styles) = world.get::<ComputedStyles>(node.0) {
// Check if the cursor moved onto a widget that qualifies as one that can contain it
if Self::can_contain_cursor(&styles.0) {
self.has_cursor = Some(node);
}
}
}
}
}
}
InputEvent::MouseLeftRelease => {
if let Some(layout) = context.get_layout(&node) {
if ignore_layout || layout.contains(&self.current_mouse_position) {
let cursor_event = self.get_cursor_event(self.current_mouse_position);
// event_stream.push(Event::new(node.0, EventType::MouseUp(cursor_event)));
Self::update_state(
states,
(node, depth),
&layout,
EventType::MouseUp(cursor_event),
);
// self.last_clicked.set(node);
if Self::contains_event(
&self.previous_events,
&node,
&EventType::MouseDown(cursor_event),
) {
Self::update_state(
states,
(node, depth),
&layout,
EventType::Click(cursor_event),
);
}
}
}
}
InputEvent::Scroll { dx, dy, is_line } => {
if let Some(layout) = context.get_layout(&node) {
// Check for scroll eligibility
if ignore_layout || layout.contains(&self.current_mouse_position) {
Self::update_state(
states,
(node, depth),
&layout,
EventType::Scroll(ScrollEvent {
delta: if *is_line {
ScrollUnit::Line { x: *dx, y: *dy }
} else {
ScrollUnit::Pixel { x: *dx, y: *dy }
},
}),
);
}
}
}
_ => {}
}
event_stream
}
fn resolve_pointer_events(index: WrappedIndex, world: &mut World) -> PointerEvents {
let mut pointer_events = PointerEvents::default();
if let Some(styles) = world.get::<ComputedStyles>(index.0) {
pointer_events = styles.0.pointer_events.resolve();
}
pointer_events
}
fn get_cursor_event(&self, position: (f32, f32)) -> CursorEvent {
let change = self.next_mouse_pressed != self.is_mouse_pressed;
let pressed = self.next_mouse_pressed;
CursorEvent {
position,
pressed,
just_pressed: change && pressed,
just_released: change && !pressed,
}
}
fn process_keyboard_events(
&mut self,
input_event: &InputEvent,
_states: &mut HashMap<EventType, EventState>,
focus_tree: &FocusTree,
) -> Vec<Event> {
let mut event_stream = Vec::new();
if let Some(current_focus) = focus_tree.current() {
match input_event {
InputEvent::CharEvent { c } => {
event_stream.push(Event::new(current_focus.0, EventType::CharInput { c: *c }))
}
InputEvent::Keyboard { key, is_pressed } => {
// === Modifers === //
match key {
KeyCode::LControl | KeyCode::RControl => {
self.keyboard_modifiers.is_ctrl_pressed = *is_pressed
}
KeyCode::LShift | KeyCode::RShift => {
self.keyboard_modifiers.is_shift_pressed = *is_pressed
}
KeyCode::LAlt | KeyCode::RAlt => {
self.keyboard_modifiers.is_alt_pressed = *is_pressed
}
KeyCode::LWin | KeyCode::RWin => {
self.keyboard_modifiers.is_meta_pressed = *is_pressed
}
_ => {}
}
// === Event === //
if *is_pressed {
event_stream.push(Event::new(
current_focus.0,
EventType::KeyDown(KeyboardEvent::new(*key, self.keyboard_modifiers)),
))
} else {
event_stream.push(Event::new(
current_focus.0,
EventType::KeyUp(KeyboardEvent::new(*key, self.keyboard_modifiers)),
))
}
}
_ => {}
}
}
event_stream
}
/// Updates the state data for the given event
fn update_state(
states: &mut HashMap<EventType, EventState>,
tree_node: TreeNode,
layout: &Rect,
event_type: EventType,
) {
let state = states.entry(event_type).or_default();
let (node, depth) = tree_node;
// Node is at or above best depth and is at or above best z-level
let mut should_update = depth >= state.best_depth && layout.z_index >= state.best_z_index;
// OR node is above best z-level
should_update |= layout.z_index >= state.best_z_index;
if should_update {
// dbg!(node.0.id(), layout.z_index);
state.best_match = Some(node);
state.best_z_index = layout.z_index;
state.best_depth = depth;
}
}
/// Checks if the given event map contains a specific event for the given widget
fn contains_event(events: &EventMap, widget_id: &WrappedIndex, event_type: &EventType) -> bool {
if let Some(entry) = events.get(widget_id) {
entry.contains(event_type)
} else {
false
}
}
/// Insert an event for a widget in the given event map
fn insert_event(
events: &mut EventMap,
widget_id: &WrappedIndex,
event_type: EventType,
) -> bool {
let entry = events.entry(*widget_id).or_default();
entry.insert(event_type)
}
/// Checks if the given widget is eligible to "contain" the cursor (i.e. the cursor is considered contained when hovering over it)
///
/// Currently a valid widget is defined as one where:
/// * RenderCommands is neither `Empty` nor `Layout` nor `Clip`
fn can_contain_cursor(widget_styles: &KStyle) -> bool {
let cmds = widget_styles.render_command.resolve();
!matches!(
cmds,
RenderCommand::Empty | RenderCommand::Layout | RenderCommand::Clip
)
}
/// Executes default actions for events
fn execute_default(&mut self, event: Event, context: &mut KayakRootContext, world: &mut World) {
match event.event_type {
EventType::KeyDown(evt) => match evt.key() {
KeyCode::Tab => {
let (index, current_focus) =
if let Ok(mut focus_tree) = context.focus_tree.try_write() {
let current_focus = focus_tree.current();
let index = if evt.is_shift_pressed() {
focus_tree.prev()
} else {
focus_tree.next()
};
(index, current_focus)
} else {
(None, None)
};
if let Some(index) = index {
let mut events = vec![Event::new(index.0, EventType::Focus)];
if let Some(current_focus) = current_focus {
if current_focus != index {
events.push(Event::new(current_focus.0, EventType::Blur));
}
}
if let Ok(mut focus_tree) = context.focus_tree.try_write() {
focus_tree.focus(index);
}
self.dispatch_events(events, context, world);
}
}
_ => {}
},
_ => {}
}
}
/// Merge this `EventDispatcher` with another, taking only the internally mutated data.
///
/// This is meant to solve the issue in `Context`, where [`EventDispatcher::process_events`] and
/// similar methods require mutable access to `Context`, forcing `EventDispatcher` to be cloned
/// before running the method. However, some data mutated through `Context` may be lost when
/// re-claiming the `EventDispatcher`. This method ensures that data mutated in such a way will not be
/// overwritten during the merge.
///
/// # Arguments
///
/// * `from`: The other `EventDispatcher` to merge from
///
/// returns: ()
pub fn merge(&mut self, from: EventDispatcher) {
// Merge only what could be changed internally. External changes (i.e. from Context)
// should not be touched
// self.last_clicked = from.last_clicked;
self.is_mouse_pressed = from.is_mouse_pressed;
self.next_mouse_pressed = from.next_mouse_pressed;
self.current_mouse_position = from.current_mouse_position;
self.next_mouse_position = from.next_mouse_position;
self.previous_events = from.previous_events;
self.keyboard_modifiers = from.keyboard_modifiers;
self.contains_cursor = from.contains_cursor;
self.wants_cursor = from.wants_cursor;
self.has_cursor = from.has_cursor;
self.hovered = from.hovered;
// Do not include:
// self.cursor_capture = from.cursor_capture;
}
}
pub struct EventDispatcherContext {
cursor_capture: Option<WrappedIndex>,
}
impl EventDispatcherContext {
/// Captures all cursor events and instead makes the given index the target
pub fn capture_cursor(&mut self, index: Entity) -> Option<WrappedIndex> {
let old = self.cursor_capture;
self.cursor_capture = Some(WrappedIndex(index));
old
}
/// Releases the captured cursor
///
/// Returns true if successful.
///
/// This will only release the cursor if the given index matches the current captor. This
/// prevents other widgets from accidentally releasing against the will of the original captor.
///
/// This check can be side-stepped if necessary by calling [`force_release_cursor`](Self::force_release_cursor)
/// instead (or by calling this method with the correct index).
pub fn release_cursor(&mut self, index: Entity) -> bool {
if self.cursor_capture == Some(WrappedIndex(index)) {
self.force_release_cursor();
true
} else {
false
}
}
/// Releases the captured cursor
///
/// Returns the index of the previous captor.
///
/// This will force the release, regardless of which widget has called it. To safely release,
/// use the standard [`release_cursor`](Self::release_cursor) method instead.
pub fn force_release_cursor(&mut self) -> Option<WrappedIndex> {
let old = self.cursor_capture;
self.cursor_capture = None;
old
}
pub(crate) fn merge(self, event_dispatcher: &mut EventDispatcher) {
event_dispatcher.cursor_capture = self.cursor_capture;
}
}