Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/kde/rust-qt-binding-generator
Generate bindings to use Rust code in Qt and QML
https://github.com/kde/rust-qt-binding-generator
Last synced: 3 days ago
JSON representation
Generate bindings to use Rust code in Qt and QML
- Host: GitHub
- URL: https://github.com/kde/rust-qt-binding-generator
- Owner: KDE
- License: gpl-2.0
- Created: 2017-09-05T08:24:08.000Z (about 7 years ago)
- Default Branch: master
- Last Pushed: 2024-04-22T02:46:24.000Z (7 months ago)
- Last Synced: 2024-05-01T12:02:14.191Z (7 months ago)
- Language: Rust
- Homepage: https://invent.kde.org/sdk/rust-qt-binding-generator
- Size: 1.08 MB
- Stars: 806
- Watchers: 33
- Forks: 36
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: ChangeLog
- License: COPYING
- Authors: AUTHORS
Awesome Lists containing this project
README
# Rust Qt Binding Generator
This code generator gets you started quickly to use Rust code from Qt and QML. In other words, it helps to create a Qt based GUI on top of Rust code.
Qt is a mature cross-platform graphical user interface library. Rust is a new programming language with strong compile time checks and a modern syntax.
## Getting started
There are two template projects that help you to get started quickly. One for [Qt Widgets](templates/qt_widgets) and one for [Qt Quick](templates/qt_quick). Just copy these folders as new project and start coding.
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
int main() {
Greeting greeting;
qDebug() << greeting.message();
return 0;
}
```
### Qt Quick with Rust
This Qt Quick (QML) code uses the Rust code written above.
```qml
Rectangle {
Greeting {
id: rust
}
Text {
text: rust.message
}
}
```
## Demo application
The project comes with a demo application that show a Qt user interface based on Rust. It uses all of the features of Object, List and Tree. Reading the demo code is a good way to get started.
Qt Widgets UI with Rust logic
Qt Quick Controls UI with Rust logic
Qt Quick Controls 2 UI with Rust logic
## Docker development environment
To get started quickly, the project comes with a `Dockerfile`. You can start a docker session with the required dependencies with `./docker/docker-bash-session.sh`.
## More information on Qt
* [Initial blog post](https://www.vandenoever.info/blog/2017/09/04/rust_qt_binding_generator.html)
### Tutorials
* [Rust and QML: a timely example](https://www.vandenoever.info/blog/2017/09/10/time_for_rust_and_qml.html)
* [To do a Rust GUI](https://www.vandenoever.info/blog/2018/06/09/to-do-a-rust-gui.html)
* [Browsing your mail with Rust and Qt](https://www.vandenoever.info/blog/2018/09/16/browsing_your_mail_with_rust_and_qt.html)
### Presentation
* [Qt GUIs with Rust](https://archive.fosdem.org/2018/schedule/event/rust_qt_binding_generator/)
### Information on Qt
* [Qt](http://doc.qt.io/)
* [Qt Examples and tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
* [The QML Book](https://qmlbook.github.io/)
## Issues
Please [report bugs and feature requests](https://bugs.kde.org/enter_bug.cgi?product=rust-qt-binding-generator) in the KDE issue tracker, product "rust-qt-binding-generator".