Struct CanvasView 

pub struct CanvasView<State>
where
    State: 'static,
{ /* private fields */ }

Declarative custom painting over the [PaintScene] trait object — a chart, a node-and-edge graph, a game board — without hand-rolling a View/ Widget pair. canvas takes a paint closure that runs in local space (the widget’s own top-left is always (0, 0), and painting past its own size is clipped, never a bug to chase) — flat-re-exported from frust-widgets so app code never names that crate directly. See CanvasView’s own doc for the full builder contract (.size/.expand sizing, .on_hit-gated .on_tap/.on_pointer, and .repaint_key for paint-only dirtying driven by data outside the ordinary View diff).

use frust::authoring::{PaintCtx, PaintScene};
use frust::{AnyView, Component, any, canvas};
use kurbo::{Point, Size};
use peniko::Color;

#[derive(Default)]
struct Clock;

impl Component for Clock {
    type State = u32;

    fn init(&self) -> Self::State {
        0
    }

    fn build(&self, state: &mut Self::State) -> AnyView<Self::State> {
        let ticks = *state;
        any(canvas(move |scene: &mut dyn PaintScene, size: Size, _ctx: &PaintCtx| {
            scene.fill_rect(Point::ZERO, size, Color::from_rgb8(0x10, 0x10, 0x10));
        })
        .expand()
        .repaint_key(ticks))
    }
}

frust::app!(Clock);

A declarative custom-painting canvas. See the module docs.

Implementations

impl<State> CanvasView<State>

where State: 'static,

pub fn size(self, size: Size) -> CanvasView<State>

Force an explicit size, clamped into whatever constraints this widget’s parent hands it. Overrides CanvasView::expand when called after it (last builder call wins, matching the crate’s other size-mode builders — e.g. crate::platform_view).

pub fn expand(self) -> CanvasView<State>

Fill the incoming constraints’ maximum — the default (see the module docs), provided as an explicit builder call for readability at call sites that want to make the choice visible.

pub fn on_hit<F>(self, hit: F) -> CanvasView<State>

where F: Fn(Point, Size) -> bool + 'static,

Narrow pointer hit-testing to hit(local_point, size) -> bool, consulted before CanvasView::on_tap/CanvasView::on_pointer dispatch (see the module docs). Unset, hit-testing falls back to the ordinary “inside the rectangular bounds” test every other baseline leaf uses.

pub fn on_tap<F>(self, on_tap: F) -> CanvasView<State>

where F: Fn(&mut State) + 'static,

Fire on_tap(state) on an up-inside release (gated by CanvasView::on_hit, see the module docs).

pub fn on_pointer<F>(self, on_pointer: F) -> CanvasView<State>

where F: Fn(&mut State, PointerEvent) + 'static,

Fire on_pointer(state, event) with the raw PointerEvent on every phase the hit-test admits (gated by CanvasView::on_hit, see the module docs) — the escape hatch for a caller that wants the full gesture (drag included) rather than just the tap summary.

pub fn repaint_key(self, key: impl Hash) -> CanvasView<State>

Opt into paint-only dirtying driven by a dependency outside the ordinary View diff: hash any Hash fingerprint of the data the paint closure reads, and a changed hash across a rebuild requests ChangeFlags::PAINT even when nothing else about the view changed. See the module docs.

Trait Implementations

impl<State> View<State> for CanvasView<State>

where State: 'static,

type Element = CanvasWidget

The retained widget this view produces.

fn build(&self, _ctx: &mut BuildCtx<'_>) -> CanvasWidget

Materialise a fresh widget for this view.

fn rebuild( &self, prev: &CanvasView<State>, element: &mut CanvasWidget, _ctx: &mut BuildCtx<'_>, ) -> ChangeFlags

Reconcile prev (the previous view of the same type) against the live element, mutating it in place and reporting what changed.

fn teardown(&self, _element: &mut Self::Element, _ctx: &mut BuildCtx<'_>)

Tear down element when this view is being removed.

fn message(&self, _element: &mut Self::Element, _state: &mut State)

Deliver an event message to this view, mutating application state.