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

glib::wrapper! {
    /// A structure capable of holding a vector with two dimensions, x and y.
    ///
    /// The contents of the [`Vec2`][crate::Vec2] structure are private and should
    /// never be accessed directly.
    #[derive(Debug, PartialOrd, Ord, Hash)]
    pub struct Vec2(Boxed<ffi::graphene_vec2_t>);

    match fn {
        copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::graphene_vec2_get_type(), ptr as *mut _) as *mut ffi::graphene_vec2_t,
        free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::graphene_vec2_get_type(), ptr as *mut _),
        init => |_ptr| (),
        clear => |_ptr| (),
        type_ => || ffi::graphene_vec2_get_type(),
    }
}

impl Vec2 {
    /// Adds each component of the two passed vectors and places
    /// each result into the components of `res`.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result
    #[doc(alias = "graphene_vec2_add")]
    pub fn add(&self, b: &Vec2) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_add(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Divides each component of the first operand `self` by the corresponding
    /// component of the second operand `b`, and places the results into the
    /// vector `res`.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result
    #[doc(alias = "graphene_vec2_divide")]
    pub fn divide(&self, b: &Vec2) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_divide(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Computes the dot product of the two given vectors.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    /// the dot product of the vectors
    #[doc(alias = "graphene_vec2_dot")]
    pub fn dot(&self, b: &Vec2) -> f32 {
        unsafe { ffi::graphene_vec2_dot(self.to_glib_none().0, b.to_glib_none().0) }
    }

    /// Checks whether the two given [`Vec2`][crate::Vec2] are equal.
    /// ## `v2`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    /// `true` if the two vectors are equal, and false otherwise
    #[doc(alias = "graphene_vec2_equal")]
    fn equal(&self, v2: &Vec2) -> bool {
        unsafe {
            from_glib(ffi::graphene_vec2_equal(
                self.to_glib_none().0,
                v2.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the X component of the [`Vec2`][crate::Vec2].
    ///
    /// # Returns
    ///
    /// the value of the X component
    #[doc(alias = "graphene_vec2_get_x")]
    #[doc(alias = "get_x")]
    pub fn x(&self) -> f32 {
        unsafe { ffi::graphene_vec2_get_x(self.to_glib_none().0) }
    }

    /// Retrieves the Y component of the [`Vec2`][crate::Vec2].
    ///
    /// # Returns
    ///
    /// the value of the Y component
    #[doc(alias = "graphene_vec2_get_y")]
    #[doc(alias = "get_y")]
    pub fn y(&self) -> f32 {
        unsafe { ffi::graphene_vec2_get_y(self.to_glib_none().0) }
    }

    /// Initializes a [`Vec2`][crate::Vec2] using the given values.
    ///
    /// This function can be called multiple times.
    /// ## `x`
    /// the X field of the vector
    /// ## `y`
    /// the Y field of the vector
    ///
    /// # Returns
    ///
    /// the initialized vector
    #[doc(alias = "graphene_vec2_init")]
    pub fn init(&mut self, x: f32, y: f32) {
        unsafe {
            ffi::graphene_vec2_init(self.to_glib_none_mut().0, x, y);
        }
    }

    //#[doc(alias = "graphene_vec2_init_from_float")]
    //pub fn init_from_float(&mut self, src: /*Unimplemented*/FixedArray TypeId { ns_id: 0, id: 20 }; 2) -> Option<Vec2> {
    //    unsafe { TODO: call ffi:graphene_vec2_init_from_float() }
    //}

    /// Copies the contents of `src` into `self`.
    /// ## `src`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    /// the initialized vector
    #[doc(alias = "graphene_vec2_init_from_vec2")]
    pub fn init_from_vec2(&mut self, src: &Vec2) {
        unsafe {
            ffi::graphene_vec2_init_from_vec2(self.to_glib_none_mut().0, src.to_glib_none().0);
        }
    }

    /// Linearly interpolates `self` and `v2` using the given `factor`.
    /// ## `v2`
    /// a [`Vec2`][crate::Vec2]
    /// ## `factor`
    /// the interpolation factor
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// the interpolated vector
    #[doc(alias = "graphene_vec2_interpolate")]
    pub fn interpolate(&self, v2: &Vec2, factor: f64) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_interpolate(
                self.to_glib_none().0,
                v2.to_glib_none().0,
                factor,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Computes the length of the given vector.
    ///
    /// # Returns
    ///
    /// the length of the vector
    #[doc(alias = "graphene_vec2_length")]
    pub fn length(&self) -> f32 {
        unsafe { ffi::graphene_vec2_length(self.to_glib_none().0) }
    }

    /// Compares the two given vectors and places the maximum
    /// values of each component into `res`.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// the resulting vector
    #[doc(alias = "graphene_vec2_max")]
    pub fn max(&self, b: &Vec2) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_max(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Compares the two given vectors and places the minimum
    /// values of each component into `res`.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// the resulting vector
    #[doc(alias = "graphene_vec2_min")]
    pub fn min(&self, b: &Vec2) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_min(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Multiplies each component of the two passed vectors and places
    /// each result into the components of `res`.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result
    #[doc(alias = "graphene_vec2_multiply")]
    pub fn multiply(&self, b: &Vec2) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_multiply(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Compares the two given [`Vec2`][crate::Vec2] vectors and checks
    /// whether their values are within the given `epsilon`.
    /// ## `v2`
    /// a [`Vec2`][crate::Vec2]
    /// ## `epsilon`
    /// the threshold between the two vectors
    ///
    /// # Returns
    ///
    /// `true` if the two vectors are near each other
    #[doc(alias = "graphene_vec2_near")]
    pub fn near(&self, v2: &Vec2, epsilon: f32) -> bool {
        unsafe {
            from_glib(ffi::graphene_vec2_near(
                self.to_glib_none().0,
                v2.to_glib_none().0,
                epsilon,
            ))
        }
    }

    /// Negates the given [`Vec2`][crate::Vec2].
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result vector
    #[doc(alias = "graphene_vec2_negate")]
    pub fn negate(&self) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_negate(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }

    /// Computes the normalized vector for the given vector `self`.
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the
    ///  normalized vector
    #[doc(alias = "graphene_vec2_normalize")]
    pub fn normalize(&self) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_normalize(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }

    /// Multiplies all components of the given vector with the given scalar `factor`.
    /// ## `factor`
    /// the scalar factor
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result vector
    #[doc(alias = "graphene_vec2_scale")]
    pub fn scale(&self, factor: f32) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_scale(self.to_glib_none().0, factor, res.to_glib_none_mut().0);
            res
        }
    }

    /// Subtracts from each component of the first operand `self` the
    /// corresponding component of the second operand `b` and places
    /// each result into the components of `res`.
    /// ## `b`
    /// a [`Vec2`][crate::Vec2]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the result
    #[doc(alias = "graphene_vec2_subtract")]
    pub fn subtract(&self, b: &Vec2) -> Vec2 {
        unsafe {
            let mut res = Vec2::uninitialized();
            ffi::graphene_vec2_subtract(
                self.to_glib_none().0,
                b.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    //#[doc(alias = "graphene_vec2_to_float")]
    //pub fn to_float(&self, dest: /*Unimplemented*/FixedArray TypeId { ns_id: 0, id: 20 }; 2) {
    //    unsafe { TODO: call ffi:graphene_vec2_to_float() }
    //}

    /// Retrieves a constant vector with (1, 1) components.
    ///
    /// # Returns
    ///
    /// the one vector
    #[doc(alias = "graphene_vec2_one")]
    pub fn one() -> Vec2 {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_vec2_one()) }
    }

    /// Retrieves a constant vector with (1, 0) components.
    ///
    /// # Returns
    ///
    /// the X axis vector
    #[doc(alias = "graphene_vec2_x_axis")]
    pub fn x_axis() -> Vec2 {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_vec2_x_axis()) }
    }

    /// Retrieves a constant vector with (0, 1) components.
    ///
    /// # Returns
    ///
    /// the Y axis vector
    #[doc(alias = "graphene_vec2_y_axis")]
    pub fn y_axis() -> Vec2 {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_vec2_y_axis()) }
    }

    /// Retrieves a constant vector with (0, 0) components.
    ///
    /// # Returns
    ///
    /// the zero vector
    #[doc(alias = "graphene_vec2_zero")]
    pub fn zero() -> Vec2 {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::graphene_vec2_zero()) }
    }
}

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

impl Eq for Vec2 {}