Struct BarChart 

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

Implementations

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

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

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

where I: IntoIterator<Item = T>,

pub fn id(self, id: impl Into<ElementId>) -> Self

Enable an interactive hover tooltip (crosshair + category/value) for this chart.

The id must be unique among sibling elements. Without it, the chart stays a non-interactive plot. Works for every BarAlignment (vertical bars get a vertical crosshair, horizontal bars a horizontal one).

pub fn name(self, name: impl Into<SharedString>) -> Self

Set the series name shown in the hover tooltip row (e.g. “Desktop”).

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 value_axis(self, value_axis: bool) -> Self

Show or hide the value-axis tick labels.

Enabling this reserves [VALUE_AXIS_GAP] along the band axis (left of vertical bars, below horizontal ones) for the labels.

Default is false.

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

Set how many even intervals the value axis is divided into, which drives both the grid line spacing and the value-axis tick labels.

This is a count, unlike Self::tick_margin, which is a stride over the band axis categories.

Default is 4.

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: Eq + Hash + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

type RequestLayoutState = ()

The type of state returned from Element::request_layout. A mutable reference to this state is subsequently provided to Element::prepaint and Element::paint.

type PrepaintState = (Option<Hitbox>, Vec<AnyElement>, Option<AnyElement>)

The type of state returned from Element::prepaint. A mutable reference to this state is subsequently provided to Element::paint.

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

If this element has a unique identifier, return it here. This is used to track elements across frames, and will cause a GlobalElementId to be passed to the request_layout, prepaint, and paint methods.

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

Source location where this element was constructed, used to disambiguate elements in the inspector and navigate to their source code.

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

Before an element can be painted, we need to know where it’s going to be and how big it is. Use this method to request a layout from Taffy and initialize the element’s state.

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

After laying out an element, we need to commit its bounds to the current frame for hitbox purposes. The state argument is the same state that was returned from Element::request_layout().

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

Once layout has been completed, this method will be called to paint the element to the screen. The state argument is the same state that was returned from Element::request_layout().

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

Returns the accessible role for this element, if any. Elements that return None are not included in the accessibility tree.

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

Write accessibility properties to the given node. Called only when a11y_role() returns Some.

fn a11y_synthetic_children( &mut self, _prepaint: &mut Self::PrepaintState, _builder: &mut A11ySubtreeBuilder<'_>, )

Add synthetic child nodes to an Element that has an .id() and a .role().

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: Eq + Hash + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

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: Eq + Hash + Into<SharedString> + 'static, V: Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

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

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

A stable element id that enables interactive tooltip support for this plot.

fn tooltip_state( &self, position: Point<Pixels>, bounds: Bounds<Pixels>, _cx: &App, ) -> Option<TooltipState>

Map the cursor to the tooltip state to display.

fn tooltip( &self, state: &TooltipState, cursor: Point<Pixels>, bounds: Bounds<Pixels>, window: &mut Window, cx: &mut App, ) -> Option<AnyElement>

Render the tooltip overlay for the active TooltipState.

fn prepaint( &mut self, _bounds: Bounds<Pixels>, _window: &mut Window, _cx: &mut App, ) -> Vec<AnyElement>

Lay out and place the child elements this plot hosts (e.g. element labels).