Struct LineChart 

pub struct LineChart<T, X, Y>
where
    T: 'static,
    X: PartialEq + Into<SharedString> + 'static,
    Y: PlotValue,
{ /* private fields */ }

Implementations

impl<T, X, Y> LineChart<T, X, Y>

where X: PartialEq + Into<SharedString> + 'static, 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 crosshair and a dot mark the hovered point, and a tooltip shows its 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 x 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 crosshair, 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 x(self, x: impl Fn(&T) -> X + 'static) -> Self

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

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

pub fn natural(self) -> Self

pub fn linear(self) -> Self

pub fn step_after(self) -> Self

pub fn dot(self) -> Self

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

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

Show or hide the x-axis line and labels.

Default is true.

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

pub fn y_domain(self, min: Y, max: Y) -> Self

Pin the y axis to min..=max instead of fitting the line from zero.

Pin it where zero is not a meaningful baseline, such as a price line that would otherwise be pressed flat against the top. The range keeps the y_padding headroom above max, 10px by default, and the line is clipped to the plot, so a value outside the range stops at its edge. Nothing is drawn when min equals max.

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

Lay the x axis out for count evenly spaced points instead of the data’s own length.

The data takes the leading points in order, the i-th item on the i-th point, and the rest stay empty, as an intraday chart does before the close. The data has to be contiguous from the first point: a missing item shifts every later one a point to the left. A count below the data’s length has no effect.

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

Show the y axis’s tick labels, one at each of the y_tick_count ticks.

Default is false.

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

Set where the y-axis tick labels sit: in a gutter left of the plot, or inside it beside their grid lines.

Default is AxisLabelPlacement::Outside.

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

Set how many ticks the y axis carries, evenly spaced from the baseline to the top edge with both ends included.

The ticks place the horizontal grid lines and the tick labels, and each label reads the value the scale puts at its height. Values below 2 are raised to 2.

Default is 5.

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

where S: Into<SharedString> + 'static,

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

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

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

With Self::point_count set, the labels spread over all the points the axis is laid out for, so they keep their places as the data grows; one that falls past the data is not drawn yet.

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

Divide the plot into count columns with vertical grid lines, the first on its left edge.

Default is 0, no vertical lines.

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

Draw the grid dashed or solid.

Default is true.

pub fn reference_line(self, value: Y) -> Self

Draw a dashed line across the plot at value, such as a previous close.

Call again for more lines. A value outside the y axis is not drawn.

pub fn y_padding(self, top: f32, bottom: f32) -> Self

Set the space kept clear above the highest value and below the lowest, in pixels.

Default is 10px above and none below.

Trait Implementations

impl<T, X, Y> IntoElement for LineChart<T, X, Y>

where T: 'static, X: PartialEq + Into<SharedString> + 'static, Y: PlotValue,

type Element = PlotElement<LineChart<T, X, 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, X, Y> Plot for LineChart<T, X, Y>

where X: PartialEq + Into<SharedString> + 'static, Y: 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 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.