esoc-chart 0.1.0

High-level charting API built on esoc-gfx — matplotlib-equivalent 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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// SPDX-License-Identifier: MIT OR Apache-2.0
//! Legend rendering for chart series.

use esoc_gfx::canvas::Canvas;
use esoc_gfx::color::Color;
use esoc_gfx::element::{DrawElement, Element};
use esoc_gfx::geom::Rect;
use esoc_gfx::layer::Layer;
use esoc_gfx::style::{Fill, FontStyle, Stroke, TextAnchor};

use crate::theme::Theme;

/// Legend position relative to the plot area.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum LegendPosition {
    /// Upper-right corner (default).
    #[default]
    UpperRight,
    /// Upper-left corner.
    UpperLeft,
    /// Lower-right corner.
    LowerRight,
    /// Lower-left corner.
    LowerLeft,
}

/// A single legend entry.
#[derive(Clone, Debug)]
pub struct LegendEntry {
    /// Series label.
    pub label: String,
    /// Series color.
    pub color: Color,
}

/// Render a legend onto a canvas.
pub fn render_legend(
    canvas: &mut Canvas,
    plot_area: Rect,
    entries: &[LegendEntry],
    position: LegendPosition,
    theme: &Theme,
) {
    if entries.is_empty() {
        return;
    }

    let row_height = theme.legend_font_size * 1.6;
    let swatch_size = theme.legend_font_size * 0.8;
    let padding = 8.0;
    let gap = 6.0;

    // Estimate legend box size
    let text_measurer = esoc_gfx::text::HeuristicTextMeasurer;
    let max_label_width = entries
        .iter()
        .map(|e| {
            esoc_gfx::text::TextMeasurer::measure_width(
                &text_measurer,
                &e.label,
                theme.legend_font_size,
            )
        })
        .fold(0.0_f64, f64::max);

    let box_width = padding * 2.0 + swatch_size + gap + max_label_width;
    let box_height = padding * 2.0 + entries.len() as f64 * row_height;

    // Position the legend box
    let (bx, by) = match position {
        LegendPosition::UpperRight => (plot_area.right() - box_width - 10.0, plot_area.y + 10.0),
        LegendPosition::UpperLeft => (plot_area.x + 10.0, plot_area.y + 10.0),
        LegendPosition::LowerRight => (
            plot_area.right() - box_width - 10.0,
            plot_area.bottom() - box_height - 10.0,
        ),
        LegendPosition::LowerLeft => (plot_area.x + 10.0, plot_area.bottom() - box_height - 10.0),
    };

    // Background box
    canvas.add(DrawElement::new(
        Element::Rect {
            rect: Rect::new(bx, by, box_width, box_height),
            fill: Fill::Solid(theme.background.with_alpha(0.9)),
            stroke: Some(Stroke::solid(theme.grid_color, 0.5)),
            rx: 3.0,
        },
        Layer::Legend,
    ));

    // Entries
    for (i, entry) in entries.iter().enumerate() {
        let ey = by + padding + i as f64 * row_height + row_height / 2.0;

        // Color swatch
        canvas.add(DrawElement::new(
            Element::Rect {
                rect: Rect::new(
                    bx + padding,
                    ey - swatch_size / 2.0,
                    swatch_size,
                    swatch_size,
                ),
                fill: Fill::Solid(entry.color),
                stroke: None,
                rx: 2.0,
            },
            Layer::Legend,
        ));

        // Label
        let font = FontStyle {
            family: theme.font_family.clone(),
            size: theme.legend_font_size,
            weight: 400,
            color: theme.foreground,
            anchor: TextAnchor::Start,
        };
        canvas.add(DrawElement::new(
            Element::text(
                bx + padding + swatch_size + gap,
                ey + theme.legend_font_size * 0.35,
                &entry.label,
                font,
            ),
            Layer::Legend,
        ));
    }
}