veusz 0.1.2

Veusz command line and embedding interface (API) for Rust
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

use crate::api1::{cmd, AsVueszApi1ValueStr};
use crate::style::line::LineStyle;
use crate::style::ColorName;
use crate::CommandLineEmbeddingInterface;
use std::io::Write;

#[derive(Default)]
pub struct PlotLine {
    color: Option<String>,
    width: Option<f32>,
    style: Option<LineStyle>,
    transparency: Option<u8>,
    scale: Option<bool>,
    hide: Option<bool>,
}

impl PlotLine {
    pub fn set_color(&mut self, color: impl Into<String>) {
        self.color = Some(color.into());
    }

    pub fn with_color(mut self, color: impl Into<String>) -> Self {
        self.set_color(color);
        self
    }

    pub fn set_color_by_name(&mut self, color_name: ColorName) {
        self.color = Some(color_name.as_veusz_api1_value_str().to_string());
    }

    pub fn with_color_by_name(mut self, color_name: ColorName) -> Self {
        self.set_color_by_name(color_name);
        self
    }

    pub fn set_width(&mut self, pt: f32) {
        self.width = Some(pt);
    }

    pub fn with_width(mut self, pt: f32) -> Self {
        self.set_width(pt);
        self
    }

    pub fn set_style(&mut self, style: LineStyle) {
        self.style = Some(style);
    }

    pub fn with_style(mut self, style: LineStyle) -> Self {
        self.set_style(style);
        self
    }

    pub fn set_transparency(&mut self, transparency: u8) {
        self.transparency = Some(transparency);
    }

    pub fn with_transparency(mut self, transparency: u8) -> Self {
        self.set_transparency(transparency);
        self
    }

    pub fn set_scale(&mut self, scale: bool) {
        self.scale = Some(scale);
    }

    pub fn with_scale(mut self, scale: bool) -> Self {
        self.set_scale(scale);
        self
    }

    pub fn set_hide(&mut self, hide: bool) {
        self.hide = Some(hide);
    }

    pub fn with_hide(mut self, hide: bool) -> Self {
        self.set_hide(hide);
        self
    }
}

impl CommandLineEmbeddingInterface for PlotLine {
    fn write<W: Write>(&self, writer: &mut W) -> std::io::Result<()> {
        if let Some(color) = &self.color {
            cmd::Set("PlotLine/color", color).write(writer)?;
        }

        if let Some(width) = &self.width {
            cmd::Set("PlotLine/width", &format!("{width}pt")).write(writer)?;
        }

        if let Some(style) = &self.style {
            cmd::Set("PlotLine/style", style.as_veusz_api1_value_str()).write(writer)?;
        }

        if let Some(transparency) = &self.transparency {
            cmd::SetRaw("PlotLine/transparency", transparency).write(writer)?;
        }

        if let Some(scale) = &self.scale {
            cmd::Set("PlotLine/scaleLine", scale.as_veusz_api1_value_str()).write(writer)?;
        }

        if let Some(hide) = &self.hide {
            cmd::SetRaw("PlotLine/hide", hide.as_veusz_api1_value_str()).write(writer)?;
        }

        Ok(())
    }
}