feat: adapt to two independent palette dconfig files

feat: 适配两个独立的调色板 dconfig 文件

1. Add OrgDeepinDTKPaletteDark dconfig generation in kernel.cmake for
   org.deepin.dtk.palette.dark.json config file
2. Change _d_palette_light to use empty subpath (org.deepin.dtk.palette)
3. Change _d_palette_dark to use OrgDeepinDTKPaletteDark class with
   org.deepin.dtk.palette.dark config name
4. Make paletteQColorFromDConfig and paletteDColorFromDConfig template
   functions to work with both config class types
5. Remove palette_config variable, use direct ternary dispatch in
   standardPalette() instead
6. Update signal connections to use OrgDeepinDTKPaletteDark signals

1. 在 kernel.cmake 中添加 OrgDeepinDTKPaletteDark dconfig 生成，
   对应 org.deepin.dtk.palette.dark.json 配置文件
2. 修改 _d_palette_light 使用空 subpath（org.deepin.dtk.palette）
3. 修改 _d_palette_dark 使用 OrgDeepinDTKPaletteDark 类，
   配置名为 org.deepin.dtk.palette.dark
4. 将 paletteQColorFromDConfig 和 paletteDColorFromDConfig 改为模板函数，
   支持两种配置类类型
5. 移除 palette_config 变量，在 standardPalette() 中直接使用三元分发
6. 更新信号连接使用 OrgDeepinDTKPaletteDark 信号

PMS: DDE-330
Log: 适配 dtkcommon 新的双文件 dconfig 方案，不再使用 subpath，改用两个独立 schema 文件
Influence: dtkgui 调色板 dconfig 读取方式变更

Author: 18202781743

src/kernel/dguiapplicationhelper.cpp

@@ -55,6 +55,8 @@
 #endif
 
 #include "orgdeepindtkpreference.hpp"
+#include "orgdeepindtkpalette.hpp"
+#include "orgdeepindtkpalettedark.hpp"
 
 #ifdef Q_OS_UNIX
 class EnvReplaceGuard
@@ -151,6 +153,13 @@ Q_GLOBAL_STATIC(DFontManager, _globalFM)
 Q_GLOBAL_STATIC_WITH_ARGS(OrgDeepinDTKPreference, _d_dconfig, (DTK_CORE_NAMESPACE::DConfig::globalThread(), nullptr,
                                                                "org.deepin.dtk.preference", DTK_CORE_NAMESPACE::DSGApplication::id(), {}, false, nullptr))
 
+Q_GLOBAL_STATIC_WITH_ARGS(OrgDeepinDTKPalette, _d_palette_light,
+    (DTK_CORE_NAMESPACE::DConfig::globalThread(), nullptr,
+     "org.deepin.dtk.palette", DTK_CORE_NAMESPACE::DSGApplication::id(), {}, false, nullptr))
+Q_GLOBAL_STATIC_WITH_ARGS(OrgDeepinDTKPaletteDark, _d_palette_dark,
+    (DTK_CORE_NAMESPACE::DConfig::globalThread(), nullptr,
+     "org.deepin.dtk.palette.dark", DTK_CORE_NAMESPACE::DSGApplication::id(), {}, false, nullptr))
+
 // Keys allowed to be forwarded between single-instance client and server.
 static const QStringList s_singleInstanceForwardEnvKeys = {
     QStringLiteral("XDG_ACTIVATION_TOKEN")
@@ -866,6 +875,78 @@ static QColor dark_dpalette[DPalette::NColorTypes] {
     QColor(255, 255, 255, 0.1 * 255)    //ObviousBackground
 };
 
+// Generation tracking for dconfig palette cache invalidation
+static QAtomicInt s_paletteGeneration(0);
+static QAtomicInt s_paletteDConfigConnected(0);
+
+static void ensurePaletteDConfigConnected()
+{
+    if (s_paletteDConfigConnected.testAndSetOrdered(0, 1)) {
+        QObject::connect(_d_palette_light.operator()(), &OrgDeepinDTKPalette::valueChanged,
+                         qApp, [](const QString &, const QVariant &) { s_paletteGeneration.fetchAndAddOrdered(1); });
+        QObject::connect(_d_palette_dark.operator()(), &OrgDeepinDTKPaletteDark::valueChanged,
+                         qApp, [](const QString &, const QVariant &) { s_paletteGeneration.fetchAndAddOrdered(1); });
+    }
+}
+
+template<typename ConfigT>
+static QColor paletteQColorFromDConfig(ConfigT *config, QPalette::ColorRole role, const QColor &fallback)
+{
+    if (!config || !config->isInitializeSucceeded())
+        return fallback;
+    QString str;
+    switch (role) {
+    case QPalette::WindowText: str = config->windowText(); break;
+    case QPalette::Button: str = config->button(); break;
+    case QPalette::Light: str = config->light(); break;
+    case QPalette::Midlight: str = config->midlight(); break;
+    case QPalette::Dark: str = config->dark(); break;
+    case QPalette::Mid: str = config->mid(); break;
+    case QPalette::Text: str = config->text(); break;
+    case QPalette::BrightText: str = config->brightText(); break;
+    case QPalette::ButtonText: str = config->buttonText(); break;
+    case QPalette::Base: str = config->base(); break;
+    case QPalette::Window: str = config->window(); break;
+    case QPalette::Shadow: str = config->shadow(); break;
+    case QPalette::Highlight: str = config->highlight(); break;
+    case QPalette::HighlightedText: str = config->highlightedText(); break;
+    case QPalette::Link: str = config->link(); break;
+    case QPalette::LinkVisited: str = config->linkVisited(); break;
+    case QPalette::AlternateBase: str = config->alternateBase(); break;
+    case QPalette::NoRole: str = config->noRole(); break;
+    case QPalette::ToolTipBase: str = config->toolTipBase(); break;
+    case QPalette::ToolTipText: str = config->toolTipText(); break;
+    default: return fallback;
+    }
+    QColor c(str);
+    return c.isValid() ? c : fallback;
+}
+
+template<typename ConfigT>
+static QColor paletteDColorFromDConfig(ConfigT *config, DPalette::ColorType type, const QColor &fallback)
+{
+    if (!config || !config->isInitializeSucceeded())
+        return fallback;
+    QString str;
+    switch (type) {
+    case DPalette::NoType: str = config->noType(); break;
+    case DPalette::ItemBackground: str = config->itemBackground(); break;
+    case DPalette::TextTitle: str = config->textTitle(); break;
+    case DPalette::TextTips: str = config->textTips(); break;
+    case DPalette::TextWarning: str = config->textWarning(); break;
+    case DPalette::TextLively: str = config->textLively(); break;
+    case DPalette::LightLively: str = config->lightLively(); break;
+    case DPalette::DarkLively: str = config->darkLively(); break;
+    case DPalette::FrameBorder: str = config->frameBorder(); break;
+    case DPalette::PlaceholderText: str = config->placeholderText(); break;
+    case DPalette::FrameShadowBorder: str = config->frameShadowBorder(); break;
+    case DPalette::ObviousBackground: str = config->obviousBackground(); break;
+    default: return fallback;
+    }
+    QColor c(str);
+    return c.isValid() ? c : fallback;
+}
+
 /*!
   \brief 根据主题获取标准调色板.
 
@@ -874,29 +955,50 @@ static QColor dark_dpalette[DPalette::NColorTypes] {
  */
 DPalette DGuiApplicationHelper::standardPalette(DGuiApplicationHelper::ColorType type)
 {
-    static const DPalette *light_palette = nullptr, *dark_palette = nullptr;
-    static const DPalette *alpha_light_palette = nullptr, *alpha_dark_palette = nullptr;
+    Q_ASSERT_X(QThread::currentThread() == qApp->thread(),
+               "DGuiApplicationHelper::standardPalette",
+               "standardPalette() must be called on the GUI thread");
+
+    ensurePaletteDConfigConnected();
+
+    static QAtomicPointer<const DPalette> light_palette, dark_palette;
+    static QAtomicPointer<const DPalette> alpha_light_palette, alpha_dark_palette;
+    static int last_generation = -1;
+
     const bool allowCompositingColor = DGuiApplicationHelper::testAttribute(ColorCompositing);
 
+    int current_gen = s_paletteGeneration.loadRelaxed();
+    if (current_gen != last_generation) {
+        last_generation = current_gen;
+        delete light_palette.fetchAndStoreRelaxed(nullptr);
+        delete dark_palette.fetchAndStoreRelaxed(nullptr);
+        delete alpha_light_palette.fetchAndStoreRelaxed(nullptr);
+        delete alpha_dark_palette.fetchAndStoreRelaxed(nullptr);
+    }
+
     if (type == LightType) {
         if (Q_UNLIKELY(allowCompositingColor)) {
-            if (Q_LIKELY(alpha_light_palette)) {
-                return *alpha_light_palette;
+            const DPalette *p = alpha_light_palette.loadRelaxed();
+            if (Q_LIKELY(p)) {
+                return *p;
             }
         }
 
-        if (Q_LIKELY(light_palette)) {
-            return *light_palette;
+        const DPalette *p = light_palette.loadRelaxed();
+        if (Q_LIKELY(p)) {
+            return *p;
         }
     } else if (type == DarkType) {
         if (Q_UNLIKELY(allowCompositingColor)) {
-            if (Q_LIKELY(alpha_dark_palette)) {
-                return *alpha_dark_palette;
+            const DPalette *p = alpha_dark_palette.loadRelaxed();
+            if (Q_LIKELY(p)) {
+                return *p;
             }
         }
 
-        if (Q_LIKELY(dark_palette)) {
-            return *dark_palette;
+        const DPalette *p = dark_palette.loadRelaxed();
+        if (Q_LIKELY(p)) {
+            return *p;
         }
     } else {
         return DPalette();
@@ -909,31 +1011,35 @@ DPalette DGuiApplicationHelper::standardPalette(DGuiApplicationHelper::ColorType
         pa = new DPalette();
 
         if (allowCompositingColor)
-            alpha_dark_palette = pa;
+            alpha_dark_palette.storeRelaxed(pa);
         else
-            dark_palette = pa;
+            dark_palette.storeRelaxed(pa);
 
         qcolor_list = dark_qpalette;
         dcolor_list = dark_dpalette;
     } else {
         pa = new DPalette();
 
         if (allowCompositingColor)
-            alpha_light_palette = pa;
+            alpha_light_palette.storeRelaxed(pa);
         else
-            light_palette = pa;
+            light_palette.storeRelaxed(pa);
 
         qcolor_list = light_qpalette;
         dcolor_list = light_dpalette;
     }
 
     for (int i = 0; i < DPalette::NColorRoles; ++i) {
         QPalette::ColorRole role = static_cast<QPalette::ColorRole>(i);
-        QColor color = qcolor_list[i];
+        QColor color = (type == DarkType)
+            ? paletteQColorFromDConfig(_d_palette_dark.operator()(), role, qcolor_list[i])
+            : paletteQColorFromDConfig(_d_palette_light.operator()(), role, qcolor_list[i]);
 
 #if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
         if (role == QPalette::PlaceholderText) {
-            color = dcolor_list[DPalette::PlaceholderText];
+            color = (type == DarkType)
+                ? paletteDColorFromDConfig(_d_palette_dark.operator()(), DPalette::PlaceholderText, dcolor_list[DPalette::PlaceholderText])
+                : paletteDColorFromDConfig(_d_palette_light.operator()(), DPalette::PlaceholderText, dcolor_list[DPalette::PlaceholderText]);
         }
 #endif
         // 处理半透明色
@@ -970,7 +1076,9 @@ DPalette DGuiApplicationHelper::standardPalette(DGuiApplicationHelper::ColorType
 
     for (int i = 0; i < DPalette::NColorTypes; ++i) {
         DPalette::ColorType role = static_cast<DPalette::ColorType>(i);
-        QColor color = dcolor_list[i];
+        QColor color = (type == DarkType)
+            ? paletteDColorFromDConfig(_d_palette_dark.operator()(), role, dcolor_list[i])
+            : paletteDColorFromDConfig(_d_palette_light.operator()(), role, dcolor_list[i]);
 
         // 处理半透明色
         if (allowCompositingColor) {
@@ -1006,13 +1114,13 @@ static void generatePaletteColor_helper(DPalette &base, M role, DGuiApplicationH
     QColor disable_mask_color, inactive_mask_color;
 
     if (type == DGuiApplicationHelper::DarkType) {
-        disable_mask_color = dark_qpalette[QPalette::Window];
-        inactive_mask_color = dark_qpalette[QPalette::Window];
+        disable_mask_color = paletteQColorFromDConfig(_d_palette_dark.operator()(), QPalette::Window, dark_qpalette[QPalette::Window]);
+        inactive_mask_color = disable_mask_color;
         disable_mask_color.setAlphaF(0.7);
         inactive_mask_color.setAlphaF(0.6);
     } else {
-        disable_mask_color = light_qpalette[QPalette::Window];
-        inactive_mask_color = light_qpalette[QPalette::Window];
+        disable_mask_color = paletteQColorFromDConfig(_d_palette_light.operator()(), QPalette::Window, light_qpalette[QPalette::Window]);
+        inactive_mask_color = disable_mask_color;
         disable_mask_color.setAlphaF(0.6);
         inactive_mask_color.setAlphaF(0.4);
     }

src/kernel/kernel.cmake

@@ -19,3 +19,25 @@ dtk_add_config_to_cpp(kernel_SRC ${_PREF_CONFIG_JSON}
   OUTPUT_FILE_NAME orgdeepindtkpreference.hpp
   CLASS_NAME OrgDeepinDTKPreference
 )
+
+if(LINUX)
+  set(_PALETTE_CONFIG_JSON /usr/share/dsg/configs/org.deepin.dtk.palette.json)
+else()
+  set(_PALETTE_CONFIG_JSON ${CMAKE_INSTALL_PREFIX}/share/dsg/configs/org.deepin.dtk.palette.json)
+endif()
+
+dtk_add_config_to_cpp(kernel_SRC ${_PALETTE_CONFIG_JSON}
+  OUTPUT_FILE_NAME orgdeepindtkpalette.hpp
+  CLASS_NAME OrgDeepinDTKPalette
+)
+
+if(LINUX)
+  set(_PALETTE_DARK_CONFIG_JSON /usr/share/dsg/configs/org.deepin.dtk.palette.dark.json)
+else()
+  set(_PALETTE_DARK_CONFIG_JSON ${CMAKE_INSTALL_PREFIX}/share/dsg/configs/org.deepin.dtk.palette.dark.json)
+endif()
+
+dtk_add_config_to_cpp(kernel_SRC ${_PALETTE_DARK_CONFIG_JSON}
+  OUTPUT_FILE_NAME orgdeepindtkpalettedark.hpp
+  CLASS_NAME OrgDeepinDTKPaletteDark
+)