graphene/auto/

box2_d.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{Point, Rect, Vec2, ffi};
use glib::translate::*;

glib::wrapper! {
    /// A 2D box, described as the axis-aligned area between a minimum and
    /// a maximum vertices lying on the same plane.
    pub struct Box2D(BoxedInline<ffi::graphene_box2d_t>);

    match fn {
        copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::graphene_box2d_get_type(), ptr as *mut _) as *mut ffi::graphene_box2d_t,
        free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::graphene_box2d_get_type(), ptr as *mut _),
        type_ => || ffi::graphene_box2d_get_type(),
    }
}

impl Box2D {
    /// Checks whether the [`Box2D`][crate::Box2D] `self` contains the given
    /// [`Box2D`][crate::Box2D] `b`.
    /// ## `b`
    /// a [`Box2D`][crate::Box2D]
    ///
    /// # Returns
    ///
    /// `true` if the box is contained in the given box
    #[doc(alias = "graphene_box2d_contains_box")]
    pub fn contains_box(&self, b: &Box2D) -> bool {
        unsafe { ffi::graphene_box2d_contains_box(self.to_glib_none().0, b.to_glib_none().0) }
    }

    /// Checks whether `self` contains the given `point`.
    /// ## `point`
    /// the coordinates to check
    ///
    /// # Returns
    ///
    /// `true` if the point is contained in the given box
    #[doc(alias = "graphene_box2d_contains_point")]
    pub fn contains_point(&self, point: &Point) -> bool {
        unsafe { ffi::graphene_box2d_contains_point(self.to_glib_none().0, point.to_glib_none().0) }
    }

    /// Checks whether `self` contains the given `rect`.
    /// ## `rect`
    /// the rectangle to check
    ///
    /// # Returns
    ///
    /// `true` if the rectangle is contained in the given box
    #[doc(alias = "graphene_box2d_contains_rect")]
    pub fn contains_rect(&self, rect: &Rect) -> bool {
        unsafe { ffi::graphene_box2d_contains_rect(self.to_glib_none().0, rect.to_glib_none().0) }
    }

    #[doc(alias = "graphene_box2d_equal")]
    fn equal(&self, b: &Box2D) -> bool {
        unsafe { ffi::graphene_box2d_equal(self.to_glib_none().0, b.to_glib_none().0) }
    }

    /// Expands the dimensions of `self` to include the coordinates at `point`.
    /// ## `point`
    /// the coordinates of the point to include
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the expanded box
    #[doc(alias = "graphene_box2d_expand")]
    #[must_use]
    pub fn expand(&self, point: &Point) -> Box2D {
        unsafe {
            let mut res = Box2D::uninitialized();
            ffi::graphene_box2d_expand(
                self.to_glib_none().0,
                point.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Expands the dimensions of `self` by the given `scalar` value.
    ///
    /// If `scalar` is positive, the [`Box2D`][crate::Box2D] will grow; if `scalar` is
    /// negative, the [`Box2D`][crate::Box2D] will shrink.
    /// ## `scalar`
    /// a scalar value
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the expanded box
    #[doc(alias = "graphene_box2d_expand_scalar")]
    #[must_use]
    pub fn expand_scalar(&self, scalar: f32) -> Box2D {
        unsafe {
            let mut res = Box2D::uninitialized();
            ffi::graphene_box2d_expand_scalar(
                self.to_glib_none().0,
                scalar,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Expands the dimensions of `self` to include the coordinates of the
    /// given vector.
    /// ## `vec`
    /// the coordinates of the point to include, as a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the expanded box
    #[doc(alias = "graphene_box2d_expand_vec2")]
    #[must_use]
    pub fn expand_vec2(&self, vec: &Vec2) -> Box2D {
        unsafe {
            let mut res = Box2D::uninitialized();
            ffi::graphene_box2d_expand_vec2(
                self.to_glib_none().0,
                vec.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Retrieves the coordinates of the center of a [`Box2D`][crate::Box2D].
    ///
    /// # Returns
    ///
    ///
    /// ## `center`
    /// return location for the coordinates of
    ///  the center
    #[doc(alias = "graphene_box2d_get_center")]
    #[doc(alias = "get_center")]
    pub fn center(&self) -> Point {
        unsafe {
            let mut center = Point::uninitialized();
            ffi::graphene_box2d_get_center(self.to_glib_none().0, center.to_glib_none_mut().0);
            center
        }
    }

    /// Retrieves the size of the `self` on the Y axis.
    ///
    /// # Returns
    ///
    /// the height of the box
    #[doc(alias = "graphene_box2d_get_height")]
    #[doc(alias = "get_height")]
    pub fn height(&self) -> f32 {
        unsafe { ffi::graphene_box2d_get_height(self.to_glib_none().0) }
    }

    /// Retrieves the coordinates of the maximum point of the given
    /// [`Box2D`][crate::Box2D].
    ///
    /// # Returns
    ///
    ///
    /// ## `max`
    /// return location for the maximum point
    #[doc(alias = "graphene_box2d_get_max")]
    #[doc(alias = "get_max")]
    pub fn max(&self) -> Point {
        unsafe {
            let mut max = Point::uninitialized();
            ffi::graphene_box2d_get_max(self.to_glib_none().0, max.to_glib_none_mut().0);
            max
        }
    }

    /// Retrieves the coordinates of the minimum point of the given
    /// [`Box2D`][crate::Box2D].
    ///
    /// # Returns
    ///
    ///
    /// ## `min`
    /// return location for the minimum point
    #[doc(alias = "graphene_box2d_get_min")]
    #[doc(alias = "get_min")]
    pub fn min(&self) -> Point {
        unsafe {
            let mut min = Point::uninitialized();
            ffi::graphene_box2d_get_min(self.to_glib_none().0, min.to_glib_none_mut().0);
            min
        }
    }

    /// Retrieves the coordinates of the minimum and maximum points of the
    /// given [`Box2D`][crate::Box2D].
    ///
    /// # Returns
    ///
    ///
    /// ## `min`
    /// return location for the minimum point
    ///
    /// ## `max`
    /// return location for the maximum point
    #[doc(alias = "graphene_box2d_get_minmax")]
    #[doc(alias = "get_minmax")]
    pub fn minmax(&self) -> (Point, Point) {
        unsafe {
            let mut min = Point::uninitialized();
            let mut max = Point::uninitialized();
            ffi::graphene_box2d_get_minmax(
                self.to_glib_none().0,
                min.to_glib_none_mut().0,
                max.to_glib_none_mut().0,
            );
            (min, max)
        }
    }

    /// Retrieves the size of the box on all three axes, and stores
    /// it into the given `size` vector.
    ///
    /// # Returns
    ///
    ///
    /// ## `size`
    /// return location for the size
    #[doc(alias = "graphene_box2d_get_size")]
    #[doc(alias = "get_size")]
    pub fn size(&self) -> Vec2 {
        unsafe {
            let mut size = Vec2::uninitialized();
            ffi::graphene_box2d_get_size(self.to_glib_none().0, size.to_glib_none_mut().0);
            size
        }
    }

    /// Retrieves the size of the `self` on the X axis.
    ///
    /// # Returns
    ///
    /// the width of the box
    #[doc(alias = "graphene_box2d_get_width")]
    #[doc(alias = "get_width")]
    pub fn width(&self) -> f32 {
        unsafe { ffi::graphene_box2d_get_width(self.to_glib_none().0) }
    }

    /// Intersects the two given [`Box2D`][crate::Box2D].
    ///
    /// If the two boxes do not intersect, `res` will contain a degenerate box
    /// initialized with [`empty()`][Self::empty()].
    /// ## `b`
    /// a [`Box2D`][crate::Box2D]
    ///
    /// # Returns
    ///
    /// true if the two boxes intersect
    ///
    /// ## `res`
    /// return location for the result
    #[doc(alias = "graphene_box2d_intersection")]
    pub fn intersection(&self, b: &Box2D) -> Option<Box2D> {
        unsafe {
            let mut res = Box2D::uninitialized();
            let ret = ffi::graphene_box2d_intersection(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            if ret { Some(res) } else { None }
        }
    }

    /// Checks whether two boxes intersect.
    ///
    /// See also: [`intersection()`][Self::intersection()]
    /// ## `b`
    /// a [`Box2D`][crate::Box2D]
    ///
    /// # Returns
    ///
    /// true if the boxes intersect, and false otherwise
    #[doc(alias = "graphene_box2d_intersects")]
    pub fn intersects(&self, b: &Box2D) -> bool {
        unsafe { ffi::graphene_box2d_intersects(self.to_glib_none().0, b.to_glib_none().0) }
    }

    /// Applies a scale and an offset to the vertices of the given box.
    ///
    /// If `scale` is [`None`], the box will be scaled by (1.0, 1.0).
    ///
    /// If `offset` is [`None`], the box will be offset by (0.0, 0.0).
    /// ## `scale`
    /// a vector with two scaling factors to be applied to the box
    /// ## `offset`
    /// the offset to apply to the box
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// the transformed box
    #[doc(alias = "graphene_box2d_scale_offset")]
    #[must_use]
    pub fn scale_offset(&self, scale: Option<&Vec2>, offset: Option<&Point>) -> Box2D {
        unsafe {
            let mut res = Box2D::uninitialized();
            ffi::graphene_box2d_scale_offset(
                self.to_glib_none().0,
                scale.to_glib_none().0,
                offset.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Stores the minimum and maximum vertices of the given [`Box2D`][crate::Box2D]
    /// into a rectangle of equivalent origin and size.
    ///
    /// # Returns
    ///
    ///
    /// ## `rect`
    /// the rectangle to initialize
    #[doc(alias = "graphene_box2d_to_rect")]
    pub fn to_rect(&self) -> Rect {
        unsafe {
            let mut rect = Rect::uninitialized();
            ffi::graphene_box2d_to_rect(self.to_glib_none().0, rect.to_glib_none_mut().0);
            rect
        }
    }

    /// Unions the two given [`Box2D`][crate::Box2D].
    /// ## `b`
    /// the box to union to `self`
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result
    #[doc(alias = "graphene_box2d_union")]
    #[must_use]
    pub fn union(&self, b: &Box2D) -> Box2D {
        unsafe {
            let mut res = Box2D::uninitialized();
            ffi::graphene_box2d_union(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// A degenerate [`Box2D`][crate::Box2D] that can only be expanded.
    ///
    /// The returned value is owned by Graphene and should not be modified or freed.
    ///
    /// # Returns
    ///
    /// a [`Box2D`][crate::Box2D]
    #[doc(alias = "graphene_box2d_empty")]
    pub fn empty() -> Box2D {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_box2d_empty()) }
    }

    /// A degenerate [`Box2D`][crate::Box2D] that cannot be expanded.
    ///
    /// The returned value is owned by Graphene and should not be modified or freed.
    ///
    /// # Returns
    ///
    /// a [`Box2D`][crate::Box2D]
    #[doc(alias = "graphene_box2d_infinite")]
    pub fn infinite() -> Box2D {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_box2d_infinite()) }
    }

    /// A [`Box2D`][crate::Box2D] with the minimum vertex set at (-1, -1) and the
    /// maximum vertex set at (0, 0).
    ///
    /// The returned value is owned by Graphene and should not be modified or freed.
    ///
    /// # Returns
    ///
    /// a [`Box2D`][crate::Box2D]
    #[doc(alias = "graphene_box2d_minus_one")]
    pub fn minus_one() -> Box2D {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_box2d_minus_one()) }
    }

    /// A [`Box2D`][crate::Box2D] with the minimum vertex set at (0, 0) and the
    /// maximum vertex set at (1, 1).
    ///
    /// The returned value is owned by Graphene and should not be modified or freed.
    ///
    /// # Returns
    ///
    /// a [`Box2D`][crate::Box2D]
    #[doc(alias = "graphene_box2d_one")]
    pub fn one() -> Box2D {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_box2d_one()) }
    }

    /// A [`Box2D`][crate::Box2D] with the minimum vertex set at (-1, -1) and the
    /// maximum vertex set at (1, 1).
    ///
    /// The returned value is owned by Graphene and should not be modified or freed.
    ///
    /// # Returns
    ///
    /// a [`Box2D`][crate::Box2D]
    #[doc(alias = "graphene_box2d_one_minus_one")]
    pub fn one_minus_one() -> Box2D {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_box2d_one_minus_one()) }
    }

    /// A [`Box2D`][crate::Box2D] with both the minimum and maximum vertices set at (0, 0).
    ///
    /// The returned value is owned by Graphene and should not be modified or freed.
    ///
    /// # Returns
    ///
    /// a [`Box2D`][crate::Box2D]
    #[doc(alias = "graphene_box2d_zero")]
    pub fn zero() -> Box2D {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_box2d_zero()) }
    }
}

impl PartialEq for Box2D {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.equal(other)
    }
}

impl Eq for Box2D {}