Struct druid::PaintCtx

pub struct PaintCtx<'a, 'b: 'a> {
    pub render_ctx: &'a mut Piet<'b>,
    pub window_id: WindowId,
    // some fields omitted
}

A context passed to paint methods of widgets.

Widgets paint their appearance by calling methods on the render_ctx, which PaintCtx derefs to for convenience. This struct is expected to grow, for example to include the "damage region" indicating that only a subset of the entire widget hierarchy needs repainting.

Fields

render_ctx: &'a mut Piet<'b>

The render context for actually painting.

window_id: WindowId

Methods

impl<'a, 'b: 'a> PaintCtx<'a, 'b>

pub fn widget_id(&self) -> WidgetId

get the WidgetId of the current widget.

pub fn is_hot(&self) -> bool

Query the "hot" state of the widget.

See EventCtx::is_hot for additional information.

pub fn is_active(&self) -> bool

Query the "active" state of the widget.

See EventCtx::is_active for additional information.

pub fn size(&self) -> Size

Returns the layout size of the current widget.

See EventCtx::size for additional information.

pub fn is_focused(&self) -> bool

Query the focus state of the widget.

This is true only if this widget has focus.

pub fn has_focus(&self) -> bool

The focus status of a widget.

See has_focus.

pub fn region(&self) -> &Region

Returns the currently visible Region.

pub fn with_child_ctx(
    &mut self,
    region: impl Into<Region>,
    f: impl FnOnce(&mut PaintCtx)
)

Creates a temporary PaintCtx with a new visible region, and calls the provided function with that PaintCtx.

This is used by containers to ensure that their children have the correct visible region given their layout.

pub fn with_save(&mut self, f: impl FnOnce(&mut PaintCtx))

Saves the current context, executes the closures, and restores the context.

This is useful if you would like to transform or clip or otherwise modify the drawing context but do not want that modification to effect other widgets.

Examples

fn paint(&mut self, ctx: &mut PaintCtx, _data: &T, env: &Env) {
    let clip_rect = ctx.size().to_rect().inset(5.0);
    ctx.with_save(|ctx| {
        ctx.clip(clip_rect);
        ctx.stroke(clip_rect, &env.get(theme::PRIMARY_DARK), 5.0);
    });
}

pub fn paint_with_z_index(
    &mut self,
    z_index: u32,
    paint_func: impl FnOnce(&mut PaintCtx) + 'static
)

Allows to specify order for paint operations.

Larger z_index indicate that an operation will be executed later.

Methods from Deref<Target = Piet<'b>>

Trait Implementations

impl<'a, 'b: 'a> Deref for PaintCtx<'a, 'b>

type Target = Piet<'b>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, 'b: 'a> DerefMut for PaintCtx<'a, 'b>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.