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

use crate::TransformCategory;
use glib::translate::*;
use std::fmt;
use std::mem;
use std::ptr;

glib::wrapper! {
    /// [`Transform`][crate::Transform] is an object to describe transform matrices.
    ///
    /// Unlike `graphene_matrix_t`, [`Transform`][crate::Transform] retains the steps in how
    /// a transform was constructed, and allows inspecting them. It is modeled
    /// after the way CSS describes transforms.
    ///
    /// [`Transform`][crate::Transform] objects are immutable and cannot be changed after creation.
    /// This means code can safely expose them as properties of objects without
    /// having to worry about others changing them.
    #[derive(Debug, PartialOrd, Ord, Hash)]
    pub struct Transform(Shared<ffi::GskTransform>);

    match fn {
        ref => |ptr| ffi::gsk_transform_ref(ptr),
        unref => |ptr| ffi::gsk_transform_unref(ptr),
        type_ => || ffi::gsk_transform_get_type(),
    }
}

impl Transform {
    #[doc(alias = "gsk_transform_new")]
    pub fn new() -> Transform {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gsk_transform_new()) }
    }

    /// Checks two transforms for equality.
    /// ## `second`
    /// the second transform
    ///
    /// # Returns
    ///
    /// [`true`] if the two transforms perform the same operation
    #[doc(alias = "gsk_transform_equal")]
    fn equal(&self, second: &Transform) -> bool {
        unsafe {
            from_glib(ffi::gsk_transform_equal(
                self.to_glib_none().0,
                second.to_glib_none().0,
            ))
        }
    }

    /// Returns the category this transform belongs to.
    ///
    /// # Returns
    ///
    /// The category of the transform
    #[doc(alias = "gsk_transform_get_category")]
    #[doc(alias = "get_category")]
    pub fn category(&self) -> TransformCategory {
        unsafe { from_glib(ffi::gsk_transform_get_category(self.to_glib_none().0)) }
    }

    /// Inverts the given transform.
    ///
    /// If `self` is not invertible, [`None`] is returned.
    /// Note that inverting [`None`] also returns [`None`], which is
    /// the correct inverse of [`None`]. If you need to differentiate
    /// between those cases, you should check `self` is not [`None`]
    /// before calling this function.
    ///
    /// # Returns
    ///
    /// The inverted transform
    #[doc(alias = "gsk_transform_invert")]
    pub fn invert(&self) -> Option<Transform> {
        unsafe { from_glib_full(ffi::gsk_transform_invert(self.to_glib_full())) }
    }

    /// Multiplies `self` with the given `matrix`.
    /// ## `matrix`
    /// the matrix to multiply `self` with
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_matrix")]
    pub fn matrix(&self, matrix: &graphene::Matrix) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_matrix(
                self.to_glib_full(),
                matrix.to_glib_none().0,
            ))
        }
    }

    /// Applies a perspective projection transform.
    ///
    /// This transform scales points in X and Y based on their Z value,
    /// scaling points with positive Z values away from the origin, and
    /// those with negative Z values towards the origin. Points
    /// on the z=0 plane are unchanged.
    /// ## `depth`
    /// distance of the z=0 plane. Lower values give a more
    ///  flattened pyramid and therefore a more pronounced
    ///  perspective effect.
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_perspective")]
    pub fn perspective(&self, depth: f32) -> Option<Transform> {
        unsafe { from_glib_full(ffi::gsk_transform_perspective(self.to_glib_full(), depth)) }
    }

    /// Rotates `self` `angle` degrees in 2D - or in 3D-speak, around the z axis.
    /// ## `angle`
    /// the rotation angle, in degrees (clockwise)
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_rotate")]
    pub fn rotate(&self, angle: f32) -> Option<Transform> {
        unsafe { from_glib_full(ffi::gsk_transform_rotate(self.to_glib_full(), angle)) }
    }

    /// Rotates `self` `angle` degrees around `axis`.
    ///
    /// For a rotation in 2D space, use [``rotate()``][`Self::rotate()`]
    /// ## `angle`
    /// the rotation angle, in degrees (clockwise)
    /// ## `axis`
    /// The rotation axis
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_rotate_3d")]
    pub fn rotate_3d(&self, angle: f32, axis: &graphene::Vec3) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_rotate_3d(
                self.to_glib_full(),
                angle,
                axis.to_glib_none().0,
            ))
        }
    }

    /// Scales `self` in 2-dimensional space by the given factors.
    ///
    /// Use [``scale_3d()``][`Self::scale_3d()`] to scale in all 3 dimensions.
    /// ## `factor_x`
    /// scaling factor on the X axis
    /// ## `factor_y`
    /// scaling factor on the Y axis
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_scale")]
    pub fn scale(&self, factor_x: f32, factor_y: f32) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_scale(
                self.to_glib_full(),
                factor_x,
                factor_y,
            ))
        }
    }

    /// Scales `self` by the given factors.
    /// ## `factor_x`
    /// scaling factor on the X axis
    /// ## `factor_y`
    /// scaling factor on the Y axis
    /// ## `factor_z`
    /// scaling factor on the Z axis
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_scale_3d")]
    pub fn scale_3d(&self, factor_x: f32, factor_y: f32, factor_z: f32) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_scale_3d(
                self.to_glib_full(),
                factor_x,
                factor_y,
                factor_z,
            ))
        }
    }

    /// Converts a [`Transform`][crate::Transform] to a 2D transformation matrix.
    ///
    /// `self` must be a 2D transformation. If you are not
    /// sure, use [`category()`][Self::category()] >=
    /// [`TransformCategory::_2d`][crate::TransformCategory::_2d] to check.
    ///
    /// The returned values have the following layout:
    ///
    /// ```text
    ///   | xx yx |   |  a  b  0 |
    ///   | xy yy | = |  c  d  0 |
    ///   | dx dy |   | tx ty  1 |
    /// ```
    ///
    /// This function can be used to convert between a [`Transform`][crate::Transform]
    /// and a matrix type from other 2D drawing libraries, in particular
    /// Cairo.
    ///
    /// # Returns
    ///
    ///
    /// ## `out_xx`
    /// return location for the xx member
    ///
    /// ## `out_yx`
    /// return location for the yx member
    ///
    /// ## `out_xy`
    /// return location for the xy member
    ///
    /// ## `out_yy`
    /// return location for the yy member
    ///
    /// ## `out_dx`
    /// return location for the x0 member
    ///
    /// ## `out_dy`
    /// return location for the y0 member
    #[doc(alias = "gsk_transform_to_2d")]
    pub fn to_2d(&self) -> (f32, f32, f32, f32, f32, f32) {
        unsafe {
            let mut out_xx = mem::MaybeUninit::uninit();
            let mut out_yx = mem::MaybeUninit::uninit();
            let mut out_xy = mem::MaybeUninit::uninit();
            let mut out_yy = mem::MaybeUninit::uninit();
            let mut out_dx = mem::MaybeUninit::uninit();
            let mut out_dy = mem::MaybeUninit::uninit();
            ffi::gsk_transform_to_2d(
                self.to_glib_none().0,
                out_xx.as_mut_ptr(),
                out_yx.as_mut_ptr(),
                out_xy.as_mut_ptr(),
                out_yy.as_mut_ptr(),
                out_dx.as_mut_ptr(),
                out_dy.as_mut_ptr(),
            );
            let out_xx = out_xx.assume_init();
            let out_yx = out_yx.assume_init();
            let out_xy = out_xy.assume_init();
            let out_yy = out_yy.assume_init();
            let out_dx = out_dx.assume_init();
            let out_dy = out_dy.assume_init();
            (out_xx, out_yx, out_xy, out_yy, out_dx, out_dy)
        }
    }

    /// Converts a [`Transform`][crate::Transform] to 2D affine transformation factors.
    ///
    /// `self` must be a 2D transformation. If you are not
    /// sure, use
    ///
    ///  [`category()`][Self::category()] >= [`TransformCategory::_2dAffine`][crate::TransformCategory::_2dAffine]
    ///
    /// to check.
    ///
    /// # Returns
    ///
    ///
    /// ## `out_scale_x`
    /// return location for the scale
    ///  factor in the x direction
    ///
    /// ## `out_scale_y`
    /// return location for the scale
    ///  factor in the y direction
    ///
    /// ## `out_dx`
    /// return location for the translation
    ///  in the x direction
    ///
    /// ## `out_dy`
    /// return location for the translation
    ///  in the y direction
    #[doc(alias = "gsk_transform_to_affine")]
    pub fn to_affine(&self) -> (f32, f32, f32, f32) {
        unsafe {
            let mut out_scale_x = mem::MaybeUninit::uninit();
            let mut out_scale_y = mem::MaybeUninit::uninit();
            let mut out_dx = mem::MaybeUninit::uninit();
            let mut out_dy = mem::MaybeUninit::uninit();
            ffi::gsk_transform_to_affine(
                self.to_glib_none().0,
                out_scale_x.as_mut_ptr(),
                out_scale_y.as_mut_ptr(),
                out_dx.as_mut_ptr(),
                out_dy.as_mut_ptr(),
            );
            let out_scale_x = out_scale_x.assume_init();
            let out_scale_y = out_scale_y.assume_init();
            let out_dx = out_dx.assume_init();
            let out_dy = out_dy.assume_init();
            (out_scale_x, out_scale_y, out_dx, out_dy)
        }
    }

    /// Computes the actual value of `self` and stores it in `out_matrix`.
    ///
    /// The previous value of `out_matrix` will be ignored.
    ///
    /// # Returns
    ///
    ///
    /// ## `out_matrix`
    /// The matrix to set
    #[doc(alias = "gsk_transform_to_matrix")]
    pub fn to_matrix(&self) -> graphene::Matrix {
        unsafe {
            let mut out_matrix = graphene::Matrix::uninitialized();
            ffi::gsk_transform_to_matrix(self.to_glib_none().0, out_matrix.to_glib_none_mut().0);
            out_matrix
        }
    }

    #[doc(alias = "gsk_transform_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(&self) -> glib::GString {
        unsafe { from_glib_full(ffi::gsk_transform_to_string(self.to_glib_none().0)) }
    }

    /// Converts a [`Transform`][crate::Transform] to a translation operation.
    ///
    /// `self` must be a 2D transformation. If you are not
    /// sure, use
    ///
    ///  [`category()`][Self::category()] >= [`TransformCategory::_2dTranslate`][crate::TransformCategory::_2dTranslate]
    ///
    /// to check.
    ///
    /// # Returns
    ///
    ///
    /// ## `out_dx`
    /// return location for the translation
    ///  in the x direction
    ///
    /// ## `out_dy`
    /// return location for the translation
    ///  in the y direction
    #[doc(alias = "gsk_transform_to_translate")]
    pub fn to_translate(&self) -> (f32, f32) {
        unsafe {
            let mut out_dx = mem::MaybeUninit::uninit();
            let mut out_dy = mem::MaybeUninit::uninit();
            ffi::gsk_transform_to_translate(
                self.to_glib_none().0,
                out_dx.as_mut_ptr(),
                out_dy.as_mut_ptr(),
            );
            let out_dx = out_dx.assume_init();
            let out_dy = out_dy.assume_init();
            (out_dx, out_dy)
        }
    }

    /// Applies all the operations from `other` to `self`.
    /// ## `other`
    /// Transform to apply
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_transform")]
    pub fn transform(&self, other: Option<&Transform>) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_transform(
                self.to_glib_full(),
                other.to_glib_none().0,
            ))
        }
    }

    /// Transforms a `graphene_rect_t` using the given transform `self`.
    ///
    /// The result is the bounding box containing the coplanar quad.
    /// ## `rect`
    /// a `graphene_rect_t`
    ///
    /// # Returns
    ///
    ///
    /// ## `out_rect`
    /// return location for the bounds
    ///  of the transformed rectangle
    #[doc(alias = "gsk_transform_transform_bounds")]
    pub fn transform_bounds(&self, rect: &graphene::Rect) -> graphene::Rect {
        unsafe {
            let mut out_rect = graphene::Rect::uninitialized();
            ffi::gsk_transform_transform_bounds(
                self.to_glib_none().0,
                rect.to_glib_none().0,
                out_rect.to_glib_none_mut().0,
            );
            out_rect
        }
    }

    /// Transforms a `graphene_point_t` using the given transform `self`.
    /// ## `point`
    /// a `graphene_point_t`
    ///
    /// # Returns
    ///
    ///
    /// ## `out_point`
    /// return location for
    ///  the transformed point
    #[doc(alias = "gsk_transform_transform_point")]
    pub fn transform_point(&self, point: &graphene::Point) -> graphene::Point {
        unsafe {
            let mut out_point = graphene::Point::uninitialized();
            ffi::gsk_transform_transform_point(
                self.to_glib_none().0,
                point.to_glib_none().0,
                out_point.to_glib_none_mut().0,
            );
            out_point
        }
    }

    /// Translates `self` in 2-dimensional space by `point`.
    /// ## `point`
    /// the point to translate the transform by
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_translate")]
    pub fn translate(&self, point: &graphene::Point) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_translate(
                self.to_glib_full(),
                point.to_glib_none().0,
            ))
        }
    }

    /// Translates `self` by `point`.
    /// ## `point`
    /// the point to translate the transform by
    ///
    /// # Returns
    ///
    /// The new transform
    #[doc(alias = "gsk_transform_translate_3d")]
    pub fn translate_3d(&self, point: &graphene::Point3D) -> Option<Transform> {
        unsafe {
            from_glib_full(ffi::gsk_transform_translate_3d(
                self.to_glib_full(),
                point.to_glib_none().0,
            ))
        }
    }

    /// Parses the given `string` into a transform and puts it in
    /// `out_transform`.
    ///
    /// Strings printed via `Gsk::`Transform::to_string()``
    /// can be read in again successfully using this function.
    ///
    /// If `string` does not describe a valid transform, [`false`] is
    /// returned and [`None`] is put in `out_transform`.
    /// ## `string`
    /// the string to parse
    ///
    /// # Returns
    ///
    /// [`true`] if `string` described a valid transform.
    ///
    /// ## `out_transform`
    /// The location to put the transform in
    #[doc(alias = "gsk_transform_parse")]
    pub fn parse(string: &str) -> Option<Transform> {
        assert_initialized_main_thread!();
        unsafe {
            let mut out_transform = ptr::null_mut();
            let ret = from_glib(ffi::gsk_transform_parse(
                string.to_glib_none().0,
                &mut out_transform,
            ));
            if ret {
                Some(from_glib_full(out_transform))
            } else {
                None
            }
        }
    }
}

impl Default for Transform {
    fn default() -> Self {
        Self::new()
    }
}

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

impl Eq for Transform {}

impl fmt::Display for Transform {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.to_str())
    }
}