plcviz 0.3.3

PLC code visualization - graphs, dependencies, and documentation
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

//! SVG styling types

/// RGBA color
#[derive(Debug, Clone, Copy)]
pub struct Color {
    pub r: u8,
    pub g: u8,
    pub b: u8,
    pub a: f32,
}

impl Color {
    pub const fn rgb(r: u8, g: u8, b: u8) -> Self {
        Self { r, g, b, a: 1.0 }
    }

    pub const fn rgba(r: u8, g: u8, b: u8, a: f32) -> Self {
        Self { r, g, b, a }
    }

    pub const BLACK: Color = Color::rgb(0, 0, 0);
    pub const WHITE: Color = Color::rgb(255, 255, 255);
    pub const GRAY: Color = Color::rgb(128, 128, 128);
    pub const LIGHT_GRAY: Color = Color::rgb(200, 200, 200);
    pub const BLUE: Color = Color::rgb(100, 149, 237);
    pub const GREEN: Color = Color::rgb(144, 238, 144);
    pub const YELLOW: Color = Color::rgb(255, 255, 224);
    pub const NONE: Color = Color::rgba(0, 0, 0, 0.0);

    pub fn to_svg(&self) -> String {
        if self.a == 0.0 {
            "none".to_string()
        } else if self.a < 1.0 {
            format!("rgba({},{},{},{})", self.r, self.g, self.b, self.a)
        } else {
            format!("rgb({},{},{})", self.r, self.g, self.b)
        }
    }
}

/// Style for SVG elements
#[derive(Debug, Clone)]
pub struct Style {
    pub fill: Option<Color>,
    pub stroke: Option<Color>,
    pub stroke_width: f64,
    pub font_family: Option<String>,
    pub font_size: Option<f64>,
}

impl Default for Style {
    fn default() -> Self {
        Self {
            fill: None,
            stroke: None,
            stroke_width: 1.0,
            font_family: None,
            font_size: None,
        }
    }
}

impl Style {
    pub fn fill(mut self, color: Color) -> Self {
        self.fill = Some(color);
        self
    }

    pub fn stroke(mut self, color: Color) -> Self {
        self.stroke = Some(color);
        self
    }

    pub fn stroke_width(mut self, width: f64) -> Self {
        self.stroke_width = width;
        self
    }

    pub fn font(mut self, family: &str, size: f64) -> Self {
        self.font_family = Some(family.to_string());
        self.font_size = Some(size);
        self
    }

    pub fn to_svg_attrs(&self) -> String {
        let mut attrs = Vec::new();
        
        if let Some(ref fill) = self.fill {
            attrs.push(format!("fill=\"{}\"", fill.to_svg()));
        }
        
        if let Some(ref stroke) = self.stroke {
            attrs.push(format!("stroke=\"{}\"", stroke.to_svg()));
            attrs.push(format!("stroke-width=\"{}\"", self.stroke_width));
        }
        
        if let Some(ref font) = self.font_family {
            attrs.push(format!("font-family=\"{}\"", font));
        }
        
        if let Some(size) = self.font_size {
            attrs.push(format!("font-size=\"{}\"", size));
        }
        
        attrs.join(" ")
    }
}