Struct State 

pub struct State<Id>
where
    Id: Clone,
{ /* private fields */ }

Local state of the Chart.

Implementations

impl<Id> State<Id>

where Id: Clone,

pub fn get_cursor_position(&self) -> Option<Point>

pub fn get_coords(&self) -> Option<Point>

pub fn get_offset(&self) -> Option<Point>

Examples found in repository

examples/items_drag.rs (line 192)

    pub fn view(&self) -> Element<'_, Message> {
        let palette = self.theme().palette();
        container(
            Chart::new()
                .width(Length::Fill)
                .height(Length::Fill)
                .x_range(-0.5..=3.5)
                .y_range(-0.5..=1.5)
                .push_series(line_series(self.handles.iter()).color(palette.primary))
                .push_series(
                    point_series(self.handles.iter())
                        .color(palette.danger)
                        .style_for_each(|_index, handle| handle.style.clone())
                        .with_id(ItemId::PointList),
                )
                .on_press(|state| {
                    let id = state.items().and_then(|l| l.first().map(|i| i.1));
                    Message::MouseDown(id, state.get_offset())
                })
                .on_move(|state| {
                    let id = state.items().and_then(|l| l.first().map(|i| i.1));
                    Message::OnMove(id, state.get_offset())
                })
                .on_release(|state| Message::MouseUp(state.get_offset())),
        )
        .into()
    }

examples/scroll.rs (line 164)

    pub fn view(&self) -> Element<'_, Message> {
        let palette = self.theme().palette();

        let top = bound("Top").center_x(Length::Fill);
        let bottom = bound("Bottom").center_x(Length::Fill);
        let left = bound("Left").center_y(Length::Fill);
        let right = bound("Right").center_y(Length::Fill);

        let chart = Chart::<_, (), _>::new()
            .width(Length::Fill)
            .height(Length::Fill)
            .x_range(self.x_range.clone())
            .x_labels(Labels::default().format(&|v| format!("{v:.2}")))
            .y_labels(Labels::default().format(&|v| format!("{v:.5}")))
            .y_range(-2.0..=2.0)
            .push_series(line_series(self.data.iter().copied()).color(palette.primary)) // .push_series(
            .push_series(line_series(&self.data_1).color(palette.success))
            .push_series(
                point_series(self.data.iter().copied().map(|(x, y)| (x, y * 1.5)))
                    .x(&|item| item.0)
                    .y(&|item| item.1)
                    .color(palette.danger),
            )
            .on_press(|state| Message::MouseDown(state.get_offset()))
            .on_release(|state| Message::MouseUp(state.get_offset()))
            .on_move(|state| Message::OnMove(state.get_offset()));

        column![top, row![left, chart, right], bottom].into()
    }

pub fn x_range(&self) -> Option<RangeInclusive<f32>>

pub fn scroll_delta(&self) -> Option<ScrollDelta>

pub fn items(&self) -> Option<&Vec<(Id, usize)>>

Examples found in repository

examples/items.rs (line 115)

    pub fn view(&self) -> Element<'_, Message> {
        let palette = self.theme().palette();
        container(
            Chart::new()
                .width(Length::Fill)
                .height(Length::Fill)
                .x_range(-0.5..=3.5)
                .y_range(-0.5..=1.5)
                .push_series(line_series(&self.data).color(palette.text))
                .push_series(
                    point_series(self.data.iter())
                        .color(palette.danger)
                        .style_for_each(|_index, item| point::Style {
                            color: Some(item.color),
                            border_color: Some(item.border_color),
                            border: item.border,
                            ..Default::default()
                        })
                        .with_id(ItemId::PointList),
                )
                .on_move(|state| Message::OnMove(state.items().cloned())),
        )
        .into()
    }

examples/items_drag.rs (line 191)

    pub fn view(&self) -> Element<'_, Message> {
        let palette = self.theme().palette();
        container(
            Chart::new()
                .width(Length::Fill)
                .height(Length::Fill)
                .x_range(-0.5..=3.5)
                .y_range(-0.5..=1.5)
                .push_series(line_series(self.handles.iter()).color(palette.primary))
                .push_series(
                    point_series(self.handles.iter())
                        .color(palette.danger)
                        .style_for_each(|_index, handle| handle.style.clone())
                        .with_id(ItemId::PointList),
                )
                .on_press(|state| {
                    let id = state.items().and_then(|l| l.first().map(|i| i.1));
                    Message::MouseDown(id, state.get_offset())
                })
                .on_move(|state| {
                    let id = state.items().and_then(|l| l.first().map(|i| i.1));
                    Message::OnMove(id, state.get_offset())
                })
                .on_release(|state| Message::MouseUp(state.get_offset())),
        )
        .into()
    }

Trait Implementations

impl<Id> Default for State<Id>

where Id: Clone,

fn default() -> Self

Returns the “default value” for a type.