pub fn size(&self) -> Size {
        let (obj_data, funcs) = self.get_widget_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 = Size::new_from_rc(t);
            } else {
                ret_val = Size::new_from_owned(t);
            }
            ret_val
        }
    }
///
/// If the widget is visible when it is being resized, it receives a resize event
/// (resizeEvent()) immediately. If the widget is not currently
/// visible, it is guaranteed to receive an event before it is shown.
///
/// The size is adjusted if it lies outside the range defined by
/// minimumSize() and maximumSize().
///
/// By default, this property contains a value that depends on the user's
/// platform and screen geometry.
///
/// **Warning**: Calling resize() or setGeometry() inside resizeEvent() can
/// lead to infinite recursion.
///
/// **Note**: Setting the size to `QSize(0, 0)` will cause the widget to not
/// appear on screen. This also applies to windows.
///
/// **See also:** pos
/// geometry
/// minimumSize
/// maximumSize
/// [`resize_event()`]
/// [`adjust_size()`]
///
/// When the user resizes the window, the size will move in steps of
/// sizeIncrement().width() pixels horizontally and
/// sizeIncrement.height() pixels vertically, with baseSize() as the
/// basis. Preferred widget sizes are for non-negative integers *i*
/// and *j:*
///
/// Note that while you can set the size increment for all widgets, it
/// only affects windows.
///
/// By default, this property contains a size with zero width and height.
///
/// **Warning**: The size increment has no effect under Windows, and may
/// be disregarded by the window manager on X11.
///
/// **See also:** size
/// minimumSize
/// maximumSize
///
/// If the value of this property is an invalid size, no size is
/// recommended.
///
/// The default implementation of sizeHint() returns an invalid size
/// if there is no layout for this widget, and returns the layout's
/// preferred size otherwise.
///
/// **See also:** [`Size::is_valid`]
/// [`minimum_size_hint()`]
/// [`size_policy()`]
/// [`set_minimum_size()`]
/// [`update_geometry()`]
///
/// If there is a QLayout that manages this widget's children, the
/// size policy specified by that layout is used. If there is no such
/// QLayout, the result of this function is used.
///
/// The default policy is Preferred/Preferred, which means that the
/// widget can be freely resized, but prefers to be the size
/// sizeHint() returns. Button-like widgets set the size policy to
/// specify that they may stretch horizontally, but are fixed
/// vertically. The same applies to lineedit controls (such as
/// QLineEdit, QSpinBox or an editable QComboBox) and other
/// horizontally orientated widgets (such as QProgressBar).
/// QToolButton's are normally square, so they allow growth in both
/// directions. Widgets that support different directions (such as
/// QSlider, QScrollBar or QHeader) specify stretching in the
/// respective direction only. Widgets that can provide scroll bars
/// (usually subclasses of QScrollArea) tend to specify that they can
/// use additional space, and that they can make do with less than
/// sizeHint().
///
/// **See also:** [`size_hint()`]
/// [`Layout`]
/// [`SizePolicy`]
/// [`update_geometry()`]
If the widget is visible when it is being resized, it receives a resize event
(resizeEvent()) immediately. If the widget is not currently
visible, it is guaranteed to receive an event before it is shown.

The size is adjusted if it lies outside the range defined by
minimumSize() and maximumSize().

By default, this property contains a value that depends on the user's
platform and screen geometry.

Warning**: Calling resize() or setGeometry() inside resizeEvent() can
lead to infinite recursion.

Note**: Setting the size to `QSize(0, 0)` will cause the widget to not
appear on screen. This also applies to windows.

See also:** pos
geometry
minimumSize
maximumSize
[`resize_event()`]
[`adjust_size()`]

When the user resizes the window, the size will move in steps of
sizeIncrement().width() pixels horizontally and
sizeIncrement.height() pixels vertically, with baseSize() as the
basis. Preferred widget sizes are for non-negative integers *i
and *j.

Note that while you can set the size increment for all widgets, it
only affects windows.

By default, this property contains a size with zero width and height.

Warning**: The size increment has no effect under Windows, and may
be disregarded by the window manager on X11.

See also:** size
minimumSize
maximumSize

If the value of this property is an invalid size, no size is
recommended.

The default implementation of sizeHint() returns an invalid size
if there is no layout for this widget, and returns the layout's
preferred size otherwise.



If there is a QLayout that manages this widget's children, the
size policy specified by that layout is used. If there is no such
QLayout, the result of this function is used.

The default policy is Preferred/Preferred, which means that the
widget can be freely resized, but prefers to be the size
sizeHint() returns. Button-like widgets set the size policy to
specify that they may stretch horizontally, but are fixed
vertically. The same applies to lineedit controls (such as
QLineEdit, QSpinBox or an editable QComboBox) and other
horizontally orientated widgets (such as QProgressBar).
QToolButton's are normally square, so they allow growth in both
directions. Widgets that support different directions (such as
QSlider, QScrollBar or QHeader) specify stretching in the
respective direction only. Widgets that can provide scroll bars
(usually subclasses of QScrollArea) tend to specify that they can
use additional space, and that they can make do with less than
sizeHint().


If the widget is visible when it is being resized it receives a resize event ( resizeEvent () ) immediately . If the widget is not currently visible it is guaranteed to receive an event before it is shown . The size is adjusted if it lies outside the range defined by minimumSize () and maximumSize () . By default this property contains a value that depends on the user ' s platform and screen geometry . Warning ** : Calling resize () or setGeometry () inside resizeEvent () can lead to infinite recursion . Note ** : Setting the size to ` QSize ( 0 0 ) ` will cause the widget to not appear on screen . This also applies to windows . See also : ** pos geometry minimumSize maximumSize [ ` resize_event () ` ] [ ` adjust_size () ` ] When the user resizes the window the size will move in steps of sizeIncrement () . width () pixels horizontally and sizeIncrement . height () pixels vertically with baseSize () as the basis . Preferred widget sizes are for non - negative integers * i and * j . Note that while you can set the size increment for all widgets it only affects windows . By default this property contains a size with zero width and height . Warning ** : The size increment has no effect under Windows and may be disregarded by the window manager on X11 . See also : ** size minimumSize maximumSize If the value of this property is an invalid size no size is recommended . The default implementation of sizeHint () returns an invalid size if there is no layout for this widget and returns the layout ' s preferred size otherwise . If there is a QLayout that manages this widget ' s children the size policy specified by that layout is used . If there is no such QLayout the result of this function is used . The default policy is Preferred / Preferred which means that the widget can be freely resized but prefers to be the size sizeHint () returns . Button - like widgets set the size policy to specify that they may stretch horizontally but are fixed vertically . The same applies to lineedit controls ( such as QLineEdit QSpinBox or an editable QComboBox ) and other horizontally orientated widgets ( such as QProgressBar ) . QToolButton ' s are normally square so they allow growth in both directions . Widgets that support different directions ( such as QSlider QScrollBar or QHeader ) specify stretching in the respective direction only . Widgets that can provide scroll bars ( usually subclasses of QScrollArea ) tend to specify that they can use additional space and that they can make do with less than sizeHint () .
pub fn size(&self) -> Size {
        let (obj_data, funcs) = self.get_widget_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 = Size::new_from_rc(t);
            } else {
                ret_val = Size::new_from_owned(t);
            }
            ret_val
        }
    }
pub fn size ( & self ) -> Size { let ( obj_data , funcs ) = self . get_widget_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 = Size :: new_from_rc ( t ) ; } else { ret_val = Size :: new_from_owned ( t ) ; } ret_val } }
If the widget is visible when it is being resized, it receives a resize event
(resizeEvent()) immediately.
If the widget is visible when it is being resized it receives a resize event ( resizeEvent () ) immediately .
&self
&self