Struct QApp 

pub struct QApp { /* private fields */ }

Entry point for a QML application.

Wraps the Qt application and QML engine. Configure it with the builder methods and call run to start the event loop.

Example

A minimal “Hello World” application without a Rust backend:

QApp::new()
    .load_qml(br#"
        import QtQuick
        import QtQuick.Controls
        Text {
            text: "Hello Rust!"
        }"#)
    .run();

Implementations

impl QApp

pub fn new() -> QApp

Creates the Qt application and QML engine.

Must be called before any QML or GUI functionality is used.

pub fn run(&mut self) -> i32

Enters the Qt main event loop.

Blocks until the application exits and returns the exit code. Usually the last call in main.

pub fn set_initial_property( &mut self, id: &str, value: impl Into<QVariant>, ) -> &mut QApp

Queues an initial property to be set on the root QML object.

Properties are applied when load_qml or load_qml_from_file is called. Call multiple times to set several properties.

Example

let prop = 42;

QApp::new()
.set_initial_property("answer", &prop)
.load_qml(br#"
    import QtQuick
    import QtQuick.Controls
    ApplicationWindow {
        required property var answer
    }"#)
.run();

pub fn set_initial_object<T>( &mut self, id: &str, object: Rc<RefCell<T>>, ) -> &mut QApp

where T: QObjectHolder,

Sets a #[qobject] instance as initial property on the root QML object, attaching a QObject to it first if none exists.

Must be called before load_qml or load_qml_from_file. Call multiple times to set several objects.

Example

#[derive(Default)]
pub struct Backend {
}
#[qobject]
impl Backend {
}

let backend = Rc::new(RefCell::new(Backend::default()));

QApp::new()
    .set_initial_object("backend", backend)
    .load_qml(br#"
        import QtQuick
        Item {
            required property var backend
        }"#)
    .run();

pub fn load_qml(&mut self, code: &[u8]) -> &mut QApp

Loads QML source from an in-memory byte slice.

Applies any properties queued with set_initial_property before loading.

pub fn load_qml_from_file(&mut self, url: &str) -> &mut QApp

Loads the entry-point QML file by URL.

Use this instead of load_qml when the QML is embedded in a Qt resource (qrc:) or accessible as a file path. Accepts URLs such as "qrc:/qt/qml/MyApp/Main.qml" or "file:///path/to/main.qml".

Import paths for any modules the file uses must be registered with add_import_path before this call.

pub fn add_import_path(&mut self, path: &str) -> &mut QApp

Adds a directory to the QML engine’s module import search path.

Call before load_qml_from_file when the loaded QML imports modules from a directory the engine would not otherwise find. Accepts both URLs and file-system paths.

pub fn register<T>(&mut self) -> &mut QApp

where T: QmlElement,

Registers T with the QML type system, making it instantiable from QML.

#[derive(Default)]
pub struct Backend {
}
#[qobject]
impl Backend {
}

QApp::new()
    .register::<Backend>()
    .load_qml(br#"
        import QtQuick
        import QtQuick.Controls
        ApplicationWindow {
            Backend {}
     }"#)
    .run();

pub fn application_name(&mut self, name: &str) -> &mut QApp

Sets the application name reported to the OS.

Trait Implementations

impl Drop for QApp

fn drop(&mut self)

Executes the destructor for this type.