zhc_ir 0.4.0

Graph-based intermediate representation framework with dialect support
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::*;
use crate::ValId;
use crate::visualization::svg::PathCommand;
use zhc_utils::graphics::{Frame, Position, Size, Y};

/// A curve connecting points through waypoints.
/// Reads positions from watched cells at render time.
pub struct Curve<C: Class = CurveClass> {
    pub waypoints: Vec<VariableWatch>,
    val_id: Option<ValId>,
    styler: Styler<C>,
    variable: VariableCell,
}

impl<C: Class> Curve<C> {
    pub fn new(
        modifier: Option<StyleModifier>,
        waypoints: Vec<VariableWatch>,
        val_id: Option<ValId>,
    ) -> Self {
        Self {
            waypoints,
            val_id,
            styler: Styler::new(modifier),
            variable: VariableCell::fresh(),
        }
    }

    /// Returns positions by reading frames from watched cells.
    /// First waypoint uses bottom_center (source port).
    /// Last waypoint uses top_center (destination port).
    /// Intermediate waypoints use center (dummies).
    pub fn get_positions(&self) -> Vec<Position> {
        let len = self.waypoints.len();
        self.waypoints
            .iter()
            .enumerate()
            .map(|(i, watch)| {
                let frame = watch.get_frame();
                if i == 0 {
                    frame.bottom_center()
                } else if i == len - 1 {
                    frame.top_center()
                } else {
                    frame.center()
                }
            })
            .collect()
    }
}

impl<C: Class> SceneElement for Curve<C> {
    fn get_size(&self) -> Size {
        self.variable.get_size()
    }

    fn get_frame(&self) -> Frame {
        self.variable.get_frame()
    }

    fn get_variable_cell(&self) -> VariableCell {
        self.variable.clone()
    }
}

impl<C: Class> Renderable for Curve<C> {
    fn render(&self) -> Vec<SvgElement> {
        let positions = self.get_positions();
        if positions.len() < 2 {
            return vec![];
        }

        let style = self.styler.get();
        let mut commands = Vec::new();
        commands.push(PathCommand::MoveTo(positions[0]));

        // Generate cubic bezier segments between consecutive waypoints
        for i in 0..positions.len() - 1 {
            let start = positions[i];
            let end = positions[i + 1];

            // Control points: vertical offset for smooth curves
            let dy = (end.y.0 - start.y.0) / 3.0;
            let cp1 = Position {
                x: start.x,
                y: Y::new(start.y.0 + dy),
            };
            let cp2 = Position {
                x: end.x,
                y: Y::new(end.y.0 - dy),
            };

            commands.push(PathCommand::CubicTo(cp1, cp2, end));
        }

        vec![
            // Invisible wider hit area for easier hover detection
            SvgElement::Path {
                commands: commands.clone(),
                fill: Some("none".into()),
                stroke: Some("transparent".into()),
                stroke_width: Some(12.0),
                class: Some("link-hitarea".into()),
                id: None,
                title: None,
                data_val: self.val_id,
            },
            // Visible curve
            SvgElement::Path {
                commands,
                fill: Some("none".into()),
                stroke: Some(style.border_color.to_string()),
                stroke_width: Some(style.border_width.0),
                class: Some("link".into()),
                id: None,
                title: None,
                data_val: self.val_id,
            },
        ]
    }
}