cxx-qt-lib: require headers to be includes manually

This allows for cxx-qt-lib to be optional later.

Related to #319

Author: ahayzen-kdab

CHANGELOG.md

@@ -9,7 +9,6 @@ members = [
     "crates/cxx-qt-build",
     "crates/cxx-qt-gen",
     "crates/cxx-qt-lib",
-    "crates/cxx-qt-lib-headers",
     "crates/qt-build-utils",
 
     "examples/cargo_without_cmake",
@@ -37,7 +36,6 @@ cxx-qt-macro = { path = "crates/cxx-qt-macro", version = "0.6.0" }
 cxx-qt-build = { path = "crates/cxx-qt-build" }
 cxx-qt-gen = { path = "crates/cxx-qt-gen", version = "0.6.0" }
 cxx-qt-lib = { path = "crates/cxx-qt-lib" }
-cxx-qt-lib-headers = { path = "crates/cxx-qt-lib-headers", version = "0.6.0" }
 qt-build-utils = { path = "crates/qt-build-utils", version = "0.6.0" }
 
 cc = { version = "1.0.86", features = ["parallel"] }

Cargo.toml

@@ -17,7 +17,6 @@ cc.workspace = true
 convert_case.workspace = true
 cxx-gen.workspace = true
 cxx-qt.workspace = true
-cxx-qt-lib-headers.workspace = true
 cxx-qt-gen.workspace = true
 proc-macro2.workspace = true
 quote.workspace = true
@@ -27,6 +26,6 @@ version_check = "0.9"
 
 [features]
 default = ["qt_gui", "qt_qml"]
-qt_gui = ["cxx-qt-lib-headers/qt_gui"]
-qt_qml = ["cxx-qt-lib-headers/qt_qml"]
+qt_gui = []
+qt_qml = []
 link_qt_object_files = ["qt-build-utils/link_qt_object_files"]

crates/cxx-qt-build/Cargo.toml

@@ -242,6 +242,15 @@ fn generate_cxxqt_cpp_files(
     generated_file_paths
 }
 
+/// The include directory needs to be namespaced by crate name when exporting for a C++ build system,
+/// but for using cargo build without a C++ build system, OUT_DIR is already namespaced by crate name.
+fn header_root() -> String {
+    match env::var("CXXQT_EXPORT_DIR") {
+        Ok(export_dir) => format!("{export_dir}/{}", env::var("CARGO_PKG_NAME").unwrap()),
+        Err(_) => env::var("OUT_DIR").unwrap(),
+    }
+}
+
 fn panic_duplicate_file_and_qml_module(
     path: impl AsRef<Path>,
     uri: &str,
@@ -291,6 +300,16 @@ pub struct CxxQtBuilder {
     qt_modules: HashSet<String>,
     qml_modules: Vec<OwningQmlModule>,
     cc_builder: cc::Build,
+    extra_defines: HashSet<String>,
+}
+
+/// Options for external crates to use
+#[derive(Default)]
+pub struct CxxQtBuildersOpts {
+    /// Any extra definitions
+    pub defines: HashSet<String>,
+    /// Contents, directory, file name
+    pub headers: Vec<(String, String, String)>,
 }
 
 impl CxxQtBuilder {
@@ -309,6 +328,7 @@ impl CxxQtBuilder {
             qt_modules,
             qml_modules: vec![],
             cc_builder: cc::Build::new(),
+            extra_defines: HashSet::new(),
         }
     }
 
@@ -426,27 +446,44 @@ impl CxxQtBuilder {
         self
     }
 
+    /// Build with the given extra options
+    pub fn with_opts(mut self, opts: CxxQtBuildersOpts) -> Self {
+        let header_root = header_root();
+        for (file_contents, dir_name, file_name) in opts.headers {
+            let directory = if dir_name.is_empty() {
+                header_root.clone()
+            } else {
+                format!("{header_root}/{dir_name}")
+            };
+            std::fs::create_dir_all(directory.clone())
+                .expect("Could not create {directory} header directory");
+
+            let h_path = format!("{directory}/{file_name}");
+            let mut header = File::create(h_path).expect("Could not create header: {h_path}");
+            write!(header, "{file_contents}").expect("Could not write header: {h_path}");
+        }
+
+        // Add any of the defines
+        self.extra_defines.extend(opts.defines);
+
+        self
+    }
+
     /// Generate and compile cxx-qt C++ code, as well as compile any additional files from
     /// [CxxQtBuilder::qobject_header] and [CxxQtBuilder::cc_builder].
     pub fn build(mut self) {
         // Ensure that the linker is setup correctly for Cargo builds
         qt_build_utils::setup_linker();
 
-        // The include directory needs to be namespaced by crate name when exporting for a C++ build system,
-        // but for using cargo build without a C++ build system, OUT_DIR is already namespaced by crate name.
-        let header_root = match env::var("CXXQT_EXPORT_DIR") {
-            Ok(export_dir) => format!("{export_dir}/{}", env::var("CARGO_PKG_NAME").unwrap()),
-            Err(_) => env::var("OUT_DIR").unwrap(),
-        };
+        let header_root = header_root();
         let generated_header_dir = format!("{header_root}/cxx-qt-gen");
 
         let mut qtbuild = qt_build_utils::QtBuild::new(self.qt_modules.into_iter().collect())
             .expect("Could not find Qt installation");
         qtbuild.cargo_link_libraries(&mut self.cc_builder);
 
-        // Write cxx-qt-gen, cxx-qt-lib and cxx headers
+        // Write cxx-qt and cxx headers
         cxx_qt::write_headers(format!("{header_root}/cxx-qt"));
-        cxx_qt_lib_headers::write_headers(format!("{header_root}/cxx-qt-lib"));
         std::fs::create_dir_all(format!("{header_root}/rust"))
             .expect("Could not create cxx header directory");
         let h_path = format!("{header_root}/rust/cxx.h");
@@ -499,12 +536,12 @@ impl CxxQtBuilder {
             builder.flag_if_supported("-std=c++17");
             // MinGW requires big-obj otherwise debug builds fail
             builder.flag_if_supported("-Wa,-mbig-obj");
-            // Enable Qt Gui in C++ if the feature is enabled
-            #[cfg(feature = "qt_gui")]
-            builder.define("CXX_QT_GUI_FEATURE", None);
-            // Enable Qt Gui in C++ if the feature is enabled
-            #[cfg(feature = "qt_qml")]
-            builder.define("CXX_QT_QML_FEATURE", None);
+
+            // Enable any extra defines
+            for extra_define in &self.extra_defines {
+                builder.define(extra_define, None);
+            }
+
             for include_dir in qtbuild.include_paths() {
                 builder.include(&include_dir);
             }

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

@@ -19,6 +19,7 @@ exclude = [ "**/generate.sh" ]
 [dependencies]
 cxx.workspace = true
 cxx-qt.workspace = true
+cxx-qt-build.workspace = true
 bytes = { version = "1.4", optional = true }
 chrono = { version = "0.4.27", optional = true }
 http = { version = "1.0", optional = true }
@@ -28,7 +29,6 @@ url = { version = "2.3", optional = true }
 
 [build-dependencies]
 cxx-build.workspace = true
-cxx-qt-lib-headers.workspace = true
 qt-build-utils.workspace = true
 
 [features]
@@ -37,8 +37,8 @@ bytes = ["dep:bytes"]
 chrono = ["dep:chrono"]
 http = ["dep:http"]
 rgb = ["dep:rgb"]
-qt_gui = ["cxx-qt-lib-headers/qt_gui"]
-qt_qml = ["cxx-qt-lib-headers/qt_qml"]
+qt_gui = ["cxx-qt-build/qt_gui"]
+qt_qml = ["cxx-qt-build/qt_qml"]
 time = ["dep:time"]
 url = ["dep:url"]
 link_qt_object_files = ["qt-build-utils/link_qt_object_files"]

crates/cxx-qt-lib-headers/Cargo.toml

@@ -263,10 +263,38 @@ fn main() {
     println!("cargo:rerun-if-changed=src/qt_types.cpp");
     println!("cargo:rerun-if-changed=src/assertion_utils.h");
 
+    fn copy_dir(src: impl AsRef<std::path::Path>, dest: impl AsRef<std::path::Path>) {
+        let dest = dest.as_ref();
+        let src = src.as_ref();
+        if src.is_dir() {
+            std::fs::create_dir_all(dest).expect("could not create directory {dest}");
+            for entry in std::fs::read_dir(src).expect("could not read dir {src}") {
+                let entry = entry.expect("could not retrieve entry for dir {src}");
+                let path = entry.path();
+                let file_name = entry
+                    .file_name()
+                    .into_string()
+                    .expect("cannot convert OsString to String");
+                let dest = dest.display();
+                if path.is_file() {
+                    std::fs::copy(path, format!("{dest}/{file_name}"))
+                        .expect("could not copy {path}");
+                }
+            }
+        }
+    }
+
     // Write this library's manually written C++ headers to files and add them to include paths
-    let out_dir = std::env::var("OUT_DIR").unwrap();
-    cxx_qt_lib_headers::write_headers(format!("{out_dir}/cxx-qt-lib"));
-    builder.include(out_dir);
+    let include_out_dir = format!("{}/include", std::env::var("OUT_DIR").unwrap());
+    copy_dir("include/core", format!("{include_out_dir}/cxx-qt-lib"));
+    copy_dir("include/gui", format!("{include_out_dir}/cxx-qt-lib"));
+    copy_dir("include/qml", format!("{include_out_dir}/cxx-qt-lib"));
+    std::fs::copy(
+        "include/common.h",
+        format!("{include_out_dir}/cxx-qt-lib/common.h"),
+    )
+    .expect("could not copy common.h");
+    builder.include(include_out_dir);
 
     // Enable Qt Gui in C++ if the feature is enabled
     if feature_qt_gui_enabled {