#![warn(missing_docs)]
use crate::item_tree::{ItemRc, ItemWeak, VisitChildrenResult};
pub use crate::items::PointerEventButton;
use crate::items::{ItemRef, TextCursorDirection};
use crate::lengths::{LogicalPoint, LogicalVector};
use crate::timers::Timer;
use crate::window::{WindowAdapter, WindowInner};
use crate::Property;
use crate::{component::ComponentRc, SharedString};
use alloc::rc::Rc;
use alloc::vec::Vec;
use const_field_offset::FieldOffsets;
use core::pin::Pin;
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq)]
#[allow(missing_docs)]
pub enum MouseEvent {
Pressed { position: LogicalPoint, button: PointerEventButton },
Released { position: LogicalPoint, button: PointerEventButton },
Moved { position: LogicalPoint },
Wheel { position: LogicalPoint, delta_x: f32, delta_y: f32 },
Exit,
}
impl MouseEvent {
pub fn position(&self) -> Option<LogicalPoint> {
match self {
MouseEvent::Pressed { position, .. } => Some(*position),
MouseEvent::Released { position, .. } => Some(*position),
MouseEvent::Moved { position } => Some(*position),
MouseEvent::Wheel { position, .. } => Some(*position),
MouseEvent::Exit => None,
}
}
pub fn translate(&mut self, vec: LogicalVector) {
let pos = match self {
MouseEvent::Pressed { position, .. } => Some(position),
MouseEvent::Released { position, .. } => Some(position),
MouseEvent::Moved { position } => Some(position),
MouseEvent::Wheel { position, .. } => Some(position),
MouseEvent::Exit => None,
};
if let Some(pos) = pos {
*pos += vec;
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
pub enum InputEventResult {
EventAccepted,
#[default]
EventIgnored,
GrabMouse,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq, Default)]
pub enum InputEventFilterResult {
#[default]
ForwardEvent,
ForwardAndIgnore,
ForwardAndInterceptGrab,
Intercept,
InterceptAndDispatch(MouseEvent),
DelayForwarding(u64),
}
#[allow(missing_docs, non_upper_case_globals)]
pub mod key_codes {
macro_rules! declare_consts_for_special_keys {
($($char:literal # $name:ident # $($_qt:ident)|* # $($_winit:ident)|* ;)*) => {
$(pub const $name : char = $char;)*
#[allow(missing_docs)]
#[derive(Debug, Copy, Clone, PartialEq)]
#[non_exhaustive]
#[repr(C)]
pub enum Key {
$($name,)*
}
impl From<Key> for char {
fn from(k: Key) -> Self {
match k {
$(Key::$name => $name,)*
}
}
}
impl From<Key> for crate::SharedString {
fn from(k: Key) -> Self {
char::from(k).into()
}
}
};
}
i_slint_common::for_each_special_keys!(declare_consts_for_special_keys);
}
#[derive(Clone, Copy, Default, Debug)]
pub(crate) struct InternalKeyboardModifierState {
left_alt: bool,
right_alt: bool,
left_control: bool,
right_control: bool,
left_meta: bool,
right_meta: bool,
left_shift: bool,
right_shift: bool,
}
impl InternalKeyboardModifierState {
pub(crate) fn state_update(mut self, pressed: bool, text: &SharedString) -> Option<Self> {
if let Some(key_code) = text.chars().next() {
match key_code {
key_codes::Alt => self.left_alt = pressed,
key_codes::Control => self.left_control = pressed,
key_codes::ControlR => self.right_control = pressed,
key_codes::Shift => self.left_shift = pressed,
key_codes::ShiftR => self.right_shift = pressed,
key_codes::Meta => self.left_meta = pressed,
key_codes::MetaR => self.right_meta = pressed,
_ => return None,
};
debug_assert_eq!(key_code.len_utf8(), text.len());
}
Some(self)
}
}
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
#[repr(C)]
pub struct KeyboardModifiers {
pub alt: bool,
pub control: bool,
pub meta: bool,
pub shift: bool,
}
impl From<InternalKeyboardModifierState> for KeyboardModifiers {
fn from(internal_state: InternalKeyboardModifierState) -> Self {
Self {
alt: internal_state.left_alt | internal_state.right_alt,
control: internal_state.left_control | internal_state.right_control,
meta: internal_state.left_meta | internal_state.right_meta,
shift: internal_state.left_shift | internal_state.right_shift,
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
#[repr(C)]
pub enum KeyEventType {
#[default]
KeyPressed,
KeyReleased,
UpdateComposition,
CommitComposition,
}
#[derive(Debug, Clone, PartialEq, Default)]
#[repr(C)]
pub struct KeyInputEvent {
pub text: SharedString,
pub event_type: KeyEventType,
pub preedit_selection_start: usize,
pub preedit_selection_end: usize,
}
#[derive(Debug, Clone, PartialEq, Default)]
#[repr(C)]
pub struct KeyEvent {
pub modifiers: KeyboardModifiers,
pub text: SharedString,
pub event_type: KeyEventType,
pub preedit_selection_start: usize,
pub preedit_selection_end: usize,
}
impl KeyEvent {
pub fn shortcut(&self) -> Option<StandardShortcut> {
if self.modifiers.control && !self.modifiers.shift {
match self.text.as_str() {
"c" => Some(StandardShortcut::Copy),
"x" => Some(StandardShortcut::Cut),
"v" => Some(StandardShortcut::Paste),
"a" => Some(StandardShortcut::SelectAll),
"f" => Some(StandardShortcut::Find),
"s" => Some(StandardShortcut::Save),
"p" => Some(StandardShortcut::Print),
"z" => Some(StandardShortcut::Undo),
#[cfg(target_os = "windows")]
"y" => Some(StandardShortcut::Redo),
"r" => Some(StandardShortcut::Refresh),
_ => None,
}
} else if self.modifiers.control && self.modifiers.shift {
match self.text.as_str() {
#[cfg(not(target_os = "windows"))]
"z" => Some(StandardShortcut::Redo),
_ => None,
}
} else {
None
}
}
pub fn text_shortcut(&self) -> Option<TextShortcut> {
let keycode = self.text.chars().next()?;
let move_mod = if cfg!(target_os = "macos") {
self.modifiers.alt && !self.modifiers.control && !self.modifiers.meta
} else {
self.modifiers.control && !self.modifiers.alt && !self.modifiers.meta
};
if move_mod {
match keycode {
key_codes::LeftArrow => {
return Some(TextShortcut::Move(TextCursorDirection::BackwardByWord))
}
key_codes::RightArrow => {
return Some(TextShortcut::Move(TextCursorDirection::ForwardByWord))
}
key_codes::UpArrow => {
return Some(TextShortcut::Move(TextCursorDirection::StartOfParagraph))
}
key_codes::DownArrow => {
return Some(TextShortcut::Move(TextCursorDirection::EndOfParagraph))
}
key_codes::Backspace => {
return Some(TextShortcut::DeleteWordBackward);
}
key_codes::Delete => {
return Some(TextShortcut::DeleteWordForward);
}
_ => (),
};
}
#[cfg(not(target_os = "macos"))]
{
if self.modifiers.control && !self.modifiers.alt && !self.modifiers.meta {
match keycode {
key_codes::Home => {
return Some(TextShortcut::Move(TextCursorDirection::StartOfText))
}
key_codes::End => {
return Some(TextShortcut::Move(TextCursorDirection::EndOfText))
}
_ => (),
};
}
}
#[cfg(target_os = "macos")]
{
if self.modifiers.control {
match keycode {
key_codes::LeftArrow => {
return Some(TextShortcut::Move(TextCursorDirection::StartOfLine))
}
key_codes::RightArrow => {
return Some(TextShortcut::Move(TextCursorDirection::EndOfLine))
}
key_codes::UpArrow => {
return Some(TextShortcut::Move(TextCursorDirection::StartOfText))
}
key_codes::DownArrow => {
return Some(TextShortcut::Move(TextCursorDirection::EndOfText))
}
_ => (),
};
}
}
match TextCursorDirection::try_from(keycode) {
Ok(direction) => return Some(TextShortcut::Move(direction)),
_ => (),
};
match keycode {
key_codes::Backspace => Some(TextShortcut::DeleteBackward),
key_codes::Delete => Some(TextShortcut::DeleteForward),
_ => None,
}
}
}
pub enum StandardShortcut {
Copy,
Cut,
Paste,
SelectAll,
Find,
Save,
Print,
Undo,
Redo,
Refresh,
}
pub enum TextShortcut {
Move(TextCursorDirection),
DeleteForward,
DeleteBackward,
DeleteWordForward,
DeleteWordBackward,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum KeyEventResult {
EventAccepted,
EventIgnored,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum FocusEventResult {
FocusAccepted,
FocusIgnored,
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[repr(C)]
pub enum FocusEvent {
FocusIn,
FocusOut,
WindowReceivedFocus,
WindowLostFocus,
}
#[derive(Default)]
pub struct MouseInputState {
item_stack: Vec<(ItemWeak, InputEventFilterResult)>,
grabbed: bool,
delayed: Option<(crate::timers::Timer, MouseEvent)>,
}
fn handle_mouse_grab(
mouse_event: &MouseEvent,
window_adapter: &Rc<dyn WindowAdapter>,
mouse_input_state: &mut MouseInputState,
) -> bool {
if !mouse_input_state.grabbed || mouse_input_state.item_stack.is_empty() {
return false;
};
let mut event = *mouse_event;
let mut intercept = false;
let mut invalid = false;
mouse_input_state.item_stack.retain(|it| {
if invalid {
return false;
}
let item = if let Some(item) = it.0.upgrade() {
item
} else {
invalid = true;
return false;
};
if intercept {
item.borrow().as_ref().input_event(MouseEvent::Exit, window_adapter, &item);
return false;
}
let g = item.geometry();
event.translate(-g.origin.to_vector());
let interested = matches!(
it.1,
InputEventFilterResult::ForwardAndInterceptGrab
| InputEventFilterResult::DelayForwarding(_)
);
if interested
&& item.borrow().as_ref().input_event_filter_before_children(
event,
window_adapter,
&item,
) == InputEventFilterResult::Intercept
{
intercept = true;
}
true
});
if invalid {
return false;
}
let grabber = mouse_input_state.item_stack.last().unwrap().0.upgrade().unwrap();
let input_result = grabber.borrow().as_ref().input_event(event, window_adapter, &grabber);
if input_result != InputEventResult::GrabMouse {
mouse_input_state.grabbed = false;
send_exit_events(mouse_input_state, mouse_event.position(), window_adapter);
}
true
}
fn send_exit_events(
mouse_input_state: &MouseInputState,
mut pos: Option<LogicalPoint>,
window_adapter: &Rc<dyn WindowAdapter>,
) {
for it in mouse_input_state.item_stack.iter() {
let item = if let Some(item) = it.0.upgrade() { item } else { break };
let g = item.geometry();
let contains = pos.map_or(false, |p| g.contains(p));
if let Some(p) = pos.as_mut() {
*p -= g.origin.to_vector();
}
if !contains {
item.borrow().as_ref().input_event(MouseEvent::Exit, window_adapter, &item);
}
}
}
pub fn process_mouse_input(
component: ComponentRc,
mouse_event: MouseEvent,
window_adapter: &Rc<dyn WindowAdapter>,
mut mouse_input_state: MouseInputState,
) -> MouseInputState {
if matches!(mouse_event, MouseEvent::Released { .. }) {
mouse_input_state = process_delayed_event(window_adapter, mouse_input_state);
}
if handle_mouse_grab(&mouse_event, window_adapter, &mut mouse_input_state) {
return mouse_input_state;
}
let mut result = MouseInputState::default();
let root = ItemRc::new(component.clone(), 0);
let r = send_mouse_event_to_item(mouse_event, root, window_adapter, &mut result, false);
if mouse_input_state.delayed.is_some() && !r.has_aborted() {
return mouse_input_state;
}
send_exit_events(&mouse_input_state, mouse_event.position(), window_adapter);
result
}
pub(crate) fn process_delayed_event(
window_adapter: &Rc<dyn WindowAdapter>,
mut mouse_input_state: MouseInputState,
) -> MouseInputState {
let event = match mouse_input_state.delayed.take() {
Some(e) => e.1,
None => return mouse_input_state,
};
let top_item = match mouse_input_state.item_stack.last().unwrap().0.upgrade() {
Some(i) => i,
None => return MouseInputState::default(),
};
let mut actual_visitor =
|component: &ComponentRc, index: usize, _: Pin<ItemRef>| -> VisitChildrenResult {
send_mouse_event_to_item(
event,
ItemRc::new(component.clone(), index),
window_adapter,
&mut mouse_input_state,
true,
)
};
vtable::new_vref!(let mut actual_visitor : VRefMut<crate::item_tree::ItemVisitorVTable> for crate::item_tree::ItemVisitor = &mut actual_visitor);
vtable::VRc::borrow_pin(&top_item.component()).as_ref().visit_children_item(
top_item.index() as isize,
crate::item_tree::TraversalOrder::FrontToBack,
actual_visitor,
);
mouse_input_state
}
fn send_mouse_event_to_item(
mouse_event: MouseEvent,
item_rc: ItemRc,
window_adapter: &Rc<dyn WindowAdapter>,
result: &mut MouseInputState,
ignore_delays: bool,
) -> VisitChildrenResult {
let item = item_rc.borrow();
let geom = item_rc.geometry();
let mut event_for_children = mouse_event;
event_for_children.translate(-geom.origin.to_vector());
let filter_result = if mouse_event.position().map_or(false, |p| geom.contains(p))
|| crate::item_rendering::is_clipping_item(item)
{
item.as_ref().input_event_filter_before_children(
event_for_children,
window_adapter,
&item_rc,
)
} else {
InputEventFilterResult::ForwardAndIgnore
};
let (forward_to_children, ignore) = match filter_result {
InputEventFilterResult::ForwardEvent => (true, false),
InputEventFilterResult::ForwardAndIgnore => (true, true),
InputEventFilterResult::ForwardAndInterceptGrab => (true, false),
InputEventFilterResult::Intercept => (false, false),
InputEventFilterResult::InterceptAndDispatch(new_event) => {
event_for_children = new_event;
(true, false)
}
InputEventFilterResult::DelayForwarding(_) if ignore_delays => (true, false),
InputEventFilterResult::DelayForwarding(duration) => {
let timer = Timer::default();
let w = Rc::downgrade(window_adapter);
timer.start(
crate::timers::TimerMode::SingleShot,
core::time::Duration::from_millis(duration),
move || {
if let Some(w) = w.upgrade() {
WindowInner::from_pub(w.window()).process_delayed_event();
}
},
);
result.delayed = Some((timer, event_for_children));
result
.item_stack
.push((item_rc.downgrade(), InputEventFilterResult::DelayForwarding(duration)));
return VisitChildrenResult::abort(item_rc.index(), 0);
}
};
result.item_stack.push((item_rc.downgrade(), filter_result));
if forward_to_children {
let mut actual_visitor =
|component: &ComponentRc, index: usize, _: Pin<ItemRef>| -> VisitChildrenResult {
send_mouse_event_to_item(
event_for_children,
ItemRc::new(component.clone(), index),
window_adapter,
result,
ignore_delays,
)
};
vtable::new_vref!(let mut actual_visitor : VRefMut<crate::item_tree::ItemVisitorVTable> for crate::item_tree::ItemVisitor = &mut actual_visitor);
let r = vtable::VRc::borrow_pin(&item_rc.component()).as_ref().visit_children_item(
item_rc.index() as isize,
crate::item_tree::TraversalOrder::FrontToBack,
actual_visitor,
);
if r.has_aborted() {
if matches!(filter_result, InputEventFilterResult::InterceptAndDispatch(_)) {
let mut event = mouse_event;
event.translate(-geom.origin.to_vector());
item.as_ref().input_event(event, window_adapter, &item_rc);
}
return r;
}
};
let r = if ignore {
InputEventResult::EventIgnored
} else {
let mut event = mouse_event;
event.translate(-geom.origin.to_vector());
item.as_ref().input_event(event, window_adapter, &item_rc)
};
match r {
InputEventResult::EventAccepted => {
return VisitChildrenResult::abort(item_rc.index(), 0);
}
InputEventResult::EventIgnored => {
let _pop = result.item_stack.pop();
debug_assert_eq!(
_pop.map(|x| (x.0.upgrade().unwrap().index(), x.1)).unwrap(),
(item_rc.index(), filter_result)
);
return VisitChildrenResult::CONTINUE;
}
InputEventResult::GrabMouse => {
result.item_stack.last_mut().unwrap().1 =
InputEventFilterResult::ForwardAndInterceptGrab;
result.grabbed = true;
return VisitChildrenResult::abort(item_rc.index(), 0);
}
}
}
#[derive(FieldOffsets)]
#[repr(C)]
#[pin]
pub(crate) struct TextCursorBlinker {
cursor_visible: Property<bool>,
cursor_blink_timer: crate::timers::Timer,
}
impl TextCursorBlinker {
pub fn new() -> Pin<Rc<Self>> {
Rc::pin(Self {
cursor_visible: Property::new(true),
cursor_blink_timer: Default::default(),
})
}
pub fn set_binding(instance: Pin<Rc<TextCursorBlinker>>, prop: &Property<bool>) {
instance.as_ref().cursor_visible.set(true);
Self::start(&instance);
prop.set_binding(move || {
TextCursorBlinker::FIELD_OFFSETS.cursor_visible.apply_pin(instance.as_ref()).get()
});
}
pub fn start(self: &Pin<Rc<Self>>) {
if self.cursor_blink_timer.running() {
self.cursor_blink_timer.restart();
} else {
let toggle_cursor = {
let weak_blinker = pin_weak::rc::PinWeak::downgrade(self.clone());
move || {
if let Some(blinker) = weak_blinker.upgrade() {
let visible = TextCursorBlinker::FIELD_OFFSETS
.cursor_visible
.apply_pin(blinker.as_ref())
.get();
blinker.cursor_visible.set(!visible);
}
}
};
self.cursor_blink_timer.start(
crate::timers::TimerMode::Repeated,
core::time::Duration::from_millis(500),
toggle_cursor,
);
}
}
pub fn stop(&self) {
self.cursor_blink_timer.stop()
}
}