use std::sync::Arc;
use parking_lot::Mutex;
use crate::{
app::{
component::Component,
ctx::Ctx,
events::{DragEvent, GesturePhase, MouseEvent, PinchEvent, ScrollEvent, TapEvent},
},
components::{ScrollBoth, Stack},
core::{ElementRef, Signal},
layout::layout_kind::ScrollState,
node::{Element, dimension::Dimension, transform::Transform2D},
};
const FILL: Dimension = Dimension::Pct(100.0);
#[derive(Clone)]
pub struct ZoomScrollProps {
width: f32,
height: f32,
min: f32,
max: f32,
double_tap: Option<f32>,
wheel: Option<f32>,
drag: bool,
bars: bool,
zoom: Option<Signal<f32>>,
scroll: Option<ScrollState>,
}
impl PartialEq for ZoomScrollProps {
fn eq(&self, _other: &Self) -> bool {
false
}
}
#[cfg(feature = "devtools")]
impl crate::app::component::DevtoolsInspectable for ZoomScrollProps {
fn write_info(&self, _buffer: &mut Vec<crate::app::component::ComponentInfo>) {}
}
impl ZoomScrollProps {
pub fn new(width: f32, height: f32) -> Self {
Self {
width,
height,
min: 1.0,
max: 4.0,
double_tap: Some(2.0),
wheel: None,
drag: false,
bars: true,
zoom: None,
scroll: None,
}
}
pub fn range(mut self, min: f32, max: f32) -> Self {
self.min = min.max(f32::EPSILON);
self.max = max.max(self.min);
self
}
pub fn double_tap(mut self, scale: Option<f32>) -> Self {
self.double_tap = scale;
self
}
pub fn wheel_zoom(mut self, step: f32) -> Self {
self.wheel = Some(step.max(1.0 + f32::EPSILON));
self
}
pub fn drag_pan(mut self, drag: bool) -> Self {
self.drag = drag;
self
}
pub fn scrollbars(mut self, bars: bool) -> Self {
self.bars = bars;
self
}
pub fn zoom(mut self, zoom: Signal<f32>) -> Self {
self.zoom = Some(zoom);
self
}
pub fn scroll(mut self, scroll: ScrollState) -> Self {
self.scroll = Some(scroll);
self
}
}
struct Held {
zoom: f32,
point: (f32, f32),
}
fn placed(size: (f32, f32), zoom: f32, viewport: (f32, f32)) -> ((f32, f32), (f32, f32)) {
let shown = (size.0 * zoom, size.1 * zoom);
let margin = (
((viewport.0 - shown.0) / 2.0).max(0.0),
((viewport.1 - shown.1) / 2.0).max(0.0),
);
(shown, margin)
}
const CTRL_WHEEL_STEP: f32 = 1.5;
const TRAVEL_PER_STEP: f32 = 40.0;
fn wheel_zoom_step(event: &ScrollEvent, wheel: Option<f32>) -> Option<f32> {
match (event.ctrl, wheel) {
(true, step) => Some(step.unwrap_or(CTRL_WHEEL_STEP)),
(false, Some(step)) if event.notched => Some(step),
(false, _) => None,
}
}
fn wheel_zoom_factor(event: &ScrollEvent, step: f32) -> f32 {
if event.notched {
if event.delta_y > 0.0 { step } else { 1.0 / step }
} else {
step.powf(event.delta_y / TRAVEL_PER_STEP)
}
}
pub struct ZoomScroll {
zoom: Signal<f32>,
scroll: ScrollState,
view: ElementRef,
viewport: Signal<(f32, f32)>,
held: Arc<Mutex<Option<Held>>>,
placed: Arc<Mutex<Option<f32>>>,
moved: Arc<Mutex<bool>>,
}
impl ZoomScroll {
pub fn mount(ctx: &mut Ctx, props: ZoomScrollProps, content: impl Into<Element>) -> Element {
ctx.mount_with::<Self>(props, vec![content.into()])
}
}
impl Component for ZoomScroll {
type Props = ZoomScrollProps;
fn create(_ctx: &mut Ctx) -> Self {
Self {
zoom: Signal::new(1.0),
scroll: ScrollState::new(),
view: ElementRef::default(),
viewport: Signal::new((0.0, 0.0)),
held: Arc::default(),
placed: Arc::default(),
moved: Arc::default(),
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let props = ctx.props::<ZoomScrollProps>().clone();
let zoom_signal = props.zoom.clone().unwrap_or_else(|| self.zoom.clone());
let scroll = props.scroll.clone().unwrap_or_else(|| self.scroll.clone());
let (min, max) = (props.min, props.max);
let size = (props.width, props.height);
let zoom = zoom_signal.get().clamp(min, max);
let viewport = self.viewport.get();
let (shown, margin) = placed(size, zoom, viewport);
{
let mut last = self.placed.lock();
let by_gesture = std::mem::take(&mut *self.moved.lock());
if let Some(was) = *last
&& (was - zoom).abs() > f32::EPSILON
&& !by_gesture
&& viewport.0 > 0.0
&& viewport.1 > 0.0
{
let (_, was_margin) = placed(size, was, viewport);
let middle = (viewport.0 / 2.0, viewport.1 / 2.0);
let point = (
(middle.0 + scroll.scroll_x() - was_margin.0) / was,
(middle.1 + scroll.scroll_y() - was_margin.1) / was,
);
scroll.set_scroll_pending(
point.0 * zoom + margin.0 - middle.0,
point.1 * zoom + margin.1 - middle.1,
);
}
*last = Some(zoom);
}
let mut content = Stack::new().size(size.0, size.1).transform(Transform2D {
a: zoom,
b: 0.0,
c: 0.0,
d: zoom,
tx: size.0 / 2.0 * (zoom - 1.0) + margin.0,
ty: size.1 / 2.0 * (zoom - 1.0) + margin.1,
});
for child in ctx.children() {
content = content.child(child.clone());
}
let area = Stack::new()
.size(shown.0.max(viewport.0), shown.1.max(viewport.1))
.child(content);
let go = {
let (zoom_signal, scroll, view) = (zoom_signal.clone(), scroll.clone(), self.view.clone());
let moved = self.moved.clone();
move |zoom: f32, point: (f32, f32), at: (f32, f32)| {
let zoom = zoom.clamp(min, max);
let (_, margin) = placed(size, zoom, (view.width(), view.height()));
if zoom_signal.get_untracked() != zoom {
*moved.lock() = true;
zoom_signal.set(zoom);
}
scroll.set_scroll_pending(point.0 * zoom + margin.0 - at.0, point.1 * zoom + margin.1 - at.1);
}
};
let point_at = {
let (zoom_signal, scroll, view) = (zoom_signal.clone(), scroll.clone(), self.view.clone());
move |x: f32, y: f32| {
let zoom = zoom_signal.get_untracked().clamp(min, max);
let (_, margin) = placed(size, zoom, (view.width(), view.height()));
let at = (x - view.x(), y - view.y());
let point = (
(at.0 + scroll.scroll_x() - margin.0) / zoom,
(at.1 + scroll.scroll_y() - margin.1) / zoom,
);
(zoom, point, at)
}
};
let mut list = ScrollBoth::new(area)
.with_scroll_state(scroll.clone())
.ref_element(self.view.clone())
.size(FILL, FILL);
if !props.bars {
list = list.scrollbar(crate::layout::scrollbar::ScrollBarStyle::hidden());
}
list = list.on_pinch({
let (held, go, point_at, view) = (self.held.clone(), go.clone(), point_at.clone(), self.view.clone());
move |event: PinchEvent| {
event.stop_propagation();
match event.phase {
GesturePhase::Start => {
let (zoom, point, _) = point_at(event.x, event.y);
*held.lock() = Some(Held { zoom, point });
}
GesturePhase::Change => {
if let Some(held) = &*held.lock() {
go(
held.zoom * event.scale,
held.point,
(event.x - view.x(), event.y - view.y()),
);
}
}
GesturePhase::End => {
held.lock().take();
}
}
}
});
{
let (go, point_at, wheel) = (go.clone(), point_at.clone(), props.wheel);
list = list.on_wheel(move |event: ScrollEvent| {
if event.delta_y == 0.0 {
return;
}
let Some(step) = wheel_zoom_step(&event, wheel) else {
return;
};
event.prevent_default();
event.stop_propagation();
let (zoom, point, at) = point_at(event.x, event.y);
go(zoom * wheel_zoom_factor(&event, step), point, at);
});
}
if props.drag {
let scroll = scroll.clone();
list = list.on_drag_move(move |event: DragEvent| scroll.scroll_by(-event.delta_x, -event.delta_y));
}
if let Some(double_tap) = props.double_tap {
let toggle = Arc::new(move |x: f32, y: f32| {
let (zoom, point, at) = point_at(x, y);
go(if zoom > min * 1.01 { min } else { min * double_tap }, point, at);
});
let by_mouse = toggle.clone();
list = list
.on_dblclick(move |event: MouseEvent| {
if event.from_keyboard {
return;
}
event.stop_propagation();
by_mouse(event.x, event.y);
})
.on_double_tap(move |event: TapEvent| {
if event.fingers != 1 {
return;
}
event.stop_propagation();
toggle(event.x, event.y);
});
}
list
}
fn after_layout(&self) {
if !self.view.is_attached() {
return;
}
let viewport = (self.view.width(), self.view.height());
let last = self.viewport.get_untracked();
if (last.0 - viewport.0).abs() > 0.25 || (last.1 - viewport.1).abs() > 0.25 {
self.viewport.set(viewport);
}
}
}