Struct kas_core::geom::Size

pub struct Size(pub i32, pub i32);

A 2D size, also known as an extent

This is both a size and a relative position. One can add or subtract a size from a Coord. One can multiply a size by a scalar.

A Size is expected to be non-negative; some methods such as Size::new and implementations of subtraction will check this, but only in debug mode (similar to overflow checks on integers).

Subtraction is defined to be saturating subtraction.

This may be converted to Offset with from / into.

Tuple Fields

0: i32

1: i32

Implementations

impl Size

pub fn as_physical(self) -> Size

Available on crate feature winit only.

Convert to a “physical” winit::dpi::Size

This implies that the Size was calculated using the correct scale factor. Before the window has been constructed (when the scale factor is supposedly unknown) this should not be used.

pub fn as_logical(self) -> Size

Available on crate feature winit only.

Convert to a “logical” winit::dpi::Size

This implies that the Size was calculated using scale_factor = 1.

impl Size

pub const ZERO: Self = _

The constant (0, 0)

pub const MIN: Self = _

The minimum value

pub const MAX: Self = _

The maximum value

pub fn lt(self, rhs: Self) -> bool

True when for all components, lhs < rhs

pub fn le(self, rhs: Self) -> bool

True when for all components, lhs ≤ rhs

pub fn ge(self, rhs: Self) -> bool

True when for all components, lhs ≥ rhs

pub fn gt(self, rhs: Self) -> bool

True when for all components, lhs > rhs

pub fn min(self, other: Self) -> Self

Return the minimum, componentwise

Examples found in repository

src/layout/size_types.rs (line 276)

    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 max(self, other: Self) -> Self

Return the maximum, componentwise

Examples found in repository

src/geom.rs (line 341)

    fn sub(self, rhs: Self) -> Self {
        // This impl should aid vectorisation.
        Size(self.0 - rhs.0, self.1 - rhs.1).max(Size::ZERO)
    }

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to the specified interval, componentwise

pub fn transpose(self) -> Self

Return the transpose (swap x and y values)

pub fn cwise_mul(self, rhs: Self) -> Self

Return the result of component-wise multiplication

pub fn cwise_div(self, rhs: Self) -> Self

Return the result of component-wise division

pub fn distance_l1(self) -> i32

Return the L1 (rectilinear / taxicab) distance

pub fn distance_l_inf(self) -> i32

Return the L-inf (max) distance

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

Extract one component, based on a direction

This merely extracts the horizontal or vertical component. It never negates it, even if the axis is reversed.

Examples found in repository

src/layout/visitor.rs (line 524)

    pub fn child_axis(&self, mut axis: AxisInfo) -> AxisInfo {
        axis.sub_other(self.size.extract(axis.flipped()));
        axis
    }

    /// Calculate child's "other axis" size, forcing center-alignment of content
    pub fn child_axis_centered(&self, mut axis: AxisInfo) -> AxisInfo {
        axis.sub_other(self.size.extract(axis.flipped()));
        axis.set_align(Some(Align::Center));
        axis
    }

src/layout/size_rules.rs (line 144)

    pub fn extract<D: Directional>(dir: D, size: Size, margins: Margins, stretch: Stretch) -> Self {
        let size = size.extract(dir);
        let m = margins.extract(dir);
        SizeRules::new(size, size, m, stretch)
    }

src/layout/size_types.rs (line 259)

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

pub fn set_component<D: Directional>(&mut self, dir: D, value: i32)

Set one component of self, based on a direction

This does not negate components when the direction is reversed.

Examples found in repository

src/layout/visitor.rs (line 222)

    fn size_rules_(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        match &mut self.layout {
            LayoutType::None => SizeRules::EMPTY,
            LayoutType::Component(component) => component.size_rules(mgr, axis),
            LayoutType::BoxComponent(component) => component.size_rules(mgr, axis),
            LayoutType::Single(child) => child.size_rules(mgr, axis),
            LayoutType::AlignSingle(child, hints) => {
                child.size_rules(mgr, axis.with_align_hints(*hints))
            }
            LayoutType::Align(layout, hints) => {
                layout.size_rules_(mgr, axis.with_align_hints(*hints))
            }
            LayoutType::Pack(layout, stor, hints) => {
                let rules = layout.size_rules_(mgr, stor.apply_align(axis, *hints));
                stor.size.set_component(axis, rules.ideal_size());
                rules
            }
            LayoutType::Margins(child, dirs, margins) => {
                let mut child_rules = child.size_rules_(mgr.re(), axis);
                if dirs.intersects(Directions::from(axis)) {
                    let mut rule_margins = child_rules.margins();
                    let margins = mgr.margins(*margins).extract(axis);
                    if dirs.intersects(Directions::LEFT | Directions::UP) {
                        rule_margins.0 = margins.0;
                    }
                    if dirs.intersects(Directions::RIGHT | Directions::DOWN) {
                        rule_margins.1 = margins.1;
                    }
                    child_rules.set_margins(rule_margins);
                }
                child_rules
            }
            LayoutType::Frame(child, storage, style) => {
                let child_rules = child.size_rules_(mgr.re(), storage.child_axis(axis));
                storage.size_rules(mgr, axis, child_rules, *style)
            }
            LayoutType::Button(child, storage, _) => {
                let child_rules = child.size_rules_(mgr.re(), storage.child_axis_centered(axis));
                storage.size_rules(mgr, axis, child_rules, FrameStyle::Button)
            }
        }
    }

    /// Apply a given `rect` to self
    #[inline]
    pub fn set_rect(mut self, mgr: &mut ConfigMgr, rect: Rect) {
        self.set_rect_(mgr, rect);
    }
    fn set_rect_(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        match &mut self.layout {
            LayoutType::None => (),
            LayoutType::Component(component) => component.set_rect(mgr, rect),
            LayoutType::BoxComponent(layout) => layout.set_rect(mgr, rect),
            LayoutType::Single(child) => child.set_rect(mgr, rect),
            LayoutType::Align(layout, _) => layout.set_rect_(mgr, rect),
            LayoutType::AlignSingle(child, _) => child.set_rect(mgr, rect),
            LayoutType::Pack(layout, stor, _) => layout.set_rect_(mgr, stor.aligned_rect(rect)),
            LayoutType::Margins(child, _, _) => child.set_rect_(mgr, rect),
            LayoutType::Frame(child, storage, _) | LayoutType::Button(child, storage, _) => {
                storage.rect = rect;
                let child_rect = Rect {
                    pos: rect.pos + storage.offset,
                    size: rect.size - storage.size,
                };
                child.set_rect_(mgr, child_rect);
            }
        }
    }

    /// Find a widget by coordinate
    ///
    /// Does not return the widget's own identifier. See example usage in
    /// [`Visitor::find_id`].
    #[inline]
    pub fn find_id(mut self, coord: Coord) -> Option<WidgetId> {
        self.find_id_(coord)
    }
    fn find_id_(&mut self, coord: Coord) -> Option<WidgetId> {
        match &mut self.layout {
            LayoutType::None => None,
            LayoutType::Component(component) => component.find_id(coord),
            LayoutType::BoxComponent(layout) => layout.find_id(coord),
            LayoutType::Single(child) | LayoutType::AlignSingle(child, _) => child.find_id(coord),
            LayoutType::Align(layout, _) => layout.find_id_(coord),
            LayoutType::Pack(layout, _, _) => layout.find_id_(coord),
            LayoutType::Margins(layout, _, _) => layout.find_id_(coord),
            LayoutType::Frame(child, _, _) => child.find_id_(coord),
            // Buttons steal clicks, hence Button never returns ID of content
            LayoutType::Button(_, _, _) => None,
        }
    }

    /// Draw a widget's children
    #[inline]
    pub fn draw(mut self, draw: DrawMgr) {
        self.draw_(draw);
    }
    fn draw_(&mut self, mut draw: DrawMgr) {
        match &mut self.layout {
            LayoutType::None => (),
            LayoutType::Component(component) => component.draw(draw),
            LayoutType::BoxComponent(layout) => layout.draw(draw),
            LayoutType::Single(child) | LayoutType::AlignSingle(child, _) => draw.recurse(*child),
            LayoutType::Align(layout, _) => layout.draw_(draw),
            LayoutType::Pack(layout, _, _) => layout.draw_(draw),
            LayoutType::Margins(layout, _, _) => layout.draw_(draw),
            LayoutType::Frame(child, storage, style) => {
                draw.frame(storage.rect, *style, Background::Default);
                child.draw_(draw);
            }
            LayoutType::Button(child, storage, color) => {
                let bg = match color {
                    Some(rgb) => Background::Rgb(*rgb),
                    None => Background::Default,
                };
                draw.frame(storage.rect, FrameStyle::Button, bg);
                child.draw_(draw);
            }
        }
    }
}

/// Implement row/column layout for children
struct List<'a, S, D, I> {
    data: &'a mut S,
    direction: D,
    children: I,
}

impl<'a, S: RowStorage, D: Directional, I> Layout for List<'a, S, D, I>
where
    I: ExactSizeIterator<Item = Visitor<'a>>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let dim = (self.direction, self.children.len());
        let mut solver = RowSolver::new(axis, dim, self.data);
        for (n, child) in (&mut self.children).enumerate() {
            solver.for_child(self.data, n, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let dim = (self.direction, self.children.len());
        let mut setter = RowSetter::<D, Vec<i32>, _>::new(rect, dim, self.data);

        for (n, child) in (&mut self.children).enumerate() {
            child.set_rect(mgr, setter.child_rect(self.data, n));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        // TODO(opt): more efficient search strategy?
        self.children.find_map(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        for child in &mut self.children {
            child.draw(draw.re_clone());
        }
    }
}

/// Float layout
struct Float<'a, I>
where
    I: DoubleEndedIterator<Item = Visitor<'a>>,
{
    children: I,
}

impl<'a, I> Layout for Float<'a, I>
where
    I: DoubleEndedIterator<Item = Visitor<'a>>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let mut rules = SizeRules::EMPTY;
        for child in &mut self.children {
            rules = rules.max(child.size_rules(mgr.re(), axis));
        }
        rules
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        for child in &mut self.children {
            child.set_rect(mgr, rect);
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        self.children.find_map(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        let mut iter = (&mut self.children).rev();
        if let Some(first) = iter.next() {
            first.draw(draw.re_clone());
        }
        for child in iter {
            draw.with_pass(|draw| child.draw(draw));
        }
    }
}

/// A row/column over a slice
struct Slice<'a, W: Widget, D: Directional> {
    data: &'a mut DynRowStorage,
    direction: D,
    children: &'a mut [W],
}

impl<'a, W: Widget, D: Directional> Layout for Slice<'a, W, D> {
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let dim = (self.direction, self.children.len());
        let mut solver = RowSolver::new(axis, dim, self.data);
        for (n, child) in self.children.iter_mut().enumerate() {
            solver.for_child(self.data, n, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let dim = (self.direction, self.children.len());
        let mut setter = RowSetter::<D, Vec<i32>, _>::new(rect, dim, self.data);

        for (n, child) in self.children.iter_mut().enumerate() {
            child.set_rect(mgr, setter.child_rect(self.data, n));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        let solver = RowPositionSolver::new(self.direction);
        solver
            .find_child_mut(self.children, coord)
            .and_then(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        let solver = RowPositionSolver::new(self.direction);
        solver.for_children(self.children, draw.get_clip_rect(), |w| draw.recurse(w));
    }
}

/// Implement grid layout for children
struct Grid<'a, S, I> {
    data: &'a mut S,
    dim: GridDimensions,
    children: I,
}

impl<'a, S: GridStorage, I> Layout for Grid<'a, S, I>
where
    I: Iterator<Item = (GridChildInfo, Visitor<'a>)>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let mut solver = GridSolver::<Vec<_>, Vec<_>, _>::new(axis, self.dim, self.data);
        for (info, child) in &mut self.children {
            solver.for_child(self.data, info, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let mut setter = GridSetter::<Vec<_>, Vec<_>, _>::new(rect, self.dim, self.data);
        for (info, child) in &mut self.children {
            child.set_rect(mgr, setter.child_rect(self.data, info));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        // TODO(opt): more efficient search strategy?
        self.children.find_map(|(_, child)| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        for (_, child) in &mut self.children {
            child.draw(draw.re_clone());
        }
    }
}

/// Layout storage for alignment
#[derive(Clone, Default, Debug)]
pub struct PackStorage {
    align: AlignPair,
    size: Size,
}
impl PackStorage {
    /// Set alignment
    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
    }

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

/// Layout storage for frame layout
#[derive(Clone, Default, Debug)]
pub struct FrameStorage {
    /// Size used by frame (sum of widths of borders)
    pub size: Size,
    /// Offset of frame contents from parent position
    pub offset: Offset,
    // NOTE: potentially rect is redundant (e.g. with widget's rect) but if we
    // want an alternative as a generic solution then all draw methods must
    // calculate and pass the child's rect, which is probably worse.
    rect: Rect,
}
impl FrameStorage {
    /// Calculate child's "other axis" size
    pub fn child_axis(&self, mut axis: AxisInfo) -> AxisInfo {
        axis.sub_other(self.size.extract(axis.flipped()));
        axis
    }

    /// Calculate child's "other axis" size, forcing center-alignment of content
    pub fn child_axis_centered(&self, mut axis: AxisInfo) -> AxisInfo {
        axis.sub_other(self.size.extract(axis.flipped()));
        axis.set_align(Some(Align::Center));
        axis
    }

    /// Generate [`SizeRules`]
    pub fn size_rules(
        &mut self,
        mgr: SizeMgr,
        axis: AxisInfo,
        child_rules: SizeRules,
        style: FrameStyle,
    ) -> SizeRules {
        let frame_rules = mgr.frame(style, axis);
        let (rules, offset, size) = frame_rules.surround(child_rules);
        self.offset.set_component(axis, offset);
        self.size.set_component(axis, size);
        rules
    }

impl Size

pub fn new(w: i32, h: i32) -> Self

Construct

In debug mode, this asserts that components are non-negative.

Examples found in repository

src/layout/size_types.rs (line 162)

    pub fn pad(self, size: Size) -> Size {
        Size::new(size.0 + self.sum_horiz(), size.1 + self.sum_vert())
    }

src/root.rs (line 173)

    fn resize_popup(&mut self, mgr: &mut ConfigMgr, index: usize) {
        // Notation: p=point/coord, s=size, m=margin
        // r=window/root rect, c=anchor rect
        let r = self.core.rect;
        let popup = &mut self.popups[index].1;

        let c = find_rect(&self.w, popup.parent.clone()).unwrap();
        let widget = self.w.find_widget_mut(&popup.id).unwrap();
        let mut cache = layout::SolveCache::find_constraints(widget, mgr.size_mgr());
        let ideal = cache.ideal(false);
        let m = cache.margins();

        let is_reversed = popup.direction.is_reversed();
        let place_in = |rp, rs: i32, cp: i32, cs: i32, ideal, m: (u16, u16)| -> (i32, i32) {
            let m: (i32, i32) = (m.0.into(), m.1.into());
            let before: i32 = cp - (rp + m.1);
            let before = before.max(0);
            let after = (rs - (cs + before + m.0)).max(0);
            if after >= ideal {
                if is_reversed && before >= ideal {
                    (cp - ideal - m.1, ideal)
                } else {
                    (cp + cs + m.0, ideal)
                }
            } else if before >= ideal {
                (cp - ideal - m.1, ideal)
            } else if before > after {
                (rp, before)
            } else {
                (cp + cs + m.0, after)
            }
        };
        #[allow(clippy::manual_clamp)]
        let place_out = |rp, rs, cp: i32, cs, ideal: i32| -> (i32, i32) {
            let pos = cp.min(rp + rs - ideal).max(rp);
            let size = ideal.max(cs).min(rs);
            (pos, size)
        };
        let rect = if popup.direction.is_horizontal() {
            let (x, w) = place_in(r.pos.0, r.size.0, c.pos.0, c.size.0, ideal.0, m.horiz);
            let (y, h) = place_out(r.pos.1, r.size.1, c.pos.1, c.size.1, ideal.1);
            Rect::new(Coord(x, y), Size::new(w, h))
        } else {
            let (x, w) = place_out(r.pos.0, r.size.0, c.pos.0, c.size.0, ideal.0);
            let (y, h) = place_in(r.pos.1, r.size.1, c.pos.1, c.size.1, ideal.1, m.vert);
            Rect::new(Coord(x, y), Size::new(w, h))
        };

        cache.apply_rect(widget, mgr, rect, false, true);
    }

pub fn splat(n: i32) -> Self

Construct, using the same value on all axes

In debug mode, this asserts that components are non-negative.

Examples found in repository

src/geom.rs (line 588)

    pub fn shrink(&self, n: i32) -> Rect {
        let pos = self.pos + Offset::splat(n);
        let size = self.size - Size::splat(n + n);
        Rect { pos, size }
    }

    /// Expand self in all directions by the given `n`
    ///
    /// In debug mode this asserts that `n` is non-negative.
    #[inline]
    #[must_use = "method does not modify self but returns a new value"]
    pub fn expand(&self, n: i32) -> Rect {
        debug_assert!(n >= 0);
        let pos = self.pos - Offset::splat(n);
        let size = self.size + Size::splat(n + n);
        Rect { pos, size }
    }

pub fn aspect_scale_to(self, target: Size) -> Option<Size>

Scale to fit within the target size, keeping aspect ratio

If either dimension of self is 0, this returns None.

Trait Implementations

impl Add<Size> for Coord

type Output = Coord

The resulting type after applying the + operator.

fn add(self, other: Size) -> Self

Performs the + operation.

impl Add<Size> for Size

type Output = Size

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl AddAssign<Size> for Coord

fn add_assign(&mut self, rhs: Size)

Performs the += operation.

impl AddAssign<Size> for Size

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Size

fn clone(&self) -> Size

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conv<(i32, i32)> for Size

fn conv(v: (i32, i32)) -> Self

Convert from T to Self

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

Try converting from T to Self

impl Conv<(u16, u16)> for Size

fn try_conv(v: (u16, u16)) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<(u32, u32)> for Size

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

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Offset> for Size

Convert an Offset into a Size

In debug mode this asserts that the result is non-negative.

fn try_conv(v: Offset) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl<X: Cast<i32>> Conv<PhysicalSize<X>> for Size

Available on crate feature winit only.

fn try_conv(size: PhysicalSize<X>) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for (u16, u16)

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

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for (u32, u32)

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

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for DVec2

fn try_conv(arg: Size) -> 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 Conv<Size> for Offset

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

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Vec2

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

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Vec2

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

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl ConvApprox<DVec2> for Size

fn try_conv_approx(arg: DVec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Size

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvFloat<DVec2> for Size

fn try_conv_trunc(x: DVec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: DVec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: DVec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: DVec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<Vec2> for Size

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl Debug for Size

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

Formats the value using the given formatter.

impl Default for Size

fn default() -> Size

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Size

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

Deserialize this value from the given Serde deserializer.

impl Div<i32> for Size

Divide a Size by an integer

In debug mode this asserts that the result is non-negative.

type Output = Size

The resulting type after applying the / operator.

fn div(self, x: i32) -> Self

Performs the / operation.

impl From<(i32, i32)> for Size

fn from(v: (i32, i32)) -> Self

Converts to this type from the input type.

impl From<Size> for Margins

fn from(size: Size) -> Self

Converts to this type from the input type.

impl Hash for Size

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 Mul<i32> for Size

Multiply a Size by an integer

In debug mode this asserts that the result is non-negative.

type Output = Size

The resulting type after applying the * operator.

fn mul(self, x: i32) -> Self

Performs the * operation.

impl PartialEq<Size> for Size

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

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

Serialize this value into the given Serde serializer.

impl Sub<Size> for Coord

type Output = Coord

The resulting type after applying the - operator.

fn sub(self, other: Size) -> Self

Performs the - operation.

impl Sub<Size> for Size

Subtract a Size from a Size

This is saturating subtraction: Size::ZERO - Size::splat(6) == Size::ZERO.

type Output = Size

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign<Size> for Coord

fn sub_assign(&mut self, rhs: Size)

Performs the -= operation.

impl SubAssign<Size> for Size

Subtract a Size from a Size

This is saturating subtraction.

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Size

impl Eq for Size

impl StructuralEq for Size

impl StructuralPartialEq for Size