/**
 * This file is generated by dconfig2cpp.
 * Command line arguments: /usr/lib/dtk6/DCore/bin/dconfig2cpp -o /build/treeland/src/treeland/build/src/treelanduserconfig.hpp -c TreelandUserConfig /build/treeland/src/treeland/misc/dconfig/org.deepin.dde.treeland.user.json
 * Generation time: 2026-08-18T12:51:56
 * JSON file version: 1.0
 * Tool version: 1.1
 *
 * WARNING: DO NOT MODIFY THIS FILE MANUALLY.
 * If you need to change the content, please modify the dconfig2cpp tool.
 */

#ifndef TREELANDUSERCONFIG_H
#define TREELANDUSERCONFIG_H

#define TREELANDUSERCONFIG_DCONFIG_FILE_VERSION_MAJOR 1
#define TREELANDUSERCONFIG_DCONFIG_FILE_VERSION_MINOR 1
#define TREELANDUSERCONFIG_DCONFIG_FILE_activeColor
#define TREELANDUSERCONFIG_DCONFIG_FILE_blurAmount
#define TREELANDUSERCONFIG_DCONFIG_FILE_blurMultiplier
#define TREELANDUSERCONFIG_DCONFIG_FILE_blurStrength
#define TREELANDUSERCONFIG_DCONFIG_FILE_currentWorkspace
#define TREELANDUSERCONFIG_DCONFIG_FILE_cursorBlink
#define TREELANDUSERCONFIG_DCONFIG_FILE_cursorBlinkTime
#define TREELANDUSERCONFIG_DCONFIG_FILE_cursorSize
#define TREELANDUSERCONFIG_DCONFIG_FILE_cursorThemeName
#define TREELANDUSERCONFIG_DCONFIG_FILE_defaultBackground
#define TREELANDUSERCONFIG_DCONFIG_FILE_dndDragThreshold
#define TREELANDUSERCONFIG_DCONFIG_FILE_doubleClickDistance
#define TREELANDUSERCONFIG_DCONFIG_FILE_doubleClickTime
#define TREELANDUSERCONFIG_DCONFIG_FILE_edgeInnerDelayMs
#define TREELANDUSERCONFIG_DCONFIG_FILE_edgeSideTriggerDistance
#define TREELANDUSERCONFIG_DCONFIG_FILE_edgeTopTriggerDistance
#define TREELANDUSERCONFIG_DCONFIG_FILE_font
#define TREELANDUSERCONFIG_DCONFIG_FILE_fontSize
#define TREELANDUSERCONFIG_DCONFIG_FILE_glassBezel
#define TREELANDUSERCONFIG_DCONFIG_FILE_glassEnabled
#define TREELANDUSERCONFIG_DCONFIG_FILE_glassProfilePower
#define TREELANDUSERCONFIG_DCONFIG_FILE_glassSaturation
#define TREELANDUSERCONFIG_DCONFIG_FILE_glassSpecular
#define TREELANDUSERCONFIG_DCONFIG_FILE_glassThickness
#define TREELANDUSERCONFIG_DCONFIG_FILE_highlightBorderWidth
#define TREELANDUSERCONFIG_DCONFIG_FILE_iconThemeName
#define TREELANDUSERCONFIG_DCONFIG_FILE_lostScreen
#define TREELANDUSERCONFIG_DCONFIG_FILE_maxWorkspace
#define TREELANDUSERCONFIG_DCONFIG_FILE_minMultitaskviewSurfaceHeight
#define TREELANDUSERCONFIG_DCONFIG_FILE_monoFont
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewAnimationDuration
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewBottomContentMargin
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewCellPadding
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewEasingCurveType
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewHorizontalMargin
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewLoadFactor
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewPaddingOpacity
#define TREELANDUSERCONFIG_DCONFIG_FILE_multitaskviewTopContentMargin
#define TREELANDUSERCONFIG_DCONFIG_FILE_normalWindowHeight
#define TREELANDUSERCONFIG_DCONFIG_FILE_numWorkspace
#define TREELANDUSERCONFIG_DCONFIG_FILE_preferDark
#define TREELANDUSERCONFIG_DCONFIG_FILE_showOnLock
#define TREELANDUSERCONFIG_DCONFIG_FILE_themeName
#define TREELANDUSERCONFIG_DCONFIG_FILE_titleBoxCornerRadius
#define TREELANDUSERCONFIG_DCONFIG_FILE_wallpaperConfig
#define TREELANDUSERCONFIG_DCONFIG_FILE_windowHeightStep
#define TREELANDUSERCONFIG_DCONFIG_FILE_windowOpacity
#define TREELANDUSERCONFIG_DCONFIG_FILE_windowRadius
#define TREELANDUSERCONFIG_DCONFIG_FILE_windowThemeType
#define TREELANDUSERCONFIG_DCONFIG_FILE_windowTitlebarHeight
#define TREELANDUSERCONFIG_DCONFIG_FILE_workspaceThumbCornerRadius
#define TREELANDUSERCONFIG_DCONFIG_FILE_workspaceThumbHeight
#define TREELANDUSERCONFIG_DCONFIG_FILE_workspaceThumbMargin

#include <QThread>
#include <QVariant>
#include <QPointer>
#include <QDebug>
#include <QAtomicPointer>
#include <QAtomicInteger>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#include <QProperty>
#endif
#include <QEvent>
#include <DSGApplication>
#include <DConfig>

class TreelandUserConfig : public QObject {
    Q_OBJECT

    Q_PROPERTY(QString activeColor READ activeColor WRITE setActiveColor NOTIFY activeColorChanged RESET resetActiveColor)
    Q_PROPERTY(double blurAmount READ blurAmount WRITE setBlurAmount NOTIFY blurAmountChanged RESET resetBlurAmount)
    Q_PROPERTY(double blurMultiplier READ blurMultiplier WRITE setBlurMultiplier NOTIFY blurMultiplierChanged RESET resetBlurMultiplier)
    Q_PROPERTY(qlonglong blurStrength READ blurStrength WRITE setBlurStrength NOTIFY blurStrengthChanged RESET resetBlurStrength)
    Q_PROPERTY(qlonglong currentWorkspace READ currentWorkspace WRITE setCurrentWorkspace NOTIFY currentWorkspaceChanged RESET resetCurrentWorkspace)
    Q_PROPERTY(bool cursorBlink READ cursorBlink WRITE setCursorBlink NOTIFY cursorBlinkChanged RESET resetCursorBlink)
    Q_PROPERTY(qlonglong cursorBlinkTime READ cursorBlinkTime WRITE setCursorBlinkTime NOTIFY cursorBlinkTimeChanged RESET resetCursorBlinkTime)
    Q_PROPERTY(qlonglong cursorSize READ cursorSize WRITE setCursorSize NOTIFY cursorSizeChanged RESET resetCursorSize)
    Q_PROPERTY(QString cursorThemeName READ cursorThemeName WRITE setCursorThemeName NOTIFY cursorThemeNameChanged RESET resetCursorThemeName)
    Q_PROPERTY(QString defaultBackground READ defaultBackground WRITE setDefaultBackground NOTIFY defaultBackgroundChanged RESET resetDefaultBackground)
    Q_PROPERTY(qlonglong dndDragThreshold READ dndDragThreshold WRITE setDndDragThreshold NOTIFY dndDragThresholdChanged RESET resetDndDragThreshold)
    Q_PROPERTY(qlonglong doubleClickDistance READ doubleClickDistance WRITE setDoubleClickDistance NOTIFY doubleClickDistanceChanged RESET resetDoubleClickDistance)
    Q_PROPERTY(qlonglong doubleClickTime READ doubleClickTime WRITE setDoubleClickTime NOTIFY doubleClickTimeChanged RESET resetDoubleClickTime)
    Q_PROPERTY(qlonglong edgeInnerDelayMs READ edgeInnerDelayMs WRITE setEdgeInnerDelayMs NOTIFY edgeInnerDelayMsChanged RESET resetEdgeInnerDelayMs)
    Q_PROPERTY(qlonglong edgeSideTriggerDistance READ edgeSideTriggerDistance WRITE setEdgeSideTriggerDistance NOTIFY edgeSideTriggerDistanceChanged RESET resetEdgeSideTriggerDistance)
    Q_PROPERTY(qlonglong edgeTopTriggerDistance READ edgeTopTriggerDistance WRITE setEdgeTopTriggerDistance NOTIFY edgeTopTriggerDistanceChanged RESET resetEdgeTopTriggerDistance)
    Q_PROPERTY(QString font READ font WRITE setFont NOTIFY fontChanged RESET resetFont)
    Q_PROPERTY(qlonglong fontSize READ fontSize WRITE setFontSize NOTIFY fontSizeChanged RESET resetFontSize)
    Q_PROPERTY(qlonglong glassBezel READ glassBezel WRITE setGlassBezel NOTIFY glassBezelChanged RESET resetGlassBezel)
    Q_PROPERTY(bool glassEnabled READ glassEnabled WRITE setGlassEnabled NOTIFY glassEnabledChanged RESET resetGlassEnabled)
    Q_PROPERTY(double glassProfilePower READ glassProfilePower WRITE setGlassProfilePower NOTIFY glassProfilePowerChanged RESET resetGlassProfilePower)
    Q_PROPERTY(double glassSaturation READ glassSaturation WRITE setGlassSaturation NOTIFY glassSaturationChanged RESET resetGlassSaturation)
    Q_PROPERTY(double glassSpecular READ glassSpecular WRITE setGlassSpecular NOTIFY glassSpecularChanged RESET resetGlassSpecular)
    Q_PROPERTY(qlonglong glassThickness READ glassThickness WRITE setGlassThickness NOTIFY glassThicknessChanged RESET resetGlassThickness)
    Q_PROPERTY(qlonglong highlightBorderWidth READ highlightBorderWidth WRITE setHighlightBorderWidth NOTIFY highlightBorderWidthChanged RESET resetHighlightBorderWidth)
    Q_PROPERTY(QString iconThemeName READ iconThemeName WRITE setIconThemeName NOTIFY iconThemeNameChanged RESET resetIconThemeName)
    Q_PROPERTY(QString lostScreen READ lostScreen WRITE setLostScreen NOTIFY lostScreenChanged RESET resetLostScreen)
    Q_PROPERTY(qlonglong maxWorkspace READ maxWorkspace WRITE setMaxWorkspace NOTIFY maxWorkspaceChanged RESET resetMaxWorkspace)
    Q_PROPERTY(qlonglong minMultitaskviewSurfaceHeight READ minMultitaskviewSurfaceHeight WRITE setMinMultitaskviewSurfaceHeight NOTIFY minMultitaskviewSurfaceHeightChanged RESET resetMinMultitaskviewSurfaceHeight)
    Q_PROPERTY(QString monoFont READ monoFont WRITE setMonoFont NOTIFY monoFontChanged RESET resetMonoFont)
    Q_PROPERTY(qlonglong multitaskviewAnimationDuration READ multitaskviewAnimationDuration WRITE setMultitaskviewAnimationDuration NOTIFY multitaskviewAnimationDurationChanged RESET resetMultitaskviewAnimationDuration)
    Q_PROPERTY(qlonglong multitaskviewBottomContentMargin READ multitaskviewBottomContentMargin WRITE setMultitaskviewBottomContentMargin NOTIFY multitaskviewBottomContentMarginChanged RESET resetMultitaskviewBottomContentMargin)
    Q_PROPERTY(qlonglong multitaskviewCellPadding READ multitaskviewCellPadding WRITE setMultitaskviewCellPadding NOTIFY multitaskviewCellPaddingChanged RESET resetMultitaskviewCellPadding)
    Q_PROPERTY(qlonglong multitaskviewEasingCurveType READ multitaskviewEasingCurveType WRITE setMultitaskviewEasingCurveType NOTIFY multitaskviewEasingCurveTypeChanged RESET resetMultitaskviewEasingCurveType)
    Q_PROPERTY(qlonglong multitaskviewHorizontalMargin READ multitaskviewHorizontalMargin WRITE setMultitaskviewHorizontalMargin NOTIFY multitaskviewHorizontalMarginChanged RESET resetMultitaskviewHorizontalMargin)
    Q_PROPERTY(double multitaskviewLoadFactor READ multitaskviewLoadFactor WRITE setMultitaskviewLoadFactor NOTIFY multitaskviewLoadFactorChanged RESET resetMultitaskviewLoadFactor)
    Q_PROPERTY(double multitaskviewPaddingOpacity READ multitaskviewPaddingOpacity WRITE setMultitaskviewPaddingOpacity NOTIFY multitaskviewPaddingOpacityChanged RESET resetMultitaskviewPaddingOpacity)
    Q_PROPERTY(qlonglong multitaskviewTopContentMargin READ multitaskviewTopContentMargin WRITE setMultitaskviewTopContentMargin NOTIFY multitaskviewTopContentMarginChanged RESET resetMultitaskviewTopContentMargin)
    Q_PROPERTY(qlonglong normalWindowHeight READ normalWindowHeight WRITE setNormalWindowHeight NOTIFY normalWindowHeightChanged RESET resetNormalWindowHeight)
    Q_PROPERTY(qlonglong numWorkspace READ numWorkspace WRITE setNumWorkspace NOTIFY numWorkspaceChanged RESET resetNumWorkspace)
    Q_PROPERTY(bool preferDark READ preferDark WRITE setPreferDark NOTIFY preferDarkChanged RESET resetPreferDark)
    Q_PROPERTY(bool showOnLock READ showOnLock WRITE setShowOnLock NOTIFY showOnLockChanged RESET resetShowOnLock)
    Q_PROPERTY(QString themeName READ themeName WRITE setThemeName NOTIFY themeNameChanged RESET resetThemeName)
    Q_PROPERTY(qlonglong titleBoxCornerRadius READ titleBoxCornerRadius WRITE setTitleBoxCornerRadius NOTIFY titleBoxCornerRadiusChanged RESET resetTitleBoxCornerRadius)
    Q_PROPERTY(QString wallpaperConfig READ wallpaperConfig WRITE setWallpaperConfig NOTIFY wallpaperConfigChanged RESET resetWallpaperConfig)
    Q_PROPERTY(qlonglong windowHeightStep READ windowHeightStep WRITE setWindowHeightStep NOTIFY windowHeightStepChanged RESET resetWindowHeightStep)
    Q_PROPERTY(qlonglong windowOpacity READ windowOpacity WRITE setWindowOpacity NOTIFY windowOpacityChanged RESET resetWindowOpacity)
    Q_PROPERTY(qlonglong windowRadius READ windowRadius WRITE setWindowRadius NOTIFY windowRadiusChanged RESET resetWindowRadius)
    Q_PROPERTY(qlonglong windowThemeType READ windowThemeType WRITE setWindowThemeType NOTIFY windowThemeTypeChanged RESET resetWindowThemeType)
    Q_PROPERTY(qlonglong windowTitlebarHeight READ windowTitlebarHeight WRITE setWindowTitlebarHeight NOTIFY windowTitlebarHeightChanged RESET resetWindowTitlebarHeight)
    Q_PROPERTY(qlonglong workspaceThumbCornerRadius READ workspaceThumbCornerRadius WRITE setWorkspaceThumbCornerRadius NOTIFY workspaceThumbCornerRadiusChanged RESET resetWorkspaceThumbCornerRadius)
    Q_PROPERTY(qlonglong workspaceThumbHeight READ workspaceThumbHeight WRITE setWorkspaceThumbHeight NOTIFY workspaceThumbHeightChanged RESET resetWorkspaceThumbHeight)
    Q_PROPERTY(qlonglong workspaceThumbMargin READ workspaceThumbMargin WRITE setWorkspaceThumbMargin NOTIFY workspaceThumbMarginChanged RESET resetWorkspaceThumbMargin)
    Q_CLASSINFO("DConfigKeyList", "activeColor;blurAmount;blurMultiplier;blurStrength;currentWorkspace;cursorBlink;cursorBlinkTime;cursorSize;cursorThemeName;defaultBackground;dndDragThreshold;doubleClickDistance;doubleClickTime;edgeInnerDelayMs;edgeSideTriggerDistance;edgeTopTriggerDistance;font;fontSize;glassBezel;glassEnabled;glassProfilePower;glassSaturation;glassSpecular;glassThickness;highlightBorderWidth;iconThemeName;lostScreen;maxWorkspace;minMultitaskviewSurfaceHeight;monoFont;multitaskviewAnimationDuration;multitaskviewBottomContentMargin;multitaskviewCellPadding;multitaskviewEasingCurveType;multitaskviewHorizontalMargin;multitaskviewLoadFactor;multitaskviewPaddingOpacity;multitaskviewTopContentMargin;normalWindowHeight;numWorkspace;preferDark;showOnLock;themeName;titleBoxCornerRadius;wallpaperConfig;windowHeightStep;windowOpacity;windowRadius;windowThemeType;windowTitlebarHeight;workspaceThumbCornerRadius;workspaceThumbHeight;workspaceThumbMargin")
    Q_CLASSINFO("DConfigFileName", "org.deepin.dde.treeland.user")
    Q_CLASSINFO("DConfigFileVersion", "1.0")

public:
    explicit TreelandUserConfig(QThread *thread, DTK_CORE_NAMESPACE::DConfigBackend *backend,
                        const QString &name, const QString &appId, const QString &subpath,
                        bool isGeneric, QObject *parent)
                  : QObject(parent), m_data(new Data) {
        m_data->m_userConfig = this;
        m_data->moveToThread(this->thread());

        if (!thread->isRunning()) {
            qWarning() << QLatin1String("Warning: The provided thread is not running.");
        }
        Q_ASSERT(QThread::currentThread() != thread);
        auto worker = new QObject();
        worker->moveToThread(thread);

        QPointer<Data> safeData(m_data);

        QMetaObject::invokeMethod(worker, [safeData, backend, name, appId, subpath, isGeneric, worker]() mutable {
            delete worker;
            worker = nullptr;

            if (!safeData->m_status.testAndSetOrdered(static_cast<int>(Data::Status::Invalid),
                                                      static_cast<int>(Data::Status::Initializing))) {
                // CAS failed: status changed (e.g., set to Destroyed by destructor)
                // Schedule deletion of Data object via deleteLater to avoid direct delete in Config thread
                safeData->deleteLater();
                return;
            }

            DTK_CORE_NAMESPACE::DConfig *config = nullptr;
            if (isGeneric) {
                if (backend) {
                    config = DTK_CORE_NAMESPACE::DConfig::createGeneric(backend, name, subpath, nullptr);
                } else {
                    config = DTK_CORE_NAMESPACE::DConfig::createGeneric(name, subpath, nullptr);
                }
            } else {
                if (backend) {
                    if (appId.isNull()) {
                        config = DTK_CORE_NAMESPACE::DConfig::create(backend, DTK_CORE_NAMESPACE::DSGApplication::id(),
                                                                     name, subpath, nullptr);
                    } else {
                        config = DTK_CORE_NAMESPACE::DConfig::create(backend, appId, name, subpath, nullptr);
                    }
                } else {
                    if (appId.isNull()) {
                        config = DTK_CORE_NAMESPACE::DConfig::create(DTK_CORE_NAMESPACE::DSGApplication::id(),
                                                                     name, subpath, nullptr);
                    } else {
                        config = DTK_CORE_NAMESPACE::DConfig::create(appId, name, subpath, nullptr);
                    }
                }
            }

            if (!config || !config->isValid()) {
                qWarning() << QLatin1String("Failed to create DConfig instance.");

                QMetaObject::invokeMethod(safeData, [safeData]() {
                    if (safeData->m_status.testAndSetOrdered(static_cast<int>(Data::Status::Initializing),
                                                             static_cast<int>(Data::Status::Failed))) {
                        Q_EMIT safeData->m_userConfig->configInitializeFailed();
                    } else {
                        // CAS failed, destroy data object
                        delete safeData;
                    }
                }, Qt::QueuedConnection);

                if (config)
                    delete config;

                return;
            }
            config->moveToThread(QThread::currentThread());
            // Initialize through Data class
            safeData->initializeInConfigThread(config);

            // Queue state transition to main thread, to ensure config values are fully initialized.
            QMetaObject::invokeMethod(safeData, [safeData, config]() {
                // Try to transition from Initializing to Succeeded
                if (safeData->m_status.testAndSetOrdered(static_cast<int>(Data::Status::Initializing),
                                                         static_cast<int>(Data::Status::Succeeded))) {
                    // CAS succeeded: connect config destroyed signal to cleanup Data, then emit success signal to main thread
                    QObject::connect(config, &QObject::destroyed, safeData, &QObject::deleteLater);
                    if (safeData->m_userConfig) {
                        Q_EMIT safeData->m_userConfig->configInitializeSucceed(config);
                    }
                } else {
                    // CAS failed - state changed (e.g., set to Destroyed)
                    // We must clean up the config we just created
                    config->deleteLater();
                    safeData->deleteLater();
                }
            }, Qt::QueuedConnection);
        });
    }
    static TreelandUserConfig* create(const QString &appId = {}, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, nullptr, QStringLiteral(u"\u006f\u0072\u0067\u002e\u0064\u0065\u0065\u0070\u0069\u006e\u002e\u0064\u0064\u0065\u002e\u0074\u0072\u0065\u0065\u006c\u0061\u006e\u0064\u002e\u0075\u0073\u0065\u0072"), appId, subpath, false, parent); }
    static TreelandUserConfig* create(DTK_CORE_NAMESPACE::DConfigBackend *backend, const QString &appId = {}, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, backend, QStringLiteral(u"\u006f\u0072\u0067\u002e\u0064\u0065\u0065\u0070\u0069\u006e\u002e\u0064\u0064\u0065\u002e\u0074\u0072\u0065\u0065\u006c\u0061\u006e\u0064\u002e\u0075\u0073\u0065\u0072"), appId, subpath, false, parent); }
    static TreelandUserConfig* createByName(const QString &name, const QString &appId = {}, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, nullptr, name, appId, subpath, false, parent); }
    static TreelandUserConfig* createByName(DTK_CORE_NAMESPACE::DConfigBackend *backend, const QString &name, const QString &appId = {}, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, backend, name, appId, subpath, false, parent); }
    static TreelandUserConfig* createGeneric(const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, nullptr, QStringLiteral(u"\u006f\u0072\u0067\u002e\u0064\u0065\u0065\u0070\u0069\u006e\u002e\u0064\u0064\u0065\u002e\u0074\u0072\u0065\u0065\u006c\u0061\u006e\u0064\u002e\u0075\u0073\u0065\u0072"), {}, subpath, true, parent); }
    static TreelandUserConfig* create(DTK_CORE_NAMESPACE::DConfigBackend *backend, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, backend, QStringLiteral(u"\u006f\u0072\u0067\u002e\u0064\u0065\u0065\u0070\u0069\u006e\u002e\u0064\u0064\u0065\u002e\u0074\u0072\u0065\u0065\u006c\u0061\u006e\u0064\u002e\u0075\u0073\u0065\u0072"), {}, subpath, true, parent); }
    static TreelandUserConfig* createGenericByName(const QString &name, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, nullptr, name, {}, subpath, true, parent); }
    static TreelandUserConfig* createGenericByName(DTK_CORE_NAMESPACE::DConfigBackend *backend, const QString &name, const QString &subpath = {}, QObject *parent = nullptr, QThread *thread = DTK_CORE_NAMESPACE::DConfig::globalThread())
    { return new TreelandUserConfig(thread, backend, name, {}, subpath, true, parent); }
    ~TreelandUserConfig() {
        m_data->m_userConfig = nullptr;
        int oldStatus = m_data->m_status.fetchAndStoreOrdered(static_cast<int>(Data::Status::Destroyed));
        if (oldStatus == static_cast<int>(Data::Status::Succeeded)) {
            // When Succeeded, release config object only
            auto config = m_data->m_config.loadRelaxed();
            Q_ASSERT(config);
            config->deleteLater();
            // m_data will be deleted by config's destroyed signal
        } else if (oldStatus == static_cast<int>(Data::Status::Failed)) {
            // When Failed state, schedule cleanup of Data object
            m_data->deleteLater();
        }
    }

    Q_INVOKABLE DTK_CORE_NAMESPACE::DConfig *config() const {
        return m_data->m_config.loadRelaxed();
    }
    // Deprecated: Use isInitializeSucceeded() instead
    Q_INVOKABLE Q_DECL_DEPRECATED_X("Use isInitializeSucceeded() instead")
    bool isInitializeSucceed() const {
        return isInitializeSucceeded();
    }
    Q_INVOKABLE bool isInitializeSucceeded() const {
        return m_data->m_status.loadRelaxed() == static_cast<int>(Data::Status::Succeeded);
    }
    Q_INVOKABLE bool isInitializeFailed() const {
        return m_data->m_status.loadRelaxed() == static_cast<int>(Data::Status::Failed);
    }
    Q_INVOKABLE bool isInitializing() const {
        return m_data->m_status.loadRelaxed() == static_cast<int>(Data::Status::Initializing);
    }

    Q_INVOKABLE QStringList keyList() const {
        return { QStringLiteral("activeColor"),
                 QStringLiteral("blurAmount"),
                 QStringLiteral("blurMultiplier"),
                 QStringLiteral("blurStrength"),
                 QStringLiteral("currentWorkspace"),
                 QStringLiteral("cursorBlink"),
                 QStringLiteral("cursorBlinkTime"),
                 QStringLiteral("cursorSize"),
                 QStringLiteral("cursorThemeName"),
                 QStringLiteral("defaultBackground"),
                 QStringLiteral("dndDragThreshold"),
                 QStringLiteral("doubleClickDistance"),
                 QStringLiteral("doubleClickTime"),
                 QStringLiteral("edgeInnerDelayMs"),
                 QStringLiteral("edgeSideTriggerDistance"),
                 QStringLiteral("edgeTopTriggerDistance"),
                 QStringLiteral("font"),
                 QStringLiteral("fontSize"),
                 QStringLiteral("glassBezel"),
                 QStringLiteral("glassEnabled"),
                 QStringLiteral("glassProfilePower"),
                 QStringLiteral("glassSaturation"),
                 QStringLiteral("glassSpecular"),
                 QStringLiteral("glassThickness"),
                 QStringLiteral("highlightBorderWidth"),
                 QStringLiteral("iconThemeName"),
                 QStringLiteral("lostScreen"),
                 QStringLiteral("maxWorkspace"),
                 QStringLiteral("minMultitaskviewSurfaceHeight"),
                 QStringLiteral("monoFont"),
                 QStringLiteral("multitaskviewAnimationDuration"),
                 QStringLiteral("multitaskviewBottomContentMargin"),
                 QStringLiteral("multitaskviewCellPadding"),
                 QStringLiteral("multitaskviewEasingCurveType"),
                 QStringLiteral("multitaskviewHorizontalMargin"),
                 QStringLiteral("multitaskviewLoadFactor"),
                 QStringLiteral("multitaskviewPaddingOpacity"),
                 QStringLiteral("multitaskviewTopContentMargin"),
                 QStringLiteral("normalWindowHeight"),
                 QStringLiteral("numWorkspace"),
                 QStringLiteral("preferDark"),
                 QStringLiteral("showOnLock"),
                 QStringLiteral("themeName"),
                 QStringLiteral("titleBoxCornerRadius"),
                 QStringLiteral("wallpaperConfig"),
                 QStringLiteral("windowHeightStep"),
                 QStringLiteral("windowOpacity"),
                 QStringLiteral("windowRadius"),
                 QStringLiteral("windowThemeType"),
                 QStringLiteral("windowTitlebarHeight"),
                 QStringLiteral("workspaceThumbCornerRadius"),
                 QStringLiteral("workspaceThumbHeight"),
                 QStringLiteral("workspaceThumbMargin")};
    }

    Q_INVOKABLE bool isDefaultValue(const QString &key) const {
        if (key == QStringLiteral("activeColor"))
            return activeColorIsDefaultValue();
        if (key == QStringLiteral("blurAmount"))
            return blurAmountIsDefaultValue();
        if (key == QStringLiteral("blurMultiplier"))
            return blurMultiplierIsDefaultValue();
        if (key == QStringLiteral("blurStrength"))
            return blurStrengthIsDefaultValue();
        if (key == QStringLiteral("currentWorkspace"))
            return currentWorkspaceIsDefaultValue();
        if (key == QStringLiteral("cursorBlink"))
            return cursorBlinkIsDefaultValue();
        if (key == QStringLiteral("cursorBlinkTime"))
            return cursorBlinkTimeIsDefaultValue();
        if (key == QStringLiteral("cursorSize"))
            return cursorSizeIsDefaultValue();
        if (key == QStringLiteral("cursorThemeName"))
            return cursorThemeNameIsDefaultValue();
        if (key == QStringLiteral("defaultBackground"))
            return defaultBackgroundIsDefaultValue();
        if (key == QStringLiteral("dndDragThreshold"))
            return dndDragThresholdIsDefaultValue();
        if (key == QStringLiteral("doubleClickDistance"))
            return doubleClickDistanceIsDefaultValue();
        if (key == QStringLiteral("doubleClickTime"))
            return doubleClickTimeIsDefaultValue();
        if (key == QStringLiteral("edgeInnerDelayMs"))
            return edgeInnerDelayMsIsDefaultValue();
        if (key == QStringLiteral("edgeSideTriggerDistance"))
            return edgeSideTriggerDistanceIsDefaultValue();
        if (key == QStringLiteral("edgeTopTriggerDistance"))
            return edgeTopTriggerDistanceIsDefaultValue();
        if (key == QStringLiteral("font"))
            return fontIsDefaultValue();
        if (key == QStringLiteral("fontSize"))
            return fontSizeIsDefaultValue();
        if (key == QStringLiteral("glassBezel"))
            return glassBezelIsDefaultValue();
        if (key == QStringLiteral("glassEnabled"))
            return glassEnabledIsDefaultValue();
        if (key == QStringLiteral("glassProfilePower"))
            return glassProfilePowerIsDefaultValue();
        if (key == QStringLiteral("glassSaturation"))
            return glassSaturationIsDefaultValue();
        if (key == QStringLiteral("glassSpecular"))
            return glassSpecularIsDefaultValue();
        if (key == QStringLiteral("glassThickness"))
            return glassThicknessIsDefaultValue();
        if (key == QStringLiteral("highlightBorderWidth"))
            return highlightBorderWidthIsDefaultValue();
        if (key == QStringLiteral("iconThemeName"))
            return iconThemeNameIsDefaultValue();
        if (key == QStringLiteral("lostScreen"))
            return lostScreenIsDefaultValue();
        if (key == QStringLiteral("maxWorkspace"))
            return maxWorkspaceIsDefaultValue();
        if (key == QStringLiteral("minMultitaskviewSurfaceHeight"))
            return minMultitaskviewSurfaceHeightIsDefaultValue();
        if (key == QStringLiteral("monoFont"))
            return monoFontIsDefaultValue();
        if (key == QStringLiteral("multitaskviewAnimationDuration"))
            return multitaskviewAnimationDurationIsDefaultValue();
        if (key == QStringLiteral("multitaskviewBottomContentMargin"))
            return multitaskviewBottomContentMarginIsDefaultValue();
        if (key == QStringLiteral("multitaskviewCellPadding"))
            return multitaskviewCellPaddingIsDefaultValue();
        if (key == QStringLiteral("multitaskviewEasingCurveType"))
            return multitaskviewEasingCurveTypeIsDefaultValue();
        if (key == QStringLiteral("multitaskviewHorizontalMargin"))
            return multitaskviewHorizontalMarginIsDefaultValue();
        if (key == QStringLiteral("multitaskviewLoadFactor"))
            return multitaskviewLoadFactorIsDefaultValue();
        if (key == QStringLiteral("multitaskviewPaddingOpacity"))
            return multitaskviewPaddingOpacityIsDefaultValue();
        if (key == QStringLiteral("multitaskviewTopContentMargin"))
            return multitaskviewTopContentMarginIsDefaultValue();
        if (key == QStringLiteral("normalWindowHeight"))
            return normalWindowHeightIsDefaultValue();
        if (key == QStringLiteral("numWorkspace"))
            return numWorkspaceIsDefaultValue();
        if (key == QStringLiteral("preferDark"))
            return preferDarkIsDefaultValue();
        if (key == QStringLiteral("showOnLock"))
            return showOnLockIsDefaultValue();
        if (key == QStringLiteral("themeName"))
            return themeNameIsDefaultValue();
        if (key == QStringLiteral("titleBoxCornerRadius"))
            return titleBoxCornerRadiusIsDefaultValue();
        if (key == QStringLiteral("wallpaperConfig"))
            return wallpaperConfigIsDefaultValue();
        if (key == QStringLiteral("windowHeightStep"))
            return windowHeightStepIsDefaultValue();
        if (key == QStringLiteral("windowOpacity"))
            return windowOpacityIsDefaultValue();
        if (key == QStringLiteral("windowRadius"))
            return windowRadiusIsDefaultValue();
        if (key == QStringLiteral("windowThemeType"))
            return windowThemeTypeIsDefaultValue();
        if (key == QStringLiteral("windowTitlebarHeight"))
            return windowTitlebarHeightIsDefaultValue();
        if (key == QStringLiteral("workspaceThumbCornerRadius"))
            return workspaceThumbCornerRadiusIsDefaultValue();
        if (key == QStringLiteral("workspaceThumbHeight"))
            return workspaceThumbHeightIsDefaultValue();
        if (key == QStringLiteral("workspaceThumbMargin"))
            return workspaceThumbMarginIsDefaultValue();
        return false;
    }

    QString activeColor() const {
        return m_data->p_activeColor;
    }
    void setActiveColor(const QString &value) {
        auto oldValue = m_data->p_activeColor;
        m_data->p_activeColor = value;
        m_data->markPropertySet(0);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("activeColor"), value);
            });
        }
        if (m_data->p_activeColor != oldValue) {
            Q_EMIT activeColorChanged();
            Q_EMIT valueChanged(QStringLiteral("activeColor"), value);
        }
    }
    void resetActiveColor() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("activeColor"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableActiveColor() {
        return QBindable<QString>(this, "activeColor");
    }
#endif
    Q_INVOKABLE bool activeColorIsDefaultValue() const {
        return !m_data->testPropertySet(0);
    }
    double blurAmount() const {
        return m_data->p_blurAmount;
    }
    void setBlurAmount(const double &value) {
        auto oldValue = m_data->p_blurAmount;
        m_data->p_blurAmount = value;
        m_data->markPropertySet(1);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("blurAmount"), value);
            });
        }
        if (m_data->p_blurAmount != oldValue) {
            Q_EMIT blurAmountChanged();
            Q_EMIT valueChanged(QStringLiteral("blurAmount"), value);
        }
    }
    void resetBlurAmount() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("blurAmount"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableBlurAmount() {
        return QBindable<double>(this, "blurAmount");
    }
#endif
    Q_INVOKABLE bool blurAmountIsDefaultValue() const {
        return !m_data->testPropertySet(1);
    }
    double blurMultiplier() const {
        return m_data->p_blurMultiplier;
    }
    void setBlurMultiplier(const double &value) {
        auto oldValue = m_data->p_blurMultiplier;
        m_data->p_blurMultiplier = value;
        m_data->markPropertySet(2);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("blurMultiplier"), value);
            });
        }
        if (m_data->p_blurMultiplier != oldValue) {
            Q_EMIT blurMultiplierChanged();
            Q_EMIT valueChanged(QStringLiteral("blurMultiplier"), value);
        }
    }
    void resetBlurMultiplier() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("blurMultiplier"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableBlurMultiplier() {
        return QBindable<double>(this, "blurMultiplier");
    }
#endif
    Q_INVOKABLE bool blurMultiplierIsDefaultValue() const {
        return !m_data->testPropertySet(2);
    }
    qlonglong blurStrength() const {
        return m_data->p_blurStrength;
    }
    void setBlurStrength(const qlonglong &value) {
        auto oldValue = m_data->p_blurStrength;
        m_data->p_blurStrength = value;
        m_data->markPropertySet(3);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("blurStrength"), value);
            });
        }
        if (m_data->p_blurStrength != oldValue) {
            Q_EMIT blurStrengthChanged();
            Q_EMIT valueChanged(QStringLiteral("blurStrength"), value);
        }
    }
    void resetBlurStrength() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("blurStrength"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableBlurStrength() {
        return QBindable<qlonglong>(this, "blurStrength");
    }
#endif
    Q_INVOKABLE bool blurStrengthIsDefaultValue() const {
        return !m_data->testPropertySet(3);
    }
    qlonglong currentWorkspace() const {
        return m_data->p_currentWorkspace;
    }
    void setCurrentWorkspace(const qlonglong &value) {
        auto oldValue = m_data->p_currentWorkspace;
        m_data->p_currentWorkspace = value;
        m_data->markPropertySet(4);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("currentWorkspace"), value);
            });
        }
        if (m_data->p_currentWorkspace != oldValue) {
            Q_EMIT currentWorkspaceChanged();
            Q_EMIT valueChanged(QStringLiteral("currentWorkspace"), value);
        }
    }
    void resetCurrentWorkspace() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("currentWorkspace"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableCurrentWorkspace() {
        return QBindable<qlonglong>(this, "currentWorkspace");
    }
#endif
    Q_INVOKABLE bool currentWorkspaceIsDefaultValue() const {
        return !m_data->testPropertySet(4);
    }
    bool cursorBlink() const {
        return m_data->p_cursorBlink;
    }
    void setCursorBlink(const bool &value) {
        auto oldValue = m_data->p_cursorBlink;
        m_data->p_cursorBlink = value;
        m_data->markPropertySet(5);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("cursorBlink"), value);
            });
        }
        if (m_data->p_cursorBlink != oldValue) {
            Q_EMIT cursorBlinkChanged();
            Q_EMIT valueChanged(QStringLiteral("cursorBlink"), value);
        }
    }
    void resetCursorBlink() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("cursorBlink"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<bool> bindableCursorBlink() {
        return QBindable<bool>(this, "cursorBlink");
    }
#endif
    Q_INVOKABLE bool cursorBlinkIsDefaultValue() const {
        return !m_data->testPropertySet(5);
    }
    qlonglong cursorBlinkTime() const {
        return m_data->p_cursorBlinkTime;
    }
    void setCursorBlinkTime(const qlonglong &value) {
        auto oldValue = m_data->p_cursorBlinkTime;
        m_data->p_cursorBlinkTime = value;
        m_data->markPropertySet(6);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("cursorBlinkTime"), value);
            });
        }
        if (m_data->p_cursorBlinkTime != oldValue) {
            Q_EMIT cursorBlinkTimeChanged();
            Q_EMIT valueChanged(QStringLiteral("cursorBlinkTime"), value);
        }
    }
    void resetCursorBlinkTime() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("cursorBlinkTime"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableCursorBlinkTime() {
        return QBindable<qlonglong>(this, "cursorBlinkTime");
    }
#endif
    Q_INVOKABLE bool cursorBlinkTimeIsDefaultValue() const {
        return !m_data->testPropertySet(6);
    }
    qlonglong cursorSize() const {
        return m_data->p_cursorSize;
    }
    void setCursorSize(const qlonglong &value) {
        auto oldValue = m_data->p_cursorSize;
        m_data->p_cursorSize = value;
        m_data->markPropertySet(7);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("cursorSize"), value);
            });
        }
        if (m_data->p_cursorSize != oldValue) {
            Q_EMIT cursorSizeChanged();
            Q_EMIT valueChanged(QStringLiteral("cursorSize"), value);
        }
    }
    void resetCursorSize() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("cursorSize"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableCursorSize() {
        return QBindable<qlonglong>(this, "cursorSize");
    }
#endif
    Q_INVOKABLE bool cursorSizeIsDefaultValue() const {
        return !m_data->testPropertySet(7);
    }
    QString cursorThemeName() const {
        return m_data->p_cursorThemeName;
    }
    void setCursorThemeName(const QString &value) {
        auto oldValue = m_data->p_cursorThemeName;
        m_data->p_cursorThemeName = value;
        m_data->markPropertySet(8);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("cursorThemeName"), value);
            });
        }
        if (m_data->p_cursorThemeName != oldValue) {
            Q_EMIT cursorThemeNameChanged();
            Q_EMIT valueChanged(QStringLiteral("cursorThemeName"), value);
        }
    }
    void resetCursorThemeName() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("cursorThemeName"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableCursorThemeName() {
        return QBindable<QString>(this, "cursorThemeName");
    }
#endif
    Q_INVOKABLE bool cursorThemeNameIsDefaultValue() const {
        return !m_data->testPropertySet(8);
    }
    QString defaultBackground() const {
        return m_data->p_defaultBackground;
    }
    void setDefaultBackground(const QString &value) {
        auto oldValue = m_data->p_defaultBackground;
        m_data->p_defaultBackground = value;
        m_data->markPropertySet(9);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("defaultBackground"), value);
            });
        }
        if (m_data->p_defaultBackground != oldValue) {
            Q_EMIT defaultBackgroundChanged();
            Q_EMIT valueChanged(QStringLiteral("defaultBackground"), value);
        }
    }
    void resetDefaultBackground() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("defaultBackground"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableDefaultBackground() {
        return QBindable<QString>(this, "defaultBackground");
    }
#endif
    Q_INVOKABLE bool defaultBackgroundIsDefaultValue() const {
        return !m_data->testPropertySet(9);
    }
    qlonglong dndDragThreshold() const {
        return m_data->p_dndDragThreshold;
    }
    void setDndDragThreshold(const qlonglong &value) {
        auto oldValue = m_data->p_dndDragThreshold;
        m_data->p_dndDragThreshold = value;
        m_data->markPropertySet(10);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("dndDragThreshold"), value);
            });
        }
        if (m_data->p_dndDragThreshold != oldValue) {
            Q_EMIT dndDragThresholdChanged();
            Q_EMIT valueChanged(QStringLiteral("dndDragThreshold"), value);
        }
    }
    void resetDndDragThreshold() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("dndDragThreshold"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableDndDragThreshold() {
        return QBindable<qlonglong>(this, "dndDragThreshold");
    }
#endif
    Q_INVOKABLE bool dndDragThresholdIsDefaultValue() const {
        return !m_data->testPropertySet(10);
    }
    qlonglong doubleClickDistance() const {
        return m_data->p_doubleClickDistance;
    }
    void setDoubleClickDistance(const qlonglong &value) {
        auto oldValue = m_data->p_doubleClickDistance;
        m_data->p_doubleClickDistance = value;
        m_data->markPropertySet(11);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("doubleClickDistance"), value);
            });
        }
        if (m_data->p_doubleClickDistance != oldValue) {
            Q_EMIT doubleClickDistanceChanged();
            Q_EMIT valueChanged(QStringLiteral("doubleClickDistance"), value);
        }
    }
    void resetDoubleClickDistance() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("doubleClickDistance"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableDoubleClickDistance() {
        return QBindable<qlonglong>(this, "doubleClickDistance");
    }
#endif
    Q_INVOKABLE bool doubleClickDistanceIsDefaultValue() const {
        return !m_data->testPropertySet(11);
    }
    qlonglong doubleClickTime() const {
        return m_data->p_doubleClickTime;
    }
    void setDoubleClickTime(const qlonglong &value) {
        auto oldValue = m_data->p_doubleClickTime;
        m_data->p_doubleClickTime = value;
        m_data->markPropertySet(12);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("doubleClickTime"), value);
            });
        }
        if (m_data->p_doubleClickTime != oldValue) {
            Q_EMIT doubleClickTimeChanged();
            Q_EMIT valueChanged(QStringLiteral("doubleClickTime"), value);
        }
    }
    void resetDoubleClickTime() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("doubleClickTime"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableDoubleClickTime() {
        return QBindable<qlonglong>(this, "doubleClickTime");
    }
#endif
    Q_INVOKABLE bool doubleClickTimeIsDefaultValue() const {
        return !m_data->testPropertySet(12);
    }
    qlonglong edgeInnerDelayMs() const {
        return m_data->p_edgeInnerDelayMs;
    }
    void setEdgeInnerDelayMs(const qlonglong &value) {
        auto oldValue = m_data->p_edgeInnerDelayMs;
        m_data->p_edgeInnerDelayMs = value;
        m_data->markPropertySet(13);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("edgeInnerDelayMs"), value);
            });
        }
        if (m_data->p_edgeInnerDelayMs != oldValue) {
            Q_EMIT edgeInnerDelayMsChanged();
            Q_EMIT valueChanged(QStringLiteral("edgeInnerDelayMs"), value);
        }
    }
    void resetEdgeInnerDelayMs() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("edgeInnerDelayMs"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableEdgeInnerDelayMs() {
        return QBindable<qlonglong>(this, "edgeInnerDelayMs");
    }
#endif
    Q_INVOKABLE bool edgeInnerDelayMsIsDefaultValue() const {
        return !m_data->testPropertySet(13);
    }
    qlonglong edgeSideTriggerDistance() const {
        return m_data->p_edgeSideTriggerDistance;
    }
    void setEdgeSideTriggerDistance(const qlonglong &value) {
        auto oldValue = m_data->p_edgeSideTriggerDistance;
        m_data->p_edgeSideTriggerDistance = value;
        m_data->markPropertySet(14);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("edgeSideTriggerDistance"), value);
            });
        }
        if (m_data->p_edgeSideTriggerDistance != oldValue) {
            Q_EMIT edgeSideTriggerDistanceChanged();
            Q_EMIT valueChanged(QStringLiteral("edgeSideTriggerDistance"), value);
        }
    }
    void resetEdgeSideTriggerDistance() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("edgeSideTriggerDistance"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableEdgeSideTriggerDistance() {
        return QBindable<qlonglong>(this, "edgeSideTriggerDistance");
    }
#endif
    Q_INVOKABLE bool edgeSideTriggerDistanceIsDefaultValue() const {
        return !m_data->testPropertySet(14);
    }
    qlonglong edgeTopTriggerDistance() const {
        return m_data->p_edgeTopTriggerDistance;
    }
    void setEdgeTopTriggerDistance(const qlonglong &value) {
        auto oldValue = m_data->p_edgeTopTriggerDistance;
        m_data->p_edgeTopTriggerDistance = value;
        m_data->markPropertySet(15);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("edgeTopTriggerDistance"), value);
            });
        }
        if (m_data->p_edgeTopTriggerDistance != oldValue) {
            Q_EMIT edgeTopTriggerDistanceChanged();
            Q_EMIT valueChanged(QStringLiteral("edgeTopTriggerDistance"), value);
        }
    }
    void resetEdgeTopTriggerDistance() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("edgeTopTriggerDistance"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableEdgeTopTriggerDistance() {
        return QBindable<qlonglong>(this, "edgeTopTriggerDistance");
    }
#endif
    Q_INVOKABLE bool edgeTopTriggerDistanceIsDefaultValue() const {
        return !m_data->testPropertySet(15);
    }
    QString font() const {
        return m_data->p_font;
    }
    void setFont(const QString &value) {
        auto oldValue = m_data->p_font;
        m_data->p_font = value;
        m_data->markPropertySet(16);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("font"), value);
            });
        }
        if (m_data->p_font != oldValue) {
            Q_EMIT fontChanged();
            Q_EMIT valueChanged(QStringLiteral("font"), value);
        }
    }
    void resetFont() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("font"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableFont() {
        return QBindable<QString>(this, "font");
    }
#endif
    Q_INVOKABLE bool fontIsDefaultValue() const {
        return !m_data->testPropertySet(16);
    }
    qlonglong fontSize() const {
        return m_data->p_fontSize;
    }
    void setFontSize(const qlonglong &value) {
        auto oldValue = m_data->p_fontSize;
        m_data->p_fontSize = value;
        m_data->markPropertySet(17);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("fontSize"), value);
            });
        }
        if (m_data->p_fontSize != oldValue) {
            Q_EMIT fontSizeChanged();
            Q_EMIT valueChanged(QStringLiteral("fontSize"), value);
        }
    }
    void resetFontSize() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("fontSize"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableFontSize() {
        return QBindable<qlonglong>(this, "fontSize");
    }
#endif
    Q_INVOKABLE bool fontSizeIsDefaultValue() const {
        return !m_data->testPropertySet(17);
    }
    qlonglong glassBezel() const {
        return m_data->p_glassBezel;
    }
    void setGlassBezel(const qlonglong &value) {
        auto oldValue = m_data->p_glassBezel;
        m_data->p_glassBezel = value;
        m_data->markPropertySet(18);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("glassBezel"), value);
            });
        }
        if (m_data->p_glassBezel != oldValue) {
            Q_EMIT glassBezelChanged();
            Q_EMIT valueChanged(QStringLiteral("glassBezel"), value);
        }
    }
    void resetGlassBezel() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("glassBezel"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableGlassBezel() {
        return QBindable<qlonglong>(this, "glassBezel");
    }
#endif
    Q_INVOKABLE bool glassBezelIsDefaultValue() const {
        return !m_data->testPropertySet(18);
    }
    bool glassEnabled() const {
        return m_data->p_glassEnabled;
    }
    void setGlassEnabled(const bool &value) {
        auto oldValue = m_data->p_glassEnabled;
        m_data->p_glassEnabled = value;
        m_data->markPropertySet(19);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("glassEnabled"), value);
            });
        }
        if (m_data->p_glassEnabled != oldValue) {
            Q_EMIT glassEnabledChanged();
            Q_EMIT valueChanged(QStringLiteral("glassEnabled"), value);
        }
    }
    void resetGlassEnabled() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("glassEnabled"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<bool> bindableGlassEnabled() {
        return QBindable<bool>(this, "glassEnabled");
    }
#endif
    Q_INVOKABLE bool glassEnabledIsDefaultValue() const {
        return !m_data->testPropertySet(19);
    }
    double glassProfilePower() const {
        return m_data->p_glassProfilePower;
    }
    void setGlassProfilePower(const double &value) {
        auto oldValue = m_data->p_glassProfilePower;
        m_data->p_glassProfilePower = value;
        m_data->markPropertySet(20);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("glassProfilePower"), value);
            });
        }
        if (m_data->p_glassProfilePower != oldValue) {
            Q_EMIT glassProfilePowerChanged();
            Q_EMIT valueChanged(QStringLiteral("glassProfilePower"), value);
        }
    }
    void resetGlassProfilePower() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("glassProfilePower"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableGlassProfilePower() {
        return QBindable<double>(this, "glassProfilePower");
    }
#endif
    Q_INVOKABLE bool glassProfilePowerIsDefaultValue() const {
        return !m_data->testPropertySet(20);
    }
    double glassSaturation() const {
        return m_data->p_glassSaturation;
    }
    void setGlassSaturation(const double &value) {
        auto oldValue = m_data->p_glassSaturation;
        m_data->p_glassSaturation = value;
        m_data->markPropertySet(21);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("glassSaturation"), value);
            });
        }
        if (m_data->p_glassSaturation != oldValue) {
            Q_EMIT glassSaturationChanged();
            Q_EMIT valueChanged(QStringLiteral("glassSaturation"), value);
        }
    }
    void resetGlassSaturation() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("glassSaturation"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableGlassSaturation() {
        return QBindable<double>(this, "glassSaturation");
    }
#endif
    Q_INVOKABLE bool glassSaturationIsDefaultValue() const {
        return !m_data->testPropertySet(21);
    }
    double glassSpecular() const {
        return m_data->p_glassSpecular;
    }
    void setGlassSpecular(const double &value) {
        auto oldValue = m_data->p_glassSpecular;
        m_data->p_glassSpecular = value;
        m_data->markPropertySet(22);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("glassSpecular"), value);
            });
        }
        if (m_data->p_glassSpecular != oldValue) {
            Q_EMIT glassSpecularChanged();
            Q_EMIT valueChanged(QStringLiteral("glassSpecular"), value);
        }
    }
    void resetGlassSpecular() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("glassSpecular"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableGlassSpecular() {
        return QBindable<double>(this, "glassSpecular");
    }
#endif
    Q_INVOKABLE bool glassSpecularIsDefaultValue() const {
        return !m_data->testPropertySet(22);
    }
    qlonglong glassThickness() const {
        return m_data->p_glassThickness;
    }
    void setGlassThickness(const qlonglong &value) {
        auto oldValue = m_data->p_glassThickness;
        m_data->p_glassThickness = value;
        m_data->markPropertySet(23);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("glassThickness"), value);
            });
        }
        if (m_data->p_glassThickness != oldValue) {
            Q_EMIT glassThicknessChanged();
            Q_EMIT valueChanged(QStringLiteral("glassThickness"), value);
        }
    }
    void resetGlassThickness() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("glassThickness"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableGlassThickness() {
        return QBindable<qlonglong>(this, "glassThickness");
    }
#endif
    Q_INVOKABLE bool glassThicknessIsDefaultValue() const {
        return !m_data->testPropertySet(23);
    }
    qlonglong highlightBorderWidth() const {
        return m_data->p_highlightBorderWidth;
    }
    void setHighlightBorderWidth(const qlonglong &value) {
        auto oldValue = m_data->p_highlightBorderWidth;
        m_data->p_highlightBorderWidth = value;
        m_data->markPropertySet(24);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("highlightBorderWidth"), value);
            });
        }
        if (m_data->p_highlightBorderWidth != oldValue) {
            Q_EMIT highlightBorderWidthChanged();
            Q_EMIT valueChanged(QStringLiteral("highlightBorderWidth"), value);
        }
    }
    void resetHighlightBorderWidth() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("highlightBorderWidth"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableHighlightBorderWidth() {
        return QBindable<qlonglong>(this, "highlightBorderWidth");
    }
#endif
    Q_INVOKABLE bool highlightBorderWidthIsDefaultValue() const {
        return !m_data->testPropertySet(24);
    }
    QString iconThemeName() const {
        return m_data->p_iconThemeName;
    }
    void setIconThemeName(const QString &value) {
        auto oldValue = m_data->p_iconThemeName;
        m_data->p_iconThemeName = value;
        m_data->markPropertySet(25);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("iconThemeName"), value);
            });
        }
        if (m_data->p_iconThemeName != oldValue) {
            Q_EMIT iconThemeNameChanged();
            Q_EMIT valueChanged(QStringLiteral("iconThemeName"), value);
        }
    }
    void resetIconThemeName() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("iconThemeName"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableIconThemeName() {
        return QBindable<QString>(this, "iconThemeName");
    }
#endif
    Q_INVOKABLE bool iconThemeNameIsDefaultValue() const {
        return !m_data->testPropertySet(25);
    }
    QString lostScreen() const {
        return m_data->p_lostScreen;
    }
    void setLostScreen(const QString &value) {
        auto oldValue = m_data->p_lostScreen;
        m_data->p_lostScreen = value;
        m_data->markPropertySet(26);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("lostScreen"), value);
            });
        }
        if (m_data->p_lostScreen != oldValue) {
            Q_EMIT lostScreenChanged();
            Q_EMIT valueChanged(QStringLiteral("lostScreen"), value);
        }
    }
    void resetLostScreen() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("lostScreen"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableLostScreen() {
        return QBindable<QString>(this, "lostScreen");
    }
#endif
    Q_INVOKABLE bool lostScreenIsDefaultValue() const {
        return !m_data->testPropertySet(26);
    }
    qlonglong maxWorkspace() const {
        return m_data->p_maxWorkspace;
    }
    void setMaxWorkspace(const qlonglong &value) {
        auto oldValue = m_data->p_maxWorkspace;
        m_data->p_maxWorkspace = value;
        m_data->markPropertySet(27);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("maxWorkspace"), value);
            });
        }
        if (m_data->p_maxWorkspace != oldValue) {
            Q_EMIT maxWorkspaceChanged();
            Q_EMIT valueChanged(QStringLiteral("maxWorkspace"), value);
        }
    }
    void resetMaxWorkspace() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("maxWorkspace"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMaxWorkspace() {
        return QBindable<qlonglong>(this, "maxWorkspace");
    }
#endif
    Q_INVOKABLE bool maxWorkspaceIsDefaultValue() const {
        return !m_data->testPropertySet(27);
    }
    qlonglong minMultitaskviewSurfaceHeight() const {
        return m_data->p_minMultitaskviewSurfaceHeight;
    }
    void setMinMultitaskviewSurfaceHeight(const qlonglong &value) {
        auto oldValue = m_data->p_minMultitaskviewSurfaceHeight;
        m_data->p_minMultitaskviewSurfaceHeight = value;
        m_data->markPropertySet(28);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("minMultitaskviewSurfaceHeight"), value);
            });
        }
        if (m_data->p_minMultitaskviewSurfaceHeight != oldValue) {
            Q_EMIT minMultitaskviewSurfaceHeightChanged();
            Q_EMIT valueChanged(QStringLiteral("minMultitaskviewSurfaceHeight"), value);
        }
    }
    void resetMinMultitaskviewSurfaceHeight() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("minMultitaskviewSurfaceHeight"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMinMultitaskviewSurfaceHeight() {
        return QBindable<qlonglong>(this, "minMultitaskviewSurfaceHeight");
    }
#endif
    Q_INVOKABLE bool minMultitaskviewSurfaceHeightIsDefaultValue() const {
        return !m_data->testPropertySet(28);
    }
    QString monoFont() const {
        return m_data->p_monoFont;
    }
    void setMonoFont(const QString &value) {
        auto oldValue = m_data->p_monoFont;
        m_data->p_monoFont = value;
        m_data->markPropertySet(29);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("monoFont"), value);
            });
        }
        if (m_data->p_monoFont != oldValue) {
            Q_EMIT monoFontChanged();
            Q_EMIT valueChanged(QStringLiteral("monoFont"), value);
        }
    }
    void resetMonoFont() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("monoFont"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableMonoFont() {
        return QBindable<QString>(this, "monoFont");
    }
#endif
    Q_INVOKABLE bool monoFontIsDefaultValue() const {
        return !m_data->testPropertySet(29);
    }
    qlonglong multitaskviewAnimationDuration() const {
        return m_data->p_multitaskviewAnimationDuration;
    }
    void setMultitaskviewAnimationDuration(const qlonglong &value) {
        auto oldValue = m_data->p_multitaskviewAnimationDuration;
        m_data->p_multitaskviewAnimationDuration = value;
        m_data->markPropertySet(30);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewAnimationDuration"), value);
            });
        }
        if (m_data->p_multitaskviewAnimationDuration != oldValue) {
            Q_EMIT multitaskviewAnimationDurationChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewAnimationDuration"), value);
        }
    }
    void resetMultitaskviewAnimationDuration() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewAnimationDuration"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMultitaskviewAnimationDuration() {
        return QBindable<qlonglong>(this, "multitaskviewAnimationDuration");
    }
#endif
    Q_INVOKABLE bool multitaskviewAnimationDurationIsDefaultValue() const {
        return !m_data->testPropertySet(30);
    }
    qlonglong multitaskviewBottomContentMargin() const {
        return m_data->p_multitaskviewBottomContentMargin;
    }
    void setMultitaskviewBottomContentMargin(const qlonglong &value) {
        auto oldValue = m_data->p_multitaskviewBottomContentMargin;
        m_data->p_multitaskviewBottomContentMargin = value;
        m_data->markPropertySet(31);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewBottomContentMargin"), value);
            });
        }
        if (m_data->p_multitaskviewBottomContentMargin != oldValue) {
            Q_EMIT multitaskviewBottomContentMarginChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewBottomContentMargin"), value);
        }
    }
    void resetMultitaskviewBottomContentMargin() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewBottomContentMargin"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMultitaskviewBottomContentMargin() {
        return QBindable<qlonglong>(this, "multitaskviewBottomContentMargin");
    }
#endif
    Q_INVOKABLE bool multitaskviewBottomContentMarginIsDefaultValue() const {
        return !m_data->testPropertySet(31);
    }
    qlonglong multitaskviewCellPadding() const {
        return m_data->p_multitaskviewCellPadding;
    }
    void setMultitaskviewCellPadding(const qlonglong &value) {
        auto oldValue = m_data->p_multitaskviewCellPadding;
        m_data->p_multitaskviewCellPadding = value;
        m_data->markPropertySet(32);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewCellPadding"), value);
            });
        }
        if (m_data->p_multitaskviewCellPadding != oldValue) {
            Q_EMIT multitaskviewCellPaddingChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewCellPadding"), value);
        }
    }
    void resetMultitaskviewCellPadding() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewCellPadding"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMultitaskviewCellPadding() {
        return QBindable<qlonglong>(this, "multitaskviewCellPadding");
    }
#endif
    Q_INVOKABLE bool multitaskviewCellPaddingIsDefaultValue() const {
        return !m_data->testPropertySet(32);
    }
    qlonglong multitaskviewEasingCurveType() const {
        return m_data->p_multitaskviewEasingCurveType;
    }
    void setMultitaskviewEasingCurveType(const qlonglong &value) {
        auto oldValue = m_data->p_multitaskviewEasingCurveType;
        m_data->p_multitaskviewEasingCurveType = value;
        m_data->markPropertySet(33);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewEasingCurveType"), value);
            });
        }
        if (m_data->p_multitaskviewEasingCurveType != oldValue) {
            Q_EMIT multitaskviewEasingCurveTypeChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewEasingCurveType"), value);
        }
    }
    void resetMultitaskviewEasingCurveType() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewEasingCurveType"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMultitaskviewEasingCurveType() {
        return QBindable<qlonglong>(this, "multitaskviewEasingCurveType");
    }
#endif
    Q_INVOKABLE bool multitaskviewEasingCurveTypeIsDefaultValue() const {
        return !m_data->testPropertySet(33);
    }
    qlonglong multitaskviewHorizontalMargin() const {
        return m_data->p_multitaskviewHorizontalMargin;
    }
    void setMultitaskviewHorizontalMargin(const qlonglong &value) {
        auto oldValue = m_data->p_multitaskviewHorizontalMargin;
        m_data->p_multitaskviewHorizontalMargin = value;
        m_data->markPropertySet(34);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewHorizontalMargin"), value);
            });
        }
        if (m_data->p_multitaskviewHorizontalMargin != oldValue) {
            Q_EMIT multitaskviewHorizontalMarginChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewHorizontalMargin"), value);
        }
    }
    void resetMultitaskviewHorizontalMargin() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewHorizontalMargin"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMultitaskviewHorizontalMargin() {
        return QBindable<qlonglong>(this, "multitaskviewHorizontalMargin");
    }
#endif
    Q_INVOKABLE bool multitaskviewHorizontalMarginIsDefaultValue() const {
        return !m_data->testPropertySet(34);
    }
    double multitaskviewLoadFactor() const {
        return m_data->p_multitaskviewLoadFactor;
    }
    void setMultitaskviewLoadFactor(const double &value) {
        auto oldValue = m_data->p_multitaskviewLoadFactor;
        m_data->p_multitaskviewLoadFactor = value;
        m_data->markPropertySet(35);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewLoadFactor"), value);
            });
        }
        if (m_data->p_multitaskviewLoadFactor != oldValue) {
            Q_EMIT multitaskviewLoadFactorChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewLoadFactor"), value);
        }
    }
    void resetMultitaskviewLoadFactor() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewLoadFactor"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableMultitaskviewLoadFactor() {
        return QBindable<double>(this, "multitaskviewLoadFactor");
    }
#endif
    Q_INVOKABLE bool multitaskviewLoadFactorIsDefaultValue() const {
        return !m_data->testPropertySet(35);
    }
    double multitaskviewPaddingOpacity() const {
        return m_data->p_multitaskviewPaddingOpacity;
    }
    void setMultitaskviewPaddingOpacity(const double &value) {
        auto oldValue = m_data->p_multitaskviewPaddingOpacity;
        m_data->p_multitaskviewPaddingOpacity = value;
        m_data->markPropertySet(36);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewPaddingOpacity"), value);
            });
        }
        if (m_data->p_multitaskviewPaddingOpacity != oldValue) {
            Q_EMIT multitaskviewPaddingOpacityChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewPaddingOpacity"), value);
        }
    }
    void resetMultitaskviewPaddingOpacity() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewPaddingOpacity"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<double> bindableMultitaskviewPaddingOpacity() {
        return QBindable<double>(this, "multitaskviewPaddingOpacity");
    }
#endif
    Q_INVOKABLE bool multitaskviewPaddingOpacityIsDefaultValue() const {
        return !m_data->testPropertySet(36);
    }
    qlonglong multitaskviewTopContentMargin() const {
        return m_data->p_multitaskviewTopContentMargin;
    }
    void setMultitaskviewTopContentMargin(const qlonglong &value) {
        auto oldValue = m_data->p_multitaskviewTopContentMargin;
        m_data->p_multitaskviewTopContentMargin = value;
        m_data->markPropertySet(37);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("multitaskviewTopContentMargin"), value);
            });
        }
        if (m_data->p_multitaskviewTopContentMargin != oldValue) {
            Q_EMIT multitaskviewTopContentMarginChanged();
            Q_EMIT valueChanged(QStringLiteral("multitaskviewTopContentMargin"), value);
        }
    }
    void resetMultitaskviewTopContentMargin() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("multitaskviewTopContentMargin"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableMultitaskviewTopContentMargin() {
        return QBindable<qlonglong>(this, "multitaskviewTopContentMargin");
    }
#endif
    Q_INVOKABLE bool multitaskviewTopContentMarginIsDefaultValue() const {
        return !m_data->testPropertySet(37);
    }
    qlonglong normalWindowHeight() const {
        return m_data->p_normalWindowHeight;
    }
    void setNormalWindowHeight(const qlonglong &value) {
        auto oldValue = m_data->p_normalWindowHeight;
        m_data->p_normalWindowHeight = value;
        m_data->markPropertySet(38);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("normalWindowHeight"), value);
            });
        }
        if (m_data->p_normalWindowHeight != oldValue) {
            Q_EMIT normalWindowHeightChanged();
            Q_EMIT valueChanged(QStringLiteral("normalWindowHeight"), value);
        }
    }
    void resetNormalWindowHeight() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("normalWindowHeight"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableNormalWindowHeight() {
        return QBindable<qlonglong>(this, "normalWindowHeight");
    }
#endif
    Q_INVOKABLE bool normalWindowHeightIsDefaultValue() const {
        return !m_data->testPropertySet(38);
    }
    qlonglong numWorkspace() const {
        return m_data->p_numWorkspace;
    }
    void setNumWorkspace(const qlonglong &value) {
        auto oldValue = m_data->p_numWorkspace;
        m_data->p_numWorkspace = value;
        m_data->markPropertySet(39);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("numWorkspace"), value);
            });
        }
        if (m_data->p_numWorkspace != oldValue) {
            Q_EMIT numWorkspaceChanged();
            Q_EMIT valueChanged(QStringLiteral("numWorkspace"), value);
        }
    }
    void resetNumWorkspace() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("numWorkspace"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableNumWorkspace() {
        return QBindable<qlonglong>(this, "numWorkspace");
    }
#endif
    Q_INVOKABLE bool numWorkspaceIsDefaultValue() const {
        return !m_data->testPropertySet(39);
    }
    bool preferDark() const {
        return m_data->p_preferDark;
    }
    void setPreferDark(const bool &value) {
        auto oldValue = m_data->p_preferDark;
        m_data->p_preferDark = value;
        m_data->markPropertySet(40);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("preferDark"), value);
            });
        }
        if (m_data->p_preferDark != oldValue) {
            Q_EMIT preferDarkChanged();
            Q_EMIT valueChanged(QStringLiteral("preferDark"), value);
        }
    }
    void resetPreferDark() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("preferDark"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<bool> bindablePreferDark() {
        return QBindable<bool>(this, "preferDark");
    }
#endif
    Q_INVOKABLE bool preferDarkIsDefaultValue() const {
        return !m_data->testPropertySet(40);
    }
    bool showOnLock() const {
        return m_data->p_showOnLock;
    }
    void setShowOnLock(const bool &value) {
        auto oldValue = m_data->p_showOnLock;
        m_data->p_showOnLock = value;
        m_data->markPropertySet(41);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("showOnLock"), value);
            });
        }
        if (m_data->p_showOnLock != oldValue) {
            Q_EMIT showOnLockChanged();
            Q_EMIT valueChanged(QStringLiteral("showOnLock"), value);
        }
    }
    void resetShowOnLock() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("showOnLock"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<bool> bindableShowOnLock() {
        return QBindable<bool>(this, "showOnLock");
    }
#endif
    Q_INVOKABLE bool showOnLockIsDefaultValue() const {
        return !m_data->testPropertySet(41);
    }
    QString themeName() const {
        return m_data->p_themeName;
    }
    void setThemeName(const QString &value) {
        auto oldValue = m_data->p_themeName;
        m_data->p_themeName = value;
        m_data->markPropertySet(42);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("themeName"), value);
            });
        }
        if (m_data->p_themeName != oldValue) {
            Q_EMIT themeNameChanged();
            Q_EMIT valueChanged(QStringLiteral("themeName"), value);
        }
    }
    void resetThemeName() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("themeName"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableThemeName() {
        return QBindable<QString>(this, "themeName");
    }
#endif
    Q_INVOKABLE bool themeNameIsDefaultValue() const {
        return !m_data->testPropertySet(42);
    }
    qlonglong titleBoxCornerRadius() const {
        return m_data->p_titleBoxCornerRadius;
    }
    void setTitleBoxCornerRadius(const qlonglong &value) {
        auto oldValue = m_data->p_titleBoxCornerRadius;
        m_data->p_titleBoxCornerRadius = value;
        m_data->markPropertySet(43);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("titleBoxCornerRadius"), value);
            });
        }
        if (m_data->p_titleBoxCornerRadius != oldValue) {
            Q_EMIT titleBoxCornerRadiusChanged();
            Q_EMIT valueChanged(QStringLiteral("titleBoxCornerRadius"), value);
        }
    }
    void resetTitleBoxCornerRadius() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("titleBoxCornerRadius"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableTitleBoxCornerRadius() {
        return QBindable<qlonglong>(this, "titleBoxCornerRadius");
    }
#endif
    Q_INVOKABLE bool titleBoxCornerRadiusIsDefaultValue() const {
        return !m_data->testPropertySet(43);
    }
    QString wallpaperConfig() const {
        return m_data->p_wallpaperConfig;
    }
    void setWallpaperConfig(const QString &value) {
        auto oldValue = m_data->p_wallpaperConfig;
        m_data->p_wallpaperConfig = value;
        m_data->markPropertySet(44);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("wallpaperConfig"), value);
            });
        }
        if (m_data->p_wallpaperConfig != oldValue) {
            Q_EMIT wallpaperConfigChanged();
            Q_EMIT valueChanged(QStringLiteral("wallpaperConfig"), value);
        }
    }
    void resetWallpaperConfig() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("wallpaperConfig"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<QString> bindableWallpaperConfig() {
        return QBindable<QString>(this, "wallpaperConfig");
    }
#endif
    Q_INVOKABLE bool wallpaperConfigIsDefaultValue() const {
        return !m_data->testPropertySet(44);
    }
    qlonglong windowHeightStep() const {
        return m_data->p_windowHeightStep;
    }
    void setWindowHeightStep(const qlonglong &value) {
        auto oldValue = m_data->p_windowHeightStep;
        m_data->p_windowHeightStep = value;
        m_data->markPropertySet(45);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("windowHeightStep"), value);
            });
        }
        if (m_data->p_windowHeightStep != oldValue) {
            Q_EMIT windowHeightStepChanged();
            Q_EMIT valueChanged(QStringLiteral("windowHeightStep"), value);
        }
    }
    void resetWindowHeightStep() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("windowHeightStep"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWindowHeightStep() {
        return QBindable<qlonglong>(this, "windowHeightStep");
    }
#endif
    Q_INVOKABLE bool windowHeightStepIsDefaultValue() const {
        return !m_data->testPropertySet(45);
    }
    qlonglong windowOpacity() const {
        return m_data->p_windowOpacity;
    }
    void setWindowOpacity(const qlonglong &value) {
        auto oldValue = m_data->p_windowOpacity;
        m_data->p_windowOpacity = value;
        m_data->markPropertySet(46);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("windowOpacity"), value);
            });
        }
        if (m_data->p_windowOpacity != oldValue) {
            Q_EMIT windowOpacityChanged();
            Q_EMIT valueChanged(QStringLiteral("windowOpacity"), value);
        }
    }
    void resetWindowOpacity() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("windowOpacity"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWindowOpacity() {
        return QBindable<qlonglong>(this, "windowOpacity");
    }
#endif
    Q_INVOKABLE bool windowOpacityIsDefaultValue() const {
        return !m_data->testPropertySet(46);
    }
    qlonglong windowRadius() const {
        return m_data->p_windowRadius;
    }
    void setWindowRadius(const qlonglong &value) {
        auto oldValue = m_data->p_windowRadius;
        m_data->p_windowRadius = value;
        m_data->markPropertySet(47);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("windowRadius"), value);
            });
        }
        if (m_data->p_windowRadius != oldValue) {
            Q_EMIT windowRadiusChanged();
            Q_EMIT valueChanged(QStringLiteral("windowRadius"), value);
        }
    }
    void resetWindowRadius() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("windowRadius"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWindowRadius() {
        return QBindable<qlonglong>(this, "windowRadius");
    }
#endif
    Q_INVOKABLE bool windowRadiusIsDefaultValue() const {
        return !m_data->testPropertySet(47);
    }
    qlonglong windowThemeType() const {
        return m_data->p_windowThemeType;
    }
    void setWindowThemeType(const qlonglong &value) {
        auto oldValue = m_data->p_windowThemeType;
        m_data->p_windowThemeType = value;
        m_data->markPropertySet(48);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("windowThemeType"), value);
            });
        }
        if (m_data->p_windowThemeType != oldValue) {
            Q_EMIT windowThemeTypeChanged();
            Q_EMIT valueChanged(QStringLiteral("windowThemeType"), value);
        }
    }
    void resetWindowThemeType() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("windowThemeType"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWindowThemeType() {
        return QBindable<qlonglong>(this, "windowThemeType");
    }
#endif
    Q_INVOKABLE bool windowThemeTypeIsDefaultValue() const {
        return !m_data->testPropertySet(48);
    }
    qlonglong windowTitlebarHeight() const {
        return m_data->p_windowTitlebarHeight;
    }
    void setWindowTitlebarHeight(const qlonglong &value) {
        auto oldValue = m_data->p_windowTitlebarHeight;
        m_data->p_windowTitlebarHeight = value;
        m_data->markPropertySet(49);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("windowTitlebarHeight"), value);
            });
        }
        if (m_data->p_windowTitlebarHeight != oldValue) {
            Q_EMIT windowTitlebarHeightChanged();
            Q_EMIT valueChanged(QStringLiteral("windowTitlebarHeight"), value);
        }
    }
    void resetWindowTitlebarHeight() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("windowTitlebarHeight"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWindowTitlebarHeight() {
        return QBindable<qlonglong>(this, "windowTitlebarHeight");
    }
#endif
    Q_INVOKABLE bool windowTitlebarHeightIsDefaultValue() const {
        return !m_data->testPropertySet(49);
    }
    qlonglong workspaceThumbCornerRadius() const {
        return m_data->p_workspaceThumbCornerRadius;
    }
    void setWorkspaceThumbCornerRadius(const qlonglong &value) {
        auto oldValue = m_data->p_workspaceThumbCornerRadius;
        m_data->p_workspaceThumbCornerRadius = value;
        m_data->markPropertySet(50);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("workspaceThumbCornerRadius"), value);
            });
        }
        if (m_data->p_workspaceThumbCornerRadius != oldValue) {
            Q_EMIT workspaceThumbCornerRadiusChanged();
            Q_EMIT valueChanged(QStringLiteral("workspaceThumbCornerRadius"), value);
        }
    }
    void resetWorkspaceThumbCornerRadius() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("workspaceThumbCornerRadius"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWorkspaceThumbCornerRadius() {
        return QBindable<qlonglong>(this, "workspaceThumbCornerRadius");
    }
#endif
    Q_INVOKABLE bool workspaceThumbCornerRadiusIsDefaultValue() const {
        return !m_data->testPropertySet(50);
    }
    qlonglong workspaceThumbHeight() const {
        return m_data->p_workspaceThumbHeight;
    }
    void setWorkspaceThumbHeight(const qlonglong &value) {
        auto oldValue = m_data->p_workspaceThumbHeight;
        m_data->p_workspaceThumbHeight = value;
        m_data->markPropertySet(51);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("workspaceThumbHeight"), value);
            });
        }
        if (m_data->p_workspaceThumbHeight != oldValue) {
            Q_EMIT workspaceThumbHeightChanged();
            Q_EMIT valueChanged(QStringLiteral("workspaceThumbHeight"), value);
        }
    }
    void resetWorkspaceThumbHeight() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("workspaceThumbHeight"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWorkspaceThumbHeight() {
        return QBindable<qlonglong>(this, "workspaceThumbHeight");
    }
#endif
    Q_INVOKABLE bool workspaceThumbHeightIsDefaultValue() const {
        return !m_data->testPropertySet(51);
    }
    qlonglong workspaceThumbMargin() const {
        return m_data->p_workspaceThumbMargin;
    }
    void setWorkspaceThumbMargin(const qlonglong &value) {
        auto oldValue = m_data->p_workspaceThumbMargin;
        m_data->p_workspaceThumbMargin = value;
        m_data->markPropertySet(52);
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config, value]() {
                config->setValue(QStringLiteral("workspaceThumbMargin"), value);
            });
        }
        if (m_data->p_workspaceThumbMargin != oldValue) {
            Q_EMIT workspaceThumbMarginChanged();
            Q_EMIT valueChanged(QStringLiteral("workspaceThumbMargin"), value);
        }
    }
    void resetWorkspaceThumbMargin() {
        if (auto config = m_data->m_config.loadRelaxed()) {
            QMetaObject::invokeMethod(config, [config]() {
                config->reset(QStringLiteral("workspaceThumbMargin"));
            });
        }
    }
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    QBindable<qlonglong> bindableWorkspaceThumbMargin() {
        return QBindable<qlonglong>(this, "workspaceThumbMargin");
    }
#endif
    Q_INVOKABLE bool workspaceThumbMarginIsDefaultValue() const {
        return !m_data->testPropertySet(52);
    }
protected:
    bool event(QEvent *e) override {
        if (e->type() == QEvent::ThreadChange) {
            Q_ASSERT(this->thread() == m_data->thread());
        }
        return QObject::event(e);
    }
Q_SIGNALS:
    void configInitializeFailed();
    void configInitializeSucceed(DTK_CORE_NAMESPACE::DConfig *config);
    void valueChanged(const QString &key, const QVariant &value);
    void activeColorChanged();
    void blurAmountChanged();
    void blurMultiplierChanged();
    void blurStrengthChanged();
    void currentWorkspaceChanged();
    void cursorBlinkChanged();
    void cursorBlinkTimeChanged();
    void cursorSizeChanged();
    void cursorThemeNameChanged();
    void defaultBackgroundChanged();
    void dndDragThresholdChanged();
    void doubleClickDistanceChanged();
    void doubleClickTimeChanged();
    void edgeInnerDelayMsChanged();
    void edgeSideTriggerDistanceChanged();
    void edgeTopTriggerDistanceChanged();
    void fontChanged();
    void fontSizeChanged();
    void glassBezelChanged();
    void glassEnabledChanged();
    void glassProfilePowerChanged();
    void glassSaturationChanged();
    void glassSpecularChanged();
    void glassThicknessChanged();
    void highlightBorderWidthChanged();
    void iconThemeNameChanged();
    void lostScreenChanged();
    void maxWorkspaceChanged();
    void minMultitaskviewSurfaceHeightChanged();
    void monoFontChanged();
    void multitaskviewAnimationDurationChanged();
    void multitaskviewBottomContentMarginChanged();
    void multitaskviewCellPaddingChanged();
    void multitaskviewEasingCurveTypeChanged();
    void multitaskviewHorizontalMarginChanged();
    void multitaskviewLoadFactorChanged();
    void multitaskviewPaddingOpacityChanged();
    void multitaskviewTopContentMarginChanged();
    void normalWindowHeightChanged();
    void numWorkspaceChanged();
    void preferDarkChanged();
    void showOnLockChanged();
    void themeNameChanged();
    void titleBoxCornerRadiusChanged();
    void wallpaperConfigChanged();
    void windowHeightStepChanged();
    void windowOpacityChanged();
    void windowRadiusChanged();
    void windowThemeTypeChanged();
    void windowTitlebarHeightChanged();
    void workspaceThumbCornerRadiusChanged();
    void workspaceThumbHeightChanged();
    void workspaceThumbMarginChanged();

private:
    // Prevent external moveToThread calls
    using QObject::moveToThread;
    class Data : public QObject {
    public:
        enum class Status {
            Invalid = 0,
            Initializing = 1,
            Succeeded = 2,
            Failed = 3,
            Destroyed = 4
        };

        explicit Data()
            : QObject(nullptr) {}

        inline void initializeInConfigThread(DTK_CORE_NAMESPACE::DConfig *config) {
            Q_ASSERT(!m_config.loadRelaxed());
            m_config.storeRelaxed(config);
            if (testPropertySet(0)) {
                config->setValue(QStringLiteral("activeColor"), QVariant::fromValue(p_activeColor));
            } else {
                updateValue(QStringLiteral("activeColor"), QVariant::fromValue(p_activeColor));
            }
            if (testPropertySet(1)) {
                config->setValue(QStringLiteral("blurAmount"), QVariant::fromValue(p_blurAmount));
            } else {
                updateValue(QStringLiteral("blurAmount"), QVariant::fromValue(p_blurAmount));
            }
            if (testPropertySet(2)) {
                config->setValue(QStringLiteral("blurMultiplier"), QVariant::fromValue(p_blurMultiplier));
            } else {
                updateValue(QStringLiteral("blurMultiplier"), QVariant::fromValue(p_blurMultiplier));
            }
            if (testPropertySet(3)) {
                config->setValue(QStringLiteral("blurStrength"), QVariant::fromValue(p_blurStrength));
            } else {
                updateValue(QStringLiteral("blurStrength"), QVariant::fromValue(p_blurStrength));
            }
            if (testPropertySet(4)) {
                config->setValue(QStringLiteral("currentWorkspace"), QVariant::fromValue(p_currentWorkspace));
            } else {
                updateValue(QStringLiteral("currentWorkspace"), QVariant::fromValue(p_currentWorkspace));
            }
            if (testPropertySet(5)) {
                config->setValue(QStringLiteral("cursorBlink"), QVariant::fromValue(p_cursorBlink));
            } else {
                updateValue(QStringLiteral("cursorBlink"), QVariant::fromValue(p_cursorBlink));
            }
            if (testPropertySet(6)) {
                config->setValue(QStringLiteral("cursorBlinkTime"), QVariant::fromValue(p_cursorBlinkTime));
            } else {
                updateValue(QStringLiteral("cursorBlinkTime"), QVariant::fromValue(p_cursorBlinkTime));
            }
            if (testPropertySet(7)) {
                config->setValue(QStringLiteral("cursorSize"), QVariant::fromValue(p_cursorSize));
            } else {
                updateValue(QStringLiteral("cursorSize"), QVariant::fromValue(p_cursorSize));
            }
            if (testPropertySet(8)) {
                config->setValue(QStringLiteral("cursorThemeName"), QVariant::fromValue(p_cursorThemeName));
            } else {
                updateValue(QStringLiteral("cursorThemeName"), QVariant::fromValue(p_cursorThemeName));
            }
            if (testPropertySet(9)) {
                config->setValue(QStringLiteral("defaultBackground"), QVariant::fromValue(p_defaultBackground));
            } else {
                updateValue(QStringLiteral("defaultBackground"), QVariant::fromValue(p_defaultBackground));
            }
            if (testPropertySet(10)) {
                config->setValue(QStringLiteral("dndDragThreshold"), QVariant::fromValue(p_dndDragThreshold));
            } else {
                updateValue(QStringLiteral("dndDragThreshold"), QVariant::fromValue(p_dndDragThreshold));
            }
            if (testPropertySet(11)) {
                config->setValue(QStringLiteral("doubleClickDistance"), QVariant::fromValue(p_doubleClickDistance));
            } else {
                updateValue(QStringLiteral("doubleClickDistance"), QVariant::fromValue(p_doubleClickDistance));
            }
            if (testPropertySet(12)) {
                config->setValue(QStringLiteral("doubleClickTime"), QVariant::fromValue(p_doubleClickTime));
            } else {
                updateValue(QStringLiteral("doubleClickTime"), QVariant::fromValue(p_doubleClickTime));
            }
            if (testPropertySet(13)) {
                config->setValue(QStringLiteral("edgeInnerDelayMs"), QVariant::fromValue(p_edgeInnerDelayMs));
            } else {
                updateValue(QStringLiteral("edgeInnerDelayMs"), QVariant::fromValue(p_edgeInnerDelayMs));
            }
            if (testPropertySet(14)) {
                config->setValue(QStringLiteral("edgeSideTriggerDistance"), QVariant::fromValue(p_edgeSideTriggerDistance));
            } else {
                updateValue(QStringLiteral("edgeSideTriggerDistance"), QVariant::fromValue(p_edgeSideTriggerDistance));
            }
            if (testPropertySet(15)) {
                config->setValue(QStringLiteral("edgeTopTriggerDistance"), QVariant::fromValue(p_edgeTopTriggerDistance));
            } else {
                updateValue(QStringLiteral("edgeTopTriggerDistance"), QVariant::fromValue(p_edgeTopTriggerDistance));
            }
            if (testPropertySet(16)) {
                config->setValue(QStringLiteral("font"), QVariant::fromValue(p_font));
            } else {
                updateValue(QStringLiteral("font"), QVariant::fromValue(p_font));
            }
            if (testPropertySet(17)) {
                config->setValue(QStringLiteral("fontSize"), QVariant::fromValue(p_fontSize));
            } else {
                updateValue(QStringLiteral("fontSize"), QVariant::fromValue(p_fontSize));
            }
            if (testPropertySet(18)) {
                config->setValue(QStringLiteral("glassBezel"), QVariant::fromValue(p_glassBezel));
            } else {
                updateValue(QStringLiteral("glassBezel"), QVariant::fromValue(p_glassBezel));
            }
            if (testPropertySet(19)) {
                config->setValue(QStringLiteral("glassEnabled"), QVariant::fromValue(p_glassEnabled));
            } else {
                updateValue(QStringLiteral("glassEnabled"), QVariant::fromValue(p_glassEnabled));
            }
            if (testPropertySet(20)) {
                config->setValue(QStringLiteral("glassProfilePower"), QVariant::fromValue(p_glassProfilePower));
            } else {
                updateValue(QStringLiteral("glassProfilePower"), QVariant::fromValue(p_glassProfilePower));
            }
            if (testPropertySet(21)) {
                config->setValue(QStringLiteral("glassSaturation"), QVariant::fromValue(p_glassSaturation));
            } else {
                updateValue(QStringLiteral("glassSaturation"), QVariant::fromValue(p_glassSaturation));
            }
            if (testPropertySet(22)) {
                config->setValue(QStringLiteral("glassSpecular"), QVariant::fromValue(p_glassSpecular));
            } else {
                updateValue(QStringLiteral("glassSpecular"), QVariant::fromValue(p_glassSpecular));
            }
            if (testPropertySet(23)) {
                config->setValue(QStringLiteral("glassThickness"), QVariant::fromValue(p_glassThickness));
            } else {
                updateValue(QStringLiteral("glassThickness"), QVariant::fromValue(p_glassThickness));
            }
            if (testPropertySet(24)) {
                config->setValue(QStringLiteral("highlightBorderWidth"), QVariant::fromValue(p_highlightBorderWidth));
            } else {
                updateValue(QStringLiteral("highlightBorderWidth"), QVariant::fromValue(p_highlightBorderWidth));
            }
            if (testPropertySet(25)) {
                config->setValue(QStringLiteral("iconThemeName"), QVariant::fromValue(p_iconThemeName));
            } else {
                updateValue(QStringLiteral("iconThemeName"), QVariant::fromValue(p_iconThemeName));
            }
            if (testPropertySet(26)) {
                config->setValue(QStringLiteral("lostScreen"), QVariant::fromValue(p_lostScreen));
            } else {
                updateValue(QStringLiteral("lostScreen"), QVariant::fromValue(p_lostScreen));
            }
            if (testPropertySet(27)) {
                config->setValue(QStringLiteral("maxWorkspace"), QVariant::fromValue(p_maxWorkspace));
            } else {
                updateValue(QStringLiteral("maxWorkspace"), QVariant::fromValue(p_maxWorkspace));
            }
            if (testPropertySet(28)) {
                config->setValue(QStringLiteral("minMultitaskviewSurfaceHeight"), QVariant::fromValue(p_minMultitaskviewSurfaceHeight));
            } else {
                updateValue(QStringLiteral("minMultitaskviewSurfaceHeight"), QVariant::fromValue(p_minMultitaskviewSurfaceHeight));
            }
            if (testPropertySet(29)) {
                config->setValue(QStringLiteral("monoFont"), QVariant::fromValue(p_monoFont));
            } else {
                updateValue(QStringLiteral("monoFont"), QVariant::fromValue(p_monoFont));
            }
            if (testPropertySet(30)) {
                config->setValue(QStringLiteral("multitaskviewAnimationDuration"), QVariant::fromValue(p_multitaskviewAnimationDuration));
            } else {
                updateValue(QStringLiteral("multitaskviewAnimationDuration"), QVariant::fromValue(p_multitaskviewAnimationDuration));
            }
            if (testPropertySet(31)) {
                config->setValue(QStringLiteral("multitaskviewBottomContentMargin"), QVariant::fromValue(p_multitaskviewBottomContentMargin));
            } else {
                updateValue(QStringLiteral("multitaskviewBottomContentMargin"), QVariant::fromValue(p_multitaskviewBottomContentMargin));
            }
            if (testPropertySet(32)) {
                config->setValue(QStringLiteral("multitaskviewCellPadding"), QVariant::fromValue(p_multitaskviewCellPadding));
            } else {
                updateValue(QStringLiteral("multitaskviewCellPadding"), QVariant::fromValue(p_multitaskviewCellPadding));
            }
            if (testPropertySet(33)) {
                config->setValue(QStringLiteral("multitaskviewEasingCurveType"), QVariant::fromValue(p_multitaskviewEasingCurveType));
            } else {
                updateValue(QStringLiteral("multitaskviewEasingCurveType"), QVariant::fromValue(p_multitaskviewEasingCurveType));
            }
            if (testPropertySet(34)) {
                config->setValue(QStringLiteral("multitaskviewHorizontalMargin"), QVariant::fromValue(p_multitaskviewHorizontalMargin));
            } else {
                updateValue(QStringLiteral("multitaskviewHorizontalMargin"), QVariant::fromValue(p_multitaskviewHorizontalMargin));
            }
            if (testPropertySet(35)) {
                config->setValue(QStringLiteral("multitaskviewLoadFactor"), QVariant::fromValue(p_multitaskviewLoadFactor));
            } else {
                updateValue(QStringLiteral("multitaskviewLoadFactor"), QVariant::fromValue(p_multitaskviewLoadFactor));
            }
            if (testPropertySet(36)) {
                config->setValue(QStringLiteral("multitaskviewPaddingOpacity"), QVariant::fromValue(p_multitaskviewPaddingOpacity));
            } else {
                updateValue(QStringLiteral("multitaskviewPaddingOpacity"), QVariant::fromValue(p_multitaskviewPaddingOpacity));
            }
            if (testPropertySet(37)) {
                config->setValue(QStringLiteral("multitaskviewTopContentMargin"), QVariant::fromValue(p_multitaskviewTopContentMargin));
            } else {
                updateValue(QStringLiteral("multitaskviewTopContentMargin"), QVariant::fromValue(p_multitaskviewTopContentMargin));
            }
            if (testPropertySet(38)) {
                config->setValue(QStringLiteral("normalWindowHeight"), QVariant::fromValue(p_normalWindowHeight));
            } else {
                updateValue(QStringLiteral("normalWindowHeight"), QVariant::fromValue(p_normalWindowHeight));
            }
            if (testPropertySet(39)) {
                config->setValue(QStringLiteral("numWorkspace"), QVariant::fromValue(p_numWorkspace));
            } else {
                updateValue(QStringLiteral("numWorkspace"), QVariant::fromValue(p_numWorkspace));
            }
            if (testPropertySet(40)) {
                config->setValue(QStringLiteral("preferDark"), QVariant::fromValue(p_preferDark));
            } else {
                updateValue(QStringLiteral("preferDark"), QVariant::fromValue(p_preferDark));
            }
            if (testPropertySet(41)) {
                config->setValue(QStringLiteral("showOnLock"), QVariant::fromValue(p_showOnLock));
            } else {
                updateValue(QStringLiteral("showOnLock"), QVariant::fromValue(p_showOnLock));
            }
            if (testPropertySet(42)) {
                config->setValue(QStringLiteral("themeName"), QVariant::fromValue(p_themeName));
            } else {
                updateValue(QStringLiteral("themeName"), QVariant::fromValue(p_themeName));
            }
            if (testPropertySet(43)) {
                config->setValue(QStringLiteral("titleBoxCornerRadius"), QVariant::fromValue(p_titleBoxCornerRadius));
            } else {
                updateValue(QStringLiteral("titleBoxCornerRadius"), QVariant::fromValue(p_titleBoxCornerRadius));
            }
            if (testPropertySet(44)) {
                config->setValue(QStringLiteral("wallpaperConfig"), QVariant::fromValue(p_wallpaperConfig));
            } else {
                updateValue(QStringLiteral("wallpaperConfig"), QVariant::fromValue(p_wallpaperConfig));
            }
            if (testPropertySet(45)) {
                config->setValue(QStringLiteral("windowHeightStep"), QVariant::fromValue(p_windowHeightStep));
            } else {
                updateValue(QStringLiteral("windowHeightStep"), QVariant::fromValue(p_windowHeightStep));
            }
            if (testPropertySet(46)) {
                config->setValue(QStringLiteral("windowOpacity"), QVariant::fromValue(p_windowOpacity));
            } else {
                updateValue(QStringLiteral("windowOpacity"), QVariant::fromValue(p_windowOpacity));
            }
            if (testPropertySet(47)) {
                config->setValue(QStringLiteral("windowRadius"), QVariant::fromValue(p_windowRadius));
            } else {
                updateValue(QStringLiteral("windowRadius"), QVariant::fromValue(p_windowRadius));
            }
            if (testPropertySet(48)) {
                config->setValue(QStringLiteral("windowThemeType"), QVariant::fromValue(p_windowThemeType));
            } else {
                updateValue(QStringLiteral("windowThemeType"), QVariant::fromValue(p_windowThemeType));
            }
            if (testPropertySet(49)) {
                config->setValue(QStringLiteral("windowTitlebarHeight"), QVariant::fromValue(p_windowTitlebarHeight));
            } else {
                updateValue(QStringLiteral("windowTitlebarHeight"), QVariant::fromValue(p_windowTitlebarHeight));
            }
            if (testPropertySet(50)) {
                config->setValue(QStringLiteral("workspaceThumbCornerRadius"), QVariant::fromValue(p_workspaceThumbCornerRadius));
            } else {
                updateValue(QStringLiteral("workspaceThumbCornerRadius"), QVariant::fromValue(p_workspaceThumbCornerRadius));
            }
            if (testPropertySet(51)) {
                config->setValue(QStringLiteral("workspaceThumbHeight"), QVariant::fromValue(p_workspaceThumbHeight));
            } else {
                updateValue(QStringLiteral("workspaceThumbHeight"), QVariant::fromValue(p_workspaceThumbHeight));
            }
            if (testPropertySet(52)) {
                config->setValue(QStringLiteral("workspaceThumbMargin"), QVariant::fromValue(p_workspaceThumbMargin));
            } else {
                updateValue(QStringLiteral("workspaceThumbMargin"), QVariant::fromValue(p_workspaceThumbMargin));
            }
            connect(config, &DTK_CORE_NAMESPACE::DConfig::valueChanged, this, [this](const QString &key) {
                updateValue(key);
            }, Qt::DirectConnection);
        }

        inline void updateValue(const QString &key, const QVariant &fallback = QVariant()) {
            if (!m_config.loadRelaxed())
                return;
            Q_ASSERT(QThread::currentThread() == m_config.loadRelaxed()->thread());
            const QVariant &value = m_config.loadRelaxed()->value(key, fallback);
            if (key == QStringLiteral("activeColor")) {
                markPropertySet(0, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_activeColor != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_activeColor = newValue;
                        Q_EMIT m_userConfig->activeColorChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("blurAmount")) {
                markPropertySet(1, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_blurAmount != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_blurAmount = newValue;
                        Q_EMIT m_userConfig->blurAmountChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("blurMultiplier")) {
                markPropertySet(2, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_blurMultiplier != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_blurMultiplier = newValue;
                        Q_EMIT m_userConfig->blurMultiplierChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("blurStrength")) {
                markPropertySet(3, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_blurStrength != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_blurStrength = newValue;
                        Q_EMIT m_userConfig->blurStrengthChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("currentWorkspace")) {
                markPropertySet(4, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_currentWorkspace != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_currentWorkspace = newValue;
                        Q_EMIT m_userConfig->currentWorkspaceChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("cursorBlink")) {
                markPropertySet(5, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<bool>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_cursorBlink != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_cursorBlink = newValue;
                        Q_EMIT m_userConfig->cursorBlinkChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("cursorBlinkTime")) {
                markPropertySet(6, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_cursorBlinkTime != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_cursorBlinkTime = newValue;
                        Q_EMIT m_userConfig->cursorBlinkTimeChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("cursorSize")) {
                markPropertySet(7, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_cursorSize != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_cursorSize = newValue;
                        Q_EMIT m_userConfig->cursorSizeChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("cursorThemeName")) {
                markPropertySet(8, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_cursorThemeName != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_cursorThemeName = newValue;
                        Q_EMIT m_userConfig->cursorThemeNameChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("defaultBackground")) {
                markPropertySet(9, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_defaultBackground != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_defaultBackground = newValue;
                        Q_EMIT m_userConfig->defaultBackgroundChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("dndDragThreshold")) {
                markPropertySet(10, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_dndDragThreshold != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_dndDragThreshold = newValue;
                        Q_EMIT m_userConfig->dndDragThresholdChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("doubleClickDistance")) {
                markPropertySet(11, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_doubleClickDistance != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_doubleClickDistance = newValue;
                        Q_EMIT m_userConfig->doubleClickDistanceChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("doubleClickTime")) {
                markPropertySet(12, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_doubleClickTime != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_doubleClickTime = newValue;
                        Q_EMIT m_userConfig->doubleClickTimeChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("edgeInnerDelayMs")) {
                markPropertySet(13, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_edgeInnerDelayMs != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_edgeInnerDelayMs = newValue;
                        Q_EMIT m_userConfig->edgeInnerDelayMsChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("edgeSideTriggerDistance")) {
                markPropertySet(14, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_edgeSideTriggerDistance != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_edgeSideTriggerDistance = newValue;
                        Q_EMIT m_userConfig->edgeSideTriggerDistanceChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("edgeTopTriggerDistance")) {
                markPropertySet(15, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_edgeTopTriggerDistance != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_edgeTopTriggerDistance = newValue;
                        Q_EMIT m_userConfig->edgeTopTriggerDistanceChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("font")) {
                markPropertySet(16, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_font != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_font = newValue;
                        Q_EMIT m_userConfig->fontChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("fontSize")) {
                markPropertySet(17, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_fontSize != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_fontSize = newValue;
                        Q_EMIT m_userConfig->fontSizeChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("glassBezel")) {
                markPropertySet(18, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_glassBezel != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_glassBezel = newValue;
                        Q_EMIT m_userConfig->glassBezelChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("glassEnabled")) {
                markPropertySet(19, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<bool>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_glassEnabled != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_glassEnabled = newValue;
                        Q_EMIT m_userConfig->glassEnabledChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("glassProfilePower")) {
                markPropertySet(20, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_glassProfilePower != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_glassProfilePower = newValue;
                        Q_EMIT m_userConfig->glassProfilePowerChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("glassSaturation")) {
                markPropertySet(21, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_glassSaturation != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_glassSaturation = newValue;
                        Q_EMIT m_userConfig->glassSaturationChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("glassSpecular")) {
                markPropertySet(22, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_glassSpecular != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_glassSpecular = newValue;
                        Q_EMIT m_userConfig->glassSpecularChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("glassThickness")) {
                markPropertySet(23, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_glassThickness != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_glassThickness = newValue;
                        Q_EMIT m_userConfig->glassThicknessChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("highlightBorderWidth")) {
                markPropertySet(24, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_highlightBorderWidth != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_highlightBorderWidth = newValue;
                        Q_EMIT m_userConfig->highlightBorderWidthChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("iconThemeName")) {
                markPropertySet(25, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_iconThemeName != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_iconThemeName = newValue;
                        Q_EMIT m_userConfig->iconThemeNameChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("lostScreen")) {
                markPropertySet(26, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_lostScreen != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_lostScreen = newValue;
                        Q_EMIT m_userConfig->lostScreenChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("maxWorkspace")) {
                markPropertySet(27, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_maxWorkspace != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_maxWorkspace = newValue;
                        Q_EMIT m_userConfig->maxWorkspaceChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("minMultitaskviewSurfaceHeight")) {
                markPropertySet(28, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_minMultitaskviewSurfaceHeight != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_minMultitaskviewSurfaceHeight = newValue;
                        Q_EMIT m_userConfig->minMultitaskviewSurfaceHeightChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("monoFont")) {
                markPropertySet(29, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_monoFont != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_monoFont = newValue;
                        Q_EMIT m_userConfig->monoFontChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewAnimationDuration")) {
                markPropertySet(30, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewAnimationDuration != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewAnimationDuration = newValue;
                        Q_EMIT m_userConfig->multitaskviewAnimationDurationChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewBottomContentMargin")) {
                markPropertySet(31, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewBottomContentMargin != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewBottomContentMargin = newValue;
                        Q_EMIT m_userConfig->multitaskviewBottomContentMarginChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewCellPadding")) {
                markPropertySet(32, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewCellPadding != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewCellPadding = newValue;
                        Q_EMIT m_userConfig->multitaskviewCellPaddingChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewEasingCurveType")) {
                markPropertySet(33, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewEasingCurveType != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewEasingCurveType = newValue;
                        Q_EMIT m_userConfig->multitaskviewEasingCurveTypeChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewHorizontalMargin")) {
                markPropertySet(34, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewHorizontalMargin != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewHorizontalMargin = newValue;
                        Q_EMIT m_userConfig->multitaskviewHorizontalMarginChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewLoadFactor")) {
                markPropertySet(35, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewLoadFactor != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewLoadFactor = newValue;
                        Q_EMIT m_userConfig->multitaskviewLoadFactorChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewPaddingOpacity")) {
                markPropertySet(36, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<double>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewPaddingOpacity != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewPaddingOpacity = newValue;
                        Q_EMIT m_userConfig->multitaskviewPaddingOpacityChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("multitaskviewTopContentMargin")) {
                markPropertySet(37, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_multitaskviewTopContentMargin != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_multitaskviewTopContentMargin = newValue;
                        Q_EMIT m_userConfig->multitaskviewTopContentMarginChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("normalWindowHeight")) {
                markPropertySet(38, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_normalWindowHeight != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_normalWindowHeight = newValue;
                        Q_EMIT m_userConfig->normalWindowHeightChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("numWorkspace")) {
                markPropertySet(39, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_numWorkspace != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_numWorkspace = newValue;
                        Q_EMIT m_userConfig->numWorkspaceChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("preferDark")) {
                markPropertySet(40, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<bool>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_preferDark != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_preferDark = newValue;
                        Q_EMIT m_userConfig->preferDarkChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("showOnLock")) {
                markPropertySet(41, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<bool>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_showOnLock != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_showOnLock = newValue;
                        Q_EMIT m_userConfig->showOnLockChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("themeName")) {
                markPropertySet(42, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_themeName != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_themeName = newValue;
                        Q_EMIT m_userConfig->themeNameChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("titleBoxCornerRadius")) {
                markPropertySet(43, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_titleBoxCornerRadius != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_titleBoxCornerRadius = newValue;
                        Q_EMIT m_userConfig->titleBoxCornerRadiusChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("wallpaperConfig")) {
                markPropertySet(44, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<QString>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_wallpaperConfig != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_wallpaperConfig = newValue;
                        Q_EMIT m_userConfig->wallpaperConfigChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("windowHeightStep")) {
                markPropertySet(45, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_windowHeightStep != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_windowHeightStep = newValue;
                        Q_EMIT m_userConfig->windowHeightStepChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("windowOpacity")) {
                markPropertySet(46, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_windowOpacity != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_windowOpacity = newValue;
                        Q_EMIT m_userConfig->windowOpacityChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("windowRadius")) {
                markPropertySet(47, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_windowRadius != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_windowRadius = newValue;
                        Q_EMIT m_userConfig->windowRadiusChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("windowThemeType")) {
                markPropertySet(48, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_windowThemeType != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_windowThemeType = newValue;
                        Q_EMIT m_userConfig->windowThemeTypeChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("windowTitlebarHeight")) {
                markPropertySet(49, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_windowTitlebarHeight != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_windowTitlebarHeight = newValue;
                        Q_EMIT m_userConfig->windowTitlebarHeightChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("workspaceThumbCornerRadius")) {
                markPropertySet(50, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_workspaceThumbCornerRadius != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_workspaceThumbCornerRadius = newValue;
                        Q_EMIT m_userConfig->workspaceThumbCornerRadiusChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("workspaceThumbHeight")) {
                markPropertySet(51, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_workspaceThumbHeight != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_workspaceThumbHeight = newValue;
                        Q_EMIT m_userConfig->workspaceThumbHeightChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
            if (key == QStringLiteral("workspaceThumbMargin")) {
                markPropertySet(52, !m_config.loadRelaxed()->isDefaultValue(key));
                auto newValue = qvariant_cast<qlonglong>(value);
                QMetaObject::invokeMethod(this, [this, newValue, key, value]() {
                    if (m_userConfig && p_workspaceThumbMargin != newValue) {
                        Q_ASSERT(QThread::currentThread() == m_userConfig->thread());
                        p_workspaceThumbMargin = newValue;
                        Q_EMIT m_userConfig->workspaceThumbMarginChanged();
                        Q_EMIT m_userConfig->valueChanged(key, value);
                    }
                });
                return;
            }
        }
        inline void markPropertySet(const int index, bool on = true) {
            if (index < 32) {
                if (on)
                    m_propertySetStatus0.fetchAndOrOrdered(1 << (index - 0));
                else
                    m_propertySetStatus0.fetchAndAndOrdered(~(1 << (index - 0)));
                return;
            }
            if (index < 64) {
                if (on)
                    m_propertySetStatus1.fetchAndOrOrdered(1 << (index - 32));
                else
                    m_propertySetStatus1.fetchAndAndOrdered(~(1 << (index - 32)));
                return;
            }
            Q_UNREACHABLE();
        }
        inline bool testPropertySet(const int index) const {
            if (index < 32) {
                return (m_propertySetStatus0.loadRelaxed() & (1 << (index - 0)));
            }
            if (index < 64) {
                return (m_propertySetStatus1.loadRelaxed() & (1 << (index - 32)));
            }
            Q_UNREACHABLE();
        }
        // Member variables
        QAtomicPointer<DTK_CORE_NAMESPACE::DConfig> m_config = nullptr;
        QAtomicInteger<int> m_status = static_cast<int>(Status::Invalid);
        QPointer<TreelandUserConfig> m_userConfig = nullptr;
        QAtomicInteger<quint32> m_propertySetStatus0 = 0;
        QAtomicInteger<quint32> m_propertySetStatus1 = 0;

        // Property storage
        // Default value: "#1F6EE7"
        QString p_activeColor { QStringLiteral(u"\u0023\u0031\u0046\u0036\u0045\u0045\u0037") };
        double p_blurAmount { 0.6 };
        double p_blurMultiplier { 0 };
        qlonglong p_blurStrength { 60 };
        qlonglong p_currentWorkspace { 0 };
        bool p_cursorBlink { true };
        qlonglong p_cursorBlinkTime { 1200 };
        qlonglong p_cursorSize { 24 };
        // Default value: "bloom"
        QString p_cursorThemeName { QStringLiteral(u"\u0062\u006c\u006f\u006f\u006d") };
        // Default value: "/usr/share/backgrounds/deepin/desktop.jpg"
        QString p_defaultBackground { QStringLiteral(u"\u002f\u0075\u0073\u0072\u002f\u0073\u0068\u0061\u0072\u0065\u002f\u0062\u0061\u0063\u006b\u0067\u0072\u006f\u0075\u006e\u0064\u0073\u002f\u0064\u0065\u0065\u0070\u0069\u006e\u002f\u0064\u0065\u0073\u006b\u0074\u006f\u0070\u002e\u006a\u0070\u0067") };
        qlonglong p_dndDragThreshold { 8 };
        qlonglong p_doubleClickDistance { 5 };
        qlonglong p_doubleClickTime { 250 };
        qlonglong p_edgeInnerDelayMs { 250 };
        qlonglong p_edgeSideTriggerDistance { 20 };
        qlonglong p_edgeTopTriggerDistance { 5 };
        // Default value: "Source Han Sans SC"
        QString p_font { QStringLiteral(u"\u0053\u006f\u0075\u0072\u0063\u0065\u0020\u0048\u0061\u006e\u0020\u0053\u0061\u006e\u0073\u0020\u0053\u0043") };
        qlonglong p_fontSize { 105 };
        qlonglong p_glassBezel { 30 };
        bool p_glassEnabled { true };
        double p_glassProfilePower { 2 };
        double p_glassSaturation { 0 };
        double p_glassSpecular { 0 };
        qlonglong p_glassThickness { 30 };
        qlonglong p_highlightBorderWidth { 4 };
        // Default value: "nirvana"
        QString p_iconThemeName { QStringLiteral(u"\u006e\u0069\u0072\u0076\u0061\u006e\u0061") };
        // Default value: "MoveToPrimary"
        QString p_lostScreen { QStringLiteral(u"\u004d\u006f\u0076\u0065\u0054\u006f\u0050\u0072\u0069\u006d\u0061\u0072\u0079") };
        qlonglong p_maxWorkspace { 6 };
        qlonglong p_minMultitaskviewSurfaceHeight { 232 };
        // Default value: "Noto Mono"
        QString p_monoFont { QStringLiteral(u"\u004e\u006f\u0074\u006f\u0020\u004d\u006f\u006e\u006f") };
        qlonglong p_multitaskviewAnimationDuration { 300 };
        qlonglong p_multitaskviewBottomContentMargin { 60 };
        qlonglong p_multitaskviewCellPadding { 12 };
        qlonglong p_multitaskviewEasingCurveType { 22 };
        qlonglong p_multitaskviewHorizontalMargin { 20 };
        double p_multitaskviewLoadFactor { 0.6 };
        double p_multitaskviewPaddingOpacity { 0.1 };
        qlonglong p_multitaskviewTopContentMargin { 40 };
        qlonglong p_normalWindowHeight { 720 };
        qlonglong p_numWorkspace { 2 };
        bool p_preferDark { false };
        bool p_showOnLock { false };
        // Default value: ""
        QString p_themeName { QLatin1String("") };
        qlonglong p_titleBoxCornerRadius { 8 };
        // Default value: ""
        QString p_wallpaperConfig { QLatin1String("") };
        qlonglong p_windowHeightStep { 15 };
        qlonglong p_windowOpacity { 40 };
        qlonglong p_windowRadius { 12 };
        qlonglong p_windowThemeType { 1 };
        qlonglong p_windowTitlebarHeight { 40 };
        qlonglong p_workspaceThumbCornerRadius { 8 };
        qlonglong p_workspaceThumbHeight { 144 };
        qlonglong p_workspaceThumbMargin { 20 };
    };

    QPointer<Data> m_data;
};

#endif // TREELANDUSERCONFIG_H
