// 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;
use glib::translate::*;

glib::wrapper! {
    /// The location and size of a rectangle region.
    ///
    /// The width and height of a [`Rect`][crate::Rect] can be negative; for instance,
    /// a [`Rect`][crate::Rect] with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
    /// equivalent to a [`Rect`][crate::Rect] with an origin of [ 10, 10 ] and a size
    /// of [ -10, -10 ].
    ///
    /// Application code can normalize rectangles using [`normalize()`][Self::normalize()];
    /// this function will ensure that the width and height of a rectangle are
    /// positive values. All functions taking a [`Rect`][crate::Rect] as an argument
    /// will internally operate on a normalized copy; all functions returning a
    /// [`Rect`][crate::Rect] will always return a normalized rectangle.
    pub struct Rect(BoxedInline<ffi::graphene_rect_t>);

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

impl Rect {
    /// Checks whether a [`Rect`][crate::Rect] contains the given coordinates.
    /// ## `p`
    /// a [`Point`][crate::Point]
    ///
    /// # Returns
    ///
    /// `true` if the rectangle contains the point
    #[doc(alias = "graphene_rect_contains_point")]
    pub fn contains_point(&self, p: &Point) -> bool {
        unsafe { ffi::graphene_rect_contains_point(self.to_glib_none().0, p.to_glib_none().0) }
    }

    /// Checks whether a [`Rect`][crate::Rect] fully contains the given
    /// rectangle.
    /// ## `b`
    /// a [`Rect`][crate::Rect]
    ///
    /// # Returns
    ///
    /// `true` if the rectangle `self` fully contains `b`
    #[doc(alias = "graphene_rect_contains_rect")]
    pub fn contains_rect(&self, b: &Rect) -> bool {
        unsafe { ffi::graphene_rect_contains_rect(self.to_glib_none().0, b.to_glib_none().0) }
    }

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

    /// Expands a [`Rect`][crate::Rect] to contain the given [`Point`][crate::Point].
    /// ## `p`
    /// a [`Point`][crate::Point]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the expanded rectangle
    #[doc(alias = "graphene_rect_expand")]
    #[must_use]
    pub fn expand(&self, p: &Point) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_expand(
                self.to_glib_none().0,
                p.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Compute the area of given normalized rectangle.
    ///
    /// # Returns
    ///
    /// the area of the normalized rectangle
    #[doc(alias = "graphene_rect_get_area")]
    #[doc(alias = "get_area")]
    pub fn area(&self) -> f32 {
        unsafe { ffi::graphene_rect_get_area(self.to_glib_none().0) }
    }

    /// Retrieves the coordinates of the bottom-left corner of the given rectangle.
    ///
    /// # Returns
    ///
    ///
    /// ## `p`
    /// return location for a [`Point`][crate::Point]
    #[doc(alias = "graphene_rect_get_bottom_left")]
    #[doc(alias = "get_bottom_left")]
    pub fn bottom_left(&self) -> Point {
        unsafe {
            let mut p = Point::uninitialized();
            ffi::graphene_rect_get_bottom_left(self.to_glib_none().0, p.to_glib_none_mut().0);
            p
        }
    }

    /// Retrieves the coordinates of the bottom-right corner of the given rectangle.
    ///
    /// # Returns
    ///
    ///
    /// ## `p`
    /// return location for a [`Point`][crate::Point]
    #[doc(alias = "graphene_rect_get_bottom_right")]
    #[doc(alias = "get_bottom_right")]
    pub fn bottom_right(&self) -> Point {
        unsafe {
            let mut p = Point::uninitialized();
            ffi::graphene_rect_get_bottom_right(self.to_glib_none().0, p.to_glib_none_mut().0);
            p
        }
    }

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

    /// Retrieves the normalized height of the given rectangle.
    ///
    /// # Returns
    ///
    /// the normalized height of the rectangle
    #[doc(alias = "graphene_rect_get_height")]
    #[doc(alias = "get_height")]
    pub fn height(&self) -> f32 {
        unsafe { ffi::graphene_rect_get_height(self.to_glib_none().0) }
    }

    /// Retrieves the coordinates of the top-left corner of the given rectangle.
    ///
    /// # Returns
    ///
    ///
    /// ## `p`
    /// return location for a [`Point`][crate::Point]
    #[doc(alias = "graphene_rect_get_top_left")]
    #[doc(alias = "get_top_left")]
    pub fn top_left(&self) -> Point {
        unsafe {
            let mut p = Point::uninitialized();
            ffi::graphene_rect_get_top_left(self.to_glib_none().0, p.to_glib_none_mut().0);
            p
        }
    }

    /// Retrieves the coordinates of the top-right corner of the given rectangle.
    ///
    /// # Returns
    ///
    ///
    /// ## `p`
    /// return location for a [`Point`][crate::Point]
    #[doc(alias = "graphene_rect_get_top_right")]
    #[doc(alias = "get_top_right")]
    pub fn top_right(&self) -> Point {
        unsafe {
            let mut p = Point::uninitialized();
            ffi::graphene_rect_get_top_right(self.to_glib_none().0, p.to_glib_none_mut().0);
            p
        }
    }

    /// Retrieves the normalized width of the given rectangle.
    ///
    /// # Returns
    ///
    /// the normalized width of the rectangle
    #[doc(alias = "graphene_rect_get_width")]
    #[doc(alias = "get_width")]
    pub fn width(&self) -> f32 {
        unsafe { ffi::graphene_rect_get_width(self.to_glib_none().0) }
    }

    /// Retrieves the normalized X coordinate of the origin of the given
    /// rectangle.
    ///
    /// # Returns
    ///
    /// the normalized X coordinate of the rectangle
    #[doc(alias = "graphene_rect_get_x")]
    #[doc(alias = "get_x")]
    pub fn x(&self) -> f32 {
        unsafe { ffi::graphene_rect_get_x(self.to_glib_none().0) }
    }

    /// Retrieves the normalized Y coordinate of the origin of the given
    /// rectangle.
    ///
    /// # Returns
    ///
    /// the normalized Y coordinate of the rectangle
    #[doc(alias = "graphene_rect_get_y")]
    #[doc(alias = "get_y")]
    pub fn y(&self) -> f32 {
        unsafe { ffi::graphene_rect_get_y(self.to_glib_none().0) }
    }

    /// Changes the given rectangle to be smaller, or larger depending on the
    /// given inset parameters.
    ///
    /// To create an inset rectangle, use positive `d_x` or `d_y` values; to
    /// create a larger, encompassing rectangle, use negative `d_x` or `d_y`
    /// values.
    ///
    /// The origin of the rectangle is offset by `d_x` and `d_y`, while the size
    /// is adjusted by `(2 * `d_x`, 2 * `d_y`)`. If `d_x` and `d_y` are positive
    /// values, the size of the rectangle is decreased; if `d_x` and `d_y` are
    /// negative values, the size of the rectangle is increased.
    ///
    /// If the size of the resulting inset rectangle has a negative width or
    /// height then the size will be set to zero.
    /// ## `d_x`
    /// the horizontal inset
    /// ## `d_y`
    /// the vertical inset
    ///
    /// # Returns
    ///
    /// the inset rectangle
    #[doc(alias = "graphene_rect_inset")]
    pub fn inset(&mut self, d_x: f32, d_y: f32) {
        unsafe {
            ffi::graphene_rect_inset(self.to_glib_none_mut().0, d_x, d_y);
        }
    }

    /// Changes the given rectangle to be smaller, or larger depending on the
    /// given inset parameters.
    ///
    /// To create an inset rectangle, use positive `d_x` or `d_y` values; to
    /// create a larger, encompassing rectangle, use negative `d_x` or `d_y`
    /// values.
    ///
    /// The origin of the rectangle is offset by `d_x` and `d_y`, while the size
    /// is adjusted by `(2 * `d_x`, 2 * `d_y`)`. If `d_x` and `d_y` are positive
    /// values, the size of the rectangle is decreased; if `d_x` and `d_y` are
    /// negative values, the size of the rectangle is increased.
    ///
    /// If the size of the resulting inset rectangle has a negative width or
    /// height then the size will be set to zero.
    /// ## `d_x`
    /// the horizontal inset
    /// ## `d_y`
    /// the vertical inset
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the inset rectangle
    #[doc(alias = "graphene_rect_inset_r")]
    #[must_use]
    pub fn inset_r(&self, d_x: f32, d_y: f32) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_inset_r(self.to_glib_none().0, d_x, d_y, res.to_glib_none_mut().0);
            res
        }
    }

    /// Linearly interpolates the origin and size of the two given
    /// rectangles.
    /// ## `b`
    /// a [`Rect`][crate::Rect]
    /// ## `factor`
    /// the linear interpolation factor
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the
    ///  interpolated rectangle
    #[doc(alias = "graphene_rect_interpolate")]
    #[must_use]
    pub fn interpolate(&self, b: &Rect, factor: f64) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_interpolate(
                self.to_glib_none().0,
                b.to_glib_none().0,
                factor,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Computes the intersection of the two given rectangles.
    ///
    /// ![](rectangle-intersection.png)
    ///
    /// The intersection in the image above is the blue outline.
    ///
    /// If the two rectangles do not intersect, `res` will contain
    /// a degenerate rectangle with origin in (0, 0) and a size of 0.
    /// ## `b`
    /// a [`Rect`][crate::Rect]
    ///
    /// # Returns
    ///
    /// `true` if the two rectangles intersect
    ///
    /// ## `res`
    /// return location for
    ///  a [`Rect`][crate::Rect]
    #[doc(alias = "graphene_rect_intersection")]
    pub fn intersection(&self, b: &Rect) -> Option<Rect> {
        unsafe {
            let mut res = Rect::uninitialized();
            let ret = ffi::graphene_rect_intersection(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            if ret {
                Some(res)
            } else {
                None
            }
        }
    }

    /// Normalizes the passed rectangle.
    ///
    /// This function ensures that the size of the rectangle is made of
    /// positive values, and that the origin is the top-left corner of
    /// the rectangle.
    ///
    /// # Returns
    ///
    /// the normalized rectangle
    #[doc(alias = "graphene_rect_normalize")]
    pub fn normalize(&mut self) {
        unsafe {
            ffi::graphene_rect_normalize(self.to_glib_none_mut().0);
        }
    }

    /// Normalizes the passed rectangle.
    ///
    /// This function ensures that the size of the rectangle is made of
    /// positive values, and that the origin is in the top-left corner
    /// of the rectangle.
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// the return location for the
    ///  normalized rectangle
    #[doc(alias = "graphene_rect_normalize_r")]
    #[must_use]
    pub fn normalize_r(&self) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_normalize_r(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }

    /// Offsets the origin by `d_x` and `d_y`.
    ///
    /// The size of the rectangle is unchanged.
    /// ## `d_x`
    /// the horizontal offset
    /// ## `d_y`
    /// the vertical offset
    ///
    /// # Returns
    ///
    /// the offset rectangle
    #[doc(alias = "graphene_rect_offset")]
    pub fn offset(&mut self, d_x: f32, d_y: f32) {
        unsafe {
            ffi::graphene_rect_offset(self.to_glib_none_mut().0, d_x, d_y);
        }
    }

    /// Offsets the origin of the given rectangle by `d_x` and `d_y`.
    ///
    /// The size of the rectangle is left unchanged.
    /// ## `d_x`
    /// the horizontal offset
    /// ## `d_y`
    /// the vertical offset
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the offset
    ///  rectangle
    #[doc(alias = "graphene_rect_offset_r")]
    #[must_use]
    pub fn offset_r(&self, d_x: f32, d_y: f32) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_offset_r(self.to_glib_none().0, d_x, d_y, res.to_glib_none_mut().0);
            res
        }
    }

    /// Rounds the origin of the given rectangle to its nearest
    /// integer value and and recompute the size so that the
    /// rectangle is large enough to contain all the conrners
    /// of the original rectangle.
    ///
    /// This function is the equivalent of calling `floor` on
    /// the coordinates of the origin, and recomputing the size
    /// calling `ceil` on the bottom-right coordinates.
    ///
    /// If you want to be sure that the rounded rectangle
    /// completely covers the area that was covered by the
    /// original rectangle — i.e. you want to cover the area
    /// including all its corners — this function will make sure
    /// that the size is recomputed taking into account the ceiling
    /// of the coordinates of the bottom-right corner.
    /// If the difference between the original coordinates and the
    /// coordinates of the rounded rectangle is greater than the
    /// difference between the original size and and the rounded
    /// size, then the move of the origin would not be compensated
    /// by a move in the anti-origin, leaving the corners of the
    /// original rectangle outside the rounded one.
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the
    ///  rectangle with rounded extents
    #[doc(alias = "graphene_rect_round_extents")]
    #[must_use]
    pub fn round_extents(&self) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_round_extents(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }

    /// Scales the size and origin of a rectangle horizontaly by `s_h`,
    /// and vertically by `s_v`. The result `res` is normalized.
    /// ## `s_h`
    /// horizontal scale factor
    /// ## `s_v`
    /// vertical scale factor
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the
    ///  scaled rectangle
    #[doc(alias = "graphene_rect_scale")]
    #[must_use]
    pub fn scale(&self, s_h: f32, s_v: f32) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_scale(self.to_glib_none().0, s_h, s_v, res.to_glib_none_mut().0);
            res
        }
    }

    /// Computes the union of the two given rectangles.
    ///
    /// ![](rectangle-union.png)
    ///
    /// The union in the image above is the blue outline.
    /// ## `b`
    /// a [`Rect`][crate::Rect]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for a [`Rect`][crate::Rect]
    #[doc(alias = "graphene_rect_union")]
    #[must_use]
    pub fn union(&self, b: &Rect) -> Rect {
        unsafe {
            let mut res = Rect::uninitialized();
            ffi::graphene_rect_union(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Returns a degenerate rectangle with origin fixed at (0, 0) and
    /// a size of 0, 0.
    ///
    /// # Returns
    ///
    /// a fixed rectangle
    #[doc(alias = "graphene_rect_zero")]
    pub fn zero() -> Rect {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_rect_zero()) }
    }
}

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

impl Eq for Rect {}