Struct nannou::ui::prelude::widget::primitive::shape::triangles::TrianglesUnpositioned

pub struct TrianglesUnpositioned<S, I> { /* fields omitted */ }

When beginning to build Triangles they are initially unpositioned.

This is an intemediary type which allows the user to choose how to position the bounding rectangle relative to the points.

Implementations

impl<S, I> TrianglesUnpositioned<S, I> where
    I: IntoIterator<Item = Triangle<<S as Style>::Vertex>>,
    S: Style,
    Triangles<S, I>: Widget, 

pub fn with_bounding_rect(self, rect: Rect) -> Triangles<S, I>

Specify the bounding rectangle for the Triangles.

Typically, the given Rect bounds should be the min and max positions along both axes that are touched by the Triangles’ points.

This method is significantly more efficient than calc_bounding_rect and centre_points_to_bounding_rect as the bounding rectangle does not have to be calculated from the Triangles’ points.

pub fn calc_bounding_rect(self) -> Triangles<S, I> where
    I: Clone, 

Calculate the position and size of the bounding rectangle from the Triangles points. The resulting bounding rectangle will fit to the absolute co-ordinates of all points.

In other words, this method will automatically call Sizeable::wh and Positionable::xy after calculating the size and position from the given points.

This requires that the points iterator is Clone so that we may iterate through and determine the bounding box of the points. If you know the bounds of the rectangle ahead of time, we recommend calling with_bounding_rect instead as it will be significantly cheaper.

If you would rather centre the points to the middle of the bounding box, use TrianglesUnpositioned::centre_points_to_bounding_rect instead.

pub fn centre_points_to_bounding_rect(self) -> Triangles<S, I> where
    I: Clone, 

Shift the location of the Triangles points so that the centre of their bounding rectangle lies at the position determined for the Triangles widget.

This is useful if your points simply describe a shape and you want to position them using conrod’s auto-layout or Positionable and Sizeable methods.

This requires that the points iterator is Clone so that we may iterate through and determine the bounding box of the points. If you know the bounds of the rectangle ahead of time, we recommend calling with_bounding_rect instead as it will be significantly cheaper.

If you would rather calculate the bounding box from the given absolute points, use the TrianglesUnpositioned::calc_bounding_rect instead.

Trait Implementations

impl<S, I> Clone for TrianglesUnpositioned<S, I> where
    I: Clone,
    S: Clone, 

pub fn clone(&self) -> TrianglesUnpositioned<S, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, I> Debug for TrianglesUnpositioned<S, I> where
    I: Debug,
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S, I> Copy for TrianglesUnpositioned<S, I> where
    I: Copy,
    S: Copy,