feat: enable XdgIconLoader support for Qt6 builds

Previously, dtkgui.cmake unconditionally disabled libxdg for all
non-Qt5 builds with:

  else()
    set(DTK_DISABLE_LIBXDG ON)
  endif()

This caused XdgIconProxyEngine to be excluded from the Qt6 build,
falling back to QPlatformTheme::createIconEngine() which uses Qt's
built-in SVG renderer. That renderer incorrectly renders <clipPath>,
<mask>, and <filter> elements outside <defs> as visible shapes,
causing opaque background corners on many app icons.

Fix by using find_package(qt6xdgiconloader QUIET) for Qt6 builds,
mirroring the existing Qt5XdgIconLoader handling. The XdgIconProxyEngine
is also updated to use DSvgRenderer (librsvg) for all scalable SVG
entries to ensure correct rendering.

Two additional fixes for the Qt6 XdgIconProxy path:

1. XdgIconProxyEngine::isNull() is added as a Qt6-only override.
   Qt6 changed isNull() from a virtual_hook-based mechanism to a
   direct virtual function (default: false), so without this override
   the proxy always appeared non-null even when the underlying engine
   found no icon. The override also treats entries with dir.size == 0
   (from XdgIconLoader::unthemedFallback, e.g. /usr/share/pixmaps)
   as null, since XdgIconProxy cannot render them correctly.

2. DIconProxyEngine::ensureEngine() uses QPlatformTheme::createIconEngine()
   as an unconditional fallback after the XdgProxy attempt. This lets
   Qt's native QIconLoaderEngine handle icons only found in non-themed
   locations like /usr/share/pixmaps (e.g. xscreensaver).

Fixes SVG icon rendering issues on Arch.

Author: felixonmars

dtkgui.cmake

@@ -116,15 +116,18 @@ find_package(DtkBuildHelper REQUIRED)
 pkg_check_modules(librsvg REQUIRED IMPORTED_TARGET librsvg-2.0)
 
 if(NOT DTK_DISABLE_LIBXDG)
-  # Only use libxdg under Qt5
   if (${QT_VERSION_MAJOR} STREQUAL "5")
     find_package(Qt5XdgIconLoader REQUIRED)
     if (NOT Qt5XdgIconLoader_FOUND)
         message(WARNING " XdgIconLoader Not Found, DISABLE LIBXDG !")
         set (DTK_DISABLE_LIBXDG ON)
     endif()
   else()
-    set (DTK_DISABLE_LIBXDG ON)
+    find_package(qt6xdgiconloader QUIET)
+    if (NOT qt6xdgiconloader_FOUND)
+        message(WARNING " Qt6XdgIconLoader Not Found, DISABLE LIBXDG !")
+        set (DTK_DISABLE_LIBXDG ON)
+    endif()
   endif()
 endif()
 

src/util/private/diconproxyengine.cpp

@@ -260,20 +260,20 @@ void DIconProxyEngine::ensureEngine()
     if (!m_iconEngine && Q_UNLIKELY(!m_option.testFlag(DIconTheme::IgnoreBuiltinIcons)) ) {
         m_iconEngine = createDBuiltinIconEngine(m_iconName);
     }
-#ifdef DTK_DISABLE_LIBXDG
+#ifndef DTK_DISABLE_LIBXDG
+    if (!m_iconEngine) {
+        m_iconEngine = createXdgProxyIconEngine(m_iconName);
+    }
+#endif
+    // Fallback to Qt's native icon engine for icons only found in /usr/share/pixmaps
+    // or other non-themed locations that XdgIconLoader cannot render correctly
+    // (e.g. xscreensaver). Also serves as fallback when libxdg is disabled.
     if (!m_iconEngine) {
         QPlatformTheme * const platformTheme = QGuiApplicationPrivate::platformTheme();
         if (platformTheme) {
             m_iconEngine = platformTheme->QPlatformTheme::createIconEngine(m_iconName);
-        } else {
-            qWarning() << "PlatformTheme not found!";
         }
     }
-#else
-    if (!m_iconEngine ) {
-        m_iconEngine = createXdgProxyIconEngine(m_iconName);
-    }
-#endif
     if (!m_iconEngine && !nonCache[theme].contains(m_iconName)) {
         qWarning() << "create icon [" << m_iconName << "] engine failed."
                    << "theme:" << theme << "and nonCache's size:" << nonCache.size();

src/util/private/xdgiconproxyengine.cpp

@@ -12,6 +12,7 @@
 #include <QPainter>
 #include <QPalette>
 #include <QGuiApplication>
+#include <DSvgRenderer>
 
 #include <cxxabi.h>
 #include <qmath.h>
@@ -61,6 +62,41 @@ static inline QPixmap entryPixmap(ScalableEntry *color_entry, const QSize &size,
     return color_entry->svgIcon.pixmap(size, mode, state);
 }
 
+// Render a scalable SVG entry using DSvgRenderer (backed by librsvg) when available.
+//
+// This is a workaround for a long-standing Qt SVG rendering bug: QSvgRenderer
+// incorrectly renders <clipPath>, <mask>, and <filter> elements that appear as
+// direct children of the root <svg> element (outside any <defs> block) as visible
+// painted shapes. This causes icons that use such constructs (e.g., many GNOME app
+// icons like Epiphany) to render with opaque black backgrounds instead of transparent
+// corners.
+//
+// DSvgRenderer uses librsvg via cairo when available, which handles these SVG
+// features correctly. If librsvg is not installed, DSvgRenderer::isValid() returns
+// false and we fall back gracefully to the default Qt rendering path (entryPixmap),
+// preserving existing behavior on systems without librsvg.
+static QPixmap renderSvgWithLibrsvg(ScalableEntry *entry, const QSize &size,
+                                     QIcon::Mode mode, QIcon::State state)
+{
+    DGUI_USE_NAMESPACE
+    DSvgRenderer renderer(entry->filename);
+    if (renderer.isValid()) {
+        QSize actualSize = renderer.defaultSize();
+        if (!size.isEmpty() && !actualSize.isEmpty()) {
+            if (actualSize.width() < size.width())
+                actualSize.scale(size, Qt::KeepAspectRatio);
+        }
+        if (!actualSize.isEmpty()) {
+            const QImage img = renderer.toImage(actualSize);
+            if (!img.isNull())
+                return QPixmap::fromImage(
+                    img.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+        }
+    }
+    // librsvg unavailable or rendering failed — fall back to QIcon-based path
+    return entryPixmap(entry, size, mode, state);
+}
+
 static const QString STYLE = QStringLiteral(".ColorScheme-Text, .ColorScheme-NeutralText{color:%1;}\
 \n.ColorScheme-Highlight{color:%2;}");
 
@@ -186,9 +222,20 @@ QPixmap XdgIconProxyEngine::followColorPixmap(ScalableEntry *color_entry, const
 
 QPixmap XdgIconProxyEngine::pixmapByEntry(QIconLoaderEngineEntry *entry, const QSize &size, QIcon::Mode mode, QIcon::State state)
 {
+    char *type_name = abi::__cxa_demangle(typeid(*entry).name(), 0, 0, 0);
+    // ScalableFollowsColorEntry is a subclass of ScalableEntry but its mangled name
+    // does NOT contain the substring "ScalableEntry", so the contains() check below
+    // correctly distinguishes between the two types.
+    const bool isScalableFollowsColor = (type_name == QByteArrayLiteral("ScalableFollowsColorEntry"));
+    const bool isScalable = isScalableFollowsColor || QByteArray(type_name).contains("ScalableEntry");
+    free(type_name);
+
     if (!XdgIconFollowColorScheme()) {
         DEEPIN_XDG_THEME::colorScheme.setLocalData(DEEPIN_XDG_THEME::PALETTE_MAP());
 
+        if (isScalable)
+            return renderSvgWithLibrsvg(static_cast<ScalableEntry *>(entry), size, mode, state);
+
 #if QT_VERSION >= QT_VERSION_CHECK(6, 8, 1)
         return entry->pixmap(size, mode, state, 1.0);
 #else
@@ -197,9 +244,8 @@ QPixmap XdgIconProxyEngine::pixmapByEntry(QIconLoaderEngineEntry *entry, const Q
     }
 
     QPixmap pixmap;
-    char *type_name = abi::__cxa_demangle(typeid(*entry).name(), 0, 0, 0);
 
-    if (type_name == QByteArrayLiteral("ScalableFollowsColorEntry")) {
+    if (isScalableFollowsColor) {
         if (DEEPIN_XDG_THEME::colorScheme.localData().isEmpty()) {
             const QPalette &pal = palette(&pixmap);
             DEEPIN_XDG_THEME::colorScheme.setLocalData(DEEPIN_XDG_THEME::PALETTE_MAP({
@@ -209,6 +255,10 @@ QPixmap XdgIconProxyEngine::pixmapByEntry(QIconLoaderEngineEntry *entry, const Q
         }
 
         pixmap = followColorPixmap(static_cast<ScalableEntry *>(entry), size, mode, state);
+    } else if (isScalable) {
+        // Regular scalable SVG entry (no color scheme) — use DSvgRenderer (librsvg)
+        // to avoid Qt's QSvgRenderer bug with <clipPath> outside <defs>.
+        pixmap = renderSvgWithLibrsvg(static_cast<ScalableEntry *>(entry), size, mode, state);
     } else {
 #if QT_VERSION >= QT_VERSION_CHECK(6, 8, 1)
         pixmap = entry->pixmap(size, mode, state, 1.0);
@@ -217,7 +267,6 @@ QPixmap XdgIconProxyEngine::pixmapByEntry(QIconLoaderEngineEntry *entry, const Q
 #endif
     }
 
-    free(type_name);
     DEEPIN_XDG_THEME::colorScheme.setLocalData(DEEPIN_XDG_THEME::PALETTE_MAP());
 
     return pixmap;
@@ -301,6 +350,25 @@ bool XdgIconProxyEngine::write(QDataStream &out) const
     return engine->write(out);
 }
 
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+bool XdgIconProxyEngine::isNull()
+{
+    if (engine->isNull())
+        return true;
+    // Entries from XdgIconLoader::unthemedFallback() (e.g. /usr/share/pixmaps)
+    // have a default-constructed QIconDirInfo with dir.size == 0. These entries
+    // cannot be rendered correctly by XdgIconProxyEngine, so treat the engine as
+    // null when all entries originate from the unthemed fallback. The caller
+    // (DIconProxyEngine) will then use Qt's native QIconLoaderEngine which handles
+    // pixmap-only icons correctly.
+    for (const auto &entry : engine->m_info.entries) {
+        if (entry->dir.size > 0)
+            return false;
+    }
+    return true;
+}
+#endif
+
 void XdgIconProxyEngine::virtual_hook(int id, void *data)
 {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)

src/util/private/xdgiconproxyengine_p.h

@@ -48,6 +48,9 @@ class Q_DECL_HIDDEN XdgIconProxyEngine : public QIconEngine
     QIconEngine *clone() const override;
     bool read(QDataStream &in) override;
     bool write(QDataStream &out) const override;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    bool isNull() override;
+#endif
     void virtual_hook(int id, void *data) override;
 
 private: