#![cfg_attr(not(feature = "winit"), allow(dead_code))]
use super::Tree;
use crate::app::events::TouchPhase;
const FIRST_FINGER: u64 = 0x6000_0000;
const FINGER_GAP: f32 = 40.0;
const PINCH_RADIUS: f32 = 60.0;
const PINCH_WHEEL: f32 = 200.0;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Fingers {
One,
Mirrored,
Two,
Three,
}
impl Fingers {
pub(crate) fn of(alt: bool, shift: bool, ctrl: bool) -> Self {
match (alt, shift, ctrl) {
(true, true, true) => Self::Three,
(true, true, false) => Self::Two,
(true, ..) => Self::Mirrored,
_ => Self::One,
}
}
}
#[derive(Debug)]
pub(crate) struct MouseFingers {
cursor: (f32, f32),
held: Fingers,
down: Option<(Fingers, (f32, f32))>,
pinch: Option<((f32, f32), f32)>,
}
impl Default for MouseFingers {
fn default() -> Self {
Self {
cursor: (0.0, 0.0),
held: Fingers::One,
down: None,
pinch: None,
}
}
}
impl MouseFingers {
fn places(fingers: Fingers, cursor: (f32, f32), start: (f32, f32), gap: f32) -> Vec<(f32, f32)> {
match fingers {
Fingers::One => vec![cursor],
Fingers::Mirrored => {
let half = gap / 2.0;
vec![
(cursor.0 + half, cursor.1),
(2.0 * start.0 - cursor.0 - half, 2.0 * start.1 - cursor.1),
]
}
Fingers::Two => vec![(cursor.0 - gap / 2.0, cursor.1), (cursor.0 + gap / 2.0, cursor.1)],
Fingers::Three => vec![(cursor.0 - gap, cursor.1), cursor, (cursor.0 + gap, cursor.1)],
}
}
fn gap(tree: &Tree) -> f32 {
FINGER_GAP * tree.scale_factor()
}
fn around(center: (f32, f32), radius: f32) -> Vec<(f32, f32)> {
(0..3)
.map(|index| {
let turn = -std::f32::consts::FRAC_PI_2 + std::f32::consts::TAU * index as f32 / 3.0;
(center.0 + radius * turn.cos(), center.1 + radius * turn.sin())
})
.collect()
}
fn mark(&self, tree: &mut Tree) {
if let Some((center, radius)) = self.pinch {
tree.set_touch_marks(Self::around(center, radius));
return;
}
let gap = Self::gap(tree);
let marks = match self.down {
Some((fingers, start)) => Self::places(fingers, self.cursor, start, gap),
None if self.held != Fingers::One => Self::places(self.held, self.cursor, self.cursor, gap),
None => Vec::new(),
};
tree.set_touch_marks(marks);
}
pub(crate) fn modifiers(&mut self, tree: &mut Tree, alt: bool, shift: bool, ctrl: bool) {
self.held = Fingers::of(alt, shift, ctrl);
if self.held != Fingers::Three {
self.end_pinch(tree, TouchPhase::End);
}
self.mark(tree);
}
pub(crate) fn wheel(&mut self, tree: &mut Tree, delta_y: f32) -> bool {
if self.held != Fingers::Three || self.down.is_some() {
return false;
}
let (center, radius) = match self.pinch {
Some(pinch) => pinch,
None => {
let pinch = (self.cursor, PINCH_RADIUS * tree.scale_factor());
for (index, (x, y)) in Self::around(pinch.0, pinch.1).into_iter().enumerate() {
tree.finger(FIRST_FINGER + index as u64, TouchPhase::Start, x, y, None);
}
pinch
}
};
let radius = (radius * (delta_y / PINCH_WHEEL).exp()).max(2.0);
self.pinch = Some((center, radius));
for (index, (x, y)) in Self::around(center, radius).into_iter().enumerate() {
tree.finger(FIRST_FINGER + index as u64, TouchPhase::Move, x, y, None);
}
self.mark(tree);
true
}
fn end_pinch(&mut self, tree: &mut Tree, phase: TouchPhase) {
let Some((center, radius)) = self.pinch.take() else {
return;
};
for (index, (x, y)) in Self::around(center, radius).into_iter().enumerate() {
tree.finger(FIRST_FINGER + index as u64, phase, x, y, None);
}
}
pub(crate) fn moved(&mut self, tree: &mut Tree, x: f32, y: f32) {
self.cursor = (x, y);
if let Some((fingers, start)) = self.down {
let gap = Self::gap(tree);
for (index, (x, y)) in Self::places(fingers, self.cursor, start, gap).into_iter().enumerate() {
tree.finger(FIRST_FINGER + index as u64, TouchPhase::Move, x, y, None);
}
}
self.mark(tree);
}
pub(crate) fn pressed(&mut self, tree: &mut Tree) {
if self.down.is_some() || self.pinch.is_some() {
return;
}
let gap = Self::gap(tree);
self.down = Some((self.held, self.cursor));
for (index, (x, y)) in Self::places(self.held, self.cursor, self.cursor, gap)
.into_iter()
.enumerate()
{
tree.finger(FIRST_FINGER + index as u64, TouchPhase::Start, x, y, None);
}
self.mark(tree);
}
pub(crate) fn released(&mut self, tree: &mut Tree) {
self.lift(tree, TouchPhase::End);
}
pub(crate) fn left(&mut self, tree: &mut Tree) {
self.end_pinch(tree, TouchPhase::Cancel);
self.lift(tree, TouchPhase::Cancel);
tree.set_touch_marks(Vec::new());
}
fn lift(&mut self, tree: &mut Tree, phase: TouchPhase) {
let Some((fingers, start)) = self.down.take() else {
return;
};
let gap = Self::gap(tree);
for (index, (x, y)) in Self::places(fingers, self.cursor, start, gap).into_iter().enumerate() {
tree.finger(FIRST_FINGER + index as u64, phase, x, y, None);
}
self.mark(tree);
}
}
impl Tree {
pub fn set_touch_marks(&mut self, marks: Vec<(f32, f32)>) {
if self.touch_marks != marks {
self.touch_marks = marks;
self.needs_redraw = true;
}
}
pub(super) fn push_touch_marks(
&self,
rects: &mut Vec<crate::layout::render_list::RectCmd>,
order: usize,
scale: f32,
) {
if self.touch_marks.is_empty() {
return;
}
let foreground = self.layout_engine.palette().foreground;
let radius = 14.0 * scale;
let fill = crate::node::color::Color::new(foreground.r(), foreground.g(), foreground.b(), 56);
let ring = crate::node::color::Color::new(foreground.r(), foreground.g(), foreground.b(), 160);
for (index, (x, y)) in self.touch_marks.iter().enumerate() {
rects.push(crate::layout::render_list::RectCmd {
order: order + index,
x: x - radius,
y: y - radius,
width: radius * 2.0,
height: radius * 2.0,
color: fill,
radii: [radius; 4],
stroke: [1.5 * scale; 4],
stroke_color: ring,
stroke_style: crate::layout::render_list::StrokeStyle::default(),
transform: [1.0, 0.0, 0.0, 1.0],
transform_origin: [0.0, 0.0],
clip: crate::layout::quad::ClipRect::default(),
gradient: None,
shadow: None,
});
}
}
}