Struct flo_canvas::CanvasGraphicsContext

pub struct CanvasGraphicsContext<'a> { /* fields omitted */ }

Graphics context for a Canvas

Trait Implementations

impl<'a> Drop for CanvasGraphicsContext<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> GraphicsContext for CanvasGraphicsContext<'a>

fn start_frame(&mut self)

Suspends rendering to the display until the next ‘ShowFrame’

fn show_frame(&mut self)

Displays any requested queued after ‘StartFrame’

fn reset_frame(&mut self)

Resets the frame count back to 0 (for when regenerating the state of a canvas)

fn new_path(&mut self)

Begins a new path

fn move_to(&mut self, x: f32, y: f32)

Move to a new point in the current path (paths should always begin with a move instruction, and moves can define subpaths)

fn line_to(&mut self, x: f32, y: f32)

Adds a line to the current path

fn bezier_curve_to(
    &mut self,
    x1: f32,
    y1: f32,
    cp1x: f32,
    cp1y: f32,
    cp2x: f32,
    cp2y: f32
)

Adds a bezier curve to the current path

fn close_path(&mut self)

Closes the current path (adds a line to the last move point)

fn fill(&mut self)

Fills the currently defined path

fn stroke(&mut self)

Draws a line around the currently defined path

fn line_width(&mut self, width: f32)

Sets the line width for the next stroke() operation

fn line_width_pixels(&mut self, width: f32)

Sets the line width for the next stroke() operation in device pixels

fn line_join(&mut self, join: LineJoin)

Sets the line join style for the next stroke() operation

fn line_cap(&mut self, cap: LineCap)

Sets the style of the start and end cap of the next line drawn by the stroke() operation

fn winding_rule(&mut self, rule: WindingRule)

Sets the winding rule used to determine if an internal subpath should be filled or empty

fn new_dash_pattern(&mut self)

Starts defining a new dash pattern

fn dash_length(&mut self, length: f32)

Adds a dash of the specified length to the dash pattern (alternating between drawing and gap lengths)

fn dash_offset(&mut self, offset: f32)

Sets the offset for where the dash pattern starts at the next stroke

fn fill_color(&mut self, col: Color)

Sets the colour of the next fill() operation

fn fill_texture(&mut self, t: TextureId, x1: f32, y1: f32, x2: f32, y2: f32)

Sets the texture to use for the next fill() operation

fn fill_gradient(&mut self, g: GradientId, x1: f32, y1: f32, x2: f32, y2: f32)

Sets the gradient to use for the next fill() operation

fn fill_transform(&mut self, transform: Transform2D)

Applies a transformation to the fill texture or gradient

fn stroke_color(&mut self, col: Color)

Sets the colour to use for the next stroke() operation

fn blend_mode(&mut self, mode: BlendMode)

Sets the blend mode of the next fill or stroke operation

fn identity_transform(&mut self)

Reset the canvas transformation to the identity transformation (so that the y axis goes from -1 to 1)

fn canvas_height(&mut self, height: f32)

Sets a transformation such that: (0,0) is the center point of the canvas (0,height/2) is the top of the canvas Pixels are square

fn center_region(&mut self, minx: f32, miny: f32, maxx: f32, maxy: f32)

Moves a particular region to the center of the canvas (coordinates are minx, miny, maxx, maxy)

fn transform(&mut self, transform: Transform2D)

Multiply a 2D transform by the current transformation

fn unclip(&mut self)

Removes the current clipping path

fn clip(&mut self)

Sets the current path as the clipping path

fn store(&mut self)

Stores the current contents of the canvas in a background buffer

fn restore(&mut self)

Restores the contents of the canvas from the background buffer

fn free_stored_buffer(&mut self)

Releases the memory allocated by the last store() operation

fn push_state(&mut self)

Stores the current state of the canvas (line width, fill colour, etc)

fn pop_state(&mut self)

Restore a state previously pushed

fn clear_canvas(&mut self, color: Color)

Clears the canvas entirely to a background colour, and removes any stored resources (layers, sprites, fonts, textures)

fn layer(&mut self, layer_id: LayerId)

Selects a particular layer for drawing Layer 0 is selected initially. Layers are drawn in order starting from 0. Layer IDs don’t have to be sequential.

fn layer_blend(&mut self, layer_id: LayerId, blend_mode: BlendMode)

Sets how a particular layer is blended with the underlying layer

fn clear_layer(&mut self)

Clears the current layer

fn clear_all_layers(&mut self)

Clears all of the layers (without resetting any other resources, as clear_canvas does)

fn swap_layers(&mut self, layer1: LayerId, layer2: LayerId)

Exchanges the contents of two layers in the drawing

fn sprite(&mut self, sprite_id: SpriteId)

Selects a particular sprite for drawing

fn clear_sprite(&mut self)

Releases the resources used by the current sprite

fn sprite_transform(&mut self, transform: SpriteTransform)

Adds a sprite transform to the next sprite drawing operation

fn draw_sprite(&mut self, sprite_id: SpriteId)

Renders a sprite with a set of transformations

fn define_font_data(&mut self, font_id: FontId, font_data: Arc<CanvasFontFace>)

Loads font data into the canvas for a particular font ID

fn set_font_size(&mut self, font_id: FontId, size: f32)

Sets the size that text in the specified font will be rendered at

fn draw_text(
    &mut self,
    font_id: FontId,
    text: String,
    baseline_x: f32,
    baseline_y: f32
)

Draws a text string using a font

fn draw_glyphs(&mut self, font_id: FontId, glyphs: Vec<GlyphPosition>)

Draws specific glyphs from a font

fn begin_line_layout(&mut self, x: f32, y: f32, align: TextAlignment)

Starts laying out a line of text

fn layout_text(&mut self, font_id: FontId, text: String)

Adds text to the current line layout

fn draw_text_layout(&mut self)

Finishes laying out text and renders the result

fn create_texture(
    &mut self,
    texture_id: TextureId,
    w: u32,
    h: u32,
    format: TextureFormat
)

Creates a new texture that can be used with fill_texture of the specified width and height

fn set_texture_bytes(
    &mut self,
    texture_id: TextureId,
    x: u32,
    y: u32,
    w: u32,
    h: u32,
    bytes: Arc<Vec<u8>>
)

Sets the bitmap data for a texture, in the format specified by the call to create_texture()

fn free_texture(&mut self, texture_id: TextureId)

Releases the memory allocated to a particular texture

fn set_texture_fill_alpha(&mut self, texture_id: TextureId, alpha: f32)

Applies an alpha value to a texture

fn create_gradient(&mut self, gradient_id: GradientId, initial_color: Color)

Defines a new gradient with a colour at stop position 0.0. Gradients can be used via fill_gradient()

fn gradient_stop(&mut self, gradient_id: GradientId, pos: f32, color: Color)

Adds a new colour stop to a texture

fn draw(&mut self, d: Draw)

Sends a single drawing instruction to this graphics context