qmetaobject-rs

The qmetaobject crate allows you to create Qt/QML applications by defining QObjects in Rust. It uses procedural macros to generate QMetaObjects at compile time, enabling you to expose Rust structs as QML types with properties, signals, and methods.

Key Workflow:

1. Use #[derive(QObject)] on a struct to make it a Qt object.
2. Use qt_base_class! to specify the Qt base class (e.g., trait QObject).
3. Use qt_property! to define properties accessible from QML.
4. Use qt_signal! to define signals.
5. Use qt_method! to define slots (methods) callable from QML.
6. Register the type with qml_register_type::<T>(...).
7. Load your QML code using QmlEngine.

use cstr::cstr;
use qmetaobject::prelude::*;

#[derive(QObject, Default)]
struct Greeter {
    base: qt_base_class!(trait QObject),
    name: qt_property!(QString; NOTIFY name_changed),
    name_changed: qt_signal!(),
    compute_greetings: qt_method!(fn compute_greetings(&self, verb: String) -> QString {
        format!("{} {}", verb, self.name.to_string()).into()
    })
}

fn main() {
    qml_register_type::<Greeter>(cstr!("Greeter"), 1, 0, cstr!("Greeter"));
    let mut engine = QmlEngine::new();
    engine.load_data(r#"
        import QtQuick 2.6
        import QtQuick.Window 2.0
        import Greeter 1.0

        Window {
            visible: true
            Greeter {
                id: greeter;
                name: "World"
            }
            Text {
                anchors.centerIn: parent
                text: greeter.compute_greetings("hello")
            }
        }
    "#.into());
    engine.exec();
}

If a specific Qt C++ function is not wrapped by qmetaobject-rs, you can call it directly from Rust using the cpp! macro from the cpp crate.

Setup Requirements

1. Dependencies: Add qttypes (with required features like qtquick), cpp, and cpp_build to your Cargo.toml.
2. Build Script: Copy the build.rs from the qmetaobject repository to your project. This ensures cpp_build runs correctly with the qttypes environment.

Using the cpp! macro

• Verbatim Content: Use {{ ... }} to append content (like #include directives or C++ class definitions) directly to the generated C++ file.
• Runtime Expressions: Use ( ... ) to call C++ expressions. This requires an unsafe block or keyword and allows passing Rust variables as C++ arguments using the [arg as "Type"] syntax.

Example: Calling a method on a QObject

To call a method on a wrapped object, use .get_cpp_object() to get the raw pointer, then pass it into the cpp! macro.

// Example: Calling QQuickItem::setFlag
let obj = self.get_cpp_object();
cpp!(unsafe [obj as "QQuickItem *"] {
    obj->setFlag(QQuickItem::ItemHasContents);
});

// 1. Include headers
cpp! {{
    #include <QtQuick/QQuickItem>
}}

// 2. Call C++ methods
impl Graph {
    fn set_flag(&mut self, flag: QQuickItemFlag) {
        let obj = self.get_cpp_object();
        assert!(!obj.is_null());
        cpp!(unsafe [obj as "QQuickItem *", flag as "QQuickItem::Flag"] {
            obj->setFlag(flag);
        });
    }
}

To create a custom data model in Rust that can be used with Qt, implement the QAbstractItemModel trait on a type that also implements QObject. This trait allows you to override the core methods of Qt's QAbstractItemModel to provide your own data structure to Qt views.

Required Methods

You must implement the following methods to satisfy the core requirements of a model:

• index(&self, row: i32, column: i32, parent: QModelIndex) -> QModelIndex: Returns the model index for a given position.
• parent(&self, index: QModelIndex) -> QModelIndex: Returns the parent index for a given index.
• row_count(&self, parent: QModelIndex) -> i32: Returns the number of rows under the given parent.
• column_count(&self, parent: QModelIndex) -> i32: Returns the number of columns under the given parent.
• data(&self, index: QModelIndex, role: i32) -> QVariant: Returns the data for a specific index and role.

Optional Methods

• set_data(&mut self, index: QModelIndex, value: &QVariant, role: i32) -> bool: Allows modifying data. Defaults to returning false.
• role_names(&self) -> HashMap<i32, QByteArray>: Defines the mapping of integer roles to byte arrays (useful for QML integration). Defaults to an empty map.

use qmetaobject::*;
use std::collections::HashMap;

#[derive(QObject, Default)]
struct MyModel {
    base: qt_base_class!(trait QAbstractItemModel),
}

impl QAbstractItemModel for MyModel {
    fn row_count(&self, _parent: QModelIndex) -> i32 {
        10
    }
    fn column_count(&self, _parent: QModelIndex) -> i32 {
        1
    }
    fn data(&self, index: QModelIndex, _role: i32) -> QVariant {
        // Return data for the row
        QVariant::from(format!("Row {}", index.row()))
    }
    fn index(&self, row: i32, column: i32, parent: QModelIndex) -> QModelIndex {
        self.create_index(row, column, 0)
    }
    fn parent(&self, _index: QModelIndex) -> QModelIndex {
        QModelIndex::new()
    }
}