Trait DrawScope 

pub trait DrawScope {
    // Required methods
    fn size(&self) -> Size;
    fn draw_content(&mut self);
    fn draw_rect(&mut self, brush: Brush);
    fn draw_rect_blend(&mut self, brush: Brush, blend_mode: BlendMode);
    fn draw_rect_at(&mut self, rect: Rect, brush: Brush);
    fn draw_rect_at_blend(
        &mut self,
        rect: Rect,
        brush: Brush,
        blend_mode: BlendMode,
    );
    fn draw_round_rect(&mut self, brush: Brush, radii: CornerRadii);
    fn draw_round_rect_blend(
        &mut self,
        brush: Brush,
        radii: CornerRadii,
        blend_mode: BlendMode,
    );
    fn draw_round_rect_at(
        &mut self,
        rect: Rect,
        brush: Brush,
        radii: CornerRadii,
    );
    fn draw_circle(&mut self, brush: Brush, center: Point, radius: f32);
    fn draw_circle_blend(
        &mut self,
        brush: Brush,
        center: Point,
        radius: f32,
        blend_mode: BlendMode,
    );
    fn draw_rect_stroked(&mut self, brush: Brush, stroke: Stroke);
    fn draw_rect_stroked_blend(
        &mut self,
        brush: Brush,
        stroke: Stroke,
        blend_mode: BlendMode,
    );
    fn draw_rect_at_stroked(&mut self, rect: Rect, brush: Brush, stroke: Stroke);
    fn draw_rect_at_stroked_blend(
        &mut self,
        rect: Rect,
        brush: Brush,
        stroke: Stroke,
        blend_mode: BlendMode,
    );
    fn draw_round_rect_stroked(
        &mut self,
        brush: Brush,
        radii: CornerRadii,
        stroke: Stroke,
    );
    fn draw_round_rect_stroked_blend(
        &mut self,
        brush: Brush,
        radii: CornerRadii,
        stroke: Stroke,
        blend_mode: BlendMode,
    );
    fn draw_round_rect_at_stroked(
        &mut self,
        rect: Rect,
        brush: Brush,
        radii: CornerRadii,
        stroke: Stroke,
    );
    fn draw_round_rect_at_stroked_blend(
        &mut self,
        rect: Rect,
        brush: Brush,
        radii: CornerRadii,
        stroke: Stroke,
        blend_mode: BlendMode,
    );
    fn draw_circle_stroked(
        &mut self,
        brush: Brush,
        center: Point,
        radius: f32,
        stroke: Stroke,
    );
    fn draw_circle_stroked_blend(
        &mut self,
        brush: Brush,
        center: Point,
        radius: f32,
        stroke: Stroke,
        blend_mode: BlendMode,
    );
    fn draw_arc(
        &mut self,
        brush: Brush,
        center: Point,
        radius: f32,
        start_angle: f32,
        sweep_angle: f32,
        stroke: Stroke,
    );
    fn draw_arc_blend(
        &mut self,
        brush: Brush,
        center: Point,
        radius: f32,
        start_angle: f32,
        sweep_angle: f32,
        stroke: Stroke,
        blend_mode: BlendMode,
    );
    fn draw_annular_sector(
        &mut self,
        brush: Brush,
        center: Point,
        inner_radius: f32,
        outer_radius: f32,
        start_angle: f32,
        sweep_angle: f32,
    );
    fn draw_annular_sector_blend(
        &mut self,
        brush: Brush,
        center: Point,
        inner_radius: f32,
        outer_radius: f32,
        start_angle: f32,
        sweep_angle: f32,
        blend_mode: BlendMode,
    );
    fn draw_image(&mut self, image: ImageBitmap);
    fn draw_image_blend(&mut self, image: ImageBitmap, blend_mode: BlendMode);
    fn draw_image_at(
        &mut self,
        rect: Rect,
        image: ImageBitmap,
        alpha: f32,
        color_filter: Option<ColorFilter>,
    );
    fn draw_image_at_sampled(
        &mut self,
        rect: Rect,
        image: ImageBitmap,
        alpha: f32,
        color_filter: Option<ColorFilter>,
        sampling: ImageSampling,
    );
    fn draw_image_at_blend(
        &mut self,
        rect: Rect,
        image: ImageBitmap,
        alpha: f32,
        color_filter: Option<ColorFilter>,
        blend_mode: BlendMode,
    );
    fn draw_image_src(
        &mut self,
        image: ImageBitmap,
        src_rect: Rect,
        dst_rect: Rect,
        alpha: f32,
        color_filter: Option<ColorFilter>,
    );
    fn draw_image_src_sampled(
        &mut self,
        image: ImageBitmap,
        src_rect: Rect,
        dst_rect: Rect,
        alpha: f32,
        color_filter: Option<ColorFilter>,
        sampling: ImageSampling,
    );
    fn draw_image_src_blend(
        &mut self,
        image: ImageBitmap,
        src_rect: Rect,
        dst_rect: Rect,
        alpha: f32,
        color_filter: Option<ColorFilter>,
        blend_mode: BlendMode,
    );
    fn draw_vector_path(&mut self, path: &VectorPath, brush: Brush);
    fn measure_text(&self, text: &str, style: &TextStyle) -> TextMeasurement;
    fn draw_text_at(
        &mut self,
        rect: Rect,
        brush: Brush,
        text: &str,
        style: &TextStyle,
    );
    fn into_primitives(self) -> Vec<DrawPrimitive>;

    // Provided methods
    fn draw_svg_path(&mut self, d: &str, brush: Brush) { ... }
    fn draw_text(&mut self, brush: Brush, text: &str, style: &TextStyle) { ... }
    fn draw_text_from(
        &mut self,
        top_left: Point,
        brush: Brush,
        text: &str,
        style: &TextStyle,
    ) { ... }
}

Required Methods

fn size(&self) -> Size

fn draw_content(&mut self)

fn draw_rect(&mut self, brush: Brush)

fn draw_rect_blend(&mut self, brush: Brush, blend_mode: BlendMode)

fn draw_rect_at(&mut self, rect: Rect, brush: Brush)

Draws a rectangle at the specified position and size.

fn draw_rect_at_blend( &mut self, rect: Rect, brush: Brush, blend_mode: BlendMode, )

fn draw_round_rect(&mut self, brush: Brush, radii: CornerRadii)

fn draw_round_rect_blend( &mut self, brush: Brush, radii: CornerRadii, blend_mode: BlendMode, )

fn draw_round_rect_at(&mut self, rect: Rect, brush: Brush, radii: CornerRadii)

Draws a rounded rectangle at the specified position and size.

fn draw_circle(&mut self, brush: Brush, center: Point, radius: f32)

fn draw_circle_blend( &mut self, brush: Brush, center: Point, radius: f32, blend_mode: BlendMode, )

fn draw_rect_stroked(&mut self, brush: Brush, stroke: Stroke)

Strokes the outline of the whole scope rect.

fn draw_rect_stroked_blend( &mut self, brush: Brush, stroke: Stroke, blend_mode: BlendMode, )

fn draw_rect_at_stroked(&mut self, rect: Rect, brush: Brush, stroke: Stroke)

Strokes the outline of rect.

fn draw_rect_at_stroked_blend( &mut self, rect: Rect, brush: Brush, stroke: Stroke, blend_mode: BlendMode, )

fn draw_round_rect_stroked( &mut self, brush: Brush, radii: CornerRadii, stroke: Stroke, )

Strokes the outline of the whole scope rect with rounded corners.

fn draw_round_rect_stroked_blend( &mut self, brush: Brush, radii: CornerRadii, stroke: Stroke, blend_mode: BlendMode, )

fn draw_round_rect_at_stroked( &mut self, rect: Rect, brush: Brush, radii: CornerRadii, stroke: Stroke, )

Strokes the outline of rect with rounded corners.

fn draw_round_rect_at_stroked_blend( &mut self, rect: Rect, brush: Brush, radii: CornerRadii, stroke: Stroke, blend_mode: BlendMode, )

fn draw_circle_stroked( &mut self, brush: Brush, center: Point, radius: f32, stroke: Stroke, )

Strokes a circle outline. Lowers to a stroked rounded rect, so it shares the fill pipeline and batches with every other shape.

fn draw_circle_stroked_blend( &mut self, brush: Brush, center: Point, radius: f32, stroke: Stroke, blend_mode: BlendMode, )

fn draw_arc( &mut self, brush: Brush, center: Point, radius: f32, start_angle: f32, sweep_angle: f32, stroke: Stroke, )

Strokes a circular arc.

Angles are in radians, 0 points along +X, and increasing angles sweep clockwise on screen (Cranpose uses y-down device coordinates, so this matches atan2(dy, dx) and the sweep-gradient brush). A negative sweep_angle sweeps counter-clockwise; |sweep| >= 2π draws a closed ring.

The stroke is centered on radius, so the band covers radius ± width/2. StrokeCap shapes the two ends. Nothing is drawn for a zero sweep, a non-positive width, or non-finite input.

fn draw_arc_blend( &mut self, brush: Brush, center: Point, radius: f32, start_angle: f32, sweep_angle: f32, stroke: Stroke, blend_mode: BlendMode, )

fn draw_annular_sector( &mut self, brush: Brush, center: Point, inner_radius: f32, outer_radius: f32, start_angle: f32, sweep_angle: f32, )

Fills an annular sector — the region between inner_radius and outer_radius, limited to an angular sweep, with flat radial ends.

This is the shape a stroked arc cannot express: its ends are straight lines through the center, not caps. inner_radius = 0 fills a pie wedge. Angle convention is identical to draw_arc. Nothing is drawn when inner_radius >= outer_radius, the sweep is zero, or any input is non-finite.

fn draw_annular_sector_blend( &mut self, brush: Brush, center: Point, inner_radius: f32, outer_radius: f32, start_angle: f32, sweep_angle: f32, blend_mode: BlendMode, )

fn draw_image(&mut self, image: ImageBitmap)

fn draw_image_blend(&mut self, image: ImageBitmap, blend_mode: BlendMode)

fn draw_image_at( &mut self, rect: Rect, image: ImageBitmap, alpha: f32, color_filter: Option<ColorFilter>, )

fn draw_image_at_sampled( &mut self, rect: Rect, image: ImageBitmap, alpha: f32, color_filter: Option<ColorFilter>, sampling: ImageSampling, )

fn draw_image_at_blend( &mut self, rect: Rect, image: ImageBitmap, alpha: f32, color_filter: Option<ColorFilter>, blend_mode: BlendMode, )

fn draw_image_src( &mut self, image: ImageBitmap, src_rect: Rect, dst_rect: Rect, alpha: f32, color_filter: Option<ColorFilter>, )

Draws a sub-region of an image. src_rect is in image-pixel coordinates; dst_rect is in scope coordinates.

fn draw_image_src_sampled( &mut self, image: ImageBitmap, src_rect: Rect, dst_rect: Rect, alpha: f32, color_filter: Option<ColorFilter>, sampling: ImageSampling, )

fn draw_image_src_blend( &mut self, image: ImageBitmap, src_rect: Rect, dst_rect: Rect, alpha: f32, color_filter: Option<ColorFilter>, blend_mode: BlendMode, )

fn draw_vector_path(&mut self, path: &VectorPath, brush: Brush)

Fills a parsed SVG path in scope coordinates (path units are dp).

The fill is rasterized on the CPU into a supersampled, anti-aliased bitmap covering the path bounds and drawn as an image primitive, so it works on every render backend. Parse the path once with crate::VectorPath::parse and redraw it per frame. Solid brushes are honored exactly; gradient brushes currently fall back to their first stop color.

fn measure_text(&self, text: &str, style: &TextStyle) -> TextMeasurement

The block size, line height and first baseline text would occupy in style.

Free to call repeatedly: the underlying text stack caches metrics on (text, style), so a game can measure every label every frame to center it without touching a font file more than once.

fn draw_text_at( &mut self, rect: Rect, brush: Brush, text: &str, style: &TextStyle, )

Draws text inside rect, positioned by TextStyle::align and TextStyle::vertical_align.

The glyphs are not clipped to rect — it is an alignment box, not a viewport. A rect narrower than the measured text overflows in the direction the alignment implies; clip the layer if that matters.

fn into_primitives(self) -> Vec<DrawPrimitive>

Provided Methods

fn draw_svg_path(&mut self, d: &str, brush: Brush)

Parses SVG path data (the d attribute syntax: M/m L/l H/h V/v C/c S/s Q/q T/t A/a Z/z) and fills it. Invalid path data draws nothing. Prefer crate::VectorPath::parse + draw_vector_path to avoid re-parsing and to surface parse errors.

fn draw_text(&mut self, brush: Brush, text: &str, style: &TextStyle)

Draws text inside the whole scope rect, positioned by TextStyle::align and TextStyle::vertical_align.

fn draw_text_from( &mut self, top_left: Point, brush: Brush, text: &str, style: &TextStyle, )

Draws text with the top-left corner of its block at top_left.

Alignment is a no-op here because the box is the measurement — this is the “I already know where it goes” form, and the one to pair with measure_text for hand-rolled centering.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl DrawScope for DrawScopeDefault