[][src]Trait piet::RenderContext

pub trait RenderContext where
    Self::Brush: IntoBrush<Self>, 
{ type Brush: Clone; type Text: Text<TextLayout = Self::TextLayout>; type TextLayout: TextLayout; type Image; fn status(&mut self) -> Result<(), Error>;
fn solid_brush(&mut self, color: Color) -> Self::Brush;
fn gradient(
        &mut self,
        gradient: impl Into<FixedGradient>
    ) -> Result<Self::Brush, Error>;
fn clear(&mut self, color: Color);
fn stroke(
        &mut self,
        shape: impl Shape,
        brush: &impl IntoBrush<Self>,
        width: f64
    );
fn stroke_styled(
        &mut self,
        shape: impl Shape,
        brush: &impl IntoBrush<Self>,
        width: f64,
        style: &StrokeStyle
    );
fn fill(&mut self, shape: impl Shape, brush: &impl IntoBrush<Self>);
fn fill_even_odd(&mut self, shape: impl Shape, brush: &impl IntoBrush<Self>);
fn clip(&mut self, shape: impl Shape);
fn text(&mut self) -> &mut Self::Text;
fn draw_text(&mut self, layout: &Self::TextLayout, pos: impl Into<Point>);
fn save(&mut self) -> Result<(), Error>;
fn restore(&mut self) -> Result<(), Error>;
fn finish(&mut self) -> Result<(), Error>;
fn transform(&mut self, transform: Affine);
fn make_image(
        &mut self,
        width: usize,
        height: usize,
        buf: &[u8],
        format: ImageFormat
    ) -> Result<Self::Image, Error>;
fn draw_image(
        &mut self,
        image: &Self::Image,
        dst_rect: impl Into<Rect>,
        interp: InterpolationMode
    );
fn draw_image_area(
        &mut self,
        image: &Self::Image,
        src_rect: impl Into<Rect>,
        dst_rect: impl Into<Rect>,
        interp: InterpolationMode
    );
fn blurred_rect(
        &mut self,
        rect: Rect,
        blur_radius: f64,
        brush: &impl IntoBrush<Self>
    );
fn current_transform(&self) -> Affine; fn with_save(
        &mut self,
        f: impl FnOnce(&mut Self) -> Result<(), Error>
    ) -> Result<(), Error> { ... } }

The main trait for rendering graphics.

This trait provides an API for drawing 2D graphics. In basic usage, it wraps a surface of some kind, so that drawing commands paint onto the surface. It can also be a recording context, creating a display list for playback later.

The intent of the design is to be general so that any number of back-ends can implement this trait.

Code that draws graphics will in general take &mut impl RenderContext.

Associated Types

type Brush: Clone

The type of a "brush".

Represents solid colors and gradients.

type Text: Text<TextLayout = Self::TextLayout>

An associated factory for creating text layouts and related resources.

type TextLayout: TextLayout

type Image

The associated type of an image.

Loading content...

Required methods

fn status(&mut self) -> Result<(), Error>

Report an internal error.

Drawing operations may cause internal errors, which may also occur asynchronously after the drawing command was issued. This method reports any such error that has been detected.

fn solid_brush(&mut self, color: Color) -> Self::Brush

Create a new brush resource.

TODO: figure out how to document lifetime and rebuilding requirements. Should that be the responsibility of the client, or should the back-end take responsibility? We could have a cache that is flushed when the Direct2D render target is rebuilt. Solid brushes are super lightweight, but other potentially retained objects will be heavier.

fn gradient(
    &mut self,
    gradient: impl Into<FixedGradient>
) -> Result<Self::Brush, Error>

Create a new gradient brush.

fn clear(&mut self, color: Color)

Clear the canvas with the given color.

Note: only opaque colors are meaningful.

fn stroke(
    &mut self,
    shape: impl Shape,
    brush: &impl IntoBrush<Self>,
    width: f64
)

Stroke a shape.

fn stroke_styled(
    &mut self,
    shape: impl Shape,
    brush: &impl IntoBrush<Self>,
    width: f64,
    style: &StrokeStyle
)

Stroke a shape, with styled strokes.

fn fill(&mut self, shape: impl Shape, brush: &impl IntoBrush<Self>)

Fill a shape, using non-zero fill rule.

fn fill_even_odd(&mut self, shape: impl Shape, brush: &impl IntoBrush<Self>)

Fill a shape, using even-odd fill rule

fn clip(&mut self, shape: impl Shape)

Clip to a shape.

All subsequent drawing operations up to the next restore are clipped by the shape.

fn text(&mut self) -> &mut Self::Text

fn draw_text(&mut self, layout: &Self::TextLayout, pos: impl Into<Point>)

Draw a text layout.

The pos parameter specifies the baseline of the left starting place of the text. Note: this is true even if the text is right-to-left.

fn save(&mut self) -> Result<(), Error>

Save the context state.

Pushes the current context state onto a stack, to be popped by restore.

Prefer with_save if possible, as that statically enforces balance of save/restore pairs.

The context state currently consists of a clip region and an affine transform, but is expected to grow in the near future.

fn restore(&mut self) -> Result<(), Error>

Restore the context state.

Pop a context state that was pushed by save. See that method for details.

fn finish(&mut self) -> Result<(), Error>

Finish any pending operations.

This will generally be called by a shell after all user drawing operations but before presenting. Not all back-ends will handle this the same way.

fn transform(&mut self, transform: Affine)

Apply a transform.

Apply an affine transformation. The transformation remains in effect until a restore operation.

fn make_image(
    &mut self,
    width: usize,
    height: usize,
    buf: &[u8],
    format: ImageFormat
) -> Result<Self::Image, Error>

Create a new image from a pixel buffer.

fn draw_image(
    &mut self,
    image: &Self::Image,
    dst_rect: impl Into<Rect>,
    interp: InterpolationMode
)

Draw an image.

The image is scaled to the provided dst_rect. It will be squashed if the aspect ratios don't match.

fn draw_image_area(
    &mut self,
    image: &Self::Image,
    src_rect: impl Into<Rect>,
    dst_rect: impl Into<Rect>,
    interp: InterpolationMode
)

Draw a specified area of an image.

The src_rect area of image is scaled to the provided dst_rect. It will be squashed if the aspect ratios don't match.

fn blurred_rect(
    &mut self,
    rect: Rect,
    blur_radius: f64,
    brush: &impl IntoBrush<Self>
)

Draw a rectangle with Gaussian blur.

The blur radius is sometimes referred to as the "standard deviation" of the blur.

fn current_transform(&self) -> Affine

Returns the transformations currently applied to the context.

Loading content...

Provided methods

fn with_save(
    &mut self,
    f: impl FnOnce(&mut Self) -> Result<(), Error>
) -> Result<(), Error>

Do graphics operations with the context state saved and then restored.

Equivalent to save, calling f, then restore. See those methods for more details.

Loading content...

Implementors

Loading content...