CXX-Qt

https://kdab.github.io/cxx-qt/book
Admin
CXX-Qt provides a safe mechanism for bridging between Qt and Rust code, enabling interop, safe...
Tokens:29,424
Snippets:368
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Run the qml_minimal example

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Execute the compiled WebAssembly example using emrun.

```bash
$ emrun ./build/examples/qml_minimal/example_qml_minimal.html
```

--------------------------------

### Run the example project

Source: https://kdab.github.io/cxx-qt/book/getting-started/6-cargo-qt-minimal.html

Execute the project using Cargo from within the repository.

```bash
cargo run -p qml-minimal-no-cmake
```

--------------------------------

### Initialize CMakeLists.txt

Source: https://kdab.github.io/cxx-qt/book/print.html

Basic setup for a CMake project supporting Qt5 and Qt6.

```cmake
cmake_minimum_required(VERSION 3.24)

project(example_qml_minimal)
```

--------------------------------

### Initialize and run the QML application

Source: https://kdab.github.io/cxx-qt/book/getting-started/6-cargo-qt-minimal.html

Set up the QGuiApplication and QQmlApplicationEngine to load the QML interface and start the event loop.

```rust
fn main() {
    // Create the application and engine
    let mut app = QGuiApplication::new();
    let mut engine = QQmlApplicationEngine::new();

    // Load the QML path into the engine
    if let Some(engine) = engine.as_mut() {
        engine.load(&QUrl::from("qrc:/qt/qml/com/kdab/cxx_qt/demo/qml/main.qml"));
    }

    if let Some(engine) = engine.as_mut() {
        let engine: Pin<&mut QQmlEngine> = engine.upcast_pin();
        // Listen to a signal from the QML Engine
        engine
            .on_quit(|_| {
                println!("QML Quit!");
            })
            .release();
    }

    // Start the app
    if let Some(app) = app.as_mut() {
        app.exec();
    }
}
```

--------------------------------

### Run the compiled CXX-Qt example

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Execute the binary generated by the build process to verify the QML application.

```bash
$ ./build/examples/qml_minimal/example_qml_minimal
```

--------------------------------

### Configure CMakeLists.txt for CXX-Qt

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Initial setup for a CXX-Qt project supporting both Qt5 and Qt6.

```cmake
cmake_minimum_required(VERSION 3.24)

project(example_qml_minimal)

# Rust always links against non-debug Windows runtime on *-msvc targets
# Note it is best to set this on the command line to ensure all targets are consistent
# https://github.com/corrosion-rs/corrosion/blob/master/doc/src/common_issues.md#linking-debug-cc-libraries-into-rust-fails-on-windows-msvc-targets
# https://github.com/rust-lang/rust/issues/39016
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
endif()

set(CMAKE_AUTOMOC ON)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CXXQT_QTCOMPONENTS Core Gui Qml QuickControls2 QuickTest Test)
    set(CXXQT_QTCOMPONENTS ${CXXQT_QTCOMPONENTS} QmlImportScanner)
if(NOT USE_QT5)
    find_package(Qt6 COMPONENTS ${CXXQT_QTCOMPONENTS})
    set(Qt "Qt6")
endif()
if(NOT Qt6_FOUND)
    find_package(Qt5 5.15 COMPONENTS ${CXXQT_QTCOMPONENTS} REQUIRED)
    set(Qt "Qt5")
endif()

if(MSVC)
    # Qt also needs to link against the non-debug version of the MSVC Runtime libraries.
    # Note: The Qt:: targets are ALIAS targets that do not support setting properties directly.
    # We therefore need to resolve the target names to either Qt5 or Qt6 directly.
    set_property(
        TARGET ${Qt}::Core ${Qt}::Gui ${Qt}::Qml ${Qt}::QuickControls2 ${Qt}::QuickTest ${Qt}::Test
        PROPERTY MAP_IMPORTED_CONFIG_DEBUG "RELEASE")
endif()
```

--------------------------------

### Verify QMake Installation

Source: https://kdab.github.io/cxx-qt/book/getting-started/index.html

Check that the qmake executable is available in the system path.

```bash
$ qmake --version
QMake version 3.1
Using Qt version 6.5.1 in /usr/lib64
```

--------------------------------

### Install Specific Emscripten Version

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Example command to install Emscripten version 3.1.14 for use with Qt 6.4.

```bash
$ ./emsdk install 3.1.14
```

--------------------------------

### Install and Activate Emscripten

Source: https://kdab.github.io/cxx-qt/book/print.html

Commands to initialize the Emscripten environment for a specific version.

```bash
$ ./emsdk install <emscripten version>
$ ./emsdk activate <emscripten version>
$ source ./emsdk_env.sh
```

```bash
$ ./emsdk install 3.1.14
```

--------------------------------

### Initialize Emscripten SDK

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Commands to install, activate, and source the environment for a specific Emscripten version.

```bash
$ ./emsdk install <emscripten version>
$ ./emsdk activate <emscripten version>
$ source ./emsdk_env.sh
```

--------------------------------

### Linker Error Example

Source: https://kdab.github.io/cxx-qt/book/common-issues.html

Example of an undefined reference error occurring during the build process when initializers are not found.

```text
= note: /.../out/cxx-qt-build/qml_module_com_kdab_cxx_qt_demo/call-initializers.cpp:2:
          error: undefined reference to 'cxx_qt_init_qml_module_com_kdab_cxx_qt_demo'
        /.../out/cxx-qt-build/initializers/crate_another_crate/call-initializers.cpp:2:
          error: undefined reference to 'cxx_qt_init_crate_another_crate'
        clang: error: linker command failed with exit code 1 (use -v to see invocation)

  = note: some `extern` functions couldn't be found; some native libraries may need to be installed or have their path specified
  = note: use the `-l` flag to specify native libraries to link
  = note: use the `cargo:rustc-link-lib` directive to specify the native libraries to link with Cargo (see https://doc.rust-lang.org/cargo/reference/build-scripts.html#rustc-link-lib)
```

--------------------------------

### Configure CXX-Qt with qt-cmake

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Use the qt-cmake binary provided with the Qt for WebAssembly installation to configure the build.

```bash
$ /path/to/qt-cmake -DBUILD_WASM=ON -B build .
```

--------------------------------

### Include Generated CXX-Qt Header

Source: https://kdab.github.io/cxx-qt/book/print.html

Example of how to include the generated header file for a CXX-Qt object.

```cpp
#include <qml_minimal/src/cxxqt_object.cxxqt.h>
```

--------------------------------

### Explicit Trait Implementation Examples

Source: https://kdab.github.io/cxx-qt/book/bridge/traits.html

Demonstrates the syntax for explicit CXX and CXX-Qt trait implementations for a type A.

```rust
impl UniquePtr<A> {} // explicit CXX trait implementation of UniquePtr for A

impl cxx_qt::Trait for A {} // explicit CXX-Qt trait implementation of Trait for A
```

--------------------------------

### Define QML interface

Source: https://kdab.github.io/cxx-qt/book/print.html

Example of using the Rust-defined QObject within a QML file.

```qml
import QtQuick 2.12
import QtQuick.Controls 2.12
import QtQuick.Window 2.12

// This must match the uri and version
// specified in the qml_module in the build.rs script.
import com.kdab.cxx_qt.demo 1.0

ApplicationWindow {
    id: root
    height: 480
    title: qsTr("Hello World")
    visible: true
    width: 640
    color: palette.window

    readonly property MyObject myObject: MyObject {
        number: 1
        string: qsTr("My String with my number: %1").arg(number)
    }
```

--------------------------------

### Build and Run Project

Source: https://kdab.github.io/cxx-qt/book/print.html

Commands to configure, build, and execute the CXX-Qt application.

```bash
$ cmake -S . -B build
$ cmake --build build
```

```bash
$ ./build/examples/qml_minimal/example_qml_minimal
```

--------------------------------

### Initialize main.cpp for CMake integration

Source: https://kdab.github.io/cxx-qt/book/print.html

Include necessary Qt headers for the C++ entry point.

```cpp
#include <QtGui/QGuiApplication>
#include <QtQml/QQmlApplicationEngine>
```

--------------------------------

### Main C++ Entry Point

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Standard main.cpp file for initializing a QML application engine.

```cpp
#include <QtGui/QGuiApplication>
#include <QtQml/QQmlApplicationEngine>

int
main(int argc, char* argv[])
{
  QGuiApplication app(argc, argv);

  QQmlApplicationEngine engine;

  const QUrl url(
    QStringLiteral("qrc:/qt/qml/com/kdab/cxx_qt/demo/qml/main.qml"));
  QObject::connect(
    &engine,
    &QQmlApplicationEngine::objectCreated,
    &app,
    [url](QObject* obj, const QUrl& objUrl) {
      if (!obj && url == objUrl)
        QCoreApplication::exit(-1);
    },
    Qt::QueuedConnection);

  engine.load(url);

  return app.exec();
}
```

--------------------------------

### Build and run the application

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Compile the project using CMake and execute the resulting HTML file using emrun.

```bash
$ cmake --build build
```

```bash
$ emrun ./build/path/to/<appname>.html
```

--------------------------------

### Verify Project Structure

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Display the expected directory structure of the CXX-Qt project.

```bash
$ tree -I target/ -I tests
.
├── CMakeLists.txt
├── cpp
│   └── main.cpp
├── qml
│   └── main.qml
└── rust
    ├── build.rs
    ├── Cargo.toml
    └── src
        ├── cxxqt_object.rs
        └── lib.rs

5 directories, 7 files
```

--------------------------------

### Import CXX-Qt modules in main.rs

Source: https://kdab.github.io/cxx-qt/book/getting-started/6-cargo-qt-minimal.html

Include the generated CXX-Qt module and necessary Qt library types in the application entry point.

```rust
pub mod cxxqt_object;

use cxx_qt::casting::Upcast;
use cxx_qt_lib::{QGuiApplication, QQmlApplicationEngine, QQmlEngine, QUrl};
use std::pin::Pin;
```

--------------------------------

### Project Directory Structure

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Recommended layout for separating C++, QML, and Rust components.

```text
tutorial
  - cpp
  - qml
  - rust
```

--------------------------------

### Fetch CXX-Qt via CMake FetchContent

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Download and include CXX-Qt dependencies if not already found on the system.

```cmake
find_package(CxxQt QUIET)
if(NOT CxxQt_FOUND)
    include(FetchContent)
    FetchContent_Declare(
        CxxQt
        GIT_REPOSITORY https://github.com/kdab/cxx-qt-cmake.git
        GIT_TAG 0.9.0
    )

    FetchContent_MakeAvailable(CxxQt)
endif()
```

--------------------------------

### Build the project

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Compile and link the project using the standard CMake build command.

```bash
$ cmake --build build
```

--------------------------------

### Initialize QML Application Engine in C++

Source: https://kdab.github.io/cxx-qt/book/print.html

Standard C++ entry point for a Qt QML application using QQmlApplicationEngine.

```cpp
int
main(int argc, char* argv[])
{
  QGuiApplication app(argc, argv);

  QQmlApplicationEngine engine;

  const QUrl url(
    QStringLiteral("qrc:/qt/qml/com/kdab/cxx_qt/demo/qml/main.qml"));
  QObject::connect(
    &engine,
    &QQmlApplicationEngine::objectCreated,
    &app,
    [url](QObject* obj, const QUrl& objUrl) {
      if (!obj && url == objUrl)
        QCoreApplication::exit(-1);
    },
    Qt::QueuedConnection);

  engine.load(url);

  return app.exec();
}
```

--------------------------------

### Configure CXX-Qt with standard CMake

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Use a standard CMake binary by specifying the Qt toolchain file manually.

```bash
$ <cmake binary> -DCMAKE_TOOLCHAIN_FILE=/path/to/qt.toolchain.cmake -DBUILD_WASM=ON -B build .
```

--------------------------------

### Initialize a new Cargo project

Source: https://kdab.github.io/cxx-qt/book/getting-started/2-our-first-cxx-qt-module.html

Commands to create a new Rust project directory and navigate into it.

```bash
$ cargo new qml_minimal
$ cd qml_minimal
```

--------------------------------

### Instantiate QObject with Constructor Parameters

Source: https://kdab.github.io/cxx-qt/book/concepts/instantiating_in_rust.html

Use renamed helper methods to support overloaded constructors with different parameters.

```rust
#[namespace = "rust::cxxqtlib1"]
unsafe extern "C++" {
    include!("cxx-qt-lib/common.h");

    #[rust_name = "new_my_object_with_parent"]
    fn make_unique(parent: *mut QObject) -> UniquePtr<MyObject>;
    
    // Overloading without the parent parameter
    #[rust_name = "new_my_object"]
    fn make_unique() -> UniquePtr<MyObject>;
}
```

--------------------------------

### Manual Initialization

Source: https://kdab.github.io/cxx-qt/book/common-issues.html

Manually call initialization macros at startup to resolve linker issues with older linkers.

```rust
fn main() {
  cxx_qt::init_crate!(another_crate);
  cxx_qt::init_qml_module!("com.kdab.cxx_qt.demo");
}
```

--------------------------------

### Configure Cargo.toml for CXX-Qt

Source: https://kdab.github.io/cxx-qt/book/getting-started/6-cargo-qt-minimal.html

Define project dependencies and build-time requirements, including the qt_minimal feature for automatic Qt retrieval.

```toml
[package]
name = "qml_minimal"
version = "0.1.0"
edition = "2021"
license = "MIT OR Apache-2.0"

[dependencies]
cxx = "1.0.95"
cxx-qt = "0.9"
cxx-qt-lib = { version="0.9", features = ["qt_full"] }

[build-dependencies]
# The link_qt_object_files feature is required for statically linking Qt 6.
cxx-qt-build = { version = "0.9", features = [ "link_qt_object_files" ] }

# Enable the qt_minimal feature in qt-build-utils
# this allows for automatically downloading Qt when not found with qmake
qt-build-utils = { version = "0.9", features = ["qt_minimal"] }
# Indicate which Qt version is required via features
qt-version = { version = "0.1", features = ["qt_version_at_least_6_10"] }
```

--------------------------------

### Build with QMAKE Environment Variable

Source: https://kdab.github.io/cxx-qt/book/getting-started/index.html

Specify the path to the qmake executable during the build process if it is not in the system PATH.

```bash
QMAKE=/usr/bin/qmake cargo build
```

--------------------------------

### Configure build with qt-cmake

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Use the bundled qt-cmake binary to automatically set the toolchain file for Qt 6.4.2.

```bash
$ /path/to/Qt/6.4.2/wasm_32/bin/qt-cmake -B build .
```

--------------------------------

### Build script configuration

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

The build.rs file used to generate and compile C++ code for CXX-Qt objects.

```rust
use cxx_qt_build::{CxxQtBuilder, QmlModule};

fn main() {
    CxxQtBuilder::new_qml_module(
        QmlModule::new("com.kdab.cxx_qt.demo").qml_file("../qml/main.qml"),
    )
    .qt_module("Qml")
    .files(["src/cxxqt_object.rs"])
    .build();
}
```

--------------------------------

### Instantiate QObjects in Rust

Source: https://kdab.github.io/cxx-qt/book/print.html

Exposes CXX-Qt helper templates to create QObject instances directly in Rust, wrapped in a UniquePtr.

```rust
#[namespace = "rust::cxxqtlib1"]
unsafe extern "C++" {
    include!("cxx-qt-lib/common.h");

    #[cxx_name = "make_unique"]
    #[doc(hidden)]
    fn myobject_make_unique() -> UniquePtr<MyObject>;
}
```

```rust
#[namespace = "rust::cxxqtlib1"]
unsafe extern "C++" {
    include!("cxx-qt-lib/common.h");
```

--------------------------------

### Define build.rs for CXX-Qt

Source: https://kdab.github.io/cxx-qt/book/getting-started/6-cargo-qt-minimal.html

Use CxxQtBuilder to compile Rust files and link necessary Qt modules during the build process.

```rust
use cxx_qt_build::{CxxQtBuilder, QmlModule};

fn main() {
    CxxQtBuilder::new_qml_module(QmlModule::new("com.kdab.cxx_qt.demo").qml_file("qml/main.qml"))
        // Link Qt's Network library
        // - Qt Core is always linked
        // - Qt Gui is linked by enabling the qt_gui Cargo feature of cxx-qt-lib.
        // - Qt Qml is linked by enabling the qt_qml Cargo feature of cxx-qt-lib.
        // - Qt Qml requires linking Qt Network on macOS
        .qt_module("Network")
        .files(["src/cxxqt_object.rs"])
        .build();
}
```

--------------------------------

### Configure CMake for WebAssembly

Source: https://kdab.github.io/cxx-qt/book/print.html

Commands to configure the build directory using the Qt toolchain file.

```bash
$ /path/to/Qt/6.4.2/wasm_32/bin/qt-cmake -B build .
```

```bash
$ cmake -DCMAKE_TOOLCHAIN_FILE=/path/to/qt.toolchain.cmake -B build .
```

--------------------------------

### Include C++ base class header

Source: https://kdab.github.io/cxx-qt/book/bridge/extern_rustqt.html

Use the include! macro within an unsafe extern "C++Qt" block to make the base class available.

```rust
    unsafe extern "C++Qt" {
        include!(<QtCore/QAbstractListModel>);
        /// Base for Qt type
        #[qobject]
        type QAbstractListModel;
    }
```

--------------------------------

### Implement QObject constructors

Source: https://kdab.github.io/cxx-qt/book/bridge/extern_rustqt.html

Use the Initialize or Constructor traits to define how the QObject is instantiated.

```rust
impl cxx_qt::Initialize for x {}
```

```rust
impl cxx_qt::Constructor<()> for x {}
```

--------------------------------

### Configure Cargo.toml for CXX-Qt

Source: https://kdab.github.io/cxx-qt/book/print.html

Defines the static library crate type and required dependencies for CXX-Qt projects.

```toml
[lib]
crate-type = ["staticlib"]

[dependencies]
cxx = "1.0.95"
cxx-qt = "0.9"
cxx-qt-lib = { version="0.9", features = ["qt_full"] }

[build-dependencies]
# The link_qt_object_files feature is required for statically linking Qt 6.
cxx-qt-build = { version = "0.9", features = [ "link_qt_object_files" ] }
```

--------------------------------

### Configure QObject for QML registration

Source: https://kdab.github.io/cxx-qt/book/bridge/extern_rustqt.html

Apply attributes like #[qml_element] and #[qproperty] to expose the QObject to QML.

```rust
// The QObject definition
// We tell CXX-Qt that we want a QObject class with the name MyObject
// based on the Rust struct MyObjectRust.
#[qobject]
#[qml_element]
#[qproperty(i32, number)]
#[qproperty(QString, string)]
#[namespace = "my_object"]
type MyObject = super::MyObjectRust;
```

--------------------------------

### Configure Cargo dependencies for CXX-Qt

Source: https://kdab.github.io/cxx-qt/book/print.html

Add the cxx-qt-build dependency with the link_qt_object_files feature to your Cargo.toml.

```toml
cxx-qt-build = { version = "0.9", features = [ "link_qt_object_files" ] }
```

--------------------------------

### Manage connection lifecycle

Source: https://kdab.github.io/cxx-qt/book/bridge/extern_rustqt.html

Connections are managed via QMetaObjectConnectionGuard, which disconnects automatically when dropped.

```rust
                // By making connections None, we trigger a drop on the connections
                // this then causes disconnections
                qobject.as_mut().rust_mut().connections = None;
```

--------------------------------

### demo_threading build error

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Compilation error in socket2 dependency caused by incorrect target environment resolution.

```text
error[E0433]: failed to resolve: use of undeclared type `IovLen`
```

--------------------------------

### Link Executable to CXX-Qt Targets

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Create the CMake executable and link it to the imported QML module.

```cmake
    add_executable(example_qml_minimal cpp/main.cpp)

# Link to the qml module, which in turn links to the Rust qml_minimal library
target_link_libraries(example_qml_minimal PRIVATE qml_minimal_qml_module)

# If we are using a statically linked Qt then we need to import any qml plugins
qt_import_qml_plugins(example_qml_minimal)
```

--------------------------------

### Import required CXX-Qt types

Source: https://kdab.github.io/cxx-qt/book/getting-started/2-our-first-cxx-qt-module.html

Ensure necessary types like Pin and QString are imported for the implementation.

```rust
use core::pin::Pin;
use cxx_qt_lib::QString;
```

--------------------------------

### Initial Cargo.toml structure

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

The default Cargo.toml file generated by cargo new or cargo init.

```toml
[package]
name = "qml_minimal"
version = "0.1.0"
edition = "2021"

[dependencies]
```

--------------------------------

### Import Rust Crate and QML Module

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Use CXX-Qt wrappers to import a Rust crate and its associated QML module into CMake.

```cmake
# CXX-Qt (using Corrosion) creates a CMake target with the same name as the crate.
cxx_qt_import_crate(
    MANIFEST_PATH rust/Cargo.toml 
    CRATES qml_minimal 
    LOCKED
    QT_MODULES Qt::Core Qt::Gui Qt::Qml Qt::QuickControls2
)

cxx_qt_import_qml_module(qml_minimal_qml_module
    URI "com.kdab.cxx_qt.demo"
    SOURCE_CRATE qml_minimal)
```

--------------------------------

### Initialization in Tests

Source: https://kdab.github.io/cxx-qt/book/common-issues.html

Ensure dependencies are initialized within tests and documentation tests.

```rust
/// ```
/// # cxx_qt::init_crate!(another_crate);
/// # cxx_qt::init_qml_module!(another_crate);
///
/// X::do_something();
/// ```
struct X {}

#[cfg(test)]
mod tests {
  #[test]
  fn initialize_eependencies() {
    cxx_qt::init_crate!(another_crate);
    cxx_qt::init_qml_module!("com.kdab.cxx_qt.demo");
  }
}
```

--------------------------------

### Declare the CXX-Qt module

Source: https://kdab.github.io/cxx-qt/book/getting-started/2-our-first-cxx-qt-module.html

Add the module declaration to the main.rs file to inform Cargo about the new component.

```rust
pub mod cxxqt_object;
```

--------------------------------

### Lint QML files with qmllint

Source: https://kdab.github.io/cxx-qt/book/concepts/build_systems.html

Use the -I flag to point qmllint to the generated QML modules directory for type checking.

```bash
qmllint -I /path/to/cxxqt/qml_modules /path/to/test.qml
```

--------------------------------

### Configure build with manual toolchain file

Source: https://kdab.github.io/cxx-qt/book/concepts/wasm-builds.html

Manually specify the toolchain file when using a CMake version newer than the one bundled with older Qt versions.

```bash
$ cmake -DCMAKE_TOOLCHAIN_FILE=/path/to/qt.toolchain.cmake -B build .
```

--------------------------------

### Instantiate QObject with UniquePtr

Source: https://kdab.github.io/cxx-qt/book/concepts/instantiating_in_rust.html

Expose the make_unique helper to create a UniquePtr instance of a QObject in Rust.

```rust
#[namespace = "rust::cxxqtlib1"]
unsafe extern "C++" {
    include!("cxx-qt-lib/common.h");

    #[cxx_name = "make_unique"]
    #[doc(hidden)]
    fn myobject_make_unique() -> UniquePtr<MyObject>;
}
```

--------------------------------

### Call base class implementation

Source: https://kdab.github.io/cxx-qt/book/print.html

Demonstrates calling a base class method by using #[inherit] alongside #[cxx_name] to avoid naming conflicts.

```rust
    extern "RustQt" {
        #[qobject]
        #[base = QAbstractListModel]
        type AbstractBaseClass = super::AbstractBaseClassRust;

        #[qobject]
        #[base = AbstractBaseClass]
        #[qml_element]
        #[qproperty(State, state)]
        type CustomBaseClass = super::CustomBaseClassRust;
    }

    unsafe extern "RustQt" {
        /// Inherited canFetchMore from the base class
        #[cxx_name = "canFetchMore"]
        #[inherit]
        fn base_can_fetch_more(self: &CustomBaseClass, parent: &QModelIndex) -> bool;

        /// Inherited index from the base class
        #[inherit]
        fn index(
            self: &CustomBaseClass,
            row: i32,
            column: i32,
            parent: &QModelIndex,
        ) -> QModelIndex;
    }

    extern "RustQt" {
        /// Return whether the base class can fetch more
        // Example of overriding a C++ virtual method and calling the base class implementation.
        #[qinvokable]
        #[cxx_override]
        #[cxx_name = "canFetchMore"]
        fn can_fetch_more(self: &CustomBaseClass, parent: &QModelIndex) -> bool;
    }
```

--------------------------------

### Connect to signals

Source: https://kdab.github.io/cxx-qt/book/bridge/extern_rustqt.html

Use the generated on_<signal_name> or connect_<signal_name> methods to handle signal emissions.

```rust
                    let connections = [
                        qobject.as_mut().on_connected(|_, url| {
                            println!("Connected: {}", url);
                        }),
                        qobject.as_mut().on_disconnected(|_| {
                            println!("Disconnected");
                        }),
                        // Demonstration of connecting with a different connection type
                        qobject.as_mut().connect_error(
                            |_, message| {
                                println!("Error: {}", message);
                            },
                            ConnectionType::QueuedConnection,
                        ),
                    ];
                    qobject.as_mut().rust_mut().connections = Some(connections);
```

--------------------------------

### Expose Base Class Methods with #[inherit]

Source: https://kdab.github.io/cxx-qt/book/concepts/inheritance.html

Use the #[inherit] macro within an extern "RustQt" block to bind C++ base class methods to Rust. Ensure that safety requirements for methods like beginInsertRows are met by calling their corresponding end methods.

```rust
    extern "RustQt" {
        #[qobject]
        #[base = QAbstractListModel]
        type AbstractBaseClass = super::AbstractBaseClassRust;

        #[qobject]
        #[base = AbstractBaseClass]
        #[qml_element]
        #[qproperty(State, state)]
        type CustomBaseClass = super::CustomBaseClassRust;
    }

    // Create Rust bindings for C++ functions of the base class (QAbstractItemModel)
    extern "RustQt" {
        /// # Safety
        ///
        /// Inherited beginInsertRows from the base class.
        /// If you call begin_insert_rows, it is your responsibility to ensure end_insert_rows is called
        #[inherit]
        #[cxx_name = "beginInsertRows"]
        unsafe fn begin_insert_rows(
            self: Pin<&mut CustomBaseClass>,
            parent: &QModelIndex,
            first: i32,
            last: i32,
        );
        /// # Safety
        ///
        /// Inherited endInsertRows from the base class.
        /// If you call `begin_insert_rows`, it is your responsibility to ensure `end_insert_rows` is called
        #[inherit]
        #[cxx_name = "endInsertRows"]
        unsafe fn end_insert_rows(self: Pin<&mut CustomBaseClass>);

        /// # Safety
        ///
        /// Inherited beginRemoveRows from the base class.
        /// If you call `begin_remove_rows`, it is your responsibility to ensure `end_remove_rows` is called
        #[inherit]
        #[cxx_name = "beginRemoveRows"]
        unsafe fn begin_remove_rows(
            self: Pin<&mut CustomBaseClass>,
            parent: &QModelIndex,
            first: i32,
            last: i32,
        );
        /// # Safety
        ///
        /// Inherited endRemoveRows from the base class.
        /// If you call `begin_remove_rows`, it is your responsibility to ensure `end_remove_rows` is called
        #[inherit]
        #[cxx_name = "endRemoveRows"]
        unsafe fn end_remove_rows(self: Pin<&mut CustomBaseClass>);

        /// # Safety
        ///
        /// Inherited beginResetModel from the base class.
        /// If you call `begin_reset_model`, it is your responsibility to ensure `end_reset_model` is called
        #[inherit]
        #[cxx_name = "beginResetModel"]
        unsafe fn begin_reset_model(self: Pin<&mut CustomBaseClass>);
        /// # Safety
        ///
        /// Inherited endResetModel from the base class.
        /// If you call `begin_reset_model`, it is your responsibility to ensure `end_reset_model` is called
        #[inherit]
        #[cxx_name = "endResetModel"]
        unsafe fn end_reset_model(self: Pin<&mut CustomBaseClass>);
    }

    extern "RustQt" {
        /// Clear the rows in the QAbstractListModel
        #[qinvokable]
        pub fn clear(self: Pin<&mut CustomBaseClass>);
    }
```

--------------------------------

### Implement QObject Logic in Rust

Source: https://kdab.github.io/cxx-qt/book/print.html

Implement the logic for the QObject methods and define the backing Rust struct.

```rust
use core::pin::Pin;
use cxx_qt_lib::QString;

/// The Rust struct for the QObject
#[derive(Default)]
pub struct MyObjectRust {
    number: i32,
    string: QString,
}

impl qobject::MyObject {
    /// Increment the number Q_PROPERTY
    pub fn increment_number(self: Pin<&mut Self>) {
        let previous = *self.number();
        self.set_number(previous + 1);
    }

    /// Print a log message with the given string and number
    pub fn say_hi(&self, string: &QString, number: i32) {
        println!("Hi from Rust! String is '{string}' and number is {number}");
    }
}
```

--------------------------------

### Configure Qt target properties for MSVC

Source: https://kdab.github.io/cxx-qt/book/getting-started/5-cmake-integration.html

Force Qt components to use the Release runtime in Debug configurations to avoid binary incompatibility with Rust's default runtime.

```cmake
# Note: The Qt:: targets are ALIAS targets that do not support setting properties directly.
# We therefore need to resolve the target names to either Qt5 or Qt6 directly.
set_property(
    TARGET Qt6::Core Qt6::Gui Qt6::Qml Qt6::Test Qt6::QuickControls2
    PROPERTY MAP_IMPORTED_CONFIG_DEBUG "RELEASE")
```

--------------------------------

### Define a QML interface for a Rust QObject

Source: https://kdab.github.io/cxx-qt/book/getting-started/3-qml-gui.html

This QML file defines an ApplicationWindow that interacts with a Rust-defined MyObject, utilizing property bindings and button signals.

```qml
import QtQuick 2.12
import QtQuick.Controls 2.12
import QtQuick.Window 2.12

// This must match the uri and version
// specified in the qml_module in the build.rs script.
import com.kdab.cxx_qt.demo 1.0

ApplicationWindow {
    id: root
    height: 480
    title: qsTr("Hello World")
    visible: true
    width: 640
    color: palette.window

    readonly property MyObject myObject: MyObject {
        number: 1
        string: qsTr("My String with my number: %1").arg(number)
    }

    Column {
        anchors.fill: parent
        anchors.margins: 10
        spacing: 10

        Label {
            text: qsTr("Number: %1").arg(root.myObject.number)
            color: palette.text
        }

        Label {
            text: qsTr("String: %1").arg(root.myObject.string)
            color: palette.text
        }

        Button {
            text: qsTr("Increment Number")

            onClicked: root.myObject.incrementNumber()
        }

        Button {
            text: qsTr("Say Hi!")

            onClicked: root.myObject.sayHi(root.myObject.string, root.myObject.number)
        }

        Button {
            text: qsTr("Quit")

            onClicked: Qt.quit()
        }
    }
}
```

--------------------------------

### Include Qt types in the bridge

Source: https://kdab.github.io/cxx-qt/book/getting-started/2-our-first-cxx-qt-module.html

Use the cxx_qt_lib crate to expose Qt types like QString to the bridge.

```rust
    unsafe extern "C++" {
        include!("cxx-qt-lib/qstring.h");
        /// An alias to the QString type
        type QString = cxx_qt_lib::QString;
    }
```
Tokens:
Raw