Struct egui::layout::Layout

pub struct Layout {
    pub main_dir: Direction,
    pub main_wrap: bool,
    pub main_align: Align,
    pub main_justify: bool,
    pub cross_align: Align,
    pub cross_justify: bool,
}

The layout of a Ui, e.g. “vertical & centered”.

ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
    ui.label("world!");
    ui.label("Hello");
});

Fields

main_dir: Direction

Main axis direction

main_wrap: bool

If true, wrap around when reading the end of the main direction. For instance, for main_dir == Direction::LeftToRight this will wrap to a new row when we reach the right side of the max_rect.

main_align: Align

How to align things on the main axis.

main_justify: bool

Justify the main axis?

cross_align: Align

How to align things on the cross axis. For vertical layouts: put things to left, center or right? For horizontal layouts: put things to top, center or bottom?

cross_justify: bool

Justify the cross axis? For vertical layouts justify mean all widgets get maximum width. For horizontal layouts justify mean all widgets get maximum height.

Implementations

impl Layout

Constructors

pub fn left_to_right(valign: Align) -> Self

Place elements horizontally, left to right.

The valign parameter controls how to align elements vertically.

pub fn right_to_left(valign: Align) -> Self

Place elements horizontally, right to left.

The valign parameter controls how to align elements vertically.

pub fn top_down(halign: Align) -> Self

Place elements vertically, top to bottom.

Use the provided horizontal alignment.

pub fn top_down_justified(halign: Align) -> Self

Top-down layout justified so that buttons etc fill the full available width.

pub fn bottom_up(halign: Align) -> Self

Place elements vertically, bottom up.

Use the provided horizontal alignment.

pub fn from_main_dir_and_cross_align( main_dir: Direction, cross_align: Align, ) -> Self

pub fn centered_and_justified(main_dir: Direction) -> Self

For when you want to add a single widget to a layout, and that widget should use up all available space.

Only one widget may be added to the inner Ui!

pub fn with_main_wrap(self, main_wrap: bool) -> Self

Wrap widgets when we overflow the main axis?

For instance, for left-to-right layouts, setting this to true will put widgets on a new row if we would overflow the right side of crate::Ui::max_rect.

pub fn with_main_align(self, main_align: Align) -> Self

The alignment to use on the main axis.

pub fn with_cross_align(self, cross_align: Align) -> Self

The alignment to use on the cross axis.

The “cross” axis is the one orthogonal to the main axis. For instance: in left-to-right layout, the main axis is horizontal and the cross axis is vertical.

pub fn with_main_justify(self, main_justify: bool) -> Self

Justify widgets on the main axis?

Justify here means “take up all available space”.

pub fn with_cross_justify(self, cross_justify: bool) -> Self

Justify widgets along the cross axis?

Justify here means “take up all available space”.

The “cross” axis is the one orthogonal to the main axis. For instance: in left-to-right layout, the main axis is horizontal and the cross axis is vertical.

impl Layout

Inspectors

pub fn main_dir(&self) -> Direction

pub fn main_wrap(&self) -> bool

pub fn cross_align(&self) -> Align

pub fn cross_justify(&self) -> bool

pub fn is_horizontal(&self) -> bool

pub fn is_vertical(&self) -> bool

pub fn prefer_right_to_left(&self) -> bool

pub fn horizontal_placement(&self) -> Align

e.g. for adjusting the placement of something.

• in horizontal layout: left or right?
• in vertical layout: same as Self::horizontal_align.

pub fn horizontal_align(&self) -> Align

e.g. for when aligning text within a button.

pub fn vertical_align(&self) -> Align

e.g. for when aligning text within a button.

fn align2(&self) -> Align2

e.g. for when aligning text within a button.

pub fn horizontal_justify(&self) -> bool

pub fn vertical_justify(&self) -> bool

impl Layout

Doing layout

pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect

fn initial_cursor(&self, max_rect: Rect) -> Rect

pub(crate) fn region_from_max_rect(&self, max_rect: Rect) -> Region

pub(crate) fn available_rect_before_wrap(&self, region: &Region) -> Rect

pub(crate) fn available_size(&self, r: &Region) -> Vec2

Amount of space available for a widget. For wrapping layouts, this is the maximum (after wrap).

fn available_from_cursor_max_rect(&self, cursor: Rect, max_rect: Rect) -> Rect

Given the cursor in the region, how much space is available for the next widget?

pub(crate) fn next_frame( &self, region: &Region, child_size: Vec2, spacing: Vec2, ) -> Rect

Returns where to put the next widget that is of the given size. The returned frame_rect Rect will always be justified along the cross axis. This is what you then pass to advance_after_rects. Use justify_and_align to get the inner widget_rect.

fn next_frame_ignore_wrap(&self, region: &Region, child_size: Vec2) -> Rect

pub(crate) fn justify_and_align(&self, frame: Rect, child_size: Vec2) -> Rect

Apply justify (fill width/height) and/or alignment after calling next_space.

pub(crate) fn next_widget_space_ignore_wrap_justify( &self, region: &Region, size: Vec2, ) -> Rect

pub(crate) fn next_widget_position(&self, region: &Region) -> Pos2

Where would the next tiny widget be centered?

pub(crate) fn advance_cursor(&self, region: &mut Region, amount: f32)

Advance the cursor by this many points, and allocate in region.

pub(crate) fn advance_after_rects( &self, cursor: &mut Rect, frame_rect: Rect, widget_rect: Rect, item_spacing: Vec2, )

Advance cursor after a widget was added to a specific rectangle.

• frame_rect: the frame inside which a widget was e.g. centered
• widget_rect: the actual rect used by the widget

pub(crate) fn end_row(&self, region: &mut Region, spacing: Vec2)

Move to the next row in a wrapping layout. Otherwise does nothing.

pub(crate) fn set_row_height(&self, region: &mut Region, height: f32)

Set row height in horizontal wrapping layout.

impl Layout

Debug stuff

pub(crate) fn paint_text_at_cursor( &self, painter: &Painter, region: &Region, stroke: Stroke, text: impl ToString, )

Shows where the next widget is going to be placed

Trait Implementations

impl Clone for Layout

fn clone(&self) -> Layout

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Layout

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

Formats the value using the given formatter.

impl Default for Layout

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Layout

fn eq(&self, other: &Layout) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Layout

impl Eq for Layout

impl StructuralPartialEq for Layout