Struct RadarChart 

pub struct RadarChart<T, Y>
where
    T: 'static,
    Y: PlotValue,
{ /* private fields */ }

A radar (spider) chart.

Each datum is one dimension (a spoke), placed clockwise around the center starting at 12 o’clock. Add one series per RadarChart::value call; each series is drawn as a closed polygon connecting its values on every spoke.

Implementations

impl<T, Y> RadarChart<T, Y>

where Y: 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 dot per series marks the hovered dimension, and a tooltip shows a row each. 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 name of the most recently added series, shown in its tooltip row.

Call after the matching RadarChart::value (e.g. .value(..).stroke(..).name("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 dimension label.

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

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

The closure receives the datum, the row’s index (the series’ index in the order value added them) and the value the row reads.

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

where H: Into<Hsla>,

Color each 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 dots and where the box sits stay the chart’s, and tooltip_title, tooltip_value and tooltip_value_color no longer apply.

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

Add a series to the radar chart.

Call multiple times to overlay multiple series, each paired with the matching RadarChart::stroke and RadarChart::fill calls.

pub fn stroke(self, stroke: impl Into<Hsla>) -> Self

Set the stroke color of the most recently added series.

Defaults to the theme chart colors, cycled per series.

pub fn fill(self, fill: impl Into<Background>) -> Self

Set the fill color of the most recently added series.

Defaults to the series stroke color with 0.3 opacity.

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

where L: Into<RadarLabel> + 'static,

Set the label for each dimension, shown outside the outer ring.

Return a string for a plain text label, or element.into_any_element() for a custom one; see RadarLabel for how the two differ.

RadarChart::new(data).label(|d| d.month.clone())

RadarChart::new(data).label(|d| {
    v_flex()
        .items_center()
        .child(Icon::new(IconName::Star).xsmall())
        .child(d.month.clone())
        .into_any_element()
})

pub fn label_color(self, color: impl Into<Hsla>) -> Self

Set the text label color (defaults to cx.theme().muted_foreground).

Element labels style themselves; this does not apply to them.

pub fn label_gap(self, gap: f32) -> Self

Set the extra gap between the outer ring and the labels (defaults to 10px).

pub fn max_value(self, max_value: Y) -> Self

Set the value at the outer ring.

Defaults to the maximum value across all series.

pub fn outer_radius(self, outer_radius: f32) -> Self

Set the outer radius of the radar chart.

Defaults to 40% of the bounds height.

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

Show or hide the grid rings and spokes.

Default is true.

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

Set the number of concentric grid rings (defaults to 4).

pub fn dot(self) -> Self

Show dots on the vertices of each series.

Trait Implementations

impl<T, Y> IntoElement for RadarChart<T, Y>

where T: 'static, Y: PlotValue,

type Element = PlotElement<RadarChart<T, Y>>

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, Y> Plot for RadarChart<T, Y>

where Y: PlotValue,

fn prepaint( &mut self, bounds: Bounds<Pixels>, window: &mut Window, cx: &mut App, ) -> Vec<AnyElement>

Resolve every dimension’s label, keeping the text ones for paint and laying out the element ones here (measuring is illegal in paint).

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