Struct BarChart 

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

Implementations

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

where B: Eq + Hash + Into<SharedString> + 'static, V: PlotValue,

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

where I: IntoIterator<Item = T>,

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

Name this chart’s ElementId, replacing the default taken from the construction site.

Pass one where a single construction site renders several of these charts as siblings: they share the default id, and with it one hover state and one path cache. The id must be unique among those siblings.

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

Turn this chart’s interactive layer on or off. On by default.

The layer is the hitbox under the cursor and what it drives: a crosshair marks the hovered band, and a tooltip shows its category and value. Turn it off for a chart that only decorates, or one an element above it wants the cursor for: without a hitbox it neither answers the mouse nor takes the hover from what sits over it. A chart that is off also drops its path cache, which is keyed on the same id.

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

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

pub fn tooltip_title(self, title: impl Fn(&T) -> SharedString + 'static) -> Self

Set the hover tooltip’s title for a datum, instead of its band value.

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

Set the text of the tooltip row’s value; the raw number by default.

The closure receives the datum and the value the row reads.

pub fn tooltip_value_color<H>( self, color: impl Fn(&T, f64) -> H + 'static, ) -> Self

where H: Into<Hsla>,

Color the tooltip row’s value, such as green or red by its sign; the tooltip’s text color by default.

The closure receives the same arguments as tooltip_value.

pub fn tooltip_content<E>( self, content: impl Fn(&T, &mut Window, &mut App) -> E + 'static, ) -> Self

where E: IntoElement,

Draw the tooltip box’s content for a datum yourself, in place of the title and rows, for a layout they cannot express such as a table.

The highlight band and where the box sits stay the chart’s, and tooltip_title, tooltip_value and tooltip_value_color no longer apply.

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_color<H>(self, color: impl Fn(&T) -> H + 'static) -> Self

where H: Into<Hsla> + 'static,

Color each bar’s label text, instead of the theme’s foreground for all of them.

Takes a closure per bar, as fill does, so a label can follow its bar’s color.

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.

Placed Outside, the default, the labels take a gutter along the band axis, left of vertical bars and below horizontal ones.

Default is false.

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

Set how many ticks the value axis carries, evenly spaced from the baseline to the far edge with both ends included, which drives both the grid lines and the value-axis tick labels.

Unlike Self::tick_margin, a stride over the band axis categories, this counts the ticks themselves. Values below 2 are raised to 2.

Default is 5.

pub fn value_axis_label_placement(self, placement: AxisLabelPlacement) -> Self

Set where the value-axis tick labels sit: in a gutter beside the bars, or inside the plot beside their grid lines, which keeps the bars’ room.

Default is AxisLabelPlacement::Outside.

pub fn value_tick_format<S>(self, format: impl Fn(f64) -> S + 'static) -> Self

where S: Into<SharedString> + 'static,

Set the text of each value-axis tick label from the value at its tick.

Default is whole numbers bare and the rest to one decimal.

pub fn band_count(self, count: usize) -> Self

Lay the band axis out for count bands instead of the data’s own length.

The data takes the leading bands in order and the rest stay empty, so each bar keeps its width and place as the data grows. A count below the data’s length has no effect.

pub fn band_tick_count(self, count: usize) -> Self

Label count of the bands, spread evenly from the first to the last, instead of every tick_margin-th.

With Self::band_count set, the labels spread over all the bands, so they keep their places as the data grows; one that falls on an empty band is not drawn yet.

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

pub fn grid_dashed(self, dashed: bool) -> Self

Draw the grid dashed or solid.

Default is true.

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).

pub fn padding_inner(self, padding: f32) -> Self

Set the gap between neighbouring bars, as a share of each band.

Default is 0.4.

pub fn padding_outer(self, padding: f32) -> Self

Set the gap before the first bar and after the last, as a share of a band.

Default is 0.2.

pub fn max_band_width(self, width: impl Into<Pixels>) -> Self

Keep every bar at most width wide, so a few bars across a wide chart stay narrow instead of filling their bands.

Default is 30px.

pub fn min_length(self, length: f32) -> Self

Draw every bar at least length pixels long, so a zero or tiny value still shows a stub instead of disappearing into the baseline.

The stub grows the way the bar’s value would: away from the zero line, to the negative side for a negative value and to the positive side for zero. A bar already that long is left alone.

Default is 0.

Trait Implementations

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

where T: 'static, B: Eq + Hash + Into<SharedString> + 'static, V: PlotValue,

type Element = PlotElement<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: PlotValue,

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).

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 hover( &mut self, hover: Option<&PlotHover>, window: &mut Window, cx: &mut App, )

Receive the hovered datum this frame, before Plot::tooltip and Plot::paint run.

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.