Struct qt_core::QCoreApplication

#[repr(C)]
pub struct QCoreApplication { /* private fields */ }

The QCoreApplication class provides an event loop for Qt applications without UI.

C++ class: QCoreApplication.

C++ documentation:

The QCoreApplication class provides an event loop for Qt applications without UI.

This class is used by non-GUI applications to provide their event loop. For non-GUI application that uses Qt, there should be exactly one QCoreApplication object. For GUI applications, see QGuiApplication. For applications that use the Qt Widgets module, see QApplication.

QCoreApplication contains the main event loop, where all events from the operating system (e.g., timer and network events) and other sources are processed and dispatched. It also handles the application's initialization and finalization, as well as system-wide and application-wide settings.

Implementations

impl QCoreApplication

pub fn init<F: FnOnce(Ptr<QCoreApplication>) -> i32>(f: F) -> !

A convenience function for performing proper initialization and de-initialization of a Qt application.

This function creates a QCoreApplication object with valid argc and argv, calls the passed closure f(app) with the application object and exits the process with the exit code returned by the closure. The closure should perform the initialization of the application and either return immediately or call QCoreApplication::exec() and return its return value:

use qt_core::QCoreApplication;

fn main() {
    QCoreApplication::init(|app| {
        unsafe {
            // initialization goes here
            QCoreApplication::exec()
        }
    })
}

impl QCoreApplication

pub fn slot_quit(&self) -> Receiver<()>

Tells the application to exit with return code 0 (success). Equivalent to calling QCoreApplication::exit(0).

Returns a built-in Qt slot QCoreApplication::quit that can be passed to qt_core::Signal::connect.

C++ documentation:

Tells the application to exit with return code 0 (success). Equivalent to calling QCoreApplication::exit(0).

It's common to connect the QGuiApplication::lastWindowClosed() signal to quit(), and you also often connect e.g. QAbstractButton::clicked() or signals in QAction, QMenu, or QMenuBar to it.

Example:

QPushButton *quitButton = new QPushButton(“Quit”);
connect(quitButton, SIGNAL(clicked()), &app, SLOT(quit()));

See also exit(), aboutToQuit(), and QGuiApplication::lastWindowClosed().

pub fn about_to_quit(&self) -> Signal<()>

This signal is emitted when the application is about to quit the main event loop, e.g. when the event loop level drops to zero. This may happen either after a call to quit() from inside the application or when the user shuts down the entire desktop session.

Returns a built-in Qt signal QCoreApplication::aboutToQuit that can be passed to qt_core::Signal::connect.

C++ documentation:

This signal is emitted when the application is about to quit the main event loop, e.g. when the event loop level drops to zero. This may happen either after a call to quit() from inside the application or when the user shuts down the entire desktop session.

The signal is particularly useful if your application has to do some last-second cleanup. Note that no user interaction is possible in this state.

Note: This is a private signal. It can be used in signal connections but cannot be emitted by the user.

See also quit().

pub fn organization_name_changed(&self) -> Signal<()>

This property holds the name of the organization that wrote this application

Returns a built-in Qt signal QCoreApplication::organizationNameChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

This property holds the name of the organization that wrote this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

On Mac, QSettings uses organizationDomain() as the organization if it's not an empty string; otherwise it uses organizationName(). On all other platforms, QSettings uses organizationName() as the organization.

Access functions:

QString	organizationName()
void	setOrganizationName(const QString &orgName)

Notifier signal:

void	organizationNameChanged()

See also organizationDomain and applicationName.

pub fn organization_domain_changed(&self) -> Signal<()>

This property holds the Internet domain of the organization that wrote this application

Returns a built-in Qt signal QCoreApplication::organizationDomainChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

This property holds the Internet domain of the organization that wrote this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

On Mac, QSettings uses organizationDomain() as the organization if it's not an empty string; otherwise it uses organizationName(). On all other platforms, QSettings uses organizationName() as the organization.

Access functions:

QString	organizationDomain()
void	setOrganizationDomain(const QString &orgDomain)

Notifier signal:

void	organizationDomainChanged()

See also organizationName, applicationName, and applicationVersion.

pub fn application_name_changed(&self) -> Signal<()>

This property holds the name of this application

Returns a built-in Qt signal QCoreApplication::applicationNameChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

This property holds the name of this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

If not set, the application name defaults to the executable name (since 5.0).

Access functions:

QString	applicationName()
void	setApplicationName(const QString &application)

Notifier signal:

void	applicationNameChanged()

See also organizationName, organizationDomain, applicationVersion, and applicationFilePath().

pub fn application_version_changed(&self) -> Signal<()>

This property holds the version of this application

Returns a built-in Qt signal QCoreApplication::applicationVersionChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

This property holds the version of this application

If not set, the application version defaults to a platform-specific value determined from the main application executable or package (since Qt 5.9):

Platform	Source
Windows (classic desktop)	PRODUCTVERSION parameter of the VERSIONINFO resource
Universal Windows Platform	version attribute of the application package manifest
macOS, iOS, tvOS, watchOS	CFBundleVersion property of the information property list
Android	android:versionName property of the AndroidManifest.xml manifest element

On other platforms, the default is the empty string.

This property was introduced in Qt 4.4.

Access functions:

QString	applicationVersion()
void	setApplicationVersion(const QString &version)

Notifier signal:

void	applicationVersionChanged()

See also applicationName, organizationName, and organizationDomain.

pub unsafe fn add_library_path(arg1: impl CastInto<Ref<QString>>)

Prepends path to the beginning of the library path list, ensuring that it is searched for libraries first. If path is empty or already in the path list, the path list is not changed.

Calls C++ function: static void QCoreApplication::addLibraryPath(const QString& arg1).

C++ documentation:

Prepends path to the beginning of the library path list, ensuring that it is searched for libraries first. If path is empty or already in the path list, the path list is not changed.

The default path list consists of a single entry, the installation directory for plugins. The default installation directory for plugins is INSTALL/plugins, where INSTALL is the directory where Qt was installed.

The library paths are reset to the default when an instance of QCoreApplication is destructed.

See also removeLibraryPath(), libraryPaths(), and setLibraryPaths().

pub unsafe fn application_dir_path() -> CppBox<QString>

Returns the directory that contains the application executable.

Calls C++ function: static QString QCoreApplication::applicationDirPath().

C++ documentation:

Returns the directory that contains the application executable.

For example, if you have installed Qt in the C:\Qt directory, and you run the regexp example, this function will return "C:/Qt/examples/tools/regexp".

On macOS and iOS this will point to the directory actually containing the executable, which may be inside an application bundle (if the application is bundled).

Warning: On Linux, this function will try to get the path from the /proc file system. If that fails, it assumes that argv[0] contains the absolute file name of the executable. The function also assumes that the current directory has not been changed by the application.

See also applicationFilePath().

pub unsafe fn application_file_path() -> CppBox<QString>

Returns the file path of the application executable.

Calls C++ function: static QString QCoreApplication::applicationFilePath().

C++ documentation:

Returns the file path of the application executable.

For example, if you have installed Qt in the /usr/local/qt directory, and you run the regexp example, this function will return "/usr/local/qt/examples/tools/regexp/regexp".

Warning: On Linux, this function will try to get the path from the /proc file system. If that fails, it assumes that argv[0] contains the absolute file name of the executable. The function also assumes that the current directory has not been changed by the application.

See also applicationDirPath().

pub unsafe fn application_name() -> CppBox<QString>

This property holds the name of this application

Calls C++ function: static QString QCoreApplication::applicationName().

C++ documentation:

This property holds the name of this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

If not set, the application name defaults to the executable name (since 5.0).

Access functions:

QString	applicationName()
void	setApplicationName(const QString &application)

See also organizationName, organizationDomain, applicationVersion, and applicationFilePath().

pub unsafe fn application_pid() -> i64

Returns the current process ID for the application.

Calls C++ function: static qint64 QCoreApplication::applicationPid().

C++ documentation:

Returns the current process ID for the application.

This function was introduced in Qt 4.4.

pub unsafe fn application_version() -> CppBox<QString>

This property holds the version of this application

Calls C++ function: static QString QCoreApplication::applicationVersion().

C++ documentation:

This property holds the version of this application

If not set, the application version defaults to a platform-specific value determined from the main application executable or package (since Qt 5.9):

Platform	Source
Windows (classic desktop)	PRODUCTVERSION parameter of the VERSIONINFO resource
Universal Windows Platform	version attribute of the application package manifest
macOS, iOS, tvOS, watchOS	CFBundleVersion property of the information property list
Android	android:versionName property of the AndroidManifest.xml manifest element

On other platforms, the default is the empty string.

This property was introduced in Qt 4.4.

Access functions:

QString	applicationVersion()
void	setApplicationVersion(const QString &version)

See also applicationName, organizationName, and organizationDomain.

pub unsafe fn arguments() -> CppBox<QStringList>

Returns the list of command-line arguments.

Calls C++ function: static QStringList QCoreApplication::arguments().

C++ documentation:

Returns the list of command-line arguments.

Usually arguments().at(0) is the program name, arguments().at(1) is the first argument, and arguments().last() is the last argument. See the note below about Windows.

Calling this function is slow - you should store the result in a variable when parsing the command line.

Warning: On Unix, this list is built from the argc and argv parameters passed to the constructor in the main() function. The string-data in argv is interpreted using QString::fromLocal8Bit(); hence it is not possible to pass, for example, Japanese command line arguments on a system that runs in a Latin1 locale. Most modern Unix systems do not have this limitation, as they are Unicode-based.

On Windows, the list is built from the argc and argv parameters only if modified argv/argc parameters are passed to the constructor. In that case, encoding problems might occur.

Otherwise, the arguments() are constructed from the return value of GetCommandLine(). As a result of this, the string given by arguments().at(0) might not be the program name on Windows, depending on how the application was started.

This function was introduced in Qt 4.1.

See also applicationFilePath() and QCommandLineParser.

pub unsafe fn closing_down() -> bool

Returns true if the application objects are being destroyed; otherwise returns false.

Calls C++ function: static bool QCoreApplication::closingDown().

C++ documentation:

Returns true if the application objects are being destroyed; otherwise returns false.

See also startingUp().

pub unsafe fn event_dispatcher() -> QPtr<QAbstractEventDispatcher>

Returns a pointer to the event dispatcher object for the main thread. If no event dispatcher exists for the thread, this function returns 0.

Calls C++ function: static QAbstractEventDispatcher* QCoreApplication::eventDispatcher().

C++ documentation:

Returns a pointer to the event dispatcher object for the main thread. If no event dispatcher exists for the thread, this function returns 0.

See also setEventDispatcher().

pub unsafe fn exec() -> c_int

Enters the main event loop and waits until exit() is called. Returns the value that was passed to exit() (which is 0 if exit() is called via quit()).

Calls C++ function: static int QCoreApplication::exec().

C++ documentation:

Enters the main event loop and waits until exit() is called. Returns the value that was passed 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.

To make your application perform idle processing (by 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() signal, instead of putting it in your application's main() function because on some platforms the exec() call may not return. For example, on Windows 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 exec() call.

See also quit(), exit(), processEvents(), and QApplication::exec().

pub unsafe fn exit_1a(retcode: c_int)

Tells the application to exit with a return code.

Calls C++ function: static void QCoreApplication::exit(int retcode = …).

C++ documentation:

Tells the application to exit with a return code.

After this function has been called, the application leaves the main event loop and returns from the call to exec(). The exec() function returns returnCode. If the event loop is not running, this function does nothing.

By convention, a returnCode of 0 means success, and any non-zero value indicates an error.

Note that unlike the C library function of the same name, this function does return to the caller -- it is event processing that stops.

See also quit() and exec().

pub unsafe fn exit_0a()

Tells the application to exit with a return code.

Calls C++ function: static void QCoreApplication::exit().

C++ documentation:

Tells the application to exit with a return code.

After this function has been called, the application leaves the main event loop and returns from the call to exec(). The exec() function returns returnCode. If the event loop is not running, this function does nothing.

By convention, a returnCode of 0 means success, and any non-zero value indicates an error.

Note that unlike the C library function of the same name, this function does return to the caller -- it is event processing that stops.

See also quit() and exec().

pub unsafe fn flush()

This function is equivalent to calling QCoreApplication::eventDispatcher()->flush(), which also is deprecated, see QAbstractEventDispatcher::flush(). Use sendPostedEvents() and processEvents() for more fine-grained control of the event loop instead.

Calls C++ function: static void QCoreApplication::flush().

C++ documentation:

This function is equivalent to calling QCoreApplication::eventDispatcher()->flush(), which also is deprecated, see QAbstractEventDispatcher::flush(). Use sendPostedEvents() and processEvents() for more fine-grained control of the event loop instead.

Historically this functions was used to flush the platform-specific native event queues.

See also sendPostedEvents(), processEvents(), and QAbstractEventDispatcher::flush().

pub unsafe fn has_pending_events() -> bool

This function returns true if there are pending events; otherwise returns false. Pending events can be either from the window system or posted events using postEvent().

Calls C++ function: static bool QCoreApplication::hasPendingEvents().

C++ documentation:

This function returns true if there are pending events; otherwise returns false. Pending events can be either from the window system or posted events using postEvent().

Note: this function is not thread-safe. It may only be called in the main thread and only if there are no other threads running in the application (including threads Qt starts for its own purposes).

See also QAbstractEventDispatcher::hasPendingEvents().

pub unsafe fn install_native_event_filter( &self, filter_obj: impl CastInto<Ptr<QAbstractNativeEventFilter>> )

Installs an event filter filterObj for all native events received by the application in the main thread.

Calls C++ function: void QCoreApplication::installNativeEventFilter(QAbstractNativeEventFilter* filterObj).

C++ documentation:

Installs an event filter filterObj for all native events received by the application in the main thread.

The event filter filterObj receives events via its nativeEventFilter() function, which is called for all native events received in the main thread.

The QAbstractNativeEventFilter::nativeEventFilter() function should return true if the event should be filtered, i.e. stopped. It should return false to allow normal Qt processing to continue: the native event can then be translated into a QEvent and handled by the standard Qt event filtering, e.g. QObject::installEventFilter().

If multiple event filters are installed, the filter that was installed last is activated first.

Note: The filter function set here receives native messages, i.e. MSG or XCB event structs.

Note: Native event filters will be disabled in the application when the Qt::AA_PluginApplication attribute is set.

For maximum portability, you should always try to use QEvent and QObject::installEventFilter() whenever possible.

This function was introduced in Qt 5.0.

See also QObject::installEventFilter().

pub unsafe fn install_translator( message_file: impl CastInto<Ptr<QTranslator>> ) -> bool

Adds the translation file translationFile to the list of translation files to be used for translations.

Calls C++ function: static bool QCoreApplication::installTranslator(QTranslator* messageFile).

C++ documentation:

Adds the translation file translationFile to the list of translation files to be used for translations.

Multiple translation files can be installed. Translations are searched for in the reverse order in which they were installed, so the most recently installed translation file is searched first and the first translation file installed is searched last. The search stops as soon as a translation containing a matching string is found.

Installing or removing a QTranslator, or changing an installed QTranslator generates a LanguageChange event for the QCoreApplication instance. A QApplication instance will propagate the event to all toplevel widgets, where a reimplementation of changeEvent can re-translate the user interface by passing user-visible strings via the tr() function to the respective property setters. User-interface classes generated by Qt Designer provide a retranslateUi() function that can be called.

The function returns true on success and false on failure.

See also removeTranslator(), translate(), QTranslator::load(), and Dynamic Translation.

pub unsafe fn instance() -> QPtr<QCoreApplication>

Returns a pointer to the application's QCoreApplication (or QGuiApplication/QApplication) instance.

Calls C++ function: static QCoreApplication* QCoreApplication::instance().

C++ documentation:

Returns a pointer to the application’s QCoreApplication (or QGuiApplication/QApplication) instance.

If no instance has been allocated, null is returned.

pub unsafe fn is_quit_lock_enabled() -> bool

This property holds whether the use of the QEventLoopLocker feature can cause the application to quit.

Calls C++ function: static bool QCoreApplication::isQuitLockEnabled().

C++ documentation:

This property holds whether the use of the QEventLoopLocker feature can cause the application to quit.

The default is true.

Access functions:

bool	isQuitLockEnabled()
void	setQuitLockEnabled(bool enabled)

See also QEventLoopLocker.

pub unsafe fn is_setuid_allowed() -> bool

Returns true if the application is allowed to run setuid on UNIX platforms.

Calls C++ function: static bool QCoreApplication::isSetuidAllowed().

C++ documentation:

Returns true if the application is allowed to run setuid on UNIX platforms.

This function was introduced in Qt 5.3.

See also QCoreApplication::setSetuidAllowed().

pub unsafe fn library_paths() -> CppBox<QStringList>

Returns a list of paths that the application will search when dynamically loading libraries.

Calls C++ function: static QStringList QCoreApplication::libraryPaths().

C++ documentation:

Returns a list of paths that the application will search when dynamically loading libraries.

The return value of this function may change when a QCoreApplication is created. It is not recommended to call it before creating a QCoreApplication. The directory of the application executable (not the working directory) is part of the list if it is known. In order to make it known a QCoreApplication has to be constructed as it will use argv[0] to find it.

Qt provides default library paths, but they can also be set using a qt.conf file. Paths specified in this file will override default values. Note that if the qt.conf file is in the directory of the application executable, it may not be found until a QCoreApplication is created. If it is not found when calling this function, the default library paths will be used.

The list will include the installation directory for plugins if it exists (the default installation directory for plugins is INSTALL/plugins, where INSTALL is the directory where Qt was installed). The colon separated entries of the QT_PLUGIN_PATH environment variable are always added. The plugin installation directory (and its existence) may change when the directory of the application executable becomes known.

If you want to iterate over the list, you can use the foreach pseudo-keyword:

foreach (const QString &path, app.libraryPaths())
      do_something(path);

See also setLibraryPaths(), addLibraryPath(), removeLibraryPath(), QLibrary, and How to Create Qt Plugins.

pub unsafe fn meta_object(&self) -> Ptr<QMetaObject>

Calls C++ function: virtual const QMetaObject* QCoreApplication::metaObject() const.

pub unsafe fn new_3a( argc: *mut c_int, argv: *mut *mut c_char, arg3: c_int ) -> QBox<QCoreApplication>

Constructs a Qt core application. Core applications are applications without a graphical user interface. Such applications are used at the console or as server processes.

Calls C++ function: [constructor] void QCoreApplication::QCoreApplication(int& argc, char** argv, int arg3 = …).

Warning: no exact match found in C++ documentation. Below is the C++ documentation for QCoreApplication::QCoreApplication(int &argc, char **argv):

Constructs a Qt core application. Core applications are applications without a graphical user interface. Such applications are used at the console or as server processes.

The argc and argv arguments are processed by the application, and made available in a more convenient form by the arguments() function.

Warning: The data referred to by argc and argv must stay valid for the entire lifetime of the QCoreApplication object. In addition, argc must be greater than zero and argv must contain at least one valid character string.

pub unsafe fn new_2a( argc: *mut c_int, argv: *mut *mut c_char ) -> QBox<QCoreApplication>

Constructs a Qt core application. Core applications are applications without a graphical user interface. Such applications are used at the console or as server processes.

Calls C++ function: [constructor] void QCoreApplication::QCoreApplication(int& argc, char** argv).

Warning: no exact match found in C++ documentation. Below is the C++ documentation for QCoreApplication::QCoreApplication(int &argc, char **argv):

Constructs a Qt core application. Core applications are applications without a graphical user interface. Such applications are used at the console or as server processes.

The argc and argv arguments are processed by the application, and made available in a more convenient form by the arguments() function.

Warning: The data referred to by argc and argv must stay valid for the entire lifetime of the QCoreApplication object. In addition, argc must be greater than zero and argv must contain at least one valid character string.

pub unsafe fn notify( &self, arg1: impl CastInto<Ptr<QObject>>, arg2: impl CastInto<Ptr<QEvent>> ) -> bool

Sends event to receiver: receiver->event(event). Returns the value that is returned from the receiver's event handler. Note that this function is called for all events sent to any object in any thread.

Calls C++ function: virtual bool QCoreApplication::notify(QObject* arg1, QEvent* arg2).

C++ documentation:

Sends event to receiver: receiver->event(event). Returns the value that is returned from the receiver’s event handler. Note that this function is called for all events sent to any object in any thread.

For certain types of events (e.g. mouse and key events), the event will be propagated to the receiver's parent and so on up to the top-level object if the receiver is not interested in the event (i.e., it returns false).

There are five different ways that events can be processed; reimplementing this virtual function is just one of them. All five approaches are listed below:

1. Reimplementing paintEvent(), mousePressEvent() and so on. This is the most common, easiest, and least powerful way.
2. Reimplementing this function. This is very powerful, providing complete control; but only one subclass can be active at a time.
3. Installing an event filter on QCoreApplication::instance(). Such an event filter is able to process all events for all widgets, so it's just as powerful as reimplementing notify(); furthermore, it's possible to have more than one application-global event filter. Global event filters even see mouse events for disabled widgets. Note that application event filters are only called for objects that live in the main thread.
4. Reimplementing QObject::event() (as QWidget does). If you do this you get Tab key presses, and you get to see the events before any widget-specific event filters.
5. Installing an event filter on the object. Such an event filter gets all the events, including Tab and Shift+Tab key press events, as long as they do not change the focus widget.

Future direction: This function will not be called for objects that live outside the main thread in Qt 6. Applications that need that functionality should find other solutions for their event inspection needs in the meantime. The change may be extended to the main thread, causing this function to be deprecated.

Warning: If you override this function, you must ensure all threads that process events stop doing so before your application object begins destruction. This includes threads started by other libraries that you may be using, but does not apply to Qt's own threads.

See also QObject::event() and installNativeEventFilter().

pub unsafe fn organization_domain() -> CppBox<QString>

This property holds the Internet domain of the organization that wrote this application

Calls C++ function: static QString QCoreApplication::organizationDomain().

C++ documentation:

This property holds the Internet domain of the organization that wrote this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

On Mac, QSettings uses organizationDomain() as the organization if it's not an empty string; otherwise it uses organizationName(). On all other platforms, QSettings uses organizationName() as the organization.

Access functions:

QString	organizationDomain()
void	setOrganizationDomain(const QString &orgDomain)

See also organizationName, applicationName, and applicationVersion.

pub unsafe fn organization_name() -> CppBox<QString>

This property holds the name of the organization that wrote this application

Calls C++ function: static QString QCoreApplication::organizationName().

C++ documentation:

This property holds the name of the organization that wrote this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

On Mac, QSettings uses organizationDomain() as the organization if it's not an empty string; otherwise it uses organizationName(). On all other platforms, QSettings uses organizationName() as the organization.

Access functions:

QString	organizationName()
void	setOrganizationName(const QString &orgName)

See also organizationDomain and applicationName.

pub unsafe fn post_event_3a( receiver: impl CastInto<Ptr<QObject>>, event: impl CastInto<Ptr<QEvent>>, priority: c_int )

Adds the event event, with the object receiver as the receiver of the event, to an event queue and returns immediately.

Calls C++ function: static void QCoreApplication::postEvent(QObject* receiver, QEvent* event, int priority = …).

C++ documentation:

Adds the event event, with the object receiver as the receiver of the event, to an event queue and returns immediately.

The event must be allocated on the heap since the post event queue will take ownership of the event and delete it once it has been posted. It is not safe to access the event after it has been posted.

When control returns to the main event loop, all events that are stored in the queue will be sent using the notify() function.

Events are sorted in descending priority order, i.e. events with a high priority are queued before events with a lower priority. The priority can be any integer value, i.e. between INT_MAX and INT_MIN, inclusive; see Qt::EventPriority for more details. Events with equal priority will be processed in the order posted.

Note: This function is thread-safe.

This function was introduced in Qt 4.3.

See also sendEvent(), notify(), sendPostedEvents(), and Qt::EventPriority.

pub unsafe fn post_event_2a( receiver: impl CastInto<Ptr<QObject>>, event: impl CastInto<Ptr<QEvent>> )

Adds the event event, with the object receiver as the receiver of the event, to an event queue and returns immediately.

Calls C++ function: static void QCoreApplication::postEvent(QObject* receiver, QEvent* event).

C++ documentation:

Adds the event event, with the object receiver as the receiver of the event, to an event queue and returns immediately.

The event must be allocated on the heap since the post event queue will take ownership of the event and delete it once it has been posted. It is not safe to access the event after it has been posted.

When control returns to the main event loop, all events that are stored in the queue will be sent using the notify() function.

Events are sorted in descending priority order, i.e. events with a high priority are queued before events with a lower priority. The priority can be any integer value, i.e. between INT_MAX and INT_MIN, inclusive; see Qt::EventPriority for more details. Events with equal priority will be processed in the order posted.

Note: This function is thread-safe.

This function was introduced in Qt 4.3.

See also sendEvent(), notify(), sendPostedEvents(), and Qt::EventPriority.

pub unsafe fn process_events_1a(flags: QFlags<ProcessEventsFlag>)

Processes all pending events for the calling thread according to the specified flags until there are no more events to process.

Calls C++ function: static void QCoreApplication::processEvents(QFlags<QEventLoop::ProcessEventsFlag> flags = …).

C++ documentation:

Processes all pending events for the calling thread according to the specified flags until there are no more events to process.

You can call this function occasionally when your program is busy performing a long operation (e.g. copying a file).

In the event that you are running a local loop which calls this function continuously, without an event loop, the DeferredDelete events will not be processed. This can affect the behaviour of widgets, e.g. QToolTip, that rely on DeferredDelete events to function properly. An alternative would be to call sendPostedEvents() from within that local loop.

Calling this function processes events only for the calling thread.

Note: This function is thread-safe.

See also exec(), QTimer, QEventLoop::processEvents(), flush(), and sendPostedEvents().

pub unsafe fn process_events_2a( flags: QFlags<ProcessEventsFlag>, maxtime: c_int )

This function overloads processEvents().

Calls C++ function: static void QCoreApplication::processEvents(QFlags<QEventLoop::ProcessEventsFlag> flags, int maxtime).

C++ documentation:

This function overloads processEvents().

Processes pending events for the calling thread for maxtime milliseconds or until there are no more events to process, whichever is shorter.

You can call this function occasionally when your program is busy doing a long operation (e.g. copying a file).

Calling this function processes events only for the calling thread.

Note: This function is thread-safe.

See also exec(), QTimer, and QEventLoop::processEvents().

pub unsafe fn process_events_0a()

Processes all pending events for the calling thread according to the specified flags until there are no more events to process.

Calls C++ function: static void QCoreApplication::processEvents().

C++ documentation:

Processes all pending events for the calling thread according to the specified flags until there are no more events to process.

You can call this function occasionally when your program is busy performing a long operation (e.g. copying a file).

In the event that you are running a local loop which calls this function continuously, without an event loop, the DeferredDelete events will not be processed. This can affect the behaviour of widgets, e.g. QToolTip, that rely on DeferredDelete events to function properly. An alternative would be to call sendPostedEvents() from within that local loop.

Calling this function processes events only for the calling thread.

Note: This function is thread-safe.

See also exec(), QTimer, QEventLoop::processEvents(), flush(), and sendPostedEvents().

pub unsafe fn qt_metacall( &self, arg1: Call, arg2: c_int, arg3: *mut *mut c_void ) -> c_int

Calls C++ function: virtual int QCoreApplication::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3).

pub unsafe fn qt_metacast(&self, arg1: *const c_char) -> *mut c_void

Calls C++ function: virtual void* QCoreApplication::qt_metacast(const char* arg1).

pub unsafe fn quit()

Tells the application to exit with return code 0 (success). Equivalent to calling QCoreApplication::exit(0).

Calls C++ function: static [slot] void QCoreApplication::quit().

C++ documentation:

Tells the application to exit with return code 0 (success). Equivalent to calling QCoreApplication::exit(0).

It's common to connect the QGuiApplication::lastWindowClosed() signal to quit(), and you also often connect e.g. QAbstractButton::clicked() or signals in QAction, QMenu, or QMenuBar to it.

Example:

QPushButton *quitButton = new QPushButton(“Quit”);
connect(quitButton, SIGNAL(clicked()), &app, SLOT(quit()));

See also exit(), aboutToQuit(), and QGuiApplication::lastWindowClosed().

pub unsafe fn remove_library_path(arg1: impl CastInto<Ref<QString>>)

Removes path from the library path list. If path is empty or not in the path list, the list is not changed.

Calls C++ function: static void QCoreApplication::removeLibraryPath(const QString& arg1).

C++ documentation:

Removes path from the library path list. If path is empty or not in the path list, the list is not changed.

The library paths are reset to the default when an instance of QCoreApplication is destructed.

See also addLibraryPath(), libraryPaths(), and setLibraryPaths().

pub unsafe fn remove_native_event_filter( &self, filter_obj: impl CastInto<Ptr<QAbstractNativeEventFilter>> )

Removes an event filterObject from this object. The request is ignored if such an event filter has not been installed.

Calls C++ function: void QCoreApplication::removeNativeEventFilter(QAbstractNativeEventFilter* filterObj).

C++ documentation:

Removes an event filterObject from this object. The request is ignored if such an event filter has not been installed.

All event filters for this object are automatically removed when this object is destroyed.

It is always safe to remove an event filter, even during event filter activation (i.e. from the nativeEventFilter() function).

This function was introduced in Qt 5.0.

See also installNativeEventFilter().

pub unsafe fn remove_posted_events_2a( receiver: impl CastInto<Ptr<QObject>>, event_type: c_int )

Removes all events of the given eventType that were posted using postEvent() for receiver.

Calls C++ function: static void QCoreApplication::removePostedEvents(QObject* receiver, int eventType = …).

C++ documentation:

Removes all events of the given eventType that were posted using postEvent() for receiver.

The events are not dispatched, instead they are removed from the queue. You should never need to call this function. If you do call it, be aware that killing events may cause receiver to break one or more invariants.

If receiver is null, the events of eventType are removed for all objects. If eventType is 0, all the events are removed for receiver. You should never call this function with eventType of 0. If you do call it in this way, be aware that killing events may cause receiver to break one or more invariants.

Note: This function is thread-safe.

This function was introduced in Qt 4.3.

pub unsafe fn remove_posted_events_1a(receiver: impl CastInto<Ptr<QObject>>)

Removes all events of the given eventType that were posted using postEvent() for receiver.

Calls C++ function: static void QCoreApplication::removePostedEvents(QObject* receiver).

C++ documentation:

Removes all events of the given eventType that were posted using postEvent() for receiver.

The events are not dispatched, instead they are removed from the queue. You should never need to call this function. If you do call it, be aware that killing events may cause receiver to break one or more invariants.

If receiver is null, the events of eventType are removed for all objects. If eventType is 0, all the events are removed for receiver. You should never call this function with eventType of 0. If you do call it in this way, be aware that killing events may cause receiver to break one or more invariants.

Note: This function is thread-safe.

This function was introduced in Qt 4.3.

pub unsafe fn remove_translator( message_file: impl CastInto<Ptr<QTranslator>> ) -> bool

Removes the translation file translationFile from the list of translation files used by this application. (It does not delete the translation file from the file system.)

Calls C++ function: static bool QCoreApplication::removeTranslator(QTranslator* messageFile).

C++ documentation:

Removes the translation file translationFile from the list of translation files used by this application. (It does not delete the translation file from the file system.)

The function returns true on success and false on failure.

See also installTranslator(), translate(), and QObject::tr().

pub unsafe fn send_event( receiver: impl CastInto<Ptr<QObject>>, event: impl CastInto<Ptr<QEvent>> ) -> bool

Sends event event directly to receiver receiver, using the notify() function. Returns the value that was returned from the event handler.

Calls C++ function: static bool QCoreApplication::sendEvent(QObject* receiver, QEvent* event).

C++ documentation:

Sends event event directly to receiver receiver, using the notify() function. Returns the value that was returned from the event handler.

The event is not deleted when the event has been sent. The normal approach is to create the event on the stack, for example:

QMouseEvent event(QEvent::MouseButtonPress, pos, 0, 0, 0);
QApplication::sendEvent(mainWindow, &event);

See also postEvent() and notify().

pub unsafe fn send_posted_events_2a( receiver: impl CastInto<Ptr<QObject>>, event_type: c_int )

Immediately dispatches all events which have been previously queued with QCoreApplication::postEvent() and which are for the object receiver and have the event type event_type.

Calls C++ function: static void QCoreApplication::sendPostedEvents(QObject* receiver = …, int event_type = …).

C++ documentation:

Immediately dispatches all events which have been previously queued with QCoreApplication::postEvent() and which are for the object receiver and have the event type event_type.

Events from the window system are not dispatched by this function, but by processEvents().

If receiver is null, the events of event_type are sent for all objects. If event_type is 0, all the events are sent for receiver.

Note: This method must be called from the thread in which its QObject parameter, receiver, lives.

See also flush() and postEvent().

pub unsafe fn send_posted_events_1a(receiver: impl CastInto<Ptr<QObject>>)

Immediately dispatches all events which have been previously queued with QCoreApplication::postEvent() and which are for the object receiver and have the event type event_type.

Calls C++ function: static void QCoreApplication::sendPostedEvents(QObject* receiver = …).

C++ documentation:

Immediately dispatches all events which have been previously queued with QCoreApplication::postEvent() and which are for the object receiver and have the event type event_type.

Events from the window system are not dispatched by this function, but by processEvents().

If receiver is null, the events of event_type are sent for all objects. If event_type is 0, all the events are sent for receiver.

Note: This method must be called from the thread in which its QObject parameter, receiver, lives.

See also flush() and postEvent().

pub unsafe fn send_posted_events_0a()

Immediately dispatches all events which have been previously queued with QCoreApplication::postEvent() and which are for the object receiver and have the event type event_type.

Calls C++ function: static void QCoreApplication::sendPostedEvents().

C++ documentation:

Immediately dispatches all events which have been previously queued with QCoreApplication::postEvent() and which are for the object receiver and have the event type event_type.

Events from the window system are not dispatched by this function, but by processEvents().

If receiver is null, the events of event_type are sent for all objects. If event_type is 0, all the events are sent for receiver.

Note: This method must be called from the thread in which its QObject parameter, receiver, lives.

See also flush() and postEvent().

pub unsafe fn set_application_name(application: impl CastInto<Ref<QString>>)

This property holds the name of this application

Calls C++ function: static void QCoreApplication::setApplicationName(const QString& application).

C++ documentation:

This property holds the name of this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

If not set, the application name defaults to the executable name (since 5.0).

Access functions:

QString	applicationName()
void	setApplicationName(const QString &application)

See also organizationName, organizationDomain, applicationVersion, and applicationFilePath().

pub unsafe fn set_application_version(version: impl CastInto<Ref<QString>>)

This property holds the version of this application

Calls C++ function: static void QCoreApplication::setApplicationVersion(const QString& version).

C++ documentation:

This property holds the version of this application

If not set, the application version defaults to a platform-specific value determined from the main application executable or package (since Qt 5.9):

Platform	Source
Windows (classic desktop)	PRODUCTVERSION parameter of the VERSIONINFO resource
Universal Windows Platform	version attribute of the application package manifest
macOS, iOS, tvOS, watchOS	CFBundleVersion property of the information property list
Android	android:versionName property of the AndroidManifest.xml manifest element

On other platforms, the default is the empty string.

This property was introduced in Qt 4.4.

Access functions:

QString	applicationVersion()
void	setApplicationVersion(const QString &version)

See also applicationName, organizationName, and organizationDomain.

pub unsafe fn set_attribute_2a(attribute: ApplicationAttribute, on: bool)

Sets the attribute attribute if on is true; otherwise clears the attribute.

Calls C++ function: static void QCoreApplication::setAttribute(Qt::ApplicationAttribute attribute, bool on = …).

C++ documentation:

Sets the attribute attribute if on is true; otherwise clears the attribute.

See also testAttribute().

pub unsafe fn set_attribute_1a(attribute: ApplicationAttribute)

Sets the attribute attribute if on is true; otherwise clears the attribute.

Calls C++ function: static void QCoreApplication::setAttribute(Qt::ApplicationAttribute attribute).

C++ documentation:

Sets the attribute attribute if on is true; otherwise clears the attribute.

See also testAttribute().

pub unsafe fn set_event_dispatcher( event_dispatcher: impl CastInto<Ptr<QAbstractEventDispatcher>> )

Sets the event dispatcher for the main thread to eventDispatcher. This is only possible as long as there is no event dispatcher installed yet. That is, before QCoreApplication has been instantiated. This method takes ownership of the object.

Calls C++ function: static void QCoreApplication::setEventDispatcher(QAbstractEventDispatcher* eventDispatcher).

C++ documentation:

Sets the event dispatcher for the main thread to eventDispatcher. This is only possible as long as there is no event dispatcher installed yet. That is, before QCoreApplication has been instantiated. This method takes ownership of the object.

See also eventDispatcher().

pub unsafe fn set_library_paths(arg1: impl CastInto<Ref<QStringList>>)

Sets the list of directories to search when loading libraries to paths. All existing paths will be deleted and the path list will consist of the paths given in paths.

Calls C++ function: static void QCoreApplication::setLibraryPaths(const QStringList& arg1).

C++ documentation:

Sets the list of directories to search when loading libraries to paths. All existing paths will be deleted and the path list will consist of the paths given in paths.

The library paths are reset to the default when an instance of QCoreApplication is destructed.

See also libraryPaths(), addLibraryPath(), removeLibraryPath(), and QLibrary.

pub unsafe fn set_organization_domain(org_domain: impl CastInto<Ref<QString>>)

This property holds the Internet domain of the organization that wrote this application

Calls C++ function: static void QCoreApplication::setOrganizationDomain(const QString& orgDomain).

C++ documentation:

This property holds the Internet domain of the organization that wrote this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

On Mac, QSettings uses organizationDomain() as the organization if it's not an empty string; otherwise it uses organizationName(). On all other platforms, QSettings uses organizationName() as the organization.

Access functions:

QString	organizationDomain()
void	setOrganizationDomain(const QString &orgDomain)

See also organizationName, applicationName, and applicationVersion.

pub unsafe fn set_organization_name(org_name: impl CastInto<Ref<QString>>)

This property holds the name of the organization that wrote this application

Calls C++ function: static void QCoreApplication::setOrganizationName(const QString& orgName).

C++ documentation:

This property holds the name of the organization that wrote this application

The value is used by the QSettings class when it is constructed using the empty constructor. This saves having to repeat this information each time a QSettings object is created.

On Mac, QSettings uses organizationDomain() as the organization if it's not an empty string; otherwise it uses organizationName(). On all other platforms, QSettings uses organizationName() as the organization.

Access functions:

QString	organizationName()
void	setOrganizationName(const QString &orgName)

See also organizationDomain and applicationName.

pub unsafe fn set_quit_lock_enabled(enabled: bool)

This property holds whether the use of the QEventLoopLocker feature can cause the application to quit.

Calls C++ function: static void QCoreApplication::setQuitLockEnabled(bool enabled).

C++ documentation:

This property holds whether the use of the QEventLoopLocker feature can cause the application to quit.

The default is true.

Access functions:

bool	isQuitLockEnabled()
void	setQuitLockEnabled(bool enabled)

See also QEventLoopLocker.

pub unsafe fn set_setuid_allowed(allow: bool)

Allows the application to run setuid on UNIX platforms if allow is true.

Calls C++ function: static void QCoreApplication::setSetuidAllowed(bool allow).

C++ documentation:

Allows the application to run setuid on UNIX platforms if allow is true.

If allow is false (the default) and Qt detects the application is running with an effective user id different than the real user id, the application will be aborted when a QCoreApplication instance is created.

Qt is not an appropriate solution for setuid programs due to its large attack surface. However some applications may be required to run in this manner for historical reasons. This flag will prevent Qt from aborting the application when this is detected, and must be set before a QCoreApplication instance is created.

Note: It is strongly recommended not to enable this option since it introduces security risks.

This function was introduced in Qt 5.3.

See also isSetuidAllowed().

pub unsafe fn starting_up() -> bool

Returns true if an application object has not been created yet; otherwise returns false.

Calls C++ function: static bool QCoreApplication::startingUp().

C++ documentation:

Returns true if an application object has not been created yet; otherwise returns false.

See also closingDown().

pub unsafe fn static_meta_object() -> Ref<QMetaObject>

Returns a reference to the staticMetaObject field.

pub unsafe fn test_attribute(attribute: ApplicationAttribute) -> bool

Returns true if attribute attribute is set; otherwise returns false.

Calls C++ function: static bool QCoreApplication::testAttribute(Qt::ApplicationAttribute attribute).

C++ documentation:

Returns true if attribute attribute is set; otherwise returns false.

See also setAttribute().

pub unsafe fn tr( s: *const c_char, c: *const c_char, n: c_int ) -> CppBox<QString>

Calls C++ function: static QString QCoreApplication::tr(const char* s, const char* c, int n).

pub unsafe fn tr_utf8( s: *const c_char, c: *const c_char, n: c_int ) -> CppBox<QString>

Calls C++ function: static QString QCoreApplication::trUtf8(const char* s, const char* c, int n).

pub unsafe fn translate_4a( context: *const c_char, key: *const c_char, disambiguation: *const c_char, n: c_int ) -> CppBox<QString>

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Calls C++ function: static QString QCoreApplication::translate(const char* context, const char* key, const char* disambiguation = …, int n = …).

Warning: no exact match found in C++ documentation. Below is the C++ documentation for static QString QCoreApplication::translate(const char *context, const char *key, const char *disambiguation, QCoreApplication::Encoding encoding, int n = ...):

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

pub unsafe fn translate_3a( context: *const c_char, key: *const c_char, disambiguation: *const c_char ) -> CppBox<QString>

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Calls C++ function: static QString QCoreApplication::translate(const char* context, const char* key, const char* disambiguation = …).

Warning: no exact match found in C++ documentation. Below is the C++ documentation for static QString QCoreApplication::translate(const char *context, const char *key, const char *disambiguation, QCoreApplication::Encoding encoding, int n = ...):

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

pub unsafe fn translate_2a( context: *const c_char, key: *const c_char ) -> CppBox<QString>

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Calls C++ function: static QString QCoreApplication::translate(const char* context, const char* key).

Warning: no exact match found in C++ documentation. Below is the C++ documentation for static QString QCoreApplication::translate(const char *context, const char *key, const char *disambiguation, QCoreApplication::Encoding encoding, int n = ...):

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Methods from Deref<Target = QObject>

pub unsafe fn find_child<T>( &self, name: &str ) -> Result<QPtr<T>, FindChildError>

where QObject: DynamicCast<T>, T: StaticUpcast<QObject>,

Finds a child of self with the specified object name and casts it to type T.

The search is performed recursively. If there is more than one child matching the search, the most direct ancestor is returned. If there are several direct ancestors, it is undefined which one will be returned.

Returns an error if there is no child object with object name name or the found object cannot be cast to T.

pub fn destroyed(&self) -> Signal<(*mut QObject,)>

This signal is emitted immediately before the object obj is destroyed, and can not be blocked.

Returns a built-in Qt signal QObject::destroyed that can be passed to qt_core::Signal::connect.

C++ documentation:

This signal is emitted immediately before the object obj is destroyed, and can not be blocked.

All the objects's children are destroyed immediately after this signal is emitted.

See also deleteLater() and QPointer.

pub fn object_name_changed(&self) -> Signal<(*const QString,)>

This signal is emitted after the object's name has been changed. The new object name is passed as objectName.

Returns a built-in Qt signal QObject::objectNameChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

This signal is emitted after the object’s name has been changed. The new object name is passed as objectName.

Note: This is a private signal. It can be used in signal connections but cannot be emitted by the user.

Note: Notifier signal for property objectName.

See also QObject::objectName.

pub fn slot_delete_later(&self) -> Receiver<()>

Schedules this object for deletion.

Returns a built-in Qt slot QObject::deleteLater that can be passed to qt_core::Signal::connect.

C++ documentation:

Schedules this object for deletion.

The object will be deleted when control returns to the event loop. If the event loop is not running when this function is called (e.g. deleteLater() is called on an object before QCoreApplication::exec()), the object will be deleted once the event loop is started. If deleteLater() is called after the main event loop has stopped, the object will not be deleted. Since Qt 4.8, if deleteLater() is called on an object that lives in a thread with no running event loop, the object will be destroyed when the thread finishes.

Note that entering and leaving a new event loop (e.g., by opening a modal dialog) will not perform the deferred deletion; for the object to be deleted, the control must return to the event loop from which deleteLater() was called.

Note: It is safe to call this function more than once; when the first deferred deletion event is delivered, any pending events for the object are removed from the event queue.

See also destroyed() and QPointer.

pub unsafe fn block_signals(&self, b: bool) -> bool

If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). If block is false, no such blocking will occur.

Calls C++ function: bool QObject::blockSignals(bool b).

C++ documentation:

If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). If block is false, no such blocking will occur.

The return value is the previous value of signalsBlocked().

Note that the destroyed() signal will be emitted even if the signals for this object have been blocked.

Signals emitted while being blocked are not buffered.

See also signalsBlocked() and QSignalBlocker.

pub unsafe fn children(&self) -> Ref<QListOfQObject>

Returns a list of child objects. The QObjectList class is defined in the <QObject> header file as the following:

Calls C++ function: const QList<QObject*>& QObject::children() const.

C++ documentation:

Returns a list of child objects. The QObjectList class is defined in the <QObject> header file as the following:

  typedef QList<QObject*> QObjectList;

The first child added is the first object in the list and the last child added is the last object in the list, i.e. new children are appended at the end.

Note that the list order changes when QWidget children are raised or lowered. A widget that is raised becomes the last object in the list, and a widget that is lowered becomes the first object in the list.

See also findChild(), findChildren(), parent(), and setParent().

pub unsafe fn delete_later(&self)

Schedules this object for deletion.

Calls C++ function: [slot] void QObject::deleteLater().

C++ documentation:

Schedules this object for deletion.

The object will be deleted when control returns to the event loop. If the event loop is not running when this function is called (e.g. deleteLater() is called on an object before QCoreApplication::exec()), the object will be deleted once the event loop is started. If deleteLater() is called after the main event loop has stopped, the object will not be deleted. Since Qt 4.8, if deleteLater() is called on an object that lives in a thread with no running event loop, the object will be destroyed when the thread finishes.

Note that entering and leaving a new event loop (e.g., by opening a modal dialog) will not perform the deferred deletion; for the object to be deleted, the control must return to the event loop from which deleteLater() was called.

Note: It is safe to call this function more than once; when the first deferred deletion event is delivered, any pending events for the object are removed from the event queue.

See also destroyed() and QPointer.

pub unsafe fn disconnect_char_q_object_char( &self, signal: *const c_char, receiver: impl CastInto<Ptr<QObject>>, member: *const c_char ) -> bool

This function overloads disconnect().

Calls C++ function: bool QObject::disconnect(const char* signal = …, const QObject* receiver = …, const char* member = …) const.

C++ documentation:

This function overloads disconnect().

Disconnects signal from method of receiver.

A signal-slot connection is removed when either of the objects involved are destroyed.

Note: This function is thread-safe.

pub unsafe fn disconnect_q_object_char( &self, receiver: impl CastInto<Ptr<QObject>>, member: *const c_char ) -> bool

This function overloads disconnect().

Calls C++ function: bool QObject::disconnect(const QObject* receiver, const char* member = …) const.

C++ documentation:

This function overloads disconnect().

Disconnects all signals in this object from receiver's method.

A signal-slot connection is removed when either of the objects involved are destroyed.

pub unsafe fn disconnect_char_q_object( &self, signal: *const c_char, receiver: impl CastInto<Ptr<QObject>> ) -> bool

This function overloads disconnect().

Calls C++ function: bool QObject::disconnect(const char* signal = …, const QObject* receiver = …) const.

C++ documentation:

This function overloads disconnect().

Disconnects signal from method of receiver.

A signal-slot connection is removed when either of the objects involved are destroyed.

Note: This function is thread-safe.

pub unsafe fn disconnect_char(&self, signal: *const c_char) -> bool

This function overloads disconnect().

Calls C++ function: bool QObject::disconnect(const char* signal = …) const.

C++ documentation:

This function overloads disconnect().

Disconnects signal from method of receiver.

A signal-slot connection is removed when either of the objects involved are destroyed.

Note: This function is thread-safe.

pub unsafe fn disconnect(&self) -> bool

This function overloads disconnect().

Calls C++ function: bool QObject::disconnect() const.

C++ documentation:

This function overloads disconnect().

Disconnects signal from method of receiver.

A signal-slot connection is removed when either of the objects involved are destroyed.

Note: This function is thread-safe.

pub unsafe fn disconnect_q_object( &self, receiver: impl CastInto<Ptr<QObject>> ) -> bool

This function overloads disconnect().

Calls C++ function: bool QObject::disconnect(const QObject* receiver) const.

C++ documentation:

This function overloads disconnect().

Disconnects all signals in this object from receiver's method.

A signal-slot connection is removed when either of the objects involved are destroyed.

pub unsafe fn dump_object_info_mut(&self)

Dumps information about signal connections, etc. for this object to the debug output.

Calls C++ function: void QObject::dumpObjectInfo().

C++ documentation:

Dumps information about signal connections, etc. for this object to the debug output.

Note: before Qt 5.9, this function was not const.

See also dumpObjectTree().

pub unsafe fn dump_object_info(&self)

Dumps information about signal connections, etc. for this object to the debug output.

Calls C++ function: void QObject::dumpObjectInfo() const.

C++ documentation:

Dumps information about signal connections, etc. for this object to the debug output.

Note: before Qt 5.9, this function was not const.

See also dumpObjectTree().

pub unsafe fn dump_object_tree_mut(&self)

Dumps a tree of children to the debug output.

Calls C++ function: void QObject::dumpObjectTree().

C++ documentation:

Dumps a tree of children to the debug output.

Note: before Qt 5.9, this function was not const.

See also dumpObjectInfo().

pub unsafe fn dump_object_tree(&self)

Dumps a tree of children to the debug output.

Calls C++ function: void QObject::dumpObjectTree() const.

C++ documentation:

Dumps a tree of children to the debug output.

Note: before Qt 5.9, this function was not const.

See also dumpObjectInfo().

pub unsafe fn dynamic_property_names(&self) -> CppBox<QListOfQByteArray>

Returns the names of all properties that were dynamically added to the object using setProperty().

Calls C++ function: QList<QByteArray> QObject::dynamicPropertyNames() const.

C++ documentation:

Returns the names of all properties that were dynamically added to the object using setProperty().

This function was introduced in Qt 4.2.

pub unsafe fn eq(&self, p: impl CastInto<Ref<QPointerOfQObject>>) -> bool

Returns true if c1 and c2 are the same Unicode character; otherwise returns false.

Calls C++ function: bool operator==(QObject* o, const QPointer<QObject>& p).

Warning: no exact match found in C++ documentation. Below is the C++ documentation for bool operator==(QChar c1, QChar c2):

Returns true if c1 and c2 are the same Unicode character; otherwise returns false.

pub unsafe fn event(&self, event: impl CastInto<Ptr<QEvent>>) -> bool

This virtual function receives events to an object and should return true if the event e was recognized and processed.

Calls C++ function: virtual bool QObject::event(QEvent* event).

C++ documentation:

This virtual function receives events to an object and should return true if the event e was recognized and processed.

The event() function can be reimplemented to customize the behavior of an object.

Make sure you call the parent event class implementation for all the events you did not handle.

Example:

class MyClass : public QWidget
{
      Q_OBJECT
public:
      MyClass(QWidget *parent = 0);
      ~MyClass();
      bool event(QEvent* ev)
      {
          if (ev->type() == QEvent::PolishRequest) {
              // overwrite handling of PolishRequest if any
              doThings();
              return true;
          } else  if (ev->type() == QEvent::Show) {
              // complement handling of Show if any
              doThings2();
              QWidget::event(ev);
              return true;
          }
          // Make sure the rest of events are handled
          return QWidget::event(ev);
      }
};

See also installEventFilter(), timerEvent(), QCoreApplication::sendEvent(), and QCoreApplication::postEvent().

pub unsafe fn event_filter( &self, watched: impl CastInto<Ptr<QObject>>, event: impl CastInto<Ptr<QEvent>> ) -> bool

Filters events if this object has been installed as an event filter for the watched object.

Calls C++ function: virtual bool QObject::eventFilter(QObject* watched, QEvent* event).

C++ documentation:

Filters events if this object has been installed as an event filter for the watched object.

In your reimplementation of this function, if you want to filter the event out, i.e. stop it being handled further, return true; otherwise return false.

Example:

class MainWindow : public QMainWindow
{
public:
      MainWindow();
protected:
      bool eventFilter(QObject obj, QEvent ev);
private:
      QTextEdit *textEdit;
};
MainWindow::MainWindow()
{
      textEdit = new QTextEdit;
      setCentralWidget(textEdit);
      textEdit->installEventFilter(this);
}
bool MainWindow::eventFilter(QObject obj, QEvent event)
{
      if (obj == textEdit) {
          if (event->type() == QEvent::KeyPress) {
              QKeyEvent keyEvent = static_cast<QKeyEvent>(event);
              qDebug() << “Ate key press” << keyEvent->key();
              return true;
          } else {
              return false;
          }
      } else {
          // pass the event on to the parent class
          return QMainWindow::eventFilter(obj, event);
      }
}

Notice in the example above that unhandled events are passed to the base class's eventFilter() function, since the base class might have reimplemented eventFilter() for its own internal purposes.

Warning: If you delete the receiver object in this function, be sure to return true. Otherwise, Qt will forward the event to the deleted object and the program might crash.

See also installEventFilter().

pub unsafe fn find_child_q_object_2a( &self, a_name: impl CastInto<Ref<QString>>, options: QFlags<FindChildOption> ) -> QPtr<QObject>

Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

Calls C++ function: QObject* QObject::findChild<QObject*>(const QString& aName = …, QFlags<Qt::FindChildOption> options = …) const.

C++ documentation:

Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

If there is more than one child matching the search, the most direct ancestor is returned. If there are several direct ancestors, it is undefined which one will be returned. In that case, findChildren() should be used.

This example returns a child QPushButton of parentWidget named "button1", even if the button isn't a direct child of the parent:

QPushButton button = parentWidget->findChild<QPushButton >(“button1”);

This example returns a QListWidget child of parentWidget:

QListWidget list = parentWidget->findChild<QListWidget >();

This example returns a child QPushButton of parentWidget (its direct parent) named "button1":

QPushButton button = parentWidget->findChild<QPushButton >(“button1”, Qt::FindDirectChildrenOnly);

This example returns a QListWidget child of parentWidget, its direct parent:

QListWidget list = parentWidget->findChild<QListWidget >(QString(), Qt::FindDirectChildrenOnly);

See also findChildren().

pub unsafe fn find_child_q_object_1a( &self, a_name: impl CastInto<Ref<QString>> ) -> QPtr<QObject>

Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

Calls C++ function: QObject* QObject::findChild<QObject*>(const QString& aName = …) const.

C++ documentation:

Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

If there is more than one child matching the search, the most direct ancestor is returned. If there are several direct ancestors, it is undefined which one will be returned. In that case, findChildren() should be used.

This example returns a child QPushButton of parentWidget named "button1", even if the button isn't a direct child of the parent:

QPushButton button = parentWidget->findChild<QPushButton >(“button1”);

This example returns a QListWidget child of parentWidget:

QListWidget list = parentWidget->findChild<QListWidget >();

This example returns a child QPushButton of parentWidget (its direct parent) named "button1":

QPushButton button = parentWidget->findChild<QPushButton >(“button1”, Qt::FindDirectChildrenOnly);

This example returns a QListWidget child of parentWidget, its direct parent:

QListWidget list = parentWidget->findChild<QListWidget >(QString(), Qt::FindDirectChildrenOnly);

See also findChildren().

pub unsafe fn find_child_q_object_0a(&self) -> QPtr<QObject>

Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

Calls C++ function: QObject* QObject::findChild<QObject*>() const.

C++ documentation:

Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

If there is more than one child matching the search, the most direct ancestor is returned. If there are several direct ancestors, it is undefined which one will be returned. In that case, findChildren() should be used.

This example returns a child QPushButton of parentWidget named "button1", even if the button isn't a direct child of the parent:

QPushButton button = parentWidget->findChild<QPushButton >(“button1”);

This example returns a QListWidget child of parentWidget:

QListWidget list = parentWidget->findChild<QListWidget >();

This example returns a child QPushButton of parentWidget (its direct parent) named "button1":

QPushButton button = parentWidget->findChild<QPushButton >(“button1”, Qt::FindDirectChildrenOnly);

This example returns a QListWidget child of parentWidget, its direct parent:

QListWidget list = parentWidget->findChild<QListWidget >(QString(), Qt::FindDirectChildrenOnly);

See also findChildren().

pub unsafe fn find_children_q_object_q_string_q_flags_find_child_option( &self, a_name: impl CastInto<Ref<QString>>, options: QFlags<FindChildOption> ) -> CppBox<QListOfQObject>

Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>(const QString& aName = …, QFlags<Qt::FindChildOption> options = …) const.

C++ documentation:

Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

The following example shows how to find a list of child QWidgets of the specified parentWidget named widgetname:

QList<QWidget > widgets = parentWidget.findChildren<QWidget >(“widgetname”);

This example returns all QPushButtons that are children of parentWidget:

QList<QPushButton > allPButtons = parentWidget.findChildren<QPushButton >();

This example returns all QPushButtons that are immediate children of parentWidget:

QList<QPushButton > childButtons = parentWidget.findChildren<QPushButton >(QString(), Qt::FindDirectChildrenOnly);

See also findChild().

pub unsafe fn find_children_q_object_q_reg_exp_q_flags_find_child_option( &self, re: impl CastInto<Ref<QRegExp>>, options: QFlags<FindChildOption> ) -> CppBox<QListOfQObject>

This function overloads findChildren().

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>(const QRegExp& re, QFlags<Qt::FindChildOption> options = …) const.

C++ documentation:

This function overloads findChildren().

Returns the children of this object that can be cast to type T and that have names matching the regular expression regExp, or an empty list if there are no such objects. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

pub unsafe fn find_children_q_object_q_regular_expression_q_flags_find_child_option( &self, re: impl CastInto<Ref<QRegularExpression>>, options: QFlags<FindChildOption> ) -> CppBox<QListOfQObject>

This function overloads findChildren().

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>(const QRegularExpression& re, QFlags<Qt::FindChildOption> options = …) const.

C++ documentation:

This function overloads findChildren().

Returns the children of this object that can be cast to type T and that have names matching the regular expression re, or an empty list if there are no such objects. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

This function was introduced in Qt 5.0.

pub unsafe fn find_children_q_object_q_string( &self, a_name: impl CastInto<Ref<QString>> ) -> CppBox<QListOfQObject>

Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>(const QString& aName = …) const.

C++ documentation:

Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

The following example shows how to find a list of child QWidgets of the specified parentWidget named widgetname:

QList<QWidget > widgets = parentWidget.findChildren<QWidget >(“widgetname”);

This example returns all QPushButtons that are children of parentWidget:

QList<QPushButton > allPButtons = parentWidget.findChildren<QPushButton >();

This example returns all QPushButtons that are immediate children of parentWidget:

QList<QPushButton > childButtons = parentWidget.findChildren<QPushButton >(QString(), Qt::FindDirectChildrenOnly);

See also findChild().

pub unsafe fn find_children_q_object(&self) -> CppBox<QListOfQObject>

Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>() const.

C++ documentation:

Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. Omitting the name argument causes all object names to be matched. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

The following example shows how to find a list of child QWidgets of the specified parentWidget named widgetname:

QList<QWidget > widgets = parentWidget.findChildren<QWidget >(“widgetname”);

This example returns all QPushButtons that are children of parentWidget:

QList<QPushButton > allPButtons = parentWidget.findChildren<QPushButton >();

This example returns all QPushButtons that are immediate children of parentWidget:

QList<QPushButton > childButtons = parentWidget.findChildren<QPushButton >(QString(), Qt::FindDirectChildrenOnly);

See also findChild().

pub unsafe fn find_children_q_object_q_reg_exp( &self, re: impl CastInto<Ref<QRegExp>> ) -> CppBox<QListOfQObject>

This function overloads findChildren().

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>(const QRegExp& re) const.

C++ documentation:

This function overloads findChildren().

Returns the children of this object that can be cast to type T and that have names matching the regular expression regExp, or an empty list if there are no such objects. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

pub unsafe fn find_children_q_object_q_regular_expression( &self, re: impl CastInto<Ref<QRegularExpression>> ) -> CppBox<QListOfQObject>

This function overloads findChildren().

Calls C++ function: QList<QObject*> QObject::findChildren<QObject*>(const QRegularExpression& re) const.

C++ documentation:

This function overloads findChildren().

Returns the children of this object that can be cast to type T and that have names matching the regular expression re, or an empty list if there are no such objects. The search is performed recursively, unless options specifies the option FindDirectChildrenOnly.

This function was introduced in Qt 5.0.

pub unsafe fn inherits(&self, classname: *const c_char) -> bool

Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false.

Calls C++ function: bool QObject::inherits(const char* classname) const.

C++ documentation:

Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false.

A class is considered to inherit itself.

Example:

QTimer *timer = new QTimer;         // QTimer inherits QObject
timer->inherits(“QTimer”);          // returns true
timer->inherits(“QObject”);         // returns true
timer->inherits(“QAbstractButton”); // returns false
// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits(“QObject”);        // returns true
layout->inherits(“QLayoutItem”);    // returns true (even though QLayoutItem is not a QObject)

If you need to determine whether an object is an instance of a particular class for the purpose of casting it, consider using qobject_cast<Type *>(object) instead.

See also metaObject() and qobject_cast().

pub unsafe fn install_event_filter( &self, filter_obj: impl CastInto<Ptr<QObject>> )

Installs an event filter filterObj on this object. For example:

Calls C++ function: void QObject::installEventFilter(QObject* filterObj).

C++ documentation:

Installs an event filter filterObj on this object. For example:

  monitoredObj->installEventFilter(filterObj);

An event filter is an object that receives all events that are sent to this object. The filter can either stop the event or forward it to this object. The event filter filterObj receives events via its eventFilter() function. The eventFilter() function must return true if the event should be filtered, (i.e. stopped); otherwise it must return false.

If multiple event filters are installed on a single object, the filter that was installed last is activated first.

Here's a KeyPressEater class that eats the key presses of its monitored objects:

class KeyPressEater : public QObject
{
      Q_OBJECT
      ...
protected:
      bool eventFilter(QObject obj, QEvent event);
};
bool KeyPressEater::eventFilter(QObject obj, QEvent event)
{
      if (event->type() == QEvent::KeyPress) {
          QKeyEvent keyEvent = static_cast<QKeyEvent >(event);
          qDebug(“Ate key press %d”, keyEvent->key());
          return true;
      } else {
          // standard event processing
          return QObject::eventFilter(obj, event);
      }
}

And here's how to install it on two widgets:

KeyPressEater keyPressEater = new KeyPressEater(this);
QPushButton pushButton = new QPushButton(this);
QListView *listView = new QListView(this);
pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

The QShortcut class, for example, uses this technique to intercept shortcut key presses.

Warning: If you delete the receiver object in your eventFilter() function, be sure to return true. If you return false, Qt sends the event to the deleted object and the program will crash.

Note that the filtering object must be in the same thread as this object. If filterObj is in a different thread, this function does nothing. If either filterObj or this object are moved to a different thread after calling this function, the event filter will not be called until both objects have the same thread affinity again (it is not removed).

See also removeEventFilter(), eventFilter(), and event().

pub unsafe fn is_widget_type(&self) -> bool

Returns true if the object is a widget; otherwise returns false.

Calls C++ function: bool QObject::isWidgetType() const.

C++ documentation:

Returns true if the object is a widget; otherwise returns false.

Calling this function is equivalent to calling inherits("QWidget"), except that it is much faster.

pub unsafe fn is_window_type(&self) -> bool

Returns true if the object is a window; otherwise returns false.

Calls C++ function: bool QObject::isWindowType() const.

C++ documentation:

Returns true if the object is a window; otherwise returns false.

Calling this function is equivalent to calling inherits("QWindow"), except that it is much faster.

pub unsafe fn kill_timer(&self, id: c_int)

Kills the timer with timer identifier, id.

Calls C++ function: void QObject::killTimer(int id).

C++ documentation:

Kills the timer with timer identifier, id.

The timer identifier is returned by startTimer() when a timer event is started.

See also timerEvent() and startTimer().

pub unsafe fn meta_object(&self) -> Ptr<QMetaObject>

Returns a pointer to the meta-object of this object.

Calls C++ function: virtual const QMetaObject* QObject::metaObject() const.

C++ documentation:

Returns a pointer to the meta-object of this object.

A meta-object contains information about a class that inherits QObject, e.g. class name, superclass name, properties, signals and slots. Every QObject subclass that contains the Q_OBJECT macro will have a meta-object.

The meta-object information is required by the signal/slot connection mechanism and the property system. The inherits() function also makes use of the meta-object.

If you have no pointer to an actual object instance but still want to access the meta-object of a class, you can use staticMetaObject.

Example:

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns “QPushButton”
QPushButton::staticMetaObject.className();  // returns “QPushButton”

See also staticMetaObject.

pub unsafe fn move_to_thread(&self, thread: impl CastInto<Ptr<QThread>>)

Changes the thread affinity for this object and its children. The object cannot be moved if it has a parent. Event processing will continue in the targetThread.

Calls C++ function: void QObject::moveToThread(QThread* thread).

C++ documentation:

Changes the thread affinity for this object and its children. The object cannot be moved if it has a parent. Event processing will continue in the targetThread.

To move an object to the main thread, use QApplication::instance() to retrieve a pointer to the current application, and then use QApplication::thread() to retrieve the thread in which the application lives. For example:

myObject->moveToThread(QApplication::instance()->thread());

If targetThread is zero, all event processing for this object and its children stops.

Note that all active timers for the object will be reset. The timers are first stopped in the current thread and restarted (with the same interval) in the targetThread. As a result, constantly moving an object between threads can postpone timer events indefinitely.

A QEvent::ThreadChange event is sent to this object just before the thread affinity is changed. You can handle this event to perform any special processing. Note that any new events that are posted to this object will be handled in the targetThread.

Warning: This function is not thread-safe; the current thread must be same as the current thread affinity. In other words, this function can only "push" an object from the current thread to another thread, it cannot "pull" an object from any arbitrary thread to the current thread.

See also thread().

pub unsafe fn object_name(&self) -> CppBox<QString>

This property holds the name of this object

Calls C++ function: QString QObject::objectName() const.

C++ documentation:

This property holds the name of this object

You can find an object by name (and type) using findChild(). You can find a set of objects with findChildren().

qDebug(“MyClass::setPrecision(): (%s) invalid precision %f”,
         qPrintable(objectName()), newPrecision);

By default, this property contains an empty string.

Access functions:

QString	objectName() const
void	setObjectName(const QString &name)

Notifier signal:

void

objectNameChanged(const QString &objectName)

[see note below]

Note: This is a private signal. It can be used in signal connections but cannot be emitted by the user.

See also metaObject() and QMetaObject::className().

pub unsafe fn parent(&self) -> QPtr<QObject>

Returns a pointer to the parent object.

Calls C++ function: QObject* QObject::parent() const.

C++ documentation:

Returns a pointer to the parent object.

See also setParent() and children().

pub unsafe fn property(&self, name: *const c_char) -> CppBox<QVariant>

Returns the value of the object's name property.

Calls C++ function: QVariant QObject::property(const char* name) const.

C++ documentation:

Returns the value of the object’s name property.

If no such property exists, the returned variant is invalid.

Information about all available properties is provided through the metaObject() and dynamicPropertyNames().

See also setProperty(), QVariant::isValid(), metaObject(), and dynamicPropertyNames().

pub unsafe fn qt_metacall( &self, arg1: Call, arg2: c_int, arg3: *mut *mut c_void ) -> c_int

Calls C++ function: virtual int QObject::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3).

pub unsafe fn qt_metacast(&self, arg1: *const c_char) -> *mut c_void

Calls C++ function: virtual void* QObject::qt_metacast(const char* arg1).

pub unsafe fn remove_event_filter(&self, obj: impl CastInto<Ptr<QObject>>)

Removes an event filter object obj from this object. The request is ignored if such an event filter has not been installed.

Calls C++ function: void QObject::removeEventFilter(QObject* obj).

C++ documentation:

Removes an event filter object obj from this object. The request is ignored if such an event filter has not been installed.

All event filters for this object are automatically removed when this object is destroyed.

It is always safe to remove an event filter, even during event filter activation (i.e. from the eventFilter() function).

See also installEventFilter(), eventFilter(), and event().

pub unsafe fn set_object_name(&self, name: impl CastInto<Ref<QString>>)

This property holds the name of this object

Calls C++ function: void QObject::setObjectName(const QString& name).

C++ documentation:

This property holds the name of this object

You can find an object by name (and type) using findChild(). You can find a set of objects with findChildren().

qDebug(“MyClass::setPrecision(): (%s) invalid precision %f”,
         qPrintable(objectName()), newPrecision);

By default, this property contains an empty string.

Access functions:

QString	objectName() const
void	setObjectName(const QString &name)

Notifier signal:

void

objectNameChanged(const QString &objectName)

[see note below]

Note: This is a private signal. It can be used in signal connections but cannot be emitted by the user.

See also metaObject() and QMetaObject::className().

pub unsafe fn set_parent(&self, parent: impl CastInto<Ptr<QObject>>)

Makes the object a child of parent.

Calls C++ function: void QObject::setParent(QObject* parent).

C++ documentation:

Makes the object a child of parent.

See also parent() and children().

pub unsafe fn set_property( &self, name: *const c_char, value: impl CastInto<Ref<QVariant>> ) -> bool

Sets the value of the object's name property to value.

Calls C++ function: bool QObject::setProperty(const char* name, const QVariant& value).

C++ documentation:

Sets the value of the object’s name property to value.

If the property is defined in the class using Q_PROPERTY then true is returned on success and false otherwise. If the property is not defined using Q_PROPERTY, and therefore not listed in the meta-object, it is added as a dynamic property and false is returned.

Information about all available properties is provided through the metaObject() and dynamicPropertyNames().

Dynamic properties can be queried again using property() and can be removed by setting the property value to an invalid QVariant. Changing the value of a dynamic property causes a QDynamicPropertyChangeEvent to be sent to the object.

Note: Dynamic properties starting with "_q_" are reserved for internal purposes.

See also property(), metaObject(), dynamicPropertyNames(), and QMetaProperty::write().

pub unsafe fn signals_blocked(&self) -> bool

Returns true if signals are blocked; otherwise returns false.

Calls C++ function: bool QObject::signalsBlocked() const.

C++ documentation:

Returns true if signals are blocked; otherwise returns false.

Signals are not blocked by default.

See also blockSignals() and QSignalBlocker.

pub unsafe fn start_timer_2a( &self, interval: c_int, timer_type: TimerType ) -> c_int

Starts a timer and returns a timer identifier, or returns zero if it could not start a timer.

Calls C++ function: int QObject::startTimer(int interval, Qt::TimerType timerType = …).

C++ documentation:

Starts a timer and returns a timer identifier, or returns zero if it could not start a timer.

A timer event will occur every interval milliseconds until killTimer() is called. If interval is 0, then the timer event occurs once every time there are no more window system events to process.

The virtual timerEvent() function is called with the QTimerEvent event parameter class when a timer event occurs. Reimplement this function to get timer events.

If multiple timers are running, the QTimerEvent::timerId() can be used to find out which timer was activated.

Example:

class MyObject : public QObject
{
      Q_OBJECT
public:
      MyObject(QObject *parent = 0);
protected:
      void timerEvent(QTimerEvent *event);
};
MyObject::MyObject(QObject *parent)
      : QObject(parent)
{
      startTimer(50);     // 50-millisecond timer
      startTimer(1000);   // 1-second timer
      startTimer(60000);  // 1-minute timer
      using namespace std::chrono;
      startTimer(milliseconds(50));
      startTimer(seconds(1));
      startTimer(minutes(1));
      // since C++14 we can use std::chrono::duration literals, e.g.:
      startTimer(100ms);
      startTimer(5s);
      startTimer(2min);
      startTimer(1h);
}
void MyObject::timerEvent(QTimerEvent *event)
{
      qDebug() << “Timer ID:” << event->timerId();
}

Note that QTimer's accuracy depends on the underlying operating system and hardware. The timerType argument allows you to customize the accuracy of the timer. See Qt::TimerType for information on the different timer types. Most platforms support an accuracy of 20 milliseconds; some provide more. If Qt is unable to deliver the requested number of timer events, it will silently discard some.

The QTimer class provides a high-level programming interface with single-shot timers and timer signals instead of events. There is also a QBasicTimer class that is more lightweight than QTimer and less clumsy than using timer IDs directly.

See also timerEvent(), killTimer(), and QTimer::singleShot().

pub unsafe fn start_timer_1a(&self, interval: c_int) -> c_int

Starts a timer and returns a timer identifier, or returns zero if it could not start a timer.

Calls C++ function: int QObject::startTimer(int interval).

C++ documentation:

Starts a timer and returns a timer identifier, or returns zero if it could not start a timer.

A timer event will occur every interval milliseconds until killTimer() is called. If interval is 0, then the timer event occurs once every time there are no more window system events to process.

The virtual timerEvent() function is called with the QTimerEvent event parameter class when a timer event occurs. Reimplement this function to get timer events.

If multiple timers are running, the QTimerEvent::timerId() can be used to find out which timer was activated.

Example:

class MyObject : public QObject
{
      Q_OBJECT
public:
      MyObject(QObject *parent = 0);
protected:
      void timerEvent(QTimerEvent *event);
};
MyObject::MyObject(QObject *parent)
      : QObject(parent)
{
      startTimer(50);     // 50-millisecond timer
      startTimer(1000);   // 1-second timer
      startTimer(60000);  // 1-minute timer
      using namespace std::chrono;
      startTimer(milliseconds(50));
      startTimer(seconds(1));
      startTimer(minutes(1));
      // since C++14 we can use std::chrono::duration literals, e.g.:
      startTimer(100ms);
      startTimer(5s);
      startTimer(2min);
      startTimer(1h);
}
void MyObject::timerEvent(QTimerEvent *event)
{
      qDebug() << “Timer ID:” << event->timerId();
}

Note that QTimer's accuracy depends on the underlying operating system and hardware. The timerType argument allows you to customize the accuracy of the timer. See Qt::TimerType for information on the different timer types. Most platforms support an accuracy of 20 milliseconds; some provide more. If Qt is unable to deliver the requested number of timer events, it will silently discard some.

The QTimer class provides a high-level programming interface with single-shot timers and timer signals instead of events. There is also a QBasicTimer class that is more lightweight than QTimer and less clumsy than using timer IDs directly.

See also timerEvent(), killTimer(), and QTimer::singleShot().

pub unsafe fn thread(&self) -> QPtr<QThread>

Returns the thread in which the object lives.

Calls C++ function: QThread* QObject::thread() const.

C++ documentation:

Returns the thread in which the object lives.

See also moveToThread().

Trait Implementations

impl CppDeletable for QCoreApplication

unsafe fn delete(&self)

Destroys the QCoreApplication object.

Calls C++ function: virtual [destructor] void QCoreApplication::~QCoreApplication().

C++ documentation:

Destroys the QCoreApplication object.

impl Deref for QCoreApplication

fn deref(&self) -> &QObject

Calls C++ function: QObject* static_cast<QObject*>(QCoreApplication* ptr).

type Target = QObject

The resulting type after dereferencing.

impl DynamicCast<QCoreApplication> for QObject

unsafe fn dynamic_cast(ptr: Ptr<QObject>) -> Ptr<QCoreApplication>

Calls C++ function: QCoreApplication* dynamic_cast<QCoreApplication*>(QObject* ptr).

impl StaticDowncast<QCoreApplication> for QObject

unsafe fn static_downcast(ptr: Ptr<QObject>) -> Ptr<QCoreApplication>

Calls C++ function: QCoreApplication* static_cast<QCoreApplication*>(QObject* ptr).

impl StaticUpcast<QObject> for QCoreApplication

unsafe fn static_upcast(ptr: Ptr<QCoreApplication>) -> Ptr<QObject>

Calls C++ function: QObject* static_cast<QObject*>(QCoreApplication* ptr).