Struct relm4::drawing::DrawHandler

pub struct DrawHandler { /* private fields */ }

Manager for drawing operations.

Implementations

impl DrawHandler

pub fn new() -> Self

Create a new DrawHandler.

Examples found in repository

relm4/examples/drawing.rs (line 123)

    fn init(
        _: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let model = App {
            width: 100.0,
            height: 100.0,
            points: Vec::new(),
            handler: DrawHandler::new(),
        };

        let area = model.handler.drawing_area();
        let widgets = view_output!();

        sender.command(|out, shutdown| {
            shutdown
                .register(async move {
                    loop {
                        tokio::time::sleep(Duration::from_millis(20)).await;
                        out.send(UpdatePointsMsg).unwrap();
                    }
                })
                .drop_on_shutdown()
        });

        ComponentParts { model, widgets }
    }

pub fn new_with_drawing_area(drawing_area: DrawingArea) -> Self

Create a new DrawHandler with an existing gtk::DrawingArea.

pub fn get_context(&mut self) -> DrawContext

Get the drawing context to draw on a gtk::DrawingArea. If the size of the gtk::DrawingArea changed, the contents of the surface will be replaced by a new, empty surface.

Examples found in repository

relm4/examples/drawing.rs (line 70)

    fn update(&mut self, msg: Msg, _sender: ComponentSender<Self>, _root: &Self::Root) {
        let cx = self.handler.get_context();

        match msg {
            Msg::AddPoint((x, y)) => {
                self.points.push(Point::new(x, y));
            }
            Msg::Resize((x, y)) => {
                self.width = x as f64;
                self.height = y as f64;
            }
            Msg::Reset => {
                cx.set_operator(Operator::Clear);
                cx.set_source_rgba(0.0, 0.0, 0.0, 0.0);
                cx.paint().expect("Couldn't fill context");
            }
        }

        draw(&cx, &self.points);
    }

    fn update_cmd(&mut self, _: UpdatePointsMsg, _: ComponentSender<Self>, _root: &Self::Root) {
        for point in &mut self.points {
            let Point { x, y, .. } = point;
            if *x < 0.0 {
                point.xs = point.xs.abs();
            } else if *x > self.width {
                point.xs = -point.xs.abs();
            }
            *x = x.clamp(0.0, self.width);
            *x += point.xs;

            if *y < 0.0 {
                point.ys = point.ys.abs();
            } else if *y > self.height {
                point.ys = -point.ys.abs();
            }
            *y = y.clamp(0.0, self.height);
            *y += point.ys;
        }

        let cx = self.handler.get_context();
        draw(&cx, &self.points);
    }

pub fn height(&self) -> i32

Get the height of the DrawHandler.

pub fn width(&self) -> i32

Get the width of the DrawHandler.

pub fn drawing_area(&self) -> &DrawingArea

Get the gtk::DrawingArea of the DrawHandler.

Examples found in repository

relm4/examples/drawing.rs (line 126)

    fn init(
        _: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let model = App {
            width: 100.0,
            height: 100.0,
            points: Vec::new(),
            handler: DrawHandler::new(),
        };

        let area = model.handler.drawing_area();
        let widgets = view_output!();

        sender.command(|out, shutdown| {
            shutdown
                .register(async move {
                    loop {
                        tokio::time::sleep(Duration::from_millis(20)).await;
                        out.send(UpdatePointsMsg).unwrap();
                    }
                })
                .drop_on_shutdown()
        });

        ComponentParts { model, widgets }
    }

Trait Implementations

impl Debug for DrawHandler

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DrawHandler

fn default() -> Self

Returns the “default value” for a type.