Struct BarChart 

pub struct BarChart<T, B, V>
where
    T: 'static,
    B: PartialEq + Into<SharedString> + 'static,
    V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,
{ /* private fields */ }

Implementations

impl<T, B, V> BarChart<T, B, V>

where B: PartialEq + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

pub fn new<I>(data: I) -> Self

where I: IntoIterator<Item = T>,

pub fn band(self, band: impl Fn(&T) -> B + 'static) -> Self

Map each datum to its band-axis value (the categorical/ordinal axis).

pub fn value(self, value: impl Fn(&T) -> V + 'static) -> Self

Map each datum to its numeric value along the value axis.

pub fn fill<Bg>( self, fill: impl Fn(&T, Bounds<f32>, Bounds<f32>, BarAlignment) -> Bg + 'static, ) -> Self

where Bg: Into<Background> + 'static,

Set a per-datum verbatim fill.

The closure receives:

1. the datum,
2. the bar’s bounds in pixel space, expressed relative to the chart’s origin (i.e. the bar’s painted rectangle within the chart),
3. the chart’s bounds in pixel space with origin (0, 0) and size equal to the full chart extent, and
4. the bar’s BarAlignment (so callers can branch on orientation, e.g. flip a gradient angle).

Both rectangles share the same coordinate system, so callers can implement arbitrary chart-aware backgrounds — bar-local gradients, chart-wide gradients, patterns, sampled colormaps, etc. — without any help from the library.

Accepts any type convertible to Background. Setting this clears any previously set BarChart::fill_gradient.

pub fn fill_gradient( self, fill: impl Fn(&T, RangeInclusive<f32>, &dyn Fn(f32) -> f32) -> [LinearColorStop; 2] + 'static, ) -> Self

Set a per-datum auto-oriented linear gradient fill.

The closure receives the datum, the chart’s full data range (chart_range, derived from all data values), and a chart_to_bar remap helper that maps a chart-value coordinate to a bar-local gradient position (where 0.0 is the bar’s base and 1.0 is its tip).

Use bar-local positions directly for per-bar gradients (every bar looks the same regardless of its value):

.fill_gradient(|_, _, _| [
    linear_color_stop(c.opacity(0.3), 0.0),
    linear_color_stop(c, 1.0),
])

Or use chart_to_bar to position stops at chart-relative values, so each bar shows the slice of a chart-wide gradient corresponding to its own [base, value] span:

.fill_gradient(|_, chart_range, chart_to_bar| [
    linear_color_stop(c.opacity(0.3), chart_to_bar(*chart_range.start())),
    linear_color_stop(c,              chart_to_bar(*chart_range.end())),
])

Stop positions returned outside [0, 1] are clipped to the bar; the library interpolates colors at the clip points so the on-bar gradient still matches the chart-wide one.

The gradient angle is derived from BarAlignment so stop-0 is at the base and stop-1 at the tip. Setting this clears any previously set BarChart::fill.

pub fn tick_margin(self, tick_margin: usize) -> Self

pub fn label<S>(self, label: impl Fn(&T) -> S + 'static) -> Self

where S: Into<SharedString> + 'static,

pub fn label_axis(self, label_axis: bool) -> Self

Show or hide the band-axis line and labels.

Default is true.

pub fn grid(self, grid: bool) -> Self

pub fn alignment(self, alignment: BarAlignment) -> Self

Set the bar alignment.

Default is BarAlignment::Bottom.

pub fn corner_radii(self, corner_radii: impl Into<Corners<Pixels>>) -> Self

Set the corner radii applied to every bar rectangle.

Use Corners::all for uniform rounding, or construct Corners manually to round only specific corners (e.g. just the tip end of each bar).

Trait Implementations

impl<T, B, V> Element for BarChart<T, B, V>

where T: 'static, B: PartialEq + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

实现 Element trait，提供图表的布局和渲染逻辑

fn id(&self) -> Option<ElementId>

返回元素 ID（图表元素不需要）

fn source_location(&self) -> Option<&'static Location<'static>>

返回源代码位置信息（图表元素不需要）

fn request_layout( &mut self, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, window: &mut Window, cx: &mut App, ) -> (LayoutId, Self::RequestLayoutState)

请求布局，使用全尺寸样式

fn prepaint( &mut self, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, _: Bounds<Pixels>, _: &mut Self::RequestLayoutState, _: &mut Window, _: &mut App, ) -> Self::PrepaintState

预绘制阶段（图表不需要额外处理）

fn paint( &mut self, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, bounds: Bounds<Pixels>, _: &mut Self::RequestLayoutState, _: &mut Self::PrepaintState, window: &mut Window, cx: &mut App, )

绘制阶段，委托给 Plot::paint 进行实际渲染

type RequestLayoutState = ()

Element::request_layout 返回的状态类型。 此状态的可变引用会在后续的 Element::prepaint 和 Element::paint 中传递。

type PrepaintState = ()

Element::prepaint 返回的状态类型。 此状态的可变引用会在后续的 Element::paint 中传递。

fn a11y_role(&self) -> Option<Role>

Returns the accessible role for this element, if any.

fn write_a11y_info(&self, _node: &mut Node)

Write accessibility properties to the given node.

fn into_any(self) -> AnyElement

Convert this element into a dynamically-typed AnyElement.

impl<T, B, V> IntoElement for BarChart<T, B, V>

where T: 'static, B: PartialEq + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

实现 IntoElement trait，使图表类型可直接作为元素使用

type Element = BarChart<T, B, V>

The specific type of element into which the implementing type is converted. Useful for converting other types into elements automatically, like Strings

fn into_element(self) -> Self::Element

Convert self into a type that implements Element.

fn into_any_element(self) -> AnyElement

Convert self into a dynamically-typed AnyElement.

impl<T, B, V> Plot for BarChart<T, B, V>

where B: PartialEq + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

fn paint(&mut self, bounds: Bounds<Pixels>, window: &mut Window, cx: &mut App)