WIP: cxx-qt-build: include headers directory manually

Author: ahayzen-kdab

crates/cxx-qt-build/src/interface.rs

@@ -139,7 +139,13 @@ impl Interface {
             .expect("Failed to create header root for interface");
         for (header_dir, dest) in &self.exported_include_directories {
             let dest_dir = header_root_interface.join(dest);
-            match dir::symlink_or_copy_directory(header_dir, &dest_dir) {
+            // If the path is relative then use the CARGO_MANIFEST_DIR as the root
+            let header_dir = if header_dir.is_relative() {
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap()).join(header_dir)
+            } else {
+                PathBuf::from(header_dir)
+            };
+            match dir::symlink_or_copy_directory(&header_dir, &dest_dir) {
                 Ok(true) => {},
                 Ok(false) => panic!("Failed to create symlink folder for `{dest}`"),
                 Err(e) => panic!(

crates/cxx-qt-build/src/lib.rs

@@ -1083,6 +1083,17 @@ extern "C" bool {init_fun}() {{
         // to the generated files without any namespacing.
         include_paths.push(header_root.join(&self.include_prefix));
 
+        // Automatically add any include/ directory from the cargo manifest dir
+        let manifest_include_dir =
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap()).join("include");
+        if manifest_include_dir.exists() {
+            println!(
+                "cargo::rerun-if-changed={}",
+                manifest_include_dir.to_string_lossy()
+            );
+            include_paths.push(manifest_include_dir);
+        }
+
         Self::setup_cc_builder(&mut self.cc_builder, &include_paths);
 
         // Generate files

crates/cxx-qt-lib-extras/build.rs

@@ -4,44 +4,8 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use cxx_qt_build::CxxQtBuilder;
-use std::path::PathBuf;
-
-fn header_dir() -> PathBuf {
-    PathBuf::from(std::env::var("OUT_DIR").unwrap())
-        .join("include")
-        .join("cxx-qt-lib-extras")
-}
-
-fn write_headers_in(subfolder: &str) {
-    println!("cargo::rerun-if-changed=include/{subfolder}");
-
-    for entry in
-        std::fs::read_dir(format!("include/{subfolder}")).expect("Failed to read include directory")
-    {
-        let entry = entry.expect("Failed to read header file!");
-        let header_name = entry.file_name();
-        println!(
-            "cargo::rerun-if-changed=include/{subfolder}/{header_name}",
-            header_name = header_name.to_string_lossy()
-        );
-
-        // TODO: Do we want to add the headers into a subdirectory?
-        std::fs::copy(entry.path(), header_dir().join(header_name))
-            .expect("Failed to copy header file!");
-    }
-}
-
-fn write_headers() {
-    println!("cargo::rerun-if-changed=include/");
-    std::fs::create_dir_all(header_dir()).expect("Failed to create include directory");
-
-    write_headers_in("core");
-    write_headers_in("gui");
-}
 
 fn main() {
-    write_headers();
-
     let mut builder = CxxQtBuilder::library()
         .qt_module("Gui")
         .qt_module("Widgets");
@@ -83,7 +47,7 @@ fn main() {
     // Disable exporting the standard include directory, as we are exporting custom header
     interface
         .export_include_prefixes([])
-        .export_include_directory(header_dir(), "cxx-qt-lib-extras")
+        .export_include_directory("include/cxx-qt-lib-extras", "cxx-qt-lib-extras")
         .reexport_dependency("cxx-qt-lib")
         .export();
 }

crates/cxx-qt-lib-extras/include/gui/qapplication.h renamed to crates/cxx-qt-lib-extras/include/cxx-qt-lib-extras/qapplication.h

@@ -383,6 +383,14 @@ fn main() {
         }
         cc.file("src/qt_types.cpp");
         println!("cargo::rerun-if-changed=src/qt_types.cpp");
+
+        // With cxx-qt-lib we need to have generated headers in the include folder
+        // so we copy them into the OUT_DIR and construct a folder
+        //
+        // TODO: can this be improved in anyway?
+        // if we included the include folder from the source dir how do we combine
+        // the generated headers into the export include dir?
+        cc.include(header_dir().parent().expect("header_dir has a parent"));
     });
 
     let interface = builder.build();

crates/cxx-qt-lib-extras/include/core/qcommandlineoption.h renamed to crates/cxx-qt-lib-extras/include/cxx-qt-lib-extras/qcommandlineoption.h

@@ -3,37 +3,9 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use std::path::PathBuf;
-
 use cxx_qt_build::CxxQtBuilder;
 
-fn header_dir() -> PathBuf {
-    PathBuf::from(std::env::var("OUT_DIR").unwrap())
-        .join("include")
-        .join("cxx-qt")
-}
-
-fn write_headers() {
-    println!("cargo::rerun-if-changed=include/");
-    std::fs::create_dir_all(header_dir()).expect("Failed to create include directory");
-
-    for file_path in [
-        "connection.h",
-        "casting.h",
-        "signalhandler.h",
-        "thread.h",
-        "threading.h",
-        "type.h",
-    ] {
-        println!("cargo::rerun-if-changed=include/{file_path}");
-        std::fs::copy(format!("include/{file_path}"), header_dir().join(file_path))
-            .expect("Failed to copy header file!");
-    }
-}
-
 fn main() {
-    write_headers();
-
     let mut builder = CxxQtBuilder::library();
 
     let cpp_files = ["src/connection.cpp"];
@@ -57,6 +29,7 @@ fn main() {
     let interface = builder.build();
     interface
         .export_include_prefixes([])
-        .export_include_directory(header_dir(), "cxx-qt")
+        // TODO: should we always export or is this fine?
+        .export_include_directory("include/cxx-qt", "cxx-qt")
         .export();
 }

crates/cxx-qt-lib-extras/include/core/qcommandlineparser.h renamed to crates/cxx-qt-lib-extras/include/cxx-qt-lib-extras/qcommandlineparser.h

@@ -11,7 +11,6 @@
 
 use std::ops::Deref;
 use std::pin::Pin;
-use std::{fs::File, io::Write, path::Path};
 
 mod connection;
 mod connectionguard;
@@ -433,28 +432,3 @@ where
         Self::initialize(self);
     }
 }
-
-#[doc(hidden)]
-// Write the cxx-qt headers to the specified directory.
-pub fn write_headers(directory: impl AsRef<Path>) {
-    let directory = directory.as_ref();
-    std::fs::create_dir_all(directory).expect("Could not create cxx-qt header directory");
-    // Note ensure that the build script is consistent with files that are copied
-    for (file_contents, file_name) in [
-        (include_str!("../include/connection.h"), "connection.h"),
-        (
-            include_str!("../include/signalhandler.h"),
-            "signalhandler.h",
-        ),
-        (include_str!("../include/thread.h"), "thread.h"),
-        (include_str!("../include/threading.h"), "threading.h"),
-        (include_str!("../include/type.h"), "type.h"),
-    ] {
-        // Note that we do not need rerun-if-changed for these files
-        // as include_str causes a rerun when the header changes
-        // and the files are always written to the target.
-        let h_path = format!("{}/{file_name}", directory.display());
-        let mut header = File::create(h_path).expect("Could not create cxx-qt header");
-        write!(header, "{file_contents}").expect("Could not write cxx-qt header");
-    }
-}