feat: sync dock fonts and improve launcher matching

Sync the dock font assets with the new UI behavior.
Improve launcher matching so fashion mode items resolve correctly.

Author: shule1987

LICENSES/OFL-1.1.txt

@@ -0,0 +1,89 @@
+SIL OPEN FONT LICENSE
+
+Version 1.1 - 26 February 2007
+
+PREAMBLE
+
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply to any
+document created using the fonts or their derivatives.
+
+DEFINITIONS
+
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in
+Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or in
+the appropriate machine-readable metadata fields within text or binary
+files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name
+as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any Modified
+Version, except to acknowledge the contribution(s) of the Copyright
+Holder(s) and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must
+be distributed entirely under this license, and must not be distributed
+under any other license. The requirement for fonts to remain under this
+license does not apply to any document created using the Font Software.
+
+TERMINATION
+
+This license becomes null and void if any of the above conditions are not
+met.
+
+DISCLAIMER
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.

REUSE.toml

@@ -92,3 +92,9 @@ path = "toolGenerate/**/**"
 precedence = "aggregate"
 SPDX-FileCopyrightText = "None"
 SPDX-License-Identifier = "CC0-1.0"
+
+[[annotations]]
+path = "shell/fonts/ElmsSans-Regular.ttf"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2025 The Elms Sans Project Authors"
+SPDX-License-Identifier = "OFL-1.1"

frame/dsqmlglobal.cpp

@@ -10,6 +10,7 @@
 
 #include <QLoggingCategory>
 #include <QCoreApplication>
+#include <QFontDatabase>
 #include <QQueue>
 #include <QWindow>
 #include <QGuiApplication>
@@ -27,6 +28,34 @@ DCORE_USE_NAMESPACE
 
 Q_DECLARE_LOGGING_CATEGORY(dsLog)
 
+namespace {
+
+QString shellDataFontFamily()
+{
+    static QString dataFontFamily;
+    static bool initialized = false;
+
+    if (initialized) {
+        return dataFontFamily;
+    }
+
+    initialized = true;
+    const int fontId = QFontDatabase::addApplicationFont(QStringLiteral(":/shell/fonts/ElmsSans-Regular.ttf"));
+    if (fontId < 0) {
+        qCWarning(dsLog) << "Failed to load shell data font resource";
+        return dataFontFamily;
+    }
+
+    const QStringList families = QFontDatabase::applicationFontFamilies(fontId);
+    if (!families.isEmpty()) {
+        dataFontFamily = families.constFirst();
+    }
+
+    return dataFontFamily;
+}
+
+} // namespace
+
 class DQmlGlobalPrivate : public DObjectPrivate
 {
 public:
@@ -87,6 +116,11 @@ DApplet *DQmlGlobal::rootApplet() const
     return DPluginLoader::instance()->rootApplet();
 }
 
+QString DQmlGlobal::dataFontFamily() const
+{
+    return shellDataFontFamily();
+}
+
 void DQmlGlobal::singleShot(int msec, QJSValue callback)
 {
     if (!callback.isCallable()) {

frame/private/dsqmlglobal_p.h

@@ -24,6 +24,7 @@ class DQmlGlobal : public QObject, public DTK_CORE_NAMESPACE::DObject
     Q_OBJECT
     D_DECLARE_PRIVATE(DQmlGlobal)
     Q_PROPERTY(DApplet* rootApplet READ rootApplet NOTIFY rootAppletChanged FINAL)
+    Q_PROPERTY(QString dataFontFamily READ dataFontFamily CONSTANT FINAL)
 public:
     explicit DQmlGlobal(QObject *parent = nullptr);
     ~DQmlGlobal() override;
@@ -36,6 +37,7 @@ class DQmlGlobal : public QObject, public DTK_CORE_NAMESPACE::DObject
     Q_INVOKABLE void singleShot(int msec, QJSValue callback);
 
     DApplet *rootApplet() const;
+    QString dataFontFamily() const;
 
     static DQmlGlobal *instance();
     static QList<QWindow *> allChildrenWindows(QWindow *target);

panels/dock/CMakeLists.txt

@@ -59,6 +59,25 @@ add_library(dockpanel SHARED
     ${dock_panel_sources}
 )
 
+add_dependencies(dockpanel tray_loader_font_sync)
+
+add_library(tray_loader_font_sync SHARED
+    tray_loader_font_sync.cpp
+    tray_loader_font_sync.qrc
+)
+
+set_target_properties(tray_loader_font_sync PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}"
+)
+
+target_link_libraries(tray_loader_font_sync PRIVATE
+    Qt${QT_VERSION_MAJOR}::Core
+    Qt${QT_VERSION_MAJOR}::Gui
+    Qt${QT_VERSION_MAJOR}::Widgets
+)
+
+install(TARGETS tray_loader_font_sync DESTINATION "${CMAKE_INSTALL_LIBDIR}/dde-shell")
+
 qt_generate_wayland_protocol_client_sources(dockpanel
     NO_INCLUDE_CORE_ONLY
     FILES

panels/dock/dockpanel.cpp

@@ -40,28 +40,69 @@ constexpr auto kAppearancePath = "/org/deepin/dde/Appearance1";
 constexpr auto kAppearanceInterface = "org.deepin.dde.Appearance1";
 constexpr auto kPropertiesInterface = "org.freedesktop.DBus.Properties";
 
-ColorTheme colorThemeFromGlobalThemeName(const QString &themeName, const ColorTheme &fallbackTheme)
+Dtk::Gui::DGuiApplicationHelper::ColorType explicitThemeTypeFromName(const QString &themeName)
 {
-    if (themeName.endsWith(QStringLiteral(".dark"), Qt::CaseInsensitive))
-        return Dark;
+    const QString normalizedThemeName = themeName.trimmed().toLower();
+    if (normalizedThemeName.isEmpty())
+        return Dtk::Gui::DGuiApplicationHelper::UnknownType;
 
-    if (themeName.endsWith(QStringLiteral(".light"), Qt::CaseInsensitive))
-        return Light;
+    if (normalizedThemeName == QStringLiteral("dark")
+        || normalizedThemeName.endsWith(QStringLiteral(".dark"))
+        || normalizedThemeName.endsWith(QStringLiteral("-dark"))
+        || normalizedThemeName.endsWith(QStringLiteral("_dark"))) {
+        return Dtk::Gui::DGuiApplicationHelper::DarkType;
+    }
+
+    if (normalizedThemeName == QStringLiteral("light")
+        || normalizedThemeName.endsWith(QStringLiteral(".light"))
+        || normalizedThemeName.endsWith(QStringLiteral("-light"))
+        || normalizedThemeName.endsWith(QStringLiteral("_light"))) {
+        return Dtk::Gui::DGuiApplicationHelper::LightType;
+    }
 
-    return fallbackTheme;
+    return Dtk::Gui::DGuiApplicationHelper::UnknownType;
 }
 
-Dtk::Gui::DGuiApplicationHelper::ColorType helperThemeTypeFromGlobalThemeName(
-    const QString &themeName,
-    Dtk::Gui::DGuiApplicationHelper::ColorType fallbackTheme)
+Dtk::Gui::DGuiApplicationHelper::ColorType currentEffectiveThemeType(Dtk::Gui::DGuiApplicationHelper *helper)
 {
-    if (themeName.endsWith(QStringLiteral(".dark"), Qt::CaseInsensitive))
-        return Dtk::Gui::DGuiApplicationHelper::DarkType;
-
-    if (themeName.endsWith(QStringLiteral(".light"), Qt::CaseInsensitive))
+    if (!helper)
         return Dtk::Gui::DGuiApplicationHelper::LightType;
 
-    return fallbackTheme;
+    const auto currentThemeType = helper->themeType();
+    if (currentThemeType != Dtk::Gui::DGuiApplicationHelper::UnknownType)
+        return currentThemeType;
+
+    const auto currentPaletteType = helper->paletteType();
+    if (currentPaletteType != Dtk::Gui::DGuiApplicationHelper::UnknownType)
+        return currentPaletteType;
+
+    return Dtk::Gui::DGuiApplicationHelper::LightType;
+}
+
+Dtk::Gui::DGuiApplicationHelper::ColorType effectiveThemeTypeFromAppearance(
+    const QString &globalThemeName,
+    const QString &gtkThemeName,
+    const QString &iconThemeName,
+    Dtk::Gui::DGuiApplicationHelper *helper)
+{
+    const auto globalThemeType = explicitThemeTypeFromName(globalThemeName);
+    if (globalThemeType != Dtk::Gui::DGuiApplicationHelper::UnknownType)
+        return globalThemeType;
+
+    const auto gtkThemeType = explicitThemeTypeFromName(gtkThemeName);
+    if (gtkThemeType != Dtk::Gui::DGuiApplicationHelper::UnknownType)
+        return gtkThemeType;
+
+    const auto iconThemeType = explicitThemeTypeFromName(iconThemeName);
+    if (iconThemeType != Dtk::Gui::DGuiApplicationHelper::UnknownType)
+        return iconThemeType;
+
+    return currentEffectiveThemeType(helper);
+}
+
+ColorTheme colorThemeFromHelperThemeType(Dtk::Gui::DGuiApplicationHelper::ColorType themeType)
+{
+    return themeType == Dtk::Gui::DGuiApplicationHelper::DarkType ? Dark : Light;
 }
 
 QString readAppearanceStringProperty(const QString &propertyName)
@@ -87,7 +128,9 @@ void syncApplicationTheme(Dtk::Gui::DGuiApplicationHelper *helper,
     if (!helper)
         return;
 
-    const auto targetThemeType = helperThemeTypeFromGlobalThemeName(globalThemeName, helper->themeType());
+    const auto explicitThemeType = explicitThemeTypeFromName(globalThemeName);
+    const bool followSystemTheme = explicitThemeType == Dtk::Gui::DGuiApplicationHelper::UnknownType;
+    const auto targetPaletteType = followSystemTheme ? Dtk::Gui::DGuiApplicationHelper::UnknownType : explicitThemeType;
 
     if (auto *applicationTheme = helper->applicationTheme()) {
         const QByteArray gtkThemeNameBytes = gtkThemeName.toUtf8();
@@ -101,10 +144,11 @@ void syncApplicationTheme(Dtk::Gui::DGuiApplicationHelper *helper,
         }
     }
 
-    if (helper->paletteType() != targetThemeType) {
-        helper->setPaletteType(targetThemeType);
+    if (helper->paletteType() != targetPaletteType) {
+        helper->setPaletteType(targetPaletteType);
     }
 
+    const auto targetThemeType = effectiveThemeTypeFromAppearance(globalThemeName, gtkThemeName, iconThemeName, helper);
     const QPalette targetPalette = helper->applicationPalette(targetThemeType);
     if (helper->applicationPalette() != targetPalette) {
         helper->setApplicationPalette(targetPalette);
@@ -353,7 +397,6 @@ void DockPanel::onAppearanceRefreshed(const QString &type)
 void DockPanel::syncColorThemeWithSystem()
 {
     auto *guiHelper = Dtk::Gui::DGuiApplicationHelper::instance();
-    const auto fallbackTheme = static_cast<ColorTheme>(guiHelper->themeType());
     QDBusInterface appearanceProperties(kAppearanceService,
                                         kAppearancePath,
                                         kPropertiesInterface,
@@ -367,13 +410,14 @@ void DockPanel::syncColorThemeWithSystem()
             const QString gtkThemeName = readAppearanceStringProperty(QStringLiteral("GtkTheme"));
             const QString iconThemeName = readAppearanceStringProperty(QStringLiteral("IconTheme"));
             syncApplicationTheme(guiHelper, globalThemeName, gtkThemeName, iconThemeName);
-            setColorTheme(colorThemeFromGlobalThemeName(globalThemeName, fallbackTheme));
+            setColorTheme(colorThemeFromHelperThemeType(
+                effectiveThemeTypeFromAppearance(globalThemeName, gtkThemeName, iconThemeName, guiHelper)));
             return;
         }
     }
 
     syncApplicationTheme(guiHelper, QString(), QString(), QString());
-    setColorTheme(fallbackTheme);
+    setColorTheme(colorThemeFromHelperThemeType(currentEffectiveThemeType(guiHelper)));
 }
 
 uint DockPanel::dockSize()

panels/dock/environments.h.in

@@ -5,4 +5,7 @@
 #pragma once
 
 #define CMAKE_INSTALL_FULL_LIBEXECDIR "@CMAKE_INSTALL_FULL_LIBEXECDIR@"
+#define CMAKE_INSTALL_FULL_LIBDIR "@CMAKE_INSTALL_FULL_LIBDIR@"
 #define CMAKE_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@"
+#define TRAY_LOADER_FONT_SYNC_BUILD_PATH "@PROJECT_BINARY_DIR@/libtray_loader_font_sync.so"
+#define TRAY_LOADER_FONT_SYNC_INSTALL_PATH "@CMAKE_INSTALL_FULL_LIBDIR@/dde-shell/libtray_loader_font_sync.so"

panels/dock/loadtrayplugins.cpp

@@ -10,11 +10,33 @@
 #include <DConfig>
 
 #include <QDir>
+#include <QFileInfo>
 #include <QTimer>
 #include <QGuiApplication>
 
 namespace dock {
 
+namespace {
+
+QString trayLoaderFontSyncPath()
+{
+    const QStringList candidates = {
+        qEnvironmentVariable("TRAY_LOADER_FONT_SYNC_PATH"),
+        QString::fromLatin1(TRAY_LOADER_FONT_SYNC_BUILD_PATH),
+        QString::fromLatin1(TRAY_LOADER_FONT_SYNC_INSTALL_PATH)
+    };
+
+    for (const QString &candidate : candidates) {
+        if (!candidate.isEmpty() && QFileInfo::exists(candidate)) {
+            return candidate;
+        }
+    }
+
+    return QString();
+}
+
+} // namespace
+
 LoadTrayPlugins::LoadTrayPlugins(QObject *parent)
     : QObject(parent)
 {
@@ -98,6 +120,15 @@ void LoadTrayPlugins::setProcessEnv(QProcess *process)
     // TODO: use protocols to determine the environment instead of environment variables
     env.remove("DDE_CURRENT_COMPOSITOR");
 
+    const QString fontSyncPath = trayLoaderFontSyncPath();
+    if (!fontSyncPath.isEmpty()) {
+        QStringList preloadEntries = env.value(QStringLiteral("LD_PRELOAD")).split(QLatin1Char(':'), Qt::SkipEmptyParts);
+        if (!preloadEntries.contains(fontSyncPath)) {
+            preloadEntries.prepend(fontSyncPath);
+        }
+        env.insert(QStringLiteral("LD_PRELOAD"), preloadEntries.join(QLatin1Char(':')));
+    }
+
     process->setProcessEnvironment(env);
 }