graphene/auto/

box_.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::{Point3D, Sphere, Vec3, ffi};
use glib::translate::*;

glib::wrapper! {
    /// A 3D box, described as the volume between a minimum and
    /// a maximum vertices.
    pub struct Box(BoxedInline<ffi::graphene_box_t>);

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

impl Box {
    /// Checks whether the [`Box`][crate::Box] `self` contains the given
    /// [`Box`][crate::Box] `b`.
    /// ## `b`
    /// a [`Box`][crate::Box]
    ///
    /// # Returns
    ///
    /// `true` if the box is contained in the given box
    #[doc(alias = "graphene_box_contains_box")]
    pub fn contains_box(&self, b: &Box) -> bool {
        unsafe { ffi::graphene_box_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_box_contains_point")]
    pub fn contains_point(&self, point: &Point3D) -> bool {
        unsafe { ffi::graphene_box_contains_point(self.to_glib_none().0, point.to_glib_none().0) }
    }

    #[doc(alias = "graphene_box_equal")]
    fn equal(&self, b: &Box) -> bool {
        unsafe { ffi::graphene_box_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_box_expand")]
    #[must_use]
    pub fn expand(&self, point: &Point3D) -> Box {
        unsafe {
            let mut res = Box::uninitialized();
            ffi::graphene_box_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 [`Box`][crate::Box] will grow; if `scalar` is
    /// negative, the [`Box`][crate::Box] will shrink.
    /// ## `scalar`
    /// a scalar value
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the expanded box
    #[doc(alias = "graphene_box_expand_scalar")]
    #[must_use]
    pub fn expand_scalar(&self, scalar: f32) -> Box {
        unsafe {
            let mut res = Box::uninitialized();
            ffi::graphene_box_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 [`Vec3`][crate::Vec3]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the expanded box
    #[doc(alias = "graphene_box_expand_vec3")]
    #[must_use]
    pub fn expand_vec3(&self, vec: &Vec3) -> Box {
        unsafe {
            let mut res = Box::uninitialized();
            ffi::graphene_box_expand_vec3(
                self.to_glib_none().0,
                vec.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Computes the bounding [`Sphere`][crate::Sphere] capable of containing the given
    /// [`Box`][crate::Box].
    ///
    /// # Returns
    ///
    ///
    /// ## `sphere`
    /// return location for the bounding sphere
    #[doc(alias = "graphene_box_get_bounding_sphere")]
    #[doc(alias = "get_bounding_sphere")]
    pub fn bounding_sphere(&self) -> Sphere {
        unsafe {
            let mut sphere = Sphere::uninitialized();
            ffi::graphene_box_get_bounding_sphere(
                self.to_glib_none().0,
                sphere.to_glib_none_mut().0,
            );
            sphere
        }
    }

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

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

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

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

    /// Retrieves the coordinates of the minimum point of the given
    /// [`Box`][crate::Box].
    ///
    /// # Returns
    ///
    ///
    /// ## `min`
    /// return location for the minimum point
    #[doc(alias = "graphene_box_get_min")]
    #[doc(alias = "get_min")]
    pub fn min(&self) -> Point3D {
        unsafe {
            let mut min = Point3D::uninitialized();
            ffi::graphene_box_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 [`Box`][crate::Box]
    ///
    /// # Returns
    ///
    ///
    /// ## `min`
    /// return location for the minimum point
    ///
    /// ## `max`
    /// return location for the maximum point
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "graphene_box_get_minmax")]
    #[doc(alias = "get_minmax")]
    pub fn minmax(&self) -> (Point3D, Point3D) {
        unsafe {
            let mut min = Point3D::uninitialized();
            let mut max = Point3D::uninitialized();
            ffi::graphene_box_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_box_get_size")]
    #[doc(alias = "get_size")]
    pub fn size(&self) -> Vec3 {
        unsafe {
            let mut size = Vec3::uninitialized();
            ffi::graphene_box_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_box_get_width")]
    #[doc(alias = "get_width")]
    pub fn width(&self) -> f32 {
        unsafe { ffi::graphene_box_get_width(self.to_glib_none().0) }
    }

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

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

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

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

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

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

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

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

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

impl Eq for Box {}