| Qt Widgets (main.cpp) / Qt Quick (main.qml) |
⟵ UI code, written by hand |
| src/Binding.h |
⟵ generated from binding.json |
| src/Binding.cpp |
| rust/src/interface.rs |
| rust/src/implementation.rs |
⟵ Rust code, written by hand |
To combine Qt and Rust, write an interface in a JSON file. From that, the generator creates Qt code and Rust code. The Qt code can be used directly. The Rust code has two files: interface and implementation. The interface can be used directly.
```json
{
"cppFile": "src/Binding.cpp",
"rust": {
"dir": "rust",
"interfaceModule": "interface",
"implementationModule": "implementation"
},
"objects": {
"Greeting": {
"type": "Object",
"properties": {
"message": {
"type": "QString",
"write": true
}
}
}
}
}
```
This file describes an binding with one object, `Greeting`. `Greeting` has one property: `message`. It is a writable property.
The Rust Qt Binding Generator will create binding source code from this description:
```bash
rust_qt_binding_generator binding.json
```
This will create four files:
* *src/Binding.h*
* *src/Binding.cpp*
* *rust/src/interface.rs*
* rust/src/implementation.rs
Only `implementation.rs` should be changed. The other files are the binding. `implementation.rs` is initialy created with a simple implementation that is shown here with some comments.
```rust
use interface::*;
/// A Greeting
pub struct Greeting {
/// Emit signals to the Qt code.
emit: GreetingEmitter,
/// The message of the person.
message: String,
}
/// Implementation of the binding
/// GreetingTrait is defined in interface.rs
impl GreetingTrait for Greeting {
/// Create a new greeting with default data.
fn new(emit: GreetingEmitter) -> Greeting {
Greeting {
emit: emit,
message: "Hello World!",
}
}
/// The emitter can emit signals to the Qt code.
fn emit(&self) -> &GreetingEmitter {
&self.emit
}
/// Get the message of the Greeting
fn message(&self) -> &str {
&self.message
}
/// Set the message of the Greeting
fn set_message(&mut self, value: String) {
self.message = value;
self.emit.message_changed();
}
}
```
The building block of Qt and QML projects are QObject and the Model View classes. `rust_qt_binding_generator` reads a json file to generate QObject or QAbstractItemModel classes that call into generated Rust files. For each type from the JSON file, a Rust trait is generated that should be implemented.
This way, Rust code can be called from Qt and QML projects.
### Qt Widgets with Rust
This C++ code uses the Rust code written above.
```cpp
#include "Binding.h"
#include 
