egui_xyflow 0.2.0

An interactive node-graph editor widget for egui, inspired by xyflow (React Flow)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Handle rendering (connection point circles on nodes).

use crate::config::FlowConfig;
use crate::edges::positions::get_handle_absolute_position;
use crate::graph::node_position::flow_to_screen;
use crate::types::node::InternalNode;
use crate::types::position::Transform;

/// Render handles for a node. Returns handle rects for hit-testing.
pub(crate) fn render_handles<D>(
    painter: &egui::Painter,
    node: &InternalNode<D>,
    transform: &Transform,
    config: &FlowConfig,
    hovered_node: bool,
    pointer_pos: Option<egui::Pos2>,
) -> Vec<HandleHitRect> {
    let source_count = node.internals.handle_bounds.source.len();
    let target_count = node.internals.handle_bounds.target.len();
    let mut hit_rects = Vec::with_capacity(source_count + target_count);
    let handle_radius = config.handle_size * 0.5 * transform.scale;

    let all_handles = node
        .internals
        .handle_bounds
        .source
        .iter()
        .chain(node.internals.handle_bounds.target.iter());

    for handle in all_handles {
        let abs_pos = get_handle_absolute_position(node, handle);
        let screen_pos = flow_to_screen(abs_pos, transform);

        // Closest handles are invisible — still register a hit rect for
        // connection dragging but skip the visual circle.
        if handle.position != crate::types::position::Position::Closest {
            let is_hovered = pointer_pos
                .map(|p| p.distance(screen_pos) < handle_radius * 2.0)
                .unwrap_or(false);

            let color = if is_hovered {
                config.handle_hover_color
            } else if hovered_node {
                config.handle_color
            } else {
                // Semi-transparent when node not hovered
                let c = config.handle_color;
                egui::Color32::from_rgba_unmultiplied(c.r(), c.g(), c.b(), 128)
            };

            painter.circle_filled(screen_pos, handle_radius, color);
            painter.circle_stroke(
                screen_pos,
                handle_radius,
                egui::Stroke::new(1.0, egui::Color32::WHITE),
            );
        }

        hit_rects.push(HandleHitRect {
            screen_center: screen_pos,
            radius: handle_radius * 1.5, // Slightly larger hit area
            handle: handle.clone(),
        });
    }

    hit_rects
}

#[derive(Debug, Clone)]
pub(crate) struct HandleHitRect {
    pub(crate) screen_center: egui::Pos2,
    pub(crate) radius: f32,
    pub(crate) handle: crate::types::handle::Handle,
}

impl HandleHitRect {
    pub(crate) fn contains(&self, pos: egui::Pos2) -> bool {
        pos.distance(self.screen_center) <= self.radius
    }
}