// This file is auto-generated by rute_gen. DO NOT EDIT.
use std::cell::Cell;
use std::rc::Rc;

#[allow(unused_imports)]
use std::marker::PhantomData;

#[allow(unused_imports)]
use std::os::raw::c_void;

#[allow(unused_imports)]
use std::mem::transmute;

#[allow(unused_imports)]
use std::ffi::{CStr, CString};

use rute_ffi_base::*;

#[allow(unused_imports)]
use auto::*;

/// **Notice these docs are heavy WIP and not very relevent yet**
///
/// A transformation specifies how to translate, scale, shear, rotate
/// or project the coordinate system, and is typically used when
/// rendering graphics.
///
/// QTransform differs from QMatrix in that it is a true 3x3 matrix,
/// allowing perspective transformations. QTransform's toAffine()
/// method allows casting QTransform to QMatrix. If a perspective
/// transformation has been specified on the matrix, then the
/// conversion will cause loss of data.
///
/// QTransform is the recommended transformation class in Qt.
///
/// A QTransform object can be built using the setMatrix(), scale(),
/// rotate(), translate() and shear() functions. Alternatively, it
/// can be built by applying [basic matrix operations](QTransform%23Basic%20Matrix%0A%20%20%20%20Operations)
/// . The matrix can also be
/// defined when constructed, and it can be reset to the identity
/// matrix (the default) using the reset() function.
///
/// The QTransform class supports mapping of graphic primitives: A given
/// point, line, polygon, region, or painter path can be mapped to the
/// coordinate system defined by *this* matrix using the map()
/// function. In case of a rectangle, its coordinates can be
/// transformed using the mapRect() function. A rectangle can also be
/// transformed into a *polygon* (mapped to the coordinate system
/// defined by *this* matrix), using the mapToPolygon() function.
///
/// QTransform provides the isIdentity() function which returns `true` if
/// the matrix is the identity matrix, and the isInvertible() function
/// which returns `true` if the matrix is non-singular (i.e. AB = BA =
/// I). The inverted() function returns an inverted copy of *this*
/// matrix if it is invertible (otherwise it returns the identity
/// matrix), and adjoint() returns the matrix's classical adjoint.
/// In addition, QTransform provides the determinant() function which
/// returns the matrix's determinant.
///
/// Finally, the QTransform class supports matrix multiplication, addition
/// and subtraction, and objects of the class can be streamed as well
/// as compared.
///
/// # Rendering Graphics
///
/// When rendering graphics, the matrix defines the transformations
/// but the actual transformation is performed by the drawing routines
/// in QPainter.
///
/// By default, QPainter operates on the associated device's own
/// coordinate system. The standard coordinate system of a
/// QPaintDevice has its origin located at the top-left position. The
/// *x* values increase to the right; *y* values increase
/// downward. For a complete description, see the [coordinate system](Coordinate%0A%20%20%20%20System)
/// documentation.
///
/// QPainter has functions to translate, scale, shear and rotate the
/// coordinate system without using a QTransform. For example:
///
/// * ![qtransform-simpletransformation.png](qtransform-simpletransformation.png)
///
///
///
/// Although these functions are very convenient, it can be more
/// efficient to build a QTransform and call QPainter::setTransform() if you
/// want to perform more than a single transform operation. For
/// example:
///
/// * ![qtransform-combinedtransformation.png](qtransform-combinedtransformation.png)
///
///
///
/// # Basic Matrix Operations
///
/// ![qtransform-representation.png](qtransform-representation.png)
///
/// A QTransform object contains a 3 x 3 matrix. The `m31` ( `dx)` and
/// `m32` ( `dy)` elements specify horizontal and vertical translation.
/// The `m11` and `m22` elements specify horizontal and vertical scaling.
/// The `m21` and `m12` elements specify horizontal and vertical *shearing.*
/// And finally, the `m13` and `m23` elements specify horizontal and vertical
/// projection, with `m33` as an additional projection factor.
///
/// QTransform transforms a point in the plane to another point using the
/// following formulas:
///
/// The point *(x,* y) is the original point, and *(x',* y') is the
/// transformed point. *(x',* y') can be transformed back to *(x,*
/// y) by performing the same operation on the inverted() matrix.
///
/// The various matrix elements can be set when constructing the
/// matrix, or by using the setMatrix() function later on. They can also
/// be manipulated using the translate(), rotate(), scale() and
/// shear() convenience functions. The currently set values can be
/// retrieved using the m11(), m12(), m13(), m21(), m22(), m23(),
/// m31(), m32(), m33(), dx() and dy() functions.
///
/// Translation is the simplest transformation. Setting `dx` and `dy` will move the coordinate system `dx` units along the X axis
/// and `dy` units along the Y axis. Scaling can be done by setting
/// `m11` and `m22.` For example, setting `m11` to 2 and `m22` to
/// 1.5 will double the height and increase the width by 50%. The
/// identity matrix has `m11,` `m22,` and `m33` set to 1 (all others are set
/// to 0) mapping a point to itself. Shearing is controlled by `m12`
/// and `m21.` Setting these elements to values different from zero
/// will twist the coordinate system. Rotation is achieved by
/// setting both the shearing factors and the scaling factors. Perspective
/// transformation is achieved by setting both the projection factors and
/// the scaling factors.
///
/// Here's the combined transformations example using basic matrix
/// operations:
///
/// * ![qtransform-combinedtransformation2.png](qtransform-combinedtransformation2.png)
///
///
///
/// **See also:** [`Painter`]
/// {Coordinate System}
/// {painting/affine}{Affine
/// Transformations Example}, {Transformations Example}
/// # Licence
///
/// The documentation is an adoption of the original [Qt Documentation](http://doc.qt.io/) and provided herein is licensed under the terms of the [GNU Free Documentation License version 1.3](http://www.gnu.org/licenses/fdl.html) as published by the Free Software Foundation.
#[derive(Clone)]
pub struct Transform<'a> {
    #[doc(hidden)]
    pub data: Rc<Cell<Option<*const RUBase>>>,
    #[doc(hidden)]
    pub all_funcs: *const RUTransformAllFuncs,
    #[doc(hidden)]
    pub owned: bool,
    #[doc(hidden)]
    pub _marker: PhantomData<::std::cell::Cell<&'a ()>>,
}

impl<'a> Transform<'a> {
    pub fn new() -> Transform<'a> {
        let data = Rc::new(Cell::new(None));

        let ffi_data = unsafe {
            ((*rute_ffi_get()).create_transform)(
                ::std::ptr::null(),
                transmute(rute_object_delete_callback as usize),
                Rc::into_raw(data.clone()) as *const c_void,
            )
        };

        data.set(Some(ffi_data.qt_data));

        Transform {
            data,
            all_funcs: ffi_data.all_funcs,
            owned: true,
            _marker: PhantomData,
        }
    }
    #[allow(dead_code)]
    pub(crate) fn new_from_rc(ffi_data: RUTransform) -> Transform<'a> {
        Transform {
            data: unsafe { Rc::from_raw(ffi_data.host_data as *const Cell<Option<*const RUBase>>) },
            all_funcs: ffi_data.all_funcs,
            owned: false,
            _marker: PhantomData,
        }
    }

    #[allow(dead_code)]
    pub(crate) fn new_from_owned(ffi_data: RUTransform) -> Transform<'a> {
        Transform {
            data: Rc::new(Cell::new(Some(ffi_data.qt_data as *const RUBase))),
            all_funcs: ffi_data.all_funcs,
            owned: true,
            _marker: PhantomData,
        }
    }

    #[allow(dead_code)]
    pub(crate) fn new_from_temporary(ffi_data: RUTransform) -> Transform<'a> {
        Transform {
            data: Rc::new(Cell::new(Some(ffi_data.qt_data as *const RUBase))),
            all_funcs: ffi_data.all_funcs,
            owned: false,
            _marker: PhantomData,
        }
    }
    ///
    /// Returns `true` if the matrix represent an affine transformation,
    /// otherwise returns `false.`
    pub fn is_affine(&self) -> bool {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_affine)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the matrix is the identity matrix, otherwise
    /// returns `false.`
    ///
    /// **See also:** [`reset()`]
    pub fn is_identity(&self) -> bool {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_identity)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the matrix is invertible, otherwise returns `false.`
    ///
    /// **See also:** [`inverted()`]
    pub fn is_invertible(&self) -> bool {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_invertible)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the matrix represents a scaling
    /// transformation, otherwise returns `false.`
    ///
    /// **See also:** [`reset()`]
    pub fn is_scaling(&self) -> bool {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_scaling)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the matrix represents some kind of a
    /// rotating transformation, otherwise returns `false.`
    ///
    /// **Note**: A rotation transformation of 180 degrees and/or 360 degrees is treated as a scaling transformation.
    ///
    /// **See also:** [`reset()`]
    pub fn is_rotating(&self) -> bool {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_rotating)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the matrix represents a translating
    /// transformation, otherwise returns `false.`
    ///
    /// **See also:** [`reset()`]
    pub fn is_translating(&self) -> bool {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_translating)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the transformation type of this matrix.
    ///
    /// The transformation type is the highest enumeration value
    /// capturing all of the matrix's transformations. For example,
    /// if the matrix both scales and shears, the type would be `TxShear,`
    /// because `TxShear` has a higher enumeration value than `TxScale.`
    ///
    /// Knowing the transformation type of a matrix is useful for optimization:
    /// you can often handle specific types more optimally than handling
    /// the generic case.
    pub fn get_type(&self) -> TransformationType {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).get_type)(obj_data);
            let ret_val = TransformationType::from_bits_truncate(ret_val);
            ret_val
        }
    }
    ///
    /// Returns the matrix's determinant.
    pub fn determinant(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).determinant)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the matrix's determinant. Use determinant() instead.
    ///
    /// Returns the matrix's determinant.
    pub fn det(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).det)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the horizontal scaling factor.
    ///
    /// **See also:** [`scale()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m11(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m11)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the vertical shearing factor.
    ///
    /// **See also:** [`shear()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m12(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m12)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the horizontal projection factor.
    ///
    /// **See also:** [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m13(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m13)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the horizontal shearing factor.
    ///
    /// **See also:** [`shear()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m21(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m21)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the vertical scaling factor.
    ///
    /// **See also:** [`scale()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m22(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m22)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the vertical projection factor.
    ///
    /// **See also:** [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m23(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m23)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the horizontal translation factor.
    ///
    /// **See also:** [`dx()`]
    /// [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m31(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m31)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the vertical translation factor.
    ///
    /// **See also:** [`dy()`]
    /// [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m32(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m32)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the division factor.
    ///
    /// **See also:** [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn m33(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).m33)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the horizontal translation factor.
    ///
    /// **See also:** [`m31()`]
    /// [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn dx(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).dx)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the vertical translation factor.
    ///
    /// **See also:** [`translate()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn dy(&self) -> f32 {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).dy)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the adjoint of this matrix.
    pub fn adjoint(&self) -> Transform {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).adjoint)(obj_data);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// Scales the coordinate system by *sx* horizontally and *sy*
    /// vertically, and returns a reference to the matrix.
    ///
    /// **See also:** [`set_matrix()`]
    pub fn scale(&self, sx: f32, sy: f32) -> Option<Transform> {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).scale)(obj_data, sx, sy);
            if ret_val.qt_data == ::std::ptr::null() {
                return None;
            }
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            Some(ret_val)
        }
    }
    ///
    /// Shears the coordinate system by *sh* horizontally and *sv*
    /// vertically, and returns a reference to the matrix.
    ///
    /// **See also:** [`set_matrix()`]
    pub fn shear(&self, sh: f32, sv: f32) -> Option<Transform> {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).shear)(obj_data, sh, sv);
            if ret_val.qt_data == ::std::ptr::null() {
                return None;
            }
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            Some(ret_val)
        }
    }
    ///
    /// Rotates the coordinate system counterclockwise by the given *angle*
    /// about the specified *axis* and returns a reference to the matrix.
    ///
    /// Note that if you apply a QTransform to a point defined in widget
    /// coordinates, the direction of the rotation will be clockwise
    /// because the y-axis points downwards.
    ///
    /// The angle is specified in degrees.
    ///
    /// **See also:** [`set_matrix()`]
    ///
    /// Rotates the coordinate system counterclockwise by the given *angle*
    /// about the specified *axis* and returns a reference to the matrix.
    ///
    /// Note that if you apply a QTransform to a point defined in widget
    /// coordinates, the direction of the rotation will be clockwise
    /// because the y-axis points downwards.
    ///
    /// The angle is specified in radians.
    ///
    /// **See also:** [`set_matrix()`]
    pub fn rotate(&self, a: f32, axis: Axis) -> Option<Transform> {
        let enum_axis_2 = axis as u32;

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).rotate)(obj_data, a, enum_axis_2);
            if ret_val.qt_data == ::std::ptr::null() {
                return None;
            }
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            Some(ret_val)
        }
    }
    ///
    /// Rotates the coordinate system counterclockwise by the given *angle*
    /// about the specified *axis* and returns a reference to the matrix.
    ///
    /// Note that if you apply a QTransform to a point defined in widget
    /// coordinates, the direction of the rotation will be clockwise
    /// because the y-axis points downwards.
    ///
    /// The angle is specified in radians.
    ///
    /// **See also:** [`set_matrix()`]
    pub fn rotate_radians(&self, a: f32, axis: Axis) -> Option<Transform> {
        let enum_axis_2 = axis as u32;

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).rotate_radians)(obj_data, a, enum_axis_2);
            if ret_val.qt_data == ::std::ptr::null() {
                return None;
            }
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            Some(ret_val)
        }
    }
    ///
    /// Creates a transformation matrix, *trans,* that maps a unit square
    /// to a four-sided polygon, *quad.* Returns `true` if the transformation
    /// is constructed or false if such a transformation does not exist.
    ///
    /// **See also:** [`quad_to_square()`]
    /// [`quad_to_quad()`]
    pub fn square_to_quad<P: PolygonFTrait<'a>, T: TransformTrait<'a>>(
        square: &P,
        result: &T,
    ) -> bool {
        let (obj_square_1, _funcs) = square.get_polygon_f_obj_funcs();
        let (obj_result_2, _funcs) = result.get_transform_obj_funcs();

        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_transform)(::std::ptr::null()).all_funcs).transform_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).square_to_quad)(obj_data, obj_square_1, obj_result_2);
            ret_val
        }
    }
    ///
    /// Creates a transformation matrix, *trans,* that maps a four-sided polygon,
    /// *quad,* to a unit square. Returns `true` if the transformation is constructed
    /// or false if such a transformation does not exist.
    ///
    /// **See also:** [`square_to_quad()`]
    /// [`quad_to_quad()`]
    pub fn quad_to_square<P: PolygonFTrait<'a>, T: TransformTrait<'a>>(
        quad: &P,
        result: &T,
    ) -> bool {
        let (obj_quad_1, _funcs) = quad.get_polygon_f_obj_funcs();
        let (obj_result_2, _funcs) = result.get_transform_obj_funcs();

        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_transform)(::std::ptr::null()).all_funcs).transform_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).quad_to_square)(obj_data, obj_quad_1, obj_result_2);
            ret_val
        }
    }
    ///
    /// Creates a transformation matrix, *trans,* that maps a four-sided
    /// polygon, *one,* to another four-sided polygon, *two.*
    /// Returns `true` if the transformation is possible; otherwise returns
    /// false.
    ///
    /// This is a convenience method combining quadToSquare() and
    /// squareToQuad() methods. It allows the input quad to be
    /// transformed into any other quad.
    ///
    /// **See also:** [`square_to_quad()`]
    /// [`quad_to_square()`]
    pub fn quad_to_quad<P: PolygonFTrait<'a>, T: TransformTrait<'a>>(
        one: &P,
        two: &P,
        result: &T,
    ) -> bool {
        let (obj_one_1, _funcs) = one.get_polygon_f_obj_funcs();
        let (obj_two_2, _funcs) = two.get_polygon_f_obj_funcs();
        let (obj_result_3, _funcs) = result.get_transform_obj_funcs();

        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_transform)(::std::ptr::null()).all_funcs).transform_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).quad_to_quad)(obj_data, obj_one_1, obj_two_2, obj_result_3);
            ret_val
        }
    }
    ///
    /// Resets the matrix to an identity matrix, i.e. all elements are set
    /// to zero, except `m11` and `m22` (specifying the scale) and `m33`
    /// which are set to 1.
    ///
    /// **See also:** [`q_transform()`]
    /// [`is_identity()`]
    /// {QTransform#Basic Matrix
    /// Operations}{Basic Matrix Operations}
    pub fn reset(&self) -> &Self {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            ((*funcs).reset)(obj_data);
        }
        self
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map<P: PointTrait<'a>>(&self, p: &P) -> Point {
        let (obj_p_1, _funcs) = p.get_point_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map)(obj_data, obj_p_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Point::new_from_rc(t);
            } else {
                ret_val = Point::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map_2<P: PointFTrait<'a>>(&self, p: &P) -> PointF {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_2)(obj_data, obj_p_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = PointF::new_from_rc(t);
            } else {
                ret_val = PointF::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map_3<L: LineTrait<'a>>(&self, l: &L) -> Line {
        let (obj_l_1, _funcs) = l.get_line_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_3)(obj_data, obj_l_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Line::new_from_rc(t);
            } else {
                ret_val = Line::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map_4<L: LineFTrait<'a>>(&self, l: &L) -> LineF {
        let (obj_l_1, _funcs) = l.get_line_f_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_4)(obj_data, obj_l_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = LineF::new_from_rc(t);
            } else {
                ret_val = LineF::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map_5<P: PolygonFTrait<'a>>(&self, a: &P) -> PolygonF {
        let (obj_a_1, _funcs) = a.get_polygon_f_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_5)(obj_data, obj_a_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = PolygonF::new_from_rc(t);
            } else {
                ret_val = PolygonF::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map_6<P: PolygonTrait<'a>>(&self, a: &P) -> Polygon {
        let (obj_a_1, _funcs) = a.get_polygon_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_6)(obj_data, obj_a_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Polygon::new_from_rc(t);
            } else {
                ret_val = Polygon::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    pub fn map_7<R: RegionTrait<'a>>(&self, r: &R) -> Region {
        let (obj_r_1, _funcs) = r.get_region_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_7)(obj_data, obj_r_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Region::new_from_rc(t);
            } else {
                ret_val = Region::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    pub fn map_to_polygon<R: RectTrait<'a>>(&self, r: &R) -> Polygon {
        let (obj_r_1, _funcs) = r.get_rect_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_to_polygon)(obj_data, obj_r_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Polygon::new_from_rc(t);
            } else {
                ret_val = Polygon::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    pub fn map_rect<R: RectTrait<'a>>(&self, arg0: &R) -> Rect {
        let (obj_arg0_1, _funcs) = arg0.get_rect_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_rect)(obj_data, obj_arg0_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Rect::new_from_rc(t);
            } else {
                ret_val = Rect::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    pub fn map_rect_2<R: RectFTrait<'a>>(&self, arg0: &R) -> RectF {
        let (obj_arg0_1, _funcs) = arg0.get_rect_f_obj_funcs();

        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).map_rect_2)(obj_data, obj_arg0_1);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = RectF::new_from_rc(t);
            } else {
                ret_val = RectF::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPointF object that is a copy of the given point,
    /// *p,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPoint object that is a copy of the given *point,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QLineF object that is a copy of the given line,
    /// *l,* mapped into the coordinate system defined by this matrix.
    ///
    /// **Overloads**
    ///
    /// Creates and returns a QLine object that is a copy of the given *line,* mapped into the coordinate system defined by this matrix.
    /// Note that the transformed coordinates are rounded to the nearest
    /// integer.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygonF object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// **Overloads**
    /// Creates and returns a QPolygon object that is a copy of the given
    /// *polygon,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// **Overloads**
    /// Creates and returns a QRegion object that is a copy of the given
    /// *region,* mapped into the coordinate system defined by this matrix.
    ///
    /// Calling this method can be rather expensive if rotations or
    /// shearing are used.
    ///
    /// **Overloads**
    /// Creates and returns a QPainterPath object that is a copy of the
    /// given *path,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// Creates and returns a QPolygon representation of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// Polygons and rectangles behave slightly differently when
    /// transformed (due to integer rounding), so
    /// `matrix.map(QPolygon(rectangle))` is not always the same as
    /// `matrix.mapToPolygon(rectangle)` .
    ///
    /// **See also:** [`map_rect()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// Creates and returns a QRectF object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix.
    ///
    /// The rectangle's coordinates are transformed using the following
    /// formulas:
    ///
    /// If rotation or shearing has been specified, this function returns
    /// the *bounding* rectangle. To retrieve the exact region the given
    /// *rectangle* maps to, use the mapToPolygon() function instead.
    ///
    /// **See also:** [`map_to_polygon()`]
    /// {QTransform#Basic Matrix Operations}{Basic Matrix
    /// Operations}
    ///
    /// **Overloads**
    /// Creates and returns a QRect object that is a copy of the given *rectangle,* mapped into the coordinate system defined by this
    /// matrix. Note that the transformed coordinates are rounded to the
    /// nearest integer.
    ///
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively.
    ///
    /// The coordinates are transformed using the following formulas:
    ///
    /// The point (x, y) is the original point, and (x', y') is the
    /// transformed point.
    ///
    /// **See also:** {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
    ///
    /// **Overloads**
    /// Maps the given coordinates *x* and *y* into the coordinate
    /// system defined by this matrix. The resulting values are put in * *tx* and * *ty,* respectively. Note that the transformed coordinates
    /// are rounded to the nearest integer.
    ///
    /// Returns the QTransform as an affine matrix.
    ///
    /// **Warning**: If a perspective transformation has been specified,
    /// then the conversion will cause loss of data.
    pub fn to_affine(&self) -> Option<Matrix> {
        let (obj_data, funcs) = self.get_transform_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).to_affine)(obj_data);
            if ret_val.qt_data == ::std::ptr::null() {
                return None;
            }
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Matrix::new_from_rc(t);
            } else {
                ret_val = Matrix::new_from_owned(t);
            }
            Some(ret_val)
        }
    }
    ///
    /// Creates a matrix which corresponds to a translation of *dx* along
    /// the x axis and *dy* along the y axis. This is the same as
    /// QTransform().translate(dx, dy) but slightly faster.
    ///
    pub fn from_translate(dx: f32, dy: f32) -> Transform<'a> {
        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_transform)(::std::ptr::null()).all_funcs).transform_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).from_translate)(obj_data, dx, dy);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// Creates a matrix which corresponds to a scaling of
    /// *sx* horizontally and *sy* vertically.
    /// This is the same as QTransform().scale(sx, sy) but slightly faster.
    ///
    pub fn from_scale(dx: f32, dy: f32) -> Transform<'a> {
        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_transform)(::std::ptr::null()).all_funcs).transform_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).from_scale)(obj_data, dx, dy);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = Transform::new_from_rc(t);
            } else {
                ret_val = Transform::new_from_owned(t);
            }
            ret_val
        }
    }

    pub fn build(&self) -> Self {
        self.clone()
    }
}
pub trait TransformTrait<'a> {
    #[inline]
    #[doc(hidden)]
    fn get_transform_obj_funcs(&self) -> (*const RUBase, *const RUTransformFuncs);
}

impl<'a> TransformTrait<'a> for Transform<'a> {
    #[doc(hidden)]
    fn get_transform_obj_funcs(&self) -> (*const RUBase, *const RUTransformFuncs) {
        let obj = self.data.get().unwrap();
        unsafe { (obj, (*self.all_funcs).transform_funcs) }
    }
}
bitflags! {
    pub struct TransformationType: u32 {
        const TxNone = 0x0;
        const TxTranslate = 0x1;
        const TxScale = 0x2;
        const TxRotate = 0x4;
        const TxShear = 0x8;
        const TxProject = 0x10;
    }
}