1use crate::capabilities::data::pie_geometry::{
2 color_at_angle, positive_finite_total, render_legend, segment_geometry,
3};
4use crate::capabilities::foundation::theme::use_theme;
5use gpui::{prelude::FluentBuilder as _, *};
6
7fn pixels_to_f32(p: Pixels) -> f32 {
8 p / px(1.0)
9}
10
11#[derive(Clone)]
12pub struct PieChartSegment {
13 pub label: SharedString,
14 pub value: f64,
15 pub color: Option<Hsla>,
16}
17
18impl PieChartSegment {
19 pub fn new(label: impl Into<SharedString>, value: f64) -> Self {
20 Self {
21 label: label.into(),
22 value: value.max(0.0),
23 color: None,
24 }
25 }
26
27 pub fn color(mut self, color: Hsla) -> Self {
28 self.color = Some(color);
29 self
30 }
31}
32
33#[derive(Copy, Clone, Default, PartialEq, Eq)]
34pub enum PieChartVariant {
35 #[default]
36 Pie,
37 Donut,
38}
39
40#[derive(Copy, Clone, Default, PartialEq, Eq)]
41pub enum PieChartLabelPosition {
42 #[default]
43 None,
44 Legend,
45}
46
47#[derive(Copy, Clone, Default, PartialEq, Eq)]
48pub enum PieChartSize {
49 Sm,
50 #[default]
51 Md,
52 Lg,
53 Custom(u32),
54}
55
56impl PieChartSize {
57 fn to_pixels(self) -> Pixels {
58 match self {
59 PieChartSize::Sm => px(120.0),
60 PieChartSize::Md => px(200.0),
61 PieChartSize::Lg => px(280.0),
62 PieChartSize::Custom(size) => px(size as f32),
63 }
64 }
65}
66
67#[derive(IntoElement)]
68pub struct PieChart {
69 segments: Vec<PieChartSegment>,
70 variant: PieChartVariant,
71 label_position: PieChartLabelPosition,
72 show_percentages: bool,
73 center_label: Option<SharedString>,
74 size: PieChartSize,
75 donut_thickness: f32,
76 style: StyleRefinement,
77}
78
79impl PieChart {
80 pub fn new(segments: Vec<PieChartSegment>) -> Self {
81 Self {
82 segments,
83 variant: PieChartVariant::Pie,
84 label_position: PieChartLabelPosition::None,
85 show_percentages: false,
86 center_label: None,
87 size: PieChartSize::Md,
88 donut_thickness: 0.35,
89 style: StyleRefinement::default(),
90 }
91 }
92
93 pub fn pie(segments: Vec<PieChartSegment>) -> Self {
94 Self::new(segments).variant(PieChartVariant::Pie)
95 }
96
97 pub fn donut(segments: Vec<PieChartSegment>) -> Self {
98 Self::new(segments).variant(PieChartVariant::Donut)
99 }
100
101 pub fn variant(mut self, variant: PieChartVariant) -> Self {
102 self.variant = variant;
103 self
104 }
105
106 pub fn size(mut self, size: PieChartSize) -> Self {
107 self.size = size;
108 self
109 }
110
111 pub fn size_px(mut self, size_val: u32) -> Self {
112 self.size = PieChartSize::Custom(size_val);
113 self
114 }
115
116 pub fn show_percentages(mut self, show: bool) -> Self {
117 self.show_percentages = show;
118 self
119 }
120
121 pub fn center_label(mut self, label: impl Into<SharedString>) -> Self {
122 self.center_label = Some(label.into());
123 self
124 }
125
126 pub fn donut_thickness(mut self, thickness: f32) -> Self {
127 self.donut_thickness = thickness.clamp(0.1, 0.9);
128 self
129 }
130
131 pub fn label_position(mut self, position: PieChartLabelPosition) -> Self {
132 self.label_position = position;
133 self
134 }
135}
136
137impl Styled for PieChart {
138 fn style(&mut self) -> &mut StyleRefinement {
139 &mut self.style
140 }
141}
142
143impl RenderOnce for PieChart {
144 fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
145 let chart_size = self.size.to_pixels();
146 let show_legend = self.label_position == PieChartLabelPosition::Legend;
147 let show_percentages = self.show_percentages;
148 let user_style = self.style;
149
150 let total = positive_finite_total(&self.segments);
151
152 let chart = if total == 0.0 || self.segments.is_empty() {
153 render_empty_chart(chart_size, cx)
154 } else {
155 render_pie_chart(
156 chart_size,
157 &self.segments,
158 total,
159 self.variant,
160 self.donut_thickness,
161 self.center_label.clone(),
162 cx,
163 )
164 };
165
166 let legend = if show_legend {
167 Some(render_legend(
168 &self.segments,
169 total,
170 show_percentages,
171 &use_theme(cx),
172 ))
173 } else {
174 None
175 };
176
177 div()
178 .flex()
179 .gap(px(24.0))
180 .items_center()
181 .child(chart)
182 .when_some(legend, |this, legend| this.child(legend))
183 .map(|this| {
184 let mut d = this;
185 d.style().refine(&user_style);
186 d
187 })
188 }
189}
190
191fn render_pie_chart(
192 chart_size: Pixels,
193 segments: &[PieChartSegment],
194 total: f64,
195 variant: PieChartVariant,
196 donut_thickness: f32,
197 center_label: Option<SharedString>,
198 cx: &App,
199) -> Div {
200 let theme = use_theme(cx);
201 let size_f32 = pixels_to_f32(chart_size);
202 let center = size_f32 * 0.5;
203 let outer_radius = size_f32 * 0.5;
204 let inner_radius = if variant == PieChartVariant::Donut {
205 outer_radius * (1.0 - donut_thickness)
206 } else {
207 0.0
208 };
209
210 let segment_data = segment_geometry(segments, total);
211
212 if segment_data.len() == 1 {
213 return render_single_segment(
214 chart_size,
215 segment_data[0].color,
216 inner_radius,
217 variant,
218 center_label,
219 cx,
220 );
221 }
222
223 let ring_width = outer_radius - inner_radius;
224 let ring_count = ((ring_width / 3.0).max(1.0) as usize).min(20);
225
226 let mut container = div()
227 .size(chart_size)
228 .rounded(px(9999.0))
229 .relative()
230 .overflow_hidden();
231
232 for ring_idx in 0..ring_count {
233 let ring_radius = inner_radius + (ring_idx as f32 + 0.5) * (ring_width / ring_count as f32);
234 let circumference = std::f32::consts::TAU * ring_radius;
235 let dots_in_ring = (circumference / 4.0).max(16.0) as usize;
236
237 for i in 0..dots_in_ring {
238 let angle = -std::f32::consts::FRAC_PI_2
239 + (i as f32 / dots_in_ring as f32) * std::f32::consts::TAU;
240 let color = color_at_angle(angle, &segment_data);
241 let x = center + ring_radius * angle.cos() - 2.0;
242 let y = center + ring_radius * angle.sin() - 2.0;
243
244 container = container.child(
245 div()
246 .absolute()
247 .size(px(5.0))
248 .rounded(px(9999.0))
249 .bg(color)
250 .left(px(x))
251 .top(px(y)),
252 );
253 }
254 }
255
256 if variant == PieChartVariant::Donut {
257 let inner_size = inner_radius * 2.0 - 4.0;
258 let inner_offset = center - inner_radius + 2.0;
259
260 container = container.child(
261 div()
262 .absolute()
263 .size(px(inner_size))
264 .rounded(px(9999.0))
265 .bg(theme.tokens.background)
266 .left(px(inner_offset))
267 .top(px(inner_offset))
268 .flex()
269 .items_center()
270 .justify_center()
271 .when_some(center_label, |this, label| {
272 this.child(
273 div()
274 .text_sm()
275 .font_weight(FontWeight::SEMIBOLD)
276 .text_color(theme.tokens.foreground)
277 .child(label),
278 )
279 }),
280 );
281 }
282
283 container
284}
285
286fn render_single_segment(
287 chart_size: Pixels,
288 color: Hsla,
289 inner_radius: f32,
290 variant: PieChartVariant,
291 center_label: Option<SharedString>,
292 cx: &App,
293) -> Div {
294 let theme = use_theme(cx);
295 let size_f32 = pixels_to_f32(chart_size);
296 let center = size_f32 * 0.5;
297
298 let mut container = div()
299 .size(chart_size)
300 .rounded(px(9999.0))
301 .relative()
302 .bg(color);
303
304 if variant == PieChartVariant::Donut {
305 let inner_size = inner_radius * 2.0;
306 let inner_offset = center - inner_radius;
307
308 container = container.child(
309 div()
310 .absolute()
311 .size(px(inner_size))
312 .rounded(px(9999.0))
313 .bg(theme.tokens.background)
314 .left(px(inner_offset))
315 .top(px(inner_offset))
316 .flex()
317 .items_center()
318 .justify_center()
319 .when_some(center_label, |this, label| {
320 this.child(
321 div()
322 .text_sm()
323 .font_weight(FontWeight::SEMIBOLD)
324 .text_color(theme.tokens.foreground)
325 .child(label),
326 )
327 }),
328 );
329 }
330
331 container
332}
333
334fn render_empty_chart(chart_size: Pixels, cx: &App) -> Div {
335 let theme = use_theme(cx);
336
337 div()
338 .size(chart_size)
339 .rounded(px(9999.0))
340 .bg(theme.tokens.muted)
341 .flex()
342 .items_center()
343 .justify_center()
344 .child(
345 div()
346 .text_sm()
347 .text_color(theme.tokens.muted_foreground)
348 .child("No data"),
349 )
350}