Struct kas_core::layout::AlignPair

source ·

pub struct AlignPair {
    pub horiz: Align,
    pub vert: Align,
}

Expand description

Provides alignment information on both axes along with ideal size

Note that the ideal size detail is only used for non-stretch alignment.

Fields§

§horiz: Align§vert: Align

Implementations§

source §

impl AlignPair

source

pub const DEFAULT: AlignPair = _

Default on both axes

source

pub const CENTER: AlignPair = _

Center on both axes

source

pub const STRETCH: AlignPair = _

Stretch on both axes

source

pub const fn new(horiz: Align, vert: Align) -> Self

Construct with horiz. and vert. alignment

Examples found in repository ?

src/layout/align.rs (line 87)

    pub fn complete(&self, horiz: Align, vert: Align) -> AlignPair {
        AlignPair::new(self.horiz.unwrap_or(horiz), self.vert.unwrap_or(vert))
    }
}

/// Provides alignment information on both axes along with ideal size
///
/// Note that the `ideal` size detail is only used for non-stretch alignment.
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct AlignPair {
    pub horiz: Align,
    pub vert: Align,
}

impl AlignPair {
    /// Default on both axes
    pub const DEFAULT: AlignPair = AlignPair::new(Align::Default, Align::Default);

    /// Center on both axes
    pub const CENTER: AlignPair = AlignPair::new(Align::Center, Align::Center);

    /// Stretch on both axes
    pub const STRETCH: AlignPair = AlignPair::new(Align::Stretch, Align::Stretch);

    /// Construct with horiz. and vert. alignment
    pub const fn new(horiz: Align, vert: Align) -> Self {
        Self { horiz, vert }
    }

    /// Extract one component, based on a direction
    #[inline]
    pub fn extract<D: Directional>(self, dir: D) -> Align {
        match dir.is_vertical() {
            false => self.horiz,
            true => self.vert,
        }
    }

    /// Set one component of self, based on a direction
    #[inline]
    pub fn set_component<D: Directional>(&mut self, dir: D, align: Align) {
        match dir.is_vertical() {
            false => self.horiz = align,
            true => self.vert = align,
        }
    }

    /// Construct a rect of size `ideal` within `rect` using the given alignment
    pub fn aligned_rect(&self, ideal: Size, rect: Rect) -> Rect {
        let mut pos = rect.pos;
        let mut size = rect.size;
        if ideal.0 < size.0 && self.horiz != Align::Stretch {
            pos.0 += match self.horiz {
                Align::Center => (size.0 - ideal.0) / 2,
                Align::BR => size.0 - ideal.0,
                Align::Default | Align::TL | Align::Stretch => 0,
            };
            size.0 = ideal.0;
        }
        if ideal.1 < size.1 && self.vert != Align::Stretch {
            pos.1 += match self.vert {
                Align::Center => (size.1 - ideal.1) / 2,
                Align::BR => size.1 - ideal.1,
                Align::Default | Align::TL | Align::Stretch => 0,
            };
            size.1 = ideal.1;
        }
        Rect { pos, size }
    }
}

impl From<(Align, Align)> for AlignPair {
    #[inline]
    fn from(p: (Align, Align)) -> Self {
        AlignPair::new(p.0, p.1)
    }

source

pub fn extract<D: Directional>(self, dir: D) -> Align

Extract one component, based on a direction

source

pub fn set_component<D: Directional>(&mut self, dir: D, align: Align)

Set one component of self, based on a direction

Examples found in repository ?

src/layout/visitor.rs (line 499)

    fn apply_align(&mut self, axis: AxisInfo, hints: AlignHints) -> AxisInfo {
        let axis = axis.with_align_hints(hints);
        self.align.set_component(axis, axis.align_or_default());
        axis
    }

More examples

Hide additional examples

src/layout/size_types.rs (line 264)

    pub fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let margins = mgr.margins(self.margins).extract(axis);
        let scale_factor = mgr.scale_factor();
        let min = self
            .size
            .to_physical(scale_factor * self.min_factor)
            .extract(axis);
        let ideal = self
            .size
            .to_physical(scale_factor * self.ideal_factor)
            .extract(axis);
        self.align.set_component(axis, axis.align_or_center());
        SizeRules::new(min, ideal, margins, self.stretch)
    }

source

pub fn aligned_rect(&self, ideal: Size, rect: Rect) -> Rect

Construct a rect of size ideal within rect using the given alignment

Examples found in repository ?

src/layout/visitor.rs (line 505)

504
505
506

    fn aligned_rect(&self, rect: Rect) -> Rect {
        self.align.aligned_rect(self.size, rect)
    }

More examples

Hide additional examples

src/layout/size_types.rs (line 291)

    pub fn align_rect(&mut self, rect: Rect, scale_factor: f32) -> Rect {
        let mut size = rect.size;

        if self.stretch == Stretch::None {
            let ideal = self.size.to_physical(scale_factor * self.ideal_factor);
            size = size.min(ideal);
        }

        if self.fix_aspect {
            let logical_size = Vec2::from(self.size);
            let Vec2(rw, rh) = Vec2::conv(size) / logical_size;

            // Use smaller ratio, if any is finite
            if rw < rh {
                size.1 = i32::conv_nearest(rw * logical_size.1);
            } else if rh < rw {
                size.0 = i32::conv_nearest(rh * logical_size.0);
            }
        }

        self.align.aligned_rect(size, rect)
    }