use super::ElementHostWidget;
use crate::declarative::prelude::*;
use fret_runtime::DragHost;
use std::sync::Arc;
fn position_local(bounds: Rect, mapped: Point) -> Point {
Point::new(
fret_core::Px(mapped.x.0 - bounds.origin.x.0),
fret_core::Px(mapped.y.0 - bounds.origin.y.0),
)
}
#[derive(Debug, Default, Clone, Copy)]
struct PressablePressTracking {
pointer_id: Option<fret_core::PointerId>,
down_position: Option<Point>,
down_hit_is_text_input: bool,
down_hit_pressable_target: Option<crate::GlobalElementId>,
down_hit_pressable_target_in_descendant_subtree: bool,
}
pub(super) fn handle_pressable<H: UiHost>(
this: &mut ElementHostWidget,
cx: &mut EventCx<'_, H>,
window: AppWindowId,
props: PressableProps,
event: &Event,
) {
if !props.enabled {
return;
}
let pixels_per_point = cx
.app
.global::<fret_core::WindowMetricsService>()
.and_then(|svc| svc.scale_factor(window))
.unwrap_or(1.0);
struct PressablePointerHookHost<'a, H: UiHost> {
app: &'a mut H,
window: AppWindowId,
element: crate::GlobalElementId,
node: NodeId,
bounds: Rect,
source_test_id: Option<Arc<str>>,
input_ctx: &'a fret_runtime::InputContext,
prevented_default_actions: &'a mut fret_runtime::DefaultActionSet,
requested_focus_target: &'a mut Option<crate::GlobalElementId>,
requested_capture: &'a mut Option<Option<NodeId>>,
requested_cursor: &'a mut Option<fret_core::CursorIcon>,
notify_requested: &'a mut bool,
notify_requested_location: &'a mut Option<crate::widget::UiSourceLocation>,
invalidations: &'a mut Vec<(NodeId, Invalidation)>,
}
impl<H: UiHost> action::UiActionHost for PressablePointerHookHost<'_, H> {
fn models_mut(&mut self) -> &mut fret_runtime::ModelStore {
self.app.models_mut()
}
fn push_effect(&mut self, effect: Effect) {
match effect {
Effect::SetTimer {
window: Some(window),
token,
..
} if window == self.window => {
crate::elements::record_timer_target(
&mut *self.app,
window,
token,
self.element,
);
}
Effect::CancelTimer { token } => {
crate::elements::clear_timer_target(&mut *self.app, self.window, token);
}
_ => {}
}
self.app.push_effect(effect);
}
fn request_redraw(&mut self, window: AppWindowId) {
self.app.request_redraw(window);
}
fn next_timer_token(&mut self) -> fret_runtime::TimerToken {
self.app.next_timer_token()
}
fn next_clipboard_token(&mut self) -> fret_runtime::ClipboardToken {
self.app.next_clipboard_token()
}
fn next_share_sheet_token(&mut self) -> fret_runtime::ShareSheetToken {
self.app.next_share_sheet_token()
}
fn record_transient_event(&mut self, cx: action::ActionCx, key: u64) {
crate::elements::record_transient_event(&mut *self.app, cx.window, cx.target, key);
}
fn record_pending_command_dispatch_source(
&mut self,
cx: action::ActionCx,
command: &fret_runtime::CommandId,
reason: ActivateReason,
) {
let kind = match reason {
ActivateReason::Pointer => fret_runtime::CommandDispatchSourceKindV1::Pointer,
ActivateReason::Keyboard => fret_runtime::CommandDispatchSourceKindV1::Keyboard,
};
let source = fret_runtime::CommandDispatchSourceV1 {
kind,
element: Some(cx.target.0),
test_id: self.source_test_id.clone(),
};
self.app.with_global_mut(
fret_runtime::WindowPendingCommandDispatchSourceService::default,
|svc, app| {
svc.record(cx.window, app.tick_id(), command.clone(), source);
},
);
}
#[track_caller]
fn notify(&mut self, _cx: action::ActionCx) {
*self.notify_requested = true;
if self.notify_requested_location.is_none() {
let caller = std::panic::Location::caller();
*self.notify_requested_location = Some(crate::widget::UiSourceLocation {
file: caller.file(),
line: caller.line(),
column: caller.column(),
});
}
}
}
impl<H: UiHost> action::UiFocusActionHost for PressablePointerHookHost<'_, H> {
fn request_focus(&mut self, target: crate::GlobalElementId) {
*self.requested_focus_target = Some(target);
}
}
impl<H: UiHost> action::UiPointerActionHost for PressablePointerHookHost<'_, H> {
fn bounds(&self) -> Rect {
self.bounds
}
fn capture_pointer(&mut self) {
*self.requested_capture = Some(Some(self.node));
}
fn release_pointer_capture(&mut self) {
*self.requested_capture = Some(None);
}
fn set_cursor_icon(&mut self, icon: fret_core::CursorIcon) {
if !self.input_ctx.caps.ui.cursor_icons {
return;
}
*self.requested_cursor = Some(icon);
}
fn prevent_default(&mut self, action: fret_runtime::DefaultAction) {
self.prevented_default_actions.insert(action);
}
fn invalidate(&mut self, invalidation: Invalidation) {
self.invalidations.push((self.node, invalidation));
}
}
impl<H: UiHost> action::UiDragActionHost for PressablePointerHookHost<'_, H> {
fn begin_drag_with_kind(
&mut self,
pointer_id: fret_core::PointerId,
kind: fret_runtime::DragKindId,
source_window: AppWindowId,
start: Point,
) {
DragHost::begin_drag_with_kind(
&mut *self.app,
pointer_id,
kind,
source_window,
start,
(),
);
}
fn begin_cross_window_drag_with_kind(
&mut self,
pointer_id: fret_core::PointerId,
kind: fret_runtime::DragKindId,
source_window: AppWindowId,
start: Point,
) {
DragHost::begin_cross_window_drag_with_kind(
&mut *self.app,
pointer_id,
kind,
source_window,
start,
(),
);
}
fn drag(&self, pointer_id: fret_core::PointerId) -> Option<&fret_runtime::DragSession> {
DragHost::drag(&*self.app, pointer_id)
}
fn drag_mut(
&mut self,
pointer_id: fret_core::PointerId,
) -> Option<&mut fret_runtime::DragSession> {
DragHost::drag_mut(&mut *self.app, pointer_id)
}
fn cancel_drag(&mut self, pointer_id: fret_core::PointerId) {
DragHost::cancel_drag(&mut *self.app, pointer_id);
}
}
struct PressableActionHookHost<'a, H: UiHost> {
app: &'a mut H,
window: AppWindowId,
element: crate::GlobalElementId,
source_test_id: Option<Arc<str>>,
notify_requested: &'a mut bool,
notify_requested_location: &'a mut Option<crate::widget::UiSourceLocation>,
}
impl<H: UiHost> action::UiActionHost for PressableActionHookHost<'_, H> {
fn models_mut(&mut self) -> &mut fret_runtime::ModelStore {
self.app.models_mut()
}
fn push_effect(&mut self, effect: Effect) {
match effect {
Effect::SetTimer {
window: Some(window),
token,
..
} if window == self.window => {
crate::elements::record_timer_target(
&mut *self.app,
window,
token,
self.element,
);
}
Effect::CancelTimer { token } => {
crate::elements::clear_timer_target(&mut *self.app, self.window, token);
}
_ => {}
}
self.app.push_effect(effect);
}
fn request_redraw(&mut self, window: AppWindowId) {
self.app.request_redraw(window);
}
fn next_timer_token(&mut self) -> fret_runtime::TimerToken {
self.app.next_timer_token()
}
fn next_clipboard_token(&mut self) -> fret_runtime::ClipboardToken {
self.app.next_clipboard_token()
}
fn next_share_sheet_token(&mut self) -> fret_runtime::ShareSheetToken {
self.app.next_share_sheet_token()
}
fn record_transient_event(&mut self, cx: action::ActionCx, key: u64) {
crate::elements::record_transient_event(&mut *self.app, cx.window, cx.target, key);
}
fn record_pending_command_dispatch_source(
&mut self,
cx: action::ActionCx,
command: &fret_runtime::CommandId,
reason: ActivateReason,
) {
let kind = match reason {
ActivateReason::Pointer => fret_runtime::CommandDispatchSourceKindV1::Pointer,
ActivateReason::Keyboard => fret_runtime::CommandDispatchSourceKindV1::Keyboard,
};
let source = fret_runtime::CommandDispatchSourceV1 {
kind,
element: Some(cx.target.0),
test_id: self.source_test_id.clone(),
};
self.app.with_global_mut(
fret_runtime::WindowPendingCommandDispatchSourceService::default,
|svc, app| {
svc.record(cx.window, app.tick_id(), command.clone(), source);
},
);
}
fn record_pending_action_payload(
&mut self,
cx: action::ActionCx,
action: &fret_runtime::ActionId,
payload: Box<dyn std::any::Any + Send + Sync>,
) {
self.app.with_global_mut(
fret_runtime::WindowPendingActionPayloadService::default,
|svc, app| {
svc.record(cx.window, app.tick_id(), action.clone(), payload);
},
);
}
#[track_caller]
fn notify(&mut self, _cx: action::ActionCx) {
*self.notify_requested = true;
if self.notify_requested_location.is_none() {
let caller = std::panic::Location::caller();
*self.notify_requested_location = Some(crate::widget::UiSourceLocation {
file: caller.file(),
line: caller.line(),
column: caller.column(),
});
}
}
}
match event {
Event::Pointer(pe) => match pe {
fret_core::PointerEvent::Move {
pointer_id,
position,
buttons,
modifiers,
pointer_type,
} => {
cx.set_cursor_icon(CursorIcon::Pointer);
if cx.captured == Some(cx.node)
&& !buttons.left
&& crate::elements::is_pressed_pressable(&mut *cx.app, window, this.element)
{
cx.release_pointer_capture();
if let Some(prev_node) =
crate::elements::set_pressed_pressable(&mut *cx.app, window, None)
{
cx.invalidate(prev_node, Invalidation::Paint);
}
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
}
let hook = crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
crate::action::PressableActionHooks::default,
|hooks| hooks.on_pointer_move.clone(),
);
if let Some(h) = hook {
let velocity_window = cx
.app
.global::<crate::pointer_motion::WindowPointerMotionService>()
.and_then(|svc| svc.velocity_window(window, *pointer_id));
let mv = action::PointerMoveCx {
pointer_id: *pointer_id,
position: *position,
position_local: position_local(cx.bounds, *position),
position_window: cx.event_window_position,
tick_id: cx.app.tick_id(),
pixels_per_point,
velocity_window,
buttons: *buttons,
modifiers: *modifiers,
pointer_type: *pointer_type,
};
let mut host = PressablePointerHookHost {
app: &mut *cx.app,
window,
element: this.element,
node: cx.node,
bounds: cx.bounds,
source_test_id: props.a11y.test_id.clone(),
input_ctx: &cx.input_ctx,
prevented_default_actions: cx.prevented_default_actions,
requested_focus_target: &mut cx.requested_focus_target,
requested_capture: &mut cx.requested_capture,
requested_cursor: &mut cx.requested_cursor,
notify_requested: &mut cx.notify_requested,
notify_requested_location: &mut cx.notify_requested_location,
invalidations: &mut cx.invalidations,
};
if h(
&mut host,
action::ActionCx {
window,
target: this.element,
},
mv,
) {
cx.stop_propagation();
}
}
}
fret_core::PointerEvent::Down {
position,
button,
modifiers,
pointer_type,
click_count,
pointer_id,
..
} => {
let hook = crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
crate::action::PressableActionHooks::default,
|hooks| hooks.on_pointer_down.clone(),
);
if let Some(h) = hook {
let down = action::PointerDownCx {
pointer_id: *pointer_id,
position: *position,
position_local: position_local(cx.bounds, *position),
position_window: cx.event_window_position,
tick_id: cx.app.tick_id(),
pixels_per_point,
button: *button,
modifiers: *modifiers,
click_count: *click_count,
pointer_type: *pointer_type,
hit_is_text_input: cx.pointer_hit_is_text_input,
hit_is_pressable: cx.pointer_hit_is_pressable,
hit_pressable_target: cx.pointer_hit_pressable_target,
hit_pressable_target_in_descendant_subtree: cx
.pointer_hit_pressable_target_in_descendant_subtree,
};
let mut host = PressablePointerHookHost {
app: &mut *cx.app,
window,
element: this.element,
node: cx.node,
bounds: cx.bounds,
source_test_id: props.a11y.test_id.clone(),
input_ctx: &cx.input_ctx,
prevented_default_actions: cx.prevented_default_actions,
requested_focus_target: &mut cx.requested_focus_target,
requested_capture: &mut cx.requested_capture,
requested_cursor: &mut cx.requested_cursor,
notify_requested: &mut cx.notify_requested,
notify_requested_location: &mut cx.notify_requested_location,
invalidations: &mut cx.invalidations,
};
match h(
&mut host,
action::ActionCx {
window,
target: this.element,
},
down,
) {
action::PressablePointerDownResult::Continue => {}
action::PressablePointerDownResult::SkipDefault => {
return;
}
action::PressablePointerDownResult::SkipDefaultAndStopPropagation => {
cx.stop_propagation();
return;
}
}
}
if *button != MouseButton::Left {
return;
}
cx.prevent_default(fret_runtime::DefaultAction::FocusOnPointerDown);
cx.capture_pointer(cx.node);
if let Some(prev_node) = crate::elements::set_pressed_pressable_with_node(
&mut *cx.app,
window,
Some((this.element, cx.node)),
) {
cx.invalidate(prev_node, Invalidation::Paint);
}
crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
PressablePressTracking::default,
|st| {
st.pointer_id = Some(*pointer_id);
st.down_position = Some(*position);
st.down_hit_is_text_input = cx.pointer_hit_is_text_input;
st.down_hit_pressable_target = cx.pointer_hit_pressable_target;
st.down_hit_pressable_target_in_descendant_subtree =
cx.pointer_hit_pressable_target_in_descendant_subtree;
},
);
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
cx.stop_propagation();
}
fret_core::PointerEvent::Up {
pointer_id,
position,
button,
modifiers,
is_click,
click_count,
pointer_type,
} => {
let hook = crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
crate::action::PressableActionHooks::default,
|hooks| hooks.on_pointer_up.clone(),
);
let mut skip_activate = false;
if let Some(h) = hook.clone() {
let up = action::PointerUpCx {
pointer_id: *pointer_id,
position: *position,
position_local: position_local(cx.bounds, *position),
position_window: cx.event_window_position,
tick_id: cx.app.tick_id(),
pixels_per_point,
velocity_window: cx
.app
.global::<crate::pointer_motion::WindowPointerMotionService>()
.and_then(|svc| svc.velocity_window(window, *pointer_id)),
button: *button,
modifiers: *modifiers,
is_click: *is_click,
click_count: *click_count,
pointer_type: *pointer_type,
down_hit_pressable_target: crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
PressablePressTracking::default,
|st| st.down_hit_pressable_target,
),
down_hit_pressable_target_in_descendant_subtree:
crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
PressablePressTracking::default,
|st| st.down_hit_pressable_target_in_descendant_subtree,
),
};
let mut host = PressablePointerHookHost {
app: &mut *cx.app,
window,
element: this.element,
node: cx.node,
bounds: cx.bounds,
source_test_id: props.a11y.test_id.clone(),
input_ctx: &cx.input_ctx,
prevented_default_actions: cx.prevented_default_actions,
requested_focus_target: &mut cx.requested_focus_target,
requested_capture: &mut cx.requested_capture,
requested_cursor: &mut cx.requested_cursor,
notify_requested: &mut cx.notify_requested,
notify_requested_location: &mut cx.notify_requested_location,
invalidations: &mut cx.invalidations,
};
skip_activate = matches!(
h(
&mut host,
action::ActionCx {
window,
target: this.element,
},
up,
),
action::PressablePointerUpResult::SkipActivate
);
}
if *button != MouseButton::Left {
if hook.is_some() {
cx.request_redraw();
}
return;
}
let pressed =
crate::elements::is_pressed_pressable(&mut *cx.app, window, this.element);
let (down_pointer_id, down_position, down_hit_is_text_input) =
crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
PressablePressTracking::default,
|st| {
let out = (st.pointer_id, st.down_position, st.down_hit_is_text_input);
st.pointer_id = None;
st.down_position = None;
st.down_hit_is_text_input = false;
out
},
);
cx.release_pointer_capture();
if let Some(prev_node) =
crate::elements::set_pressed_pressable(&mut *cx.app, window, None)
{
cx.invalidate(prev_node, Invalidation::Paint);
}
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
let moved = if down_pointer_id == Some(*pointer_id)
&& let Some(prev) = down_position
{
let dx = position.x.0 - prev.x.0;
let dy = position.y.0 - prev.y.0;
(dx * dx + dy * dy).sqrt()
} else {
f32::INFINITY
};
let hovered = cx.bounds.contains(*position) || moved <= 2.0;
let is_touch = *pointer_type == fret_core::PointerType::Touch;
if pressed && hovered && (!is_touch || *is_click) && !down_hit_is_text_input {
cx.request_focus(cx.node);
}
if pressed && hovered && (!is_touch || *is_click) && !skip_activate {
let hook = crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
crate::action::PressableActionHooks::default,
|hooks| hooks.on_activate.clone(),
);
if let Some(h) = hook {
let mut host = PressableActionHookHost {
app: &mut *cx.app,
window,
element: this.element,
source_test_id: props.a11y.test_id.clone(),
notify_requested: &mut cx.notify_requested,
notify_requested_location: &mut cx.notify_requested_location,
};
h(
&mut host,
action::ActionCx {
window,
target: this.element,
},
ActivateReason::Pointer,
);
}
}
cx.release_pointer_capture();
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
cx.stop_propagation();
}
_ => {}
},
Event::PointerCancel(_) => {
if !crate::elements::is_pressed_pressable(&mut *cx.app, window, this.element) {
return;
}
crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
PressablePressTracking::default,
|st| {
st.pointer_id = None;
st.down_position = None;
},
);
if cx.captured == Some(cx.node) {
cx.release_pointer_capture();
}
if let Some(prev_node) =
crate::elements::set_pressed_pressable(&mut *cx.app, window, None)
{
cx.invalidate(prev_node, Invalidation::Paint);
}
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
}
Event::KeyDown { key, repeat, .. } => {
if *repeat {
return;
}
if cx.focus != Some(cx.node) {
return;
}
if !props.key_activation.allows(*key) {
return;
}
if let Some(prev_node) = crate::elements::set_pressed_pressable_with_node(
&mut *cx.app,
window,
Some((this.element, cx.node)),
) {
cx.invalidate(prev_node, Invalidation::Paint);
}
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
cx.stop_propagation();
}
Event::KeyUp { key, .. } => {
if cx.focus != Some(cx.node) {
return;
}
if !props.key_activation.allows(*key) {
return;
}
let pressed = crate::elements::is_pressed_pressable(&mut *cx.app, window, this.element);
if !pressed {
return;
}
if let Some(prev_node) =
crate::elements::set_pressed_pressable(&mut *cx.app, window, None)
{
cx.invalidate(prev_node, Invalidation::Paint);
}
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
let hook = crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
crate::action::PressableActionHooks::default,
|hooks| hooks.on_activate.clone(),
);
if let Some(h) = hook {
let mut host = PressableActionHookHost {
app: &mut *cx.app,
window,
element: this.element,
source_test_id: props.a11y.test_id.clone(),
notify_requested: &mut cx.notify_requested,
notify_requested_location: &mut cx.notify_requested_location,
};
h(
&mut host,
action::ActionCx {
window,
target: this.element,
},
ActivateReason::Keyboard,
);
}
cx.invalidate_self(Invalidation::Paint);
cx.request_redraw();
cx.stop_propagation();
}
Event::ClipboardWriteCompleted { token, outcome } => {
let hook = crate::elements::with_element_state(
&mut *cx.app,
window,
this.element,
crate::action::PressableActionHooks::default,
|hooks| hooks.on_clipboard_write_completed.clone(),
);
let Some(hook) = hook else {
return;
};
let mut host = PressableActionHookHost {
app: &mut *cx.app,
window,
element: this.element,
source_test_id: props.a11y.test_id.clone(),
notify_requested: &mut cx.notify_requested,
notify_requested_location: &mut cx.notify_requested_location,
};
if hook(
&mut host,
action::ActionCx {
window,
target: this.element,
},
*token,
outcome,
) {
cx.stop_propagation();
}
}
_ => {}
};
}