1use serde::{Deserialize, Serialize};
4
5use crate::node::{Common, IntoNode, Node};
6use crate::style::Style;
7use crate::text::{Line, Span};
8
9#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
11#[serde(rename_all = "camelCase")]
12pub struct Gauge {
13 #[serde(flatten)]
15 pub common: Common,
16 #[serde(default, skip_serializing_if = "Option::is_none")]
18 pub ratio: Option<f64>,
19 #[serde(default, skip_serializing_if = "Option::is_none")]
21 pub percent: Option<u16>,
22 #[serde(default, skip_serializing_if = "Option::is_none")]
24 pub label: Option<Span>,
25 #[serde(default, skip_serializing_if = "Option::is_none")]
27 pub gauge_style: Option<Style>,
28 #[serde(default, skip_serializing_if = "Option::is_none")]
30 pub use_unicode: Option<bool>,
31}
32
33impl Gauge {
34 #[must_use]
36 pub fn new() -> Self {
37 Self {
38 common: Common::new(),
39 ratio: None,
40 percent: None,
41 label: None,
42 gauge_style: None,
43 use_unicode: None,
44 }
45 }
46
47 #[must_use]
49 pub fn ratio(mut self, ratio: f64) -> Self {
50 self.ratio = Some(ratio);
51 self
52 }
53
54 #[must_use]
56 pub fn percent(mut self, percent: u16) -> Self {
57 self.percent = Some(percent);
58 self
59 }
60
61 #[must_use]
63 pub fn label(mut self, label: impl Into<Span>) -> Self {
64 self.label = Some(label.into());
65 self
66 }
67
68 #[must_use]
70 pub fn gauge_style(mut self, style: Style) -> Self {
71 self.gauge_style = Some(style);
72 self
73 }
74
75 #[must_use]
77 pub fn use_unicode(mut self, use_unicode: bool) -> Self {
78 self.use_unicode = Some(use_unicode);
79 self
80 }
81}
82
83impl Default for Gauge {
84 fn default() -> Self {
85 Self::new()
86 }
87}
88
89impl IntoNode for Gauge {}
90impl From<Gauge> for Node {
91 fn from(g: Gauge) -> Self {
92 Node::Gauge(g)
93 }
94}
95
96#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
98pub enum LineSet {
99 #[default]
101 Normal,
102 Thick,
104 Double,
106}
107
108#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
110#[serde(rename_all = "camelCase")]
111pub struct LineGauge {
112 #[serde(flatten)]
114 pub common: Common,
115 pub ratio: f64,
117 #[serde(default, skip_serializing_if = "Option::is_none")]
119 pub label: Option<Line>,
120 #[serde(default, skip_serializing_if = "Option::is_none")]
122 pub filled_style: Option<Style>,
123 #[serde(default, skip_serializing_if = "Option::is_none")]
125 pub unfilled_style: Option<Style>,
126 #[serde(default, skip_serializing_if = "Option::is_none")]
128 pub line_set: Option<LineSet>,
129}
130
131impl LineGauge {
132 #[must_use]
134 pub fn new(ratio: f64) -> Self {
135 Self {
136 common: Common::new(),
137 ratio,
138 label: None,
139 filled_style: None,
140 unfilled_style: None,
141 line_set: None,
142 }
143 }
144
145 #[must_use]
147 pub fn label(mut self, label: impl Into<Line>) -> Self {
148 self.label = Some(label.into());
149 self
150 }
151
152 #[must_use]
154 pub fn filled_style(mut self, style: Style) -> Self {
155 self.filled_style = Some(style);
156 self
157 }
158
159 #[must_use]
161 pub fn unfilled_style(mut self, style: Style) -> Self {
162 self.unfilled_style = Some(style);
163 self
164 }
165
166 #[must_use]
168 pub fn line_set(mut self, line_set: LineSet) -> Self {
169 self.line_set = Some(line_set);
170 self
171 }
172}
173
174impl Default for LineGauge {
175 fn default() -> Self {
176 Self::new(0.0)
177 }
178}
179
180impl IntoNode for LineGauge {}
181impl From<LineGauge> for Node {
182 fn from(g: LineGauge) -> Self {
183 Node::LineGauge(g)
184 }
185}