This blog shows how Qt applications can be built with Cargo. The goal is to make compiling them as simple as installing Qt and running

cargo build

qrep and mailmodel are examples. You can try qrep with

cargo install qrep
qrep

Rust Qt Binding Generator repository.

Why Cargo?

In previous blogs we built applications with CMake. CMake is probably the most widely used tool to compile Qt software. CMake uses Cargo to build the Rust parts.

CMake is a familiar tool for Qt developers, but not for Rust developers. For them, CMake is an unneeded hurdle. Rust Qt Binding Generator can be used with only Cargo. To do so you use the Rust way of building C++ code: build.rs.

`build.rs`

build.rs contains Rust code that is compiled and run by Cargo to build an application. Here is a simple build.rs file:

extern crate rust_qt_binding_generator;

fn main() {
    // obtain the output directory from an environment variable
    let out_dir = ::std::env::var("OUT_DIR").unwrap();

    // create a new builder
    rust_qt_binding_generator::build::Build::new(&out_dir)
        // add Rust Qt bindings
        .bindings("bindings.json")
        // add files to compile into the program as resources
        .qrc("qml.qrc")
        // add some C++ code
        .cpp("src/main.cpp")
        // compile it to a static library
        .compile("my_project");
}

[package]
name = "my_project"
version = "0.1.0"
build = "build.rs"    # use build.rs for custom build steps
links = "my_project"  # and link to the resulting library

[dependencies]
libc = "0.2"

[build-dependencies]
rust_qt_binding_generator = "0.2"

extern crate libc;

// include the interface generated from bindings.json
pub mod interface {
    include!(concat!(env!("OUT_DIR"), "/src/interface.rs"));
}

// the module with our implementation of the interface
mod implementation;

// declare the function that calls into the C++ code
extern {
    fn main_cpp(app: *const ::std::os::raw::c_char);
}

fn main() {
    use std::ffi::CString;
    let app_name = ::std::env::args().next().unwrap();
    let app_name = CString::new(app_name).unwrap();
    unsafe {
        //  call the C++ function that starts the Qt event loop
        main_cpp(app_name.as_ptr());
    }
}

#include "Bindings.h"

#include <QtCore/QFile>
#include <QtGui/QGuiApplication>
#include <QtQml/QQmlApplicationEngine>
#include <QtQml/qqml.h>

extern "C" {
    int main_cpp(const char* app);
}

int main_cpp(const char* appPath) {
    // create a QGuiApplication
    int argc = 1;
    char* argv[1] = { (char*)appPath };
    QGuiApplication app(argc, argv);

    // register the type that we wrote in Rust
    qmlRegisterType<Simple>("RustCode", 1, 0, "Simple");

    // This is QML application. We load the QML file from the file system
    // or take the one embedded into the application otherwise.
    QQmlApplicationEngine engine;
    if (QFile("main.qml").exists()) {
        engine.load(QUrl(QStringLiteral("main.qml")));
    } else {
        engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
    }
    // start the event loop
    return app.exec();
}

<RCC>
    <qresource prefix="/">
        <file>main.qml</file>
        <file>MainForm.ui.qml</file>
    </qresource>
</RCC>

here.

Qt applications with Cargo

2018-10-30

Why Cargo?

`build.rs`

`Cargo.toml`

`src/main.rs`

`src/main.cpp`

`qml.qrc`

Concluding

Comments