orrery 0.4.1

A diagram language for creating component and sequence diagrams
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

//! SVG rendering for sequence diagrams.

use orrery_core::{
    draw::{Drawable, Fragment, LayeredOutput, Note, PositionedArrowWithText, PositionedDrawable},
    geometry::{Bounds, Point},
};

use super::Svg;
use crate::layout::{layer::ContentStack, sequence};

impl Svg {
    /// Renders a sequence diagram participant to layered SVG output.
    pub fn render_participant(&self, participant: &sequence::Participant) -> LayeredOutput {
        let mut output = LayeredOutput::new();
        let component = participant.component();

        // Use the renderer to generate the SVG for the participant
        let shape_output = component.drawable().render_to_layers();
        output.merge(shape_output);

        // Render the pre-positioned lifeline from the participant
        let lifeline_output = participant.lifeline().render_to_layers();
        output.merge(lifeline_output);

        output
    }

    /// Renders a positioned message arrow to layered SVG output.
    pub fn render_message(&mut self, message: &PositionedArrowWithText) -> LayeredOutput {
        message.render_to_layers(&mut self.arrow_with_text_drawer)
    }

    /// Renders a fragment box in a sequence diagram.
    ///
    /// Converts a fragment into its SVG representation.
    ///
    /// # Arguments
    ///
    /// * `fragment` - The fragment to render with its sections and bounds.
    ///
    /// # Returns
    ///
    /// A [`LayeredOutput`] representing the fragment.
    pub fn render_fragment(&self, fragment: &PositionedDrawable<Fragment>) -> LayeredOutput {
        fragment.render_to_layers()
    }

    /// Renders a note in a sequence diagram.
    ///
    /// Converts a note into its SVG representation.
    ///
    /// # Arguments
    ///
    /// * `note` - The positioned note to render.
    ///
    /// # Returns
    ///
    /// A [`LayeredOutput`] representing the note.
    pub fn render_note(&self, note: &PositionedDrawable<Note>) -> LayeredOutput {
        note.render_to_layers()
    }

    /// Renders an activation box at its stored participant X and center Y.
    pub fn render_activation_box(&self, activation_box: &sequence::ActivationBox) -> LayeredOutput {
        let position = Point::new(activation_box.participant_x(), activation_box.center_y());

        activation_box.drawable().render_to_layers(position)
    }

    pub fn calculate_sequence_diagram_bounds(
        &self,
        content_stack: &ContentStack<sequence::Layout>,
    ) -> Bounds {
        let last_positioned_content = content_stack.iter().last();
        last_positioned_content
            .map(|positioned_content| {
                let layout = &positioned_content.content();

                if layout.participants().is_empty() {
                    return Bounds::default();
                }

                let mut content_bounds = layout
                    .participants()
                    .values()
                    .map(|p| p.component().bounds())
                    .reduce(|acc, bounds| acc.merge(&bounds))
                    .unwrap_or_default();

                // Include notes in bounds calculation
                for note in layout.notes() {
                    let note_bounds = note.position().to_bounds(note.size());
                    content_bounds = content_bounds.merge(&note_bounds);
                }

                content_bounds.with_max_y(layout.max_lifeline_end())
            })
            .unwrap_or_default()
    }
}