Struct plotters_druid::Plot

pub struct Plot<T: Data> { /* private fields */ }

The type of a plot widget.

See Plot::new for information on how to construct this.

This implements druid::Widget so it can be used like any other widget type.

fn build_plot_widget() -> impl Widget<()> {
    // ... construct and return widget using Plot::new()
}

let main_window = WindowDesc::new(build_plot_widget());

Implementations

impl<T: Data> Plot<T>

pub fn new(
    f: impl Fn((u32, u32), &T, &DrawingArea<PietBackend<'_, '_>, Shift>) + 'static
) -> Plot<T>

Create a plot widget

This takes a function that should draw the plot using the normal plotters API. The function has access to the width and height of the plotting area, to the Data of the rust widget, and to a plotters DrawingArea.

Plot::new(|(width, height), data: &AppState, root| {
    root.fill(&WHITE).unwrap();
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(-1f32..1f32, -0.1f32..1f32)
        .unwrap();

    // see the plotters documentation on how to use `chart`
});

Examples found in repository

examples/simple.rs (lines 6-35)

fn build_plot_widget() -> impl Widget<()> {
    Plot::new(|_size, _data, root| {
        // Code taken from the plotters example: https://github.com/38/plotters#quick-start
        root.fill(&WHITE).unwrap();
        let mut chart = ChartBuilder::on(&root)
            .caption("y=x^2", ("sans-serif", 50).into_font())
            .margin(5)
            .margin_right(15)
            .x_label_area_size(30)
            .y_label_area_size(30)
            .build_cartesian_2d(-1f32..1f32, -0.1f32..1f32)
            .unwrap();

        chart.configure_mesh().draw().unwrap();

        chart
            .draw_series(LineSeries::new(
                (-50..=50).map(|x| x as f32 / 50.0).map(|x| (x, x * x)),
                &RED,
            ))
            .unwrap()
            .label("y = x^2")
            .legend(|(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], &RED));

        chart
            .configure_series_labels()
            .background_style(&WHITE.mix(0.8))
            .border_style(&BLACK)
            .draw()
            .unwrap();
    })
}

examples/interactive.rs (lines 14-63)

fn build_plot_widget() -> impl Widget<State> {
    Plot::new(|_size, data: &State, root| {
        let μ = data.μ as f32;

        let res = 400;
        let font = FontDesc::new(FontFamily::SansSerif, 16., FontStyle::Normal);

        let mut chart = ChartBuilder::on(&root)
            .x_label_area_size(30)
            .y_label_area_size(30)
            .margin_right(10)
            .build_cartesian_2d(0.0..1_f32, 0.0..6_f32)
            .unwrap();

        chart
            .configure_mesh()
            .axis_style(&RGBColor(28, 28, 28))
            .x_label_style(font.clone().with_color(&WHITE))
            .y_label_style(font.clone().with_color(&WHITE))
            .draw()
            .unwrap();

        for (σ, idx) in [0.32_f32, 0.56, 1., 1.78, 3.16].into_iter().zip(0..) {
            let fac = 1. / (σ * std::f32::consts::TAU.sqrt());
            let color = Palette99::pick(idx);

            let data = (0..res).map(|x| x as f32 / res as f32).map(|x| {
                let y = fac * (-(logit(x) - μ).powi(2) / (2. * σ.powi(2))).exp() / (x * (1. - x));
                (x, y)
            });

            chart
                .draw_series(LineSeries::new(data, &color))
                .unwrap()
                .label(format!("σ = {σ}"))
                .legend(move |(x, y)| {
                    PathElement::new(
                        vec![(x, y), (x + 20, y)],
                        ShapeStyle::from(&color).stroke_width(2),
                    )
                });
        }
        chart
            .configure_series_labels()
            .position(SeriesLabelPosition::UpperRight)
            .background_style(&RGBColor(41, 41, 41))
            .border_style(&RGBColor(28, 28, 28))
            .label_font(font.with_color(&WHITE))
            .draw()
            .unwrap();
    })
}

Trait Implementations

impl<T> Widget<T> for Plot<T>where
    T: Data,

fn event(&mut self, _: &mut EventCtx<'_, '_>, _: &Event, _: &mut T, _: &Env)

Handle an event.

fn lifecycle(&mut self, _: &mut LifeCycleCtx<'_, '_>, _: &LifeCycle, _: &T, _: &Env)

Handle a life cycle notification.

fn update(
    &mut self,
    ctx: &mut UpdateCtx<'_, '_>,
    old_data: &T,
    data: &T,
    _env: &Env
)

Update the widget’s appearance in response to a change in the app’s Data or Env.

fn layout(
    &mut self,
    _: &mut LayoutCtx<'_, '_>,
    bc: &BoxConstraints,
    _: &T,
    _: &Env
) -> Size

Compute layout.

fn paint(&mut self, ctx: &mut PaintCtx<'_, '_, '_>, data: &T, _: &Env)

Paint the widget appearance.

fn compute_max_intrinsic(
    &mut self,
    axis: Axis,
    ctx: &mut LayoutCtx<'_, '_>,
    bc: &BoxConstraints,
    data: &T,
    env: &Env
) -> f64

Computes max intrinsic/preferred dimension of a widget on the provided axis.