use leptos::prelude::*;
use web_sys::{KeyboardEvent, MouseEvent, WheelEvent};
use crate::registry::{BoxSelect, DragState, EditorRegistry};
use crate::types::*;
use crate::utils;
fn canvas_pos_from_event<N, P, C, T>(
registry: &EditorRegistry<N, P, C, T>,
ev: &MouseEvent,
container_ref: &NodeRef<leptos::html::Div>,
) -> Position
where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
let viewport = registry.viewport.get_untracked();
let (offset_x, offset_y) = container_ref.with_untracked(|el| {
if let Some(el) = el {
let rect = el.get_bounding_client_rect();
(rect.left(), rect.top())
} else {
(0.0, 0.0)
}
});
let screen = Position::new(
ev.client_x() as f64 - offset_x,
ev.client_y() as f64 - offset_y,
);
viewport.screen_to_canvas(screen)
}
pub fn handle_canvas_mousedown<N, P, C, T>(
registry: &EditorRegistry<N, P, C, T>,
ev: MouseEvent,
container_ref: &NodeRef<leptos::html::Div>,
) where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
if ev.button() == 1 || (ev.button() == 0 && ev.ctrl_key()) {
registry.is_panning.set(true);
registry.pan_origin.set(Some(Position::new(
ev.client_x() as f64,
ev.client_y() as f64,
)));
return;
}
if ev.button() != 0 {
return;
}
if let Some(target) = ev.target() {
use leptos::wasm_bindgen::JsCast;
if let Some(el) = target.dyn_ref::<web_sys::Element>() {
let on_node: bool = el.closest("[data-node]").ok().flatten().is_some();
let on_anchor: bool = el.closest("[data-anchor]").ok().flatten().is_some();
if on_node || on_anchor {
return;
}
}
}
registry.draft_connection.set(None);
if !ev.shift_key() {
registry.clear_selection();
}
let canvas_pos = canvas_pos_from_event(registry, &ev, container_ref);
registry.box_select.set(Some(BoxSelect {
start: canvas_pos,
current: canvas_pos,
create_group: ev.alt_key(),
}));
}
pub fn handle_canvas_mousemove<N, P, C, T>(
registry: &EditorRegistry<N, P, C, T>,
ev: MouseEvent,
container_ref: &NodeRef<leptos::html::Div>,
) where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
let resize = registry.resize_state.with_untracked(|rs| rs.clone());
if let Some(rs) = resize {
let canvas_pos = canvas_pos_from_event(registry, &ev, container_ref);
let mut width = rs.start_width + (canvas_pos.x - rs.start_x);
width = width.max(rs.min_width);
if let Some(max) = rs.max_width {
width = width.min(max);
}
rs.width_signal.set(Some(width));
return;
}
if registry.is_panning.get_untracked() {
let now = Position::new(ev.client_x() as f64, ev.client_y() as f64);
let last = registry.pan_origin.get_untracked().unwrap_or(now);
registry.pan_origin.set(Some(now));
let (dx, dy) = (now.x - last.x, now.y - last.y);
registry.viewport.update(|vp| {
vp.pan_x += dx;
vp.pan_y += dy;
});
return;
}
if ev.alt_key()
&& registry
.drag_state
.with_untracked(|drag| drag.as_ref().is_some_and(|drag| !drag.alt_key))
{
registry.drag_state.update(latch_group_transfer);
}
let has_drag = registry.drag_state.with_untracked(|ds| ds.is_some());
if has_drag {
let canvas_pos = canvas_pos_from_event(registry, &ev, container_ref);
registry.pending_drag_pos.set(Some(canvas_pos));
if !registry.drag_raf_pending.get_untracked() {
registry.drag_raf_pending.set(true);
let reg = registry.clone();
crate::raf::request_animation_frame(move || {
reg.drag_raf_pending.set(false);
let canvas_pos = reg.pending_drag_pos.get_untracked();
if let Some(canvas_pos) = canvas_pos {
reg.pending_drag_pos.set(None);
let grid_size = reg.config.with_untracked(|c| c.grid_size);
reg.drag_state.with_untracked(|ds| {
if let Some(ds) = ds {
let delta = Position::new(
canvas_pos.x - ds.offset.x,
canvas_pos.y - ds.offset.y,
);
let updates: Vec<(N, Position)> = ds
.start_positions
.iter()
.map(|(node_id, start_pos)| {
let mut new_pos =
Position::new(start_pos.x + delta.x, start_pos.y + delta.y);
if let Some(grid) = grid_size {
new_pos = utils::snap_to_grid(new_pos, grid);
}
(node_id.clone(), new_pos)
})
.collect();
reg.batch_set_positions(&updates);
}
});
}
});
}
return;
}
let has_box = registry.box_select.with_untracked(|bs| bs.is_some());
if has_box {
let canvas_pos = canvas_pos_from_event(registry, &ev, container_ref);
registry.box_select.update(|bs| {
if let Some(bs) = bs {
bs.current = canvas_pos;
}
});
let rect = registry
.box_select
.with_untracked(|bs| bs.as_ref().map(|bs| bs.to_rect()));
if let Some(rect) = rect {
let nodes_in = registry.nodes_in_rect(&rect);
registry.selected_nodes.set(nodes_in);
}
return;
}
let has_draft = registry.draft_connection.with_untracked(|dc| dc.is_some());
if has_draft {
let canvas_pos = canvas_pos_from_event(registry, &ev, container_ref);
let snap_distance = registry.config.with_untracked(|c| c.snap_distance);
let snap = if snap_distance > 0.0 {
let zoom = registry.viewport.get_untracked().zoom;
let zoom = if zoom.abs() < 1e-6 { 1.0 } else { zoom };
registry.snap_target_for_draft(canvas_pos, snap_distance / zoom)
} else {
None
};
registry.draft_connection.update(|dc| {
if let Some(dc) = dc {
match &snap {
Some((port_id, port_pos)) => {
dc.current_end = *port_pos;
dc.snap_target = Some(port_id.clone());
}
None => {
dc.current_end = canvas_pos;
dc.snap_target = None;
}
}
}
});
}
}
pub fn handle_canvas_mouseup<N, P, C, T>(
registry: &EditorRegistry<N, P, C, T>,
ev: MouseEvent,
_container_ref: &NodeRef<leptos::html::Div>,
) where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
let was_panning = registry.is_panning.get_untracked();
registry.is_panning.set(false);
if was_panning {
registry.pan_origin.set(None);
}
let box_select = registry.box_select.get_untracked();
registry.box_select.set(None);
if box_select.is_some_and(|bs| bs.create_group) {
let ids: Vec<N> = registry
.selected_nodes
.with_untracked(|selected| selected.iter().cloned().collect());
if ids.len() > 1 {
registry.emit(GraphEvent::GroupCreated { node_ids: ids });
}
}
if registry.resize_state.with_untracked(|rs| rs.is_some()) {
registry.resize_state.set(None);
}
let drag = registry.drag_state.with_untracked(|ds| ds.clone());
if let Some(drag) = drag {
registry.drag_state.set(None);
let nodes: Vec<_> = registry.nodes.with_untracked(|current| {
drag.start_positions
.keys()
.filter_map(|node_id| {
current
.get(node_id)
.map(|node| (node_id.clone(), node.position))
})
.collect()
});
if !nodes.is_empty() {
registry.emit(GraphEvent::NodesMoved { nodes });
}
}
if was_panning || ev.button() != 0 {
return;
}
if registry.menu_open.get_untracked() {
return;
}
let snapped = registry
.draft_connection
.with_untracked(|dc| dc.as_ref().and_then(|d| d.snap_target.clone()));
if let Some(port_id) = snapped {
let direction = registry.get_port(&port_id).map(|p| p.direction);
if let Some(direction) = direction
&& crate::anchor::try_complete_connection(registry, &port_id, direction)
{
return;
}
}
if let Some(target) = ev.target() {
use leptos::wasm_bindgen::JsCast;
if let Some(el) = target.dyn_ref::<web_sys::Element>() {
let is_anchor = el.closest("[data-anchor]").ok().flatten().is_some();
let is_menu = el.closest("[data-node-menu]").ok().flatten().is_some();
if !is_anchor && !is_menu {
registry.draft_connection.set(None);
}
} else {
registry.draft_connection.set(None);
}
} else {
registry.draft_connection.set(None);
}
}
const NO_ZOOM_SELECTOR: &str =
"[data-node-menu],[data-node-overlay],[data-node-overlay-backdrop],[data-graph-no-zoom]";
fn wheel_scrolls_content(ev: &WheelEvent, container: &web_sys::Element) -> bool {
use leptos::wasm_bindgen::JsCast;
let Some(target) = ev
.target()
.and_then(|t| t.dyn_ref::<web_sys::Element>().cloned())
else {
return false;
};
if target.closest(NO_ZOOM_SELECTOR).ok().flatten().is_some() {
return true;
}
let win = leptos::prelude::window();
let mut node = Some(target);
while let Some(el) = node {
if el.is_same_node(Some(container)) {
return false;
}
let overflows = el.scroll_height() > el.client_height();
if overflows
&& win
.get_computed_style(&el)
.ok()
.flatten()
.and_then(|s| s.get_property_value("overflow-y").ok())
.is_some_and(|o| o == "auto" || o == "scroll")
{
return true;
}
node = el.parent_element();
}
true
}
pub fn handle_wheel<N, P, C, T>(
registry: &EditorRegistry<N, P, C, T>,
ev: WheelEvent,
container_ref: &NodeRef<leptos::html::Div>,
) where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
let scrolls_content = container_ref.with_untracked(|el| {
el.as_ref()
.is_some_and(|el| wheel_scrolls_content(&ev, AsRef::<web_sys::Element>::as_ref(el)))
});
if scrolls_content {
return;
}
ev.prevent_default();
let (min_zoom, max_zoom) = registry.config.with_untracked(|c| (c.min_zoom, c.max_zoom));
let (offset_x, offset_y) = container_ref.with_untracked(|el| {
if let Some(el) = el {
let rect = el.get_bounding_client_rect();
(rect.left(), rect.top())
} else {
(0.0, 0.0)
}
});
let mouse_x = ev.client_x() as f64 - offset_x;
let mouse_y = ev.client_y() as f64 - offset_y;
const ZOOM_STEP: f64 = 0.3;
let dir = if ev.delta_y() < 0.0 { 1.0 } else { -1.0 };
let zoom_factor = (dir * ZOOM_STEP).exp();
registry.viewport.update(|vp| {
let old_zoom = vp.zoom;
let new_zoom = (old_zoom * zoom_factor).clamp(min_zoom, max_zoom);
let scale_change = new_zoom / old_zoom;
vp.pan_x = mouse_x - (mouse_x - vp.pan_x) * scale_change;
vp.pan_y = mouse_y - (mouse_y - vp.pan_y) * scale_change;
vp.zoom = new_zoom;
});
}
pub fn handle_keydown<N, P, C, T>(
registry: &EditorRegistry<N, P, C, T>,
ev: KeyboardEvent,
_container_ref: &NodeRef<leptos::html::Div>,
) where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
if ev.key() == "Alt" {
registry.drag_state.update(latch_group_transfer);
return;
}
if let Some(target) = ev.target() {
use leptos::wasm_bindgen::JsCast;
if let Some(el) = target.dyn_ref::<web_sys::Element>() {
let tag = el.tag_name().to_uppercase();
let editable = matches!(tag.as_str(), "INPUT" | "TEXTAREA" | "SELECT")
|| el.closest("[contenteditable]").ok().flatten().is_some();
if editable {
return;
}
}
}
let key = ev.key();
let ctrl = ev.ctrl_key() || ev.meta_key();
let shift = ev.shift_key();
match key.as_str() {
"Delete" | "Backspace" => {
ev.prevent_default();
registry.delete_selected();
}
"a" if ctrl => {
ev.prevent_default();
registry.select_all();
}
"f" | "F" if !ctrl => {
ev.prevent_default();
registry.fit_view();
}
"c" if ctrl => {
ev.prevent_default();
let ids: Vec<N> = registry
.selected_nodes
.with_untracked(|sel| sel.iter().cloned().collect());
registry.emit(GraphEvent::NodesCopied { ids });
}
"v" if ctrl => {
ev.prevent_default();
registry.emit(GraphEvent::NodesPasted {
offset: Position::new(20.0, 20.0),
});
}
"z" if ctrl && shift => {
ev.prevent_default();
registry.emit(GraphEvent::Redo);
}
"z" if ctrl => {
ev.prevent_default();
registry.emit(GraphEvent::Undo);
}
"g" if ctrl => {
ev.prevent_default();
let ids: Vec<N> = registry
.selected_nodes
.with_untracked(|sel| sel.iter().cloned().collect());
registry.emit(GraphEvent::GroupCreated { node_ids: ids });
}
"Escape" => {
let resize = registry.resize_state.with_untracked(|rs| rs.clone());
if let Some(rs) = resize {
rs.width_signal.set(Some(rs.start_width));
registry.resize_state.set(None);
}
registry.draft_connection.set(None);
registry.clear_selection();
}
_ => {}
}
}
fn latch_group_transfer<N: NodeId>(drag: &mut Option<DragState<N>>) {
if let Some(drag) = drag {
drag.alt_key = true;
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use super::*;
#[test]
fn alt_can_activate_group_transfer_after_drag_start() {
let mut drag = Some(DragState {
node_id: "node".to_string(),
offset: Position::new(10.0, 20.0),
start_positions: HashMap::from([("node".to_string(), Position::new(0.0, 0.0))]),
alt_key: false,
});
latch_group_transfer(&mut drag);
assert!(drag.unwrap().alt_key);
}
}