Struct RectAlign 

pub struct RectAlign {
    pub parent: Align2,
    pub child: Align2,
}

Position a child Rect relative to a parent Rect.

The corner from RectAlign::child on the new rect will be aligned to the corner from RectAlign::parent on the original rect.

There are helper constants for the 12 common menu positions:

             ┌───────────┐  ┌────────┐  ┌─────────┐
             │ TOP_START │  │  TOP   │  │ TOP_END │
             └───────────┘  └────────┘  └─────────┘
┌──────────┐ ┌────────────────────────────────────┐ ┌───────────┐
│LEFT_START│ │                                    │ │RIGHT_START│
└──────────┘ │                                    │ └───────────┘
┌──────────┐ │                                    │ ┌───────────┐
│   LEFT   │ │             some_rect              │ │   RIGHT   │
└──────────┘ │                                    │ └───────────┘
┌──────────┐ │                                    │ ┌───────────┐
│ LEFT_END │ │                                    │ │ RIGHT_END │
└──────────┘ └────────────────────────────────────┘ └───────────┘
             ┌────────────┐  ┌──────┐  ┌──────────┐
             │BOTTOM_START│  │BOTTOM│  │BOTTOM_END│
             └────────────┘  └──────┘  └──────────┘

Fields

parent: Align2

The alignment in the parent (original) rect.

child: Align2

The alignment in the child (new) rect.

Implementations

impl RectAlign

pub const TOP_START: Self

Along the top edge, leftmost.

pub const TOP: Self

Along the top edge, centered.

pub const TOP_END: Self

Along the top edge, rightmost.

pub const RIGHT_START: Self

Along the right edge, topmost.

pub const RIGHT: Self

Along the right edge, centered.

pub const RIGHT_END: Self

Along the right edge, bottommost.

pub const BOTTOM_END: Self

Along the bottom edge, rightmost.

pub const BOTTOM: Self

Along the bottom edge, centered.

pub const BOTTOM_START: Self

Along the bottom edge, leftmost.

pub const LEFT_END: Self

Along the left edge, bottommost.

pub const LEFT: Self

Along the left edge, centered.

pub const LEFT_START: Self

Along the left edge, topmost.

pub const MENU_ALIGNS: [Self; 12]

The 12 most common menu positions as an array, for use with RectAlign::find_best_align.

pub fn parent(&self) -> Align2

Align in the parent rect.

pub fn child(&self) -> Align2

Align in the child rect.

pub fn from_align2(align: Align2) -> Self

Convert an Align2 to an RectAlign, positioning the child rect inside the parent.

pub fn over_corner(align: Align2) -> Self

The center of the child rect will be aligned to a corner of the parent rect.

pub fn outside(align: Align2) -> Self

Position the child rect outside the parent rect.

pub fn align_rect(&self, parent_rect: &Rect, size: Vec2, gap: f32) -> Rect

Calculate the child rect based on a size and some optional gap.

pub fn pivot_pos(&self, parent_rect: &Rect, gap: f32) -> (Align2, Pos2)

Returns a Align2 and a Pos2 that you can e.g. use with Area::fixed_pos and Area::pivot to align an Area to some rect.

pub fn gap_vector(&self) -> Vec2

Returns a sign vector (-1, 0 or 1 in each direction) that can be used as an offset to the child rect, creating a gap between the rects while keeping the edges aligned.

pub fn anchor(&self, parent_rect: &Rect, gap: f32) -> Pos2

Calculator the anchor point for the child rect, based on the parent rect and an optional gap.

pub fn flip_x(self) -> Self

Flip the alignment on the x-axis.

pub fn flip_y(self) -> Self

Flip the alignment on the y-axis.

pub fn flip(self) -> Self

Flip the alignment on both axes.

pub fn symmetries(self) -> [Self; 3]

Returns the 3 alternative RectAligns that are flipped in various ways, for use with RectAlign::find_best_align.

pub fn find_best_align( values_to_try: impl Iterator<Item = Self>, content_rect: Rect, parent_rect: Rect, gap: f32, expected_size: Vec2, ) -> Option<Self>

Look for the first alternative RectAlign that allows the child rect to fit inside the content_rect.

If no alternative fits, the first is returned. If no alternatives are given, None is returned.

See also:

• RectAlign::symmetries to calculate alternatives
• RectAlign::MENU_ALIGNS for the 12 common menu positions

Trait Implementations

impl Clone for RectAlign

fn clone(&self) -> RectAlign

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RectAlign

impl Debug for RectAlign

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

Formats the value using the given formatter.

impl Default for RectAlign

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RectAlign

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RectAlign

impl Hash for RectAlign

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RectAlign

fn eq(&self, other: &RectAlign) -> 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 Serialize for RectAlign

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RectAlign