Struct immi::DrawContext

pub struct DrawContext<'b, D: ?Sized + Draw + 'b> { /* fields omitted */ }

Contains everything required to draw a widget.

Methods

impl<'b, D: ?Sized + Draw + 'b> DrawContext<'b, D>

fn matrix(&self) -> Matrix

Returns a matrix that turns a fullscreen rectangle into a rectangle that covers only the context's area.

fn cursor_was_pressed(&self) -> bool

Returns true if the cursor went from up to down in the current frame.

This is the value that was passed when constructing the context.

fn cursor_was_released(&self) -> bool

Returns true if the cursor went from down to up in the current frame.

This is the value that was passed when constructing the context.

fn cursor_hovered_widget(&self) -> bool

Returns true if one of the elements that has been drawn is under the mouse cursor.

When you create the context, this value is initally false. Each widget that you draw can call set_cursor_hovered_widget to pass this value to true.

fn set_cursor_hovered_widget(&self)

Signals the context that the cursor is currently hovering it. This can be later retreived with cursor_hovered_widget().

fn reserve_widget_id(&self) -> WidgetId

Reserves a new ID for a widget. Calling this function multiple times always returns a different id.

fn is_cursor_hovering(&self) -> bool

Returns true if the cursor is currently hovering this part of the viewport.

This is equivalent to cursor_hover_coordinates().is_some(), except more optimized.

fn cursor_hover_coordinates(&self) -> Option<[f32; 2]>

If the cursor is hovering the context, returns the coordinates of the cursor within the context.

The result is in OpenGL-like coordinates. In other words, (-1,-1) is the bottom-left hand corner and (1,1) is the top-right hand corner.

fn width_per_height(&self) -> f32

Returns the ratio of the width of the surface divided by its height.

fn margin(
    &self,
    top: f32,
    right: f32,
    bottom: f32,
    left: f32
) -> DrawContext<'b, D>

Builds a new draw context containing a subarea of the current context, but with a margin.

The margin is expressed in percentage of the surface (between 0.0 and 1.0).

fn uniform_margin(
    &self,
    top: f32,
    right: f32,
    bottom: f32,
    left: f32
) -> DrawContext<'b, D>

Builds a new draw context containing a subarea of the current context, but with a margin.

If the width of the surface is inferior to the height then the margin is expressed as a percentage of the width, and vice versa.

This guarantees that the size in pixels of the margin is the same if you pass the same values.

fn enforce_aspect_ratio_downscale(
    &self,
    width_per_height: f32,
    alignment: &Alignment
) -> DrawContext<'b, D>

Modifies the layout so that the given width per height ratio is respected. The size of the new viewport will always been equal or small to the existing viewport.

If the viewport needs to be reduced horizontally, then the horizontal alignment is used. If it needs to be reduced vertically, then the vertical alignment is used.

fn enforce_aspect_ratio_upscale(
    &self,
    width_per_height: f32,
    alignment: &Alignment
) -> DrawContext<'b, D>

Modifies the layout so that the given width per height ratio is respected. The size of the new viewport will always been equal or greater to the existing viewport.

If the viewport needs to be increased horizontally, then the horizontal alignment is used. If it needs to be increased vertically, then the vertical alignment is used.

fn vertical_rescale(
    &self,
    scale: f32,
    alignment: &VerticalAlignment
) -> DrawContext<'b, D>

Builds a new draw context containing a subarea of the current context. The width of the new viewport will be the same as the current one, but its new height will be multipled by the value of scale.

The alignment is used to determine the position of the new viewport inside the old one.

fn horizontal_rescale(
    &self,
    scale: f32,
    alignment: &HorizontalAlignment
) -> DrawContext<'b, D>

Builds a new draw context containing a subarea of the current context. The height of the new viewport will be the same as the current one, but its new width will be multipled by the value of scale.

The alignment is used to determine the position of the new viewport inside the old one.

fn vertical_split<'a>(&'a self, splits: usize) -> SplitsIter<'a, 'b, OneGen, D>

Splits the viewport in splits vertical chunks of equal size.

fn vertical_split_weights<'a, I>(
    &'a self,
    weights: I
) -> SplitsIter<'a, 'b, I::IntoIter, D> where
    I: IntoIterator<Item = f32>,
    I::IntoIter: ExactSizeIterator + Clone, 

Same as vertical_split, but attributes a weight to each chunk. For example a chunk of weight 2 will have twice the size of a chunk of weight 1.

fn horizontal_split<'a>(
    &'a self,
    splits: usize
) -> SplitsIter<'a, 'b, OneGen, D>

Splits the viewport in splits horizontal chunks of equal size.

fn horizontal_split_weights<'a, I>(
    &'a self,
    weights: I
) -> SplitsIter<'a, 'b, I::IntoIter, D> where
    I: IntoIterator<Item = f32>,
    I::IntoIter: ExactSizeIterator + Clone, 

Same as horizontal_split, but attributes a weight to each chunk. For example a chunk of weight 2 will have twice the size of a chunk of weight 1.

fn rescale(
    &self,
    width_percent: f32,
    height_percent: f32,
    alignment: &Alignment
) -> DrawContext<'b, D>

Changes the dimensions of the context.

The dimensions are a percentage of the current dimensions. For example to divide the width by two, you need to pass 0.5.

The alignment is used to determine the position of the newly-created context relative to the old one.

fn animation_start<I>(
    &self,
    interpolation: I,
    start_time: SystemTime,
    duration: Duration
) -> DrawContext<'b, D> where
    I: Interpolation, 

Starts an animation. The interpolation, start time and duration are used to calculate at which point of the animation we are.

At the moment where you call this function, the element must be at its starting point. After you call this function, you must add further transformations to represent the destination. Don't forget to call animation_stop if you want to add further transformations.

You can easily reverse this order (ie. the element is at its destination when you call the function and will be moved to its source) by reversing the interpolation with .reverse().

fn animation_stop(&self) -> DrawContext<'b, D>

Stops the animation process. The next commands will always be applied.

Trait Implementations

impl<'a, 'b, D: ?Sized + Draw + 'b> Clone for DrawContext<'b, D>

fn clone(&self) -> DrawContext<'b, D>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.