Struct RadarChart 

pub struct RadarChart<T, Y>
where
    T: 'static,
    Y: Clone + Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,
{ /* 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: Clone + 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 (a dot and row per series at the hovered dimension).

The id must be unique among sibling elements. Without it, the chart stays a non-interactive plot.

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

where T: 'static, Y: Clone + 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, Y> IntoElement for RadarChart<T, Y>

where T: 'static, Y: Clone + Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

type Element = 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: Clone + Copy + PartialOrd + Num + ToPrimitive + Sealed + 'static,

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.