pub fn exec() -> i32 {
        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_application)(::std::ptr::null()).all_funcs)
                    .application_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).exec)(obj_data);
            ret_val
        }
    }
///
/// Enters the main event loop and waits until exit() is called, then returns
/// the value that was set to exit() (which is 0 if exit() is called via
/// quit()).
///
/// It is necessary to call this function to start event handling. The main
/// event loop receives events from the window system and dispatches these to
/// the application widgets.
///
/// Generally, no user interaction can take place before calling exec(). As a
/// special case, modal widgets like QMessageBox can be used before calling
/// exec(), because modal widgets call exec() to start a local event loop.
///
/// To make your application perform idle processing, i.e., executing a special
/// function whenever there are no pending events, use a QTimer with 0 timeout.
/// More advanced idle processing schemes can be achieved using processEvents().
///
/// We recommend that you connect clean-up code to the
/// [aboutToQuit()](QCoreApplication::)
/// signal, instead of putting it in your
/// application's `main()` function. This is because, on some platforms the
/// QApplication::exec() call may not return. For example, on the Windows
/// platform, when the user logs off, the system terminates the process after Qt
/// closes all top-level windows. Hence, there is *no guarantee* that the
/// application will have time to exit its event loop and execute code at the
/// end of the `main()` function, after the QApplication::exec() call.
///
/// **See also:** quitOnLastWindowClosed
/// [`CoreApplication::quit`]
/// [`CoreApplication::exit`]
/// [`CoreApplication::process_events`]
/// [`CoreApplication::exec`]
Enters the main event loop and waits until exit() is called, then returns
the value that was set to exit() (which is 0 if exit() is called via
quit()).

It is necessary to call this function to start event handling. The main
event loop receives events from the window system and dispatches these to
the application widgets.

Generally, no user interaction can take place before calling exec(). As a
special case, modal widgets like QMessageBox can be used before calling
exec(), because modal widgets call exec() to start a local event loop.

To make your application perform idle processing, i.e., executing a special
function whenever there are no pending events, use a QTimer with 0 timeout.
More advanced idle processing schemes can be achieved using processEvents().

We recommend that you connect clean-up code to the
[aboutToQuit()](QCoreApplication::)
signal, instead of putting it in your
application's `main()` function. This is because, on some platforms the
QApplication::exec() call may not return. For example, on the Windows
platform, when the user logs off, the system terminates the process after Qt
closes all top-level windows. Hence, there is *no guarantee* that the
application will have time to exit its event loop and execute code at the
end of the `main()` function, after the QApplication::exec() call.


Enters the main event loop and waits until exit () is called then returns the value that was set to exit () ( which is 0 if exit () is called via quit () ) . It is necessary to call this function to start event handling . The main event loop receives events from the window system and dispatches these to the application widgets . Generally no user interaction can take place before calling exec () . As a special case modal widgets like QMessageBox can be used before calling exec () because modal widgets call exec () to start a local event loop . To make your application perform idle processing i . e . executing a special function whenever there are no pending events use a QTimer with 0 timeout . More advanced idle processing schemes can be achieved using processEvents () . We recommend that you connect clean - up code to the [ aboutToQuit () ] ( QCoreApplication :: ) signal instead of putting it in your application ' s ` main () ` function . This is because on some platforms the QApplication :: exec () call may not return . For example on the Windows platform when the user logs off the system terminates the process after Qt closes all top - level windows . Hence there is * no guarantee * that the application will have time to exit its event loop and execute code at the end of the ` main () ` function after the QApplication :: exec () call .
pub fn exec() -> i32 {
        let (obj_data, funcs) = unsafe {
            (
                ::std::ptr::null(),
                (*((*rute_ffi_get()).get_application)(::std::ptr::null()).all_funcs)
                    .application_funcs,
            )
        };
        unsafe {
            let ret_val = ((*funcs).exec)(obj_data);
            ret_val
        }
    }
pub fn exec ( ) -> i32 { let ( obj_data , funcs ) = unsafe { ( :: std :: ptr :: null ( ) , ( * ( ( * rute_ffi_get ( ) ) . get_application ) ( :: std :: ptr :: null ( ) ) . all_funcs ) . application_funcs , ) } ; unsafe { let ret_val = ( ( * funcs ) . exec ) ( obj_data ) ; ret_val } }
Enters the main event loop and waits until exit() is called, then returns
the value that was set to exit() (which is 0 if exit() is called via
quit()).
Enters the main event loop and waits until exit () is called then returns the value that was set to exit () ( which is 0 if exit () is called via quit () ) .