Struct kas_core::layout::LogicalSize

pub struct LogicalSize(pub f32, pub f32);

Logical (pre-scaling) pixel size

A measure of size in “logical pixels”. May be used to define scalable layouts.

Tuple Fields

0: f32

1: f32

Implementations

impl LogicalSize

pub fn to_physical(self, scale_factor: f32) -> Size

Convert to physical pixels

Values are multiplied by the window’s scale factor and cast to nearest.

Examples found in repository

src/layout/size_types.rs (line 258)

    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)
    }

    /// Constrains and aligns within `rect`
    ///
    /// The resulting size is then aligned using the `align` hints, defaulting to centered.
    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)
    }

pub fn to_rules(self, dir: impl Directional, scale_factor: f32) -> SizeRules

Convert to SizeRules, fixed size

pub fn to_rules_with_factor(
    self,
    dir: impl Directional,
    scale_factor: f32,
    ideal_factor: f32
) -> SizeRules

Convert to SizeRules

Ideal size is component * ideal_factor * scale_factor.

pub fn extract(self, dir: impl Directional) -> f32

Take horizontal/vertical axis component

Examples found in repository

src/layout/size_types.rs (line 65)

    pub fn extract_scaled(self, dir: impl Directional, scale_factor: f32) -> i32 {
        (self.extract(dir) * scale_factor).cast_nearest()
    }

pub fn extract_scaled(self, dir: impl Directional, scale_factor: f32) -> i32

Take component and scale

Examples found in repository

src/layout/size_types.rs (line 38)

    pub fn to_rules(self, dir: impl Directional, scale_factor: f32) -> SizeRules {
        SizeRules::fixed(self.extract_scaled(dir, scale_factor), (0, 0))
    }

    /// Convert to [`SizeRules`]
    ///
    /// Ideal size is `component * ideal_factor * scale_factor`.
    pub fn to_rules_with_factor(
        self,
        dir: impl Directional,
        scale_factor: f32,
        ideal_factor: f32,
    ) -> SizeRules {
        let min = self.extract_scaled(dir, scale_factor);
        let ideal = self.extract_scaled(dir, scale_factor * ideal_factor);
        SizeRules::new(min, ideal, (0, 0), Stretch::None)
    }

Trait Implementations

impl Clone for LogicalSize

fn clone(&self) -> LogicalSize

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conv<(i32, i32)> for LogicalSize

fn try_conv((w, h): (i32, i32)) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<(u32, u32)> for LogicalSize

fn try_conv((w, h): (u32, u32)) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for LogicalSize

fn try_conv(size: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Debug for LogicalSize

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

Formats the value using the given formatter.

impl Default for LogicalSize

fn default() -> LogicalSize

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LogicalSize

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(f32, f32)> for LogicalSize

fn from((w, h): (f32, f32)) -> Self

Converts to this type from the input type.

impl From<LogicalSize> for Vec2

fn from(LogicalSize: LogicalSize) -> Self

Converts to this type from the input type.

impl From<Vec2> for LogicalSize

fn from(Vec2: Vec2) -> Self

Converts to this type from the input type.

impl PartialEq<LogicalSize> for LogicalSize

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for LogicalSize

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

Serialize this value into the given Serde serializer.

impl Copy for LogicalSize

impl StructuralPartialEq for LogicalSize