Trait flo_canvas::GraphicsContext[−][src]

pub trait GraphicsContext {

Show 59 methods    fn start_frame(&mut self);

    fn show_frame(&mut self);

    fn reset_frame(&mut self);

    fn new_path(&mut self);

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

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

    fn bezier_curve_to(
        &mut self, 
        x: f32, 
        y: f32, 
        cp1_x: f32, 
        cp1_y: f32, 
        cp2_x: f32, 
        cp2_y: f32
    );

    fn close_path(&mut self);

    fn fill(&mut self);

    fn stroke(&mut self);

    fn line_width(&mut self, width: f32);

    fn line_width_pixels(&mut self, width: f32);

    fn line_join(&mut self, join: LineJoin);

    fn line_cap(&mut self, cap: LineCap);

    fn winding_rule(&mut self, winding_rule: WindingRule);

    fn new_dash_pattern(&mut self);

    fn dash_length(&mut self, length: f32);

    fn dash_offset(&mut self, offset: f32);

    fn fill_color(&mut self, col: Color);

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

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

    fn fill_transform(&mut self, transform: Transform2D);

    fn stroke_color(&mut self, col: Color);

    fn blend_mode(&mut self, mode: BlendMode);

    fn identity_transform(&mut self);

    fn canvas_height(&mut self, height: f32);

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

    fn transform(&mut self, transform: Transform2D);

    fn unclip(&mut self);

    fn clip(&mut self);

    fn store(&mut self);

    fn restore(&mut self);

    fn free_stored_buffer(&mut self);

    fn push_state(&mut self);

    fn pop_state(&mut self);

    fn clear_canvas(&mut self, color: Color);

    fn layer(&mut self, layer_id: LayerId);

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

    fn clear_layer(&mut self);

    fn clear_all_layers(&mut self);

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

    fn sprite(&mut self, sprite_id: SpriteId);

    fn clear_sprite(&mut self);

    fn sprite_transform(&mut self, transform: SpriteTransform);

    fn draw_sprite(&mut self, sprite_id: SpriteId);

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

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

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

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

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

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

    fn draw_text_layout(&mut self);

    fn create_texture(
        &mut self, 
        texture_id: TextureId, 
        width: u32, 
        height: u32, 
        format: TextureFormat
    );

    fn free_texture(&mut self, texture_id: TextureId);

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

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

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

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

    fn draw(&mut self, d: Draw) { ... }

}
Expand description

A graphics context provides the basic set of graphics actions that can be performed

Required methods

Suspends rendering to the display until the next ‘ShowFrame’

The renderer may perform tessellation or rendering in the background after ‘StartFrame’ but won’t commit anything to the visible frame buffer until ‘ShowFrame’ is hit. If ‘StartFrame’ is nested, then the frame won’t be displayed until ‘ShowFrame’ has been requested at least that many times.

The frame state persists across a ‘ClearCanvas’

Displays any requested queued after ‘StartFrame’

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

Begins a new path

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

Adds a line to the current path

Adds a bezier curve to the current path

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

Fills the currently defined path

Draws a line around the currently defined path

Sets the line width for the next stroke() operation

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

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

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

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

Starts defining a new dash pattern

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

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

Sets the colour of the next fill() operation

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

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

Applies a transformation to the fill texture or gradient

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

Sets the blend mode of the next fill or stroke operation

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

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

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

Multiply a 2D transform by the current transformation

Removes the current clipping path

Sets the current path as the clipping path

Stores the current contents of the canvas in a background buffer

Restores the contents of the canvas from the background buffer

Releases the memory allocated by the last store() operation

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

Restore a state previously pushed

This will restore the line width (and the other stroke settings), stroke colour, current path, fill colour, winding rule, sprite settings and blend settings.

The currently selected layer is not affected by this operation.

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

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.

Sets how a particular layer is blended with the underlying layer

Clears the current layer

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

Exchanges the contents of two layers in the drawing

Selects a particular sprite for drawing

Future drawing actions are sent to this sprite: use something like Layer(0) to start drawing to a layer again.

Sprites can be repeatedly re-rendered with a single command and their appearance may be cached for efficiency. Actions that affect the whole canvas or layers are not permitted in sprites.

Releases the resources used by the current sprite

Adds a sprite transform to the next sprite drawing operation

Renders a sprite with a set of transformations

Loads font data into the canvas for a particular font ID

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

[src]

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

Draws a text string using a font

Draws specific glyphs from a font

Starts laying out a line of text

[src]

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

Adds text to the current line layout

[src]

fn draw_text_layout(&mut self)

Finishes laying out text and renders the result

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

Releases the memory allocated to a particular texture

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

Applies an alpha value to a texture

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

Adds a new colour stop to a texture

Provided methods

Sends a single drawing instruction to this graphics context

Trait Implementations

The dynamic graphics context object also implements the graphics primitives

Draws a rectangle between particular coordinates Read more

Draws a circle at a particular point Read more

Draws a bezier path Read more

Draws a bezier curve (defined by the BezierCurve trait) Read more

Draws a series of instructions Read more

Implementations on Foreign Types

A Vec can be treated as a target for graphics primitives (just pushing the appropriate draw instructions)

[src]

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

[src]

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

[src]

fn draw_text_layout(&mut self)

Implementors