duhanbalci/dreport
1
0
Fork 0
mirror of https://github.com/duhanbalci/dreport.git synced 2026-07-02 02:49:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

bug fixes & improvements & missing features & font loader

Browse Source
This commit is contained in:
Duhan BALCI
2026-04-07 00:36:21 +03:00
parent ad0d2fda0a
commit b6287906a9
50 changed files with 4087 additions and 1843 deletions
Download Patch File Download Diff File Expand all files Collapse all files

715
layout-engine/src/chart_render.rs
View File

@@ -1,15 +1,10 @@
use crate::chart_layout::{
self, color_at, compute_bar_layout, compute_chart_layout, compute_legend,
compute_line_layout, compute_pie_layout, format_value, ChartLayout,
};
use crate::data_resolve::ResolvedChartData;
use dreport_core::models::{ChartType, GroupMode};
use std::fmt::Write;
pub const DEFAULT_COLORS: &[&str] = &[
"#4F46E5", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6", "#EC4899", "#06B6D4", "#84CC16",
];
fn color_at(palette: &[String], i: usize) -> &str {
&palette[i % palette.len()]
}
/// mm cinsinden chart SVG uret
pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> String {
let mut svg = String::with_capacity(4096);
@@ -33,134 +28,40 @@ pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> St
)
.unwrap();
// Max sayida renk: kategoriler + seriler
let n_colors = data.categories.len().max(data.series.len()).max(1);
let palette: Vec<String> = (0..n_colors)
.map(|i| {
if let Some(ref user_colors) = data.style.colors {
if i < user_colors.len() {
return user_colors[i].clone();
}
}
DEFAULT_COLORS[i % DEFAULT_COLORS.len()].to_string()
})
.collect();
// Margin hesaplari
let mut margin_top = 2.0_f64;
let mut margin_bottom = 4.0_f64;
let mut margin_left = 8.0_f64;
let margin_right = 4.0_f64;
let cl = compute_chart_layout(data, width_mm, height_mm, 0.0, 0.0);
// Title
if let Some(ref title) = data.title {
if !title.text.is_empty() {
let font_size = title.font_size.unwrap_or(4.0);
margin_top += font_size * 0.4 + 2.0;
let color = title.color.as_deref().unwrap_or("#333333");
let align = title.align.as_deref().unwrap_or("center");
let x = match align {
"left" => margin_left,
"right" => width_mm - margin_right,
_ => width_mm / 2.0,
};
let anchor = match align {
"left" => "start",
"right" => "end",
_ => "middle",
};
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="{}" font-weight="bold">{}</text>"##,
x,
margin_top - 1.0,
font_size,
color,
anchor,
escape_xml(&title.text)
)
.unwrap();
}
}
// Legend space
let legend_show = data.legend.as_ref().is_some_and(|l| l.show);
let legend_pos = data
.legend
.as_ref()
.and_then(|l| l.position.as_deref())
.unwrap_or("bottom");
let legend_font = data
.legend
.as_ref()
.and_then(|l| l.font_size)
.unwrap_or(2.8);
if legend_show && data.series.len() > 1 {
match legend_pos {
"top" => margin_top += legend_font + 3.0,
"bottom" => margin_bottom += legend_font + 3.0,
_ => {} // right — icerde handle edilecek
}
}
// Axis labels icin yer ac (bar ve line)
let has_axis = !matches!(data.chart_type, ChartType::Pie);
if has_axis {
if data.axis.as_ref().and_then(|a| a.x_label.as_ref()).is_some() {
margin_bottom += 4.0;
}
if data.axis.as_ref().and_then(|a| a.y_label.as_ref()).is_some() {
margin_left += 4.0;
}
// Category labels icin alt bosluk
let max_label_len = data.categories.iter().map(|c| c.len()).max().unwrap_or(0);
let n_cats = data.categories.len();
let available_w = width_mm - margin_left - margin_right;
let cat_width = if n_cats > 0 {
available_w / n_cats as f64
} else {
available_w
if let Some(ref title) = cl.title {
let anchor = match title.align.as_str() {
"left" => "start",
"right" => "end",
_ => "middle",
};
let max_chars_fit = (cat_width / 1.25).max(1.0) as usize;
let will_rotate = max_label_len > max_chars_fit;
if will_rotate {
// Rotated labels (-45°): dikey ≈ text_width * sin(45°), yatay ≈ text_width * cos(45°)
let char_w_mm = 1.1;
let max_text_w = max_label_len as f64 * char_w_mm;
let label_v = max_text_w * 0.707; // sin(45°)
margin_bottom += label_v.min(25.0).max(6.0);
// Sol taraftaki label yana tasabilir
let label_h = max_text_w * 0.707; // cos(45°)
let extra_left = (label_h - cat_width / 2.0).max(0.0);
margin_left += extra_left.min(10.0);
} else {
margin_bottom += 4.0;
}
// Y-axis value labels icin sol bosluk
margin_left += 6.0;
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="{}" font-weight="bold">{}</text>"##,
title.x, title.y, title.font_size, title.color, anchor, escape_xml(&title.text)
)
.unwrap();
}
let plot_x = margin_left;
let plot_y = margin_top;
let plot_w = (width_mm - margin_left - margin_right).max(1.0);
let plot_h = (height_mm - margin_top - margin_bottom).max(1.0);
match data.chart_type {
ChartType::Bar => render_bar(&mut svg, data, &palette, plot_x, plot_y, plot_w, plot_h),
ChartType::Line => render_line(&mut svg, data, &palette, plot_x, plot_y, plot_w, plot_h),
ChartType::Pie => render_pie(&mut svg, data, &palette, width_mm, height_mm, plot_x, plot_y, plot_w, plot_h),
dreport_core::models::ChartType::Bar => render_bar(&mut svg, data, &cl),
dreport_core::models::ChartType::Line => render_line(&mut svg, data, &cl),
dreport_core::models::ChartType::Pie => render_pie(&mut svg, data, &cl),
}
// Legend render
if legend_show && data.series.len() > 1 {
render_legend(&mut svg, data, &palette, legend_pos, legend_font, width_mm, height_mm, margin_left, margin_top, plot_w, plot_h);
if cl.legend_show && data.series.len() > 1 {
render_legend(&mut svg, data, &cl, width_mm, height_mm);
}
// Axis labels
let has_axis = !matches!(data.chart_type, dreport_core::models::ChartType::Pie);
if has_axis {
if let Some(ref axis) = data.axis {
if let Some(ref x_label) = axis.x_label {
let x = plot_x + plot_w / 2.0;
let x = cl.plot_x + cl.plot_w / 2.0;
let y = height_mm - 2.0;
write!(
svg,
@@ -171,7 +72,7 @@ pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> St
}
if let Some(ref y_label) = axis.y_label {
let x = 3.0;
let y = plot_y + plot_h / 2.0;
let y = cl.plot_y + cl.plot_h / 2.0;
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.8" fill="#666" text-anchor="middle" transform="rotate(-90,{:.2},{:.2})">{}</text>"##,
@@ -186,199 +87,91 @@ pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> St
svg
}
fn render_bar(
svg: &mut String,
data: &ResolvedChartData,
palette: &[String],
px: f64,
py: f64,
pw: f64,
ph: f64,
) {
fn render_bar(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout) {
if data.categories.is_empty() || data.series.is_empty() {
return;
}
let stacked = matches!(data.group_mode, Some(GroupMode::Stacked));
let (min_val, max_val) = value_range(data, stacked);
let bl = compute_bar_layout(data, cl);
let show_grid = data.axis.as_ref().and_then(|a| a.show_grid).unwrap_or(true);
let grid_color = data
.axis
.as_ref()
.and_then(|a| a.grid_color.as_deref())
.unwrap_or("#E5E7EB");
// Y axis
render_y_axis_svg(svg, &bl.y_axis);
// Grid + Y axis labels
render_y_axis(svg, min_val, max_val, px, py, pw, ph, show_grid, grid_color);
// Bars
for bar in &bl.bars {
let color = color_at(&cl.palette, bar.color_idx);
write!(
svg,
r##"<rect x="{:.2}" y="{:.2}" width="{:.2}" height="{:.2}" fill="{}" rx="0.5"/>"##,
bar.x, bar.y, bar.w, bar.h, color
)
.unwrap();
let n_cats = data.categories.len();
let n_series = data.series.len();
let cat_width = pw / n_cats as f64;
let bar_gap = data.style.bar_gap.unwrap_or(0.2).clamp(0.0, 0.8);
let group_width = cat_width * (1.0 - bar_gap);
let show_labels = data.labels.as_ref().is_some_and(|l| l.show);
let label_font = data.labels.as_ref().and_then(|l| l.font_size).unwrap_or(2.2);
let label_color = data
.labels
.as_ref()
.and_then(|l| l.color.as_deref())
.unwrap_or("#333");
let range = if (max_val - min_val).abs() < 1e-10 {
1.0
} else {
max_val - min_val
};
for ci in 0..data.categories.len() {
let cat_x = px + ci as f64 * cat_width;
if stacked {
let mut y_offset = 0.0_f64;
for (si, series) in data.series.iter().enumerate() {
let val = series.values.get(ci).copied().unwrap_or(0.0);
let bar_h = (val / range) * ph;
let bar_y = py + ph - y_offset - bar_h;
write!(
svg,
r##"<rect x="{:.2}" y="{:.2}" width="{:.2}" height="{:.2}" fill="{}" rx="0.5"/>"##,
cat_x + cat_width * bar_gap / 2.0,
bar_y,
group_width,
bar_h.max(0.0),
color_at(palette,si)
)
.unwrap();
if show_labels && val > 0.0 {
if bl.show_labels {
if bl.stacked {
if bar.value > 0.0 {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
cat_x + cat_width / 2.0,
bar_y + bar_h / 2.0 + label_font * 0.15,
label_font,
label_color,
format_value(val)
bar.label_x, bar.label_y, bl.label_font, bl.label_color, format_value(bar.value)
)
.unwrap();
}
y_offset += bar_h;
}
} else {
// Grouped
let bar_w = group_width / n_series as f64;
for (si, series) in data.series.iter().enumerate() {
let val = series.values.get(ci).copied().unwrap_or(0.0);
let bar_h = ((val - min_val) / range) * ph;
let bar_x = cat_x + cat_width * bar_gap / 2.0 + si as f64 * bar_w;
let bar_y = py + ph - bar_h;
} else {
write!(
svg,
r##"<rect x="{:.2}" y="{:.2}" width="{:.2}" height="{:.2}" fill="{}" rx="0.5"/>"##,
bar_x,
bar_y,
bar_w.max(0.1),
bar_h.max(0.0),
color_at(palette,si)
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
bar.label_x, bar.label_y, bl.label_font, bl.label_color, format_value(bar.value)
)
.unwrap();
if show_labels {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
bar_x + bar_w / 2.0,
bar_y - 0.8,
label_font,
label_color,
format_value(val)
)
.unwrap();
}
}
}
}
// X axis labels — rotate if too many categories
render_x_labels(svg, &data.categories, px, py + ph, pw, n_cats);
// X axis labels
render_x_labels_svg(svg, &bl.x_labels);
// X axis line
write!(
svg,
r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#9CA3AF" stroke-width="0.3"/>"##,
px, py + ph, px + pw, py + ph
bl.x_axis_x1, bl.x_axis_y, bl.x_axis_x2, bl.x_axis_y
)
.unwrap();
}
fn render_line(
svg: &mut String,
data: &ResolvedChartData,
palette: &[String],
px: f64,
py: f64,
pw: f64,
ph: f64,
) {
fn render_line(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout) {
if data.categories.is_empty() || data.series.is_empty() {
return;
}
let (min_val, max_val) = value_range(data, false);
let range = if (max_val - min_val).abs() < 1e-10 {
1.0
} else {
max_val - min_val
};
let ll = compute_line_layout(data, cl);
let show_grid = data.axis.as_ref().and_then(|a| a.show_grid).unwrap_or(true);
let grid_color = data
.axis
.as_ref()
.and_then(|a| a.grid_color.as_deref())
.unwrap_or("#E5E7EB");
render_y_axis(svg, min_val, max_val, px, py, pw, ph, show_grid, grid_color);
// Y axis
render_y_axis_svg(svg, &ll.y_axis);
let n_cats = data.categories.len();
let line_w = data.style.line_width.unwrap_or(0.5);
let show_points = data.style.show_points.unwrap_or(true);
let show_labels = data.labels.as_ref().is_some_and(|l| l.show);
let label_font = data.labels.as_ref().and_then(|l| l.font_size).unwrap_or(2.2);
let label_color = data
.labels
.as_ref()
.and_then(|l| l.color.as_deref())
.unwrap_or("#333");
for (si, series) in data.series.iter().enumerate() {
let color = color_at(palette,si);
for series_layout in &ll.series {
let color = color_at(&cl.palette, series_layout.color_idx);
let mut points = String::new();
let mut point_circles = String::new();
for (ci, val) in series.values.iter().enumerate() {
let x = if n_cats == 1 {
px + pw / 2.0
} else {
px + ci as f64 * pw / (n_cats - 1) as f64
};
let y = py + ph - ((val - min_val) / range) * ph;
write!(points, "{:.2},{:.2} ", x, y).unwrap();
for pt in &series_layout.points {
write!(points, "{:.2},{:.2} ", pt.x, pt.y).unwrap();
if show_points {
if ll.show_points {
write!(
point_circles,
r##"<circle cx="{:.2}" cy="{:.2}" r="0.8" fill="{}" stroke="white" stroke-width="0.3"/>"##,
x, y, color
pt.x, pt.y, color
)
.unwrap();
}
if show_labels {
if ll.show_labels {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
x, y - 1.5, label_font, label_color, format_value(*val)
pt.x, pt.y - 1.5, ll.label_font, ll.label_color, format_value(pt.value)
)
.unwrap();
}
@@ -387,100 +180,50 @@ fn render_line(
write!(
svg,
r##"<polyline points="{}" fill="none" stroke="{}" stroke-width="{:.2}" stroke-linejoin="round" stroke-linecap="round"/>"##,
points.trim(),
color,
line_w
points.trim(), color, ll.line_width
)
.unwrap();
svg.push_str(&point_circles);
}
// X axis labels — for line chart, spacing is different
render_x_labels_line(svg, &data.categories, px, py + ph, pw, n_cats);
// X axis labels
render_x_labels_svg(svg, &ll.x_labels);
// Axis lines
// Axis line
write!(
svg,
r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#9CA3AF" stroke-width="0.3"/>"##,
px, py + ph, px + pw, py + ph
ll.x_axis_x1, ll.x_axis_y, ll.x_axis_x2, ll.x_axis_y
)
.unwrap();
}
fn render_pie(
svg: &mut String,
data: &ResolvedChartData,
palette: &[String],
_total_w: f64,
_total_h: f64,
px: f64,
py: f64,
pw: f64,
ph: f64,
) {
// Pie icin ilk serinin degerlerini kullan (veya tum serilerin toplamlarini)
let values: Vec<f64> = if data.series.len() == 1 {
data.series[0].values.clone()
} else {
// Birden fazla seri varsa, her kategori icin toplam al
data.categories
.iter()
.enumerate()
.map(|(ci, _)| {
data.series
.iter()
.map(|s| s.values.get(ci).copied().unwrap_or(0.0))
.sum()
})
.collect()
};
fn render_pie(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout) {
let pl = compute_pie_layout(data, cl);
let total: f64 = values.iter().sum();
if total <= 0.0 || data.categories.is_empty() {
if pl.slices.is_empty() {
return;
}
let cx = px + pw / 2.0;
let cy = py + ph / 2.0;
let radius = pw.min(ph) / 2.0 * 0.65;
let inner_frac = data.style.inner_radius.unwrap_or(0.0).clamp(0.0, 0.9);
let inner_r = radius * inner_frac;
let cx = pl.cx;
let cy = pl.cy;
let radius = pl.radius;
let inner_r = pl.inner_radius;
let show_labels = data.labels.as_ref().is_some_and(|l| l.show);
let label_font = data.labels.as_ref().and_then(|l| l.font_size).unwrap_or(3.0);
let label_color = data
.labels
.as_ref()
.and_then(|l| l.color.as_deref())
.unwrap_or("#333");
for slice in &pl.slices {
let color = color_at(&cl.palette, slice.color_idx);
let large_arc = if slice.sweep > std::f64::consts::PI { 1 } else { 0 };
let mut start_angle = -std::f64::consts::FRAC_PI_2; // 12 o'clock
for (i, val) in values.iter().enumerate() {
if *val <= 0.0 {
continue;
}
let sweep = (val / total) * std::f64::consts::TAU;
let end_angle = start_angle + sweep;
let large_arc = if sweep > std::f64::consts::PI {
1
} else {
0
};
let x1 = cx + radius * start_angle.cos();
let y1 = cy + radius * start_angle.sin();
let x2 = cx + radius * end_angle.cos();
let y2 = cy + radius * end_angle.sin();
let color = color_at(palette,i);
let x1 = cx + radius * slice.start_angle.cos();
let y1 = cy + radius * slice.start_angle.sin();
let x2 = cx + radius * slice.end_angle.cos();
let y2 = cy + radius * slice.end_angle.sin();
if inner_r > 0.0 {
// Donut
let ix1 = cx + inner_r * start_angle.cos();
let iy1 = cy + inner_r * start_angle.sin();
let ix2 = cx + inner_r * end_angle.cos();
let iy2 = cy + inner_r * end_angle.sin();
let ix1 = cx + inner_r * slice.start_angle.cos();
let iy1 = cy + inner_r * slice.start_angle.sin();
let ix2 = cx + inner_r * slice.end_angle.cos();
let iy2 = cy + inner_r * slice.end_angle.sin();
write!(
svg,
r##"<path d="M {:.2} {:.2} A {:.2} {:.2} 0 {} 1 {:.2} {:.2} L {:.2} {:.2} A {:.2} {:.2} 0 {} 0 {:.2} {:.2} Z" fill="{}" stroke="white" stroke-width="0.3"/>"##,
@@ -490,7 +233,6 @@ fn render_pie(
)
.unwrap();
} else {
// Full pie
write!(
svg,
r##"<path d="M {:.2} {:.2} L {:.2} {:.2} A {:.2} {:.2} 0 {} 1 {:.2} {:.2} Z" fill="{}" stroke="white" stroke-width="0.3"/>"##,
@@ -500,258 +242,75 @@ fn render_pie(
}
// Percentage label inside slice
if show_labels {
let mid_angle = start_angle + sweep / 2.0;
let label_r = if inner_r > 0.0 {
(radius + inner_r) / 2.0
} else {
radius * 0.65
};
let lx = cx + label_r * mid_angle.cos();
let ly = cy + label_r * mid_angle.sin();
let pct = (val / total * 100.0).round();
if pl.show_labels {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle" dominant-baseline="central">{}%</text>"##,
lx, ly, label_font, label_color, pct
slice.label_x, slice.label_y, pl.label_font, pl.label_color,
(slice.fraction * 100.0).round()
)
.unwrap();
}
// Category name label outside slice with leader line
if i < data.categories.len() {
let mid_angle = start_angle + sweep / 2.0;
let line_start_r = radius; // starts at pie edge
let line_end_r = radius + 3.0;
let text_r = radius + 4.0;
// Leader line from pie edge to label
let lx1 = cx + line_start_r * mid_angle.cos();
let ly1 = cy + line_start_r * mid_angle.sin();
let lx2 = cx + line_end_r * mid_angle.cos();
let ly2 = cy + line_end_r * mid_angle.sin();
if !slice.cat_label_text.is_empty() {
write!(
svg,
r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#999" stroke-width="0.2"/>"##,
lx1, ly1, lx2, ly2
slice.leader_start_x, slice.leader_start_y,
slice.leader_end_x, slice.leader_end_y
)
.unwrap();
// Category text
let tx = cx + text_r * mid_angle.cos();
let ty = cy + text_r * mid_angle.sin();
let anchor = if mid_angle.cos() >= 0.0 { "start" } else { "end" };
let anchor = if slice.cat_label_anchor_end { "end" } else { "start" };
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.5" fill="#555" text-anchor="{}" dominant-baseline="central">{}</text>"##,
tx, ty, anchor, escape_xml(&data.categories[i])
slice.cat_label_x, slice.cat_label_y, anchor, escape_xml(&slice.cat_label_text)
)
.unwrap();
}
start_angle = end_angle;
}
}
fn render_legend(
svg: &mut String,
data: &ResolvedChartData,
palette: &[String],
position: &str,
font_size: f64,
total_w: f64,
total_h: f64,
margin_left: f64,
margin_top: f64,
plot_w: f64,
_plot_h: f64,
) {
let names: Vec<&str> = if matches!(data.chart_type, ChartType::Pie) {
data.categories.iter().map(|s| s.as_str()).collect()
} else {
data.series.iter().map(|s| s.name.as_str()).collect()
};
fn render_legend(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout, total_w: f64, total_h: f64) {
let legend = compute_legend(data, cl, 0.0, 0.0, total_w, total_h);
let item_w = 3.0 + font_size * 0.4; // color rect + gap
let spacing = 4.0;
match position {
"top" => {
let y = margin_top - font_size - 1.5;
let mut x = margin_left;
for (i, name) in names.iter().enumerate() {
write!(
svg,
r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
x, y - font_size * 0.3, color_at(palette,i)
)
.unwrap();
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
x + item_w, y + font_size * 0.3, font_size, escape_xml(name)
)
.unwrap();
x += item_w + name.len() as f64 * font_size * 0.5 + spacing;
}
}
"right" => {
let x = margin_left + plot_w + 4.0;
let mut y = margin_top + 2.0;
for (i, name) in names.iter().enumerate() {
write!(
svg,
r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
x, y, color_at(palette,i)
)
.unwrap();
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
x + item_w, y + font_size * 0.7, font_size, escape_xml(name)
)
.unwrap();
y += font_size + 2.0;
}
}
_ => {
// bottom (default)
let y = total_h - 3.0;
let total_legend_w: f64 = names
.iter()
.map(|n| item_w + n.len() as f64 * font_size * 0.5 + spacing)
.sum::<f64>()
- spacing;
let mut x = (total_w - total_legend_w) / 2.0;
for (i, name) in names.iter().enumerate() {
write!(
svg,
r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
x, y - font_size * 0.3, color_at(palette,i)
)
.unwrap();
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
x + item_w, y + font_size * 0.3, font_size, escape_xml(name)
)
.unwrap();
x += item_w + name.len() as f64 * font_size * 0.5 + spacing;
}
}
}
}
/// X-axis labels ortak render — bar chart icin (slot-based spacing)
fn render_x_labels(
svg: &mut String,
categories: &[String],
px: f64,
baseline_y: f64,
pw: f64,
n_cats: usize,
) {
if n_cats == 0 {
return;
}
let cat_width = pw / n_cats as f64;
let max_chars = (cat_width / 1.25).max(1.0) as usize;
let needs_rotate = categories.iter().any(|c| c.len() > max_chars);
for (ci, cat) in categories.iter().enumerate() {
let x = px + ci as f64 * cat_width + cat_width / 2.0;
let y = baseline_y + 2.5;
render_single_x_label(svg, cat, x, y, needs_rotate);
}
}
/// X-axis labels — line chart icin (point-based spacing)
fn render_x_labels_line(
svg: &mut String,
categories: &[String],
px: f64,
baseline_y: f64,
pw: f64,
n_cats: usize,
) {
if n_cats == 0 {
return;
}
let spacing = if n_cats == 1 { pw } else { pw / (n_cats - 1) as f64 };
let max_chars = (spacing / 1.25).max(1.0) as usize;
let needs_rotate = categories.iter().any(|c| c.len() > max_chars);
for (ci, cat) in categories.iter().enumerate() {
let x = if n_cats == 1 {
px + pw / 2.0
} else {
px + ci as f64 * pw / (n_cats - 1) as f64
};
let y = baseline_y + 2.5;
render_single_x_label(svg, cat, x, y, needs_rotate);
}
}
/// Tek bir X-axis label render — rotate gerekiyorsa -45° ile, anchor "end"
/// Anchor noktasi bar/point'in tam altinda, text sola yukari dogru uzanir
fn render_single_x_label(svg: &mut String, text: &str, x: f64, y: f64, rotate: bool) {
if rotate {
// -45° rotate, text-anchor="end": text, anchor noktasindan sola-yukari dogru uzanir
// Bu sayede text asagi-sola tasmaz, sadece yukari-sola gider (plot area icinde kalir)
for item in &legend.items {
let color = color_at(&cl.palette, item.color_idx);
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.2" fill="#666" text-anchor="end" transform="rotate(-45,{:.2},{:.2})">{}</text>"##,
x, y, x, y, escape_xml(text)
r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
item.swatch_x, item.swatch_y, color
)
.unwrap();
} else {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.5" fill="#666" text-anchor="middle">{}</text>"##,
x, y, escape_xml(text)
r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
item.text_x, item.text_y, legend.font_size, escape_xml(&item.name)
)
.unwrap();
}
}
fn render_y_axis(
svg: &mut String,
min_val: f64,
max_val: f64,
px: f64,
py: f64,
pw: f64,
ph: f64,
show_grid: bool,
grid_color: &str,
) {
let range = if (max_val - min_val).abs() < 1e-10 {
1.0
} else {
max_val - min_val
};
let tick_count = 5;
for i in 0..=tick_count {
let frac = i as f64 / tick_count as f64;
let val = min_val + frac * range;
let y = py + ph - frac * ph;
// ---------------------------------------------------------------------------
// SVG-specific helper renderers that consume shared layout structs
// ---------------------------------------------------------------------------
// Label
fn render_y_axis_svg(svg: &mut String, y_axis: &chart_layout::YAxisLayout) {
for tick in &y_axis.ticks {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.3" fill="#666" text-anchor="end">{}</text>"##,
px - 1.5,
y + 0.8,
format_value(val)
y_axis.axis_x - 1.5, tick.y + 0.8, tick.label
)
.unwrap();
// Grid line
if show_grid {
if y_axis.show_grid {
write!(
svg,
r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="{}" stroke-width="0.15"/>"##,
px, y, px + pw, y, grid_color
y_axis.axis_x, tick.y, y_axis.grid_end_x, tick.y, y_axis.grid_color
)
.unwrap();
}
@@ -761,56 +320,28 @@ fn render_y_axis(
write!(
svg,
r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#9CA3AF" stroke-width="0.3"/>"##,
px, py, px, py + ph
y_axis.axis_x, y_axis.axis_y_start, y_axis.axis_x, y_axis.axis_y_end
)
.unwrap();
}
/// Tum serilerdeki min/max deger araligini bul
fn value_range(data: &ResolvedChartData, stacked: bool) -> (f64, f64) {
if data.series.is_empty() {
return (0.0, 1.0);
}
if stacked {
let n = data.categories.len();
let mut max_stack = 0.0_f64;
for ci in 0..n {
let sum: f64 = data
.series
.iter()
.map(|s| s.values.get(ci).copied().unwrap_or(0.0))
.sum();
max_stack = max_stack.max(sum);
fn render_x_labels_svg(svg: &mut String, x_labels: &chart_layout::XLabelLayout) {
for label in &x_labels.labels {
if x_labels.needs_rotate {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.2" fill="#666" text-anchor="end" transform="rotate(-45,{:.2},{:.2})">{}</text>"##,
label.x, label.y, label.x, label.y, escape_xml(&label.text)
)
.unwrap();
} else {
write!(
svg,
r##"<text x="{:.2}" y="{:.2}" font-size="2.5" fill="#666" text-anchor="middle">{}</text>"##,
label.x, label.y, escape_xml(&label.text)
)
.unwrap();
}
(0.0, max_stack * 1.05)
} else {
let mut min_v = f64::MAX;
let mut max_v = f64::MIN;
for series in &data.series {
for val in &series.values {
min_v = min_v.min(*val);
max_v = max_v.max(*val);
}
}
// min sifirdan buyukse sifirdan basla
if min_v > 0.0 {
min_v = 0.0;
}
max_v *= 1.05;
(min_v, max_v)
}
}
fn format_value(v: f64) -> String {
if v.abs() >= 1_000_000.0 {
format!("{:.1}M", v / 1_000_000.0)
} else if v.abs() >= 1_000.0 {
format!("{:.1}K", v / 1_000.0)
} else if v.fract().abs() < 1e-10 {
format!("{}", v as i64)
} else {
format!("{:.1}", v)
}
}