Skip to main content

fc_ui/capabilities/data/
pie_chart.rs

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}