fix: unify screen scaling management with ScreenScale plugin

Refactored the XSettings scaling logic to use the new ScreenScale plugin
as the primary source of truth. The XSettingsManager now delegates scale
factor updates to the "org.deepin.dde.ScreenScale1" D-Bus service. This
change removes redundant scaling calculations and ensures that scaling
configurations are synchronized correctly between XSettings and the
dedicated scaling service. Added a fallback synchronization logic in
onScaleFactorChanged for cases where the ScreenScale service is
unavailable.

Influence:
1. Verify screen scaling updates via XSettings D-Bus and DConfig keys.
2. Ensure ScreenScale1 service correctly handles SetScaleFactor calls.
3. Confirm Plymouth and GTK cursor size are updated on scale changes.
4. Test backward compatibility for apps relying on existing D-Bus properties.

fix: 统一屏幕缩放管理到 ScreenScale 插件

重构了 XSettings 缩放逻辑，将 ScreenScale 插件作为缩放配置的事实来源。
XSettingsManager 现在将缩放因子更新操作委托给
"org.deepin.dde.ScreenScale1" D-Bus 服务。此更改删除了冗余的缩放计算逻
辑，并确保 XSettings 与专用缩放服务之间的配置保持同步。同时，在
ScreenScale 服务不可用时，在 onScaleFactorChanged 中提供了回退同步逻辑。

影响范围：
1. 验证通过 XSettings D-Bus 和 DConfig 键进行的屏幕缩放更新是否生效。
2. 确认 ScreenScale1 服务能正确处理 SetScaleFactor 调用。
3. 确保缩放因子更改时，Plymouth 和 GTK 光标大小能正确更新。
4. 检查与依赖现有 XSettings D-Bus 属性的应用程序的向后兼容性。

pms: BUG-355227
Change-Id: I2363239245451fc5079c39e6b76042d42a87b2a4

Author: fly602

src/plugin-qt/CMakeLists.txt

@@ -1,7 +1,8 @@
-# SPDX-FileCopyrightText: 2025 UnionTech Software Technology Co., Ltd.
+# SPDX-FileCopyrightText: 2025 - 2026 UnionTech Software Technology Co., Ltd.
 #
 # SPDX-License-Identifier: LGPL-3.0-or-later
 
 add_subdirectory("thememanager")
 add_subdirectory("wallpaperslideshow")
-add_subdirectory("xsettings")
+add_subdirectory("xsettings")
+add_subdirectory("screenscale")

src/plugin-qt/screenscale/CMakeLists.txt

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+set(BIN_NAME "plugin-dde-screenscale")
+
+project(${BIN_NAME})
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+
+include(GNUInstallDirs)
+file(GLOB_RECURSE SRCS "*.h" "*.cpp")
+
+find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core DBus Gui)
+find_package(Dtk${DTK_VERSION_MAJOR} REQUIRED COMPONENTS Core)
+
+add_library(${BIN_NAME} MODULE
+    ${SRCS}
+)
+
+target_link_libraries(${BIN_NAME}
+    Qt${QT_VERSION_MAJOR}::Core
+    Qt${QT_VERSION_MAJOR}::DBus
+    Qt${QT_VERSION_MAJOR}::Gui
+    Dtk${DTK_VERSION_MAJOR}::Core
+)
+
+# Install module
+install(TARGETS ${BIN_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR}/deepin-service-manager/)
+
+# Install dbus service file
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/misc/dbus/org.deepin.dde.ScreenScale1.service DESTINATION ${CMAKE_INSTALL_FULL_DATADIR}/dbus-1/services)
+
+# Install systemd service file
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/misc/org.deepin.dde.ScreenScale1.service
+    DESTINATION lib/systemd/user/
+    RENAME org.deepin.dde.ScreenScale1.service
+)
+
+# Install plugin config
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/misc/plugin-dde-screenscale.json DESTINATION ${CMAKE_INSTALL_FULL_DATADIR}/deepin-service-manager/user)
+
+# Install dconf config meta
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/misc/org.deepin.dde.ScreenScale1.json DESTINATION ${CMAKE_INSTALL_FULL_DATADIR}/dsg/configs/org.deepin.dde.daemon)

src/plugin-qt/screenscale/impl/screenscale.cpp

@@ -0,0 +1,255 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "screenscale.h"
+
+#include <DConfig>
+
+#include <QDebug>
+#include <QGuiApplication>
+#include <QScreen>
+
+#include <algorithm>
+#include <cmath>
+
+namespace {
+double toListedScaleFactor(double s, double step = 0.25)
+{
+    const double min = 1.0;
+    const double max = 3.0;
+
+    if (step <= 0)
+        step = 0.25;
+
+    return std::clamp(std::round(s / step) * step, min, max);
+}
+
+double calcRecommendedScaleFactor(
+    double widthPx, double heightPx, double widthMm, double heightMm, double step = 0.25)
+{
+    if (widthMm == 0.0 || heightMm == 0.0) {
+        return 1.0;
+    }
+    double lenPx = std::sqrt(std::pow(widthPx, 2) + std::pow(heightPx, 2));
+    double lenMm = std::sqrt(std::pow(widthMm, 2) + std::pow(heightMm, 2));
+
+    double lenPxStd =
+        std::sqrt(std::pow(1920, 2) + std::pow(1080, 2)); // 标准分辨率对角线长度 (1080p)
+    double lenMmStd =
+        std::sqrt(std::pow(477, 2) + std::pow(268, 2)); // 标准物理尺寸对角线长度 (约21.5英寸显示器)
+
+    const double a = 0.00158; // 经验修正系数，用于平滑不同尺寸屏幕带来的缩放偏差
+    double fix = (lenMm - lenMmStd) * (lenPx / lenPxStd) * a;
+    double scaleFactor = (lenPx / lenMm) / (lenPxStd / lenMmStd) + fix;
+
+    return toListedScaleFactor(scaleFactor, step);
+}
+
+double getRecommendedScaleFactor(double step = 0.25)
+{
+    // If no QGuiApplication instance, we cannot get screens, fallback to 1.0
+    if (!qApp) {
+        return 1.0;
+    }
+
+    auto screens = QGuiApplication::screens();
+    if (screens.isEmpty()) {
+        return 1.0;
+    }
+
+    double minScaleFactor = 3.0;
+    for (auto &&screen : screens) {
+        double realWidth = screen->geometry().width() * screen->devicePixelRatio();
+        double realHeight = screen->geometry().height() * screen->devicePixelRatio();
+
+        qDebug() << "Screen:" << realWidth << realHeight << screen->physicalSize().width()
+                 << screen->physicalSize().height();
+
+        double scaleFactor = calcRecommendedScaleFactor(realWidth,
+                                                        realHeight,
+                                                        screen->physicalSize().width(),
+                                                        screen->physicalSize().height(),
+                                                        step);
+        if (minScaleFactor > scaleFactor) {
+            minScaleFactor = scaleFactor;
+        }
+    }
+
+    return minScaleFactor;
+}
+} // namespace
+
+ScreenScale::ScreenScale(QObject *parent)
+    : QObject(parent)
+    , m_config(DTK_CORE_NAMESPACE::DConfig::create(
+          "org.deepin.dde.daemon", "org.deepin.dde.ScreenScale1", "", this))
+{
+    if (!m_config) {
+        qWarning() << "Failed to create DConfig instance for ScreenScale";
+        return;
+    }
+
+    if (m_config->isValid()) {
+        double step = getScaleStep();
+        double currentFactor = m_config->value("scale-factor").toDouble();
+        if (currentFactor <= 0.0) {
+            double recommended = getRecommendedScaleFactor(step);
+            m_config->setValue("scale-factor", recommended);
+            qDebug() << "Initialized scale-factor to recommended:" << recommended;
+        }
+
+        connect(m_config,
+                &DTK_CORE_NAMESPACE::DConfig::valueChanged,
+                this,
+                [this](const QString &key) {
+                    if (key == "scale-step") {
+                        Q_EMIT AvailableScalesChanged();
+                        Q_EMIT RecommendedScaleChanged();
+                    }
+                });
+    }
+
+    if (qApp) {
+        connect(qApp, &QGuiApplication::screenAdded, this, [this]() {
+            Q_EMIT AvailableScalesChanged();
+            Q_EMIT RecommendedScaleChanged();
+        });
+        connect(qApp, &QGuiApplication::screenRemoved, this, [this]() {
+            Q_EMIT AvailableScalesChanged();
+            Q_EMIT RecommendedScaleChanged();
+        });
+    }
+}
+
+double ScreenScale::GetScaleFactor() const
+{
+    if (m_config && m_config->isValid()) {
+        double currentFactor = m_config->value("scale-factor").toDouble();
+        if (currentFactor > 0.0) {
+            return currentFactor;
+        }
+    }
+
+    // Calculate recommended scale factor but do not save in const method
+    return getRecommendedScaleFactor(getScaleStep());
+}
+
+double ScreenScale::getMaxScaleLimit() const
+{
+    if (!qApp) {
+        return 3.0;
+    }
+
+    auto screens = QGuiApplication::screens();
+    if (screens.isEmpty()) {
+        return 3.0;
+    }
+
+    double maxScale = 3.0;
+    for (auto &&screen : screens) {
+        double realWidth = screen->geometry().width() * screen->devicePixelRatio();
+        double realHeight = screen->geometry().height() * screen->devicePixelRatio();
+
+        double scaleW = realWidth / 1024.0;
+        double scaleH = realHeight / 768.0;
+        double limit = std::min(scaleW, scaleH);
+
+        if (maxScale > limit) {
+            maxScale = limit;
+        }
+    }
+
+    double step = getScaleStep();
+    return std::clamp(std::floor(maxScale / step) * step, 1.0, 3.0);
+}
+
+QList<double> ScreenScale::getAvailableScales() const
+{
+    double maxScaleVal = getMaxScaleLimit();
+    double step = getScaleStep();
+
+    QList<double> range;
+    // 使用整数循环避免浮点数累加误差
+    int count = static_cast<int>((maxScaleVal - 1.0 + 0.0001) / step);
+    for (int i = 0; i <= count; ++i) {
+        range.append(1.0 + i * step);
+    }
+
+    // 补偿精度，确保最后一个值一定是精确的最大值
+    if (range.isEmpty() || !qFuzzyCompare(range.last(), maxScaleVal)) {
+        if (range.isEmpty() || range.last() < maxScaleVal) {
+            range.append(maxScaleVal);
+        }
+    }
+
+    return range;
+}
+
+double ScreenScale::getRecommendedScale() const
+{
+    return getRecommendedScaleFactor(getScaleStep());
+}
+
+double ScreenScale::getScaleStep() const
+{
+    double step = 0.25;
+    if (m_config && m_config->isValid()) {
+        step = m_config->value("scale-step", 0.25).toDouble();
+    }
+
+    if (step <= 0)
+        step = 0.25;
+
+    return step;
+}
+
+void ScreenScale::SetScaleFactor(double factor)
+{
+    if (!m_config || !m_config->isValid()) {
+        return;
+    }
+
+    if (std::isnan(factor) || std::isinf(factor)) {
+        if (calledFromDBus()) {
+            sendErrorReply("org.deepin.dde.ScreenScale1.Error.InvalidParameter",
+                           "NaN or Infinity is not allowed.");
+        }
+        qWarning() << "Invalid scale factor (NaN or Infinity) received, ignoring.";
+        return;
+    }
+
+    // 校验 factor 是否在可用列表中
+    auto availableList = getAvailableScales();
+    bool found = false;
+    for (double v : availableList) {
+        if (qFuzzyCompare(v, factor)) {
+            factor = v; // 修正为列表中的精确值
+            found = true;
+            break;
+        }
+    }
+
+    if (!found) {
+        if (calledFromDBus()) {
+            sendErrorReply(
+                "org.deepin.dde.ScreenScale1.Error.InvalidParameter",
+                QString("Scale factor %1 is not in the available scales list.").arg(factor));
+        }
+        qWarning() << "Requested scale factor" << factor << "is not in the available list.";
+        return;
+    }
+
+    if (qFuzzyCompare(GetScaleFactor(), factor)) {
+        return;
+    }
+
+    qDebug() << "SetScaleFactor:" << factor;
+    m_config->setValue("scale-factor", factor);
+
+    if (qFuzzyCompare(m_config->value("scale-factor").toDouble(), factor)) {
+        Q_EMIT ScaleFactorChanged(factor);
+    } else {
+        qWarning() << "Failed to save scale factor to DConfig.";
+    }
+}

src/plugin-qt/screenscale/impl/screenscale.h

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#ifndef SCREEN_SCALE_H
+#define SCREEN_SCALE_H
+
+#include <DConfig>
+
+#include <QDBusContext>
+#include <QList>
+#include <QObject>
+
+class ScreenScale : public QObject, protected QDBusContext
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.deepin.dde.ScreenScale1")
+    Q_PROPERTY(double RecommendedScale READ getRecommendedScale NOTIFY RecommendedScaleChanged)
+    Q_PROPERTY(QList<double> AvailableScales READ getAvailableScales NOTIFY AvailableScalesChanged)
+    Q_PROPERTY(double ScaleFactor READ GetScaleFactor WRITE SetScaleFactor NOTIFY ScaleFactorChanged)
+
+public:
+    explicit ScreenScale(QObject *parent = nullptr);
+    ~ScreenScale() override = default;
+
+    double getRecommendedScale() const;
+    QList<double> getAvailableScales() const;
+
+public Q_SLOTS:
+    double GetScaleFactor() const;
+    void SetScaleFactor(double factor);
+
+Q_SIGNALS:
+    void ScaleFactorChanged(double factor);
+    void AvailableScalesChanged();
+    void RecommendedScaleChanged();
+
+private:
+    double getMaxScaleLimit() const;
+    double getScaleStep() const;
+
+    DTK_CORE_NAMESPACE::DConfig *m_config = nullptr;
+};
+
+#endif // SCREEN_SCALE_H

src/plugin-qt/screenscale/misc/dbus/org.deepin.dde.ScreenScale1.service

@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=org.deepin.dde.ScreenScale1
+Exec=/usr/bin/false
+SystemdService=org.deepin.dde.ScreenScale1.service

src/plugin-qt/screenscale/misc/org.deepin.dde.ScreenScale1.json

@@ -0,0 +1,26 @@
+{
+  "magic": "dsg.config.meta",
+  "version": "1.0",
+  "contents": {
+    "scale-factor": {
+      "value": 0.0,
+      "serial": 0,
+      "flags": [],
+      "name": "Global Scale Factor",
+      "name[zh_CN]": "全局缩放比例",
+      "description": "Global scale factor for all monitors.",
+      "permissions": "readwrite",
+      "visibility": "public"
+    },
+    "scale-step": {
+      "value": 0.25,
+      "serial": 0,
+      "flags": [],
+      "name": "Scale Step",
+      "name[zh_CN]": "缩放步长",
+      "description": "Step size for screen scaling.",
+      "permissions": "readonly",
+      "visibility": "public"
+    }
+  }
+}