diff --git a/README.md b/README.md
index d6e23a8..1f77adb 100644
--- a/README.md
+++ b/README.md
@@ -6,21 +6,47 @@ This code generator gets you started quickly to use Rust code from Qt and QML. I
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/person.cpp",
+ "cppFile": "src/Binding.cpp",
"rust": {
"dir": "rust",
"interfaceModule": "interface",
"implementationModule": "implementation"
},
"objects": {
- "Person": {
+ "Greeting": {
"type": "Object",
"properties": {
- "name": {
+ "message": {
"type": "QString",
"write": true
}
@@ -30,7 +56,7 @@ To combine Qt and Rust, write an interface in a JSON file. From that, the genera
}
```
-This file describes an binding with one object, `Person`. `Person` has one property: `name`. It is a writable property.
+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:
@@ -40,45 +66,46 @@ rust_qt_binding_generator binding.json
This will create four files:
-* *src/person.h*
-* *src/person.cpp*
-* rust/src/implementation.rs
+* *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 Person
-pub struct Person {
+/// A Greeting
+pub struct Greeting {
/// Emit signals the the Qt code.
- emit: PersonEmitter,
- /// The name of the person.
- name: String,
+ emit: GreetingEmitter,
+ /// The message of the person.
+ message: String,
}
/// Implementation of the binding
-impl PersonTrait for Person {
- /// Create a new person with default data.
- fn new(emit: PersonEmitter) -> Person {
- Person {
+/// 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,
- name: String::new(),
+ message: "Hello World!",
}
}
/// The emitter can emit signals to the Qt code.
- fn emit(&self) -> &PersonEmitter {
+ fn emit(&self) -> &GreetingEmitter {
&self.emit
}
- /// Get the name of the Person
- fn get_name(&self) -> &str {
- &self.name
+ /// Get the message of the Greeting
+ fn get_message(&self) -> &str {
+ &self.message
}
- /// Set the name of the Person
- fn set_name(&mut self, value: String) {
- self.name = value;
- self.emit.name_changed();
+ /// Set the message of the Greeting
+ fn set_message(&mut self, value: String) {
+ self.message = value;
+ self.emit.message_changed();
}
}
```
@@ -87,6 +114,60 @@ The building block of Qt and QML projects are QObject and the Model View classes
This way, Rust code can be called from Qt and QML projects.
-## More information
+### 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.
+
+
+
+
+
+
+
+## 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
+
+* [Qt](http://doc.qt.io/)
+* [Qt Examples and tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
* [The QML Book](https://qmlbook.github.io/)
diff --git a/demo/screenshots/demo.png b/demo/screenshots/demo.png
new file mode 100644
index 0000000..f4c9bdd
Binary files /dev/null and b/demo/screenshots/demo.png differ
diff --git a/demo/screenshots/demo2.png b/demo/screenshots/demo2.png
new file mode 100644
index 0000000..64ae8e4
Binary files /dev/null and b/demo/screenshots/demo2.png differ
diff --git a/demo/screenshots/demo3.png b/demo/screenshots/demo3.png
new file mode 100644
index 0000000..30904e2
Binary files /dev/null and b/demo/screenshots/demo3.png differ