rute 0.0.4

// 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 rectangle is normally expressed as a top-left corner and a
/// size. The size (width and height) of a QRectF is always equivalent
/// to the mathematical rectangle that forms the basis for its
/// rendering.
///
/// A QRectF can be constructed with a set of left, top, width and
/// height coordinates, or from a QPointF and a QSizeF. The following
/// code creates two identical rectangles.
///
/// There is also a third constructor creating a QRectF from a QRect,
/// and a corresponding toRect() function that returns a QRect object
/// based on the values of this rectangle (note that the coordinates
/// in the returned rectangle are rounded to the nearest integer).
///
/// The QRectF class provides a collection of functions that return
/// the various rectangle coordinates, and enable manipulation of
/// these. QRectF also provides functions to move the rectangle
/// relative to the various coordinates. In addition there is a
/// moveTo() function that moves the rectangle, leaving its top left
/// corner at the given coordinates. Alternatively, the translate()
/// function moves the rectangle the given offset relative to the
/// current position, and the translated() function returns a
/// translated copy of this rectangle.
///
/// The size() function returns the rectange's dimensions as a
/// QSizeF. The dimensions can also be retrieved separately using the
/// width() and height() functions. To manipulate the dimensions use
/// the setSize(), setWidth() or setHeight() functions. Alternatively,
/// the size can be changed by applying either of the functions
/// setting the rectangle coordinates, for example, setBottom() or
/// setRight().
///
/// The contains() function tells whether a given point is inside the
/// rectangle or not, and the intersects() function returns `true` if
/// this rectangle intersects with a given rectangle (otherwise
/// false). The QRectF class also provides the intersected() function
/// which returns the intersection rectangle, and the united() function
/// which returns the rectangle that encloses the given rectangle and
/// this:
///
/// * ![qrect-intersect.png](qrect-intersect.png)
///
/// * ![qrect-unite.png](qrect-unite.png)
///
/// * intersected()
/// * united()
///
/// The isEmpty() function returns `true` if the rectangle's width or
/// height is less than, or equal to, 0. Note that an empty rectangle
/// is not valid: The isValid() function returns `true` if both width
/// and height is larger than 0. A null rectangle (isNull() == true)
/// on the other hand, has both width and height set to 0.
///
/// Note that due to the way QRect and QRectF are defined, an
/// empty QRectF is defined in essentially the same way as QRect.
///
/// Finally, QRectF objects can be streamed as well as compared.
///
/// # Rendering
///
/// When using an [anti-aliased](QPainter::Antialiasing)
/// painter,
/// the boundary line of a QRectF will be rendered symmetrically on both
/// sides of the mathematical rectangle's boundary line. But when
/// using an aliased painter (the default) other rules apply.
///
/// Then, when rendering with a one pixel wide pen the QRectF's boundary
/// line will be rendered to the right and below the mathematical
/// rectangle's boundary line.
///
/// When rendering with a two pixels wide pen the boundary line will
/// be split in the middle by the mathematical rectangle. This will be
/// the case whenever the pen is set to an even number of pixels,
/// while rendering with a pen with an odd number of pixels, the spare
/// pixel will be rendered to the right and below the mathematical
/// rectangle as in the one pixel case.
///
/// * ![qrect-diagram-zero.png](qrect-diagram-zero.png)
///
/// * ![qrectf-diagram-one.png](qrectf-diagram-one.png)
///
/// * Logical representation
/// * One pixel wide pen
///
/// * ![qrectf-diagram-two.png](qrectf-diagram-two.png)
///
/// * ![qrectf-diagram-three.png](qrectf-diagram-three.png)
///
/// * Two pixel wide pen
/// * Three pixel wide pen
///
/// # Coordinates
///
/// The QRectF class provides a collection of functions that return
/// the various rectangle coordinates, and enable manipulation of
/// these. QRectF also provides functions to move the rectangle
/// relative to the various coordinates.
///
/// For example: the bottom(), setBottom() and moveBottom() functions:
/// bottom() returns the y-coordinate of the rectangle's bottom edge,
/// setBottom() sets the bottom edge of the rectangle to the given y
/// coordinate (it may change the height, but will never change the
/// rectangle's top edge) and moveBottom() moves the entire rectangle
/// vertically, leaving the rectangle's bottom edge at the given y
/// coordinate and its size unchanged.
///
/// ![qrectf-coordinates.png](qrectf-coordinates.png)
///
/// It is also possible to add offsets to this rectangle's coordinates
/// using the adjust() function, as well as retrieve a new rectangle
/// based on adjustments of the original one using the adjusted()
/// function. If either of the width and height is negative, use the
/// normalized() function to retrieve a rectangle where the corners
/// are swapped.
///
/// In addition, QRectF provides the getCoords() function which extracts
/// the position of the rectangle's top-left and bottom-right corner,
/// and the getRect() function which extracts the rectangle's top-left
/// corner, width and height. Use the setCoords() and setRect()
/// function to manipulate the rectangle's coordinates and dimensions
/// in one go.
///
/// **See also:** [`Rect`]
/// [`Region`]
/// # 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 RectF<'a> {
    #[doc(hidden)]
    pub data: Rc<Cell<Option<*const RUBase>>>,
    #[doc(hidden)]
    pub all_funcs: *const RURectFAllFuncs,
    #[doc(hidden)]
    pub owned: bool,
    #[doc(hidden)]
    pub _marker: PhantomData<::std::cell::Cell<&'a ()>>,
}

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

        let ffi_data = unsafe {
            ((*rute_ffi_get()).create_rect_f)(
                ::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));

        RectF {
            data,
            all_funcs: ffi_data.all_funcs,
            owned: true,
            _marker: PhantomData,
        }
    }
    #[allow(dead_code)]
    pub(crate) fn new_from_rc(ffi_data: RURectF) -> RectF<'a> {
        RectF {
            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: RURectF) -> RectF<'a> {
        RectF {
            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: RURectF) -> RectF<'a> {
        RectF {
            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 rectangle is a null rectangle, otherwise returns `false.`
    ///
    /// A null rectangle has both the width and the height set to 0. A
    /// null rectangle is also empty, and hence not valid.
    ///
    /// **See also:** [`is_empty()`]
    /// [`is_valid()`]
    pub fn is_null(&self) -> bool {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_null)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the rectangle is empty, otherwise returns `false.`
    ///
    /// An empty rectangle has width() <= 0 or height() <= 0. An empty
    /// rectangle is not valid (i.e., isEmpty() == !isValid()).
    ///
    /// Use the normalized() function to retrieve a rectangle where the
    /// corners are swapped.
    ///
    /// **See also:** [`is_null()`]
    /// [`is_valid()`]
    /// [`normalized()`]
    pub fn is_empty(&self) -> bool {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_empty)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns `true` if the rectangle is valid, otherwise returns `false.`
    ///
    /// A valid rectangle has a width() > 0 and height() > 0. Note that
    /// non-trivial operations like intersections are not defined for
    /// invalid rectangles. A valid rectangle is not empty (i.e., isValid()
    /// == !isEmpty()).
    ///
    /// **See also:** [`is_null()`]
    /// [`is_empty()`]
    /// [`normalized()`]
    pub fn is_valid(&self) -> bool {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).is_valid)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns a normalized rectangle; i.e., a rectangle that has a
    /// non-negative width and height.
    ///
    /// If width() < 0 the function swaps the left and right corners, and
    /// it swaps the top and bottom corners if height() < 0.
    ///
    /// **See also:** [`is_valid()`]
    /// [`is_empty()`]
    pub fn normalized(&self) -> RectF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).normalized)(obj_data);
            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
        }
    }
    ///
    /// Returns the x-coordinate of the rectangle's left edge. Equivalent
    /// to x().
    ///
    /// **See also:** [`set_left()`]
    /// [`top_left()`]
    /// [`bottom_left()`]
    pub fn left(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).left)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the y-coordinate of the rectangle's top edge. Equivalent
    /// to y().
    ///
    /// **See also:** [`set_top()`]
    /// [`top_left()`]
    /// [`top_right()`]
    ///
    /// Returns the position of the rectangle's top-left corner.
    ///
    /// **See also:** [`set_top_left()`]
    /// [`top()`]
    /// [`left()`]
    ///
    /// Returns the position of the rectangle's top-right corner.
    ///
    /// **See also:** [`set_top_right()`]
    /// [`top()`]
    /// [`right()`]
    pub fn top(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).top)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the x-coordinate of the rectangle's right edge.
    ///
    /// **See also:** [`set_right()`]
    /// [`top_right()`]
    /// [`bottom_right()`]
    pub fn right(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).right)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the y-coordinate of the rectangle's bottom edge.
    ///
    /// **See also:** [`set_bottom()`]
    /// [`bottom_left()`]
    /// [`bottom_right()`]
    ///
    /// Returns the position of the rectangle's bottom-right corner.
    ///
    /// **See also:** [`set_bottom_right()`]
    /// [`bottom()`]
    /// [`right()`]
    ///
    /// Returns the position of the rectangle's bottom-left corner.
    ///
    /// **See also:** [`set_bottom_left()`]
    /// [`bottom()`]
    /// [`left()`]
    pub fn bottom(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).bottom)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the x-coordinate of the rectangle's left edge. Equivalent
    /// to left().
    ///
    /// **See also:** [`set_x()`]
    /// [`y()`]
    /// [`top_left()`]
    pub fn x(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).x)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the y-coordinate of the rectangle's top edge. Equivalent
    /// to top().
    ///
    /// **See also:** [`set_y()`]
    /// [`x()`]
    /// [`top_left()`]
    pub fn y(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).y)(obj_data);
            ret_val
        }
    }
    ///
    /// Sets the left edge of the rectangle to the given *x*
    /// coordinate. May change the width, but will never change the right
    /// edge of the rectangle.
    ///
    /// Equivalent to setX().
    ///
    /// **See also:** [`left()`]
    /// [`move_left()`]
    pub fn set_left(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_left)(obj_data, pos);
        }
        self
    }
    ///
    /// Sets the top edge of the rectangle to the given *y* coordinate. May
    /// change the height, but will never change the bottom edge of the
    /// rectangle.
    ///
    /// Equivalent to setY().
    ///
    /// **See also:** [`top()`]
    /// [`move_top()`]
    ///
    /// Set the top-left corner of the rectangle to the given *position.* May change the size, but will never change the
    /// bottom-right corner of the rectangle.
    ///
    /// **See also:** [`top_left()`]
    /// [`move_top_left()`]
    ///
    /// Set the top-right corner of the rectangle to the given *position.* May change the size, but will never change the
    /// bottom-left corner of the rectangle.
    ///
    /// **See also:** [`top_right()`]
    /// [`move_top_right()`]
    pub fn set_top(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_top)(obj_data, pos);
        }
        self
    }
    ///
    /// Sets the right edge of the rectangle to the given *x*
    /// coordinate. May change the width, but will never change the left
    /// edge of the rectangle.
    ///
    /// **See also:** [`right()`]
    /// [`move_right()`]
    pub fn set_right(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_right)(obj_data, pos);
        }
        self
    }
    ///
    /// Sets the bottom edge of the rectangle to the given *y*
    /// coordinate. May change the height, but will never change the top
    /// edge of the rectangle.
    ///
    /// **See also:** [`bottom()`]
    /// [`move_bottom()`]
    ///
    /// Set the bottom-right corner of the rectangle to the given *position.* May change the size, but will never change the
    /// top-left corner of the rectangle.
    ///
    /// **See also:** [`bottom_right()`]
    /// [`move_bottom_right()`]
    ///
    /// Set the bottom-left corner of the rectangle to the given *position.* May change the size, but will never change the
    /// top-right corner of the rectangle.
    ///
    /// **See also:** [`bottom_left()`]
    /// [`move_bottom_left()`]
    pub fn set_bottom(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_bottom)(obj_data, pos);
        }
        self
    }
    ///
    /// Sets the left edge of the rectangle to the given *x*
    /// coordinate. May change the width, but will never change the right
    /// edge of the rectangle.
    ///
    /// Equivalent to setLeft().
    ///
    /// **See also:** [`x()`]
    /// [`set_y()`]
    /// [`set_top_left()`]
    pub fn set_x(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_x)(obj_data, pos);
        }
        self
    }
    ///
    /// Sets the top edge of the rectangle to the given *y*
    /// coordinate. May change the height, but will never change the
    /// bottom edge of the rectangle.
    ///
    /// Equivalent to setTop().
    ///
    /// **See also:** [`y()`]
    /// [`set_x()`]
    /// [`set_top_left()`]
    pub fn set_y(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_y)(obj_data, pos);
        }
        self
    }
    ///
    /// Returns the position of the rectangle's top-left corner.
    ///
    /// **See also:** [`set_top_left()`]
    /// [`top()`]
    /// [`left()`]
    pub fn top_left(&self) -> PointF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).top_left)(obj_data);
            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
        }
    }
    ///
    /// Returns the position of the rectangle's bottom-right corner.
    ///
    /// **See also:** [`set_bottom_right()`]
    /// [`bottom()`]
    /// [`right()`]
    pub fn bottom_right(&self) -> PointF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).bottom_right)(obj_data);
            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
        }
    }
    ///
    /// Returns the position of the rectangle's top-right corner.
    ///
    /// **See also:** [`set_top_right()`]
    /// [`top()`]
    /// [`right()`]
    pub fn top_right(&self) -> PointF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).top_right)(obj_data);
            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
        }
    }
    ///
    /// Returns the position of the rectangle's bottom-left corner.
    ///
    /// **See also:** [`set_bottom_left()`]
    /// [`bottom()`]
    /// [`left()`]
    pub fn bottom_left(&self) -> PointF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).bottom_left)(obj_data);
            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
        }
    }
    ///
    /// Returns the center point of the rectangle.
    ///
    /// **See also:** [`move_center()`]
    pub fn center(&self) -> PointF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).center)(obj_data);
            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
        }
    }
    ///
    /// Set the top-left corner of the rectangle to the given *position.* May change the size, but will never change the
    /// bottom-right corner of the rectangle.
    ///
    /// **See also:** [`top_left()`]
    /// [`move_top_left()`]
    pub fn set_top_left<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_top_left)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Set the bottom-right corner of the rectangle to the given *position.* May change the size, but will never change the
    /// top-left corner of the rectangle.
    ///
    /// **See also:** [`bottom_right()`]
    /// [`move_bottom_right()`]
    pub fn set_bottom_right<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_bottom_right)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Set the top-right corner of the rectangle to the given *position.* May change the size, but will never change the
    /// bottom-left corner of the rectangle.
    ///
    /// **See also:** [`top_right()`]
    /// [`move_top_right()`]
    pub fn set_top_right<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_top_right)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Set the bottom-left corner of the rectangle to the given *position.* May change the size, but will never change the
    /// top-right corner of the rectangle.
    ///
    /// **See also:** [`bottom_left()`]
    /// [`move_bottom_left()`]
    pub fn set_bottom_left<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_bottom_left)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Moves the rectangle horizontally, leaving the rectangle's left
    /// edge at the given *x* coordinate. The rectangle's size is
    /// unchanged.
    ///
    /// **See also:** [`left()`]
    /// [`set_left()`]
    /// [`move_right()`]
    pub fn move_left(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_left)(obj_data, pos);
        }
        self
    }
    ///
    /// Moves the rectangle vertically, leaving the rectangle's top line
    /// at the given *y* coordinate. The rectangle's size is unchanged.
    ///
    /// **See also:** [`top()`]
    /// [`set_top()`]
    /// [`move_bottom()`]
    ///
    /// Moves the rectangle, leaving the top-left corner at the given *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_left()`]
    /// [`move_top()`]
    /// [`move_left()`]
    ///
    /// Moves the rectangle, leaving the top-right corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_right()`]
    /// [`move_top()`]
    /// [`move_right()`]
    pub fn move_top(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_top)(obj_data, pos);
        }
        self
    }
    ///
    /// Moves the rectangle horizontally, leaving the rectangle's right
    /// edge at the given *x* coordinate. The rectangle's size is
    /// unchanged.
    ///
    /// **See also:** [`right()`]
    /// [`set_right()`]
    /// [`move_left()`]
    pub fn move_right(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_right)(obj_data, pos);
        }
        self
    }
    ///
    /// Moves the rectangle vertically, leaving the rectangle's bottom
    /// edge at the given *y* coordinate. The rectangle's size is
    /// unchanged.
    ///
    /// **See also:** [`bottom()`]
    /// [`set_bottom()`]
    /// [`move_top()`]
    ///
    /// Moves the rectangle, leaving the bottom-right corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_bottom_right()`]
    /// [`move_bottom()`]
    /// [`move_right()`]
    ///
    /// Moves the rectangle, leaving the bottom-left corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_bottom_left()`]
    /// [`move_bottom()`]
    /// [`move_left()`]
    pub fn move_bottom(&self, pos: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_bottom)(obj_data, pos);
        }
        self
    }
    ///
    /// Moves the rectangle, leaving the top-left corner at the given *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_left()`]
    /// [`move_top()`]
    /// [`move_left()`]
    pub fn move_top_left<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_top_left)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Moves the rectangle, leaving the bottom-right corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_bottom_right()`]
    /// [`move_bottom()`]
    /// [`move_right()`]
    pub fn move_bottom_right<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_bottom_right)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Moves the rectangle, leaving the top-right corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_right()`]
    /// [`move_top()`]
    /// [`move_right()`]
    pub fn move_top_right<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_top_right)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Moves the rectangle, leaving the bottom-left corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_bottom_left()`]
    /// [`move_bottom()`]
    /// [`move_left()`]
    pub fn move_bottom_left<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_bottom_left)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Moves the rectangle, leaving the center point at the given *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`center()`]
    pub fn move_center<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_center)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Moves the rectangle vertically, leaving the rectangle's top line
    /// at the given *y* coordinate. The rectangle's size is unchanged.
    ///
    /// **See also:** [`top()`]
    /// [`set_top()`]
    /// [`move_bottom()`]
    ///
    /// Moves the rectangle, leaving the top-left corner at the given *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_left()`]
    /// [`move_top()`]
    /// [`move_left()`]
    ///
    /// Moves the rectangle, leaving the top-right corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_right()`]
    /// [`move_top()`]
    /// [`move_right()`]
    ///
    /// Moves the rectangle, leaving the top-left corner at the given
    /// position ( *x,* *y).* The rectangle's size is unchanged.
    ///
    /// **See also:** [`translate()`]
    /// [`move_top_left()`]
    ///
    /// **Overloads**
    /// Moves the rectangle, leaving the top-left corner at the given *position.*
    pub fn move_to(&self, x: f32, y: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_to)(obj_data, x, y);
        }
        self
    }
    ///
    /// Moves the rectangle vertically, leaving the rectangle's top line
    /// at the given *y* coordinate. The rectangle's size is unchanged.
    ///
    /// **See also:** [`top()`]
    /// [`set_top()`]
    /// [`move_bottom()`]
    ///
    /// Moves the rectangle, leaving the top-left corner at the given *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_left()`]
    /// [`move_top()`]
    /// [`move_left()`]
    ///
    /// Moves the rectangle, leaving the top-right corner at the given
    /// *position.* The rectangle's size is unchanged.
    ///
    /// **See also:** [`set_top_right()`]
    /// [`move_top()`]
    /// [`move_right()`]
    ///
    /// Moves the rectangle, leaving the top-left corner at the given
    /// position ( *x,* *y).* The rectangle's size is unchanged.
    ///
    /// **See also:** [`translate()`]
    /// [`move_top_left()`]
    ///
    /// **Overloads**
    /// Moves the rectangle, leaving the top-left corner at the given *position.*
    pub fn move_to_2<P: PointFTrait<'a>>(&self, p: &P) -> &Self {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).move_to_2)(obj_data, obj_p_1);
        }
        self
    }
    ///
    /// Sets the coordinates of the rectangle's top-left corner to ( *x,*
    /// *y),* and its size to the given *width* and *height.*
    ///
    /// **See also:** [`get_rect()`]
    /// [`set_coords()`]
    pub fn set_rect(&self, x: f32, y: f32, w: f32, h: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_rect)(obj_data, x, y, w, h);
        }
        self
    }
    ///
    /// Sets the coordinates of the rectangle's top-left corner to ( *x1,*
    /// *y1),* and the coordinates of its bottom-right corner to ( *x2,*
    /// *y2).*
    ///
    /// **See also:** [`get_coords()`]
    /// [`set_rect()`]
    pub fn set_coords(&self, x1: f32, y1: f32, x2: f32, y2: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_coords)(obj_data, x1, y1, x2, y2);
        }
        self
    }
    ///
    /// Returns a new rectangle with *dx1,* *dy1,* *dx2* and *dy2*
    /// added respectively to the existing coordinates of this rectangle.
    ///
    /// **See also:** [`adjust()`]
    ///
    /// Adds *dx1,* *dy1,* *dx2* and *dy2* respectively to the
    /// existing coordinates of the rectangle.
    ///
    /// **See also:** [`adjusted()`]
    /// [`set_rect()`]
    pub fn adjust(&self, x1: f32, y1: f32, x2: f32, y2: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).adjust)(obj_data, x1, y1, x2, y2);
        }
        self
    }
    ///
    /// Returns a new rectangle with *dx1,* *dy1,* *dx2* and *dy2*
    /// added respectively to the existing coordinates of this rectangle.
    ///
    /// **See also:** [`adjust()`]
    pub fn adjusted(&self, x1: f32, y1: f32, x2: f32, y2: f32) -> RectF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).adjusted)(obj_data, x1, y1, x2, y2);
            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
        }
    }
    ///
    /// Returns the size of the rectangle.
    ///
    /// **See also:** [`set_size()`]
    /// [`width()`]
    /// [`height()`]
    pub fn size(&self) -> SizeF {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).size)(obj_data);
            let t = ret_val;
            let ret_val;
            if t.host_data != ::std::ptr::null() {
                ret_val = SizeF::new_from_rc(t);
            } else {
                ret_val = SizeF::new_from_owned(t);
            }
            ret_val
        }
    }
    ///
    /// Returns the width of the rectangle.
    ///
    /// **See also:** [`set_width()`]
    /// [`height()`]
    /// [`size()`]
    pub fn width(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).width)(obj_data);
            ret_val
        }
    }
    ///
    /// Returns the height of the rectangle.
    ///
    /// **See also:** [`set_height()`]
    /// [`width()`]
    /// [`size()`]
    pub fn height(&self) -> f32 {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).height)(obj_data);
            ret_val
        }
    }
    ///
    /// Sets the width of the rectangle to the given *width.* The right
    /// edge is changed, but not the left one.
    ///
    /// **See also:** [`width()`]
    /// [`set_size()`]
    pub fn set_width(&self, w: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_width)(obj_data, w);
        }
        self
    }
    ///
    /// Sets the height of the rectangle to the given *height.* The bottom
    /// edge is changed, but not the top one.
    ///
    /// **See also:** [`height()`]
    /// [`set_size()`]
    pub fn set_height(&self, h: f32) -> &Self {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_height)(obj_data, h);
        }
        self
    }
    ///
    /// Sets the size of the rectangle to the given *size.* The top-left
    /// corner is not moved.
    ///
    /// **See also:** [`size()`]
    /// [`set_width()`]
    /// [`set_height()`]
    pub fn set_size<S: SizeFTrait<'a>>(&self, s: &S) -> &Self {
        let (obj_s_1, _funcs) = s.get_size_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            ((*funcs).set_size)(obj_data, obj_s_1);
        }
        self
    }
    ///
    /// Returns `true` if the given *point* is inside or on the edge of the
    /// rectangle; otherwise returns `false.`
    ///
    /// **See also:** [`intersects()`]
    ///
    /// **Overloads**
    /// Returns `true` if the point ( *x,* *y)* is inside or on the edge of
    /// the rectangle; otherwise returns `false.`
    ///
    /// **Overloads**
    /// Returns `true` if the given *rectangle* is inside this rectangle;
    /// otherwise returns `false.`
    pub fn contains<R: RectFTrait<'a>>(&self, r: &R) -> bool {
        let (obj_r_1, _funcs) = r.get_rect_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).contains)(obj_data, obj_r_1);
            ret_val
        }
    }
    ///
    /// Returns `true` if the given *point* is inside or on the edge of the
    /// rectangle; otherwise returns `false.`
    ///
    /// **See also:** [`intersects()`]
    ///
    /// **Overloads**
    /// Returns `true` if the point ( *x,* *y)* is inside or on the edge of
    /// the rectangle; otherwise returns `false.`
    ///
    /// **Overloads**
    /// Returns `true` if the given *rectangle* is inside this rectangle;
    /// otherwise returns `false.`
    pub fn contains_2<P: PointFTrait<'a>>(&self, p: &P) -> bool {
        let (obj_p_1, _funcs) = p.get_point_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).contains_2)(obj_data, obj_p_1);
            ret_val
        }
    }
    ///
    /// Returns `true` if the given *point* is inside or on the edge of the
    /// rectangle; otherwise returns `false.`
    ///
    /// **See also:** [`intersects()`]
    ///
    /// **Overloads**
    /// Returns `true` if the point ( *x,* *y)* is inside or on the edge of
    /// the rectangle; otherwise returns `false.`
    ///
    /// **Overloads**
    /// Returns `true` if the given *rectangle* is inside this rectangle;
    /// otherwise returns `false.`
    pub fn contains_3(&self, x: f32, y: f32) -> bool {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).contains_3)(obj_data, x, y);
            ret_val
        }
    }
    ///
    /// Returns the bounding rectangle of this rectangle and the given *rectangle.*
    ///
    /// ![qrect-unite.png](qrect-unite.png)
    ///
    /// **See also:** [`intersected()`]
    pub fn united<R: RectFTrait<'a>>(&self, other: &R) -> RectF {
        let (obj_other_1, _funcs) = other.get_rect_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).united)(obj_data, obj_other_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
        }
    }
    ///
    /// Returns the intersection of this rectangle and the given *rectangle.* Note that `r.intersected(s)` is equivalent to `r & s` .
    ///
    /// ![qrect-intersect.png](qrect-intersect.png)
    ///
    /// **See also:** [`intersects()`]
    /// [`united()`]
    /// [`operator()`]
    pub fn intersected<R: RectFTrait<'a>>(&self, other: &R) -> RectF {
        let (obj_other_1, _funcs) = other.get_rect_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).intersected)(obj_data, obj_other_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
        }
    }
    ///
    /// Returns `true` if this rectangle intersects with the given *rectangle* (i.e. there is a non-empty area of overlap between
    /// them), otherwise returns `false.`
    ///
    /// The intersection rectangle can be retrieved using the intersected()
    /// function.
    ///
    /// **See also:** [`contains()`]
    pub fn intersects<R: RectFTrait<'a>>(&self, r: &R) -> bool {
        let (obj_r_1, _funcs) = r.get_rect_f_obj_funcs();

        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).intersects)(obj_data, obj_r_1);
            ret_val
        }
    }
    ///
    /// Returns a rectangle grown by the *margins.*
    ///
    /// **See also:** [`operator()`]
    /// [`margins_removed()`]
    /// [`operator()`]
    ///
    /// Removes the *margins* from the rectangle, shrinking it.
    ///
    /// **See also:** [`margins_added()`]
    /// [`operator()`]
    ///
    /// Returns a QRect based on the values of this rectangle. Note that the
    /// coordinates in the returned rectangle are rounded to the nearest integer.
    ///
    /// **See also:** [`q_rect_f()`]
    /// [`to_aligned_rect()`]
    pub fn to_rect(&self) -> Rect {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).to_rect)(obj_data);
            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
        }
    }
    ///
    /// Returns a QRect based on the values of this rectangle that is the
    /// smallest possible integer rectangle that completely contains this
    /// rectangle.
    ///
    /// **See also:** [`to_rect()`]
    pub fn to_aligned_rect(&self) -> Rect {
        let (obj_data, funcs) = self.get_rect_f_obj_funcs();
        unsafe {
            let ret_val = ((*funcs).to_aligned_rect)(obj_data);
            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
        }
    }
}
pub trait RectFTrait<'a> {
    #[inline]
    #[doc(hidden)]
    fn get_rect_f_obj_funcs(&self) -> (*const RUBase, *const RURectFFuncs);
}

impl<'a> RectFTrait<'a> for RectF<'a> {
    #[doc(hidden)]
    fn get_rect_f_obj_funcs(&self) -> (*const RUBase, *const RURectFFuncs) {
        let obj = self.data.get().unwrap();
        unsafe { (obj, (*self.all_funcs).rect_f_funcs) }
    }
}