Struct LinearLayout

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

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<LD, VG> LinearLayout<LD, VG>

pub fn inner(&self) -> &VG

Returns a reference to the contained views.

pub fn inner_mut(&mut self) -> &mut VG

Returns a mutable reference to the contained views.

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.

pub fn arrange_view_group(&self, view_group: &mut impl ViewGroup)

Arrange a ViewGroup according to the layout properties.

Trait Implementations

impl<LD, VG> Clone for LinearLayout<LD, VG>

where LD: Orientation, VG: ViewGroup + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<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.

impl<LD, VG> ViewGroup for LinearLayout<LD, VG>

where LD: Orientation, VG: ViewGroup,

fn len(&self) -> usize

Returns the number of View objects in this view group.

fn at(&self, idx: usize) -> &dyn View

Returns a shared reference the View object at position idx.

fn at_mut(&mut self, idx: usize) -> &mut dyn View

Returns an exclusive reference to the View object at position idx.

fn bounds_of(&self, idx: usize) -> Rectangle

Returns the bounding box of the given View.

fn translate_child(&mut self, idx: usize, by: Point)

Translates the given View.