avenger/marks/
rule.rs

1use crate::marks::value::{ColorOrGradient, EncodingValue, Gradient, StrokeCap};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
5#[serde(rename_all = "kebab-case")]
6pub struct RuleMark {
7    pub name: String,
8    pub clip: bool,
9    pub len: u32,
10    pub gradients: Vec<Gradient>,
11    pub stroke_dash: Option<EncodingValue<Vec<f32>>>,
12    pub x0: EncodingValue<f32>,
13    pub y0: EncodingValue<f32>,
14    pub x1: EncodingValue<f32>,
15    pub y1: EncodingValue<f32>,
16    pub stroke: EncodingValue<ColorOrGradient>,
17    pub stroke_width: EncodingValue<f32>,
18    pub stroke_cap: EncodingValue<StrokeCap>,
19    pub indices: Option<Vec<usize>>,
20    pub zindex: Option<i32>,
21}
22
23impl RuleMark {
24    pub fn x0_iter(&self) -> Box<dyn Iterator<Item = &f32> + '_> {
25        self.x0.as_iter(self.len as usize, self.indices.as_ref())
26    }
27    pub fn y0_iter(&self) -> Box<dyn Iterator<Item = &f32> + '_> {
28        self.y0.as_iter(self.len as usize, self.indices.as_ref())
29    }
30    pub fn x1_iter(&self) -> Box<dyn Iterator<Item = &f32> + '_> {
31        self.x1.as_iter(self.len as usize, self.indices.as_ref())
32    }
33    pub fn y1_iter(&self) -> Box<dyn Iterator<Item = &f32> + '_> {
34        self.y1.as_iter(self.len as usize, self.indices.as_ref())
35    }
36    pub fn stroke_iter(&self) -> Box<dyn Iterator<Item = &ColorOrGradient> + '_> {
37        self.stroke
38            .as_iter(self.len as usize, self.indices.as_ref())
39    }
40    pub fn stroke_width_iter(&self) -> Box<dyn Iterator<Item = &f32> + '_> {
41        self.stroke_width
42            .as_iter(self.len as usize, self.indices.as_ref())
43    }
44    pub fn stroke_cap_iter(&self) -> Box<dyn Iterator<Item = &StrokeCap> + '_> {
45        self.stroke_cap
46            .as_iter(self.len as usize, self.indices.as_ref())
47    }
48    pub fn stroke_dash_iter(&self) -> Option<Box<dyn Iterator<Item = &Vec<f32>> + '_>> {
49        if let Some(stroke_dash) = &self.stroke_dash {
50            Some(stroke_dash.as_iter(self.len as usize, self.indices.as_ref()))
51        } else {
52            None
53        }
54    }
55}
56
57impl Default for RuleMark {
58    fn default() -> Self {
59        Self {
60            name: "rule_mark".to_string(),
61            clip: true,
62            len: 1,
63            gradients: vec![],
64            stroke_dash: None,
65            x0: EncodingValue::Scalar { value: 0.0 },
66            y0: EncodingValue::Scalar { value: 0.0 },
67            x1: EncodingValue::Scalar { value: 0.0 },
68            y1: EncodingValue::Scalar { value: 0.0 },
69            stroke: EncodingValue::Scalar {
70                value: ColorOrGradient::Color([0.0, 0.0, 0.0, 1.0]),
71            },
72            stroke_width: EncodingValue::Scalar { value: 1.0 },
73            stroke_cap: EncodingValue::Scalar {
74                value: StrokeCap::Butt,
75            },
76            indices: None,
77            zindex: None,
78        }
79    }
80}