0.14.0: rules-qt places Qt's own translations (translations::qt_languages): lconvert combines the linked modules' catalogs into qt_<language>.qm, as windeployqt does

Author: Sunrisepeak

.github/scripts/check-deps-and-qt.sh

@@ -201,6 +201,9 @@ qt_consumer() {
         fail "moc, rcc or lrelease did not reach the program"
     find target -name 'qt_consumer_de.qm' | grep -q . || fail "no .qm was produced"
     echo "ok: moc (header and inline), rcc and lrelease reached the program"
+    grep -q "Qt's own 'Abbrechen'$" target/ci/run.log ||
+        fail "Qt's own strings were not translated from the combined qt_de.qm"
+    echo "ok: lconvert combined Qt's catalogs into qt_de.qm, and the program loads it"
     "$MCPP" build --profile dev -v > target/ci/second-build.log 2>&1 ||
         { cat target/ci/second-build.log; fail "the second build failed"; }
     ! grep -qE '/(lupdate|lrelease)[^ ]* ' target/ci/second-build.log ||

README.md

@@ -1015,7 +1015,7 @@ int main() {
 | `private_modules` | modules whose private headers are included |
 | `moc`, `moc_headers` | `moc_scan::project_headers` (default) scans the package's headers by content; `moc_scan::listed` takes `moc_headers` only |
 | `forms`, `resources` | `.ui` and `.qrc` files beside those in `[build] sources` |
-| `i18n` | `.ts` files beside those in `[build] sources`; `update_sources` runs `lupdate` before `lrelease`, as an action whose output is the `.ts` file it rewrites; `tr_function_alias`; `deploy_to` (default `translations`); `out_dir`, where `lrelease` writes (default `<out dir>/qt/translations`) |
+| `i18n` | `.ts` files beside those in `[build] sources`; `update_sources` runs `lupdate` before `lrelease`, as an action whose output is the `.ts` file it rewrites; `tr_function_alias`; `deploy_to` (default `translations`); `out_dir`, where `lrelease` writes (default `<out dir>/qt/translations`); `qt_languages`, Qt's own strings for each language: the catalogs of the linked modules combined by `lconvert` into `qt_<language>.qm` under `deploy_to`, the file windeployqt writes |
 | `deploy_plugins` | plugin directories placed beside the program; default `platforms` |
 | `deploy_software_gl` | Windows: `opengl32sw.dll` and `d3dcompiler_47.dll` beside the program |
 | `root`, `extra_roots` | an SDK, and further prefixes |

rules/qt.cppm

@@ -69,6 +69,11 @@ struct translations {
     // Where `lrelease` writes them. Empty is `<out dir>/qt/translations`; a
     // project whose own release step copies them names a directory it knows.
     std::string out_dir;
+    // Qt's own UI strings for these languages (`de`, `zh_CN`): the catalogs of
+    // the modules the program links, from the SDK's `translations/`, combined
+    // by `lconvert` into one `qt_<language>.qm` with no dependency left to
+    // resolve, and placed under `deploy_to` -- the file windeployqt writes.
+    std::vector<std::string> qt_languages;
 };
 
 struct options {
@@ -131,6 +136,26 @@ inline std::string module_name(std::string m) {
     return m;
 }
 
+// The translation catalog Qt ships a module's strings in: `qtbase` for the
+// modules of qtbase, the repository's name for the others. A module with no
+// catalog of its own has its strings in qtbase's.
+inline std::string catalog_of(const std::string& module) {
+    static const std::vector<std::pair<std::string, std::vector<std::string>>> table = {
+        {"qtdeclarative", {"Qml", "Quick", "QuickControls2", "QuickWidgets", "QuickDialogs2"}},
+        {"qtmultimedia",  {"Multimedia", "MultimediaWidgets"}},
+        {"qtserialport",  {"SerialPort"}},
+        {"qtwebsockets",  {"WebSockets"}},
+        {"qtconnectivity", {"Bluetooth", "Nfc"}},
+        {"qtlocation",    {"Location"}},
+        {"qtwebengine",   {"WebEngineCore", "WebEngineWidgets", "WebEngineQuick"}},
+        {"qt_help",       {"Help"}},
+    };
+    for (auto const& [catalog, modules] : table)
+        for (auto const& m : modules)
+            if (m == module) return catalog;
+    return "qtbase";
+}
+
 // By index, as `mcpp.deps.vcpkg` lowers a triplet line: GCC 16 cannot inline a
 // non-const std::string iterator in a module unit.
 inline std::string upper(std::string s) {
@@ -579,6 +604,50 @@ inline bool compile(options opt = {}) {
         }
     }
 
+    // ── Qt's own translations ──
+    if (!opt.i18n.qt_languages.empty()) {
+        const std::string lconvert = detail::tool(sdks, "lconvert");
+        const fs::path qmDir = opt.i18n.out_dir.empty() ? gen / "translations"
+                                                        : detail::absolute_from_root(opt.i18n.out_dir);
+        std::vector<std::string> catalogs = {"qtbase"};
+        for (auto const& m : opt.modules) {
+            const std::string c = detail::catalog_of(detail::module_name(m));
+            if (std::ranges::find(catalogs, c) == catalogs.end()) catalogs.push_back(c);
+        }
+        if (lconvert.empty()) {
+            detail::warn(std::format("{}: `lconvert` not found under {}; it is part of qttools, and "
+                                     "Qt's own translations are not placed.", who, generic(main)));
+        } else {
+            for (auto const& lang : opt.i18n.qt_languages) {
+                std::vector<std::string> inputs;
+                for (auto const& c : catalogs)
+                    for (auto const& r : sdks)
+                        if (const auto qm = r / "translations" / (c + "_" + lang + ".qm"); fs::is_regular_file(qm, ec)) {
+                            inputs.push_back(generic(qm));
+                            break;
+                        }
+                if (inputs.empty()) {
+                    detail::warn(std::format("{}: the SDK has no Qt translation for '{}' (no "
+                                             "translations/qtbase_{}.qm under {}).", who, lang, lang, generic(main)));
+                    continue;
+                }
+                const std::string name = "qt_" + lang + ".qm";
+                if (!claim(name, fs::path(inputs.front()))) return false;
+                const std::string out  = generic(qmDir / name);
+                const std::string id   = "qt:lconvert:" + lang;
+                const std::string desc = "LCONVERT " + name;
+                mcpp::action a;
+                a.id = id.c_str();
+                a.role = mcpp::roles::source;
+                a.description = desc.c_str();
+                a.arg(lconvert.c_str()).arg("-o").arg(out.c_str());
+                for (auto const& in : inputs) a.arg("-i").arg(in.c_str()).input(in.c_str());
+                a.output(out.c_str()).submit();
+                mcpp::deploy(out.c_str(), opt.i18n.deploy_to.c_str());
+            }
+        }
+    }
+
     // ── what Qt loads at run time ──
     for (auto const& dir : opt.deploy_plugins) {
         bool any = false;

tests/qt-consumer/build.mcpp

@@ -10,5 +10,8 @@ int main() {
     // lupdate brings the `.ts` up to date with src/ before lrelease reads it.
     // The committed file is lupdate's own output, so a build leaves it as is.
     o.i18n.update_sources = true;
+    // Qt's own strings in German, combined from the catalogs of the modules
+    // linked into `translations/qt_de.qm`, as windeployqt writes it.
+    o.i18n.qt_languages = {"de"};
     return mcpp::rules::qt::compile(o) ? 0 : 1;
 }

tests/qt-consumer/src/main.cpp

@@ -40,11 +40,22 @@ int main(int argc, char** argv) {
         return 1;
     }
     QCoreApplication::installTranslator(&translator);
-    const QString hello = QCoreApplication::translate("main", "hello");
-
-    std::printf("qt-consumer: signal %d, resource '%s', translation '%s', Qt %s\n",
-                relay.seen, text.constData(), hello.toUtf8().constData(), qVersion());
-    return relay.seen == 42 && text == "greetings from rcc" && hello == "hallo" ? 0 : 1;
+    // Qt's own strings, from the qt_de.qm rules-qt combined: it loads only
+    // when no catalog it depends on is missing.
+    QTranslator qtTranslator;
+    if (!qtTranslator.load("qt_de", dir)) {
+        std::printf("qt-consumer: translations/qt_de.qm does not load\n");
+        return 1;
+    }
+    QCoreApplication::installTranslator(&qtTranslator);
+    const QString hello  = QCoreApplication::translate("main", "hello");
+    const QString cancel = QCoreApplication::translate("QProgressDialog", "Cancel");
+
+    std::printf("qt-consumer: signal %d, resource '%s', translation '%s', Qt %s, Qt's own '%s'\n",
+                relay.seen, text.constData(), hello.toUtf8().constData(), qVersion(),
+                cancel.toUtf8().constData());
+    return relay.seen == 42 && text == "greetings from rcc" && hello == "hallo" &&
+           cancel == "Abbrechen" ? 0 : 1;
 }
 
 #include "main.moc"