Struct embedded_layout::layout::linear::LinearLayout

pub struct LinearLayout<LD, VG> { /* fields omitted */ }

LinearLayout

LinearLayout is used to arrange views along the horizontal or vertical axis.

For more information and examples see the module level documentation.

Implementations

impl<VG> LinearLayout<Horizontal<Bottom, Tight>, VG> where
    VG: ViewGroup, 

pub fn horizontal(views: VG) -> Self

Create a new LinearLayout that places views left to right

impl<VG> LinearLayout<Vertical<Left, Tight>, VG> where
    VG: ViewGroup, 

pub fn vertical(views: VG) -> Self

Create a new LinearLayout that places views top to bottom

impl<S, ELS, VG> LinearLayout<Horizontal<S, ELS>, VG> where
    S: SecondaryAlignment + VerticalAlignment,
    ELS: ElementSpacing,
    VG: ViewGroup, 

pub fn with_alignment<Sec>(
    self,
    alignment: Sec
) -> LinearLayout<Horizontal<Sec, ELS>, VG> where
    Sec: SecondaryAlignment + VerticalAlignment, 

Change the secondary alignment for this LinearLayout object.

For layouts created using LinearLayout::horizontal the secondary alignment is vertical.

pub fn with_spacing<ES>(
    self,
    spacing: ES
) -> LinearLayout<Horizontal<S, ES>, VG> where
    ES: ElementSpacing, 

Change the element spacing

For available values and their properties, see spacing

impl<S, ELS, VG> LinearLayout<Vertical<S, ELS>, VG> where
    S: SecondaryAlignment + HorizontalAlignment,
    ELS: ElementSpacing,
    VG: ViewGroup, 

pub fn with_alignment<Sec>(
    self,
    alignment: Sec
) -> LinearLayout<Vertical<Sec, ELS>, VG> where
    Sec: SecondaryAlignment + HorizontalAlignment, 

Change the secondary alignment for this LinearLayout object.

For layouts created using LinearLayout::vertical the secondary alignment is horizontal.

pub fn with_spacing<ES>(self, spacing: ES) -> LinearLayout<Vertical<S, ES>, VG> where
    ES: ElementSpacing, 

Change the element spacing

For available values and their properties, see spacing

impl<LD, VG> LinearLayout<LD, VG> where
    LD: Orientation,
    VG: ViewGroup, 

pub fn into_inner(self) -> VG

Consume the layout object and return the wrapped ViewGroup.

After calling arrange() it is no longer necessary to hold the views in a LinearLayout. Use this method to extract the original view group object if you need to work with the arranged views.

Example

Arrange an array of StyledText objects, then check the second object’s position.

let text_style = MonoTextStyle::new(&FONT_6X9, BinaryColor::On);

// First, wrap out views in a `ViewGroup`.
let mut texts = [
    Text::new("Hello,", Point::zero(), text_style),
    Text::new("World!", Point::zero(), text_style)
];
let mut views = Views::new(&mut texts);

// Arrange our views and extract our original view group.
let views = LinearLayout::vertical(views).arrange().into_inner();

// We can access our `StyledText` objects now. Note that `Views` works like a slice!
assert_eq!(Point::new(0, 9), views[1].bounds().top_left);

// `Views` is also a drawable `ViewGroup`, so let's display our arranged text!
views.draw(&mut display).unwrap();

pub fn arrange(self) -> Self

Arrange the views according to the layout properties and return the views as a ViewGroup. Note: The top left point is always Point::zero().

Trait Implementations

impl<'a, C, LD, VG> Drawable for LinearLayout<LD, VG> where
    C: PixelColor,
    LD: Orientation,
    VG: ViewGroup + Drawable<Color = C>, 

type Color = C

The pixel color type.

type Output = ()

The return type of the draw method.

fn draw<D>(&self, display: &mut D) -> Result<(), D::Error> where
    D: DrawTarget<Color = C>, 

Draw the graphics object using the supplied DrawTarget.

impl<LD, VG> View for LinearLayout<LD, VG> where
    LD: Orientation,
    VG: ViewGroup, 

fn translate_impl(&mut self, by: Point)

Object-safe version of translate_mut().

fn bounds(&self) -> Rectangle

Returns the bounding box of the View as a Rectangle

fn size(&self) -> Size

Get the size of a View.

fn translate_mut(&mut self, by: Point) -> &mut Self where
    Self: Sized, 

Move the origin of an object by a given number of (x, y) pixels, mutating the object in place.

fn translate(self, by: Point) -> Self where
    Self: Sized, 

Move the origin of an object by a given number of (x, y) pixels, returning a new object.