dan/gpui-component
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

plot: Use f32 instead of f64 (#1052)

Browse source 
## Break Change
- Convert all `f64` parameters to `f32`.

Since the GPUI geometry module uses f32 for rendering, we are also
switching to f32. This helps avoid many as operators and unnecessary
conversions.
This commit is contained in:
Floyd Wang 2025-07-08 16:24:59 +08:00 committed by GitHub
parent 8bf66443b2
commit 3b759cd448
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 121 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
crates/story/src/chart_story.rs
View file

@ -164,7 +164,7 @@ impl Render for ChartStory {
.child(chart_container(
"Pie Chart",
PieChart::new(self.monthly_devices.clone())
.value(|d| d.desktop)
.value(|d| d.desktop as f32)
.outer_radius(100.)
.color(move |d| d.color(color)),
true,
@ -173,7 +173,7 @@ impl Render for ChartStory {
.child(chart_container(
"Pie Chart - Donut",
PieChart::new(self.monthly_devices.clone())
.value(|d| d.desktop)
.value(|d| d.desktop as f32)
.outer_radius(100.)
.inner_radius(60.)
.color(move |d| d.color(color)),
@ -183,7 +183,7 @@ impl Render for ChartStory {
.child(chart_container(
"Pie Chart - Pad Angle",
PieChart::new(self.monthly_devices.clone())
.value(|d| d.desktop)
.value(|d| d.desktop as f32)
.outer_radius(100.)
.inner_radius(60.)
.pad_angle(4. / 100.)

6
crates/ui/src/chart/area_chart.rs
View file

@ -94,8 +94,8 @@ where
return;
}
let width = bounds.size.width.to_f64();
let height = bounds.size.height.to_f64() - AXIS_GAP;
let width = bounds.size.width.0;
let height = bounds.size.height.0 - AXIS_GAP;
// X scale
let x = ScalePoint::new(self.data.iter().map(|v| x_fn(v)).collect(), vec![0., width]);
@ -134,7 +134,7 @@ where
// Draw grid
Grid::new()
.y((0..=3).map(|i| height * i as f64 / 4.0).collect())
.y((0..=3).map(|i| height * i as f32 / 4.0).collect())
.stroke(cx.theme().border)
.dash_array(&[px(4.), px(2.)])
.paint(&bounds, window);

6
crates/ui/src/chart/bar_chart.rs
View file

@ -90,8 +90,8 @@ where
return;
};
let width = bounds.size.width.to_f64();
let height = bounds.size.height.to_f64() - AXIS_GAP;
let width = bounds.size.width.0;
let height = bounds.size.height.0 - AXIS_GAP;
// X scale
let x = ScaleBand::new(self.data.iter().map(|v| x_fn(v)).collect(), vec![0., width])
@ -133,7 +133,7 @@ where
// Draw grid
Grid::new()
.y((0..=3).map(|i| height * i as f64 / 4.0).collect())
.y((0..=3).map(|i| height * i as f32 / 4.0).collect())
.stroke(cx.theme().border)
.dash_array(&[px(4.), px(2.)])
.paint(&bounds, window);

6
crates/ui/src/chart/line_chart.rs
View file

@ -85,8 +85,8 @@ where
return;
};
let width = bounds.size.width.to_f64();
let height = bounds.size.height.to_f64() - AXIS_GAP;
let width = bounds.size.width.0;
let height = bounds.size.height.0 - AXIS_GAP;
// X scale
let x = ScalePoint::new(self.data.iter().map(|v| x_fn(v)).collect(), vec![0., width]);
@ -126,7 +126,7 @@ where
// Draw grid
Grid::new()
.y((0..=3).map(|i| height * i as f64 / 4.0).collect())
.y((0..=3).map(|i| height * i as f32 / 4.0).collect())
.stroke(cx.theme().border)
.dash_array(&[px(4.), px(2.)])
.paint(&bounds, window);

18
crates/ui/src/chart/pie_chart.rs
View file

@ -15,10 +15,10 @@ use crate::{
#[derive(IntoPlot)]
pub struct PieChart<T: 'static> {
data: Vec<T>,
inner_radius: f64,
outer_radius: f64,
pad_angle: f64,
value: Option<Rc<dyn Fn(&T) -> f64>>,
inner_radius: f32,
outer_radius: f32,
pad_angle: f32,
value: Option<Rc<dyn Fn(&T) -> f32>>,
color: Option<Rc<dyn Fn(&T) -> Hsla>>,
}
@ -37,22 +37,22 @@ impl<T> PieChart<T> {
}
}
pub fn inner_radius(mut self, inner_radius: f64) -> Self {
pub fn inner_radius(mut self, inner_radius: f32) -> Self {
self.inner_radius = inner_radius;
self
}
pub fn outer_radius(mut self, outer_radius: f64) -> Self {
pub fn outer_radius(mut self, outer_radius: f32) -> Self {
self.outer_radius = outer_radius;
self
}
pub fn pad_angle(mut self, pad_angle: f64) -> Self {
pub fn pad_angle(mut self, pad_angle: f32) -> Self {
self.pad_angle = pad_angle;
self
}
pub fn value(mut self, value: impl Fn(&T) -> f64 + 'static) -> Self {
pub fn value(mut self, value: impl Fn(&T) -> f32 + 'static) -> Self {
self.value = Some(Rc::new(value));
self
}
@ -73,7 +73,7 @@ impl<T> Plot for PieChart<T> {
};
let outer_radius = if self.outer_radius.is_zero() {
bounds.size.height.to_f64() * 0.4
bounds.size.height.0 * 0.4
} else {
self.outer_radius
};

6
crates/ui/src/plot/axis.rs
View file

@ -5,7 +5,7 @@ use gpui::{
use super::{label::Label, label::Text, label::TEXT_GAP, label::TEXT_SIZE, origin_point};
pub const AXIS_GAP: f64 = 18.;
pub const AXIS_GAP: f32 = 18.;
pub struct AxisText {
pub text: SharedString,
@ -75,7 +75,7 @@ impl Axis {
.into_iter()
.map(|t| Text {
text: t.text,
origin: point(t.tick, x + px((TEXT_GAP * 3.) as f32)),
origin: point(t.tick, x + px(TEXT_GAP * 3.)),
color: t.color,
font_size: t.font_size,
font_weight: FontWeight::NORMAL,
@ -105,7 +105,7 @@ impl Axis {
.into_iter()
.map(|t| Text {
text: t.text,
origin: point(y + px(TEXT_GAP as f32), t.tick),
origin: point(y + px(TEXT_GAP), t.tick),
color: t.color,
font_size: t.font_size,
font_weight: FontWeight::NORMAL,

6
crates/ui/src/plot/label.rs
View file

@ -7,9 +7,9 @@ use gpui::{
use super::origin_point;
pub const TEXT_SIZE: f64 = 10.;
pub const TEXT_GAP: f64 = 2.;
pub const TEXT_HEIGHT: f64 = TEXT_SIZE + TEXT_GAP;
pub const TEXT_SIZE: f32 = 10.;
pub const TEXT_GAP: f32 = 2.;
pub const TEXT_HEIGHT: f32 = TEXT_SIZE + TEXT_GAP;
pub struct Text {
pub text: SharedString,

6
crates/ui/src/plot/mod.rs
View file

@ -35,15 +35,15 @@ where
pub fn polygon<T>(points: &[Point<T>], bounds: &Bounds<Pixels>) -> Option<Path<Pixels>>
where
T: Default + Clone + Copy + Debug + Into<f64> + PartialEq,
T: Default + Clone + Copy + Debug + Into<f32> + PartialEq,
{
let mut path = PathBuilder::stroke(px(1.));
let points = &points
.iter()
.map(|p| {
point(
px((p.x.into() + bounds.origin.x.to_f64()) as f32),
px((p.y.into() + bounds.origin.y.to_f64()) as f32),
px(p.x.into() + bounds.origin.x.0),
px(p.y.into() + bounds.origin.y.0),
)
})
.collect::<Vec<_>>();

4
crates/ui/src/plot/scale.rs
View file

@ -10,8 +10,8 @@ pub(crate) use sealed::Sealed;
pub trait Scale<T> {
/// Get the tick of the scale.
fn tick(&self, value: &T) -> Option<f64>;
fn tick(&self, value: &T) -> Option<f32>;
/// Get the least index of the scale.
fn least_index(&self, tick: f64) -> usize;
fn least_index(&self, tick: f32) -> usize;
}

28
crates/ui/src/plot/scale/band.rs
View file

@ -8,15 +8,15 @@ use super::Scale;
#[derive(Clone)]
pub struct ScaleBand<T> {
domain: Vec<T>,
range_diff: f64,
avg_width: f64,
padding_inner: f64,
padding_outer: f64,
range_diff: f32,
avg_width: f32,
padding_inner: f32,
padding_outer: f32,
}
impl<T> ScaleBand<T> {
pub fn new(domain: Vec<T>, range: Vec<f64>) -> Self {
let len = domain.len() as f64;
pub fn new(domain: Vec<T>, range: Vec<f32>) -> Self {
let len = domain.len() as f32;
let range_diff = range
.iter()
.minmax()
@ -33,18 +33,18 @@ impl<T> ScaleBand<T> {
}
/// Get the width of the band.
pub fn band_width(&self) -> f64 {
pub fn band_width(&self) -> f32 {
(self.avg_width * (1. - self.padding_inner)).min(30.)
}
/// Set the padding inner of the band.
pub fn padding_inner(mut self, padding_inner: f64) -> Self {
pub fn padding_inner(mut self, padding_inner: f32) -> Self {
self.padding_inner = padding_inner;
self
}
/// Set the padding outer of the band.
pub fn padding_outer(mut self, padding_outer: f64) -> Self {
pub fn padding_outer(mut self, padding_outer: f32) -> Self {
self.padding_outer = padding_outer;
self
}
@ -54,7 +54,7 @@ impl<T> Scale<T> for ScaleBand<T>
where
T: PartialEq,
{
fn tick(&self, value: &T) -> Option<f64> {
fn tick(&self, value: &T) -> Option<f32> {
let index = self.domain.iter().position(|v| v == value)?;
let domain_len = self.domain.len();
@ -63,13 +63,13 @@ where
return Some((self.range_diff - self.band_width()) / 2.);
}
let ratio = 1. + self.padding_inner / (self.domain.len() - 1) as f64;
let ratio = 1. + self.padding_inner / (self.domain.len() - 1) as f32;
let padding_outer_width = self.avg_width * self.padding_outer;
let avg_width = (self.range_diff - padding_outer_width * 2.) / self.domain.len() as f64;
Some(index as f64 * avg_width * ratio + padding_outer_width)
let avg_width = (self.range_diff - padding_outer_width * 2.) / self.domain.len() as f32;
Some(index as f32 * avg_width * ratio + padding_outer_width)
}
fn least_index(&self, tick: f64) -> usize {
fn least_index(&self, tick: f32) -> usize {
let index = (tick / self.avg_width).round() as usize;
index.min(self.domain.len().saturating_sub(1))
}

12
crates/ui/src/plot/scale/linear.rs
View file

@ -10,15 +10,15 @@ pub struct ScaleLinear<T> {
domain_len: usize,
domain_min: T,
domain_diff: T,
range_min: f64,
range_diff: f64,
range_min: f32,
range_diff: f32,
}
impl<T> ScaleLinear<T>
where
T: Copy + PartialOrd + Num + ToPrimitive + Sealed,
{
pub fn new(domain: Vec<T>, range: Vec<f64>) -> Self {
pub fn new(domain: Vec<T>, range: Vec<f32>) -> Self {
let (domain_min, domain_max) = domain
.iter()
.minmax()
@ -45,17 +45,17 @@ impl<T> Scale<T> for ScaleLinear<T>
where
T: Copy + PartialOrd + Num + ToPrimitive + Sealed,
{
fn tick(&self, value: &T) -> Option<f64> {
fn tick(&self, value: &T) -> Option<f32> {
if self.domain_diff.is_zero() {
return None;
}
let ratio = ((*value - self.domain_min) / self.domain_diff).to_f64()?;
let ratio = ((*value - self.domain_min) / self.domain_diff).to_f32()?;
Some((1. - ratio) * self.range_diff + self.range_min)
}
fn least_index(&self, tick: f64) -> usize {
fn least_index(&self, tick: f32) -> usize {
let index = (tick / self.range_diff).round() as usize;
index.min(self.domain_len.saturating_sub(1))
}

12
crates/ui/src/plot/scale/point.rs
View file

@ -8,14 +8,14 @@ use super::Scale;
#[derive(Clone)]
pub struct ScalePoint<T> {
domain: Vec<T>,
range_tick: f64,
range_tick: f32,
}
impl<T> ScalePoint<T>
where
T: PartialEq,
{
pub fn new(domain: Vec<T>, range: Vec<f64>) -> Self {
pub fn new(domain: Vec<T>, range: Vec<f32>) -> Self {
let len = domain.len();
let range_tick = if len.is_zero() {
0.
@ -26,7 +26,7 @@ where
.into_option()
.map_or(0., |(min, max)| max - min);
range_diff / (len - 1) as f64
range_diff / (len - 1) as f32
};
Self { domain, range_tick }
@ -37,12 +37,12 @@ impl<T> Scale<T> for ScalePoint<T>
where
T: PartialEq,
{
fn tick(&self, value: &T) -> Option<f64> {
fn tick(&self, value: &T) -> Option<f32> {
let index = self.domain.iter().position(|v| v == value)?;
Some(index as f64 * self.range_tick)
Some(index as f32 * self.range_tick)
}
fn least_index(&self, tick: f64) -> usize {
fn least_index(&self, tick: f32) -> usize {
let index = (tick / self.range_tick).round() as usize;
index.min(self.domain.len().saturating_sub(1))
}

42
crates/ui/src/plot/shape/arc.rs
View file

@ -1,19 +1,19 @@
// @reference: https://d3js.org/d3-shape/arc
use std::{f64::consts::PI, fmt::Debug};
use std::{f32::consts::PI, fmt::Debug};
use gpui::{point, px, Bounds, Hsla, Path, PathBuilder, Pixels, Point, Window};
const EPSILON: f64 = 1e-12;
const HALF_PI: f64 = PI / 2.;
const EPSILON: f32 = 1e-12;
const HALF_PI: f32 = PI / 2.;
pub struct ArcData<'a, T> {
pub data: &'a T,
pub index: usize,
pub value: f64,
pub start_angle: f64,
pub end_angle: f64,
pub pad_angle: f64,
pub value: f32,
pub start_angle: f32,
pub end_angle: f32,
pub pad_angle: f32,
}
impl<T> Debug for ArcData<'_, T> {
@ -27,8 +27,8 @@ impl<T> Debug for ArcData<'_, T> {
}
pub struct Arc {
inner_radius: f64,
outer_radius: f64,
inner_radius: f32,
outer_radius: f32,
}
impl Default for Arc {
@ -46,19 +46,19 @@ impl Arc {
}
/// Set the inner radius of the Arc.
pub fn inner_radius(mut self, inner_radius: f64) -> Self {
pub fn inner_radius(mut self, inner_radius: f32) -> Self {
self.inner_radius = inner_radius;
self
}
/// Set the outer radius of the Arc.
pub fn outer_radius(mut self, outer_radius: f64) -> Self {
pub fn outer_radius(mut self, outer_radius: f32) -> Self {
self.outer_radius = outer_radius;
self
}
/// Get the centroid of the Arc.
pub fn centroid<T>(&self, arc: &ArcData<T>) -> Point<f64> {
pub fn centroid<T>(&self, arc: &ArcData<T>) -> Point<f32> {
let start_angle = arc.start_angle - HALF_PI;
let end_angle = arc.end_angle - HALF_PI;
let r = (self.inner_radius + self.outer_radius) / 2.;
@ -75,8 +75,8 @@ impl Arc {
let r1 = self.outer_radius.max(0.);
// Calculate the center point.
let center_x = bounds.origin.x.to_f64() + bounds.size.width.to_f64() / 2.;
let center_y = bounds.origin.y.to_f64() + bounds.size.height.to_f64() / 2.;
let center_x = bounds.origin.x.0 + bounds.size.width.0 / 2.;
let center_y = bounds.origin.y.0 + bounds.size.height.0 / 2.;
// Angle difference.
let da = end_angle - start_angle;
@ -123,38 +123,38 @@ impl Arc {
let mut builder = PathBuilder::fill();
// Move to the start point of the outer arc.
builder.move_to(point(px(x01 as f32), px(y01 as f32)));
builder.move_to(point(px(x01), px(y01)));
// Draw the outer arc.
let large_arc = (a1_outer - a0_outer).abs() > PI;
builder.arc_to(
point(px(r1 as f32), px(r1 as f32)),
point(px(r1), px(r1)),
px(0.),
large_arc,
true,
point(px(x11 as f32), px(y11 as f32)),
point(px(x11), px(y11)),
);
if r0 > EPSILON {
// End point of the inner arc.
let x10 = center_x + r0 * a1_inner.cos();
let y10 = center_y + r0 * a1_inner.sin();
builder.line_to(point(px(x10 as f32), px(y10 as f32)));
builder.line_to(point(px(x10), px(y10)));
// Draw the inner arc.
let x00 = center_x + r0 * a0_inner.cos();
let y00 = center_y + r0 * a0_inner.sin();
let large_arc_inner = (a1_inner - a0_inner).abs() > PI;
builder.arc_to(
point(px(r0 as f32), px(r0 as f32)),
point(px(r0), px(r0)),
px(0.),
large_arc_inner,
false,
point(px(x00 as f32), px(y00 as f32)),
point(px(x00), px(y00)),
);
} else {
// If there is no inner radius, draw a line to the center.
builder.line_to(point(px(center_x as f32), px(center_y as f32)));
builder.line_to(point(px(center_x), px(center_y)));
}
builder.build().ok()

18
crates/ui/src/plot/shape/area.rs
View file

@ -7,9 +7,9 @@ use crate::plot::{origin_point, StrokeStyle};
#[allow(clippy::type_complexity)]
pub struct Area<T> {
data: Vec<T>,
x: Box<dyn Fn(&T) -> Option<f64>>,
y0: Option<f64>,
y1: Box<dyn Fn(&T) -> Option<f64>>,
x: Box<dyn Fn(&T) -> Option<f32>>,
y0: Option<f32>,
y1: Box<dyn Fn(&T) -> Option<f32>>,
fill: Background,
stroke: Background,
stroke_style: StrokeStyle,
@ -46,14 +46,14 @@ impl<T> Area<T> {
/// Set the x of the Area.
pub fn x<F>(mut self, x: F) -> Self
where
F: Fn(&T) -> Option<f64> + 'static,
F: Fn(&T) -> Option<f32> + 'static,
{
self.x = Box::new(x);
self
}
/// Set the y0 of the Area.
pub fn y0(mut self, y0: f64) -> Self {
pub fn y0(mut self, y0: f32) -> Self {
self.y0 = Some(y0);
self
}
@ -61,7 +61,7 @@ impl<T> Area<T> {
/// Set the y1 of the Area.
pub fn y1<F>(mut self, y1: F) -> Self
where
F: Fn(&T) -> Option<f64> + 'static,
F: Fn(&T) -> Option<f32> + 'static,
{
self.y1 = Box::new(y1);
self
@ -97,7 +97,7 @@ impl<T> Area<T> {
let y_tick = (self.y1)(v);
if let (Some(x), Some(y)) = (x_tick, y_tick) {
let pos = origin_point(px(x as f32), px(y as f32), origin);
let pos = origin_point(px(x), px(y), origin);
points.push(pos);
}
@ -150,8 +150,8 @@ impl<T> Area<T> {
if let Some(last) = self.data.last() {
let x_tick = (self.x)(last);
if let (Some(x), Some(y)) = (x_tick, self.y0) {
area_builder.line_to(origin_point(px(x as f32), px(y as f32), bounds.origin));
area_builder.line_to(origin_point(px(0.), px(y as f32), bounds.origin));
area_builder.line_to(origin_point(px(x), px(y), bounds.origin));
area_builder.line_to(origin_point(px(0.), px(y), bounds.origin));
area_builder.close();
}
}

38
crates/ui/src/plot/shape/bar.rs
View file

@ -8,10 +8,10 @@ use crate::plot::{
#[allow(clippy::type_complexity)]
pub struct Bar<T> {
data: Vec<T>,
x: Box<dyn Fn(&T) -> Option<f64>>,
band_width: f64,
y0: f64,
y1: Box<dyn Fn(&T) -> Option<f64>>,
x: Box<dyn Fn(&T) -> Option<f32>>,
band_width: f32,
y0: f32,
y1: Box<dyn Fn(&T) -> Option<f32>>,
fill: Box<dyn Fn(&T) -> Hsla>,
label: Option<Box<dyn Fn(&T, Point<Pixels>) -> Text>>,
}
@ -47,20 +47,20 @@ impl<T> Bar<T> {
/// Set the x of the Bar.
pub fn x<F>(mut self, x: F) -> Self
where
F: Fn(&T) -> Option<f64> + 'static,
F: Fn(&T) -> Option<f32> + 'static,
{
self.x = Box::new(x);
self
}
/// Set the band width of the Bar.
pub fn band_width(mut self, band_width: f64) -> Self {
pub fn band_width(mut self, band_width: f32) -> Self {
self.band_width = band_width;
self
}
/// Set the y0 of the Bar.
pub fn y0(mut self, y0: f64) -> Self {
pub fn y0(mut self, y0: f32) -> Self {
self.y0 = y0;
self
}
@ -68,7 +68,7 @@ impl<T> Bar<T> {
/// Set the y1 of the Bar.
pub fn y1<F>(mut self, y: F) -> Self
where
F: Fn(&T) -> Option<f64> + 'static,
F: Fn(&T) -> Option<f32> + 'static,
{
self.y1 = Box::new(y);
self
@ -106,21 +106,13 @@ impl<T> Bar<T> {
let is_negative = y_tick > self.y0;
let (p1, p2) = if is_negative {
(
origin_point(px(x_tick as f32), px(self.y0 as f32), origin),
origin_point(
px((x_tick + self.band_width) as f32),
px(y_tick as f32),
origin,
),
origin_point(px(x_tick), px(self.y0), origin),
origin_point(px(x_tick + self.band_width), px(y_tick), origin),
)
} else {
(
origin_point(px(x_tick as f32), px(y_tick as f32), origin),
origin_point(
px((x_tick + self.band_width) as f32),
px(self.y0 as f32),
origin,
),
origin_point(px(x_tick), px(y_tick), origin),
origin_point(px(x_tick + self.band_width), px(self.y0), origin),
)
};
@ -132,11 +124,11 @@ impl<T> Bar<T> {
labels.push(label(
v,
point(
px((x_tick + self.band_width / 2.) as f32),
px(x_tick + self.band_width / 2.),
if is_negative {
px((y_tick + TEXT_GAP) as f32)
px(y_tick + TEXT_GAP)
} else {
px((y_tick - TEXT_HEIGHT) as f32)
px(y_tick - TEXT_HEIGHT)
},
),
));

18
crates/ui/src/plot/shape/line.rs
View file

@ -10,8 +10,8 @@ use crate::plot::{origin_point, StrokeStyle};
#[allow(clippy::type_complexity)]
pub struct Line<T> {
data: Vec<T>,
x: Box<dyn Fn(&T) -> Option<f64>>,
y: Box<dyn Fn(&T) -> Option<f64>>,
x: Box<dyn Fn(&T) -> Option<f32>>,
y: Box<dyn Fn(&T) -> Option<f32>>,
stroke: Background,
stroke_width: Pixels,
stroke_style: StrokeStyle,
@ -55,7 +55,7 @@ impl<T> Line<T> {
/// Set the x of the Line.
pub fn x<F>(mut self, x: F) -> Self
where
F: Fn(&T) -> Option<f64> + 'static,
F: Fn(&T) -> Option<f32> + 'static,
{
self.x = Box::new(x);
self
@ -64,7 +64,7 @@ impl<T> Line<T> {
/// Set the y of the Line.
pub fn y<F>(mut self, y: F) -> Self
where
F: Fn(&T) -> Option<f64> + 'static,
F: Fn(&T) -> Option<f32> + 'static,
{
self.y = Box::new(y);
self
@ -135,15 +135,11 @@ impl<T> Line<T> {
let y_tick = (self.y)(v);
if let (Some(x), Some(y)) = (x_tick, y_tick) {
let pos = origin_point(px(x as f32), px(y as f32), origin);
let pos = origin_point(px(x), px(y), origin);
if self.dot {
let dot_radius = self.dot_size.to_f64() / 2.;
let dot_pos = origin_point(
px((x - dot_radius) as f32),
px((y - dot_radius) as f32),
origin,
);
let dot_radius = self.dot_size.0 / 2.;
let dot_pos = origin_point(px(x - dot_radius), px(y - dot_radius), origin);
paint_dots.push(self.paint_dot(dot_pos));
}

18
crates/ui/src/plot/shape/pie.rs
View file

@ -1,15 +1,15 @@
// @reference: https://d3js.org/d3-shape/pie
use std::f64::consts::TAU;
use std::f32::consts::TAU;
use super::arc::ArcData;
#[allow(clippy::type_complexity)]
pub struct Pie<T> {
value: Box<dyn Fn(&T) -> Option<f64>>,
start_angle: f64,
end_angle: f64,
pad_angle: f64,
value: Box<dyn Fn(&T) -> Option<f32>>,
start_angle: f32,
end_angle: f32,
pad_angle: f32,
}
impl<T> Default for Pie<T> {
@ -31,26 +31,26 @@ impl<T> Pie<T> {
/// Set the value of the Pie.
pub fn value<F>(mut self, value: F) -> Self
where
F: 'static + Fn(&T) -> Option<f64>,
F: 'static + Fn(&T) -> Option<f32>,
{
self.value = Box::new(value);
self
}
/// Set the start angle of the Pie.
pub fn start_angle(mut self, start_angle: f64) -> Self {
pub fn start_angle(mut self, start_angle: f32) -> Self {
self.start_angle = start_angle;
self
}
/// Set the end angle of the Pie.
pub fn end_angle(mut self, end_angle: f64) -> Self {
pub fn end_angle(mut self, end_angle: f32) -> Self {
self.end_angle = end_angle;
self
}
/// Set the pad angle of the Pie.
pub fn pad_angle(mut self, pad_angle: f64) -> Self {
pub fn pad_angle(mut self, pad_angle: f32) -> Self {
self.pad_angle = pad_angle;
self
}

4
crates/ui/src/plot/tooltip.rs
View file

@ -19,8 +19,8 @@ impl CrossLine {
}
}
pub fn height(mut self, height: f64) -> Self {
self.height = Some(height as f32);
pub fn height(mut self, height: f32) -> Self {
self.height = Some(height);
self
}
}