Struct pane::Pane

pub struct Pane<R = [f64; 4]> where
    R: Rectangle,  { /* fields omitted */ }

A rectangle which automatically determines the positions and sizes of things withing it

A Pane can have any number of child Panes, each of which has a size constrained by their parent Pane. The size and position of each child pane depends on its weight relative to its siblings as well as the split Orientation of its parent. This allows panes to be resized while keeping all their child panes consistently sized.

A pane can also have optional contents. Contents will be resized to fit the Pane

Methods

impl<R> Pane<R> where
    R: Rectangle, 

pub fn new() -> Self

Create a new Pane

pub fn children(&self) -> impl DoubleEndedIterator<Item = &Pane<R>>

Immutable iterate over the Pane's children

pub fn children_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Pane<R>>

Mutable iterate over the Pane's children

pub fn contents(&self) -> Option<&Contents<R::Scalar>>

Get the Pane's contents

pub fn with_contents(self, contents: Contents<R::Scalar>) -> Self

Change the Pane's contents

pub fn with_no_contents(self) -> Self

Remove the Pane's contents

pub fn rect(&self) -> R

Get the Pane's rectangle

pub fn with_rect(self, rect: R) -> Self

Set the Pane's rectangle

pub fn size(&self) -> R::Vector

Get the Pane's size

pub fn with_size<T, V>(self, size: V) -> Self where
    T: Scalar,
    R::Scalar: From<T>,
    V: Vector2<Scalar = T>, 

Set the Pane's size

pub fn top_left(&self) -> R::Vector

Get the position of the Pane's top-left corner

pub fn with_top_left<T, V>(self, top_left: V) -> Self where
    T: Scalar,
    R::Scalar: From<T>,
    V: Vector2<Scalar = T>, 

Set the position of the Pane's top-left corner

pub fn with_panes<'a, P, I>(self, panes: I) -> Self where
    P: NamedWeightedPane<'a, R>,
    I: IntoIterator<Item = P>, 

Set the Pane's inner Panes. Each inner Pane has a weight which defines how it is resized relative to its siblings. Panes can also have optional names that can be used to index their parent.

pub fn orientation(&self) -> Orientation

Get the split orientation of the Pane's children

pub fn with_orientation(self, orientation: Orientation) -> Self

Set the split orientation of the Pane's children

pub fn color(&self) -> Color

Get the Pane's color

pub fn with_color(self, color: Color) -> Self

Set the Pane's color

pub fn margin(&self) -> R::Scalar

Get the Pane's margin

pub fn with_margin(self, margin: R::Scalar) -> Self

Set the Pane's margin

pub fn margin_rect(&self) -> R

Get the inner rectangle created by the Pane and its margin

pub fn fit_text<C>(self, glyphs: &mut C) -> Self where
    C: CharacterWidthCache<Scalar = R::Scalar>, 

Recursively fit the text of any Contents::Text in the Pane's tree

impl<R> Pane<R> where
    R: Rectangle<Scalar = f64>, 

pub fn draw<T, C, G>(
    &self,
    glyphs: &mut C,
    transform: Matrix2d,
    graphics: &mut G
) -> Result<(), C::Error> where
    T: ImageSize,
    C: CharacterCache<Texture = T>,
    G: Graphics<Texture = T>, 

Draw the Pane and all its contents to something using the piston2d-graphics crate

Trait Implementations

impl<'a, R> NamedWeightedPane<'a, R> for Pane<R> where
    R: Rectangle, 

fn named_weighted_pane(self) -> (Option<&'a str>, R::Scalar, Pane<R>)

Converts into a child Pane with a weight and optional name

impl<R: Clone> Clone for Pane<R> where
    R: Rectangle,
    R::Scalar: Clone,
    R::Scalar: Clone,
    R::Scalar: Clone, 

fn clone(&self) -> Pane<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R> Default for Pane<R> where
    R: Rectangle, 

fn default() -> Self

Returns the "default value" for a type.

impl<R: Debug> Debug for Pane<R> where
    R: Rectangle,
    R::Scalar: Debug,
    R::Scalar: Debug,
    R::Scalar: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<R> Index<usize> for Pane<R> where
    R: Rectangle, 

type Output = Pane<R>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, R> Index<&'a str> for Pane<R> where
    R: Rectangle, 

type Output = Pane<R>

The returned type after indexing.

fn index(&self, index: &'a str) -> &Self::Output

Performs the indexing (container[index]) operation.